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
177/* IYUV output: full size Y plane followed by the quarter size U and V planes */
178WINPR_ATTR_NODISCARD
179static size_t getSrcOffset(const H264_CONTEXT_MF* sys, UINT32 line, size_t plane)
180{
181 WINPR_ASSERT(sys);
182
183 const size_t stride = (plane == 0) ? sys->stride : sys->stride / 2u;
184 const size_t height = (plane == 0) ? sys->frameHeight : sys->frameHeight / 2u;
185 size_t offset = 0;
186 if (plane > 0)
187 offset += (size_t)sys->stride * sys->frameHeight;
188 if (plane > 1)
189 offset += stride * height;
190
191 WINPR_ASSERT(line < height);
192 const size_t row = sys->bottomUp ? height - line - 1u : line;
193 return offset + row * stride;
194}
195
196static HRESULT mf_process_output(H264_CONTEXT_MF* sys)
197{
198 DWORD status = 0;
199 MFT_OUTPUT_DATA_BUFFER buffer = WINPR_C_ARRAY_INIT;
200
201 buffer.pSample = sys->outputSample;
202 const HRESULT hr =
203 sys->transform->lpVtbl->ProcessOutput(sys->transform, 0, 1, &buffer, &status);
204 if (buffer.pEvents)
205 buffer.pEvents->lpVtbl->Release(buffer.pEvents);
206 return hr;
207}
208
209static int mf_decompress(H264_CONTEXT* WINPR_RESTRICT h264, const BYTE* WINPR_RESTRICT pSrcData,
210 UINT32 SrcSize)
211{
212 int rc = -1;
213 BYTE* pbBuffer = nullptr;
214 DWORD cbMaxLength = 0;
215 DWORD cbCurrentLength = 0;
216 IMFSample* inputSample = nullptr;
217 IMFMediaBuffer* inputBuffer = nullptr;
218 IMFMediaBuffer* outputBuffer = nullptr;
219
220 WINPR_ASSERT(h264);
221
222 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
223 UINT32* iStride = h264->iStride;
224 BYTE** pYUVData = h264->pYUVData;
225 HRESULT hr = sys->MFCreateMemoryBuffer(SrcSize, &inputBuffer);
226
227 if (FAILED(hr))
228 {
229 WLog_Print(h264->log, WLOG_ERROR, "MFCreateMemoryBuffer failure: 0x%08" PRIX32 "", hr);
230 goto error;
231 }
232
233 hr = inputBuffer->lpVtbl->Lock(inputBuffer, &pbBuffer, &cbMaxLength, &cbCurrentLength);
234
235 if (FAILED(hr))
236 {
237 WLog_Print(h264->log, WLOG_ERROR, "Lock failure: 0x%08" PRIX32 "", hr);
238 goto error;
239 }
240
241 CopyMemory(pbBuffer, pSrcData, SrcSize);
242 hr = inputBuffer->lpVtbl->SetCurrentLength(inputBuffer, SrcSize);
243
244 if (FAILED(hr))
245 {
246 WLog_Print(h264->log, WLOG_ERROR, "SetCurrentLength failure: 0x%08" PRIX32 "", hr);
247 goto error;
248 }
249
250 hr = inputBuffer->lpVtbl->Unlock(inputBuffer);
251
252 if (FAILED(hr))
253 {
254 WLog_Print(h264->log, WLOG_ERROR, "Unlock failure: 0x%08" PRIX32 "", hr);
255 goto error;
256 }
257
258 hr = sys->MFCreateSample(&inputSample);
259
260 if (FAILED(hr))
261 {
262 WLog_Print(h264->log, WLOG_ERROR, "MFCreateSample failure: 0x%08" PRIX32 "", hr);
263 goto error;
264 }
265
266 hr = inputSample->lpVtbl->AddBuffer(inputSample, inputBuffer);
267
268 if (FAILED(hr))
269 {
270 WLog_Print(h264->log, WLOG_ERROR, "AddBuffer failure: 0x%08" PRIX32 "", hr);
271 goto error;
272 }
273
274 hr = sys->transform->lpVtbl->ProcessInput(sys->transform, 0, inputSample, 0);
275
276 if (FAILED(hr))
277 {
278 WLog_Print(h264->log, WLOG_ERROR, "ProcessInput failure: 0x%08" PRIX32 "", hr);
279 goto error;
280 }
281
282 hr = mf_create_output_sample(h264, sys);
283
284 if (FAILED(hr))
285 {
286 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "", hr);
287 goto error;
288 }
289
290 hr = mf_process_output(sys);
291
292 if (hr == MF_E_TRANSFORM_STREAM_CHANGE)
293 {
294 UINT64 frameSize = 0;
295
296 if (sys->outputType)
297 {
298 sys->outputType->lpVtbl->Release(sys->outputType);
299 sys->outputType = nullptr;
300 }
301
302 hr = mf_find_output_type(sys, &sMFVideoFormat_IYUV, &sys->outputType);
303
304 if (FAILED(hr))
305 {
306 WLog_Print(h264->log, WLOG_ERROR, "mf_find_output_type failure: 0x%08" PRIX32 "", hr);
307 goto error;
308 }
309
310 hr = sys->transform->lpVtbl->SetOutputType(sys->transform, 0, sys->outputType, 0);
311
312 if (FAILED(hr))
313 {
314 WLog_Print(h264->log, WLOG_ERROR, "SetOutputType failure: 0x%08" PRIX32 "", hr);
315 goto error;
316 }
317
318 hr = mf_create_output_sample(h264, sys);
319
320 if (FAILED(hr))
321 {
322 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "",
323 hr);
324 goto error;
325 }
326
327 hr = sys->outputType->lpVtbl->GetUINT64(sys->outputType, &sMF_MT_FRAME_SIZE, &frameSize);
328
329 if (FAILED(hr))
330 {
331 WLog_Print(h264->log, WLOG_ERROR,
332 "GetUINT64(MF_MT_FRAME_SIZE) failure: 0x%08" PRIX32 "", hr);
333 goto error;
334 }
335
336 sys->frameWidth = (UINT32)(frameSize >> 32);
337 sys->frameHeight = (UINT32)frameSize;
338 hr = sys->outputType->lpVtbl->GetUINT32(sys->outputType, &sMF_MT_DEFAULT_STRIDE,
339 &sys->stride);
340
341 if (FAILED(hr))
342 {
343 WLog_Print(h264->log, WLOG_ERROR,
344 "GetUINT32(MF_MT_DEFAULT_STRIDE) failure: 0x%08" PRIX32 "", hr);
345 goto error;
346 }
347
348 const INT32 istride = (INT32)sys->stride;
349 sys->bottomUp = (istride < 0);
350 if (sys->bottomUp)
351 sys->stride = istride * -1;
352
353 if (!avc420_ensure_buffer(h264, sys->stride, sys->frameWidth, sys->frameHeight))
354 goto error;
355
356 /* the decoder still holds the frame, fetch it with the new output type */
357 hr = mf_process_output(sys);
358 }
359
360 if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
361 rc = 0;
362 else if (FAILED(hr))
363 {
364 WLog_Print(h264->log, WLOG_ERROR, "ProcessOutput failure: 0x%08" PRIX32 "", hr);
365 goto error;
366 }
367 else
368 {
369 BYTE* buffer = nullptr;
370 DWORD bufferCount = 0;
371 DWORD cbMaxLength = 0;
372 DWORD cbCurrentLength = 0;
373 hr = sys->outputSample->lpVtbl->GetBufferCount(sys->outputSample, &bufferCount);
374
375 if (FAILED(hr))
376 {
377 WLog_Print(h264->log, WLOG_ERROR, "GetBufferCount failure: 0x%08" PRIX32 "", hr);
378 goto error;
379 }
380
381 hr = sys->outputSample->lpVtbl->GetBufferByIndex(sys->outputSample, 0, &outputBuffer);
382
383 if (FAILED(hr))
384 {
385 WLog_Print(h264->log, WLOG_ERROR, "GetBufferByIndex failure: 0x%08" PRIX32 "", hr);
386 goto error;
387 }
388
389 hr = outputBuffer->lpVtbl->Lock(outputBuffer, &buffer, &cbMaxLength, &cbCurrentLength);
390
391 if (FAILED(hr))
392 {
393 WLog_Print(h264->log, WLOG_ERROR, "Lock failure: 0x%08" PRIX32 "", hr);
394 goto error;
395 }
396
397 if ((sys->stride == 0) || (cbCurrentLength / 3u / sys->stride < sys->frameHeight / 2u))
398 {
399 WLog_Print(h264->log, WLOG_ERROR, "output buffer too small: %" PRIu32 "",
400 cbCurrentLength);
401 (void)outputBuffer->lpVtbl->Unlock(outputBuffer);
402 goto error;
403 }
404
405 /* Copy data from decoder buffer to our YUV buffer.
406 * strides differ (the YUV buffer is always larger) so copy only data available from the
407 * decoder buffer but increment the YUV buffer with the YUV buffer strides.
408 */
409 for (UINT32 x = 0; x < sys->frameHeight; x++)
410 {
411 const size_t srcOffset = getSrcOffset(sys, x, 0);
412 const UINT32 dstOffset = (UINT32)iStride[0] * x;
413 CopyMemory(&pYUVData[0][dstOffset], &buffer[srcOffset], sys->stride);
414 }
415 for (UINT32 x = 0; x < sys->frameHeight / 2; x++)
416 {
417 const size_t srcUOffset = getSrcOffset(sys, x, 1);
418 const size_t srcVOffset = getSrcOffset(sys, x, 2);
419 const UINT32 dstUOffset = (UINT32)iStride[1] * x;
420 const UINT32 dstVOffset = (UINT32)iStride[2] * x;
421 CopyMemory(&pYUVData[1][dstUOffset], &buffer[srcUOffset], sys->stride / 2u);
422 CopyMemory(&pYUVData[2][dstVOffset], &buffer[srcVOffset], sys->stride / 2u);
423 }
424
425 hr = outputBuffer->lpVtbl->Unlock(outputBuffer);
426
427 if (FAILED(hr))
428 {
429 WLog_Print(h264->log, WLOG_ERROR, "Unlock failure: 0x%08" PRIX32 "", hr);
430 goto error;
431 }
432
433 h264->YUVWidth = sys->frameWidth;
434 h264->YUVHeight = sys->frameHeight;
435 rc = 1;
436 }
437
438error:
439 if (outputBuffer)
440 outputBuffer->lpVtbl->Release(outputBuffer);
441 if (inputSample)
442 inputSample->lpVtbl->Release(inputSample);
443 if (inputBuffer)
444 inputBuffer->lpVtbl->Release(inputBuffer);
445 if (rc < 0)
446 WLog_Print(h264->log, WLOG_ERROR, "decompression failed");
447 return rc;
448}
449
450static int mf_compress(H264_CONTEXT* WINPR_RESTRICT h264, const BYTE** WINPR_RESTRICT ppSrcYuv,
451 const UINT32* WINPR_RESTRICT pStride, BYTE** WINPR_RESTRICT ppDstData,
452 UINT32* WINPR_RESTRICT pDstSize)
453{
454 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
455 WLog_Print(h264->log, WLOG_ERROR, "TODO: compression not implemented");
456 return -1;
457}
458
459static BOOL mf_plat_loaded(H264_CONTEXT_MF* sys)
460{
461 return sys->MFStartup && sys->MFShutdown && sys->MFCreateSample && sys->MFCreateMemoryBuffer &&
462 sys->MFCreateMediaType;
463}
464
465static void mf_uninit(H264_CONTEXT* h264)
466{
467 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)h264->pSystemData;
468
469 if (sys)
470 {
471 if (sys->transform)
472 {
473 sys->transform->lpVtbl->Release(sys->transform);
474 sys->transform = nullptr;
475 }
476
477 if (sys->codecApi)
478 {
479 sys->codecApi->lpVtbl->Release(sys->codecApi);
480 sys->codecApi = nullptr;
481 }
482
483 if (sys->inputType)
484 {
485 sys->inputType->lpVtbl->Release(sys->inputType);
486 sys->inputType = nullptr;
487 }
488
489 if (sys->outputType)
490 {
491 sys->outputType->lpVtbl->Release(sys->outputType);
492 sys->outputType = nullptr;
493 }
494
495 if (sys->outputSample)
496 {
497 sys->outputSample->lpVtbl->Release(sys->outputSample);
498 sys->outputSample = nullptr;
499 }
500
501 if (sys->mfplat)
502 {
503 if (mf_plat_loaded(sys))
504 sys->MFShutdown();
505
506 FreeLibrary(sys->mfplat);
507 sys->mfplat = nullptr;
508
509 if (mf_plat_loaded(sys))
510 CoUninitialize();
511 }
512
513 for (size_t x = 0; x < sizeof(h264->pYUVData) / sizeof(h264->pYUVData[0]); x++)
514 winpr_aligned_free(h264->pYUVData[x]);
515
516 memset(h264->pYUVData, 0, sizeof(h264->pYUVData));
517 memset(h264->iStride, 0, sizeof(h264->iStride));
518
519 free(sys);
520 h264->pSystemData = nullptr;
521 }
522}
523
524static BOOL mf_init(H264_CONTEXT* h264)
525{
526 HRESULT hr;
527 H264_CONTEXT_MF* sys = (H264_CONTEXT_MF*)calloc(1, sizeof(H264_CONTEXT_MF));
528
529 if (!sys)
530 goto error;
531
532 h264->pSystemData = (void*)sys;
533 /* http://decklink-sdk-delphi.googlecode.com/svn/trunk/Blackmagic%20DeckLink%20SDK%209.7/Win/Samples/Streaming/StreamingPreview/DecoderMF.cpp
534 */
535 sys->mfplat = LoadLibraryA("mfplat.dll");
536
537 if (!sys->mfplat)
538 goto error;
539
540 sys->MFStartup = GetProcAddressAs(sys->mfplat, "MFStartup", pfnMFStartup);
541 sys->MFShutdown = GetProcAddressAs(sys->mfplat, "MFShutdown", pfnMFShutdown);
542 sys->MFCreateSample = GetProcAddressAs(sys->mfplat, "MFCreateSample", pfnMFCreateSample);
543 sys->MFCreateMemoryBuffer =
544 GetProcAddressAs(sys->mfplat, "MFCreateMemoryBuffer", pfnMFCreateMemoryBuffer);
545 sys->MFCreateMediaType =
546 GetProcAddressAs(sys->mfplat, "MFCreateMediaType", pfnMFCreateMediaType);
547
548 if (!mf_plat_loaded(sys))
549 goto error;
550
551 CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
552
553 if (h264->Compressor)
554 {
555 }
556 else
557 {
558 VARIANT var = WINPR_C_ARRAY_INIT;
559 hr = sys->MFStartup(MF_VERSION, 0);
560
561 if (FAILED(hr))
562 {
563 WLog_Print(h264->log, WLOG_ERROR, "MFStartup failure: 0x%08" PRIX32 "", hr);
564 goto error;
565 }
566
567 hr = CoCreateInstance(&sCLSID_CMSH264DecoderMFT, nullptr, CLSCTX_INPROC_SERVER,
568 &sIID_IMFTransform, (void**)&sys->transform);
569
570 if (FAILED(hr))
571 {
572 WLog_Print(h264->log, WLOG_ERROR,
573 "CoCreateInstance(CLSID_CMSH264DecoderMFT) failure: 0x%08" PRIX32 "", hr);
574 goto error;
575 }
576
577 hr = sys->transform->lpVtbl->QueryInterface(sys->transform, &sIID_ICodecAPI,
578 (void**)&sys->codecApi);
579
580 if (FAILED(hr))
581 {
582 WLog_Print(h264->log, WLOG_ERROR,
583 "QueryInterface(IID_ICodecAPI) failure: 0x%08" PRIX32 "", hr);
584 goto error;
585 }
586
587 var.n1.n2.vt = VT_UI4;
588 var.n1.n2.n3.ulVal = 1;
589 hr = sys->codecApi->lpVtbl->SetValue(sys->codecApi, &sCODECAPI_AVLowLatencyMode, &var);
590
591 if (FAILED(hr))
592 {
593 WLog_Print(h264->log, WLOG_ERROR,
594 "SetValue(CODECAPI_AVLowLatencyMode) failure: 0x%08" PRIX32 "", hr);
595 goto error;
596 }
597
598 hr = sys->MFCreateMediaType(&sys->inputType);
599
600 if (FAILED(hr))
601 {
602 WLog_Print(h264->log, WLOG_ERROR, "MFCreateMediaType failure: 0x%08" PRIX32 "", hr);
603 goto error;
604 }
605
606 hr = sys->inputType->lpVtbl->SetGUID(sys->inputType, &sMF_MT_MAJOR_TYPE,
607 &sMFMediaType_Video);
608
609 if (FAILED(hr))
610 {
611 WLog_Print(h264->log, WLOG_ERROR, "SetGUID(MF_MT_MAJOR_TYPE) failure: 0x%08" PRIX32 "",
612 hr);
613 goto error;
614 }
615
616 hr = sys->inputType->lpVtbl->SetGUID(sys->inputType, &sMF_MT_SUBTYPE, &sMFVideoFormat_H264);
617
618 if (FAILED(hr))
619 {
620 WLog_Print(h264->log, WLOG_ERROR, "SetGUID(MF_MT_SUBTYPE) failure: 0x%08" PRIX32 "",
621 hr);
622 goto error;
623 }
624
625 hr = sys->transform->lpVtbl->SetInputType(sys->transform, 0, sys->inputType, 0);
626
627 if (FAILED(hr))
628 {
629 WLog_Print(h264->log, WLOG_ERROR, "SetInputType failure: 0x%08" PRIX32 "", hr);
630 goto error;
631 }
632
633 hr = mf_find_output_type(sys, &sMFVideoFormat_IYUV, &sys->outputType);
634
635 if (FAILED(hr))
636 {
637 WLog_Print(h264->log, WLOG_ERROR, "mf_find_output_type failure: 0x%08" PRIX32 "", hr);
638 goto error;
639 }
640
641 hr = sys->transform->lpVtbl->SetOutputType(sys->transform, 0, sys->outputType, 0);
642
643 if (FAILED(hr))
644 {
645 WLog_Print(h264->log, WLOG_ERROR, "SetOutputType failure: 0x%08" PRIX32 "", hr);
646 goto error;
647 }
648
649 hr = mf_create_output_sample(h264, sys);
650
651 if (FAILED(hr))
652 {
653 WLog_Print(h264->log, WLOG_ERROR, "mf_create_output_sample failure: 0x%08" PRIX32 "",
654 hr);
655 goto error;
656 }
657 }
658
659 return TRUE;
660error:
661 WLog_Print(h264->log, WLOG_ERROR, "mf_init failure");
662 mf_uninit(h264);
663 return FALSE;
664}
665
666const H264_CONTEXT_SUBSYSTEM g_Subsystem_MF = { "MediaFoundation", mf_init, mf_uninit,
667 mf_decompress, mf_compress };