?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
win32u: Use the dummy surface for empty layered window surfaces.
[wine.git] / dlls / winegstreamer / mfplat.c
blobd84939ce13d4699ef282fc3ea4717161353e6d6d
1 /*
2 * Copyright 2019 Nikolay Sivov for CodeWeavers
3 * Copyright 2020 Zebediah Figura for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "gst_private.h"
21
22 #include "ks.h"
23 #include "ksmedia.h"
24 #include "wmcodecdsp.h"
25 #include "d3d9types.h"
26 #include "mfapi.h"
27 #include "mmreg.h"
28
29 #include "wine/debug.h"
30 #include "wine/list.h"
31
32 #include "initguid.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
35
36 DEFINE_GUID(DMOVideoFormat_RGB32,D3DFMT_X8R8G8B8,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);
37 DEFINE_GUID(DMOVideoFormat_RGB24,D3DFMT_R8G8B8,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);
38 DEFINE_GUID(DMOVideoFormat_RGB565,D3DFMT_R5G6B5,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);
39 DEFINE_GUID(DMOVideoFormat_RGB555,D3DFMT_X1R5G5B5,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);
40 DEFINE_GUID(DMOVideoFormat_RGB8,D3DFMT_P8,0x524f,0x11ce,0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70);
41 DEFINE_MEDIATYPE_GUID(MFAudioFormat_RAW_AAC,WAVE_FORMAT_RAW_AAC1);
42 DEFINE_MEDIATYPE_GUID(MFVideoFormat_VC1S,MAKEFOURCC('V','C','1','S'));
43 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IV50,MAKEFOURCC('I','V','5','0'));
44 DEFINE_MEDIATYPE_GUID(MFVideoFormat_ABGR32,D3DFMT_A8B8G8R8);
45 DEFINE_GUID(MEDIASUBTYPE_WMV_Unknown, 0x7ce12ca9,0xbfbf,0x43d9,0x9d,0x00,0x82,0xb8,0xed,0x54,0x31,0x6b);
46
47 struct class_factory
48 {
49 IClassFactory IClassFactory_iface;
50 LONG refcount;
51 HRESULT (*create_instance)(REFIID riid, void **obj);
52 };
53
54 static struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
55 {
56 return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
57 }
58
59 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
60 {
61 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
62
63 if (IsEqualGUID(riid, &IID_IClassFactory) ||
64 IsEqualGUID(riid, &IID_IUnknown))
65 {
66 *obj = iface;
67 IClassFactory_AddRef(iface);
68 return S_OK;
69 }
70
71 WARN("%s is not supported.\n", debugstr_guid(riid));
72 *obj = NULL;
73 return E_NOINTERFACE;
74 }
75
76 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
77 {
78 struct class_factory *factory = impl_from_IClassFactory(iface);
79 return InterlockedIncrement(&factory->refcount);
80 }
81
82 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
83 {
84 struct class_factory *factory = impl_from_IClassFactory(iface);
85 ULONG refcount = InterlockedDecrement(&factory->refcount);
86
87 if (!refcount)
88 free(factory);
89
90 return refcount;
91 }
92
93 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
94 {
95 struct class_factory *factory = impl_from_IClassFactory(iface);
96
97 TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), obj);
98
99 if (outer)
100 {
101 *obj = NULL;
102 return CLASS_E_NOAGGREGATION;
103 }
104
105 return factory->create_instance(riid, obj);
106 }
107
108 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL dolock)
109 {
110 TRACE("%p, %d.\n", iface, dolock);
111 return S_OK;
112 }
113
114 static const IClassFactoryVtbl class_factory_vtbl =
115 {
116 class_factory_QueryInterface,
117 class_factory_AddRef,
118 class_factory_Release,
119 class_factory_CreateInstance,
120 class_factory_LockServer,
121 };
122
123 static const GUID CLSID_GStreamerByteStreamHandler = {0x317df618, 0x5e5a, 0x468a, {0x9f, 0x15, 0xd8, 0x27, 0xa9, 0xa0, 0x81, 0x62}};
124
125 static const struct class_object
126 {
127 const GUID *clsid;
128 HRESULT (*create_instance)(REFIID riid, void **obj);
129 }
130 class_objects[] =
131 {
132 { &CLSID_VideoProcessorMFT, &video_processor_create },
133 { &CLSID_GStreamerByteStreamHandler, &gstreamer_byte_stream_handler_create },
134 { &CLSID_MSAACDecMFT, &aac_decoder_create },
135 { &CLSID_MSH264DecoderMFT, &h264_decoder_create },
136 { &CLSID_MSH264EncoderMFT, &h264_encoder_create },
137 };
138
139 HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj)
140 {
141 struct class_factory *factory;
142 unsigned int i;
143 HRESULT hr;
144
145 for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
146 {
147 if (IsEqualGUID(class_objects[i].clsid, rclsid))
148 {
149 if (!(factory = malloc(sizeof(*factory))))
150 return E_OUTOFMEMORY;
151
152 factory->IClassFactory_iface.lpVtbl = &class_factory_vtbl;
153 factory->refcount = 1;
154 factory->create_instance = class_objects[i].create_instance;
155
156 hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj);
157 IClassFactory_Release(&factory->IClassFactory_iface);
158 return hr;
159 }
160 }
161
162 return CLASS_E_CLASSNOTAVAILABLE;
163 }
164
165 HRESULT mfplat_DllRegisterServer(void)
166 {
167 MFT_REGISTER_TYPE_INFO resampler_types[] =
168 {
169 {MFMediaType_Audio, MFAudioFormat_PCM},
170 {MFMediaType_Audio, MFAudioFormat_Float},
171 };
172
173 MFT_REGISTER_TYPE_INFO aac_decoder_input_types[] =
174 {
175 {MFMediaType_Audio, MFAudioFormat_AAC},
176 {MFMediaType_Audio, MFAudioFormat_RAW_AAC},
177 {MFMediaType_Audio, MFAudioFormat_ADTS},
178 };
179 MFT_REGISTER_TYPE_INFO aac_decoder_output_types[] =
180 {
181 {MFMediaType_Audio, MFAudioFormat_Float},
182 {MFMediaType_Audio, MFAudioFormat_PCM},
183 };
184
185 MFT_REGISTER_TYPE_INFO wma_decoder_input_types[] =
186 {
187 {MFMediaType_Audio, MEDIASUBTYPE_MSAUDIO1},
188 {MFMediaType_Audio, MFAudioFormat_WMAudioV8},
189 {MFMediaType_Audio, MFAudioFormat_WMAudioV9},
190 {MFMediaType_Audio, MFAudioFormat_WMAudio_Lossless},
191 };
192 MFT_REGISTER_TYPE_INFO wma_decoder_output_types[] =
193 {
194 {MFMediaType_Audio, MFAudioFormat_PCM},
195 {MFMediaType_Audio, MFAudioFormat_Float},
196 };
197
198 MFT_REGISTER_TYPE_INFO h264_decoder_input_types[] =
199 {
200 {MFMediaType_Video, MFVideoFormat_H264},
201 {MFMediaType_Video, MFVideoFormat_H264_ES},
202 };
203 MFT_REGISTER_TYPE_INFO h264_decoder_output_types[] =
204 {
205 {MFMediaType_Video, MFVideoFormat_NV12},
206 {MFMediaType_Video, MFVideoFormat_YV12},
207 {MFMediaType_Video, MFVideoFormat_IYUV},
208 {MFMediaType_Video, MFVideoFormat_I420},
209 {MFMediaType_Video, MFVideoFormat_YUY2},
210 };
211
212 MFT_REGISTER_TYPE_INFO h264_encoder_input_types[] =
213 {
214 {MFMediaType_Video, MFVideoFormat_IYUV},
215 {MFMediaType_Video, MFVideoFormat_YV12},
216 {MFMediaType_Video, MFVideoFormat_NV12},
217 {MFMediaType_Video, MFVideoFormat_YUY2},
218 };
219 MFT_REGISTER_TYPE_INFO h264_encoder_output_types[] =
220 {
221 {MFMediaType_Video, MFVideoFormat_H264},
222 };
223
224 MFT_REGISTER_TYPE_INFO video_processor_input_types[] =
225 {
226 {MFMediaType_Video, MFVideoFormat_IYUV},
227 {MFMediaType_Video, MFVideoFormat_YV12},
228 {MFMediaType_Video, MFVideoFormat_NV12},
229 {MFMediaType_Video, MFVideoFormat_YUY2},
230 {MFMediaType_Video, MFVideoFormat_ARGB32},
231 {MFMediaType_Video, MFVideoFormat_RGB32},
232 {MFMediaType_Video, MFVideoFormat_NV11},
233 {MFMediaType_Video, MFVideoFormat_AYUV},
234 {MFMediaType_Video, MFVideoFormat_UYVY},
235 {MFMediaType_Video, MEDIASUBTYPE_P208},
236 {MFMediaType_Video, MFVideoFormat_RGB24},
237 {MFMediaType_Video, MFVideoFormat_RGB555},
238 {MFMediaType_Video, MFVideoFormat_RGB565},
239 {MFMediaType_Video, MFVideoFormat_RGB8},
240 {MFMediaType_Video, MFVideoFormat_I420},
241 {MFMediaType_Video, MFVideoFormat_Y216},
242 {MFMediaType_Video, MFVideoFormat_v410},
243 {MFMediaType_Video, MFVideoFormat_Y41P},
244 {MFMediaType_Video, MFVideoFormat_Y41T},
245 {MFMediaType_Video, MFVideoFormat_Y42T},
246 {MFMediaType_Video, MFVideoFormat_YVYU},
247 {MFMediaType_Video, MFVideoFormat_420O},
248 };
249 MFT_REGISTER_TYPE_INFO video_processor_output_types[] =
250 {
251 {MFMediaType_Video, MFVideoFormat_IYUV},
252 {MFMediaType_Video, MFVideoFormat_YV12},
253 {MFMediaType_Video, MFVideoFormat_NV12},
254 {MFMediaType_Video, MFVideoFormat_YUY2},
255 {MFMediaType_Video, MFVideoFormat_ARGB32},
256 {MFMediaType_Video, MFVideoFormat_RGB32},
257 {MFMediaType_Video, MFVideoFormat_NV11},
258 {MFMediaType_Video, MFVideoFormat_AYUV},
259 {MFMediaType_Video, MFVideoFormat_UYVY},
260 {MFMediaType_Video, MEDIASUBTYPE_P208},
261 {MFMediaType_Video, MFVideoFormat_RGB24},
262 {MFMediaType_Video, MFVideoFormat_RGB555},
263 {MFMediaType_Video, MFVideoFormat_RGB565},
264 {MFMediaType_Video, MFVideoFormat_RGB8},
265 {MFMediaType_Video, MFVideoFormat_I420},
266 {MFMediaType_Video, MFVideoFormat_Y216},
267 {MFMediaType_Video, MFVideoFormat_v410},
268 {MFMediaType_Video, MFVideoFormat_Y41P},
269 {MFMediaType_Video, MFVideoFormat_Y41T},
270 {MFMediaType_Video, MFVideoFormat_Y42T},
271 {MFMediaType_Video, MFVideoFormat_YVYU},
272 };
273
274 MFT_REGISTER_TYPE_INFO wmv_decoder_input_types[] =
275 {
276 {MFMediaType_Video, MFVideoFormat_WMV1},
277 {MFMediaType_Video, MFVideoFormat_WMV2},
278 {MFMediaType_Video, MFVideoFormat_WMV3},
279 {MFMediaType_Video, MEDIASUBTYPE_WMVP},
280 {MFMediaType_Video, MEDIASUBTYPE_WVP2},
281 {MFMediaType_Video, MEDIASUBTYPE_WMVR},
282 {MFMediaType_Video, MEDIASUBTYPE_WMVA},
283 {MFMediaType_Video, MFVideoFormat_WVC1},
284 {MFMediaType_Video, MFVideoFormat_VC1S},
285 };
286 MFT_REGISTER_TYPE_INFO wmv_decoder_output_types[] =
287 {
288 {MFMediaType_Video, MFVideoFormat_YV12},
289 {MFMediaType_Video, MFVideoFormat_YUY2},
290 {MFMediaType_Video, MFVideoFormat_UYVY},
291 {MFMediaType_Video, MFVideoFormat_YVYU},
292 {MFMediaType_Video, MFVideoFormat_NV11},
293 {MFMediaType_Video, MFVideoFormat_NV12},
294 {MFMediaType_Video, DMOVideoFormat_RGB32},
295 {MFMediaType_Video, DMOVideoFormat_RGB24},
296 {MFMediaType_Video, DMOVideoFormat_RGB565},
297 {MFMediaType_Video, DMOVideoFormat_RGB555},
298 {MFMediaType_Video, DMOVideoFormat_RGB8},
299 };
300
301 MFT_REGISTER_TYPE_INFO color_convert_input_types[] =
302 {
303 {MFMediaType_Video, MFVideoFormat_YV12},
304 {MFMediaType_Video, MFVideoFormat_YUY2},
305 {MFMediaType_Video, MFVideoFormat_UYVY},
306 {MFMediaType_Video, MFVideoFormat_AYUV},
307 {MFMediaType_Video, MFVideoFormat_NV12},
308 {MFMediaType_Video, DMOVideoFormat_RGB32},
309 {MFMediaType_Video, DMOVideoFormat_RGB565},
310 {MFMediaType_Video, MFVideoFormat_I420},
311 {MFMediaType_Video, MFVideoFormat_IYUV},
312 {MFMediaType_Video, MFVideoFormat_YVYU},
313 {MFMediaType_Video, DMOVideoFormat_RGB24},
314 {MFMediaType_Video, DMOVideoFormat_RGB555},
315 {MFMediaType_Video, DMOVideoFormat_RGB8},
316 {MFMediaType_Video, MEDIASUBTYPE_V216},
317 {MFMediaType_Video, MEDIASUBTYPE_V410},
318 {MFMediaType_Video, MFVideoFormat_NV11},
319 {MFMediaType_Video, MFVideoFormat_Y41P},
320 {MFMediaType_Video, MFVideoFormat_Y41T},
321 {MFMediaType_Video, MFVideoFormat_Y42T},
322 {MFMediaType_Video, MFVideoFormat_YVU9},
323 };
324 MFT_REGISTER_TYPE_INFO color_convert_output_types[] =
325 {
326 {MFMediaType_Video, MFVideoFormat_YV12},
327 {MFMediaType_Video, MFVideoFormat_YUY2},
328 {MFMediaType_Video, MFVideoFormat_UYVY},
329 {MFMediaType_Video, MFVideoFormat_AYUV},
330 {MFMediaType_Video, MFVideoFormat_NV12},
331 {MFMediaType_Video, DMOVideoFormat_RGB32},
332 {MFMediaType_Video, DMOVideoFormat_RGB565},
333 {MFMediaType_Video, MFVideoFormat_I420},
334 {MFMediaType_Video, MFVideoFormat_IYUV},
335 {MFMediaType_Video, MFVideoFormat_YVYU},
336 {MFMediaType_Video, DMOVideoFormat_RGB24},
337 {MFMediaType_Video, DMOVideoFormat_RGB555},
338 {MFMediaType_Video, DMOVideoFormat_RGB8},
339 {MFMediaType_Video, MEDIASUBTYPE_V216},
340 {MFMediaType_Video, MEDIASUBTYPE_V410},
341 {MFMediaType_Video, MFVideoFormat_NV11},
342 };
343
344 struct mft
345 {
346 GUID clsid;
347 GUID category;
348 WCHAR name[MAX_PATH];
349 UINT32 flags;
350 UINT32 input_types_count;
351 MFT_REGISTER_TYPE_INFO *input_types;
352 UINT32 output_types_count;
353 MFT_REGISTER_TYPE_INFO *output_types;
354 }
355 mfts[] =
356 {
357 {
358 CLSID_MSAACDecMFT,
359 MFT_CATEGORY_AUDIO_DECODER,
360 L"Microsoft AAC Audio Decoder MFT",
361 MFT_ENUM_FLAG_SYNCMFT,
362 ARRAY_SIZE(aac_decoder_input_types),
363 aac_decoder_input_types,
364 ARRAY_SIZE(aac_decoder_output_types),
365 aac_decoder_output_types,
366 },
367 {
368 CLSID_WMADecMediaObject,
369 MFT_CATEGORY_AUDIO_DECODER,
370 L"WMAudio Decoder MFT",
371 MFT_ENUM_FLAG_SYNCMFT,
372 ARRAY_SIZE(wma_decoder_input_types),
373 wma_decoder_input_types,
374 ARRAY_SIZE(wma_decoder_output_types),
375 wma_decoder_output_types,
376 },
377 {
378 CLSID_MSH264DecoderMFT,
379 MFT_CATEGORY_VIDEO_DECODER,
380 L"Microsoft H264 Video Decoder MFT",
381 MFT_ENUM_FLAG_SYNCMFT,
382 ARRAY_SIZE(h264_decoder_input_types),
383 h264_decoder_input_types,
384 ARRAY_SIZE(h264_decoder_output_types),
385 h264_decoder_output_types,
386 },
387 {
388 CLSID_MSH264EncoderMFT,
389 MFT_CATEGORY_VIDEO_ENCODER,
390 L"H264 Encoder MFT",
391 MFT_ENUM_FLAG_SYNCMFT,
392 ARRAY_SIZE(h264_encoder_input_types),
393 h264_encoder_input_types,
394 ARRAY_SIZE(h264_encoder_output_types),
395 h264_encoder_output_types,
396 },
397 {
398 CLSID_WMVDecoderMFT,
399 MFT_CATEGORY_VIDEO_DECODER,
400 L"WMVideo Decoder MFT",
401 MFT_ENUM_FLAG_SYNCMFT,
402 ARRAY_SIZE(wmv_decoder_input_types),
403 wmv_decoder_input_types,
404 ARRAY_SIZE(wmv_decoder_output_types),
405 wmv_decoder_output_types,
406 },
407 {
408 CLSID_VideoProcessorMFT,
409 MFT_CATEGORY_VIDEO_PROCESSOR,
410 L"Microsoft Video Processor MFT",
411 MFT_ENUM_FLAG_SYNCMFT,
412 ARRAY_SIZE(video_processor_input_types),
413 video_processor_input_types,
414 ARRAY_SIZE(video_processor_output_types),
415 video_processor_output_types,
416 },
417 {
418 CLSID_CResamplerMediaObject,
419 MFT_CATEGORY_AUDIO_EFFECT,
420 L"Resampler MFT",
421 MFT_ENUM_FLAG_SYNCMFT,
422 ARRAY_SIZE(resampler_types),
423 resampler_types,
424 ARRAY_SIZE(resampler_types),
425 resampler_types,
426 },
427 {
428 CLSID_CColorConvertDMO,
429 MFT_CATEGORY_VIDEO_EFFECT,
430 L"Color Converter MFT",
431 MFT_ENUM_FLAG_SYNCMFT,
432 ARRAY_SIZE(color_convert_input_types),
433 color_convert_input_types,
434 ARRAY_SIZE(color_convert_output_types),
435 color_convert_output_types,
436 },
437 };
438
439 unsigned int i;
440 HRESULT hr;
441
442 for (i = 0; i < ARRAY_SIZE(mfts); i++)
443 {
444 hr = MFTRegister(mfts[i].clsid, mfts[i].category, mfts[i].name, mfts[i].flags, mfts[i].input_types_count,
445 mfts[i].input_types, mfts[i].output_types_count, mfts[i].output_types, NULL);
446
447 if (FAILED(hr))
448 {
449 FIXME("Failed to register MFT, hr %#lx.\n", hr);
450 return hr;
451 }
452 }
453
454 return S_OK;
455 }
456
457 static const struct
458 {
459 const GUID *subtype;
460 enum wg_video_format format;
461 }
462 video_formats[] =
463 {
464 {&MFVideoFormat_ARGB32, WG_VIDEO_FORMAT_BGRA},
465 {&MFVideoFormat_RGB32, WG_VIDEO_FORMAT_BGRx},
466 {&MFVideoFormat_RGB24, WG_VIDEO_FORMAT_BGR},
467 {&MFVideoFormat_RGB555, WG_VIDEO_FORMAT_RGB15},
468 {&MFVideoFormat_RGB565, WG_VIDEO_FORMAT_RGB16},
469 {&MFVideoFormat_ABGR32, WG_VIDEO_FORMAT_RGBA},
470 {&MFVideoFormat_AYUV, WG_VIDEO_FORMAT_AYUV},
471 {&MFVideoFormat_I420, WG_VIDEO_FORMAT_I420},
472 {&MFVideoFormat_IYUV, WG_VIDEO_FORMAT_I420},
473 {&MFVideoFormat_NV12, WG_VIDEO_FORMAT_NV12},
474 {&MFVideoFormat_UYVY, WG_VIDEO_FORMAT_UYVY},
475 {&MFVideoFormat_YUY2, WG_VIDEO_FORMAT_YUY2},
476 {&MFVideoFormat_YV12, WG_VIDEO_FORMAT_YV12},
477 {&MFVideoFormat_YVYU, WG_VIDEO_FORMAT_YVYU},
478 };
479
480 static const struct
481 {
482 const GUID *subtype;
483 UINT32 depth;
484 enum wg_audio_format format;
485 }
486 audio_formats[] =
487 {
488 {&MFAudioFormat_PCM, 8, WG_AUDIO_FORMAT_U8},
489 {&MFAudioFormat_PCM, 16, WG_AUDIO_FORMAT_S16LE},
490 {&MFAudioFormat_PCM, 24, WG_AUDIO_FORMAT_S24LE},
491 {&MFAudioFormat_PCM, 32, WG_AUDIO_FORMAT_S32LE},
492 {&MFAudioFormat_Float, 32, WG_AUDIO_FORMAT_F32LE},
493 {&MFAudioFormat_Float, 64, WG_AUDIO_FORMAT_F64LE},
494 };
495
496 static inline UINT64 make_uint64(UINT32 high, UINT32 low)
497 {
498 return ((UINT64)high << 32) | low;
499 }
500
501 static IMFMediaType *mf_media_type_from_wg_format_audio(const struct wg_format *format)
502 {
503 unsigned int i, block_align;
504 IMFMediaType *type;
505
506 for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
507 {
508 if (format->u.audio.format == audio_formats[i].format)
509 {
510 if (FAILED(MFCreateMediaType(&type)))
511 return NULL;
512
513 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
514 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, audio_formats[i].subtype);
515 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, audio_formats[i].depth);
516 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->u.audio.rate);
517 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
518 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
519 IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
520
521 block_align = format->u.audio.channels * audio_formats[i].depth / 8;
522 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, block_align);
523 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, block_align * format->u.audio.rate);
524
525 return type;
526 }
527 }
528
529 FIXME("Unknown audio format %#x.\n", format->u.audio.format);
530 return NULL;
531 }
532
533 static IMFMediaType *mf_media_type_from_wg_format_video(const struct wg_format *format)
534 {
535 IMFMediaType *type;
536 unsigned int i;
537
538 for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
539 {
540 if (format->u.video.format == video_formats[i].format)
541 {
542 unsigned int stride = wg_format_get_stride(format);
543 int32_t height = abs(format->u.video.height);
544 int32_t width = format->u.video.width;
545
546 if (FAILED(MFCreateMediaType(&type)))
547 return NULL;
548
549 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
550 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, video_formats[i].subtype);
551 IMFMediaType_SetUINT64(type, &MF_MT_FRAME_SIZE, make_uint64(width, height));
552 IMFMediaType_SetUINT64(type, &MF_MT_FRAME_RATE,
553 make_uint64(format->u.video.fps_n, format->u.video.fps_d));
554 IMFMediaType_SetUINT32(type, &MF_MT_COMPRESSED, FALSE);
555 IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
556 IMFMediaType_SetUINT32(type, &MF_MT_VIDEO_ROTATION, MFVideoRotationFormat_0);
557
558 if (format->u.video.height < 0)
559 stride = -stride;
560 IMFMediaType_SetUINT32(type, &MF_MT_DEFAULT_STRIDE, stride);
561
562 if (format->u.video.padding.left || format->u.video.padding.right
563 || format->u.video.padding.top || format->u.video.padding.bottom)
564 {
565 MFVideoArea aperture =
566 {
567 .OffsetX = {.value = format->u.video.padding.left},
568 .OffsetY = {.value = format->u.video.padding.top},
569 .Area.cx = width - format->u.video.padding.right - format->u.video.padding.left,
570 .Area.cy = height - format->u.video.padding.bottom - format->u.video.padding.top,
571 };
572
573 IMFMediaType_SetBlob(type, &MF_MT_MINIMUM_DISPLAY_APERTURE,
574 (BYTE *)&aperture, sizeof(aperture));
575 IMFMediaType_SetBlob(type, &MF_MT_GEOMETRIC_APERTURE,
576 (BYTE *)&aperture, sizeof(aperture));
577 IMFMediaType_SetBlob(type, &MF_MT_PAN_SCAN_APERTURE,
578 (BYTE *)&aperture, sizeof(aperture));
579 }
580
581 return type;
582 }
583 }
584
585 FIXME("Unknown video format %#x.\n", format->u.video.format);
586 return NULL;
587 }
588
589 static IMFMediaType *mf_media_type_from_wg_format_audio_mpeg1(const struct wg_format *format)
590 {
591 IMFMediaType *type;
592
593 if (FAILED(MFCreateMediaType(&type)))
594 return NULL;
595
596 if (format->u.audio.layer != 3)
597 FIXME("Unhandled layer %#x.\n", format->u.audio.layer);
598
599 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
600 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFAudioFormat_MP3);
601 IMFMediaType_SetGUID(type, &MF_MT_AM_FORMAT_TYPE, &FORMAT_WaveFormatEx);
602 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
603 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
604 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_PREFER_WAVEFORMATEX, TRUE);
605 IMFMediaType_SetUINT32(type, &MF_MT_FIXED_SIZE_SAMPLES, TRUE);
606 IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
607
608 return type;
609 }
610
611 static IMFMediaType *mf_media_type_from_wg_format_audio_mpeg4(const struct wg_format *format)
612 {
613 IMFMediaType *type;
614
615 if (FAILED(MFCreateMediaType(&type)))
616 return NULL;
617
618 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
619 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFAudioFormat_AAC);
620 IMFMediaType_SetGUID(type, &MF_MT_AM_FORMAT_TYPE, &FORMAT_WaveFormatEx);
621 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 16);
622 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->u.audio.rate);
623 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
624 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
625 IMFMediaType_SetUINT32(type, &MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0); /* unknown */
626 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_PREFER_WAVEFORMATEX, TRUE);
627 IMFMediaType_SetUINT32(type, &MF_MT_FIXED_SIZE_SAMPLES, TRUE);
628 IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
629 IMFMediaType_SetBlob(type, &MF_MT_USER_DATA, format->u.audio.codec_data, format->u.audio.codec_data_len);
630
631 return type;
632 }
633
634 static IMFMediaType *mf_media_type_from_wg_format_h264(const struct wg_format *format)
635 {
636 IMFMediaType *type;
637
638 if (FAILED(MFCreateMediaType(&type)))
639 return NULL;
640
641 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
642 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFVideoFormat_H264);
643 IMFMediaType_SetGUID(type, &MF_MT_AM_FORMAT_TYPE, &FORMAT_MPEG2Video);
644 IMFMediaType_SetUINT64(type, &MF_MT_FRAME_SIZE,
645 make_uint64(format->u.video.width, format->u.video.height));
646 IMFMediaType_SetUINT64(type, &MF_MT_FRAME_RATE,
647 make_uint64(format->u.video.fps_n, format->u.video.fps_d));
648 IMFMediaType_SetUINT32(type, &MF_MT_VIDEO_ROTATION, MFVideoRotationFormat_0);
649 IMFMediaType_SetUINT32(type, &MF_MT_MPEG2_PROFILE, format->u.video.profile);
650 IMFMediaType_SetUINT32(type, &MF_MT_MPEG2_LEVEL, format->u.video.level);
651
652 return type;
653 }
654
655 static IMFMediaType *mf_media_type_from_wg_format_wmv(const struct wg_format *format)
656 {
657 IMFMediaType *type;
658
659 if (FAILED(MFCreateMediaType(&type)))
660 return NULL;
661
662 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
663
664 if (format->u.video.format == WG_VIDEO_FORMAT_WMV1)
665 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_WMV1);
666 else if (format->u.video.format == WG_VIDEO_FORMAT_WMV2)
667 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_WMV2);
668 else if (format->u.video.format == WG_VIDEO_FORMAT_WMV3)
669 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_WMV3);
670 else if (format->u.video.format == WG_VIDEO_FORMAT_WMVA)
671 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_WMVA);
672 else if (format->u.video.format == WG_VIDEO_FORMAT_WVC1)
673 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_WVC1);
674 else
675 FIXME("Unhandled format %#x.\n", format->u.video.format);
676
677 IMFMediaType_SetUINT64(type, &MF_MT_FRAME_SIZE,
678 make_uint64(format->u.video.width, format->u.video.height));
679 IMFMediaType_SetUINT32(type, &MF_MT_VIDEO_ROTATION, MFVideoRotationFormat_0);
680
681 if (format->u.video.codec_data_len)
682 IMFMediaType_SetBlob(type, &MF_MT_USER_DATA, format->u.video.codec_data, format->u.video.codec_data_len);
683
684 return type;
685 }
686
687 static IMFMediaType *mf_media_type_from_wg_format_wma(const struct wg_format *format)
688 {
689 IMFMediaType *type;
690
691 if (FAILED(MFCreateMediaType(&type)))
692 return NULL;
693
694 IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
695
696 if (format->u.audio.version == 1)
697 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MEDIASUBTYPE_MSAUDIO1);
698 else if (format->u.audio.version == 2)
699 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFAudioFormat_WMAudioV8);
700 else if (format->u.audio.version == 3)
701 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFAudioFormat_WMAudioV9);
702 else if (format->u.audio.version == 4)
703 IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, &MFAudioFormat_WMAudio_Lossless);
704 else
705 FIXME("Unhandled version %#x.\n", format->u.audio.version);
706
707 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->u.audio.rate);
708 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
709 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
710 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, format->u.audio.bitrate / 8);
711 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_PREFER_WAVEFORMATEX, TRUE);
712 IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, format->u.audio.block_align);
713 IMFMediaType_SetBlob(type, &MF_MT_USER_DATA, format->u.audio.codec_data, format->u.audio.codec_data_len);
714
715 return type;
716 }
717
718 IMFMediaType *mf_media_type_from_wg_format(const struct wg_format *format)
719 {
720 switch (format->major_type)
721 {
722 case WG_MAJOR_TYPE_VIDEO_CINEPAK:
723 case WG_MAJOR_TYPE_VIDEO_INDEO:
724 case WG_MAJOR_TYPE_VIDEO_MPEG1:
725 FIXME("Format %u not implemented!\n", format->major_type);
726 /* fallthrough */
727 case WG_MAJOR_TYPE_UNKNOWN:
728 return NULL;
729
730 case WG_MAJOR_TYPE_AUDIO:
731 return mf_media_type_from_wg_format_audio(format);
732
733 case WG_MAJOR_TYPE_VIDEO:
734 return mf_media_type_from_wg_format_video(format);
735
736 case WG_MAJOR_TYPE_VIDEO_H264:
737 return mf_media_type_from_wg_format_h264(format);
738
739 case WG_MAJOR_TYPE_AUDIO_MPEG1:
740 return mf_media_type_from_wg_format_audio_mpeg1(format);
741
742 case WG_MAJOR_TYPE_AUDIO_MPEG4:
743 return mf_media_type_from_wg_format_audio_mpeg4(format);
744
745 case WG_MAJOR_TYPE_VIDEO_WMV:
746 return mf_media_type_from_wg_format_wmv(format);
747
748 case WG_MAJOR_TYPE_AUDIO_WMA:
749 return mf_media_type_from_wg_format_wma(format);
750 }
751
752 assert(0);
753 return NULL;
754 }
755
756 static void mf_media_type_to_wg_format_audio(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
757 {
758 UINT32 rate, channels, channel_mask, depth;
759 unsigned int i;
760
761 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
762 {
763 FIXME("Sample rate is not set.\n");
764 return;
765 }
766 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
767 {
768 FIXME("Channel count is not set.\n");
769 return;
770 }
771 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &depth)))
772 {
773 FIXME("Depth is not set.\n");
774 return;
775 }
776 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, &channel_mask)))
777 {
778 if (channels == 1)
779 channel_mask = KSAUDIO_SPEAKER_MONO;
780 else if (channels == 2)
781 channel_mask = KSAUDIO_SPEAKER_STEREO;
782 else
783 {
784 FIXME("Channel mask is not set.\n");
785 return;
786 }
787 }
788
789 format->major_type = WG_MAJOR_TYPE_AUDIO;
790 format->u.audio.channels = channels;
791 format->u.audio.channel_mask = channel_mask;
792 format->u.audio.rate = rate;
793
794 for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
795 {
796 if (IsEqualGUID(subtype, audio_formats[i].subtype) && depth == audio_formats[i].depth)
797 {
798 format->u.audio.format = audio_formats[i].format;
799 return;
800 }
801 }
802 FIXME("Unrecognized audio subtype %s, depth %u.\n", debugstr_guid(subtype), depth);
803 }
804
805 static void mf_media_type_to_wg_format_audio_mpeg(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
806 {
807 MPEG1WAVEFORMAT wfx = {0};
808 UINT32 codec_data_size;
809 UINT32 rate, channels;
810
811 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
812 {
813 FIXME("Sample rate is not set.\n");
814 return;
815 }
816 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
817 {
818 FIXME("Channel count is not set.\n");
819 return;
820 }
821 if (FAILED(IMFMediaType_GetBlob(type, &MF_MT_USER_DATA, (UINT8 *)(&wfx.wfx + 1),
822 sizeof(wfx) - sizeof(WAVEFORMATEX), &codec_data_size)))
823 {
824 FIXME("Codec data is not set.\n");
825 return;
826 }
827 if (codec_data_size < sizeof(wfx) - sizeof(WAVEFORMATEX))
828 {
829 FIXME("Codec data is incomplete.\n");
830 return;
831 }
832
833 format->major_type = WG_MAJOR_TYPE_AUDIO_MPEG1;
834 format->u.audio.channels = channels;
835 format->u.audio.rate = rate;
836 format->u.audio.layer = wfx.fwHeadLayer;
837 }
838
839 static void mf_media_type_to_wg_format_audio_mpeg_layer3(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
840 {
841 UINT32 rate, channels;
842
843 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
844 {
845 FIXME("Sample rate is not set.\n");
846 return;
847 }
848 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
849 {
850 FIXME("Channel count is not set.\n");
851 return;
852 }
853
854 format->major_type = WG_MAJOR_TYPE_AUDIO_MPEG1;
855 format->u.audio.channels = channels;
856 format->u.audio.rate = rate;
857 format->u.audio.layer = 3;
858 }
859
860 static void mf_media_type_to_wg_format_audio_mpeg4(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
861 {
862 BYTE buffer[sizeof(HEAACWAVEFORMAT) + 64];
863 HEAACWAVEFORMAT *wfx = (HEAACWAVEFORMAT *)buffer;
864 UINT32 codec_data_size;
865 BOOL raw_aac;
866
867 wfx->wfInfo.wfx.cbSize = sizeof(buffer) - sizeof(wfx->wfInfo.wfx);
868 if (FAILED(IMFMediaType_GetBlob(type, &MF_MT_USER_DATA, (BYTE *)(&wfx->wfInfo.wfx + 1),
869 wfx->wfInfo.wfx.cbSize, &codec_data_size)))
870 {
871 FIXME("Codec data is not set.\n");
872 return;
873 }
874
875 raw_aac = IsEqualGUID(subtype, &MFAudioFormat_RAW_AAC);
876 if (!raw_aac)
877 codec_data_size -= min(codec_data_size, sizeof(HEAACWAVEINFO) - sizeof(WAVEFORMATEX));
878 if (codec_data_size > sizeof(format->u.audio.codec_data))
879 {
880 FIXME("Codec data needs %u bytes.\n", codec_data_size);
881 return;
882 }
883 if (raw_aac)
884 memcpy(format->u.audio.codec_data, (BYTE *)(&wfx->wfInfo.wfx + 1), codec_data_size);
885 else
886 memcpy(format->u.audio.codec_data, wfx->pbAudioSpecificConfig, codec_data_size);
887
888 format->major_type = WG_MAJOR_TYPE_AUDIO_MPEG4;
889
890 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AAC_PAYLOAD_TYPE, &format->u.audio.payload_type)))
891 format->u.audio.payload_type = 0;
892
893 format->u.audio.codec_data_len = codec_data_size;
894 }
895
896 static enum wg_video_format mf_video_format_to_wg(const GUID *subtype)
897 {
898 unsigned int i;
899
900 for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
901 {
902 if (IsEqualGUID(subtype, video_formats[i].subtype))
903 return video_formats[i].format;
904 }
905 FIXME("Unrecognized video subtype %s.\n", debugstr_guid(subtype));
906 return WG_VIDEO_FORMAT_UNKNOWN;
907 }
908
909 static void mf_media_type_to_wg_format_video(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
910 {
911 UINT64 frame_rate, frame_size;
912 MFVideoArea aperture;
913 UINT32 size, stride;
914
915 if (FAILED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
916 {
917 FIXME("Frame size is not set.\n");
918 return;
919 }
920
921 format->major_type = WG_MAJOR_TYPE_VIDEO;
922 format->u.video.width = (UINT32)(frame_size >> 32);
923 format->u.video.height = (UINT32)frame_size;
924 format->u.video.fps_n = 1;
925 format->u.video.fps_d = 1;
926
927 if (SUCCEEDED(IMFMediaType_GetBlob(type, &MF_MT_MINIMUM_DISPLAY_APERTURE, (BYTE *)&aperture,
928 sizeof(aperture), &size)) && size == sizeof(aperture))
929 {
930 format->u.video.padding.left = aperture.OffsetX.value;
931 format->u.video.padding.top = aperture.OffsetY.value;
932 format->u.video.padding.right = format->u.video.width - aperture.Area.cx - aperture.OffsetX.value;
933 format->u.video.padding.bottom = format->u.video.height - aperture.Area.cy - aperture.OffsetY.value;
934 }
935
936 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
937 {
938 format->u.video.fps_n = (UINT32)(frame_rate >> 32);
939 format->u.video.fps_d = (UINT32)frame_rate;
940 }
941
942 format->u.video.format = mf_video_format_to_wg(subtype);
943
944 if (SUCCEEDED(IMFMediaType_GetUINT32(type, &MF_MT_DEFAULT_STRIDE, &stride)))
945 {
946 if ((int)stride < 0)
947 format->u.video.height = -format->u.video.height;
948 }
949 else if (wg_video_format_is_rgb(format->u.video.format))
950 {
951 format->u.video.height = -format->u.video.height;
952 }
953 }
954
955 static void mf_media_type_to_wg_format_audio_wma(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
956 {
957 UINT32 rate, depth, channels, block_align, bytes_per_second, codec_data_len;
958 BYTE codec_data[64];
959 UINT32 version;
960
961 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
962 {
963 FIXME("Sample rate is not set.\n");
964 return;
965 }
966 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
967 {
968 FIXME("Channel count is not set.\n");
969 return;
970 }
971 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_align)))
972 {
973 FIXME("Block alignment is not set.\n");
974 return;
975 }
976 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &depth)))
977 {
978 FIXME("Depth is not set.\n");
979 return;
980 }
981 if (FAILED(IMFMediaType_GetBlob(type, &MF_MT_USER_DATA, codec_data, sizeof(codec_data), &codec_data_len)))
982 {
983 FIXME("Codec data is not set.\n");
984 return;
985 }
986 if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &bytes_per_second)))
987 {
988 FIXME("Bitrate is not set.\n");
989 bytes_per_second = 0;
990 }
991
992 if (IsEqualGUID(subtype, &MEDIASUBTYPE_MSAUDIO1))
993 version = 1;
994 else if (IsEqualGUID(subtype, &MFAudioFormat_WMAudioV8))
995 version = 2;
996 else if (IsEqualGUID(subtype, &MFAudioFormat_WMAudioV9))
997 version = 3;
998 else if (IsEqualGUID(subtype, &MFAudioFormat_WMAudio_Lossless))
999 version = 4;
1000 else
1001 {
1002 assert(0);
1003 return;
1004 }
1005
1006 format->major_type = WG_MAJOR_TYPE_AUDIO_WMA;
1007 format->u.audio.version = version;
1008 format->u.audio.bitrate = bytes_per_second * 8;
1009 format->u.audio.rate = rate;
1010 format->u.audio.depth = depth;
1011 format->u.audio.channels = channels;
1012 format->u.audio.block_align = block_align;
1013 format->u.audio.codec_data_len = codec_data_len;
1014 memcpy(format->u.audio.codec_data, codec_data, codec_data_len);
1015 }
1016
1017 static void mf_media_type_to_wg_format_video_h264(IMFMediaType *type, struct wg_format *format)
1018 {
1019 UINT32 profile, level, codec_data_len;
1020 UINT64 frame_rate, frame_size;
1021 BYTE *codec_data;
1022
1023 memset(format, 0, sizeof(*format));
1024 format->major_type = WG_MAJOR_TYPE_VIDEO_H264;
1025
1026 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
1027 {
1028 format->u.video.width = frame_size >> 32;
1029 format->u.video.height = (UINT32)frame_size;
1030 }
1031
1032 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
1033 {
1034 format->u.video.fps_n = frame_rate >> 32;
1035 format->u.video.fps_d = (UINT32)frame_rate;
1036 }
1037 else
1038 {
1039 format->u.video.fps_n = 1;
1040 format->u.video.fps_d = 1;
1041 }
1042
1043 if (SUCCEEDED(IMFMediaType_GetUINT32(type, &MF_MT_MPEG2_PROFILE, &profile)))
1044 format->u.video.profile = profile;
1045
1046 if (SUCCEEDED(IMFMediaType_GetUINT32(type, &MF_MT_MPEG2_LEVEL, &level)))
1047 format->u.video.level = level;
1048
1049 if (SUCCEEDED(IMFMediaType_GetAllocatedBlob(type, &MF_MT_MPEG_SEQUENCE_HEADER, &codec_data, &codec_data_len)))
1050 {
1051 if (codec_data_len <= sizeof(format->u.video.codec_data))
1052 {
1053 format->u.video.codec_data_len = codec_data_len;
1054 memcpy(format->u.video.codec_data, codec_data, codec_data_len);
1055 }
1056 else
1057 {
1058 WARN("Codec data buffer too small, codec data size %u.\n", codec_data_len);
1059 }
1060 CoTaskMemFree(codec_data);
1061 }
1062 }
1063
1064 static void mf_media_type_to_wg_format_video_indeo(IMFMediaType *type, uint32_t version, struct wg_format *format)
1065 {
1066 UINT64 frame_rate, frame_size;
1067
1068 memset(format, 0, sizeof(*format));
1069 format->major_type = WG_MAJOR_TYPE_VIDEO_INDEO;
1070
1071 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
1072 {
1073 format->u.video.width = frame_size >> 32;
1074 format->u.video.height = (UINT32)frame_size;
1075 }
1076
1077 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
1078 {
1079 format->u.video.fps_n = frame_rate >> 32;
1080 format->u.video.fps_d = (UINT32)frame_rate;
1081 }
1082 else
1083 {
1084 format->u.video.fps_n = 1;
1085 format->u.video.fps_d = 1;
1086 }
1087
1088 format->u.video.version = version;
1089 }
1090
1091 static void mf_media_type_to_wg_format_video_wmv(IMFMediaType *type, const GUID *subtype, struct wg_format *format)
1092 {
1093 UINT64 frame_rate, frame_size;
1094 UINT32 codec_data_len;
1095 BYTE *codec_data;
1096
1097 memset(format, 0, sizeof(*format));
1098 format->major_type = WG_MAJOR_TYPE_VIDEO_WMV;
1099
1100 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
1101 {
1102 format->u.video.width = frame_size >> 32;
1103 format->u.video.height = (UINT32)frame_size;
1104 }
1105
1106 if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
1107 {
1108 format->u.video.fps_n = frame_rate >> 32;
1109 format->u.video.fps_d = (UINT32)frame_rate;
1110 }
1111 else
1112 {
1113 format->u.video.fps_n = 1;
1114 format->u.video.fps_d = 1;
1115 }
1116
1117 if (IsEqualGUID(subtype, &MEDIASUBTYPE_WMV1))
1118 format->u.video.format = WG_VIDEO_FORMAT_WMV1;
1119 else if (IsEqualGUID(subtype, &MEDIASUBTYPE_WMV2))
1120 format->u.video.format = WG_VIDEO_FORMAT_WMV2;
1121 else if (IsEqualGUID(subtype, &MEDIASUBTYPE_WMV3))
1122 format->u.video.format = WG_VIDEO_FORMAT_WMV3;
1123 else if (IsEqualGUID(subtype, &MEDIASUBTYPE_WMVA))
1124 format->u.video.format = WG_VIDEO_FORMAT_WMVA;
1125 else if (IsEqualGUID(subtype, &MEDIASUBTYPE_WVC1))
1126 format->u.video.format = WG_VIDEO_FORMAT_WVC1;
1127 else
1128 format->u.video.format = WG_VIDEO_FORMAT_UNKNOWN;
1129
1130 if (SUCCEEDED(IMFMediaType_GetAllocatedBlob(type, &MF_MT_USER_DATA, &codec_data, &codec_data_len)))
1131 {
1132 if (codec_data_len <= sizeof(format->u.video.codec_data))
1133 {
1134 format->u.video.codec_data_len = codec_data_len;
1135 memcpy(format->u.video.codec_data, codec_data, codec_data_len);
1136 }
1137 else
1138 {
1139 WARN("Codec data buffer too small, codec data size %u.\n", codec_data_len);
1140 }
1141 CoTaskMemFree(codec_data);
1142 }
1143 }
1144
1145 void mf_media_type_to_wg_format(IMFMediaType *type, struct wg_format *format)
1146 {
1147 GUID major_type, subtype;
1148
1149 memset(format, 0, sizeof(*format));
1150
1151 if (FAILED(IMFMediaType_GetMajorType(type, &major_type)))
1152 {
1153 FIXME("Major type is not set.\n");
1154 return;
1155 }
1156 if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
1157 {
1158 FIXME("Subtype is not set.\n");
1159 return;
1160 }
1161
1162 if (IsEqualGUID(&major_type, &MFMediaType_Audio))
1163 {
1164 if (IsEqualGUID(&subtype, &MFAudioFormat_MPEG))
1165 mf_media_type_to_wg_format_audio_mpeg(type, &subtype, format);
1166 else if (IsEqualGUID(&subtype, &MFAudioFormat_MP3))
1167 mf_media_type_to_wg_format_audio_mpeg_layer3(type, &subtype, format);
1168 else if (IsEqualGUID(&subtype, &MEDIASUBTYPE_MSAUDIO1) ||
1169 IsEqualGUID(&subtype, &MFAudioFormat_WMAudioV8) ||
1170 IsEqualGUID(&subtype, &MFAudioFormat_WMAudioV9) ||
1171 IsEqualGUID(&subtype, &MFAudioFormat_WMAudio_Lossless))
1172 mf_media_type_to_wg_format_audio_wma(type, &subtype, format);
1173 else if (IsEqualGUID(&subtype, &MFAudioFormat_AAC) || IsEqualGUID(&subtype, &MFAudioFormat_RAW_AAC))
1174 mf_media_type_to_wg_format_audio_mpeg4(type, &subtype, format);
1175 else
1176 mf_media_type_to_wg_format_audio(type, &subtype, format);
1177 }
1178 else if (IsEqualGUID(&major_type, &MFMediaType_Video))
1179 {
1180 if (IsEqualGUID(&subtype, &MFVideoFormat_H264))
1181 mf_media_type_to_wg_format_video_h264(type, format);
1182 else if (IsEqualGUID(&subtype, &MFVideoFormat_IV50))
1183 mf_media_type_to_wg_format_video_indeo(type, 5, format);
1184 else if (IsEqualGUID(&subtype, &MEDIASUBTYPE_WMV1)
1185 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WMV2)
1186 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WMVA)
1187 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WMVP)
1188 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WVP2)
1189 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WMV_Unknown)
1190 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WVC1)
1191 || IsEqualGUID(&subtype, &MEDIASUBTYPE_WMV3)
1192 || IsEqualGUID(&subtype, &MFVideoFormat_VC1S))
1193 mf_media_type_to_wg_format_video_wmv(type, &subtype, format);
1194 else
1195 mf_media_type_to_wg_format_video(type, &subtype, format);
1196 }
1197 else
1198 FIXME("Unrecognized major type %s.\n", debugstr_guid(&major_type));
1199 }
Windows API implementation