IVideoCompositor Interfaccia

Definizione

Spazio dei nomi:

Windows.Media.Effects

Interfaccia implementata per creare un compositore video personalizzato.

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

Attributi

ContractVersionAttribute GuidAttribute

Implementazioni

IMediaExtension

Requisiti Windows

Famiglia di dispositivi	Windows 10 (è stato introdotto in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v1.0)

Esempio

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

Commenti

1. In un progetto componente Windows Runtime derivare una classe chiusa pubblica da questa interfaccia (vedere l'esempio seguente).

2. Usare il nome completo della classe in un costruttore MediaOverlayLayer .

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

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

   var mediaOverlayLayer = new MediaOverlayLayer(compositorDefinition);

Proprietà

TimeIndependent

Ottiene un valore che indica se l'effetto video personalizzato è indipendente dal tempo.

Metodi

Close(MediaEffectClosedReason)	Chiamato quando il compositore video deve chiudere e pulire le risorse allocate.
CompositeFrame(CompositeVideoFrameContext)	Chiamato quando i fotogrammi sono disponibili per la composizione da un compositore video personalizzato.
DiscardQueuedFrames()	Chiamato per consentire implementazioni del compositore video facoltativamente eliminare qualsiasi stato archiviato correlato ai fotogrammi già ricevuti.
SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice)	Chiamato per impostare le proprietà di codifica di un compositore video personalizzato.
SetProperties(IPropertySet)	Imposta le proprietà di configurazione fornite quando è stato registrato il parser multimediale o il codec. (Ereditato da IMediaExtension)

Vedi anche

• IMediaExtension