FreeRDP
Loading...
Searching...
No Matches
h264_mf.c
1
20#include <winpr/winpr.h>
21#include <winpr/library.h>
22
23#include <freerdp/log.h>
24#include <freerdp/codec/h264.h>
25
26#include <ks.h>
27#include <codecapi.h>
28
29#include <mfapi.h>
30#include <mferror.h>
31#include <wmcodecdsp.h>
32#include <mftransform.h>
33
34#include "h264.h"
35
36#define TAG FREERDP_TAG("codec")
37
38static const GUID sCLSID_CMSH264DecoderMFT = {
39 0x62CE7E72, 0x4C71, 0x4d20, { 0xB1, 0x5D, 0x45, 0x28, 0x31, 0xA8, 0x7D, 0x9D }
40};
41static const GUID sIID_IMFTransform = {
42 0xbf94c121, 0x5b05, 0x4e6f, { 0x80, 0x00, 0xba, 0x59, 0x89, 0x61, 0x41, 0x4d }
43};
44static const GUID sMF_MT_MAJOR_TYPE = {
45 0x48eba18e, 0xf8c9, 0x4687, { 0xbf, 0x11, 0x0a, 0x74, 0xc9, 0xf9, 0x6a, 0x8f }
46};
47static const GUID sMF_MT_FRAME_SIZE = {
48 0x1652c33d, 0xd6b2, 0x4012, { 0xb8, 0x34, 0x72, 0x03, 0x08, 0x49, 0xa3, 0x7d }
49};
50static const GUID sMF_MT_DEFAULT_STRIDE = {
51 0x644b4e48, 0x1e02, 0x4516, { 0xb0, 0xeb, 0xc0, 0x1c, 0xa9, 0xd4, 0x9a, 0xc6 }
52};
53static const GUID sMF_MT_SUBTYPE = {
54 0xf7e34c9a, 0x42e8, 0x4714, { 0xb7, 0x4b, 0xcb, 0x29, 0xd7, 0x2c, 0x35, 0xe5 }
55};
56static const GUID sMFMediaType_Video = {
57 0x73646976, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71 }
58};
59static const GUID sMFVideoFormat_H264 = {
60 0x34363248, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
61};
62static const GUID sMFVideoFormat_IYUV = {
63 0x56555949, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
64};
65static const GUID sIID_ICodecAPI = {
66 0x901db4c7, 0x31ce, 0x41a2, { 0x85, 0xdc, 0x8f, 0xa0, 0xbf, 0x41, 0xb8, 0xda }
67};
68static const GUID sCODECAPI_AVLowLatencyMode = {
69 0x9c27891a, 0xed7a, 0x40e1, { 0x88, 0xe8, 0xb2, 0x27, 0x27, 0xa0, 0x24, 0xee }
70};
71
72typedef HRESULT(__stdcall* pfnMFStartup)(ULONG Version, DWORD dwFlags);
73typedef HRESULT(__stdcall* pfnMFShutdown)(void);
74typedef HRESULT(__stdcall* pfnMFCreateSample)(IMFSample** ppIMFSample);
75typedef HRESULT(__stdcall* pfnMFCreateMemoryBuffer)(DWORD cbMaxLength, IMFMediaBuffer** ppBuffer);
76typedef HRESULT(__stdcall* pfnMFCreateMediaType)(IMFMediaType** ppMFType);
77
78typedef struct
79{
80 ICodecAPI* codecApi;
81 IMFTransform* transform;
82 IMFMediaType* inputType;
83 IMFMediaType* outputType;
84 IMFSample* sample;
85 UINT32 frameWidth;
86 UINT32 frameHeight;
87 IMFSample* outputSample;
88 IMFMediaBuffer* outputBuffer;
89 HMODULE mfplat;
90 pfnMFStartup MFStartup;
91 pfnMFShutdown MFShutdown;
92 pfnMFCreateSample MFCreateSample;
93 pfnMFCreateMemoryBuffer MFCreateMemoryBuffer;
94 pfnMFCreateMediaType MFCreateMediaType;
95 UINT32 stride;
96 BOOL bottomUp;
97} H264_CONTEXT_MF;
98
99static HRESULT mf_find_output_type(H264_CONTEXT_MF* sys, const GUID* guid,
100 IMFMediaType** ppMediaType)
101{
102 DWORD idx = 0;
103 GUID mediaGuid;
104 HRESULT hr = S_OK;
105 IMFMediaType* pMediaType = nullptr;
106
107 while (1)
108 {
109 hr = sys->transform->lpVtbl->GetOutputAvailableType(sys->transform, 0, idx, &pMediaType);
110
111 if (FAILED(hr))
112 break;
113
114 pMediaType->lpVtbl->GetGUID(pMediaType, &sMF_MT_SUBTYPE, &mediaGuid);
115
116 if (IsEqualGUID(&mediaGuid, guid))
117 {
118 *ppMediaType = pMediaType;
119 return S_OK;
120 }
121
122 pMediaType->lpVtbl->Release(pMediaType);
123 idx++;
124 }
125
126 return hr;
127}
128
129static HRESULT mf_create_output_sample(H264_CONTEXT* h264, H264_CONTEXT_MF* sys)
130{
131 HRESULT hr = S_OK;
132 MFT_OUTPUT_STREAM_INFO streamInfo;
133
134 if (sys->outputSample)
135 {
136 sys->outputSample->lpVtbl->Release(sys->outputSample);
137 sys->outputSample = nullptr;
138 }
139
140 hr = sys->MFCreateSample(&sys->outputSample);
141
142 if (FAILED(hr))
143 {
144 WLog_Print(h264->log, WLOG_ERROR, "MFCreateSample failure: 0x%08" PRIX32 "", hr);
145 goto error;
146 }
147
148 hr = sys->transform->lpVtbl->GetOutputStreamInfo(sys->transform, 0, &streamInfo);
149
150 if (FAILED(hr))
151 {
152 WLog_Print(h264->log, WLOG_ERROR, "GetOutputStreamInfo failure: 0x%08" PRIX32 "", hr);
153 goto error;
154 }
155
156 hr = sys->MFCreateMemoryBuffer(streamInfo.cbSize, &sys->outputBuffer);
157
158 if (FAILED(hr))
159 {
160 WLog_Print(h264->log, WLOG_ERROR, "MFCreateMemoryBuffer failure: 0x%08" PRIX32 "", hr);
161 goto error;
162 }
163
164 hr = sys->outputSample->lpVtbl->AddBuffer(sys->outputSample, sys->outputBuffer);
165
166 if (FAILED(hr))
167 {
168 WLog_Print(h264->log, WLOG_ERROR, "AddBuffer failure: 0x%08" PRIX32 "", hr);
169 goto error;
170 }
171
172 sys->outputBuffer->lpVtbl->Release(sys->outputBuffer);
173error:
174 return hr;
175}
176
177WINPR_ATTR_NODISCARD
178static UINT32 getSrcOffset(H264_CONTEXT_MF* sys, UINT32 line, BOOL isUV)
179{
180 WINPR_ASSERT(sys);
181
182 if (sys->frameHeight < 1)
183 return 0;
184 if (line >= sys->frameHeight)
185 return 0;
186
187 UINT64 offset = (sys->frameHeight - line - 1u);
188 if (!sys->bottomUp)
189 offset = line;
190
191 offset *= sys->stride;
192 if (isUV)
193 offset /= 2u;
194 return WINPR_ASSERTING_INT_CAST(UINT32, offset);
195}
196
197static int mf_decompress(H264_CONTEXT* WINPR_RESTRICT h264, const BYTE* WINPR_RESTRICT pSrcData,
198 UINT32 SrcSize)
199{
200 BYTE* pbBuffer = nullptr;
201 DWORD cbMaxLength = 0;
202 DWORD cbCurrentLength = 0;
203 DWORD outputStatus = 0;
204 IMFSample* inputSample = nullptr;
205 IMFMediaBuffer* inputBuffer = nullptr;
206 IMFMediaBuffer* outputBuffer = nullptr;
207 MFT_OUTPUT_DATA_BUFFER outputDataBuffer = WINPR_C_ARRAY_INIT;
208
209 WINPR_ASSERT(h264);
210
211 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
212 UINT32* iStride = h264->iStride;
213 BYTE** pYUVData = h264->pYUVData;
214 HRESULT hr = sys->MFCreateMemoryBuffer(SrcSize, &inputBuffer);
215
216 if (FAILED(hr))
217 {
218 WLog_Print(h264->log, WLOG_ERROR, "MFCreateMemoryBuffer failure: 0x%08" PRIX32 "", hr);
219 goto error;
220 }
221
222 hr = inputBuffer->lpVtbl->Lock(inputBuffer, &pbBuffer, &cbMaxLength, &cbCurrentLength);
223
224 if (FAILED(hr))
225 {
226 WLog_Print(h264->log, WLOG_ERROR, "Lock failure: 0x%08" PRIX32 "", hr);
227 goto error;
228 }
229
230 CopyMemory(pbBuffer, pSrcData, SrcSize);
231 hr = inputBuffer->lpVtbl->SetCurrentLength(inputBuffer, SrcSize);
232
233 if (FAILED(hr))
234 {
235 WLog_Print(h264->log, WLOG_ERROR, "SetCurrentLength failure: 0x%08" PRIX32 "", hr);
236 goto error;
237 }
238
239 hr = inputBuffer->lpVtbl->Unlock(inputBuffer);
240
241 if (FAILED(hr))
242 {
243 WLog_Print(h264->log, WLOG_ERROR, "Unlock failure: 0x%08" PRIX32 "", hr);
244 goto error;
245 }
246
247 hr = sys->MFCreateSample(&inputSample);
248
249 if (FAILED(hr))
250 {
251 WLog_Print(h264->log, WLOG_ERROR, "MFCreateSample failure: 0x%08" PRIX32 "", hr);
252 goto error;
253 }
254
255 hr = inputSample->lpVtbl->AddBuffer(inputSample, inputBuffer);
256
257 if (FAILED(hr))
258 {
259 WLog_Print(h264->log, WLOG_ERROR, "AddBuffer failure: 0x%08" PRIX32 "", hr);
260 goto error;
261 }
262
263 inputBuffer->lpVtbl->Release(inputBuffer);
264 hr = sys->transform->lpVtbl->ProcessInput(sys->transform, 0, inputSample, 0);
265
266 if (FAILED(hr))
267 {
268 WLog_Print(h264->log, WLOG_ERROR, "ProcessInput failure: 0x%08" PRIX32 "", hr);
269 goto error;
270 }
271
272 hr = mf_create_output_sample(h264, sys);
273
274 if (FAILED(hr))
275 {
276 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "", hr);
277 goto error;
278 }
279
280 outputDataBuffer.dwStreamID = 0;
281 outputDataBuffer.dwStatus = 0;
282 outputDataBuffer.pEvents = nullptr;
283 outputDataBuffer.pSample = sys->outputSample;
284 hr = sys->transform->lpVtbl->ProcessOutput(sys->transform, 0, 1, &outputDataBuffer,
285 &outputStatus);
286
287 if (hr == MF_E_TRANSFORM_STREAM_CHANGE)
288 {
289 UINT64 frameSize = 0;
290
291 if (sys->outputType)
292 {
293 sys->outputType->lpVtbl->Release(sys->outputType);
294 sys->outputType = nullptr;
295 }
296
297 hr = mf_find_output_type(sys, &sMFVideoFormat_IYUV, &sys->outputType);
298
299 if (FAILED(hr))
300 {
301 WLog_Print(h264->log, WLOG_ERROR, "mf_find_output_type failure: 0x%08" PRIX32 "", hr);
302 goto error;
303 }
304
305 hr = sys->transform->lpVtbl->SetOutputType(sys->transform, 0, sys->outputType, 0);
306
307 if (FAILED(hr))
308 {
309 WLog_Print(h264->log, WLOG_ERROR, "SetOutputType failure: 0x%08" PRIX32 "", hr);
310 goto error;
311 }
312
313 hr = mf_create_output_sample(h264, sys);
314
315 if (FAILED(hr))
316 {
317 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "",
318 hr);
319 goto error;
320 }
321
322 hr = sys->outputType->lpVtbl->GetUINT64(sys->outputType, &sMF_MT_FRAME_SIZE, &frameSize);
323
324 if (FAILED(hr))
325 {
326 WLog_Print(h264->log, WLOG_ERROR,
327 "GetUINT64(MF_MT_FRAME_SIZE) failure: 0x%08" PRIX32 "", hr);
328 goto error;
329 }
330
331 sys->frameWidth = (UINT32)(frameSize >> 32);
332 sys->frameHeight = (UINT32)frameSize;
333 hr = sys->outputType->lpVtbl->GetUINT32(sys->outputType, &sMF_MT_DEFAULT_STRIDE,
334 &sys->stride);
335
336 if (FAILED(hr))
337 {
338 WLog_Print(h264->log, WLOG_ERROR,
339 "GetUINT32(MF_MT_DEFAULT_STRIDE) failure: 0x%08" PRIX32 "", hr);
340 goto error;
341 }
342
343 const INT32 istride = (INT32)sys->stride;
344 if (istride < 0)
345 {
346 sys->bottomUp = TRUE;
347 sys->stride = istride * -1;
348 }
349
350 if (!avc420_ensure_buffer(h264, sys->stride, sys->frameWidth, sys->frameHeight))
351 goto error;
352 }
353 else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
354 {
355 }
356 else if (FAILED(hr))
357 {
358 WLog_Print(h264->log, WLOG_ERROR, "ProcessOutput failure: 0x%08" PRIX32 "", hr);
359 goto error;
360 }
361 else
362 {
363 int offset = 0;
364 BYTE* buffer = nullptr;
365 DWORD bufferCount = 0;
366 DWORD cbMaxLength = 0;
367 DWORD cbCurrentLength = 0;
368 hr = sys->outputSample->lpVtbl->GetBufferCount(sys->outputSample, &bufferCount);
369
370 if (FAILED(hr))
371 {
372 WLog_Print(h264->log, WLOG_ERROR, "GetBufferCount failure: 0x%08" PRIX32 "", hr);
373 goto error;
374 }
375
376 hr = sys->outputSample->lpVtbl->GetBufferByIndex(sys->outputSample, 0, &outputBuffer);
377
378 if (FAILED(hr))
379 {
380 WLog_Print(h264->log, WLOG_ERROR, "GetBufferByIndex failure: 0x%08" PRIX32 "", hr);
381 goto error;
382 }
383
384 hr = outputBuffer->lpVtbl->Lock(outputBuffer, &buffer, &cbMaxLength, &cbCurrentLength);
385
386 if (FAILED(hr))
387 {
388 WLog_Print(h264->log, WLOG_ERROR, "Lock failure: 0x%08" PRIX32 "", hr);
389 goto error;
390 }
391
392 /* Copy data from decoder buffer to our YUV buffer.
393 * strides differ (the YUV buffer is always larger) so copy only data available from the
394 * decoder buffer but increment the YUV buffer with the YUV buffer strides.
395 */
396 for (UINT32 x = 0; x < sys->frameHeight; x++)
397 {
398 const UINT32 srcOffset = getSrcOffset(sys, x, FALSE);
399 const UINT32 dstOffset = (UINT32)iStride[0] * x;
400 CopyMemory(&pYUVData[0][dstOffset], &buffer[srcOffset], sys->stride);
401 }
402 for (UINT32 x = 0; x < sys->frameHeight / 2; x++)
403 {
404 const UINT32 srcOffset = getSrcOffset(sys, x, TRUE);
405 const UINT32 dstUOffset = (UINT32)iStride[1] * x;
406 const UINT32 dstVOffset = (UINT32)iStride[2] * x;
407 CopyMemory(&pYUVData[1][dstUOffset], &buffer[srcOffset], sys->stride / 2u);
408 CopyMemory(&pYUVData[2][dstVOffset], &buffer[srcOffset], sys->stride / 2u);
409 }
410
411 hr = outputBuffer->lpVtbl->Unlock(outputBuffer);
412
413 if (FAILED(hr))
414 {
415 WLog_Print(h264->log, WLOG_ERROR, "Unlock failure: 0x%08" PRIX32 "", hr);
416 goto error;
417 }
418
419 outputBuffer->lpVtbl->Release(outputBuffer);
420 h264->YUVWidth = sys->frameWidth;
421 h264->YUVHeight = sys->frameHeight;
422 }
423
424 inputSample->lpVtbl->Release(inputSample);
425 return 1;
426error:
427 WLog_Print(h264->log, WLOG_ERROR, "decompression failed");
428 return -1;
429}
430
431static int mf_compress(H264_CONTEXT* WINPR_RESTRICT h264, const BYTE** WINPR_RESTRICT ppSrcYuv,
432 const UINT32* WINPR_RESTRICT pStride, BYTE** WINPR_RESTRICT ppDstData,
433 UINT32* WINPR_RESTRICT pDstSize)
434{
435 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
436 WLog_Print(h264->log, WLOG_ERROR, "TODO: compression not implemented");
437 return -1;
438}
439
440static BOOL mf_plat_loaded(H264_CONTEXT_MF* sys)
441{
442 return sys->MFStartup && sys->MFShutdown && sys->MFCreateSample && sys->MFCreateMemoryBuffer &&
443 sys->MFCreateMediaType;
444}
445
446static void mf_uninit(H264_CONTEXT* h264)
447{
448 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
449
450 if (sys)
451 {
452 if (sys->transform)
453 {
454 sys->transform->lpVtbl->Release(sys->transform);
455 sys->transform = nullptr;
456 }
457
458 if (sys->codecApi)
459 {
460 sys->codecApi->lpVtbl->Release(sys->codecApi);
461 sys->codecApi = nullptr;
462 }
463
464 if (sys->inputType)
465 {
466 sys->inputType->lpVtbl->Release(sys->inputType);
467 sys->inputType = nullptr;
468 }
469
470 if (sys->outputType)
471 {
472 sys->outputType->lpVtbl->Release(sys->outputType);
473 sys->outputType = nullptr;
474 }
475
476 if (sys->outputSample)
477 {
478 sys->outputSample->lpVtbl->Release(sys->outputSample);
479 sys->outputSample = nullptr;
480 }
481
482 if (sys->mfplat)
483 {
484 if (mf_plat_loaded(sys))
485 sys->MFShutdown();
486
487 FreeLibrary(sys->mfplat);
488 sys->mfplat = nullptr;
489
490 if (mf_plat_loaded(sys))
491 CoUninitialize();
492 }
493
494 for (size_t x = 0; x < sizeof(h264->pYUVData) / sizeof(h264->pYUVData[0]); x++)
495 winpr_aligned_free(h264->pYUVData[x]);
496
497 memset(h264->pYUVData, 0, sizeof(h264->pYUVData));
498 memset(h264->iStride, 0, sizeof(h264->iStride));
499
500 free(sys);
501 h264->pSystemData = nullptr;
502 }
503}
504
505static BOOL mf_init(H264_CONTEXT* h264)
506{
507 HRESULT hr;
508 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)calloc(1, sizeof(H264_CONTEXT_MF));
509
510 if (!sys)
511 goto error;
512
513 h264->pSystemData = (void*)sys;
514 /* http://decklink-sdk-delphi.googlecode.com/svn/trunk/Blackmagic%20DeckLink%20SDK%209.7/Win/Samples/Streaming/StreamingPreview/DecoderMF.cpp
515 */
516 sys->mfplat = LoadLibraryA("mfplat.dll");
517
518 if (!sys->mfplat)
519 goto error;
520
521 sys->MFStartup = GetProcAddressAs(sys->mfplat, "MFStartup", pfnMFStartup);
522 sys->MFShutdown = GetProcAddressAs(sys->mfplat, "MFShutdown", pfnMFShutdown);
523 sys->MFCreateSample = GetProcAddressAs(sys->mfplat, "MFCreateSample", pfnMFCreateSample);
524 sys->MFCreateMemoryBuffer =
525 GetProcAddressAs(sys->mfplat, "MFCreateMemoryBuffer", pfnMFCreateMemoryBuffer);
526 sys->MFCreateMediaType =
527 GetProcAddressAs(sys->mfplat, "MFCreateMediaType", pfnMFCreateMediaType);
528
529 if (!mf_plat_loaded(sys))
530 goto error;
531
532 CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
533
534 if (h264->Compressor)
535 {
536 }
537 else
538 {
539 VARIANT var = WINPR_C_ARRAY_INIT;
540 hr = sys->MFStartup(MF_VERSION, 0);
541
542 if (FAILED(hr))
543 {
544 WLog_Print(h264->log, WLOG_ERROR, "MFStartup failure: 0x%08" PRIX32 "", hr);
545 goto error;
546 }
547
548 hr = CoCreateInstance(&sCLSID_CMSH264DecoderMFT, nullptr, CLSCTX_INPROC_SERVER,
549 &sIID_IMFTransform, (void**)&sys->transform);
550
551 if (FAILED(hr))
552 {
553 WLog_Print(h264->log, WLOG_ERROR,
554 "CoCreateInstance(CLSID_CMSH264DecoderMFT) failure: 0x%08" PRIX32 "", hr);
555 goto error;
556 }
557
558 hr = sys->transform->lpVtbl->QueryInterface(sys->transform, &sIID_ICodecAPI,
559 (void**)&sys->codecApi);
560
561 if (FAILED(hr))
562 {
563 WLog_Print(h264->log, WLOG_ERROR,
564 "QueryInterface(IID_ICodecAPI) failure: 0x%08" PRIX32 "", hr);
565 goto error;
566 }
567
568 var.n1.n2.vt = VT_UI4;
569 var.n1.n2.n3.ulVal = 1;
570 hr = sys->codecApi->lpVtbl->SetValue(sys->codecApi, &sCODECAPI_AVLowLatencyMode, &var);
571
572 if (FAILED(hr))
573 {
574 WLog_Print(h264->log, WLOG_ERROR,
575 "SetValue(CODECAPI_AVLowLatencyMode) failure: 0x%08" PRIX32 "", hr);
576 goto error;
577 }
578
579 hr = sys->MFCreateMediaType(&sys->inputType);
580
581 if (FAILED(hr))
582 {
583 WLog_Print(h264->log, WLOG_ERROR, "MFCreateMediaType failure: 0x%08" PRIX32 "", hr);
584 goto error;
585 }
586
587 hr = sys->inputType->lpVtbl->SetGUID(sys->inputType, &sMF_MT_MAJOR_TYPE,
588 &sMFMediaType_Video);
589
590 if (FAILED(hr))
591 {
592 WLog_Print(h264->log, WLOG_ERROR, "SetGUID(MF_MT_MAJOR_TYPE) failure: 0x%08" PRIX32 "",
593 hr);
594 goto error;
595 }
596
597 hr = sys->inputType->lpVtbl->SetGUID(sys->inputType, &sMF_MT_SUBTYPE, &sMFVideoFormat_H264);
598
599 if (FAILED(hr))
600 {
601 WLog_Print(h264->log, WLOG_ERROR, "SetGUID(MF_MT_SUBTYPE) failure: 0x%08" PRIX32 "",
602 hr);
603 goto error;
604 }
605
606 hr = sys->transform->lpVtbl->SetInputType(sys->transform, 0, sys->inputType, 0);
607
608 if (FAILED(hr))
609 {
610 WLog_Print(h264->log, WLOG_ERROR, "SetInputType failure: 0x%08" PRIX32 "", hr);
611 goto error;
612 }
613
614 hr = mf_find_output_type(sys, &sMFVideoFormat_IYUV, &sys->outputType);
615
616 if (FAILED(hr))
617 {
618 WLog_Print(h264->log, WLOG_ERROR, "mf_find_output_type failure: 0x%08" PRIX32 "", hr);
619 goto error;
620 }
621
622 hr = sys->transform->lpVtbl->SetOutputType(sys->transform, 0, sys->outputType, 0);
623
624 if (FAILED(hr))
625 {
626 WLog_Print(h264->log, WLOG_ERROR, "SetOutputType failure: 0x%08" PRIX32 "", hr);
627 goto error;
628 }
629
630 hr = mf_create_output_sample(h264, sys);
631
632 if (FAILED(hr))
633 {
634 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "",
635 hr);
636 goto error;
637 }
638 }
639
640 return TRUE;
641error:
642 WLog_Print(h264->log, WLOG_ERROR, "mf_init failure");
643 mf_uninit(h264);
644 return FALSE;
645}
646
647const H264_CONTEXT_SUBSYSTEM g_Subsystem_MF = { "MediaFoundation", mf_init, mf_uninit,
648 mf_decompress, mf_compress };