MixedRemoteViewCompositor.idl

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

import "inspectable.idl";
import "AsyncInfo.idl";
import "EventToken.idl";
import "Windows.Foundation.idl";
import "Windows.Foundation.Numerics.idl";
import "Windows.Media.idl";
import "Windows.Media.Capture.idl";
import "Windows.Media.Capture.Core.idl";
import "Windows.Networking.Sockets.idl";
import "Windows.Perception.Spatial.idl";
import "Windows.Storage.idl";
import "Windows.Storage.Streams.idl";

// Additional imports to ensure that all required headers are included
//cpp_quote("#if defined(__cplusplus)")
//cpp_quote("}")
//cpp_quote("#endif // defined(__cplusplus)")
cpp_quote("#include <Windows.Foundation.h>")
cpp_quote("#if !defined(__windows2Enetworking2Esockets_h__)")
cpp_quote("#include <Windows.Networking.Sockets.h>")
cpp_quote("#endif // !defined(__windows2Enetworking2Esockets_h__)")
//cpp_quote("#if defined(__cplusplus)")
//cpp_quote("extern \"C\" {")
//cpp_quote("#endif // defined(__cplusplus)")

namespace MixedRemoteViewCompositor
{
    typedef UINT32 ModuleHandle;
    cpp_quote("#ifndef MODULE_HANDLE")
        cpp_quote("typedef UINT32 MODULE_HANDLE;")
        cpp_quote("#define MODULE_HANDLE_INVALID (UINT)0x0bad")
        cpp_quote("#define MODULE_HANDLE_START (UINT)0x0bae")
    cpp_quote("#endif // MODULE_HANDLE")

    cpp_quote("const ULONG c_cbReceiveBufferSize = 2 * 1024;")
    cpp_quote("const ULONG c_cbMaxBundleSize = 1024 * 1024;")
    cpp_quote("const UINT16 c_cbMaxBufferFailures = 7;")
    cpp_quote("const UINT16 c_cbMaxBundleFailures = 3;")
    cpp_quote("extern wchar_t const __declspec(selectany)c_szNetworkScheme[] = L\"mrvc\";")
    cpp_quote("extern wchar_t const __declspec(selectany)c_szNetworkSchemeWithColon[] = L\"mrvc:\";")
}

cpp_quote("#ifdef __cplusplus")
cpp_quote("namespace MixedRemoteViewCompositor { namespace Network {")
cpp_quote("typedef ABI::Windows::Foundation::ITypedEventHandler<ABI::Windows::Networking::Sockets::StreamSocketListener*, ABI::Windows::Networking::Sockets::StreamSocketListenerConnectionReceivedEventArgs*> IConnectionReceivedEventHandler;")
cpp_quote("}}")
cpp_quote("#endif //__cplusplus")

// Forward Declare
namespace MixedRemoteViewCompositor
{
    typedef enum PayloadType PayloadType;
    typedef enum SampleFlags SampleFlags;

    typedef struct MF_FLOAT2 MF_FLOAT2;
    typedef struct MFCameraIntrinsic_PinholeCameraModel MFCameraIntrinsic_PinholeCameraModel;
    typedef struct MFCameraIntrinsic_DistortionModel MFCameraIntrinsic_DistortionModel;
    typedef struct MFPinholeCameraIntrinsic_IntrinsicModel MFPinholeCameraIntrinsic_IntrinsicModel;
    typedef struct MFPinholeCameraIntrinsics MFPinholeCameraIntrinsics;

    typedef struct PayloadHeader PayloadHeader;
    typedef struct MediaTypeDescription MediaTypeDescription;
    typedef struct MediaSampleHeader MediaSampleHeader;
    typedef struct MediaSampleTransforms MediaSampleTransforms;
    typedef struct MediaStreamTick MediaStreamTick;
}

// forward declares
namespace MixedRemoteViewCompositor { namespace Plugin {
    typedef enum DeviceType DeviceType;
    typedef enum PluginEventType PluginEventType;

    delegate ClosedEventHandler;

    interface IModule;
    interface IModuleManager;
    interface IModuleManagerStatics;
    runtimeclass ModuleManager;

    interface IPluginManager;
    interface IPluginManagerStatics;
    runtimeclass PluginManager;

    interface IDirectXManager;
} }

namespace MixedRemoteViewCompositor{ namespace Network {
    delegate DisconnectedEventHandler;
    delegate BundleReceivedEventHandler;
    delegate ConnectedEventHandler;

    interface IDataBuffer;
    interface IDataBufferStatics;
    runtimeclass DataBuffer;

    interface IDataBundle;
    interface IDataBundleStatics;
    runtimeclass DataBundle;

    interface IBundleReceivedArgs;
    interface IBundleReceivedArgsStatics;
    runtimeclass BundleReceivedArgs;

    interface IConnection;
    interface IConnectionInternal;
    interface IConnectionStatics;
    runtimeclass Connection;

    interface IConnectionLock;
    runtimeclass ConnectionLock;

    interface IConnectedEventArgs;
    runtimeclass ConnectedEventArgs;

    interface IConnector;
    interface IConnectorStatics;
    runtimeclass Connector;

    interface IListener;
    interface IListenerStatics;
    runtimeclass Listener;
} }

namespace MixedRemoteViewCompositor { namespace Media {
    typedef enum SourceStreamState SourceStreamState;
    typedef enum SinkStreamState SinkStreamState;
    typedef enum SinkStreamOperation SinkStreamOperation;

    typedef Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation*> IDeviceEnumerationOperation;
    typedef Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Enumeration.DeviceInformation*> IDeviceEnumerationCompletedHandler;

    delegate FormatChangedEventHandler;
    interface IFormatChangedEventArgs;
    runtimeclass FormatChangedEventArgs;

    delegate SampleUpdatedEventHandler;
    interface ISampleUpdatedEventArgs;
    runtimeclass SampleUpdatedEventArgs;

    interface IMrvcSchemeHandler;
    runtimeclass MrvcSchemeHandler;

    interface INetworkMediaSourceStream;

    interface INetworkMediaSource;
    interface INetworkMediaSourceStatics;
    runtimeclass NetworkMediaSource;

    interface IPlaybackEngine;
    interface IPlaybackEngineStatics;
    runtimeclass PlaybackEngine;

    interface INetworkMediaSink;
    interface INetworkMediaSinkInternal;
    runtimeclass NetworkMediaSink;

    typedef enum AudioMixerMode AudioMixerMode;
    interface IMrcAudioEffectDefinition;
    runtimeclass MrcAudioEffectDefinition;

    interface IMrcVideoEffectDefinition;
    runtimeclass MrcVideoEffectDefinition;

    interface ICaptureEngine;
    interface ICaptureEngineStatics;
    runtimeclass CaptureEngine;
} }

// interface defines
namespace MixedRemoteViewCompositor {

    // enums
    [version(1.0)]
    enum PayloadType
    {
        Unknown,
        State_Scene,
        State_Input,
        State_CaptureReady,
        State_CaptureStarted,
        State_CaptureStopped,
        RequestMediaDescription,
        RequestMediaStart,
        RequestMediaStop,
        RequestMediaCaptureStart,
        RequestMediaCaptureRecord,
        RequestMediaCaptureStop,
        RequestMediaEncodeStart,
        RequestMediaEncodeStop,
        SendMediaDescription,
        SendMediaSample,
        SendMediaStreamTick,
        SendFormatChange,
        ENDOFLIST
    };

    [version(1.0)]
    enum SampleFlags
    {
        SampleFlag_BottomFieldFirst = 0,
        SampleFlag_CleanPoint = 1,
        SampleFlag_DerivedFromTopField = 2,
        SampleFlag_Discontinuity = 3,
        SampleFlag_Interlaced = 4,
        SampleFlag_RepeatFirstField = 5,
        SampleFlag_SingleField = 6
    };

    // structs
    [version(1.0)]
    struct PayloadHeader
    {
        PayloadType ePayloadType;
        DWORD cbPayloadSize;
    };

    [version(1.0)]
    struct MediaDescription
    {
        DWORD StreamCount;
        DWORD StreamTypeHeaderSize;
    };

    [version(1.0)]
    struct MediaTypeDescription
    {
        GUID guiMajorType;
        GUID guiSubType;
        DWORD dwStreamId;
        UINT32 AttributesBlobSize;
    };

    [version(1.0)]
    struct MF_FLOAT2
    {
        FLOAT   x;
        FLOAT   y;
    };

    [version(1.0)]
    struct MFCameraIntrinsic_PinholeCameraModel
    {
        MF_FLOAT2   FocalLength;      // In Image space
        MF_FLOAT2   PrincipalPoint;   // In Image space
    };

    [version(1.0)]
    struct MFCameraIntrinsic_DistortionModel
    {
        FLOAT Radial_k1;
        FLOAT Radial_k2;
        FLOAT Radial_k3;
        FLOAT Tangential_p1;
        FLOAT Tangential_p2;
    };

    [version(1.0)]
    struct MFPinholeCameraIntrinsic_IntrinsicModel
    {
        UINT32 Width;
        UINT32 Height;
        MFCameraIntrinsic_PinholeCameraModel CameraModel;
        MFCameraIntrinsic_DistortionModel DistortionModel;
    };

    [version(1.0)]
    struct MFPinholeCameraIntrinsics
    {
        UINT32 count;
        MFPinholeCameraIntrinsic_IntrinsicModel IntrinsicModels;
    };

    [version(1.0)]
    struct MediaSampleHeader
    {
        DWORD dwStreamId;
        LONGLONG hnsTimestamp;
        LONGLONG hnsDuration;
        DWORD dwFlags;
        DWORD dwFlagMasks;
        DWORD cbCameraDataSize;
        Windows.Foundation.Numerics.Matrix4x4 worldToCameraMatrix;
        Windows.Foundation.Numerics.Matrix4x4 cameraProjectionTransform;
        Windows.Foundation.Numerics.Matrix4x4 cameraViewTransform;
    };

    [version(1.0)]
    struct MediaSampleTransforms
    {
        Windows.Foundation.Numerics.Matrix4x4 worldToCameraMatrix;
        Windows.Foundation.Numerics.Matrix4x4 cameraProjectionTransform;
        Windows.Foundation.Numerics.Matrix4x4 cameraViewTransform;
		MFPinholeCameraIntrinsics cameraIntrinsics;
    };

    [version(1.0)]
    struct MediaStreamTick
    {
        DWORD dwStreamId;
        LONGLONG hnsTimestamp;
        UINT32 cbAttributesSize;
    };

}

namespace MixedRemoteViewCompositor { namespace Plugin {

    [version(1.0)]
    enum DeviceType
    {
        Null = 0,
        DX11 = 1,
        Warp = 2
    };

    [version(1.0)]
    enum PluginEventType
    {
        Update = 1,
        Render = 2,
        Flush = 3
    };

    // delegates
    [uuid(742c3239-1cf3-40bb-98c8-73270e0e337f)]
    [version(1.0)]
    delegate HRESULT ClosedEventHandler(
        [in] IInspectable* sender);

    // IModule
    [uuid(2edeb3fb-8008-4a13-b8d3-7081fd11443f)]
    [version(1.0)]
    interface IModule : IInspectable requires
        Windows.Foundation.IClosable
    {
        [propget] HRESULT IsInitialized([out, retval] boolean* isInitialized);
        HRESULT Uninitialize();
    };

    // ModuleManager
    [exclusiveto(ModuleManager)]
    [uuid(ee26ebc8-2eba-4476-be2a-4bf9389590bc)]
    [version(1.0)]
    interface IModuleManager : IInspectable
    {
        HRESULT AddModule(
            [in] MixedRemoteViewCompositor.Plugin.IModule* pluginModule,
            [out, retval] MixedRemoteViewCompositor.ModuleHandle* moduleHandle);
        HRESULT GetModule(
            [in] MixedRemoteViewCompositor.ModuleHandle moduleHandle,
            [out, retval] MixedRemoteViewCompositor.Plugin.IModule** pluginModule);
        HRESULT ReleaseModule(
            [in] MixedRemoteViewCompositor.ModuleHandle moduleHandle);
        HRESULT Uninitialize();
    };

    [exclusiveto(ModuleManager)]
    [uuid(5feb052c-d722-4f2a-8bf5-7d03ba808794)]
    [version(1.0)]
    interface IModuleManagerStatics : IInspectable
    {
        [propget] HRESULT InvalidModuleHandle(
            [out, retval] MixedRemoteViewCompositor.ModuleHandle* moduleHandle);
    };

    [activatable(1.0)]
    [static(MixedRemoteViewCompositor.Plugin.IModuleManagerStatics, 1.0)]
    [version(1.0)]
    runtimeclass ModuleManager
    {
        [default] interface MixedRemoteViewCompositor.Plugin.IModuleManager;
    };

    // PluginManager
    [exclusiveto(PluginManager)]
    [uuid(c9630182-dd7a-4fe8-b797-14aa4daf297a)]
    [version(1.0)]
    interface IPluginManager : IInspectable
    {
        [propget] HRESULT ModuleManager(
            [out][retval] MixedRemoteViewCompositor.Plugin.ModuleManager** moduleManager);
        [propget] HRESULT DirectXManager(
            [out][retval] MixedRemoteViewCompositor.Plugin.IDirectXManager** dxManager);
    };

    [exclusiveto(PluginManager)]
    [uuid(172d17ad-464c-4da4-ad26-34d2a70d4f07)]
    [version(1.0)]
    interface IPluginManagerStatics : IInspectable
    {
        [propget] HRESULT Instance([out][retval] MixedRemoteViewCompositor.Plugin.PluginManager** pluginManager);
    };

    [static(MixedRemoteViewCompositor.Plugin.IPluginManagerStatics, 1.0)]
    [version(1.0)]
    runtimeclass PluginManager
    {
        [default] interface MixedRemoteViewCompositor.Plugin.IPluginManager;
    };

    // IDirectXManager
    [uuid(712c3f26-ea19-44a2-b947-0313c7d41a2b)]
    [version(1.0)]
    interface IDirectXManager : IInspectable
    {
    };

} }

namespace MixedRemoteViewCompositor{ namespace Network {

    declare
    {
        interface Windows.Foundation.Collections.IVector<MixedRemoteViewCompositor.Network.DataBuffer*>;
        interface Windows.Foundation.Collections.IIterable<MixedRemoteViewCompositor.Network.DataBuffer*>;
        interface Windows.Foundation.IAsyncOperation<MixedRemoteViewCompositor.Network.Connection*>;
    }

    // delegates
    [uuid(7f6533cb-58a5-4634-a0ca-1af12e82f508)]
    [version(1.0)]
    delegate HRESULT DisconnectedEventHandler(
        [in] MixedRemoteViewCompositor.Network.Connection* sender);

    [uuid(351aade9-5b42-4ae8-9d72-dd5b765d3420)]
    [version(1.0)]
    delegate HRESULT BundleReceivedEventHandler(
        [in] MixedRemoteViewCompositor.Network.Connection* sender,
        [in] MixedRemoteViewCompositor.Network.BundleReceivedArgs* args);

    [uuid(6f17b4ae-f506-4d6e-a666-893638581b19)]
    [version(1.0)]
    delegate HRESULT ConnectedEventHandler(
        [in] MixedRemoteViewCompositor.Network.Connection* connection);

    // DataPacket
    [uuid(3fcabce1-d85d-4990-93cc-64b26b8b9505)]
    [version(1.0)]
    interface IDataPacket : IInspectable
        requires Windows.Storage.Streams.IBuffer
    {
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass DataPacket
    {
        [default] interface MixedRemoteViewCompositor.Network.IDataPacket;
    };

    // DataBuffer
    [uuid(2fffa1dc-aa9b-4f0f-a67c-414da47613b8)]
    [version(1.0)]
    interface IDataBuffer : IInspectable
    {
        [propget] HRESULT Offset(
            [out][retval] DWORD* offset);
        [propput] HRESULT Offset(
            [in] DWORD offset);

        [propget] HRESULT CurrentLength(
            [out][retval] DWORD* currentLength);
        [propput] HRESULT CurrentLength(
            [in] DWORD currentLength);

        HRESULT TrimLeft(
            [in] ULONG cbSize);
        HRESULT TrimRight(
            [in] ULONG cbSize,
            [out] MixedRemoteViewCompositor.Network.DataBuffer** dataBuffer);

        HRESULT Reset();
    };

    [uuid(eb453df3-e098-4fcb-b76c-ef3838583033)]
    [version(1.0)]
    interface IDataBufferStatics : IInspectable
    {
        [overload("Create")] HRESULT Create(
            [in] ULONG size);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass DataBuffer
    {
        [default] interface MixedRemoteViewCompositor.Network.IDataBuffer;
    };

    // DataBufferLock
    [uuid(4375ee9d-0302-416b-af1a-2b8ff632a06f)]
    [version(1.0)]
    interface IDataBufferLock : IInspectable
    {
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass DataBufferLock
    {
        [default] interface MixedRemoteViewCompositor.Network.IDataBufferLock;
    };

    // DataBundle
    [uuid(049cd02e-12ec-45dc-8f58-931c342087ed)]
    [version(1.0)]
    interface IDataBundle : IInspectable 
    {
        [propget] HRESULT BufferCount(
            [out][retval] UINT32* count);
        [propget] HRESULT TotalSize(
            [out][retval] ULONG* size);

        HRESULT AddBuffer(
            [in] MixedRemoteViewCompositor.Network.DataBuffer* dataBuffer);
        HRESULT InsertBuffer(
            [in] UINT32 index,
            [in] MixedRemoteViewCompositor.Network.DataBuffer* dataBuffer);
        HRESULT RemoveBuffer(
            [in] MixedRemoteViewCompositor.Network.DataBuffer* dataBuffer);
        HRESULT RemoveBufferByIndex(
            [in] UINT32 index,
            [out][retval] MixedRemoteViewCompositor.Network.DataBuffer** dataBuffer);
        HRESULT Reset(void);
    };

    [uuid(bac3c09b-76ca-44d9-ad40-080f3101884a)]
    [version(1.0)]
    interface IDataBundleStatics :IInspectable
    {
        [overload("Create")] HRESULT Create(
            [in] MixedRemoteViewCompositor.Network.DataBuffer* dataBuffer);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass DataBundle
    {
        [default] interface MixedRemoteViewCompositor.Network.IDataBundle;
    };

    // BundleReceivedArgs
    [uuid(c0d9ad8e-f586-4314-af4d-69b80513b470)]
    [version(1.0)]
    interface IBundleReceivedArgs : IInspectable
    {
        [propget] HRESULT PayloadType(
            [out][retval] MixedRemoteViewCompositor.PayloadType* payloadType);

        [propget] HRESULT Connection(
            [out][retval] MixedRemoteViewCompositor.Network.Connection** connection);

        [propget] HRESULT DataBundle(
            [out][retval] MixedRemoteViewCompositor.Network.DataBundle** dataBundle);

        [propget] HRESULT RemoteUri(
            [out][retval] Windows.Foundation.Uri** uri);
    };

    [exclusiveto(MixedRemoteViewCompositor.Network.BundleReceivedArgs)]
    [uuid(3fa67b47-6b91-42ad-912c-ddd97ce02d50)]
    [version(1.0)]
    interface IBundleReceivedArgsStatics : IInspectable
    {
        [overload("Create")] HRESULT Create(
            [in] MixedRemoteViewCompositor.PayloadType type,
            [in] MixedRemoteViewCompositor.Network.Connection* connection,
            [in] MixedRemoteViewCompositor.Network.DataBundle* dataBundle,
            [in] Windows.Foundation.Uri* uri,
            [out][retval] MixedRemoteViewCompositor.Network.BundleReceivedArgs** args);
    };

    [activatable(MixedRemoteViewCompositor.Network.IBundleReceivedArgsStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass BundleReceivedArgs
    {
        [default] interface MixedRemoteViewCompositor.Network.IBundleReceivedArgs;
    };

    // Connection
    [exclusiveto(MixedRemoteViewCompositor.Network.Connection)]
    [uuid(027d0a6d-3ffb-480e-9e68-255cba264d40)]
    [version(1.0)]
    interface IConnection : IInspectable requires
        MixedRemoteViewCompositor.Network.IConnectionInternal,
        MixedRemoteViewCompositor.Plugin.IModule,
        Windows.Foundation.IClosable
    {
        [propget] HRESULT IsConnected(
            [out][retval] boolean* connected);

        [eventadd] HRESULT Disconnected(
            [in] MixedRemoteViewCompositor.Network.DisconnectedEventHandler* eventHandler,
            [out, retval] EventRegistrationToken* token);
        [eventremove] HRESULT Disconnected(
            [in] EventRegistrationToken token);

        [eventadd] HRESULT Received(
            [in] MixedRemoteViewCompositor.Network.BundleReceivedEventHandler* eventHandler,
            [out, retval] EventRegistrationToken* token);
        [eventremove] HRESULT Received(
            [in] EventRegistrationToken token);

        HRESULT SendPayloadType(
            [in] MixedRemoteViewCompositor.PayloadType type);
        HRESULT SendBundle(
            [in] MixedRemoteViewCompositor.Network.DataBundle* dataBundle);
        HRESULT SendBundleAsync(
            [in] MixedRemoteViewCompositor.Network.DataBundle* dataBundle,
            [out, retval] Windows.Foundation.IAsyncAction** asyncAction);
    };

    [exclusiveto(MixedRemoteViewCompositor.Network.Connection)]
    [uuid(7e41360e-7307-4ee3-8f5d-b644e7e5c55a)]
    [version(1.0)]
    interface IConnectionInternal : IInspectable
    {
        HRESULT CheckClosed();
        HRESULT WaitForHeader();
        HRESULT WaitForPayload();
        HRESULT ResetBundle();
    };

    [exclusiveto(MixedRemoteViewCompositor.Network.Connection)]
    [uuid(b3c719f9-b1c6-425a-9b21-8a36eaac7be4)]
    [version(1.0)]
    interface IConnectionStatics : IInspectable
    {
        HRESULT Create(
            [in] Windows.Networking.Sockets.StreamSocket* streamSocket,
            [out][retval] MixedRemoteViewCompositor.Network.Connection** connection);
    };

    [activatable(MixedRemoteViewCompositor.Network.IConnectionStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass Connection
    {
        [default] interface MixedRemoteViewCompositor.Network.IConnection;
        interface MixedRemoteViewCompositor.Network.IConnectionInternal;
        interface MixedRemoteViewCompositor.Plugin.IModule;
        interface Windows.Foundation.IClosable;
    };

    // Listener
    [exclusiveto(MixedRemoteViewCompositor.Network.Listener)]
    [uuid(887397c7-ce0f-4ced-86f1-54f4ee079d0b)]
    [version(1.0)]
    interface IListener : IInspectable requires
        Windows.Foundation.IClosable,
        MixedRemoteViewCompositor.Plugin.IModule
    {
        [eventadd] HRESULT Closed(
            [in] MixedRemoteViewCompositor.Plugin.ClosedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT Closed([in] EventRegistrationToken token);

        HRESULT ListenAsync(
            [out][retval] Windows.Foundation.IAsyncOperation<Connection*>** operation);
    };

    [uuid(0cfcc430-07f5-49c1-b86a-123da17030b5)]
    [version(1.0)]
    interface IListenerStatics : IInspectable
    {
        [overload("Create")] HRESULT Create(
            [in] UINT16 port,
            [out][retval] MixedRemoteViewCompositor.Network.Listener** listener);
    };

    [activatable(MixedRemoteViewCompositor.Network.IListenerStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass Listener
    {
        [default] interface MixedRemoteViewCompositor.Network.IListener;
        interface MixedRemoteViewCompositor.Plugin.IModule;
        interface Windows.Foundation.IClosable;
    };

    // Connector
    [exclusiveto(MixedRemoteViewCompositor.Network.Connector)]
    [uuid(4d3288f4-b509-4ffe-848d-200218029096)]
    [version(1.0)]
    interface IConnector : IInspectable requires
        Windows.Foundation.IClosable,
        MixedRemoteViewCompositor.Plugin.IModule
    {
        [eventadd] HRESULT Closed(
            [in] MixedRemoteViewCompositor.Plugin.ClosedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT Closed(
            [in] EventRegistrationToken token);

        HRESULT ConnectAsync(
            [out][retval] Windows.Foundation.IAsyncOperation<Connection*>** operation);
    };

    [exclusiveto(MixedRemoteViewCompositor.Network.Connector)]
    [uuid(5af2e9f2-5052-46f5-a118-85d281b11314)]
    [version(1.0)]
    interface IConnectorStatics : IInspectable
    {
        HRESULT Create(
            [in] HSTRING hostAddress,
            [in] UINT16 port,
            [out][retval] MixedRemoteViewCompositor.Network.Connector** connector);
    };

    [activatable(MixedRemoteViewCompositor.Network.IConnectorStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass Connector
    {
        [default] interface MixedRemoteViewCompositor.Network.IConnector;
        interface MixedRemoteViewCompositor.Plugin.IModule;
        interface Windows.Foundation.IClosable;
    };
} }

namespace MixedRemoteViewCompositor{ namespace Media {

    [version(1.0)]
    enum SourceStreamState
    {
        Invalid,
        Opening,
        Starting,
        Started,
        Stopped,
        Shutdown,
        Count
    };

    [version(1.0)]
    enum SinkStreamState
    {
        NotSet = 0,
        Ready,
        Started,
        Stopped,
        Paused,
        Count
    };

    [version(1.0)]
    enum SinkStreamOperation
    {
        SetMediaType = 0,
        Start,
        Restart,
        Pause,
        Stop,
        ProcessSample,
        PlaceMarker,
        Count   // Number of operations
    };


    [version(1.0)]
    enum AudioMixerMode
    {
        Mic = 0,
        Loopback = 1,
        MicAndLoopback = 2
    };

    // FormatChangedEvent
    [uuid(7b2c1549-c998-4d37-a379-e0b51251a52c)]
    [version(1.0)]
    delegate HRESULT FormatChangedEventHandler(
        [in] MixedRemoteViewCompositor.Media.FormatChangedEventArgs* args);

    [exclusiveto(MixedRemoteViewCompositor.Media.FormatChangedEventArgs)]
    [uuid(aa65736c-5842-4510-9490-fa43dc9f37d4)]
    [version(1.0)]
    interface IFormatChangedEventArgs : IInspectable
    {
        [propget] HRESULT Width(
            [out][retval] UINT32* width);
        [propget] HRESULT Height(
            [out][retval] UINT32* height);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass FormatChangedEventArgs
    {
        [default] interface MixedRemoteViewCompositor.Media.IFormatChangedEventArgs;
    };

    // SampleUpdatedEvent
    [uuid(1003b11c-debe-48a6-b1ba-0fd0ea5d06e4)]
    [version(1.0)]
    delegate HRESULT SampleUpdatedEventHandler(
        [in] MixedRemoteViewCompositor.Media.SampleUpdatedEventArgs* args);

    [exclusiveto(MixedRemoteViewCompositor.Media.SampleUpdatedEventArgs)]
    [uuid(c8968fde-7644-497c-b03c-1c11ca626dd3)]
    [version(1.0)]
    interface ISampleUpdatedEventArgs : IInspectable
    {
        [propget] HRESULT Width(
            [out][retval] UINT32* width);
        [propget] HRESULT Height(
            [out][retval] UINT32* height);
        [propget] HRESULT Timestamp(
            [out][retval] UINT64* timestamp);
        [propget] HRESULT Transforms(
            [out][retval] MixedRemoteViewCompositor.MediaSampleTransforms* transform);
        [propget] HRESULT VideoTexture(
            [out][retval] IInspectable** ppvTexture);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass SampleUpdatedEventArgs
    {
        [default] interface MixedRemoteViewCompositor.Media.ISampleUpdatedEventArgs;
    };

    // MrvcSchemeHandler
    [exclusiveto(MixedRemoteViewCompositor.Media.MrvcSchemeHandler)]
    [uuid(5a4a9427-1f66-40c6-ad6a-b3df73370112)]
    [version(1.0)]
    interface IMrvcSchemeHandler : IInspectable requires
        Windows.Media.IMediaExtension
    {
        [propget] HRESULT Connection(
            [out][retval] MixedRemoteViewCompositor.Network.Connection** connection);
        [propput] HRESULT Connection(
            [in] MixedRemoteViewCompositor.Network.Connection* connection);
    };

    [activatable(1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass MrvcSchemeHandler
    {
        [default] interface Windows.Media.IMediaExtension;
        interface IMrvcSchemeHandler;
    };

    // INetworkMediaSourceStream
    [uuid(43c188c7-387b-45a9-ae18-547a4a0ef48e)]
    [version(1.0)]
    interface INetworkMediaSourceStream : IInspectable
    {
    };

    // NetworkMediaSource
    [exclusiveto(MixedRemoteViewCompositor.Media.NetworkMediaSource)]
    [uuid(e63951ce-a61e-494b-8010-33847c6da00b)]
    [version(1.0)]
    interface INetworkMediaSource : IInspectable requires
        Windows.Media.IMediaExtension
    {
    };

    [exclusiveto(MixedRemoteViewCompositor.Media.NetworkMediaSource)]
    [uuid(d4238dfb-9849-485b-abca-226d7530aaed)]
    [version(1.0)]
    interface INetworkMediaSourceStatics : IInspectable
    {
        HRESULT Create(
            [in] MixedRemoteViewCompositor.Network.Connection* connection,
            [out][retval] MixedRemoteViewCompositor.Media.NetworkMediaSource** mediaSource);
    };

    [activatable(INetworkMediaSourceStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass NetworkMediaSource
    {
        [default] interface Windows.Media.Core.IMediaSource;
        interface Windows.Media.IMediaExtension;
        interface INetworkMediaSource;
    };

    // PlaybackEngine
    [exclusiveto(MixedRemoteViewCompositor.Media.PlaybackEngine)]
    [uuid(b55bf4f3-2883-4c09-a231-7e75bd59bf9e)]
    [version(1.0)]
    interface IPlaybackEngine : IInspectable requires
        MixedRemoteViewCompositor.Plugin.IModule,
        Windows.Foundation.IClosable
    {
        [eventadd] HRESULT Closed(
            [in] MixedRemoteViewCompositor.Plugin.ClosedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT Closed(
            [in] EventRegistrationToken token);

        [eventadd] HRESULT FormatChanged(
            [in] MixedRemoteViewCompositor.Media.FormatChangedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT FormatChanged(
            [in] EventRegistrationToken token);

        [eventadd] HRESULT SampleUpdated(
            [in] MixedRemoteViewCompositor.Media.SampleUpdatedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT SampleUpdated(
            [in] EventRegistrationToken token);

        HRESULT InitializeAsync(
            [out] Windows.Foundation.IAsyncAction** asyncAction);

        HRESULT StartPlayback();

        HRESULT StopPlayback();
    };

    [exclusiveto(MixedRemoteViewCompositor.Media.PlaybackEngine)]
    [uuid(22708031-4143-44e9-98aa-ca3d9b836f6a)]
    [version(1.0)]
    interface IPlaybackEngineStatics : IInspectable
    {
        HRESULT Create(
            [in] MixedRemoteViewCompositor.Network.Connection* connection,
            [out][retval] MixedRemoteViewCompositor.Media.PlaybackEngine** playbackEngine);
    };

    [marshaling_behavior(agile)]
    [static(MixedRemoteViewCompositor.Media.IPlaybackEngineStatics, 1.0)]
    [threading(both)]
    [version(1.0)]
    runtimeclass PlaybackEngine
    {
        interface Windows.Media.IMediaExtension;
        [default] interface IPlaybackEngine;
    };

    // NetworkMediaSink
    [exclusiveto(MixedRemoteViewCompositor.Media.NetworkMediaSink)]
    [uuid(c9fff32c-31f3-452f-b126-3c5c6da57206)]
    [version(1.0)]
    interface INetworkMediaSink : IInspectable requires
        Windows.Media.IMediaExtension
    {
        [propget] HRESULT SpatialCoordinateSystem(
            [out][retval] Windows.Perception.Spatial.SpatialCoordinateSystem** coordinateSystem);
        [propput] HRESULT SpatialCoordinateSystem(
            [in] Windows.Perception.Spatial.SpatialCoordinateSystem* coordinateSystem);

        [eventadd] HRESULT Closed(
            [in] MixedRemoteViewCompositor.Plugin.ClosedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT Closed(
            [in] EventRegistrationToken token);

        [eventadd] HRESULT FormatChanged(
            [in] MixedRemoteViewCompositor.Media.FormatChangedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT FormatChanged(
            [in] EventRegistrationToken token);

        [eventadd] HRESULT SampleUpdated(
            [in] MixedRemoteViewCompositor.Media.SampleUpdatedEventHandler* eventhandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT SampleUpdated(
            [in] EventRegistrationToken token);

        HRESULT OnEndOfStream(
            [in] DWORD streamId);

        HRESULT HandleError(
            [in] HRESULT hr);

        HRESULT CheckShutdown(void);

        HRESULT SendDescription(void);

        HRESULT SetMediaStreamProperties(
            [in] Windows.Media.Capture.MediaStreamType MediaStreamType,
            [in] Windows.Media.MediaProperties.IMediaEncodingProperties *mediaEncodingProperties);

    };

    [activatable(1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass NetworkMediaSink
    {
        [default] interface Windows.Media.IMediaExtension;
        interface INetworkMediaSink;
    };

    // MrcAudioEffectDefinition
    [exclusiveto(MixedRemoteViewCompositor.Media.MrcAudioEffectDefinition)]
    [uuid(ced68fe5-28d7-4d99-b837-b7b3803e2b23)]
    [version(1.0)]
    interface IMrcAudioEffectDefinition : IInspectable requires
        Windows.Media.Effects.IAudioEffectDefinition
    {
        [propget] HRESULT MixerMode(
            [out, retval] AudioMixerMode* mixerMode);
        [propput] HRESULT MixerMode(
            [in] AudioMixerMode mixerMode);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass MrcAudioEffectDefinition
    {
        [default] interface Windows.Media.Effects.IAudioEffectDefinition;
        interface MixedRemoteViewCompositor.Media.IMrcAudioEffectDefinition;
    };

    // MrcVideoEffectDefinition
    [exclusiveto(MixedRemoteViewCompositor.Media.MrcVideoEffectDefinition)]
    [uuid(8d37f003-fbf7-4b94-8530-be34e26c943a)]
    [version(1.0)]
    interface IMrcVideoEffectDefinition : IInspectable requires
        Windows.Media.Effects.IVideoEffectDefinition
    {
        [propget] HRESULT StreamType(
            [out, retval] Windows.Media.Capture.MediaStreamType* value);
        [propput] HRESULT StreamType(
            [in] Windows.Media.Capture.MediaStreamType value);
        [propget] HRESULT HologramComposition(
            [out, retval] boolean* value);
        [propput] HRESULT HologramComposition(
            [in] boolean value);
        [propget] HRESULT VideoStabilization(
            [out, retval] boolean* value);
        [propput] HRESULT VideoStabilization(
            [in] boolean value);
        [propget] HRESULT VideoStabilizationBufferLength(
            [out, retval] UINT32* value);
        [propput] HRESULT VideoStabilizationBufferLength(
            [in] UINT32 value);
        [propget] HRESULT VideoStabilizationMaximumBufferLength(
            [out, retval] UINT32* value);
        [propput] HRESULT GlobalOpacityCoefficient(
            [in] float value);
        [propget] HRESULT GlobalOpacityCoefficient(
            [out, retval] float* value);
        [propput] HRESULT RecordingIndicatorEnabled(
            [in] boolean value);
        [propget] HRESULT RecordingIndicatorEnabled(
            [out, retval] boolean* value);
    };

    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass MrcVideoEffectDefinition
    {
        [default] interface Windows.Media.Effects.IVideoEffectDefinition;
        interface MixedRemoteViewCompositor.Media.IMrcVideoEffectDefinition;
    };

    // CaptureEngine
    [exclusiveto(MixedRemoteViewCompositor.Media.CaptureEngine)]
    [uuid(5e9858a9-5ef5-4b84-9645-eb3c11610a17)]
    [version(1.0)]
    interface ICaptureEngine : IInspectable requires
        MixedRemoteViewCompositor.Plugin.IModule,
        Windows.Foundation.IClosable
    {
        [eventadd] HRESULT Closed(
            [in] MixedRemoteViewCompositor.Plugin.ClosedEventHandler* eventHandler,
            [out][retval] EventRegistrationToken* token);
        [eventremove] HRESULT Closed(
            [in] EventRegistrationToken token);

        [propget] HRESULT SpatialCoordinateSystem(
            [out][retval] Windows.Perception.Spatial.SpatialCoordinateSystem** coordinateSystem);
        [propput] HRESULT SpatialCoordinateSystem(
            [in] Windows.Perception.Spatial.SpatialCoordinateSystem* coordinateSystem);

        HRESULT InitAsync(
            [in] boolean enableAudio,
            [out][retval] Windows.Foundation.IAsyncAction** action);

        HRESULT StartAsync(
            [in] boolean enableMrc,
            [in] MixedRemoteViewCompositor.Network.Connection* connection,
            [out][retval] Windows.Foundation.IAsyncAction** action);

        HRESULT StopAsync(
            [out][retval] Windows.Foundation.IAsyncAction** action);
    };

    [exclusiveto(MixedRemoteViewCompositor.Media.CaptureEngine)]
    [uuid(da706722-7bf4-4527-ad4c-2222cb81a7ab)]
    [version(1.0)]
    interface ICaptureEngineStatics : IInspectable
    {
        HRESULT CreateAsync(
            [in] boolean enableAudio,
            [out][retval] Windows.Foundation.IAsyncOperation<MixedRemoteViewCompositor.Media.CaptureEngine>** createAsynOp);
    };

    //[activatable(MixedRemoteViewCompositor.Media.ICaptureEngineStatics, 1.0)]
    //[activatable(1.0)]
    [static(MixedRemoteViewCompositor.Media.ICaptureEngineStatics, 1.0)]
    [marshaling_behavior(agile)]
    [threading(both)]
    [version(1.0)]
    runtimeclass CaptureEngine
    {
        [default] interface MixedRemoteViewCompositor.Media.ICaptureEngine;
        interface MixedRemoteViewCompositor.Plugin.IModule;
    };

} }