IVideoCompositor IVideoCompositor IVideoCompositor IVideoCompositor Interface

Definition

The interface you implement to create a custom video compositor.

public : interface IVideoCompositorpublic interface IVideoCompositorPublic Interface IVideoCompositor// You can use this interface in JavaScript.
Inheritance
IVideoCompositorIVideoCompositorIVideoCompositorIVideoCompositor
Attributes
Windows 10 requirements
Device family
Windows 10 (introduced v10.0.10240.0)
API contract
Windows.Foundation.UniversalApiContract (introduced v1)

Inherited Members

Inherited methods

Examples

using Microsoft.Graphics.Canvas; using Microsoft.Graphics.Canvas.Effects; using Windows.Foundation.Collections; using Windows.Graphics.DirectX.Direct3D11; using Windows.Media.Effects; using Windows.Media.MediaProperties; using 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
    }
}

Remarks

  1. In a Windows Runtime Component project, derive a public sealed class from this interface (see example below).
  2. Use the full class name in a MediaOverlayLayer constructor.

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

    var compositorDefinition = new VideoCompositorDefinition( "Effects.ChromaKeyVideoCompositor", propertySet);

    var mediaOverlayLayer = new MediaOverlayLayer(compositorDefinition);

Properties

TimeIndependent TimeIndependent TimeIndependent TimeIndependent

Gets a value that indicates whether the custom video effect is time independent.

public : PlatForm::Boolean TimeIndependent { get; }public bool TimeIndependent { get; }Public ReadOnly Property TimeIndependent As bool// You can use this property in JavaScript.
Value
PlatForm::Boolean bool bool bool

True, if the video effect is time independent; otherwise, false.

Methods

Close(MediaEffectClosedReason) Close(MediaEffectClosedReason) Close(MediaEffectClosedReason) Close(MediaEffectClosedReason)

Called when the video compositor should close and clean up allocated resources.

public : void Close(MediaEffectClosedReason reason)public void Close(MediaEffectClosedReason reason)Public Function Close(reason As MediaEffectClosedReason) As void// You can use this method in JavaScript.
Parameters

CompositeFrame(CompositeVideoFrameContext) CompositeFrame(CompositeVideoFrameContext) CompositeFrame(CompositeVideoFrameContext) CompositeFrame(CompositeVideoFrameContext)

Called when frames are available for composition by a custom video compositor.

public : void CompositeFrame(CompositeVideoFrameContext context)public void CompositeFrame(CompositeVideoFrameContext context)Public Function CompositeFrame(context As CompositeVideoFrameContext) As void// You can use this method in JavaScript.
Parameters
context
CompositeVideoFrameContext CompositeVideoFrameContext CompositeVideoFrameContext CompositeVideoFrameContext

The context object that provides the input and output frames for the composition operation.

DiscardQueuedFrames() DiscardQueuedFrames() DiscardQueuedFrames() DiscardQueuedFrames()

Called to allow video compositor implementations optionally discard any stored state related to frames that have already been received.

public : void DiscardQueuedFrames()public void DiscardQueuedFrames()Public Function DiscardQueuedFrames() As void// You can use this method in JavaScript.

SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice) SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice) SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice) SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice)

Called to set the encoding properties of a custom video compositor.

public : void SetEncodingProperties(VideoEncodingProperties backgroundProperties, IDirect3DDevice device)public void SetEncodingProperties(VideoEncodingProperties backgroundProperties, IDirect3DDevice device)Public Function SetEncodingProperties(backgroundProperties As VideoEncodingProperties, device As IDirect3DDevice) As void// You can use this method in JavaScript.
Parameters
device
IDirect3DDevice IDirect3DDevice IDirect3DDevice IDirect3DDevice

The Microsoft Direct3D device that can be used to create resources based on the media format described by the encoding properties.

See Also