次の方法で共有


IVideoCompositor インターフェイス

定義

カスタム ビデオ コンポジターを作成するために実装するインターフェイス。

public interface class IVideoCompositor : IMediaExtension
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.Guid(2232464446, 16908, 16911, 150, 199, 124, 152, 187, 161, 252, 85)]
struct IVideoCompositor : IMediaExtension
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.Guid(2232464446, 16908, 16911, 150, 199, 124, 152, 187, 161, 252, 85)]
public interface IVideoCompositor : IMediaExtension
Public Interface IVideoCompositor
Implements IMediaExtension
属性
実装

Windows の要件

デバイス ファミリ
Windows 10 (10.0.10240.0 で導入)
API contract
Windows.Foundation.UniversalApiContract (v1.0 で導入)

Microsoft.Graphics.Canvas を使用する。Microsoft.Graphics.Canvas.Effects を使用する。Windows.Foundation.Collections を使用する。Windows.Graphics.DirectX.Direct3D11 を使用する。Windows.Media.Effects を使用する。Windows.Media.MediaProperties の使用。Windows.UI を使用する。

namespace Effects
{
    /// <summary>
    /// Chroma key compositor
    /// <list type="Bullet">
    /// <listheader>Properties</listheader>
    /// <item>Color (Color) : Chroma key color (default is black)</item>
    /// <item>Feather (Boolean): true to soften edges of the output (default is false)</item>
    /// <item>Tolerance (float): Color tolerance 0-1 (default is 0.1)</item>
    /// <item>InvertAlpha (Boolean): invert the alpha value (default is false)</item>
    /// </list>
    /// </summary>
    public sealed class ChromaKeyVideoCompositor : IVideoCompositor
    {
        #region Fields
        private VideoEncodingProperties _backgroundProperties;
        private CanvasDevice _canvasDevice;
        #endregion

        #region Properties
        /// <summary>
        /// Gets the chroma-key color
        /// </summary>
        public Color Color { get; private set; } = Colors.Black;

        /// <summary>
        /// Gets a value indicating whether to feather the edges of the chroma key
        /// </summary>
        public bool Feather { get; private set; } = false;

        /// <summary>
        /// Gets the color tolerance 
        /// </summary>
        public float Tolerance { get; private set; } = 0.1f;

        /// <summary>
        /// Gets a value indicating whether to invert the alpha transparency
        /// </summary>
        public bool InvertAlpha { get; private set; } = false;

        /// <summary>
        /// Gets a value indicating whether the compositor is time-independent
        /// </summary>
        public bool TimeIndependent => true;
        #endregion

        #region Methods
        /// <summary>
        /// Sets the encoding properties
        /// </summary>
        /// <param name="backgroundProperties">the background properties</param>
        /// <param name="device">the Direct3D device</param>
        public void SetEncodingProperties(VideoEncodingProperties backgroundProperties, IDirect3DDevice device)
        {
            _backgroundProperties = backgroundProperties;

            _canvasDevice = CanvasDevice.CreateFromDirect3D11Device(device);
        }

        /// <summary>
        /// Composite the frame
        /// </summary>
        /// <param name="context">the composite frame context</param>
        public void CompositeFrame(CompositeVideoFrameContext context)
        {
            foreach (var surface in context.SurfacesToOverlay)
            {
                using (CanvasBitmap inputBitmap = CanvasBitmap.CreateFromDirect3D11Surface(_canvasDevice, surface))
                using (CanvasRenderTarget renderTarget = CanvasRenderTarget.CreateFromDirect3D11Surface(_canvasDevice, context.OutputFrame.Direct3DSurface))
                using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
                using (var chromaKeyEffect = new ChromaKeyEffect
                {
                    Source = inputBitmap,
                    Color = Color,
                    Feather = Feather,
                    Tolerance = Tolerance,
                    InvertAlpha = InvertAlpha
                })
                {
                    var overlay = context.GetOverlayForSurface(surface);

                    var destinationRectangle = overlay.Position;

                    var sourceRectangle = inputBitmap.Bounds;

                    var opacity = System.Convert.ToSingle(overlay.Opacity);

                    ds.DrawImage(chromaKeyEffect, destinationRectangle, sourceRectangle, opacity);
                }
            }
        }

        /// <summary>
        /// Close the compositor & dispose of the canvas device
        /// </summary>
        /// <param name="reason">the media effect closed reason</param>
        public void Close(MediaEffectClosedReason reason)
        {
            if (_canvasDevice != null)
            {
                _canvasDevice.Dispose();
                _canvasDevice = null;
            }
        }

        /// <summary>
        /// Discard of the queued frames
        /// </summary>
        /// <remarks>this does nothing</remarks>
        public void DiscardQueuedFrames()
        {
        }

        /// <summary>
        /// Sets the properties passed into the compositor
        /// </summary>
        /// <param name="configuration">the configuration</param>
        public void SetProperties(IPropertySet configuration)
        {
            if (configuration == null)
            {
                return;
            }

            object value;

            if (configuration.TryGetValue("Color", out value))
            {
                Color = (Color)value;
            }

            if (configuration.TryGetValue("Tolerance", out value))
            {
                Tolerance = (float)value;
            }

            if (configuration.TryGetValue("Feather", out value))
            {
                Feather = (bool)value;
            }

            if (configuration.TryGetValue("InvertAlpha", out value))
            {
                InvertAlpha = (bool)value;
            }
        }
        #endregion
    }
}

注釈

  1. Windows ランタイム コンポーネント プロジェクトで、このインターフェイスからパブリック シール クラスを派生させます (以下の例を参照)。

  2. MediaOverlayLayer コンストラクターで完全なクラス名を使用します。

    var propertySet = new PropertySet { ["Feather"] = true, ["Tolerance"] = 0.2f, ["Color"] = Colors.Blue };

    var compositorDefinition = 新しい VideoCompositorDefinition( "Effects.ChromaKeyVideoCompositor", propertySet);

    var mediaOverlayLayer = new MediaOverlayLayer(compositorDefinition);

プロパティ

TimeIndependent

カスタム ビデオ効果が時間に依存しないかどうかを示す値を取得します。

メソッド

Close(MediaEffectClosedReason)

ビデオコンポジターが閉じ、割り当てられたリソースをクリーンするときに呼び出されます。

CompositeFrame(CompositeVideoFrameContext)

カスタム ビデオ コンポジターによって合成にフレームを使用できる場合に呼び出されます。

DiscardQueuedFrames()

ビデオコンポジターの実装で、既に受信されているフレームに関連する保存された状態を必要に応じて破棄できるようにするために呼び出されます。

SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice)

カスタム ビデオ コンポジターのエンコード プロパティを設定するために呼び出されます。

SetProperties(IPropertySet)

メディア パーサーまたはコーデックの登録時に指定された構成プロパティを設定します。

(継承元 IMediaExtension)

適用対象

こちらもご覧ください