dlls/mfplat/mediatype.c

   1 /*
   2  * Copyright 2017 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "mfplat_private.h"
  22
  23 #include "dxva2api.h"
  24 #include "uuids.h"
  25 #include "strmif.h"
  26 #include "initguid.h"
  27 #include "ks.h"
  28 #include "ksmedia.h"
  29 #include "amvideo.h"
  30 #include "wmcodecdsp.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  33
  34 DEFINE_MEDIATYPE_GUID(MFVideoFormat_RGB1, D3DFMT_A1);
  35 DEFINE_MEDIATYPE_GUID(MFVideoFormat_RGB4, MAKEFOURCC('4','P','x','x'));
  36 DEFINE_MEDIATYPE_GUID(MFVideoFormat_ARGB1555, D3DFMT_A1R5G5B5);
  37 DEFINE_MEDIATYPE_GUID(MFVideoFormat_ARGB4444, D3DFMT_A4R4G4B4);
  38 /* SDK MFVideoFormat_A2R10G10B10 uses D3DFMT_A2B10G10R10, let's name it the other way */
  39 DEFINE_MEDIATYPE_GUID(MFVideoFormat_A2B10G10R10, D3DFMT_A2R10G10B10);
  40
  41 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IMC1, MAKEFOURCC('I','M','C','1'));
  42 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IMC2, MAKEFOURCC('I','M','C','2'));
  43 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IMC3, MAKEFOURCC('I','M','C','3'));
  44 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IMC4, MAKEFOURCC('I','M','C','4'));
  45
  46 struct media_type
  47 {
  48     struct attributes attributes;
  49     IMFMediaType IMFMediaType_iface;
  50     IMFVideoMediaType IMFVideoMediaType_iface;
  51     IMFAudioMediaType IMFAudioMediaType_iface;
  52     MFVIDEOFORMAT *video_format;
  53     WAVEFORMATEX *audio_format;
  54 };
  55
  56 struct stream_desc
  57 {
  58     struct attributes attributes;
  59     IMFStreamDescriptor IMFStreamDescriptor_iface;
  60     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
  61     DWORD identifier;
  62     IMFMediaType **media_types;
  63     unsigned int media_types_count;
  64     IMFMediaType *current_type;
  65 };
  66
  67 struct presentation_desc_entry
  68 {
  69     IMFStreamDescriptor *descriptor;
  70     BOOL selected;
  71 };
  72
  73 struct presentation_desc
  74 {
  75     struct attributes attributes;
  76     IMFPresentationDescriptor IMFPresentationDescriptor_iface;
  77     struct presentation_desc_entry *descriptors;
  78     unsigned int count;
  79 };
  80
  81 static HRESULT presentation_descriptor_init(struct presentation_desc *object, DWORD count);
  82
  83 static struct media_type *impl_from_IMFMediaType(IMFMediaType *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct media_type, IMFMediaType_iface);
  86 }
  87
  88 static struct media_type *impl_from_IMFVideoMediaType(IMFVideoMediaType *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct media_type, IMFVideoMediaType_iface);
  91 }
  92
  93 static struct media_type *impl_from_IMFAudioMediaType(IMFAudioMediaType *iface)
  94 {
  95     return CONTAINING_RECORD(iface, struct media_type, IMFAudioMediaType_iface);
  96 }
  97
  98 static inline struct stream_desc *impl_from_IMFStreamDescriptor(IMFStreamDescriptor *iface)
  99 {
 100     return CONTAINING_RECORD(iface, struct stream_desc, IMFStreamDescriptor_iface);
 101 }
 102
 103 static struct stream_desc *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 104 {
 105     return CONTAINING_RECORD(iface, struct stream_desc, IMFMediaTypeHandler_iface);
 106 }
 107
 108 static struct presentation_desc *impl_from_IMFPresentationDescriptor(IMFPresentationDescriptor *iface)
 109 {
 110     return CONTAINING_RECORD(iface, struct presentation_desc, IMFPresentationDescriptor_iface);
 111 }
 112
 113 static HRESULT WINAPI mediatype_QueryInterface(IMFMediaType *iface, REFIID riid, void **out)
 114 {
 115     struct media_type *media_type = impl_from_IMFMediaType(iface);
 116     GUID major = { 0 };
 117
 118     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 119
 120     attributes_GetGUID(&media_type->attributes, &MF_MT_MAJOR_TYPE, &major);
 121
 122     if (IsEqualGUID(&major, &MFMediaType_Video) && IsEqualIID(riid, &IID_IMFVideoMediaType))
 123     {
 124         *out = &media_type->IMFVideoMediaType_iface;
 125     }
 126     else if (IsEqualGUID(&major, &MFMediaType_Audio) && IsEqualIID(riid, &IID_IMFAudioMediaType))
 127     {
 128         *out = &media_type->IMFAudioMediaType_iface;
 129     }
 130     else if (IsEqualIID(riid, &IID_IMFMediaType) ||
 131             IsEqualIID(riid, &IID_IMFAttributes) ||
 132             IsEqualIID(riid, &IID_IUnknown))
 133     {
 134         *out = &media_type->IMFMediaType_iface;
 135     }
 136     else
 137     {
 138         WARN("Unsupported %s.\n", debugstr_guid(riid));
 139         *out = NULL;
 140         return E_NOINTERFACE;
 141     }
 142
 143     IUnknown_AddRef((IUnknown *)*out);
 144     return S_OK;
 145 }
 146
 147 static ULONG WINAPI mediatype_AddRef(IMFMediaType *iface)
 148 {
 149     struct media_type *media_type = impl_from_IMFMediaType(iface);
 150     ULONG refcount = InterlockedIncrement(&media_type->attributes.ref);
 151
 152     TRACE("%p, refcount %lu.\n", iface, refcount);
 153
 154     return refcount;
 155 }
 156
 157 static ULONG WINAPI mediatype_Release(IMFMediaType *iface)
 158 {
 159     struct media_type *media_type = impl_from_IMFMediaType(iface);
 160     ULONG refcount = InterlockedDecrement(&media_type->attributes.ref);
 161
 162     TRACE("%p, refcount %lu.\n", iface, refcount);
 163
 164     if (!refcount)
 165     {
 166         clear_attributes_object(&media_type->attributes);
 167         CoTaskMemFree(media_type->video_format);
 168         CoTaskMemFree(media_type->audio_format);
 169         free(media_type);
 170     }
 171
 172     return refcount;
 173 }
 174
 175 static HRESULT WINAPI mediatype_GetItem(IMFMediaType *iface, REFGUID key, PROPVARIANT *value)
 176 {
 177     struct media_type *media_type = impl_from_IMFMediaType(iface);
 178
 179     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 180
 181     return attributes_GetItem(&media_type->attributes, key, value);
 182 }
 183
 184 static HRESULT WINAPI mediatype_GetItemType(IMFMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 185 {
 186     struct media_type *media_type = impl_from_IMFMediaType(iface);
 187
 188     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
 189
 190     return attributes_GetItemType(&media_type->attributes, key, type);
 191 }
 192
 193 static HRESULT WINAPI mediatype_CompareItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 194 {
 195     struct media_type *media_type = impl_from_IMFMediaType(iface);
 196
 197     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
 198
 199     return attributes_CompareItem(&media_type->attributes, key, value, result);
 200 }
 201
 202 static HRESULT WINAPI mediatype_Compare(IMFMediaType *iface, IMFAttributes *attrs, MF_ATTRIBUTES_MATCH_TYPE type,
 203                 BOOL *result)
 204 {
 205     struct media_type *media_type = impl_from_IMFMediaType(iface);
 206
 207     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
 208
 209     return attributes_Compare(&media_type->attributes, attrs, type, result);
 210 }
 211
 212 static HRESULT WINAPI mediatype_GetUINT32(IMFMediaType *iface, REFGUID key, UINT32 *value)
 213 {
 214     struct media_type *media_type = impl_from_IMFMediaType(iface);
 215
 216     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 217
 218     return attributes_GetUINT32(&media_type->attributes, key, value);
 219 }
 220
 221 static HRESULT WINAPI mediatype_GetUINT64(IMFMediaType *iface, REFGUID key, UINT64 *value)
 222 {
 223     struct media_type *media_type = impl_from_IMFMediaType(iface);
 224
 225     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 226
 227     return attributes_GetUINT64(&media_type->attributes, key, value);
 228 }
 229
 230 static HRESULT WINAPI mediatype_GetDouble(IMFMediaType *iface, REFGUID key, double *value)
 231 {
 232     struct media_type *media_type = impl_from_IMFMediaType(iface);
 233
 234     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 235
 236     return attributes_GetDouble(&media_type->attributes, key, value);
 237 }
 238
 239 static HRESULT WINAPI mediatype_GetGUID(IMFMediaType *iface, REFGUID key, GUID *value)
 240 {
 241     struct media_type *media_type = impl_from_IMFMediaType(iface);
 242
 243     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 244
 245     return attributes_GetGUID(&media_type->attributes, key, value);
 246 }
 247
 248 static HRESULT WINAPI mediatype_GetStringLength(IMFMediaType *iface, REFGUID key, UINT32 *length)
 249 {
 250     struct media_type *media_type = impl_from_IMFMediaType(iface);
 251
 252     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
 253
 254     return attributes_GetStringLength(&media_type->attributes, key, length);
 255 }
 256
 257 static HRESULT WINAPI mediatype_GetString(IMFMediaType *iface, REFGUID key, WCHAR *value,
 258         UINT32 size, UINT32 *length)
 259 {
 260     struct media_type *media_type = impl_from_IMFMediaType(iface);
 261
 262     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
 263
 264     return attributes_GetString(&media_type->attributes, key, value, size, length);
 265 }
 266
 267 static HRESULT WINAPI mediatype_GetAllocatedString(IMFMediaType *iface, REFGUID key,
 268         WCHAR **value, UINT32 *length)
 269 {
 270     struct media_type *media_type = impl_from_IMFMediaType(iface);
 271
 272     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
 273
 274     return attributes_GetAllocatedString(&media_type->attributes, key, value, length);
 275 }
 276
 277 static HRESULT WINAPI mediatype_GetBlobSize(IMFMediaType *iface, REFGUID key, UINT32 *size)
 278 {
 279     struct media_type *media_type = impl_from_IMFMediaType(iface);
 280
 281     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
 282
 283     return attributes_GetBlobSize(&media_type->attributes, key, size);
 284 }
 285
 286 static HRESULT WINAPI mediatype_GetBlob(IMFMediaType *iface, REFGUID key, UINT8 *buf,
 287         UINT32 bufsize, UINT32 *blobsize)
 288 {
 289     struct media_type *media_type = impl_from_IMFMediaType(iface);
 290
 291     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
 292
 293     return attributes_GetBlob(&media_type->attributes, key, buf, bufsize, blobsize);
 294 }
 295
 296 static HRESULT WINAPI mediatype_GetAllocatedBlob(IMFMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 297 {
 298     struct media_type *media_type = impl_from_IMFMediaType(iface);
 299
 300     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
 301
 302     return attributes_GetAllocatedBlob(&media_type->attributes, key, buf, size);
 303 }
 304
 305 static HRESULT WINAPI mediatype_GetUnknown(IMFMediaType *iface, REFGUID key, REFIID riid, void **obj)
 306 {
 307     struct media_type *media_type = impl_from_IMFMediaType(iface);
 308
 309     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
 310
 311     return attributes_GetUnknown(&media_type->attributes, key, riid, obj);
 312 }
 313
 314 static HRESULT WINAPI mediatype_SetItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value)
 315 {
 316     struct media_type *media_type = impl_from_IMFMediaType(iface);
 317
 318     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
 319
 320     return attributes_SetItem(&media_type->attributes, key, value);
 321 }
 322
 323 static HRESULT WINAPI mediatype_DeleteItem(IMFMediaType *iface, REFGUID key)
 324 {
 325     struct media_type *media_type = impl_from_IMFMediaType(iface);
 326
 327     TRACE("%p, %s.\n", iface, debugstr_attr(key));
 328
 329     return attributes_DeleteItem(&media_type->attributes, key);
 330 }
 331
 332 static HRESULT WINAPI mediatype_DeleteAllItems(IMFMediaType *iface)
 333 {
 334     struct media_type *media_type = impl_from_IMFMediaType(iface);
 335
 336     TRACE("%p.\n", iface);
 337
 338     return attributes_DeleteAllItems(&media_type->attributes);
 339 }
 340
 341 static HRESULT WINAPI mediatype_SetUINT32(IMFMediaType *iface, REFGUID key, UINT32 value)
 342 {
 343     struct media_type *media_type = impl_from_IMFMediaType(iface);
 344
 345     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
 346
 347     return attributes_SetUINT32(&media_type->attributes, key, value);
 348 }
 349
 350 static HRESULT WINAPI mediatype_SetUINT64(IMFMediaType *iface, REFGUID key, UINT64 value)
 351 {
 352     struct media_type *media_type = impl_from_IMFMediaType(iface);
 353
 354     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
 355
 356     return attributes_SetUINT64(&media_type->attributes, key, value);
 357 }
 358
 359 static HRESULT WINAPI mediatype_SetDouble(IMFMediaType *iface, REFGUID key, double value)
 360 {
 361     struct media_type *media_type = impl_from_IMFMediaType(iface);
 362
 363     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
 364
 365     return attributes_SetDouble(&media_type->attributes, key, value);
 366 }
 367
 368 static HRESULT WINAPI mediatype_SetGUID(IMFMediaType *iface, REFGUID key, REFGUID value)
 369 {
 370     struct media_type *media_type = impl_from_IMFMediaType(iface);
 371
 372     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
 373
 374     return attributes_SetGUID(&media_type->attributes, key, value);
 375 }
 376
 377 static HRESULT WINAPI mediatype_SetString(IMFMediaType *iface, REFGUID key, const WCHAR *value)
 378 {
 379     struct media_type *media_type = impl_from_IMFMediaType(iface);
 380
 381     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
 382
 383     return attributes_SetString(&media_type->attributes, key, value);
 384 }
 385
 386 static HRESULT WINAPI mediatype_SetBlob(IMFMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 387 {
 388     struct media_type *media_type = impl_from_IMFMediaType(iface);
 389
 390     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
 391
 392     return attributes_SetBlob(&media_type->attributes, key, buf, size);
 393 }
 394
 395 static HRESULT WINAPI mediatype_SetUnknown(IMFMediaType *iface, REFGUID key, IUnknown *unknown)
 396 {
 397     struct media_type *media_type = impl_from_IMFMediaType(iface);
 398
 399     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
 400
 401     return attributes_SetUnknown(&media_type->attributes, key, unknown);
 402 }
 403
 404 static HRESULT WINAPI mediatype_LockStore(IMFMediaType *iface)
 405 {
 406     struct media_type *media_type = impl_from_IMFMediaType(iface);
 407
 408     TRACE("%p.\n", iface);
 409
 410     return attributes_LockStore(&media_type->attributes);
 411 }
 412
 413 static HRESULT WINAPI mediatype_UnlockStore(IMFMediaType *iface)
 414 {
 415     struct media_type *media_type = impl_from_IMFMediaType(iface);
 416
 417     TRACE("%p.\n", iface);
 418
 419     return attributes_UnlockStore(&media_type->attributes);
 420 }
 421
 422 static HRESULT WINAPI mediatype_GetCount(IMFMediaType *iface, UINT32 *count)
 423 {
 424     struct media_type *media_type = impl_from_IMFMediaType(iface);
 425
 426     TRACE("%p, %p.\n", iface, count);
 427
 428     return attributes_GetCount(&media_type->attributes, count);
 429 }
 430
 431 static HRESULT WINAPI mediatype_GetItemByIndex(IMFMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 432 {
 433     struct media_type *media_type = impl_from_IMFMediaType(iface);
 434
 435     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 436
 437     return attributes_GetItemByIndex(&media_type->attributes, index, key, value);
 438 }
 439
 440 static HRESULT WINAPI mediatype_CopyAllItems(IMFMediaType *iface, IMFAttributes *dest)
 441 {
 442     struct media_type *media_type = impl_from_IMFMediaType(iface);
 443
 444     TRACE("%p, %p.\n", iface, dest);
 445
 446     return attributes_CopyAllItems(&media_type->attributes, dest);
 447 }
 448
 449 static HRESULT WINAPI mediatype_GetMajorType(IMFMediaType *iface, GUID *guid)
 450 {
 451     struct media_type *media_type = impl_from_IMFMediaType(iface);
 452
 453     TRACE("%p, %p.\n", iface, guid);
 454
 455     return attributes_GetGUID(&media_type->attributes, &MF_MT_MAJOR_TYPE, guid);
 456 }
 457
 458 static HRESULT mediatype_is_compressed(struct media_type *media_type, BOOL *compressed)
 459 {
 460     UINT32 value;
 461
 462     if (FAILED(attributes_GetUINT32(&media_type->attributes, &MF_MT_ALL_SAMPLES_INDEPENDENT, &value)))
 463     {
 464         value = 0;
 465     }
 466
 467     *compressed = !value;
 468
 469     return S_OK;
 470 }
 471
 472 static HRESULT WINAPI mediatype_IsCompressedFormat(IMFMediaType *iface, BOOL *compressed)
 473 {
 474     struct media_type *media_type = impl_from_IMFMediaType(iface);
 475
 476     TRACE("%p, %p.\n", iface, compressed);
 477
 478     return mediatype_is_compressed(media_type, compressed);
 479 }
 480
 481 static HRESULT media_type_is_equal(struct media_type *media_type, IMFMediaType *type, DWORD *flags)
 482 {
 483     const DWORD full_equality_flags = MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES |
 484             MF_MEDIATYPE_EQUAL_FORMAT_DATA | MF_MEDIATYPE_EQUAL_FORMAT_USER_DATA;
 485     struct comparand
 486     {
 487         IMFAttributes *type;
 488         PROPVARIANT value;
 489         UINT32 count;
 490         GUID guid;
 491         HRESULT hr;
 492     } left, right, swp;
 493     unsigned int i;
 494     BOOL result;
 495
 496     *flags = 0;
 497
 498     left.type = &media_type->attributes.IMFAttributes_iface;
 499     right.type = (IMFAttributes *)type;
 500
 501     if (FAILED(IMFAttributes_GetGUID(left.type, &MF_MT_MAJOR_TYPE, &left.guid)))
 502         return E_INVALIDARG;
 503
 504     if (FAILED(IMFAttributes_GetGUID(right.type, &MF_MT_MAJOR_TYPE, &right.guid)))
 505         return E_INVALIDARG;
 506
 507     if (IsEqualGUID(&left.guid, &right.guid))
 508         *flags |= MF_MEDIATYPE_EQUAL_MAJOR_TYPES;
 509
 510     /* Subtypes equal or both missing. */
 511     left.hr = IMFAttributes_GetGUID(left.type, &MF_MT_SUBTYPE, &left.guid);
 512     right.hr = IMFAttributes_GetGUID(right.type, &MF_MT_SUBTYPE, &right.guid);
 513
 514     if ((SUCCEEDED(left.hr) && SUCCEEDED(right.hr) && IsEqualGUID(&left.guid, &right.guid)) ||
 515            (FAILED(left.hr) && FAILED(right.hr)))
 516     {
 517         *flags |= MF_MEDIATYPE_EQUAL_FORMAT_TYPES;
 518     }
 519
 520     /* Format data */
 521     IMFAttributes_GetCount(left.type, &left.count);
 522     IMFAttributes_GetCount(right.type, &right.count);
 523
 524     if (right.count < left.count)
 525     {
 526         swp = left;
 527         left = right;
 528         right = swp;
 529     }
 530
 531     *flags |= MF_MEDIATYPE_EQUAL_FORMAT_DATA;
 532
 533     for (i = 0; i < left.count; ++i)
 534     {
 535         PROPVARIANT value;
 536         GUID key;
 537
 538         if (SUCCEEDED(IMFAttributes_GetItemByIndex(left.type, i, &key, &value)))
 539         {
 540             if (IsEqualGUID(&key, &MF_MT_USER_DATA) ||
 541                     IsEqualGUID(&key, &MF_MT_FRAME_RATE_RANGE_MIN) ||
 542                     IsEqualGUID(&key, &MF_MT_FRAME_RATE_RANGE_MAX))
 543             {
 544                 PropVariantClear(&value);
 545                 continue;
 546             }
 547
 548             result = FALSE;
 549             IMFAttributes_CompareItem(right.type, &key, &value, &result);
 550             PropVariantClear(&value);
 551             if (!result)
 552             {
 553                 *flags &= ~MF_MEDIATYPE_EQUAL_FORMAT_DATA;
 554                 break;
 555             }
 556         }
 557     }
 558
 559     /* User data */
 560     PropVariantInit(&left.value);
 561     left.hr = IMFAttributes_GetItem(left.type, &MF_MT_USER_DATA, &left.value);
 562     PropVariantInit(&right.value);
 563     right.hr = IMFAttributes_GetItem(right.type, &MF_MT_USER_DATA, &right.value);
 564
 565     /* Compare user data if both types have it, otherwise simply check if both don't. */
 566     if (SUCCEEDED(left.hr) && SUCCEEDED(right.hr))
 567     {
 568         result = FALSE;
 569         IMFAttributes_CompareItem(left.type, &MF_MT_USER_DATA, &left.value, &result);
 570     }
 571     else
 572         result = FAILED(left.hr) && FAILED(right.hr);
 573
 574     PropVariantClear(&left.value);
 575     PropVariantClear(&right.value);
 576
 577     if (result)
 578         *flags |= MF_MEDIATYPE_EQUAL_FORMAT_USER_DATA;
 579
 580     return *flags == full_equality_flags ? S_OK : S_FALSE;
 581 }
 582
 583 static HRESULT WINAPI mediatype_IsEqual(IMFMediaType *iface, IMFMediaType *type, DWORD *flags)
 584 {
 585     struct media_type *media_type = impl_from_IMFMediaType(iface);
 586
 587     TRACE("%p, %p, %p.\n", iface, type, flags);
 588
 589     return media_type_is_equal(media_type, type, flags);
 590 }
 591
 592 static HRESULT WINAPI mediatype_GetRepresentation(IMFMediaType *iface, GUID guid, void **representation)
 593 {
 594     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
 595
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI mediatype_FreeRepresentation(IMFMediaType *iface, GUID guid, void *representation)
 600 {
 601     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
 602
 603     return E_NOTIMPL;
 604 }
 605
 606 static const IMFMediaTypeVtbl mediatypevtbl =
 607 {
 608     mediatype_QueryInterface,
 609     mediatype_AddRef,
 610     mediatype_Release,
 611     mediatype_GetItem,
 612     mediatype_GetItemType,
 613     mediatype_CompareItem,
 614     mediatype_Compare,
 615     mediatype_GetUINT32,
 616     mediatype_GetUINT64,
 617     mediatype_GetDouble,
 618     mediatype_GetGUID,
 619     mediatype_GetStringLength,
 620     mediatype_GetString,
 621     mediatype_GetAllocatedString,
 622     mediatype_GetBlobSize,
 623     mediatype_GetBlob,
 624     mediatype_GetAllocatedBlob,
 625     mediatype_GetUnknown,
 626     mediatype_SetItem,
 627     mediatype_DeleteItem,
 628     mediatype_DeleteAllItems,
 629     mediatype_SetUINT32,
 630     mediatype_SetUINT64,
 631     mediatype_SetDouble,
 632     mediatype_SetGUID,
 633     mediatype_SetString,
 634     mediatype_SetBlob,
 635     mediatype_SetUnknown,
 636     mediatype_LockStore,
 637     mediatype_UnlockStore,
 638     mediatype_GetCount,
 639     mediatype_GetItemByIndex,
 640     mediatype_CopyAllItems,
 641     mediatype_GetMajorType,
 642     mediatype_IsCompressedFormat,
 643     mediatype_IsEqual,
 644     mediatype_GetRepresentation,
 645     mediatype_FreeRepresentation
 646 };
 647
 648 static HRESULT WINAPI video_mediatype_QueryInterface(IMFVideoMediaType *iface, REFIID riid, void **out)
 649 {
 650     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 651     return IMFMediaType_QueryInterface(&media_type->IMFMediaType_iface, riid, out);
 652 }
 653
 654 static ULONG WINAPI video_mediatype_AddRef(IMFVideoMediaType *iface)
 655 {
 656     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 657     return IMFMediaType_AddRef(&media_type->IMFMediaType_iface);
 658 }
 659
 660 static ULONG WINAPI video_mediatype_Release(IMFVideoMediaType *iface)
 661 {
 662     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 663     return IMFMediaType_Release(&media_type->IMFMediaType_iface);
 664 }
 665
 666 static HRESULT WINAPI video_mediatype_GetItem(IMFVideoMediaType *iface, REFGUID key, PROPVARIANT *value)
 667 {
 668     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 669
 670     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 671
 672     return attributes_GetItem(&media_type->attributes, key, value);
 673 }
 674
 675 static HRESULT WINAPI video_mediatype_GetItemType(IMFVideoMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 676 {
 677     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 678
 679     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
 680
 681     return attributes_GetItemType(&media_type->attributes, key, type);
 682 }
 683
 684 static HRESULT WINAPI video_mediatype_CompareItem(IMFVideoMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 685 {
 686     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 687
 688     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
 689
 690     return attributes_CompareItem(&media_type->attributes, key, value, result);
 691 }
 692
 693 static HRESULT WINAPI video_mediatype_Compare(IMFVideoMediaType *iface, IMFAttributes *attrs,
 694         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
 695 {
 696     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 697
 698     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
 699
 700     return attributes_Compare(&media_type->attributes, attrs, type, result);
 701 }
 702
 703 static HRESULT WINAPI video_mediatype_GetUINT32(IMFVideoMediaType *iface, REFGUID key, UINT32 *value)
 704 {
 705     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 706
 707     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 708
 709     return attributes_GetUINT32(&media_type->attributes, key, value);
 710 }
 711
 712 static HRESULT WINAPI video_mediatype_GetUINT64(IMFVideoMediaType *iface, REFGUID key, UINT64 *value)
 713 {
 714     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 715
 716     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 717
 718     return attributes_GetUINT64(&media_type->attributes, key, value);
 719 }
 720
 721 static HRESULT WINAPI video_mediatype_GetDouble(IMFVideoMediaType *iface, REFGUID key, double *value)
 722 {
 723     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 724
 725     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 726
 727     return attributes_GetDouble(&media_type->attributes, key, value);
 728 }
 729
 730 static HRESULT WINAPI video_mediatype_GetGUID(IMFVideoMediaType *iface, REFGUID key, GUID *value)
 731 {
 732     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 733
 734     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 735
 736     return attributes_GetGUID(&media_type->attributes, key, value);
 737 }
 738
 739 static HRESULT WINAPI video_mediatype_GetStringLength(IMFVideoMediaType *iface, REFGUID key, UINT32 *length)
 740 {
 741     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 742
 743     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
 744
 745     return attributes_GetStringLength(&media_type->attributes, key, length);
 746 }
 747
 748 static HRESULT WINAPI video_mediatype_GetString(IMFVideoMediaType *iface, REFGUID key, WCHAR *value,
 749         UINT32 size, UINT32 *length)
 750 {
 751     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 752
 753     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
 754
 755     return attributes_GetString(&media_type->attributes, key, value, size, length);
 756 }
 757
 758 static HRESULT WINAPI video_mediatype_GetAllocatedString(IMFVideoMediaType *iface, REFGUID key,
 759         WCHAR **value, UINT32 *length)
 760 {
 761     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 762
 763     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
 764
 765     return attributes_GetAllocatedString(&media_type->attributes, key, value, length);
 766 }
 767
 768 static HRESULT WINAPI video_mediatype_GetBlobSize(IMFVideoMediaType *iface, REFGUID key, UINT32 *size)
 769 {
 770     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 771
 772     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
 773
 774     return attributes_GetBlobSize(&media_type->attributes, key, size);
 775 }
 776
 777 static HRESULT WINAPI video_mediatype_GetBlob(IMFVideoMediaType *iface, REFGUID key, UINT8 *buf,
 778         UINT32 bufsize, UINT32 *blobsize)
 779 {
 780     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 781
 782     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
 783
 784     return attributes_GetBlob(&media_type->attributes, key, buf, bufsize, blobsize);
 785 }
 786
 787 static HRESULT WINAPI video_mediatype_GetAllocatedBlob(IMFVideoMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 788 {
 789     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 790
 791     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
 792
 793     return attributes_GetAllocatedBlob(&media_type->attributes, key, buf, size);
 794 }
 795
 796 static HRESULT WINAPI video_mediatype_GetUnknown(IMFVideoMediaType *iface, REFGUID key, REFIID riid, void **obj)
 797 {
 798     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 799
 800     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
 801
 802     return attributes_GetUnknown(&media_type->attributes, key, riid, obj);
 803 }
 804
 805 static HRESULT WINAPI video_mediatype_SetItem(IMFVideoMediaType *iface, REFGUID key, REFPROPVARIANT value)
 806 {
 807     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 808
 809     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
 810
 811     return attributes_SetItem(&media_type->attributes, key, value);
 812 }
 813
 814 static HRESULT WINAPI video_mediatype_DeleteItem(IMFVideoMediaType *iface, REFGUID key)
 815 {
 816     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 817
 818     TRACE("%p, %s.\n", iface, debugstr_attr(key));
 819
 820     return attributes_DeleteItem(&media_type->attributes, key);
 821 }
 822
 823 static HRESULT WINAPI video_mediatype_DeleteAllItems(IMFVideoMediaType *iface)
 824 {
 825     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 826
 827     TRACE("%p.\n", iface);
 828
 829     return attributes_DeleteAllItems(&media_type->attributes);
 830 }
 831
 832 static HRESULT WINAPI video_mediatype_SetUINT32(IMFVideoMediaType *iface, REFGUID key, UINT32 value)
 833 {
 834     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 835
 836     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
 837
 838     return attributes_SetUINT32(&media_type->attributes, key, value);
 839 }
 840
 841 static HRESULT WINAPI video_mediatype_SetUINT64(IMFVideoMediaType *iface, REFGUID key, UINT64 value)
 842 {
 843     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 844
 845     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
 846
 847     return attributes_SetUINT64(&media_type->attributes, key, value);
 848 }
 849
 850 static HRESULT WINAPI video_mediatype_SetDouble(IMFVideoMediaType *iface, REFGUID key, double value)
 851 {
 852     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 853
 854     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
 855
 856     return attributes_SetDouble(&media_type->attributes, key, value);
 857 }
 858
 859 static HRESULT WINAPI video_mediatype_SetGUID(IMFVideoMediaType *iface, REFGUID key, REFGUID value)
 860 {
 861     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 862
 863     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
 864
 865     return attributes_SetGUID(&media_type->attributes, key, value);
 866 }
 867
 868 static HRESULT WINAPI video_mediatype_SetString(IMFVideoMediaType *iface, REFGUID key, const WCHAR *value)
 869 {
 870     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 871
 872     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
 873
 874     return attributes_SetString(&media_type->attributes, key, value);
 875 }
 876
 877 static HRESULT WINAPI video_mediatype_SetBlob(IMFVideoMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 878 {
 879     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 880
 881     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
 882
 883     return attributes_SetBlob(&media_type->attributes, key, buf, size);
 884 }
 885
 886 static HRESULT WINAPI video_mediatype_SetUnknown(IMFVideoMediaType *iface, REFGUID key, IUnknown *unknown)
 887 {
 888     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 889
 890     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
 891
 892     return attributes_SetUnknown(&media_type->attributes, key, unknown);
 893 }
 894
 895 static HRESULT WINAPI video_mediatype_LockStore(IMFVideoMediaType *iface)
 896 {
 897     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 898
 899     TRACE("%p.\n", iface);
 900
 901     return attributes_LockStore(&media_type->attributes);
 902 }
 903
 904 static HRESULT WINAPI video_mediatype_UnlockStore(IMFVideoMediaType *iface)
 905 {
 906     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 907
 908     TRACE("%p.\n", iface);
 909
 910     return attributes_UnlockStore(&media_type->attributes);
 911 }
 912
 913 static HRESULT WINAPI video_mediatype_GetCount(IMFVideoMediaType *iface, UINT32 *count)
 914 {
 915     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 916
 917     TRACE("%p, %p.\n", iface, count);
 918
 919     return attributes_GetCount(&media_type->attributes, count);
 920 }
 921
 922 static HRESULT WINAPI video_mediatype_GetItemByIndex(IMFVideoMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 923 {
 924     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 925
 926     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 927
 928     return attributes_GetItemByIndex(&media_type->attributes, index, key, value);
 929 }
 930
 931 static HRESULT WINAPI video_mediatype_CopyAllItems(IMFVideoMediaType *iface, IMFAttributes *dest)
 932 {
 933     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 934
 935     TRACE("%p, %p.\n", iface, dest);
 936
 937     return attributes_CopyAllItems(&media_type->attributes, dest);
 938 }
 939
 940 static HRESULT WINAPI video_mediatype_GetMajorType(IMFVideoMediaType *iface, GUID *guid)
 941 {
 942     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 943
 944     TRACE("%p, %p.\n", iface, guid);
 945
 946     return attributes_GetGUID(&media_type->attributes, &MF_MT_MAJOR_TYPE, guid);
 947 }
 948
 949 static HRESULT WINAPI video_mediatype_IsCompressedFormat(IMFVideoMediaType *iface, BOOL *compressed)
 950 {
 951     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 952
 953     TRACE("%p, %p.\n", iface, compressed);
 954
 955     return mediatype_is_compressed(media_type, compressed);
 956 }
 957
 958 static HRESULT WINAPI video_mediatype_IsEqual(IMFVideoMediaType *iface, IMFMediaType *type, DWORD *flags)
 959 {
 960     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 961
 962     TRACE("%p, %p, %p.\n", iface, type, flags);
 963
 964     return media_type_is_equal(media_type, type, flags);
 965 }
 966
 967 static HRESULT WINAPI video_mediatype_GetRepresentation(IMFVideoMediaType *iface, GUID guid, void **representation)
 968 {
 969     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
 970
 971     return E_NOTIMPL;
 972 }
 973
 974 static HRESULT WINAPI video_mediatype_FreeRepresentation(IMFVideoMediaType *iface, GUID guid, void *representation)
 975 {
 976     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
 977
 978     return E_NOTIMPL;
 979 }
 980
 981 static const MFVIDEOFORMAT * WINAPI video_mediatype_GetVideoFormat(IMFVideoMediaType *iface)
 982 {
 983     struct media_type *media_type = impl_from_IMFVideoMediaType(iface);
 984     unsigned int size;
 985     HRESULT hr;
 986
 987     TRACE("%p.\n", iface);
 988
 989     CoTaskMemFree(media_type->video_format);
 990     media_type->video_format = NULL;
 991     if (FAILED(hr = MFCreateMFVideoFormatFromMFMediaType(&media_type->IMFMediaType_iface, &media_type->video_format, &size)))
 992         WARN("Failed to create format description, hr %#lx.\n", hr);
 993
 994     return media_type->video_format;
 995 }
 996
 997 static HRESULT WINAPI video_mediatype_GetVideoRepresentation(IMFVideoMediaType *iface, GUID representation,
 998         void **data, LONG stride)
 999 {
1000     FIXME("%p, %s, %p, %ld.\n", iface, debugstr_guid(&representation), data, stride);
1001
1002     return E_NOTIMPL;
1003 }
1004
1005 static const IMFVideoMediaTypeVtbl videomediatypevtbl =
1006 {
1007     video_mediatype_QueryInterface,
1008     video_mediatype_AddRef,
1009     video_mediatype_Release,
1010     video_mediatype_GetItem,
1011     video_mediatype_GetItemType,
1012     video_mediatype_CompareItem,
1013     video_mediatype_Compare,
1014     video_mediatype_GetUINT32,
1015     video_mediatype_GetUINT64,
1016     video_mediatype_GetDouble,
1017     video_mediatype_GetGUID,
1018     video_mediatype_GetStringLength,
1019     video_mediatype_GetString,
1020     video_mediatype_GetAllocatedString,
1021     video_mediatype_GetBlobSize,
1022     video_mediatype_GetBlob,
1023     video_mediatype_GetAllocatedBlob,
1024     video_mediatype_GetUnknown,
1025     video_mediatype_SetItem,
1026     video_mediatype_DeleteItem,
1027     video_mediatype_DeleteAllItems,
1028     video_mediatype_SetUINT32,
1029     video_mediatype_SetUINT64,
1030     video_mediatype_SetDouble,
1031     video_mediatype_SetGUID,
1032     video_mediatype_SetString,
1033     video_mediatype_SetBlob,
1034     video_mediatype_SetUnknown,
1035     video_mediatype_LockStore,
1036     video_mediatype_UnlockStore,
1037     video_mediatype_GetCount,
1038     video_mediatype_GetItemByIndex,
1039     video_mediatype_CopyAllItems,
1040     video_mediatype_GetMajorType,
1041     video_mediatype_IsCompressedFormat,
1042     video_mediatype_IsEqual,
1043     video_mediatype_GetRepresentation,
1044     video_mediatype_FreeRepresentation,
1045     video_mediatype_GetVideoFormat,
1046     video_mediatype_GetVideoRepresentation,
1047 };
1048
1049 static HRESULT WINAPI audio_mediatype_QueryInterface(IMFAudioMediaType *iface, REFIID riid, void **out)
1050 {
1051     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1052     return IMFMediaType_QueryInterface(&media_type->IMFMediaType_iface, riid, out);
1053 }
1054
1055 static ULONG WINAPI audio_mediatype_AddRef(IMFAudioMediaType *iface)
1056 {
1057     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1058     return IMFMediaType_AddRef(&media_type->IMFMediaType_iface);
1059 }
1060
1061 static ULONG WINAPI audio_mediatype_Release(IMFAudioMediaType *iface)
1062 {
1063     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1064     return IMFMediaType_Release(&media_type->IMFMediaType_iface);
1065 }
1066
1067 static HRESULT WINAPI audio_mediatype_GetItem(IMFAudioMediaType *iface, REFGUID key, PROPVARIANT *value)
1068 {
1069     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1070
1071     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1072
1073     return attributes_GetItem(&media_type->attributes, key, value);
1074 }
1075
1076 static HRESULT WINAPI audio_mediatype_GetItemType(IMFAudioMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1077 {
1078     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1079
1080     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
1081
1082     return attributes_GetItemType(&media_type->attributes, key, type);
1083 }
1084
1085 static HRESULT WINAPI audio_mediatype_CompareItem(IMFAudioMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
1086 {
1087     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1088
1089     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
1090
1091     return attributes_CompareItem(&media_type->attributes, key, value, result);
1092 }
1093
1094 static HRESULT WINAPI audio_mediatype_Compare(IMFAudioMediaType *iface, IMFAttributes *attrs,
1095         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1096 {
1097     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1098
1099     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
1100
1101     return attributes_Compare(&media_type->attributes, attrs, type, result);
1102 }
1103
1104 static HRESULT WINAPI audio_mediatype_GetUINT32(IMFAudioMediaType *iface, REFGUID key, UINT32 *value)
1105 {
1106     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1107
1108     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1109
1110     return attributes_GetUINT32(&media_type->attributes, key, value);
1111 }
1112
1113 static HRESULT WINAPI audio_mediatype_GetUINT64(IMFAudioMediaType *iface, REFGUID key, UINT64 *value)
1114 {
1115     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1116
1117     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1118
1119     return attributes_GetUINT64(&media_type->attributes, key, value);
1120 }
1121
1122 static HRESULT WINAPI audio_mediatype_GetDouble(IMFAudioMediaType *iface, REFGUID key, double *value)
1123 {
1124     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1125
1126     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1127
1128     return attributes_GetDouble(&media_type->attributes, key, value);
1129 }
1130
1131 static HRESULT WINAPI audio_mediatype_GetGUID(IMFAudioMediaType *iface, REFGUID key, GUID *value)
1132 {
1133     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1134
1135     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1136
1137     return attributes_GetGUID(&media_type->attributes, key, value);
1138 }
1139
1140 static HRESULT WINAPI audio_mediatype_GetStringLength(IMFAudioMediaType *iface, REFGUID key, UINT32 *length)
1141 {
1142     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1143
1144     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
1145
1146     return attributes_GetStringLength(&media_type->attributes, key, length);
1147 }
1148
1149 static HRESULT WINAPI audio_mediatype_GetString(IMFAudioMediaType *iface, REFGUID key, WCHAR *value,
1150         UINT32 size, UINT32 *length)
1151 {
1152     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1153
1154     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
1155
1156     return attributes_GetString(&media_type->attributes, key, value, size, length);
1157 }
1158
1159 static HRESULT WINAPI audio_mediatype_GetAllocatedString(IMFAudioMediaType *iface, REFGUID key,
1160         WCHAR **value, UINT32 *length)
1161 {
1162     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1163
1164     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
1165
1166     return attributes_GetAllocatedString(&media_type->attributes, key, value, length);
1167 }
1168
1169 static HRESULT WINAPI audio_mediatype_GetBlobSize(IMFAudioMediaType *iface, REFGUID key, UINT32 *size)
1170 {
1171     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1172
1173     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
1174
1175     return attributes_GetBlobSize(&media_type->attributes, key, size);
1176 }
1177
1178 static HRESULT WINAPI audio_mediatype_GetBlob(IMFAudioMediaType *iface, REFGUID key, UINT8 *buf,
1179         UINT32 bufsize, UINT32 *blobsize)
1180 {
1181     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1182
1183     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
1184
1185     return attributes_GetBlob(&media_type->attributes, key, buf, bufsize, blobsize);
1186 }
1187
1188 static HRESULT WINAPI audio_mediatype_GetAllocatedBlob(IMFAudioMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1189 {
1190     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1191
1192     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
1193
1194     return attributes_GetAllocatedBlob(&media_type->attributes, key, buf, size);
1195 }
1196
1197 static HRESULT WINAPI audio_mediatype_GetUnknown(IMFAudioMediaType *iface, REFGUID key, REFIID riid, void **obj)
1198 {
1199     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1200
1201     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
1202
1203     return attributes_GetUnknown(&media_type->attributes, key, riid, obj);
1204 }
1205
1206 static HRESULT WINAPI audio_mediatype_SetItem(IMFAudioMediaType *iface, REFGUID key, REFPROPVARIANT value)
1207 {
1208     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1209
1210     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
1211
1212     return attributes_SetItem(&media_type->attributes, key, value);
1213 }
1214
1215 static HRESULT WINAPI audio_mediatype_DeleteItem(IMFAudioMediaType *iface, REFGUID key)
1216 {
1217     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1218
1219     TRACE("%p, %s.\n", iface, debugstr_attr(key));
1220
1221     return attributes_DeleteItem(&media_type->attributes, key);
1222 }
1223
1224 static HRESULT WINAPI audio_mediatype_DeleteAllItems(IMFAudioMediaType *iface)
1225 {
1226     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1227
1228     TRACE("%p.\n", iface);
1229
1230     return attributes_DeleteAllItems(&media_type->attributes);
1231 }
1232
1233 static HRESULT WINAPI audio_mediatype_SetUINT32(IMFAudioMediaType *iface, REFGUID key, UINT32 value)
1234 {
1235     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1236
1237     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
1238
1239     return attributes_SetUINT32(&media_type->attributes, key, value);
1240 }
1241
1242 static HRESULT WINAPI audio_mediatype_SetUINT64(IMFAudioMediaType *iface, REFGUID key, UINT64 value)
1243 {
1244     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1245
1246     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
1247
1248     return attributes_SetUINT64(&media_type->attributes, key, value);
1249 }
1250
1251 static HRESULT WINAPI audio_mediatype_SetDouble(IMFAudioMediaType *iface, REFGUID key, double value)
1252 {
1253     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1254
1255     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
1256
1257     return attributes_SetDouble(&media_type->attributes, key, value);
1258 }
1259
1260 static HRESULT WINAPI audio_mediatype_SetGUID(IMFAudioMediaType *iface, REFGUID key, REFGUID value)
1261 {
1262     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1263
1264     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
1265
1266     return attributes_SetGUID(&media_type->attributes, key, value);
1267 }
1268
1269 static HRESULT WINAPI audio_mediatype_SetString(IMFAudioMediaType *iface, REFGUID key, const WCHAR *value)
1270 {
1271     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1272
1273     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
1274
1275     return attributes_SetString(&media_type->attributes, key, value);
1276 }
1277
1278 static HRESULT WINAPI audio_mediatype_SetBlob(IMFAudioMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1279 {
1280     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1281
1282     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
1283
1284     return attributes_SetBlob(&media_type->attributes, key, buf, size);
1285 }
1286
1287 static HRESULT WINAPI audio_mediatype_SetUnknown(IMFAudioMediaType *iface, REFGUID key, IUnknown *unknown)
1288 {
1289     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1290
1291     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
1292
1293     return attributes_SetUnknown(&media_type->attributes, key, unknown);
1294 }
1295
1296 static HRESULT WINAPI audio_mediatype_LockStore(IMFAudioMediaType *iface)
1297 {
1298     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1299
1300     TRACE("%p.\n", iface);
1301
1302     return attributes_LockStore(&media_type->attributes);
1303 }
1304
1305 static HRESULT WINAPI audio_mediatype_UnlockStore(IMFAudioMediaType *iface)
1306 {
1307     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1308
1309     TRACE("%p.\n", iface);
1310
1311     return attributes_UnlockStore(&media_type->attributes);
1312 }
1313
1314 static HRESULT WINAPI audio_mediatype_GetCount(IMFAudioMediaType *iface, UINT32 *count)
1315 {
1316     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1317
1318     TRACE("%p, %p.\n", iface, count);
1319
1320     return attributes_GetCount(&media_type->attributes, count);
1321 }
1322
1323 static HRESULT WINAPI audio_mediatype_GetItemByIndex(IMFAudioMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1324 {
1325     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1326
1327     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1328
1329     return attributes_GetItemByIndex(&media_type->attributes, index, key, value);
1330 }
1331
1332 static HRESULT WINAPI audio_mediatype_CopyAllItems(IMFAudioMediaType *iface, IMFAttributes *dest)
1333 {
1334     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1335
1336     TRACE("%p, %p.\n", iface, dest);
1337
1338     return attributes_CopyAllItems(&media_type->attributes, dest);
1339 }
1340
1341 static HRESULT WINAPI audio_mediatype_GetMajorType(IMFAudioMediaType *iface, GUID *guid)
1342 {
1343     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1344
1345     TRACE("%p, %p.\n", iface, guid);
1346
1347     return attributes_GetGUID(&media_type->attributes, &MF_MT_MAJOR_TYPE, guid);
1348 }
1349
1350 static HRESULT WINAPI audio_mediatype_IsCompressedFormat(IMFAudioMediaType *iface, BOOL *compressed)
1351 {
1352     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1353
1354     TRACE("%p, %p.\n", iface, compressed);
1355
1356     return mediatype_is_compressed(media_type, compressed);
1357 }
1358
1359 static HRESULT WINAPI audio_mediatype_IsEqual(IMFAudioMediaType *iface, IMFMediaType *type, DWORD *flags)
1360 {
1361     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1362
1363     TRACE("%p, %p, %p.\n", iface, type, flags);
1364
1365     return media_type_is_equal(media_type, type, flags);
1366 }
1367
1368 static HRESULT WINAPI audio_mediatype_GetRepresentation(IMFAudioMediaType *iface, GUID guid, void **representation)
1369 {
1370     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
1371
1372     return E_NOTIMPL;
1373 }
1374
1375 static HRESULT WINAPI audio_mediatype_FreeRepresentation(IMFAudioMediaType *iface, GUID guid, void *representation)
1376 {
1377     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
1378
1379     return E_NOTIMPL;
1380 }
1381
1382 static const WAVEFORMATEX * WINAPI audio_mediatype_GetAudioFormat(IMFAudioMediaType *iface)
1383 {
1384     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1385     unsigned int size;
1386     HRESULT hr;
1387
1388     TRACE("%p.\n", iface);
1389
1390     CoTaskMemFree(media_type->audio_format);
1391     media_type->audio_format = NULL;
1392     if (FAILED(hr = MFCreateWaveFormatExFromMFMediaType(&media_type->IMFMediaType_iface, &media_type->audio_format,
1393             &size, MFWaveFormatExConvertFlag_Normal)))
1394     {
1395         WARN("Failed to create wave format description, hr %#lx.\n", hr);
1396     }
1397
1398     return media_type->audio_format;
1399 }
1400
1401 static const IMFAudioMediaTypeVtbl audiomediatypevtbl =
1402 {
1403     audio_mediatype_QueryInterface,
1404     audio_mediatype_AddRef,
1405     audio_mediatype_Release,
1406     audio_mediatype_GetItem,
1407     audio_mediatype_GetItemType,
1408     audio_mediatype_CompareItem,
1409     audio_mediatype_Compare,
1410     audio_mediatype_GetUINT32,
1411     audio_mediatype_GetUINT64,
1412     audio_mediatype_GetDouble,
1413     audio_mediatype_GetGUID,
1414     audio_mediatype_GetStringLength,
1415     audio_mediatype_GetString,
1416     audio_mediatype_GetAllocatedString,
1417     audio_mediatype_GetBlobSize,
1418     audio_mediatype_GetBlob,
1419     audio_mediatype_GetAllocatedBlob,
1420     audio_mediatype_GetUnknown,
1421     audio_mediatype_SetItem,
1422     audio_mediatype_DeleteItem,
1423     audio_mediatype_DeleteAllItems,
1424     audio_mediatype_SetUINT32,
1425     audio_mediatype_SetUINT64,
1426     audio_mediatype_SetDouble,
1427     audio_mediatype_SetGUID,
1428     audio_mediatype_SetString,
1429     audio_mediatype_SetBlob,
1430     audio_mediatype_SetUnknown,
1431     audio_mediatype_LockStore,
1432     audio_mediatype_UnlockStore,
1433     audio_mediatype_GetCount,
1434     audio_mediatype_GetItemByIndex,
1435     audio_mediatype_CopyAllItems,
1436     audio_mediatype_GetMajorType,
1437     audio_mediatype_IsCompressedFormat,
1438     audio_mediatype_IsEqual,
1439     audio_mediatype_GetRepresentation,
1440     audio_mediatype_FreeRepresentation,
1441     audio_mediatype_GetAudioFormat,
1442 };
1443
1444 static HRESULT create_media_type(struct media_type **ret)
1445 {
1446     struct media_type *object;
1447     HRESULT hr;
1448
1449     if (!(object = calloc(1, sizeof(*object))))
1450         return E_OUTOFMEMORY;
1451
1452     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
1453     {
1454         free(object);
1455         return hr;
1456     }
1457     object->IMFMediaType_iface.lpVtbl = &mediatypevtbl;
1458     object->IMFVideoMediaType_iface.lpVtbl = &videomediatypevtbl;
1459     object->IMFAudioMediaType_iface.lpVtbl = &audiomediatypevtbl;
1460
1461     *ret = object;
1462
1463     return S_OK;
1464 }
1465
1466 /***********************************************************************
1467  *      MFCreateMediaType (mfplat.@)
1468  */
1469 HRESULT WINAPI MFCreateMediaType(IMFMediaType **media_type)
1470 {
1471     struct media_type *object;
1472     HRESULT hr;
1473
1474     TRACE("%p.\n", media_type);
1475
1476     if (!media_type)
1477         return E_INVALIDARG;
1478
1479     if (FAILED(hr = create_media_type(&object)))
1480         return hr;
1481
1482     *media_type = &object->IMFMediaType_iface;
1483
1484     TRACE("Created media type %p.\n", *media_type);
1485
1486     return S_OK;
1487 }
1488
1489 static HRESULT WINAPI stream_descriptor_QueryInterface(IMFStreamDescriptor *iface, REFIID riid, void **out)
1490 {
1491     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
1492
1493     if (IsEqualIID(riid, &IID_IMFStreamDescriptor) ||
1494             IsEqualIID(riid, &IID_IMFAttributes) ||
1495             IsEqualIID(riid, &IID_IUnknown))
1496     {
1497         *out = iface;
1498         IMFStreamDescriptor_AddRef(iface);
1499         return S_OK;
1500     }
1501
1502     WARN("Unsupported %s.\n", debugstr_guid(riid));
1503     *out = NULL;
1504     return E_NOINTERFACE;
1505 }
1506
1507 static ULONG WINAPI stream_descriptor_AddRef(IMFStreamDescriptor *iface)
1508 {
1509     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1510     ULONG refcount = InterlockedIncrement(&stream_desc->attributes.ref);
1511
1512     TRACE("%p, refcount %lu.\n", iface, refcount);
1513
1514     return refcount;
1515 }
1516
1517 static ULONG WINAPI stream_descriptor_Release(IMFStreamDescriptor *iface)
1518 {
1519     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1520     ULONG refcount = InterlockedDecrement(&stream_desc->attributes.ref);
1521     unsigned int i;
1522
1523     TRACE("%p, refcount %lu.\n", iface, refcount);
1524
1525     if (!refcount)
1526     {
1527         for (i = 0; i < stream_desc->media_types_count; ++i)
1528         {
1529             if (stream_desc->media_types[i])
1530                 IMFMediaType_Release(stream_desc->media_types[i]);
1531         }
1532         free(stream_desc->media_types);
1533         if (stream_desc->current_type)
1534             IMFMediaType_Release(stream_desc->current_type);
1535         clear_attributes_object(&stream_desc->attributes);
1536         free(stream_desc);
1537     }
1538
1539     return refcount;
1540 }
1541
1542 static HRESULT WINAPI stream_descriptor_GetItem(IMFStreamDescriptor *iface, REFGUID key, PROPVARIANT *value)
1543 {
1544     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1545
1546     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1547
1548     return attributes_GetItem(&stream_desc->attributes, key, value);
1549 }
1550
1551 static HRESULT WINAPI stream_descriptor_GetItemType(IMFStreamDescriptor *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1552 {
1553     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1554
1555     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
1556
1557     return attributes_GetItemType(&stream_desc->attributes, key, type);
1558 }
1559
1560 static HRESULT WINAPI stream_descriptor_CompareItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value,
1561         BOOL *result)
1562 {
1563     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1564
1565     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
1566
1567     return attributes_CompareItem(&stream_desc->attributes, key, value, result);
1568 }
1569
1570 static HRESULT WINAPI stream_descriptor_Compare(IMFStreamDescriptor *iface, IMFAttributes *theirs,
1571         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1572 {
1573     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1574
1575     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
1576
1577     return attributes_Compare(&stream_desc->attributes, theirs, type, result);
1578 }
1579
1580 static HRESULT WINAPI stream_descriptor_GetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 *value)
1581 {
1582     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1583
1584     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1585
1586     return attributes_GetUINT32(&stream_desc->attributes, key, value);
1587 }
1588
1589 static HRESULT WINAPI stream_descriptor_GetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 *value)
1590 {
1591     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1592
1593     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1594
1595     return attributes_GetUINT64(&stream_desc->attributes, key, value);
1596 }
1597
1598 static HRESULT WINAPI stream_descriptor_GetDouble(IMFStreamDescriptor *iface, REFGUID key, double *value)
1599 {
1600     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1601
1602     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1603
1604     return attributes_GetDouble(&stream_desc->attributes, key, value);
1605 }
1606
1607 static HRESULT WINAPI stream_descriptor_GetGUID(IMFStreamDescriptor *iface, REFGUID key, GUID *value)
1608 {
1609     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1610
1611     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1612
1613     return attributes_GetGUID(&stream_desc->attributes, key, value);
1614 }
1615
1616 static HRESULT WINAPI stream_descriptor_GetStringLength(IMFStreamDescriptor *iface, REFGUID key, UINT32 *length)
1617 {
1618     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1619
1620     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
1621
1622     return attributes_GetStringLength(&stream_desc->attributes, key, length);
1623 }
1624
1625 static HRESULT WINAPI stream_descriptor_GetString(IMFStreamDescriptor *iface, REFGUID key, WCHAR *value,
1626         UINT32 size, UINT32 *length)
1627 {
1628     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1629
1630     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
1631
1632     return attributes_GetString(&stream_desc->attributes, key, value, size, length);
1633 }
1634
1635 static HRESULT WINAPI stream_descriptor_GetAllocatedString(IMFStreamDescriptor *iface, REFGUID key,
1636         WCHAR **value, UINT32 *length)
1637 {
1638     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1639
1640     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
1641
1642     return attributes_GetAllocatedString(&stream_desc->attributes, key, value, length);
1643 }
1644
1645 static HRESULT WINAPI stream_descriptor_GetBlobSize(IMFStreamDescriptor *iface, REFGUID key, UINT32 *size)
1646 {
1647     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1648
1649     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
1650
1651     return attributes_GetBlobSize(&stream_desc->attributes, key, size);
1652 }
1653
1654 static HRESULT WINAPI stream_descriptor_GetBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 *buf,
1655         UINT32 bufsize, UINT32 *blobsize)
1656 {
1657     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1658
1659     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
1660
1661     return attributes_GetBlob(&stream_desc->attributes, key, buf, bufsize, blobsize);
1662 }
1663
1664 static HRESULT WINAPI stream_descriptor_GetAllocatedBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 **buf,
1665         UINT32 *size)
1666 {
1667     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1668
1669     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
1670
1671     return attributes_GetAllocatedBlob(&stream_desc->attributes, key, buf, size);
1672 }
1673
1674 static HRESULT WINAPI stream_descriptor_GetUnknown(IMFStreamDescriptor *iface, REFGUID key, REFIID riid, void **out)
1675 {
1676     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1677
1678     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
1679
1680     return attributes_GetUnknown(&stream_desc->attributes, key, riid, out);
1681 }
1682
1683 static HRESULT WINAPI stream_descriptor_SetItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value)
1684 {
1685     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1686
1687     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
1688
1689     return attributes_SetItem(&stream_desc->attributes, key, value);
1690 }
1691
1692 static HRESULT WINAPI stream_descriptor_DeleteItem(IMFStreamDescriptor *iface, REFGUID key)
1693 {
1694     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1695
1696     TRACE("%p, %s.\n", iface, debugstr_attr(key));
1697
1698     return attributes_DeleteItem(&stream_desc->attributes, key);
1699 }
1700
1701 static HRESULT WINAPI stream_descriptor_DeleteAllItems(IMFStreamDescriptor *iface)
1702 {
1703     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1704
1705     TRACE("%p.\n", iface);
1706
1707     return attributes_DeleteAllItems(&stream_desc->attributes);
1708 }
1709
1710 static HRESULT WINAPI stream_descriptor_SetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 value)
1711 {
1712     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1713
1714     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
1715
1716     return attributes_SetUINT32(&stream_desc->attributes, key, value);
1717 }
1718
1719 static HRESULT WINAPI stream_descriptor_SetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 value)
1720 {
1721     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1722
1723     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
1724
1725     return attributes_SetUINT64(&stream_desc->attributes, key, value);
1726 }
1727
1728 static HRESULT WINAPI stream_descriptor_SetDouble(IMFStreamDescriptor *iface, REFGUID key, double value)
1729 {
1730     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1731
1732     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
1733
1734     return attributes_SetDouble(&stream_desc->attributes, key, value);
1735 }
1736
1737 static HRESULT WINAPI stream_descriptor_SetGUID(IMFStreamDescriptor *iface, REFGUID key, REFGUID value)
1738 {
1739     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1740
1741     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
1742
1743     return attributes_SetGUID(&stream_desc->attributes, key, value);
1744 }
1745
1746 static HRESULT WINAPI stream_descriptor_SetString(IMFStreamDescriptor *iface, REFGUID key, const WCHAR *value)
1747 {
1748     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1749
1750     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
1751
1752     return attributes_SetString(&stream_desc->attributes, key, value);
1753 }
1754
1755 static HRESULT WINAPI stream_descriptor_SetBlob(IMFStreamDescriptor *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1756 {
1757     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1758
1759     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
1760
1761     return attributes_SetBlob(&stream_desc->attributes, key, buf, size);
1762 }
1763
1764 static HRESULT WINAPI stream_descriptor_SetUnknown(IMFStreamDescriptor *iface, REFGUID key, IUnknown *unknown)
1765 {
1766     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1767
1768     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
1769
1770     return attributes_SetUnknown(&stream_desc->attributes, key, unknown);
1771 }
1772
1773 static HRESULT WINAPI stream_descriptor_LockStore(IMFStreamDescriptor *iface)
1774 {
1775     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1776
1777     TRACE("%p.\n", iface);
1778
1779     return attributes_LockStore(&stream_desc->attributes);
1780 }
1781
1782 static HRESULT WINAPI stream_descriptor_UnlockStore(IMFStreamDescriptor *iface)
1783 {
1784     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1785
1786     TRACE("%p.\n", iface);
1787
1788     return attributes_UnlockStore(&stream_desc->attributes);
1789 }
1790
1791 static HRESULT WINAPI stream_descriptor_GetCount(IMFStreamDescriptor *iface, UINT32 *count)
1792 {
1793     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1794
1795     TRACE("%p, %p.\n", iface, count);
1796
1797     return attributes_GetCount(&stream_desc->attributes, count);
1798 }
1799
1800 static HRESULT WINAPI stream_descriptor_GetItemByIndex(IMFStreamDescriptor *iface, UINT32 index, GUID *key,
1801         PROPVARIANT *value)
1802 {
1803     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1804
1805     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1806
1807     return attributes_GetItemByIndex(&stream_desc->attributes, index, key, value);
1808 }
1809
1810 static HRESULT WINAPI stream_descriptor_CopyAllItems(IMFStreamDescriptor *iface, IMFAttributes *dest)
1811 {
1812     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1813
1814     TRACE("%p, %p.\n", iface, dest);
1815
1816     return attributes_CopyAllItems(&stream_desc->attributes, dest);
1817 }
1818
1819 static HRESULT WINAPI stream_descriptor_GetStreamIdentifier(IMFStreamDescriptor *iface, DWORD *identifier)
1820 {
1821     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1822
1823     TRACE("%p, %p.\n", iface, identifier);
1824
1825     *identifier = stream_desc->identifier;
1826
1827     return S_OK;
1828 }
1829
1830 static HRESULT WINAPI stream_descriptor_GetMediaTypeHandler(IMFStreamDescriptor *iface, IMFMediaTypeHandler **handler)
1831 {
1832     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1833
1834     TRACE("%p, %p.\n", iface, handler);
1835
1836     *handler = &stream_desc->IMFMediaTypeHandler_iface;
1837     IMFMediaTypeHandler_AddRef(*handler);
1838
1839     return S_OK;
1840 }
1841
1842 static const IMFStreamDescriptorVtbl streamdescriptorvtbl =
1843 {
1844     stream_descriptor_QueryInterface,
1845     stream_descriptor_AddRef,
1846     stream_descriptor_Release,
1847     stream_descriptor_GetItem,
1848     stream_descriptor_GetItemType,
1849     stream_descriptor_CompareItem,
1850     stream_descriptor_Compare,
1851     stream_descriptor_GetUINT32,
1852     stream_descriptor_GetUINT64,
1853     stream_descriptor_GetDouble,
1854     stream_descriptor_GetGUID,
1855     stream_descriptor_GetStringLength,
1856     stream_descriptor_GetString,
1857     stream_descriptor_GetAllocatedString,
1858     stream_descriptor_GetBlobSize,
1859     stream_descriptor_GetBlob,
1860     stream_descriptor_GetAllocatedBlob,
1861     stream_descriptor_GetUnknown,
1862     stream_descriptor_SetItem,
1863     stream_descriptor_DeleteItem,
1864     stream_descriptor_DeleteAllItems,
1865     stream_descriptor_SetUINT32,
1866     stream_descriptor_SetUINT64,
1867     stream_descriptor_SetDouble,
1868     stream_descriptor_SetGUID,
1869     stream_descriptor_SetString,
1870     stream_descriptor_SetBlob,
1871     stream_descriptor_SetUnknown,
1872     stream_descriptor_LockStore,
1873     stream_descriptor_UnlockStore,
1874     stream_descriptor_GetCount,
1875     stream_descriptor_GetItemByIndex,
1876     stream_descriptor_CopyAllItems,
1877     stream_descriptor_GetStreamIdentifier,
1878     stream_descriptor_GetMediaTypeHandler
1879 };
1880
1881 static HRESULT WINAPI mediatype_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
1882 {
1883     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1884
1885     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler) ||
1886             IsEqualIID(riid, &IID_IUnknown))
1887     {
1888         *obj = iface;
1889         IMFMediaTypeHandler_AddRef(iface);
1890         return S_OK;
1891     }
1892
1893     WARN("Unsupported %s.\n", debugstr_guid(riid));
1894     *obj = NULL;
1895     return E_NOINTERFACE;
1896 }
1897
1898 static ULONG WINAPI mediatype_handler_AddRef(IMFMediaTypeHandler *iface)
1899 {
1900     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1901     return IMFStreamDescriptor_AddRef(&stream_desc->IMFStreamDescriptor_iface);
1902 }
1903
1904 static ULONG WINAPI mediatype_handler_Release(IMFMediaTypeHandler *iface)
1905 {
1906     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1907     return IMFStreamDescriptor_Release(&stream_desc->IMFStreamDescriptor_iface);
1908 }
1909
1910 static BOOL stream_descriptor_is_mediatype_supported(IMFMediaType *media_type, IMFMediaType *candidate)
1911 {
1912     DWORD flags = 0;
1913
1914     if (FAILED(IMFMediaType_IsEqual(media_type, candidate, &flags)))
1915         return FALSE;
1916
1917     return (flags & (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES)) ==
1918             (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES);
1919 }
1920
1921 static HRESULT WINAPI mediatype_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
1922         IMFMediaType **out_type)
1923 {
1924     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1925     BOOL supported = FALSE;
1926     unsigned int i;
1927
1928     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1929
1930     if (!in_type)
1931         return E_POINTER;
1932
1933     if (out_type)
1934         *out_type = NULL;
1935
1936     EnterCriticalSection(&stream_desc->attributes.cs);
1937
1938     supported = stream_desc->current_type && stream_descriptor_is_mediatype_supported(stream_desc->current_type, in_type);
1939     if (!supported)
1940     {
1941         for (i = 0; i < stream_desc->media_types_count; ++i)
1942         {
1943             if ((supported = stream_descriptor_is_mediatype_supported(stream_desc->media_types[i], in_type)))
1944                 break;
1945         }
1946     }
1947
1948     LeaveCriticalSection(&stream_desc->attributes.cs);
1949
1950     return supported ? S_OK : MF_E_INVALIDMEDIATYPE;
1951 }
1952
1953 static HRESULT WINAPI mediatype_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1954 {
1955     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1956
1957     TRACE("%p, %p.\n", iface, count);
1958
1959     *count = stream_desc->media_types_count;
1960
1961     return S_OK;
1962 }
1963
1964 static HRESULT WINAPI mediatype_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1965         IMFMediaType **type)
1966 {
1967     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1968
1969     TRACE("%p, %lu, %p.\n", iface, index, type);
1970
1971     if (index >= stream_desc->media_types_count)
1972         return MF_E_NO_MORE_TYPES;
1973
1974     if (stream_desc->media_types[index])
1975     {
1976         *type = stream_desc->media_types[index];
1977         IMFMediaType_AddRef(*type);
1978     }
1979
1980     return stream_desc->media_types[index] ? S_OK : E_FAIL;
1981 }
1982
1983 static HRESULT WINAPI mediatype_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
1984 {
1985     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1986
1987     TRACE("%p, %p.\n", iface, type);
1988
1989     if (!type)
1990         return E_POINTER;
1991
1992     EnterCriticalSection(&stream_desc->attributes.cs);
1993     if (stream_desc->current_type)
1994         IMFMediaType_Release(stream_desc->current_type);
1995     stream_desc->current_type = type;
1996     IMFMediaType_AddRef(stream_desc->current_type);
1997     LeaveCriticalSection(&stream_desc->attributes.cs);
1998
1999     return S_OK;
2000 }
2001
2002 static HRESULT WINAPI mediatype_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
2003 {
2004     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
2005     HRESULT hr = S_OK;
2006
2007     TRACE("%p, %p.\n", iface, type);
2008
2009     EnterCriticalSection(&stream_desc->attributes.cs);
2010     if (stream_desc->current_type)
2011     {
2012         *type = stream_desc->current_type;
2013         IMFMediaType_AddRef(*type);
2014     }
2015     else
2016         hr = MF_E_NOT_INITIALIZED;
2017     LeaveCriticalSection(&stream_desc->attributes.cs);
2018
2019     return hr;
2020 }
2021
2022 static HRESULT WINAPI mediatype_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
2023 {
2024     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
2025     HRESULT hr;
2026
2027     TRACE("%p, %p.\n", iface, type);
2028
2029     EnterCriticalSection(&stream_desc->attributes.cs);
2030     hr = IMFMediaType_GetGUID(stream_desc->current_type ? stream_desc->current_type :
2031             stream_desc->media_types[0], &MF_MT_MAJOR_TYPE, type);
2032     LeaveCriticalSection(&stream_desc->attributes.cs);
2033
2034     return hr;
2035 }
2036
2037 static const IMFMediaTypeHandlerVtbl mediatypehandlervtbl =
2038 {
2039     mediatype_handler_QueryInterface,
2040     mediatype_handler_AddRef,
2041     mediatype_handler_Release,
2042     mediatype_handler_IsMediaTypeSupported,
2043     mediatype_handler_GetMediaTypeCount,
2044     mediatype_handler_GetMediaTypeByIndex,
2045     mediatype_handler_SetCurrentMediaType,
2046     mediatype_handler_GetCurrentMediaType,
2047     mediatype_handler_GetMajorType,
2048 };
2049
2050 /***********************************************************************
2051  *      MFCreateStreamDescriptor (mfplat.@)
2052  */
2053 HRESULT WINAPI MFCreateStreamDescriptor(DWORD identifier, DWORD count,
2054         IMFMediaType **types, IMFStreamDescriptor **descriptor)
2055 {
2056     struct stream_desc *object;
2057     unsigned int i;
2058     HRESULT hr;
2059
2060     TRACE("%ld, %ld, %p, %p.\n", identifier, count, types, descriptor);
2061
2062     if (!count)
2063         return E_INVALIDARG;
2064
2065     if (!(object = calloc(1, sizeof(*object))))
2066         return E_OUTOFMEMORY;
2067
2068     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
2069     {
2070         free(object);
2071         return hr;
2072     }
2073     object->IMFStreamDescriptor_iface.lpVtbl = &streamdescriptorvtbl;
2074     object->IMFMediaTypeHandler_iface.lpVtbl = &mediatypehandlervtbl;
2075     object->identifier = identifier;
2076     object->media_types = calloc(count, sizeof(*object->media_types));
2077     if (!object->media_types)
2078     {
2079         IMFStreamDescriptor_Release(&object->IMFStreamDescriptor_iface);
2080         return E_OUTOFMEMORY;
2081     }
2082     for (i = 0; i < count; ++i)
2083     {
2084         object->media_types[i] = types[i];
2085         if (object->media_types[i])
2086             IMFMediaType_AddRef(object->media_types[i]);
2087     }
2088     object->media_types_count = count;
2089
2090     *descriptor = &object->IMFStreamDescriptor_iface;
2091
2092     return S_OK;
2093 }
2094
2095 static HRESULT WINAPI presentation_descriptor_QueryInterface(IMFPresentationDescriptor *iface, REFIID riid, void **out)
2096 {
2097     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
2098
2099     if (IsEqualIID(riid, &IID_IMFPresentationDescriptor) ||
2100             IsEqualIID(riid, &IID_IMFAttributes) ||
2101             IsEqualIID(riid, &IID_IUnknown))
2102     {
2103         *out = iface;
2104         IMFPresentationDescriptor_AddRef(iface);
2105         return S_OK;
2106     }
2107
2108     WARN("Unsupported %s.\n", debugstr_guid(riid));
2109     *out = NULL;
2110     return E_NOINTERFACE;
2111 }
2112
2113 static ULONG WINAPI presentation_descriptor_AddRef(IMFPresentationDescriptor *iface)
2114 {
2115     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2116     ULONG refcount = InterlockedIncrement(&presentation_desc->attributes.ref);
2117
2118     TRACE("%p, refcount %lu.\n", iface, refcount);
2119
2120     return refcount;
2121 }
2122
2123 static ULONG WINAPI presentation_descriptor_Release(IMFPresentationDescriptor *iface)
2124 {
2125     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2126     ULONG refcount = InterlockedDecrement(&presentation_desc->attributes.ref);
2127     unsigned int i;
2128
2129     TRACE("%p, refcount %lu.\n", iface, refcount);
2130
2131     if (!refcount)
2132     {
2133         for (i = 0; i < presentation_desc->count; ++i)
2134         {
2135             if (presentation_desc->descriptors[i].descriptor)
2136                 IMFStreamDescriptor_Release(presentation_desc->descriptors[i].descriptor);
2137         }
2138         clear_attributes_object(&presentation_desc->attributes);
2139         free(presentation_desc->descriptors);
2140         free(presentation_desc);
2141     }
2142
2143     return refcount;
2144 }
2145
2146 static HRESULT WINAPI presentation_descriptor_GetItem(IMFPresentationDescriptor *iface, REFGUID key,
2147         PROPVARIANT *value)
2148 {
2149     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2150
2151     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2152
2153     return attributes_GetItem(&presentation_desc->attributes, key, value);
2154 }
2155
2156 static HRESULT WINAPI presentation_descriptor_GetItemType(IMFPresentationDescriptor *iface, REFGUID key,
2157         MF_ATTRIBUTE_TYPE *type)
2158 {
2159     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2160
2161     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
2162
2163     return attributes_GetItemType(&presentation_desc->attributes, key, type);
2164 }
2165
2166 static HRESULT WINAPI presentation_descriptor_CompareItem(IMFPresentationDescriptor *iface, REFGUID key,
2167         REFPROPVARIANT value, BOOL *result)
2168 {
2169     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2170
2171     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
2172
2173     return attributes_CompareItem(&presentation_desc->attributes, key, value, result);
2174 }
2175
2176 static HRESULT WINAPI presentation_descriptor_Compare(IMFPresentationDescriptor *iface, IMFAttributes *attrs,
2177         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
2178 {
2179     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2180
2181     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
2182
2183     return attributes_Compare(&presentation_desc->attributes, attrs, type, result);
2184 }
2185
2186 static HRESULT WINAPI presentation_descriptor_GetUINT32(IMFPresentationDescriptor *iface, REFGUID key, UINT32 *value)
2187 {
2188     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2189
2190     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2191
2192     return attributes_GetUINT32(&presentation_desc->attributes, key, value);
2193 }
2194
2195 static HRESULT WINAPI presentation_descriptor_GetUINT64(IMFPresentationDescriptor *iface, REFGUID key, UINT64 *value)
2196 {
2197     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2198
2199     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2200
2201     return attributes_GetUINT64(&presentation_desc->attributes, key, value);
2202 }
2203
2204 static HRESULT WINAPI presentation_descriptor_GetDouble(IMFPresentationDescriptor *iface, REFGUID key, double *value)
2205 {
2206     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2207
2208     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2209
2210     return attributes_GetDouble(&presentation_desc->attributes, key, value);
2211 }
2212
2213 static HRESULT WINAPI presentation_descriptor_GetGUID(IMFPresentationDescriptor *iface, REFGUID key, GUID *value)
2214 {
2215     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2216
2217     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2218
2219     return attributes_GetGUID(&presentation_desc->attributes, key, value);
2220 }
2221
2222 static HRESULT WINAPI presentation_descriptor_GetStringLength(IMFPresentationDescriptor *iface, REFGUID key,
2223         UINT32 *length)
2224 {
2225     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2226
2227     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
2228
2229     return attributes_GetStringLength(&presentation_desc->attributes, key, length);
2230 }
2231
2232 static HRESULT WINAPI presentation_descriptor_GetString(IMFPresentationDescriptor *iface, REFGUID key, WCHAR *value,
2233         UINT32 size, UINT32 *length)
2234 {
2235     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2236
2237     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
2238
2239     return attributes_GetString(&presentation_desc->attributes, key, value, size, length);
2240 }
2241
2242 static HRESULT WINAPI presentation_descriptor_GetAllocatedString(IMFPresentationDescriptor *iface, REFGUID key,
2243         WCHAR **value, UINT32 *length)
2244 {
2245     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2246
2247     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
2248
2249     return attributes_GetAllocatedString(&presentation_desc->attributes, key, value, length);
2250 }
2251
2252 static HRESULT WINAPI presentation_descriptor_GetBlobSize(IMFPresentationDescriptor *iface, REFGUID key, UINT32 *size)
2253 {
2254     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2255
2256     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
2257
2258     return attributes_GetBlobSize(&presentation_desc->attributes, key, size);
2259 }
2260
2261 static HRESULT WINAPI presentation_descriptor_GetBlob(IMFPresentationDescriptor *iface, REFGUID key, UINT8 *buf,
2262         UINT32 bufsize, UINT32 *blobsize)
2263 {
2264     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2265
2266     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
2267
2268     return attributes_GetBlob(&presentation_desc->attributes, key, buf, bufsize, blobsize);
2269 }
2270
2271 static HRESULT WINAPI presentation_descriptor_GetAllocatedBlob(IMFPresentationDescriptor *iface, REFGUID key,
2272         UINT8 **buf, UINT32 *size)
2273 {
2274     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2275
2276     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
2277
2278     return attributes_GetAllocatedBlob(&presentation_desc->attributes, key, buf, size);
2279 }
2280
2281 static HRESULT WINAPI presentation_descriptor_GetUnknown(IMFPresentationDescriptor *iface, REFGUID key,
2282         REFIID riid, void **out)
2283 {
2284     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2285
2286     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
2287
2288     return attributes_GetUnknown(&presentation_desc->attributes, key, riid, out);
2289 }
2290
2291 static HRESULT WINAPI presentation_descriptor_SetItem(IMFPresentationDescriptor *iface, REFGUID key,
2292         REFPROPVARIANT value)
2293 {
2294     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2295
2296     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
2297
2298     return attributes_SetItem(&presentation_desc->attributes, key, value);
2299 }
2300
2301 static HRESULT WINAPI presentation_descriptor_DeleteItem(IMFPresentationDescriptor *iface, REFGUID key)
2302 {
2303     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2304
2305     TRACE("%p, %s.\n", iface, debugstr_attr(key));
2306
2307     return attributes_DeleteItem(&presentation_desc->attributes, key);
2308 }
2309
2310 static HRESULT WINAPI presentation_descriptor_DeleteAllItems(IMFPresentationDescriptor *iface)
2311 {
2312     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2313
2314     TRACE("%p.\n", iface);
2315
2316     return attributes_DeleteAllItems(&presentation_desc->attributes);
2317 }
2318
2319 static HRESULT WINAPI presentation_descriptor_SetUINT32(IMFPresentationDescriptor *iface, REFGUID key, UINT32 value)
2320 {
2321     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2322
2323     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
2324
2325     return attributes_SetUINT32(&presentation_desc->attributes, key, value);
2326 }
2327
2328 static HRESULT WINAPI presentation_descriptor_SetUINT64(IMFPresentationDescriptor *iface, REFGUID key, UINT64 value)
2329 {
2330     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2331
2332     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
2333
2334     return attributes_SetUINT64(&presentation_desc->attributes, key, value);
2335 }
2336
2337 static HRESULT WINAPI presentation_descriptor_SetDouble(IMFPresentationDescriptor *iface, REFGUID key, double value)
2338 {
2339     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2340
2341     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
2342
2343     return attributes_SetDouble(&presentation_desc->attributes, key, value);
2344 }
2345
2346 static HRESULT WINAPI presentation_descriptor_SetGUID(IMFPresentationDescriptor *iface, REFGUID key, REFGUID value)
2347 {
2348     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2349
2350     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
2351
2352     return attributes_SetGUID(&presentation_desc->attributes, key, value);
2353 }
2354
2355 static HRESULT WINAPI presentation_descriptor_SetString(IMFPresentationDescriptor *iface, REFGUID key,
2356         const WCHAR *value)
2357 {
2358     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2359
2360     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
2361
2362     return attributes_SetString(&presentation_desc->attributes, key, value);
2363 }
2364
2365 static HRESULT WINAPI presentation_descriptor_SetBlob(IMFPresentationDescriptor *iface, REFGUID key, const UINT8 *buf,
2366         UINT32 size)
2367 {
2368     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2369
2370     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
2371
2372     return attributes_SetBlob(&presentation_desc->attributes, key, buf, size);
2373 }
2374
2375 static HRESULT WINAPI presentation_descriptor_SetUnknown(IMFPresentationDescriptor *iface, REFGUID key,
2376         IUnknown *unknown)
2377 {
2378     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2379
2380     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
2381
2382     return attributes_SetUnknown(&presentation_desc->attributes, key, unknown);
2383 }
2384
2385 static HRESULT WINAPI presentation_descriptor_LockStore(IMFPresentationDescriptor *iface)
2386 {
2387     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2388
2389     TRACE("%p.\n", iface);
2390
2391     return attributes_LockStore(&presentation_desc->attributes);
2392 }
2393
2394 static HRESULT WINAPI presentation_descriptor_UnlockStore(IMFPresentationDescriptor *iface)
2395 {
2396     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2397
2398     TRACE("%p.\n", iface);
2399
2400     return attributes_UnlockStore(&presentation_desc->attributes);
2401 }
2402
2403 static HRESULT WINAPI presentation_descriptor_GetCount(IMFPresentationDescriptor *iface, UINT32 *count)
2404 {
2405     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2406
2407     TRACE("%p, %p.\n", iface, count);
2408
2409     return attributes_GetCount(&presentation_desc->attributes, count);
2410 }
2411
2412 static HRESULT WINAPI presentation_descriptor_GetItemByIndex(IMFPresentationDescriptor *iface, UINT32 index, GUID *key,
2413         PROPVARIANT *value)
2414 {
2415     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2416
2417     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2418
2419     return attributes_GetItemByIndex(&presentation_desc->attributes, index, key, value);
2420 }
2421
2422 static HRESULT WINAPI presentation_descriptor_CopyAllItems(IMFPresentationDescriptor *iface, IMFAttributes *dest)
2423 {
2424     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2425
2426     TRACE("%p, %p.\n", iface, dest);
2427
2428     return attributes_CopyAllItems(&presentation_desc->attributes, dest);
2429 }
2430
2431 static HRESULT WINAPI presentation_descriptor_GetStreamDescriptorCount(IMFPresentationDescriptor *iface, DWORD *count)
2432 {
2433     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2434
2435     TRACE("%p, %p.\n", iface, count);
2436
2437     *count = presentation_desc->count;
2438
2439     return S_OK;
2440 }
2441
2442 static HRESULT WINAPI presentation_descriptor_GetStreamDescriptorByIndex(IMFPresentationDescriptor *iface, DWORD index,
2443         BOOL *selected, IMFStreamDescriptor **descriptor)
2444 {
2445     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2446
2447     TRACE("%p, %lu, %p, %p.\n", iface, index, selected, descriptor);
2448
2449     if (index >= presentation_desc->count)
2450         return E_INVALIDARG;
2451
2452     EnterCriticalSection(&presentation_desc->attributes.cs);
2453     *selected = presentation_desc->descriptors[index].selected;
2454     LeaveCriticalSection(&presentation_desc->attributes.cs);
2455
2456     *descriptor = presentation_desc->descriptors[index].descriptor;
2457     IMFStreamDescriptor_AddRef(*descriptor);
2458
2459     return S_OK;
2460 }
2461
2462 static HRESULT WINAPI presentation_descriptor_SelectStream(IMFPresentationDescriptor *iface, DWORD index)
2463 {
2464     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2465
2466     TRACE("%p, %lu.\n", iface, index);
2467
2468     if (index >= presentation_desc->count)
2469         return E_INVALIDARG;
2470
2471     EnterCriticalSection(&presentation_desc->attributes.cs);
2472     presentation_desc->descriptors[index].selected = TRUE;
2473     LeaveCriticalSection(&presentation_desc->attributes.cs);
2474
2475     return S_OK;
2476 }
2477
2478 static HRESULT WINAPI presentation_descriptor_DeselectStream(IMFPresentationDescriptor *iface, DWORD index)
2479 {
2480     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2481
2482     TRACE("%p, %lu.\n", iface, index);
2483
2484     if (index >= presentation_desc->count)
2485         return E_INVALIDARG;
2486
2487     EnterCriticalSection(&presentation_desc->attributes.cs);
2488     presentation_desc->descriptors[index].selected = FALSE;
2489     LeaveCriticalSection(&presentation_desc->attributes.cs);
2490
2491     return S_OK;
2492 }
2493
2494 static HRESULT WINAPI presentation_descriptor_Clone(IMFPresentationDescriptor *iface,
2495         IMFPresentationDescriptor **descriptor)
2496 {
2497     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2498     struct presentation_desc *object;
2499     unsigned int i;
2500
2501     TRACE("%p, %p.\n", iface, descriptor);
2502
2503     if (!(object = calloc(1, sizeof(*object))))
2504         return E_OUTOFMEMORY;
2505
2506     presentation_descriptor_init(object, presentation_desc->count);
2507
2508     EnterCriticalSection(&presentation_desc->attributes.cs);
2509
2510     for (i = 0; i < presentation_desc->count; ++i)
2511     {
2512         object->descriptors[i] = presentation_desc->descriptors[i];
2513         IMFStreamDescriptor_AddRef(object->descriptors[i].descriptor);
2514     }
2515
2516     attributes_CopyAllItems(&presentation_desc->attributes, (IMFAttributes *)&object->IMFPresentationDescriptor_iface);
2517
2518     LeaveCriticalSection(&presentation_desc->attributes.cs);
2519
2520     *descriptor = &object->IMFPresentationDescriptor_iface;
2521
2522     return S_OK;
2523 }
2524
2525 static const IMFPresentationDescriptorVtbl presentationdescriptorvtbl =
2526 {
2527     presentation_descriptor_QueryInterface,
2528     presentation_descriptor_AddRef,
2529     presentation_descriptor_Release,
2530     presentation_descriptor_GetItem,
2531     presentation_descriptor_GetItemType,
2532     presentation_descriptor_CompareItem,
2533     presentation_descriptor_Compare,
2534     presentation_descriptor_GetUINT32,
2535     presentation_descriptor_GetUINT64,
2536     presentation_descriptor_GetDouble,
2537     presentation_descriptor_GetGUID,
2538     presentation_descriptor_GetStringLength,
2539     presentation_descriptor_GetString,
2540     presentation_descriptor_GetAllocatedString,
2541     presentation_descriptor_GetBlobSize,
2542     presentation_descriptor_GetBlob,
2543     presentation_descriptor_GetAllocatedBlob,
2544     presentation_descriptor_GetUnknown,
2545     presentation_descriptor_SetItem,
2546     presentation_descriptor_DeleteItem,
2547     presentation_descriptor_DeleteAllItems,
2548     presentation_descriptor_SetUINT32,
2549     presentation_descriptor_SetUINT64,
2550     presentation_descriptor_SetDouble,
2551     presentation_descriptor_SetGUID,
2552     presentation_descriptor_SetString,
2553     presentation_descriptor_SetBlob,
2554     presentation_descriptor_SetUnknown,
2555     presentation_descriptor_LockStore,
2556     presentation_descriptor_UnlockStore,
2557     presentation_descriptor_GetCount,
2558     presentation_descriptor_GetItemByIndex,
2559     presentation_descriptor_CopyAllItems,
2560     presentation_descriptor_GetStreamDescriptorCount,
2561     presentation_descriptor_GetStreamDescriptorByIndex,
2562     presentation_descriptor_SelectStream,
2563     presentation_descriptor_DeselectStream,
2564     presentation_descriptor_Clone,
2565 };
2566
2567 static HRESULT presentation_descriptor_init(struct presentation_desc *object, DWORD count)
2568 {
2569     HRESULT hr;
2570
2571     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
2572         return hr;
2573     object->IMFPresentationDescriptor_iface.lpVtbl = &presentationdescriptorvtbl;
2574     if (!(object->descriptors = calloc(count, sizeof(*object->descriptors))))
2575     {
2576         IMFPresentationDescriptor_Release(&object->IMFPresentationDescriptor_iface);
2577         return E_OUTOFMEMORY;
2578     }
2579     object->count = count;
2580
2581     return S_OK;
2582 }
2583
2584 /***********************************************************************
2585  *      MFCreatePresentationDescriptor (mfplat.@)
2586  */
2587 HRESULT WINAPI MFCreatePresentationDescriptor(DWORD count, IMFStreamDescriptor **descriptors,
2588         IMFPresentationDescriptor **out)
2589 {
2590     struct presentation_desc *object;
2591     unsigned int i;
2592     HRESULT hr;
2593
2594     TRACE("%lu, %p, %p.\n", count, descriptors, out);
2595
2596     if (!count)
2597         return E_INVALIDARG;
2598
2599     for (i = 0; i < count; ++i)
2600     {
2601         if (!descriptors[i])
2602             return E_INVALIDARG;
2603     }
2604
2605     if (!(object = calloc(1, sizeof(*object))))
2606         return E_OUTOFMEMORY;
2607
2608     if (FAILED(hr = presentation_descriptor_init(object, count)))
2609     {
2610         free(object);
2611         return hr;
2612     }
2613
2614     for (i = 0; i < count; ++i)
2615     {
2616         object->descriptors[i].descriptor = descriptors[i];
2617         IMFStreamDescriptor_AddRef(object->descriptors[i].descriptor);
2618     }
2619
2620     *out = &object->IMFPresentationDescriptor_iface;
2621
2622     return S_OK;
2623 }
2624
2625 struct uncompressed_video_format
2626 {
2627     const GUID *subtype;
2628     unsigned char bytes_per_pixel;
2629     unsigned char alignment;
2630     unsigned char bottom_up;
2631     unsigned char yuv;
2632 };
2633
2634 static int __cdecl uncompressed_video_format_compare(const void *a, const void *b)
2635 {
2636     const GUID *guid = a;
2637     const struct uncompressed_video_format *format = b;
2638     return memcmp(guid, format->subtype, sizeof(*guid));
2639 }
2640
2641 static const struct uncompressed_video_format video_formats[] =
2642 {
2643     { &MFVideoFormat_RGB24,         3, 3, 1, 0 },
2644     { &MFVideoFormat_ARGB32,        4, 3, 1, 0 },
2645     { &MFVideoFormat_RGB32,         4, 3, 1, 0 },
2646     { &MFVideoFormat_RGB565,        2, 3, 1, 0 },
2647     { &MFVideoFormat_RGB555,        2, 3, 1, 0 },
2648     { &MFVideoFormat_A2R10G10B10,   4, 3, 1, 0 },
2649     { &MFVideoFormat_A2B10G10R10,   4, 3, 1, 0 },
2650     { &MFVideoFormat_RGB8,          1, 3, 1, 0 },
2651     { &MFVideoFormat_L8,            1, 3, 1, 0 },
2652     { &MFVideoFormat_AYUV,          4, 3, 0, 1 },
2653     { &MFVideoFormat_I420,          1, 0, 0, 1 },
2654     { &MFVideoFormat_IMC1,          2, 3, 0, 1 },
2655     { &MFVideoFormat_IMC2,          1, 0, 0, 1 },
2656     { &MFVideoFormat_IMC3,          2, 3, 0, 1 },
2657     { &MFVideoFormat_IMC4,          1, 0, 0, 1 },
2658     { &MFVideoFormat_IYUV,          1, 0, 0, 1 },
2659     { &MFVideoFormat_NV11,          1, 0, 0, 1 },
2660     { &MFVideoFormat_NV12,          1, 0, 0, 1 },
2661     { &MFVideoFormat_D16,           2, 3, 0, 0 },
2662     { &MFVideoFormat_L16,           2, 3, 0, 0 },
2663     { &MFVideoFormat_UYVY,          2, 0, 0, 1 },
2664     { &MFVideoFormat_YUY2,          2, 0, 0, 1 },
2665     { &MFVideoFormat_YV12,          1, 0, 0, 1 },
2666     { &MFVideoFormat_YVYU,          2, 0, 0, 1 },
2667     { &MFVideoFormat_A16B16G16R16F, 8, 3, 1, 0 },
2668     { &MEDIASUBTYPE_RGB8,           1, 3, 1, 0 },
2669     { &MEDIASUBTYPE_RGB565,         2, 3, 1, 0 },
2670     { &MEDIASUBTYPE_RGB555,         2, 3, 1, 0 },
2671     { &MEDIASUBTYPE_RGB24,          3, 3, 1, 0 },
2672     { &MEDIASUBTYPE_RGB32,          4, 3, 1, 0 },
2673 };
2674
2675 static struct uncompressed_video_format *mf_get_video_format(const GUID *subtype)
2676 {
2677     return bsearch(subtype, video_formats, ARRAY_SIZE(video_formats), sizeof(*video_formats),
2678             uncompressed_video_format_compare);
2679 }
2680
2681 static unsigned int mf_get_stride_for_format(const struct uncompressed_video_format *format, unsigned int width)
2682 {
2683     return (width * format->bytes_per_pixel + format->alignment) & ~format->alignment;
2684 }
2685
2686 unsigned int mf_format_get_stride(const GUID *subtype, unsigned int width, BOOL *is_yuv)
2687 {
2688     struct uncompressed_video_format *format = mf_get_video_format(subtype);
2689
2690     if (format)
2691     {
2692         *is_yuv = format->yuv;
2693         return mf_get_stride_for_format(format, width);
2694     }
2695
2696     return 0;
2697 }
2698
2699 /***********************************************************************
2700  *      MFGetStrideForBitmapInfoHeader (mfplat.@)
2701  */
2702 HRESULT WINAPI MFGetStrideForBitmapInfoHeader(DWORD fourcc, DWORD width, LONG *stride)
2703 {
2704     struct uncompressed_video_format *format;
2705     GUID subtype;
2706
2707     TRACE("%s, %lu, %p.\n", mf_debugstr_fourcc(fourcc), width, stride);
2708
2709     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
2710     subtype.Data1 = fourcc;
2711
2712     if (!(format = mf_get_video_format(&subtype)))
2713     {
2714         *stride = 0;
2715         return MF_E_INVALIDMEDIATYPE;
2716     }
2717
2718     *stride = mf_get_stride_for_format(format, width);
2719     if (format->bottom_up)
2720         *stride *= -1;
2721
2722     return S_OK;
2723 }
2724
2725 /***********************************************************************
2726  *      MFCalculateImageSize (mfplat.@)
2727  */
2728 HRESULT WINAPI MFCalculateImageSize(REFGUID subtype, UINT32 width, UINT32 height, UINT32 *size)
2729 {
2730     struct uncompressed_video_format *format;
2731     unsigned int stride;
2732
2733     TRACE("%s, %u, %u, %p.\n", debugstr_mf_guid(subtype), width, height, size);
2734
2735     if (!(format = mf_get_video_format(subtype)))
2736     {
2737         *size = 0;
2738         return E_INVALIDARG;
2739     }
2740
2741     switch (subtype->Data1)
2742     {
2743         case MAKEFOURCC('I','M','C','2'):
2744         case MAKEFOURCC('I','M','C','4'):
2745         case MAKEFOURCC('N','V','1','2'):
2746         case MAKEFOURCC('Y','V','1','2'):
2747         case MAKEFOURCC('I','4','2','0'):
2748         case MAKEFOURCC('I','Y','U','V'):
2749             /* 2 x 2 block, interleaving UV for half the height */
2750             *size = ((width + 1) & ~1) * height * 3 / 2;
2751             break;
2752         case MAKEFOURCC('N','V','1','1'):
2753             *size = ((width + 3) & ~3) * height * 3 / 2;
2754             break;
2755         case D3DFMT_L8:
2756         case D3DFMT_L16:
2757         case D3DFMT_D16:
2758             *size = width * format->bytes_per_pixel * height;
2759             break;
2760         default:
2761             stride = mf_get_stride_for_format(format, width);
2762             *size = stride * height;
2763     }
2764
2765     return S_OK;
2766 }
2767
2768 /***********************************************************************
2769  *      MFGetPlaneSize (mfplat.@)
2770  */
2771 HRESULT WINAPI MFGetPlaneSize(DWORD fourcc, DWORD width, DWORD height, DWORD *size)
2772 {
2773     struct uncompressed_video_format *format;
2774     unsigned int stride;
2775     GUID subtype;
2776
2777     TRACE("%s, %lu, %lu, %p.\n", mf_debugstr_fourcc(fourcc), width, height, size);
2778
2779     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
2780     subtype.Data1 = fourcc;
2781
2782     if ((format = mf_get_video_format(&subtype)))
2783         stride = mf_get_stride_for_format(format, width);
2784     else
2785         stride = 0;
2786
2787     switch (fourcc)
2788     {
2789         case MAKEFOURCC('I','M','C','2'):
2790         case MAKEFOURCC('I','M','C','4'):
2791         case MAKEFOURCC('N','V','1','2'):
2792         case MAKEFOURCC('Y','V','1','2'):
2793         case MAKEFOURCC('I','4','2','0'):
2794         case MAKEFOURCC('I','Y','U','V'):
2795         case MAKEFOURCC('N','V','1','1'):
2796             *size = stride * height * 3 / 2;
2797             break;
2798         default:
2799             *size = stride * height;
2800     }
2801
2802     return S_OK;
2803 }
2804
2805 /***********************************************************************
2806  *      MFCompareFullToPartialMediaType (mfplat.@)
2807  */
2808 BOOL WINAPI MFCompareFullToPartialMediaType(IMFMediaType *full_type, IMFMediaType *partial_type)
2809 {
2810     BOOL result;
2811     GUID major;
2812
2813     TRACE("%p, %p.\n", full_type, partial_type);
2814
2815     if (FAILED(IMFMediaType_GetMajorType(partial_type, &major)))
2816         return FALSE;
2817
2818     if (FAILED(IMFMediaType_Compare(partial_type, (IMFAttributes *)full_type, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result)))
2819         return FALSE;
2820
2821     return result;
2822 }
2823
2824 /***********************************************************************
2825  *      MFWrapMediaType (mfplat.@)
2826  */
2827 HRESULT WINAPI MFWrapMediaType(IMFMediaType *original, REFGUID major, REFGUID subtype, IMFMediaType **ret)
2828 {
2829     IMFMediaType *mediatype;
2830     UINT8 *buffer;
2831     UINT32 size;
2832     HRESULT hr;
2833
2834     TRACE("%p, %s, %s, %p.\n", original, debugstr_guid(major), debugstr_guid(subtype), ret);
2835
2836     if (FAILED(hr = MFGetAttributesAsBlobSize((IMFAttributes *)original, &size)))
2837         return hr;
2838
2839     if (!(buffer = malloc(size)))
2840         return E_OUTOFMEMORY;
2841
2842     if (FAILED(hr = MFGetAttributesAsBlob((IMFAttributes *)original, buffer, size)))
2843         goto failed;
2844
2845     if (FAILED(hr = MFCreateMediaType(&mediatype)))
2846         goto failed;
2847
2848     if (FAILED(hr = IMFMediaType_SetGUID(mediatype, &MF_MT_MAJOR_TYPE, major)))
2849         goto failed;
2850
2851     if (FAILED(hr = IMFMediaType_SetGUID(mediatype, &MF_MT_SUBTYPE, subtype)))
2852         goto failed;
2853
2854     if (FAILED(hr = IMFMediaType_SetBlob(mediatype, &MF_MT_WRAPPED_TYPE, buffer, size)))
2855         goto failed;
2856
2857     *ret = mediatype;
2858
2859 failed:
2860     free(buffer);
2861
2862     return hr;
2863 }
2864
2865 /***********************************************************************
2866  *      MFUnwrapMediaType (mfplat.@)
2867  */
2868 HRESULT WINAPI MFUnwrapMediaType(IMFMediaType *wrapper, IMFMediaType **ret)
2869 {
2870     IMFMediaType *mediatype;
2871     UINT8 *buffer;
2872     UINT32 size;
2873     HRESULT hr;
2874
2875     TRACE("%p, %p.\n", wrapper, ret);
2876
2877     if (FAILED(hr = MFCreateMediaType(&mediatype)))
2878         return hr;
2879
2880     if (FAILED(hr = IMFMediaType_GetAllocatedBlob(wrapper, &MF_MT_WRAPPED_TYPE, &buffer, &size)))
2881     {
2882         IMFMediaType_Release(mediatype);
2883         return hr;
2884     }
2885
2886     hr = MFInitAttributesFromBlob((IMFAttributes *)mediatype, buffer, size);
2887     CoTaskMemFree(buffer);
2888     if (FAILED(hr))
2889         return hr;
2890
2891     *ret = mediatype;
2892
2893     return S_OK;
2894 }
2895
2896 /***********************************************************************
2897  *      MFCreateWaveFormatExFromMFMediaType (mfplat.@)
2898  */
2899 HRESULT WINAPI MFCreateWaveFormatExFromMFMediaType(IMFMediaType *mediatype, WAVEFORMATEX **ret_format,
2900         UINT32 *size, UINT32 flags)
2901 {
2902     WAVEFORMATEXTENSIBLE *format_ext = NULL;
2903     WAVEFORMATEX *format;
2904     GUID major, subtype;
2905     UINT32 value;
2906     HRESULT hr;
2907
2908     TRACE("%p, %p, %p, %#x.\n", mediatype, ret_format, size, flags);
2909
2910     if (FAILED(hr = IMFMediaType_GetGUID(mediatype, &MF_MT_MAJOR_TYPE, &major)))
2911         return hr;
2912
2913     if (FAILED(hr = IMFMediaType_GetGUID(mediatype, &MF_MT_SUBTYPE, &subtype)))
2914         return hr;
2915
2916     if (!IsEqualGUID(&major, &MFMediaType_Audio))
2917         return E_INVALIDARG;
2918
2919     if (!IsEqualGUID(&subtype, &MFAudioFormat_PCM) && !IsEqualGUID(&subtype, &MFAudioFormat_Float))
2920     {
2921         FIXME("Unsupported audio format %s.\n", debugstr_guid(&subtype));
2922         return E_NOTIMPL;
2923     }
2924
2925     /* FIXME: probably WAVE_FORMAT_MPEG/WAVE_FORMAT_MPEGLAYER3 should be handled separately. */
2926     if (flags == MFWaveFormatExConvertFlag_ForceExtensible)
2927     {
2928         format_ext = CoTaskMemAlloc(sizeof(*format_ext));
2929         *size = sizeof(*format_ext);
2930         format = (WAVEFORMATEX *)format_ext;
2931     }
2932     else
2933     {
2934         format = CoTaskMemAlloc(sizeof(*format));
2935         *size = sizeof(*format);
2936     }
2937
2938     if (!format)
2939         return E_OUTOFMEMORY;
2940
2941     memset(format, 0, *size);
2942
2943     if (format_ext)
2944         format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
2945     else if (IsEqualGUID(&subtype, &MFAudioFormat_Float))
2946         format->wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
2947     else
2948         format->wFormatTag = WAVE_FORMAT_PCM;
2949
2950     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_NUM_CHANNELS, &value)))
2951         format->nChannels = value;
2952     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &value)))
2953         format->nSamplesPerSec = value;
2954     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &value)))
2955         format->nAvgBytesPerSec = value;
2956     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &value)))
2957         format->nBlockAlign = value;
2958     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_BITS_PER_SAMPLE, &value)))
2959         format->wBitsPerSample = value;
2960     if (format_ext)
2961     {
2962         format->cbSize = sizeof(*format_ext) - sizeof(*format);
2963
2964         if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, &value)))
2965             format_ext->Samples.wSamplesPerBlock = value;
2966
2967         if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_CHANNEL_MASK, &value)))
2968             format_ext->dwChannelMask = value;
2969         memcpy(&format_ext->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM, sizeof(format_ext->SubFormat));
2970     }
2971
2972     *ret_format = format;
2973
2974     return S_OK;
2975 }
2976
2977 static void mediatype_set_uint32(IMFMediaType *mediatype, const GUID *attr, unsigned int value, HRESULT *hr)
2978 {
2979     if (SUCCEEDED(*hr))
2980         *hr = IMFMediaType_SetUINT32(mediatype, attr, value);
2981 }
2982
2983 static void mediatype_set_uint64(IMFMediaType *mediatype, const GUID *attr, unsigned int high, unsigned int low, HRESULT *hr)
2984 {
2985     if (SUCCEEDED(*hr))
2986         *hr = IMFMediaType_SetUINT64(mediatype, attr, (UINT64)high << 32 | low);
2987 }
2988
2989 static void mediatype_set_guid(IMFMediaType *mediatype, const GUID *attr, const GUID *value, HRESULT *hr)
2990 {
2991     if (SUCCEEDED(*hr))
2992         *hr = IMFMediaType_SetGUID(mediatype, attr, value);
2993 }
2994
2995 static void mediatype_set_blob(IMFMediaType *mediatype, const GUID *attr, const UINT8 *data,
2996         unsigned int size, HRESULT *hr)
2997 {
2998     if (SUCCEEDED(*hr))
2999         *hr = IMFMediaType_SetBlob(mediatype, attr, data, size);
3000 }
3001
3002 /***********************************************************************
3003  *      MFInitMediaTypeFromWaveFormatEx (mfplat.@)
3004  */
3005 HRESULT WINAPI MFInitMediaTypeFromWaveFormatEx(IMFMediaType *mediatype, const WAVEFORMATEX *format, UINT32 size)
3006 {
3007     const WAVEFORMATEXTENSIBLE *wfex = (const WAVEFORMATEXTENSIBLE *)format;
3008     GUID subtype;
3009     HRESULT hr;
3010
3011     TRACE("%p, %p, %u.\n", mediatype, format, size);
3012
3013     if (!mediatype || !format)
3014         return E_POINTER;
3015
3016     if (format->cbSize + sizeof(*format) > size)
3017         return E_INVALIDARG;
3018
3019     hr = IMFMediaType_DeleteAllItems(mediatype);
3020
3021     mediatype_set_guid(mediatype, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio, &hr);
3022
3023     if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
3024     {
3025         memcpy(&subtype, &wfex->SubFormat, sizeof(subtype));
3026
3027         if (wfex->dwChannelMask)
3028             mediatype_set_uint32(mediatype, &MF_MT_AUDIO_CHANNEL_MASK, wfex->dwChannelMask, &hr);
3029
3030         if (format->wBitsPerSample && wfex->Samples.wValidBitsPerSample)
3031             mediatype_set_uint32(mediatype, &MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, wfex->Samples.wValidBitsPerSample, &hr);
3032     }
3033     else
3034     {
3035         memcpy(&subtype, &MFAudioFormat_Base, sizeof(subtype));
3036         subtype.Data1 = format->wFormatTag;
3037
3038         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1, &hr);
3039     }
3040     mediatype_set_guid(mediatype, &MF_MT_SUBTYPE, &subtype, &hr);
3041
3042     if (format->nChannels)
3043         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_NUM_CHANNELS, format->nChannels, &hr);
3044
3045     if (format->nSamplesPerSec)
3046         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->nSamplesPerSec, &hr);
3047
3048     if (format->nAvgBytesPerSec)
3049         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, format->nAvgBytesPerSec, &hr);
3050
3051     if (format->nBlockAlign)
3052         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_BLOCK_ALIGNMENT, format->nBlockAlign, &hr);
3053
3054     if (format->wBitsPerSample)
3055         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_BITS_PER_SAMPLE, format->wBitsPerSample, &hr);
3056
3057     if (IsEqualGUID(&subtype, &MFAudioFormat_PCM) ||
3058             IsEqualGUID(&subtype, &MFAudioFormat_Float))
3059     {
3060         mediatype_set_uint32(mediatype, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3061     }
3062
3063     if (format->cbSize && format->wFormatTag != WAVE_FORMAT_EXTENSIBLE)
3064         mediatype_set_blob(mediatype, &MF_MT_USER_DATA, (const UINT8 *)(format + 1), format->cbSize, &hr);
3065
3066     return hr;
3067 }
3068
3069 /***********************************************************************
3070  *      MFCreateVideoMediaTypeFromSubtype (mfplat.@)
3071  */
3072 HRESULT WINAPI MFCreateVideoMediaTypeFromSubtype(const GUID *subtype, IMFVideoMediaType **media_type)
3073 {
3074     struct media_type *object;
3075     HRESULT hr;
3076
3077     TRACE("%s, %p.\n", debugstr_guid(subtype), media_type);
3078
3079     if (!media_type)
3080         return E_INVALIDARG;
3081
3082     if (FAILED(hr = create_media_type(&object)))
3083         return hr;
3084
3085     IMFMediaType_SetGUID(&object->IMFMediaType_iface, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
3086     IMFMediaType_SetGUID(&object->IMFMediaType_iface, &MF_MT_SUBTYPE, subtype);
3087
3088     *media_type = &object->IMFVideoMediaType_iface;
3089
3090     return S_OK;
3091 }
3092
3093 /***********************************************************************
3094  *      MFCreateAudioMediaType (mfplat.@)
3095  */
3096 HRESULT WINAPI MFCreateAudioMediaType(const WAVEFORMATEX *format, IMFAudioMediaType **media_type)
3097 {
3098     struct media_type *object;
3099     HRESULT hr;
3100
3101     TRACE("%p, %p.\n", format, media_type);
3102
3103     if (!media_type)
3104         return E_INVALIDARG;
3105
3106     if (FAILED(hr = create_media_type(&object)))
3107         return hr;
3108
3109     if (FAILED(hr = MFInitMediaTypeFromWaveFormatEx(&object->IMFMediaType_iface, format, sizeof(*format) + format->cbSize)))
3110     {
3111         IMFMediaType_Release(&object->IMFMediaType_iface);
3112         return hr;
3113     }
3114
3115     *media_type = &object->IMFAudioMediaType_iface;
3116
3117     return S_OK;
3118 }
3119
3120 static void media_type_get_ratio(IMFMediaType *media_type, const GUID *attr, DWORD *numerator,
3121         DWORD *denominator)
3122 {
3123     UINT64 value;
3124
3125     if (SUCCEEDED(IMFMediaType_GetUINT64(media_type, attr, &value)))
3126     {
3127         *numerator = value >> 32;
3128         *denominator = value;
3129     }
3130 }
3131
3132 /***********************************************************************
3133  *      MFCreateAMMediaTypeFromMFMediaType (mfplat.@)
3134  */
3135 HRESULT WINAPI MFCreateAMMediaTypeFromMFMediaType(IMFMediaType *media_type, GUID format, AM_MEDIA_TYPE **am_type)
3136 {
3137     FIXME("%p, %s, %p stub!\n", media_type, debugstr_mf_guid(&format), am_type);
3138     return E_NOTIMPL;
3139 }
3140
3141 /***********************************************************************
3142  *      MFCreateMFVideoFormatFromMFMediaType (mfplat.@)
3143  */
3144 HRESULT WINAPI MFCreateMFVideoFormatFromMFMediaType(IMFMediaType *media_type, MFVIDEOFORMAT **video_format, UINT32 *size)
3145 {
3146     UINT32 flags, palette_size = 0, value;
3147     MFVIDEOFORMAT *format;
3148     INT32 stride;
3149     GUID guid;
3150
3151     TRACE("%p, %p, %p.\n", media_type, video_format, size);
3152
3153     *size = sizeof(*format);
3154
3155     if (SUCCEEDED(IMFMediaType_GetBlobSize(media_type, &MF_MT_PALETTE, &palette_size)))
3156         *size += palette_size;
3157
3158     if (!(format = CoTaskMemAlloc(*size)))
3159         return E_OUTOFMEMORY;
3160
3161     *video_format = format;
3162
3163     memset(format, 0, sizeof(*format));
3164     format->dwSize = *size;
3165
3166     if (SUCCEEDED(IMFMediaType_GetGUID(media_type, &MF_MT_SUBTYPE, &guid)))
3167     {
3168         memcpy(&format->guidFormat, &guid, sizeof(guid));
3169         format->surfaceInfo.Format = guid.Data1;
3170     }
3171
3172     media_type_get_ratio(media_type, &MF_MT_FRAME_SIZE, &format->videoInfo.dwWidth, &format->videoInfo.dwHeight);
3173     media_type_get_ratio(media_type, &MF_MT_PIXEL_ASPECT_RATIO, &format->videoInfo.PixelAspectRatio.Numerator,
3174             &format->videoInfo.PixelAspectRatio.Denominator);
3175     media_type_get_ratio(media_type, &MF_MT_FRAME_RATE, &format->videoInfo.FramesPerSecond.Numerator,
3176             &format->videoInfo.FramesPerSecond.Denominator);
3177
3178     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_CHROMA_SITING, &format->videoInfo.SourceChromaSubsampling);
3179     IMFMediaType_GetUINT32(media_type, &MF_MT_INTERLACE_MODE, &format->videoInfo.InterlaceMode);
3180     IMFMediaType_GetUINT32(media_type, &MF_MT_TRANSFER_FUNCTION, &format->videoInfo.TransferFunction);
3181     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_PRIMARIES, &format->videoInfo.ColorPrimaries);
3182     IMFMediaType_GetUINT32(media_type, &MF_MT_YUV_MATRIX, &format->videoInfo.TransferMatrix);
3183     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_LIGHTING, &format->videoInfo.SourceLighting);
3184     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_NOMINAL_RANGE, &format->videoInfo.NominalRange);
3185     IMFMediaType_GetBlob(media_type, &MF_MT_GEOMETRIC_APERTURE, (UINT8 *)&format->videoInfo.GeometricAperture,
3186            sizeof(format->videoInfo.GeometricAperture), NULL);
3187     IMFMediaType_GetBlob(media_type, &MF_MT_MINIMUM_DISPLAY_APERTURE, (UINT8 *)&format->videoInfo.MinimumDisplayAperture,
3188            sizeof(format->videoInfo.MinimumDisplayAperture), NULL);
3189
3190     /* Video flags. */
3191     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_PAD_CONTROL_FLAGS, &flags)))
3192         format->videoInfo.VideoFlags |= flags;
3193     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_SOURCE_CONTENT_HINT, &flags)))
3194         format->videoInfo.VideoFlags |= flags;
3195     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_DRM_FLAGS, &flags)))
3196         format->videoInfo.VideoFlags |= flags;
3197     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_PAN_SCAN_ENABLED, &flags)) && !!flags)
3198     {
3199         format->videoInfo.VideoFlags |= MFVideoFlag_PanScanEnabled;
3200         IMFMediaType_GetBlob(media_type, &MF_MT_PAN_SCAN_APERTURE, (UINT8 *)&format->videoInfo.PanScanAperture,
3201                sizeof(format->videoInfo.PanScanAperture), NULL);
3202     }
3203     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, (UINT32 *)&stride)) && stride < 0)
3204         format->videoInfo.VideoFlags |= MFVideoFlag_BottomUpLinearRep;
3205
3206     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AVG_BITRATE, &value)))
3207         format->compressedInfo.AvgBitrate = value;
3208     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AVG_BIT_ERROR_RATE, &value)))
3209         format->compressedInfo.AvgBitErrorRate = value;
3210     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_MAX_KEYFRAME_SPACING, &value)))
3211         format->compressedInfo.MaxKeyFrameSpacing = value;
3212
3213     /* Palette. */
3214     if (palette_size)
3215     {
3216         format->surfaceInfo.PaletteEntries = palette_size / sizeof(*format->surfaceInfo.Palette);
3217         IMFMediaType_GetBlob(media_type, &MF_MT_PALETTE, (UINT8 *)format->surfaceInfo.Palette, palette_size, NULL);
3218     }
3219
3220     return S_OK;
3221 }
3222
3223 /***********************************************************************
3224  *      MFConvertColorInfoToDXVA (mfplat.@)
3225  */
3226 HRESULT WINAPI MFConvertColorInfoToDXVA(DWORD *dxva_info, const MFVIDEOFORMAT *format)
3227 {
3228     struct
3229     {
3230         UINT SampleFormat           : 8;
3231         UINT VideoChromaSubsampling : 4;
3232         UINT NominalRange           : 3;
3233         UINT VideoTransferMatrix    : 3;
3234         UINT VideoLighting          : 4;
3235         UINT VideoPrimaries         : 5;
3236         UINT VideoTransferFunction  : 5;
3237     } *dxva_format = (void *)dxva_info;
3238
3239     TRACE("%p, %p.\n", dxva_info, format);
3240
3241     if (format->videoInfo.InterlaceMode == MFVideoInterlace_MixedInterlaceOrProgressive)
3242         dxva_format->SampleFormat = DXVA2_SampleFieldInterleavedEvenFirst;
3243     else
3244         dxva_format->SampleFormat = format->videoInfo.InterlaceMode;
3245
3246     dxva_format->VideoChromaSubsampling = format->videoInfo.SourceChromaSubsampling;
3247     dxva_format->NominalRange = format->videoInfo.NominalRange;
3248     dxva_format->VideoTransferMatrix = format->videoInfo.TransferMatrix;
3249     dxva_format->VideoLighting = format->videoInfo.SourceLighting;
3250     dxva_format->VideoPrimaries = format->videoInfo.ColorPrimaries;
3251     dxva_format->VideoTransferFunction = format->videoInfo.TransferFunction;
3252
3253     return S_OK;
3254 }
3255
3256 struct frame_rate
3257 {
3258     UINT64 key;
3259     UINT64 value;
3260 };
3261
3262 static int __cdecl frame_rate_compare(const void *a, const void *b)
3263 {
3264     const UINT64 *key = a;
3265     const struct frame_rate *known_rate = b;
3266     return *key == known_rate->key ? 0 : ( *key < known_rate->key ? 1 : -1 );
3267 }
3268
3269 /***********************************************************************
3270  *      MFFrameRateToAverageTimePerFrame (mfplat.@)
3271  */
3272 HRESULT WINAPI MFFrameRateToAverageTimePerFrame(UINT32 numerator, UINT32 denominator, UINT64 *avgframetime)
3273 {
3274     static const struct frame_rate known_rates[] =
3275     {
3276 #define KNOWN_RATE(n,d,ft) { ((UINT64)n << 32) | d, ft }
3277         KNOWN_RATE(60000, 1001, 166833),
3278         KNOWN_RATE(30000, 1001, 333667),
3279         KNOWN_RATE(24000, 1001, 417188),
3280         KNOWN_RATE(60,       1, 166667),
3281         KNOWN_RATE(50,       1, 200000),
3282         KNOWN_RATE(30,       1, 333333),
3283         KNOWN_RATE(25,       1, 400000),
3284         KNOWN_RATE(24,       1, 416667),
3285 #undef KNOWN_RATE
3286     };
3287     UINT64 rate = ((UINT64)numerator << 32) | denominator;
3288     const struct frame_rate *entry;
3289
3290     TRACE("%u, %u, %p.\n", numerator, denominator, avgframetime);
3291
3292     if ((entry = bsearch(&rate, known_rates, ARRAY_SIZE(known_rates), sizeof(*known_rates),
3293             frame_rate_compare)))
3294     {
3295         *avgframetime = entry->value;
3296     }
3297     else
3298         *avgframetime = numerator ? denominator * (UINT64)10000000 / numerator : 0;
3299
3300     return S_OK;
3301 }
3302
3303 static unsigned int get_gcd(unsigned int a, unsigned int b)
3304 {
3305     unsigned int m;
3306
3307     while (b)
3308     {
3309         m = a % b;
3310         a = b;
3311         b = m;
3312     }
3313
3314     return a;
3315 }
3316
3317 /***********************************************************************
3318  *      MFAverageTimePerFrameToFrameRate (mfplat.@)
3319  */
3320 HRESULT WINAPI MFAverageTimePerFrameToFrameRate(UINT64 avgtime, UINT32 *numerator, UINT32 *denominator)
3321 {
3322     static const struct frame_rate known_rates[] =
3323     {
3324 #define KNOWN_RATE(ft,n,d) { ft, ((UINT64)n << 32) | d }
3325         KNOWN_RATE(417188, 24000, 1001),
3326         KNOWN_RATE(416667,    24,    1),
3327         KNOWN_RATE(400000,    25,    1),
3328         KNOWN_RATE(333667, 30000, 1001),
3329         KNOWN_RATE(333333,    30,    1),
3330         KNOWN_RATE(200000,    50,    1),
3331         KNOWN_RATE(166833, 60000, 1001),
3332         KNOWN_RATE(166667,    60,    1),
3333 #undef KNOWN_RATE
3334     };
3335     const struct frame_rate *entry;
3336     unsigned int gcd;
3337
3338     TRACE("%s, %p, %p.\n", wine_dbgstr_longlong(avgtime), numerator, denominator);
3339
3340     if ((entry = bsearch(&avgtime, known_rates, ARRAY_SIZE(known_rates), sizeof(*known_rates),
3341             frame_rate_compare)))
3342     {
3343         *numerator = entry->value >> 32;
3344         *denominator = entry->value;
3345     }
3346     else if (avgtime)
3347     {
3348         if (avgtime > 100000000) avgtime = 100000000;
3349         gcd = get_gcd(10000000, avgtime);
3350         *numerator = 10000000 / gcd;
3351         *denominator = avgtime / gcd;
3352     }
3353     else
3354     {
3355         *numerator = *denominator = 0;
3356     }
3357
3358     return S_OK;
3359 }
3360
3361 /***********************************************************************
3362  *      MFMapDXGIFormatToDX9Format (mfplat.@)
3363  */
3364 DWORD WINAPI MFMapDXGIFormatToDX9Format(DXGI_FORMAT dxgi_format)
3365 {
3366     switch (dxgi_format)
3367     {
3368         case DXGI_FORMAT_R32G32B32A32_FLOAT:
3369             return D3DFMT_A32B32G32R32F;
3370         case DXGI_FORMAT_R16G16B16A16_FLOAT:
3371             return D3DFMT_A16B16G16R16F;
3372         case DXGI_FORMAT_R16G16B16A16_UNORM:
3373             return D3DFMT_A16B16G16R16;
3374         case DXGI_FORMAT_R16G16B16A16_SNORM:
3375             return D3DFMT_Q16W16V16U16;
3376         case DXGI_FORMAT_R32G32_FLOAT:
3377             return D3DFMT_G32R32F;
3378         case DXGI_FORMAT_R10G10B10A2_UNORM:
3379             return D3DFMT_A2B10G10R10;
3380         case DXGI_FORMAT_R8G8B8A8_SNORM:
3381             return D3DFMT_Q8W8V8U8;
3382         case DXGI_FORMAT_R16G16_FLOAT:
3383             return D3DFMT_G16R16F;
3384         case DXGI_FORMAT_R16G16_UNORM:
3385             return D3DFMT_G16R16;
3386         case DXGI_FORMAT_R16G16_SNORM:
3387             return D3DFMT_V16U16;
3388         case DXGI_FORMAT_D32_FLOAT:
3389             return D3DFMT_D32F_LOCKABLE;
3390         case DXGI_FORMAT_R32_FLOAT:
3391             return D3DFMT_R32F;
3392         case DXGI_FORMAT_D24_UNORM_S8_UINT:
3393             return D3DFMT_D24S8;
3394         case DXGI_FORMAT_R8G8_SNORM:
3395             return D3DFMT_V8U8;
3396         case DXGI_FORMAT_R16_FLOAT:
3397             return D3DFMT_R16F;
3398         case DXGI_FORMAT_D16_UNORM:
3399             return D3DFMT_D16_LOCKABLE;
3400         case DXGI_FORMAT_R16_UNORM:
3401             return D3DFMT_L16;
3402         case DXGI_FORMAT_R8_UNORM:
3403             return D3DFMT_L8;
3404         case DXGI_FORMAT_A8_UNORM:
3405             return D3DFMT_A8;
3406         case DXGI_FORMAT_BC1_UNORM:
3407         case DXGI_FORMAT_BC1_UNORM_SRGB:
3408             return D3DFMT_DXT1;
3409         case DXGI_FORMAT_BC2_UNORM:
3410         case DXGI_FORMAT_BC2_UNORM_SRGB:
3411             return D3DFMT_DXT2;
3412         case DXGI_FORMAT_BC3_UNORM:
3413         case DXGI_FORMAT_BC3_UNORM_SRGB:
3414             return D3DFMT_DXT4;
3415         case DXGI_FORMAT_R8G8B8A8_UNORM:
3416             return D3DFMT_A8B8G8R8;
3417         case DXGI_FORMAT_B8G8R8A8_UNORM:
3418         case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
3419         case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
3420             return D3DFMT_A8R8G8B8;
3421         case DXGI_FORMAT_B8G8R8X8_UNORM:
3422         case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
3423             return D3DFMT_X8R8G8B8;
3424         case DXGI_FORMAT_AYUV:
3425             return MAKEFOURCC('A','Y','U','V');
3426         case DXGI_FORMAT_Y410:
3427             return MAKEFOURCC('Y','4','1','0');
3428         case DXGI_FORMAT_Y416:
3429             return MAKEFOURCC('Y','4','1','6');
3430         case DXGI_FORMAT_NV12:
3431             return MAKEFOURCC('N','V','1','2');
3432         case DXGI_FORMAT_P010:
3433             return MAKEFOURCC('P','0','1','0');
3434         case DXGI_FORMAT_P016:
3435             return MAKEFOURCC('P','0','1','6');
3436         case DXGI_FORMAT_420_OPAQUE:
3437             return MAKEFOURCC('4','2','0','O');
3438         case DXGI_FORMAT_YUY2:
3439             return D3DFMT_YUY2;
3440         case DXGI_FORMAT_Y210:
3441             return MAKEFOURCC('Y','2','1','0');
3442         case DXGI_FORMAT_Y216:
3443             return MAKEFOURCC('Y','2','1','6');
3444         case DXGI_FORMAT_NV11:
3445             return MAKEFOURCC('N','V','1','1');
3446         case DXGI_FORMAT_AI44:
3447             return MAKEFOURCC('A','I','4','4');
3448         case DXGI_FORMAT_IA44:
3449             return MAKEFOURCC('I','A','4','4');
3450         case DXGI_FORMAT_P8:
3451             return D3DFMT_P8;
3452         case DXGI_FORMAT_A8P8:
3453             return D3DFMT_A8P8;
3454         default:
3455             return 0;
3456     }
3457 }
3458
3459 /***********************************************************************
3460  *      MFMapDX9FormatToDXGIFormat (mfplat.@)
3461  */
3462 DXGI_FORMAT WINAPI MFMapDX9FormatToDXGIFormat(DWORD format)
3463 {
3464     switch (format)
3465     {
3466         case D3DFMT_A32B32G32R32F:
3467             return DXGI_FORMAT_R32G32B32A32_FLOAT;
3468         case D3DFMT_A16B16G16R16F:
3469             return DXGI_FORMAT_R16G16B16A16_FLOAT;
3470         case D3DFMT_A16B16G16R16:
3471             return DXGI_FORMAT_R16G16B16A16_UNORM;
3472         case D3DFMT_Q16W16V16U16:
3473             return DXGI_FORMAT_R16G16B16A16_SNORM;
3474         case D3DFMT_G32R32F:
3475             return DXGI_FORMAT_R32G32_FLOAT;
3476         case D3DFMT_A2B10G10R10:
3477             return DXGI_FORMAT_R10G10B10A2_UNORM;
3478         case D3DFMT_Q8W8V8U8:
3479             return DXGI_FORMAT_R8G8B8A8_SNORM;
3480         case D3DFMT_G16R16F:
3481             return DXGI_FORMAT_R16G16_FLOAT;
3482         case D3DFMT_G16R16:
3483             return DXGI_FORMAT_R16G16_UNORM;
3484         case D3DFMT_V16U16:
3485             return DXGI_FORMAT_R16G16_SNORM;
3486         case D3DFMT_D32F_LOCKABLE:
3487             return DXGI_FORMAT_D32_FLOAT;
3488         case D3DFMT_R32F:
3489             return DXGI_FORMAT_R32_FLOAT;
3490         case D3DFMT_D24S8:
3491             return DXGI_FORMAT_D24_UNORM_S8_UINT;
3492         case D3DFMT_V8U8:
3493             return DXGI_FORMAT_R8G8_SNORM;
3494         case D3DFMT_R16F:
3495             return DXGI_FORMAT_R16_FLOAT;
3496         case D3DFMT_L16:
3497             return DXGI_FORMAT_R16_UNORM;
3498         case D3DFMT_L8:
3499             return DXGI_FORMAT_R8_UNORM;
3500         case D3DFMT_A8:
3501             return DXGI_FORMAT_A8_UNORM;
3502         case D3DFMT_DXT1:
3503             return DXGI_FORMAT_BC1_UNORM;
3504         case D3DFMT_DXT2:
3505             return DXGI_FORMAT_BC2_UNORM;
3506         case D3DFMT_DXT4:
3507             return DXGI_FORMAT_BC3_UNORM;
3508         case D3DFMT_A8R8G8B8:
3509             return DXGI_FORMAT_B8G8R8A8_UNORM;
3510         case D3DFMT_X8R8G8B8:
3511             return DXGI_FORMAT_B8G8R8X8_UNORM;
3512         case MAKEFOURCC('A','Y','U','V'):
3513             return DXGI_FORMAT_AYUV;
3514         case MAKEFOURCC('Y','4','1','0'):
3515             return DXGI_FORMAT_Y410;
3516         case MAKEFOURCC('Y','4','1','6'):
3517             return DXGI_FORMAT_Y416;
3518         case MAKEFOURCC('N','V','1','2'):
3519             return DXGI_FORMAT_NV12;
3520         case MAKEFOURCC('P','0','1','0'):
3521             return DXGI_FORMAT_P010;
3522         case MAKEFOURCC('P','0','1','6'):
3523             return DXGI_FORMAT_P016;
3524         case MAKEFOURCC('4','2','0','O'):
3525             return DXGI_FORMAT_420_OPAQUE;
3526         case D3DFMT_YUY2:
3527             return DXGI_FORMAT_YUY2;
3528         case MAKEFOURCC('Y','2','1','0'):
3529             return DXGI_FORMAT_Y210;
3530         case MAKEFOURCC('Y','2','1','6'):
3531             return DXGI_FORMAT_Y216;
3532         case MAKEFOURCC('N','V','1','1'):
3533             return DXGI_FORMAT_NV11;
3534         case MAKEFOURCC('A','I','4','4'):
3535             return DXGI_FORMAT_AI44;
3536         case MAKEFOURCC('I','A','4','4'):
3537             return DXGI_FORMAT_IA44;
3538         case D3DFMT_P8:
3539             return DXGI_FORMAT_P8;
3540         case D3DFMT_A8P8:
3541             return DXGI_FORMAT_A8P8;
3542         default:
3543             return DXGI_FORMAT_UNKNOWN;
3544     }
3545 }
3546
3547 /***********************************************************************
3548  *      MFInitVideoFormat_RGB (mfplat.@)
3549  */
3550 HRESULT WINAPI MFInitVideoFormat_RGB(MFVIDEOFORMAT *format, DWORD width, DWORD height, DWORD d3dformat)
3551 {
3552     unsigned int transfer_function;
3553
3554     TRACE("%p, %lu, %lu, %#lx.\n", format, width, height, d3dformat);
3555
3556     if (!format)
3557         return E_INVALIDARG;
3558
3559     if (!d3dformat) d3dformat = D3DFMT_X8R8G8B8;
3560
3561     switch (d3dformat)
3562     {
3563         case D3DFMT_X8R8G8B8:
3564         case D3DFMT_R8G8B8:
3565         case D3DFMT_A8R8G8B8:
3566         case D3DFMT_R5G6B5:
3567         case D3DFMT_X1R5G5B5:
3568         case D3DFMT_A2B10G10R10:
3569         case D3DFMT_A2R10G10B10:
3570         case D3DFMT_P8:
3571             transfer_function = MFVideoTransFunc_sRGB;
3572             break;
3573         default:
3574             transfer_function = MFVideoTransFunc_10;
3575     }
3576
3577     memset(format, 0, sizeof(*format));
3578     format->dwSize = sizeof(*format);
3579     format->videoInfo.dwWidth = width;
3580     format->videoInfo.dwHeight = height;
3581     format->videoInfo.PixelAspectRatio.Numerator = 1;
3582     format->videoInfo.PixelAspectRatio.Denominator = 1;
3583     format->videoInfo.InterlaceMode = MFVideoInterlace_Progressive;
3584     format->videoInfo.TransferFunction = transfer_function;
3585     format->videoInfo.ColorPrimaries = MFVideoPrimaries_BT709;
3586     format->videoInfo.SourceLighting = MFVideoLighting_office;
3587     format->videoInfo.FramesPerSecond.Numerator = 60;
3588     format->videoInfo.FramesPerSecond.Denominator = 1;
3589     format->videoInfo.NominalRange = MFNominalRange_Normal;
3590     format->videoInfo.GeometricAperture.Area.cx = width;
3591     format->videoInfo.GeometricAperture.Area.cy = height;
3592     format->videoInfo.MinimumDisplayAperture = format->videoInfo.GeometricAperture;
3593     memcpy(&format->guidFormat, &MFVideoFormat_Base, sizeof(format->guidFormat));
3594     format->guidFormat.Data1 = d3dformat;
3595     format->surfaceInfo.Format = d3dformat;
3596
3597     return S_OK;
3598 }
3599
3600 static HRESULT mf_get_stride_for_bitmap_info_header(DWORD fourcc, const BITMAPINFOHEADER *bih, LONG *stride)
3601 {
3602     HRESULT hr;
3603
3604     if (FAILED(hr = MFGetStrideForBitmapInfoHeader(fourcc, bih->biWidth, stride))) return hr;
3605     if (bih->biHeight < 0) *stride *= -1;
3606
3607     return hr;
3608 }
3609
3610 static const GUID * get_mf_subtype_for_am_subtype(const GUID *subtype)
3611 {
3612     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB1))
3613         return &MFVideoFormat_RGB1;
3614     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB4))
3615         return &MFVideoFormat_RGB4;
3616     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB8))
3617         return &MFVideoFormat_RGB8;
3618     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB555))
3619         return &MFVideoFormat_RGB555;
3620     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB565))
3621         return &MFVideoFormat_RGB565;
3622     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB24))
3623         return &MFVideoFormat_RGB24;
3624     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB32))
3625         return &MFVideoFormat_RGB32;
3626     if (IsEqualGUID(subtype, &MEDIASUBTYPE_ARGB1555))
3627         return &MFVideoFormat_ARGB1555;
3628     if (IsEqualGUID(subtype, &MEDIASUBTYPE_ARGB4444))
3629         return &MFVideoFormat_ARGB4444;
3630     if (IsEqualGUID(subtype, &MEDIASUBTYPE_ARGB32))
3631         return &MFVideoFormat_ARGB32;
3632     if (IsEqualGUID(subtype, &MEDIASUBTYPE_A2R10G10B10))
3633         return &MFVideoFormat_A2B10G10R10;
3634     if (IsEqualGUID(subtype, &MEDIASUBTYPE_A2B10G10R10))
3635         return &MFVideoFormat_A2R10G10B10;
3636     return subtype;
3637 }
3638
3639 /***********************************************************************
3640  *      MFCreateVideoMediaTypeFromVideoInfoHeader (mfplat.@)
3641  */
3642 HRESULT WINAPI MFCreateVideoMediaTypeFromVideoInfoHeader(const KS_VIDEOINFOHEADER *vih, DWORD size, DWORD pixel_aspect_ratio_x,
3643         DWORD pixel_aspect_ratio_y, MFVideoInterlaceMode interlace_mode, QWORD video_flags, const GUID *subtype,
3644         IMFVideoMediaType **ret)
3645 {
3646     FIXME("%p, %lu, %lu, %lu, %d, %I64x, %s, %p.\n", vih, size, pixel_aspect_ratio_x, pixel_aspect_ratio_y, interlace_mode,
3647             video_flags, debugstr_guid(subtype), ret);
3648
3649     return E_NOTIMPL;
3650 }
3651
3652 /***********************************************************************
3653  *      MFInitMediaTypeFromVideoInfoHeader (mfplat.@)
3654  */
3655 HRESULT WINAPI MFInitMediaTypeFromVideoInfoHeader(IMFMediaType *media_type, const VIDEOINFOHEADER *vih, UINT32 size,
3656         const GUID *subtype)
3657 {
3658     HRESULT hr = S_OK;
3659     DWORD height;
3660     LONG stride;
3661
3662     FIXME("%p, %p, %u, %s.\n", media_type, vih, size, debugstr_guid(subtype));
3663
3664     IMFMediaType_DeleteAllItems(media_type);
3665
3666     if (!subtype)
3667     {
3668         FIXME("Implicit subtype is not supported.\n");
3669         return E_NOTIMPL;
3670     }
3671
3672     height = abs(vih->bmiHeader.biHeight);
3673
3674     mediatype_set_guid(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video, &hr);
3675     mediatype_set_guid(media_type, &MF_MT_SUBTYPE, subtype, &hr);
3676     mediatype_set_uint64(media_type, &MF_MT_PIXEL_ASPECT_RATIO, 1, 1, &hr);
3677     mediatype_set_uint32(media_type, &MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive, &hr);
3678     mediatype_set_uint64(media_type, &MF_MT_FRAME_SIZE, vih->bmiHeader.biWidth, height, &hr);
3679
3680     if (SUCCEEDED(mf_get_stride_for_bitmap_info_header(subtype->Data1, &vih->bmiHeader, &stride)))
3681     {
3682         mediatype_set_uint32(media_type, &MF_MT_DEFAULT_STRIDE, stride, &hr);
3683         mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, abs(stride) * height, &hr);
3684         mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3685         mediatype_set_uint32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3686     }
3687
3688     return hr;
3689 }
3690
3691 /***********************************************************************
3692  *      MFInitAMMediaTypeFromMFMediaType (mfplat.@)
3693  */
3694 HRESULT WINAPI MFInitAMMediaTypeFromMFMediaType(IMFMediaType *media_type, GUID format, AM_MEDIA_TYPE *am_type)
3695 {
3696     FIXME("%p, %s, %p\n", media_type, debugstr_guid(&format), am_type);
3697     return E_NOTIMPL;
3698 }
3699
3700 /***********************************************************************
3701  *      MFInitMediaTypeFromAMMediaType (mfplat.@)
3702  */
3703 HRESULT WINAPI MFInitMediaTypeFromAMMediaType(IMFMediaType *media_type, const AM_MEDIA_TYPE *am_type)
3704 {
3705     HRESULT hr = S_OK;
3706
3707     TRACE("%p, %p.\n", media_type, am_type);
3708
3709     IMFMediaType_DeleteAllItems(media_type);
3710
3711     if (IsEqualGUID(&am_type->majortype, &MEDIATYPE_Video))
3712     {
3713         if (IsEqualGUID(&am_type->formattype, &FORMAT_VideoInfo))
3714         {
3715             const VIDEOINFOHEADER *vih = (const VIDEOINFOHEADER *)am_type->pbFormat;
3716             const GUID *subtype;
3717             DWORD height;
3718             LONG stride;
3719
3720             subtype = get_mf_subtype_for_am_subtype(&am_type->subtype);
3721             height = abs(vih->bmiHeader.biHeight);
3722
3723             mediatype_set_guid(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video, &hr);
3724             mediatype_set_guid(media_type, &MF_MT_SUBTYPE, subtype, &hr);
3725             mediatype_set_uint64(media_type, &MF_MT_PIXEL_ASPECT_RATIO, 1, 1, &hr);
3726             mediatype_set_uint32(media_type, &MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive, &hr);
3727             mediatype_set_uint64(media_type, &MF_MT_FRAME_SIZE, vih->bmiHeader.biWidth, height, &hr);
3728             mediatype_set_uint32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3729
3730             if (SUCCEEDED(mf_get_stride_for_bitmap_info_header(subtype->Data1, &vih->bmiHeader, &stride)))
3731             {
3732                 mediatype_set_uint32(media_type, &MF_MT_DEFAULT_STRIDE, stride, &hr);
3733                 mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, abs(stride) * height, &hr);
3734                 mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3735             }
3736             else
3737             {
3738                 if (am_type->bFixedSizeSamples)
3739                     mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3740                 if (am_type->lSampleSize)
3741                     mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, am_type->lSampleSize, &hr);
3742             }
3743
3744             return hr;
3745         }
3746         else
3747         {
3748             FIXME("Unsupported format type %s.\n", debugstr_guid(&am_type->formattype));
3749         }
3750     }
3751     else
3752         FIXME("Unsupported major type %s.\n", debugstr_guid(&am_type->majortype));
3753
3754     return E_NOTIMPL;
3755 }