internal override void SetupFrame(SafeMILHandle frameEncodeHandle, SafeMILHandle encoderOptions)
 {
     HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.Initialize(
         frameEncodeHandle,
         encoderOptions
         ));
 }

        internal ColorTransform(SafeMILHandle bitmapSource, ColorContext srcContext, ColorContext dstContext, System.Windows.Media.PixelFormat pixelFormat) 
        {
            InitializeICM(); 

            if (srcContext == null)
            {
                srcContext = new ColorContext(pixelFormat); 
            }
            if (dstContext == null) 
            { 
                dstContext = new ColorContext(pixelFormat);
            } 

            _inputColorType = srcContext.ColorType;
            _outputColorType = dstContext.ColorType;
 
            //if this failed or the handle is invalid, we can't continue
            if (srcContext.ProfileHandle != null && !srcContext.ProfileHandle.IsInvalid) 
            { 
                //if this failed or the handle is invalid, we can't continue
                if (dstContext.ProfileHandle != null && !dstContext.ProfileHandle.IsInvalid) 
                {
                    _colorTransformHelper.CreateTransform(srcContext.ProfileHandle, dstContext.ProfileHandle);
                }
            } 
        }

 internal void CopyMemoryPressure(SafeMILHandle original)
 {
     _gcPressure = original._gcPressure;
     if (_gcPressure != null)
     {
         _gcPressure.AddRef();
     }
 }

        internal static void CreateMediaEventsHelper(MediaPlayer mediaPlayer, 
                                                     out MediaEventsHelper eventsHelper,
                                                     out SafeMILHandle unmanagedProxy)
        {
            eventsHelper = new MediaEventsHelper(mediaPlayer); 

            // Created with ref count = 1. Since this object does not hold on 
            // to the unmanaged proxy, the lifetime is now controlled by whoever 
            // called CreateMediaEventsHelper.
            unmanagedProxy = EventProxyWrapper.CreateEventProxyWrapper(eventsHelper); 
        }

 internal UnknownBitmapDecoder(
     SafeMILHandle decoderHandle,
     BitmapDecoder decoder,
     Uri baseUri,
     Uri uri,
     Stream stream,
     BitmapCreateOptions createOptions,
     BitmapCacheOption cacheOption,
     bool insertInDecoderCache,
     bool originalWritable,
     Stream uriStream,
     UnmanagedMemoryStream unmanagedMemoryStream,
     SafeFileHandle safeFilehandle             
     ) : base(decoderHandle, decoder, baseUri, uri, stream, createOptions, cacheOption, insertInDecoderCache, originalWritable, uriStream, unmanagedMemoryStream, safeFilehandle)
 {
 }

        private void EnsureMetadata(bool createBitmapMetadata)
        {
            if (!_supportsGlobalMetadata)
            {
                return;
            }

            if (_metadataHandle == null)
            {
                SafeMILHandle /* IWICMetadataQueryWriter */ metadataHandle = new SafeMILHandle();

                int hr = UnsafeNativeMethods.WICBitmapEncoder.GetMetadataQueryWriter(
                    _encoderHandle,
                    out metadataHandle
                    );

                if (hr == (int)WinCodecErrors.WINCODEC_ERR_UNSUPPORTEDOPERATION)
                {
                    _supportsGlobalMetadata = false;
                    return;
                }
                HRESULT.Check(hr);

                _metadataHandle = metadataHandle;
            }

            if (createBitmapMetadata &&
                _metadata == null &&
                _metadataHandle != null)
            {
                _metadata = new BitmapMetadata(_metadataHandle, false, IsMetadataFixedSize, _metadataHandle);
            }
        }

        public virtual void Save(System.IO.Stream stream)
        {
            VerifyAccess();
            EnsureBuiltIn();
            EnsureUnmanagedEncoder();

            // No-op to get rid of build error
            if (_encodeState == EncodeState.None)
            {
            }

            if (_hasSaved)
            {
                throw new InvalidOperationException(SR.Get(SRID.Image_OnlyOneSave));
            }

            if (_frames == null)
            {
                throw new System.NotSupportedException(SR.Get(SRID.Image_NoFrames, null));
            }

            int count = _frames.Count;
            if (count <= 0)
            {
                throw new System.NotSupportedException(SR.Get(SRID.Image_NoFrames, null));
            }

            IntPtr comStream = IntPtr.Zero;
            SafeMILHandle encoderHandle = _encoderHandle;

            try
            {
                comStream = StreamAsIStream.IStreamFrom(stream);

                // does this addref the stream?
                HRESULT.Check(UnsafeNativeMethods.WICBitmapEncoder.Initialize(
                    encoderHandle,
                    comStream,
                    WICBitmapEncodeCacheOption.WICBitmapEncodeNoCache
                    ));

                // Helpful for debugging stress and remote dumps
                _encodeState = EncodeState.EncoderInitialized;

                // Save global thumbnail if any.
                if (_thumbnail != null)
                {
                    Debug.Assert(_supportsGlobalThumbnail);
                    SafeMILHandle thumbnailBitmapSource = _thumbnail.WicSourceHandle;

                    lock (_thumbnail.SyncObject)
                    {
                        HRESULT.Check(UnsafeNativeMethods.WICBitmapEncoder.SetThumbnail(
                            encoderHandle,
                            thumbnailBitmapSource
                            ));

                        // Helpful for debugging stress and remote dumps
                        _encodeState = EncodeState.EncoderThumbnailSet;
                    }
                }

                // Save global palette if any.
                if (_palette != null && _palette.Colors.Count > 0)
                {
                    SafeMILHandle paletteHandle = _palette.InternalPalette;

                    HRESULT.Check(UnsafeNativeMethods.WICBitmapEncoder.SetPalette(
                        encoderHandle,
                        paletteHandle
                        ));

                    // Helpful for debugging stress and remote dumps
                    _encodeState = EncodeState.EncoderPaletteSet;
                }

                // Save global metadata if any.
                if (_metadata != null && _metadata.GuidFormat == ContainerFormat)
                {
                    Debug.Assert(_supportsGlobalMetadata);

                    EnsureMetadata(false);

                    if (_metadata.InternalMetadataHandle != _metadataHandle)
                    {
                        PROPVARIANT propVar = new PROPVARIANT();

                        try
                        {
                            propVar.Init(_metadata);

                            lock (_metadata.SyncObject)
                            {
                                HRESULT.Check(UnsafeNativeMethods.WICMetadataQueryWriter.SetMetadataByName(
                                    _metadataHandle,
                                    "/",
                                    ref propVar
                                    ));
                            }
                        }
//.........这里部分代码省略.........

 internal static extern int /* HRESULT */ GetMetadataQueryWriter(
     SafeMILHandle /* IWICBitmapEncoder */ THIS_PTR,
     out SafeMILHandle /* IWICMetadataQueryWriter */ ppIQueryWriter
     ); 

 internal static extern int /* HRESULT */ SetThumbnail(SafeMILHandle /* IWICBitmapEncoder*  */ THIS_PTR,
     System.Windows.Media.SafeMILHandle /* IWICBitmapSource* */ pIThumbnail);

 internal static extern int /* HRESULT */ GetEncoderInfo(SafeMILHandle /* IWICBitmapEncoder* */ THIS_PTR, 
     out SafeMILHandle /* IWICBitmapEncoderInfo ** */ ppIEncoderInfo
     ); 

 internal static extern int /* HRESULT */ GetMetadataQueryReader(
     SafeMILHandle /* IWICBitmapFrameDecode */ THIS_PTR,
     out IntPtr /* IWICMetadataQueryReader */ ppIQueryReader
     ); 

 internal static extern int /* HRESULT */ GetThumbnail(
     SafeMILHandle /* IWICBitmapFrameDecode */ THIS_PTR,
     out IntPtr /* IWICBitmap */ ppIThumbnail
     ); 

 internal static extern int /* HRESULT */ GetFrame(
     SafeMILHandle /* IWICBitmapDecoder */ THIS_PTR, 
     UInt32 index, 
     out IntPtr /* IWICBitmapFrameDecode */ ppIFrameDecode
     ); 

 internal static extern int /* HRESULT */ GetFrameCount(
     SafeMILHandle THIS_PTR, 
     out uint pFrameCount 
     );

 internal static extern int /* HRESULT */ GetPreview(
     SafeMILHandle THIS_PTR, 
     out IntPtr /* IWICBitmapSource */ ppIBitmapSource
     ); 

 internal static extern int /* HRESULT */ SetColorContexts(SafeMILHandle /* IWICBitmapEncoder*  */ THIS_PTR,
         uint nIndex, 
         IntPtr[] /* IWICColorContext */ ppIColorContext 
         );

 internal static extern int /* HRESULT */ Initialize(SafeMILHandle /* IWICBitmapEncoder* */ THIS_PTR,
     IntPtr /* IStream */ pStream,
     WICBitmapEncodeCacheOption option); 

 internal static extern int /* HRESULT */ GetColorContexts( 
     SafeMILHandle /* IWICBitmapFrameDecode */ THIS_PTR,
     uint count, 
     IntPtr[] /* IWICColorContext */ ppIColorContext,
     out uint pActualCount
     );

 internal static extern int /* HRESULT */ CreateNewFrame(SafeMILHandle /* IWICBitmapEncoder* */ THIS_PTR,
     out SafeMILHandle /* IWICBitmapFrameEncode ** */ ppIFramEncode, 
     out SafeMILHandle /* IPropertyBag2 ** */ ppIEncoderOptions
 );

 internal static extern UInt32 AddRef(SafeMILHandle pIUnkown);