dlls/winegstreamer/mfplat.c

   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 "mfapi.h"
  23 #include "ks.h"
  24 #include "ksmedia.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  29
  30 struct video_processor
  31 {
  32     IMFTransform IMFTransform_iface;
  33     LONG refcount;
  34     IMFAttributes *attributes;
  35     IMFAttributes *output_attributes;
  36 };
  37
  38 static struct video_processor *impl_video_processor_from_IMFTransform(IMFTransform *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct video_processor, IMFTransform_iface);
  41 }
  42
  43 static HRESULT WINAPI video_processor_QueryInterface(IMFTransform *iface, REFIID riid, void **obj)
  44 {
  45     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  46
  47     if (IsEqualIID(riid, &IID_IMFTransform) ||
  48             IsEqualIID(riid, &IID_IUnknown))
  49     {
  50         *obj = iface;
  51         IMFTransform_AddRef(iface);
  52         return S_OK;
  53     }
  54
  55     WARN("Unsupported %s.\n", debugstr_guid(riid));
  56     *obj = NULL;
  57     return E_NOINTERFACE;
  58 }
  59
  60 static ULONG WINAPI video_processor_AddRef(IMFTransform *iface)
  61 {
  62     struct video_processor *transform = impl_video_processor_from_IMFTransform(iface);
  63     ULONG refcount = InterlockedIncrement(&transform->refcount);
  64
  65     TRACE("%p, refcount %u.\n", iface, refcount);
  66
  67     return refcount;
  68 }
  69
  70 static ULONG WINAPI video_processor_Release(IMFTransform *iface)
  71 {
  72     struct video_processor *transform = impl_video_processor_from_IMFTransform(iface);
  73     ULONG refcount = InterlockedDecrement(&transform->refcount);
  74
  75     TRACE("%p, refcount %u.\n", iface, refcount);
  76
  77     if (!refcount)
  78     {
  79         if (transform->attributes)
  80             IMFAttributes_Release(transform->attributes);
  81         if (transform->output_attributes)
  82             IMFAttributes_Release(transform->output_attributes);
  83         free(transform);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 static HRESULT WINAPI video_processor_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum, DWORD *input_maximum,
  90         DWORD *output_minimum, DWORD *output_maximum)
  91 {
  92     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);
  93
  94     *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
  95
  96     return S_OK;
  97 }
  98
  99 static HRESULT WINAPI video_processor_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 100 {
 101     TRACE("%p, %p, %p.\n", iface, inputs, outputs);
 102
 103     *inputs = *outputs = 1;
 104
 105     return S_OK;
 106 }
 107
 108 static HRESULT WINAPI video_processor_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 109         DWORD output_size, DWORD *outputs)
 110 {
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT WINAPI video_processor_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 115 {
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT WINAPI video_processor_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 120 {
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI video_processor_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 125 {
 126     struct video_processor *transform = impl_video_processor_from_IMFTransform(iface);
 127
 128     TRACE("%p, %p.\n", iface, attributes);
 129
 130     *attributes = transform->attributes;
 131     IMFAttributes_AddRef(*attributes);
 132
 133     return S_OK;
 134 }
 135
 136 static HRESULT WINAPI video_processor_GetInputStreamAttributes(IMFTransform *iface, DWORD id,
 137         IMFAttributes **attributes)
 138 {
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI video_processor_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
 143         IMFAttributes **attributes)
 144 {
 145     struct video_processor *transform = impl_video_processor_from_IMFTransform(iface);
 146
 147     TRACE("%p, %u, %p.\n", iface, id, attributes);
 148
 149     *attributes = transform->output_attributes;
 150     IMFAttributes_AddRef(*attributes);
 151
 152     return S_OK;
 153 }
 154
 155 static HRESULT WINAPI video_processor_DeleteInputStream(IMFTransform *iface, DWORD id)
 156 {
 157     TRACE("%p, %u.\n", iface, id);
 158
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI video_processor_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 163 {
 164     TRACE("%p, %u, %p.\n", iface, streams, ids);
 165
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI video_processor_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 170         IMFMediaType **type)
 171 {
 172     FIXME("%p, %u, %u, %p.\n", iface, id, index, type);
 173
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI video_processor_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 178         IMFMediaType **type)
 179 {
 180     FIXME("%p, %u, %u, %p.\n", iface, id, index, type);
 181
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI video_processor_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 186 {
 187     FIXME("%p, %u, %p, %#x.\n", iface, id, type, flags);
 188
 189     return E_NOTIMPL;
 190 }
 191
 192 static HRESULT WINAPI video_processor_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 193 {
 194     FIXME("%p, %u, %p, %#x.\n", iface, id, type, flags);
 195
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI video_processor_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 200 {
 201     FIXME("%p, %u, %p.\n", iface, id, type);
 202
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI video_processor_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 207 {
 208     FIXME("%p, %u, %p.\n", iface, id, type);
 209
 210     return E_NOTIMPL;
 211 }
 212
 213 static HRESULT WINAPI video_processor_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
 214 {
 215     FIXME("%p, %u, %p.\n", iface, id, flags);
 216
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI video_processor_GetOutputStatus(IMFTransform *iface, DWORD *flags)
 221 {
 222     FIXME("%p, %p.\n", iface, flags);
 223
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI video_processor_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 228 {
 229     FIXME("%p, %s, %s.\n", iface, wine_dbgstr_longlong(lower), wine_dbgstr_longlong(upper));
 230
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI video_processor_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
 235 {
 236     TRACE("%p, %u, %p.\n", iface, id, event);
 237
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI video_processor_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
 242 {
 243     FIXME("%p, %u.\n", iface, message);
 244
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI video_processor_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
 249 {
 250     FIXME("%p, %u, %p, %#x.\n", iface, id, sample, flags);
 251
 252     return E_NOTIMPL;
 253 }
 254
 255 static HRESULT WINAPI video_processor_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
 256         MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status)
 257 {
 258     FIXME("%p, %#x, %u, %p, %p.\n", iface, flags, count, samples, status);
 259
 260     return E_NOTIMPL;
 261 }
 262
 263 static const IMFTransformVtbl video_processor_vtbl =
 264 {
 265     video_processor_QueryInterface,
 266     video_processor_AddRef,
 267     video_processor_Release,
 268     video_processor_GetStreamLimits,
 269     video_processor_GetStreamCount,
 270     video_processor_GetStreamIDs,
 271     video_processor_GetInputStreamInfo,
 272     video_processor_GetOutputStreamInfo,
 273     video_processor_GetAttributes,
 274     video_processor_GetInputStreamAttributes,
 275     video_processor_GetOutputStreamAttributes,
 276     video_processor_DeleteInputStream,
 277     video_processor_AddInputStreams,
 278     video_processor_GetInputAvailableType,
 279     video_processor_GetOutputAvailableType,
 280     video_processor_SetInputType,
 281     video_processor_SetOutputType,
 282     video_processor_GetInputCurrentType,
 283     video_processor_GetOutputCurrentType,
 284     video_processor_GetInputStatus,
 285     video_processor_GetOutputStatus,
 286     video_processor_SetOutputBounds,
 287     video_processor_ProcessEvent,
 288     video_processor_ProcessMessage,
 289     video_processor_ProcessInput,
 290     video_processor_ProcessOutput,
 291 };
 292
 293 struct class_factory
 294 {
 295     IClassFactory IClassFactory_iface;
 296     LONG refcount;
 297     HRESULT (*create_instance)(REFIID riid, void **obj);
 298 };
 299
 300 static struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 301 {
 302     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 303 }
 304
 305 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
 306 {
 307     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 308
 309     if (IsEqualGUID(riid, &IID_IClassFactory) ||
 310             IsEqualGUID(riid, &IID_IUnknown))
 311     {
 312         *obj = iface;
 313         IClassFactory_AddRef(iface);
 314         return S_OK;
 315     }
 316
 317     WARN("%s is not supported.\n", debugstr_guid(riid));
 318     *obj = NULL;
 319     return E_NOINTERFACE;
 320 }
 321
 322 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 323 {
 324     struct class_factory *factory = impl_from_IClassFactory(iface);
 325     return InterlockedIncrement(&factory->refcount);
 326 }
 327
 328 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 329 {
 330     struct class_factory *factory = impl_from_IClassFactory(iface);
 331     ULONG refcount = InterlockedDecrement(&factory->refcount);
 332
 333     if (!refcount)
 334         free(factory);
 335
 336     return refcount;
 337 }
 338
 339 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 340 {
 341     struct class_factory *factory = impl_from_IClassFactory(iface);
 342
 343     TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), obj);
 344
 345     if (outer)
 346     {
 347         *obj = NULL;
 348         return CLASS_E_NOAGGREGATION;
 349     }
 350
 351     return factory->create_instance(riid, obj);
 352 }
 353
 354 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 355 {
 356     TRACE("%p, %d.\n", iface, dolock);
 357
 358     if (dolock)
 359         InterlockedIncrement(&object_locks);
 360     else
 361         InterlockedDecrement(&object_locks);
 362
 363     return S_OK;
 364 }
 365
 366 static const IClassFactoryVtbl class_factory_vtbl =
 367 {
 368     class_factory_QueryInterface,
 369     class_factory_AddRef,
 370     class_factory_Release,
 371     class_factory_CreateInstance,
 372     class_factory_LockServer,
 373 };
 374
 375 static HRESULT video_processor_create(REFIID riid, void **ret)
 376 {
 377     struct video_processor *object;
 378     HRESULT hr;
 379
 380     if (!(object = calloc(1, sizeof(*object))))
 381         return E_OUTOFMEMORY;
 382
 383     object->IMFTransform_iface.lpVtbl = &video_processor_vtbl;
 384     object->refcount = 1;
 385
 386     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
 387         goto failed;
 388
 389     if (FAILED(hr = MFCreateAttributes(&object->output_attributes, 0)))
 390         goto failed;
 391
 392     *ret = &object->IMFTransform_iface;
 393     return S_OK;
 394
 395 failed:
 396
 397     IMFTransform_Release(&object->IMFTransform_iface);
 398     return hr;
 399 }
 400
 401 static const GUID CLSID_GStreamerByteStreamHandler = {0x317df618, 0x5e5a, 0x468a, {0x9f, 0x15, 0xd8, 0x27, 0xa9, 0xa0, 0x81, 0x62}};
 402
 403 static const GUID CLSID_WINEAudioConverter = {0x6a170414,0xaad9,0x4693,{0xb8,0x06,0x3a,0x0c,0x47,0xc5,0x70,0xd6}};
 404
 405 static const struct class_object
 406 {
 407     const GUID *clsid;
 408     HRESULT (*create_instance)(REFIID riid, void **obj);
 409 }
 410 class_objects[] =
 411 {
 412     { &CLSID_VideoProcessorMFT, &video_processor_create },
 413     { &CLSID_GStreamerByteStreamHandler, &winegstreamer_stream_handler_create },
 414     { &CLSID_WINEAudioConverter, &audio_converter_create },
 415 };
 416
 417 HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj)
 418 {
 419     struct class_factory *factory;
 420     unsigned int i;
 421     HRESULT hr;
 422
 423     for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
 424     {
 425         if (IsEqualGUID(class_objects[i].clsid, rclsid))
 426         {
 427             if (!(factory = malloc(sizeof(*factory))))
 428                 return E_OUTOFMEMORY;
 429
 430             factory->IClassFactory_iface.lpVtbl = &class_factory_vtbl;
 431             factory->refcount = 1;
 432             factory->create_instance = class_objects[i].create_instance;
 433
 434             hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj);
 435             IClassFactory_Release(&factory->IClassFactory_iface);
 436             return hr;
 437         }
 438     }
 439
 440     return CLASS_E_CLASSNOTAVAILABLE;
 441 }
 442
 443 static WCHAR audio_converterW[] = L"Audio Converter";
 444 static const GUID *audio_converter_supported_types[] =
 445 {
 446     &MFAudioFormat_PCM,
 447     &MFAudioFormat_Float,
 448 };
 449
 450 static const struct mft
 451 {
 452     const GUID *clsid;
 453     const GUID *category;
 454     LPWSTR name;
 455     const UINT32 flags;
 456     const GUID *major_type;
 457     const UINT32 input_types_count;
 458     const GUID **input_types;
 459     const UINT32 output_types_count;
 460     const GUID **output_types;
 461 }
 462 mfts[] =
 463 {
 464     {
 465         &CLSID_WINEAudioConverter,
 466         &MFT_CATEGORY_AUDIO_EFFECT,
 467         audio_converterW,
 468         MFT_ENUM_FLAG_SYNCMFT,
 469         &MFMediaType_Audio,
 470         ARRAY_SIZE(audio_converter_supported_types),
 471         audio_converter_supported_types,
 472         ARRAY_SIZE(audio_converter_supported_types),
 473         audio_converter_supported_types,
 474     },
 475 };
 476
 477 HRESULT mfplat_DllRegisterServer(void)
 478 {
 479     unsigned int i, j;
 480     HRESULT hr;
 481     MFT_REGISTER_TYPE_INFO input_types[2], output_types[2];
 482
 483     for (i = 0; i < ARRAY_SIZE(mfts); i++)
 484     {
 485         const struct mft *cur = &mfts[i];
 486
 487         for (j = 0; j < cur->input_types_count; j++)
 488         {
 489             input_types[j].guidMajorType = *(cur->major_type);
 490             input_types[j].guidSubtype = *(cur->input_types[j]);
 491         }
 492         for (j = 0; j < cur->output_types_count; j++)
 493         {
 494             output_types[j].guidMajorType = *(cur->major_type);
 495             output_types[j].guidSubtype = *(cur->output_types[j]);
 496         }
 497
 498         hr = MFTRegister(*(cur->clsid), *(cur->category), cur->name, cur->flags, cur->input_types_count,
 499                     input_types, cur->output_types_count, output_types, NULL);
 500
 501         if (FAILED(hr))
 502         {
 503             FIXME("Failed to register MFT, hr %#x\n", hr);
 504             return hr;
 505         }
 506     }
 507     return S_OK;
 508 }
 509
 510 static const struct
 511 {
 512     const GUID *subtype;
 513     enum wg_video_format format;
 514 }
 515 video_formats[] =
 516 {
 517     {&MFVideoFormat_ARGB32, WG_VIDEO_FORMAT_BGRA},
 518     {&MFVideoFormat_RGB32,  WG_VIDEO_FORMAT_BGRx},
 519     {&MFVideoFormat_RGB24,  WG_VIDEO_FORMAT_BGR},
 520     {&MFVideoFormat_RGB555, WG_VIDEO_FORMAT_RGB15},
 521     {&MFVideoFormat_RGB565, WG_VIDEO_FORMAT_RGB16},
 522     {&MFVideoFormat_AYUV,   WG_VIDEO_FORMAT_AYUV},
 523     {&MFVideoFormat_I420,   WG_VIDEO_FORMAT_I420},
 524     {&MFVideoFormat_NV12,   WG_VIDEO_FORMAT_NV12},
 525     {&MFVideoFormat_UYVY,   WG_VIDEO_FORMAT_UYVY},
 526     {&MFVideoFormat_YUY2,   WG_VIDEO_FORMAT_YUY2},
 527     {&MFVideoFormat_YV12,   WG_VIDEO_FORMAT_YV12},
 528     {&MFVideoFormat_YVYU,   WG_VIDEO_FORMAT_YVYU},
 529 };
 530
 531 static const struct
 532 {
 533     const GUID *subtype;
 534     UINT32 depth;
 535     enum wg_audio_format format;
 536 }
 537 audio_formats[] =
 538 {
 539     {&MFAudioFormat_PCM,     8, WG_AUDIO_FORMAT_U8},
 540     {&MFAudioFormat_PCM,    16, WG_AUDIO_FORMAT_S16LE},
 541     {&MFAudioFormat_PCM,    24, WG_AUDIO_FORMAT_S24LE},
 542     {&MFAudioFormat_PCM,    32, WG_AUDIO_FORMAT_S32LE},
 543     {&MFAudioFormat_Float,  32, WG_AUDIO_FORMAT_F32LE},
 544     {&MFAudioFormat_Float,  64, WG_AUDIO_FORMAT_F64LE},
 545 };
 546
 547 static inline UINT64 make_uint64(UINT32 high, UINT32 low)
 548 {
 549     return ((UINT64)high << 32) | low;
 550 }
 551
 552 static IMFMediaType *mf_media_type_from_wg_format_audio(const struct wg_format *format)
 553 {
 554     IMFMediaType *type;
 555     unsigned int i;
 556
 557     for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
 558     {
 559         if (format->u.audio.format == audio_formats[i].format)
 560         {
 561             if (FAILED(MFCreateMediaType(&type)))
 562                 return NULL;
 563
 564             IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
 565             IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, audio_formats[i].subtype);
 566             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, audio_formats[i].depth);
 567             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->u.audio.rate);
 568             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
 569             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
 570
 571             return type;
 572         }
 573     }
 574
 575     return NULL;
 576 }
 577
 578 static IMFMediaType *mf_media_type_from_wg_format_video(const struct wg_format *format)
 579 {
 580     IMFMediaType *type;
 581     unsigned int i;
 582
 583     for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
 584     {
 585         if (format->u.video.format == video_formats[i].format)
 586         {
 587             if (FAILED(MFCreateMediaType(&type)))
 588                 return NULL;
 589
 590             IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
 591             IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, video_formats[i].subtype);
 592             IMFMediaType_SetUINT64(type, &MF_MT_FRAME_SIZE,
 593                     make_uint64(format->u.video.width, format->u.video.height));
 594             IMFMediaType_SetUINT64(type, &MF_MT_FRAME_RATE,
 595                     make_uint64(format->u.video.fps_n, format->u.video.fps_d));
 596             IMFMediaType_SetUINT32(type, &MF_MT_COMPRESSED, FALSE);
 597
 598             return type;
 599         }
 600     }
 601
 602     return NULL;
 603 }
 604
 605 IMFMediaType *mf_media_type_from_wg_format(const struct wg_format *format)
 606 {
 607     switch (format->major_type)
 608     {
 609         case WG_MAJOR_TYPE_UNKNOWN:
 610             return NULL;
 611
 612         case WG_MAJOR_TYPE_AUDIO:
 613             return mf_media_type_from_wg_format_audio(format);
 614
 615         case WG_MAJOR_TYPE_VIDEO:
 616             return mf_media_type_from_wg_format_video(format);
 617     }
 618
 619     assert(0);
 620     return NULL;
 621 }
 622
 623 static void mf_media_type_to_wg_format_audio(IMFMediaType *type, struct wg_format *format)
 624 {
 625     UINT32 rate, channels, channel_mask, depth;
 626     unsigned int i;
 627     GUID subtype;
 628
 629     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 630     {
 631         FIXME("Subtype is not set.\n");
 632         return;
 633     }
 634     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
 635     {
 636         FIXME("Sample rate is not set.\n");
 637         return;
 638     }
 639     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
 640     {
 641         FIXME("Channel count is not set.\n");
 642         return;
 643     }
 644     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &depth)))
 645     {
 646         FIXME("Depth is not set.\n");
 647         return;
 648     }
 649     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, &channel_mask)))
 650     {
 651         if (channels == 1)
 652             channel_mask = KSAUDIO_SPEAKER_MONO;
 653         else if (channels == 2)
 654             channel_mask = KSAUDIO_SPEAKER_STEREO;
 655         else
 656         {
 657             FIXME("Channel mask is not set.\n");
 658             return;
 659         }
 660     }
 661
 662     format->major_type = WG_MAJOR_TYPE_AUDIO;
 663     format->u.audio.channels = channels;
 664     format->u.audio.channel_mask = channel_mask;
 665     format->u.audio.rate = rate;
 666
 667     for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
 668     {
 669         if (IsEqualGUID(&subtype, audio_formats[i].subtype) && depth == audio_formats[i].depth)
 670         {
 671             format->u.audio.format = audio_formats[i].format;
 672             return;
 673         }
 674     }
 675     FIXME("Unrecognized audio subtype %s, depth %u.\n", debugstr_guid(&subtype), depth);
 676 }
 677
 678 static void mf_media_type_to_wg_format_video(IMFMediaType *type, struct wg_format *format)
 679 {
 680     UINT64 frame_rate, frame_size;
 681     unsigned int i;
 682     GUID subtype;
 683
 684     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 685     {
 686         FIXME("Subtype is not set.\n");
 687         return;
 688     }
 689     if (FAILED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
 690     {
 691         FIXME("Frame size is not set.\n");
 692         return;
 693     }
 694
 695     format->major_type = WG_MAJOR_TYPE_VIDEO;
 696     format->u.video.width = (UINT32)(frame_size >> 32);
 697     format->u.video.height = (UINT32)frame_size;
 698     format->u.video.fps_n = 1;
 699     format->u.video.fps_d = 1;
 700
 701     if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
 702     {
 703         format->u.video.fps_n = (UINT32)(frame_rate >> 32);
 704         format->u.video.fps_d = (UINT32)frame_rate;
 705     }
 706
 707     for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
 708     {
 709         if (IsEqualGUID(&subtype, video_formats[i].subtype))
 710         {
 711             format->u.video.format = video_formats[i].format;
 712             return;
 713         }
 714     }
 715     FIXME("Unrecognized video subtype %s.\n", debugstr_guid(&subtype));
 716 }
 717
 718 void mf_media_type_to_wg_format(IMFMediaType *type, struct wg_format *format)
 719 {
 720     GUID major_type;
 721
 722     memset(format, 0, sizeof(*format));
 723
 724     if (FAILED(IMFMediaType_GetMajorType(type, &major_type)))
 725     {
 726         FIXME("Major type is not set.\n");
 727         return;
 728     }
 729
 730     if (IsEqualGUID(&major_type, &MFMediaType_Audio))
 731         mf_media_type_to_wg_format_audio(type, format);
 732     else if (IsEqualGUID(&major_type, &MFMediaType_Video))
 733         mf_media_type_to_wg_format_video(type, format);
 734     else
 735         FIXME("Unrecognized major type %s.\n", debugstr_guid(&major_type));
 736 }