IVideoCompositor 인터페이스

정의

네임스페이스:

Windows.Media.Effects

사용자 지정 비디오 작성기를 만들기 위해 구현하는 인터페이스입니다.

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

특성

ContractVersionAttribute GuidAttribute

구현

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 = new VideoCompositorDefinition( "Effects.ChromaKeyVideoCompositor", propertySet);

   var mediaOverlayLayer = new MediaOverlayLayer(compositorDefinition);

속성

TimeIndependent

사용자 지정 비디오 효과가 시간 독립적인지 여부를 나타내는 값을 가져옵니다.

메서드

Close(MediaEffectClosedReason)	비디오 작성자가 닫고 할당된 리소스를 클린 때 호출됩니다.
CompositeFrame(CompositeVideoFrameContext)	사용자 지정 비디오 작성기에서 프레임을 컴퍼지션에 사용할 수 있을 때 호출됩니다.
DiscardQueuedFrames()	비디오 작성기 구현을 허용하기 위해 호출되어 이미 수신된 프레임과 관련된 저장된 상태를 선택적으로 삭제합니다.
SetEncodingProperties(VideoEncodingProperties, IDirect3DDevice)	사용자 지정 비디오 작성기의 인코딩 속성을 설정하기 위해 호출됩니다.
SetProperties(IPropertySet)	미디어 파서 또는 코덱이 등록되었을 때 제공된 구성 속성을 설정합니다. (다음에서 상속됨 IMediaExtension)

추가 정보

• IMediaExtension