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     return S_OK;
 358 }
 359
 360 static const IClassFactoryVtbl class_factory_vtbl =
 361 {
 362     class_factory_QueryInterface,
 363     class_factory_AddRef,
 364     class_factory_Release,
 365     class_factory_CreateInstance,
 366     class_factory_LockServer,
 367 };
 368
 369 static HRESULT video_processor_create(REFIID riid, void **ret)
 370 {
 371     struct video_processor *object;
 372     HRESULT hr;
 373
 374     if (!(object = calloc(1, sizeof(*object))))
 375         return E_OUTOFMEMORY;
 376
 377     object->IMFTransform_iface.lpVtbl = &video_processor_vtbl;
 378     object->refcount = 1;
 379
 380     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
 381         goto failed;
 382
 383     if (FAILED(hr = MFCreateAttributes(&object->output_attributes, 0)))
 384         goto failed;
 385
 386     *ret = &object->IMFTransform_iface;
 387     return S_OK;
 388
 389 failed:
 390
 391     IMFTransform_Release(&object->IMFTransform_iface);
 392     return hr;
 393 }
 394
 395 static const GUID CLSID_GStreamerByteStreamHandler = {0x317df618, 0x5e5a, 0x468a, {0x9f, 0x15, 0xd8, 0x27, 0xa9, 0xa0, 0x81, 0x62}};
 396
 397 static const GUID CLSID_WINEAudioConverter = {0x6a170414,0xaad9,0x4693,{0xb8,0x06,0x3a,0x0c,0x47,0xc5,0x70,0xd6}};
 398
 399 static const struct class_object
 400 {
 401     const GUID *clsid;
 402     HRESULT (*create_instance)(REFIID riid, void **obj);
 403 }
 404 class_objects[] =
 405 {
 406     { &CLSID_VideoProcessorMFT, &video_processor_create },
 407     { &CLSID_GStreamerByteStreamHandler, &winegstreamer_stream_handler_create },
 408     { &CLSID_WINEAudioConverter, &audio_converter_create },
 409 };
 410
 411 HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj)
 412 {
 413     struct class_factory *factory;
 414     unsigned int i;
 415     HRESULT hr;
 416
 417     for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
 418     {
 419         if (IsEqualGUID(class_objects[i].clsid, rclsid))
 420         {
 421             if (!(factory = malloc(sizeof(*factory))))
 422                 return E_OUTOFMEMORY;
 423
 424             factory->IClassFactory_iface.lpVtbl = &class_factory_vtbl;
 425             factory->refcount = 1;
 426             factory->create_instance = class_objects[i].create_instance;
 427
 428             hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj);
 429             IClassFactory_Release(&factory->IClassFactory_iface);
 430             return hr;
 431         }
 432     }
 433
 434     return CLASS_E_CLASSNOTAVAILABLE;
 435 }
 436
 437 static WCHAR audio_converterW[] = L"Audio Converter";
 438 static const GUID *audio_converter_supported_types[] =
 439 {
 440     &MFAudioFormat_PCM,
 441     &MFAudioFormat_Float,
 442 };
 443
 444 static const struct mft
 445 {
 446     const GUID *clsid;
 447     const GUID *category;
 448     LPWSTR name;
 449     const UINT32 flags;
 450     const GUID *major_type;
 451     const UINT32 input_types_count;
 452     const GUID **input_types;
 453     const UINT32 output_types_count;
 454     const GUID **output_types;
 455 }
 456 mfts[] =
 457 {
 458     {
 459         &CLSID_WINEAudioConverter,
 460         &MFT_CATEGORY_AUDIO_EFFECT,
 461         audio_converterW,
 462         MFT_ENUM_FLAG_SYNCMFT,
 463         &MFMediaType_Audio,
 464         ARRAY_SIZE(audio_converter_supported_types),
 465         audio_converter_supported_types,
 466         ARRAY_SIZE(audio_converter_supported_types),
 467         audio_converter_supported_types,
 468     },
 469 };
 470
 471 HRESULT mfplat_DllRegisterServer(void)
 472 {
 473     unsigned int i, j;
 474     HRESULT hr;
 475     MFT_REGISTER_TYPE_INFO input_types[2], output_types[2];
 476
 477     for (i = 0; i < ARRAY_SIZE(mfts); i++)
 478     {
 479         const struct mft *cur = &mfts[i];
 480
 481         for (j = 0; j < cur->input_types_count; j++)
 482         {
 483             input_types[j].guidMajorType = *(cur->major_type);
 484             input_types[j].guidSubtype = *(cur->input_types[j]);
 485         }
 486         for (j = 0; j < cur->output_types_count; j++)
 487         {
 488             output_types[j].guidMajorType = *(cur->major_type);
 489             output_types[j].guidSubtype = *(cur->output_types[j]);
 490         }
 491
 492         hr = MFTRegister(*(cur->clsid), *(cur->category), cur->name, cur->flags, cur->input_types_count,
 493                     input_types, cur->output_types_count, output_types, NULL);
 494
 495         if (FAILED(hr))
 496         {
 497             FIXME("Failed to register MFT, hr %#x\n", hr);
 498             return hr;
 499         }
 500     }
 501     return S_OK;
 502 }
 503
 504 static const struct
 505 {
 506     const GUID *subtype;
 507     enum wg_video_format format;
 508 }
 509 video_formats[] =
 510 {
 511     {&MFVideoFormat_ARGB32, WG_VIDEO_FORMAT_BGRA},
 512     {&MFVideoFormat_RGB32,  WG_VIDEO_FORMAT_BGRx},
 513     {&MFVideoFormat_RGB24,  WG_VIDEO_FORMAT_BGR},
 514     {&MFVideoFormat_RGB555, WG_VIDEO_FORMAT_RGB15},
 515     {&MFVideoFormat_RGB565, WG_VIDEO_FORMAT_RGB16},
 516     {&MFVideoFormat_AYUV,   WG_VIDEO_FORMAT_AYUV},
 517     {&MFVideoFormat_I420,   WG_VIDEO_FORMAT_I420},
 518     {&MFVideoFormat_IYUV,   WG_VIDEO_FORMAT_I420},
 519     {&MFVideoFormat_NV12,   WG_VIDEO_FORMAT_NV12},
 520     {&MFVideoFormat_UYVY,   WG_VIDEO_FORMAT_UYVY},
 521     {&MFVideoFormat_YUY2,   WG_VIDEO_FORMAT_YUY2},
 522     {&MFVideoFormat_YV12,   WG_VIDEO_FORMAT_YV12},
 523     {&MFVideoFormat_YVYU,   WG_VIDEO_FORMAT_YVYU},
 524 };
 525
 526 static const struct
 527 {
 528     const GUID *subtype;
 529     UINT32 depth;
 530     enum wg_audio_format format;
 531 }
 532 audio_formats[] =
 533 {
 534     {&MFAudioFormat_PCM,     8, WG_AUDIO_FORMAT_U8},
 535     {&MFAudioFormat_PCM,    16, WG_AUDIO_FORMAT_S16LE},
 536     {&MFAudioFormat_PCM,    24, WG_AUDIO_FORMAT_S24LE},
 537     {&MFAudioFormat_PCM,    32, WG_AUDIO_FORMAT_S32LE},
 538     {&MFAudioFormat_Float,  32, WG_AUDIO_FORMAT_F32LE},
 539     {&MFAudioFormat_Float,  64, WG_AUDIO_FORMAT_F64LE},
 540 };
 541
 542 static inline UINT64 make_uint64(UINT32 high, UINT32 low)
 543 {
 544     return ((UINT64)high << 32) | low;
 545 }
 546
 547 static IMFMediaType *mf_media_type_from_wg_format_audio(const struct wg_format *format)
 548 {
 549     IMFMediaType *type;
 550     unsigned int i;
 551
 552     for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
 553     {
 554         if (format->u.audio.format == audio_formats[i].format)
 555         {
 556             if (FAILED(MFCreateMediaType(&type)))
 557                 return NULL;
 558
 559             IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
 560             IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, audio_formats[i].subtype);
 561             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, audio_formats[i].depth);
 562             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->u.audio.rate);
 563             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, format->u.audio.channels);
 564             IMFMediaType_SetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, format->u.audio.channel_mask);
 565             IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
 566
 567             return type;
 568         }
 569     }
 570
 571     return NULL;
 572 }
 573
 574 static IMFMediaType *mf_media_type_from_wg_format_video(const struct wg_format *format)
 575 {
 576     IMFMediaType *type;
 577     unsigned int i;
 578
 579     for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
 580     {
 581         if (format->u.video.format == video_formats[i].format)
 582         {
 583             if (FAILED(MFCreateMediaType(&type)))
 584                 return NULL;
 585
 586             IMFMediaType_SetGUID(type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
 587             IMFMediaType_SetGUID(type, &MF_MT_SUBTYPE, video_formats[i].subtype);
 588             IMFMediaType_SetUINT64(type, &MF_MT_FRAME_SIZE,
 589                     make_uint64(format->u.video.width, format->u.video.height));
 590             IMFMediaType_SetUINT64(type, &MF_MT_FRAME_RATE,
 591                     make_uint64(format->u.video.fps_n, format->u.video.fps_d));
 592             IMFMediaType_SetUINT32(type, &MF_MT_COMPRESSED, FALSE);
 593             IMFMediaType_SetUINT32(type, &MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
 594             IMFMediaType_SetUINT32(type, &MF_MT_VIDEO_ROTATION, MFVideoRotationFormat_0);
 595
 596             return type;
 597         }
 598     }
 599
 600     return NULL;
 601 }
 602
 603 IMFMediaType *mf_media_type_from_wg_format(const struct wg_format *format)
 604 {
 605     switch (format->major_type)
 606     {
 607         case WG_MAJOR_TYPE_UNKNOWN:
 608             return NULL;
 609
 610         case WG_MAJOR_TYPE_AUDIO:
 611             return mf_media_type_from_wg_format_audio(format);
 612
 613         case WG_MAJOR_TYPE_VIDEO:
 614             return mf_media_type_from_wg_format_video(format);
 615     }
 616
 617     assert(0);
 618     return NULL;
 619 }
 620
 621 static void mf_media_type_to_wg_format_audio(IMFMediaType *type, struct wg_format *format)
 622 {
 623     UINT32 rate, channels, channel_mask, depth;
 624     unsigned int i;
 625     GUID subtype;
 626
 627     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 628     {
 629         FIXME("Subtype is not set.\n");
 630         return;
 631     }
 632     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &rate)))
 633     {
 634         FIXME("Sample rate is not set.\n");
 635         return;
 636     }
 637     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channels)))
 638     {
 639         FIXME("Channel count is not set.\n");
 640         return;
 641     }
 642     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &depth)))
 643     {
 644         FIXME("Depth is not set.\n");
 645         return;
 646     }
 647     if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_CHANNEL_MASK, &channel_mask)))
 648     {
 649         if (channels == 1)
 650             channel_mask = KSAUDIO_SPEAKER_MONO;
 651         else if (channels == 2)
 652             channel_mask = KSAUDIO_SPEAKER_STEREO;
 653         else
 654         {
 655             FIXME("Channel mask is not set.\n");
 656             return;
 657         }
 658     }
 659
 660     format->major_type = WG_MAJOR_TYPE_AUDIO;
 661     format->u.audio.channels = channels;
 662     format->u.audio.channel_mask = channel_mask;
 663     format->u.audio.rate = rate;
 664
 665     for (i = 0; i < ARRAY_SIZE(audio_formats); ++i)
 666     {
 667         if (IsEqualGUID(&subtype, audio_formats[i].subtype) && depth == audio_formats[i].depth)
 668         {
 669             format->u.audio.format = audio_formats[i].format;
 670             return;
 671         }
 672     }
 673     FIXME("Unrecognized audio subtype %s, depth %u.\n", debugstr_guid(&subtype), depth);
 674 }
 675
 676 static void mf_media_type_to_wg_format_video(IMFMediaType *type, struct wg_format *format)
 677 {
 678     UINT64 frame_rate, frame_size;
 679     unsigned int i;
 680     GUID subtype;
 681
 682     if (FAILED(IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 683     {
 684         FIXME("Subtype is not set.\n");
 685         return;
 686     }
 687     if (FAILED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
 688     {
 689         FIXME("Frame size is not set.\n");
 690         return;
 691     }
 692
 693     format->major_type = WG_MAJOR_TYPE_VIDEO;
 694     format->u.video.width = (UINT32)(frame_size >> 32);
 695     format->u.video.height = (UINT32)frame_size;
 696     format->u.video.fps_n = 1;
 697     format->u.video.fps_d = 1;
 698
 699     if (SUCCEEDED(IMFMediaType_GetUINT64(type, &MF_MT_FRAME_RATE, &frame_rate)) && (UINT32)frame_rate)
 700     {
 701         format->u.video.fps_n = (UINT32)(frame_rate >> 32);
 702         format->u.video.fps_d = (UINT32)frame_rate;
 703     }
 704
 705     for (i = 0; i < ARRAY_SIZE(video_formats); ++i)
 706     {
 707         if (IsEqualGUID(&subtype, video_formats[i].subtype))
 708         {
 709             format->u.video.format = video_formats[i].format;
 710             return;
 711         }
 712     }
 713     FIXME("Unrecognized video subtype %s.\n", debugstr_guid(&subtype));
 714 }
 715
 716 void mf_media_type_to_wg_format(IMFMediaType *type, struct wg_format *format)
 717 {
 718     GUID major_type;
 719
 720     memset(format, 0, sizeof(*format));
 721
 722     if (FAILED(IMFMediaType_GetMajorType(type, &major_type)))
 723     {
 724         FIXME("Major type is not set.\n");
 725         return;
 726     }
 727
 728     if (IsEqualGUID(&major_type, &MFMediaType_Audio))
 729         mf_media_type_to_wg_format_audio(type, format);
 730     else if (IsEqualGUID(&major_type, &MFMediaType_Video))
 731         mf_media_type_to_wg_format_video(type, format);
 732     else
 733         FIXME("Unrecognized major type %s.\n", debugstr_guid(&major_type));
 734 }