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