dlls/mfplat/mediatype.c

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