Ejemplo n.º 1
0
        internal override void FinalizeCreation()
        {
            _bitmapInit.EnsureInitializedComplete();
            BitmapSourceSafeMILHandle wicClipper = null;

            Int32Rect    rect   = SourceRect;
            BitmapSource source = Source;

            if (rect.IsEmpty)
            {
                rect.Width  = source.PixelWidth;
                rect.Height = source.PixelHeight;
            }

            using (FactoryMaker factoryMaker = new FactoryMaker())
            {
                try
                {
                    IntPtr wicFactory = factoryMaker.ImagingFactoryPtr;

                    HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateBitmapClipper(
                                      wicFactory,
                                      out wicClipper));

                    lock (_syncObject)
                    {
                        HRESULT.Check(UnsafeNativeMethods.WICBitmapClipper.Initialize(
                                          wicClipper,
                                          source.WicSourceHandle,
                                          ref rect));
                    }

                    //
                    // This is just a link in a BitmapSource chain. The memory is being used by
                    // the BitmapSource at the end of the chain, so no memory pressure needs
                    // to be added here.
                    //
                    WicSourceHandle = wicClipper;
                    _isSourceCached = source.IsSourceCached;
                    wicClipper      = null;
                }
                catch
                {
                    _bitmapInit.Reset();
                    throw;
                }
                finally
                {
                    if (wicClipper != null)
                    {
                        wicClipper.Close();
                    }
                }
            }

            CreationCompleted = true;
            UpdateCachedSettings();
        }
Ejemplo n.º 2
0
        internal override void FinalizeCreation()
        {
            _bitmapInit.EnsureInitializedComplete();
            BitmapSourceSafeMILHandle wicFormatter = null;

            using (FactoryMaker factoryMaker = new FactoryMaker())
            {
                try
                {
                    IntPtr wicFactory = factoryMaker.ImagingFactoryPtr;

                    HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateFormatConverter(
                                      wicFactory,
                                      out wicFormatter));

                    SafeMILHandle internalPalette;
                    if (DestinationPalette != null)
                    {
                        internalPalette = DestinationPalette.InternalPalette;
                    }
                    else
                    {
                        internalPalette = new SafeMILHandle();
                    }

                    Guid format = DestinationFormat.Guid;

                    lock (_syncObject)
                    {
                        HRESULT.Check(UnsafeNativeMethods.WICFormatConverter.Initialize(
                                          wicFormatter,
                                          Source.WicSourceHandle,
                                          ref format,
                                          DitherType.DitherTypeErrorDiffusion,
                                          internalPalette,
                                          AlphaThreshold,
                                          WICPaletteType.WICPaletteTypeOptimal
                                          ));
                    }

                    //
                    // This is just a link in a BitmapSource chain. The memory is being used by
                    // the BitmapSource at the end of the chain, so no memory pressure needs
                    // to be added here.
                    //
                    WicSourceHandle = wicFormatter;

                    // Even if our source is cached, format conversion is expensive and so we'll
                    // always maintain our own cache for the purpose of rendering.
                    _isSourceCached = false;
                }
                catch
                {
                    _bitmapInit.Reset();
                    throw;
                }
                finally
                {
                    if (wicFormatter != null)
                    {
                        wicFormatter.Close();
                    }
                }
            }

            CreationCompleted = true;
            UpdateCachedSettings();
        }