| 1 | /** | 
 
 
 
 
 | 2 | * This file has no copyright assigned and is placed in the Public Domain. | 
 
 
 
 
 | 3 | * This file is part of the mingw-w64 runtime package. | 
 
 
 
 
 | 4 | * No warranty is given; refer to the file DISCLAIMER.PD within this package. | 
 
 
 
 
 | 5 | */ | 
 
 
 
 
 | 6 |  | 
 
 
 
 
 | 7 | import "mfobjects.idl"; | 
 
 
 
 
 | 8 |  | 
 
 
 
 
 | 9 | cpp_quote("#include <mftransform.h>") // FIXME: import "mftransform.idl"; | 
 
 
 
 
 | 10 |  | 
 
 
 
 
 | 11 | cpp_quote("#include <windef.h>") | 
 
 
 
 
 | 12 |  | 
 
 
 
 
 | 13 | typedef enum MFSESSION_SETTOPOLOGY_FLAGS { | 
 
 
 
 
 | 14 | MFSESSION_SETTOPOLOGY_IMMEDIATE     = 0x1, | 
 
 
 
 
 | 15 | MFSESSION_SETTOPOLOGY_NORESOLUTION  = 0x2, | 
 
 
 
 
 | 16 | MFSESSION_SETTOPOLOGY_CLEAR_CURRENT = 0x4 | 
 
 
 
 
 | 17 | } MFSESSION_SETTOPOLOGY_FLAGS; | 
 
 
 
 
 | 18 |  | 
 
 
 
 
 | 19 | typedef enum MFSESSION_GETFULLTOPOLOGY_FLAGS { | 
 
 
 
 
 | 20 | MFSESSION_GETFULLTOPOLOGY_CURRENT | 
 
 
 
 
 | 21 | } MFSESSION_GETFULLTOPOLOGY_FLAGS; | 
 
 
 
 
 | 22 |  | 
 
 
 
 
 | 23 | typedef enum MFPMPSESSION_CREATION_FLAGS { | 
 
 
 
 
 | 24 | MFPMPSESSION_UNPROTECTED_PROCESS = 0x1 | 
 
 
 
 
 | 25 | } MFPMPSESSION_CREATION_FLAGS; | 
 
 
 
 
 | 26 |  | 
 
 
 
 
 | 27 | typedef unsigned __int64 TOPOID; | 
 
 
 
 
 | 28 |  | 
 
 
 
 
 | 29 | typedef enum MF_TOPOLOGY_TYPE { | 
 
 
 
 
 | 30 | MF_TOPOLOGY_OUTPUT_NODE, | 
 
 
 
 
 | 31 | MF_TOPOLOGY_SOURCESTREAM_NODE, | 
 
 
 
 
 | 32 | MF_TOPOLOGY_TRANSFORM_NODE, | 
 
 
 
 
 | 33 | MF_TOPOLOGY_TEE_NODE, | 
 
 
 
 
 | 34 | MF_TOPOLOGY_MAX = 0xffffffff | 
 
 
 
 
 | 35 | } MF_TOPOLOGY_TYPE; | 
 
 
 
 
 | 36 |  | 
 
 
 
 
 | 37 | [ | 
 
 
 
 
 | 38 | object, | 
 
 
 
 
 | 39 | uuid(83cf873a-f6da-4bc8-823f-bacfd55dc430), | 
 
 
 
 
 | 40 | ] | 
 
 
 
 
 | 41 | interface IMFTopologyNode : IMFAttributes | 
 
 
 
 
 | 42 | { | 
 
 
 
 
 | 43 | HRESULT SetObject([in] IUnknown *pObject); | 
 
 
 
 
 | 44 | HRESULT GetObject([out] IUnknown **ppObject); | 
 
 
 
 
 | 45 | HRESULT GetNodeType([out] MF_TOPOLOGY_TYPE *pType); | 
 
 
 
 
 | 46 | HRESULT GetTopoNodeID([out] TOPOID *pID); | 
 
 
 
 
 | 47 | HRESULT SetTopoNodeID([in] TOPOID ullTopoID); | 
 
 
 
 
 | 48 | HRESULT GetInputCount([out] DWORD *pcInputs); | 
 
 
 
 
 | 49 | HRESULT GetOutputCount([out] DWORD *pcOutputs); | 
 
 
 
 
 | 50 |  | 
 
 
 
 
 | 51 | [local] | 
 
 
 
 
 | 52 | HRESULT ConnectOutput([in] DWORD dwOutputIndex, [in] IMFTopologyNode* pDownstreamNode, | 
 
 
 
 
 | 53 | [in] DWORD dwInputIndexOnDownstreamNode); | 
 
 
 
 
 | 54 | [local] HRESULT DisconnectOutput([in] DWORD dwOutputIndex); | 
 
 
 
 
 | 55 | HRESULT GetInput([in] DWORD dwInputIndex, [out] IMFTopologyNode** ppUpstreamNode, | 
 
 
 
 
 | 56 | [out] DWORD *pdwOutputIndexOnUpstreamNode); | 
 
 
 
 
 | 57 | HRESULT GetOutput([in] DWORD dwOutputIndex, [out] IMFTopologyNode** ppDownstreamNode, | 
 
 
 
 
 | 58 | [out] DWORD* pdwInputIndexOnDownstreamNode); | 
 
 
 
 
 | 59 | [local] HRESULT SetOutputPrefType([in] DWORD dwOutputIndex, [in] IMFMediaType *pType); | 
 
 
 
 
 | 60 |  | 
 
 
 
 
 | 61 | [local] HRESULT GetOutputPrefType([in] DWORD dwOutputIndex, [out] IMFMediaType **ppType); | 
 
 
 
 
 | 62 | [call_as(GetOutputPrefType)] HRESULT RemoteGetOutputPrefType([in] DWORD dwOutputIndex, | 
 
 
 
 
 | 63 | [out] DWORD *pcbData, [out, size_is(,*pcbData)] BYTE **ppbData); | 
 
 
 
 
 | 64 |  | 
 
 
 
 
 | 65 | [local] HRESULT SetInputPrefType([in] DWORD dwInputIndex, [in] IMFMediaType *pType); | 
 
 
 
 
 | 66 |  | 
 
 
 
 
 | 67 | [local] HRESULT GetInputPrefType([in] DWORD dwInputIndex, [out] IMFMediaType **ppType); | 
 
 
 
 
 | 68 | [call_as(GetInputPrefType)] HRESULT RemoteGetInputPrefType( [in] DWORD dwInputIndex, | 
 
 
 
 
 | 69 | [out] DWORD *pcbData, [out, size_is(,*pcbData)] BYTE **ppbData); | 
 
 
 
 
 | 70 |  | 
 
 
 
 
 | 71 | HRESULT CloneFrom([in] IMFTopologyNode *pNode); | 
 
 
 
 
 | 72 | } | 
 
 
 
 
 | 73 |  | 
 
 
 
 
 | 74 | [ | 
 
 
 
 
 | 75 | object, | 
 
 
 
 
 | 76 | uuid(83cf873a-f6da-4bc8-823f-bacfd55dc433), | 
 
 
 
 
 | 77 | ] | 
 
 
 
 
 | 78 | interface IMFTopology : IMFAttributes | 
 
 
 
 
 | 79 | { | 
 
 
 
 
 | 80 | HRESULT GetTopologyID([out] TOPOID *pID); | 
 
 
 
 
 | 81 | [local] HRESULT AddNode([in] IMFTopologyNode *pNode); | 
 
 
 
 
 | 82 | [local] HRESULT RemoveNode([in] IMFTopologyNode *pNode); | 
 
 
 
 
 | 83 | HRESULT GetNodeCount([out] WORD *pwNodes); | 
 
 
 
 
 | 84 | HRESULT GetNode([in] WORD wIndex, [out] IMFTopologyNode **ppNode); | 
 
 
 
 
 | 85 | [local] HRESULT Clear(); | 
 
 
 
 
 | 86 | HRESULT CloneFrom([in] IMFTopology *pTopology); | 
 
 
 
 
 | 87 | HRESULT GetNodeByID([in] TOPOID qwTopoNodeID, [out] IMFTopologyNode **ppNode); | 
 
 
 
 
 | 88 | HRESULT GetSourceNodeCollection([out] IMFCollection **ppCollection); | 
 
 
 
 
 | 89 | HRESULT GetOutputNodeCollection([out] IMFCollection **ppCollection); | 
 
 
 
 
 | 90 | } | 
 
 
 
 
 | 91 |  | 
 
 
 
 
 | 92 | [ | 
 
 
 
 
 | 93 | object, | 
 
 
 
 
 | 94 | uuid(fa993888-4383-415a-a930-dd472a8cf6f7) | 
 
 
 
 
 | 95 | ] | 
 
 
 
 
 | 96 | interface IMFGetService : IUnknown | 
 
 
 
 
 | 97 | { | 
 
 
 
 
 | 98 | HRESULT GetService([in] REFGUID guidService, [in] REFIID riid, [out, iid_is(riid)] LPVOID *ppvObject); | 
 
 
 
 
 | 99 | } | 
 
 
 
 
 | 100 |  | 
 
 
 
 
 | 101 | typedef LONGLONG MFTIME; | 
 
 
 
 
 | 102 |  | 
 
 
 
 
 | 103 | typedef enum _MF_CLOCK_STATE { | 
 
 
 
 
 | 104 | MFCLOCK_STATE_INVALID, | 
 
 
 
 
 | 105 | MFCLOCK_STATE_RUNNING, | 
 
 
 
 
 | 106 | MFCLOCK_STATE_STOPPED, | 
 
 
 
 
 | 107 | MFCLOCK_STATE_PAUSED | 
 
 
 
 
 | 108 | } MF_CLOCK_STATE, MFCLOCK_STATE; | 
 
 
 
 
 | 109 |  | 
 
 
 
 
 | 110 | typedef struct _MFCLOCK_PROPERTIES { | 
 
 
 
 
 | 111 | unsigned __int64 qwCorrelationRate; | 
 
 
 
 
 | 112 | GUID             guidClockId; | 
 
 
 
 
 | 113 | DWORD            dwClockFlags; | 
 
 
 
 
 | 114 | unsigned __int64 qwClockFrequency; | 
 
 
 
 
 | 115 | DWORD            dwClockTolerance; | 
 
 
 
 
 | 116 | DWORD            dwClockJitter; | 
 
 
 
 
 | 117 | } MFCLOCK_PROPERTIES; | 
 
 
 
 
 | 118 |  | 
 
 
 
 
 | 119 | [ | 
 
 
 
 
 | 120 | object, | 
 
 
 
 
 | 121 | uuid(2eb1e945-18b8-4139-9b1a-d5d584818530), | 
 
 
 
 
 | 122 | ] | 
 
 
 
 
 | 123 | interface IMFClock : IUnknown | 
 
 
 
 
 | 124 | { | 
 
 
 
 
 | 125 | HRESULT GetClockCharacteristics([out] DWORD *pdwCharacteristics); | 
 
 
 
 
 | 126 | HRESULT GetCorrelatedTime([in] DWORD dwReserved, [out] LONGLONG *pllClockTime, [out] MFTIME *phnsSystemTime); | 
 
 
 
 
 | 127 | HRESULT GetContinuityKey([out] DWORD *pdwContinuityKey); | 
 
 
 
 
 | 128 | HRESULT GetState([in] DWORD dwReserved, [out] MFCLOCK_STATE *peClockState); | 
 
 
 
 
 | 129 | HRESULT GetProperties([out] MFCLOCK_PROPERTIES *pClockProperties); | 
 
 
 
 
 | 130 | } | 
 
 
 
 
 | 131 |  | 
 
 
 
 
 | 132 | cpp_quote("#define SHA_HASH_LEN 20") | 
 
 
 
 
 | 133 | cpp_quote("#define STR_HASH_LEN (SHA_HASH_LEN*2+3)") | 
 
 
 
 
 | 134 |  | 
 
 
 
 
 | 135 | cpp_quote("typedef struct _MFRR_COMPONENT_HASH_INFO {") | 
 
 
 
 
 | 136 | cpp_quote("  DWORD ulReason;") | 
 
 
 
 
 | 137 | cpp_quote("  WCHAR rgHeaderHash[STR_HASH_LEN];") | 
 
 
 
 
 | 138 | cpp_quote("  WCHAR rgPublicKeyHash[STR_HASH_LEN];") | 
 
 
 
 
 | 139 | cpp_quote("  WCHAR wszName[MAX_PATH];") | 
 
 
 
 
 | 140 | cpp_quote("} MFRR_COMPONENT_HASH_INFO, *PMFRR_COMPONENT_HASH_INFO;") | 
 
 
 
 
 | 141 |  | 
 
 
 
 
 | 142 | cpp_quote("EXTERN_GUID(MF_PD_DURATION, 0x6c990d33,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a);") | 
 
 
 
 
 | 143 |  | 
 
 
 
 
 | 144 | typedef enum _MF_CONNECT_METHOD { | 
 
 
 
 
 | 145 | MF_CONNECT_DIRECT                            = 0x00000000, | 
 
 
 
 
 | 146 | MF_CONNECT_ALLOW_CONVERTER                   = 0x00000001, | 
 
 
 
 
 | 147 | MF_CONNECT_ALLOW_DECODER                     = 0x00000003, | 
 
 
 
 
 | 148 | MF_CONNECT_RESOLVE_INDEPENDENT_OUTPUTTYPES   = 0x00000004, | 
 
 
 
 
 | 149 | MF_CONNECT_AS_OPTIONAL                       = 0x00010000, | 
 
 
 
 
 | 150 | MF_CONNECT_AS_OPTIONAL_BRANCH                = 0x00020000 | 
 
 
 
 
 | 151 | } MF_CONNECT_METHOD; | 
 
 
 
 
 | 152 |  | 
 
 
 
 
 | 153 | [ | 
 
 
 
 
 | 154 | object, | 
 
 
 
 
 | 155 | uuid(90377834-21d0-4dee-8214-ba2e3e6c1127), | 
 
 
 
 
 | 156 | ] | 
 
 
 
 
 | 157 | interface IMFMediaSession : IMFMediaEventGenerator | 
 
 
 
 
 | 158 | { | 
 
 
 
 
 | 159 | HRESULT SetTopology([in] DWORD dwSetTopologyFlags, [in] IMFTopology *pTopology); | 
 
 
 
 
 | 160 | HRESULT ClearTopologies(); | 
 
 
 
 
 | 161 | HRESULT Start([in, unique] const GUID *pguidTimeFormat, [in, unique] const PROPVARIANT *pvarStartPosition); | 
 
 
 
 
 | 162 | HRESULT Pause(); | 
 
 
 
 
 | 163 | HRESULT Stop(); | 
 
 
 
 
 | 164 | HRESULT Close(); | 
 
 
 
 
 | 165 | HRESULT Shutdown(); | 
 
 
 
 
 | 166 | HRESULT GetClock([out] IMFClock **ppClock); | 
 
 
 
 
 | 167 | HRESULT GetSessionCapabilities([out] DWORD *pdwCaps); | 
 
 
 
 
 | 168 | HRESULT GetFullTopology([in] DWORD dwGetFullTopologyFlags, [in] TOPOID TopoId, [out] IMFTopology **ppFullTopology); | 
 
 
 
 
 | 169 | } | 
 
 
 
 
 | 170 |  | 
 
 
 
 
 | 171 | [ | 
 
 
 
 
 | 172 | object, | 
 
 
 
 
 | 173 | uuid(e93dcf6c-4b07-4e1e-8123-aa16ed6eadf5), | 
 
 
 
 
 | 174 | ] | 
 
 
 
 
 | 175 | interface IMFMediaTypeHandler : IUnknown | 
 
 
 
 
 | 176 | { | 
 
 
 
 
 | 177 | [local] HRESULT IsMediaTypeSupported([in] IMFMediaType *pMediaType, [out] IMFMediaType **ppMediaType); | 
 
 
 
 
 | 178 | [local] HRESULT GetMediaTypeCount([out] DWORD *pdwTypeCount); | 
 
 
 
 
 | 179 | [local] HRESULT GetMediaTypeByIndex([in] DWORD dwIndex, [out] IMFMediaType **ppType); | 
 
 
 
 
 | 180 | [local] HRESULT SetCurrentMediaType([in] IMFMediaType *pMediaType); | 
 
 
 
 
 | 181 |  | 
 
 
 
 
 | 182 | [local] | 
 
 
 
 
 | 183 | HRESULT GetCurrentMediaType([out] IMFMediaType **ppMediaType); | 
 
 
 
 
 | 184 | [call_as(GetCurrentMediaType)] | 
 
 
 
 
 | 185 | HRESULT RemoteGetCurrentMediaType([out, size_is(,*pcbData)] BYTE **ppbData, [out] DWORD *pcbData); | 
 
 
 
 
 | 186 |  | 
 
 
 
 
 | 187 | HRESULT GetMajorType([out] GUID *pguidMajorType); | 
 
 
 
 
 | 188 | } | 
 
 
 
 
 | 189 |  | 
 
 
 
 
 | 190 | [ | 
 
 
 
 
 | 191 | object, | 
 
 
 
 
 | 192 | uuid(56c03d9c-9dbb-45f5-ab4b-d80f47c05938), | 
 
 
 
 
 | 193 | ] | 
 
 
 
 
 | 194 | interface IMFStreamDescriptor : IMFAttributes | 
 
 
 
 
 | 195 | { | 
 
 
 
 
 | 196 | HRESULT GetStreamIdentifier([out] DWORD *pdwStreamIdentifier); | 
 
 
 
 
 | 197 | HRESULT GetMediaTypeHandler([out] IMFMediaTypeHandler **ppMediaTypeHandler); | 
 
 
 
 
 | 198 | } | 
 
 
 
 
 | 199 |  | 
 
 
 
 
 | 200 | [ | 
 
 
 
 
 | 201 | object, | 
 
 
 
 
 | 202 | uuid(03cb2711-24d7-4db6-a17f-f3a7a479a536), | 
 
 
 
 
 | 203 | ] | 
 
 
 
 
 | 204 | interface IMFPresentationDescriptor : IMFAttributes | 
 
 
 
 
 | 205 | { | 
 
 
 
 
 | 206 | HRESULT GetStreamDescriptorCount([out] DWORD *pdwDescriptorCount); | 
 
 
 
 
 | 207 | HRESULT GetStreamDescriptorByIndex([in] DWORD dwIndex, [out] BOOL *pfSelected, [out] IMFStreamDescriptor **ppDescriptor); | 
 
 
 
 
 | 208 | HRESULT SelectStream([in] DWORD dwDescriptorIndex); | 
 
 
 
 
 | 209 | HRESULT DeselectStream([in] DWORD dwDescriptorIndex); | 
 
 
 
 
 | 210 | HRESULT Clone([out] IMFPresentationDescriptor **ppPresentationDescriptor); | 
 
 
 
 
 | 211 | } | 
 
 
 
 
 | 212 |  | 
 
 
 
 
 | 213 | [ | 
 
 
 
 
 | 214 | object, | 
 
 
 
 
 | 215 | uuid(279a808d-aec7-40c8-9c6b-a6b492c78a66), | 
 
 
 
 
 | 216 | ] | 
 
 
 
 
 | 217 | interface IMFMediaSource : IMFMediaEventGenerator | 
 
 
 
 
 | 218 | { | 
 
 
 
 
 | 219 | HRESULT GetCharacteristics([out] DWORD *pdwCharacteristics); | 
 
 
 
 
 | 220 |  | 
 
 
 
 
 | 221 | [local] | 
 
 
 
 
 | 222 | HRESULT CreatePresentationDescriptor([out] IMFPresentationDescriptor **ppPresentationDescriptor); | 
 
 
 
 
 | 223 | [call_as(CreatePresentationDescriptor)] | 
 
 
 
 
 | 224 | HRESULT RemoteCreatePresentationDescriptor( | 
 
 
 
 
 | 225 | [out] DWORD *pcbPD, | 
 
 
 
 
 | 226 | [out, size_is(,*pcbPD)] BYTE **pbPD, | 
 
 
 
 
 | 227 | [out] IMFPresentationDescriptor **ppRemotePD); | 
 
 
 
 
 | 228 |  | 
 
 
 
 
 | 229 | HRESULT Start( | 
 
 
 
 
 | 230 | [in] IMFPresentationDescriptor *pPresentationDescriptor, | 
 
 
 
 
 | 231 | [in, unique] const GUID *pguidTimeFormat, | 
 
 
 
 
 | 232 | [in, unique] const PROPVARIANT *pvarStartPosition); | 
 
 
 
 
 | 233 |  | 
 
 
 
 
 | 234 | HRESULT Stop(); | 
 
 
 
 
 | 235 | HRESULT Pause(); | 
 
 
 
 
 | 236 | HRESULT Shutdown(); | 
 
 
 
 
 | 237 | } | 
 
 
 
 
 | 238 |  | 
 
 
 
 
 | 239 | typedef [public] struct _MF_LEAKY_BUCKET_PAIR { | 
 
 
 
 
 | 240 | DWORD dwBitrate; | 
 
 
 
 
 | 241 | DWORD msBufferWindow; | 
 
 
 
 
 | 242 | } MF_LEAKY_BUCKET_PAIR; | 
 
 
 
 
 | 243 |  | 
 
 
 
 
 | 244 | typedef [public] struct _MFBYTESTREAM_BUFFERING_PARAMS { | 
 
 
 
 
 | 245 | QWORD                cbTotalFileSize; | 
 
 
 
 
 | 246 | QWORD                cbPlayableDataSize; | 
 
 
 
 
 | 247 | MF_LEAKY_BUCKET_PAIR *prgBuckets; | 
 
 
 
 
 | 248 | DWORD                cBuckets; | 
 
 
 
 
 | 249 | QWORD                qwNetBufferingTime; | 
 
 
 
 
 | 250 | QWORD                qwExtraBufferingTimeDuringSeek; | 
 
 
 
 
 | 251 | QWORD                qwPlayDuration; | 
 
 
 
 
 | 252 | float                dRate; | 
 
 
 
 
 | 253 | } MFBYTESTREAM_BUFFERING_PARAMS; | 
 
 
 
 
 | 254 |  | 
 
 
 
 
 | 255 | [ | 
 
 
 
 
 | 256 | object, | 
 
 
 
 
 | 257 | uuid(6d66d782-1d4f-4db7-8c63-cb8c77f1ef5e), | 
 
 
 
 
 | 258 | local | 
 
 
 
 
 | 259 | ] | 
 
 
 
 
 | 260 | interface IMFByteStreamBuffering : IUnknown | 
 
 
 
 
 | 261 | { | 
 
 
 
 
 | 262 | HRESULT SetBufferingParams([in] MFBYTESTREAM_BUFFERING_PARAMS *pParams); | 
 
 
 
 
 | 263 | HRESULT EnableBuffering([in] BOOL fEnable); | 
 
 
 
 
 | 264 | HRESULT StopBuffering(); | 
 
 
 
 
 | 265 | } | 
 
 
 
 
 | 266 |  | 
 
 
 
 
 | 267 | [ | 
 
 
 
 
 | 268 | object, | 
 
 
 
 
 | 269 | uuid(F6696E82-74F7-4f3d-A178-8A5E09C3659F), | 
 
 
 
 
 | 270 | ] | 
 
 
 
 
 | 271 | interface IMFClockStateSink : IUnknown | 
 
 
 
 
 | 272 | { | 
 
 
 
 
 | 273 | HRESULT OnClockStart([in] MFTIME hnsSystemTime,[in] LONGLONG llClockStartOffset); | 
 
 
 
 
 | 274 | HRESULT OnClockStop([in] MFTIME hnsSystemTime); | 
 
 
 
 
 | 275 | HRESULT OnClockPause([in] MFTIME hnsSystemTime); | 
 
 
 
 
 | 276 | HRESULT OnClockRestart([in] MFTIME hnsSystemTime); | 
 
 
 
 
 | 277 | HRESULT OnClockSetRate([in] MFTIME hnsSystemTime, [in] float flRate); | 
 
 
 
 
 | 278 | } | 
 
 
 
 
 | 279 |  | 
 
 
 
 
 | 280 | cpp_quote("HRESULT WINAPI MFRequireProtectedEnvironment(IMFPresentationDescriptor *pPresentationDescriptor);") | 
 
 
 
 
 | 281 | cpp_quote("HRESULT WINAPI MFSerializePresentationDescriptor(IMFPresentationDescriptor *pPD,DWORD *pcbData,BYTE **ppbData);") | 
 
 
 
 
 | 282 |  | 
 
 
 
 
 | 283 | typedef DWORD MFSequencerElementId; | 
 
 
 
 
 | 284 |  | 
 
 
 
 
 | 285 | typedef enum _MFCLOCK_CHARACTERISTICS_FLAGS | 
 
 
 
 
 | 286 | { | 
 
 
 
 
 | 287 | MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ   = 0x2, | 
 
 
 
 
 | 288 | MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING    = 0x4, | 
 
 
 
 
 | 289 | MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK   = 0x8 | 
 
 
 
 
 | 290 | } MFCLOCK_CHARACTERISTICS_FLAGS; | 
 
 
 
 
 | 291 |  | 
 
 
 
 
 | 292 | cpp_quote("#if (WINVER >= 0x0601)") | 
 
 
 
 
 | 293 |  | 
 
 
 
 
 | 294 | typedef enum _MF_QUALITY_ADVISE_FLAGS | 
 
 
 
 
 | 295 | { | 
 
 
 
 
 | 296 | MF_QUALITY_CANNOT_KEEP_UP = 0x1 | 
 
 
 
 
 | 297 | } MF_QUALITY_ADVISE_FLAGS; | 
 
 
 
 
 | 298 |  | 
 
 
 
 
 | 299 | cpp_quote("#endif /*(WINVER >= 0x0601)*/") | 
 
 
 
 
 | 300 |  | 
 
 
 
 
 | 301 | typedef enum _MF_QUALITY_DROP_MODE | 
 
 
 
 
 | 302 | { | 
 
 
 
 
 | 303 | MF_DROP_MODE_NONE = 0x0, | 
 
 
 
 
 | 304 | MF_DROP_MODE_1    = 0x1, | 
 
 
 
 
 | 305 | MF_DROP_MODE_2    = 0x2, | 
 
 
 
 
 | 306 | MF_DROP_MODE_3    = 0x3, | 
 
 
 
 
 | 307 | MF_DROP_MODE_4    = 0x4, | 
 
 
 
 
 | 308 | MF_DROP_MODE_5    = 0x5, | 
 
 
 
 
 | 309 | MF_NUM_DROP_MODES = 0x6 | 
 
 
 
 
 | 310 | } MF_QUALITY_DROP_MODE; | 
 
 
 
 
 | 311 |  | 
 
 
 
 
 | 312 | typedef enum _MF_QUALITY_LEVEL | 
 
 
 
 
 | 313 | { | 
 
 
 
 
 | 314 | MF_QUALITY_NORMAL         = 0x0, | 
 
 
 
 
 | 315 | MF_QUALITY_NORMAL_MINUS_1 = 0x1, | 
 
 
 
 
 | 316 | MF_QUALITY_NORMAL_MINUS_2 = 0x2, | 
 
 
 
 
 | 317 | MF_QUALITY_NORMAL_MINUS_3 = 0x3, | 
 
 
 
 
 | 318 | MF_QUALITY_NORMAL_MINUS_4 = 0x4, | 
 
 
 
 
 | 319 | MF_QUALITY_NORMAL_MINUS_5 = 0x5, | 
 
 
 
 
 | 320 | MF_NUM_QUALITY_LEVELS     = 0x6 | 
 
 
 
 
 | 321 | } MF_QUALITY_LEVEL; | 
 
 
 
 
 | 322 |  | 
 
 
 
 
 | 323 | typedef enum _MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS | 
 
 
 
 
 | 324 | { | 
 
 
 
 
 | 325 | MF_TOPOLOGY_RESOLUTION_SUCCEEDED            = 0x00000000, | 
 
 
 
 
 | 326 | MF_OPTIONAL_NODE_REJECTED_MEDIA_TYPE        = 0x00000001, | 
 
 
 
 
 | 327 | MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS = 0x00000002 | 
 
 
 
 
 | 328 | } MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS; | 
 
 
 
 
 | 329 |  | 
 
 
 
 
 | 330 | typedef enum _MF_TOPONODE_DRAIN_MODE | 
 
 
 
 
 | 331 | { | 
 
 
 
 
 | 332 | MF_TOPONODE_DRAIN_DEFAULT, | 
 
 
 
 
 | 333 | MF_TOPONODE_DRAIN_ALWAYS, | 
 
 
 
 
 | 334 | MF_TOPONODE_DRAIN_NEVER | 
 
 
 
 
 | 335 | } MF_TOPONODE_DRAIN_MODE; | 
 
 
 
 
 | 336 |  | 
 
 
 
 
 | 337 | typedef enum _MF_TOPONODE_FLUSH_MODE | 
 
 
 
 
 | 338 | { | 
 
 
 
 
 | 339 | MF_TOPONODE_FLUSH_ALWAYS, | 
 
 
 
 
 | 340 | MF_TOPONODE_FLUSH_SEEK, | 
 
 
 
 
 | 341 | MF_TOPONODE_FLUSH_NEVER | 
 
 
 
 
 | 342 | } MF_TOPONODE_FLUSH_MODE; | 
 
 
 
 
 | 343 |  | 
 
 
 
 
 | 344 | cpp_quote("#if (WINVER >= 0x0601)") | 
 
 
 
 
 | 345 |  | 
 
 
 
 
 | 346 | typedef enum _MF_TRANSCODE_TOPOLOGY_MODE_FLAGS | 
 
 
 
 
 | 347 | { | 
 
 
 
 
 | 348 | MF_TRANSCODE_TOPOLOGYMODE_SOFTWARE_ONLY    = 0, | 
 
 
 
 
 | 349 | MF_TRANSCODE_TOPOLOGYMODE_HARDWARE_ALLOWED = 1 | 
 
 
 
 
 | 350 | } MF_TRANSCODE_TOPOLOGYMODE_FLAGS; | 
 
 
 
 
 | 351 |  | 
 
 
 
 
 | 352 | cpp_quote("#endif") | 
 
 
 
 
 | 353 |  | 
 
 
 
 
 | 354 | cpp_quote("EXTERN_GUID(MF_TRANSCODE_CONTAINERTYPE, 0x150ff23f, 0x4abc, 0x478b, 0xac, 0x4f, 0xe1, 0x91, 0x6f, 0xba, 0x1c, 0xca);") | 
 
 
 
 
 | 355 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_ASF, 0x430f6f6e, 0xb6bf, 0x4fc1, 0xa0, 0xbd, 0x9e, 0xe4, 0x6e, 0xee, 0x2a, 0xfb);") | 
 
 
 
 
 | 356 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_MPEG4, 0xdc6cd05d, 0xb9d0, 0x40ef, 0xbd, 0x35, 0xfa, 0x62, 0x2c, 0x1a, 0xb2, 0x8a);") | 
 
 
 
 
 | 357 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_MP3, 0xe438b912, 0x83f1, 0x4de6, 0x9e, 0x3a, 0x9f, 0xfb, 0xc6, 0xdd, 0x24, 0xd1);") | 
 
 
 
 
 | 358 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_FLAC, 0x31344aa3, 0x05a9, 0x42b5, 0x90, 0x1b, 0x8e, 0x9d, 0x42, 0x57, 0xf7, 0x5e);") | 
 
 
 
 
 | 359 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_3GP, 0x34c50167, 0x4472, 0x4f34, 0x9e, 0xa0, 0xc4, 0x9f, 0xba, 0xcf, 0x03, 0x7d);") | 
 
 
 
 
 | 360 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_AC3, 0x6d8d91c3, 0x8c91, 0x4ed1, 0x87, 0x42, 0x8c, 0x34, 0x7d, 0x5b, 0x44, 0xd0);") | 
 
 
 
 
 | 361 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_ADTS, 0x132fd27d, 0x0f02, 0x43de, 0xa3, 0x01, 0x38, 0xfb, 0xbb, 0xb3, 0x83, 0x4e);") | 
 
 
 
 
 | 362 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_MPEG2, 0xbfc2dbf9, 0x7bb4, 0x4f8f, 0xaf, 0xde, 0xe1, 0x12, 0xc4, 0x4b, 0xa8, 0x82);") | 
 
 
 
 
 | 363 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_WAVE, 0x64c3453c, 0x0f26, 0x4741, 0xbe, 0x63, 0x87, 0xbd, 0xf8, 0xbb, 0x93, 0x5b);") | 
 
 
 
 
 | 364 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_AVI, 0x7edfe8af, 0x402f, 0x4d76, 0xa3, 0x3c, 0x61, 0x9f, 0xd1, 0x57, 0xd0, 0xf1);") | 
 
 
 
 
 | 365 | cpp_quote("#if (WINVER >= _WIN32_WINNT_WIN8)") | 
 
 
 
 
 | 366 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_FMPEG4, 0x9ba876f1, 0x419f, 0x4b77, 0xa1, 0xe0, 0x35, 0x95, 0x9d, 0x9d, 0x40, 0x4);") | 
 
 
 
 
 | 367 | cpp_quote("#endif // (WINVER >= _WIN32_WINNT_WIN8)") | 
 
 
 
 
 | 368 | cpp_quote("EXTERN_GUID(MFTranscodeContainerType_AMR, 0x25d5ad3, 0x621a, 0x475b, 0x96, 0x4d, 0x66, 0xb1, 0xc8, 0x24, 0xf0, 0x79);") | 
 
 
 
 
 | 369 |  | 
 
 
 
 
 | 370 | typedef enum | 
 
 
 
 
 | 371 | { | 
 
 
 
 
 | 372 | MF_LICENSE_URL_UNTRUSTED, | 
 
 
 
 
 | 373 | MF_LICENSE_URL_TRUSTED, | 
 
 
 
 
 | 374 | MF_LICENSE_URL_TAMPERED | 
 
 
 
 
 | 375 | } MF_URL_TRUST_STATUS; | 
 
 
 
 
 | 376 |  | 
 
 
 
 
 | 377 | typedef enum _MFCLOCK_RELATIONAL_FLAGS | 
 
 
 
 
 | 378 | { | 
 
 
 
 
 | 379 | MFCLOCK_RELATIONAL_FLAG_JITTER_NEVER_AHEAD = 0x1 | 
 
 
 
 
 | 380 | } MFCLOCK_RELATIONAL_FLAGS; | 
 
 
 
 
 | 381 |  | 
 
 
 
 
 | 382 | typedef enum _MFMEDIASOURCE_CHARACTERISTICS | 
 
 
 
 
 | 383 | { | 
 
 
 
 
 | 384 | MFMEDIASOURCE_IS_LIVE                    = 0x1, | 
 
 
 
 
 | 385 | MFMEDIASOURCE_CAN_SEEK                   = 0x2, | 
 
 
 
 
 | 386 | MFMEDIASOURCE_CAN_PAUSE                  = 0x4, | 
 
 
 
 
 | 387 | MFMEDIASOURCE_HAS_SLOW_SEEK              = 0x8, | 
 
 
 
 
 | 388 | MFMEDIASOURCE_HAS_MULTIPLE_PRESENTATIONS = 0x10, | 
 
 
 
 
 | 389 | MFMEDIASOURCE_CAN_SKIPFORWARD            = 0x20, | 
 
 
 
 
 | 390 | MFMEDIASOURCE_CAN_SKIPBACKWARD           = 0x40 | 
 
 
 
 
 | 391 | } MFMEDIASOURCE_CHARACTERISTICS; | 
 
 
 
 
 | 392 |  | 
 
 
 
 
 | 393 | typedef enum _MFNET_PROXYSETTINGS | 
 
 
 
 
 | 394 | { | 
 
 
 
 
 | 395 | MFNET_PROXYSETTING_NONE    = 0, | 
 
 
 
 
 | 396 | MFNET_PROXYSETTING_MANUAL  = 1, | 
 
 
 
 
 | 397 | MFNET_PROXYSETTING_AUTO    = 2, | 
 
 
 
 
 | 398 | MFNET_PROXYSETTING_BROWSER = 3 | 
 
 
 
 
 | 399 | } MFNET_PROXYSETTINGS; | 
 
 
 
 
 | 400 |  | 
 
 
 
 
 | 401 | typedef enum _MFNetAuthenticationFlags | 
 
 
 
 
 | 402 | { | 
 
 
 
 
 | 403 | MFNET_AUTHENTICATION_PROXY          = 0x00000001, | 
 
 
 
 
 | 404 | MFNET_AUTHENTICATION_CLEAR_TEXT     = 0x00000002, | 
 
 
 
 
 | 405 | MFNET_AUTHENTICATION_LOGGED_ON_USER = 0x00000004 | 
 
 
 
 
 | 406 | } MFNetAuthenticationFlags; | 
 
 
 
 
 | 407 |  | 
 
 
 
 
 | 408 | typedef enum _MFNetCredentialOptions | 
 
 
 
 
 | 409 | { | 
 
 
 
 
 | 410 | MFNET_CREDENTIAL_SAVE             = 0x00000001, | 
 
 
 
 
 | 411 | MFNET_CREDENTIAL_DONT_CACHE       = 0x00000002, | 
 
 
 
 
 | 412 | MFNET_CREDENTIAL_ALLOW_CLEAR_TEXT = 0x00000004 | 
 
 
 
 
 | 413 | } MFNetCredentialOptions; | 
 
 
 
 
 | 414 |  | 
 
 
 
 
 | 415 | typedef enum _MFNetCredentialRequirements { | 
 
 
 
 
 | 416 | REQUIRE_PROMPT        = 0x00000001, | 
 
 
 
 
 | 417 | REQUIRE_SAVE_SELECTED = 0x00000002 | 
 
 
 
 
 | 418 | } MFNetCredentialRequirements; | 
 
 
 
 
 | 419 |  | 
 
 
 
 
 | 420 | typedef enum _MFNETSOURCE_CACHE_STATE | 
 
 
 
 
 | 421 | { | 
 
 
 
 
 | 422 | MFNETSOURCE_CACHE_UNAVAILABLE, | 
 
 
 
 
 | 423 | MFNETSOURCE_CACHE_ACTIVE_WRITING, | 
 
 
 
 
 | 424 | MFNETSOURCE_CACHE_ACTIVE_COMPLETE | 
 
 
 
 
 | 425 | } MFNETSOURCE_CACHE_STATE; | 
 
 
 
 
 | 426 |  | 
 
 
 
 
 | 427 | typedef enum _MFNETSOURCE_PROTOCOL_TYPE | 
 
 
 
 
 | 428 | { | 
 
 
 
 
 | 429 | MFNETSOURCE_UNDEFINED = 0x0, | 
 
 
 
 
 | 430 | MFNETSOURCE_HTTP      = 0x1, | 
 
 
 
 
 | 431 | MFNETSOURCE_RTSP      = 0x2, | 
 
 
 
 
 | 432 | MFNETSOURCE_FILE      = 0x3, | 
 
 
 
 
 | 433 | MFNETSOURCE_MULTICAST = 0x4 | 
 
 
 
 
 | 434 | } MFNETSOURCE_PROTOCOL_TYPE; | 
 
 
 
 
 | 435 |  | 
 
 
 
 
 | 436 | typedef enum _MFNETSOURCE_STATISTICS_IDS | 
 
 
 
 
 | 437 | { | 
 
 
 
 
 | 438 | MFNETSOURCE_RECVPACKETS_ID = 0, | 
 
 
 
 
 | 439 | MFNETSOURCE_LOSTPACKETS_ID, | 
 
 
 
 
 | 440 | MFNETSOURCE_RESENDSREQUESTED_ID, | 
 
 
 
 
 | 441 | MFNETSOURCE_RESENDSRECEIVED_ID, | 
 
 
 
 
 | 442 | MFNETSOURCE_RECOVEREDBYECCPACKETS_ID, | 
 
 
 
 
 | 443 | MFNETSOURCE_RECOVEREDBYRTXPACKETS_ID, | 
 
 
 
 
 | 444 | MFNETSOURCE_OUTPACKETS_ID, | 
 
 
 
 
 | 445 | MFNETSOURCE_RECVRATE_ID, | 
 
 
 
 
 | 446 | MFNETSOURCE_AVGBANDWIDTHBPS_ID, | 
 
 
 
 
 | 447 | MFNETSOURCE_BYTESRECEIVED_ID, | 
 
 
 
 
 | 448 | MFNETSOURCE_PROTOCOL_ID, | 
 
 
 
 
 | 449 | MFNETSOURCE_TRANSPORT_ID, | 
 
 
 
 
 | 450 | MFNETSOURCE_CACHE_STATE_ID, | 
 
 
 
 
 | 451 | MFNETSOURCE_LINKBANDWIDTH_ID, | 
 
 
 
 
 | 452 | MFNETSOURCE_CONTENTBITRATE_ID, | 
 
 
 
 
 | 453 | MFNETSOURCE_SPEEDFACTOR_ID, | 
 
 
 
 
 | 454 | MFNETSOURCE_BUFFERSIZE_ID, | 
 
 
 
 
 | 455 | MFNETSOURCE_BUFFERPROGRESS_ID, | 
 
 
 
 
 | 456 | MFNETSOURCE_LASTBWSWITCHTS_ID, | 
 
 
 
 
 | 457 | MFNETSOURCE_SEEKRANGESTART_ID, | 
 
 
 
 
 | 458 | MFNETSOURCE_SEEKRANGEEND_ID, | 
 
 
 
 
 | 459 | MFNETSOURCE_BUFFERINGCOUNT_ID, | 
 
 
 
 
 | 460 | MFNETSOURCE_INCORRECTLYSIGNEDPACKETS_ID, | 
 
 
 
 
 | 461 | MFNETSOURCE_SIGNEDSESSION_ID, | 
 
 
 
 
 | 462 | MFNETSOURCE_MAXBITRATE_ID, | 
 
 
 
 
 | 463 | MFNETSOURCE_RECEPTION_QUALITY_ID, | 
 
 
 
 
 | 464 | MFNETSOURCE_RECOVEREDPACKETS_ID, | 
 
 
 
 
 | 465 | MFNETSOURCE_VBR_ID, | 
 
 
 
 
 | 466 | MFNETSOURCE_DOWNLOADPROGRESS_ID | 
 
 
 
 
 | 467 | } MFNETSOURCE_STATISTICS_IDS; | 
 
 
 
 
 | 468 |  | 
 
 
 
 
 | 469 | typedef enum _MFNETSOURCE_TRANSPORT_TYPE | 
 
 
 
 
 | 470 | { | 
 
 
 
 
 | 471 | MFNETSOURCE_UDP, | 
 
 
 
 
 | 472 | MFNETSOURCE_TCP | 
 
 
 
 
 | 473 | } MFNETSOURCE_TRANSPORT_TYPE; | 
 
 
 
 
 | 474 |  | 
 
 
 
 
 | 475 | typedef enum MF_OBJECT_TYPE | 
 
 
 
 
 | 476 | { | 
 
 
 
 
 | 477 | MF_OBJECT_MEDIASOURCE, | 
 
 
 
 
 | 478 | MF_OBJECT_BYTESTREAM, | 
 
 
 
 
 | 479 | MF_OBJECT_INVALID | 
 
 
 
 
 | 480 | } MF_OBJECT_TYPE; | 
 
 
 
 
 | 481 |  | 
 
 
 
 
 | 482 | typedef enum _MFPOLICYMANAGER_ACTION | 
 
 
 
 
 | 483 | { | 
 
 
 
 
 | 484 | PEACTION_NO        = 0, | 
 
 
 
 
 | 485 | PEACTION_PLAY      = 1, | 
 
 
 
 
 | 486 | PEACTION_COPY      = 2, | 
 
 
 
 
 | 487 | PEACTION_EXPORT    = 3, | 
 
 
 
 
 | 488 | PEACTION_EXTRACT   = 4, | 
 
 
 
 
 | 489 | PEACTION_RESERVED1 = 5, | 
 
 
 
 
 | 490 | PEACTION_RESERVED2 = 6, | 
 
 
 
 
 | 491 | PEACTION_RESERVED3 = 7, | 
 
 
 
 
 | 492 | PEACTION_LAST      = 7 | 
 
 
 
 
 | 493 | } MFPOLICYMANAGER_ACTION; | 
 
 
 
 
 | 494 |  | 
 
 
 
 
 | 495 | typedef enum _MFRATE_DIRECTION | 
 
 
 
 
 | 496 | { | 
 
 
 
 
 | 497 | MFRATE_FORWARD, | 
 
 
 
 
 | 498 | MFRATE_REVERSE | 
 
 
 
 
 | 499 | } MFRATE_DIRECTION; | 
 
 
 
 
 | 500 |  | 
 
 
 
 
 | 501 | typedef enum _MFSequencerTopologyFlags | 
 
 
 
 
 | 502 | { | 
 
 
 
 
 | 503 | SequencerTopologyFlags_Last = 0x00000001 | 
 
 
 
 
 | 504 | } MFSequencerTopologyFlags; | 
 
 
 
 
 | 505 |  | 
 
 
 
 
 | 506 | typedef enum _MFSHUTDOWN_STATUS | 
 
 
 
 
 | 507 | { | 
 
 
 
 
 | 508 | MFSHUTDOWN_INITIATED, | 
 
 
 
 
 | 509 | MFSHUTDOWN_COMPLETED | 
 
 
 
 
 | 510 | } MFSHUTDOWN_STATUS; | 
 
 
 
 
 | 511 |  | 
 
 
 
 
 | 512 | typedef enum MFSTREAMSINK_MARKER_TYPE | 
 
 
 
 
 | 513 | { | 
 
 
 
 
 | 514 | MFSTREAMSINK_MARKER_DEFAULT, | 
 
 
 
 
 | 515 | MFSTREAMSINK_MARKER_ENDOFSEGMENT, | 
 
 
 
 
 | 516 | MFSTREAMSINK_MARKER_TICK, | 
 
 
 
 
 | 517 | MFSTREAMSINK_MARKER_EVENT | 
 
 
 
 
 | 518 | } MFSTREAMSINK_MARKER_TYPE; | 
 
 
 
 
 | 519 |  | 
 
 
 
 
 | 520 | typedef enum MFTIMER_FLAGS | 
 
 
 
 
 | 521 | { | 
 
 
 
 
 | 522 | MFTIMER_RELATIVE = 0x00000001 | 
 
 
 
 
 | 523 | } MFTIMER_FLAGS; | 
 
 
 
 
 | 524 |  | 
 
 
 
 
 | 525 | cpp_quote("#if (WINVER >= 0x0601)") | 
 
 
 
 
 | 526 |  | 
 
 
 
 
 | 527 | typedef enum MFTOPOLOGY_DXVA_MODE | 
 
 
 
 
 | 528 | { | 
 
 
 
 
 | 529 | MFTOPOLOGY_DXVA_DEFAULT = 0, | 
 
 
 
 
 | 530 | MFTOPOLOGY_DXVA_NONE    = 1, | 
 
 
 
 
 | 531 | MFTOPOLOGY_DXVA_FULL    = 2 | 
 
 
 
 
 | 532 | } MFTOPOLOGY_DXVA_MODE; | 
 
 
 
 
 | 533 |  | 
 
 
 
 
 | 534 | typedef enum MFTOPOLOGY_HARDWARE_MODE | 
 
 
 
 
 | 535 | { | 
 
 
 
 
 | 536 | MFTOPOLOGY_HWMODE_SOFTWARE_ONLY = 0, | 
 
 
 
 
 | 537 | MFTOPOLOGY_HWMODE_USE_HARDWARE  = 1 | 
 
 
 
 
 | 538 | } MFTOPOLOGY_HARDWARE_MODE; | 
 
 
 
 
 | 539 |  | 
 
 
 
 
 | 540 | typedef struct _MFT_REGISTRATION_INFO | 
 
 
 
 
 | 541 | { | 
 
 
 
 
 | 542 | CLSID clsid; | 
 
 
 
 
 | 543 | GUID guidCategory; | 
 
 
 
 
 | 544 | UINT32 uiFlags; | 
 
 
 
 
 | 545 | LPCWSTR pszName; | 
 
 
 
 
 | 546 | DWORD cInTypes; | 
 
 
 
 
 | 547 | [size_is(cInTypes)] MFT_REGISTER_TYPE_INFO *pInTypes; | 
 
 
 
 
 | 548 | DWORD cOutTypes; | 
 
 
 
 
 | 549 | [size_is(cOutTypes)] MFT_REGISTER_TYPE_INFO *pOutTypes; | 
 
 
 
 
 | 550 | } MFT_REGISTRATION_INFO; | 
 
 
 
 
 | 551 |  | 
 
 
 
 
 | 552 | cpp_quote("#endif /*(WINVER >= 0x0601)*/") | 
 
 
 
 
 | 553 |  | 
 
 
 
 
 | 554 | cpp_quote("typedef struct _ASFFlatPicture {") | 
 
 
 
 
 | 555 | cpp_quote("  BYTE  bPictureType;") | 
 
 
 
 
 | 556 | cpp_quote("  DWORD dwDataLen;") | 
 
 
 
 
 | 557 | cpp_quote("} ASF_FLAT_PICTURE;") | 
 
 
 
 
 | 558 | cpp_quote("") | 
 
 
 
 
 | 559 | cpp_quote("typedef struct _ASFFlatSynchronisedLyrics {") | 
 
 
 
 
 | 560 | cpp_quote("  BYTE  bTimeStampFormat;") | 
 
 
 
 
 | 561 | cpp_quote("  BYTE  bContentType;") | 
 
 
 
 
 | 562 | cpp_quote("  DWORD dwLyricsLen;") | 
 
 
 
 
 | 563 | cpp_quote("} ASF_FLAT_SYNCHRONISED_LYRICS;") | 
 
 
 
 
 | 564 |  | 
 
 
 
 
 | 565 | typedef enum SAMPLE_PROTECTION_VERSION | 
 
 
 
 
 | 566 | { | 
 
 
 
 
 | 567 | SAMPLE_PROTECTION_VERSION_NO         = 0, | 
 
 
 
 
 | 568 | SAMPLE_PROTECTION_VERSION_BASIC_LOKI = 1, | 
 
 
 
 
 | 569 | SAMPLE_PROTECTION_VERSION_SCATTER    = 2, | 
 
 
 
 
 | 570 | SAMPLE_PROTECTION_VERSION_RC4        = 3 | 
 
 
 
 
 | 571 | } SAMPLE_PROTECTION_VERSION; | 
 
 
 
 
 | 572 |  | 
 
 
 
 
 | 573 | typedef struct _MFINPUTTRUSTAUTHORITY_ACTION | 
 
 
 
 
 | 574 | { | 
 
 
 
 
 | 575 | MFPOLICYMANAGER_ACTION Action; | 
 
 
 
 
 | 576 | BYTE                   *pbTicket; | 
 
 
 
 
 | 577 | DWORD                  cbTicket; | 
 
 
 
 
 | 578 | } MFINPUTTRUSTAUTHORITY_ACCESS_ACTION; | 
 
 
 
 
 | 579 |  | 
 
 
 
 
 | 580 | typedef struct _MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS | 
 
 
 
 
 | 581 | { | 
 
 
 
 
 | 582 | DWORD                               dwSize; | 
 
 
 
 
 | 583 | DWORD                               dwVer; | 
 
 
 
 
 | 584 | DWORD                               cbSignatureOffset; | 
 
 
 
 
 | 585 | DWORD                               cbSignatureSize; | 
 
 
 
 
 | 586 | DWORD                               cbExtensionOffset; | 
 
 
 
 
 | 587 | DWORD                               cbExtensionSize; | 
 
 
 
 
 | 588 | DWORD                               cActions; | 
 
 
 
 
 | 589 | MFINPUTTRUSTAUTHORITY_ACCESS_ACTION rgOutputActions[1]; | 
 
 
 
 
 | 590 | } MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS; | 
 
 
 
 
 | 591 |  | 
 
 
 
 
 | 592 | typedef struct _MFNetCredentialManagerGetParam | 
 
 
 
 
 | 593 | { | 
 
 
 
 
 | 594 | HRESULT hrOp; | 
 
 
 
 
 | 595 | WINBOOL fAllowLoggedOnUser; | 
 
 
 
 
 | 596 | WINBOOL fClearTextPackage; | 
 
 
 
 
 | 597 | LPCWSTR pszUrl; | 
 
 
 
 
 | 598 | LPCWSTR pszSite; | 
 
 
 
 
 | 599 | LPCWSTR pszRealm; | 
 
 
 
 
 | 600 | LPCWSTR pszPackage; | 
 
 
 
 
 | 601 | LONG    nRetries; | 
 
 
 
 
 | 602 | } MFNetCredentialManagerGetParam; | 
 
 
 
 
 | 603 |  | 
 
 
 
 
 | 604 | cpp_quote("#define MEDIASINK_FIXED_STREAMS                 0x00000001") | 
 
 
 
 
 | 605 | cpp_quote("#define MEDIASINK_CANNOT_MATCH_CLOCK            0x00000002") | 
 
 
 
 
 | 606 | cpp_quote("#define MEDIASINK_RATELESS                      0x00000004") | 
 
 
 
 
 | 607 | cpp_quote("#define MEDIASINK_CLOCK_REQUIRED                0x00000008") | 
 
 
 
 
 | 608 | cpp_quote("#define MEDIASINK_CAN_PREROLL                   0x00000010") | 
 
 
 
 
 | 609 | cpp_quote("#define MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE   0x00000020") | 
 
 
 
 
 | 610 |  | 
 
 
 
 
 | 611 | enum | 
 
 
 
 
 | 612 | { | 
 
 
 
 
 | 613 | MF_RESOLUTION_MEDIASOURCE                                           = 0x00000001, | 
 
 
 
 
 | 614 | MF_RESOLUTION_BYTESTREAM                                            = 0x00000002, | 
 
 
 
 
 | 615 | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE = 0x00000010, | 
 
 
 
 
 | 616 | MF_RESOLUTION_KEEP_BYTE_STREAM_ALIVE_ON_FAIL                        = 0x00000020, | 
 
 
 
 
 | 617 | MF_RESOLUTION_READ                                                  = 0x00010000, | 
 
 
 
 
 | 618 | MF_RESOLUTION_WRITE                                                 = 0x00020000 | 
 
 
 
 
 | 619 | }; | 
 
 
 
 
 | 620 |  | 
 
 
 
 
 | 621 | /* Forward declaration goes here. | 
 
 
 
 
 | 622 | * Just for ease, declare interfaces alphabatically. | 
 
 
 
 
 | 623 | */ | 
 
 
 
 
 | 624 | interface IMFASFContentInfo; | 
 
 
 
 
 | 625 | interface IMFASFIndexer; | 
 
 
 
 
 | 626 | interface IMFASFMultiplexer; | 
 
 
 
 
 | 627 | interface IMFASFProfile; | 
 
 
 
 
 | 628 | interface IMFASFSplitter; | 
 
 
 
 
 | 629 | interface IMFPMPServer; | 
 
 
 
 
 | 630 | interface IMFPresentationClock; | 
 
 
 
 
 | 631 | interface IMFNetProxyLocator; | 
 
 
 
 
 | 632 | interface IMFRemoteDesktopPlugin; | 
 
 
 
 
 | 633 | interface IMFTransform; | 
 
 
 
 
 | 634 | interface IMFSequencerSource; | 
 
 
 
 
 | 635 | interface IMFStreamSink; | 
 
 
 
 
 | 636 | interface IMFQualityManager; | 
 
 
 
 
 | 637 | interface IMFTranscodeProfile; | 
 
 
 
 
 | 638 |  | 
 
 
 
 
 | 639 | [object, uuid(76b1bbdb-4ec8-4f36-b106-70a9316df593)] | 
 
 
 
 
 | 640 | interface IMFAudioStreamVolume : IUnknown | 
 
 
 
 
 | 641 | { | 
 
 
 
 
 | 642 | HRESULT GetChannelCount([out] UINT32 *pdwCount); | 
 
 
 
 
 | 643 | HRESULT SetChannelVolume([in] UINT32 dwIndex, [in] const float fLevel); | 
 
 
 
 
 | 644 | HRESULT GetChannelVolume([in] UINT32 dwIndex, [out] float *pfLevel); | 
 
 
 
 
 | 645 | HRESULT SetAllVolumes([in] UINT32 dwCount, [in, size_is(dwCount)] const float *pfVolumes); | 
 
 
 
 
 | 646 | HRESULT GetAllVolumes([in] UINT32 dwCount, [out, size_is(dwCount)] float *pfVolumes); | 
 
 
 
 
 | 647 | } | 
 
 
 
 
 | 648 |  | 
 
 
 
 
 | 649 | [object, uuid(6ef2a660-47c0-4666-b13d-cbb717f2fa2c)] | 
 
 
 
 
 | 650 | interface IMFMediaSink : IUnknown | 
 
 
 
 
 | 651 | { | 
 
 
 
 
 | 652 | HRESULT GetCharacteristics([out] DWORD *pdwCharacteristics); | 
 
 
 
 
 | 653 | HRESULT AddStreamSink([in] DWORD dwStreamSinkIdentifier, [in] IMFMediaType *pMediaType, [out] IMFStreamSink **ppStreamSink); | 
 
 
 
 
 | 654 | HRESULT RemoveStreamSink([in] DWORD dwStreamSinkIdentifier); | 
 
 
 
 
 | 655 | HRESULT GetStreamSinkCount([out] DWORD *pcStreamSinkCount); | 
 
 
 
 
 | 656 | HRESULT GetStreamSinkByIndex([in] DWORD dwIndex, [out] IMFStreamSink **ppStreamSink); | 
 
 
 
 
 | 657 | HRESULT GetStreamSinkById([in] DWORD dwStreamSinkIdentifier, [out] IMFStreamSink **ppStreamSink); | 
 
 
 
 
 | 658 | HRESULT SetPresentationClock([in] IMFPresentationClock *pPresentationClock); | 
 
 
 
 
 | 659 | HRESULT GetPresentationClock([out] IMFPresentationClock **ppPresentationClock); | 
 
 
 
 
 | 660 | HRESULT Shutdown(void); | 
 
 
 
 
 | 661 | } | 
 
 
 
 
 | 662 |  | 
 
 
 
 
 | 663 | [object, uuid(eaecb74a-9a50-42ce-9541-6a7f57aa4ad7), local] | 
 
 
 
 
 | 664 | interface IMFFinalizableMediaSink : IMFMediaSink | 
 
 
 
 
 | 665 | { | 
 
 
 
 
 | 666 | HRESULT BeginFinalize([in] IMFAsyncCallback *pCallback, [in] IUnknown *punkState); | 
 
 
 
 
 | 667 | HRESULT EndFinalize([in] IMFAsyncResult *pResult); | 
 
 
 
 
 | 668 | } | 
 
 
 
 
 | 669 |  | 
 
 
 
 
 | 670 | [object, uuid(5dfd4b2a-7674-4110-a4e6-8a68fd5f3688)] | 
 
 
 
 
 | 671 | interface IMFMediaSinkPreroll : IUnknown | 
 
 
 
 
 | 672 | { | 
 
 
 
 
 | 673 | HRESULT NotifyPreroll([in] MFTIME hnsUpcomingStartTime); | 
 
 
 
 
 | 674 | } | 
 
 
 
 
 | 675 |  | 
 
 
 
 
 | 676 | [object, uuid(d182108f-4ec6-443f-aa42-a71106ec825f)] | 
 
 
 
 
 | 677 | interface IMFMediaStream : IMFMediaEventGenerator | 
 
 
 
 
 | 678 | { | 
 
 
 
 
 | 679 | HRESULT GetMediaSource([out] IMFMediaSource**ppMediaSource); | 
 
 
 
 
 | 680 | HRESULT GetStreamDescriptor([out] IMFStreamDescriptor **ppStreamDescriptor); | 
 
 
 
 
 | 681 |  | 
 
 
 
 
 | 682 | [local] | 
 
 
 
 
 | 683 | HRESULT RequestSample([in] IUnknown *pToken); | 
 
 
 
 
 | 684 |  | 
 
 
 
 
 | 685 | [call_as(RequestSample)] | 
 
 
 
 
 | 686 | HRESULT RemoteRequestSample(void); | 
 
 
 
 
 | 687 | } | 
 
 
 
 
 | 688 |  | 
 
 
 
 
 | 689 | [object, uuid(f88cfb8c-ef16-4991-b450-cb8c69e51704)] | 
 
 
 
 
 | 690 | interface IMFMetadata : IUnknown | 
 
 
 
 
 | 691 | { | 
 
 
 
 
 | 692 | HRESULT SetLanguage([in] LPCWSTR pwszRFC1766); | 
 
 
 
 
 | 693 | HRESULT GetLanguage([out] LPWSTR *ppwszRFC1766); | 
 
 
 
 
 | 694 | HRESULT GetAllLanguages([out] PROPVARIANT *ppvLanguages); | 
 
 
 
 
 | 695 | HRESULT SetProperty([in] LPCWSTR pwszName, [in] const PROPVARIANT *ppvValue); | 
 
 
 
 
 | 696 | HRESULT GetProperty([in] LPCWSTR pwszName, [out] PROPVARIANT *ppvValue); | 
 
 
 
 
 | 697 | HRESULT DeleteProperty([in] LPCWSTR pwszName); | 
 
 
 
 
 | 698 | HRESULT GetAllPropertyNames([out] PROPVARIANT *ppvNames); | 
 
 
 
 
 | 699 | } | 
 
 
 
 
 | 700 |  | 
 
 
 
 
 | 701 | [object, uuid(56181d2d-e221-4adb-b1c8-3cee6a53f76f)] | 
 
 
 
 
 | 702 | interface IMFMetadataProvider : IUnknown | 
 
 
 
 
 | 703 | { | 
 
 
 
 
 | 704 | HRESULT GetMFMetadata([in] IMFPresentationDescriptor *pPresentationDescriptor, [in] DWORD dwStreamIdentifier, [in] DWORD dwFlags, [out] IMFMetadata **ppMFMetadata); | 
 
 
 
 
 | 705 | } | 
 
 
 
 
 | 706 |  | 
 
 
 
 
 | 707 | [object, uuid(7ff12cce-f76f-41c2-863b-1666c8e5e139)] | 
 
 
 
 
 | 708 | interface IMFPresentationTimeSource : IMFClock | 
 
 
 
 
 | 709 | { | 
 
 
 
 
 | 710 | HRESULT GetUnderlyingClock([out] IMFClock **ppClock); | 
 
 
 
 
 | 711 | } | 
 
 
 
 
 | 712 |  | 
 
 
 
 
 | 713 | [object, uuid(868ce85c-8ea9-4f55-ab82-b009a910a805)] | 
 
 
 
 
 | 714 | interface IMFPresentationClock : IMFClock | 
 
 
 
 
 | 715 | { | 
 
 
 
 
 | 716 | HRESULT SetTimeSource([in] IMFPresentationTimeSource *pTimeSource); | 
 
 
 
 
 | 717 | HRESULT GetTimeSource([out] IMFPresentationTimeSource **ppTimeSource); | 
 
 
 
 
 | 718 | HRESULT GetTime([out] MFTIME *phnsClockTime); | 
 
 
 
 
 | 719 | HRESULT AddClockStateSink([in] IMFClockStateSink *pStateSink); | 
 
 
 
 
 | 720 | HRESULT RemoveClockStateSink([in] IMFClockStateSink* pStateSink); | 
 
 
 
 
 | 721 | HRESULT Start([in] LONGLONG llClockStartOffset); | 
 
 
 
 
 | 722 | HRESULT Stop(void); | 
 
 
 
 
 | 723 | HRESULT Pause(void); | 
 
 
 
 
 | 724 | } | 
 
 
 
 
 | 725 |  | 
 
 
 
 
 | 726 | [object, uuid(88ddcd21-03c3-4275-91ed-55ee3929328f), pointer_default(unique)] | 
 
 
 
 
 | 727 | interface IMFRateControl : IUnknown | 
 
 
 
 
 | 728 | { | 
 
 
 
 
 | 729 | HRESULT SetRate([in] WINBOOL fThin, [in] float flRate); | 
 
 
 
 
 | 730 | HRESULT GetRate([in, out, unique] WINBOOL *pfThin, [in, out, unique] float *pflRate); | 
 
 
 
 
 | 731 | } | 
 
 
 
 
 | 732 |  | 
 
 
 
 
 | 733 | [object, uuid(0a9ccdbc-d797-4563-9667-94ec5d79292d), pointer_default(unique)] | 
 
 
 
 
 | 734 | interface IMFRateSupport : IUnknown | 
 
 
 
 
 | 735 | { | 
 
 
 
 
 | 736 | HRESULT GetSlowestRate([in] MFRATE_DIRECTION eDirection, [in] WINBOOL fThin, [out] float *pflRate); | 
 
 
 
 
 | 737 | HRESULT GetFastestRate([in] MFRATE_DIRECTION eDirection, [in] WINBOOL fThin, [out] float *pflRate); | 
 
 
 
 
 | 738 | HRESULT IsRateSupported([in] WINBOOL fThin, [in] float flRate, [in, out, unique] float *pflNearestSupportedRate); | 
 
 
 
 
 | 739 | } | 
 
 
 
 
 | 740 |  | 
 
 
 
 
 | 741 | [object, uuid(8c7b80bf-ee42-4b59-b1df-55668e1bdca8), local] | 
 
 
 
 
 | 742 | interface IMFSampleGrabberSinkCallback : IMFClockStateSink | 
 
 
 
 
 | 743 | { | 
 
 
 
 
 | 744 | HRESULT OnSetPresentationClock([in] IMFPresentationClock *pPresentationClock); | 
 
 
 
 
 | 745 | HRESULT OnProcessSample([in] REFGUID guidMajorMediaType, [in] DWORD dwSampleFlags, [in] LONGLONG llSampleTime, [in] LONGLONG llSampleDuration, [in] const BYTE *pSampleBuffer, [in] DWORD dwSampleSize); | 
 
 
 
 
 | 746 | HRESULT OnShutdown(void); | 
 
 
 
 
 | 747 | } | 
 
 
 
 
 | 748 |  | 
 
 
 
 
 | 749 | [object, uuid(fbe5a32d-a497-4b61-bb85-97b1a848a6e3)] | 
 
 
 
 
 | 750 | interface IMFSourceResolver : IUnknown | 
 
 
 
 
 | 751 | { | 
 
 
 
 
 | 752 | [local] | 
 
 
 
 
 | 753 | HRESULT CreateObjectFromURL([in] LPCWSTR pwszURL, [in] DWORD dwFlags, [in] IPropertyStore *pProps, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 754 |  | 
 
 
 
 
 | 755 | [local] | 
 
 
 
 
 | 756 | HRESULT CreateObjectFromByteStream([in] IMFByteStream* pByteStream, [in] LPCWSTR pwszURL, [in] DWORD dwFlags, [in] IPropertyStore *pProps, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 757 |  | 
 
 
 
 
 | 758 | [local] | 
 
 
 
 
 | 759 | HRESULT BeginCreateObjectFromURL([in] LPCWSTR pwszURL, [in] DWORD dwFlags, [in] IPropertyStore *pProps, [out] IUnknown **ppIUnknownCancelCookie, [in] IMFAsyncCallback *pCallback, [in] IUnknown *punkState); | 
 
 
 
 
 | 760 |  | 
 
 
 
 
 | 761 | [call_as(BeginCreateObjectFromURL)] | 
 
 
 
 
 | 762 | HRESULT RemoteBeginCreateObjectFromURL([in, string] LPCWSTR pwszURL, [in] DWORD dwFlags, [in] IPropertyStore *pProps, [in] IMFRemoteAsyncCallback *pCallback); | 
 
 
 
 
 | 763 |  | 
 
 
 
 
 | 764 | [local] | 
 
 
 
 
 | 765 | HRESULT EndCreateObjectFromURL([in] IMFAsyncResult *pResult, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 766 |  | 
 
 
 
 
 | 767 | [call_as(EndCreateObjectFromURL)] | 
 
 
 
 
 | 768 | HRESULT RemoteEndCreateObjectFromURL([in] IUnknown *pResult, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 769 |  | 
 
 
 
 
 | 770 | [local] | 
 
 
 
 
 | 771 | HRESULT BeginCreateObjectFromByteStream([in] IMFByteStream* pByteStream, [in] LPCWSTR pwszURL, [in] DWORD dwFlags, [in] IPropertyStore *pProps, [out] IUnknown **ppIUnknownCancelCookie, [in] IMFAsyncCallback *pCallback, [in] IUnknown *punkState); | 
 
 
 
 
 | 772 |  | 
 
 
 
 
 | 773 | [call_as(BeginCreateObjectFromByteStream)] | 
 
 
 
 
 | 774 | HRESULT RemoteBeginCreateObjectFromByteStream([in] IMFByteStream* pByteStream, [in, unique] LPCWSTR pwszURL, [in] DWORD dwFlags, [in, unique] IPropertyStore *pProps, [in] IMFRemoteAsyncCallback *pCallback); | 
 
 
 
 
 | 775 |  | 
 
 
 
 
 | 776 | [local] | 
 
 
 
 
 | 777 | HRESULT EndCreateObjectFromByteStream([in] IMFAsyncResult *pResult, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 778 |  | 
 
 
 
 
 | 779 | [call_as(EndCreateObjectFromByteStream)] | 
 
 
 
 
 | 780 | HRESULT RemoteEndCreateObjectFromByteStream([in] IUnknown *pResult, [out] MF_OBJECT_TYPE *pObjectType, [out] IUnknown **ppObject); | 
 
 
 
 
 | 781 |  | 
 
 
 
 
 | 782 | [local] | 
 
 
 
 
 | 783 | HRESULT CancelObjectCreation([in] IUnknown *pIUnknownCancelCookie); | 
 
 
 
 
 | 784 | } | 
 
 
 
 
 | 785 |  | 
 
 
 
 
 | 786 | [object, uuid(0a97b3cf-8e7c-4a3d-8f8c-0c843dc247fb)] | 
 
 
 
 
 | 787 | interface IMFStreamSink : IMFMediaEventGenerator | 
 
 
 
 
 | 788 | { | 
 
 
 
 
 | 789 | HRESULT GetMediaSink([out] IMFMediaSink **ppMediaSink); | 
 
 
 
 
 | 790 | HRESULT GetIdentifier([out] DWORD *pdwIdentifier); | 
 
 
 
 
 | 791 | HRESULT GetMediaTypeHandler([out] IMFMediaTypeHandler **ppHandler); | 
 
 
 
 
 | 792 | HRESULT ProcessSample([in] IMFSample *pSample); | 
 
 
 
 
 | 793 | HRESULT PlaceMarker([in] MFSTREAMSINK_MARKER_TYPE eMarkerType, [in] const PROPVARIANT *pvarMarkerValue, [in] const PROPVARIANT *pvarContextValue); | 
 
 
 
 
 | 794 | HRESULT Flush(void); | 
 
 
 
 
 | 795 | } | 
 
 
 
 
 | 796 |  | 
 
 
 
 
 | 797 | [object, uuid(de9a6157-f660-4643-b56a-df9f7998c7cd), local] | 
 
 
 
 
 | 798 | interface IMFTopoLoader : IUnknown | 
 
 
 
 
 | 799 | { | 
 
 
 
 
 | 800 | HRESULT Load([in] IMFTopology *pInputTopo, [out] IMFTopology **ppOutputTopo, [in] IMFTopology *pCurrentTopo); | 
 
 
 
 
 | 801 | } | 
 
 
 
 
 | 802 |  | 
 
 
 
 
 | 803 | cpp_quote("HRESULT WINAPI MFCreate3GPMediaSink(IMFByteStream *pIByteStream,IMFMediaType *pVideoMediaType,IMFMediaType *pAudioMediaType,IMFMediaSink **ppIMediaSink);") | 
 
 
 
 
 | 804 | cpp_quote("HRESULT WINAPI MFCreateAggregateSource(IMFCollection *pSourceCollection,IMFMediaSource **ppAggSource);") | 
 
 
 
 
 | 805 | cpp_quote("") | 
 
 
 
 
 | 806 | cpp_quote("HRESULT WINAPI MFCreateAlignedMemoryBuffer(DWORD cbMaxLength,DWORD fAlignmentFlags,IMFMediaBuffer **ppBuffer);") | 
 
 
 
 
 | 807 | cpp_quote("HRESULT WINAPI MFCreateASFContentInfo(IMFASFContentInfo **ppIContentInfo);") | 
 
 
 
 
 | 808 | cpp_quote("HRESULT WINAPI MFCreateASFIndexer(IMFASFIndexer **ppIIndexer);") | 
 
 
 
 
 | 809 | cpp_quote("HRESULT WINAPI MFCreateASFIndexerByteStream(IMFByteStream *pIContentByteStream,QWORD cbIndexStartOffset,IMFByteStream **pIIndexByteStream);") | 
 
 
 
 
 | 810 | cpp_quote("HRESULT WINAPI MFCreateASFMediaSink(IMFByteStream *pIByteStream,IMFMediaSink **ppIMediaSink);") | 
 
 
 
 
 | 811 | cpp_quote("HRESULT WINAPI MFCreateASFMediaSinkActivate(LPCWSTR pwszFileName,IMFASFContentInfo *pContentInfo,IMFActivate **ppIActivate);") | 
 
 
 
 
 | 812 | cpp_quote("HRESULT WINAPI MFCreateASFMultiplexer(IMFASFMultiplexer **ppIMultiplexer);") | 
 
 
 
 
 | 813 | cpp_quote("HRESULT WINAPI MFCreateASFProfile(IMFASFProfile **ppIProfile);") | 
 
 
 
 
 | 814 | cpp_quote("HRESULT WINAPI MFCreateASFProfileFromPresentationDescriptor(IMFPresentationDescriptor *pIPD,IMFASFProfile **ppIProfile);") | 
 
 
 
 
 | 815 | cpp_quote("HRESULT WINAPI MFCreateASFSplitter(IMFASFSplitter **ppISplitter);") | 
 
 
 
 
 | 816 | cpp_quote("HRESULT WINAPI MFCreateAudioRenderer(IMFAttributes *pAudioAttributes, IMFMediaSink **ppSink);") | 
 
 
 
 
 | 817 | cpp_quote("HRESULT WINAPI MFCreateAudioRendererActivate(IMFActivate **ppActivate);") | 
 
 
 
 
 | 818 | cpp_quote("HRESULT WINAPI MFCreateMediaSession(IMFAttributes *pConfiguration,IMFMediaSession **ppMS);") | 
 
 
 
 
 | 819 | cpp_quote("HRESULT WINAPI MFCreateMP3MediaSink(IMFByteStream *pTargetByteStream,IMFMediaSink **ppMediaSink);") | 
 
 
 
 
 | 820 | cpp_quote("HRESULT WINAPI MFCreateMPEG4MediaSink(IMFByteStream *pIByteStream,IMFMediaType *pVideoMediaType,IMFMediaType *pAudioMediaType,IMFMediaSink **ppIMediaSink);") | 
 
 
 
 
 | 821 | cpp_quote("HRESULT WINAPI MFCreateNetSchemePlugin(REFIID riid,LPVOID *ppvHandler);") | 
 
 
 
 
 | 822 | cpp_quote("HRESULT WINAPI MFCreatePMPServer(DWORD dwCreationFlags,IMFPMPServer **ppPMPServer);") | 
 
 
 
 
 | 823 | cpp_quote("HRESULT WINAPI MFCreatePMPMediaSession(DWORD dwCreationFlags,IMFAttributes *pConfiguration,IMFMediaSession **ppMediaSession,IMFActivate **ppEnablerActivate);") | 
 
 
 
 
 | 824 | cpp_quote("HRESULT WINAPI MFCreatePathFromURL(LPCWSTR pwszFileURL,LPWSTR *ppwszFilePath);") | 
 
 
 
 
 | 825 | cpp_quote("HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **ppPresentationClock);") | 
 
 
 
 
 | 826 | cpp_quote("HRESULT WINAPI MFCreatePresentationDescriptor(DWORD cStreamDescriptors,IMFStreamDescriptor **apStreamDescriptors,IMFPresentationDescriptor **ppPresentationDescriptor);") | 
 
 
 
 
 | 827 | cpp_quote("HRESULT WINAPI MFCreatePresentationDescriptorFromASFProfile(IMFASFProfile *pIProfile,IMFPresentationDescriptor **ppIPD);") | 
 
 
 
 
 | 828 | cpp_quote("HRESULT WINAPI MFCreateProxyLocator(LPCWSTR pszProtocol,IPropertyStore *pProxyConfig,IMFNetProxyLocator **ppProxyLocator);") | 
 
 
 
 
 | 829 | cpp_quote("HRESULT WINAPI MFCreateRemoteDesktopPlugin(IMFRemoteDesktopPlugin **ppPlugin);") | 
 
 
 
 
 | 830 | cpp_quote("HRESULT WINAPI MFCreateSample(IMFSample **ppIMFSample);") | 
 
 
 
 
 | 831 | cpp_quote("HRESULT WINAPI MFCreateSampleCopierMFT(IMFTransform **ppCopierMFT);") | 
 
 
 
 
 | 832 | cpp_quote("HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *pIMFMediaType,IMFSampleGrabberSinkCallback *pIMFSampleGrabberSinkCallback,IMFActivate **ppIActivate);") | 
 
 
 
 
 | 833 | cpp_quote("HRESULT WINAPI MFCreateSequencerSource(IUnknown *pReserved,IMFSequencerSource **ppSequencerSource);") | 
 
 
 
 
 | 834 | cpp_quote("HRESULT WINAPI MFCreateSimpleTypeHandler(IMFMediaTypeHandler **ppHandler);") | 
 
 
 
 
 | 835 | cpp_quote("HRESULT WINAPI MFCreateStandardQualityManager(IMFQualityManager **ppQualityManager);") | 
 
 
 
 
 | 836 | cpp_quote("HRESULT WINAPI MFCreateStreamDescriptor(DWORD dwStreamIdentifier,DWORD cMediaTypes,IMFMediaType **apMediaTypes,IMFStreamDescriptor **ppDescriptor);") | 
 
 
 
 
 | 837 | cpp_quote("HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **ppISourceResolver);") | 
 
 
 
 
 | 838 | cpp_quote("HRESULT WINAPI MFCreateSystemTimeSource(IMFPresentationTimeSource **ppSystemTimeSource);") | 
 
 
 
 
 | 839 | cpp_quote("HRESULT WINAPI MFCreateTopoLoader(IMFTopoLoader **ppObj);") | 
 
 
 
 
 | 840 | cpp_quote("HRESULT WINAPI MFCreateTopology(IMFTopology **ppTopo);") | 
 
 
 
 
 | 841 | cpp_quote("HRESULT WINAPI MFCreateTopologyNode(MF_TOPOLOGY_TYPE NodeType,IMFTopologyNode **ppNode);") | 
 
 
 
 
 | 842 | cpp_quote("HRESULT WINAPI MFCreateVideoRenderer(REFIID riidRenderer,void **ppVideoRenderer);") | 
 
 
 
 
 | 843 | cpp_quote("HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwndVideo,IMFActivate **ppActivate);") | 
 
 
 
 
 | 844 | cpp_quote("HRESULT WINAPI MFGetService(IUnknown *punkObject,REFGUID guidService,REFIID riid,LPVOID *ppvObject);") | 
 
 
 
 
 | 845 | cpp_quote("HRESULT WINAPI MFGetSupportedMimeTypes(PROPVARIANT *pPropVarMimeTypeArray);") | 
 
 
 
 
 | 846 | cpp_quote("HRESULT WINAPI MFGetSupportedSchemes(PROPVARIANT *pPropVarSchemeArray);") | 
 
 
 
 
 | 847 | cpp_quote("MFTIME WINAPI MFGetSystemTime(void);") | 
 
 
 
 
 | 848 | cpp_quote("HRESULT WINAPI MFShutdownObject(IUnknown *pUnk);") | 
 
 
 
 
 | 849 | cpp_quote("HRESULT WINAPI CreateNamedPropertyStore(INamedPropertyStore **ppStore);") | 
 
 
 
 
 | 850 | cpp_quote("HRESULT WINAPI CreatePropertyStore(IPropertyStore **ppStore);") | 
 
 
 
 
 | 851 | cpp_quote("#if (WINVER >= 0x0601)") | 
 
 
 
 
 | 852 | cpp_quote("") | 
 
 
 
 
 | 853 | cpp_quote("HRESULT WINAPI MFCreateTranscodeProfile(IMFTranscodeProfile **ppTranscodeProfile);") | 
 
 
 
 
 | 854 | cpp_quote("HRESULT WINAPI MFCreateTranscodeSinkActivate(IMFActivate **ppActivate);") | 
 
 
 
 
 | 855 | cpp_quote("HRESULT WINAPI MFCreateTranscodeTopology(IMFMediaSource *pSrc,LPCWSTR pwszOutputFilePath,IMFTranscodeProfile *pProfile,IMFTopology **ppTranscodeTopo);") | 
 
 
 
 
 | 856 | cpp_quote("HRESULT WINAPI MFEnumDeviceSources(IMFAttributes *pAttributes,IMFActivate ***pppSourceActivate,UINT32 *pcSourceActivate);") | 
 
 
 
 
 | 857 | cpp_quote("HRESULT WINAPI MFGetTopoNodeCurrentType(IMFTopologyNode *pNode,DWORD dwStreamIndex,WINBOOL fOutput,IMFMediaType **ppType);") | 
 
 
 
 
 | 858 | cpp_quote("HRESULT WINAPI MFTranscodeGetAudioOutputAvailableTypes(REFGUID guidSubType,DWORD dwMFTFlags,IMFAttributes *pCodecConfig,IMFCollection **ppAvailableTypes);") | 
 
 
 
 
 | 859 | cpp_quote("#endif") | 
 
 
 
 
 | 860 |  | 
 
 
 
 
 | 861 | cpp_quote("EXTERN_GUID(MFNETSOURCE_STATISTICS, 0x3cb1f274, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1);") | 
 
 
 
 
 | 862 | cpp_quote("EXTERN_GUID(MFNETSOURCE_STATISTICS_SERVICE, 0x3cb1f275, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1);") | 
 
 
 
 
 | 863 |  | 
 
 
 
 
 | 864 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, 0xba491360, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 865 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE, 0xba491361, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 866 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, 0xba491362, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 867 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, 0xba491364, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 868 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE, 0xba491365, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 869 | cpp_quote("EXTERN_GUID(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, 0xba491366, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 );") | 
 
 
 
 
 | 870 |  | 
 
 
 
 
 | 871 | cpp_quote("EXTERN_GUID(MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID, 0xede4b5e3, 0xf805, 0x4d6c, 0x99, 0xb3, 0xdb, 0x01, 0xbf, 0x95, 0xdf, 0xab);") | 
 
 
 
 
 | 872 | cpp_quote("EXTERN_GUID(MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID, 0xb10aaec3, 0xef71, 0x4cc3, 0xb8, 0x73, 0x5, 0xa9, 0xa0, 0x8b, 0x9f, 0x8e);") | 
 
 
 
 
 | 873 | cpp_quote("EXTERN_GUID(MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, 0x6ba644ff, 0x27c5, 0x4d02, 0x98, 0x87, 0xc2, 0x86, 0x19, 0xfd, 0xb9, 0x1b);") | 
 
 
 
 
 | 874 | cpp_quote("EXTERN_GUID(MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY, 0xa9770471, 0x92ec, 0x4df4, 0x94, 0xfe, 0x81, 0xc3, 0x6f, 0xc, 0x3a, 0x7a);") | 
 
 
 
 
 | 875 |  | 
 
 
 
 
 | 876 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, 0x60d0e559,0x52f8,0x4fa2,0xbb,0xce,0xac,0xdb,0x34,0xa8,0xec,0x1);") | 
 
 
 
 
 | 877 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE, 0x56a819ca,0xc78,0x4de4,0xa0,0xa7,0x3d,0xda,0xba,0xf,0x24,0xd4);") | 
 
 
 
 
 | 878 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID, 0x30da9258,0xfeb9,0x47a7,0xa4,0x53,0x76,0x3a,0x7a,0x8e,0x1c,0x5f);") | 
 
 
 
 
 | 879 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE, 0xbc9d118e,0x8c67,0x4a18,0x85,0xd4,0x12,0xd3,0x0,0x40,0x5,0x52);") | 
 
 
 
 
 | 880 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY, 0x77f0ae69,0xc3bd,0x4509,0x94,0x1d,0x46,0x7e,0x4d,0x24,0x89,0x9e);") | 
 
 
 
 
 | 881 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE, 0xde7046ba,0x54d6,0x4487,0xa2,0xa4,0xec,0x7c,0xd,0x1b,0xd1,0x63);") | 
 
 
 
 
 | 882 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS, 0x7dd9b730,0x4f2d,0x41d5,0x8f,0x95,0xc,0xc9,0xa9,0x12,0xba,0x26);") | 
 
 
 
 
 | 883 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, 0x58f0aad8,0x22bf,0x4f8a,0xbb,0x3d,0xd2,0xc4,0x97,0x8c,0x6e,0x2f);") | 
 
 
 
 
 | 884 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, 0xc60ac5fe,0x252a,0x478f,0xa0,0xef,0xbc,0x8f,0xa5,0xf7,0xca,0xd3);") | 
 
 
 
 
 | 885 | cpp_quote("EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID, 0x8ac3587a,0x4ae7,0x42d8,0x99,0xe0,0x0a,0x60,0x13,0xee,0xf9,0x0f);") | 
 
 
 
 
 | 886 |  | 
 
 
 
 
 | 887 | cpp_quote("EXTERN_GUID(MF_METADATA_PROVIDER_SERVICE, 0xdb214084, 0x58a4, 0x4d2e, 0xb8, 0x4f, 0x6f, 0x75, 0x5b, 0x2f, 0x7a, 0xd);") | 
 
 
 
 
 | 888 | cpp_quote("EXTERN_GUID(MF_PROPERTY_HANDLER_SERVICE, 0xa3face02, 0x32b8, 0x41dd, 0x90, 0xe7, 0x5f, 0xef, 0x7c, 0x89, 0x91, 0xb5);") | 
 
 
 
 
 | 889 | cpp_quote("EXTERN_GUID(MF_RATE_CONTROL_SERVICE, 0x866fa297, 0xb802, 0x4bf8, 0x9d, 0xc9, 0x5e, 0x3b, 0x6a, 0x9f, 0x53, 0xc9);") | 
 
 
 
 
 | 890 | cpp_quote("EXTERN_GUID(MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, 0x0efda2c0, 0x2b69, 0x4e2e, 0xab, 0x8d, 0x46, 0xdc, 0xbf, 0xf7, 0xd2, 0x5d);") | 
 
 
 
 
 | 891 |  | 
 
 
 
 
 | 892 | cpp_quote("EXTERN_GUID(MF_TOPONODE_DRAIN, 0x494bbce9, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 893 | cpp_quote("EXTERN_GUID(MF_TOPONODE_D3DAWARE, 0x494bbced, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 894 | cpp_quote("EXTERN_GUID(MF_TOPOLOGY_RESOLUTION_STATUS, 0x494bbcde, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 895 | cpp_quote("EXTERN_GUID(MF_TOPONODE_ERRORCODE, 0x494bbcee, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 896 | cpp_quote("EXTERN_GUID(MF_TOPONODE_CONNECT_METHOD, 0x494bbcf1, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 897 | cpp_quote("EXTERN_GUID(MF_TOPONODE_LOCKED, 0x494bbcf7, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 898 | cpp_quote("EXTERN_GUID(MF_TOPONODE_WORKQUEUE_ID, 0x494bbcf8, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 899 | cpp_quote("EXTERN_GUID(MF_TOPONODE_WORKQUEUE_MMCSS_CLASS, 0x494bbcf9, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 900 | cpp_quote("EXTERN_GUID(MF_TOPONODE_DECRYPTOR, 0x494bbcfa, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 901 | cpp_quote("EXTERN_GUID(MF_TOPONODE_DISCARDABLE, 0x494bbcfb, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 902 | cpp_quote("EXTERN_GUID(MF_TOPONODE_ERROR_MAJORTYPE, 0x494bbcfd, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 903 | cpp_quote("EXTERN_GUID(MF_TOPONODE_ERROR_SUBTYPE, 0x494bbcfe, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 904 | cpp_quote("EXTERN_GUID(MF_TOPONODE_WORKQUEUE_MMCSS_TASKID, 0x494bbcff, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 905 | cpp_quote("EXTERN_GUID(MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY, 0x5001f840, 0x2816, 0x48f4, 0x93, 0x64, 0xad, 0x1e, 0xf6, 0x61, 0xa1, 0x23);") | 
 
 
 
 
 | 906 | cpp_quote("EXTERN_GUID(MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY, 0xa1ff99be, 0x5e97, 0x4a53, 0xb4, 0x94, 0x56, 0x8c, 0x64, 0x2c, 0x0f, 0xf3);") | 
 
 
 
 
 | 907 | cpp_quote("EXTERN_GUID(MF_TOPONODE_MARKIN_HERE, 0x494bbd00, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 908 | cpp_quote("EXTERN_GUID(MF_TOPONODE_MARKOUT_HERE, 0x494bbd01, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 909 | cpp_quote("EXTERN_GUID(MF_TOPONODE_DECODER, 0x494bbd02, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc);") | 
 
 
 
 
 | 910 | cpp_quote("EXTERN_GUID(MF_TOPONODE_MEDIASTART, 0x835c58ea, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 911 | cpp_quote("EXTERN_GUID(MF_TOPONODE_MEDIASTOP, 0x835c58eb, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 912 | cpp_quote("EXTERN_GUID(MF_TOPONODE_SOURCE, 0x835c58ec, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 913 | cpp_quote("EXTERN_GUID(MF_TOPONODE_PRESENTATION_DESCRIPTOR, 0x835c58ed, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 914 | cpp_quote("EXTERN_GUID(MF_TOPONODE_STREAM_DESCRIPTOR, 0x835c58ee, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 915 | cpp_quote("EXTERN_GUID(MF_TOPONODE_SEQUENCE_ELEMENTID, 0x835c58ef, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6);") | 
 
 
 
 
 | 916 | cpp_quote("EXTERN_GUID(MF_TOPONODE_TRANSFORM_OBJECTID, 0x88dcc0c9, 0x293e, 0x4e8b, 0x9a, 0xeb, 0xa, 0xd6, 0x4c, 0xc0, 0x16, 0xb0);") | 
 
 
 
 
 | 917 | cpp_quote("EXTERN_GUID(MF_TOPONODE_STREAMID, 0x14932f9b, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04);") | 
 
 
 
 
 | 918 | cpp_quote("EXTERN_GUID(MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, 0x14932f9c, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04);") | 
 
 
 
 
 | 919 | cpp_quote("EXTERN_GUID(MF_TOPONODE_RATELESS, 0x14932f9d, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04);") | 
 
 
 
 
 | 920 | cpp_quote("EXTERN_GUID(MF_TOPONODE_DISABLE_PREROLL, 0x14932f9e, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04);") | 
 
 
 
 
 | 921 | cpp_quote("EXTERN_GUID(MF_TOPONODE_PRIMARYOUTPUT, 0x6304ef99, 0x16b2, 0x4ebe, 0x9d, 0x67, 0xe4, 0xc5, 0x39, 0xb3, 0xa2, 0x59);") | 
 
 
 
 
 | 922 |  | 
 
 
 
 
 | 923 | cpp_quote("EXTERN_GUID(MR_STREAM_VOLUME_SERVICE, 0xf8b5fa2f, 0x32ef, 0x46f5, 0xb1, 0x72, 0x13, 0x21, 0x21, 0x2f, 0xb2, 0xc4);") |