?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winevulkan: Update to VK spec version 1.2.188.
[wine.git] / dlls / mfplat / main.c
blob7fd713261fcfb52423041a0b53dc90128ce95f08
1 /*
2 * Copyright 2014 Austin English
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 #include <stdarg.h>
20 #include <string.h>
21 #include <math.h>
22 #include <limits.h>
23
24 #define COBJMACROS
25 #define NONAMELESSUNION
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "winreg.h"
31
32 #include "initguid.h"
33 #include "rtworkq.h"
34 #include "ole2.h"
35 #include "propsys.h"
36 #include "d3d11.h"
37 #include "uuids.h"
38
39 #include "wine/debug.h"
40 #include "wine/list.h"
41
42 #include "mfplat_private.h"
43 #include "mfreadwrite.h"
44 #include "mfmediaengine.h"
45 #include "propvarutil.h"
46 #include "strsafe.h"
47 #undef INITGUID
48 #include "evr.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
51
52 struct local_handler
53 {
54 struct list entry;
55 union
56 {
57 WCHAR *scheme;
58 struct
59 {
60 WCHAR *extension;
61 WCHAR *mime;
62 } bytestream;
63 } u;
64 IMFActivate *activate;
65 };
66
67 static CRITICAL_SECTION local_handlers_section = { NULL, -1, 0, 0, 0, 0 };
68
69 static struct list local_scheme_handlers = LIST_INIT(local_scheme_handlers);
70 static struct list local_bytestream_handlers = LIST_INIT(local_bytestream_handlers);
71
72 struct mft_registration
73 {
74 struct list entry;
75 IClassFactory *factory;
76 CLSID clsid;
77 GUID category;
78 WCHAR *name;
79 DWORD flags;
80 MFT_REGISTER_TYPE_INFO *input_types;
81 UINT32 input_types_count;
82 MFT_REGISTER_TYPE_INFO *output_types;
83 UINT32 output_types_count;
84 BOOL local;
85 };
86
87 static CRITICAL_SECTION local_mfts_section = { NULL, -1, 0, 0, 0, 0 };
88
89 static struct list local_mfts = LIST_INIT(local_mfts);
90
91 struct transform_activate
92 {
93 struct attributes attributes;
94 IMFActivate IMFActivate_iface;
95 IClassFactory *factory;
96 IMFTransform *transform;
97 };
98
99 struct system_clock
100 {
101 IMFClock IMFClock_iface;
102 LONG refcount;
103 };
104
105 struct system_time_source
106 {
107 IMFPresentationTimeSource IMFPresentationTimeSource_iface;
108 IMFClockStateSink IMFClockStateSink_iface;
109 LONG refcount;
110 MFCLOCK_STATE state;
111 IMFClock *clock;
112 LONGLONG start_offset;
113 float rate;
114 int i_rate;
115 CRITICAL_SECTION cs;
116 };
117
118 static void system_time_source_apply_rate(const struct system_time_source *source, LONGLONG *value)
119 {
120 if (source->i_rate)
121 *value *= source->i_rate;
122 else
123 *value *= source->rate;
124 }
125
126 static struct system_time_source *impl_from_IMFPresentationTimeSource(IMFPresentationTimeSource *iface)
127 {
128 return CONTAINING_RECORD(iface, struct system_time_source, IMFPresentationTimeSource_iface);
129 }
130
131 static struct system_time_source *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
132 {
133 return CONTAINING_RECORD(iface, struct system_time_source, IMFClockStateSink_iface);
134 }
135
136 static struct system_clock *impl_from_IMFClock(IMFClock *iface)
137 {
138 return CONTAINING_RECORD(iface, struct system_clock, IMFClock_iface);
139 }
140
141 static struct transform_activate *impl_from_IMFActivate(IMFActivate *iface)
142 {
143 return CONTAINING_RECORD(iface, struct transform_activate, IMFActivate_iface);
144 }
145
146 static HRESULT WINAPI transform_activate_QueryInterface(IMFActivate *iface, REFIID riid, void **out)
147 {
148 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
149
150 if (IsEqualIID(riid, &IID_IMFActivate) ||
151 IsEqualIID(riid, &IID_IMFAttributes) ||
152 IsEqualIID(riid, &IID_IUnknown))
153 {
154 *out = iface;
155 IMFActivate_AddRef(iface);
156 return S_OK;
157 }
158
159 WARN("Unsupported %s.\n", debugstr_guid(riid));
160 *out = NULL;
161 return E_NOINTERFACE;
162 }
163
164 static ULONG WINAPI transform_activate_AddRef(IMFActivate *iface)
165 {
166 struct transform_activate *activate = impl_from_IMFActivate(iface);
167 ULONG refcount = InterlockedIncrement(&activate->attributes.ref);
168
169 TRACE("%p, refcount %u.\n", iface, refcount);
170
171 return refcount;
172 }
173
174 static ULONG WINAPI transform_activate_Release(IMFActivate *iface)
175 {
176 struct transform_activate *activate = impl_from_IMFActivate(iface);
177 ULONG refcount = InterlockedDecrement(&activate->attributes.ref);
178
179 TRACE("%p, refcount %u.\n", iface, refcount);
180
181 if (!refcount)
182 {
183 clear_attributes_object(&activate->attributes);
184 if (activate->factory)
185 IClassFactory_Release(activate->factory);
186 if (activate->transform)
187 IMFTransform_Release(activate->transform);
188 free(activate);
189 }
190
191 return refcount;
192 }
193
194 static HRESULT WINAPI transform_activate_GetItem(IMFActivate *iface, REFGUID key, PROPVARIANT *value)
195 {
196 struct transform_activate *activate = impl_from_IMFActivate(iface);
197
198 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
199
200 return attributes_GetItem(&activate->attributes, key, value);
201 }
202
203 static HRESULT WINAPI transform_activate_GetItemType(IMFActivate *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
204 {
205 struct transform_activate *activate = impl_from_IMFActivate(iface);
206
207 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
208
209 return attributes_GetItemType(&activate->attributes, key, type);
210 }
211
212 static HRESULT WINAPI transform_activate_CompareItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value,
213 BOOL *result)
214 {
215 struct transform_activate *activate = impl_from_IMFActivate(iface);
216
217 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
218
219 return attributes_CompareItem(&activate->attributes, key, value, result);
220 }
221
222 static HRESULT WINAPI transform_activate_Compare(IMFActivate *iface, IMFAttributes *theirs,
223 MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
224 {
225 struct transform_activate *activate = impl_from_IMFActivate(iface);
226
227 TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
228
229 return attributes_Compare(&activate->attributes, theirs, match_type, ret);
230 }
231
232 static HRESULT WINAPI transform_activate_GetUINT32(IMFActivate *iface, REFGUID key, UINT32 *value)
233 {
234 struct transform_activate *activate = impl_from_IMFActivate(iface);
235
236 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
237
238 return attributes_GetUINT32(&activate->attributes, key, value);
239 }
240
241 static HRESULT WINAPI transform_activate_GetUINT64(IMFActivate *iface, REFGUID key, UINT64 *value)
242 {
243 struct transform_activate *activate = impl_from_IMFActivate(iface);
244
245 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
246
247 return attributes_GetUINT64(&activate->attributes, key, value);
248 }
249
250 static HRESULT WINAPI transform_activate_GetDouble(IMFActivate *iface, REFGUID key, double *value)
251 {
252 struct transform_activate *activate = impl_from_IMFActivate(iface);
253
254 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
255
256 return attributes_GetDouble(&activate->attributes, key, value);
257 }
258
259 static HRESULT WINAPI transform_activate_GetGUID(IMFActivate *iface, REFGUID key, GUID *value)
260 {
261 struct transform_activate *activate = impl_from_IMFActivate(iface);
262
263 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
264
265 return attributes_GetGUID(&activate->attributes, key, value);
266 }
267
268 static HRESULT WINAPI transform_activate_GetStringLength(IMFActivate *iface, REFGUID key, UINT32 *length)
269 {
270 struct transform_activate *activate = impl_from_IMFActivate(iface);
271
272 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
273
274 return attributes_GetStringLength(&activate->attributes, key, length);
275 }
276
277 static HRESULT WINAPI transform_activate_GetString(IMFActivate *iface, REFGUID key, WCHAR *value,
278 UINT32 size, UINT32 *length)
279 {
280 struct transform_activate *activate = impl_from_IMFActivate(iface);
281
282 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
283
284 return attributes_GetString(&activate->attributes, key, value, size, length);
285 }
286
287 static HRESULT WINAPI transform_activate_GetAllocatedString(IMFActivate *iface, REFGUID key, WCHAR **value,
288 UINT32 *length)
289 {
290 struct transform_activate *activate = impl_from_IMFActivate(iface);
291
292 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
293
294 return attributes_GetAllocatedString(&activate->attributes, key, value, length);
295 }
296
297 static HRESULT WINAPI transform_activate_GetBlobSize(IMFActivate *iface, REFGUID key, UINT32 *size)
298 {
299 struct transform_activate *activate = impl_from_IMFActivate(iface);
300
301 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
302
303 return attributes_GetBlobSize(&activate->attributes, key, size);
304 }
305
306 static HRESULT WINAPI transform_activate_GetBlob(IMFActivate *iface, REFGUID key, UINT8 *buf, UINT32 bufsize,
307 UINT32 *blobsize)
308 {
309 struct transform_activate *activate = impl_from_IMFActivate(iface);
310
311 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
312
313 return attributes_GetBlob(&activate->attributes, key, buf, bufsize, blobsize);
314 }
315
316 static HRESULT WINAPI transform_activate_GetAllocatedBlob(IMFActivate *iface, REFGUID key, UINT8 **buf, UINT32 *size)
317 {
318 struct transform_activate *activate = impl_from_IMFActivate(iface);
319
320 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
321
322 return attributes_GetAllocatedBlob(&activate->attributes, key, buf, size);
323 }
324
325 static HRESULT WINAPI transform_activate_GetUnknown(IMFActivate *iface, REFGUID key, REFIID riid, void **out)
326 {
327 struct transform_activate *activate = impl_from_IMFActivate(iface);
328
329 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
330
331 return attributes_GetUnknown(&activate->attributes, key, riid, out);
332 }
333
334 static HRESULT WINAPI transform_activate_SetItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value)
335 {
336 struct transform_activate *activate = impl_from_IMFActivate(iface);
337
338 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
339
340 return attributes_SetItem(&activate->attributes, key, value);
341 }
342
343 static HRESULT WINAPI transform_activate_DeleteItem(IMFActivate *iface, REFGUID key)
344 {
345 struct transform_activate *activate = impl_from_IMFActivate(iface);
346
347 TRACE("%p, %s.\n", iface, debugstr_attr(key));
348
349 return attributes_DeleteItem(&activate->attributes, key);
350 }
351
352 static HRESULT WINAPI transform_activate_DeleteAllItems(IMFActivate *iface)
353 {
354 struct transform_activate *activate = impl_from_IMFActivate(iface);
355
356 TRACE("%p.\n", iface);
357
358 return attributes_DeleteAllItems(&activate->attributes);
359 }
360
361 static HRESULT WINAPI transform_activate_SetUINT32(IMFActivate *iface, REFGUID key, UINT32 value)
362 {
363 struct transform_activate *activate = impl_from_IMFActivate(iface);
364
365 TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
366
367 return attributes_SetUINT32(&activate->attributes, key, value);
368 }
369
370 static HRESULT WINAPI transform_activate_SetUINT64(IMFActivate *iface, REFGUID key, UINT64 value)
371 {
372 struct transform_activate *activate = impl_from_IMFActivate(iface);
373
374 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
375
376 return attributes_SetUINT64(&activate->attributes, key, value);
377 }
378
379 static HRESULT WINAPI transform_activate_SetDouble(IMFActivate *iface, REFGUID key, double value)
380 {
381 struct transform_activate *activate = impl_from_IMFActivate(iface);
382
383 TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
384
385 return attributes_SetDouble(&activate->attributes, key, value);
386 }
387
388 static HRESULT WINAPI transform_activate_SetGUID(IMFActivate *iface, REFGUID key, REFGUID value)
389 {
390 struct transform_activate *activate = impl_from_IMFActivate(iface);
391
392 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
393
394 return attributes_SetGUID(&activate->attributes, key, value);
395 }
396
397 static HRESULT WINAPI transform_activate_SetString(IMFActivate *iface, REFGUID key, const WCHAR *value)
398 {
399 struct transform_activate *activate = impl_from_IMFActivate(iface);
400
401 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
402
403 return attributes_SetString(&activate->attributes, key, value);
404 }
405
406 static HRESULT WINAPI transform_activate_SetBlob(IMFActivate *iface, REFGUID key, const UINT8 *buf, UINT32 size)
407 {
408 struct transform_activate *activate = impl_from_IMFActivate(iface);
409
410 TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
411
412 return attributes_SetBlob(&activate->attributes, key, buf, size);
413 }
414
415 static HRESULT WINAPI transform_activate_SetUnknown(IMFActivate *iface, REFGUID key, IUnknown *unknown)
416 {
417 struct transform_activate *activate = impl_from_IMFActivate(iface);
418
419 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
420
421 return attributes_SetUnknown(&activate->attributes, key, unknown);
422 }
423
424 static HRESULT WINAPI transform_activate_LockStore(IMFActivate *iface)
425 {
426 struct transform_activate *activate = impl_from_IMFActivate(iface);
427
428 TRACE("%p.\n", iface);
429
430 return attributes_LockStore(&activate->attributes);
431 }
432
433 static HRESULT WINAPI transform_activate_UnlockStore(IMFActivate *iface)
434 {
435 struct transform_activate *activate = impl_from_IMFActivate(iface);
436
437 TRACE("%p.\n", iface);
438
439 return attributes_UnlockStore(&activate->attributes);
440 }
441
442 static HRESULT WINAPI transform_activate_GetCount(IMFActivate *iface, UINT32 *count)
443 {
444 struct transform_activate *activate = impl_from_IMFActivate(iface);
445
446 TRACE("%p, %p.\n", iface, count);
447
448 return attributes_GetCount(&activate->attributes, count);
449 }
450
451 static HRESULT WINAPI transform_activate_GetItemByIndex(IMFActivate *iface, UINT32 index, GUID *key,
452 PROPVARIANT *value)
453 {
454 struct transform_activate *activate = impl_from_IMFActivate(iface);
455
456 TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
457
458 return attributes_GetItemByIndex(&activate->attributes, index, key, value);
459 }
460
461 static HRESULT WINAPI transform_activate_CopyAllItems(IMFActivate *iface, IMFAttributes *dest)
462 {
463 struct transform_activate *activate = impl_from_IMFActivate(iface);
464
465 TRACE("%p, %p.\n", iface, dest);
466
467 return attributes_CopyAllItems(&activate->attributes, dest);
468 }
469
470 static HRESULT WINAPI transform_activate_ActivateObject(IMFActivate *iface, REFIID riid, void **obj)
471 {
472 struct transform_activate *activate = impl_from_IMFActivate(iface);
473 CLSID clsid;
474 HRESULT hr;
475
476 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
477
478 EnterCriticalSection(&activate->attributes.cs);
479
480 if (!activate->transform)
481 {
482 if (activate->factory)
483 {
484 if (FAILED(hr = IClassFactory_CreateInstance(activate->factory, NULL, &IID_IMFTransform,
485 (void **)&activate->transform)))
486 {
487 hr = MF_E_INVALIDREQUEST;
488 }
489 }
490 else
491 {
492 if (SUCCEEDED(hr = attributes_GetGUID(&activate->attributes, &MFT_TRANSFORM_CLSID_Attribute, &clsid)))
493 {
494 if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform,
495 (void **)&activate->transform)))
496 {
497 hr = MF_E_INVALIDREQUEST;
498 }
499 }
500 }
501 }
502
503 if (activate->transform)
504 hr = IMFTransform_QueryInterface(activate->transform, riid, obj);
505
506 LeaveCriticalSection(&activate->attributes.cs);
507
508 return hr;
509 }
510
511 static HRESULT WINAPI transform_activate_ShutdownObject(IMFActivate *iface)
512 {
513 struct transform_activate *activate = impl_from_IMFActivate(iface);
514
515 TRACE("%p.\n", iface);
516
517 EnterCriticalSection(&activate->attributes.cs);
518
519 if (activate->transform)
520 {
521 IMFTransform_Release(activate->transform);
522 activate->transform = NULL;
523 }
524
525 LeaveCriticalSection(&activate->attributes.cs);
526
527 return S_OK;
528 }
529
530 static HRESULT WINAPI transform_activate_DetachObject(IMFActivate *iface)
531 {
532 TRACE("%p.\n", iface);
533
534 return E_NOTIMPL;
535 }
536
537 static const IMFActivateVtbl transform_activate_vtbl =
538 {
539 transform_activate_QueryInterface,
540 transform_activate_AddRef,
541 transform_activate_Release,
542 transform_activate_GetItem,
543 transform_activate_GetItemType,
544 transform_activate_CompareItem,
545 transform_activate_Compare,
546 transform_activate_GetUINT32,
547 transform_activate_GetUINT64,
548 transform_activate_GetDouble,
549 transform_activate_GetGUID,
550 transform_activate_GetStringLength,
551 transform_activate_GetString,
552 transform_activate_GetAllocatedString,
553 transform_activate_GetBlobSize,
554 transform_activate_GetBlob,
555 transform_activate_GetAllocatedBlob,
556 transform_activate_GetUnknown,
557 transform_activate_SetItem,
558 transform_activate_DeleteItem,
559 transform_activate_DeleteAllItems,
560 transform_activate_SetUINT32,
561 transform_activate_SetUINT64,
562 transform_activate_SetDouble,
563 transform_activate_SetGUID,
564 transform_activate_SetString,
565 transform_activate_SetBlob,
566 transform_activate_SetUnknown,
567 transform_activate_LockStore,
568 transform_activate_UnlockStore,
569 transform_activate_GetCount,
570 transform_activate_GetItemByIndex,
571 transform_activate_CopyAllItems,
572 transform_activate_ActivateObject,
573 transform_activate_ShutdownObject,
574 transform_activate_DetachObject,
575 };
576
577 static HRESULT create_transform_activate(IClassFactory *factory, IMFActivate **activate)
578 {
579 struct transform_activate *object;
580 HRESULT hr;
581
582 if (!(object = calloc(1, sizeof(*object))))
583 return E_OUTOFMEMORY;
584
585 if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
586 {
587 free(object);
588 return hr;
589 }
590
591 object->IMFActivate_iface.lpVtbl = &transform_activate_vtbl;
592 object->factory = factory;
593 if (object->factory)
594 IClassFactory_AddRef(object->factory);
595
596 *activate = &object->IMFActivate_iface;
597
598 return S_OK;
599 }
600
601 HRESULT WINAPI MFCreateTransformActivate(IMFActivate **activate)
602 {
603 TRACE("%p.\n", activate);
604
605 return create_transform_activate(NULL, activate);
606 }
607
608 static const WCHAR transform_keyW[] = L"MediaFoundation\\Transforms";
609 static const WCHAR categories_keyW[] = L"MediaFoundation\\Transforms\\Categories";
610
611 static const BYTE guid_conv_table[256] =
612 {
613 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
614 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
615 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
616 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
617 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
618 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
619 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf /* 0x60 */
620 };
621
622 static WCHAR* GUIDToString(WCHAR *str, REFGUID guid)
623 {
624 swprintf(str, 39, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
625 guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1],
626 guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5],
627 guid->Data4[6], guid->Data4[7]);
628
629 return str;
630 }
631
632 static inline BOOL is_valid_hex(WCHAR c)
633 {
634 if (!(((c >= '0') && (c <= '9')) ||
635 ((c >= 'a') && (c <= 'f')) ||
636 ((c >= 'A') && (c <= 'F'))))
637 return FALSE;
638 return TRUE;
639 }
640
641 static BOOL GUIDFromString(LPCWSTR s, GUID *id)
642 {
643 int i;
644
645 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
646
647 id->Data1 = 0;
648 for (i = 0; i < 8; i++)
649 {
650 if (!is_valid_hex(s[i])) return FALSE;
651 id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
652 }
653 if (s[8]!='-') return FALSE;
654
655 id->Data2 = 0;
656 for (i = 9; i < 13; i++)
657 {
658 if (!is_valid_hex(s[i])) return FALSE;
659 id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
660 }
661 if (s[13]!='-') return FALSE;
662
663 id->Data3 = 0;
664 for (i = 14; i < 18; i++)
665 {
666 if (!is_valid_hex(s[i])) return FALSE;
667 id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
668 }
669 if (s[18]!='-') return FALSE;
670
671 for (i = 19; i < 36; i+=2)
672 {
673 if (i == 23)
674 {
675 if (s[i]!='-') return FALSE;
676 i++;
677 }
678 if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
679 id->Data4[(i-19)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
680 }
681
682 if (!s[36]) return TRUE;
683 return FALSE;
684 }
685
686 static HRESULT register_transform(const CLSID *clsid, const WCHAR *name, UINT32 flags,
687 UINT32 cinput, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
688 const MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
689 {
690 HRESULT hr = S_OK;
691 HKEY hclsid = 0;
692 WCHAR buffer[64];
693 DWORD size, ret;
694 WCHAR str[250];
695 UINT8 *blob;
696
697 GUIDToString(buffer, clsid);
698 swprintf(str, ARRAY_SIZE(str), L"%s\\%s", transform_keyW, buffer);
699
700 if ((ret = RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid)))
701 hr = HRESULT_FROM_WIN32(ret);
702
703 if (SUCCEEDED(hr))
704 {
705 size = (lstrlenW(name) + 1) * sizeof(WCHAR);
706 if ((ret = RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size)))
707 hr = HRESULT_FROM_WIN32(ret);
708 }
709
710 if (SUCCEEDED(hr) && cinput && input_types)
711 {
712 size = cinput * sizeof(MFT_REGISTER_TYPE_INFO);
713 if ((ret = RegSetValueExW(hclsid, L"InputTypes", 0, REG_BINARY, (BYTE *)input_types, size)))
714 hr = HRESULT_FROM_WIN32(ret);
715 }
716
717 if (SUCCEEDED(hr) && coutput && output_types)
718 {
719 size = coutput * sizeof(MFT_REGISTER_TYPE_INFO);
720 if ((ret = RegSetValueExW(hclsid, L"OutputTypes", 0, REG_BINARY, (BYTE *)output_types, size)))
721 hr = HRESULT_FROM_WIN32(ret);
722 }
723
724 if (SUCCEEDED(hr) && attributes)
725 {
726 if (SUCCEEDED(hr = MFGetAttributesAsBlobSize(attributes, &size)))
727 {
728 if ((blob = malloc(size)))
729 {
730 if (SUCCEEDED(hr = MFGetAttributesAsBlob(attributes, blob, size)))
731 {
732 if ((ret = RegSetValueExW(hclsid, L"Attributes", 0, REG_BINARY, blob, size)))
733 hr = HRESULT_FROM_WIN32(ret);
734 }
735 free(blob);
736 }
737 else
738 hr = E_OUTOFMEMORY;
739 }
740 }
741
742 if (SUCCEEDED(hr) && flags)
743 {
744 if ((ret = RegSetValueExW(hclsid, L"MFTFlags", 0, REG_DWORD, (BYTE *)&flags, sizeof(flags))))
745 hr = HRESULT_FROM_WIN32(ret);
746 }
747
748 RegCloseKey(hclsid);
749 return hr;
750 }
751
752 static HRESULT register_category(CLSID *clsid, GUID *category)
753 {
754 HKEY htmp1;
755 WCHAR guid1[64], guid2[64];
756 WCHAR str[350];
757
758 GUIDToString(guid1, category);
759 GUIDToString(guid2, clsid);
760
761 swprintf(str, ARRAY_SIZE(str), L"%s\\%s\\%s", categories_keyW, guid1, guid2);
762
763 if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &htmp1))
764 return E_FAIL;
765
766 RegCloseKey(htmp1);
767 return S_OK;
768 }
769
770 /***********************************************************************
771 * MFTRegister (mfplat.@)
772 */
773 HRESULT WINAPI MFTRegister(CLSID clsid, GUID category, LPWSTR name, UINT32 flags, UINT32 cinput,
774 MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
775 MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
776 {
777 HRESULT hr;
778
779 TRACE("%s, %s, %s, %#x, %u, %p, %u, %p, %p.\n", debugstr_guid(&clsid), debugstr_guid(&category),
780 debugstr_w(name), flags, cinput, input_types, coutput, output_types, attributes);
781
782 hr = register_transform(&clsid, name, flags, cinput, input_types, coutput, output_types, attributes);
783 if(FAILED(hr))
784 ERR("Failed to write register transform\n");
785
786 if (SUCCEEDED(hr))
787 hr = register_category(&clsid, &category);
788
789 return hr;
790 }
791
792 static void release_mft_registration(struct mft_registration *mft)
793 {
794 if (mft->factory)
795 IClassFactory_Release(mft->factory);
796 free(mft->name);
797 free(mft->input_types);
798 free(mft->output_types);
799 free(mft);
800 }
801
802 static HRESULT mft_register_local(IClassFactory *factory, REFCLSID clsid, REFGUID category, LPCWSTR name, UINT32 flags,
803 UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
804 const MFT_REGISTER_TYPE_INFO *output_types)
805 {
806 struct mft_registration *mft, *cur, *unreg_mft = NULL;
807 HRESULT hr = S_OK;
808
809 if (!factory && !clsid)
810 {
811 WARN("Can't register without factory or CLSID.\n");
812 return E_FAIL;
813 }
814
815 if (!(mft = calloc(1, sizeof(*mft))))
816 return E_OUTOFMEMORY;
817
818 mft->factory = factory;
819 if (mft->factory)
820 IClassFactory_AddRef(mft->factory);
821 if (clsid)
822 mft->clsid = *clsid;
823 mft->category = *category;
824 if (!(flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
825 flags |= MFT_ENUM_FLAG_SYNCMFT;
826 mft->flags = flags;
827 mft->local = TRUE;
828 if (name && !(mft->name = wcsdup(name)))
829 {
830 hr = E_OUTOFMEMORY;
831 goto failed;
832 }
833
834 if (input_count && input_types)
835 {
836 mft->input_types_count = input_count;
837 if (!(mft->input_types = calloc(mft->input_types_count, sizeof(*input_types))))
838 {
839 hr = E_OUTOFMEMORY;
840 goto failed;
841 }
842 memcpy(mft->input_types, input_types, mft->input_types_count * sizeof(*input_types));
843 }
844
845 if (output_count && output_types)
846 {
847 mft->output_types_count = output_count;
848 if (!(mft->output_types = calloc(mft->output_types_count, sizeof(*output_types))))
849 {
850 hr = E_OUTOFMEMORY;
851 goto failed;
852 }
853 memcpy(mft->output_types, output_types, mft->output_types_count * sizeof(*output_types));
854 }
855
856 EnterCriticalSection(&local_mfts_section);
857
858 LIST_FOR_EACH_ENTRY(cur, &local_mfts, struct mft_registration, entry)
859 {
860 if (cur->factory == factory)
861 {
862 unreg_mft = cur;
863 list_remove(&cur->entry);
864 break;
865 }
866 }
867 list_add_tail(&local_mfts, &mft->entry);
868
869 LeaveCriticalSection(&local_mfts_section);
870
871 if (unreg_mft)
872 release_mft_registration(unreg_mft);
873
874 failed:
875 if (FAILED(hr))
876 release_mft_registration(mft);
877
878 return hr;
879 }
880
881 HRESULT WINAPI MFTRegisterLocal(IClassFactory *factory, REFGUID category, LPCWSTR name, UINT32 flags,
882 UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
883 const MFT_REGISTER_TYPE_INFO *output_types)
884 {
885 TRACE("%p, %s, %s, %#x, %u, %p, %u, %p.\n", factory, debugstr_guid(category), debugstr_w(name), flags, input_count,
886 input_types, output_count, output_types);
887
888 return mft_register_local(factory, NULL, category, name, flags, input_count, input_types, output_count, output_types);
889 }
890
891 HRESULT WINAPI MFTRegisterLocalByCLSID(REFCLSID clsid, REFGUID category, LPCWSTR name, UINT32 flags,
892 UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
893 const MFT_REGISTER_TYPE_INFO *output_types)
894 {
895 TRACE("%s, %s, %s, %#x, %u, %p, %u, %p.\n", debugstr_guid(clsid), debugstr_guid(category), debugstr_w(name), flags,
896 input_count, input_types, output_count, output_types);
897
898 return mft_register_local(NULL, clsid, category, name, flags, input_count, input_types, output_count, output_types);
899 }
900
901 static HRESULT mft_unregister_local(IClassFactory *factory, REFCLSID clsid)
902 {
903 struct mft_registration *cur, *cur2;
904 BOOL unregister_all = !factory && !clsid;
905 struct list unreg;
906
907 list_init(&unreg);
908
909 EnterCriticalSection(&local_mfts_section);
910
911 LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &local_mfts, struct mft_registration, entry)
912 {
913 if (!unregister_all)
914 {
915 if ((factory && cur->factory == factory) || IsEqualCLSID(&cur->clsid, clsid))
916 {
917 list_remove(&cur->entry);
918 list_add_tail(&unreg, &cur->entry);
919 break;
920 }
921 }
922 else
923 {
924 list_remove(&cur->entry);
925 list_add_tail(&unreg, &cur->entry);
926 }
927 }
928
929 LeaveCriticalSection(&local_mfts_section);
930
931 if (!unregister_all && list_empty(&unreg))
932 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
933
934 LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &unreg, struct mft_registration, entry)
935 {
936 list_remove(&cur->entry);
937 release_mft_registration(cur);
938 }
939
940 return S_OK;
941 }
942
943 HRESULT WINAPI MFTUnregisterLocalByCLSID(CLSID clsid)
944 {
945 TRACE("%s.\n", debugstr_guid(&clsid));
946
947 return mft_unregister_local(NULL, &clsid);
948 }
949
950 HRESULT WINAPI MFTUnregisterLocal(IClassFactory *factory)
951 {
952 TRACE("%p.\n", factory);
953
954 return mft_unregister_local(factory, NULL);
955 }
956
957 MFTIME WINAPI MFGetSystemTime(void)
958 {
959 MFTIME mf;
960
961 GetSystemTimeAsFileTime( (FILETIME*)&mf );
962
963 return mf;
964 }
965
966 static BOOL mft_is_type_info_match(struct mft_registration *mft, const GUID *category, UINT32 flags,
967 IMFPluginControl *plugin_control, const MFT_REGISTER_TYPE_INFO *input_type,
968 const MFT_REGISTER_TYPE_INFO *output_type)
969 {
970 BOOL matching = TRUE;
971 DWORD model;
972 int i;
973
974 if (!IsEqualGUID(category, &mft->category))
975 return FALSE;
976
977 /* Default model is synchronous. */
978 model = mft->flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE);
979 if (!model)
980 model = MFT_ENUM_FLAG_SYNCMFT;
981 if (!(model & flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
982 return FALSE;
983
984 /* These flags should be explicitly enabled. */
985 if (mft->flags & ~flags & (MFT_ENUM_FLAG_FIELDOFUSE | MFT_ENUM_FLAG_TRANSCODE_ONLY))
986 return FALSE;
987
988 if (flags & MFT_ENUM_FLAG_SORTANDFILTER && !mft->factory && plugin_control
989 && IMFPluginControl_IsDisabled(plugin_control, MF_Plugin_Type_MFT, &mft->clsid) == S_OK)
990 {
991 return FALSE;
992 }
993
994 if (input_type)
995 {
996 for (i = 0, matching = FALSE; input_type && i < mft->input_types_count; ++i)
997 {
998 if (!memcmp(&mft->input_types[i], input_type, sizeof(*input_type)))
999 {
1000 matching = TRUE;
1001 break;
1002 }
1003 }
1004 }
1005
1006 if (output_type && matching)
1007 {
1008 for (i = 0, matching = FALSE; i < mft->output_types_count; ++i)
1009 {
1010 if (!memcmp(&mft->output_types[i], output_type, sizeof(*output_type)))
1011 {
1012 matching = TRUE;
1013 break;
1014 }
1015 }
1016 }
1017
1018 return matching;
1019 }
1020
1021 static void mft_get_reg_type_info(const WCHAR *clsidW, const WCHAR *typeW, MFT_REGISTER_TYPE_INFO **type,
1022 UINT32 *count)
1023 {
1024 HKEY htransform, hfilter;
1025 DWORD reg_type, size;
1026
1027 *type = NULL;
1028 *count = 0;
1029
1030 if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
1031 return;
1032
1033 if (RegOpenKeyW(htransform, clsidW, &hfilter))
1034 {
1035 RegCloseKey(htransform);
1036 return;
1037 }
1038
1039 if (RegQueryValueExW(hfilter, typeW, NULL, &reg_type, NULL, &size))
1040 goto out;
1041
1042 if (reg_type != REG_BINARY)
1043 goto out;
1044
1045 if (!size || size % sizeof(**type))
1046 goto out;
1047
1048 if (!(*type = malloc(size)))
1049 goto out;
1050
1051 *count = size / sizeof(**type);
1052
1053 if (RegQueryValueExW(hfilter, typeW, NULL, &reg_type, (BYTE *)*type, &size))
1054 {
1055 free(*type);
1056 *type = NULL;
1057 *count = 0;
1058 }
1059
1060 out:
1061 RegCloseKey(hfilter);
1062 RegCloseKey(htransform);
1063 }
1064
1065 static void mft_get_reg_flags(const WCHAR *clsidW, const WCHAR *nameW, DWORD *flags)
1066 {
1067 DWORD ret, reg_type, size;
1068 HKEY hroot, hmft;
1069
1070 *flags = 0;
1071
1072 if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &hroot))
1073 return;
1074
1075 ret = RegOpenKeyW(hroot, clsidW, &hmft);
1076 RegCloseKey(hroot);
1077 if (ret)
1078 return;
1079
1080 reg_type = 0;
1081 if (!RegQueryValueExW(hmft, nameW, NULL, &reg_type, NULL, &size) && reg_type == REG_DWORD)
1082 RegQueryValueExW(hmft, nameW, NULL, &reg_type, (BYTE *)flags, &size);
1083
1084 RegCloseKey(hmft);
1085 }
1086
1087 static HRESULT mft_collect_machine_reg(struct list *mfts, const GUID *category, UINT32 flags,
1088 IMFPluginControl *plugin_control, const MFT_REGISTER_TYPE_INFO *input_type,
1089 const MFT_REGISTER_TYPE_INFO *output_type)
1090 {
1091 struct mft_registration mft, *cur;
1092 HKEY hcategory, hlist;
1093 WCHAR clsidW[64];
1094 DWORD ret, size;
1095 int index = 0;
1096
1097 if (RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
1098 return E_FAIL;
1099
1100 GUIDToString(clsidW, category);
1101 ret = RegOpenKeyW(hcategory, clsidW, &hlist);
1102 RegCloseKey(hcategory);
1103 if (ret)
1104 return E_FAIL;
1105
1106 size = ARRAY_SIZE(clsidW);
1107 while (!RegEnumKeyExW(hlist, index, clsidW, &size, NULL, NULL, NULL, NULL))
1108 {
1109 memset(&mft, 0, sizeof(mft));
1110 mft.category = *category;
1111 if (!GUIDFromString(clsidW, &mft.clsid))
1112 goto next;
1113
1114 mft_get_reg_flags(clsidW, L"MFTFlags", &mft.flags);
1115
1116 if (output_type)
1117 mft_get_reg_type_info(clsidW, L"OutputTypes", &mft.output_types, &mft.output_types_count);
1118
1119 if (input_type)
1120 mft_get_reg_type_info(clsidW, L"InputTypes", &mft.input_types, &mft.input_types_count);
1121
1122 if (!mft_is_type_info_match(&mft, category, flags, plugin_control, input_type, output_type))
1123 {
1124 free(mft.input_types);
1125 free(mft.output_types);
1126 goto next;
1127 }
1128
1129 cur = malloc(sizeof(*cur));
1130 /* Reuse allocated type arrays. */
1131 *cur = mft;
1132 list_add_tail(mfts, &cur->entry);
1133
1134 next:
1135 size = ARRAY_SIZE(clsidW);
1136 index++;
1137 }
1138
1139 return S_OK;
1140 }
1141
1142 static BOOL mft_is_preferred(IMFPluginControl *plugin_control, const CLSID *clsid)
1143 {
1144 CLSID preferred;
1145 WCHAR *selector;
1146 int index = 0;
1147
1148 while (SUCCEEDED(IMFPluginControl_GetPreferredClsidByIndex(plugin_control, MF_Plugin_Type_MFT, index++, &selector,
1149 &preferred)))
1150 {
1151 CoTaskMemFree(selector);
1152
1153 if (IsEqualGUID(&preferred, clsid))
1154 return TRUE;
1155 }
1156
1157 return FALSE;
1158 }
1159
1160 static HRESULT mft_enum(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1161 const MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, IMFActivate ***activate, UINT32 *count)
1162 {
1163 IMFPluginControl *plugin_control = NULL;
1164 struct list mfts, mfts_sorted, *result = &mfts;
1165 struct mft_registration *mft, *mft2;
1166 unsigned int obj_count;
1167 HRESULT hr;
1168
1169 *count = 0;
1170 *activate = NULL;
1171
1172 if (!flags)
1173 flags = MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_LOCALMFT | MFT_ENUM_FLAG_SORTANDFILTER;
1174
1175 /* Synchronous processing is default. */
1176 if (!(flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
1177 flags |= MFT_ENUM_FLAG_SYNCMFT;
1178
1179 if (FAILED(hr = MFGetPluginControl(&plugin_control)))
1180 {
1181 WARN("Failed to get plugin control instance, hr %#x.\n", hr);
1182 return hr;
1183 }
1184
1185 list_init(&mfts);
1186
1187 /* Collect from registry */
1188 mft_collect_machine_reg(&mfts, &category, flags, plugin_control, input_type, output_type);
1189
1190 /* Collect locally registered ones. */
1191 if (flags & MFT_ENUM_FLAG_LOCALMFT)
1192 {
1193 struct mft_registration *local;
1194
1195 EnterCriticalSection(&local_mfts_section);
1196
1197 LIST_FOR_EACH_ENTRY(local, &local_mfts, struct mft_registration, entry)
1198 {
1199 if (mft_is_type_info_match(local, &category, flags, plugin_control, input_type, output_type))
1200 {
1201 mft = calloc(1, sizeof(*mft));
1202
1203 mft->clsid = local->clsid;
1204 mft->factory = local->factory;
1205 if (mft->factory)
1206 IClassFactory_AddRef(mft->factory);
1207 mft->flags = local->flags;
1208 mft->local = local->local;
1209
1210 list_add_tail(&mfts, &mft->entry);
1211 }
1212 }
1213
1214 LeaveCriticalSection(&local_mfts_section);
1215 }
1216
1217 list_init(&mfts_sorted);
1218
1219 if (flags & MFT_ENUM_FLAG_SORTANDFILTER)
1220 {
1221 /* Local registrations. */
1222 LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1223 {
1224 if (mft->local)
1225 {
1226 list_remove(&mft->entry);
1227 list_add_tail(&mfts_sorted, &mft->entry);
1228 }
1229 }
1230
1231 /* FIXME: Sort by merit value, for the ones that got it. Currently not handled. */
1232
1233 /* Preferred transforms. */
1234 LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1235 {
1236 if (!mft->factory && mft_is_preferred(plugin_control, &mft->clsid))
1237 {
1238 list_remove(&mft->entry);
1239 list_add_tail(&mfts_sorted, &mft->entry);
1240 }
1241 }
1242
1243 /* Append the rest. */
1244 LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1245 {
1246 list_remove(&mft->entry);
1247 list_add_tail(&mfts_sorted, &mft->entry);
1248 }
1249
1250 result = &mfts_sorted;
1251 }
1252
1253 IMFPluginControl_Release(plugin_control);
1254
1255 /* Create activation objects from CLSID/IClassFactory. */
1256
1257 obj_count = list_count(result);
1258
1259 if (obj_count)
1260 {
1261 if (!(*activate = CoTaskMemAlloc(obj_count * sizeof(**activate))))
1262 hr = E_OUTOFMEMORY;
1263
1264 obj_count = 0;
1265
1266 LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, result, struct mft_registration, entry)
1267 {
1268 IMFActivate *mft_activate;
1269
1270 if (*activate)
1271 {
1272 if (SUCCEEDED(create_transform_activate(mft->factory, &mft_activate)))
1273 {
1274 (*activate)[obj_count] = mft_activate;
1275
1276 if (mft->local)
1277 {
1278 IMFActivate_SetUINT32(mft_activate, &MFT_PROCESS_LOCAL_Attribute, 1);
1279 }
1280 else
1281 {
1282 if (mft->name)
1283 IMFActivate_SetString(mft_activate, &MFT_FRIENDLY_NAME_Attribute, mft->name);
1284 if (mft->input_types)
1285 IMFActivate_SetBlob(mft_activate, &MFT_INPUT_TYPES_Attributes, (const UINT8 *)mft->input_types,
1286 sizeof(*mft->input_types) * mft->input_types_count);
1287 if (mft->output_types)
1288 IMFActivate_SetBlob(mft_activate, &MFT_OUTPUT_TYPES_Attributes, (const UINT8 *)mft->output_types,
1289 sizeof(*mft->output_types) * mft->output_types_count);
1290 }
1291
1292 if (!mft->factory)
1293 IMFActivate_SetGUID(mft_activate, &MFT_TRANSFORM_CLSID_Attribute, &mft->clsid);
1294
1295 IMFActivate_SetUINT32(mft_activate, &MF_TRANSFORM_FLAGS_Attribute, mft->flags);
1296 IMFActivate_SetGUID(mft_activate, &MF_TRANSFORM_CATEGORY_Attribute, &mft->category);
1297
1298 obj_count++;
1299 }
1300 }
1301
1302 list_remove(&mft->entry);
1303 release_mft_registration(mft);
1304 }
1305 }
1306
1307 if (!obj_count)
1308 {
1309 CoTaskMemFree(*activate);
1310 *activate = NULL;
1311 }
1312 *count = obj_count;
1313
1314 return hr;
1315 }
1316
1317 /***********************************************************************
1318 * MFTEnum (mfplat.@)
1319 */
1320 HRESULT WINAPI MFTEnum(GUID category, UINT32 flags, MFT_REGISTER_TYPE_INFO *input_type,
1321 MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, CLSID **clsids, UINT32 *count)
1322 {
1323 struct mft_registration *mft, *mft2;
1324 unsigned int mft_count;
1325 struct list mfts;
1326 HRESULT hr;
1327
1328 TRACE("%s, %#x, %p, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, attributes,
1329 clsids, count);
1330
1331 if (!clsids || !count)
1332 return E_INVALIDARG;
1333
1334 *count = 0;
1335
1336 list_init(&mfts);
1337
1338 if (FAILED(hr = mft_collect_machine_reg(&mfts, &category, MFT_ENUM_FLAG_SYNCMFT, NULL, input_type, output_type)))
1339 return hr;
1340
1341 mft_count = list_count(&mfts);
1342
1343 if (mft_count)
1344 {
1345 if (!(*clsids = CoTaskMemAlloc(mft_count * sizeof(**clsids))))
1346 hr = E_OUTOFMEMORY;
1347
1348 mft_count = 0;
1349 LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1350 {
1351 if (*clsids)
1352 (*clsids)[mft_count++] = mft->clsid;
1353 list_remove(&mft->entry);
1354 release_mft_registration(mft);
1355 }
1356 }
1357
1358 if (!mft_count)
1359 {
1360 CoTaskMemFree(*clsids);
1361 *clsids = NULL;
1362 }
1363 *count = mft_count;
1364
1365 return hr;
1366 }
1367
1368 /***********************************************************************
1369 * MFTEnumEx (mfplat.@)
1370 */
1371 HRESULT WINAPI MFTEnumEx(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1372 const MFT_REGISTER_TYPE_INFO *output_type, IMFActivate ***activate, UINT32 *count)
1373 {
1374 TRACE("%s, %#x, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, activate, count);
1375
1376 return mft_enum(category, flags, input_type, output_type, NULL, activate, count);
1377 }
1378
1379 /***********************************************************************
1380 * MFTEnum2 (mfplat.@)
1381 */
1382 HRESULT WINAPI MFTEnum2(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1383 const MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, IMFActivate ***activate, UINT32 *count)
1384 {
1385 TRACE("%s, %#x, %p, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, attributes,
1386 activate, count);
1387
1388 if (attributes)
1389 FIXME("Ignoring attributes.\n");
1390
1391 return mft_enum(category, flags, input_type, output_type, attributes, activate, count);
1392 }
1393
1394 /***********************************************************************
1395 * MFTUnregister (mfplat.@)
1396 */
1397 HRESULT WINAPI MFTUnregister(CLSID clsid)
1398 {
1399 WCHAR buffer[64], category[MAX_PATH];
1400 HKEY htransform, hcategory, htmp;
1401 DWORD size = MAX_PATH;
1402 DWORD index = 0;
1403
1404 TRACE("(%s)\n", debugstr_guid(&clsid));
1405
1406 GUIDToString(buffer, &clsid);
1407
1408 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
1409 {
1410 RegDeleteKeyW(htransform, buffer);
1411 RegCloseKey(htransform);
1412 }
1413
1414 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
1415 {
1416 while (RegEnumKeyExW(hcategory, index, category, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1417 {
1418 if (!RegOpenKeyW(hcategory, category, &htmp))
1419 {
1420 RegDeleteKeyW(htmp, buffer);
1421 RegCloseKey(htmp);
1422 }
1423 size = MAX_PATH;
1424 index++;
1425 }
1426 RegCloseKey(hcategory);
1427 }
1428
1429 return S_OK;
1430 }
1431
1432 /***********************************************************************
1433 * MFStartup (mfplat.@)
1434 */
1435 HRESULT WINAPI MFStartup(ULONG version, DWORD flags)
1436 {
1437 #define MF_VERSION_XP MAKELONG( MF_API_VERSION, 1 )
1438 #define MF_VERSION_WIN7 MAKELONG( MF_API_VERSION, 2 )
1439
1440 TRACE("%#x, %#x.\n", version, flags);
1441
1442 if (version != MF_VERSION_XP && version != MF_VERSION_WIN7)
1443 return MF_E_BAD_STARTUP_VERSION;
1444
1445 RtwqStartup();
1446
1447 return S_OK;
1448 }
1449
1450 /***********************************************************************
1451 * MFShutdown (mfplat.@)
1452 */
1453 HRESULT WINAPI MFShutdown(void)
1454 {
1455 TRACE("\n");
1456
1457 RtwqShutdown();
1458
1459 return S_OK;
1460 }
1461
1462 /***********************************************************************
1463 * MFCopyImage (mfplat.@)
1464 */
1465 HRESULT WINAPI MFCopyImage(BYTE *dest, LONG deststride, const BYTE *src, LONG srcstride, DWORD width, DWORD lines)
1466 {
1467 TRACE("%p, %d, %p, %d, %u, %u.\n", dest, deststride, src, srcstride, width, lines);
1468
1469 while (lines--)
1470 {
1471 memcpy(dest, src, width);
1472 dest += deststride;
1473 src += srcstride;
1474 }
1475
1476 return S_OK;
1477 }
1478
1479 struct guid_def
1480 {
1481 const GUID *guid;
1482 const char *name;
1483 };
1484
1485 static int __cdecl debug_compare_guid(const void *a, const void *b)
1486 {
1487 const GUID *guid = a;
1488 const struct guid_def *guid_def = b;
1489 return memcmp(guid, guid_def->guid, sizeof(*guid));
1490 }
1491
1492 const char *debugstr_attr(const GUID *guid)
1493 {
1494 static const struct guid_def guid_defs[] =
1495 {
1496 #define X(g) { &(g), #g }
1497 #define MF_READER_WRITER_D3D_MANAGER MF_SOURCE_READER_D3D_MANAGER
1498 X(MF_READWRITE_MMCSS_CLASS),
1499 X(MF_TOPONODE_MARKIN_HERE),
1500 X(MF_MT_H264_SUPPORTED_SYNC_FRAME_TYPES),
1501 X(MF_TOPONODE_MARKOUT_HERE),
1502 X(EVRConfig_ForceBob),
1503 X(MF_TOPONODE_DECODER),
1504 X(EVRConfig_AllowDropToBob),
1505 X(MF_TOPOLOGY_PROJECTSTART),
1506 X(EVRConfig_ForceThrottle),
1507 X(MF_VIDEO_MAX_MB_PER_SEC),
1508 X(MF_TOPOLOGY_PROJECTSTOP),
1509 X(MF_SINK_WRITER_ENCODER_CONFIG),
1510 X(EVRConfig_AllowDropToThrottle),
1511 X(MF_TOPOLOGY_NO_MARKIN_MARKOUT),
1512 X(EVRConfig_ForceHalfInterlace),
1513 X(EVRConfig_AllowDropToHalfInterlace),
1514 X(EVRConfig_ForceScaling),
1515 X(MF_MT_H264_CAPABILITIES),
1516 X(EVRConfig_AllowScaling),
1517 X(MF_SOURCE_READER_ENABLE_TRANSCODE_ONLY_TRANSFORMS),
1518 X(MFT_PREFERRED_ENCODER_PROFILE),
1519 X(EVRConfig_ForceBatching),
1520 X(EVRConfig_AllowBatching),
1521 X(MF_TOPOLOGY_DYNAMIC_CHANGE_NOT_ALLOWED),
1522 X(MF_MT_VIDEO_PROFILE),
1523 X(MF_MT_DV_AAUX_CTRL_PACK_1),
1524 X(MF_MT_ALPHA_MODE),
1525 X(MF_MT_MPEG2_TIMECODE),
1526 X(MF_PMP_SERVER_CONTEXT),
1527 X(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE),
1528 X(MF_MEDIA_ENGINE_TRACK_ID),
1529 X(MF_MT_CUSTOM_VIDEO_PRIMARIES),
1530 X(MF_MT_TIMESTAMP_CAN_BE_DTS),
1531 X(MFT_CODEC_MERIT_Attribute),
1532 X(MF_TOPOLOGY_PLAYBACK_MAX_DIMS),
1533 X(MF_XVP_DISABLE_FRC),
1534 X(MF_LOW_LATENCY),
1535 X(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS),
1536 X(MF_MT_MPEG2_FLAGS),
1537 X(MF_MEDIA_ENGINE_AUDIO_CATEGORY),
1538 X(MF_MT_PIXEL_ASPECT_RATIO),
1539 X(MF_VIDEO_PROCESSOR_ALGORITHM),
1540 X(MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK),
1541 X(MFT_CONNECTED_STREAM_ATTRIBUTE),
1542 X(MF_MT_REALTIME_CONTENT),
1543 X(MF_MEDIA_ENGINE_CONTENT_PROTECTION_FLAGS),
1544 X(MF_MT_WRAPPED_TYPE),
1545 X(MF_MT_DRM_FLAGS),
1546 X(MF_MT_AVG_BITRATE),
1547 X(MF_MT_DECODER_USE_MAX_RESOLUTION),
1548 X(MF_MT_MAX_LUMINANCE_LEVEL),
1549 X(MFT_CONNECTED_TO_HW_STREAM),
1550 X(MF_SA_D3D_AWARE),
1551 X(MF_XVP_SAMPLE_LOCK_TIMEOUT),
1552 X(MF_MT_MAX_KEYFRAME_SPACING),
1553 X(MFT_TRANSFORM_CLSID_Attribute),
1554 X(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING),
1555 X(MF_MT_AM_FORMAT_TYPE),
1556 X(MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME),
1557 X(MF_MEDIA_ENGINE_SYNCHRONOUS_CLOSE),
1558 X(MF_MT_H264_MAX_MB_PER_SEC),
1559 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS),
1560 X(MF_MT_AUDIO_BLOCK_ALIGNMENT),
1561 X(MF_PD_PMPHOST_CONTEXT),
1562 X(MF_PD_APP_CONTEXT),
1563 X(MF_PD_DURATION),
1564 X(MF_PD_TOTAL_FILE_SIZE),
1565 X(MF_PD_AUDIO_ENCODING_BITRATE),
1566 X(MF_PD_VIDEO_ENCODING_BITRATE),
1567 X(MFSampleExtension_TargetGlobalLuminance),
1568 X(MF_PD_MIME_TYPE),
1569 X(MF_MT_H264_SUPPORTED_SLICE_MODES),
1570 X(MF_PD_LAST_MODIFIED_TIME),
1571 X(VIDEO_ZOOM_RECT),
1572 X(MF_PD_PLAYBACK_ELEMENT_ID),
1573 X(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE9),
1574 X(MF_MT_ALL_SAMPLES_INDEPENDENT),
1575 X(MF_PD_PREFERRED_LANGUAGE),
1576 X(MF_PD_PLAYBACK_BOUNDARY_TIME),
1577 X(MF_MEDIA_ENGINE_TELEMETRY_APPLICATION_ID),
1578 X(MF_ACTIVATE_MFT_LOCKED),
1579 X(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT),
1580 X(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING),
1581 X(MF_MT_FRAME_SIZE),
1582 X(MF_MT_H264_SIMULCAST_SUPPORT),
1583 X(MF_SINK_WRITER_ASYNC_CALLBACK),
1584 X(MF_TOPOLOGY_START_TIME_ON_PRESENTATION_SWITCH),
1585 X(MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER),
1586 X(MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY),
1587 X(MF_MT_FRAME_RATE_RANGE_MAX),
1588 X(MF_MT_PALETTE),
1589 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_PROVIDER_DEVICE_ID),
1590 X(MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS),
1591 X(MF_SA_D3D11_USAGE),
1592 X(MF_MEDIA_ENGINE_NEEDKEY_CALLBACK),
1593 X(MF_MT_GEOMETRIC_APERTURE),
1594 X(MF_MT_ORIGINAL_WAVE_FORMAT_TAG),
1595 X(MF_MT_DV_AAUX_SRC_PACK_1),
1596 X(MF_MEDIA_ENGINE_STREAM_CONTAINS_ALPHA_CHANNEL),
1597 X(MF_MEDIA_ENGINE_MEDIA_PLAYER_MODE),
1598 X(MF_MEDIA_ENGINE_EXTENSION),
1599 X(MF_MT_DEFAULT_STRIDE),
1600 X(MF_MT_ARBITRARY_FORMAT),
1601 X(MF_TRANSFORM_CATEGORY_Attribute),
1602 X(MF_MT_MPEG2_HDCP),
1603 X(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND),
1604 X(MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS),
1605 X(MF_MT_DECODER_MAX_DPB_COUNT),
1606 X(MFSampleExtension_ForwardedDecodeUnits),
1607 X(MF_SA_D3D11_SHARED_WITHOUT_MUTEX),
1608 X(MF_MT_DV_AAUX_CTRL_PACK_0),
1609 X(MF_MT_YUV_MATRIX),
1610 X(MF_EVENT_SOURCE_TOPOLOGY_CANCELED),
1611 X(MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY),
1612 X(MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL),
1613 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID),
1614 X(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME),
1615 X(MF_MT_VIDEO_ROTATION),
1616 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK),
1617 X(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE11),
1618 X(MF_MT_USER_DATA),
1619 X(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID),
1620 X(MF_MT_MIN_MASTERING_LUMINANCE),
1621 X(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE),
1622 X(MF_SA_REQUIRED_SAMPLE_COUNT),
1623 X(MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS),
1624 X(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID),
1625 X(MF_EVENT_STREAM_METADATA_SYSTEMID),
1626 X(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE),
1627 X(MF_MT_AUDIO_CHANNEL_MASK),
1628 X(MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN),
1629 X(MF_READWRITE_DISABLE_CONVERTERS),
1630 X(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE_EDGE),
1631 X(MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS),
1632 X(MF_MT_MINIMUM_DISPLAY_APERTURE),
1633 X(MFSampleExtension_Token),
1634 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY),
1635 X(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE),
1636 X(MF_TRANSFORM_ASYNC_UNLOCK),
1637 X(MF_DISABLE_FRAME_CORRUPTION_INFO),
1638 X(MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES),
1639 X(MF_MT_VIDEO_NO_FRAME_ORDERING),
1640 X(MF_MEDIA_ENGINE_PLAYBACK_VISUAL),
1641 X(MF_MT_VIDEO_CHROMA_SITING),
1642 X(MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY),
1643 X(MF_SA_BUFFERS_PER_SAMPLE),
1644 X(MFSampleExtension_3DVideo_SampleFormat),
1645 X(MF_MT_H264_RESOLUTION_SCALING),
1646 X(MF_MT_VIDEO_LEVEL),
1647 X(MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET),
1648 X(MF_MT_SAMPLE_SIZE),
1649 X(MF_MT_AAC_PAYLOAD_TYPE),
1650 X(MF_TOPOLOGY_PLAYBACK_FRAMERATE),
1651 X(MF_SOURCE_READER_D3D11_BIND_FLAGS),
1652 X(MF_MT_AUDIO_FOLDDOWN_MATRIX),
1653 X(MF_MT_AUDIO_WMADRC_PEAKREF),
1654 X(MF_MT_AUDIO_WMADRC_PEAKTARGET),
1655 X(MF_TRANSFORM_FLAGS_Attribute),
1656 X(MF_MT_H264_SUPPORTED_RATE_CONTROL_MODES),
1657 X(MF_PD_SAMI_STYLELIST),
1658 X(MF_MT_AUDIO_WMADRC_AVGREF),
1659 X(MF_MT_AUDIO_BITS_PER_SAMPLE),
1660 X(MF_SD_LANGUAGE),
1661 X(MF_MT_AUDIO_WMADRC_AVGTARGET),
1662 X(MF_SD_PROTECTED),
1663 X(MF_SESSION_TOPOLOADER),
1664 X(MF_SESSION_GLOBAL_TIME),
1665 X(MF_SESSION_QUALITY_MANAGER),
1666 X(MF_SESSION_CONTENT_PROTECTION_MANAGER),
1667 X(MF_MT_MPEG4_SAMPLE_DESCRIPTION),
1668 X(MF_MT_MPEG_START_TIME_CODE),
1669 X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT),
1670 X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT),
1671 X(MF_READWRITE_MMCSS_PRIORITY_AUDIO),
1672 X(MF_MT_H264_MAX_CODEC_CONFIG_DELAY),
1673 X(MF_MT_DV_AAUX_SRC_PACK_0),
1674 X(MF_BYTESTREAM_ORIGIN_NAME),
1675 X(MF_BYTESTREAM_CONTENT_TYPE),
1676 X(MF_MT_DEPTH_MEASUREMENT),
1677 X(MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WIN10),
1678 X(MF_MT_VIDEO_3D_NUM_VIEWS),
1679 X(MF_BYTESTREAM_DURATION),
1680 X(MF_SD_SAMI_LANGUAGE),
1681 X(MF_EVENT_OUTPUT_NODE),
1682 X(MF_BYTESTREAM_LAST_MODIFIED_TIME),
1683 X(MFT_ENUM_ADAPTER_LUID),
1684 X(MF_MT_FRAME_RATE_RANGE_MIN),
1685 X(MF_BYTESTREAM_IFO_FILE_URI),
1686 X(MF_EVENT_TOPOLOGY_STATUS),
1687 X(MF_BYTESTREAM_DLNA_PROFILE_ID),
1688 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE),
1689 X(MF_MT_MAJOR_TYPE),
1690 X(MF_SA_REQUIRED_SAMPLE_COUNT_PROGRESSIVE),
1691 X(MF_MT_IN_BAND_PARAMETER_SET),
1692 X(MF_EVENT_SOURCE_CHARACTERISTICS),
1693 X(MF_EVENT_SOURCE_CHARACTERISTICS_OLD),
1694 X(MF_SESSION_SERVER_CONTEXT),
1695 X(MF_MT_VIDEO_3D_FIRST_IS_LEFT),
1696 X(MFT_DECODER_FINAL_VIDEO_RESOLUTION_HINT),
1697 X(MF_PD_ADAPTIVE_STREAMING),
1698 X(MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE),
1699 X(MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WWA_EDGE),
1700 X(MF_MT_H264_SUPPORTED_USAGES),
1701 X(MFT_PREFERRED_OUTPUTTYPE_Attribute),
1702 X(MFSampleExtension_Timestamp),
1703 X(MF_TOPONODE_PRIMARYOUTPUT),
1704 X(MF_MT_SUBTYPE),
1705 X(MF_TRANSFORM_ASYNC),
1706 X(MF_TOPONODE_STREAMID),
1707 X(MF_MEDIA_ENGINE_PLAYBACK_HWND),
1708 X(MF_TOPONODE_NOSHUTDOWN_ON_REMOVE),
1709 X(MF_MT_VIDEO_LIGHTING),
1710 X(MF_SD_MUTUALLY_EXCLUSIVE),
1711 X(MF_SD_STREAM_NAME),
1712 X(MF_MT_DV_VAUX_SRC_PACK),
1713 X(MF_TOPONODE_RATELESS),
1714 X(MF_EVENT_STREAM_METADATA_CONTENT_KEYIDS),
1715 X(MF_TOPONODE_DISABLE_PREROLL),
1716 X(MF_SA_D3D11_ALLOW_DYNAMIC_YUV_TEXTURE),
1717 X(MF_MT_VIDEO_3D_FORMAT),
1718 X(MF_EVENT_STREAM_METADATA_KEYDATA),
1719 X(MF_READER_WRITER_D3D_MANAGER),
1720 X(MFSampleExtension_3DVideo),
1721 X(MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE),
1722 X(MF_MT_H264_USAGE),
1723 X(MF_MEDIA_ENGINE_EME_CALLBACK),
1724 X(MF_EVENT_SOURCE_FAKE_START),
1725 X(MF_EVENT_SOURCE_PROJECTSTART),
1726 X(MF_EVENT_SOURCE_ACTUAL_START),
1727 X(MF_MEDIA_ENGINE_CONTENT_PROTECTION_MANAGER),
1728 X(MF_MT_AUDIO_SAMPLES_PER_BLOCK),
1729 X(MFT_ENUM_HARDWARE_URL_Attribute),
1730 X(MF_SOURCE_READER_ASYNC_CALLBACK),
1731 X(MF_MT_OUTPUT_BUFFER_NUM),
1732 X(MF_SA_D3D11_BINDFLAGS),
1733 X(MFT_ENCODER_SUPPORTS_CONFIG_EVENT),
1734 X(MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE),
1735 X(MFT_FRIENDLY_NAME_Attribute),
1736 X(MF_MT_FIXED_SIZE_SAMPLES),
1737 X(MFT_SUPPORT_3DVIDEO),
1738 X(MFT_SUPPORT_3DVIDEO),
1739 X(MFT_INPUT_TYPES_Attributes),
1740 X(MF_MT_H264_LAYOUT_PER_STREAM),
1741 X(MF_EVENT_SCRUBSAMPLE_TIME),
1742 X(MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS),
1743 X(MF_MT_MPEG2_ONE_FRAME_PER_PACKET),
1744 X(MF_MT_INTERLACE_MODE),
1745 X(MF_MEDIA_ENGINE_CALLBACK),
1746 X(MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE),
1747 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE),
1748 X(MF_MT_AUDIO_PREFER_WAVEFORMATEX),
1749 X(MF_XVP_CALLER_ALLOCATES_OUTPUT),
1750 X(MF_MT_H264_SVC_CAPABILITIES),
1751 X(MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY),
1752 X(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH),
1753 X(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID),
1754 X(MF_SAMPLEGRABBERSINK_IGNORE_CLOCK),
1755 X(MF_SA_D3D11_SHARED),
1756 X(MF_MT_PAN_SCAN_ENABLED),
1757 X(MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID),
1758 X(MF_MT_DV_VAUX_CTRL_PACK),
1759 X(MFSampleExtension_ForwardedDecodeUnitType),
1760 X(MF_SA_D3D11_AWARE),
1761 X(MF_MT_AUDIO_AVG_BYTES_PER_SECOND),
1762 X(MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS),
1763 X(MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING),
1764 X(MF_TOPONODE_TRANSFORM_OBJECTID),
1765 X(MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE),
1766 X(MF_EVENT_MFT_INPUT_STREAM_ID),
1767 X(MF_MT_SOURCE_CONTENT_HINT),
1768 X(MFT_ENUM_HARDWARE_VENDOR_ID_Attribute),
1769 X(MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE),
1770 X(MF_READWRITE_MMCSS_PRIORITY),
1771 X(MF_MT_VIDEO_3D),
1772 X(MF_EVENT_START_PRESENTATION_TIME),
1773 X(MF_EVENT_SESSIONCAPS),
1774 X(MF_EVENT_PRESENTATION_TIME_OFFSET),
1775 X(MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE),
1776 X(MF_EVENT_SESSIONCAPS_DELTA),
1777 X(MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT),
1778 X(MFSampleExtension_DecodeTimestamp),
1779 X(MF_MEDIA_ENGINE_COMPATIBILITY_MODE),
1780 X(MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT),
1781 X(MF_MT_VIDEO_H264_NO_FMOASO),
1782 X(MF_MT_AVG_BIT_ERROR_RATE),
1783 X(MF_MT_VIDEO_PRIMARIES),
1784 X(MF_SINK_WRITER_DISABLE_THROTTLING),
1785 X(MF_MT_H264_RATE_CONTROL_MODES),
1786 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK),
1787 X(MF_READWRITE_D3D_OPTIONAL),
1788 X(MF_SA_D3D11_HW_PROTECTED),
1789 X(MF_MEDIA_ENGINE_DXGI_MANAGER),
1790 X(MF_READWRITE_MMCSS_CLASS_AUDIO),
1791 X(MF_MEDIA_ENGINE_COREWINDOW),
1792 X(MF_SOURCE_READER_DISABLE_CAMERA_PLUGINS),
1793 X(MF_MT_MPEG4_TRACK_TYPE),
1794 X(MF_ACTIVATE_VIDEO_WINDOW),
1795 X(MF_MT_PAN_SCAN_APERTURE),
1796 X(MF_TOPOLOGY_RESOLUTION_STATUS),
1797 X(MF_MT_ORIGINAL_4CC),
1798 X(MF_PD_AUDIO_ISVARIABLEBITRATE),
1799 X(MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS),
1800 X(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE),
1801 X(MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID),
1802 X(MF_MT_MPEG2_CONTENT_PACKET),
1803 X(MFT_PROCESS_LOCAL_Attribute),
1804 X(MFT_PROCESS_LOCAL_Attribute),
1805 X(MF_MT_PAD_CONTROL_FLAGS),
1806 X(MF_MT_VIDEO_NOMINAL_RANGE),
1807 X(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION),
1808 X(MF_MT_MPEG_SEQUENCE_HEADER),
1809 X(MF_MEDIA_ENGINE_OPM_HWND),
1810 X(MF_MT_AUDIO_SAMPLES_PER_SECOND),
1811 X(MF_MT_SPATIAL_AUDIO_DATA_PRESENT),
1812 X(MF_MT_FRAME_RATE),
1813 X(MF_TOPONODE_FLUSH),
1814 X(MF_MT_MPEG2_STANDARD),
1815 X(MF_TOPONODE_DRAIN),
1816 X(MF_MT_TRANSFER_FUNCTION),
1817 X(MF_TOPONODE_MEDIASTART),
1818 X(MF_TOPONODE_MEDIASTOP),
1819 X(MF_SOURCE_READER_MEDIASOURCE_CONFIG),
1820 X(MF_TOPONODE_SOURCE),
1821 X(MF_TOPONODE_PRESENTATION_DESCRIPTOR),
1822 X(MF_TOPONODE_D3DAWARE),
1823 X(MF_MT_COMPRESSED),
1824 X(MF_TOPONODE_STREAM_DESCRIPTOR),
1825 X(MF_TOPONODE_ERRORCODE),
1826 X(MF_TOPONODE_SEQUENCE_ELEMENTID),
1827 X(MF_EVENT_MFT_CONTEXT),
1828 X(MF_MT_FORWARD_CUSTOM_SEI),
1829 X(MF_TOPONODE_CONNECT_METHOD),
1830 X(MFT_OUTPUT_TYPES_Attributes),
1831 X(MF_MT_IMAGE_LOSS_TOLERANT),
1832 X(MF_SESSION_REMOTE_SOURCE_MODE),
1833 X(MF_MT_DEPTH_VALUE_UNIT),
1834 X(MF_MT_AUDIO_NUM_CHANNELS),
1835 X(MF_MT_ARBITRARY_HEADER),
1836 X(MF_TOPOLOGY_DXVA_MODE),
1837 X(MF_TOPONODE_LOCKED),
1838 X(MF_TOPONODE_WORKQUEUE_ID),
1839 X(MF_MEDIA_ENGINE_CONTINUE_ON_CODEC_ERROR),
1840 X(MF_TOPONODE_WORKQUEUE_MMCSS_CLASS),
1841 X(MF_TOPONODE_DECRYPTOR),
1842 X(MF_EVENT_DO_THINNING),
1843 X(MF_TOPONODE_DISCARDABLE),
1844 X(MF_TOPOLOGY_HARDWARE_MODE),
1845 X(MF_SOURCE_READER_DISABLE_DXVA),
1846 X(MF_MT_FORWARD_CUSTOM_NALU),
1847 X(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE10),
1848 X(MF_TOPONODE_ERROR_MAJORTYPE),
1849 X(MF_MT_SECURE),
1850 X(MFT_FIELDOFUSE_UNLOCK_Attribute),
1851 X(MF_TOPONODE_ERROR_SUBTYPE),
1852 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE),
1853 X(MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE),
1854 X(MF_MT_VIDEO_3D_LEFT_IS_BASE),
1855 X(MF_TOPONODE_WORKQUEUE_MMCSS_TASKID),
1856 #undef MF_READER_WRITER_D3D_MANAGER
1857 #undef X
1858 };
1859 struct guid_def *ret = NULL;
1860
1861 if (guid)
1862 ret = bsearch(guid, guid_defs, ARRAY_SIZE(guid_defs), sizeof(*guid_defs), debug_compare_guid);
1863
1864 return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbgstr_guid(guid);
1865 }
1866
1867 const char *debugstr_mf_guid(const GUID *guid)
1868 {
1869 static const struct guid_def guid_defs[] =
1870 {
1871 #define X(g) { &(g), #g }
1872 X(MFAudioFormat_ADTS),
1873 X(MFAudioFormat_PCM),
1874 X(MFAudioFormat_PCM_HDCP),
1875 X(MFAudioFormat_Float),
1876 X(MFAudioFormat_DTS),
1877 X(MFAudioFormat_DRM),
1878 X(MFAudioFormat_MSP1),
1879 X(MFAudioFormat_Vorbis),
1880 X(MFAudioFormat_AAC),
1881 X(MFVideoFormat_RGB24),
1882 X(MFVideoFormat_ARGB32),
1883 X(MFVideoFormat_RGB32),
1884 X(MFVideoFormat_RGB565),
1885 X(MFVideoFormat_RGB555),
1886 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID),
1887 X(MFVideoFormat_A2R10G10B10),
1888 X(MFMediaType_Script),
1889 X(MFMediaType_Image),
1890 X(MFMediaType_HTML),
1891 X(MFMediaType_Binary),
1892 X(MFVideoFormat_MPEG2),
1893 X(MFMediaType_FileTransfer),
1894 X(MFVideoFormat_RGB8),
1895 X(MFAudioFormat_Dolby_AC3),
1896 X(MFVideoFormat_L8),
1897 X(MFAudioFormat_LPCM),
1898 X(MFVideoFormat_420O),
1899 X(MFVideoFormat_AI44),
1900 X(MFVideoFormat_AV1),
1901 X(MFVideoFormat_AYUV),
1902 X(MFVideoFormat_H263),
1903 X(MFVideoFormat_H264),
1904 X(MFVideoFormat_H265),
1905 X(MFVideoFormat_HEVC),
1906 X(MFVideoFormat_HEVC_ES),
1907 X(MFVideoFormat_I420),
1908 X(MFVideoFormat_IYUV),
1909 X(MFVideoFormat_M4S2),
1910 X(MFVideoFormat_MJPG),
1911 X(MFVideoFormat_MP43),
1912 X(MFVideoFormat_MP4S),
1913 X(MFVideoFormat_MP4V),
1914 X(MFVideoFormat_MPG1),
1915 X(MFVideoFormat_MSS1),
1916 X(MFVideoFormat_MSS2),
1917 X(MFVideoFormat_NV11),
1918 X(MFVideoFormat_NV12),
1919 X(MFVideoFormat_ORAW),
1920 X(MFAudioFormat_Opus),
1921 X(MFVideoFormat_D16),
1922 X(MFAudioFormat_MPEG),
1923 X(MFVideoFormat_P010),
1924 X(MFVideoFormat_P016),
1925 X(MFVideoFormat_P210),
1926 X(MFVideoFormat_P216),
1927 X(MFVideoFormat_L16),
1928 X(MFAudioFormat_MP3),
1929 X(MFVideoFormat_UYVY),
1930 X(MFVideoFormat_VP10),
1931 X(MFVideoFormat_VP80),
1932 X(MFVideoFormat_VP90),
1933 X(MFVideoFormat_WMV1),
1934 X(MFVideoFormat_WMV2),
1935 X(MFVideoFormat_WMV3),
1936 X(MFVideoFormat_WVC1),
1937 X(MFVideoFormat_Y210),
1938 X(MFVideoFormat_Y216),
1939 X(MFVideoFormat_Y410),
1940 X(MFVideoFormat_Y416),
1941 X(MFVideoFormat_Y41P),
1942 X(MFVideoFormat_Y41T),
1943 X(MFVideoFormat_Y42T),
1944 X(MFVideoFormat_YUY2),
1945 X(MFVideoFormat_YV12),
1946 X(MFVideoFormat_YVU9),
1947 X(MFVideoFormat_YVYU),
1948 X(MFAudioFormat_WMAudioV8),
1949 X(MFAudioFormat_ALAC),
1950 X(MFAudioFormat_AMR_NB),
1951 X(MFMediaType_Audio),
1952 X(MFAudioFormat_WMAudioV9),
1953 X(MFAudioFormat_AMR_WB),
1954 X(MFAudioFormat_WMAudio_Lossless),
1955 X(MFAudioFormat_AMR_WP),
1956 X(MFAudioFormat_WMASPDIF),
1957 X(MFVideoFormat_DV25),
1958 X(MFVideoFormat_DV50),
1959 X(MFVideoFormat_DVC),
1960 X(MFVideoFormat_DVH1),
1961 X(MFVideoFormat_DVHD),
1962 X(MFVideoFormat_DVSD),
1963 X(MFVideoFormat_DVSL),
1964 X(MFVideoFormat_A16B16G16R16F),
1965 X(MFVideoFormat_v210),
1966 X(MFVideoFormat_v216),
1967 X(MFVideoFormat_v410),
1968 X(MFMediaType_Video),
1969 X(MFAudioFormat_AAC_HDCP),
1970 X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID),
1971 X(MFAudioFormat_Dolby_AC3_HDCP),
1972 X(MFMediaType_Subtitle),
1973 X(MFMediaType_Stream),
1974 X(MFAudioFormat_Dolby_AC3_SPDIF),
1975 X(MFAudioFormat_Float_SpatialObjects),
1976 X(MFMediaType_SAMI),
1977 X(MFAudioFormat_ADTS_HDCP),
1978 X(MFAudioFormat_FLAC),
1979 X(MFAudioFormat_Dolby_DDPlus),
1980 X(MFMediaType_MultiplexedFrames),
1981 X(MFAudioFormat_Base_HDCP),
1982 X(MFVideoFormat_Base_HDCP),
1983 X(MFVideoFormat_H264_HDCP),
1984 X(MFVideoFormat_HEVC_HDCP),
1985 X(MFMediaType_Default),
1986 X(MFMediaType_Protected),
1987 X(MFVideoFormat_H264_ES),
1988 X(MFMediaType_Perception),
1989 #undef X
1990 };
1991 struct guid_def *ret = NULL;
1992
1993 if (guid)
1994 ret = bsearch(guid, guid_defs, ARRAY_SIZE(guid_defs), sizeof(*guid_defs), debug_compare_guid);
1995
1996 return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbgstr_guid(guid);
1997 }
1998
1999 struct event_id
2000 {
2001 DWORD id;
2002 const char *name;
2003 };
2004
2005 static int __cdecl debug_event_id(const void *a, const void *b)
2006 {
2007 const DWORD *id = a;
2008 const struct event_id *event_id = b;
2009 return *id - event_id->id;
2010 }
2011
2012 static const char *debugstr_eventid(DWORD event)
2013 {
2014 static const struct event_id
2015 {
2016 DWORD id;
2017 const char *name;
2018 }
2019 event_ids[] =
2020 {
2021 #define X(e) { e, #e }
2022 X(MEUnknown),
2023 X(MEError),
2024 X(MEExtendedType),
2025 X(MENonFatalError),
2026 X(MESessionUnknown),
2027 X(MESessionTopologySet),
2028 X(MESessionTopologiesCleared),
2029 X(MESessionStarted),
2030 X(MESessionPaused),
2031 X(MESessionStopped),
2032 X(MESessionClosed),
2033 X(MESessionEnded),
2034 X(MESessionRateChanged),
2035 X(MESessionScrubSampleComplete),
2036 X(MESessionCapabilitiesChanged),
2037 X(MESessionTopologyStatus),
2038 X(MESessionNotifyPresentationTime),
2039 X(MENewPresentation),
2040 X(MELicenseAcquisitionStart),
2041 X(MELicenseAcquisitionCompleted),
2042 X(MEIndividualizationStart),
2043 X(MEIndividualizationCompleted),
2044 X(MEEnablerProgress),
2045 X(MEEnablerCompleted),
2046 X(MEPolicyError),
2047 X(MEPolicyReport),
2048 X(MEBufferingStarted),
2049 X(MEBufferingStopped),
2050 X(MEConnectStart),
2051 X(MEConnectEnd),
2052 X(MEReconnectStart),
2053 X(MEReconnectEnd),
2054 X(MERendererEvent),
2055 X(MESessionStreamSinkFormatChanged),
2056 X(MESourceUnknown),
2057 X(MESourceStarted),
2058 X(MEStreamStarted),
2059 X(MESourceSeeked),
2060 X(MEStreamSeeked),
2061 X(MENewStream),
2062 X(MEUpdatedStream),
2063 X(MESourceStopped),
2064 X(MEStreamStopped),
2065 X(MESourcePaused),
2066 X(MEStreamPaused),
2067 X(MEEndOfPresentation),
2068 X(MEEndOfStream),
2069 X(MEMediaSample),
2070 X(MEStreamTick),
2071 X(MEStreamThinMode),
2072 X(MEStreamFormatChanged),
2073 X(MESourceRateChanged),
2074 X(MEEndOfPresentationSegment),
2075 X(MESourceCharacteristicsChanged),
2076 X(MESourceRateChangeRequested),
2077 X(MESourceMetadataChanged),
2078 X(MESequencerSourceTopologyUpdated),
2079 X(MESinkUnknown),
2080 X(MEStreamSinkStarted),
2081 X(MEStreamSinkStopped),
2082 X(MEStreamSinkPaused),
2083 X(MEStreamSinkRateChanged),
2084 X(MEStreamSinkRequestSample),
2085 X(MEStreamSinkMarker),
2086 X(MEStreamSinkPrerolled),
2087 X(MEStreamSinkScrubSampleComplete),
2088 X(MEStreamSinkFormatChanged),
2089 X(MEStreamSinkDeviceChanged),
2090 X(MEQualityNotify),
2091 X(MESinkInvalidated),
2092 X(MEAudioSessionNameChanged),
2093 X(MEAudioSessionVolumeChanged),
2094 X(MEAudioSessionDeviceRemoved),
2095 X(MEAudioSessionServerShutdown),
2096 X(MEAudioSessionGroupingParamChanged),
2097 X(MEAudioSessionIconChanged),
2098 X(MEAudioSessionFormatChanged),
2099 X(MEAudioSessionDisconnected),
2100 X(MEAudioSessionExclusiveModeOverride),
2101 X(METrustUnknown),
2102 X(MEPolicyChanged),
2103 X(MEContentProtectionMessage),
2104 X(MEPolicySet),
2105 X(MEWMDRMLicenseBackupCompleted),
2106 X(MEWMDRMLicenseBackupProgress),
2107 X(MEWMDRMLicenseRestoreCompleted),
2108 X(MEWMDRMLicenseRestoreProgress),
2109 X(MEWMDRMLicenseAcquisitionCompleted),
2110 X(MEWMDRMIndividualizationCompleted),
2111 X(MEWMDRMIndividualizationProgress),
2112 X(MEWMDRMProximityCompleted),
2113 X(MEWMDRMLicenseStoreCleaned),
2114 X(MEWMDRMRevocationDownloadCompleted),
2115 X(METransformUnknown),
2116 X(METransformNeedInput),
2117 X(METransformHaveOutput),
2118 X(METransformDrainComplete),
2119 X(METransformMarker),
2120 X(METransformInputStreamStateChanged),
2121 X(MEByteStreamCharacteristicsChanged),
2122 X(MEVideoCaptureDeviceRemoved),
2123 X(MEVideoCaptureDevicePreempted),
2124 X(MEStreamSinkFormatInvalidated),
2125 X(MEEncodingParameters),
2126 X(MEContentProtectionMetadata),
2127 X(MEDeviceThermalStateChanged),
2128 #undef X
2129 };
2130
2131 struct event_id *ret = bsearch(&event, event_ids, ARRAY_SIZE(event_ids), sizeof(*event_ids), debug_event_id);
2132 return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbg_sprintf("%u", event);
2133 }
2134
2135 static inline struct attributes *impl_from_IMFAttributes(IMFAttributes *iface)
2136 {
2137 return CONTAINING_RECORD(iface, struct attributes, IMFAttributes_iface);
2138 }
2139
2140 static HRESULT WINAPI mfattributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
2141 {
2142 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
2143
2144 if (IsEqualIID(riid, &IID_IMFAttributes) ||
2145 IsEqualGUID(riid, &IID_IUnknown))
2146 {
2147 *out = iface;
2148 IMFAttributes_AddRef(iface);
2149 return S_OK;
2150 }
2151
2152 WARN("Unsupported %s.\n", debugstr_guid(riid));
2153 *out = NULL;
2154 return E_NOINTERFACE;
2155 }
2156
2157 static ULONG WINAPI mfattributes_AddRef(IMFAttributes *iface)
2158 {
2159 struct attributes *attributes = impl_from_IMFAttributes(iface);
2160 ULONG refcount = InterlockedIncrement(&attributes->ref);
2161
2162 TRACE("%p, refcount %d.\n", iface, refcount);
2163
2164 return refcount;
2165 }
2166
2167 static ULONG WINAPI mfattributes_Release(IMFAttributes *iface)
2168 {
2169 struct attributes *attributes = impl_from_IMFAttributes(iface);
2170 ULONG refcount = InterlockedDecrement(&attributes->ref);
2171
2172 TRACE("%p, refcount %d.\n", iface, refcount);
2173
2174 if (!refcount)
2175 {
2176 clear_attributes_object(attributes);
2177 free(attributes);
2178 }
2179
2180 return refcount;
2181 }
2182
2183 static struct attribute *attributes_find_item(struct attributes *attributes, REFGUID key, size_t *index)
2184 {
2185 size_t i;
2186
2187 for (i = 0; i < attributes->count; ++i)
2188 {
2189 if (IsEqualGUID(key, &attributes->attributes[i].key))
2190 {
2191 if (index)
2192 *index = i;
2193 return &attributes->attributes[i];
2194 }
2195 }
2196
2197 return NULL;
2198 }
2199
2200 static HRESULT attributes_get_item(struct attributes *attributes, const GUID *key, PROPVARIANT *value)
2201 {
2202 struct attribute *attribute;
2203 HRESULT hr;
2204
2205 EnterCriticalSection(&attributes->cs);
2206
2207 attribute = attributes_find_item(attributes, key, NULL);
2208 if (attribute)
2209 {
2210 if (attribute->value.vt == value->vt && !(value->vt == VT_UNKNOWN && !attribute->value.punkVal))
2211 hr = PropVariantCopy(value, &attribute->value);
2212 else
2213 hr = MF_E_INVALIDTYPE;
2214 }
2215 else
2216 hr = MF_E_ATTRIBUTENOTFOUND;
2217
2218 LeaveCriticalSection(&attributes->cs);
2219
2220 return hr;
2221 }
2222
2223 HRESULT attributes_GetItem(struct attributes *attributes, REFGUID key, PROPVARIANT *value)
2224 {
2225 struct attribute *attribute;
2226 HRESULT hr;
2227
2228 EnterCriticalSection(&attributes->cs);
2229
2230 if ((attribute = attributes_find_item(attributes, key, NULL)))
2231 hr = value ? PropVariantCopy(value, &attribute->value) : S_OK;
2232 else
2233 hr = MF_E_ATTRIBUTENOTFOUND;
2234
2235 LeaveCriticalSection(&attributes->cs);
2236
2237 return hr;
2238 }
2239
2240 HRESULT attributes_GetItemType(struct attributes *attributes, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2241 {
2242 struct attribute *attribute;
2243 HRESULT hr = S_OK;
2244
2245 EnterCriticalSection(&attributes->cs);
2246
2247 if ((attribute = attributes_find_item(attributes, key, NULL)))
2248 {
2249 *type = attribute->value.vt;
2250 }
2251 else
2252 hr = MF_E_ATTRIBUTENOTFOUND;
2253
2254 LeaveCriticalSection(&attributes->cs);
2255
2256 return hr;
2257 }
2258
2259 HRESULT attributes_CompareItem(struct attributes *attributes, REFGUID key, REFPROPVARIANT value, BOOL *result)
2260 {
2261 struct attribute *attribute;
2262
2263 *result = FALSE;
2264
2265 EnterCriticalSection(&attributes->cs);
2266
2267 if ((attribute = attributes_find_item(attributes, key, NULL)))
2268 {
2269 *result = attribute->value.vt == value->vt &&
2270 !PropVariantCompareEx(&attribute->value, value, PVCU_DEFAULT, PVCF_DEFAULT);
2271 }
2272
2273 LeaveCriticalSection(&attributes->cs);
2274
2275 return S_OK;
2276 }
2277
2278 HRESULT attributes_Compare(struct attributes *attributes, IMFAttributes *theirs,
2279 MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
2280 {
2281 IMFAttributes *smaller, *other;
2282 MF_ATTRIBUTE_TYPE type;
2283 HRESULT hr = S_OK;
2284 UINT32 count;
2285 BOOL result;
2286 size_t i;
2287
2288 if (FAILED(hr = IMFAttributes_GetCount(theirs, &count)))
2289 return hr;
2290
2291 EnterCriticalSection(&attributes->cs);
2292
2293 result = TRUE;
2294
2295 switch (match_type)
2296 {
2297 case MF_ATTRIBUTES_MATCH_OUR_ITEMS:
2298 for (i = 0; i < attributes->count; ++i)
2299 {
2300 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2301 &attributes->attributes[i].value, &result)))
2302 break;
2303 if (!result)
2304 break;
2305 }
2306 break;
2307 case MF_ATTRIBUTES_MATCH_THEIR_ITEMS:
2308 hr = IMFAttributes_Compare(theirs, &attributes->IMFAttributes_iface, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result);
2309 break;
2310 case MF_ATTRIBUTES_MATCH_ALL_ITEMS:
2311 if (count != attributes->count)
2312 {
2313 result = FALSE;
2314 break;
2315 }
2316 for (i = 0; i < count; ++i)
2317 {
2318 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2319 &attributes->attributes[i].value, &result)))
2320 break;
2321 if (!result)
2322 break;
2323 }
2324 break;
2325 case MF_ATTRIBUTES_MATCH_INTERSECTION:
2326 for (i = 0; i < attributes->count; ++i)
2327 {
2328 if (FAILED(IMFAttributes_GetItemType(theirs, &attributes->attributes[i].key, &type)))
2329 continue;
2330
2331 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2332 &attributes->attributes[i].value, &result)))
2333 break;
2334
2335 if (!result)
2336 break;
2337 }
2338 break;
2339 case MF_ATTRIBUTES_MATCH_SMALLER:
2340 smaller = attributes->count > count ? theirs : &attributes->IMFAttributes_iface;
2341 other = attributes->count > count ? &attributes->IMFAttributes_iface : theirs;
2342 hr = IMFAttributes_Compare(smaller, other, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result);
2343 break;
2344 default:
2345 WARN("Unknown match type %d.\n", match_type);
2346 hr = E_INVALIDARG;
2347 }
2348
2349 LeaveCriticalSection(&attributes->cs);
2350
2351 if (SUCCEEDED(hr))
2352 *ret = result;
2353
2354 return hr;
2355 }
2356
2357 HRESULT attributes_GetUINT32(struct attributes *attributes, REFGUID key, UINT32 *value)
2358 {
2359 PROPVARIANT attrval;
2360 HRESULT hr;
2361
2362 PropVariantInit(&attrval);
2363 attrval.vt = VT_UI4;
2364 hr = attributes_get_item(attributes, key, &attrval);
2365 if (SUCCEEDED(hr))
2366 *value = attrval.ulVal;
2367
2368 return hr;
2369 }
2370
2371 HRESULT attributes_GetUINT64(struct attributes *attributes, REFGUID key, UINT64 *value)
2372 {
2373 PROPVARIANT attrval;
2374 HRESULT hr;
2375
2376 PropVariantInit(&attrval);
2377 attrval.vt = VT_UI8;
2378 hr = attributes_get_item(attributes, key, &attrval);
2379 if (SUCCEEDED(hr))
2380 *value = attrval.uhVal.QuadPart;
2381
2382 return hr;
2383 }
2384
2385 HRESULT attributes_GetDouble(struct attributes *attributes, REFGUID key, double *value)
2386 {
2387 PROPVARIANT attrval;
2388 HRESULT hr;
2389
2390 PropVariantInit(&attrval);
2391 attrval.vt = VT_R8;
2392 hr = attributes_get_item(attributes, key, &attrval);
2393 if (SUCCEEDED(hr))
2394 *value = attrval.dblVal;
2395
2396 return hr;
2397 }
2398
2399 HRESULT attributes_GetGUID(struct attributes *attributes, REFGUID key, GUID *value)
2400 {
2401 struct attribute *attribute;
2402 HRESULT hr = S_OK;
2403
2404 EnterCriticalSection(&attributes->cs);
2405
2406 attribute = attributes_find_item(attributes, key, NULL);
2407 if (attribute)
2408 {
2409 if (attribute->value.vt == MF_ATTRIBUTE_GUID)
2410 *value = *attribute->value.puuid;
2411 else
2412 hr = MF_E_INVALIDTYPE;
2413 }
2414 else
2415 hr = MF_E_ATTRIBUTENOTFOUND;
2416
2417 LeaveCriticalSection(&attributes->cs);
2418
2419 return hr;
2420 }
2421
2422 HRESULT attributes_GetStringLength(struct attributes *attributes, REFGUID key, UINT32 *length)
2423 {
2424 struct attribute *attribute;
2425 HRESULT hr = S_OK;
2426
2427 EnterCriticalSection(&attributes->cs);
2428
2429 attribute = attributes_find_item(attributes, key, NULL);
2430 if (attribute)
2431 {
2432 if (attribute->value.vt == MF_ATTRIBUTE_STRING)
2433 *length = lstrlenW(attribute->value.pwszVal);
2434 else
2435 hr = MF_E_INVALIDTYPE;
2436 }
2437 else
2438 hr = MF_E_ATTRIBUTENOTFOUND;
2439
2440 LeaveCriticalSection(&attributes->cs);
2441
2442 return hr;
2443 }
2444
2445 HRESULT attributes_GetString(struct attributes *attributes, REFGUID key, WCHAR *value,
2446 UINT32 size, UINT32 *length)
2447 {
2448 struct attribute *attribute;
2449 HRESULT hr = S_OK;
2450
2451 EnterCriticalSection(&attributes->cs);
2452
2453 attribute = attributes_find_item(attributes, key, NULL);
2454 if (attribute)
2455 {
2456 if (attribute->value.vt == MF_ATTRIBUTE_STRING)
2457 {
2458 int len = lstrlenW(attribute->value.pwszVal);
2459
2460 if (length)
2461 *length = len;
2462
2463 if (size <= len)
2464 hr = STRSAFE_E_INSUFFICIENT_BUFFER;
2465 else
2466 memcpy(value, attribute->value.pwszVal, (len + 1) * sizeof(WCHAR));
2467 }
2468 else
2469 hr = MF_E_INVALIDTYPE;
2470 }
2471 else
2472 hr = MF_E_ATTRIBUTENOTFOUND;
2473
2474 LeaveCriticalSection(&attributes->cs);
2475
2476 return hr;
2477 }
2478
2479 HRESULT attributes_GetAllocatedString(struct attributes *attributes, REFGUID key, WCHAR **value, UINT32 *length)
2480 {
2481 PROPVARIANT attrval;
2482 HRESULT hr;
2483
2484 PropVariantInit(&attrval);
2485 attrval.vt = VT_LPWSTR;
2486 hr = attributes_get_item(attributes, key, &attrval);
2487 if (SUCCEEDED(hr))
2488 {
2489 *value = attrval.pwszVal;
2490 *length = lstrlenW(*value);
2491 }
2492
2493 return hr;
2494 }
2495
2496 HRESULT attributes_GetBlobSize(struct attributes *attributes, REFGUID key, UINT32 *size)
2497 {
2498 struct attribute *attribute;
2499 HRESULT hr = S_OK;
2500
2501 EnterCriticalSection(&attributes->cs);
2502
2503 attribute = attributes_find_item(attributes, key, NULL);
2504 if (attribute)
2505 {
2506 if (attribute->value.vt == MF_ATTRIBUTE_BLOB)
2507 *size = attribute->value.caub.cElems;
2508 else
2509 hr = MF_E_INVALIDTYPE;
2510 }
2511 else
2512 hr = MF_E_ATTRIBUTENOTFOUND;
2513
2514 LeaveCriticalSection(&attributes->cs);
2515
2516 return hr;
2517 }
2518
2519 HRESULT attributes_GetBlob(struct attributes *attributes, REFGUID key, UINT8 *buf, UINT32 bufsize, UINT32 *blobsize)
2520 {
2521 struct attribute *attribute;
2522 HRESULT hr;
2523
2524 EnterCriticalSection(&attributes->cs);
2525
2526 attribute = attributes_find_item(attributes, key, NULL);
2527 if (attribute)
2528 {
2529 if (attribute->value.vt == MF_ATTRIBUTE_BLOB)
2530 {
2531 UINT32 size = attribute->value.caub.cElems;
2532
2533 if (bufsize >= size)
2534 hr = PropVariantToBuffer(&attribute->value, buf, size);
2535 else
2536 hr = E_NOT_SUFFICIENT_BUFFER;
2537
2538 if (blobsize)
2539 *blobsize = size;
2540 }
2541 else
2542 hr = MF_E_INVALIDTYPE;
2543 }
2544 else
2545 hr = MF_E_ATTRIBUTENOTFOUND;
2546
2547 LeaveCriticalSection(&attributes->cs);
2548
2549 return hr;
2550 }
2551
2552 HRESULT attributes_GetAllocatedBlob(struct attributes *attributes, REFGUID key, UINT8 **buf, UINT32 *size)
2553 {
2554 PROPVARIANT attrval;
2555 HRESULT hr;
2556
2557 attrval.vt = VT_VECTOR | VT_UI1;
2558 hr = attributes_get_item(attributes, key, &attrval);
2559 if (SUCCEEDED(hr))
2560 {
2561 *buf = attrval.caub.pElems;
2562 *size = attrval.caub.cElems;
2563 }
2564
2565 return hr;
2566 }
2567
2568 HRESULT attributes_GetUnknown(struct attributes *attributes, REFGUID key, REFIID riid, void **out)
2569 {
2570 PROPVARIANT attrval;
2571 HRESULT hr;
2572
2573 PropVariantInit(&attrval);
2574 attrval.vt = VT_UNKNOWN;
2575 hr = attributes_get_item(attributes, key, &attrval);
2576 if (SUCCEEDED(hr))
2577 hr = IUnknown_QueryInterface(attrval.punkVal, riid, out);
2578 PropVariantClear(&attrval);
2579 return hr;
2580 }
2581
2582 static HRESULT attributes_set_item(struct attributes *attributes, REFGUID key, REFPROPVARIANT value)
2583 {
2584 struct attribute *attribute;
2585
2586 EnterCriticalSection(&attributes->cs);
2587
2588 attribute = attributes_find_item(attributes, key, NULL);
2589 if (!attribute)
2590 {
2591 if (!mf_array_reserve((void **)&attributes->attributes, &attributes->capacity, attributes->count + 1,
2592 sizeof(*attributes->attributes)))
2593 {
2594 LeaveCriticalSection(&attributes->cs);
2595 return E_OUTOFMEMORY;
2596 }
2597 attributes->attributes[attributes->count].key = *key;
2598 attribute = &attributes->attributes[attributes->count++];
2599 }
2600 else
2601 PropVariantClear(&attribute->value);
2602
2603 PropVariantCopy(&attribute->value, value);
2604
2605 LeaveCriticalSection(&attributes->cs);
2606
2607 return S_OK;
2608 }
2609
2610 HRESULT attributes_SetItem(struct attributes *attributes, REFGUID key, REFPROPVARIANT value)
2611 {
2612 PROPVARIANT empty;
2613
2614 switch (value->vt)
2615 {
2616 case MF_ATTRIBUTE_UINT32:
2617 case MF_ATTRIBUTE_UINT64:
2618 case MF_ATTRIBUTE_DOUBLE:
2619 case MF_ATTRIBUTE_GUID:
2620 case MF_ATTRIBUTE_STRING:
2621 case MF_ATTRIBUTE_BLOB:
2622 case MF_ATTRIBUTE_IUNKNOWN:
2623 return attributes_set_item(attributes, key, value);
2624 default:
2625 PropVariantInit(&empty);
2626 attributes_set_item(attributes, key, &empty);
2627 return MF_E_INVALIDTYPE;
2628 }
2629 }
2630
2631 HRESULT attributes_DeleteItem(struct attributes *attributes, REFGUID key)
2632 {
2633 struct attribute *attribute;
2634 size_t index = 0;
2635
2636 EnterCriticalSection(&attributes->cs);
2637
2638 if ((attribute = attributes_find_item(attributes, key, &index)))
2639 {
2640 size_t count;
2641
2642 PropVariantClear(&attribute->value);
2643
2644 attributes->count--;
2645 count = attributes->count - index;
2646 if (count)
2647 memmove(&attributes->attributes[index], &attributes->attributes[index + 1], count * sizeof(*attributes->attributes));
2648 }
2649
2650 LeaveCriticalSection(&attributes->cs);
2651
2652 return S_OK;
2653 }
2654
2655 HRESULT attributes_DeleteAllItems(struct attributes *attributes)
2656 {
2657 EnterCriticalSection(&attributes->cs);
2658
2659 while (attributes->count)
2660 {
2661 PropVariantClear(&attributes->attributes[--attributes->count].value);
2662 }
2663 free(attributes->attributes);
2664 attributes->attributes = NULL;
2665 attributes->capacity = 0;
2666
2667 LeaveCriticalSection(&attributes->cs);
2668
2669 return S_OK;
2670 }
2671
2672 HRESULT attributes_SetUINT32(struct attributes *attributes, REFGUID key, UINT32 value)
2673 {
2674 PROPVARIANT attrval;
2675
2676 attrval.vt = VT_UI4;
2677 attrval.ulVal = value;
2678 return attributes_set_item(attributes, key, &attrval);
2679 }
2680
2681 HRESULT attributes_SetUINT64(struct attributes *attributes, REFGUID key, UINT64 value)
2682 {
2683 PROPVARIANT attrval;
2684
2685 attrval.vt = VT_UI8;
2686 attrval.uhVal.QuadPart = value;
2687 return attributes_set_item(attributes, key, &attrval);
2688 }
2689
2690 HRESULT attributes_SetDouble(struct attributes *attributes, REFGUID key, double value)
2691 {
2692 PROPVARIANT attrval;
2693
2694 attrval.vt = VT_R8;
2695 attrval.dblVal = value;
2696 return attributes_set_item(attributes, key, &attrval);
2697 }
2698
2699 HRESULT attributes_SetGUID(struct attributes *attributes, REFGUID key, REFGUID value)
2700 {
2701 PROPVARIANT attrval;
2702
2703 attrval.vt = VT_CLSID;
2704 attrval.puuid = (CLSID *)value;
2705 return attributes_set_item(attributes, key, &attrval);
2706 }
2707
2708 HRESULT attributes_SetString(struct attributes *attributes, REFGUID key, const WCHAR *value)
2709 {
2710 PROPVARIANT attrval;
2711
2712 attrval.vt = VT_LPWSTR;
2713 attrval.pwszVal = (WCHAR *)value;
2714 return attributes_set_item(attributes, key, &attrval);
2715 }
2716
2717 HRESULT attributes_SetBlob(struct attributes *attributes, REFGUID key, const UINT8 *buf, UINT32 size)
2718 {
2719 PROPVARIANT attrval;
2720
2721 attrval.vt = VT_VECTOR | VT_UI1;
2722 attrval.caub.cElems = size;
2723 attrval.caub.pElems = (UINT8 *)buf;
2724 return attributes_set_item(attributes, key, &attrval);
2725 }
2726
2727 HRESULT attributes_SetUnknown(struct attributes *attributes, REFGUID key, IUnknown *unknown)
2728 {
2729 PROPVARIANT attrval;
2730
2731 attrval.vt = VT_UNKNOWN;
2732 attrval.punkVal = unknown;
2733 return attributes_set_item(attributes, key, &attrval);
2734 }
2735
2736 HRESULT attributes_LockStore(struct attributes *attributes)
2737 {
2738 EnterCriticalSection(&attributes->cs);
2739
2740 return S_OK;
2741 }
2742
2743 HRESULT attributes_UnlockStore(struct attributes *attributes)
2744 {
2745 LeaveCriticalSection(&attributes->cs);
2746
2747 return S_OK;
2748 }
2749
2750 HRESULT attributes_GetCount(struct attributes *attributes, UINT32 *count)
2751 {
2752 EnterCriticalSection(&attributes->cs);
2753 *count = attributes->count;
2754 LeaveCriticalSection(&attributes->cs);
2755
2756 return S_OK;
2757 }
2758
2759 HRESULT attributes_GetItemByIndex(struct attributes *attributes, UINT32 index, GUID *key, PROPVARIANT *value)
2760 {
2761 HRESULT hr = S_OK;
2762
2763 EnterCriticalSection(&attributes->cs);
2764
2765 if (index < attributes->count)
2766 {
2767 *key = attributes->attributes[index].key;
2768 if (value)
2769 PropVariantCopy(value, &attributes->attributes[index].value);
2770 }
2771 else
2772 hr = E_INVALIDARG;
2773
2774 LeaveCriticalSection(&attributes->cs);
2775
2776 return hr;
2777 }
2778
2779 HRESULT attributes_CopyAllItems(struct attributes *attributes, IMFAttributes *dest)
2780 {
2781 HRESULT hr = S_OK;
2782 size_t i;
2783
2784 EnterCriticalSection(&attributes->cs);
2785
2786 IMFAttributes_LockStore(dest);
2787
2788 IMFAttributes_DeleteAllItems(dest);
2789
2790 for (i = 0; i < attributes->count; ++i)
2791 {
2792 hr = IMFAttributes_SetItem(dest, &attributes->attributes[i].key, &attributes->attributes[i].value);
2793 if (FAILED(hr))
2794 break;
2795 }
2796
2797 IMFAttributes_UnlockStore(dest);
2798
2799 LeaveCriticalSection(&attributes->cs);
2800
2801 return hr;
2802 }
2803
2804 static HRESULT WINAPI mfattributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
2805 {
2806 struct attributes *attributes = impl_from_IMFAttributes(iface);
2807
2808 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2809
2810 return attributes_GetItem(attributes, key, value);
2811 }
2812
2813 static HRESULT WINAPI mfattributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2814 {
2815 struct attributes *attributes = impl_from_IMFAttributes(iface);
2816
2817 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
2818
2819 return attributes_GetItemType(attributes, key, type);
2820 }
2821
2822 static HRESULT WINAPI mfattributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
2823 {
2824 struct attributes *attributes = impl_from_IMFAttributes(iface);
2825
2826 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
2827
2828 return attributes_CompareItem(attributes, key, value, result);
2829 }
2830
2831 static HRESULT WINAPI mfattributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
2832 MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
2833 {
2834 struct attributes *attributes = impl_from_IMFAttributes(iface);
2835
2836 TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
2837
2838 return attributes_Compare(attributes, theirs, match_type, ret);
2839 }
2840
2841 static HRESULT WINAPI mfattributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
2842 {
2843 struct attributes *attributes = impl_from_IMFAttributes(iface);
2844
2845 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2846
2847 return attributes_GetUINT32(attributes, key, value);
2848 }
2849
2850 static HRESULT WINAPI mfattributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
2851 {
2852 struct attributes *attributes = impl_from_IMFAttributes(iface);
2853
2854 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2855
2856 return attributes_GetUINT64(attributes, key, value);
2857 }
2858
2859 static HRESULT WINAPI mfattributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
2860 {
2861 struct attributes *attributes = impl_from_IMFAttributes(iface);
2862
2863 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2864
2865 return attributes_GetDouble(attributes, key, value);
2866 }
2867
2868 static HRESULT WINAPI mfattributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
2869 {
2870 struct attributes *attributes = impl_from_IMFAttributes(iface);
2871
2872 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2873
2874 return attributes_GetGUID(attributes, key, value);
2875 }
2876
2877 static HRESULT WINAPI mfattributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
2878 {
2879 struct attributes *attributes = impl_from_IMFAttributes(iface);
2880
2881 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
2882
2883 return attributes_GetStringLength(attributes, key, length);
2884 }
2885
2886 static HRESULT WINAPI mfattributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
2887 UINT32 size, UINT32 *length)
2888 {
2889 struct attributes *attributes = impl_from_IMFAttributes(iface);
2890
2891 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
2892
2893 return attributes_GetString(attributes, key, value, size, length);
2894 }
2895
2896 static HRESULT WINAPI mfattributes_GetAllocatedString(IMFAttributes *iface, REFGUID key, WCHAR **value, UINT32 *length)
2897 {
2898 struct attributes *attributes = impl_from_IMFAttributes(iface);
2899
2900 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
2901
2902 return attributes_GetAllocatedString(attributes, key, value, length);
2903 }
2904
2905 static HRESULT WINAPI mfattributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
2906 {
2907 struct attributes *attributes = impl_from_IMFAttributes(iface);
2908
2909 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
2910
2911 return attributes_GetBlobSize(attributes, key, size);
2912 }
2913
2914 static HRESULT WINAPI mfattributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
2915 UINT32 bufsize, UINT32 *blobsize)
2916 {
2917 struct attributes *attributes = impl_from_IMFAttributes(iface);
2918
2919 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
2920
2921 return attributes_GetBlob(attributes, key, buf, bufsize, blobsize);
2922 }
2923
2924 static HRESULT WINAPI mfattributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
2925 {
2926 struct attributes *attributes = impl_from_IMFAttributes(iface);
2927
2928 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
2929
2930 return attributes_GetAllocatedBlob(attributes, key, buf, size);
2931 }
2932
2933 static HRESULT WINAPI mfattributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
2934 {
2935 struct attributes *attributes = impl_from_IMFAttributes(iface);
2936
2937 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
2938
2939 return attributes_GetUnknown(attributes, key, riid, out);
2940 }
2941
2942 static HRESULT WINAPI mfattributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
2943 {
2944 struct attributes *attributes = impl_from_IMFAttributes(iface);
2945
2946 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
2947
2948 return attributes_SetItem(attributes, key, value);
2949 }
2950
2951 static HRESULT WINAPI mfattributes_DeleteItem(IMFAttributes *iface, REFGUID key)
2952 {
2953 struct attributes *attributes = impl_from_IMFAttributes(iface);
2954
2955 TRACE("%p, %s.\n", iface, debugstr_attr(key));
2956
2957 return attributes_DeleteItem(attributes, key);
2958 }
2959
2960 static HRESULT WINAPI mfattributes_DeleteAllItems(IMFAttributes *iface)
2961 {
2962 struct attributes *attributes = impl_from_IMFAttributes(iface);
2963
2964 TRACE("%p.\n", iface);
2965
2966 return attributes_DeleteAllItems(attributes);
2967 }
2968
2969 static HRESULT WINAPI mfattributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
2970 {
2971 struct attributes *attributes = impl_from_IMFAttributes(iface);
2972
2973 TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
2974
2975 return attributes_SetUINT32(attributes, key, value);
2976 }
2977
2978 static HRESULT WINAPI mfattributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
2979 {
2980 struct attributes *attributes = impl_from_IMFAttributes(iface);
2981
2982 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
2983
2984 return attributes_SetUINT64(attributes, key, value);
2985 }
2986
2987 static HRESULT WINAPI mfattributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2988 {
2989 struct attributes *attributes = impl_from_IMFAttributes(iface);
2990
2991 TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
2992
2993 return attributes_SetDouble(attributes, key, value);
2994 }
2995
2996 static HRESULT WINAPI mfattributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2997 {
2998 struct attributes *attributes = impl_from_IMFAttributes(iface);
2999
3000 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
3001
3002 return attributes_SetGUID(attributes, key, value);
3003 }
3004
3005 static HRESULT WINAPI mfattributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
3006 {
3007 struct attributes *attributes = impl_from_IMFAttributes(iface);
3008
3009 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
3010
3011 return attributes_SetString(attributes, key, value);
3012 }
3013
3014 static HRESULT WINAPI mfattributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
3015 {
3016 struct attributes *attributes = impl_from_IMFAttributes(iface);
3017
3018 TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
3019
3020 return attributes_SetBlob(attributes, key, buf, size);
3021 }
3022
3023 static HRESULT WINAPI mfattributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
3024 {
3025 struct attributes *attributes = impl_from_IMFAttributes(iface);
3026
3027 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
3028
3029 return attributes_SetUnknown(attributes, key, unknown);
3030 }
3031
3032 static HRESULT WINAPI mfattributes_LockStore(IMFAttributes *iface)
3033 {
3034 struct attributes *attributes = impl_from_IMFAttributes(iface);
3035
3036 TRACE("%p.\n", iface);
3037
3038 return attributes_LockStore(attributes);
3039 }
3040
3041 static HRESULT WINAPI mfattributes_UnlockStore(IMFAttributes *iface)
3042 {
3043 struct attributes *attributes = impl_from_IMFAttributes(iface);
3044
3045 TRACE("%p.\n", iface);
3046
3047 return attributes_UnlockStore(attributes);
3048 }
3049
3050 static HRESULT WINAPI mfattributes_GetCount(IMFAttributes *iface, UINT32 *count)
3051 {
3052 struct attributes *attributes = impl_from_IMFAttributes(iface);
3053
3054 TRACE("%p, %p.\n", iface, count);
3055
3056 return attributes_GetCount(attributes, count);
3057 }
3058
3059 static HRESULT WINAPI mfattributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
3060 {
3061 struct attributes *attributes = impl_from_IMFAttributes(iface);
3062
3063 TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
3064
3065 return attributes_GetItemByIndex(attributes, index, key, value);
3066 }
3067
3068 static HRESULT WINAPI mfattributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
3069 {
3070 struct attributes *attributes = impl_from_IMFAttributes(iface);
3071
3072 TRACE("%p, %p.\n", iface, dest);
3073
3074 return attributes_CopyAllItems(attributes, dest);
3075 }
3076
3077 static const IMFAttributesVtbl mfattributes_vtbl =
3078 {
3079 mfattributes_QueryInterface,
3080 mfattributes_AddRef,
3081 mfattributes_Release,
3082 mfattributes_GetItem,
3083 mfattributes_GetItemType,
3084 mfattributes_CompareItem,
3085 mfattributes_Compare,
3086 mfattributes_GetUINT32,
3087 mfattributes_GetUINT64,
3088 mfattributes_GetDouble,
3089 mfattributes_GetGUID,
3090 mfattributes_GetStringLength,
3091 mfattributes_GetString,
3092 mfattributes_GetAllocatedString,
3093 mfattributes_GetBlobSize,
3094 mfattributes_GetBlob,
3095 mfattributes_GetAllocatedBlob,
3096 mfattributes_GetUnknown,
3097 mfattributes_SetItem,
3098 mfattributes_DeleteItem,
3099 mfattributes_DeleteAllItems,
3100 mfattributes_SetUINT32,
3101 mfattributes_SetUINT64,
3102 mfattributes_SetDouble,
3103 mfattributes_SetGUID,
3104 mfattributes_SetString,
3105 mfattributes_SetBlob,
3106 mfattributes_SetUnknown,
3107 mfattributes_LockStore,
3108 mfattributes_UnlockStore,
3109 mfattributes_GetCount,
3110 mfattributes_GetItemByIndex,
3111 mfattributes_CopyAllItems
3112 };
3113
3114 HRESULT init_attributes_object(struct attributes *object, UINT32 size)
3115 {
3116 object->IMFAttributes_iface.lpVtbl = &mfattributes_vtbl;
3117 object->ref = 1;
3118 InitializeCriticalSection(&object->cs);
3119
3120 object->attributes = NULL;
3121 object->count = 0;
3122 object->capacity = 0;
3123 if (!mf_array_reserve((void **)&object->attributes, &object->capacity, size,
3124 sizeof(*object->attributes)))
3125 {
3126 DeleteCriticalSection(&object->cs);
3127 return E_OUTOFMEMORY;
3128 }
3129
3130 return S_OK;
3131 }
3132
3133 void clear_attributes_object(struct attributes *object)
3134 {
3135 size_t i;
3136
3137 for (i = 0; i < object->count; i++)
3138 PropVariantClear(&object->attributes[i].value);
3139 free(object->attributes);
3140
3141 DeleteCriticalSection(&object->cs);
3142 }
3143
3144 /***********************************************************************
3145 * MFCreateAttributes (mfplat.@)
3146 */
3147 HRESULT WINAPI MFCreateAttributes(IMFAttributes **attributes, UINT32 size)
3148 {
3149 struct attributes *object;
3150 HRESULT hr;
3151
3152 TRACE("%p, %d\n", attributes, size);
3153
3154 if (!(object = calloc(1, sizeof(*object))))
3155 return E_OUTOFMEMORY;
3156
3157 if (FAILED(hr = init_attributes_object(object, size)))
3158 {
3159 free(object);
3160 return hr;
3161 }
3162 *attributes = &object->IMFAttributes_iface;
3163
3164 return S_OK;
3165 }
3166
3167 #define ATTRIBUTES_STORE_MAGIC 0x494d4641 /* IMFA */
3168
3169 struct attributes_store_header
3170 {
3171 DWORD magic;
3172 UINT32 count;
3173 };
3174
3175 struct attributes_store_item
3176 {
3177 GUID key;
3178 QWORD type;
3179 union
3180 {
3181 double f;
3182 UINT32 i32;
3183 UINT64 i64;
3184 struct
3185 {
3186 DWORD size;
3187 DWORD offset;
3188 } subheader;
3189 } u;
3190 };
3191
3192 /***********************************************************************
3193 * MFGetAttributesAsBlobSize (mfplat.@)
3194 */
3195 HRESULT WINAPI MFGetAttributesAsBlobSize(IMFAttributes *attributes, UINT32 *size)
3196 {
3197 unsigned int i, count, length;
3198 HRESULT hr;
3199 GUID key;
3200
3201 TRACE("%p, %p.\n", attributes, size);
3202
3203 IMFAttributes_LockStore(attributes);
3204
3205 hr = IMFAttributes_GetCount(attributes, &count);
3206
3207 *size = sizeof(struct attributes_store_header);
3208
3209 for (i = 0; i < count; ++i)
3210 {
3211 MF_ATTRIBUTE_TYPE type;
3212
3213 hr = IMFAttributes_GetItemByIndex(attributes, i, &key, NULL);
3214 if (FAILED(hr))
3215 break;
3216
3217 *size += sizeof(struct attributes_store_item);
3218
3219 IMFAttributes_GetItemType(attributes, &key, &type);
3220
3221 switch (type)
3222 {
3223 case MF_ATTRIBUTE_GUID:
3224 *size += sizeof(GUID);
3225 break;
3226 case MF_ATTRIBUTE_STRING:
3227 IMFAttributes_GetStringLength(attributes, &key, &length);
3228 *size += (length + 1) * sizeof(WCHAR);
3229 break;
3230 case MF_ATTRIBUTE_BLOB:
3231 IMFAttributes_GetBlobSize(attributes, &key, &length);
3232 *size += length;
3233 break;
3234 case MF_ATTRIBUTE_UINT32:
3235 case MF_ATTRIBUTE_UINT64:
3236 case MF_ATTRIBUTE_DOUBLE:
3237 case MF_ATTRIBUTE_IUNKNOWN:
3238 default:
3239 ;
3240 }
3241 }
3242
3243 IMFAttributes_UnlockStore(attributes);
3244
3245 return hr;
3246 }
3247
3248 struct attr_serialize_context
3249 {
3250 UINT8 *buffer;
3251 UINT8 *ptr;
3252 UINT32 size;
3253 };
3254
3255 static void attributes_serialize_write(struct attr_serialize_context *context, const void *value, unsigned int size)
3256 {
3257 memcpy(context->ptr, value, size);
3258 context->ptr += size;
3259 }
3260
3261 static BOOL attributes_serialize_write_item(struct attr_serialize_context *context, struct attributes_store_item *item,
3262 const void *value)
3263 {
3264 switch (item->type)
3265 {
3266 case MF_ATTRIBUTE_UINT32:
3267 case MF_ATTRIBUTE_UINT64:
3268 case MF_ATTRIBUTE_DOUBLE:
3269 attributes_serialize_write(context, item, sizeof(*item));
3270 break;
3271 case MF_ATTRIBUTE_GUID:
3272 case MF_ATTRIBUTE_STRING:
3273 case MF_ATTRIBUTE_BLOB:
3274 item->u.subheader.offset = context->size - item->u.subheader.size;
3275 attributes_serialize_write(context, item, sizeof(*item));
3276 memcpy(context->buffer + item->u.subheader.offset, value, item->u.subheader.size);
3277 context->size -= item->u.subheader.size;
3278 break;
3279 default:
3280 return FALSE;
3281 }
3282
3283 return TRUE;
3284 }
3285
3286 /***********************************************************************
3287 * MFGetAttributesAsBlob (mfplat.@)
3288 */
3289 HRESULT WINAPI MFGetAttributesAsBlob(IMFAttributes *attributes, UINT8 *buffer, UINT size)
3290 {
3291 struct attributes_store_header header;
3292 struct attr_serialize_context context;
3293 unsigned int required_size, i;
3294 PROPVARIANT value;
3295 UINT32 count;
3296 HRESULT hr;
3297
3298 TRACE("%p, %p, %u.\n", attributes, buffer, size);
3299
3300 if (FAILED(hr = MFGetAttributesAsBlobSize(attributes, &required_size)))
3301 return hr;
3302
3303 if (required_size > size)
3304 return MF_E_BUFFERTOOSMALL;
3305
3306 context.buffer = buffer;
3307 context.ptr = buffer;
3308 context.size = required_size;
3309
3310 IMFAttributes_LockStore(attributes);
3311
3312 header.magic = ATTRIBUTES_STORE_MAGIC;
3313 header.count = 0; /* Will be updated later */
3314 IMFAttributes_GetCount(attributes, &count);
3315
3316 attributes_serialize_write(&context, &header, sizeof(header));
3317
3318 for (i = 0; i < count; ++i)
3319 {
3320 struct attributes_store_item item;
3321 const void *data = NULL;
3322
3323 hr = IMFAttributes_GetItemByIndex(attributes, i, &item.key, &value);
3324 if (FAILED(hr))
3325 break;
3326
3327 item.type = value.vt;
3328
3329 switch (value.vt)
3330 {
3331 case MF_ATTRIBUTE_UINT32:
3332 case MF_ATTRIBUTE_UINT64:
3333 item.u.i64 = value.uhVal.QuadPart;
3334 break;
3335 case MF_ATTRIBUTE_DOUBLE:
3336 item.u.f = value.dblVal;
3337 break;
3338 case MF_ATTRIBUTE_GUID:
3339 item.u.subheader.size = sizeof(*value.puuid);
3340 data = value.puuid;
3341 break;
3342 case MF_ATTRIBUTE_STRING:
3343 item.u.subheader.size = (lstrlenW(value.pwszVal) + 1) * sizeof(WCHAR);
3344 data = value.pwszVal;
3345 break;
3346 case MF_ATTRIBUTE_BLOB:
3347 item.u.subheader.size = value.caub.cElems;
3348 data = value.caub.pElems;
3349 break;
3350 case MF_ATTRIBUTE_IUNKNOWN:
3351 break;
3352 default:
3353 WARN("Unknown attribute type %#x.\n", value.vt);
3354 }
3355
3356 if (attributes_serialize_write_item(&context, &item, data))
3357 header.count++;
3358
3359 PropVariantClear(&value);
3360 }
3361
3362 memcpy(context.buffer, &header, sizeof(header));
3363
3364 IMFAttributes_UnlockStore(attributes);
3365
3366 return S_OK;
3367 }
3368
3369 static HRESULT attributes_deserialize_read(struct attr_serialize_context *context, void *value, unsigned int size)
3370 {
3371 if (context->size < (context->ptr - context->buffer) + size)
3372 return E_INVALIDARG;
3373
3374 memcpy(value, context->ptr, size);
3375 context->ptr += size;
3376
3377 return S_OK;
3378 }
3379
3380 /***********************************************************************
3381 * MFInitAttributesFromBlob (mfplat.@)
3382 */
3383 HRESULT WINAPI MFInitAttributesFromBlob(IMFAttributes *dest, const UINT8 *buffer, UINT size)
3384 {
3385 struct attr_serialize_context context;
3386 struct attributes_store_header header;
3387 struct attributes_store_item item;
3388 IMFAttributes *attributes;
3389 unsigned int i;
3390 HRESULT hr;
3391
3392 TRACE("%p, %p, %u.\n", dest, buffer, size);
3393
3394 context.buffer = (UINT8 *)buffer;
3395 context.ptr = (UINT8 *)buffer;
3396 context.size = size;
3397
3398 /* Validate buffer structure. */
3399 if (FAILED(hr = attributes_deserialize_read(&context, &header, sizeof(header))))
3400 return hr;
3401
3402 if (header.magic != ATTRIBUTES_STORE_MAGIC)
3403 return E_UNEXPECTED;
3404
3405 if (FAILED(hr = MFCreateAttributes(&attributes, header.count)))
3406 return hr;
3407
3408 for (i = 0; i < header.count; ++i)
3409 {
3410 if (FAILED(hr = attributes_deserialize_read(&context, &item, sizeof(item))))
3411 break;
3412
3413 hr = E_UNEXPECTED;
3414
3415 switch (item.type)
3416 {
3417 case MF_ATTRIBUTE_UINT32:
3418 hr = IMFAttributes_SetUINT32(attributes, &item.key, item.u.i32);
3419 break;
3420 case MF_ATTRIBUTE_UINT64:
3421 hr = IMFAttributes_SetUINT64(attributes, &item.key, item.u.i64);
3422 break;
3423 case MF_ATTRIBUTE_DOUBLE:
3424 hr = IMFAttributes_SetDouble(attributes, &item.key, item.u.f);
3425 break;
3426 case MF_ATTRIBUTE_GUID:
3427 if (item.u.subheader.size == sizeof(GUID) &&
3428 item.u.subheader.offset + item.u.subheader.size <= context.size)
3429 {
3430 hr = IMFAttributes_SetGUID(attributes, &item.key,
3431 (const GUID *)(context.buffer + item.u.subheader.offset));
3432 }
3433 break;
3434 case MF_ATTRIBUTE_STRING:
3435 if (item.u.subheader.size >= sizeof(WCHAR) &&
3436 item.u.subheader.offset + item.u.subheader.size <= context.size)
3437 {
3438 hr = IMFAttributes_SetString(attributes, &item.key,
3439 (const WCHAR *)(context.buffer + item.u.subheader.offset));
3440 }
3441 break;
3442 case MF_ATTRIBUTE_BLOB:
3443 if (item.u.subheader.size > 0 && item.u.subheader.offset + item.u.subheader.size <= context.size)
3444 {
3445 hr = IMFAttributes_SetBlob(attributes, &item.key, context.buffer + item.u.subheader.offset,
3446 item.u.subheader.size);
3447 }
3448 break;
3449 default:
3450 ;
3451 }
3452
3453 if (FAILED(hr))
3454 break;
3455 }
3456
3457 if (SUCCEEDED(hr))
3458 {
3459 IMFAttributes_DeleteAllItems(dest);
3460 hr = IMFAttributes_CopyAllItems(attributes, dest);
3461 }
3462
3463 IMFAttributes_Release(attributes);
3464
3465 return hr;
3466 }
3467
3468 struct bytestream
3469 {
3470 struct attributes attributes;
3471 IMFByteStream IMFByteStream_iface;
3472 IMFGetService IMFGetService_iface;
3473 IRtwqAsyncCallback read_callback;
3474 IRtwqAsyncCallback write_callback;
3475 IStream *stream;
3476 HANDLE hfile;
3477 QWORD position;
3478 DWORD capabilities;
3479 struct list pending;
3480 CRITICAL_SECTION cs;
3481 };
3482
3483 static inline struct bytestream *impl_from_IMFByteStream(IMFByteStream *iface)
3484 {
3485 return CONTAINING_RECORD(iface, struct bytestream, IMFByteStream_iface);
3486 }
3487
3488 static struct bytestream *impl_bytestream_from_IMFGetService(IMFGetService *iface)
3489 {
3490 return CONTAINING_RECORD(iface, struct bytestream, IMFGetService_iface);
3491 }
3492
3493 static struct bytestream *impl_from_read_callback_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
3494 {
3495 return CONTAINING_RECORD(iface, struct bytestream, read_callback);
3496 }
3497
3498 static struct bytestream *impl_from_write_callback_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
3499 {
3500 return CONTAINING_RECORD(iface, struct bytestream, write_callback);
3501 }
3502
3503 enum async_stream_op_type
3504 {
3505 ASYNC_STREAM_OP_READ,
3506 ASYNC_STREAM_OP_WRITE,
3507 };
3508
3509 struct async_stream_op
3510 {
3511 IUnknown IUnknown_iface;
3512 LONG refcount;
3513 union
3514 {
3515 const BYTE *src;
3516 BYTE *dest;
3517 } u;
3518 QWORD position;
3519 ULONG requested_length;
3520 ULONG actual_length;
3521 IMFAsyncResult *caller;
3522 struct list entry;
3523 enum async_stream_op_type type;
3524 };
3525
3526 static struct async_stream_op *impl_async_stream_op_from_IUnknown(IUnknown *iface)
3527 {
3528 return CONTAINING_RECORD(iface, struct async_stream_op, IUnknown_iface);
3529 }
3530
3531 static HRESULT WINAPI async_stream_op_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
3532 {
3533 if (IsEqualIID(riid, &IID_IUnknown))
3534 {
3535 *obj = iface;
3536 IUnknown_AddRef(iface);
3537 return S_OK;
3538 }
3539
3540 WARN("Unsupported %s.\n", debugstr_guid(riid));
3541 *obj = NULL;
3542 return E_NOINTERFACE;
3543 }
3544
3545 static ULONG WINAPI async_stream_op_AddRef(IUnknown *iface)
3546 {
3547 struct async_stream_op *op = impl_async_stream_op_from_IUnknown(iface);
3548 ULONG refcount = InterlockedIncrement(&op->refcount);
3549
3550 TRACE("%p, refcount %d.\n", iface, refcount);
3551
3552 return refcount;
3553 }
3554
3555 static ULONG WINAPI async_stream_op_Release(IUnknown *iface)
3556 {
3557 struct async_stream_op *op = impl_async_stream_op_from_IUnknown(iface);
3558 ULONG refcount = InterlockedDecrement(&op->refcount);
3559
3560 TRACE("%p, refcount %d.\n", iface, refcount);
3561
3562 if (!refcount)
3563 {
3564 if (op->caller)
3565 IMFAsyncResult_Release(op->caller);
3566 free(op);
3567 }
3568
3569 return refcount;
3570 }
3571
3572 static const IUnknownVtbl async_stream_op_vtbl =
3573 {
3574 async_stream_op_QueryInterface,
3575 async_stream_op_AddRef,
3576 async_stream_op_Release,
3577 };
3578
3579 static HRESULT bytestream_create_io_request(struct bytestream *stream, enum async_stream_op_type type,
3580 const BYTE *data, ULONG size, IMFAsyncCallback *callback, IUnknown *state)
3581 {
3582 struct async_stream_op *op;
3583 IRtwqAsyncResult *request;
3584 HRESULT hr;
3585
3586 op = malloc(sizeof(*op));
3587 if (!op)
3588 return E_OUTOFMEMORY;
3589
3590 op->IUnknown_iface.lpVtbl = &async_stream_op_vtbl;
3591 op->refcount = 1;
3592 op->u.src = data;
3593 op->position = stream->position;
3594 op->requested_length = size;
3595 op->type = type;
3596 if (FAILED(hr = RtwqCreateAsyncResult((IUnknown *)&stream->IMFByteStream_iface, (IRtwqAsyncCallback *)callback, state,
3597 (IRtwqAsyncResult **)&op->caller)))
3598 {
3599 goto failed;
3600 }
3601
3602 if (FAILED(hr = RtwqCreateAsyncResult(&op->IUnknown_iface, type == ASYNC_STREAM_OP_READ ? &stream->read_callback :
3603 &stream->write_callback, NULL, &request)))
3604 goto failed;
3605
3606 RtwqPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, 0, request);
3607 IRtwqAsyncResult_Release(request);
3608
3609 failed:
3610 IUnknown_Release(&op->IUnknown_iface);
3611 return hr;
3612 }
3613
3614 static HRESULT bytestream_complete_io_request(struct bytestream *stream, enum async_stream_op_type type,
3615 IMFAsyncResult *result, ULONG *actual_length)
3616 {
3617 struct async_stream_op *op = NULL, *cur;
3618 HRESULT hr;
3619
3620 EnterCriticalSection(&stream->cs);
3621 LIST_FOR_EACH_ENTRY(cur, &stream->pending, struct async_stream_op, entry)
3622 {
3623 if (cur->caller == result && cur->type == type)
3624 {
3625 op = cur;
3626 list_remove(&cur->entry);
3627 break;
3628 }
3629 }
3630 LeaveCriticalSection(&stream->cs);
3631
3632 if (!op)
3633 return E_INVALIDARG;
3634
3635 if (SUCCEEDED(hr = IMFAsyncResult_GetStatus(result)))
3636 *actual_length = op->actual_length;
3637
3638 IUnknown_Release(&op->IUnknown_iface);
3639
3640 return hr;
3641 }
3642
3643 static HRESULT WINAPI bytestream_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
3644 {
3645 if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
3646 IsEqualIID(riid, &IID_IUnknown))
3647 {
3648 *obj = iface;
3649 IRtwqAsyncCallback_AddRef(iface);
3650 return S_OK;
3651 }
3652
3653 WARN("Unsupported %s.\n", debugstr_guid(riid));
3654 *obj = NULL;
3655 return E_NOINTERFACE;
3656 }
3657
3658 static ULONG WINAPI bytestream_read_callback_AddRef(IRtwqAsyncCallback *iface)
3659 {
3660 struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
3661 return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
3662 }
3663
3664 static ULONG WINAPI bytestream_read_callback_Release(IRtwqAsyncCallback *iface)
3665 {
3666 struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
3667 return IMFByteStream_Release(&stream->IMFByteStream_iface);
3668 }
3669
3670 static HRESULT WINAPI bytestream_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
3671 {
3672 return E_NOTIMPL;
3673 }
3674
3675 static ULONG WINAPI bytestream_write_callback_AddRef(IRtwqAsyncCallback *iface)
3676 {
3677 struct bytestream *stream = impl_from_write_callback_IRtwqAsyncCallback(iface);
3678 return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
3679 }
3680
3681 static ULONG WINAPI bytestream_write_callback_Release(IRtwqAsyncCallback *iface)
3682 {
3683 struct bytestream *stream = impl_from_write_callback_IRtwqAsyncCallback(iface);
3684 return IMFByteStream_Release(&stream->IMFByteStream_iface);
3685 }
3686
3687 static HRESULT WINAPI bytestream_QueryInterface(IMFByteStream *iface, REFIID riid, void **out)
3688 {
3689 struct bytestream *stream = impl_from_IMFByteStream(iface);
3690
3691 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
3692
3693 if (IsEqualIID(riid, &IID_IMFByteStream) ||
3694 IsEqualIID(riid, &IID_IUnknown))
3695 {
3696 *out = &stream->IMFByteStream_iface;
3697 }
3698 else if (IsEqualIID(riid, &IID_IMFAttributes))
3699 {
3700 *out = &stream->attributes.IMFAttributes_iface;
3701 }
3702 else if (stream->IMFGetService_iface.lpVtbl && IsEqualIID(riid, &IID_IMFGetService))
3703 {
3704 *out = &stream->IMFGetService_iface;
3705 }
3706 else
3707 {
3708 WARN("Unsupported %s.\n", debugstr_guid(riid));
3709 *out = NULL;
3710 return E_NOINTERFACE;
3711 }
3712
3713 IUnknown_AddRef((IUnknown*)*out);
3714 return S_OK;
3715 }
3716
3717 static ULONG WINAPI bytestream_AddRef(IMFByteStream *iface)
3718 {
3719 struct bytestream *stream = impl_from_IMFByteStream(iface);
3720 ULONG refcount = InterlockedIncrement(&stream->attributes.ref);
3721
3722 TRACE("%p, refcount %d.\n", iface, refcount);
3723
3724 return refcount;
3725 }
3726
3727 static ULONG WINAPI bytestream_Release(IMFByteStream *iface)
3728 {
3729 struct bytestream *stream = impl_from_IMFByteStream(iface);
3730 ULONG refcount = InterlockedDecrement(&stream->attributes.ref);
3731 struct async_stream_op *cur, *cur2;
3732
3733 TRACE("%p, refcount %d.\n", iface, refcount);
3734
3735 if (!refcount)
3736 {
3737 clear_attributes_object(&stream->attributes);
3738 LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &stream->pending, struct async_stream_op, entry)
3739 {
3740 list_remove(&cur->entry);
3741 IUnknown_Release(&cur->IUnknown_iface);
3742 }
3743 DeleteCriticalSection(&stream->cs);
3744 if (stream->stream)
3745 IStream_Release(stream->stream);
3746 if (stream->hfile)
3747 CloseHandle(stream->hfile);
3748 free(stream);
3749 }
3750
3751 return refcount;
3752 }
3753
3754 static HRESULT WINAPI bytestream_stream_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
3755 {
3756 struct bytestream *stream = impl_from_IMFByteStream(iface);
3757 STATSTG stat;
3758 HRESULT hr;
3759
3760 TRACE("%p, %p.\n", iface, capabilities);
3761
3762 if (FAILED(hr = IStream_Stat(stream->stream, &stat, STATFLAG_NONAME)))
3763 return hr;
3764
3765 *capabilities = MFBYTESTREAM_IS_READABLE | MFBYTESTREAM_IS_SEEKABLE;
3766 if (stat.grfMode & (STGM_WRITE | STGM_READWRITE))
3767 *capabilities |= MFBYTESTREAM_IS_WRITABLE;
3768
3769 return S_OK;
3770 }
3771
3772 static HRESULT WINAPI bytestream_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
3773 {
3774 struct bytestream *stream = impl_from_IMFByteStream(iface);
3775
3776 TRACE("%p, %p.\n", iface, capabilities);
3777
3778 *capabilities = stream->capabilities;
3779
3780 return S_OK;
3781 }
3782
3783 static HRESULT WINAPI bytestream_SetLength(IMFByteStream *iface, QWORD length)
3784 {
3785 FIXME("%p, %s\n", iface, wine_dbgstr_longlong(length));
3786
3787 return E_NOTIMPL;
3788 }
3789
3790 static HRESULT WINAPI bytestream_file_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
3791 {
3792 struct bytestream *stream = impl_from_IMFByteStream(iface);
3793
3794 TRACE("%p, %p.\n", iface, position);
3795
3796 if (!position)
3797 return E_INVALIDARG;
3798
3799 *position = stream->position;
3800
3801 return S_OK;
3802 }
3803
3804 static HRESULT WINAPI bytestream_file_GetLength(IMFByteStream *iface, QWORD *length)
3805 {
3806 struct bytestream *stream = impl_from_IMFByteStream(iface);
3807 LARGE_INTEGER li;
3808
3809 TRACE("%p, %p.\n", iface, length);
3810
3811 if (!length)
3812 return E_INVALIDARG;
3813
3814 if (GetFileSizeEx(stream->hfile, &li))
3815 *length = li.QuadPart;
3816 else
3817 return HRESULT_FROM_WIN32(GetLastError());
3818
3819 return S_OK;
3820 }
3821
3822 static HRESULT WINAPI bytestream_file_IsEndOfStream(IMFByteStream *iface, BOOL *ret)
3823 {
3824 struct bytestream *stream = impl_from_IMFByteStream(iface);
3825 LARGE_INTEGER position, length;
3826 HRESULT hr = S_OK;
3827
3828 TRACE("%p, %p.\n", iface, ret);
3829
3830 EnterCriticalSection(&stream->cs);
3831
3832 position.QuadPart = 0;
3833 if (SetFilePointerEx(stream->hfile, position, &length, FILE_END))
3834 *ret = stream->position >= length.QuadPart;
3835 else
3836 hr = HRESULT_FROM_WIN32(GetLastError());
3837
3838 LeaveCriticalSection(&stream->cs);
3839
3840 return hr;
3841 }
3842
3843 static HRESULT WINAPI bytestream_file_Read(IMFByteStream *iface, BYTE *buffer, ULONG size, ULONG *read_len)
3844 {
3845 struct bytestream *stream = impl_from_IMFByteStream(iface);
3846 LARGE_INTEGER position;
3847 HRESULT hr = S_OK;
3848 BOOL ret;
3849
3850 TRACE("%p, %p, %u, %p.\n", iface, buffer, size, read_len);
3851
3852 EnterCriticalSection(&stream->cs);
3853
3854 position.QuadPart = stream->position;
3855 if ((ret = SetFilePointerEx(stream->hfile, position, NULL, FILE_BEGIN)))
3856 {
3857 if ((ret = ReadFile(stream->hfile, buffer, size, read_len, NULL)))
3858 stream->position += *read_len;
3859 }
3860
3861 if (!ret)
3862 hr = HRESULT_FROM_WIN32(GetLastError());
3863
3864 LeaveCriticalSection(&stream->cs);
3865
3866 return hr;
3867 }
3868
3869 static HRESULT WINAPI bytestream_BeginRead(IMFByteStream *iface, BYTE *data, ULONG size, IMFAsyncCallback *callback,
3870 IUnknown *state)
3871 {
3872 struct bytestream *stream = impl_from_IMFByteStream(iface);
3873
3874 TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
3875
3876 return bytestream_create_io_request(stream, ASYNC_STREAM_OP_READ, data, size, callback, state);
3877 }
3878
3879 static HRESULT WINAPI bytestream_EndRead(IMFByteStream *iface, IMFAsyncResult *result, ULONG *byte_read)
3880 {
3881 struct bytestream *stream = impl_from_IMFByteStream(iface);
3882
3883 TRACE("%p, %p, %p.\n", iface, result, byte_read);
3884
3885 return bytestream_complete_io_request(stream, ASYNC_STREAM_OP_READ, result, byte_read);
3886 }
3887
3888 static HRESULT WINAPI bytestream_Write(IMFByteStream *iface, const BYTE *data, ULONG count, ULONG *written)
3889 {
3890 FIXME("%p, %p, %u, %p\n", iface, data, count, written);
3891
3892 return E_NOTIMPL;
3893 }
3894
3895 static HRESULT WINAPI bytestream_BeginWrite(IMFByteStream *iface, const BYTE *data, ULONG size,
3896 IMFAsyncCallback *callback, IUnknown *state)
3897 {
3898 struct bytestream *stream = impl_from_IMFByteStream(iface);
3899
3900 TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
3901
3902 return bytestream_create_io_request(stream, ASYNC_STREAM_OP_WRITE, data, size, callback, state);
3903 }
3904
3905 static HRESULT WINAPI bytestream_EndWrite(IMFByteStream *iface, IMFAsyncResult *result, ULONG *written)
3906 {
3907 struct bytestream *stream = impl_from_IMFByteStream(iface);
3908
3909 TRACE("%p, %p, %p.\n", iface, result, written);
3910
3911 return bytestream_complete_io_request(stream, ASYNC_STREAM_OP_WRITE, result, written);
3912 }
3913
3914 static HRESULT WINAPI bytestream_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN seek, LONGLONG offset,
3915 DWORD flags, QWORD *current)
3916 {
3917 FIXME("%p, %u, %s, 0x%08x, %p\n", iface, seek, wine_dbgstr_longlong(offset), flags, current);
3918
3919 return E_NOTIMPL;
3920 }
3921
3922 static HRESULT WINAPI bytestream_Flush(IMFByteStream *iface)
3923 {
3924 FIXME("%p\n", iface);
3925
3926 return E_NOTIMPL;
3927 }
3928
3929 static HRESULT WINAPI bytestream_Close(IMFByteStream *iface)
3930 {
3931 FIXME("%p\n", iface);
3932
3933 return E_NOTIMPL;
3934 }
3935
3936 static HRESULT WINAPI bytestream_SetCurrentPosition(IMFByteStream *iface, QWORD position)
3937 {
3938 struct bytestream *stream = impl_from_IMFByteStream(iface);
3939
3940 TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
3941
3942 EnterCriticalSection(&stream->cs);
3943 stream->position = position;
3944 LeaveCriticalSection(&stream->cs);
3945
3946 return S_OK;
3947 }
3948
3949 static const IMFByteStreamVtbl bytestream_file_vtbl =
3950 {
3951 bytestream_QueryInterface,
3952 bytestream_AddRef,
3953 bytestream_Release,
3954 bytestream_GetCapabilities,
3955 bytestream_file_GetLength,
3956 bytestream_SetLength,
3957 bytestream_file_GetCurrentPosition,
3958 bytestream_SetCurrentPosition,
3959 bytestream_file_IsEndOfStream,
3960 bytestream_file_Read,
3961 bytestream_BeginRead,
3962 bytestream_EndRead,
3963 bytestream_Write,
3964 bytestream_BeginWrite,
3965 bytestream_EndWrite,
3966 bytestream_Seek,
3967 bytestream_Flush,
3968 bytestream_Close
3969 };
3970
3971 static HRESULT WINAPI bytestream_stream_GetLength(IMFByteStream *iface, QWORD *length)
3972 {
3973 struct bytestream *stream = impl_from_IMFByteStream(iface);
3974 STATSTG statstg;
3975 HRESULT hr;
3976
3977 TRACE("%p, %p.\n", iface, length);
3978
3979 if (FAILED(hr = IStream_Stat(stream->stream, &statstg, STATFLAG_NONAME)))
3980 return hr;
3981
3982 *length = statstg.cbSize.QuadPart;
3983
3984 return S_OK;
3985 }
3986
3987 static HRESULT WINAPI bytestream_stream_SetLength(IMFByteStream *iface, QWORD length)
3988 {
3989 struct bytestream *stream = impl_from_IMFByteStream(iface);
3990 ULARGE_INTEGER size;
3991 HRESULT hr;
3992
3993 TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(length));
3994
3995 EnterCriticalSection(&stream->cs);
3996
3997 size.QuadPart = length;
3998 hr = IStream_SetSize(stream->stream, size);
3999
4000 LeaveCriticalSection(&stream->cs);
4001
4002 return hr;
4003 }
4004
4005 static HRESULT WINAPI bytestream_stream_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
4006 {
4007 struct bytestream *stream = impl_from_IMFByteStream(iface);
4008
4009 TRACE("%p, %p.\n", iface, position);
4010
4011 *position = stream->position;
4012
4013 return S_OK;
4014 }
4015
4016 static HRESULT WINAPI bytestream_stream_IsEndOfStream(IMFByteStream *iface, BOOL *ret)
4017 {
4018 struct bytestream *stream = impl_from_IMFByteStream(iface);
4019 STATSTG statstg;
4020 HRESULT hr;
4021
4022 TRACE("%p, %p.\n", iface, ret);
4023
4024 EnterCriticalSection(&stream->cs);
4025
4026 if (SUCCEEDED(hr = IStream_Stat(stream->stream, &statstg, STATFLAG_NONAME)))
4027 *ret = stream->position >= statstg.cbSize.QuadPart;
4028
4029 LeaveCriticalSection(&stream->cs);
4030
4031 return hr;
4032 }
4033
4034 static HRESULT WINAPI bytestream_stream_Read(IMFByteStream *iface, BYTE *buffer, ULONG size, ULONG *read_len)
4035 {
4036 struct bytestream *stream = impl_from_IMFByteStream(iface);
4037 LARGE_INTEGER position;
4038 HRESULT hr;
4039
4040 TRACE("%p, %p, %u, %p.\n", iface, buffer, size, read_len);
4041
4042 EnterCriticalSection(&stream->cs);
4043
4044 position.QuadPart = stream->position;
4045 if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4046 {
4047 if (SUCCEEDED(hr = IStream_Read(stream->stream, buffer, size, read_len)))
4048 stream->position += *read_len;
4049 }
4050
4051 LeaveCriticalSection(&stream->cs);
4052
4053 return hr;
4054 }
4055
4056 static HRESULT WINAPI bytestream_stream_Write(IMFByteStream *iface, const BYTE *buffer, ULONG size, ULONG *written)
4057 {
4058 struct bytestream *stream = impl_from_IMFByteStream(iface);
4059 LARGE_INTEGER position;
4060 HRESULT hr;
4061
4062 TRACE("%p, %p, %u, %p.\n", iface, buffer, size, written);
4063
4064 EnterCriticalSection(&stream->cs);
4065
4066 position.QuadPart = stream->position;
4067 if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4068 {
4069 if (SUCCEEDED(hr = IStream_Write(stream->stream, buffer, size, written)))
4070 stream->position += *written;
4071 }
4072
4073 LeaveCriticalSection(&stream->cs);
4074
4075 return hr;
4076 }
4077
4078 static HRESULT WINAPI bytestream_stream_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN origin, LONGLONG offset,
4079 DWORD flags, QWORD *current)
4080 {
4081 struct bytestream *stream = impl_from_IMFByteStream(iface);
4082 HRESULT hr = S_OK;
4083
4084 TRACE("%p, %u, %s, %#x, %p.\n", iface, origin, wine_dbgstr_longlong(offset), flags, current);
4085
4086 EnterCriticalSection(&stream->cs);
4087
4088 switch (origin)
4089 {
4090 case msoBegin:
4091 stream->position = offset;
4092 break;
4093 case msoCurrent:
4094 stream->position += offset;
4095 break;
4096 default:
4097 WARN("Unknown origin mode %d.\n", origin);
4098 hr = E_INVALIDARG;
4099 }
4100
4101 *current = stream->position;
4102
4103 LeaveCriticalSection(&stream->cs);
4104
4105 return hr;
4106 }
4107
4108 static HRESULT WINAPI bytestream_stream_Flush(IMFByteStream *iface)
4109 {
4110 struct bytestream *stream = impl_from_IMFByteStream(iface);
4111
4112 TRACE("%p.\n", iface);
4113
4114 return IStream_Commit(stream->stream, STGC_DEFAULT);
4115 }
4116
4117 static HRESULT WINAPI bytestream_stream_Close(IMFByteStream *iface)
4118 {
4119 TRACE("%p.\n", iface);
4120
4121 return S_OK;
4122 }
4123
4124 static const IMFByteStreamVtbl bytestream_stream_vtbl =
4125 {
4126 bytestream_QueryInterface,
4127 bytestream_AddRef,
4128 bytestream_Release,
4129 bytestream_stream_GetCapabilities,
4130 bytestream_stream_GetLength,
4131 bytestream_stream_SetLength,
4132 bytestream_stream_GetCurrentPosition,
4133 bytestream_SetCurrentPosition,
4134 bytestream_stream_IsEndOfStream,
4135 bytestream_stream_Read,
4136 bytestream_BeginRead,
4137 bytestream_EndRead,
4138 bytestream_stream_Write,
4139 bytestream_BeginWrite,
4140 bytestream_EndWrite,
4141 bytestream_stream_Seek,
4142 bytestream_stream_Flush,
4143 bytestream_stream_Close,
4144 };
4145
4146 static inline struct bytestream *impl_from_IMFByteStream_IMFAttributes(IMFAttributes *iface)
4147 {
4148 return CONTAINING_RECORD(iface, struct bytestream, attributes.IMFAttributes_iface);
4149 }
4150
4151 static HRESULT WINAPI bytestream_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
4152 {
4153 struct bytestream *stream = impl_from_IMFByteStream_IMFAttributes(iface);
4154 return IMFByteStream_QueryInterface(&stream->IMFByteStream_iface, riid, out);
4155 }
4156
4157 static ULONG WINAPI bytestream_attributes_AddRef(IMFAttributes *iface)
4158 {
4159 struct bytestream *stream = impl_from_IMFByteStream_IMFAttributes(iface);
4160 return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
4161 }
4162
4163 static ULONG WINAPI bytestream_attributes_Release(IMFAttributes *iface)
4164 {
4165 struct bytestream *stream = impl_from_IMFByteStream_IMFAttributes(iface);
4166 return IMFByteStream_Release(&stream->IMFByteStream_iface);
4167 }
4168
4169 static const IMFAttributesVtbl bytestream_attributes_vtbl =
4170 {
4171 bytestream_attributes_QueryInterface,
4172 bytestream_attributes_AddRef,
4173 bytestream_attributes_Release,
4174 mfattributes_GetItem,
4175 mfattributes_GetItemType,
4176 mfattributes_CompareItem,
4177 mfattributes_Compare,
4178 mfattributes_GetUINT32,
4179 mfattributes_GetUINT64,
4180 mfattributes_GetDouble,
4181 mfattributes_GetGUID,
4182 mfattributes_GetStringLength,
4183 mfattributes_GetString,
4184 mfattributes_GetAllocatedString,
4185 mfattributes_GetBlobSize,
4186 mfattributes_GetBlob,
4187 mfattributes_GetAllocatedBlob,
4188 mfattributes_GetUnknown,
4189 mfattributes_SetItem,
4190 mfattributes_DeleteItem,
4191 mfattributes_DeleteAllItems,
4192 mfattributes_SetUINT32,
4193 mfattributes_SetUINT64,
4194 mfattributes_SetDouble,
4195 mfattributes_SetGUID,
4196 mfattributes_SetString,
4197 mfattributes_SetBlob,
4198 mfattributes_SetUnknown,
4199 mfattributes_LockStore,
4200 mfattributes_UnlockStore,
4201 mfattributes_GetCount,
4202 mfattributes_GetItemByIndex,
4203 mfattributes_CopyAllItems
4204 };
4205
4206 static HRESULT WINAPI bytestream_stream_read_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4207 {
4208 struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
4209 struct async_stream_op *op;
4210 LARGE_INTEGER position;
4211 IUnknown *object;
4212 HRESULT hr;
4213
4214 if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
4215 return hr;
4216
4217 op = impl_async_stream_op_from_IUnknown(object);
4218
4219 EnterCriticalSection(&stream->cs);
4220
4221 position.QuadPart = op->position;
4222 if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4223 {
4224 if (SUCCEEDED(hr = IStream_Read(stream->stream, op->u.dest, op->requested_length, &op->actual_length)))
4225 stream->position += op->actual_length;
4226 }
4227
4228 IMFAsyncResult_SetStatus(op->caller, hr);
4229 list_add_tail(&stream->pending, &op->entry);
4230
4231 LeaveCriticalSection(&stream->cs);
4232
4233 MFInvokeCallback(op->caller);
4234
4235 return S_OK;
4236 }
4237
4238 static HRESULT WINAPI bytestream_stream_write_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4239 {
4240 struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
4241 struct async_stream_op *op;
4242 LARGE_INTEGER position;
4243 IUnknown *object;
4244 HRESULT hr;
4245
4246 if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
4247 return hr;
4248
4249 op = impl_async_stream_op_from_IUnknown(object);
4250
4251 EnterCriticalSection(&stream->cs);
4252
4253 position.QuadPart = op->position;
4254 if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4255 {
4256 if (SUCCEEDED(hr = IStream_Write(stream->stream, op->u.src, op->requested_length, &op->actual_length)))
4257 stream->position += op->actual_length;
4258 }
4259
4260 IMFAsyncResult_SetStatus(op->caller, hr);
4261 list_add_tail(&stream->pending, &op->entry);
4262
4263 LeaveCriticalSection(&stream->cs);
4264
4265 MFInvokeCallback(op->caller);
4266
4267 return S_OK;
4268 }
4269
4270 static const IRtwqAsyncCallbackVtbl bytestream_stream_read_callback_vtbl =
4271 {
4272 bytestream_callback_QueryInterface,
4273 bytestream_read_callback_AddRef,
4274 bytestream_read_callback_Release,
4275 bytestream_callback_GetParameters,
4276 bytestream_stream_read_callback_Invoke,
4277 };
4278
4279 static const IRtwqAsyncCallbackVtbl bytestream_stream_write_callback_vtbl =
4280 {
4281 bytestream_callback_QueryInterface,
4282 bytestream_write_callback_AddRef,
4283 bytestream_write_callback_Release,
4284 bytestream_callback_GetParameters,
4285 bytestream_stream_write_callback_Invoke,
4286 };
4287
4288 /***********************************************************************
4289 * MFCreateMFByteStreamOnStream (mfplat.@)
4290 */
4291 HRESULT WINAPI MFCreateMFByteStreamOnStream(IStream *stream, IMFByteStream **bytestream)
4292 {
4293 struct bytestream *object;
4294 LARGE_INTEGER position;
4295 STATSTG stat;
4296 HRESULT hr;
4297
4298 TRACE("%p, %p.\n", stream, bytestream);
4299
4300 if (!(object = calloc(1, sizeof(*object))))
4301 return E_OUTOFMEMORY;
4302
4303 if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
4304 {
4305 free(object);
4306 return hr;
4307 }
4308
4309 object->IMFByteStream_iface.lpVtbl = &bytestream_stream_vtbl;
4310 object->attributes.IMFAttributes_iface.lpVtbl = &bytestream_attributes_vtbl;
4311 object->read_callback.lpVtbl = &bytestream_stream_read_callback_vtbl;
4312 object->write_callback.lpVtbl = &bytestream_stream_write_callback_vtbl;
4313 InitializeCriticalSection(&object->cs);
4314 list_init(&object->pending);
4315
4316 object->stream = stream;
4317 IStream_AddRef(object->stream);
4318 position.QuadPart = 0;
4319 IStream_Seek(object->stream, position, STREAM_SEEK_SET, NULL);
4320
4321 if (SUCCEEDED(IStream_Stat(object->stream, &stat, 0)))
4322 {
4323 if (stat.pwcsName)
4324 {
4325 IMFAttributes_SetString(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_ORIGIN_NAME,
4326 stat.pwcsName);
4327 CoTaskMemFree(stat.pwcsName);
4328 }
4329 }
4330
4331 *bytestream = &object->IMFByteStream_iface;
4332
4333 return S_OK;
4334 }
4335
4336 static HRESULT WINAPI bytestream_file_read_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4337 {
4338 FIXME("%p, %p.\n", iface, result);
4339
4340 return E_NOTIMPL;
4341 }
4342
4343 static HRESULT WINAPI bytestream_file_write_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4344 {
4345 FIXME("%p, %p.\n", iface, result);
4346
4347 return E_NOTIMPL;
4348 }
4349
4350 static const IRtwqAsyncCallbackVtbl bytestream_file_read_callback_vtbl =
4351 {
4352 bytestream_callback_QueryInterface,
4353 bytestream_read_callback_AddRef,
4354 bytestream_read_callback_Release,
4355 bytestream_callback_GetParameters,
4356 bytestream_file_read_callback_Invoke,
4357 };
4358
4359 static const IRtwqAsyncCallbackVtbl bytestream_file_write_callback_vtbl =
4360 {
4361 bytestream_callback_QueryInterface,
4362 bytestream_write_callback_AddRef,
4363 bytestream_write_callback_Release,
4364 bytestream_callback_GetParameters,
4365 bytestream_file_write_callback_Invoke,
4366 };
4367
4368 static HRESULT WINAPI bytestream_file_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
4369 {
4370 struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4371 return IMFByteStream_QueryInterface(&stream->IMFByteStream_iface, riid, obj);
4372 }
4373
4374 static ULONG WINAPI bytestream_file_getservice_AddRef(IMFGetService *iface)
4375 {
4376 struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4377 return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
4378 }
4379
4380 static ULONG WINAPI bytestream_file_getservice_Release(IMFGetService *iface)
4381 {
4382 struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4383 return IMFByteStream_Release(&stream->IMFByteStream_iface);
4384 }
4385
4386 static HRESULT WINAPI bytestream_file_getservice_GetService(IMFGetService *iface, REFGUID service,
4387 REFIID riid, void **obj)
4388 {
4389 FIXME("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
4390
4391 return E_NOTIMPL;
4392 }
4393
4394 static const IMFGetServiceVtbl bytestream_file_getservice_vtbl =
4395 {
4396 bytestream_file_getservice_QueryInterface,
4397 bytestream_file_getservice_AddRef,
4398 bytestream_file_getservice_Release,
4399 bytestream_file_getservice_GetService,
4400 };
4401
4402 /***********************************************************************
4403 * MFCreateFile (mfplat.@)
4404 */
4405 HRESULT WINAPI MFCreateFile(MF_FILE_ACCESSMODE accessmode, MF_FILE_OPENMODE openmode, MF_FILE_FLAGS flags,
4406 LPCWSTR url, IMFByteStream **bytestream)
4407 {
4408 DWORD capabilities = MFBYTESTREAM_IS_SEEKABLE | MFBYTESTREAM_DOES_NOT_USE_NETWORK;
4409 DWORD filecreation_disposition = 0, fileaccessmode = 0, fileattributes = 0;
4410 DWORD filesharemode = FILE_SHARE_READ;
4411 struct bytestream *object;
4412 FILETIME writetime;
4413 HANDLE file;
4414 HRESULT hr;
4415
4416 TRACE("%d, %d, %#x, %s, %p.\n", accessmode, openmode, flags, debugstr_w(url), bytestream);
4417
4418 switch (accessmode)
4419 {
4420 case MF_ACCESSMODE_READ:
4421 fileaccessmode = GENERIC_READ;
4422 capabilities |= MFBYTESTREAM_IS_READABLE;
4423 break;
4424 case MF_ACCESSMODE_WRITE:
4425 fileaccessmode = GENERIC_WRITE;
4426 capabilities |= MFBYTESTREAM_IS_WRITABLE;
4427 break;
4428 case MF_ACCESSMODE_READWRITE:
4429 fileaccessmode = GENERIC_READ | GENERIC_WRITE;
4430 capabilities |= (MFBYTESTREAM_IS_READABLE | MFBYTESTREAM_IS_WRITABLE);
4431 break;
4432 }
4433
4434 switch (openmode)
4435 {
4436 case MF_OPENMODE_FAIL_IF_NOT_EXIST:
4437 filecreation_disposition = OPEN_EXISTING;
4438 break;
4439 case MF_OPENMODE_FAIL_IF_EXIST:
4440 filecreation_disposition = CREATE_NEW;
4441 break;
4442 case MF_OPENMODE_RESET_IF_EXIST:
4443 filecreation_disposition = TRUNCATE_EXISTING;
4444 break;
4445 case MF_OPENMODE_APPEND_IF_EXIST:
4446 filecreation_disposition = OPEN_ALWAYS;
4447 fileaccessmode |= FILE_APPEND_DATA;
4448 break;
4449 case MF_OPENMODE_DELETE_IF_EXIST:
4450 filecreation_disposition = CREATE_ALWAYS;
4451 break;
4452 }
4453
4454 if (flags & MF_FILEFLAGS_NOBUFFERING)
4455 fileattributes |= FILE_FLAG_NO_BUFFERING;
4456
4457 /* Open HANDLE to file */
4458 file = CreateFileW(url, fileaccessmode, filesharemode, NULL,
4459 filecreation_disposition, fileattributes, 0);
4460
4461 if(file == INVALID_HANDLE_VALUE)
4462 return HRESULT_FROM_WIN32(GetLastError());
4463
4464 if (!(object = calloc(1, sizeof(*object))))
4465 {
4466 CloseHandle(file);
4467 return E_OUTOFMEMORY;
4468 }
4469
4470 if (FAILED(hr = init_attributes_object(&object->attributes, 2)))
4471 {
4472 CloseHandle(file);
4473 free(object);
4474 return hr;
4475 }
4476 object->IMFByteStream_iface.lpVtbl = &bytestream_file_vtbl;
4477 object->attributes.IMFAttributes_iface.lpVtbl = &bytestream_attributes_vtbl;
4478 object->IMFGetService_iface.lpVtbl = &bytestream_file_getservice_vtbl;
4479 object->read_callback.lpVtbl = &bytestream_file_read_callback_vtbl;
4480 object->write_callback.lpVtbl = &bytestream_file_write_callback_vtbl;
4481 InitializeCriticalSection(&object->cs);
4482 list_init(&object->pending);
4483 object->capabilities = capabilities;
4484 object->hfile = file;
4485
4486 if (GetFileTime(file, NULL, NULL, &writetime))
4487 {
4488 IMFAttributes_SetBlob(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_LAST_MODIFIED_TIME,
4489 (const UINT8 *)&writetime, sizeof(writetime));
4490 }
4491
4492 IMFAttributes_SetString(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_ORIGIN_NAME, url);
4493
4494 *bytestream = &object->IMFByteStream_iface;
4495
4496 return S_OK;
4497 }
4498
4499 struct bytestream_wrapper
4500 {
4501 IMFByteStreamCacheControl IMFByteStreamCacheControl_iface;
4502 IMFByteStreamBuffering IMFByteStreamBuffering_iface;
4503 IMFMediaEventGenerator IMFMediaEventGenerator_iface;
4504 IMFByteStreamTimeSeek IMFByteStreamTimeSeek_iface;
4505 IMFSampleOutputStream IMFSampleOutputStream_iface;
4506 IPropertyStore IPropertyStore_iface;
4507 IMFByteStream IMFByteStream_iface;
4508 IMFAttributes IMFAttributes_iface;
4509 LONG refcount;
4510
4511 IMFByteStreamCacheControl *cache_control;
4512 IMFByteStreamBuffering *stream_buffering;
4513 IMFMediaEventGenerator *event_generator;
4514 IMFByteStreamTimeSeek *time_seek;
4515 IMFSampleOutputStream *sample_output;
4516 IPropertyStore *propstore;
4517 IMFByteStream *stream;
4518 IMFAttributes *attributes;
4519 BOOL is_closed;
4520 };
4521
4522 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStream(IMFByteStream *iface)
4523 {
4524 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStream_iface);
4525 }
4526
4527 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamCacheControl(IMFByteStreamCacheControl *iface)
4528 {
4529 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamCacheControl_iface);
4530 }
4531
4532 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamBuffering(IMFByteStreamBuffering *iface)
4533 {
4534 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamBuffering_iface);
4535 }
4536
4537 static struct bytestream_wrapper *impl_wrapper_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
4538 {
4539 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFMediaEventGenerator_iface);
4540 }
4541
4542 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamTimeSeek(IMFByteStreamTimeSeek *iface)
4543 {
4544 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamTimeSeek_iface);
4545 }
4546
4547 static struct bytestream_wrapper *impl_wrapper_from_IMFSampleOutputStream(IMFSampleOutputStream *iface)
4548 {
4549 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFSampleOutputStream_iface);
4550 }
4551
4552 static struct bytestream_wrapper *impl_wrapper_from_IPropertyStore(IPropertyStore *iface)
4553 {
4554 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IPropertyStore_iface);
4555 }
4556
4557 static struct bytestream_wrapper *impl_wrapper_from_IMFAttributes(IMFAttributes *iface)
4558 {
4559 return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFAttributes_iface);
4560 }
4561
4562 static HRESULT WINAPI bytestream_wrapper_QueryInterface(IMFByteStream *iface, REFIID riid, void **out)
4563 {
4564 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4565
4566 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
4567
4568 if (IsEqualIID(riid, &IID_IMFByteStream) ||
4569 IsEqualIID(riid, &IID_IUnknown))
4570 {
4571 *out = &wrapper->IMFByteStream_iface;
4572 }
4573 else if (wrapper->cache_control && IsEqualIID(riid, &IID_IMFByteStreamCacheControl))
4574 {
4575 *out = &wrapper->IMFByteStreamCacheControl_iface;
4576 }
4577 else if (wrapper->stream_buffering && IsEqualIID(riid, &IID_IMFByteStreamBuffering))
4578 {
4579 *out = &wrapper->IMFByteStreamBuffering_iface;
4580 }
4581 else if (wrapper->event_generator && IsEqualIID(riid, &IID_IMFMediaEventGenerator))
4582 {
4583 *out = &wrapper->IMFMediaEventGenerator_iface;
4584 }
4585 else if (wrapper->time_seek && IsEqualIID(riid, &IID_IMFByteStreamTimeSeek))
4586 {
4587 *out = &wrapper->IMFByteStreamTimeSeek_iface;
4588 }
4589 else if (wrapper->sample_output && IsEqualIID(riid, &IID_IMFSampleOutputStream))
4590 {
4591 *out = &wrapper->IMFSampleOutputStream_iface;
4592 }
4593 else if (wrapper->propstore && IsEqualIID(riid, &IID_IPropertyStore))
4594 {
4595 *out = &wrapper->IPropertyStore_iface;
4596 }
4597 else if (wrapper->attributes && IsEqualIID(riid, &IID_IMFAttributes))
4598 {
4599 *out = &wrapper->IMFAttributes_iface;
4600 }
4601 else
4602 {
4603 WARN("Unsupported %s.\n", debugstr_guid(riid));
4604 *out = NULL;
4605 return E_NOINTERFACE;
4606 }
4607
4608 IUnknown_AddRef((IUnknown *)*out);
4609 return S_OK;
4610 }
4611
4612 static ULONG WINAPI bytestream_wrapper_AddRef(IMFByteStream *iface)
4613 {
4614 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4615 ULONG refcount = InterlockedIncrement(&wrapper->refcount);
4616
4617 TRACE("%p, refcount %d.\n", iface, refcount);
4618
4619 return refcount;
4620 }
4621
4622 static ULONG WINAPI bytestream_wrapper_Release(IMFByteStream *iface)
4623 {
4624 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4625 ULONG refcount = InterlockedDecrement(&wrapper->refcount);
4626
4627 TRACE("%p, refcount %d.\n", iface, refcount);
4628
4629 if (!refcount)
4630 {
4631 if (wrapper->cache_control)
4632 IMFByteStreamCacheControl_Release(wrapper->cache_control);
4633 if (wrapper->stream_buffering)
4634 IMFByteStreamBuffering_Release(wrapper->stream_buffering);
4635 if (wrapper->event_generator)
4636 IMFMediaEventGenerator_Release(wrapper->event_generator);
4637 if (wrapper->time_seek)
4638 IMFByteStreamTimeSeek_Release(wrapper->time_seek);
4639 if (wrapper->sample_output)
4640 IMFSampleOutputStream_Release(wrapper->sample_output);
4641 if (wrapper->propstore)
4642 IPropertyStore_Release(wrapper->propstore);
4643 if (wrapper->attributes)
4644 IMFAttributes_Release(wrapper->attributes);
4645 IMFByteStream_Release(wrapper->stream);
4646 free(wrapper);
4647 }
4648
4649 return refcount;
4650 }
4651
4652 static HRESULT WINAPI bytestream_wrapper_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
4653 {
4654 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4655
4656 TRACE("%p, %p.\n", iface, capabilities);
4657
4658 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4659 IMFByteStream_GetCapabilities(wrapper->stream, capabilities);
4660 }
4661
4662 static HRESULT WINAPI bytestream_wrapper_GetLength(IMFByteStream *iface, QWORD *length)
4663 {
4664 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4665
4666 TRACE("%p, %p.\n", iface, length);
4667
4668 if (wrapper->is_closed)
4669 return MF_E_INVALIDREQUEST;
4670
4671 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4672 IMFByteStream_GetLength(wrapper->stream, length);
4673 }
4674
4675 static HRESULT WINAPI bytestream_wrapper_SetLength(IMFByteStream *iface, QWORD length)
4676 {
4677 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4678
4679 TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(length));
4680
4681 if (wrapper->is_closed)
4682 return MF_E_INVALIDREQUEST;
4683
4684 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4685 IMFByteStream_SetLength(wrapper->stream, length);
4686 }
4687
4688 static HRESULT WINAPI bytestream_wrapper_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
4689 {
4690 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4691
4692 TRACE("%p, %p.\n", iface, position);
4693
4694 if (wrapper->is_closed)
4695 return MF_E_INVALIDREQUEST;
4696
4697 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4698 IMFByteStream_GetCurrentPosition(wrapper->stream, position);
4699 }
4700
4701 static HRESULT WINAPI bytestream_wrapper_SetCurrentPosition(IMFByteStream *iface, QWORD position)
4702 {
4703 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4704
4705 TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
4706
4707 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4708 IMFByteStream_SetCurrentPosition(wrapper->stream, position);
4709 }
4710
4711 static HRESULT WINAPI bytestream_wrapper_IsEndOfStream(IMFByteStream *iface, BOOL *eos)
4712 {
4713 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4714
4715 TRACE("%p, %p.\n", iface, eos);
4716
4717 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4718 IMFByteStream_IsEndOfStream(wrapper->stream, eos);
4719 }
4720
4721 static HRESULT WINAPI bytestream_wrapper_Read(IMFByteStream *iface, BYTE *data, ULONG count, ULONG *byte_read)
4722 {
4723 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4724
4725 TRACE("%p, %p, %u, %p.\n", iface, data, count, byte_read);
4726
4727 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4728 IMFByteStream_Read(wrapper->stream, data, count, byte_read);
4729 }
4730
4731 static HRESULT WINAPI bytestream_wrapper_BeginRead(IMFByteStream *iface, BYTE *data, ULONG size,
4732 IMFAsyncCallback *callback, IUnknown *state)
4733 {
4734 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4735
4736 TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
4737
4738 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4739 IMFByteStream_BeginRead(wrapper->stream, data, size, callback, state);
4740 }
4741
4742 static HRESULT WINAPI bytestream_wrapper_EndRead(IMFByteStream *iface, IMFAsyncResult *result, ULONG *byte_read)
4743 {
4744 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4745
4746 TRACE("%p, %p, %p.\n", iface, result, byte_read);
4747
4748 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4749 IMFByteStream_EndRead(wrapper->stream, result, byte_read);
4750 }
4751
4752 static HRESULT WINAPI bytestream_wrapper_Write(IMFByteStream *iface, const BYTE *data, ULONG count, ULONG *written)
4753 {
4754 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4755
4756 TRACE("%p, %p, %u, %p.\n", iface, data, count, written);
4757
4758 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4759 IMFByteStream_Write(wrapper->stream, data, count, written);
4760 }
4761
4762 static HRESULT WINAPI bytestream_wrapper_BeginWrite(IMFByteStream *iface, const BYTE *data, ULONG size,
4763 IMFAsyncCallback *callback, IUnknown *state)
4764 {
4765 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4766
4767 TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
4768
4769 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4770 IMFByteStream_BeginWrite(wrapper->stream, data, size, callback, state);
4771 }
4772
4773 static HRESULT WINAPI bytestream_wrapper_EndWrite(IMFByteStream *iface, IMFAsyncResult *result, ULONG *written)
4774 {
4775 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4776
4777 TRACE("%p, %p, %p.\n", iface, result, written);
4778
4779 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4780 IMFByteStream_EndWrite(wrapper->stream, result, written);
4781 }
4782
4783 static HRESULT WINAPI bytestream_wrapper_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN seek, LONGLONG offset,
4784 DWORD flags, QWORD *current)
4785 {
4786 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4787
4788 TRACE("%p, %u, %s, %#x, %p.\n", iface, seek, wine_dbgstr_longlong(offset), flags, current);
4789
4790 return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4791 IMFByteStream_Seek(wrapper->stream, seek, offset, flags, current);
4792 }
4793
4794 static HRESULT WINAPI bytestream_wrapper_Flush(IMFByteStream *iface)
4795 {
4796 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4797
4798 TRACE("%p\n", iface);
4799
4800 return wrapper->is_closed ? MF_E_INVALIDREQUEST : IMFByteStream_Flush(wrapper->stream);
4801 }
4802
4803 static HRESULT WINAPI bytestream_wrapper_Close(IMFByteStream *iface)
4804 {
4805 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4806
4807 TRACE("%p\n", iface);
4808
4809 wrapper->is_closed = TRUE;
4810
4811 return S_OK;
4812 }
4813
4814 static const IMFByteStreamVtbl bytestream_wrapper_vtbl =
4815 {
4816 bytestream_wrapper_QueryInterface,
4817 bytestream_wrapper_AddRef,
4818 bytestream_wrapper_Release,
4819 bytestream_wrapper_GetCapabilities,
4820 bytestream_wrapper_GetLength,
4821 bytestream_wrapper_SetLength,
4822 bytestream_wrapper_GetCurrentPosition,
4823 bytestream_wrapper_SetCurrentPosition,
4824 bytestream_wrapper_IsEndOfStream,
4825 bytestream_wrapper_Read,
4826 bytestream_wrapper_BeginRead,
4827 bytestream_wrapper_EndRead,
4828 bytestream_wrapper_Write,
4829 bytestream_wrapper_BeginWrite,
4830 bytestream_wrapper_EndWrite,
4831 bytestream_wrapper_Seek,
4832 bytestream_wrapper_Flush,
4833 bytestream_wrapper_Close,
4834 };
4835
4836 static HRESULT WINAPI bytestream_wrapper_cache_control_QueryInterface(IMFByteStreamCacheControl *iface,
4837 REFIID riid, void **obj)
4838 {
4839 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4840 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4841 }
4842
4843 static ULONG WINAPI bytestream_wrapper_cache_control_AddRef(IMFByteStreamCacheControl *iface)
4844 {
4845 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4846 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4847 }
4848
4849 static ULONG WINAPI bytestream_wrapper_cache_control_Release(IMFByteStreamCacheControl *iface)
4850 {
4851 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4852 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4853 }
4854
4855 static HRESULT WINAPI bytestream_wrapper_cache_control_StopBackgroundTransfer(IMFByteStreamCacheControl *iface)
4856 {
4857 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4858
4859 TRACE("%p.\n", iface);
4860
4861 return IMFByteStreamCacheControl_StopBackgroundTransfer(wrapper->cache_control);
4862 }
4863
4864 static const IMFByteStreamCacheControlVtbl bytestream_wrapper_cache_control_vtbl =
4865 {
4866 bytestream_wrapper_cache_control_QueryInterface,
4867 bytestream_wrapper_cache_control_AddRef,
4868 bytestream_wrapper_cache_control_Release,
4869 bytestream_wrapper_cache_control_StopBackgroundTransfer,
4870 };
4871
4872 static HRESULT WINAPI bytestream_wrapper_buffering_QueryInterface(IMFByteStreamBuffering *iface,
4873 REFIID riid, void **obj)
4874 {
4875 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4876 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4877 }
4878
4879 static ULONG WINAPI bytestream_wrapper_buffering_AddRef(IMFByteStreamBuffering *iface)
4880 {
4881 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4882 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4883 }
4884
4885 static ULONG WINAPI bytestream_wrapper_buffering_Release(IMFByteStreamBuffering *iface)
4886 {
4887 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4888 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4889 }
4890
4891 static HRESULT WINAPI bytestream_wrapper_buffering_SetBufferingParams(IMFByteStreamBuffering *iface,
4892 MFBYTESTREAM_BUFFERING_PARAMS *params)
4893 {
4894 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4895
4896 TRACE("%p, %p.\n", iface, params);
4897
4898 return IMFByteStreamBuffering_SetBufferingParams(wrapper->stream_buffering, params);
4899 }
4900
4901 static HRESULT WINAPI bytestream_wrapper_buffering_EnableBuffering(IMFByteStreamBuffering *iface,
4902 BOOL enable)
4903 {
4904 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4905
4906 TRACE("%p, %d.\n", iface, enable);
4907
4908 return IMFByteStreamBuffering_EnableBuffering(wrapper->stream_buffering, enable);
4909 }
4910
4911 static HRESULT WINAPI bytestream_wrapper_buffering_StopBuffering(IMFByteStreamBuffering *iface)
4912 {
4913 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4914
4915 TRACE("%p.\n", iface);
4916
4917 return IMFByteStreamBuffering_StopBuffering(wrapper->stream_buffering);
4918 }
4919
4920 static const IMFByteStreamBufferingVtbl bytestream_wrapper_buffering_vtbl =
4921 {
4922 bytestream_wrapper_buffering_QueryInterface,
4923 bytestream_wrapper_buffering_AddRef,
4924 bytestream_wrapper_buffering_Release,
4925 bytestream_wrapper_buffering_SetBufferingParams,
4926 bytestream_wrapper_buffering_EnableBuffering,
4927 bytestream_wrapper_buffering_StopBuffering,
4928 };
4929
4930 static HRESULT WINAPI bytestream_wrapper_timeseek_QueryInterface(IMFByteStreamTimeSeek *iface,
4931 REFIID riid, void **obj)
4932 {
4933 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4934 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4935 }
4936
4937 static ULONG WINAPI bytestream_wrapper_timeseek_AddRef(IMFByteStreamTimeSeek *iface)
4938 {
4939 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4940 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4941 }
4942
4943 static ULONG WINAPI bytestream_wrapper_timeseek_Release(IMFByteStreamTimeSeek *iface)
4944 {
4945 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4946 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4947 }
4948
4949 static HRESULT WINAPI bytestream_wrapper_timeseek_IsTimeSeekSupported(IMFByteStreamTimeSeek *iface, BOOL *result)
4950 {
4951 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4952
4953 TRACE("%p, %p.\n", iface, result);
4954
4955 return IMFByteStreamTimeSeek_IsTimeSeekSupported(wrapper->time_seek, result);
4956 }
4957
4958 static HRESULT WINAPI bytestream_wrapper_timeseek_TimeSeek(IMFByteStreamTimeSeek *iface, QWORD position)
4959 {
4960 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4961
4962 TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
4963
4964 return IMFByteStreamTimeSeek_TimeSeek(wrapper->time_seek, position);
4965 }
4966
4967 static HRESULT WINAPI bytestream_wrapper_timeseek_GetTimeSeekResult(IMFByteStreamTimeSeek *iface, QWORD *start_time,
4968 QWORD *stop_time, QWORD *duration)
4969 {
4970 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4971
4972 TRACE("%p, %p, %p, %p.\n", iface, start_time, stop_time, duration);
4973
4974 return IMFByteStreamTimeSeek_GetTimeSeekResult(wrapper->time_seek, start_time, stop_time, duration);
4975 }
4976
4977 static const IMFByteStreamTimeSeekVtbl bytestream_wrapper_timeseek_vtbl =
4978 {
4979 bytestream_wrapper_timeseek_QueryInterface,
4980 bytestream_wrapper_timeseek_AddRef,
4981 bytestream_wrapper_timeseek_Release,
4982 bytestream_wrapper_timeseek_IsTimeSeekSupported,
4983 bytestream_wrapper_timeseek_TimeSeek,
4984 bytestream_wrapper_timeseek_GetTimeSeekResult,
4985 };
4986
4987 static HRESULT WINAPI bytestream_wrapper_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
4988 {
4989 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4990 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4991 }
4992
4993 static ULONG WINAPI bytestream_wrapper_events_AddRef(IMFMediaEventGenerator *iface)
4994 {
4995 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4996 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4997 }
4998
4999 static ULONG WINAPI bytestream_wrapper_events_Release(IMFMediaEventGenerator *iface)
5000 {
5001 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
5002 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5003 }
5004
5005 static HRESULT WINAPI bytestream_wrapper_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
5006 {
5007 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
5008
5009 TRACE("%p, %#x, %p.\n", iface, flags, event);
5010
5011 return IMFMediaEventGenerator_GetEvent(wrapper->event_generator, flags, event);
5012 }
5013
5014 static HRESULT WINAPI bytestream_wrapper_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback, IUnknown *state)
5015 {
5016 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
5017
5018 TRACE("%p, %p, %p.\n", iface, callback, state);
5019
5020 return IMFMediaEventGenerator_BeginGetEvent(wrapper->event_generator, callback, state);
5021 }
5022
5023 static HRESULT WINAPI bytestream_wrapper_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result, IMFMediaEvent **event)
5024 {
5025 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
5026
5027 TRACE("%p, %p, %p.\n", iface, result, event);
5028
5029 return IMFMediaEventGenerator_EndGetEvent(wrapper->event_generator, result, event);
5030 }
5031
5032 static HRESULT WINAPI bytestream_wrapper_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType type,
5033 REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
5034 {
5035 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
5036
5037 TRACE("%p, %d, %s, %#x, %s.\n", iface, type, debugstr_guid(ext_type), hr, debugstr_propvar(value));
5038
5039 return IMFMediaEventGenerator_QueueEvent(wrapper->event_generator, type, ext_type, hr, value);
5040 }
5041
5042 static const IMFMediaEventGeneratorVtbl bytestream_wrapper_events_vtbl =
5043 {
5044 bytestream_wrapper_events_QueryInterface,
5045 bytestream_wrapper_events_AddRef,
5046 bytestream_wrapper_events_Release,
5047 bytestream_wrapper_events_GetEvent,
5048 bytestream_wrapper_events_BeginGetEvent,
5049 bytestream_wrapper_events_EndGetEvent,
5050 bytestream_wrapper_events_QueueEvent,
5051 };
5052
5053 static HRESULT WINAPI bytestream_wrapper_sample_output_QueryInterface(IMFSampleOutputStream *iface, REFIID riid, void **obj)
5054 {
5055 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5056 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
5057 }
5058
5059 static ULONG WINAPI bytestream_wrapper_sample_output_AddRef(IMFSampleOutputStream *iface)
5060 {
5061 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5062 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
5063 }
5064
5065 static ULONG WINAPI bytestream_wrapper_sample_output_Release(IMFSampleOutputStream *iface)
5066 {
5067 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5068 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5069 }
5070
5071 static HRESULT WINAPI bytestream_wrapper_sample_output_BeginWriteSample(IMFSampleOutputStream *iface, IMFSample *sample,
5072 IMFAsyncCallback *callback, IUnknown *state)
5073 {
5074 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5075
5076 TRACE("%p, %p, %p, %p.\n", iface, sample, callback, state);
5077
5078 return IMFSampleOutputStream_BeginWriteSample(wrapper->sample_output, sample, callback, state);
5079 }
5080
5081 static HRESULT WINAPI bytestream_wrapper_sample_output_EndWriteSample(IMFSampleOutputStream *iface, IMFAsyncResult *result)
5082 {
5083 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5084
5085 TRACE("%p, %p.\n", iface, result);
5086
5087 return IMFSampleOutputStream_EndWriteSample(wrapper->sample_output, result);
5088 }
5089
5090 static HRESULT WINAPI bytestream_wrapper_sample_output_Close(IMFSampleOutputStream *iface)
5091 {
5092 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
5093
5094 TRACE("%p.\n", iface);
5095
5096 return IMFSampleOutputStream_Close(wrapper->sample_output);
5097 }
5098
5099 static const IMFSampleOutputStreamVtbl bytestream_wrapper_sample_output_vtbl =
5100 {
5101 bytestream_wrapper_sample_output_QueryInterface,
5102 bytestream_wrapper_sample_output_AddRef,
5103 bytestream_wrapper_sample_output_Release,
5104 bytestream_wrapper_sample_output_BeginWriteSample,
5105 bytestream_wrapper_sample_output_EndWriteSample,
5106 bytestream_wrapper_sample_output_Close,
5107 };
5108
5109 static HRESULT WINAPI bytestream_wrapper_propstore_QueryInterface(IPropertyStore *iface, REFIID riid, void **obj)
5110 {
5111 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5112 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
5113 }
5114
5115 static ULONG WINAPI bytestream_wrapper_propstore_AddRef(IPropertyStore *iface)
5116 {
5117 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5118 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
5119 }
5120
5121 static ULONG WINAPI bytestream_wrapper_propstore_Release(IPropertyStore *iface)
5122 {
5123 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5124 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5125 }
5126
5127 static HRESULT WINAPI bytestream_wrapper_propstore_GetCount(IPropertyStore *iface, DWORD *count)
5128 {
5129 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5130
5131 TRACE("%p, %p.\n", iface, count);
5132
5133 return IPropertyStore_GetCount(wrapper->propstore, count);
5134 }
5135
5136 static HRESULT WINAPI bytestream_wrapper_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
5137 {
5138 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5139
5140 TRACE("%p, %u, %p.\n", iface, prop, key);
5141
5142 return IPropertyStore_GetAt(wrapper->propstore, prop, key);
5143 }
5144
5145 static HRESULT WINAPI bytestream_wrapper_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
5146 {
5147 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5148
5149 TRACE("%p, %p, %p.\n", iface, key, value);
5150
5151 return IPropertyStore_GetValue(wrapper->propstore, key, value);
5152 }
5153
5154 static HRESULT WINAPI bytestream_wrapper_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key,
5155 const PROPVARIANT *value)
5156 {
5157 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5158
5159 TRACE("%p, %p, %s.\n", iface, key, debugstr_propvar(value));
5160
5161 return IPropertyStore_SetValue(wrapper->propstore, key, value);
5162 }
5163
5164 static HRESULT WINAPI bytestream_wrapper_propstore_Commit(IPropertyStore *iface)
5165 {
5166 struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5167
5168 TRACE("%p.\n", iface);
5169
5170 return IPropertyStore_Commit(wrapper->propstore);
5171 }
5172
5173 static const IPropertyStoreVtbl bytestream_wrapper_propstore_vtbl =
5174 {
5175 bytestream_wrapper_propstore_QueryInterface,
5176 bytestream_wrapper_propstore_AddRef,
5177 bytestream_wrapper_propstore_Release,
5178 bytestream_wrapper_propstore_GetCount,
5179 bytestream_wrapper_propstore_GetAt,
5180 bytestream_wrapper_propstore_GetValue,
5181 bytestream_wrapper_propstore_SetValue,
5182 bytestream_wrapper_propstore_Commit,
5183 };
5184
5185 static HRESULT WINAPI bytestream_wrapper_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
5186 {
5187 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5188 return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
5189 }
5190
5191 static ULONG WINAPI bytestream_wrapper_attributes_AddRef(IMFAttributes *iface)
5192 {
5193 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5194 return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
5195 }
5196
5197 static ULONG WINAPI bytestream_wrapper_attributes_Release(IMFAttributes *iface)
5198 {
5199 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5200 return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5201 }
5202
5203 static HRESULT WINAPI bytestream_wrapper_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
5204 {
5205 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5206
5207 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5208
5209 return IMFAttributes_GetItem(wrapper->attributes, key, value);
5210 }
5211
5212 static HRESULT WINAPI bytestream_wrapper_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
5213 {
5214 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5215
5216 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
5217
5218 return IMFAttributes_GetItemType(wrapper->attributes, key, type);
5219 }
5220
5221 static HRESULT WINAPI bytestream_wrapper_attributes_CompareItem(IMFAttributes *iface, REFGUID key,
5222 REFPROPVARIANT value, BOOL *result)
5223 {
5224 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5225
5226 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
5227
5228 return IMFAttributes_CompareItem(wrapper->attributes, key, value, result);
5229 }
5230
5231 static HRESULT WINAPI bytestream_wrapper_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
5232 MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
5233 {
5234 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5235
5236 TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
5237
5238 return IMFAttributes_Compare(wrapper->attributes, theirs, match_type, ret);
5239 }
5240
5241 static HRESULT WINAPI bytestream_wrapper_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
5242 {
5243 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5244
5245 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5246
5247 return IMFAttributes_GetUINT32(wrapper->attributes, key, value);
5248 }
5249
5250 static HRESULT WINAPI bytestream_wrapper_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
5251 {
5252 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5253
5254 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5255
5256 return IMFAttributes_GetUINT64(wrapper->attributes, key, value);
5257 }
5258
5259 static HRESULT WINAPI bytestream_wrapper_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
5260 {
5261 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5262
5263 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5264
5265 return IMFAttributes_GetDouble(wrapper->attributes, key, value);
5266 }
5267
5268 static HRESULT WINAPI bytestream_wrapper_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
5269 {
5270 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5271
5272 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5273
5274 return IMFAttributes_GetGUID(wrapper->attributes, key, value);
5275 }
5276
5277 static HRESULT WINAPI bytestream_wrapper_attributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
5278 {
5279 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5280
5281 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
5282
5283 return IMFAttributes_GetStringLength(wrapper->attributes, key, length);
5284 }
5285
5286 static HRESULT WINAPI bytestream_wrapper_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
5287 UINT32 size, UINT32 *length)
5288 {
5289 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5290
5291 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
5292
5293 return IMFAttributes_GetString(wrapper->attributes, key, value, size, length);
5294 }
5295
5296 static HRESULT WINAPI bytestream_wrapper_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key, WCHAR **value, UINT32 *length)
5297 {
5298 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5299
5300 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
5301
5302 return IMFAttributes_GetAllocatedString(wrapper->attributes, key, value, length);
5303 }
5304
5305 static HRESULT WINAPI bytestream_wrapper_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
5306 {
5307 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5308
5309 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
5310
5311 return IMFAttributes_GetBlobSize(wrapper->attributes, key, size);
5312 }
5313
5314 static HRESULT WINAPI bytestream_wrapper_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
5315 UINT32 bufsize, UINT32 *blobsize)
5316 {
5317 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5318
5319 TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
5320
5321 return IMFAttributes_GetBlob(wrapper->attributes, key, buf, bufsize, blobsize);
5322 }
5323
5324 static HRESULT WINAPI bytestream_wrapper_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
5325 {
5326 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5327
5328 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
5329
5330 return IMFAttributes_GetAllocatedBlob(wrapper->attributes, key, buf, size);
5331 }
5332
5333 static HRESULT WINAPI bytestream_wrapper_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **obj)
5334 {
5335 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5336
5337 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
5338
5339 return IMFAttributes_GetUnknown(wrapper->attributes, key, riid, obj);
5340 }
5341
5342 static HRESULT WINAPI bytestream_wrapper_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
5343 {
5344 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5345
5346 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
5347
5348 return IMFAttributes_SetItem(wrapper->attributes, key, value);
5349 }
5350
5351 static HRESULT WINAPI bytestream_wrapper_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
5352 {
5353 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5354
5355 TRACE("%p, %s.\n", iface, debugstr_attr(key));
5356
5357 return IMFAttributes_DeleteItem(wrapper->attributes, key);
5358 }
5359
5360 static HRESULT WINAPI bytestream_wrapper_attributes_DeleteAllItems(IMFAttributes *iface)
5361 {
5362 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5363
5364 TRACE("%p.\n", iface);
5365
5366 return IMFAttributes_DeleteAllItems(wrapper->attributes);
5367 }
5368
5369 static HRESULT WINAPI bytestream_wrapper_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
5370 {
5371 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5372
5373 TRACE("%p, %s, %d.\n", iface, debugstr_attr(key), value);
5374
5375 return IMFAttributes_SetUINT32(wrapper->attributes, key, value);
5376 }
5377
5378 static HRESULT WINAPI bytestream_wrapper_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
5379 {
5380 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5381
5382 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
5383
5384 return IMFAttributes_SetUINT64(wrapper->attributes, key, value);
5385 }
5386
5387 static HRESULT WINAPI bytestream_wrapper_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
5388 {
5389 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5390
5391 TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
5392
5393 return IMFAttributes_SetDouble(wrapper->attributes, key, value);
5394 }
5395
5396 static HRESULT WINAPI bytestream_wrapper_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
5397 {
5398 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5399
5400 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
5401
5402 return IMFAttributes_SetGUID(wrapper->attributes, key, value);
5403 }
5404
5405 static HRESULT WINAPI bytestream_wrapper_attributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
5406 {
5407 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5408
5409 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
5410
5411 return IMFAttributes_SetString(wrapper->attributes, key, value);
5412 }
5413
5414 static HRESULT WINAPI bytestream_wrapper_attributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
5415 {
5416 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5417
5418 TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
5419
5420 return IMFAttributes_SetBlob(wrapper->attributes, key, buf, size);
5421 }
5422
5423 static HRESULT WINAPI bytestream_wrapper_attributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
5424 {
5425 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5426
5427 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
5428
5429 return IMFAttributes_SetUnknown(wrapper->attributes, key, unknown);
5430 }
5431
5432 static HRESULT WINAPI bytestream_wrapper_attributes_LockStore(IMFAttributes *iface)
5433 {
5434 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5435
5436 TRACE("%p.\n", iface);
5437
5438 return IMFAttributes_LockStore(wrapper->attributes);
5439 }
5440
5441 static HRESULT WINAPI bytestream_wrapper_attributes_UnlockStore(IMFAttributes *iface)
5442 {
5443 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5444
5445 TRACE("%p.\n", iface);
5446
5447 return IMFAttributes_UnlockStore(wrapper->attributes);
5448 }
5449
5450 static HRESULT WINAPI bytestream_wrapper_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
5451 {
5452 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5453
5454 TRACE("%p, %p.\n", iface, count);
5455
5456 return IMFAttributes_GetCount(wrapper->attributes, count);
5457 }
5458
5459 static HRESULT WINAPI bytestream_wrapper_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
5460 {
5461 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5462
5463 TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
5464
5465 return IMFAttributes_GetItemByIndex(wrapper->attributes, index, key, value);
5466 }
5467
5468 static HRESULT WINAPI bytestream_wrapper_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
5469 {
5470 struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5471
5472 TRACE("%p, %p.\n", iface, dest);
5473
5474 return IMFAttributes_CopyAllItems(wrapper->attributes, dest);
5475 }
5476
5477 static const IMFAttributesVtbl bytestream_wrapper_attributes_vtbl =
5478 {
5479 bytestream_wrapper_attributes_QueryInterface,
5480 bytestream_wrapper_attributes_AddRef,
5481 bytestream_wrapper_attributes_Release,
5482 bytestream_wrapper_attributes_GetItem,
5483 bytestream_wrapper_attributes_GetItemType,
5484 bytestream_wrapper_attributes_CompareItem,
5485 bytestream_wrapper_attributes_Compare,
5486 bytestream_wrapper_attributes_GetUINT32,
5487 bytestream_wrapper_attributes_GetUINT64,
5488 bytestream_wrapper_attributes_GetDouble,
5489 bytestream_wrapper_attributes_GetGUID,
5490 bytestream_wrapper_attributes_GetStringLength,
5491 bytestream_wrapper_attributes_GetString,
5492 bytestream_wrapper_attributes_GetAllocatedString,
5493 bytestream_wrapper_attributes_GetBlobSize,
5494 bytestream_wrapper_attributes_GetBlob,
5495 bytestream_wrapper_attributes_GetAllocatedBlob,
5496 bytestream_wrapper_attributes_GetUnknown,
5497 bytestream_wrapper_attributes_SetItem,
5498 bytestream_wrapper_attributes_DeleteItem,
5499 bytestream_wrapper_attributes_DeleteAllItems,
5500 bytestream_wrapper_attributes_SetUINT32,
5501 bytestream_wrapper_attributes_SetUINT64,
5502 bytestream_wrapper_attributes_SetDouble,
5503 bytestream_wrapper_attributes_SetGUID,
5504 bytestream_wrapper_attributes_SetString,
5505 bytestream_wrapper_attributes_SetBlob,
5506 bytestream_wrapper_attributes_SetUnknown,
5507 bytestream_wrapper_attributes_LockStore,
5508 bytestream_wrapper_attributes_UnlockStore,
5509 bytestream_wrapper_attributes_GetCount,
5510 bytestream_wrapper_attributes_GetItemByIndex,
5511 bytestream_wrapper_attributes_CopyAllItems
5512 };
5513
5514 /***********************************************************************
5515 * MFCreateMFByteStreamWrapper (mfplat.@)
5516 */
5517 HRESULT WINAPI MFCreateMFByteStreamWrapper(IMFByteStream *stream, IMFByteStream **wrapper)
5518 {
5519 struct bytestream_wrapper *object;
5520
5521 TRACE("%p, %p.\n", stream, wrapper);
5522
5523 if (!(object = calloc(1, sizeof(*object))))
5524 return E_OUTOFMEMORY;
5525
5526 object->IMFByteStreamCacheControl_iface.lpVtbl = &bytestream_wrapper_cache_control_vtbl;
5527 object->IMFByteStreamBuffering_iface.lpVtbl = &bytestream_wrapper_buffering_vtbl;
5528 object->IMFMediaEventGenerator_iface.lpVtbl = &bytestream_wrapper_events_vtbl;
5529 object->IMFByteStreamTimeSeek_iface.lpVtbl = &bytestream_wrapper_timeseek_vtbl;
5530 object->IMFSampleOutputStream_iface.lpVtbl = &bytestream_wrapper_sample_output_vtbl;
5531 object->IMFByteStream_iface.lpVtbl = &bytestream_wrapper_vtbl;
5532 object->IPropertyStore_iface.lpVtbl = &bytestream_wrapper_propstore_vtbl;
5533 object->IMFAttributes_iface.lpVtbl = &bytestream_wrapper_attributes_vtbl;
5534
5535 IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamCacheControl, (void **)&object->cache_control);
5536 IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamBuffering, (void **)&object->stream_buffering);
5537 IMFByteStream_QueryInterface(stream, &IID_IMFMediaEventGenerator, (void **)&object->event_generator);
5538 IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamTimeSeek, (void **)&object->time_seek);
5539 IMFByteStream_QueryInterface(stream, &IID_IMFSampleOutputStream, (void **)&object->sample_output);
5540 IMFByteStream_QueryInterface(stream, &IID_IPropertyStore, (void **)&object->propstore);
5541 IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&object->attributes);
5542
5543 object->stream = stream;
5544 IMFByteStream_AddRef(object->stream);
5545
5546 object->refcount = 1;
5547
5548 *wrapper = &object->IMFByteStream_iface;
5549
5550 return S_OK;
5551 }
5552
5553 static HRESULT WINAPI MFPluginControl_QueryInterface(IMFPluginControl *iface, REFIID riid, void **ppv)
5554 {
5555 if(IsEqualGUID(riid, &IID_IUnknown)) {
5556 TRACE("(IID_IUnknown %p)\n", ppv);
5557 *ppv = iface;
5558 }else if(IsEqualGUID(riid, &IID_IMFPluginControl)) {
5559 TRACE("(IID_IMFPluginControl %p)\n", ppv);
5560 *ppv = iface;
5561 }else {
5562 FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
5563 *ppv = NULL;
5564 return E_NOINTERFACE;
5565 }
5566
5567 IUnknown_AddRef((IUnknown*)*ppv);
5568 return S_OK;
5569 }
5570
5571 static ULONG WINAPI MFPluginControl_AddRef(IMFPluginControl *iface)
5572 {
5573 TRACE("\n");
5574 return 2;
5575 }
5576
5577 static ULONG WINAPI MFPluginControl_Release(IMFPluginControl *iface)
5578 {
5579 TRACE("\n");
5580 return 1;
5581 }
5582
5583 static HRESULT WINAPI MFPluginControl_GetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
5584 const WCHAR *selector, CLSID *clsid)
5585 {
5586 FIXME("(%d %s %p)\n", plugin_type, debugstr_w(selector), clsid);
5587 return E_NOTIMPL;
5588 }
5589
5590 static HRESULT WINAPI MFPluginControl_GetPreferredClsidByIndex(IMFPluginControl *iface, DWORD plugin_type,
5591 DWORD index, WCHAR **selector, CLSID *clsid)
5592 {
5593 FIXME("(%d %d %p %p)\n", plugin_type, index, selector, clsid);
5594 return E_NOTIMPL;
5595 }
5596
5597 static HRESULT WINAPI MFPluginControl_SetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
5598 const WCHAR *selector, const CLSID *clsid)
5599 {
5600 FIXME("(%d %s %s)\n", plugin_type, debugstr_w(selector), debugstr_guid(clsid));
5601 return E_NOTIMPL;
5602 }
5603
5604 static HRESULT WINAPI MFPluginControl_IsDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid)
5605 {
5606 FIXME("(%d %s)\n", plugin_type, debugstr_guid(clsid));
5607 return E_NOTIMPL;
5608 }
5609
5610 static HRESULT WINAPI MFPluginControl_GetDisabledByIndex(IMFPluginControl *iface, DWORD plugin_type, DWORD index, CLSID *clsid)
5611 {
5612 FIXME("(%d %d %p)\n", plugin_type, index, clsid);
5613 return E_NOTIMPL;
5614 }
5615
5616 static HRESULT WINAPI MFPluginControl_SetDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid, BOOL disabled)
5617 {
5618 FIXME("(%d %s %x)\n", plugin_type, debugstr_guid(clsid), disabled);
5619 return E_NOTIMPL;
5620 }
5621
5622 static const IMFPluginControlVtbl MFPluginControlVtbl = {
5623 MFPluginControl_QueryInterface,
5624 MFPluginControl_AddRef,
5625 MFPluginControl_Release,
5626 MFPluginControl_GetPreferredClsid,
5627 MFPluginControl_GetPreferredClsidByIndex,
5628 MFPluginControl_SetPreferredClsid,
5629 MFPluginControl_IsDisabled,
5630 MFPluginControl_GetDisabledByIndex,
5631 MFPluginControl_SetDisabled
5632 };
5633
5634 static IMFPluginControl plugin_control = { &MFPluginControlVtbl };
5635
5636 /***********************************************************************
5637 * MFGetPluginControl (mfplat.@)
5638 */
5639 HRESULT WINAPI MFGetPluginControl(IMFPluginControl **ret)
5640 {
5641 TRACE("(%p)\n", ret);
5642
5643 *ret = &plugin_control;
5644 return S_OK;
5645 }
5646
5647 enum resolved_object_origin
5648 {
5649 OBJECT_FROM_BYTESTREAM,
5650 OBJECT_FROM_URL,
5651 };
5652
5653 struct resolver_queued_result
5654 {
5655 struct list entry;
5656 IUnknown *object;
5657 MF_OBJECT_TYPE obj_type;
5658 HRESULT hr;
5659 IRtwqAsyncResult *inner_result;
5660 enum resolved_object_origin origin;
5661 };
5662
5663 struct resolver_cancel_object
5664 {
5665 IUnknown IUnknown_iface;
5666 LONG refcount;
5667 union
5668 {
5669 IUnknown *handler;
5670 IMFByteStreamHandler *stream_handler;
5671 IMFSchemeHandler *scheme_handler;
5672 } u;
5673 IUnknown *cancel_cookie;
5674 enum resolved_object_origin origin;
5675 };
5676
5677 struct source_resolver
5678 {
5679 IMFSourceResolver IMFSourceResolver_iface;
5680 LONG refcount;
5681 IRtwqAsyncCallback stream_callback;
5682 IRtwqAsyncCallback url_callback;
5683 CRITICAL_SECTION cs;
5684 struct list pending;
5685 };
5686
5687 static struct source_resolver *impl_from_IMFSourceResolver(IMFSourceResolver *iface)
5688 {
5689 return CONTAINING_RECORD(iface, struct source_resolver, IMFSourceResolver_iface);
5690 }
5691
5692 static struct source_resolver *impl_from_stream_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
5693 {
5694 return CONTAINING_RECORD(iface, struct source_resolver, stream_callback);
5695 }
5696
5697 static struct source_resolver *impl_from_url_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
5698 {
5699 return CONTAINING_RECORD(iface, struct source_resolver, url_callback);
5700 }
5701
5702 static HRESULT resolver_handler_end_create(struct source_resolver *resolver, enum resolved_object_origin origin,
5703 IRtwqAsyncResult *result)
5704 {
5705 IRtwqAsyncResult *inner_result = (IRtwqAsyncResult *)IRtwqAsyncResult_GetStateNoAddRef(result);
5706 RTWQASYNCRESULT *data = (RTWQASYNCRESULT *)inner_result;
5707 struct resolver_queued_result *queued_result;
5708 union
5709 {
5710 IUnknown *handler;
5711 IMFByteStreamHandler *stream_handler;
5712 IMFSchemeHandler *scheme_handler;
5713 } handler;
5714
5715 if (!(queued_result = calloc(1, sizeof(*queued_result))))
5716 return E_OUTOFMEMORY;
5717
5718 queued_result->origin = origin;
5719
5720 IRtwqAsyncResult_GetObject(inner_result, &handler.handler);
5721
5722 switch (origin)
5723 {
5724 case OBJECT_FROM_BYTESTREAM:
5725 queued_result->hr = IMFByteStreamHandler_EndCreateObject(handler.stream_handler, (IMFAsyncResult *)result,
5726 &queued_result->obj_type, &queued_result->object);
5727 break;
5728 case OBJECT_FROM_URL:
5729 queued_result->hr = IMFSchemeHandler_EndCreateObject(handler.scheme_handler, (IMFAsyncResult *)result,
5730 &queued_result->obj_type, &queued_result->object);
5731 break;
5732 default:
5733 queued_result->hr = E_FAIL;
5734 }
5735
5736 IUnknown_Release(handler.handler);
5737
5738 if (data->hEvent)
5739 {
5740 queued_result->inner_result = inner_result;
5741 IRtwqAsyncResult_AddRef(queued_result->inner_result);
5742 }
5743
5744 /* Push resolved object type and created object, so we don't have to guess on End*() call. */
5745 EnterCriticalSection(&resolver->cs);
5746 list_add_tail(&resolver->pending, &queued_result->entry);
5747 LeaveCriticalSection(&resolver->cs);
5748
5749 if (data->hEvent)
5750 SetEvent(data->hEvent);
5751 else
5752 {
5753 IUnknown *caller_state = IRtwqAsyncResult_GetStateNoAddRef(inner_result);
5754 IRtwqAsyncResult *caller_result;
5755
5756 if (SUCCEEDED(RtwqCreateAsyncResult(queued_result->object, data->pCallback, caller_state, &caller_result)))
5757 {
5758 RtwqInvokeCallback(caller_result);
5759 IRtwqAsyncResult_Release(caller_result);
5760 }
5761 }
5762
5763 return S_OK;
5764 }
5765
5766 static struct resolver_cancel_object *impl_cancel_obj_from_IUnknown(IUnknown *iface)
5767 {
5768 return CONTAINING_RECORD(iface, struct resolver_cancel_object, IUnknown_iface);
5769 }
5770
5771 static HRESULT WINAPI resolver_cancel_object_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
5772 {
5773 if (IsEqualIID(riid, &IID_IUnknown))
5774 {
5775 *obj = iface;
5776 IUnknown_AddRef(iface);
5777 return S_OK;
5778 }
5779
5780 *obj = NULL;
5781 return E_NOINTERFACE;
5782 }
5783
5784 static ULONG WINAPI resolver_cancel_object_AddRef(IUnknown *iface)
5785 {
5786 struct resolver_cancel_object *object = impl_cancel_obj_from_IUnknown(iface);
5787 return InterlockedIncrement(&object->refcount);
5788 }
5789
5790 static ULONG WINAPI resolver_cancel_object_Release(IUnknown *iface)
5791 {
5792 struct resolver_cancel_object *object = impl_cancel_obj_from_IUnknown(iface);
5793 ULONG refcount = InterlockedDecrement(&object->refcount);
5794
5795 if (!refcount)
5796 {
5797 if (object->cancel_cookie)
5798 IUnknown_Release(object->cancel_cookie);
5799 IUnknown_Release(object->u.handler);
5800 free(object);
5801 }
5802
5803 return refcount;
5804 }
5805
5806 static const IUnknownVtbl resolver_cancel_object_vtbl =
5807 {
5808 resolver_cancel_object_QueryInterface,
5809 resolver_cancel_object_AddRef,
5810 resolver_cancel_object_Release,
5811 };
5812
5813 static struct resolver_cancel_object *unsafe_impl_cancel_obj_from_IUnknown(IUnknown *iface)
5814 {
5815 if (!iface)
5816 return NULL;
5817
5818 return (iface->lpVtbl == &resolver_cancel_object_vtbl) ?
5819 CONTAINING_RECORD(iface, struct resolver_cancel_object, IUnknown_iface) : NULL;
5820 }
5821
5822 static HRESULT resolver_create_cancel_object(IUnknown *handler, enum resolved_object_origin origin,
5823 IUnknown *cancel_cookie, IUnknown **cancel_object)
5824 {
5825 struct resolver_cancel_object *object;
5826
5827 if (!(object = calloc(1, sizeof(*object))))
5828 return E_OUTOFMEMORY;
5829
5830 object->IUnknown_iface.lpVtbl = &resolver_cancel_object_vtbl;
5831 object->refcount = 1;
5832 object->u.handler = handler;
5833 IUnknown_AddRef(object->u.handler);
5834 object->cancel_cookie = cancel_cookie;
5835 IUnknown_AddRef(object->cancel_cookie);
5836 object->origin = origin;
5837
5838 *cancel_object = &object->IUnknown_iface;
5839
5840 return S_OK;
5841 }
5842
5843 static HRESULT WINAPI source_resolver_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
5844 {
5845 if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
5846 IsEqualIID(riid, &IID_IUnknown))
5847 {
5848 *obj = iface;
5849 IRtwqAsyncCallback_AddRef(iface);
5850 return S_OK;
5851 }
5852
5853 *obj = NULL;
5854 return E_NOINTERFACE;
5855 }
5856
5857 static ULONG WINAPI source_resolver_callback_stream_AddRef(IRtwqAsyncCallback *iface)
5858 {
5859 struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5860 return IMFSourceResolver_AddRef(&resolver->IMFSourceResolver_iface);
5861 }
5862
5863 static ULONG WINAPI source_resolver_callback_stream_Release(IRtwqAsyncCallback *iface)
5864 {
5865 struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5866 return IMFSourceResolver_Release(&resolver->IMFSourceResolver_iface);
5867 }
5868
5869 static HRESULT WINAPI source_resolver_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
5870 {
5871 return E_NOTIMPL;
5872 }
5873
5874 static HRESULT WINAPI source_resolver_callback_stream_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
5875 {
5876 struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5877
5878 return resolver_handler_end_create(resolver, OBJECT_FROM_BYTESTREAM, result);
5879 }
5880
5881 static const IRtwqAsyncCallbackVtbl source_resolver_callback_stream_vtbl =
5882 {
5883 source_resolver_callback_QueryInterface,
5884 source_resolver_callback_stream_AddRef,
5885 source_resolver_callback_stream_Release,
5886 source_resolver_callback_GetParameters,
5887 source_resolver_callback_stream_Invoke,
5888 };
5889
5890 static ULONG WINAPI source_resolver_callback_url_AddRef(IRtwqAsyncCallback *iface)
5891 {
5892 struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5893 return IMFSourceResolver_AddRef(&resolver->IMFSourceResolver_iface);
5894 }
5895
5896 static ULONG WINAPI source_resolver_callback_url_Release(IRtwqAsyncCallback *iface)
5897 {
5898 struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5899 return IMFSourceResolver_Release(&resolver->IMFSourceResolver_iface);
5900 }
5901
5902 static HRESULT WINAPI source_resolver_callback_url_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
5903 {
5904 struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5905
5906 return resolver_handler_end_create(resolver, OBJECT_FROM_URL, result);
5907 }
5908
5909 static const IRtwqAsyncCallbackVtbl source_resolver_callback_url_vtbl =
5910 {
5911 source_resolver_callback_QueryInterface,
5912 source_resolver_callback_url_AddRef,
5913 source_resolver_callback_url_Release,
5914 source_resolver_callback_GetParameters,
5915 source_resolver_callback_url_Invoke,
5916 };
5917
5918 static HRESULT resolver_create_registered_handler(HKEY hkey, REFIID riid, void **handler)
5919 {
5920 unsigned int j = 0, name_length, type;
5921 HRESULT hr = E_FAIL;
5922 WCHAR clsidW[39];
5923 CLSID clsid;
5924
5925 name_length = ARRAY_SIZE(clsidW);
5926 while (!RegEnumValueW(hkey, j++, clsidW, &name_length, NULL, &type, NULL, NULL))
5927 {
5928 if (type == REG_SZ)
5929 {
5930 if (SUCCEEDED(CLSIDFromString(clsidW, &clsid)))
5931 {
5932 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, riid, handler);
5933 if (SUCCEEDED(hr))
5934 break;
5935 }
5936 }
5937
5938 name_length = ARRAY_SIZE(clsidW);
5939 }
5940
5941 return hr;
5942 }
5943
5944 static HRESULT resolver_get_bytestream_handler(IMFByteStream *stream, const WCHAR *url, DWORD flags,
5945 IMFByteStreamHandler **handler)
5946 {
5947 static const char streamhandlerspath[] = "Software\\Microsoft\\Windows Media Foundation\\ByteStreamHandlers";
5948 static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
5949 IMFAttributes *attributes;
5950 const WCHAR *url_ext;
5951 WCHAR *mimeW = NULL;
5952 HRESULT hr = E_FAIL;
5953 unsigned int i, j;
5954 UINT32 length;
5955
5956 *handler = NULL;
5957
5958 /* MIME type */
5959 if (SUCCEEDED(IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&attributes)))
5960 {
5961 IMFAttributes_GetAllocatedString(attributes, &MF_BYTESTREAM_CONTENT_TYPE, &mimeW, &length);
5962 IMFAttributes_Release(attributes);
5963 }
5964
5965 /* Extension */
5966 url_ext = url ? wcsrchr(url, '.') : NULL;
5967
5968 if (!url_ext && !mimeW)
5969 {
5970 CoTaskMemFree(mimeW);
5971 return MF_E_UNSUPPORTED_BYTESTREAM_TYPE;
5972 }
5973
5974 if (!(flags & MF_RESOLUTION_DISABLE_LOCAL_PLUGINS))
5975 {
5976 struct local_handler *local_handler;
5977
5978 EnterCriticalSection(&local_handlers_section);
5979
5980 LIST_FOR_EACH_ENTRY(local_handler, &local_bytestream_handlers, struct local_handler, entry)
5981 {
5982 if ((mimeW && !lstrcmpiW(mimeW, local_handler->u.bytestream.mime))
5983 || (url_ext && !lstrcmpiW(url_ext, local_handler->u.bytestream.extension)))
5984 {
5985 if (SUCCEEDED(hr = IMFActivate_ActivateObject(local_handler->activate, &IID_IMFByteStreamHandler,
5986 (void **)handler)))
5987 break;
5988 }
5989 }
5990
5991 LeaveCriticalSection(&local_handlers_section);
5992
5993 if (*handler)
5994 return hr;
5995 }
5996
5997 for (i = 0, hr = E_FAIL; i < ARRAY_SIZE(hkey_roots); ++i)
5998 {
5999 const WCHAR *namesW[2] = { mimeW, url_ext };
6000 HKEY hkey, hkey_handler;
6001
6002 if (RegOpenKeyA(hkey_roots[i], streamhandlerspath, &hkey))
6003 continue;
6004
6005 for (j = 0; j < ARRAY_SIZE(namesW); ++j)
6006 {
6007 if (!namesW[j])
6008 continue;
6009
6010 if (!RegOpenKeyW(hkey, namesW[j], &hkey_handler))
6011 {
6012 hr = resolver_create_registered_handler(hkey_handler, &IID_IMFByteStreamHandler, (void **)handler);
6013 RegCloseKey(hkey_handler);
6014 }
6015
6016 if (SUCCEEDED(hr))
6017 break;
6018 }
6019
6020 RegCloseKey(hkey);
6021
6022 if (SUCCEEDED(hr))
6023 break;
6024 }
6025
6026 if (FAILED(hr))
6027 {
6028 static const GUID CLSID_GStreamerByteStreamHandler = {0x317df618, 0x5e5a, 0x468a, {0x9f, 0x15, 0xd8, 0x27, 0xa9, 0xa0, 0x81, 0x62}};
6029 hr = CoCreateInstance(&CLSID_GStreamerByteStreamHandler, NULL, CLSCTX_INPROC_SERVER, &IID_IMFByteStreamHandler, (void **)handler);
6030 }
6031
6032 CoTaskMemFree(mimeW);
6033 return hr;
6034 }
6035
6036 static HRESULT resolver_create_scheme_handler(const WCHAR *scheme, DWORD flags, IMFSchemeHandler **handler)
6037 {
6038 static const char schemehandlerspath[] = "Software\\Microsoft\\Windows Media Foundation\\SchemeHandlers";
6039 static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
6040 HRESULT hr = MF_E_UNSUPPORTED_SCHEME;
6041 unsigned int i;
6042
6043 TRACE("%s, %#x, %p.\n", debugstr_w(scheme), flags, handler);
6044
6045 *handler = NULL;
6046
6047 if (!(flags & MF_RESOLUTION_DISABLE_LOCAL_PLUGINS))
6048 {
6049 struct local_handler *local_handler;
6050
6051 EnterCriticalSection(&local_handlers_section);
6052
6053 LIST_FOR_EACH_ENTRY(local_handler, &local_scheme_handlers, struct local_handler, entry)
6054 {
6055 if (!lstrcmpiW(scheme, local_handler->u.scheme))
6056 {
6057 if (SUCCEEDED(hr = IMFActivate_ActivateObject(local_handler->activate, &IID_IMFSchemeHandler,
6058 (void **)handler)))
6059 break;
6060 }
6061 }
6062
6063 LeaveCriticalSection(&local_handlers_section);
6064
6065 if (*handler)
6066 return hr;
6067 }
6068
6069 for (i = 0; i < ARRAY_SIZE(hkey_roots); ++i)
6070 {
6071 HKEY hkey, hkey_handler;
6072
6073 hr = MF_E_UNSUPPORTED_SCHEME;
6074
6075 if (RegOpenKeyA(hkey_roots[i], schemehandlerspath, &hkey))
6076 continue;
6077
6078 if (!RegOpenKeyW(hkey, scheme, &hkey_handler))
6079 {
6080 hr = resolver_create_registered_handler(hkey_handler, &IID_IMFSchemeHandler, (void **)handler);
6081 RegCloseKey(hkey_handler);
6082 }
6083
6084 RegCloseKey(hkey);
6085
6086 if (SUCCEEDED(hr))
6087 break;
6088 }
6089
6090 return hr;
6091 }
6092
6093 static HRESULT resolver_get_scheme_handler(const WCHAR *url, DWORD flags, IMFSchemeHandler **handler)
6094 {
6095 static const WCHAR fileschemeW[] = L"file:";
6096 const WCHAR *ptr = url;
6097 unsigned int len;
6098 WCHAR *scheme;
6099 HRESULT hr;
6100
6101 /* RFC 3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
6102 while (*ptr)
6103 {
6104 WCHAR ch = towlower(*ptr);
6105
6106 if (*ptr == '*' && ptr == url)
6107 {
6108 ptr++;
6109 break;
6110 }
6111 else if (!(*ptr >= '0' && *ptr <= '9') &&
6112 !(ch >= 'a' && ch <= 'z') &&
6113 *ptr != '+' && *ptr != '-' && *ptr != '.')
6114 {
6115 break;
6116 }
6117
6118 ptr++;
6119 }
6120
6121 /* Schemes must end with a ':', if not found try "file:" */
6122 if (ptr == url || *ptr != ':')
6123 {
6124 url = fileschemeW;
6125 ptr = fileschemeW + ARRAY_SIZE(fileschemeW) - 1;
6126 }
6127
6128 len = ptr - url;
6129 scheme = malloc((len + 1) * sizeof(WCHAR));
6130 if (!scheme)
6131 return E_OUTOFMEMORY;
6132
6133 memcpy(scheme, url, len * sizeof(WCHAR));
6134 scheme[len] = 0;
6135
6136 hr = resolver_create_scheme_handler(scheme, flags, handler);
6137 if (FAILED(hr) && url != fileschemeW)
6138 hr = resolver_create_scheme_handler(fileschemeW, flags, handler);
6139
6140 free(scheme);
6141
6142 return hr;
6143 }
6144
6145 static HRESULT resolver_end_create_object(struct source_resolver *resolver, enum resolved_object_origin origin,
6146 IRtwqAsyncResult *result, MF_OBJECT_TYPE *obj_type, IUnknown **out)
6147 {
6148 struct resolver_queued_result *queued_result = NULL, *iter;
6149 IUnknown *object;
6150 HRESULT hr;
6151
6152 if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
6153 return hr;
6154
6155 EnterCriticalSection(&resolver->cs);
6156
6157 LIST_FOR_EACH_ENTRY(iter, &resolver->pending, struct resolver_queued_result, entry)
6158 {
6159 if (iter->inner_result == result || (iter->object == object && iter->origin == origin))
6160 {
6161 list_remove(&iter->entry);
6162 queued_result = iter;
6163 break;
6164 }
6165 }
6166
6167 LeaveCriticalSection(&resolver->cs);
6168
6169 IUnknown_Release(object);
6170
6171 if (queued_result)
6172 {
6173 *out = queued_result->object;
6174 *obj_type = queued_result->obj_type;
6175 hr = queued_result->hr;
6176 if (queued_result->inner_result)
6177 IRtwqAsyncResult_Release(queued_result->inner_result);
6178 free(queued_result);
6179 }
6180 else
6181 hr = E_UNEXPECTED;
6182
6183 return hr;
6184 }
6185
6186 static HRESULT WINAPI source_resolver_QueryInterface(IMFSourceResolver *iface, REFIID riid, void **obj)
6187 {
6188 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6189
6190 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6191
6192 if (IsEqualIID(riid, &IID_IMFSourceResolver) ||
6193 IsEqualIID(riid, &IID_IUnknown))
6194 {
6195 *obj = &resolver->IMFSourceResolver_iface;
6196 }
6197 else
6198 {
6199 *obj = NULL;
6200 FIXME("unsupported interface %s\n", debugstr_guid(riid));
6201 return E_NOINTERFACE;
6202 }
6203
6204 IUnknown_AddRef((IUnknown *)*obj);
6205 return S_OK;
6206 }
6207
6208 static ULONG WINAPI source_resolver_AddRef(IMFSourceResolver *iface)
6209 {
6210 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6211 ULONG refcount = InterlockedIncrement(&resolver->refcount);
6212
6213 TRACE("%p, refcount %d.\n", iface, refcount);
6214
6215 return refcount;
6216 }
6217
6218 static ULONG WINAPI source_resolver_Release(IMFSourceResolver *iface)
6219 {
6220 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6221 ULONG refcount = InterlockedDecrement(&resolver->refcount);
6222 struct resolver_queued_result *result, *result2;
6223
6224 TRACE("%p, refcount %d.\n", iface, refcount);
6225
6226 if (!refcount)
6227 {
6228 LIST_FOR_EACH_ENTRY_SAFE(result, result2, &resolver->pending, struct resolver_queued_result, entry)
6229 {
6230 if (result->object)
6231 IUnknown_Release(result->object);
6232 list_remove(&result->entry);
6233 free(result);
6234 }
6235 DeleteCriticalSection(&resolver->cs);
6236 free(resolver);
6237 }
6238
6239 return refcount;
6240 }
6241
6242 static HRESULT WINAPI source_resolver_CreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
6243 DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
6244 {
6245 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6246 IMFSchemeHandler *handler;
6247 IRtwqAsyncResult *result;
6248 RTWQASYNCRESULT *data;
6249 HRESULT hr;
6250
6251 TRACE("%p, %s, %#x, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, obj_type, object);
6252
6253 if (!url || !obj_type || !object)
6254 return E_POINTER;
6255
6256 if (FAILED(hr = resolver_get_scheme_handler(url, flags, &handler)))
6257 return hr;
6258
6259 hr = RtwqCreateAsyncResult((IUnknown *)handler, NULL, NULL, &result);
6260 IMFSchemeHandler_Release(handler);
6261 if (FAILED(hr))
6262 return hr;
6263
6264 data = (RTWQASYNCRESULT *)result;
6265 data->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
6266
6267 hr = IMFSchemeHandler_BeginCreateObject(handler, url, flags, props, NULL, (IMFAsyncCallback *)&resolver->url_callback,
6268 (IUnknown *)result);
6269 if (FAILED(hr))
6270 {
6271 IRtwqAsyncResult_Release(result);
6272 return hr;
6273 }
6274
6275 WaitForSingleObject(data->hEvent, INFINITE);
6276
6277 hr = resolver_end_create_object(resolver, OBJECT_FROM_URL, result, obj_type, object);
6278 IRtwqAsyncResult_Release(result);
6279
6280 return hr;
6281 }
6282
6283 static HRESULT WINAPI source_resolver_CreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
6284 const WCHAR *url, DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
6285 {
6286 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6287 IMFByteStreamHandler *handler;
6288 IRtwqAsyncResult *result;
6289 RTWQASYNCRESULT *data;
6290 HRESULT hr;
6291
6292 TRACE("%p, %p, %s, %#x, %p, %p, %p.\n", iface, stream, debugstr_w(url), flags, props, obj_type, object);
6293
6294 if (!stream || !obj_type || !object)
6295 return E_POINTER;
6296
6297 if (FAILED(hr = resolver_get_bytestream_handler(stream, url, flags, &handler)))
6298 return MF_E_UNSUPPORTED_BYTESTREAM_TYPE;
6299
6300 hr = RtwqCreateAsyncResult((IUnknown *)handler, NULL, NULL, &result);
6301 IMFByteStreamHandler_Release(handler);
6302 if (FAILED(hr))
6303 return hr;
6304
6305 data = (RTWQASYNCRESULT *)result;
6306 data->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
6307
6308 hr = IMFByteStreamHandler_BeginCreateObject(handler, stream, url, flags, props, NULL,
6309 (IMFAsyncCallback *)&resolver->stream_callback, (IUnknown *)result);
6310 if (FAILED(hr))
6311 {
6312 IRtwqAsyncResult_Release(result);
6313 return hr;
6314 }
6315
6316 WaitForSingleObject(data->hEvent, INFINITE);
6317
6318 hr = resolver_end_create_object(resolver, OBJECT_FROM_BYTESTREAM, result, obj_type, object);
6319 IRtwqAsyncResult_Release(result);
6320
6321 return hr;
6322 }
6323
6324 static HRESULT WINAPI source_resolver_BeginCreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
6325 DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
6326 {
6327 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6328 IMFSchemeHandler *handler;
6329 IUnknown *inner_cookie = NULL;
6330 IRtwqAsyncResult *result;
6331 HRESULT hr;
6332
6333 TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
6334
6335 if (FAILED(hr = resolver_get_scheme_handler(url, flags, &handler)))
6336 return hr;
6337
6338 if (cancel_cookie)
6339 *cancel_cookie = NULL;
6340
6341 hr = RtwqCreateAsyncResult((IUnknown *)handler, (IRtwqAsyncCallback *)callback, state, &result);
6342 IMFSchemeHandler_Release(handler);
6343 if (FAILED(hr))
6344 return hr;
6345
6346 hr = IMFSchemeHandler_BeginCreateObject(handler, url, flags, props, cancel_cookie ? &inner_cookie : NULL,
6347 (IMFAsyncCallback *)&resolver->url_callback, (IUnknown *)result);
6348
6349 if (SUCCEEDED(hr) && inner_cookie)
6350 resolver_create_cancel_object((IUnknown *)handler, OBJECT_FROM_URL, inner_cookie, cancel_cookie);
6351
6352 IRtwqAsyncResult_Release(result);
6353
6354 return hr;
6355 }
6356
6357 static HRESULT WINAPI source_resolver_EndCreateObjectFromURL(IMFSourceResolver *iface, IMFAsyncResult *result,
6358 MF_OBJECT_TYPE *obj_type, IUnknown **object)
6359 {
6360 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6361
6362 TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
6363
6364 return resolver_end_create_object(resolver, OBJECT_FROM_URL, (IRtwqAsyncResult *)result, obj_type, object);
6365 }
6366
6367 static HRESULT WINAPI source_resolver_BeginCreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
6368 const WCHAR *url, DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback,
6369 IUnknown *state)
6370 {
6371 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6372 IMFByteStreamHandler *handler;
6373 IUnknown *inner_cookie = NULL;
6374 IRtwqAsyncResult *result;
6375 HRESULT hr;
6376
6377 TRACE("%p, %p, %s, %#x, %p, %p, %p, %p.\n", iface, stream, debugstr_w(url), flags, props, cancel_cookie,
6378 callback, state);
6379
6380 if (FAILED(hr = resolver_get_bytestream_handler(stream, url, flags, &handler)))
6381 return hr;
6382
6383 if (cancel_cookie)
6384 *cancel_cookie = NULL;
6385
6386 hr = RtwqCreateAsyncResult((IUnknown *)handler, (IRtwqAsyncCallback *)callback, state, &result);
6387 IMFByteStreamHandler_Release(handler);
6388 if (FAILED(hr))
6389 return hr;
6390
6391 hr = IMFByteStreamHandler_BeginCreateObject(handler, stream, url, flags, props,
6392 cancel_cookie ? &inner_cookie : NULL, (IMFAsyncCallback *)&resolver->stream_callback, (IUnknown *)result);
6393
6394 /* Cancel object wraps underlying handler cancel cookie with context necessary to call CancelObjectCreate(). */
6395 if (SUCCEEDED(hr) && inner_cookie)
6396 resolver_create_cancel_object((IUnknown *)handler, OBJECT_FROM_BYTESTREAM, inner_cookie, cancel_cookie);
6397
6398 IRtwqAsyncResult_Release(result);
6399
6400 return hr;
6401 }
6402
6403 static HRESULT WINAPI source_resolver_EndCreateObjectFromByteStream(IMFSourceResolver *iface, IMFAsyncResult *result,
6404 MF_OBJECT_TYPE *obj_type, IUnknown **object)
6405 {
6406 struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6407
6408 TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
6409
6410 return resolver_end_create_object(resolver, OBJECT_FROM_BYTESTREAM, (IRtwqAsyncResult *)result, obj_type, object);
6411 }
6412
6413 static HRESULT WINAPI source_resolver_CancelObjectCreation(IMFSourceResolver *iface, IUnknown *cancel_cookie)
6414 {
6415 struct resolver_cancel_object *object;
6416 HRESULT hr;
6417
6418 TRACE("%p, %p.\n", iface, cancel_cookie);
6419
6420 if (!(object = unsafe_impl_cancel_obj_from_IUnknown(cancel_cookie)))
6421 return E_UNEXPECTED;
6422
6423 switch (object->origin)
6424 {
6425 case OBJECT_FROM_BYTESTREAM:
6426 hr = IMFByteStreamHandler_CancelObjectCreation(object->u.stream_handler, object->cancel_cookie);
6427 break;
6428 case OBJECT_FROM_URL:
6429 hr = IMFSchemeHandler_CancelObjectCreation(object->u.scheme_handler, object->cancel_cookie);
6430 break;
6431 default:
6432 hr = E_UNEXPECTED;
6433 }
6434
6435 return hr;
6436 }
6437
6438 static const IMFSourceResolverVtbl mfsourceresolvervtbl =
6439 {
6440 source_resolver_QueryInterface,
6441 source_resolver_AddRef,
6442 source_resolver_Release,
6443 source_resolver_CreateObjectFromURL,
6444 source_resolver_CreateObjectFromByteStream,
6445 source_resolver_BeginCreateObjectFromURL,
6446 source_resolver_EndCreateObjectFromURL,
6447 source_resolver_BeginCreateObjectFromByteStream,
6448 source_resolver_EndCreateObjectFromByteStream,
6449 source_resolver_CancelObjectCreation,
6450 };
6451
6452 /***********************************************************************
6453 * MFCreateSourceResolver (mfplat.@)
6454 */
6455 HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **resolver)
6456 {
6457 struct source_resolver *object;
6458
6459 TRACE("%p\n", resolver);
6460
6461 if (!resolver)
6462 return E_POINTER;
6463
6464 if (!(object = calloc(1, sizeof(*object))))
6465 return E_OUTOFMEMORY;
6466
6467 object->IMFSourceResolver_iface.lpVtbl = &mfsourceresolvervtbl;
6468 object->stream_callback.lpVtbl = &source_resolver_callback_stream_vtbl;
6469 object->url_callback.lpVtbl = &source_resolver_callback_url_vtbl;
6470 object->refcount = 1;
6471 list_init(&object->pending);
6472 InitializeCriticalSection(&object->cs);
6473
6474 *resolver = &object->IMFSourceResolver_iface;
6475
6476 return S_OK;
6477 }
6478
6479 struct media_event
6480 {
6481 struct attributes attributes;
6482 IMFMediaEvent IMFMediaEvent_iface;
6483
6484 MediaEventType type;
6485 GUID extended_type;
6486 HRESULT status;
6487 PROPVARIANT value;
6488 };
6489
6490 static inline struct media_event *impl_from_IMFMediaEvent(IMFMediaEvent *iface)
6491 {
6492 return CONTAINING_RECORD(iface, struct media_event, IMFMediaEvent_iface);
6493 }
6494
6495 static HRESULT WINAPI mfmediaevent_QueryInterface(IMFMediaEvent *iface, REFIID riid, void **out)
6496 {
6497 struct media_event *event = impl_from_IMFMediaEvent(iface);
6498
6499 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
6500
6501 if(IsEqualGUID(riid, &IID_IUnknown) ||
6502 IsEqualGUID(riid, &IID_IMFAttributes) ||
6503 IsEqualGUID(riid, &IID_IMFMediaEvent))
6504 {
6505 *out = &event->IMFMediaEvent_iface;
6506 }
6507 else
6508 {
6509 FIXME("%s, %p.\n", debugstr_guid(riid), out);
6510 *out = NULL;
6511 return E_NOINTERFACE;
6512 }
6513
6514 IUnknown_AddRef((IUnknown*)*out);
6515 return S_OK;
6516 }
6517
6518 static ULONG WINAPI mfmediaevent_AddRef(IMFMediaEvent *iface)
6519 {
6520 struct media_event *event = impl_from_IMFMediaEvent(iface);
6521 ULONG refcount = InterlockedIncrement(&event->attributes.ref);
6522
6523 TRACE("%p, refcount %u.\n", iface, refcount);
6524
6525 return refcount;
6526 }
6527
6528 static ULONG WINAPI mfmediaevent_Release(IMFMediaEvent *iface)
6529 {
6530 struct media_event *event = impl_from_IMFMediaEvent(iface);
6531 ULONG refcount = InterlockedDecrement(&event->attributes.ref);
6532
6533 TRACE("%p, refcount %u.\n", iface, refcount);
6534
6535 if (!refcount)
6536 {
6537 clear_attributes_object(&event->attributes);
6538 PropVariantClear(&event->value);
6539 free(event);
6540 }
6541
6542 return refcount;
6543 }
6544
6545 static HRESULT WINAPI mfmediaevent_GetItem(IMFMediaEvent *iface, REFGUID key, PROPVARIANT *value)
6546 {
6547 struct media_event *event = impl_from_IMFMediaEvent(iface);
6548
6549 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6550
6551 return attributes_GetItem(&event->attributes, key, value);
6552 }
6553
6554 static HRESULT WINAPI mfmediaevent_GetItemType(IMFMediaEvent *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
6555 {
6556 struct media_event *event = impl_from_IMFMediaEvent(iface);
6557
6558 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
6559
6560 return attributes_GetItemType(&event->attributes, key, type);
6561 }
6562
6563 static HRESULT WINAPI mfmediaevent_CompareItem(IMFMediaEvent *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
6564 {
6565 struct media_event *event = impl_from_IMFMediaEvent(iface);
6566
6567 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
6568
6569 return attributes_CompareItem(&event->attributes, key, value, result);
6570 }
6571
6572 static HRESULT WINAPI mfmediaevent_Compare(IMFMediaEvent *iface, IMFAttributes *attrs, MF_ATTRIBUTES_MATCH_TYPE type,
6573 BOOL *result)
6574 {
6575 struct media_event *event = impl_from_IMFMediaEvent(iface);
6576
6577 TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
6578
6579 return attributes_Compare(&event->attributes, attrs, type, result);
6580 }
6581
6582 static HRESULT WINAPI mfmediaevent_GetUINT32(IMFMediaEvent *iface, REFGUID key, UINT32 *value)
6583 {
6584 struct media_event *event = impl_from_IMFMediaEvent(iface);
6585
6586 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6587
6588 return attributes_GetUINT32(&event->attributes, key, value);
6589 }
6590
6591 static HRESULT WINAPI mfmediaevent_GetUINT64(IMFMediaEvent *iface, REFGUID key, UINT64 *value)
6592 {
6593 struct media_event *event = impl_from_IMFMediaEvent(iface);
6594
6595 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6596
6597 return attributes_GetUINT64(&event->attributes, key, value);
6598 }
6599
6600 static HRESULT WINAPI mfmediaevent_GetDouble(IMFMediaEvent *iface, REFGUID key, double *value)
6601 {
6602 struct media_event *event = impl_from_IMFMediaEvent(iface);
6603
6604 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6605
6606 return attributes_GetDouble(&event->attributes, key, value);
6607 }
6608
6609 static HRESULT WINAPI mfmediaevent_GetGUID(IMFMediaEvent *iface, REFGUID key, GUID *value)
6610 {
6611 struct media_event *event = impl_from_IMFMediaEvent(iface);
6612
6613 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6614
6615 return attributes_GetGUID(&event->attributes, key, value);
6616 }
6617
6618 static HRESULT WINAPI mfmediaevent_GetStringLength(IMFMediaEvent *iface, REFGUID key, UINT32 *length)
6619 {
6620 struct media_event *event = impl_from_IMFMediaEvent(iface);
6621
6622 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
6623
6624 return attributes_GetStringLength(&event->attributes, key, length);
6625 }
6626
6627 static HRESULT WINAPI mfmediaevent_GetString(IMFMediaEvent *iface, REFGUID key, WCHAR *value,
6628 UINT32 size, UINT32 *length)
6629 {
6630 struct media_event *event = impl_from_IMFMediaEvent(iface);
6631
6632 TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
6633
6634 return attributes_GetString(&event->attributes, key, value, size, length);
6635 }
6636
6637 static HRESULT WINAPI mfmediaevent_GetAllocatedString(IMFMediaEvent *iface, REFGUID key,
6638 WCHAR **value, UINT32 *length)
6639 {
6640 struct media_event *event = impl_from_IMFMediaEvent(iface);
6641
6642 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
6643
6644 return attributes_GetAllocatedString(&event->attributes, key, value, length);
6645 }
6646
6647 static HRESULT WINAPI mfmediaevent_GetBlobSize(IMFMediaEvent *iface, REFGUID key, UINT32 *size)
6648 {
6649 struct media_event *event = impl_from_IMFMediaEvent(iface);
6650
6651 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
6652
6653 return attributes_GetBlobSize(&event->attributes, key, size);
6654 }
6655
6656 static HRESULT WINAPI mfmediaevent_GetBlob(IMFMediaEvent *iface, REFGUID key, UINT8 *buf,
6657 UINT32 bufsize, UINT32 *blobsize)
6658 {
6659 struct media_event *event = impl_from_IMFMediaEvent(iface);
6660
6661 TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
6662
6663 return attributes_GetBlob(&event->attributes, key, buf, bufsize, blobsize);
6664 }
6665
6666 static HRESULT WINAPI mfmediaevent_GetAllocatedBlob(IMFMediaEvent *iface, REFGUID key, UINT8 **buf, UINT32 *size)
6667 {
6668 struct media_event *event = impl_from_IMFMediaEvent(iface);
6669
6670 TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
6671
6672 return attributes_GetAllocatedBlob(&event->attributes, key, buf, size);
6673 }
6674
6675 static HRESULT WINAPI mfmediaevent_GetUnknown(IMFMediaEvent *iface, REFGUID key, REFIID riid, void **out)
6676 {
6677 struct media_event *event = impl_from_IMFMediaEvent(iface);
6678
6679 TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
6680
6681 return attributes_GetUnknown(&event->attributes, key, riid, out);
6682 }
6683
6684 static HRESULT WINAPI mfmediaevent_SetItem(IMFMediaEvent *iface, REFGUID key, REFPROPVARIANT value)
6685 {
6686 struct media_event *event = impl_from_IMFMediaEvent(iface);
6687
6688 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
6689
6690 return attributes_SetItem(&event->attributes, key, value);
6691 }
6692
6693 static HRESULT WINAPI mfmediaevent_DeleteItem(IMFMediaEvent *iface, REFGUID key)
6694 {
6695 struct media_event *event = impl_from_IMFMediaEvent(iface);
6696
6697 TRACE("%p, %s.\n", iface, debugstr_attr(key));
6698
6699 return attributes_DeleteItem(&event->attributes, key);
6700 }
6701
6702 static HRESULT WINAPI mfmediaevent_DeleteAllItems(IMFMediaEvent *iface)
6703 {
6704 struct media_event *event = impl_from_IMFMediaEvent(iface);
6705
6706 TRACE("%p.\n", iface);
6707
6708 return attributes_DeleteAllItems(&event->attributes);
6709 }
6710
6711 static HRESULT WINAPI mfmediaevent_SetUINT32(IMFMediaEvent *iface, REFGUID key, UINT32 value)
6712 {
6713 struct media_event *event = impl_from_IMFMediaEvent(iface);
6714
6715 TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
6716
6717 return attributes_SetUINT32(&event->attributes, key, value);
6718 }
6719
6720 static HRESULT WINAPI mfmediaevent_SetUINT64(IMFMediaEvent *iface, REFGUID key, UINT64 value)
6721 {
6722 struct media_event *event = impl_from_IMFMediaEvent(iface);
6723
6724 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
6725
6726 return attributes_SetUINT64(&event->attributes, key, value);
6727 }
6728
6729 static HRESULT WINAPI mfmediaevent_SetDouble(IMFMediaEvent *iface, REFGUID key, double value)
6730 {
6731 struct media_event *event = impl_from_IMFMediaEvent(iface);
6732
6733 TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
6734
6735 return attributes_SetDouble(&event->attributes, key, value);
6736 }
6737
6738 static HRESULT WINAPI mfmediaevent_SetGUID(IMFMediaEvent *iface, REFGUID key, REFGUID value)
6739 {
6740 struct media_event *event = impl_from_IMFMediaEvent(iface);
6741
6742 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
6743
6744 return attributes_SetGUID(&event->attributes, key, value);
6745 }
6746
6747 static HRESULT WINAPI mfmediaevent_SetString(IMFMediaEvent *iface, REFGUID key, const WCHAR *value)
6748 {
6749 struct media_event *event = impl_from_IMFMediaEvent(iface);
6750
6751 TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
6752
6753 return attributes_SetString(&event->attributes, key, value);
6754 }
6755
6756 static HRESULT WINAPI mfmediaevent_SetBlob(IMFMediaEvent *iface, REFGUID key, const UINT8 *buf, UINT32 size)
6757 {
6758 struct media_event *event = impl_from_IMFMediaEvent(iface);
6759
6760 TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
6761
6762 return attributes_SetBlob(&event->attributes, key, buf, size);
6763 }
6764
6765 static HRESULT WINAPI mfmediaevent_SetUnknown(IMFMediaEvent *iface, REFGUID key, IUnknown *unknown)
6766 {
6767 struct media_event *event = impl_from_IMFMediaEvent(iface);
6768
6769 TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
6770
6771 return attributes_SetUnknown(&event->attributes, key, unknown);
6772 }
6773
6774 static HRESULT WINAPI mfmediaevent_LockStore(IMFMediaEvent *iface)
6775 {
6776 struct media_event *event = impl_from_IMFMediaEvent(iface);
6777
6778 TRACE("%p.\n", iface);
6779
6780 return attributes_LockStore(&event->attributes);
6781 }
6782
6783 static HRESULT WINAPI mfmediaevent_UnlockStore(IMFMediaEvent *iface)
6784 {
6785 struct media_event *event = impl_from_IMFMediaEvent(iface);
6786
6787 TRACE("%p.\n", iface);
6788
6789 return attributes_UnlockStore(&event->attributes);
6790 }
6791
6792 static HRESULT WINAPI mfmediaevent_GetCount(IMFMediaEvent *iface, UINT32 *count)
6793 {
6794 struct media_event *event = impl_from_IMFMediaEvent(iface);
6795
6796 TRACE("%p, %p.\n", iface, count);
6797
6798 return attributes_GetCount(&event->attributes, count);
6799 }
6800
6801 static HRESULT WINAPI mfmediaevent_GetItemByIndex(IMFMediaEvent *iface, UINT32 index, GUID *key, PROPVARIANT *value)
6802 {
6803 struct media_event *event = impl_from_IMFMediaEvent(iface);
6804
6805 TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
6806
6807 return attributes_GetItemByIndex(&event->attributes, index, key, value);
6808 }
6809
6810 static HRESULT WINAPI mfmediaevent_CopyAllItems(IMFMediaEvent *iface, IMFAttributes *dest)
6811 {
6812 struct media_event *event = impl_from_IMFMediaEvent(iface);
6813
6814 TRACE("%p, %p.\n", iface, dest);
6815
6816 return attributes_CopyAllItems(&event->attributes, dest);
6817 }
6818
6819 static HRESULT WINAPI mfmediaevent_GetType(IMFMediaEvent *iface, MediaEventType *type)
6820 {
6821 struct media_event *event = impl_from_IMFMediaEvent(iface);
6822
6823 TRACE("%p, %p.\n", iface, type);
6824
6825 *type = event->type;
6826
6827 return S_OK;
6828 }
6829
6830 static HRESULT WINAPI mfmediaevent_GetExtendedType(IMFMediaEvent *iface, GUID *extended_type)
6831 {
6832 struct media_event *event = impl_from_IMFMediaEvent(iface);
6833
6834 TRACE("%p, %p.\n", iface, extended_type);
6835
6836 *extended_type = event->extended_type;
6837
6838 return S_OK;
6839 }
6840
6841 static HRESULT WINAPI mfmediaevent_GetStatus(IMFMediaEvent *iface, HRESULT *status)
6842 {
6843 struct media_event *event = impl_from_IMFMediaEvent(iface);
6844
6845 TRACE("%p, %p.\n", iface, status);
6846
6847 *status = event->status;
6848
6849 return S_OK;
6850 }
6851
6852 static HRESULT WINAPI mfmediaevent_GetValue(IMFMediaEvent *iface, PROPVARIANT *value)
6853 {
6854 struct media_event *event = impl_from_IMFMediaEvent(iface);
6855
6856 TRACE("%p, %p.\n", iface, value);
6857
6858 PropVariantCopy(value, &event->value);
6859
6860 return S_OK;
6861 }
6862
6863 static const IMFMediaEventVtbl mfmediaevent_vtbl =
6864 {
6865 mfmediaevent_QueryInterface,
6866 mfmediaevent_AddRef,
6867 mfmediaevent_Release,
6868 mfmediaevent_GetItem,
6869 mfmediaevent_GetItemType,
6870 mfmediaevent_CompareItem,
6871 mfmediaevent_Compare,
6872 mfmediaevent_GetUINT32,
6873 mfmediaevent_GetUINT64,
6874 mfmediaevent_GetDouble,
6875 mfmediaevent_GetGUID,
6876 mfmediaevent_GetStringLength,
6877 mfmediaevent_GetString,
6878 mfmediaevent_GetAllocatedString,
6879 mfmediaevent_GetBlobSize,
6880 mfmediaevent_GetBlob,
6881 mfmediaevent_GetAllocatedBlob,
6882 mfmediaevent_GetUnknown,
6883 mfmediaevent_SetItem,
6884 mfmediaevent_DeleteItem,
6885 mfmediaevent_DeleteAllItems,
6886 mfmediaevent_SetUINT32,
6887 mfmediaevent_SetUINT64,
6888 mfmediaevent_SetDouble,
6889 mfmediaevent_SetGUID,
6890 mfmediaevent_SetString,
6891 mfmediaevent_SetBlob,
6892 mfmediaevent_SetUnknown,
6893 mfmediaevent_LockStore,
6894 mfmediaevent_UnlockStore,
6895 mfmediaevent_GetCount,
6896 mfmediaevent_GetItemByIndex,
6897 mfmediaevent_CopyAllItems,
6898 mfmediaevent_GetType,
6899 mfmediaevent_GetExtendedType,
6900 mfmediaevent_GetStatus,
6901 mfmediaevent_GetValue,
6902 };
6903
6904 /***********************************************************************
6905 * MFCreateMediaEvent (mfplat.@)
6906 */
6907 HRESULT WINAPI MFCreateMediaEvent(MediaEventType type, REFGUID extended_type, HRESULT status, const PROPVARIANT *value,
6908 IMFMediaEvent **event)
6909 {
6910 struct media_event *object;
6911 HRESULT hr;
6912
6913 TRACE("%s, %s, %#x, %s, %p.\n", debugstr_eventid(type), debugstr_guid(extended_type), status,
6914 debugstr_propvar(value), event);
6915
6916 object = malloc(sizeof(*object));
6917 if (!object)
6918 return E_OUTOFMEMORY;
6919
6920 if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
6921 {
6922 free(object);
6923 return hr;
6924 }
6925 object->IMFMediaEvent_iface.lpVtbl = &mfmediaevent_vtbl;
6926
6927 object->type = type;
6928 object->extended_type = *extended_type;
6929 object->status = status;
6930
6931 PropVariantInit(&object->value);
6932 if (value)
6933 PropVariantCopy(&object->value, value);
6934
6935 *event = &object->IMFMediaEvent_iface;
6936
6937 TRACE("Created event %p.\n", *event);
6938
6939 return S_OK;
6940 }
6941
6942 struct event_queue
6943 {
6944 IMFMediaEventQueue IMFMediaEventQueue_iface;
6945 LONG refcount;
6946
6947 CRITICAL_SECTION cs;
6948 CONDITION_VARIABLE update_event;
6949 struct list events;
6950 BOOL is_shut_down;
6951 BOOL notified;
6952 IRtwqAsyncResult *subscriber;
6953 };
6954
6955 struct queued_event
6956 {
6957 struct list entry;
6958 IMFMediaEvent *event;
6959 };
6960
6961 static inline struct event_queue *impl_from_IMFMediaEventQueue(IMFMediaEventQueue *iface)
6962 {
6963 return CONTAINING_RECORD(iface, struct event_queue, IMFMediaEventQueue_iface);
6964 }
6965
6966 static IMFMediaEvent *queue_pop_event(struct event_queue *queue)
6967 {
6968 struct list *head = list_head(&queue->events);
6969 struct queued_event *queued_event;
6970 IMFMediaEvent *event;
6971
6972 if (!head)
6973 return NULL;
6974
6975 queued_event = LIST_ENTRY(head, struct queued_event, entry);
6976 event = queued_event->event;
6977 list_remove(&queued_event->entry);
6978 free(queued_event);
6979 return event;
6980 }
6981
6982 static void event_queue_clear_subscriber(struct event_queue *queue)
6983 {
6984 if (queue->subscriber)
6985 IRtwqAsyncResult_Release(queue->subscriber);
6986 queue->subscriber = NULL;
6987 }
6988
6989 static void event_queue_cleanup(struct event_queue *queue)
6990 {
6991 IMFMediaEvent *event;
6992
6993 while ((event = queue_pop_event(queue)))
6994 IMFMediaEvent_Release(event);
6995 event_queue_clear_subscriber(queue);
6996 }
6997
6998 static HRESULT WINAPI eventqueue_QueryInterface(IMFMediaEventQueue *iface, REFIID riid, void **out)
6999 {
7000 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7001
7002 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
7003
7004 if (IsEqualIID(riid, &IID_IMFMediaEventQueue) ||
7005 IsEqualIID(riid, &IID_IUnknown))
7006 {
7007 *out = &queue->IMFMediaEventQueue_iface;
7008 IMFMediaEventQueue_AddRef(iface);
7009 return S_OK;
7010 }
7011
7012 WARN("Unsupported %s.\n", debugstr_guid(riid));
7013 *out = NULL;
7014 return E_NOINTERFACE;
7015 }
7016
7017 static ULONG WINAPI eventqueue_AddRef(IMFMediaEventQueue *iface)
7018 {
7019 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7020 ULONG refcount = InterlockedIncrement(&queue->refcount);
7021
7022 TRACE("%p, refcount %u.\n", iface, refcount);
7023
7024 return refcount;
7025 }
7026
7027 static ULONG WINAPI eventqueue_Release(IMFMediaEventQueue *iface)
7028 {
7029 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7030 ULONG refcount = InterlockedDecrement(&queue->refcount);
7031
7032 TRACE("%p, refcount %u.\n", queue, refcount);
7033
7034 if (!refcount)
7035 {
7036 event_queue_cleanup(queue);
7037 DeleteCriticalSection(&queue->cs);
7038 free(queue);
7039 }
7040
7041 return refcount;
7042 }
7043
7044 static HRESULT WINAPI eventqueue_GetEvent(IMFMediaEventQueue *iface, DWORD flags, IMFMediaEvent **event)
7045 {
7046 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7047 HRESULT hr = S_OK;
7048
7049 TRACE("%p, %p.\n", iface, event);
7050
7051 EnterCriticalSection(&queue->cs);
7052
7053 if (queue->is_shut_down)
7054 hr = MF_E_SHUTDOWN;
7055 else if (queue->subscriber)
7056 hr = MF_E_MULTIPLE_SUBSCRIBERS;
7057 else
7058 {
7059 if (flags & MF_EVENT_FLAG_NO_WAIT)
7060 {
7061 if (!(*event = queue_pop_event(queue)))
7062 hr = MF_E_NO_EVENTS_AVAILABLE;
7063 }
7064 else
7065 {
7066 while (list_empty(&queue->events) && !queue->is_shut_down)
7067 {
7068 SleepConditionVariableCS(&queue->update_event, &queue->cs, INFINITE);
7069 }
7070 *event = queue_pop_event(queue);
7071 if (queue->is_shut_down)
7072 hr = MF_E_SHUTDOWN;
7073 }
7074 }
7075
7076 LeaveCriticalSection(&queue->cs);
7077
7078 return hr;
7079 }
7080
7081 static void queue_notify_subscriber(struct event_queue *queue)
7082 {
7083 if (list_empty(&queue->events) || !queue->subscriber || queue->notified)
7084 return;
7085
7086 queue->notified = TRUE;
7087 RtwqPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, 0, queue->subscriber);
7088 }
7089
7090 static HRESULT WINAPI eventqueue_BeginGetEvent(IMFMediaEventQueue *iface, IMFAsyncCallback *callback, IUnknown *state)
7091 {
7092 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7093 RTWQASYNCRESULT *result_data;
7094 HRESULT hr;
7095
7096 TRACE("%p, %p, %p.\n", iface, callback, state);
7097
7098 if (!callback)
7099 return E_INVALIDARG;
7100
7101 EnterCriticalSection(&queue->cs);
7102
7103 if (queue->is_shut_down)
7104 hr = MF_E_SHUTDOWN;
7105 else if ((result_data = (RTWQASYNCRESULT *)queue->subscriber))
7106 {
7107 if (result_data->pCallback == (IRtwqAsyncCallback *)callback)
7108 hr = IRtwqAsyncResult_GetStateNoAddRef(queue->subscriber) == state ?
7109 MF_S_MULTIPLE_BEGIN : MF_E_MULTIPLE_BEGIN;
7110 else
7111 hr = MF_E_MULTIPLE_SUBSCRIBERS;
7112 }
7113 else
7114 {
7115 hr = RtwqCreateAsyncResult(NULL, (IRtwqAsyncCallback *)callback, state, &queue->subscriber);
7116 if (SUCCEEDED(hr))
7117 queue_notify_subscriber(queue);
7118 }
7119
7120 LeaveCriticalSection(&queue->cs);
7121
7122 return hr;
7123 }
7124
7125 static HRESULT WINAPI eventqueue_EndGetEvent(IMFMediaEventQueue *iface, IMFAsyncResult *result, IMFMediaEvent **event)
7126 {
7127 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7128 HRESULT hr = E_FAIL;
7129
7130 TRACE("%p, %p, %p.\n", iface, result, event);
7131
7132 EnterCriticalSection(&queue->cs);
7133
7134 if (queue->is_shut_down)
7135 hr = MF_E_SHUTDOWN;
7136 else if (queue->subscriber == (IRtwqAsyncResult *)result)
7137 {
7138 *event = queue_pop_event(queue);
7139 event_queue_clear_subscriber(queue);
7140 queue->notified = FALSE;
7141 hr = *event ? S_OK : E_FAIL;
7142 }
7143
7144 LeaveCriticalSection(&queue->cs);
7145
7146 return hr;
7147 }
7148
7149 static HRESULT eventqueue_queue_event(struct event_queue *queue, IMFMediaEvent *event)
7150 {
7151 struct queued_event *queued_event;
7152 HRESULT hr = S_OK;
7153
7154 queued_event = malloc(sizeof(*queued_event));
7155 if (!queued_event)
7156 return E_OUTOFMEMORY;
7157
7158 queued_event->event = event;
7159
7160 EnterCriticalSection(&queue->cs);
7161
7162 if (queue->is_shut_down)
7163 hr = MF_E_SHUTDOWN;
7164 else
7165 {
7166 IMFMediaEvent_AddRef(queued_event->event);
7167 list_add_tail(&queue->events, &queued_event->entry);
7168 queue_notify_subscriber(queue);
7169 }
7170
7171 LeaveCriticalSection(&queue->cs);
7172
7173 if (FAILED(hr))
7174 free(queued_event);
7175
7176 WakeAllConditionVariable(&queue->update_event);
7177
7178 return hr;
7179 }
7180
7181 static HRESULT WINAPI eventqueue_QueueEvent(IMFMediaEventQueue *iface, IMFMediaEvent *event)
7182 {
7183 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7184
7185 TRACE("%p, %p.\n", iface, event);
7186
7187 return eventqueue_queue_event(queue, event);
7188 }
7189
7190 static HRESULT WINAPI eventqueue_QueueEventParamVar(IMFMediaEventQueue *iface, MediaEventType event_type,
7191 REFGUID extended_type, HRESULT status, const PROPVARIANT *value)
7192 {
7193 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7194 IMFMediaEvent *event;
7195 HRESULT hr;
7196
7197 TRACE("%p, %s, %s, %#x, %s\n", iface, debugstr_eventid(event_type), debugstr_guid(extended_type), status,
7198 debugstr_propvar(value));
7199
7200 if (FAILED(hr = MFCreateMediaEvent(event_type, extended_type, status, value, &event)))
7201 return hr;
7202
7203 hr = eventqueue_queue_event(queue, event);
7204 IMFMediaEvent_Release(event);
7205 return hr;
7206 }
7207
7208 static HRESULT WINAPI eventqueue_QueueEventParamUnk(IMFMediaEventQueue *iface, MediaEventType event_type,
7209 REFGUID extended_type, HRESULT status, IUnknown *unk)
7210 {
7211 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7212 IMFMediaEvent *event;
7213 PROPVARIANT value;
7214 HRESULT hr;
7215
7216 TRACE("%p, %s, %s, %#x, %p.\n", iface, debugstr_eventid(event_type), debugstr_guid(extended_type), status, unk);
7217
7218 value.vt = VT_UNKNOWN;
7219 value.punkVal = unk;
7220
7221 if (FAILED(hr = MFCreateMediaEvent(event_type, extended_type, status, &value, &event)))
7222 return hr;
7223
7224 hr = eventqueue_queue_event(queue, event);
7225 IMFMediaEvent_Release(event);
7226 return hr;
7227 }
7228
7229 static HRESULT WINAPI eventqueue_Shutdown(IMFMediaEventQueue *iface)
7230 {
7231 struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7232
7233 TRACE("%p\n", queue);
7234
7235 EnterCriticalSection(&queue->cs);
7236
7237 if (!queue->is_shut_down)
7238 {
7239 event_queue_cleanup(queue);
7240 queue->is_shut_down = TRUE;
7241 }
7242
7243 LeaveCriticalSection(&queue->cs);
7244
7245 WakeAllConditionVariable(&queue->update_event);
7246
7247 return S_OK;
7248 }
7249
7250 static const IMFMediaEventQueueVtbl eventqueuevtbl =
7251 {
7252 eventqueue_QueryInterface,
7253 eventqueue_AddRef,
7254 eventqueue_Release,
7255 eventqueue_GetEvent,
7256 eventqueue_BeginGetEvent,
7257 eventqueue_EndGetEvent,
7258 eventqueue_QueueEvent,
7259 eventqueue_QueueEventParamVar,
7260 eventqueue_QueueEventParamUnk,
7261 eventqueue_Shutdown
7262 };
7263
7264 /***********************************************************************
7265 * MFCreateEventQueue (mfplat.@)
7266 */
7267 HRESULT WINAPI MFCreateEventQueue(IMFMediaEventQueue **queue)
7268 {
7269 struct event_queue *object;
7270
7271 TRACE("%p\n", queue);
7272
7273 if (!(object = calloc(1, sizeof(*object))))
7274 return E_OUTOFMEMORY;
7275
7276 object->IMFMediaEventQueue_iface.lpVtbl = &eventqueuevtbl;
7277 object->refcount = 1;
7278 list_init(&object->events);
7279 InitializeCriticalSection(&object->cs);
7280 InitializeConditionVariable(&object->update_event);
7281
7282 *queue = &object->IMFMediaEventQueue_iface;
7283
7284 return S_OK;
7285 }
7286
7287 struct collection
7288 {
7289 IMFCollection IMFCollection_iface;
7290 LONG refcount;
7291 IUnknown **elements;
7292 size_t capacity;
7293 size_t count;
7294 };
7295
7296 static struct collection *impl_from_IMFCollection(IMFCollection *iface)
7297 {
7298 return CONTAINING_RECORD(iface, struct collection, IMFCollection_iface);
7299 }
7300
7301 static void collection_clear(struct collection *collection)
7302 {
7303 size_t i;
7304
7305 for (i = 0; i < collection->count; ++i)
7306 {
7307 if (collection->elements[i])
7308 IUnknown_Release(collection->elements[i]);
7309 }
7310
7311 free(collection->elements);
7312 collection->elements = NULL;
7313 collection->count = 0;
7314 collection->capacity = 0;
7315 }
7316
7317 static HRESULT WINAPI collection_QueryInterface(IMFCollection *iface, REFIID riid, void **out)
7318 {
7319 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
7320
7321 if (IsEqualIID(riid, &IID_IMFCollection) ||
7322 IsEqualIID(riid, &IID_IUnknown))
7323 {
7324 *out = iface;
7325 IMFCollection_AddRef(iface);
7326 return S_OK;
7327 }
7328
7329 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
7330 *out = NULL;
7331 return E_NOINTERFACE;
7332 }
7333
7334 static ULONG WINAPI collection_AddRef(IMFCollection *iface)
7335 {
7336 struct collection *collection = impl_from_IMFCollection(iface);
7337 ULONG refcount = InterlockedIncrement(&collection->refcount);
7338
7339 TRACE("%p, %d.\n", collection, refcount);
7340
7341 return refcount;
7342 }
7343
7344 static ULONG WINAPI collection_Release(IMFCollection *iface)
7345 {
7346 struct collection *collection = impl_from_IMFCollection(iface);
7347 ULONG refcount = InterlockedDecrement(&collection->refcount);
7348
7349 TRACE("%p, %d.\n", collection, refcount);
7350
7351 if (!refcount)
7352 {
7353 collection_clear(collection);
7354 free(collection->elements);
7355 free(collection);
7356 }
7357
7358 return refcount;
7359 }
7360
7361 static HRESULT WINAPI collection_GetElementCount(IMFCollection *iface, DWORD *count)
7362 {
7363 struct collection *collection = impl_from_IMFCollection(iface);
7364
7365 TRACE("%p, %p.\n", iface, count);
7366
7367 if (!count)
7368 return E_POINTER;
7369
7370 *count = collection->count;
7371
7372 return S_OK;
7373 }
7374
7375 static HRESULT WINAPI collection_GetElement(IMFCollection *iface, DWORD idx, IUnknown **element)
7376 {
7377 struct collection *collection = impl_from_IMFCollection(iface);
7378
7379 TRACE("%p, %u, %p.\n", iface, idx, element);
7380
7381 if (!element)
7382 return E_POINTER;
7383
7384 if (idx >= collection->count)
7385 return E_INVALIDARG;
7386
7387 *element = collection->elements[idx];
7388 if (*element)
7389 IUnknown_AddRef(*element);
7390
7391 return *element ? S_OK : E_UNEXPECTED;
7392 }
7393
7394 static HRESULT WINAPI collection_AddElement(IMFCollection *iface, IUnknown *element)
7395 {
7396 struct collection *collection = impl_from_IMFCollection(iface);
7397
7398 TRACE("%p, %p.\n", iface, element);
7399
7400 if (!mf_array_reserve((void **)&collection->elements, &collection->capacity, collection->count + 1,
7401 sizeof(*collection->elements)))
7402 return E_OUTOFMEMORY;
7403
7404 collection->elements[collection->count++] = element;
7405 if (element)
7406 IUnknown_AddRef(element);
7407
7408 return S_OK;
7409 }
7410
7411 static HRESULT WINAPI collection_RemoveElement(IMFCollection *iface, DWORD idx, IUnknown **element)
7412 {
7413 struct collection *collection = impl_from_IMFCollection(iface);
7414 size_t count;
7415
7416 TRACE("%p, %u, %p.\n", iface, idx, element);
7417
7418 if (!element)
7419 return E_POINTER;
7420
7421 if (idx >= collection->count)
7422 return E_INVALIDARG;
7423
7424 *element = collection->elements[idx];
7425
7426 count = collection->count - idx - 1;
7427 if (count)
7428 memmove(&collection->elements[idx], &collection->elements[idx + 1], count * sizeof(*collection->elements));
7429 collection->count--;
7430
7431 return S_OK;
7432 }
7433
7434 static HRESULT WINAPI collection_InsertElementAt(IMFCollection *iface, DWORD idx, IUnknown *element)
7435 {
7436 struct collection *collection = impl_from_IMFCollection(iface);
7437 size_t i;
7438
7439 TRACE("%p, %u, %p.\n", iface, idx, element);
7440
7441 if (!mf_array_reserve((void **)&collection->elements, &collection->capacity, idx + 1,
7442 sizeof(*collection->elements)))
7443 return E_OUTOFMEMORY;
7444
7445 if (idx < collection->count)
7446 {
7447 memmove(&collection->elements[idx + 1], &collection->elements[idx],
7448 (collection->count - idx) * sizeof(*collection->elements));
7449 collection->count++;
7450 }
7451 else
7452 {
7453 for (i = collection->count; i < idx; ++i)
7454 collection->elements[i] = NULL;
7455 collection->count = idx + 1;
7456 }
7457
7458 collection->elements[idx] = element;
7459 if (collection->elements[idx])
7460 IUnknown_AddRef(collection->elements[idx]);
7461
7462 return S_OK;
7463 }
7464
7465 static HRESULT WINAPI collection_RemoveAllElements(IMFCollection *iface)
7466 {
7467 struct collection *collection = impl_from_IMFCollection(iface);
7468
7469 TRACE("%p.\n", iface);
7470
7471 collection_clear(collection);
7472
7473 return S_OK;
7474 }
7475
7476 static const IMFCollectionVtbl mfcollectionvtbl =
7477 {
7478 collection_QueryInterface,
7479 collection_AddRef,
7480 collection_Release,
7481 collection_GetElementCount,
7482 collection_GetElement,
7483 collection_AddElement,
7484 collection_RemoveElement,
7485 collection_InsertElementAt,
7486 collection_RemoveAllElements,
7487 };
7488
7489 /***********************************************************************
7490 * MFCreateCollection (mfplat.@)
7491 */
7492 HRESULT WINAPI MFCreateCollection(IMFCollection **collection)
7493 {
7494 struct collection *object;
7495
7496 TRACE("%p\n", collection);
7497
7498 if (!collection)
7499 return E_POINTER;
7500
7501 if (!(object = calloc(1, sizeof(*object))))
7502 return E_OUTOFMEMORY;
7503
7504 object->IMFCollection_iface.lpVtbl = &mfcollectionvtbl;
7505 object->refcount = 1;
7506
7507 *collection = &object->IMFCollection_iface;
7508
7509 return S_OK;
7510 }
7511
7512 /***********************************************************************
7513 * MFHeapAlloc (mfplat.@)
7514 */
7515 void *WINAPI MFHeapAlloc(SIZE_T size, ULONG flags, char *file, int line, EAllocationType type)
7516 {
7517 TRACE("%lu, %#x, %s, %d, %#x.\n", size, flags, debugstr_a(file), line, type);
7518 return HeapAlloc(GetProcessHeap(), flags, size);
7519 }
7520
7521 /***********************************************************************
7522 * MFHeapFree (mfplat.@)
7523 */
7524 void WINAPI MFHeapFree(void *p)
7525 {
7526 TRACE("%p\n", p);
7527 HeapFree(GetProcessHeap(), 0, p);
7528 }
7529
7530 /***********************************************************************
7531 * MFCreateMFByteStreamOnStreamEx (mfplat.@)
7532 */
7533 HRESULT WINAPI MFCreateMFByteStreamOnStreamEx(IUnknown *stream, IMFByteStream **bytestream)
7534 {
7535 FIXME("(%p, %p): stub\n", stream, bytestream);
7536
7537 return E_NOTIMPL;
7538 }
7539
7540 static HRESULT WINAPI system_clock_QueryInterface(IMFClock *iface, REFIID riid, void **obj)
7541 {
7542 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7543
7544 if (IsEqualIID(riid, &IID_IMFClock) ||
7545 IsEqualIID(riid, &IID_IUnknown))
7546 {
7547 *obj = iface;
7548 IMFClock_AddRef(iface);
7549 return S_OK;
7550 }
7551
7552 WARN("Unsupported %s.\n", debugstr_guid(riid));
7553 *obj = NULL;
7554 return E_NOINTERFACE;
7555 }
7556
7557 static ULONG WINAPI system_clock_AddRef(IMFClock *iface)
7558 {
7559 struct system_clock *clock = impl_from_IMFClock(iface);
7560 ULONG refcount = InterlockedIncrement(&clock->refcount);
7561
7562 TRACE("%p, refcount %u.\n", iface, refcount);
7563
7564 return refcount;
7565 }
7566
7567 static ULONG WINAPI system_clock_Release(IMFClock *iface)
7568 {
7569 struct system_clock *clock = impl_from_IMFClock(iface);
7570 ULONG refcount = InterlockedDecrement(&clock->refcount);
7571
7572 TRACE("%p, refcount %u.\n", iface, refcount);
7573
7574 if (!refcount)
7575 free(clock);
7576
7577 return refcount;
7578 }
7579
7580 static HRESULT WINAPI system_clock_GetClockCharacteristics(IMFClock *iface, DWORD *flags)
7581 {
7582 TRACE("%p, %p.\n", iface, flags);
7583
7584 *flags = MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ | MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING |
7585 MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK;
7586
7587 return S_OK;
7588 }
7589
7590 static HRESULT WINAPI system_clock_GetCorrelatedTime(IMFClock *iface, DWORD reserved, LONGLONG *clock_time,
7591 MFTIME *system_time)
7592 {
7593 TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
7594
7595 *clock_time = *system_time = MFGetSystemTime();
7596
7597 return S_OK;
7598 }
7599
7600 static HRESULT WINAPI system_clock_GetContinuityKey(IMFClock *iface, DWORD *key)
7601 {
7602 TRACE("%p, %p.\n", iface, key);
7603
7604 *key = 0;
7605
7606 return S_OK;
7607 }
7608
7609 static HRESULT WINAPI system_clock_GetState(IMFClock *iface, DWORD reserved, MFCLOCK_STATE *state)
7610 {
7611 TRACE("%p, %#x, %p.\n", iface, reserved, state);
7612
7613 *state = MFCLOCK_STATE_RUNNING;
7614
7615 return S_OK;
7616 }
7617
7618 static HRESULT WINAPI system_clock_GetProperties(IMFClock *iface, MFCLOCK_PROPERTIES *props)
7619 {
7620 TRACE("%p, %p.\n", iface, props);
7621
7622 if (!props)
7623 return E_POINTER;
7624
7625 memset(props, 0, sizeof(*props));
7626 props->qwClockFrequency = MFCLOCK_FREQUENCY_HNS;
7627 props->dwClockTolerance = MFCLOCK_TOLERANCE_UNKNOWN;
7628 props->dwClockJitter = 1;
7629
7630 return S_OK;
7631 }
7632
7633 static const IMFClockVtbl system_clock_vtbl =
7634 {
7635 system_clock_QueryInterface,
7636 system_clock_AddRef,
7637 system_clock_Release,
7638 system_clock_GetClockCharacteristics,
7639 system_clock_GetCorrelatedTime,
7640 system_clock_GetContinuityKey,
7641 system_clock_GetState,
7642 system_clock_GetProperties,
7643 };
7644
7645 static HRESULT create_system_clock(IMFClock **clock)
7646 {
7647 struct system_clock *object;
7648
7649 if (!(object = malloc(sizeof(*object))))
7650 return E_OUTOFMEMORY;
7651
7652 object->IMFClock_iface.lpVtbl = &system_clock_vtbl;
7653 object->refcount = 1;
7654
7655 *clock = &object->IMFClock_iface;
7656
7657 return S_OK;
7658 }
7659
7660 static HRESULT WINAPI system_time_source_QueryInterface(IMFPresentationTimeSource *iface, REFIID riid, void **obj)
7661 {
7662 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7663
7664 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7665
7666 if (IsEqualIID(riid, &IID_IMFPresentationTimeSource) ||
7667 IsEqualIID(riid, &IID_IUnknown))
7668 {
7669 *obj = &source->IMFPresentationTimeSource_iface;
7670 }
7671 else if (IsEqualIID(riid, &IID_IMFClockStateSink))
7672 {
7673 *obj = &source->IMFClockStateSink_iface;
7674 }
7675 else
7676 {
7677 WARN("Unsupported %s.\n", debugstr_guid(riid));
7678 *obj = NULL;
7679 return E_NOINTERFACE;
7680 }
7681
7682 IUnknown_AddRef((IUnknown *)*obj);
7683 return S_OK;
7684 }
7685
7686 static ULONG WINAPI system_time_source_AddRef(IMFPresentationTimeSource *iface)
7687 {
7688 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7689 ULONG refcount = InterlockedIncrement(&source->refcount);
7690
7691 TRACE("%p, refcount %u.\n", iface, refcount);
7692
7693 return refcount;
7694 }
7695
7696 static ULONG WINAPI system_time_source_Release(IMFPresentationTimeSource *iface)
7697 {
7698 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7699 ULONG refcount = InterlockedDecrement(&source->refcount);
7700
7701 TRACE("%p, refcount %u.\n", iface, refcount);
7702
7703 if (!refcount)
7704 {
7705 if (source->clock)
7706 IMFClock_Release(source->clock);
7707 DeleteCriticalSection(&source->cs);
7708 free(source);
7709 }
7710
7711 return refcount;
7712 }
7713
7714 static HRESULT WINAPI system_time_source_GetClockCharacteristics(IMFPresentationTimeSource *iface, DWORD *flags)
7715 {
7716 TRACE("%p, %p.\n", iface, flags);
7717
7718 *flags = MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ | MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK;
7719
7720 return S_OK;
7721 }
7722
7723 static HRESULT WINAPI system_time_source_GetCorrelatedTime(IMFPresentationTimeSource *iface, DWORD reserved,
7724 LONGLONG *clock_time, MFTIME *system_time)
7725 {
7726 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7727 HRESULT hr;
7728
7729 TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
7730
7731 EnterCriticalSection(&source->cs);
7732 if (SUCCEEDED(hr = IMFClock_GetCorrelatedTime(source->clock, 0, clock_time, system_time)))
7733 {
7734 if (source->state == MFCLOCK_STATE_RUNNING)
7735 {
7736 system_time_source_apply_rate(source, clock_time);
7737 *clock_time += source->start_offset;
7738 }
7739 else
7740 *clock_time = source->start_offset;
7741 }
7742 LeaveCriticalSection(&source->cs);
7743
7744 return hr;
7745 }
7746
7747 static HRESULT WINAPI system_time_source_GetContinuityKey(IMFPresentationTimeSource *iface, DWORD *key)
7748 {
7749 TRACE("%p, %p.\n", iface, key);
7750
7751 *key = 0;
7752
7753 return S_OK;
7754 }
7755
7756 static HRESULT WINAPI system_time_source_GetState(IMFPresentationTimeSource *iface, DWORD reserved,
7757 MFCLOCK_STATE *state)
7758 {
7759 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7760
7761 TRACE("%p, %#x, %p.\n", iface, reserved, state);
7762
7763 EnterCriticalSection(&source->cs);
7764 *state = source->state;
7765 LeaveCriticalSection(&source->cs);
7766
7767 return S_OK;
7768 }
7769
7770 static HRESULT WINAPI system_time_source_GetProperties(IMFPresentationTimeSource *iface, MFCLOCK_PROPERTIES *props)
7771 {
7772 TRACE("%p, %p.\n", iface, props);
7773
7774 if (!props)
7775 return E_POINTER;
7776
7777 memset(props, 0, sizeof(*props));
7778 props->qwClockFrequency = MFCLOCK_FREQUENCY_HNS;
7779 props->dwClockTolerance = MFCLOCK_TOLERANCE_UNKNOWN;
7780 props->dwClockJitter = 1;
7781
7782 return S_OK;
7783 }
7784
7785 static HRESULT WINAPI system_time_source_GetUnderlyingClock(IMFPresentationTimeSource *iface, IMFClock **clock)
7786 {
7787 struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7788
7789 TRACE("%p, %p.\n", iface, clock);
7790
7791 *clock = source->clock;
7792 IMFClock_AddRef(*clock);
7793
7794 return S_OK;
7795 }
7796
7797 static const IMFPresentationTimeSourceVtbl systemtimesourcevtbl =
7798 {
7799 system_time_source_QueryInterface,
7800 system_time_source_AddRef,
7801 system_time_source_Release,
7802 system_time_source_GetClockCharacteristics,
7803 system_time_source_GetCorrelatedTime,
7804 system_time_source_GetContinuityKey,
7805 system_time_source_GetState,
7806 system_time_source_GetProperties,
7807 system_time_source_GetUnderlyingClock,
7808 };
7809
7810 static HRESULT WINAPI system_time_source_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **out)
7811 {
7812 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7813 return IMFPresentationTimeSource_QueryInterface(&source->IMFPresentationTimeSource_iface, riid, out);
7814 }
7815
7816 static ULONG WINAPI system_time_source_sink_AddRef(IMFClockStateSink *iface)
7817 {
7818 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7819 return IMFPresentationTimeSource_AddRef(&source->IMFPresentationTimeSource_iface);
7820 }
7821
7822 static ULONG WINAPI system_time_source_sink_Release(IMFClockStateSink *iface)
7823 {
7824 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7825 return IMFPresentationTimeSource_Release(&source->IMFPresentationTimeSource_iface);
7826 }
7827
7828 enum clock_command
7829 {
7830 CLOCK_CMD_START = 0,
7831 CLOCK_CMD_STOP,
7832 CLOCK_CMD_PAUSE,
7833 CLOCK_CMD_RESTART,
7834 CLOCK_CMD_MAX,
7835 };
7836
7837 static HRESULT system_time_source_change_state(struct system_time_source *source, enum clock_command command)
7838 {
7839 static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] =
7840 { /* S S* P R */
7841 /* INVALID */ { 1, 0, 1, 0 },
7842 /* RUNNING */ { 1, 1, 1, 0 },
7843 /* STOPPED */ { 1, 1, 0, 0 },
7844 /* PAUSED */ { 1, 1, 0, 1 },
7845 };
7846 static const MFCLOCK_STATE states[CLOCK_CMD_MAX] =
7847 {
7848 /* CLOCK_CMD_START */ MFCLOCK_STATE_RUNNING,
7849 /* CLOCK_CMD_STOP */ MFCLOCK_STATE_STOPPED,
7850 /* CLOCK_CMD_PAUSE */ MFCLOCK_STATE_PAUSED,
7851 /* CLOCK_CMD_RESTART */ MFCLOCK_STATE_RUNNING,
7852 };
7853
7854 /* Special case that go against usual state change vs return value behavior. */
7855 if (source->state == MFCLOCK_STATE_INVALID && command == CLOCK_CMD_STOP)
7856 return S_OK;
7857
7858 if (!state_change_is_allowed[source->state][command])
7859 return MF_E_INVALIDREQUEST;
7860
7861 source->state = states[command];
7862
7863 return S_OK;
7864 }
7865
7866 static HRESULT WINAPI system_time_source_sink_OnClockStart(IMFClockStateSink *iface, MFTIME system_time,
7867 LONGLONG start_offset)
7868 {
7869 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7870 MFCLOCK_STATE state;
7871 HRESULT hr;
7872
7873 TRACE("%p, %s, %s.\n", iface, debugstr_time(system_time), debugstr_time(start_offset));
7874
7875 EnterCriticalSection(&source->cs);
7876 state = source->state;
7877 if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_START)))
7878 {
7879 system_time_source_apply_rate(source, &system_time);
7880 if (start_offset == PRESENTATION_CURRENT_POSITION)
7881 {
7882 switch (state)
7883 {
7884 case MFCLOCK_STATE_RUNNING:
7885 break;
7886 case MFCLOCK_STATE_PAUSED:
7887 source->start_offset -= system_time;
7888 break;
7889 default:
7890 source->start_offset = -system_time;
7891 break;
7892 ;
7893 }
7894 }
7895 else
7896 {
7897 source->start_offset = -system_time + start_offset;
7898 }
7899 }
7900 LeaveCriticalSection(&source->cs);
7901
7902 return hr;
7903 }
7904
7905 static HRESULT WINAPI system_time_source_sink_OnClockStop(IMFClockStateSink *iface, MFTIME system_time)
7906 {
7907 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7908 HRESULT hr;
7909
7910 TRACE("%p, %s.\n", iface, debugstr_time(system_time));
7911
7912 EnterCriticalSection(&source->cs);
7913 if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_STOP)))
7914 source->start_offset = 0;
7915 LeaveCriticalSection(&source->cs);
7916
7917 return hr;
7918 }
7919
7920 static HRESULT WINAPI system_time_source_sink_OnClockPause(IMFClockStateSink *iface, MFTIME system_time)
7921 {
7922 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7923 HRESULT hr;
7924
7925 TRACE("%p, %s.\n", iface, debugstr_time(system_time));
7926
7927 EnterCriticalSection(&source->cs);
7928 if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_PAUSE)))
7929 {
7930 system_time_source_apply_rate(source, &system_time);
7931 source->start_offset += system_time;
7932 }
7933 LeaveCriticalSection(&source->cs);
7934
7935 return hr;
7936 }
7937
7938 static HRESULT WINAPI system_time_source_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME system_time)
7939 {
7940 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7941 HRESULT hr;
7942
7943 TRACE("%p, %s.\n", iface, debugstr_time(system_time));
7944
7945 EnterCriticalSection(&source->cs);
7946 if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_RESTART)))
7947 {
7948 system_time_source_apply_rate(source, &system_time);
7949 source->start_offset -= system_time;
7950 }
7951 LeaveCriticalSection(&source->cs);
7952
7953 return hr;
7954 }
7955
7956 static HRESULT WINAPI system_time_source_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME system_time, float rate)
7957 {
7958 struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7959 double intpart;
7960
7961 TRACE("%p, %s, %f.\n", iface, debugstr_time(system_time), rate);
7962
7963 if (rate == 0.0f)
7964 return MF_E_UNSUPPORTED_RATE;
7965
7966 modf(rate, &intpart);
7967
7968 EnterCriticalSection(&source->cs);
7969 source->rate = rate;
7970 source->i_rate = rate == intpart ? rate : 0;
7971 LeaveCriticalSection(&source->cs);
7972
7973 return S_OK;
7974 }
7975
7976 static const IMFClockStateSinkVtbl systemtimesourcesinkvtbl =
7977 {
7978 system_time_source_sink_QueryInterface,
7979 system_time_source_sink_AddRef,
7980 system_time_source_sink_Release,
7981 system_time_source_sink_OnClockStart,
7982 system_time_source_sink_OnClockStop,
7983 system_time_source_sink_OnClockPause,
7984 system_time_source_sink_OnClockRestart,
7985 system_time_source_sink_OnClockSetRate,
7986 };
7987
7988 /***********************************************************************
7989 * MFCreateSystemTimeSource (mfplat.@)
7990 */
7991 HRESULT WINAPI MFCreateSystemTimeSource(IMFPresentationTimeSource **time_source)
7992 {
7993 struct system_time_source *object;
7994 HRESULT hr;
7995
7996 TRACE("%p.\n", time_source);
7997
7998 object = calloc(1, sizeof(*object));
7999 if (!object)
8000 return E_OUTOFMEMORY;
8001
8002 object->IMFPresentationTimeSource_iface.lpVtbl = &systemtimesourcevtbl;
8003 object->IMFClockStateSink_iface.lpVtbl = &systemtimesourcesinkvtbl;
8004 object->refcount = 1;
8005 object->rate = 1.0f;
8006 object->i_rate = 1;
8007 InitializeCriticalSection(&object->cs);
8008
8009 if (FAILED(hr = create_system_clock(&object->clock)))
8010 {
8011 IMFPresentationTimeSource_Release(&object->IMFPresentationTimeSource_iface);
8012 return hr;
8013 }
8014
8015 *time_source = &object->IMFPresentationTimeSource_iface;
8016
8017 return S_OK;
8018 }
8019
8020 struct async_create_file
8021 {
8022 IRtwqAsyncCallback IRtwqAsyncCallback_iface;
8023 LONG refcount;
8024 MF_FILE_ACCESSMODE access_mode;
8025 MF_FILE_OPENMODE open_mode;
8026 MF_FILE_FLAGS flags;
8027 WCHAR *path;
8028 };
8029
8030 struct async_create_file_result
8031 {
8032 struct list entry;
8033 IRtwqAsyncResult *result;
8034 IMFByteStream *stream;
8035 };
8036
8037 static struct list async_create_file_results = LIST_INIT(async_create_file_results);
8038 static CRITICAL_SECTION async_create_file_cs = { NULL, -1, 0, 0, 0, 0 };
8039
8040 static struct async_create_file *impl_from_create_file_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
8041 {
8042 return CONTAINING_RECORD(iface, struct async_create_file, IRtwqAsyncCallback_iface);
8043 }
8044
8045 static HRESULT WINAPI async_create_file_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
8046 {
8047 if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
8048 IsEqualIID(riid, &IID_IUnknown))
8049 {
8050 *obj = iface;
8051 IRtwqAsyncCallback_AddRef(iface);
8052 return S_OK;
8053 }
8054
8055 *obj = NULL;
8056 return E_NOINTERFACE;
8057 }
8058
8059 static ULONG WINAPI async_create_file_callback_AddRef(IRtwqAsyncCallback *iface)
8060 {
8061 struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8062 ULONG refcount = InterlockedIncrement(&async->refcount);
8063
8064 TRACE("%p, refcount %u.\n", iface, refcount);
8065
8066 return refcount;
8067 }
8068
8069 static ULONG WINAPI async_create_file_callback_Release(IRtwqAsyncCallback *iface)
8070 {
8071 struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8072 ULONG refcount = InterlockedDecrement(&async->refcount);
8073
8074 TRACE("%p, refcount %u.\n", iface, refcount);
8075
8076 if (!refcount)
8077 {
8078 free(async->path);
8079 free(async);
8080 }
8081
8082 return refcount;
8083 }
8084
8085 static HRESULT WINAPI async_create_file_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
8086 {
8087 return E_NOTIMPL;
8088 }
8089
8090 static HRESULT WINAPI async_create_file_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
8091 {
8092 struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8093 IRtwqAsyncResult *caller;
8094 IMFByteStream *stream;
8095 HRESULT hr;
8096
8097 caller = (IRtwqAsyncResult *)IRtwqAsyncResult_GetStateNoAddRef(result);
8098
8099 hr = MFCreateFile(async->access_mode, async->open_mode, async->flags, async->path, &stream);
8100 if (SUCCEEDED(hr))
8101 {
8102 struct async_create_file_result *result_item;
8103
8104 result_item = malloc(sizeof(*result_item));
8105 if (result_item)
8106 {
8107 result_item->result = caller;
8108 IRtwqAsyncResult_AddRef(caller);
8109 result_item->stream = stream;
8110 IMFByteStream_AddRef(stream);
8111
8112 EnterCriticalSection(&async_create_file_cs);
8113 list_add_tail(&async_create_file_results, &result_item->entry);
8114 LeaveCriticalSection(&async_create_file_cs);
8115 }
8116
8117 IMFByteStream_Release(stream);
8118 }
8119 else
8120 IRtwqAsyncResult_SetStatus(caller, hr);
8121
8122 RtwqInvokeCallback(caller);
8123
8124 return S_OK;
8125 }
8126
8127 static const IRtwqAsyncCallbackVtbl async_create_file_callback_vtbl =
8128 {
8129 async_create_file_callback_QueryInterface,
8130 async_create_file_callback_AddRef,
8131 async_create_file_callback_Release,
8132 async_create_file_callback_GetParameters,
8133 async_create_file_callback_Invoke,
8134 };
8135
8136 /***********************************************************************
8137 * MFBeginCreateFile (mfplat.@)
8138 */
8139 HRESULT WINAPI MFBeginCreateFile(MF_FILE_ACCESSMODE access_mode, MF_FILE_OPENMODE open_mode, MF_FILE_FLAGS flags,
8140 const WCHAR *path, IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_cookie)
8141 {
8142 struct async_create_file *async = NULL;
8143 IRtwqAsyncResult *caller, *item = NULL;
8144 HRESULT hr;
8145
8146 TRACE("%#x, %#x, %#x, %s, %p, %p, %p.\n", access_mode, open_mode, flags, debugstr_w(path), callback, state,
8147 cancel_cookie);
8148
8149 if (cancel_cookie)
8150 *cancel_cookie = NULL;
8151
8152 if (FAILED(hr = RtwqCreateAsyncResult(NULL, (IRtwqAsyncCallback *)callback, state, &caller)))
8153 return hr;
8154
8155 if (!(async = malloc(sizeof(*async))))
8156 {
8157 hr = E_OUTOFMEMORY;
8158 goto failed;
8159 }
8160
8161 async->IRtwqAsyncCallback_iface.lpVtbl = &async_create_file_callback_vtbl;
8162 async->refcount = 1;
8163 async->access_mode = access_mode;
8164 async->open_mode = open_mode;
8165 async->flags = flags;
8166 if (!(async->path = wcsdup(path)))
8167 {
8168 hr = E_OUTOFMEMORY;
8169 goto failed;
8170 }
8171
8172 hr = RtwqCreateAsyncResult(NULL, &async->IRtwqAsyncCallback_iface, (IUnknown *)caller, &item);
8173 if (FAILED(hr))
8174 goto failed;
8175
8176 if (cancel_cookie)
8177 {
8178 *cancel_cookie = (IUnknown *)caller;
8179 IUnknown_AddRef(*cancel_cookie);
8180 }
8181
8182 hr = RtwqInvokeCallback(item);
8183
8184 failed:
8185 if (async)
8186 IRtwqAsyncCallback_Release(&async->IRtwqAsyncCallback_iface);
8187 if (item)
8188 IRtwqAsyncResult_Release(item);
8189 if (caller)
8190 IRtwqAsyncResult_Release(caller);
8191
8192 return hr;
8193 }
8194
8195 static HRESULT async_create_file_pull_result(IUnknown *unk, IMFByteStream **stream)
8196 {
8197 struct async_create_file_result *item;
8198 HRESULT hr = MF_E_UNEXPECTED;
8199 IRtwqAsyncResult *result;
8200
8201 *stream = NULL;
8202
8203 if (FAILED(IUnknown_QueryInterface(unk, &IID_IRtwqAsyncResult, (void **)&result)))
8204 return hr;
8205
8206 EnterCriticalSection(&async_create_file_cs);
8207
8208 LIST_FOR_EACH_ENTRY(item, &async_create_file_results, struct async_create_file_result, entry)
8209 {
8210 if (result == item->result)
8211 {
8212 *stream = item->stream;
8213 IRtwqAsyncResult_Release(item->result);
8214 list_remove(&item->entry);
8215 free(item);
8216 break;
8217 }
8218 }
8219
8220 LeaveCriticalSection(&async_create_file_cs);
8221
8222 if (*stream)
8223 hr = IRtwqAsyncResult_GetStatus(result);
8224
8225 IRtwqAsyncResult_Release(result);
8226
8227 return hr;
8228 }
8229
8230 /***********************************************************************
8231 * MFEndCreateFile (mfplat.@)
8232 */
8233 HRESULT WINAPI MFEndCreateFile(IMFAsyncResult *result, IMFByteStream **stream)
8234 {
8235 TRACE("%p, %p.\n", result, stream);
8236
8237 return async_create_file_pull_result((IUnknown *)result, stream);
8238 }
8239
8240 /***********************************************************************
8241 * MFCancelCreateFile (mfplat.@)
8242 */
8243 HRESULT WINAPI MFCancelCreateFile(IUnknown *cancel_cookie)
8244 {
8245 IMFByteStream *stream = NULL;
8246 HRESULT hr;
8247
8248 TRACE("%p.\n", cancel_cookie);
8249
8250 hr = async_create_file_pull_result(cancel_cookie, &stream);
8251
8252 if (stream)
8253 IMFByteStream_Release(stream);
8254
8255 return hr;
8256 }
8257
8258 /***********************************************************************
8259 * MFRegisterLocalSchemeHandler (mfplat.@)
8260 */
8261 HRESULT WINAPI MFRegisterLocalSchemeHandler(const WCHAR *scheme, IMFActivate *activate)
8262 {
8263 struct local_handler *handler;
8264
8265 TRACE("%s, %p.\n", debugstr_w(scheme), activate);
8266
8267 if (!scheme || !activate)
8268 return E_INVALIDARG;
8269
8270 if (!(handler = malloc(sizeof(*handler))))
8271 return E_OUTOFMEMORY;
8272
8273 if (!(handler->u.scheme = wcsdup(scheme)))
8274 {
8275 free(handler);
8276 return E_OUTOFMEMORY;
8277 }
8278 handler->activate = activate;
8279 IMFActivate_AddRef(handler->activate);
8280
8281 EnterCriticalSection(&local_handlers_section);
8282 list_add_head(&local_scheme_handlers, &handler->entry);
8283 LeaveCriticalSection(&local_handlers_section);
8284
8285 return S_OK;
8286 }
8287
8288 /***********************************************************************
8289 * MFRegisterLocalByteStreamHandler (mfplat.@)
8290 */
8291 HRESULT WINAPI MFRegisterLocalByteStreamHandler(const WCHAR *extension, const WCHAR *mime, IMFActivate *activate)
8292 {
8293 struct local_handler *handler;
8294
8295 TRACE("%s, %s, %p.\n", debugstr_w(extension), debugstr_w(mime), activate);
8296
8297 if ((!extension && !mime) || !activate)
8298 return E_INVALIDARG;
8299
8300 if (!(handler = calloc(1, sizeof(*handler))))
8301 return E_OUTOFMEMORY;
8302
8303 if (extension && !(handler->u.bytestream.extension = wcsdup(extension)))
8304 goto failed;
8305 if (mime && !(handler->u.bytestream.mime = wcsdup(mime)))
8306 goto failed;
8307
8308 EnterCriticalSection(&local_handlers_section);
8309 list_add_head(&local_bytestream_handlers, &handler->entry);
8310 LeaveCriticalSection(&local_handlers_section);
8311
8312 return S_OK;
8313
8314 failed:
8315 free(handler->u.bytestream.extension);
8316 free(handler->u.bytestream.mime);
8317 free(handler);
8318
8319 return E_OUTOFMEMORY;
8320 }
8321
8322 struct property_store
8323 {
8324 IPropertyStore IPropertyStore_iface;
8325 LONG refcount;
8326 CRITICAL_SECTION cs;
8327 size_t count, capacity;
8328 struct
8329 {
8330 PROPERTYKEY key;
8331 PROPVARIANT value;
8332 } *values;
8333 };
8334
8335 static struct property_store *impl_from_IPropertyStore(IPropertyStore *iface)
8336 {
8337 return CONTAINING_RECORD(iface, struct property_store, IPropertyStore_iface);
8338 }
8339
8340 static HRESULT WINAPI property_store_QueryInterface(IPropertyStore *iface, REFIID riid, void **obj)
8341 {
8342 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
8343
8344 if (IsEqualIID(riid, &IID_IPropertyStore) || IsEqualIID(riid, &IID_IUnknown))
8345 {
8346 *obj = iface;
8347 IPropertyStore_AddRef(iface);
8348 return S_OK;
8349 }
8350
8351 *obj = NULL;
8352 WARN("Unsupported interface %s.\n", debugstr_guid(riid));
8353 return E_NOINTERFACE;
8354 }
8355
8356 static ULONG WINAPI property_store_AddRef(IPropertyStore *iface)
8357 {
8358 struct property_store *store = impl_from_IPropertyStore(iface);
8359 ULONG refcount = InterlockedIncrement(&store->refcount);
8360
8361 TRACE("%p, refcount %d.\n", iface, refcount);
8362
8363 return refcount;
8364 }
8365
8366 static ULONG WINAPI property_store_Release(IPropertyStore *iface)
8367 {
8368 struct property_store *store = impl_from_IPropertyStore(iface);
8369 ULONG refcount = InterlockedDecrement(&store->refcount);
8370
8371 TRACE("%p, refcount %d.\n", iface, refcount);
8372
8373 if (!refcount)
8374 {
8375 DeleteCriticalSection(&store->cs);
8376 free(store->values);
8377 free(store);
8378 }
8379
8380 return refcount;
8381 }
8382
8383 static HRESULT WINAPI property_store_GetCount(IPropertyStore *iface, DWORD *count)
8384 {
8385 struct property_store *store = impl_from_IPropertyStore(iface);
8386
8387 TRACE("%p, %p.\n", iface, count);
8388
8389 if (!count)
8390 return E_INVALIDARG;
8391
8392 EnterCriticalSection(&store->cs);
8393 *count = store->count;
8394 LeaveCriticalSection(&store->cs);
8395 return S_OK;
8396 }
8397
8398 static HRESULT WINAPI property_store_GetAt(IPropertyStore *iface, DWORD index, PROPERTYKEY *key)
8399 {
8400 struct property_store *store = impl_from_IPropertyStore(iface);
8401
8402 TRACE("%p, %u, %p.\n", iface, index, key);
8403
8404 EnterCriticalSection(&store->cs);
8405
8406 if (index >= store->count)
8407 {
8408 LeaveCriticalSection(&store->cs);
8409 return E_INVALIDARG;
8410 }
8411
8412 *key = store->values[index].key;
8413
8414 LeaveCriticalSection(&store->cs);
8415 return S_OK;
8416 }
8417
8418 static HRESULT WINAPI property_store_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
8419 {
8420 struct property_store *store = impl_from_IPropertyStore(iface);
8421 unsigned int i;
8422
8423 TRACE("%p, %p, %p.\n", iface, key, value);
8424
8425 if (!value)
8426 return E_INVALIDARG;
8427
8428 if (!key)
8429 return S_FALSE;
8430
8431 EnterCriticalSection(&store->cs);
8432
8433 for (i = 0; i < store->count; ++i)
8434 {
8435 if (!memcmp(key, &store->values[i].key, sizeof(PROPERTYKEY)))
8436 {
8437 PropVariantCopy(value, &store->values[i].value);
8438 LeaveCriticalSection(&store->cs);
8439 return S_OK;
8440 }
8441 }
8442
8443 LeaveCriticalSection(&store->cs);
8444 return S_FALSE;
8445 }
8446
8447 static HRESULT WINAPI property_store_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
8448 {
8449 struct property_store *store = impl_from_IPropertyStore(iface);
8450 unsigned int i;
8451
8452 TRACE("%p, %p, %p.\n", iface, key, value);
8453
8454 EnterCriticalSection(&store->cs);
8455
8456 for (i = 0; i < store->count; ++i)
8457 {
8458 if (!memcmp(key, &store->values[i].key, sizeof(PROPERTYKEY)))
8459 {
8460 PropVariantCopy(&store->values[i].value, value);
8461 LeaveCriticalSection(&store->cs);
8462 return S_OK;
8463 }
8464 }
8465
8466 if (!mf_array_reserve((void **)&store->values, &store->capacity, store->count + 1, sizeof(*store->values)))
8467 {
8468 LeaveCriticalSection(&store->cs);
8469 return E_OUTOFMEMORY;
8470 }
8471
8472 store->values[store->count].key = *key;
8473 PropVariantCopy(&store->values[store->count].value, value);
8474 ++store->count;
8475
8476 LeaveCriticalSection(&store->cs);
8477 return S_OK;
8478 }
8479
8480 static HRESULT WINAPI property_store_Commit(IPropertyStore *iface)
8481 {
8482 TRACE("%p.\n", iface);
8483
8484 return E_NOTIMPL;
8485 }
8486
8487 static const IPropertyStoreVtbl property_store_vtbl =
8488 {
8489 property_store_QueryInterface,
8490 property_store_AddRef,
8491 property_store_Release,
8492 property_store_GetCount,
8493 property_store_GetAt,
8494 property_store_GetValue,
8495 property_store_SetValue,
8496 property_store_Commit,
8497 };
8498
8499 /***********************************************************************
8500 * CreatePropertyStore (mfplat.@)
8501 */
8502 HRESULT WINAPI CreatePropertyStore(IPropertyStore **store)
8503 {
8504 struct property_store *object;
8505
8506 TRACE("%p.\n", store);
8507
8508 if (!store)
8509 return E_INVALIDARG;
8510
8511 if (!(object = calloc(1, sizeof(*object))))
8512 return E_OUTOFMEMORY;
8513
8514 object->IPropertyStore_iface.lpVtbl = &property_store_vtbl;
8515 object->refcount = 1;
8516 InitializeCriticalSection(&object->cs);
8517
8518 TRACE("Created store %p.\n", object);
8519 *store = &object->IPropertyStore_iface;
8520
8521 return S_OK;
8522 }
8523
8524 struct shared_dxgi_manager
8525 {
8526 IMFDXGIDeviceManager *manager;
8527 unsigned int token;
8528 unsigned int locks;
8529 };
8530
8531 static struct shared_dxgi_manager shared_dm;
8532 static CRITICAL_SECTION shared_dm_cs = { NULL, -1, 0, 0, 0, 0 };
8533
8534 enum dxgi_device_handle_flags
8535 {
8536 DXGI_DEVICE_HANDLE_FLAG_OPEN = 0x1,
8537 DXGI_DEVICE_HANDLE_FLAG_INVALID = 0x2,
8538 DXGI_DEVICE_HANDLE_FLAG_LOCKED = 0x4,
8539 };
8540
8541 struct dxgi_device_manager
8542 {
8543 IMFDXGIDeviceManager IMFDXGIDeviceManager_iface;
8544 LONG refcount;
8545 UINT token;
8546 IDXGIDevice *device;
8547
8548 unsigned int *handles;
8549 size_t count;
8550 size_t capacity;
8551
8552 unsigned int locks;
8553 unsigned int locking_tid;
8554
8555 CRITICAL_SECTION cs;
8556 CONDITION_VARIABLE lock;
8557 };
8558
8559 static struct dxgi_device_manager *impl_from_IMFDXGIDeviceManager(IMFDXGIDeviceManager *iface)
8560 {
8561 return CONTAINING_RECORD(iface, struct dxgi_device_manager, IMFDXGIDeviceManager_iface);
8562 }
8563
8564 static HRESULT dxgi_device_manager_get_handle_index(struct dxgi_device_manager *manager, HANDLE hdevice, size_t *idx)
8565 {
8566 if (!hdevice || hdevice > ULongToHandle(manager->count))
8567 return E_HANDLE;
8568 *idx = (ULONG_PTR)hdevice - 1;
8569 return S_OK;
8570 }
8571
8572 static HRESULT WINAPI dxgi_device_manager_QueryInterface(IMFDXGIDeviceManager *iface, REFIID riid, void **obj)
8573 {
8574 TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
8575
8576 if (IsEqualIID(riid, &IID_IMFDXGIDeviceManager) ||
8577 IsEqualGUID(riid, &IID_IUnknown))
8578 {
8579 *obj = iface;
8580 IMFDXGIDeviceManager_AddRef(iface);
8581 return S_OK;
8582 }
8583
8584 WARN("Unsupported %s.\n", debugstr_guid(riid));
8585 *obj = NULL;
8586 return E_NOINTERFACE;
8587 }
8588
8589 static ULONG WINAPI dxgi_device_manager_AddRef(IMFDXGIDeviceManager *iface)
8590 {
8591 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8592 ULONG refcount = InterlockedIncrement(&manager->refcount);
8593
8594 TRACE("%p, refcount %u.\n", iface, refcount);
8595
8596 return refcount;
8597 }
8598
8599 static ULONG WINAPI dxgi_device_manager_Release(IMFDXGIDeviceManager *iface)
8600 {
8601 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8602 ULONG refcount = InterlockedDecrement(&manager->refcount);
8603
8604 TRACE("%p, refcount %u.\n", iface, refcount);
8605
8606 if (!refcount)
8607 {
8608 if (manager->device)
8609 IDXGIDevice_Release(manager->device);
8610 DeleteCriticalSection(&manager->cs);
8611 free(manager->handles);
8612 free(manager);
8613 }
8614
8615 return refcount;
8616 }
8617
8618 static void dxgi_device_manager_lock_handle(struct dxgi_device_manager *manager, size_t idx)
8619 {
8620 if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_LOCKED)
8621 return;
8622
8623 manager->handles[idx] |= DXGI_DEVICE_HANDLE_FLAG_LOCKED;
8624 manager->locks++;
8625 }
8626
8627 static void dxgi_device_manager_unlock_handle(struct dxgi_device_manager *manager, size_t idx)
8628 {
8629 if (!(manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_LOCKED))
8630 return;
8631
8632 manager->handles[idx] &= ~DXGI_DEVICE_HANDLE_FLAG_LOCKED;
8633 if (!--manager->locks)
8634 manager->locking_tid = 0;
8635 }
8636
8637 static HRESULT WINAPI dxgi_device_manager_CloseDeviceHandle(IMFDXGIDeviceManager *iface, HANDLE hdevice)
8638 {
8639 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8640 HRESULT hr;
8641 size_t idx;
8642
8643 TRACE("%p, %p.\n", iface, hdevice);
8644
8645 EnterCriticalSection(&manager->cs);
8646
8647 if (SUCCEEDED(hr = dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8648 {
8649 if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_OPEN)
8650 {
8651 dxgi_device_manager_unlock_handle(manager, idx);
8652 manager->handles[idx] = 0;
8653 if (idx == manager->count - 1)
8654 manager->count--;
8655 }
8656 else
8657 hr = E_HANDLE;
8658 }
8659
8660 LeaveCriticalSection(&manager->cs);
8661
8662 WakeAllConditionVariable(&manager->lock);
8663
8664 return hr;
8665 }
8666
8667 static HRESULT WINAPI dxgi_device_manager_GetVideoService(IMFDXGIDeviceManager *iface, HANDLE hdevice,
8668 REFIID riid, void **service)
8669 {
8670 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8671 HRESULT hr;
8672 size_t idx;
8673
8674 TRACE("%p, %p, %s, %p.\n", iface, hdevice, debugstr_guid(riid), service);
8675
8676 EnterCriticalSection(&manager->cs);
8677
8678 if (!manager->device)
8679 hr = MF_E_DXGI_DEVICE_NOT_INITIALIZED;
8680 else if (SUCCEEDED(hr = dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8681 {
8682 if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_INVALID)
8683 hr = MF_E_DXGI_NEW_VIDEO_DEVICE;
8684 else if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_OPEN)
8685 hr = IDXGIDevice_QueryInterface(manager->device, riid, service);
8686 else
8687 hr = E_HANDLE;
8688 }
8689
8690 LeaveCriticalSection(&manager->cs);
8691
8692 return hr;
8693 }
8694
8695 static HRESULT WINAPI dxgi_device_manager_LockDevice(IMFDXGIDeviceManager *iface, HANDLE hdevice,
8696 REFIID riid, void **obj, BOOL block)
8697 {
8698 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8699 HRESULT hr;
8700 size_t idx;
8701
8702 TRACE("%p, %p, %s, %p, %d.\n", iface, hdevice, wine_dbgstr_guid(riid), obj, block);
8703
8704 EnterCriticalSection(&manager->cs);
8705
8706 if (SUCCEEDED(hr = dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8707 {
8708 if (!manager->device)
8709 {
8710 hr = MF_E_DXGI_DEVICE_NOT_INITIALIZED;
8711 }
8712 else if (manager->locking_tid == GetCurrentThreadId())
8713 {
8714 if (SUCCEEDED(hr = IDXGIDevice_QueryInterface(manager->device, riid, obj)))
8715 dxgi_device_manager_lock_handle(manager, idx);
8716 }
8717 else if (manager->locking_tid && !block)
8718 {
8719 hr = MF_E_DXGI_VIDEO_DEVICE_LOCKED;
8720 }
8721 else
8722 {
8723 while (manager->locking_tid)
8724 {
8725 SleepConditionVariableCS(&manager->lock, &manager->cs, INFINITE);
8726 }
8727
8728 if (SUCCEEDED(hr = dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8729 {
8730 if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_INVALID)
8731 hr = MF_E_DXGI_NEW_VIDEO_DEVICE;
8732 else if (SUCCEEDED(hr = IDXGIDevice_QueryInterface(manager->device, riid, obj)))
8733 {
8734 manager->locking_tid = GetCurrentThreadId();
8735 dxgi_device_manager_lock_handle(manager, idx);
8736 }
8737 }
8738 }
8739 }
8740
8741 LeaveCriticalSection(&manager->cs);
8742
8743 return hr;
8744 }
8745
8746 static HRESULT WINAPI dxgi_device_manager_OpenDeviceHandle(IMFDXGIDeviceManager *iface, HANDLE *hdevice)
8747 {
8748 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8749 HRESULT hr = S_OK;
8750 size_t i;
8751
8752 TRACE("%p, %p.\n", iface, hdevice);
8753
8754 *hdevice = NULL;
8755
8756 EnterCriticalSection(&manager->cs);
8757
8758 if (!manager->device)
8759 hr = MF_E_DXGI_DEVICE_NOT_INITIALIZED;
8760 else
8761 {
8762 for (i = 0; i < manager->count; ++i)
8763 {
8764 if (!(manager->handles[i] & DXGI_DEVICE_HANDLE_FLAG_OPEN))
8765 {
8766 manager->handles[i] |= DXGI_DEVICE_HANDLE_FLAG_OPEN;
8767 *hdevice = ULongToHandle(i + 1);
8768 break;
8769 }
8770 }
8771
8772 if (mf_array_reserve((void **)&manager->handles, &manager->capacity, manager->count + 1,
8773 sizeof(*manager->handles)))
8774 {
8775 *hdevice = ULongToHandle(manager->count + 1);
8776 manager->handles[manager->count++] = DXGI_DEVICE_HANDLE_FLAG_OPEN;
8777 }
8778 else
8779 hr = E_OUTOFMEMORY;
8780 }
8781
8782 LeaveCriticalSection(&manager->cs);
8783
8784 return hr;
8785 }
8786
8787 static HRESULT WINAPI dxgi_device_manager_ResetDevice(IMFDXGIDeviceManager *iface, IUnknown *device, UINT token)
8788 {
8789 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8790 IDXGIDevice *dxgi_device;
8791 size_t i;
8792
8793 TRACE("%p, %p, %u.\n", iface, device, token);
8794
8795 if (!device || token != manager->token)
8796 return E_INVALIDARG;
8797
8798 if (FAILED(IUnknown_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgi_device)))
8799 return E_INVALIDARG;
8800
8801 EnterCriticalSection(&manager->cs);
8802
8803 if (manager->device)
8804 {
8805 for (i = 0; i < manager->count; ++i)
8806 {
8807 manager->handles[i] |= DXGI_DEVICE_HANDLE_FLAG_INVALID;
8808 manager->handles[i] &= ~DXGI_DEVICE_HANDLE_FLAG_LOCKED;
8809 }
8810 manager->locking_tid = 0;
8811 manager->locks = 0;
8812 IDXGIDevice_Release(manager->device);
8813 }
8814 manager->device = dxgi_device;
8815
8816 LeaveCriticalSection(&manager->cs);
8817
8818 WakeAllConditionVariable(&manager->lock);
8819
8820 return S_OK;
8821 }
8822
8823 static HRESULT WINAPI dxgi_device_manager_TestDevice(IMFDXGIDeviceManager *iface, HANDLE hdevice)
8824 {
8825 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8826 HRESULT hr;
8827 size_t idx;
8828
8829 TRACE("%p, %p.\n", iface, hdevice);
8830
8831 EnterCriticalSection(&manager->cs);
8832
8833 if (SUCCEEDED(hr = dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8834 {
8835 if (manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_INVALID)
8836 hr = MF_E_DXGI_NEW_VIDEO_DEVICE;
8837 else if (!(manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_OPEN))
8838 hr = E_HANDLE;
8839 }
8840
8841 LeaveCriticalSection(&manager->cs);
8842
8843 return hr;
8844 }
8845
8846 static HRESULT WINAPI dxgi_device_manager_UnlockDevice(IMFDXGIDeviceManager *iface, HANDLE hdevice,
8847 BOOL savestate)
8848 {
8849 struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8850 HRESULT hr = E_FAIL;
8851 size_t idx;
8852
8853 TRACE("%p, %p, %d.\n", iface, hdevice, savestate);
8854
8855 EnterCriticalSection(&manager->cs);
8856
8857 if (SUCCEEDED(dxgi_device_manager_get_handle_index(manager, hdevice, &idx)))
8858 {
8859 hr = manager->handles[idx] & DXGI_DEVICE_HANDLE_FLAG_LOCKED ? S_OK : E_INVALIDARG;
8860 if (SUCCEEDED(hr))
8861 dxgi_device_manager_unlock_handle(manager, idx);
8862 }
8863
8864 LeaveCriticalSection(&manager->cs);
8865
8866 WakeAllConditionVariable(&manager->lock);
8867
8868 return hr;
8869 }
8870
8871 static const IMFDXGIDeviceManagerVtbl dxgi_device_manager_vtbl =
8872 {
8873 dxgi_device_manager_QueryInterface,
8874 dxgi_device_manager_AddRef,
8875 dxgi_device_manager_Release,
8876 dxgi_device_manager_CloseDeviceHandle,
8877 dxgi_device_manager_GetVideoService,
8878 dxgi_device_manager_LockDevice,
8879 dxgi_device_manager_OpenDeviceHandle,
8880 dxgi_device_manager_ResetDevice,
8881 dxgi_device_manager_TestDevice,
8882 dxgi_device_manager_UnlockDevice,
8883 };
8884
8885 /***********************************************************************
8886 * MFCreateDXGIDeviceManager (mfplat.@)
8887 */
8888 HRESULT WINAPI MFCreateDXGIDeviceManager(UINT *token, IMFDXGIDeviceManager **manager)
8889 {
8890 struct dxgi_device_manager *object;
8891
8892 TRACE("%p, %p.\n", token, manager);
8893
8894 if (!token || !manager)
8895 return E_POINTER;
8896
8897 if (!(object = calloc(1, sizeof(*object))))
8898 return E_OUTOFMEMORY;
8899
8900 object->IMFDXGIDeviceManager_iface.lpVtbl = &dxgi_device_manager_vtbl;
8901 object->refcount = 1;
8902 object->token = GetTickCount();
8903 InitializeCriticalSection(&object->cs);
8904 InitializeConditionVariable(&object->lock);
8905
8906 TRACE("Created device manager: %p, token: %u.\n", object, object->token);
8907
8908 *token = object->token;
8909 *manager = &object->IMFDXGIDeviceManager_iface;
8910
8911 return S_OK;
8912 }
8913
8914 /***********************************************************************
8915 * MFLockDXGIDeviceManager (mfplat.@)
8916 */
8917 HRESULT WINAPI MFLockDXGIDeviceManager(UINT *token, IMFDXGIDeviceManager **manager)
8918 {
8919 HRESULT hr = S_OK;
8920
8921 TRACE("%p, %p.\n", token, manager);
8922
8923 EnterCriticalSection(&shared_dm_cs);
8924
8925 if (!shared_dm.manager)
8926 hr = MFCreateDXGIDeviceManager(&shared_dm.token, &shared_dm.manager);
8927
8928 if (SUCCEEDED(hr))
8929 {
8930 *manager = shared_dm.manager;
8931 IMFDXGIDeviceManager_AddRef(*manager);
8932 shared_dm.locks++;
8933
8934 if (token) *token = shared_dm.token;
8935 }
8936
8937 LeaveCriticalSection(&shared_dm_cs);
8938
8939 return hr;
8940 }
8941
8942 /***********************************************************************
8943 * MFUnlockDXGIDeviceManager (mfplat.@)
8944 */
8945 HRESULT WINAPI MFUnlockDXGIDeviceManager(void)
8946 {
8947 TRACE("\n");
8948
8949 EnterCriticalSection(&shared_dm_cs);
8950
8951 if (shared_dm.manager)
8952 {
8953 IMFDXGIDeviceManager_Release(shared_dm.manager);
8954 if (!--shared_dm.locks)
8955 {
8956 shared_dm.manager = NULL;
8957 shared_dm.token = 0;
8958 }
8959 }
8960
8961 LeaveCriticalSection(&shared_dm_cs);
8962
8963 return S_OK;
8964 }
8965
8966
8967 /*
8968 * MFllMulDiv implementation is derived from gstreamer utility functions code (gstutils.c),
8969 * released under LGPL2. Full authors list follows.
8970 * ===================================================================================
8971 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
8972 * 2000 Wim Taymans <wtay@chello.be>
8973 * 2002 Thomas Vander Stichele <thomas@apestaart.org>
8974 * 2004 Wim Taymans <wim@fluendo.com>
8975 * 2015 Jan Schmidt <jan@centricular.com>
8976 * ===================================================================================
8977 */
8978
8979 static void llmult128(ULARGE_INTEGER *c1, ULARGE_INTEGER *c0, LONGLONG val, LONGLONG num)
8980 {
8981 ULARGE_INTEGER a1, b0, v, n;
8982
8983 v.QuadPart = llabs(val);
8984 n.QuadPart = llabs(num);
8985
8986 /* do 128 bits multiply
8987 * nh nl
8988 * * vh vl
8989 * ----------
8990 * a0 = vl * nl
8991 * a1 = vl * nh
8992 * b0 = vh * nl
8993 * b1 = + vh * nh
8994 * -------------------
8995 * c1h c1l c0h c0l
8996 *
8997 * "a0" is optimized away, result is stored directly in c0. "b1" is
8998 * optimized away, result is stored directly in c1.
8999 */
9000 c0->QuadPart = (ULONGLONG)v.LowPart * n.LowPart;
9001 a1.QuadPart = (ULONGLONG)v.LowPart * n.HighPart;
9002 b0.QuadPart = (ULONGLONG)v.HighPart * n.LowPart;
9003
9004 /* add the high word of a0 to the low words of a1 and b0 using c1 as
9005 * scratch space to capture the carry. the low word of the result becomes
9006 * the final high word of c0 */
9007 c1->QuadPart = (ULONGLONG)c0->HighPart + a1.LowPart + b0.LowPart;
9008 c0->HighPart = c1->LowPart;
9009
9010 /* add the carry from the result above (found in the high word of c1) and
9011 * the high words of a1 and b0 to b1, the result is c1. */
9012 c1->QuadPart = (ULONGLONG)v.HighPart * n.HighPart + c1->HighPart + a1.HighPart + b0.HighPart;
9013 }
9014
9015 static ULONGLONG lldiv128(ULARGE_INTEGER c1, ULARGE_INTEGER c0, LONGLONG denom)
9016 {
9017 ULARGE_INTEGER q1, q0, rhat;
9018 ULARGE_INTEGER v, cmp1, cmp2;
9019 unsigned int s = 0;
9020
9021 v.QuadPart = llabs(denom);
9022
9023 /* 64bit numerator */
9024 if (c1.QuadPart == 0)
9025 return c0.QuadPart / v.QuadPart;
9026
9027 /* 96bit numerator, 32bit denominator */
9028 if (v.HighPart == 0 && c1.HighPart == 0)
9029 {
9030 ULONGLONG low = c0.LowPart, high = c0.HighPart + ((ULONGLONG)c1.LowPart << 32);
9031 low += (high % v.LowPart) << 32;
9032 return ((high / v.LowPart) << 32) + (low / v.LowPart);
9033 }
9034
9035 /* 128bit numerator, 32bit denominator */
9036 if (v.HighPart == 0)
9037 return UI64_MAX;
9038
9039 /* count number of leading zeroes */
9040 BitScanReverse(&s, v.HighPart);
9041 s = 31 - s;
9042
9043 if (s)
9044 {
9045 /* normalize divisor and dividend */
9046 v.QuadPart <<= s;
9047 c1.QuadPart = (c1.QuadPart << s) | (c0.HighPart >> (32 - s));
9048 c0.QuadPart <<= s;
9049 }
9050
9051 q1.QuadPart = c1.QuadPart / v.HighPart;
9052 rhat.QuadPart = c1.QuadPart - q1.QuadPart * v.HighPart;
9053
9054 cmp1.HighPart = rhat.LowPart;
9055 cmp1.LowPart = c0.HighPart;
9056 cmp2.QuadPart = q1.QuadPart * v.LowPart;
9057
9058 while (q1.HighPart || cmp2.QuadPart > cmp1.QuadPart)
9059 {
9060 q1.QuadPart--;
9061 rhat.QuadPart += v.HighPart;
9062 if (rhat.HighPart)
9063 break;
9064 cmp1.HighPart = rhat.LowPart;
9065 cmp2.QuadPart -= v.LowPart;
9066 }
9067 c1.HighPart = c1.LowPart;
9068 c1.LowPart = c0.HighPart;
9069 c1.QuadPart -= q1.QuadPart * v.QuadPart;
9070 q0.QuadPart = c1.QuadPart / v.HighPart;
9071 rhat.QuadPart = c1.QuadPart - q0.QuadPart * v.HighPart;
9072
9073 cmp1.HighPart = rhat.LowPart;
9074 cmp1.LowPart = c0.LowPart;
9075 cmp2.QuadPart = q0.QuadPart * v.LowPart;
9076
9077 while (q0.HighPart || cmp2.QuadPart > cmp1.QuadPart)
9078 {
9079 q0.QuadPart--;
9080 rhat.QuadPart += v.HighPart;
9081 if (rhat.HighPart)
9082 break;
9083 cmp1.HighPart = rhat.LowPart;
9084 cmp2.QuadPart -= v.LowPart;
9085 }
9086 q0.HighPart += q1.LowPart;
9087
9088 return q0.QuadPart;
9089 }
9090
9091 /***********************************************************************
9092 * MFllMulDiv (mfplat.@)
9093 */
9094 LONGLONG WINAPI MFllMulDiv(LONGLONG val, LONGLONG num, LONGLONG denom, LONGLONG factor)
9095 {
9096 #define LLOVERFLOW (sign ? I64_MIN : I64_MAX)
9097 unsigned int sign, factor_sign, denom_sign;
9098 ULARGE_INTEGER c1, c0;
9099 ULONGLONG ret;
9100
9101 TRACE("%s, %s, %s, %s.\n", wine_dbgstr_longlong(val), wine_dbgstr_longlong(num),
9102 wine_dbgstr_longlong(denom), wine_dbgstr_longlong(factor));
9103
9104 /* compute 128-bit numerator product */
9105 llmult128(&c1, &c0, val, num);
9106
9107 sign = (val < 0) ^ (num < 0);
9108 factor_sign = factor < 0;
9109 denom_sign = denom < 0;
9110
9111 factor = llabs(factor);
9112 if (sign == factor_sign)
9113 {
9114 if (UI64_MAX - c0.QuadPart < factor)
9115 {
9116 if (c1.QuadPart == UI64_MAX) return LLOVERFLOW;
9117 c1.QuadPart++;
9118 }
9119 c0.QuadPart += factor;
9120 }
9121 else
9122 {
9123 if (c0.QuadPart >= factor)
9124 c0.QuadPart -= factor;
9125 else
9126 {
9127 if (c1.QuadPart)
9128 c1.QuadPart--;
9129 else
9130 sign = !sign;
9131
9132 c0.QuadPart = factor - c0.QuadPart;
9133 }
9134 }
9135
9136 if (c1.QuadPart >= denom) return LLOVERFLOW;
9137
9138 /* compute quotient, fits in 64 bits */
9139 ret = lldiv128(c1, c0, denom);
9140 sign ^= denom_sign;
9141 if (ret >= I64_MAX) return LLOVERFLOW;
9142 return sign ? -(LONGLONG)ret : ret;
9143 #undef LLOVERFLOW
9144 }
Windows API implementation