eeabd0ce0bd56908ca8d4d3b5a93e3120eb86af4
[ffmpeg.git] / libavcodec / mf_utils.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #define COBJMACROS
20 #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
21 #undef _WIN32_WINNT
22 #define _WIN32_WINNT 0x0602
23 #endif
24
25 #include "mf_utils.h"
26 #include "libavutil/pixdesc.h"
27
28 HRESULT ff_MFGetAttributeSize(IMFAttributes *pattr, REFGUID guid,
29                               UINT32 *pw, UINT32 *ph)
30 {
31     UINT64 t;
32     HRESULT hr = IMFAttributes_GetUINT64(pattr, guid, &t);
33     if (!FAILED(hr)) {
34         *pw = t >> 32;
35         *ph = (UINT32)t;
36     }
37     return hr;
38 }
39
40 HRESULT ff_MFSetAttributeSize(IMFAttributes *pattr, REFGUID guid,
41                               UINT32 uw, UINT32 uh)
42 {
43     UINT64 t = (((UINT64)uw) << 32) | uh;
44     return IMFAttributes_SetUINT64(pattr, guid, t);
45 }
46
47 #define ff_MFSetAttributeRatio ff_MFSetAttributeSize
48 #define ff_MFGetAttributeRatio ff_MFGetAttributeSize
49
50 // MFTEnumEx was missing from mingw-w64's mfplat import library until
51 // mingw-w64 v6.0.0, thus wrap it and load it using GetProcAddress.
52 // It's also missing in Windows Vista's mfplat.dll.
53 HRESULT ff_MFTEnumEx(GUID guidCategory, UINT32 Flags,
54                      const MFT_REGISTER_TYPE_INFO *pInputType,
55                      const MFT_REGISTER_TYPE_INFO *pOutputType,
56                      IMFActivate ***pppMFTActivate, UINT32 *pnumMFTActivate)
57 {
58     HRESULT (WINAPI *MFTEnumEx_ptr)(GUID guidCategory, UINT32 Flags,
59                                     const MFT_REGISTER_TYPE_INFO *pInputType,
60                                     const MFT_REGISTER_TYPE_INFO *pOutputType,
61                                     IMFActivate ***pppMFTActivate,
62                                     UINT32 *pnumMFTActivate) = NULL;
63 #if !HAVE_UWP
64     HANDLE lib = GetModuleHandleW(L"mfplat.dll");
65     if (lib)
66         MFTEnumEx_ptr = (void *)GetProcAddress(lib, "MFTEnumEx");
67 #else
68     // In UWP (which lacks GetModuleHandle), just link directly against
69     // the functions - this requires building with new/complete enough
70     // import libraries.
71     MFTEnumEx_ptr = MFTEnumEx;
72 #endif
73     if (!MFTEnumEx_ptr)
74         return E_FAIL;
75     return MFTEnumEx_ptr(guidCategory,
76                          Flags,
77                          pInputType,
78                          pOutputType,
79                          pppMFTActivate,
80                          pnumMFTActivate);
81 }
82
83 char *ff_hr_str_buf(char *buf, size_t size, HRESULT hr)
84 {
85 #define HR(x) case x: return (char *) # x;
86     switch (hr) {
87     HR(S_OK)
88     HR(E_UNEXPECTED)
89     HR(MF_E_INVALIDMEDIATYPE)
90     HR(MF_E_INVALIDSTREAMNUMBER)
91     HR(MF_E_INVALIDTYPE)
92     HR(MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING)
93     HR(MF_E_TRANSFORM_TYPE_NOT_SET)
94     HR(MF_E_UNSUPPORTED_D3D_TYPE)
95     HR(MF_E_TRANSFORM_NEED_MORE_INPUT)
96     HR(MF_E_TRANSFORM_STREAM_CHANGE)
97     HR(MF_E_NOTACCEPTING)
98     HR(MF_E_NO_SAMPLE_TIMESTAMP)
99     HR(MF_E_NO_SAMPLE_DURATION)
100 #undef HR
101     }
102     snprintf(buf, size, "%x", (unsigned)hr);
103     return buf;
104 }
105
106 // If fill_data!=NULL, initialize the buffer and set the length. (This is a
107 // subtle but important difference: some decoders want CurrentLength==0 on
108 // provided output buffers.)
109 IMFSample *ff_create_memory_sample(void *fill_data, size_t size, size_t align)
110 {
111     HRESULT hr;
112     IMFSample *sample;
113     IMFMediaBuffer *buffer;
114
115     hr = MFCreateSample(&sample);
116     if (FAILED(hr))
117         return NULL;
118
119     align = FFMAX(align, 16); // 16 is "recommended", even if not required
120
121     hr = MFCreateAlignedMemoryBuffer(size, align - 1, &buffer);
122     if (FAILED(hr))
123         return NULL;
124
125     if (fill_data) {
126         BYTE *tmp;
127
128         hr = IMFMediaBuffer_Lock(buffer, &tmp, NULL, NULL);
129         if (FAILED(hr)) {
130             IMFMediaBuffer_Release(buffer);
131             IMFSample_Release(sample);
132             return NULL;
133         }
134         memcpy(tmp, fill_data, size);
135
136         IMFMediaBuffer_SetCurrentLength(buffer, size);
137         IMFMediaBuffer_Unlock(buffer);
138     }
139
140     IMFSample_AddBuffer(sample, buffer);
141     IMFMediaBuffer_Release(buffer);
142
143     return sample;
144 }
145
146 enum AVSampleFormat ff_media_type_to_sample_fmt(IMFAttributes *type)
147 {
148     HRESULT hr;
149     UINT32 bits;
150     GUID subtype;
151
152     hr = IMFAttributes_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &bits);
153     if (FAILED(hr))
154         return AV_SAMPLE_FMT_NONE;
155
156     hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &subtype);
157     if (FAILED(hr))
158         return AV_SAMPLE_FMT_NONE;
159
160     if (IsEqualGUID(&subtype, &MFAudioFormat_PCM)) {
161         switch (bits) {
162         case 8:  return AV_SAMPLE_FMT_U8;
163         case 16: return AV_SAMPLE_FMT_S16;
164         case 32: return AV_SAMPLE_FMT_S32;
165         }
166     } else if (IsEqualGUID(&subtype, &MFAudioFormat_Float)) {
167         switch (bits) {
168         case 32: return AV_SAMPLE_FMT_FLT;
169         case 64: return AV_SAMPLE_FMT_DBL;
170         }
171     }
172
173     return AV_SAMPLE_FMT_NONE;
174 }
175
176 struct mf_pix_fmt_entry {
177     const GUID *guid;
178     enum AVPixelFormat pix_fmt;
179 };
180
181 static const struct mf_pix_fmt_entry mf_pix_fmts[] = {
182     {&MFVideoFormat_IYUV, AV_PIX_FMT_YUV420P},
183     {&MFVideoFormat_I420, AV_PIX_FMT_YUV420P},
184     {&MFVideoFormat_NV12, AV_PIX_FMT_NV12},
185     {&MFVideoFormat_P010, AV_PIX_FMT_P010},
186     {&MFVideoFormat_P016, AV_PIX_FMT_P010}, // not equal, but compatible
187     {&MFVideoFormat_YUY2, AV_PIX_FMT_YUYV422},
188 };
189
190 enum AVPixelFormat ff_media_type_to_pix_fmt(IMFAttributes *type)
191 {
192     HRESULT hr;
193     GUID subtype;
194     int i;
195
196     hr = IMFAttributes_GetGUID(type, &MF_MT_SUBTYPE, &subtype);
197     if (FAILED(hr))
198         return AV_PIX_FMT_NONE;
199
200     for (i = 0; i < FF_ARRAY_ELEMS(mf_pix_fmts); i++) {
201         if (IsEqualGUID(&subtype, mf_pix_fmts[i].guid))
202             return mf_pix_fmts[i].pix_fmt;
203     }
204
205     return AV_PIX_FMT_NONE;
206 }
207
208 const GUID *ff_pix_fmt_to_guid(enum AVPixelFormat pix_fmt)
209 {
210     int i;
211
212     for (i = 0; i < FF_ARRAY_ELEMS(mf_pix_fmts); i++) {
213         if (mf_pix_fmts[i].pix_fmt == pix_fmt)
214             return mf_pix_fmts[i].guid;
215     }
216
217     return NULL;
218 }
219
220 // If this GUID is of the form XXXXXXXX-0000-0010-8000-00AA00389B71, then
221 // extract the XXXXXXXX prefix as FourCC (oh the pain).
222 int ff_fourcc_from_guid(const GUID *guid, uint32_t *out_fourcc)
223 {
224     if (guid->Data2 == 0 && guid->Data3 == 0x0010 &&
225         guid->Data4[0] == 0x80 &&
226         guid->Data4[1] == 0x00 &&
227         guid->Data4[2] == 0x00 &&
228         guid->Data4[3] == 0xAA &&
229         guid->Data4[4] == 0x00 &&
230         guid->Data4[5] == 0x38 &&
231         guid->Data4[6] == 0x9B &&
232         guid->Data4[7] == 0x71) {
233         *out_fourcc = guid->Data1;
234         return 0;
235     }
236
237     *out_fourcc = 0;
238     return AVERROR_UNKNOWN;
239 }
240
241 struct GUID_Entry {
242     const GUID *guid;
243     const char *name;
244 };
245
246 #define GUID_ENTRY(var) {&(var), # var}
247
248 static struct GUID_Entry guid_names[] = {
249     GUID_ENTRY(MFT_FRIENDLY_NAME_Attribute),
250     GUID_ENTRY(MFT_TRANSFORM_CLSID_Attribute),
251     GUID_ENTRY(MFT_ENUM_HARDWARE_URL_Attribute),
252     GUID_ENTRY(MFT_CONNECTED_STREAM_ATTRIBUTE),
253     GUID_ENTRY(MFT_CONNECTED_TO_HW_STREAM),
254     GUID_ENTRY(MF_SA_D3D_AWARE),
255     GUID_ENTRY(ff_MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT),
256     GUID_ENTRY(ff_MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE),
257     GUID_ENTRY(ff_MF_SA_D3D11_BINDFLAGS),
258     GUID_ENTRY(ff_MF_SA_D3D11_USAGE),
259     GUID_ENTRY(ff_MF_SA_D3D11_AWARE),
260     GUID_ENTRY(ff_MF_SA_D3D11_SHARED),
261     GUID_ENTRY(ff_MF_SA_D3D11_SHARED_WITHOUT_MUTEX),
262     GUID_ENTRY(MF_MT_SUBTYPE),
263     GUID_ENTRY(MF_MT_MAJOR_TYPE),
264     GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_SECOND),
265     GUID_ENTRY(MF_MT_AUDIO_NUM_CHANNELS),
266     GUID_ENTRY(MF_MT_AUDIO_CHANNEL_MASK),
267     GUID_ENTRY(MF_MT_FRAME_SIZE),
268     GUID_ENTRY(MF_MT_INTERLACE_MODE),
269     GUID_ENTRY(MF_MT_USER_DATA),
270     GUID_ENTRY(MF_MT_PIXEL_ASPECT_RATIO),
271     GUID_ENTRY(MFMediaType_Audio),
272     GUID_ENTRY(MFMediaType_Video),
273     GUID_ENTRY(MFAudioFormat_PCM),
274     GUID_ENTRY(MFAudioFormat_Float),
275     GUID_ENTRY(MFVideoFormat_H264),
276     GUID_ENTRY(MFVideoFormat_H264_ES),
277     GUID_ENTRY(ff_MFVideoFormat_HEVC),
278     GUID_ENTRY(ff_MFVideoFormat_HEVC_ES),
279     GUID_ENTRY(MFVideoFormat_MPEG2),
280     GUID_ENTRY(MFVideoFormat_MP43),
281     GUID_ENTRY(MFVideoFormat_MP4V),
282     GUID_ENTRY(MFVideoFormat_WMV1),
283     GUID_ENTRY(MFVideoFormat_WMV2),
284     GUID_ENTRY(MFVideoFormat_WMV3),
285     GUID_ENTRY(MFVideoFormat_WVC1),
286     GUID_ENTRY(MFAudioFormat_Dolby_AC3),
287     GUID_ENTRY(MFAudioFormat_Dolby_DDPlus),
288     GUID_ENTRY(MFAudioFormat_AAC),
289     GUID_ENTRY(MFAudioFormat_MP3),
290     GUID_ENTRY(MFAudioFormat_MSP1),
291     GUID_ENTRY(MFAudioFormat_WMAudioV8),
292     GUID_ENTRY(MFAudioFormat_WMAudioV9),
293     GUID_ENTRY(MFAudioFormat_WMAudio_Lossless),
294     GUID_ENTRY(MF_MT_ALL_SAMPLES_INDEPENDENT),
295     GUID_ENTRY(MF_MT_COMPRESSED),
296     GUID_ENTRY(MF_MT_FIXED_SIZE_SAMPLES),
297     GUID_ENTRY(MF_MT_SAMPLE_SIZE),
298     GUID_ENTRY(MF_MT_WRAPPED_TYPE),
299     GUID_ENTRY(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION),
300     GUID_ENTRY(MF_MT_AAC_PAYLOAD_TYPE),
301     GUID_ENTRY(MF_MT_AUDIO_AVG_BYTES_PER_SECOND),
302     GUID_ENTRY(MF_MT_AUDIO_BITS_PER_SAMPLE),
303     GUID_ENTRY(MF_MT_AUDIO_BLOCK_ALIGNMENT),
304     GUID_ENTRY(MF_MT_AUDIO_CHANNEL_MASK),
305     GUID_ENTRY(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND),
306     GUID_ENTRY(MF_MT_AUDIO_FOLDDOWN_MATRIX),
307     GUID_ENTRY(MF_MT_AUDIO_NUM_CHANNELS),
308     GUID_ENTRY(MF_MT_AUDIO_PREFER_WAVEFORMATEX),
309     GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_BLOCK),
310     GUID_ENTRY(MF_MT_AUDIO_SAMPLES_PER_SECOND),
311     GUID_ENTRY(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE),
312     GUID_ENTRY(MF_MT_AUDIO_WMADRC_AVGREF),
313     GUID_ENTRY(MF_MT_AUDIO_WMADRC_AVGTARGET),
314     GUID_ENTRY(MF_MT_AUDIO_WMADRC_PEAKREF),
315     GUID_ENTRY(MF_MT_AUDIO_WMADRC_PEAKTARGET),
316     GUID_ENTRY(MF_MT_AVG_BIT_ERROR_RATE),
317     GUID_ENTRY(MF_MT_AVG_BITRATE),
318     GUID_ENTRY(MF_MT_DEFAULT_STRIDE),
319     GUID_ENTRY(MF_MT_DRM_FLAGS),
320     GUID_ENTRY(MF_MT_FRAME_RATE),
321     GUID_ENTRY(MF_MT_FRAME_RATE_RANGE_MAX),
322     GUID_ENTRY(MF_MT_FRAME_RATE_RANGE_MIN),
323     GUID_ENTRY(MF_MT_FRAME_SIZE),
324     GUID_ENTRY(MF_MT_GEOMETRIC_APERTURE),
325     GUID_ENTRY(MF_MT_INTERLACE_MODE),
326     GUID_ENTRY(MF_MT_MAX_KEYFRAME_SPACING),
327     GUID_ENTRY(MF_MT_MINIMUM_DISPLAY_APERTURE),
328     GUID_ENTRY(MF_MT_MPEG_SEQUENCE_HEADER),
329     GUID_ENTRY(MF_MT_MPEG_START_TIME_CODE),
330     GUID_ENTRY(MF_MT_MPEG2_FLAGS),
331     GUID_ENTRY(MF_MT_MPEG2_LEVEL),
332     GUID_ENTRY(MF_MT_MPEG2_PROFILE),
333     GUID_ENTRY(MF_MT_PAD_CONTROL_FLAGS),
334     GUID_ENTRY(MF_MT_PALETTE),
335     GUID_ENTRY(MF_MT_PAN_SCAN_APERTURE),
336     GUID_ENTRY(MF_MT_PAN_SCAN_ENABLED),
337     GUID_ENTRY(MF_MT_PIXEL_ASPECT_RATIO),
338     GUID_ENTRY(MF_MT_SOURCE_CONTENT_HINT),
339     GUID_ENTRY(MF_MT_TRANSFER_FUNCTION),
340     GUID_ENTRY(MF_MT_VIDEO_CHROMA_SITING),
341     GUID_ENTRY(MF_MT_VIDEO_LIGHTING),
342     GUID_ENTRY(MF_MT_VIDEO_NOMINAL_RANGE),
343     GUID_ENTRY(MF_MT_VIDEO_PRIMARIES),
344     GUID_ENTRY(MF_MT_VIDEO_ROTATION),
345     GUID_ENTRY(MF_MT_YUV_MATRIX),
346     GUID_ENTRY(ff_CODECAPI_AVDecVideoThumbnailGenerationMode),
347     GUID_ENTRY(ff_CODECAPI_AVDecVideoDropPicWithMissingRef),
348     GUID_ENTRY(ff_CODECAPI_AVDecVideoSoftwareDeinterlaceMode),
349     GUID_ENTRY(ff_CODECAPI_AVDecVideoFastDecodeMode),
350     GUID_ENTRY(ff_CODECAPI_AVLowLatencyMode),
351     GUID_ENTRY(ff_CODECAPI_AVDecVideoH264ErrorConcealment),
352     GUID_ENTRY(ff_CODECAPI_AVDecVideoMPEG2ErrorConcealment),
353     GUID_ENTRY(ff_CODECAPI_AVDecVideoCodecType),
354     GUID_ENTRY(ff_CODECAPI_AVDecVideoDXVAMode),
355     GUID_ENTRY(ff_CODECAPI_AVDecVideoDXVABusEncryption),
356     GUID_ENTRY(ff_CODECAPI_AVDecVideoSWPowerLevel),
357     GUID_ENTRY(ff_CODECAPI_AVDecVideoMaxCodedWidth),
358     GUID_ENTRY(ff_CODECAPI_AVDecVideoMaxCodedHeight),
359     GUID_ENTRY(ff_CODECAPI_AVDecNumWorkerThreads),
360     GUID_ENTRY(ff_CODECAPI_AVDecSoftwareDynamicFormatChange),
361     GUID_ENTRY(ff_CODECAPI_AVDecDisableVideoPostProcessing),
362 };
363
364 char *ff_guid_str_buf(char *buf, size_t buf_size, const GUID *guid)
365 {
366     uint32_t fourcc;
367     int n;
368     for (n = 0; n < FF_ARRAY_ELEMS(guid_names); n++) {
369         if (IsEqualGUID(guid, guid_names[n].guid)) {
370             snprintf(buf, buf_size, "%s", guid_names[n].name);
371             return buf;
372         }
373     }
374
375     if (ff_fourcc_from_guid(guid, &fourcc) >= 0) {
376         snprintf(buf, buf_size, "<FourCC %s>", av_fourcc2str(fourcc));
377         return buf;
378     }
379
380     snprintf(buf, buf_size,
381              "{%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x}",
382              (unsigned) guid->Data1, guid->Data2, guid->Data3,
383              guid->Data4[0], guid->Data4[1],
384              guid->Data4[2], guid->Data4[3],
385              guid->Data4[4], guid->Data4[5],
386              guid->Data4[6], guid->Data4[7]);
387     return buf;
388 }
389
390 void ff_attributes_dump(void *log, IMFAttributes *attrs)
391 {
392     HRESULT hr;
393     UINT32 count;
394     int n;
395
396     hr = IMFAttributes_GetCount(attrs, &count);
397     if (FAILED(hr))
398         return;
399
400     for (n = 0; n < count; n++) {
401         GUID key;
402         MF_ATTRIBUTE_TYPE type;
403         char extra[80] = {0};
404         const char *name = NULL;
405
406         hr = IMFAttributes_GetItemByIndex(attrs, n, &key, NULL);
407         if (FAILED(hr))
408             goto err;
409
410         name = ff_guid_str(&key);
411
412         if (IsEqualGUID(&key, &MF_MT_AUDIO_CHANNEL_MASK)) {
413             UINT32 v;
414             hr = IMFAttributes_GetUINT32(attrs, &key, &v);
415             if (FAILED(hr))
416                 goto err;
417             snprintf(extra, sizeof(extra), " (0x%x)", (unsigned)v);
418         } else if (IsEqualGUID(&key, &MF_MT_FRAME_SIZE)) {
419             UINT32 w, h;
420
421             hr = ff_MFGetAttributeSize(attrs, &MF_MT_FRAME_SIZE, &w, &h);
422             if (FAILED(hr))
423                 goto err;
424             snprintf(extra, sizeof(extra), " (%dx%d)", (int)w, (int)h);
425         } else if (IsEqualGUID(&key, &MF_MT_PIXEL_ASPECT_RATIO) ||
426                    IsEqualGUID(&key, &MF_MT_FRAME_RATE)) {
427             UINT32 num, den;
428
429             hr = ff_MFGetAttributeRatio(attrs, &key, &num, &den);
430             if (FAILED(hr))
431                 goto err;
432             snprintf(extra, sizeof(extra), " (%d:%d)", (int)num, (int)den);
433         }
434
435         hr = IMFAttributes_GetItemType(attrs, &key, &type);
436         if (FAILED(hr))
437             goto err;
438
439         switch (type) {
440         case MF_ATTRIBUTE_UINT32: {
441             UINT32 v;
442             hr = IMFAttributes_GetUINT32(attrs, &key, &v);
443             if (FAILED(hr))
444                 goto err;
445             av_log(log, AV_LOG_VERBOSE, "   %s=%d%s\n", name, (int)v, extra);
446             break;
447         case MF_ATTRIBUTE_UINT64: {
448             UINT64 v;
449             hr = IMFAttributes_GetUINT64(attrs, &key, &v);
450             if (FAILED(hr))
451                 goto err;
452             av_log(log, AV_LOG_VERBOSE, "   %s=%lld%s\n", name, (long long)v, extra);
453             break;
454         }
455         case MF_ATTRIBUTE_DOUBLE: {
456             DOUBLE v;
457             hr = IMFAttributes_GetDouble(attrs, &key, &v);
458             if (FAILED(hr))
459                 goto err;
460             av_log(log, AV_LOG_VERBOSE, "   %s=%f%s\n", name, (double)v, extra);
461             break;
462         }
463         case MF_ATTRIBUTE_STRING: {
464             wchar_t s[512]; // being lazy here
465             hr = IMFAttributes_GetString(attrs, &key, s, sizeof(s), NULL);
466             if (FAILED(hr))
467                 goto err;
468             av_log(log, AV_LOG_VERBOSE, "   %s='%ls'%s\n", name, s, extra);
469             break;
470         }
471         case MF_ATTRIBUTE_GUID: {
472             GUID v;
473             hr = IMFAttributes_GetGUID(attrs, &key, &v);
474             if (FAILED(hr))
475                 goto err;
476             av_log(log, AV_LOG_VERBOSE, "   %s=%s%s\n", name, ff_guid_str(&v), extra);
477             break;
478         }
479         case MF_ATTRIBUTE_BLOB: {
480             UINT32 sz;
481             UINT8 buffer[100];
482             hr = IMFAttributes_GetBlobSize(attrs, &key, &sz);
483             if (FAILED(hr))
484                 goto err;
485             if (sz <= sizeof(buffer)) {
486                 // hex-dump it
487                 char str[512] = {0};
488                 size_t pos = 0;
489                 hr = IMFAttributes_GetBlob(attrs, &key, buffer, sizeof(buffer), &sz);
490                 if (FAILED(hr))
491                     goto err;
492                 for (pos = 0; pos < sz; pos++) {
493                     const char *hex = "0123456789ABCDEF";
494                     if (pos * 3 + 3 > sizeof(str))
495                         break;
496                     str[pos * 3 + 0] = hex[buffer[pos] >> 4];
497                     str[pos * 3 + 1] = hex[buffer[pos] & 15];
498                     str[pos * 3 + 2] = ' ';
499                 }
500                 str[pos * 3 + 0] = 0;
501                 av_log(log, AV_LOG_VERBOSE, "   %s=<blob size %d: %s>%s\n", name, (int)sz, str, extra);
502             } else {
503                 av_log(log, AV_LOG_VERBOSE, "   %s=<blob size %d>%s\n", name, (int)sz, extra);
504             }
505             break;
506         }
507         case MF_ATTRIBUTE_IUNKNOWN: {
508             av_log(log, AV_LOG_VERBOSE, "   %s=<IUnknown>%s\n", name, extra);
509             break;
510         }
511         default:
512             av_log(log, AV_LOG_VERBOSE, "   %s=<unknown type>%s\n", name, extra);
513             break;
514         }
515         }
516
517         if (IsEqualGUID(&key, &MF_MT_SUBTYPE)) {
518             const char *fmt;
519             fmt = av_get_sample_fmt_name(ff_media_type_to_sample_fmt(attrs));
520             if (fmt)
521                 av_log(log, AV_LOG_VERBOSE, "   FF-sample-format=%s\n", fmt);
522
523             fmt = av_get_pix_fmt_name(ff_media_type_to_pix_fmt(attrs));
524             if (fmt)
525                 av_log(log, AV_LOG_VERBOSE, "   FF-pixel-format=%s\n", fmt);
526         }
527
528         continue;
529     err:
530         av_log(log, AV_LOG_VERBOSE, "   %s=<failed to get value>\n", name ? name : "?");
531     }
532 }
533
534 void ff_media_type_dump(void *log, IMFMediaType *type)
535 {
536     ff_attributes_dump(log, (IMFAttributes *)type);
537 }
538
539 const CLSID *ff_codec_to_mf_subtype(enum AVCodecID codec)
540 {
541     switch (codec) {
542     case AV_CODEC_ID_H264:              return &MFVideoFormat_H264;
543     case AV_CODEC_ID_HEVC:              return &ff_MFVideoFormat_HEVC;
544     case AV_CODEC_ID_AC3:               return &MFAudioFormat_Dolby_AC3;
545     case AV_CODEC_ID_AAC:               return &MFAudioFormat_AAC;
546     case AV_CODEC_ID_MP3:               return &MFAudioFormat_MP3;
547     default:                            return NULL;
548     }
549 }
550
551 static int init_com_mf(void *log)
552 {
553     HRESULT hr;
554
555     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
556     if (hr == RPC_E_CHANGED_MODE) {
557         av_log(log, AV_LOG_ERROR, "COM must not be in STA mode\n");
558         return AVERROR(EINVAL);
559     } else if (FAILED(hr)) {
560         av_log(log, AV_LOG_ERROR, "could not initialize COM\n");
561         return AVERROR(ENOSYS);
562     }
563
564     hr = MFStartup(MF_VERSION, MFSTARTUP_FULL);
565     if (FAILED(hr)) {
566         av_log(log, AV_LOG_ERROR, "could not initialize MediaFoundation\n");
567         CoUninitialize();
568         return AVERROR(ENOSYS);
569     }
570
571     return 0;
572 }
573
574 static void uninit_com_mf(void)
575 {
576     MFShutdown();
577     CoUninitialize();
578 }
579
580 // Find and create a IMFTransform with the given input/output types. When done,
581 // you should use ff_free_mf() to destroy it, which will also uninit COM.
582 int ff_instantiate_mf(void *log,
583                       GUID category,
584                       MFT_REGISTER_TYPE_INFO *in_type,
585                       MFT_REGISTER_TYPE_INFO *out_type,
586                       int use_hw,
587                       IMFTransform **res)
588 {
589     HRESULT hr;
590     int n;
591     int ret;
592     IMFActivate **activate;
593     UINT32 num_activate;
594     IMFActivate *winner = 0;
595     UINT32 flags;
596
597     ret = init_com_mf(log);
598     if (ret < 0)
599         return ret;
600
601     flags = MFT_ENUM_FLAG_SORTANDFILTER;
602
603     if (use_hw) {
604         flags |= MFT_ENUM_FLAG_HARDWARE;
605     } else {
606         flags |= MFT_ENUM_FLAG_SYNCMFT;
607     }
608
609     hr = ff_MFTEnumEx(category, flags, in_type, out_type, &activate,
610                       &num_activate);
611     if (FAILED(hr))
612         goto error_uninit_mf;
613
614     if (log) {
615         if (!num_activate)
616             av_log(log, AV_LOG_ERROR, "could not find any MFT for the given media type\n");
617
618         for (n = 0; n < num_activate; n++) {
619             av_log(log, AV_LOG_VERBOSE, "MF %d attributes:\n", n);
620             ff_attributes_dump(log, (IMFAttributes *)activate[n]);
621         }
622     }
623
624     *res = NULL;
625     for (n = 0; n < num_activate; n++) {
626         if (log)
627             av_log(log, AV_LOG_VERBOSE, "activate MFT %d\n", n);
628         hr = IMFActivate_ActivateObject(activate[n], &IID_IMFTransform,
629                                         (void **)res);
630         if (*res) {
631             winner = activate[n];
632             IMFActivate_AddRef(winner);
633             break;
634         }
635     }
636
637     for (n = 0; n < num_activate; n++)
638        IMFActivate_Release(activate[n]);
639     CoTaskMemFree(activate);
640
641     if (!*res) {
642         if (log)
643             av_log(log, AV_LOG_ERROR, "could not create MFT\n");
644         goto error_uninit_mf;
645     }
646
647     if (log) {
648         wchar_t s[512]; // being lazy here
649         IMFAttributes *attrs;
650         hr = IMFTransform_GetAttributes(*res, &attrs);
651         if (!FAILED(hr) && attrs) {
652
653             av_log(log, AV_LOG_VERBOSE, "MFT attributes\n");
654             ff_attributes_dump(log, attrs);
655             IMFAttributes_Release(attrs);
656         }
657
658         hr = IMFActivate_GetString(winner, &MFT_FRIENDLY_NAME_Attribute, s,
659                                    sizeof(s), NULL);
660         if (!FAILED(hr))
661             av_log(log, AV_LOG_INFO, "MFT name: '%ls'\n", s);
662
663     }
664
665     IMFActivate_Release(winner);
666
667     return 0;
668
669 error_uninit_mf:
670     uninit_com_mf();
671     return AVERROR(ENOSYS);
672 }
673
674 void ff_free_mf(IMFTransform **mft)
675 {
676     if (*mft)
677         IMFTransform_Release(*mft);
678     *mft = NULL;
679     uninit_com_mf();
680 }