dlls/mfplat/mediatype.c

   1 /*
   2  * Copyright 2017 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "mfplat_private.h"
  22
  23 #include "dxva2api.h"
  24 #include "uuids.h"
  25 #include "initguid.h"
  26 #include "ks.h"
  27 #include "ksmedia.h"
  28 #include "amvideo.h"
  29
  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 %lu.\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 %lu.\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     media_type->video_format = NULL;
 982     if (FAILED(hr = MFCreateMFVideoFormatFromMFMediaType(&media_type->IMFMediaType_iface, &media_type->video_format, &size)))
 983         WARN("Failed to create format description, hr %#lx.\n", hr);
 984
 985     return media_type->video_format;
 986 }
 987
 988 static HRESULT WINAPI video_mediatype_GetVideoRepresentation(IMFVideoMediaType *iface, GUID representation,
 989         void **data, LONG stride)
 990 {
 991     FIXME("%p, %s, %p, %ld.\n", iface, debugstr_guid(&representation), data, stride);
 992
 993     return E_NOTIMPL;
 994 }
 995
 996 static const IMFVideoMediaTypeVtbl videomediatypevtbl =
 997 {
 998     video_mediatype_QueryInterface,
 999     video_mediatype_AddRef,
1000     video_mediatype_Release,
1001     video_mediatype_GetItem,
1002     video_mediatype_GetItemType,
1003     video_mediatype_CompareItem,
1004     video_mediatype_Compare,
1005     video_mediatype_GetUINT32,
1006     video_mediatype_GetUINT64,
1007     video_mediatype_GetDouble,
1008     video_mediatype_GetGUID,
1009     video_mediatype_GetStringLength,
1010     video_mediatype_GetString,
1011     video_mediatype_GetAllocatedString,
1012     video_mediatype_GetBlobSize,
1013     video_mediatype_GetBlob,
1014     video_mediatype_GetAllocatedBlob,
1015     video_mediatype_GetUnknown,
1016     video_mediatype_SetItem,
1017     video_mediatype_DeleteItem,
1018     video_mediatype_DeleteAllItems,
1019     video_mediatype_SetUINT32,
1020     video_mediatype_SetUINT64,
1021     video_mediatype_SetDouble,
1022     video_mediatype_SetGUID,
1023     video_mediatype_SetString,
1024     video_mediatype_SetBlob,
1025     video_mediatype_SetUnknown,
1026     video_mediatype_LockStore,
1027     video_mediatype_UnlockStore,
1028     video_mediatype_GetCount,
1029     video_mediatype_GetItemByIndex,
1030     video_mediatype_CopyAllItems,
1031     video_mediatype_GetMajorType,
1032     video_mediatype_IsCompressedFormat,
1033     video_mediatype_IsEqual,
1034     video_mediatype_GetRepresentation,
1035     video_mediatype_FreeRepresentation,
1036     video_mediatype_GetVideoFormat,
1037     video_mediatype_GetVideoRepresentation,
1038 };
1039
1040 static HRESULT WINAPI audio_mediatype_QueryInterface(IMFAudioMediaType *iface, REFIID riid, void **out)
1041 {
1042     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1043     return IMFMediaType_QueryInterface(&media_type->IMFMediaType_iface, riid, out);
1044 }
1045
1046 static ULONG WINAPI audio_mediatype_AddRef(IMFAudioMediaType *iface)
1047 {
1048     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1049     return IMFMediaType_AddRef(&media_type->IMFMediaType_iface);
1050 }
1051
1052 static ULONG WINAPI audio_mediatype_Release(IMFAudioMediaType *iface)
1053 {
1054     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1055     return IMFMediaType_Release(&media_type->IMFMediaType_iface);
1056 }
1057
1058 static HRESULT WINAPI audio_mediatype_GetItem(IMFAudioMediaType *iface, REFGUID key, PROPVARIANT *value)
1059 {
1060     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1061
1062     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1063
1064     return attributes_GetItem(&media_type->attributes, key, value);
1065 }
1066
1067 static HRESULT WINAPI audio_mediatype_GetItemType(IMFAudioMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1068 {
1069     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1070
1071     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
1072
1073     return attributes_GetItemType(&media_type->attributes, key, type);
1074 }
1075
1076 static HRESULT WINAPI audio_mediatype_CompareItem(IMFAudioMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
1077 {
1078     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1079
1080     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
1081
1082     return attributes_CompareItem(&media_type->attributes, key, value, result);
1083 }
1084
1085 static HRESULT WINAPI audio_mediatype_Compare(IMFAudioMediaType *iface, IMFAttributes *attrs,
1086         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1087 {
1088     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1089
1090     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
1091
1092     return attributes_Compare(&media_type->attributes, attrs, type, result);
1093 }
1094
1095 static HRESULT WINAPI audio_mediatype_GetUINT32(IMFAudioMediaType *iface, REFGUID key, UINT32 *value)
1096 {
1097     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1098
1099     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1100
1101     return attributes_GetUINT32(&media_type->attributes, key, value);
1102 }
1103
1104 static HRESULT WINAPI audio_mediatype_GetUINT64(IMFAudioMediaType *iface, REFGUID key, UINT64 *value)
1105 {
1106     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1107
1108     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1109
1110     return attributes_GetUINT64(&media_type->attributes, key, value);
1111 }
1112
1113 static HRESULT WINAPI audio_mediatype_GetDouble(IMFAudioMediaType *iface, REFGUID key, double *value)
1114 {
1115     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1116
1117     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1118
1119     return attributes_GetDouble(&media_type->attributes, key, value);
1120 }
1121
1122 static HRESULT WINAPI audio_mediatype_GetGUID(IMFAudioMediaType *iface, REFGUID key, GUID *value)
1123 {
1124     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1125
1126     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1127
1128     return attributes_GetGUID(&media_type->attributes, key, value);
1129 }
1130
1131 static HRESULT WINAPI audio_mediatype_GetStringLength(IMFAudioMediaType *iface, REFGUID key, UINT32 *length)
1132 {
1133     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1134
1135     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
1136
1137     return attributes_GetStringLength(&media_type->attributes, key, length);
1138 }
1139
1140 static HRESULT WINAPI audio_mediatype_GetString(IMFAudioMediaType *iface, REFGUID key, WCHAR *value,
1141         UINT32 size, UINT32 *length)
1142 {
1143     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1144
1145     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
1146
1147     return attributes_GetString(&media_type->attributes, key, value, size, length);
1148 }
1149
1150 static HRESULT WINAPI audio_mediatype_GetAllocatedString(IMFAudioMediaType *iface, REFGUID key,
1151         WCHAR **value, UINT32 *length)
1152 {
1153     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1154
1155     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
1156
1157     return attributes_GetAllocatedString(&media_type->attributes, key, value, length);
1158 }
1159
1160 static HRESULT WINAPI audio_mediatype_GetBlobSize(IMFAudioMediaType *iface, REFGUID key, UINT32 *size)
1161 {
1162     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1163
1164     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
1165
1166     return attributes_GetBlobSize(&media_type->attributes, key, size);
1167 }
1168
1169 static HRESULT WINAPI audio_mediatype_GetBlob(IMFAudioMediaType *iface, REFGUID key, UINT8 *buf,
1170         UINT32 bufsize, UINT32 *blobsize)
1171 {
1172     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1173
1174     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
1175
1176     return attributes_GetBlob(&media_type->attributes, key, buf, bufsize, blobsize);
1177 }
1178
1179 static HRESULT WINAPI audio_mediatype_GetAllocatedBlob(IMFAudioMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1180 {
1181     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1182
1183     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
1184
1185     return attributes_GetAllocatedBlob(&media_type->attributes, key, buf, size);
1186 }
1187
1188 static HRESULT WINAPI audio_mediatype_GetUnknown(IMFAudioMediaType *iface, REFGUID key, REFIID riid, void **obj)
1189 {
1190     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1191
1192     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
1193
1194     return attributes_GetUnknown(&media_type->attributes, key, riid, obj);
1195 }
1196
1197 static HRESULT WINAPI audio_mediatype_SetItem(IMFAudioMediaType *iface, REFGUID key, REFPROPVARIANT value)
1198 {
1199     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1200
1201     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
1202
1203     return attributes_SetItem(&media_type->attributes, key, value);
1204 }
1205
1206 static HRESULT WINAPI audio_mediatype_DeleteItem(IMFAudioMediaType *iface, REFGUID key)
1207 {
1208     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1209
1210     TRACE("%p, %s.\n", iface, debugstr_attr(key));
1211
1212     return attributes_DeleteItem(&media_type->attributes, key);
1213 }
1214
1215 static HRESULT WINAPI audio_mediatype_DeleteAllItems(IMFAudioMediaType *iface)
1216 {
1217     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1218
1219     TRACE("%p.\n", iface);
1220
1221     return attributes_DeleteAllItems(&media_type->attributes);
1222 }
1223
1224 static HRESULT WINAPI audio_mediatype_SetUINT32(IMFAudioMediaType *iface, REFGUID key, UINT32 value)
1225 {
1226     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1227
1228     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
1229
1230     return attributes_SetUINT32(&media_type->attributes, key, value);
1231 }
1232
1233 static HRESULT WINAPI audio_mediatype_SetUINT64(IMFAudioMediaType *iface, REFGUID key, UINT64 value)
1234 {
1235     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1236
1237     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
1238
1239     return attributes_SetUINT64(&media_type->attributes, key, value);
1240 }
1241
1242 static HRESULT WINAPI audio_mediatype_SetDouble(IMFAudioMediaType *iface, REFGUID key, double value)
1243 {
1244     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1245
1246     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
1247
1248     return attributes_SetDouble(&media_type->attributes, key, value);
1249 }
1250
1251 static HRESULT WINAPI audio_mediatype_SetGUID(IMFAudioMediaType *iface, REFGUID key, REFGUID value)
1252 {
1253     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1254
1255     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
1256
1257     return attributes_SetGUID(&media_type->attributes, key, value);
1258 }
1259
1260 static HRESULT WINAPI audio_mediatype_SetString(IMFAudioMediaType *iface, REFGUID key, const WCHAR *value)
1261 {
1262     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1263
1264     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
1265
1266     return attributes_SetString(&media_type->attributes, key, value);
1267 }
1268
1269 static HRESULT WINAPI audio_mediatype_SetBlob(IMFAudioMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1270 {
1271     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1272
1273     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
1274
1275     return attributes_SetBlob(&media_type->attributes, key, buf, size);
1276 }
1277
1278 static HRESULT WINAPI audio_mediatype_SetUnknown(IMFAudioMediaType *iface, REFGUID key, IUnknown *unknown)
1279 {
1280     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1281
1282     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
1283
1284     return attributes_SetUnknown(&media_type->attributes, key, unknown);
1285 }
1286
1287 static HRESULT WINAPI audio_mediatype_LockStore(IMFAudioMediaType *iface)
1288 {
1289     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1290
1291     TRACE("%p.\n", iface);
1292
1293     return attributes_LockStore(&media_type->attributes);
1294 }
1295
1296 static HRESULT WINAPI audio_mediatype_UnlockStore(IMFAudioMediaType *iface)
1297 {
1298     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1299
1300     TRACE("%p.\n", iface);
1301
1302     return attributes_UnlockStore(&media_type->attributes);
1303 }
1304
1305 static HRESULT WINAPI audio_mediatype_GetCount(IMFAudioMediaType *iface, UINT32 *count)
1306 {
1307     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1308
1309     TRACE("%p, %p.\n", iface, count);
1310
1311     return attributes_GetCount(&media_type->attributes, count);
1312 }
1313
1314 static HRESULT WINAPI audio_mediatype_GetItemByIndex(IMFAudioMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1315 {
1316     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1317
1318     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1319
1320     return attributes_GetItemByIndex(&media_type->attributes, index, key, value);
1321 }
1322
1323 static HRESULT WINAPI audio_mediatype_CopyAllItems(IMFAudioMediaType *iface, IMFAttributes *dest)
1324 {
1325     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1326
1327     TRACE("%p, %p.\n", iface, dest);
1328
1329     return attributes_CopyAllItems(&media_type->attributes, dest);
1330 }
1331
1332 static HRESULT WINAPI audio_mediatype_GetMajorType(IMFAudioMediaType *iface, GUID *guid)
1333 {
1334     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1335
1336     TRACE("%p, %p.\n", iface, guid);
1337
1338     return attributes_GetGUID(&media_type->attributes, &MF_MT_MAJOR_TYPE, guid);
1339 }
1340
1341 static HRESULT WINAPI audio_mediatype_IsCompressedFormat(IMFAudioMediaType *iface, BOOL *compressed)
1342 {
1343     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1344
1345     TRACE("%p, %p.\n", iface, compressed);
1346
1347     return mediatype_is_compressed(media_type, compressed);
1348 }
1349
1350 static HRESULT WINAPI audio_mediatype_IsEqual(IMFAudioMediaType *iface, IMFMediaType *type, DWORD *flags)
1351 {
1352     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1353
1354     TRACE("%p, %p, %p.\n", iface, type, flags);
1355
1356     return media_type_is_equal(media_type, type, flags);
1357 }
1358
1359 static HRESULT WINAPI audio_mediatype_GetRepresentation(IMFAudioMediaType *iface, GUID guid, void **representation)
1360 {
1361     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
1362
1363     return E_NOTIMPL;
1364 }
1365
1366 static HRESULT WINAPI audio_mediatype_FreeRepresentation(IMFAudioMediaType *iface, GUID guid, void *representation)
1367 {
1368     FIXME("%p, %s, %p.\n", iface, debugstr_guid(&guid), representation);
1369
1370     return E_NOTIMPL;
1371 }
1372
1373 static const WAVEFORMATEX * WINAPI audio_mediatype_GetAudioFormat(IMFAudioMediaType *iface)
1374 {
1375     struct media_type *media_type = impl_from_IMFAudioMediaType(iface);
1376     unsigned int size;
1377     HRESULT hr;
1378
1379     TRACE("%p.\n", iface);
1380
1381     CoTaskMemFree(media_type->audio_format);
1382     media_type->audio_format = NULL;
1383     if (FAILED(hr = MFCreateWaveFormatExFromMFMediaType(&media_type->IMFMediaType_iface, &media_type->audio_format,
1384             &size, MFWaveFormatExConvertFlag_Normal)))
1385     {
1386         WARN("Failed to create wave format description, hr %#lx.\n", hr);
1387     }
1388
1389     return media_type->audio_format;
1390 }
1391
1392 static const IMFAudioMediaTypeVtbl audiomediatypevtbl =
1393 {
1394     audio_mediatype_QueryInterface,
1395     audio_mediatype_AddRef,
1396     audio_mediatype_Release,
1397     audio_mediatype_GetItem,
1398     audio_mediatype_GetItemType,
1399     audio_mediatype_CompareItem,
1400     audio_mediatype_Compare,
1401     audio_mediatype_GetUINT32,
1402     audio_mediatype_GetUINT64,
1403     audio_mediatype_GetDouble,
1404     audio_mediatype_GetGUID,
1405     audio_mediatype_GetStringLength,
1406     audio_mediatype_GetString,
1407     audio_mediatype_GetAllocatedString,
1408     audio_mediatype_GetBlobSize,
1409     audio_mediatype_GetBlob,
1410     audio_mediatype_GetAllocatedBlob,
1411     audio_mediatype_GetUnknown,
1412     audio_mediatype_SetItem,
1413     audio_mediatype_DeleteItem,
1414     audio_mediatype_DeleteAllItems,
1415     audio_mediatype_SetUINT32,
1416     audio_mediatype_SetUINT64,
1417     audio_mediatype_SetDouble,
1418     audio_mediatype_SetGUID,
1419     audio_mediatype_SetString,
1420     audio_mediatype_SetBlob,
1421     audio_mediatype_SetUnknown,
1422     audio_mediatype_LockStore,
1423     audio_mediatype_UnlockStore,
1424     audio_mediatype_GetCount,
1425     audio_mediatype_GetItemByIndex,
1426     audio_mediatype_CopyAllItems,
1427     audio_mediatype_GetMajorType,
1428     audio_mediatype_IsCompressedFormat,
1429     audio_mediatype_IsEqual,
1430     audio_mediatype_GetRepresentation,
1431     audio_mediatype_FreeRepresentation,
1432     audio_mediatype_GetAudioFormat,
1433 };
1434
1435 static HRESULT create_media_type(struct media_type **ret)
1436 {
1437     struct media_type *object;
1438     HRESULT hr;
1439
1440     if (!(object = calloc(1, sizeof(*object))))
1441         return E_OUTOFMEMORY;
1442
1443     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
1444     {
1445         free(object);
1446         return hr;
1447     }
1448     object->IMFMediaType_iface.lpVtbl = &mediatypevtbl;
1449     object->IMFVideoMediaType_iface.lpVtbl = &videomediatypevtbl;
1450     object->IMFAudioMediaType_iface.lpVtbl = &audiomediatypevtbl;
1451
1452     *ret = object;
1453
1454     return S_OK;
1455 }
1456
1457 /***********************************************************************
1458  *      MFCreateMediaType (mfplat.@)
1459  */
1460 HRESULT WINAPI MFCreateMediaType(IMFMediaType **media_type)
1461 {
1462     struct media_type *object;
1463     HRESULT hr;
1464
1465     TRACE("%p.\n", media_type);
1466
1467     if (!media_type)
1468         return E_INVALIDARG;
1469
1470     if (FAILED(hr = create_media_type(&object)))
1471         return hr;
1472
1473     *media_type = &object->IMFMediaType_iface;
1474
1475     TRACE("Created media type %p.\n", *media_type);
1476
1477     return S_OK;
1478 }
1479
1480 static HRESULT WINAPI stream_descriptor_QueryInterface(IMFStreamDescriptor *iface, REFIID riid, void **out)
1481 {
1482     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
1483
1484     if (IsEqualIID(riid, &IID_IMFStreamDescriptor) ||
1485             IsEqualIID(riid, &IID_IMFAttributes) ||
1486             IsEqualIID(riid, &IID_IUnknown))
1487     {
1488         *out = iface;
1489         IMFStreamDescriptor_AddRef(iface);
1490         return S_OK;
1491     }
1492
1493     WARN("Unsupported %s.\n", debugstr_guid(riid));
1494     *out = NULL;
1495     return E_NOINTERFACE;
1496 }
1497
1498 static ULONG WINAPI stream_descriptor_AddRef(IMFStreamDescriptor *iface)
1499 {
1500     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1501     ULONG refcount = InterlockedIncrement(&stream_desc->attributes.ref);
1502
1503     TRACE("%p, refcount %lu.\n", iface, refcount);
1504
1505     return refcount;
1506 }
1507
1508 static ULONG WINAPI stream_descriptor_Release(IMFStreamDescriptor *iface)
1509 {
1510     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1511     ULONG refcount = InterlockedDecrement(&stream_desc->attributes.ref);
1512     unsigned int i;
1513
1514     TRACE("%p, refcount %lu.\n", iface, refcount);
1515
1516     if (!refcount)
1517     {
1518         for (i = 0; i < stream_desc->media_types_count; ++i)
1519         {
1520             if (stream_desc->media_types[i])
1521                 IMFMediaType_Release(stream_desc->media_types[i]);
1522         }
1523         free(stream_desc->media_types);
1524         if (stream_desc->current_type)
1525             IMFMediaType_Release(stream_desc->current_type);
1526         clear_attributes_object(&stream_desc->attributes);
1527         free(stream_desc);
1528     }
1529
1530     return refcount;
1531 }
1532
1533 static HRESULT WINAPI stream_descriptor_GetItem(IMFStreamDescriptor *iface, REFGUID key, PROPVARIANT *value)
1534 {
1535     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1536
1537     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1538
1539     return attributes_GetItem(&stream_desc->attributes, key, value);
1540 }
1541
1542 static HRESULT WINAPI stream_descriptor_GetItemType(IMFStreamDescriptor *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1543 {
1544     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1545
1546     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
1547
1548     return attributes_GetItemType(&stream_desc->attributes, key, type);
1549 }
1550
1551 static HRESULT WINAPI stream_descriptor_CompareItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value,
1552         BOOL *result)
1553 {
1554     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1555
1556     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
1557
1558     return attributes_CompareItem(&stream_desc->attributes, key, value, result);
1559 }
1560
1561 static HRESULT WINAPI stream_descriptor_Compare(IMFStreamDescriptor *iface, IMFAttributes *theirs,
1562         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1563 {
1564     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1565
1566     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
1567
1568     return attributes_Compare(&stream_desc->attributes, theirs, type, result);
1569 }
1570
1571 static HRESULT WINAPI stream_descriptor_GetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 *value)
1572 {
1573     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1574
1575     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1576
1577     return attributes_GetUINT32(&stream_desc->attributes, key, value);
1578 }
1579
1580 static HRESULT WINAPI stream_descriptor_GetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 *value)
1581 {
1582     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1583
1584     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1585
1586     return attributes_GetUINT64(&stream_desc->attributes, key, value);
1587 }
1588
1589 static HRESULT WINAPI stream_descriptor_GetDouble(IMFStreamDescriptor *iface, REFGUID key, double *value)
1590 {
1591     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1592
1593     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1594
1595     return attributes_GetDouble(&stream_desc->attributes, key, value);
1596 }
1597
1598 static HRESULT WINAPI stream_descriptor_GetGUID(IMFStreamDescriptor *iface, REFGUID key, GUID *value)
1599 {
1600     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1601
1602     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
1603
1604     return attributes_GetGUID(&stream_desc->attributes, key, value);
1605 }
1606
1607 static HRESULT WINAPI stream_descriptor_GetStringLength(IMFStreamDescriptor *iface, REFGUID key, UINT32 *length)
1608 {
1609     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1610
1611     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
1612
1613     return attributes_GetStringLength(&stream_desc->attributes, key, length);
1614 }
1615
1616 static HRESULT WINAPI stream_descriptor_GetString(IMFStreamDescriptor *iface, REFGUID key, WCHAR *value,
1617         UINT32 size, UINT32 *length)
1618 {
1619     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1620
1621     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
1622
1623     return attributes_GetString(&stream_desc->attributes, key, value, size, length);
1624 }
1625
1626 static HRESULT WINAPI stream_descriptor_GetAllocatedString(IMFStreamDescriptor *iface, REFGUID key,
1627         WCHAR **value, UINT32 *length)
1628 {
1629     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1630
1631     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
1632
1633     return attributes_GetAllocatedString(&stream_desc->attributes, key, value, length);
1634 }
1635
1636 static HRESULT WINAPI stream_descriptor_GetBlobSize(IMFStreamDescriptor *iface, REFGUID key, UINT32 *size)
1637 {
1638     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1639
1640     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
1641
1642     return attributes_GetBlobSize(&stream_desc->attributes, key, size);
1643 }
1644
1645 static HRESULT WINAPI stream_descriptor_GetBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 *buf,
1646         UINT32 bufsize, UINT32 *blobsize)
1647 {
1648     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1649
1650     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
1651
1652     return attributes_GetBlob(&stream_desc->attributes, key, buf, bufsize, blobsize);
1653 }
1654
1655 static HRESULT WINAPI stream_descriptor_GetAllocatedBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 **buf,
1656         UINT32 *size)
1657 {
1658     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1659
1660     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
1661
1662     return attributes_GetAllocatedBlob(&stream_desc->attributes, key, buf, size);
1663 }
1664
1665 static HRESULT WINAPI stream_descriptor_GetUnknown(IMFStreamDescriptor *iface, REFGUID key, REFIID riid, void **out)
1666 {
1667     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1668
1669     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
1670
1671     return attributes_GetUnknown(&stream_desc->attributes, key, riid, out);
1672 }
1673
1674 static HRESULT WINAPI stream_descriptor_SetItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value)
1675 {
1676     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1677
1678     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
1679
1680     return attributes_SetItem(&stream_desc->attributes, key, value);
1681 }
1682
1683 static HRESULT WINAPI stream_descriptor_DeleteItem(IMFStreamDescriptor *iface, REFGUID key)
1684 {
1685     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1686
1687     TRACE("%p, %s.\n", iface, debugstr_attr(key));
1688
1689     return attributes_DeleteItem(&stream_desc->attributes, key);
1690 }
1691
1692 static HRESULT WINAPI stream_descriptor_DeleteAllItems(IMFStreamDescriptor *iface)
1693 {
1694     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1695
1696     TRACE("%p.\n", iface);
1697
1698     return attributes_DeleteAllItems(&stream_desc->attributes);
1699 }
1700
1701 static HRESULT WINAPI stream_descriptor_SetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 value)
1702 {
1703     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1704
1705     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
1706
1707     return attributes_SetUINT32(&stream_desc->attributes, key, value);
1708 }
1709
1710 static HRESULT WINAPI stream_descriptor_SetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 value)
1711 {
1712     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1713
1714     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
1715
1716     return attributes_SetUINT64(&stream_desc->attributes, key, value);
1717 }
1718
1719 static HRESULT WINAPI stream_descriptor_SetDouble(IMFStreamDescriptor *iface, REFGUID key, double value)
1720 {
1721     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1722
1723     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
1724
1725     return attributes_SetDouble(&stream_desc->attributes, key, value);
1726 }
1727
1728 static HRESULT WINAPI stream_descriptor_SetGUID(IMFStreamDescriptor *iface, REFGUID key, REFGUID value)
1729 {
1730     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1731
1732     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
1733
1734     return attributes_SetGUID(&stream_desc->attributes, key, value);
1735 }
1736
1737 static HRESULT WINAPI stream_descriptor_SetString(IMFStreamDescriptor *iface, REFGUID key, const WCHAR *value)
1738 {
1739     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1740
1741     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
1742
1743     return attributes_SetString(&stream_desc->attributes, key, value);
1744 }
1745
1746 static HRESULT WINAPI stream_descriptor_SetBlob(IMFStreamDescriptor *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1747 {
1748     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1749
1750     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
1751
1752     return attributes_SetBlob(&stream_desc->attributes, key, buf, size);
1753 }
1754
1755 static HRESULT WINAPI stream_descriptor_SetUnknown(IMFStreamDescriptor *iface, REFGUID key, IUnknown *unknown)
1756 {
1757     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1758
1759     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
1760
1761     return attributes_SetUnknown(&stream_desc->attributes, key, unknown);
1762 }
1763
1764 static HRESULT WINAPI stream_descriptor_LockStore(IMFStreamDescriptor *iface)
1765 {
1766     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1767
1768     TRACE("%p.\n", iface);
1769
1770     return attributes_LockStore(&stream_desc->attributes);
1771 }
1772
1773 static HRESULT WINAPI stream_descriptor_UnlockStore(IMFStreamDescriptor *iface)
1774 {
1775     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1776
1777     TRACE("%p.\n", iface);
1778
1779     return attributes_UnlockStore(&stream_desc->attributes);
1780 }
1781
1782 static HRESULT WINAPI stream_descriptor_GetCount(IMFStreamDescriptor *iface, UINT32 *count)
1783 {
1784     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1785
1786     TRACE("%p, %p.\n", iface, count);
1787
1788     return attributes_GetCount(&stream_desc->attributes, count);
1789 }
1790
1791 static HRESULT WINAPI stream_descriptor_GetItemByIndex(IMFStreamDescriptor *iface, UINT32 index, GUID *key,
1792         PROPVARIANT *value)
1793 {
1794     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1795
1796     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1797
1798     return attributes_GetItemByIndex(&stream_desc->attributes, index, key, value);
1799 }
1800
1801 static HRESULT WINAPI stream_descriptor_CopyAllItems(IMFStreamDescriptor *iface, IMFAttributes *dest)
1802 {
1803     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1804
1805     TRACE("%p, %p.\n", iface, dest);
1806
1807     return attributes_CopyAllItems(&stream_desc->attributes, dest);
1808 }
1809
1810 static HRESULT WINAPI stream_descriptor_GetStreamIdentifier(IMFStreamDescriptor *iface, DWORD *identifier)
1811 {
1812     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1813
1814     TRACE("%p, %p.\n", iface, identifier);
1815
1816     *identifier = stream_desc->identifier;
1817
1818     return S_OK;
1819 }
1820
1821 static HRESULT WINAPI stream_descriptor_GetMediaTypeHandler(IMFStreamDescriptor *iface, IMFMediaTypeHandler **handler)
1822 {
1823     struct stream_desc *stream_desc = impl_from_IMFStreamDescriptor(iface);
1824
1825     TRACE("%p, %p.\n", iface, handler);
1826
1827     *handler = &stream_desc->IMFMediaTypeHandler_iface;
1828     IMFMediaTypeHandler_AddRef(*handler);
1829
1830     return S_OK;
1831 }
1832
1833 static const IMFStreamDescriptorVtbl streamdescriptorvtbl =
1834 {
1835     stream_descriptor_QueryInterface,
1836     stream_descriptor_AddRef,
1837     stream_descriptor_Release,
1838     stream_descriptor_GetItem,
1839     stream_descriptor_GetItemType,
1840     stream_descriptor_CompareItem,
1841     stream_descriptor_Compare,
1842     stream_descriptor_GetUINT32,
1843     stream_descriptor_GetUINT64,
1844     stream_descriptor_GetDouble,
1845     stream_descriptor_GetGUID,
1846     stream_descriptor_GetStringLength,
1847     stream_descriptor_GetString,
1848     stream_descriptor_GetAllocatedString,
1849     stream_descriptor_GetBlobSize,
1850     stream_descriptor_GetBlob,
1851     stream_descriptor_GetAllocatedBlob,
1852     stream_descriptor_GetUnknown,
1853     stream_descriptor_SetItem,
1854     stream_descriptor_DeleteItem,
1855     stream_descriptor_DeleteAllItems,
1856     stream_descriptor_SetUINT32,
1857     stream_descriptor_SetUINT64,
1858     stream_descriptor_SetDouble,
1859     stream_descriptor_SetGUID,
1860     stream_descriptor_SetString,
1861     stream_descriptor_SetBlob,
1862     stream_descriptor_SetUnknown,
1863     stream_descriptor_LockStore,
1864     stream_descriptor_UnlockStore,
1865     stream_descriptor_GetCount,
1866     stream_descriptor_GetItemByIndex,
1867     stream_descriptor_CopyAllItems,
1868     stream_descriptor_GetStreamIdentifier,
1869     stream_descriptor_GetMediaTypeHandler
1870 };
1871
1872 static HRESULT WINAPI mediatype_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
1873 {
1874     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1875
1876     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler) ||
1877             IsEqualIID(riid, &IID_IUnknown))
1878     {
1879         *obj = iface;
1880         IMFMediaTypeHandler_AddRef(iface);
1881         return S_OK;
1882     }
1883
1884     WARN("Unsupported %s.\n", debugstr_guid(riid));
1885     *obj = NULL;
1886     return E_NOINTERFACE;
1887 }
1888
1889 static ULONG WINAPI mediatype_handler_AddRef(IMFMediaTypeHandler *iface)
1890 {
1891     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1892     return IMFStreamDescriptor_AddRef(&stream_desc->IMFStreamDescriptor_iface);
1893 }
1894
1895 static ULONG WINAPI mediatype_handler_Release(IMFMediaTypeHandler *iface)
1896 {
1897     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1898     return IMFStreamDescriptor_Release(&stream_desc->IMFStreamDescriptor_iface);
1899 }
1900
1901 static BOOL stream_descriptor_is_mediatype_supported(IMFMediaType *media_type, IMFMediaType *candidate)
1902 {
1903     DWORD flags = 0;
1904
1905     if (FAILED(IMFMediaType_IsEqual(media_type, candidate, &flags)))
1906         return FALSE;
1907
1908     return (flags & (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES)) ==
1909             (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES);
1910 }
1911
1912 static HRESULT WINAPI mediatype_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
1913         IMFMediaType **out_type)
1914 {
1915     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1916     BOOL supported = FALSE;
1917     unsigned int i;
1918
1919     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1920
1921     if (!in_type)
1922         return E_POINTER;
1923
1924     if (out_type)
1925         *out_type = NULL;
1926
1927     EnterCriticalSection(&stream_desc->attributes.cs);
1928
1929     supported = stream_desc->current_type && stream_descriptor_is_mediatype_supported(stream_desc->current_type, in_type);
1930     if (!supported)
1931     {
1932         for (i = 0; i < stream_desc->media_types_count; ++i)
1933         {
1934             if ((supported = stream_descriptor_is_mediatype_supported(stream_desc->media_types[i], in_type)))
1935                 break;
1936         }
1937     }
1938
1939     LeaveCriticalSection(&stream_desc->attributes.cs);
1940
1941     return supported ? S_OK : MF_E_INVALIDMEDIATYPE;
1942 }
1943
1944 static HRESULT WINAPI mediatype_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1945 {
1946     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1947
1948     TRACE("%p, %p.\n", iface, count);
1949
1950     *count = stream_desc->media_types_count;
1951
1952     return S_OK;
1953 }
1954
1955 static HRESULT WINAPI mediatype_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1956         IMFMediaType **type)
1957 {
1958     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1959
1960     TRACE("%p, %lu, %p.\n", iface, index, type);
1961
1962     if (index >= stream_desc->media_types_count)
1963         return MF_E_NO_MORE_TYPES;
1964
1965     if (stream_desc->media_types[index])
1966     {
1967         *type = stream_desc->media_types[index];
1968         IMFMediaType_AddRef(*type);
1969     }
1970
1971     return stream_desc->media_types[index] ? S_OK : E_FAIL;
1972 }
1973
1974 static HRESULT WINAPI mediatype_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
1975 {
1976     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1977
1978     TRACE("%p, %p.\n", iface, type);
1979
1980     if (!type)
1981         return E_POINTER;
1982
1983     EnterCriticalSection(&stream_desc->attributes.cs);
1984     if (stream_desc->current_type)
1985         IMFMediaType_Release(stream_desc->current_type);
1986     stream_desc->current_type = type;
1987     IMFMediaType_AddRef(stream_desc->current_type);
1988     LeaveCriticalSection(&stream_desc->attributes.cs);
1989
1990     return S_OK;
1991 }
1992
1993 static HRESULT WINAPI mediatype_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
1994 {
1995     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
1996     HRESULT hr = S_OK;
1997
1998     TRACE("%p, %p.\n", iface, type);
1999
2000     EnterCriticalSection(&stream_desc->attributes.cs);
2001     if (stream_desc->current_type)
2002     {
2003         *type = stream_desc->current_type;
2004         IMFMediaType_AddRef(*type);
2005     }
2006     else
2007         hr = MF_E_NOT_INITIALIZED;
2008     LeaveCriticalSection(&stream_desc->attributes.cs);
2009
2010     return hr;
2011 }
2012
2013 static HRESULT WINAPI mediatype_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
2014 {
2015     struct stream_desc *stream_desc = impl_from_IMFMediaTypeHandler(iface);
2016     HRESULT hr;
2017
2018     TRACE("%p, %p.\n", iface, type);
2019
2020     EnterCriticalSection(&stream_desc->attributes.cs);
2021     hr = IMFMediaType_GetGUID(stream_desc->current_type ? stream_desc->current_type :
2022             stream_desc->media_types[0], &MF_MT_MAJOR_TYPE, type);
2023     LeaveCriticalSection(&stream_desc->attributes.cs);
2024
2025     return hr;
2026 }
2027
2028 static const IMFMediaTypeHandlerVtbl mediatypehandlervtbl =
2029 {
2030     mediatype_handler_QueryInterface,
2031     mediatype_handler_AddRef,
2032     mediatype_handler_Release,
2033     mediatype_handler_IsMediaTypeSupported,
2034     mediatype_handler_GetMediaTypeCount,
2035     mediatype_handler_GetMediaTypeByIndex,
2036     mediatype_handler_SetCurrentMediaType,
2037     mediatype_handler_GetCurrentMediaType,
2038     mediatype_handler_GetMajorType,
2039 };
2040
2041 /***********************************************************************
2042  *      MFCreateStreamDescriptor (mfplat.@)
2043  */
2044 HRESULT WINAPI MFCreateStreamDescriptor(DWORD identifier, DWORD count,
2045         IMFMediaType **types, IMFStreamDescriptor **descriptor)
2046 {
2047     struct stream_desc *object;
2048     unsigned int i;
2049     HRESULT hr;
2050
2051     TRACE("%ld, %ld, %p, %p.\n", identifier, count, types, descriptor);
2052
2053     if (!count)
2054         return E_INVALIDARG;
2055
2056     if (!(object = calloc(1, sizeof(*object))))
2057         return E_OUTOFMEMORY;
2058
2059     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
2060     {
2061         free(object);
2062         return hr;
2063     }
2064     object->IMFStreamDescriptor_iface.lpVtbl = &streamdescriptorvtbl;
2065     object->IMFMediaTypeHandler_iface.lpVtbl = &mediatypehandlervtbl;
2066     object->identifier = identifier;
2067     object->media_types = calloc(count, sizeof(*object->media_types));
2068     if (!object->media_types)
2069     {
2070         IMFStreamDescriptor_Release(&object->IMFStreamDescriptor_iface);
2071         return E_OUTOFMEMORY;
2072     }
2073     for (i = 0; i < count; ++i)
2074     {
2075         object->media_types[i] = types[i];
2076         if (object->media_types[i])
2077             IMFMediaType_AddRef(object->media_types[i]);
2078     }
2079     object->media_types_count = count;
2080
2081     *descriptor = &object->IMFStreamDescriptor_iface;
2082
2083     return S_OK;
2084 }
2085
2086 static HRESULT WINAPI presentation_descriptor_QueryInterface(IMFPresentationDescriptor *iface, REFIID riid, void **out)
2087 {
2088     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
2089
2090     if (IsEqualIID(riid, &IID_IMFPresentationDescriptor) ||
2091             IsEqualIID(riid, &IID_IMFAttributes) ||
2092             IsEqualIID(riid, &IID_IUnknown))
2093     {
2094         *out = iface;
2095         IMFPresentationDescriptor_AddRef(iface);
2096         return S_OK;
2097     }
2098
2099     WARN("Unsupported %s.\n", debugstr_guid(riid));
2100     *out = NULL;
2101     return E_NOINTERFACE;
2102 }
2103
2104 static ULONG WINAPI presentation_descriptor_AddRef(IMFPresentationDescriptor *iface)
2105 {
2106     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2107     ULONG refcount = InterlockedIncrement(&presentation_desc->attributes.ref);
2108
2109     TRACE("%p, refcount %lu.\n", iface, refcount);
2110
2111     return refcount;
2112 }
2113
2114 static ULONG WINAPI presentation_descriptor_Release(IMFPresentationDescriptor *iface)
2115 {
2116     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2117     ULONG refcount = InterlockedDecrement(&presentation_desc->attributes.ref);
2118     unsigned int i;
2119
2120     TRACE("%p, refcount %lu.\n", iface, refcount);
2121
2122     if (!refcount)
2123     {
2124         for (i = 0; i < presentation_desc->count; ++i)
2125         {
2126             if (presentation_desc->descriptors[i].descriptor)
2127                 IMFStreamDescriptor_Release(presentation_desc->descriptors[i].descriptor);
2128         }
2129         clear_attributes_object(&presentation_desc->attributes);
2130         free(presentation_desc->descriptors);
2131         free(presentation_desc);
2132     }
2133
2134     return refcount;
2135 }
2136
2137 static HRESULT WINAPI presentation_descriptor_GetItem(IMFPresentationDescriptor *iface, REFGUID key,
2138         PROPVARIANT *value)
2139 {
2140     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2141
2142     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2143
2144     return attributes_GetItem(&presentation_desc->attributes, key, value);
2145 }
2146
2147 static HRESULT WINAPI presentation_descriptor_GetItemType(IMFPresentationDescriptor *iface, REFGUID key,
2148         MF_ATTRIBUTE_TYPE *type)
2149 {
2150     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2151
2152     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
2153
2154     return attributes_GetItemType(&presentation_desc->attributes, key, type);
2155 }
2156
2157 static HRESULT WINAPI presentation_descriptor_CompareItem(IMFPresentationDescriptor *iface, REFGUID key,
2158         REFPROPVARIANT value, BOOL *result)
2159 {
2160     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2161
2162     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
2163
2164     return attributes_CompareItem(&presentation_desc->attributes, key, value, result);
2165 }
2166
2167 static HRESULT WINAPI presentation_descriptor_Compare(IMFPresentationDescriptor *iface, IMFAttributes *attrs,
2168         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
2169 {
2170     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2171
2172     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
2173
2174     return attributes_Compare(&presentation_desc->attributes, attrs, type, result);
2175 }
2176
2177 static HRESULT WINAPI presentation_descriptor_GetUINT32(IMFPresentationDescriptor *iface, REFGUID key, UINT32 *value)
2178 {
2179     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2180
2181     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2182
2183     return attributes_GetUINT32(&presentation_desc->attributes, key, value);
2184 }
2185
2186 static HRESULT WINAPI presentation_descriptor_GetUINT64(IMFPresentationDescriptor *iface, REFGUID key, UINT64 *value)
2187 {
2188     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2189
2190     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2191
2192     return attributes_GetUINT64(&presentation_desc->attributes, key, value);
2193 }
2194
2195 static HRESULT WINAPI presentation_descriptor_GetDouble(IMFPresentationDescriptor *iface, REFGUID key, double *value)
2196 {
2197     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2198
2199     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2200
2201     return attributes_GetDouble(&presentation_desc->attributes, key, value);
2202 }
2203
2204 static HRESULT WINAPI presentation_descriptor_GetGUID(IMFPresentationDescriptor *iface, REFGUID key, GUID *value)
2205 {
2206     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2207
2208     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2209
2210     return attributes_GetGUID(&presentation_desc->attributes, key, value);
2211 }
2212
2213 static HRESULT WINAPI presentation_descriptor_GetStringLength(IMFPresentationDescriptor *iface, REFGUID key,
2214         UINT32 *length)
2215 {
2216     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2217
2218     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
2219
2220     return attributes_GetStringLength(&presentation_desc->attributes, key, length);
2221 }
2222
2223 static HRESULT WINAPI presentation_descriptor_GetString(IMFPresentationDescriptor *iface, REFGUID key, WCHAR *value,
2224         UINT32 size, UINT32 *length)
2225 {
2226     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2227
2228     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
2229
2230     return attributes_GetString(&presentation_desc->attributes, key, value, size, length);
2231 }
2232
2233 static HRESULT WINAPI presentation_descriptor_GetAllocatedString(IMFPresentationDescriptor *iface, REFGUID key,
2234         WCHAR **value, UINT32 *length)
2235 {
2236     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2237
2238     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
2239
2240     return attributes_GetAllocatedString(&presentation_desc->attributes, key, value, length);
2241 }
2242
2243 static HRESULT WINAPI presentation_descriptor_GetBlobSize(IMFPresentationDescriptor *iface, REFGUID key, UINT32 *size)
2244 {
2245     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2246
2247     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
2248
2249     return attributes_GetBlobSize(&presentation_desc->attributes, key, size);
2250 }
2251
2252 static HRESULT WINAPI presentation_descriptor_GetBlob(IMFPresentationDescriptor *iface, REFGUID key, UINT8 *buf,
2253         UINT32 bufsize, UINT32 *blobsize)
2254 {
2255     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2256
2257     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
2258
2259     return attributes_GetBlob(&presentation_desc->attributes, key, buf, bufsize, blobsize);
2260 }
2261
2262 static HRESULT WINAPI presentation_descriptor_GetAllocatedBlob(IMFPresentationDescriptor *iface, REFGUID key,
2263         UINT8 **buf, UINT32 *size)
2264 {
2265     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2266
2267     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
2268
2269     return attributes_GetAllocatedBlob(&presentation_desc->attributes, key, buf, size);
2270 }
2271
2272 static HRESULT WINAPI presentation_descriptor_GetUnknown(IMFPresentationDescriptor *iface, REFGUID key,
2273         REFIID riid, void **out)
2274 {
2275     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2276
2277     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
2278
2279     return attributes_GetUnknown(&presentation_desc->attributes, key, riid, out);
2280 }
2281
2282 static HRESULT WINAPI presentation_descriptor_SetItem(IMFPresentationDescriptor *iface, REFGUID key,
2283         REFPROPVARIANT value)
2284 {
2285     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2286
2287     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
2288
2289     return attributes_SetItem(&presentation_desc->attributes, key, value);
2290 }
2291
2292 static HRESULT WINAPI presentation_descriptor_DeleteItem(IMFPresentationDescriptor *iface, REFGUID key)
2293 {
2294     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2295
2296     TRACE("%p, %s.\n", iface, debugstr_attr(key));
2297
2298     return attributes_DeleteItem(&presentation_desc->attributes, key);
2299 }
2300
2301 static HRESULT WINAPI presentation_descriptor_DeleteAllItems(IMFPresentationDescriptor *iface)
2302 {
2303     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2304
2305     TRACE("%p.\n", iface);
2306
2307     return attributes_DeleteAllItems(&presentation_desc->attributes);
2308 }
2309
2310 static HRESULT WINAPI presentation_descriptor_SetUINT32(IMFPresentationDescriptor *iface, REFGUID key, UINT32 value)
2311 {
2312     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2313
2314     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
2315
2316     return attributes_SetUINT32(&presentation_desc->attributes, key, value);
2317 }
2318
2319 static HRESULT WINAPI presentation_descriptor_SetUINT64(IMFPresentationDescriptor *iface, REFGUID key, UINT64 value)
2320 {
2321     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2322
2323     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
2324
2325     return attributes_SetUINT64(&presentation_desc->attributes, key, value);
2326 }
2327
2328 static HRESULT WINAPI presentation_descriptor_SetDouble(IMFPresentationDescriptor *iface, REFGUID key, double value)
2329 {
2330     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2331
2332     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
2333
2334     return attributes_SetDouble(&presentation_desc->attributes, key, value);
2335 }
2336
2337 static HRESULT WINAPI presentation_descriptor_SetGUID(IMFPresentationDescriptor *iface, REFGUID key, REFGUID value)
2338 {
2339     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2340
2341     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
2342
2343     return attributes_SetGUID(&presentation_desc->attributes, key, value);
2344 }
2345
2346 static HRESULT WINAPI presentation_descriptor_SetString(IMFPresentationDescriptor *iface, REFGUID key,
2347         const WCHAR *value)
2348 {
2349     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2350
2351     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
2352
2353     return attributes_SetString(&presentation_desc->attributes, key, value);
2354 }
2355
2356 static HRESULT WINAPI presentation_descriptor_SetBlob(IMFPresentationDescriptor *iface, REFGUID key, const UINT8 *buf,
2357         UINT32 size)
2358 {
2359     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2360
2361     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
2362
2363     return attributes_SetBlob(&presentation_desc->attributes, key, buf, size);
2364 }
2365
2366 static HRESULT WINAPI presentation_descriptor_SetUnknown(IMFPresentationDescriptor *iface, REFGUID key,
2367         IUnknown *unknown)
2368 {
2369     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2370
2371     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
2372
2373     return attributes_SetUnknown(&presentation_desc->attributes, key, unknown);
2374 }
2375
2376 static HRESULT WINAPI presentation_descriptor_LockStore(IMFPresentationDescriptor *iface)
2377 {
2378     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2379
2380     TRACE("%p.\n", iface);
2381
2382     return attributes_LockStore(&presentation_desc->attributes);
2383 }
2384
2385 static HRESULT WINAPI presentation_descriptor_UnlockStore(IMFPresentationDescriptor *iface)
2386 {
2387     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2388
2389     TRACE("%p.\n", iface);
2390
2391     return attributes_UnlockStore(&presentation_desc->attributes);
2392 }
2393
2394 static HRESULT WINAPI presentation_descriptor_GetCount(IMFPresentationDescriptor *iface, UINT32 *count)
2395 {
2396     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2397
2398     TRACE("%p, %p.\n", iface, count);
2399
2400     return attributes_GetCount(&presentation_desc->attributes, count);
2401 }
2402
2403 static HRESULT WINAPI presentation_descriptor_GetItemByIndex(IMFPresentationDescriptor *iface, UINT32 index, GUID *key,
2404         PROPVARIANT *value)
2405 {
2406     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2407
2408     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2409
2410     return attributes_GetItemByIndex(&presentation_desc->attributes, index, key, value);
2411 }
2412
2413 static HRESULT WINAPI presentation_descriptor_CopyAllItems(IMFPresentationDescriptor *iface, IMFAttributes *dest)
2414 {
2415     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2416
2417     TRACE("%p, %p.\n", iface, dest);
2418
2419     return attributes_CopyAllItems(&presentation_desc->attributes, dest);
2420 }
2421
2422 static HRESULT WINAPI presentation_descriptor_GetStreamDescriptorCount(IMFPresentationDescriptor *iface, DWORD *count)
2423 {
2424     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2425
2426     TRACE("%p, %p.\n", iface, count);
2427
2428     *count = presentation_desc->count;
2429
2430     return S_OK;
2431 }
2432
2433 static HRESULT WINAPI presentation_descriptor_GetStreamDescriptorByIndex(IMFPresentationDescriptor *iface, DWORD index,
2434         BOOL *selected, IMFStreamDescriptor **descriptor)
2435 {
2436     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2437
2438     TRACE("%p, %lu, %p, %p.\n", iface, index, selected, descriptor);
2439
2440     if (index >= presentation_desc->count)
2441         return E_INVALIDARG;
2442
2443     EnterCriticalSection(&presentation_desc->attributes.cs);
2444     *selected = presentation_desc->descriptors[index].selected;
2445     LeaveCriticalSection(&presentation_desc->attributes.cs);
2446
2447     *descriptor = presentation_desc->descriptors[index].descriptor;
2448     IMFStreamDescriptor_AddRef(*descriptor);
2449
2450     return S_OK;
2451 }
2452
2453 static HRESULT WINAPI presentation_descriptor_SelectStream(IMFPresentationDescriptor *iface, DWORD index)
2454 {
2455     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2456
2457     TRACE("%p, %lu.\n", iface, index);
2458
2459     if (index >= presentation_desc->count)
2460         return E_INVALIDARG;
2461
2462     EnterCriticalSection(&presentation_desc->attributes.cs);
2463     presentation_desc->descriptors[index].selected = TRUE;
2464     LeaveCriticalSection(&presentation_desc->attributes.cs);
2465
2466     return S_OK;
2467 }
2468
2469 static HRESULT WINAPI presentation_descriptor_DeselectStream(IMFPresentationDescriptor *iface, DWORD index)
2470 {
2471     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2472
2473     TRACE("%p, %lu.\n", iface, index);
2474
2475     if (index >= presentation_desc->count)
2476         return E_INVALIDARG;
2477
2478     EnterCriticalSection(&presentation_desc->attributes.cs);
2479     presentation_desc->descriptors[index].selected = FALSE;
2480     LeaveCriticalSection(&presentation_desc->attributes.cs);
2481
2482     return S_OK;
2483 }
2484
2485 static HRESULT WINAPI presentation_descriptor_Clone(IMFPresentationDescriptor *iface,
2486         IMFPresentationDescriptor **descriptor)
2487 {
2488     struct presentation_desc *presentation_desc = impl_from_IMFPresentationDescriptor(iface);
2489     struct presentation_desc *object;
2490     unsigned int i;
2491
2492     TRACE("%p, %p.\n", iface, descriptor);
2493
2494     if (!(object = calloc(1, sizeof(*object))))
2495         return E_OUTOFMEMORY;
2496
2497     presentation_descriptor_init(object, presentation_desc->count);
2498
2499     EnterCriticalSection(&presentation_desc->attributes.cs);
2500
2501     for (i = 0; i < presentation_desc->count; ++i)
2502     {
2503         object->descriptors[i] = presentation_desc->descriptors[i];
2504         IMFStreamDescriptor_AddRef(object->descriptors[i].descriptor);
2505     }
2506
2507     attributes_CopyAllItems(&presentation_desc->attributes, (IMFAttributes *)&object->IMFPresentationDescriptor_iface);
2508
2509     LeaveCriticalSection(&presentation_desc->attributes.cs);
2510
2511     *descriptor = &object->IMFPresentationDescriptor_iface;
2512
2513     return S_OK;
2514 }
2515
2516 static const IMFPresentationDescriptorVtbl presentationdescriptorvtbl =
2517 {
2518     presentation_descriptor_QueryInterface,
2519     presentation_descriptor_AddRef,
2520     presentation_descriptor_Release,
2521     presentation_descriptor_GetItem,
2522     presentation_descriptor_GetItemType,
2523     presentation_descriptor_CompareItem,
2524     presentation_descriptor_Compare,
2525     presentation_descriptor_GetUINT32,
2526     presentation_descriptor_GetUINT64,
2527     presentation_descriptor_GetDouble,
2528     presentation_descriptor_GetGUID,
2529     presentation_descriptor_GetStringLength,
2530     presentation_descriptor_GetString,
2531     presentation_descriptor_GetAllocatedString,
2532     presentation_descriptor_GetBlobSize,
2533     presentation_descriptor_GetBlob,
2534     presentation_descriptor_GetAllocatedBlob,
2535     presentation_descriptor_GetUnknown,
2536     presentation_descriptor_SetItem,
2537     presentation_descriptor_DeleteItem,
2538     presentation_descriptor_DeleteAllItems,
2539     presentation_descriptor_SetUINT32,
2540     presentation_descriptor_SetUINT64,
2541     presentation_descriptor_SetDouble,
2542     presentation_descriptor_SetGUID,
2543     presentation_descriptor_SetString,
2544     presentation_descriptor_SetBlob,
2545     presentation_descriptor_SetUnknown,
2546     presentation_descriptor_LockStore,
2547     presentation_descriptor_UnlockStore,
2548     presentation_descriptor_GetCount,
2549     presentation_descriptor_GetItemByIndex,
2550     presentation_descriptor_CopyAllItems,
2551     presentation_descriptor_GetStreamDescriptorCount,
2552     presentation_descriptor_GetStreamDescriptorByIndex,
2553     presentation_descriptor_SelectStream,
2554     presentation_descriptor_DeselectStream,
2555     presentation_descriptor_Clone,
2556 };
2557
2558 static HRESULT presentation_descriptor_init(struct presentation_desc *object, DWORD count)
2559 {
2560     HRESULT hr;
2561
2562     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
2563         return hr;
2564     object->IMFPresentationDescriptor_iface.lpVtbl = &presentationdescriptorvtbl;
2565     if (!(object->descriptors = calloc(count, sizeof(*object->descriptors))))
2566     {
2567         IMFPresentationDescriptor_Release(&object->IMFPresentationDescriptor_iface);
2568         return E_OUTOFMEMORY;
2569     }
2570     object->count = count;
2571
2572     return S_OK;
2573 }
2574
2575 /***********************************************************************
2576  *      MFCreatePresentationDescriptor (mfplat.@)
2577  */
2578 HRESULT WINAPI MFCreatePresentationDescriptor(DWORD count, IMFStreamDescriptor **descriptors,
2579         IMFPresentationDescriptor **out)
2580 {
2581     struct presentation_desc *object;
2582     unsigned int i;
2583     HRESULT hr;
2584
2585     TRACE("%lu, %p, %p.\n", count, descriptors, out);
2586
2587     if (!count)
2588         return E_INVALIDARG;
2589
2590     for (i = 0; i < count; ++i)
2591     {
2592         if (!descriptors[i])
2593             return E_INVALIDARG;
2594     }
2595
2596     if (!(object = calloc(1, sizeof(*object))))
2597         return E_OUTOFMEMORY;
2598
2599     if (FAILED(hr = presentation_descriptor_init(object, count)))
2600     {
2601         free(object);
2602         return hr;
2603     }
2604
2605     for (i = 0; i < count; ++i)
2606     {
2607         object->descriptors[i].descriptor = descriptors[i];
2608         IMFStreamDescriptor_AddRef(object->descriptors[i].descriptor);
2609     }
2610
2611     *out = &object->IMFPresentationDescriptor_iface;
2612
2613     return S_OK;
2614 }
2615
2616 struct uncompressed_video_format
2617 {
2618     const GUID *subtype;
2619     unsigned char bytes_per_pixel;
2620     unsigned char alignment;
2621     unsigned char bottom_up;
2622     unsigned char yuv;
2623 };
2624
2625 static int __cdecl uncompressed_video_format_compare(const void *a, const void *b)
2626 {
2627     const GUID *guid = a;
2628     const struct uncompressed_video_format *format = b;
2629     return memcmp(guid, format->subtype, sizeof(*guid));
2630 }
2631
2632 static const struct uncompressed_video_format video_formats[] =
2633 {
2634     { &MFVideoFormat_RGB24,         4, 3, 1, 0 },
2635     { &MFVideoFormat_ARGB32,        4, 3, 1, 0 },
2636     { &MFVideoFormat_RGB32,         4, 3, 1, 0 },
2637     { &MFVideoFormat_RGB565,        2, 3, 1, 0 },
2638     { &MFVideoFormat_RGB555,        2, 3, 1, 0 },
2639     { &MFVideoFormat_A2R10G10B10,   4, 3, 1, 0 },
2640     { &MFVideoFormat_RGB8,          1, 3, 1, 0 },
2641     { &MFVideoFormat_L8,            1, 3, 1, 0 },
2642     { &MFVideoFormat_AYUV,          4, 3, 0, 1 },
2643     { &MFVideoFormat_I420,          1, 0, 0, 1 },
2644     { &MFVideoFormat_IMC1,          2, 3, 0, 1 },
2645     { &MFVideoFormat_IMC2,          1, 0, 0, 1 },
2646     { &MFVideoFormat_IMC3,          2, 3, 0, 1 },
2647     { &MFVideoFormat_IMC4,          1, 0, 0, 1 },
2648     { &MFVideoFormat_IYUV,          1, 0, 0, 1 },
2649     { &MFVideoFormat_NV12,          1, 0, 0, 1 },
2650     { &MFVideoFormat_D16,           2, 3, 0, 0 },
2651     { &MFVideoFormat_L16,           2, 3, 0, 0 },
2652     { &MFVideoFormat_UYVY,          2, 0, 0, 1 },
2653     { &MFVideoFormat_YUY2,          2, 0, 0, 1 },
2654     { &MFVideoFormat_YV12,          1, 0, 0, 1 },
2655     { &MFVideoFormat_A16B16G16R16F, 8, 3, 1, 0 },
2656 };
2657
2658 static struct uncompressed_video_format *mf_get_video_format(const GUID *subtype)
2659 {
2660     return bsearch(subtype, video_formats, ARRAY_SIZE(video_formats), sizeof(*video_formats),
2661             uncompressed_video_format_compare);
2662 }
2663
2664 static unsigned int mf_get_stride_for_format(const struct uncompressed_video_format *format, unsigned int width)
2665 {
2666     return (width * format->bytes_per_pixel + format->alignment) & ~format->alignment;
2667 }
2668
2669 unsigned int mf_format_get_stride(const GUID *subtype, unsigned int width, BOOL *is_yuv)
2670 {
2671     struct uncompressed_video_format *format = mf_get_video_format(subtype);
2672
2673     if (format)
2674     {
2675         *is_yuv = format->yuv;
2676         return mf_get_stride_for_format(format, width);
2677     }
2678
2679     return 0;
2680 }
2681
2682 /***********************************************************************
2683  *      MFGetStrideForBitmapInfoHeader (mfplat.@)
2684  */
2685 HRESULT WINAPI MFGetStrideForBitmapInfoHeader(DWORD fourcc, DWORD width, LONG *stride)
2686 {
2687     struct uncompressed_video_format *format;
2688     GUID subtype;
2689
2690     TRACE("%s, %lu, %p.\n", debugstr_fourcc(fourcc), width, stride);
2691
2692     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
2693     subtype.Data1 = fourcc;
2694
2695     if (!(format = mf_get_video_format(&subtype)))
2696     {
2697         *stride = 0;
2698         return MF_E_INVALIDMEDIATYPE;
2699     }
2700
2701     *stride = mf_get_stride_for_format(format, width);
2702     if (format->bottom_up)
2703         *stride *= -1;
2704
2705     return S_OK;
2706 }
2707
2708 /***********************************************************************
2709  *      MFCalculateImageSize (mfplat.@)
2710  */
2711 HRESULT WINAPI MFCalculateImageSize(REFGUID subtype, UINT32 width, UINT32 height, UINT32 *size)
2712 {
2713     struct uncompressed_video_format *format;
2714     unsigned int stride;
2715
2716     TRACE("%s, %u, %u, %p.\n", debugstr_mf_guid(subtype), width, height, size);
2717
2718     if (!(format = mf_get_video_format(subtype)))
2719     {
2720         *size = 0;
2721         return E_INVALIDARG;
2722     }
2723
2724     switch (subtype->Data1)
2725     {
2726         case MAKEFOURCC('I','M','C','2'):
2727         case MAKEFOURCC('I','M','C','4'):
2728         case MAKEFOURCC('N','V','1','2'):
2729         case MAKEFOURCC('Y','V','1','2'):
2730         case MAKEFOURCC('I','4','2','0'):
2731         case MAKEFOURCC('I','Y','U','V'):
2732             /* 2 x 2 block, interleaving UV for half the height */
2733             *size = ((width + 1) & ~1) * height * 3 / 2;
2734             break;
2735         case D3DFMT_L8:
2736         case D3DFMT_L16:
2737         case D3DFMT_D16:
2738             *size = width * format->bytes_per_pixel * height;
2739             break;
2740         default:
2741             stride = mf_get_stride_for_format(format, width);
2742             *size = stride * height;
2743     }
2744
2745     return S_OK;
2746 }
2747
2748 /***********************************************************************
2749  *      MFGetPlaneSize (mfplat.@)
2750  */
2751 HRESULT WINAPI MFGetPlaneSize(DWORD fourcc, DWORD width, DWORD height, DWORD *size)
2752 {
2753     struct uncompressed_video_format *format;
2754     unsigned int stride;
2755     GUID subtype;
2756
2757     TRACE("%s, %lu, %lu, %p.\n", debugstr_fourcc(fourcc), width, height, size);
2758
2759     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
2760     subtype.Data1 = fourcc;
2761
2762     if ((format = mf_get_video_format(&subtype)))
2763         stride = mf_get_stride_for_format(format, width);
2764     else
2765         stride = 0;
2766
2767     switch (fourcc)
2768     {
2769         case MAKEFOURCC('I','M','C','2'):
2770         case MAKEFOURCC('I','M','C','4'):
2771         case MAKEFOURCC('N','V','1','2'):
2772         case MAKEFOURCC('Y','V','1','2'):
2773         case MAKEFOURCC('I','4','2','0'):
2774         case MAKEFOURCC('I','Y','U','V'):
2775             *size = stride * height * 3 / 2;
2776             break;
2777         default:
2778             *size = stride * height;
2779     }
2780
2781     return S_OK;
2782 }
2783
2784 /***********************************************************************
2785  *      MFCompareFullToPartialMediaType (mfplat.@)
2786  */
2787 BOOL WINAPI MFCompareFullToPartialMediaType(IMFMediaType *full_type, IMFMediaType *partial_type)
2788 {
2789     BOOL result;
2790     GUID major;
2791
2792     TRACE("%p, %p.\n", full_type, partial_type);
2793
2794     if (FAILED(IMFMediaType_GetMajorType(partial_type, &major)))
2795         return FALSE;
2796
2797     if (FAILED(IMFMediaType_Compare(partial_type, (IMFAttributes *)full_type, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result)))
2798         return FALSE;
2799
2800     return result;
2801 }
2802
2803 /***********************************************************************
2804  *      MFWrapMediaType (mfplat.@)
2805  */
2806 HRESULT WINAPI MFWrapMediaType(IMFMediaType *original, REFGUID major, REFGUID subtype, IMFMediaType **ret)
2807 {
2808     IMFMediaType *mediatype;
2809     UINT8 *buffer;
2810     UINT32 size;
2811     HRESULT hr;
2812
2813     TRACE("%p, %s, %s, %p.\n", original, debugstr_guid(major), debugstr_guid(subtype), ret);
2814
2815     if (FAILED(hr = MFGetAttributesAsBlobSize((IMFAttributes *)original, &size)))
2816         return hr;
2817
2818     if (!(buffer = malloc(size)))
2819         return E_OUTOFMEMORY;
2820
2821     if (FAILED(hr = MFGetAttributesAsBlob((IMFAttributes *)original, buffer, size)))
2822         goto failed;
2823
2824     if (FAILED(hr = MFCreateMediaType(&mediatype)))
2825         goto failed;
2826
2827     if (FAILED(hr = IMFMediaType_SetGUID(mediatype, &MF_MT_MAJOR_TYPE, major)))
2828         goto failed;
2829
2830     if (FAILED(hr = IMFMediaType_SetGUID(mediatype, &MF_MT_SUBTYPE, subtype)))
2831         goto failed;
2832
2833     if (FAILED(hr = IMFMediaType_SetBlob(mediatype, &MF_MT_WRAPPED_TYPE, buffer, size)))
2834         goto failed;
2835
2836     *ret = mediatype;
2837
2838 failed:
2839     free(buffer);
2840
2841     return hr;
2842 }
2843
2844 /***********************************************************************
2845  *      MFUnwrapMediaType (mfplat.@)
2846  */
2847 HRESULT WINAPI MFUnwrapMediaType(IMFMediaType *wrapper, IMFMediaType **ret)
2848 {
2849     IMFMediaType *mediatype;
2850     UINT8 *buffer;
2851     UINT32 size;
2852     HRESULT hr;
2853
2854     TRACE("%p, %p.\n", wrapper, ret);
2855
2856     if (FAILED(hr = MFCreateMediaType(&mediatype)))
2857         return hr;
2858
2859     if (FAILED(hr = IMFMediaType_GetAllocatedBlob(wrapper, &MF_MT_WRAPPED_TYPE, &buffer, &size)))
2860     {
2861         IMFMediaType_Release(mediatype);
2862         return hr;
2863     }
2864
2865     hr = MFInitAttributesFromBlob((IMFAttributes *)mediatype, buffer, size);
2866     CoTaskMemFree(buffer);
2867     if (FAILED(hr))
2868         return hr;
2869
2870     *ret = mediatype;
2871
2872     return S_OK;
2873 }
2874
2875 /***********************************************************************
2876  *      MFCreateWaveFormatExFromMFMediaType (mfplat.@)
2877  */
2878 HRESULT WINAPI MFCreateWaveFormatExFromMFMediaType(IMFMediaType *mediatype, WAVEFORMATEX **ret_format,
2879         UINT32 *size, UINT32 flags)
2880 {
2881     WAVEFORMATEXTENSIBLE *format_ext = NULL;
2882     WAVEFORMATEX *format;
2883     GUID major, subtype;
2884     UINT32 value;
2885     HRESULT hr;
2886
2887     TRACE("%p, %p, %p, %#x.\n", mediatype, ret_format, size, flags);
2888
2889     if (FAILED(hr = IMFMediaType_GetGUID(mediatype, &MF_MT_MAJOR_TYPE, &major)))
2890         return hr;
2891
2892     if (FAILED(hr = IMFMediaType_GetGUID(mediatype, &MF_MT_SUBTYPE, &subtype)))
2893         return hr;
2894
2895     if (!IsEqualGUID(&major, &MFMediaType_Audio))
2896         return E_INVALIDARG;
2897
2898     if (!IsEqualGUID(&subtype, &MFAudioFormat_PCM) && !IsEqualGUID(&subtype, &MFAudioFormat_Float))
2899     {
2900         FIXME("Unsupported audio format %s.\n", debugstr_guid(&subtype));
2901         return E_NOTIMPL;
2902     }
2903
2904     /* FIXME: probably WAVE_FORMAT_MPEG/WAVE_FORMAT_MPEGLAYER3 should be handled separately. */
2905     if (flags == MFWaveFormatExConvertFlag_ForceExtensible)
2906     {
2907         format_ext = CoTaskMemAlloc(sizeof(*format_ext));
2908         *size = sizeof(*format_ext);
2909         format = (WAVEFORMATEX *)format_ext;
2910     }
2911     else
2912     {
2913         format = CoTaskMemAlloc(sizeof(*format));
2914         *size = sizeof(*format);
2915     }
2916
2917     if (!format)
2918         return E_OUTOFMEMORY;
2919
2920     memset(format, 0, *size);
2921
2922     if (format_ext)
2923         format->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
2924     else if (IsEqualGUID(&subtype, &MFAudioFormat_Float))
2925         format->wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
2926     else
2927         format->wFormatTag = WAVE_FORMAT_PCM;
2928
2929     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_NUM_CHANNELS, &value)))
2930         format->nChannels = value;
2931     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &value)))
2932         format->nSamplesPerSec = value;
2933     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &value)))
2934         format->nAvgBytesPerSec = value;
2935     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &value)))
2936         format->nBlockAlign = value;
2937     if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_BITS_PER_SAMPLE, &value)))
2938         format->wBitsPerSample = value;
2939     if (format_ext)
2940     {
2941         format->cbSize = sizeof(*format_ext) - sizeof(*format);
2942
2943         if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, &value)))
2944             format_ext->Samples.wSamplesPerBlock = value;
2945
2946         if (SUCCEEDED(IMFMediaType_GetUINT32(mediatype, &MF_MT_AUDIO_CHANNEL_MASK, &value)))
2947             format_ext->dwChannelMask = value;
2948         memcpy(&format_ext->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM, sizeof(format_ext->SubFormat));
2949     }
2950
2951     *ret_format = format;
2952
2953     return S_OK;
2954 }
2955
2956 static void mediatype_set_uint32(IMFMediaType *mediatype, const GUID *attr, unsigned int value, HRESULT *hr)
2957 {
2958     if (SUCCEEDED(*hr))
2959         *hr = IMFMediaType_SetUINT32(mediatype, attr, value);
2960 }
2961
2962 static void mediatype_set_uint64(IMFMediaType *mediatype, const GUID *attr, unsigned int high, unsigned int low, HRESULT *hr)
2963 {
2964     if (SUCCEEDED(*hr))
2965         *hr = IMFMediaType_SetUINT64(mediatype, attr, (UINT64)high << 32 | low);
2966 }
2967
2968 static void mediatype_set_guid(IMFMediaType *mediatype, const GUID *attr, const GUID *value, HRESULT *hr)
2969 {
2970     if (SUCCEEDED(*hr))
2971         *hr = IMFMediaType_SetGUID(mediatype, attr, value);
2972 }
2973
2974 static void mediatype_set_blob(IMFMediaType *mediatype, const GUID *attr, const UINT8 *data,
2975         unsigned int size, HRESULT *hr)
2976 {
2977     if (SUCCEEDED(*hr))
2978         *hr = IMFMediaType_SetBlob(mediatype, attr, data, size);
2979 }
2980
2981 /***********************************************************************
2982  *      MFInitMediaTypeFromWaveFormatEx (mfplat.@)
2983  */
2984 HRESULT WINAPI MFInitMediaTypeFromWaveFormatEx(IMFMediaType *mediatype, const WAVEFORMATEX *format, UINT32 size)
2985 {
2986     const WAVEFORMATEXTENSIBLE *wfex = (const WAVEFORMATEXTENSIBLE *)format;
2987     GUID subtype;
2988     HRESULT hr;
2989
2990     TRACE("%p, %p, %u.\n", mediatype, format, size);
2991
2992     if (!mediatype || !format)
2993         return E_POINTER;
2994
2995     if (format->cbSize + sizeof(*format) > size)
2996         return E_INVALIDARG;
2997
2998     hr = IMFMediaType_DeleteAllItems(mediatype);
2999
3000     mediatype_set_guid(mediatype, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio, &hr);
3001
3002     if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
3003     {
3004         memcpy(&subtype, &wfex->SubFormat, sizeof(subtype));
3005
3006         if (wfex->dwChannelMask)
3007             mediatype_set_uint32(mediatype, &MF_MT_AUDIO_CHANNEL_MASK, wfex->dwChannelMask, &hr);
3008
3009         if (format->wBitsPerSample && wfex->Samples.wValidBitsPerSample)
3010             mediatype_set_uint32(mediatype, &MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, wfex->Samples.wValidBitsPerSample, &hr);
3011     }
3012     else
3013     {
3014         memcpy(&subtype, &MFAudioFormat_Base, sizeof(subtype));
3015         subtype.Data1 = format->wFormatTag;
3016
3017         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1, &hr);
3018     }
3019     mediatype_set_guid(mediatype, &MF_MT_SUBTYPE, &subtype, &hr);
3020
3021     if (format->nChannels)
3022         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_NUM_CHANNELS, format->nChannels, &hr);
3023
3024     if (format->nSamplesPerSec)
3025         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_SAMPLES_PER_SECOND, format->nSamplesPerSec, &hr);
3026
3027     if (format->nAvgBytesPerSec)
3028         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, format->nAvgBytesPerSec, &hr);
3029
3030     if (format->nBlockAlign)
3031         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_BLOCK_ALIGNMENT, format->nBlockAlign, &hr);
3032
3033     if (format->wBitsPerSample)
3034         mediatype_set_uint32(mediatype, &MF_MT_AUDIO_BITS_PER_SAMPLE, format->wBitsPerSample, &hr);
3035
3036     if (IsEqualGUID(&subtype, &MFAudioFormat_PCM) ||
3037             IsEqualGUID(&subtype, &MFAudioFormat_Float))
3038     {
3039         mediatype_set_uint32(mediatype, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3040     }
3041
3042     if (format->cbSize && format->wFormatTag != WAVE_FORMAT_EXTENSIBLE)
3043         mediatype_set_blob(mediatype, &MF_MT_USER_DATA, (const UINT8 *)(format + 1), format->cbSize, &hr);
3044
3045     return hr;
3046 }
3047
3048 /***********************************************************************
3049  *      MFCreateVideoMediaTypeFromSubtype (mfplat.@)
3050  */
3051 HRESULT WINAPI MFCreateVideoMediaTypeFromSubtype(const GUID *subtype, IMFVideoMediaType **media_type)
3052 {
3053     struct media_type *object;
3054     HRESULT hr;
3055
3056     TRACE("%s, %p.\n", debugstr_guid(subtype), media_type);
3057
3058     if (!media_type)
3059         return E_INVALIDARG;
3060
3061     if (FAILED(hr = create_media_type(&object)))
3062         return hr;
3063
3064     IMFMediaType_SetGUID(&object->IMFMediaType_iface, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
3065     IMFMediaType_SetGUID(&object->IMFMediaType_iface, &MF_MT_SUBTYPE, subtype);
3066
3067     *media_type = &object->IMFVideoMediaType_iface;
3068
3069     return S_OK;
3070 }
3071
3072 /***********************************************************************
3073  *      MFCreateAudioMediaType (mfplat.@)
3074  */
3075 HRESULT WINAPI MFCreateAudioMediaType(const WAVEFORMATEX *format, IMFAudioMediaType **media_type)
3076 {
3077     struct media_type *object;
3078     HRESULT hr;
3079
3080     TRACE("%p, %p.\n", format, media_type);
3081
3082     if (!media_type)
3083         return E_INVALIDARG;
3084
3085     if (FAILED(hr = create_media_type(&object)))
3086         return hr;
3087
3088     if (FAILED(hr = MFInitMediaTypeFromWaveFormatEx(&object->IMFMediaType_iface, format, sizeof(*format) + format->cbSize)))
3089     {
3090         IMFMediaType_Release(&object->IMFMediaType_iface);
3091         return hr;
3092     }
3093
3094     *media_type = &object->IMFAudioMediaType_iface;
3095
3096     return S_OK;
3097 }
3098
3099 static void media_type_get_ratio(IMFMediaType *media_type, const GUID *attr, DWORD *numerator,
3100         DWORD *denominator)
3101 {
3102     UINT64 value;
3103
3104     if (SUCCEEDED(IMFMediaType_GetUINT64(media_type, attr, &value)))
3105     {
3106         *numerator = value >> 32;
3107         *denominator = value;
3108     }
3109 }
3110
3111 /***********************************************************************
3112  *      MFCreateMFVideoFormatFromMFMediaType (mfplat.@)
3113  */
3114 HRESULT WINAPI MFCreateMFVideoFormatFromMFMediaType(IMFMediaType *media_type, MFVIDEOFORMAT **video_format, UINT32 *size)
3115 {
3116     UINT32 flags, palette_size = 0, value;
3117     MFVIDEOFORMAT *format;
3118     INT32 stride;
3119     GUID guid;
3120
3121     TRACE("%p, %p, %p.\n", media_type, video_format, size);
3122
3123     *size = sizeof(*format);
3124
3125     if (SUCCEEDED(IMFMediaType_GetBlobSize(media_type, &MF_MT_PALETTE, &palette_size)))
3126         *size += palette_size;
3127
3128     if (!(format = CoTaskMemAlloc(*size)))
3129         return E_OUTOFMEMORY;
3130
3131     *video_format = format;
3132
3133     memset(format, 0, sizeof(*format));
3134     format->dwSize = *size;
3135
3136     if (SUCCEEDED(IMFMediaType_GetGUID(media_type, &MF_MT_SUBTYPE, &guid)))
3137     {
3138         memcpy(&format->guidFormat, &guid, sizeof(guid));
3139         format->surfaceInfo.Format = guid.Data1;
3140     }
3141
3142     media_type_get_ratio(media_type, &MF_MT_FRAME_SIZE, &format->videoInfo.dwWidth, &format->videoInfo.dwHeight);
3143     media_type_get_ratio(media_type, &MF_MT_PIXEL_ASPECT_RATIO, &format->videoInfo.PixelAspectRatio.Numerator,
3144             &format->videoInfo.PixelAspectRatio.Denominator);
3145     media_type_get_ratio(media_type, &MF_MT_FRAME_RATE, &format->videoInfo.FramesPerSecond.Numerator,
3146             &format->videoInfo.FramesPerSecond.Denominator);
3147
3148     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_CHROMA_SITING, &format->videoInfo.SourceChromaSubsampling);
3149     IMFMediaType_GetUINT32(media_type, &MF_MT_INTERLACE_MODE, &format->videoInfo.InterlaceMode);
3150     IMFMediaType_GetUINT32(media_type, &MF_MT_TRANSFER_FUNCTION, &format->videoInfo.TransferFunction);
3151     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_PRIMARIES, &format->videoInfo.ColorPrimaries);
3152     IMFMediaType_GetUINT32(media_type, &MF_MT_YUV_MATRIX, &format->videoInfo.TransferMatrix);
3153     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_LIGHTING, &format->videoInfo.SourceLighting);
3154     IMFMediaType_GetUINT32(media_type, &MF_MT_VIDEO_NOMINAL_RANGE, &format->videoInfo.NominalRange);
3155     IMFMediaType_GetBlob(media_type, &MF_MT_GEOMETRIC_APERTURE, (UINT8 *)&format->videoInfo.GeometricAperture,
3156            sizeof(format->videoInfo.GeometricAperture), NULL);
3157     IMFMediaType_GetBlob(media_type, &MF_MT_MINIMUM_DISPLAY_APERTURE, (UINT8 *)&format->videoInfo.MinimumDisplayAperture,
3158            sizeof(format->videoInfo.MinimumDisplayAperture), NULL);
3159
3160     /* Video flags. */
3161     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_PAD_CONTROL_FLAGS, &flags)))
3162         format->videoInfo.VideoFlags |= flags;
3163     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_SOURCE_CONTENT_HINT, &flags)))
3164         format->videoInfo.VideoFlags |= flags;
3165     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_DRM_FLAGS, &flags)))
3166         format->videoInfo.VideoFlags |= flags;
3167     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_PAN_SCAN_ENABLED, &flags)) && !!flags)
3168     {
3169         format->videoInfo.VideoFlags |= MFVideoFlag_PanScanEnabled;
3170         IMFMediaType_GetBlob(media_type, &MF_MT_PAN_SCAN_APERTURE, (UINT8 *)&format->videoInfo.PanScanAperture,
3171                sizeof(format->videoInfo.PanScanAperture), NULL);
3172     }
3173     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, (UINT32 *)&stride)) && stride < 0)
3174         format->videoInfo.VideoFlags |= MFVideoFlag_BottomUpLinearRep;
3175
3176     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AVG_BITRATE, &value)))
3177         format->compressedInfo.AvgBitrate = value;
3178     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AVG_BIT_ERROR_RATE, &value)))
3179         format->compressedInfo.AvgBitErrorRate = value;
3180     if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_MAX_KEYFRAME_SPACING, &value)))
3181         format->compressedInfo.MaxKeyFrameSpacing = value;
3182
3183     /* Palette. */
3184     if (palette_size)
3185     {
3186         format->surfaceInfo.PaletteEntries = palette_size / sizeof(*format->surfaceInfo.Palette);
3187         IMFMediaType_GetBlob(media_type, &MF_MT_PALETTE, (UINT8 *)format->surfaceInfo.Palette, palette_size, NULL);
3188     }
3189
3190     return S_OK;
3191 }
3192
3193 /***********************************************************************
3194  *      MFConvertColorInfoToDXVA (mfplat.@)
3195  */
3196 HRESULT WINAPI MFConvertColorInfoToDXVA(DWORD *dxva_info, const MFVIDEOFORMAT *format)
3197 {
3198     struct
3199     {
3200         UINT SampleFormat           : 8;
3201         UINT VideoChromaSubsampling : 4;
3202         UINT NominalRange           : 3;
3203         UINT VideoTransferMatrix    : 3;
3204         UINT VideoLighting          : 4;
3205         UINT VideoPrimaries         : 5;
3206         UINT VideoTransferFunction  : 5;
3207     } *dxva_format = (void *)dxva_info;
3208
3209     TRACE("%p, %p.\n", dxva_info, format);
3210
3211     if (format->videoInfo.InterlaceMode == MFVideoInterlace_MixedInterlaceOrProgressive)
3212         dxva_format->SampleFormat = DXVA2_SampleFieldInterleavedEvenFirst;
3213     else
3214         dxva_format->SampleFormat = format->videoInfo.InterlaceMode;
3215
3216     dxva_format->VideoChromaSubsampling = format->videoInfo.SourceChromaSubsampling;
3217     dxva_format->NominalRange = format->videoInfo.NominalRange;
3218     dxva_format->VideoTransferMatrix = format->videoInfo.TransferMatrix;
3219     dxva_format->VideoLighting = format->videoInfo.SourceLighting;
3220     dxva_format->VideoPrimaries = format->videoInfo.ColorPrimaries;
3221     dxva_format->VideoTransferFunction = format->videoInfo.TransferFunction;
3222
3223     return S_OK;
3224 }
3225
3226 struct frame_rate
3227 {
3228     UINT64 key;
3229     UINT64 value;
3230 };
3231
3232 static int __cdecl frame_rate_compare(const void *a, const void *b)
3233 {
3234     const UINT64 *key = a;
3235     const struct frame_rate *known_rate = b;
3236     return *key == known_rate->key ? 0 : ( *key < known_rate->key ? 1 : -1 );
3237 }
3238
3239 /***********************************************************************
3240  *      MFFrameRateToAverageTimePerFrame (mfplat.@)
3241  */
3242 HRESULT WINAPI MFFrameRateToAverageTimePerFrame(UINT32 numerator, UINT32 denominator, UINT64 *avgframetime)
3243 {
3244     static const struct frame_rate known_rates[] =
3245     {
3246 #define KNOWN_RATE(n,d,ft) { ((UINT64)n << 32) | d, ft }
3247         KNOWN_RATE(60000, 1001, 166833),
3248         KNOWN_RATE(30000, 1001, 333667),
3249         KNOWN_RATE(24000, 1001, 417188),
3250         KNOWN_RATE(60,       1, 166667),
3251         KNOWN_RATE(50,       1, 200000),
3252         KNOWN_RATE(30,       1, 333333),
3253         KNOWN_RATE(25,       1, 400000),
3254         KNOWN_RATE(24,       1, 416667),
3255 #undef KNOWN_RATE
3256     };
3257     UINT64 rate = ((UINT64)numerator << 32) | denominator;
3258     const struct frame_rate *entry;
3259
3260     TRACE("%u, %u, %p.\n", numerator, denominator, avgframetime);
3261
3262     if ((entry = bsearch(&rate, known_rates, ARRAY_SIZE(known_rates), sizeof(*known_rates),
3263             frame_rate_compare)))
3264     {
3265         *avgframetime = entry->value;
3266     }
3267     else
3268         *avgframetime = numerator ? denominator * (UINT64)10000000 / numerator : 0;
3269
3270     return S_OK;
3271 }
3272
3273 static unsigned int get_gcd(unsigned int a, unsigned int b)
3274 {
3275     unsigned int m;
3276
3277     while (b)
3278     {
3279         m = a % b;
3280         a = b;
3281         b = m;
3282     }
3283
3284     return a;
3285 }
3286
3287 /***********************************************************************
3288  *      MFAverageTimePerFrameToFrameRate (mfplat.@)
3289  */
3290 HRESULT WINAPI MFAverageTimePerFrameToFrameRate(UINT64 avgtime, UINT32 *numerator, UINT32 *denominator)
3291 {
3292     static const struct frame_rate known_rates[] =
3293     {
3294 #define KNOWN_RATE(ft,n,d) { ft, ((UINT64)n << 32) | d }
3295         KNOWN_RATE(417188, 24000, 1001),
3296         KNOWN_RATE(416667,    24,    1),
3297         KNOWN_RATE(400000,    25,    1),
3298         KNOWN_RATE(333667, 30000, 1001),
3299         KNOWN_RATE(333333,    30,    1),
3300         KNOWN_RATE(200000,    50,    1),
3301         KNOWN_RATE(166833, 60000, 1001),
3302         KNOWN_RATE(166667,    60,    1),
3303 #undef KNOWN_RATE
3304     };
3305     const struct frame_rate *entry;
3306     unsigned int gcd;
3307
3308     TRACE("%s, %p, %p.\n", wine_dbgstr_longlong(avgtime), numerator, denominator);
3309
3310     if ((entry = bsearch(&avgtime, known_rates, ARRAY_SIZE(known_rates), sizeof(*known_rates),
3311             frame_rate_compare)))
3312     {
3313         *numerator = entry->value >> 32;
3314         *denominator = entry->value;
3315     }
3316     else if (avgtime)
3317     {
3318         if (avgtime > 100000000) avgtime = 100000000;
3319         gcd = get_gcd(10000000, avgtime);
3320         *numerator = 10000000 / gcd;
3321         *denominator = avgtime / gcd;
3322     }
3323     else
3324     {
3325         *numerator = *denominator = 0;
3326     }
3327
3328     return S_OK;
3329 }
3330
3331 /***********************************************************************
3332  *      MFMapDXGIFormatToDX9Format (mfplat.@)
3333  */
3334 DWORD WINAPI MFMapDXGIFormatToDX9Format(DXGI_FORMAT dxgi_format)
3335 {
3336     switch (dxgi_format)
3337     {
3338         case DXGI_FORMAT_R32G32B32A32_FLOAT:
3339             return D3DFMT_A32B32G32R32F;
3340         case DXGI_FORMAT_R16G16B16A16_FLOAT:
3341             return D3DFMT_A16B16G16R16F;
3342         case DXGI_FORMAT_R16G16B16A16_UNORM:
3343             return D3DFMT_A16B16G16R16;
3344         case DXGI_FORMAT_R16G16B16A16_SNORM:
3345             return D3DFMT_Q16W16V16U16;
3346         case DXGI_FORMAT_R32G32_FLOAT:
3347             return D3DFMT_G32R32F;
3348         case DXGI_FORMAT_R10G10B10A2_UNORM:
3349             return D3DFMT_A2B10G10R10;
3350         case DXGI_FORMAT_R8G8B8A8_SNORM:
3351             return D3DFMT_Q8W8V8U8;
3352         case DXGI_FORMAT_R16G16_FLOAT:
3353             return D3DFMT_G16R16F;
3354         case DXGI_FORMAT_R16G16_UNORM:
3355             return D3DFMT_G16R16;
3356         case DXGI_FORMAT_R16G16_SNORM:
3357             return D3DFMT_V16U16;
3358         case DXGI_FORMAT_D32_FLOAT:
3359             return D3DFMT_D32F_LOCKABLE;
3360         case DXGI_FORMAT_R32_FLOAT:
3361             return D3DFMT_R32F;
3362         case DXGI_FORMAT_D24_UNORM_S8_UINT:
3363             return D3DFMT_D24S8;
3364         case DXGI_FORMAT_R8G8_SNORM:
3365             return D3DFMT_V8U8;
3366         case DXGI_FORMAT_R16_FLOAT:
3367             return D3DFMT_R16F;
3368         case DXGI_FORMAT_D16_UNORM:
3369             return D3DFMT_D16_LOCKABLE;
3370         case DXGI_FORMAT_R16_UNORM:
3371             return D3DFMT_L16;
3372         case DXGI_FORMAT_R8_UNORM:
3373             return D3DFMT_L8;
3374         case DXGI_FORMAT_A8_UNORM:
3375             return D3DFMT_A8;
3376         case DXGI_FORMAT_BC1_UNORM:
3377         case DXGI_FORMAT_BC1_UNORM_SRGB:
3378             return D3DFMT_DXT1;
3379         case DXGI_FORMAT_BC2_UNORM:
3380         case DXGI_FORMAT_BC2_UNORM_SRGB:
3381             return D3DFMT_DXT2;
3382         case DXGI_FORMAT_BC3_UNORM:
3383         case DXGI_FORMAT_BC3_UNORM_SRGB:
3384             return D3DFMT_DXT4;
3385         case DXGI_FORMAT_R8G8B8A8_UNORM:
3386             return D3DFMT_A8B8G8R8;
3387         case DXGI_FORMAT_B8G8R8A8_UNORM:
3388         case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
3389         case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
3390             return D3DFMT_A8R8G8B8;
3391         case DXGI_FORMAT_B8G8R8X8_UNORM:
3392         case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
3393             return D3DFMT_X8R8G8B8;
3394         case DXGI_FORMAT_AYUV:
3395             return MAKEFOURCC('A','Y','U','V');
3396         case DXGI_FORMAT_Y410:
3397             return MAKEFOURCC('Y','4','1','0');
3398         case DXGI_FORMAT_Y416:
3399             return MAKEFOURCC('Y','4','1','6');
3400         case DXGI_FORMAT_NV12:
3401             return MAKEFOURCC('N','V','1','2');
3402         case DXGI_FORMAT_P010:
3403             return MAKEFOURCC('P','0','1','0');
3404         case DXGI_FORMAT_P016:
3405             return MAKEFOURCC('P','0','1','6');
3406         case DXGI_FORMAT_420_OPAQUE:
3407             return MAKEFOURCC('4','2','0','O');
3408         case DXGI_FORMAT_YUY2:
3409             return D3DFMT_YUY2;
3410         case DXGI_FORMAT_Y210:
3411             return MAKEFOURCC('Y','2','1','0');
3412         case DXGI_FORMAT_Y216:
3413             return MAKEFOURCC('Y','2','1','6');
3414         case DXGI_FORMAT_NV11:
3415             return MAKEFOURCC('N','V','1','1');
3416         case DXGI_FORMAT_AI44:
3417             return MAKEFOURCC('A','I','4','4');
3418         case DXGI_FORMAT_IA44:
3419             return MAKEFOURCC('I','A','4','4');
3420         case DXGI_FORMAT_P8:
3421             return D3DFMT_P8;
3422         case DXGI_FORMAT_A8P8:
3423             return D3DFMT_A8P8;
3424         default:
3425             return 0;
3426     }
3427 }
3428
3429 /***********************************************************************
3430  *      MFMapDX9FormatToDXGIFormat (mfplat.@)
3431  */
3432 DXGI_FORMAT WINAPI MFMapDX9FormatToDXGIFormat(DWORD format)
3433 {
3434     switch (format)
3435     {
3436         case D3DFMT_A32B32G32R32F:
3437             return DXGI_FORMAT_R32G32B32A32_FLOAT;
3438         case D3DFMT_A16B16G16R16F:
3439             return DXGI_FORMAT_R16G16B16A16_FLOAT;
3440         case D3DFMT_A16B16G16R16:
3441             return DXGI_FORMAT_R16G16B16A16_UNORM;
3442         case D3DFMT_Q16W16V16U16:
3443             return DXGI_FORMAT_R16G16B16A16_SNORM;
3444         case D3DFMT_G32R32F:
3445             return DXGI_FORMAT_R32G32_FLOAT;
3446         case D3DFMT_A2B10G10R10:
3447             return DXGI_FORMAT_R10G10B10A2_UNORM;
3448         case D3DFMT_Q8W8V8U8:
3449             return DXGI_FORMAT_R8G8B8A8_SNORM;
3450         case D3DFMT_G16R16F:
3451             return DXGI_FORMAT_R16G16_FLOAT;
3452         case D3DFMT_G16R16:
3453             return DXGI_FORMAT_R16G16_UNORM;
3454         case D3DFMT_V16U16:
3455             return DXGI_FORMAT_R16G16_SNORM;
3456         case D3DFMT_D32F_LOCKABLE:
3457             return DXGI_FORMAT_D32_FLOAT;
3458         case D3DFMT_R32F:
3459             return DXGI_FORMAT_R32_FLOAT;
3460         case D3DFMT_D24S8:
3461             return DXGI_FORMAT_D24_UNORM_S8_UINT;
3462         case D3DFMT_V8U8:
3463             return DXGI_FORMAT_R8G8_SNORM;
3464         case D3DFMT_R16F:
3465             return DXGI_FORMAT_R16_FLOAT;
3466         case D3DFMT_L16:
3467             return DXGI_FORMAT_R16_UNORM;
3468         case D3DFMT_L8:
3469             return DXGI_FORMAT_R8_UNORM;
3470         case D3DFMT_A8:
3471             return DXGI_FORMAT_A8_UNORM;
3472         case D3DFMT_DXT1:
3473             return DXGI_FORMAT_BC1_UNORM;
3474         case D3DFMT_DXT2:
3475             return DXGI_FORMAT_BC2_UNORM;
3476         case D3DFMT_DXT4:
3477             return DXGI_FORMAT_BC3_UNORM;
3478         case D3DFMT_A8R8G8B8:
3479             return DXGI_FORMAT_B8G8R8A8_UNORM;
3480         case D3DFMT_X8R8G8B8:
3481             return DXGI_FORMAT_B8G8R8X8_UNORM;
3482         case MAKEFOURCC('A','Y','U','V'):
3483             return DXGI_FORMAT_AYUV;
3484         case MAKEFOURCC('Y','4','1','0'):
3485             return DXGI_FORMAT_Y410;
3486         case MAKEFOURCC('Y','4','1','6'):
3487             return DXGI_FORMAT_Y416;
3488         case MAKEFOURCC('N','V','1','2'):
3489             return DXGI_FORMAT_NV12;
3490         case MAKEFOURCC('P','0','1','0'):
3491             return DXGI_FORMAT_P010;
3492         case MAKEFOURCC('P','0','1','6'):
3493             return DXGI_FORMAT_P016;
3494         case MAKEFOURCC('4','2','0','O'):
3495             return DXGI_FORMAT_420_OPAQUE;
3496         case D3DFMT_YUY2:
3497             return DXGI_FORMAT_YUY2;
3498         case MAKEFOURCC('Y','2','1','0'):
3499             return DXGI_FORMAT_Y210;
3500         case MAKEFOURCC('Y','2','1','6'):
3501             return DXGI_FORMAT_Y216;
3502         case MAKEFOURCC('N','V','1','1'):
3503             return DXGI_FORMAT_NV11;
3504         case MAKEFOURCC('A','I','4','4'):
3505             return DXGI_FORMAT_AI44;
3506         case MAKEFOURCC('I','A','4','4'):
3507             return DXGI_FORMAT_IA44;
3508         case D3DFMT_P8:
3509             return DXGI_FORMAT_P8;
3510         case D3DFMT_A8P8:
3511             return DXGI_FORMAT_A8P8;
3512         default:
3513             return DXGI_FORMAT_UNKNOWN;
3514     }
3515 }
3516
3517 /***********************************************************************
3518  *      MFInitVideoFormat_RGB (mfplat.@)
3519  */
3520 HRESULT WINAPI MFInitVideoFormat_RGB(MFVIDEOFORMAT *format, DWORD width, DWORD height, DWORD d3dformat)
3521 {
3522     unsigned int transfer_function;
3523
3524     TRACE("%p, %lu, %lu, %#lx.\n", format, width, height, d3dformat);
3525
3526     if (!format)
3527         return E_INVALIDARG;
3528
3529     if (!d3dformat) d3dformat = D3DFMT_X8R8G8B8;
3530
3531     switch (d3dformat)
3532     {
3533         case D3DFMT_X8R8G8B8:
3534         case D3DFMT_R8G8B8:
3535         case D3DFMT_A8R8G8B8:
3536         case D3DFMT_R5G6B5:
3537         case D3DFMT_X1R5G5B5:
3538         case D3DFMT_A2B10G10R10:
3539         case D3DFMT_P8:
3540             transfer_function = MFVideoTransFunc_sRGB;
3541             break;
3542         default:
3543             transfer_function = MFVideoTransFunc_10;
3544     }
3545
3546     memset(format, 0, sizeof(*format));
3547     format->dwSize = sizeof(*format);
3548     format->videoInfo.dwWidth = width;
3549     format->videoInfo.dwHeight = height;
3550     format->videoInfo.PixelAspectRatio.Numerator = 1;
3551     format->videoInfo.PixelAspectRatio.Denominator = 1;
3552     format->videoInfo.InterlaceMode = MFVideoInterlace_Progressive;
3553     format->videoInfo.TransferFunction = transfer_function;
3554     format->videoInfo.ColorPrimaries = MFVideoPrimaries_BT709;
3555     format->videoInfo.SourceLighting = MFVideoLighting_office;
3556     format->videoInfo.FramesPerSecond.Numerator = 60;
3557     format->videoInfo.FramesPerSecond.Denominator = 1;
3558     format->videoInfo.NominalRange = MFNominalRange_Normal;
3559     format->videoInfo.GeometricAperture.Area.cx = width;
3560     format->videoInfo.GeometricAperture.Area.cy = height;
3561     format->videoInfo.MinimumDisplayAperture = format->videoInfo.GeometricAperture;
3562     memcpy(&format->guidFormat, &MFVideoFormat_Base, sizeof(format->guidFormat));
3563     format->guidFormat.Data1 = d3dformat;
3564     format->surfaceInfo.Format = d3dformat;
3565
3566     return S_OK;
3567 }
3568
3569 static HRESULT mf_get_stride_for_bitmap_info_header(DWORD fourcc, const BITMAPINFOHEADER *bih, LONG *stride)
3570 {
3571     HRESULT hr;
3572
3573     if (FAILED(hr = MFGetStrideForBitmapInfoHeader(fourcc, bih->biWidth, stride))) return hr;
3574     if (bih->biHeight < 0) *stride *= -1;
3575
3576     return hr;
3577 }
3578
3579 static const GUID * get_mf_subtype_for_am_subtype(const GUID *subtype)
3580 {
3581     static const GUID null;
3582
3583     if (IsEqualGUID(subtype, &MEDIASUBTYPE_RGB32))
3584         return &MFVideoFormat_RGB32;
3585     else
3586     {
3587         FIXME("Unknown subtype %s.\n", debugstr_guid(subtype));
3588         return &null;
3589     }
3590 }
3591
3592 /***********************************************************************
3593  *      MFCreateVideoMediaTypeFromVideoInfoHeader (mfplat.@)
3594  */
3595 HRESULT WINAPI MFCreateVideoMediaTypeFromVideoInfoHeader(const KS_VIDEOINFOHEADER *vih, DWORD size, DWORD pixel_aspect_ratio_x,
3596         DWORD pixel_aspect_ratio_y, MFVideoInterlaceMode interlace_mode, QWORD video_flags, const GUID *subtype,
3597         IMFVideoMediaType **ret)
3598 {
3599     FIXME("%p, %lu, %lu, %lu, %d, %I64x, %s, %p.\n", vih, size, pixel_aspect_ratio_x, pixel_aspect_ratio_y, interlace_mode,
3600             video_flags, debugstr_guid(subtype), ret);
3601
3602     return E_NOTIMPL;
3603 }
3604
3605 /***********************************************************************
3606  *      MFInitMediaTypeFromVideoInfoHeader (mfplat.@)
3607  */
3608 HRESULT WINAPI MFInitMediaTypeFromVideoInfoHeader(IMFMediaType *media_type, const VIDEOINFOHEADER *vih, UINT32 size,
3609         const GUID *subtype)
3610 {
3611     HRESULT hr = S_OK;
3612     DWORD height;
3613     LONG stride;
3614
3615     FIXME("%p, %p, %u, %s.\n", media_type, vih, size, debugstr_guid(subtype));
3616
3617     IMFMediaType_DeleteAllItems(media_type);
3618
3619     if (!subtype)
3620     {
3621         FIXME("Implicit subtype is not supported.\n");
3622         return E_NOTIMPL;
3623     }
3624
3625     height = abs(vih->bmiHeader.biHeight);
3626
3627     mediatype_set_guid(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video, &hr);
3628     mediatype_set_guid(media_type, &MF_MT_SUBTYPE, subtype, &hr);
3629     mediatype_set_uint64(media_type, &MF_MT_PIXEL_ASPECT_RATIO, 1, 1, &hr);
3630     mediatype_set_uint32(media_type, &MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive, &hr);
3631     mediatype_set_uint64(media_type, &MF_MT_FRAME_SIZE, vih->bmiHeader.biWidth, height, &hr);
3632
3633     if (SUCCEEDED(mf_get_stride_for_bitmap_info_header(subtype->Data1, &vih->bmiHeader, &stride)))
3634     {
3635         mediatype_set_uint32(media_type, &MF_MT_DEFAULT_STRIDE, stride, &hr);
3636         mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, abs(stride) * height, &hr);
3637         mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3638         mediatype_set_uint32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3639     }
3640
3641     return hr;
3642 }
3643
3644 /***********************************************************************
3645  *      MFInitMediaTypeFromAMMediaType (mfplat.@)
3646  */
3647 HRESULT WINAPI MFInitMediaTypeFromAMMediaType(IMFMediaType *media_type, const AM_MEDIA_TYPE *am_type)
3648 {
3649     HRESULT hr = S_OK;
3650
3651     TRACE("%p, %p.\n", media_type, am_type);
3652
3653     IMFMediaType_DeleteAllItems(media_type);
3654
3655     if (IsEqualGUID(&am_type->majortype, &MEDIATYPE_Video))
3656     {
3657         if (IsEqualGUID(&am_type->formattype, &FORMAT_VideoInfo))
3658         {
3659             const VIDEOINFOHEADER *vih = (const VIDEOINFOHEADER *)am_type->pbFormat;
3660             const GUID *subtype;
3661             DWORD height;
3662             LONG stride;
3663
3664             subtype = get_mf_subtype_for_am_subtype(&am_type->subtype);
3665             height = abs(vih->bmiHeader.biHeight);
3666
3667             mediatype_set_guid(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video, &hr);
3668             mediatype_set_guid(media_type, &MF_MT_SUBTYPE, subtype, &hr);
3669             mediatype_set_uint64(media_type, &MF_MT_PIXEL_ASPECT_RATIO, 1, 1, &hr);
3670             mediatype_set_uint32(media_type, &MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive, &hr);
3671             mediatype_set_uint64(media_type, &MF_MT_FRAME_SIZE, vih->bmiHeader.biWidth, height, &hr);
3672             mediatype_set_uint32(media_type, &MF_MT_ALL_SAMPLES_INDEPENDENT, 1, &hr);
3673
3674             if (SUCCEEDED(mf_get_stride_for_bitmap_info_header(subtype->Data1, &vih->bmiHeader, &stride)))
3675             {
3676                 mediatype_set_uint32(media_type, &MF_MT_DEFAULT_STRIDE, stride, &hr);
3677                 mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, abs(stride) * height, &hr);
3678                 mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3679             }
3680             else
3681             {
3682                 if (am_type->bFixedSizeSamples)
3683                     mediatype_set_uint32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1, &hr);
3684                 if (am_type->lSampleSize)
3685                     mediatype_set_uint32(media_type, &MF_MT_SAMPLE_SIZE, am_type->lSampleSize, &hr);
3686             }
3687
3688             return hr;
3689         }
3690         else
3691         {
3692             FIXME("Unsupported format type %s.\n", debugstr_guid(&am_type->formattype));
3693         }
3694     }
3695     else
3696         FIXME("Unsupported major type %s.\n", debugstr_guid(&am_type->majortype));
3697
3698     return E_NOTIMPL;
3699 }