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