?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4: Write the function header into the procedure format string.
[wine.git] / dlls / mfplat / main.c
blob33080d0b27899874dadc85ea1a745f7f8eaa8963
1 /*
2 *
3 * Copyright 2014 Austin English
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdarg.h>
21 #include <string.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29
30 #include "initguid.h"
31 #include "mfapi.h"
32 #include "mfidl.h"
33 #include "mferror.h"
34
35 #include "wine/heap.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
40
41 static const WCHAR transform_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
42 'T','r','a','n','s','f','o','r','m','s',0};
43 static const WCHAR categories_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
44 'T','r','a','n','s','f','o','r','m','s','\\',
45 'C','a','t','e','g','o','r','i','e','s',0};
46 static const WCHAR inputtypesW[] = {'I','n','p','u','t','T','y','p','e','s',0};
47 static const WCHAR outputtypesW[] = {'O','u','t','p','u','t','T','y','p','e','s',0};
48 static const WCHAR szGUIDFmt[] =
49 {
50 '%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0',
51 '2','x','%','0','2','x','-','%','0','2','x','%','0','2','x','%','0','2',
52 'x','%','0','2','x','%','0','2','x','%','0','2','x',0
53 };
54
55 static const BYTE guid_conv_table[256] =
56 {
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
59 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
60 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
61 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
62 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
63 0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf /* 0x60 */
64 };
65
66 static WCHAR* GUIDToString(WCHAR *str, REFGUID guid)
67 {
68 sprintfW(str, szGUIDFmt, guid->Data1, guid->Data2,
69 guid->Data3, guid->Data4[0], guid->Data4[1],
70 guid->Data4[2], guid->Data4[3], guid->Data4[4],
71 guid->Data4[5], guid->Data4[6], guid->Data4[7]);
72
73 return str;
74 }
75
76 static inline BOOL is_valid_hex(WCHAR c)
77 {
78 if (!(((c >= '0') && (c <= '9')) ||
79 ((c >= 'a') && (c <= 'f')) ||
80 ((c >= 'A') && (c <= 'F'))))
81 return FALSE;
82 return TRUE;
83 }
84
85 static BOOL GUIDFromString(LPCWSTR s, GUID *id)
86 {
87 int i;
88
89 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
90
91 id->Data1 = 0;
92 for (i = 0; i < 8; i++)
93 {
94 if (!is_valid_hex(s[i])) return FALSE;
95 id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
96 }
97 if (s[8]!='-') return FALSE;
98
99 id->Data2 = 0;
100 for (i = 9; i < 13; i++)
101 {
102 if (!is_valid_hex(s[i])) return FALSE;
103 id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
104 }
105 if (s[13]!='-') return FALSE;
106
107 id->Data3 = 0;
108 for (i = 14; i < 18; i++)
109 {
110 if (!is_valid_hex(s[i])) return FALSE;
111 id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
112 }
113 if (s[18]!='-') return FALSE;
114
115 for (i = 19; i < 36; i+=2)
116 {
117 if (i == 23)
118 {
119 if (s[i]!='-') return FALSE;
120 i++;
121 }
122 if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
123 id->Data4[(i-19)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
124 }
125
126 if (!s[37]) return TRUE;
127 return FALSE;
128 }
129
130 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
131 {
132 switch (reason)
133 {
134 case DLL_WINE_PREATTACH:
135 return FALSE; /* prefer native version */
136 case DLL_PROCESS_ATTACH:
137 DisableThreadLibraryCalls(instance);
138 break;
139 }
140
141 return TRUE;
142 }
143
144 static HRESULT register_transform(CLSID *clsid, WCHAR *name,
145 UINT32 cinput, MFT_REGISTER_TYPE_INFO *input_types,
146 UINT32 coutput, MFT_REGISTER_TYPE_INFO *output_types)
147 {
148 static const WCHAR reg_format[] = {'%','s','\\','%','s',0};
149 HKEY hclsid = 0;
150 WCHAR buffer[64];
151 DWORD size;
152 WCHAR str[250];
153
154 GUIDToString(buffer, clsid);
155 sprintfW(str, reg_format, transform_keyW, buffer);
156
157 if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid))
158 return E_FAIL;
159
160 size = (strlenW(name) + 1) * sizeof(WCHAR);
161 if (RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size))
162 goto err;
163
164 if (cinput && input_types)
165 {
166 size = cinput * sizeof(MFT_REGISTER_TYPE_INFO);
167 if (RegSetValueExW(hclsid, inputtypesW, 0, REG_BINARY, (BYTE *)input_types, size))
168 goto err;
169 }
170
171 if (coutput && output_types)
172 {
173 size = coutput * sizeof(MFT_REGISTER_TYPE_INFO);
174 if (RegSetValueExW(hclsid, outputtypesW, 0, REG_BINARY, (BYTE *)output_types, size))
175 goto err;
176 }
177
178 RegCloseKey(hclsid);
179 return S_OK;
180
181 err:
182 RegCloseKey(hclsid);
183 return E_FAIL;
184 }
185
186 static HRESULT register_category(CLSID *clsid, GUID *category)
187 {
188 static const WCHAR reg_format[] = {'%','s','\\','%','s','\\','%','s',0};
189 HKEY htmp1;
190 WCHAR guid1[64], guid2[64];
191 WCHAR str[350];
192
193 GUIDToString(guid1, category);
194 GUIDToString(guid2, clsid);
195
196 sprintfW(str, reg_format, categories_keyW, guid1, guid2);
197
198 if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &htmp1))
199 return E_FAIL;
200
201 RegCloseKey(htmp1);
202 return S_OK;
203 }
204
205 /***********************************************************************
206 * MFTRegister (mfplat.@)
207 */
208 HRESULT WINAPI MFTRegister(CLSID clsid, GUID category, LPWSTR name, UINT32 flags, UINT32 cinput,
209 MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
210 MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
211 {
212 HRESULT hr;
213
214 TRACE("(%s, %s, %s, %x, %u, %p, %u, %p, %p)\n", debugstr_guid(&clsid), debugstr_guid(&category),
215 debugstr_w(name), flags, cinput, input_types,
216 coutput, output_types, attributes);
217
218 if (attributes)
219 FIXME("attributes not yet supported.\n");
220
221 if (flags)
222 FIXME("flags not yet supported.\n");
223
224 hr = register_transform(&clsid, name, cinput, input_types, coutput, output_types);
225 if(FAILED(hr))
226 ERR("Failed to write register transform\n");
227
228 if (SUCCEEDED(hr))
229 hr = register_category(&clsid, &category);
230
231 return hr;
232 }
233
234 HRESULT WINAPI MFTRegisterLocal(IClassFactory *factory, REFGUID category, LPCWSTR name,
235 UINT32 flags, UINT32 cinput, const MFT_REGISTER_TYPE_INFO *input_types,
236 UINT32 coutput, const MFT_REGISTER_TYPE_INFO* output_types)
237 {
238 FIXME("(%p, %s, %s, %x, %u, %p, %u, %p)\n", factory, debugstr_guid(category), debugstr_w(name),
239 flags, cinput, input_types, coutput, output_types);
240
241 return S_OK;
242 }
243
244 HRESULT WINAPI MFTUnregisterLocal(IClassFactory *factory)
245 {
246 FIXME("(%p)\n", factory);
247
248 return S_OK;
249 }
250
251 static BOOL match_type(const WCHAR *clsid_str, const WCHAR *type_str, MFT_REGISTER_TYPE_INFO *type)
252 {
253 HKEY htransform, hfilter;
254 DWORD reg_type, size;
255 LONG ret = FALSE;
256 MFT_REGISTER_TYPE_INFO *info = NULL;
257 int i;
258
259 if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
260 return FALSE;
261
262 if (RegOpenKeyW(htransform, clsid_str, &hfilter))
263 {
264 RegCloseKey(htransform);
265 return FALSE;
266 }
267
268 if (RegQueryValueExW(hfilter, type_str, NULL, &reg_type, NULL, &size) != ERROR_SUCCESS)
269 goto out;
270
271 if (reg_type != REG_BINARY)
272 goto out;
273
274 if (!size || size % (sizeof(MFT_REGISTER_TYPE_INFO)) != 0)
275 goto out;
276
277 info = HeapAlloc(GetProcessHeap(), 0, size);
278 if (!info)
279 goto out;
280
281 if (RegQueryValueExW(hfilter, type_str, NULL, &reg_type, (LPBYTE)info, &size) != ERROR_SUCCESS)
282 goto out;
283
284 for (i = 0; i < size / sizeof(MFT_REGISTER_TYPE_INFO); i++)
285 {
286 if (IsEqualGUID(&info[i].guidMajorType, &type->guidMajorType) &&
287 IsEqualGUID(&info[i].guidSubtype, &type->guidSubtype))
288 {
289 ret = TRUE;
290 break;
291 }
292 }
293
294 out:
295 HeapFree(GetProcessHeap(), 0, info);
296 RegCloseKey(hfilter);
297 RegCloseKey(htransform);
298 return ret;
299 }
300
301 /***********************************************************************
302 * MFTEnum (mfplat.@)
303 */
304 HRESULT WINAPI MFTEnum(GUID category, UINT32 flags, MFT_REGISTER_TYPE_INFO *input_type,
305 MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes,
306 CLSID **pclsids, UINT32 *pcount)
307 {
308 WCHAR buffer[64], clsid_str[MAX_PATH] = {0};
309 HKEY hcategory, hlist;
310 DWORD index = 0;
311 DWORD size = MAX_PATH;
312 CLSID *clsids = NULL;
313 UINT32 count = 0;
314 LONG ret;
315
316 TRACE("(%s, %x, %p, %p, %p, %p, %p)\n", debugstr_guid(&category), flags, input_type,
317 output_type, attributes, pclsids, pcount);
318
319 if (!pclsids || !pcount)
320 return E_INVALIDARG;
321
322 if (RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
323 return E_FAIL;
324
325 GUIDToString(buffer, &category);
326
327 ret = RegOpenKeyW(hcategory, buffer, &hlist);
328 RegCloseKey(hcategory);
329 if (ret) return E_FAIL;
330
331 while (RegEnumKeyExW(hlist, index, clsid_str, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
332 {
333 GUID clsid;
334 void *tmp;
335
336 if (!GUIDFromString(clsid_str, &clsid))
337 goto next;
338
339 if (output_type && !match_type(clsid_str, outputtypesW, output_type))
340 goto next;
341
342 if (input_type && !match_type(clsid_str, inputtypesW, input_type))
343 goto next;
344
345 tmp = CoTaskMemRealloc(clsids, (count + 1) * sizeof(GUID));
346 if (!tmp)
347 {
348 CoTaskMemFree(clsids);
349 RegCloseKey(hlist);
350 return E_OUTOFMEMORY;
351 }
352
353 clsids = tmp;
354 clsids[count++] = clsid;
355
356 next:
357 size = MAX_PATH;
358 index++;
359 }
360
361 *pclsids = clsids;
362 *pcount = count;
363
364 RegCloseKey(hlist);
365 return S_OK;
366 }
367
368 /***********************************************************************
369 * MFTEnumEx (mfplat.@)
370 */
371 HRESULT WINAPI MFTEnumEx(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
372 const MFT_REGISTER_TYPE_INFO *output_type, IMFActivate ***activate,
373 UINT32 *pcount)
374 {
375 FIXME("(%s, %x, %p, %p, %p, %p): stub\n", debugstr_guid(&category), flags, input_type,
376 output_type, activate, pcount);
377
378 *pcount = 0;
379 return S_OK;
380 }
381
382 /***********************************************************************
383 * MFTUnregister (mfplat.@)
384 */
385 HRESULT WINAPI MFTUnregister(CLSID clsid)
386 {
387 WCHAR buffer[64], category[MAX_PATH];
388 HKEY htransform, hcategory, htmp;
389 DWORD size = MAX_PATH;
390 DWORD index = 0;
391
392 TRACE("(%s)\n", debugstr_guid(&clsid));
393
394 GUIDToString(buffer, &clsid);
395
396 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
397 {
398 RegDeleteKeyW(htransform, buffer);
399 RegCloseKey(htransform);
400 }
401
402 if (!RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
403 {
404 while (RegEnumKeyExW(hcategory, index, category, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
405 {
406 if (!RegOpenKeyW(hcategory, category, &htmp))
407 {
408 RegDeleteKeyW(htmp, buffer);
409 RegCloseKey(htmp);
410 }
411 size = MAX_PATH;
412 index++;
413 }
414 RegCloseKey(hcategory);
415 }
416
417 return S_OK;
418 }
419
420 /***********************************************************************
421 * MFStartup (mfplat.@)
422 */
423 HRESULT WINAPI MFStartup(ULONG version, DWORD flags)
424 {
425 #define MF_VERSION_XP MAKELONG( MF_API_VERSION, 1 )
426 #define MF_VERSION_WIN7 MAKELONG( MF_API_VERSION, 2 )
427
428 FIXME("(%u, %u): stub\n", version, flags);
429
430 if(version != MF_VERSION_XP && version != MF_VERSION_WIN7)
431 return MF_E_BAD_STARTUP_VERSION;
432
433 return S_OK;
434 }
435
436 /***********************************************************************
437 * MFShutdown (mfplat.@)
438 */
439 HRESULT WINAPI MFShutdown(void)
440 {
441 FIXME("(): stub\n");
442 return S_OK;
443 }
444
445 HRESULT WINAPI MFCopyImage(BYTE *dest, LONG deststride, const BYTE *src, LONG srcstride, DWORD width, DWORD lines)
446 {
447 FIXME("(%p, %d, %p, %d, %d, %d) stub\n", dest, deststride, src, srcstride, width, lines);
448 return E_NOTIMPL;
449 }
450
451 typedef struct _mfattributes
452 {
453 IMFAttributes IMFAttributes_iface;
454 LONG ref;
455 } mfattributes;
456
457 static inline mfattributes *impl_from_IMFAttributes(IMFAttributes *iface)
458 {
459 return CONTAINING_RECORD(iface, mfattributes, IMFAttributes_iface);
460 }
461
462 static HRESULT WINAPI mfattributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
463 {
464 mfattributes *This = impl_from_IMFAttributes(iface);
465
466 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
467
468 if(IsEqualGUID(riid, &IID_IUnknown) ||
469 IsEqualGUID(riid, &IID_IMFAttributes))
470 {
471 *out = &This->IMFAttributes_iface;
472 }
473 else
474 {
475 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
476 *out = NULL;
477 return E_NOINTERFACE;
478 }
479
480 IUnknown_AddRef((IUnknown*)*out);
481 return S_OK;
482 }
483
484 static ULONG WINAPI mfattributes_AddRef(IMFAttributes *iface)
485 {
486 mfattributes *This = impl_from_IMFAttributes(iface);
487 ULONG ref = InterlockedIncrement(&This->ref);
488
489 TRACE("(%p) ref=%u\n", This, ref);
490
491 return ref;
492 }
493
494 static ULONG WINAPI mfattributes_Release(IMFAttributes *iface)
495 {
496 mfattributes *This = impl_from_IMFAttributes(iface);
497 ULONG ref = InterlockedDecrement(&This->ref);
498
499 TRACE("(%p) ref=%u\n", This, ref);
500
501 if (!ref)
502 {
503 HeapFree(GetProcessHeap(), 0, This);
504 }
505
506 return ref;
507 }
508
509 static HRESULT WINAPI mfattributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
510 {
511 mfattributes *This = impl_from_IMFAttributes(iface);
512
513 FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
514
515 return E_NOTIMPL;
516 }
517
518 static HRESULT WINAPI mfattributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
519 {
520 mfattributes *This = impl_from_IMFAttributes(iface);
521
522 FIXME("%p, %s, %p\n", This, debugstr_guid(key), type);
523
524 return E_NOTIMPL;
525 }
526
527 static HRESULT WINAPI mfattributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
528 {
529 mfattributes *This = impl_from_IMFAttributes(iface);
530
531 FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, result);
532
533 return E_NOTIMPL;
534 }
535
536 static HRESULT WINAPI mfattributes_Compare(IMFAttributes *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
537 BOOL *result)
538 {
539 mfattributes *This = impl_from_IMFAttributes(iface);
540
541 FIXME("%p, %p, %d, %p\n", This, theirs, type, result);
542
543 return E_NOTIMPL;
544 }
545
546 static HRESULT WINAPI mfattributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
547 {
548 mfattributes *This = impl_from_IMFAttributes(iface);
549
550 FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
551
552 return E_NOTIMPL;
553 }
554
555 static HRESULT WINAPI mfattributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
556 {
557 mfattributes *This = impl_from_IMFAttributes(iface);
558
559 FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
560
561 return E_NOTIMPL;
562 }
563
564 static HRESULT WINAPI mfattributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
565 {
566 mfattributes *This = impl_from_IMFAttributes(iface);
567
568 FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
569
570 return E_NOTIMPL;
571 }
572
573 static HRESULT WINAPI mfattributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
574 {
575 mfattributes *This = impl_from_IMFAttributes(iface);
576
577 FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
578
579 return E_NOTIMPL;
580 }
581
582 static HRESULT WINAPI mfattributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
583 {
584 mfattributes *This = impl_from_IMFAttributes(iface);
585
586 FIXME("%p, %s, %p\n", This, debugstr_guid(key), length);
587
588 return E_NOTIMPL;
589 }
590
591 static HRESULT WINAPI mfattributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
592 UINT32 size, UINT32 *length)
593 {
594 mfattributes *This = impl_from_IMFAttributes(iface);
595
596 FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), value, size, length);
597
598 return E_NOTIMPL;
599 }
600
601 static HRESULT WINAPI mfattributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
602 WCHAR **value, UINT32 *length)
603 {
604 mfattributes *This = impl_from_IMFAttributes(iface);
605
606 FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, length);
607
608 return E_NOTIMPL;
609 }
610
611 static HRESULT WINAPI mfattributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
612 {
613 mfattributes *This = impl_from_IMFAttributes(iface);
614
615 FIXME("%p, %s, %p\n", This, debugstr_guid(key), size);
616
617 return E_NOTIMPL;
618 }
619
620 static HRESULT WINAPI mfattributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
621 UINT32 bufsize, UINT32 *blobsize)
622 {
623 mfattributes *This = impl_from_IMFAttributes(iface);
624
625 FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), buf, bufsize, blobsize);
626
627 return E_NOTIMPL;
628 }
629
630 static HRESULT WINAPI mfattributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
631 {
632 mfattributes *This = impl_from_IMFAttributes(iface);
633
634 FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), buf, size);
635
636 return E_NOTIMPL;
637 }
638
639 static HRESULT WINAPI mfattributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **ppv)
640 {
641 mfattributes *This = impl_from_IMFAttributes(iface);
642
643 FIXME("%p, %s, %s, %p\n", This, debugstr_guid(key), debugstr_guid(riid), ppv);
644
645 return E_NOTIMPL;
646 }
647
648 static HRESULT WINAPI mfattributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT Value)
649 {
650 mfattributes *This = impl_from_IMFAttributes(iface);
651
652 FIXME("%p, %s, %p\n", This, debugstr_guid(key), Value);
653
654 return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI mfattributes_DeleteItem(IMFAttributes *iface, REFGUID key)
658 {
659 mfattributes *This = impl_from_IMFAttributes(iface);
660
661 FIXME("%p, %s\n", This, debugstr_guid(key));
662
663 return E_NOTIMPL;
664 }
665
666 static HRESULT WINAPI mfattributes_DeleteAllItems(IMFAttributes *iface)
667 {
668 mfattributes *This = impl_from_IMFAttributes(iface);
669
670 FIXME("%p\n", This);
671
672 return E_NOTIMPL;
673 }
674
675 static HRESULT WINAPI mfattributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
676 {
677 mfattributes *This = impl_from_IMFAttributes(iface);
678
679 FIXME("%p, %s, %d\n", This, debugstr_guid(key), value);
680
681 return E_NOTIMPL;
682 }
683
684 static HRESULT WINAPI mfattributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
685 {
686 mfattributes *This = impl_from_IMFAttributes(iface);
687
688 FIXME("%p, %s, %s\n", This, debugstr_guid(key), wine_dbgstr_longlong(value));
689
690 return E_NOTIMPL;
691 }
692
693 static HRESULT WINAPI mfattributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
694 {
695 mfattributes *This = impl_from_IMFAttributes(iface);
696
697 FIXME("%p, %s, %f\n", This, debugstr_guid(key), value);
698
699 return E_NOTIMPL;
700 }
701
702 static HRESULT WINAPI mfattributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
703 {
704 mfattributes *This = impl_from_IMFAttributes(iface);
705
706 FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_guid(value));
707
708 return E_NOTIMPL;
709 }
710
711 static HRESULT WINAPI mfattributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
712 {
713 mfattributes *This = impl_from_IMFAttributes(iface);
714
715 FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_w(value));
716
717 return E_NOTIMPL;
718 }
719
720 static HRESULT WINAPI mfattributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
721 {
722 mfattributes *This = impl_from_IMFAttributes(iface);
723
724 FIXME("%p, %s, %p, %d\n", This, debugstr_guid(key), buf, size);
725
726 return E_NOTIMPL;
727 }
728
729 static HRESULT WINAPI mfattributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
730 {
731 mfattributes *This = impl_from_IMFAttributes(iface);
732
733 FIXME("%p, %s, %p\n", This, debugstr_guid(key), unknown);
734
735 return E_NOTIMPL;
736 }
737
738 static HRESULT WINAPI mfattributes_LockStore(IMFAttributes *iface)
739 {
740 mfattributes *This = impl_from_IMFAttributes(iface);
741
742 FIXME("%p\n", This);
743
744 return E_NOTIMPL;
745 }
746
747 static HRESULT WINAPI mfattributes_UnlockStore(IMFAttributes *iface)
748 {
749 mfattributes *This = impl_from_IMFAttributes(iface);
750
751 FIXME("%p\n", This);
752
753 return E_NOTIMPL;
754 }
755
756 static HRESULT WINAPI mfattributes_GetCount(IMFAttributes *iface, UINT32 *items)
757 {
758 mfattributes *This = impl_from_IMFAttributes(iface);
759
760 FIXME("%p, %p\n", This, items);
761
762 if(items)
763 *items = 0;
764
765 return E_NOTIMPL;
766 }
767
768 static HRESULT WINAPI mfattributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
769 {
770 mfattributes *This = impl_from_IMFAttributes(iface);
771
772 FIXME("%p, %d, %p, %p\n", This, index, key, value);
773
774 return E_NOTIMPL;
775 }
776
777 static HRESULT WINAPI mfattributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
778 {
779 mfattributes *This = impl_from_IMFAttributes(iface);
780
781 FIXME("%p, %p\n", This, dest);
782
783 return E_NOTIMPL;
784 }
785
786 static const IMFAttributesVtbl mfattributes_vtbl =
787 {
788 mfattributes_QueryInterface,
789 mfattributes_AddRef,
790 mfattributes_Release,
791 mfattributes_GetItem,
792 mfattributes_GetItemType,
793 mfattributes_CompareItem,
794 mfattributes_Compare,
795 mfattributes_GetUINT32,
796 mfattributes_GetUINT64,
797 mfattributes_GetDouble,
798 mfattributes_GetGUID,
799 mfattributes_GetStringLength,
800 mfattributes_GetString,
801 mfattributes_GetAllocatedString,
802 mfattributes_GetBlobSize,
803 mfattributes_GetBlob,
804 mfattributes_GetAllocatedBlob,
805 mfattributes_GetUnknown,
806 mfattributes_SetItem,
807 mfattributes_DeleteItem,
808 mfattributes_DeleteAllItems,
809 mfattributes_SetUINT32,
810 mfattributes_SetUINT64,
811 mfattributes_SetDouble,
812 mfattributes_SetGUID,
813 mfattributes_SetString,
814 mfattributes_SetBlob,
815 mfattributes_SetUnknown,
816 mfattributes_LockStore,
817 mfattributes_UnlockStore,
818 mfattributes_GetCount,
819 mfattributes_GetItemByIndex,
820 mfattributes_CopyAllItems
821 };
822
823 static void init_attribute_object(mfattributes *object, UINT32 size)
824 {
825 object->ref = 1;
826 object->IMFAttributes_iface.lpVtbl = &mfattributes_vtbl;
827 }
828
829 /***********************************************************************
830 * MFCreateAttributes (mfplat.@)
831 */
832 HRESULT WINAPI MFCreateAttributes(IMFAttributes **attributes, UINT32 size)
833 {
834 mfattributes *object;
835
836 TRACE("%p, %d\n", attributes, size);
837
838 object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
839 if(!object)
840 return E_OUTOFMEMORY;
841
842 init_attribute_object(object, size);
843 *attributes = &object->IMFAttributes_iface;
844
845 return S_OK;
846 }
847
848 typedef struct _mfbytestream
849 {
850 mfattributes attributes;
851 IMFByteStream IMFByteStream_iface;
852 } mfbytestream;
853
854 static inline mfbytestream *impl_from_IMFByteStream(IMFByteStream *iface)
855 {
856 return CONTAINING_RECORD(iface, mfbytestream, IMFByteStream_iface);
857 }
858
859 static HRESULT WINAPI mfbytestream_QueryInterface(IMFByteStream *iface, REFIID riid, void **out)
860 {
861 mfbytestream *This = impl_from_IMFByteStream(iface);
862
863 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
864
865 if(IsEqualGUID(riid, &IID_IUnknown) ||
866 IsEqualGUID(riid, &IID_IMFByteStream))
867 {
868 *out = &This->IMFByteStream_iface;
869 }
870 else if(IsEqualGUID(riid, &IID_IMFAttributes))
871 {
872 *out = &This->attributes.IMFAttributes_iface;
873 }
874 else
875 {
876 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
877 *out = NULL;
878 return E_NOINTERFACE;
879 }
880
881 IUnknown_AddRef((IUnknown*)*out);
882 return S_OK;
883 }
884
885 static ULONG WINAPI mfbytestream_AddRef(IMFByteStream *iface)
886 {
887 mfbytestream *This = impl_from_IMFByteStream(iface);
888 ULONG ref = InterlockedIncrement(&This->attributes.ref);
889
890 TRACE("(%p) ref=%u\n", This, ref);
891
892 return ref;
893 }
894
895 static ULONG WINAPI mfbytestream_Release(IMFByteStream *iface)
896 {
897 mfbytestream *This = impl_from_IMFByteStream(iface);
898 ULONG ref = InterlockedDecrement(&This->attributes.ref);
899
900 TRACE("(%p) ref=%u\n", This, ref);
901
902 if (!ref)
903 {
904 HeapFree(GetProcessHeap(), 0, This);
905 }
906
907 return ref;
908 }
909
910 static HRESULT WINAPI mfbytestream_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
911 {
912 mfbytestream *This = impl_from_IMFByteStream(iface);
913
914 FIXME("%p, %p\n", This, capabilities);
915
916 return E_NOTIMPL;
917 }
918
919 static HRESULT WINAPI mfbytestream_GetLength(IMFByteStream *iface, QWORD *length)
920 {
921 mfbytestream *This = impl_from_IMFByteStream(iface);
922
923 FIXME("%p, %p\n", This, length);
924
925 return E_NOTIMPL;
926 }
927
928 static HRESULT WINAPI mfbytestream_SetLength(IMFByteStream *iface, QWORD length)
929 {
930 mfbytestream *This = impl_from_IMFByteStream(iface);
931
932 FIXME("%p, %s\n", This, wine_dbgstr_longlong(length));
933
934 return E_NOTIMPL;
935 }
936
937 static HRESULT WINAPI mfbytestream_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
938 {
939 mfbytestream *This = impl_from_IMFByteStream(iface);
940
941 FIXME("%p, %p\n", This, position);
942
943 return E_NOTIMPL;
944 }
945
946 static HRESULT WINAPI mfbytestream_SetCurrentPosition(IMFByteStream *iface, QWORD position)
947 {
948 mfbytestream *This = impl_from_IMFByteStream(iface);
949
950 FIXME("%p, %s\n", This, wine_dbgstr_longlong(position));
951
952 return E_NOTIMPL;
953 }
954
955 static HRESULT WINAPI mfbytestream_IsEndOfStream(IMFByteStream *iface, BOOL *endstream)
956 {
957 mfbytestream *This = impl_from_IMFByteStream(iface);
958
959 FIXME("%p, %p\n", This, endstream);
960
961 if(endstream)
962 *endstream = TRUE;
963
964 return S_OK;
965 }
966
967 static HRESULT WINAPI mfbytestream_Read(IMFByteStream *iface, BYTE *data, ULONG count, ULONG *byte_read)
968 {
969 mfbytestream *This = impl_from_IMFByteStream(iface);
970
971 FIXME("%p, %p, %u, %p\n", This, data, count, byte_read);
972
973 return E_NOTIMPL;
974 }
975
976 static HRESULT WINAPI mfbytestream_BeginRead(IMFByteStream *iface, BYTE *data, ULONG count,
977 IMFAsyncCallback *callback, IUnknown *state)
978 {
979 mfbytestream *This = impl_from_IMFByteStream(iface);
980
981 FIXME("%p, %p, %u, %p, %p\n", This, data, count, callback, state);
982
983 return E_NOTIMPL;
984 }
985
986 static HRESULT WINAPI mfbytestream_EndRead(IMFByteStream *iface, IMFAsyncResult *result, ULONG *byte_read)
987 {
988 mfbytestream *This = impl_from_IMFByteStream(iface);
989
990 FIXME("%p, %p, %p\n", This, result, byte_read);
991
992 return E_NOTIMPL;
993 }
994
995 static HRESULT WINAPI mfbytestream_Write(IMFByteStream *iface, const BYTE *data, ULONG count, ULONG *written)
996 {
997 mfbytestream *This = impl_from_IMFByteStream(iface);
998
999 FIXME("%p, %p, %u, %p\n", This, data, count, written);
1000
1001 return E_NOTIMPL;
1002 }
1003
1004 static HRESULT WINAPI mfbytestream_BeginWrite(IMFByteStream *iface, const BYTE *data, ULONG count,
1005 IMFAsyncCallback *callback, IUnknown *state)
1006 {
1007 mfbytestream *This = impl_from_IMFByteStream(iface);
1008
1009 FIXME("%p, %p, %u, %p, %p\n", This, data, count, callback, state);
1010
1011 return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI mfbytestream_EndWrite(IMFByteStream *iface, IMFAsyncResult *result, ULONG *written)
1015 {
1016 mfbytestream *This = impl_from_IMFByteStream(iface);
1017
1018 FIXME("%p, %p, %p\n", This, result, written);
1019
1020 return E_NOTIMPL;
1021 }
1022
1023 static HRESULT WINAPI mfbytestream_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN seek, LONGLONG offset,
1024 DWORD flags, QWORD *current)
1025 {
1026 mfbytestream *This = impl_from_IMFByteStream(iface);
1027
1028 FIXME("%p, %u, %s, 0x%08x, %p\n", This, seek, wine_dbgstr_longlong(offset), flags, current);
1029
1030 return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI mfbytestream_Flush(IMFByteStream *iface)
1034 {
1035 mfbytestream *This = impl_from_IMFByteStream(iface);
1036
1037 FIXME("%p\n", This);
1038
1039 return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI mfbytestream_Close(IMFByteStream *iface)
1043 {
1044 mfbytestream *This = impl_from_IMFByteStream(iface);
1045
1046 FIXME("%p\n", This);
1047
1048 return E_NOTIMPL;
1049 }
1050
1051 static const IMFByteStreamVtbl mfbytestream_vtbl =
1052 {
1053 mfbytestream_QueryInterface,
1054 mfbytestream_AddRef,
1055 mfbytestream_Release,
1056 mfbytestream_GetCapabilities,
1057 mfbytestream_GetLength,
1058 mfbytestream_SetLength,
1059 mfbytestream_GetCurrentPosition,
1060 mfbytestream_SetCurrentPosition,
1061 mfbytestream_IsEndOfStream,
1062 mfbytestream_Read,
1063 mfbytestream_BeginRead,
1064 mfbytestream_EndRead,
1065 mfbytestream_Write,
1066 mfbytestream_BeginWrite,
1067 mfbytestream_EndWrite,
1068 mfbytestream_Seek,
1069 mfbytestream_Flush,
1070 mfbytestream_Close
1071 };
1072
1073 static inline mfbytestream *impl_from_IMFByteStream_IMFAttributes(IMFAttributes *iface)
1074 {
1075 return CONTAINING_RECORD(iface, mfbytestream, attributes.IMFAttributes_iface);
1076 }
1077
1078 static HRESULT WINAPI mfbytestream_attributes_QueryInterface(
1079 IMFAttributes *iface, REFIID riid, void **out)
1080 {
1081 mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
1082 return IMFByteStream_QueryInterface(&This->IMFByteStream_iface, riid, out);
1083 }
1084
1085 static ULONG WINAPI mfbytestream_attributes_AddRef(IMFAttributes *iface)
1086 {
1087 mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
1088 return IMFByteStream_AddRef(&This->IMFByteStream_iface);
1089 }
1090
1091 static ULONG WINAPI mfbytestream_attributes_Release(IMFAttributes *iface)
1092 {
1093 mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
1094 return IMFByteStream_Release(&This->IMFByteStream_iface);
1095 }
1096
1097 static const IMFAttributesVtbl mfbytestream_attributes_vtbl =
1098 {
1099 mfbytestream_attributes_QueryInterface,
1100 mfbytestream_attributes_AddRef,
1101 mfbytestream_attributes_Release,
1102 mfattributes_GetItem,
1103 mfattributes_GetItemType,
1104 mfattributes_CompareItem,
1105 mfattributes_Compare,
1106 mfattributes_GetUINT32,
1107 mfattributes_GetUINT64,
1108 mfattributes_GetDouble,
1109 mfattributes_GetGUID,
1110 mfattributes_GetStringLength,
1111 mfattributes_GetString,
1112 mfattributes_GetAllocatedString,
1113 mfattributes_GetBlobSize,
1114 mfattributes_GetBlob,
1115 mfattributes_GetAllocatedBlob,
1116 mfattributes_GetUnknown,
1117 mfattributes_SetItem,
1118 mfattributes_DeleteItem,
1119 mfattributes_DeleteAllItems,
1120 mfattributes_SetUINT32,
1121 mfattributes_SetUINT64,
1122 mfattributes_SetDouble,
1123 mfattributes_SetGUID,
1124 mfattributes_SetString,
1125 mfattributes_SetBlob,
1126 mfattributes_SetUnknown,
1127 mfattributes_LockStore,
1128 mfattributes_UnlockStore,
1129 mfattributes_GetCount,
1130 mfattributes_GetItemByIndex,
1131 mfattributes_CopyAllItems
1132 };
1133
1134 HRESULT WINAPI MFCreateMFByteStreamOnStream(IStream *stream, IMFByteStream **bytestream)
1135 {
1136 mfbytestream *object;
1137
1138 TRACE("(%p, %p): stub\n", stream, bytestream);
1139
1140 object = heap_alloc( sizeof(*object) );
1141 if(!object)
1142 return E_OUTOFMEMORY;
1143
1144 init_attribute_object(&object->attributes, 0);
1145 object->IMFByteStream_iface.lpVtbl = &mfbytestream_vtbl;
1146 object->attributes.IMFAttributes_iface.lpVtbl = &mfbytestream_attributes_vtbl;
1147
1148 *bytestream = &object->IMFByteStream_iface;
1149
1150 return S_OK;
1151 }
1152
1153 HRESULT WINAPI MFCreateFile(MF_FILE_ACCESSMODE accessmode, MF_FILE_OPENMODE openmode, MF_FILE_FLAGS flags,
1154 LPCWSTR url, IMFByteStream **bytestream)
1155 {
1156 mfbytestream *object;
1157 DWORD fileaccessmode = 0;
1158 DWORD filesharemode = FILE_SHARE_READ;
1159 DWORD filecreation_disposition = 0;
1160 DWORD fileattributes = 0;
1161 HANDLE file;
1162
1163 FIXME("(%d, %d, %d, %s, %p): stub\n", accessmode, openmode, flags, debugstr_w(url), bytestream);
1164
1165 switch (accessmode)
1166 {
1167 case MF_ACCESSMODE_READ:
1168 fileaccessmode = GENERIC_READ;
1169 break;
1170 case MF_ACCESSMODE_WRITE:
1171 fileaccessmode = GENERIC_WRITE;
1172 break;
1173 case MF_ACCESSMODE_READWRITE:
1174 fileaccessmode = GENERIC_READ | GENERIC_WRITE;
1175 break;
1176 }
1177
1178 switch (openmode)
1179 {
1180 case MF_OPENMODE_FAIL_IF_NOT_EXIST:
1181 filecreation_disposition = OPEN_EXISTING;
1182 break;
1183 case MF_OPENMODE_FAIL_IF_EXIST:
1184 filecreation_disposition = CREATE_NEW;
1185 break;
1186 case MF_OPENMODE_RESET_IF_EXIST:
1187 filecreation_disposition = TRUNCATE_EXISTING;
1188 break;
1189 case MF_OPENMODE_APPEND_IF_EXIST:
1190 filecreation_disposition = OPEN_ALWAYS;
1191 fileaccessmode |= FILE_APPEND_DATA;
1192 break;
1193 case MF_OPENMODE_DELETE_IF_EXIST:
1194 filecreation_disposition = CREATE_ALWAYS;
1195 break;
1196 }
1197
1198 if (flags & MF_FILEFLAGS_NOBUFFERING)
1199 fileattributes |= FILE_FLAG_NO_BUFFERING;
1200
1201 /* Open HANDLE to file */
1202 file = CreateFileW(url, fileaccessmode, filesharemode, NULL,
1203 filecreation_disposition, fileattributes, 0);
1204
1205 if(file == INVALID_HANDLE_VALUE)
1206 return HRESULT_FROM_WIN32(GetLastError());
1207
1208 /* Close the file again, since we don't do anything with it yet */
1209 CloseHandle(file);
1210
1211 object = heap_alloc( sizeof(*object) );
1212 if(!object)
1213 return E_OUTOFMEMORY;
1214
1215 init_attribute_object(&object->attributes, 0);
1216 object->IMFByteStream_iface.lpVtbl = &mfbytestream_vtbl;
1217 object->attributes.IMFAttributes_iface.lpVtbl = &mfbytestream_attributes_vtbl;
1218
1219 *bytestream = &object->IMFByteStream_iface;
1220
1221 return S_OK;
1222 }
1223
1224 static HRESULT WINAPI MFPluginControl_QueryInterface(IMFPluginControl *iface, REFIID riid, void **ppv)
1225 {
1226 if(IsEqualGUID(riid, &IID_IUnknown)) {
1227 TRACE("(IID_IUnknown %p)\n", ppv);
1228 *ppv = iface;
1229 }else if(IsEqualGUID(riid, &IID_IMFPluginControl)) {
1230 TRACE("(IID_IMFPluginControl %p)\n", ppv);
1231 *ppv = iface;
1232 }else {
1233 FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
1234 *ppv = NULL;
1235 return E_NOINTERFACE;
1236 }
1237
1238 IUnknown_AddRef((IUnknown*)*ppv);
1239 return S_OK;
1240 }
1241
1242 static ULONG WINAPI MFPluginControl_AddRef(IMFPluginControl *iface)
1243 {
1244 TRACE("\n");
1245 return 2;
1246 }
1247
1248 static ULONG WINAPI MFPluginControl_Release(IMFPluginControl *iface)
1249 {
1250 TRACE("\n");
1251 return 1;
1252 }
1253
1254 static HRESULT WINAPI MFPluginControl_GetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
1255 const WCHAR *selector, CLSID *clsid)
1256 {
1257 FIXME("(%d %s %p)\n", plugin_type, debugstr_w(selector), clsid);
1258 return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI MFPluginControl_GetPreferredClsidByIndex(IMFPluginControl *iface, DWORD plugin_type,
1262 DWORD index, WCHAR **selector, CLSID *clsid)
1263 {
1264 FIXME("(%d %d %p %p)\n", plugin_type, index, selector, clsid);
1265 return E_NOTIMPL;
1266 }
1267
1268 static HRESULT WINAPI MFPluginControl_SetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
1269 const WCHAR *selector, const CLSID *clsid)
1270 {
1271 FIXME("(%d %s %s)\n", plugin_type, debugstr_w(selector), debugstr_guid(clsid));
1272 return E_NOTIMPL;
1273 }
1274
1275 static HRESULT WINAPI MFPluginControl_IsDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid)
1276 {
1277 FIXME("(%d %s)\n", plugin_type, debugstr_guid(clsid));
1278 return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI MFPluginControl_GetDisabledByIndex(IMFPluginControl *iface, DWORD plugin_type, DWORD index, CLSID *clsid)
1282 {
1283 FIXME("(%d %d %p)\n", plugin_type, index, clsid);
1284 return E_NOTIMPL;
1285 }
1286
1287 static HRESULT WINAPI MFPluginControl_SetDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid, BOOL disabled)
1288 {
1289 FIXME("(%d %s %x)\n", plugin_type, debugstr_guid(clsid), disabled);
1290 return E_NOTIMPL;
1291 }
1292
1293 static const IMFPluginControlVtbl MFPluginControlVtbl = {
1294 MFPluginControl_QueryInterface,
1295 MFPluginControl_AddRef,
1296 MFPluginControl_Release,
1297 MFPluginControl_GetPreferredClsid,
1298 MFPluginControl_GetPreferredClsidByIndex,
1299 MFPluginControl_SetPreferredClsid,
1300 MFPluginControl_IsDisabled,
1301 MFPluginControl_GetDisabledByIndex,
1302 MFPluginControl_SetDisabled
1303 };
1304
1305 static IMFPluginControl plugin_control = { &MFPluginControlVtbl };
1306
1307 /***********************************************************************
1308 * MFGetPluginControl (mfplat.@)
1309 */
1310 HRESULT WINAPI MFGetPluginControl(IMFPluginControl **ret)
1311 {
1312 TRACE("(%p)\n", ret);
1313
1314 *ret = &plugin_control;
1315 return S_OK;
1316 }
1317
1318 typedef struct _mfsourceresolver
1319 {
1320 IMFSourceResolver IMFSourceResolver_iface;
1321 LONG ref;
1322 } mfsourceresolver;
1323
1324 static inline mfsourceresolver *impl_from_IMFSourceResolver(IMFSourceResolver *iface)
1325 {
1326 return CONTAINING_RECORD(iface, mfsourceresolver, IMFSourceResolver_iface);
1327 }
1328
1329 static HRESULT WINAPI mfsourceresolver_QueryInterface(IMFSourceResolver *iface, REFIID riid, void **obj)
1330 {
1331 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1332
1333 TRACE("(%p->(%s, %p)\n", This, debugstr_guid(riid), obj);
1334
1335 if (IsEqualIID(riid, &IID_IMFSourceResolver) ||
1336 IsEqualIID(riid, &IID_IUnknown))
1337 {
1338 *obj = &This->IMFSourceResolver_iface;
1339 }
1340 else
1341 {
1342 *obj = NULL;
1343 FIXME("unsupported interface %s\n", debugstr_guid(riid));
1344 return E_NOINTERFACE;
1345 }
1346
1347 IUnknown_AddRef((IUnknown *)*obj);
1348 return S_OK;
1349 }
1350
1351 static ULONG WINAPI mfsourceresolver_AddRef(IMFSourceResolver *iface)
1352 {
1353 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1354 ULONG ref = InterlockedIncrement(&This->ref);
1355
1356 TRACE("(%p)->(%u)\n", This, ref);
1357
1358 return ref;
1359 }
1360
1361 static ULONG WINAPI mfsourceresolver_Release(IMFSourceResolver *iface)
1362 {
1363 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1364 ULONG ref = InterlockedDecrement(&This->ref);
1365
1366 TRACE("(%p)->(%u)\n", This, ref);
1367
1368 if (!ref)
1369 HeapFree(GetProcessHeap(), 0, This);
1370
1371 return ref;
1372 }
1373
1374 static HRESULT WINAPI mfsourceresolver_CreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
1375 DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
1376 {
1377 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1378
1379 FIXME("(%p)->(%s, %#x, %p, %p, %p): stub\n", This, debugstr_w(url), flags, props, obj_type, object);
1380
1381 return E_NOTIMPL;
1382 }
1383
1384 static HRESULT WINAPI mfsourceresolver_CreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
1385 const WCHAR *url, DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
1386 {
1387 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1388
1389 FIXME("(%p)->(%p, %s, %#x, %p, %p, %p): stub\n", This, stream, debugstr_w(url), flags, props, obj_type, object);
1390
1391 return E_NOTIMPL;
1392 }
1393
1394 static HRESULT WINAPI mfsourceresolver_BeginCreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
1395 DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *unk_state)
1396 {
1397 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1398
1399 FIXME("(%p)->(%s, %#x, %p, %p, %p, %p): stub\n", This, debugstr_w(url), flags, props, cancel_cookie,
1400 callback, unk_state);
1401
1402 return E_NOTIMPL;
1403 }
1404
1405 static HRESULT WINAPI mfsourceresolver_EndCreateObjectFromURL(IMFSourceResolver *iface, IMFAsyncResult *result,
1406 MF_OBJECT_TYPE *obj_type, IUnknown **object)
1407 {
1408 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1409
1410 FIXME("(%p)->(%p, %p, %p): stub\n", This, result, obj_type, object);
1411
1412 return E_NOTIMPL;
1413 }
1414
1415 static HRESULT WINAPI mfsourceresolver_BeginCreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
1416 const WCHAR *url, DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback,
1417 IUnknown *unk_state)
1418 {
1419 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1420
1421 FIXME("(%p)->(%p, %s, %#x, %p, %p, %p, %p): stub\n", This, stream, debugstr_w(url), flags, props, cancel_cookie,
1422 callback, unk_state);
1423
1424 return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI mfsourceresolver_EndCreateObjectFromByteStream(IMFSourceResolver *iface, IMFAsyncResult *result,
1428 MF_OBJECT_TYPE *obj_type, IUnknown **object)
1429 {
1430 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1431
1432 FIXME("(%p)->(%p, %p, %p): stub\n", This, result, obj_type, object);
1433
1434 return E_NOTIMPL;
1435 }
1436
1437 static HRESULT WINAPI mfsourceresolver_CancelObjectCreation(IMFSourceResolver *iface, IUnknown *cancel_cookie)
1438 {
1439 mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1440
1441 FIXME("(%p)->(%p): stub\n", This, cancel_cookie);
1442
1443 return E_NOTIMPL;
1444 }
1445
1446 static const IMFSourceResolverVtbl mfsourceresolvervtbl =
1447 {
1448 mfsourceresolver_QueryInterface,
1449 mfsourceresolver_AddRef,
1450 mfsourceresolver_Release,
1451 mfsourceresolver_CreateObjectFromURL,
1452 mfsourceresolver_CreateObjectFromByteStream,
1453 mfsourceresolver_BeginCreateObjectFromURL,
1454 mfsourceresolver_EndCreateObjectFromURL,
1455 mfsourceresolver_BeginCreateObjectFromByteStream,
1456 mfsourceresolver_EndCreateObjectFromByteStream,
1457 mfsourceresolver_CancelObjectCreation,
1458 };
1459
1460 /***********************************************************************
1461 * MFCreateSourceResolver (mfplat.@)
1462 */
1463 HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **resolver)
1464 {
1465 mfsourceresolver *object;
1466
1467 TRACE("%p\n", resolver);
1468
1469 if (!resolver)
1470 return E_POINTER;
1471
1472 object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
1473 if (!object)
1474 return E_OUTOFMEMORY;
1475
1476 object->IMFSourceResolver_iface.lpVtbl = &mfsourceresolvervtbl;
1477 object->ref = 1;
1478
1479 *resolver = &object->IMFSourceResolver_iface;
1480 return S_OK;
1481 }
1482
1483 typedef struct _mfmediatype
1484 {
1485 mfattributes attributes;
1486 IMFMediaType IMFMediaType_iface;
1487 } mfmediatype;
1488
1489 static inline mfmediatype *impl_from_IMFMediaType(IMFMediaType *iface)
1490 {
1491 return CONTAINING_RECORD(iface, mfmediatype, IMFMediaType_iface);
1492 }
1493
1494 static HRESULT WINAPI mediatype_QueryInterface(IMFMediaType *iface, REFIID riid, void **object)
1495 {
1496 mfmediatype *This = impl_from_IMFMediaType(iface);
1497
1498 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), object);
1499
1500 if(IsEqualGUID(riid, &IID_IUnknown) ||
1501 IsEqualGUID(riid, &IID_IMFAttributes) ||
1502 IsEqualGUID(riid, &IID_IMFMediaType))
1503 {
1504 *object = &This->IMFMediaType_iface;
1505 }
1506 else
1507 {
1508 FIXME("(%s, %p)\n", debugstr_guid(riid), object);
1509 *object = NULL;
1510 return E_NOINTERFACE;
1511 }
1512
1513 IUnknown_AddRef((IUnknown*)*object);
1514 return S_OK;
1515 }
1516
1517 static ULONG WINAPI mediatype_AddRef(IMFMediaType *iface)
1518 {
1519 mfmediatype *This = impl_from_IMFMediaType(iface);
1520 ULONG ref = InterlockedIncrement(&This->attributes.ref);
1521
1522 TRACE("(%p) ref=%u\n", This, ref);
1523
1524 return ref;
1525 }
1526
1527 static ULONG WINAPI mediatype_Release(IMFMediaType *iface)
1528 {
1529 mfmediatype *This = impl_from_IMFMediaType(iface);
1530 ULONG ref = InterlockedDecrement(&This->attributes.ref);
1531
1532 TRACE("(%p) ref=%u\n", This, ref);
1533
1534 if (!ref)
1535 {
1536 HeapFree(GetProcessHeap(), 0, This);
1537 }
1538
1539 return ref;
1540 }
1541
1542 static HRESULT WINAPI mediatype_GetItem(IMFMediaType *iface, REFGUID key, PROPVARIANT *value)
1543 {
1544 mfmediatype *This = impl_from_IMFMediaType(iface);
1545 return IMFAttributes_GetItem(&This->attributes.IMFAttributes_iface, key, value);
1546 }
1547
1548 static HRESULT WINAPI mediatype_GetItemType(IMFMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1549 {
1550 mfmediatype *This = impl_from_IMFMediaType(iface);
1551 return IMFAttributes_GetItemType(&This->attributes.IMFAttributes_iface, key, type);
1552 }
1553
1554 static HRESULT WINAPI mediatype_CompareItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
1555 {
1556 mfmediatype *This = impl_from_IMFMediaType(iface);
1557 return IMFAttributes_CompareItem(&This->attributes.IMFAttributes_iface, key, value, result);
1558 }
1559
1560 static HRESULT WINAPI mediatype_Compare(IMFMediaType *iface, IMFAttributes *attrs, MF_ATTRIBUTES_MATCH_TYPE type,
1561 BOOL *result)
1562 {
1563 mfmediatype *This = impl_from_IMFMediaType(iface);
1564 return IMFAttributes_Compare(&This->attributes.IMFAttributes_iface, attrs, type, result);
1565 }
1566
1567 static HRESULT WINAPI mediatype_GetUINT32(IMFMediaType *iface, REFGUID key, UINT32 *value)
1568 {
1569 mfmediatype *This = impl_from_IMFMediaType(iface);
1570 return IMFAttributes_GetUINT32(&This->attributes.IMFAttributes_iface, key, value);
1571 }
1572
1573 static HRESULT WINAPI mediatype_GetUINT64(IMFMediaType *iface, REFGUID key, UINT64 *value)
1574 {
1575 mfmediatype *This = impl_from_IMFMediaType(iface);
1576 return IMFAttributes_GetUINT64(&This->attributes.IMFAttributes_iface, key, value);
1577 }
1578
1579 static HRESULT WINAPI mediatype_GetDouble(IMFMediaType *iface, REFGUID key, double *value)
1580 {
1581 mfmediatype *This = impl_from_IMFMediaType(iface);
1582 return IMFAttributes_GetDouble(&This->attributes.IMFAttributes_iface, key, value);
1583 }
1584
1585 static HRESULT WINAPI mediatype_GetGUID(IMFMediaType *iface, REFGUID key, GUID *value)
1586 {
1587 mfmediatype *This = impl_from_IMFMediaType(iface);
1588 return IMFAttributes_GetGUID(&This->attributes.IMFAttributes_iface, key, value);
1589 }
1590
1591 static HRESULT WINAPI mediatype_GetStringLength(IMFMediaType *iface, REFGUID key, UINT32 *length)
1592 {
1593 mfmediatype *This = impl_from_IMFMediaType(iface);
1594 return IMFAttributes_GetStringLength(&This->attributes.IMFAttributes_iface, key, length);
1595 }
1596
1597 static HRESULT WINAPI mediatype_GetString(IMFMediaType *iface, REFGUID key, WCHAR *value,
1598 UINT32 size, UINT32 *length)
1599 {
1600 mfmediatype *This = impl_from_IMFMediaType(iface);
1601 return IMFAttributes_GetString(&This->attributes.IMFAttributes_iface, key, value, size, length);
1602 }
1603
1604 static HRESULT WINAPI mediatype_GetAllocatedString(IMFMediaType *iface, REFGUID key,
1605 WCHAR **value, UINT32 *length)
1606 {
1607 mfmediatype *This = impl_from_IMFMediaType(iface);
1608 return IMFAttributes_GetAllocatedString(&This->attributes.IMFAttributes_iface, key, value, length);
1609 }
1610
1611 static HRESULT WINAPI mediatype_GetBlobSize(IMFMediaType *iface, REFGUID key, UINT32 *size)
1612 {
1613 mfmediatype *This = impl_from_IMFMediaType(iface);
1614 return IMFAttributes_GetBlobSize(&This->attributes.IMFAttributes_iface, key, size);
1615 }
1616
1617 static HRESULT WINAPI mediatype_GetBlob(IMFMediaType *iface, REFGUID key, UINT8 *buf,
1618 UINT32 bufsize, UINT32 *blobsize)
1619 {
1620 mfmediatype *This = impl_from_IMFMediaType(iface);
1621 return IMFAttributes_GetBlob(&This->attributes.IMFAttributes_iface, key, buf, bufsize, blobsize);
1622 }
1623
1624 static HRESULT WINAPI mediatype_GetAllocatedBlob(IMFMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1625 {
1626 mfmediatype *This = impl_from_IMFMediaType(iface);
1627 return IMFAttributes_GetAllocatedBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
1628 }
1629
1630 static HRESULT WINAPI mediatype_GetUnknown(IMFMediaType *iface, REFGUID key, REFIID riid, void **ppv)
1631 {
1632 mfmediatype *This = impl_from_IMFMediaType(iface);
1633 return IMFAttributes_GetUnknown(&This->attributes.IMFAttributes_iface, key, riid, ppv);
1634 }
1635
1636 static HRESULT WINAPI mediatype_SetItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value)
1637 {
1638 mfmediatype *This = impl_from_IMFMediaType(iface);
1639 return IMFAttributes_SetItem(&This->attributes.IMFAttributes_iface, key, value);
1640 }
1641
1642 static HRESULT WINAPI mediatype_DeleteItem(IMFMediaType *iface, REFGUID key)
1643 {
1644 mfmediatype *This = impl_from_IMFMediaType(iface);
1645 return IMFAttributes_DeleteItem(&This->attributes.IMFAttributes_iface, key);
1646 }
1647
1648 static HRESULT WINAPI mediatype_DeleteAllItems(IMFMediaType *iface)
1649 {
1650 mfmediatype *This = impl_from_IMFMediaType(iface);
1651 return IMFAttributes_DeleteAllItems(&This->attributes.IMFAttributes_iface);
1652 }
1653
1654 static HRESULT WINAPI mediatype_SetUINT32(IMFMediaType *iface, REFGUID key, UINT32 value)
1655 {
1656 mfmediatype *This = impl_from_IMFMediaType(iface);
1657 return IMFAttributes_SetUINT32(&This->attributes.IMFAttributes_iface, key, value);
1658 }
1659
1660 static HRESULT WINAPI mediatype_SetUINT64(IMFMediaType *iface, REFGUID key, UINT64 value)
1661 {
1662 mfmediatype *This = impl_from_IMFMediaType(iface);
1663 return IMFAttributes_SetUINT64(&This->attributes.IMFAttributes_iface, key, value);
1664 }
1665
1666 static HRESULT WINAPI mediatype_SetDouble(IMFMediaType *iface, REFGUID key, double value)
1667 {
1668 mfmediatype *This = impl_from_IMFMediaType(iface);
1669 return IMFAttributes_SetDouble(&This->attributes.IMFAttributes_iface, key, value);
1670 }
1671
1672 static HRESULT WINAPI mediatype_SetGUID(IMFMediaType *iface, REFGUID key, REFGUID value)
1673 {
1674 mfmediatype *This = impl_from_IMFMediaType(iface);
1675 return IMFAttributes_SetGUID(&This->attributes.IMFAttributes_iface, key, value);
1676 }
1677
1678 static HRESULT WINAPI mediatype_SetString(IMFMediaType *iface, REFGUID key, const WCHAR *value)
1679 {
1680 mfmediatype *This = impl_from_IMFMediaType(iface);
1681 return IMFAttributes_SetString(&This->attributes.IMFAttributes_iface, key, value);
1682 }
1683
1684 static HRESULT WINAPI mediatype_SetBlob(IMFMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1685 {
1686 mfmediatype *This = impl_from_IMFMediaType(iface);
1687 return IMFAttributes_SetBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
1688 }
1689
1690 static HRESULT WINAPI mediatype_SetUnknown(IMFMediaType *iface, REFGUID key, IUnknown *unknown)
1691 {
1692 mfmediatype *This = impl_from_IMFMediaType(iface);
1693 return IMFAttributes_SetUnknown(&This->attributes.IMFAttributes_iface, key, unknown);
1694 }
1695
1696 static HRESULT WINAPI mediatype_LockStore(IMFMediaType *iface)
1697 {
1698 mfmediatype *This = impl_from_IMFMediaType(iface);
1699 return IMFAttributes_LockStore(&This->attributes.IMFAttributes_iface);
1700 }
1701
1702 static HRESULT WINAPI mediatype_UnlockStore(IMFMediaType *iface)
1703 {
1704 mfmediatype *This = impl_from_IMFMediaType(iface);
1705 return IMFAttributes_UnlockStore(&This->attributes.IMFAttributes_iface);
1706 }
1707
1708 static HRESULT WINAPI mediatype_GetCount(IMFMediaType *iface, UINT32 *items)
1709 {
1710 mfmediatype *This = impl_from_IMFMediaType(iface);
1711 return IMFAttributes_GetCount(&This->attributes.IMFAttributes_iface, items);
1712 }
1713
1714 static HRESULT WINAPI mediatype_GetItemByIndex(IMFMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1715 {
1716 mfmediatype *This = impl_from_IMFMediaType(iface);
1717 return IMFAttributes_GetItemByIndex(&This->attributes.IMFAttributes_iface, index, key, value);
1718 }
1719
1720 static HRESULT WINAPI mediatype_CopyAllItems(IMFMediaType *iface, IMFAttributes *dest)
1721 {
1722 mfmediatype *This = impl_from_IMFMediaType(iface);
1723
1724 FIXME("%p, %p\n", This, dest);
1725
1726 return E_NOTIMPL;
1727 }
1728
1729 static HRESULT WINAPI mediatype_GetMajorType(IMFMediaType *iface, GUID *guid)
1730 {
1731 mfmediatype *This = impl_from_IMFMediaType(iface);
1732
1733 FIXME("%p, %p\n", This, guid);
1734
1735 return E_NOTIMPL;
1736 }
1737
1738 static HRESULT WINAPI mediatype_IsCompressedFormat(IMFMediaType *iface, BOOL *compressed)
1739 {
1740 mfmediatype *This = impl_from_IMFMediaType(iface);
1741
1742 FIXME("%p, %p\n", This, compressed);
1743
1744 return E_NOTIMPL;
1745 }
1746
1747 static HRESULT WINAPI mediatype_IsEqual(IMFMediaType *iface, IMFMediaType *type, DWORD *flags)
1748 {
1749 mfmediatype *This = impl_from_IMFMediaType(iface);
1750
1751 FIXME("%p, %p, %p\n", This, type, flags);
1752
1753 return E_NOTIMPL;
1754 }
1755
1756 static HRESULT WINAPI mediatype_GetRepresentation(IMFMediaType *iface, GUID guid, void **representation)
1757 {
1758 mfmediatype *This = impl_from_IMFMediaType(iface);
1759
1760 FIXME("%p, %s, %p\n", This, debugstr_guid(&guid), representation);
1761
1762 return E_NOTIMPL;
1763 }
1764
1765 static HRESULT WINAPI mediatype_FreeRepresentation(IMFMediaType *iface, GUID guid, void *representation)
1766 {
1767 mfmediatype *This = impl_from_IMFMediaType(iface);
1768
1769 FIXME("%p, %s, %p\n", This, debugstr_guid(&guid), representation);
1770
1771 return E_NOTIMPL;
1772 }
1773
1774 static const IMFMediaTypeVtbl mediatype_vtbl =
1775 {
1776 mediatype_QueryInterface,
1777 mediatype_AddRef,
1778 mediatype_Release,
1779 mediatype_GetItem,
1780 mediatype_GetItemType,
1781 mediatype_CompareItem,
1782 mediatype_Compare,
1783 mediatype_GetUINT32,
1784 mediatype_GetUINT64,
1785 mediatype_GetDouble,
1786 mediatype_GetGUID,
1787 mediatype_GetStringLength,
1788 mediatype_GetString,
1789 mediatype_GetAllocatedString,
1790 mediatype_GetBlobSize,
1791 mediatype_GetBlob,
1792 mediatype_GetAllocatedBlob,
1793 mediatype_GetUnknown,
1794 mediatype_SetItem,
1795 mediatype_DeleteItem,
1796 mediatype_DeleteAllItems,
1797 mediatype_SetUINT32,
1798 mediatype_SetUINT64,
1799 mediatype_SetDouble,
1800 mediatype_SetGUID,
1801 mediatype_SetString,
1802 mediatype_SetBlob,
1803 mediatype_SetUnknown,
1804 mediatype_LockStore,
1805 mediatype_UnlockStore,
1806 mediatype_GetCount,
1807 mediatype_GetItemByIndex,
1808 mediatype_CopyAllItems,
1809 mediatype_GetMajorType,
1810 mediatype_IsCompressedFormat,
1811 mediatype_IsEqual,
1812 mediatype_GetRepresentation,
1813 mediatype_FreeRepresentation
1814 };
1815
1816 /***********************************************************************
1817 * MFCreateMediaType (mfplat.@)
1818 */
1819 HRESULT WINAPI MFCreateMediaType(IMFMediaType **type)
1820 {
1821 mfmediatype *object;
1822
1823 TRACE("%p\n", type);
1824
1825 if(!type)
1826 return E_INVALIDARG;
1827
1828 object = heap_alloc( sizeof(*object) );
1829 if(!object)
1830 return E_OUTOFMEMORY;
1831
1832 init_attribute_object(&object->attributes, 0);
1833 object->IMFMediaType_iface.lpVtbl = &mediatype_vtbl;
1834
1835 *type = &object->IMFMediaType_iface;
1836
1837 return S_OK;
1838 }
1839
1840 typedef struct _mfeventqueue
1841 {
1842 IMFMediaEventQueue IMFMediaEventQueue_iface;
1843 LONG ref;
1844 } mfeventqueue;
1845
1846 static inline mfeventqueue *impl_from_IMFMediaEventQueue(IMFMediaEventQueue *iface)
1847 {
1848 return CONTAINING_RECORD(iface, mfeventqueue, IMFMediaEventQueue_iface);
1849 }
1850
1851 static HRESULT WINAPI mfeventqueue_QueryInterface(IMFMediaEventQueue *iface, REFIID riid, void **out)
1852 {
1853 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1854
1855 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
1856
1857 if(IsEqualGUID(riid, &IID_IUnknown) ||
1858 IsEqualGUID(riid, &IID_IMFMediaEventQueue))
1859 {
1860 *out = &This->IMFMediaEventQueue_iface;
1861 }
1862 else
1863 {
1864 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
1865 *out = NULL;
1866 return E_NOINTERFACE;
1867 }
1868
1869 IUnknown_AddRef((IUnknown*)*out);
1870 return S_OK;
1871 }
1872
1873 static ULONG WINAPI mfeventqueue_AddRef(IMFMediaEventQueue *iface)
1874 {
1875 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1876 ULONG ref = InterlockedIncrement(&This->ref);
1877
1878 TRACE("(%p) ref=%u\n", This, ref);
1879
1880 return ref;
1881 }
1882
1883 static ULONG WINAPI mfeventqueue_Release(IMFMediaEventQueue *iface)
1884 {
1885 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1886 ULONG ref = InterlockedDecrement(&This->ref);
1887
1888 TRACE("(%p) ref=%u\n", This, ref);
1889
1890 if (!ref)
1891 {
1892 HeapFree(GetProcessHeap(), 0, This);
1893 }
1894
1895 return ref;
1896 }
1897
1898 static HRESULT WINAPI mfeventqueue_GetEvent(IMFMediaEventQueue *iface, DWORD flags, IMFMediaEvent **event)
1899 {
1900 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1901
1902 FIXME("%p, %p\n", This, event);
1903
1904 return E_NOTIMPL;
1905 }
1906
1907 static HRESULT WINAPI mfeventqueue_BeginGetEvent(IMFMediaEventQueue *iface, IMFAsyncCallback *callback, IUnknown *state)
1908 {
1909 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1910
1911 FIXME("%p, %p, %p\n", This, callback, state);
1912
1913 return E_NOTIMPL;
1914 }
1915
1916 static HRESULT WINAPI mfeventqueue_EndGetEvent(IMFMediaEventQueue *iface, IMFAsyncResult *result, IMFMediaEvent **event)
1917 {
1918 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1919
1920 FIXME("%p, %p, %p\n", This, result, event);
1921
1922 return E_NOTIMPL;
1923 }
1924
1925 static HRESULT WINAPI mfeventqueue_QueueEvent(IMFMediaEventQueue *iface, IMFMediaEvent *event)
1926 {
1927 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1928
1929 FIXME("%p, %p\n", This, event);
1930
1931 return E_NOTIMPL;
1932 }
1933
1934 static HRESULT WINAPI mfeventqueue_QueueEventParamVar(IMFMediaEventQueue *iface, MediaEventType met,
1935 REFGUID type, HRESULT status, const PROPVARIANT *value)
1936 {
1937 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1938
1939 FIXME("%p, %d, %s, 0x%08x, %p\n", This, met, debugstr_guid(type), status, value);
1940
1941 return E_NOTIMPL;
1942 }
1943
1944 static HRESULT WINAPI mfeventqueue_QueueEventParamUnk(IMFMediaEventQueue *iface, MediaEventType met, REFGUID type,
1945 HRESULT status, IUnknown *unk)
1946 {
1947 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1948
1949 FIXME("%p, %d, %s, 0x%08x, %p\n", This, met, debugstr_guid(type), status, unk);
1950
1951 return E_NOTIMPL;
1952 }
1953
1954 static HRESULT WINAPI mfeventqueue_Shutdown(IMFMediaEventQueue *iface)
1955 {
1956 mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1957
1958 FIXME("%p\n", This);
1959
1960 return E_NOTIMPL;
1961 }
1962
1963 static const IMFMediaEventQueueVtbl mfeventqueue_vtbl =
1964 {
1965 mfeventqueue_QueryInterface,
1966 mfeventqueue_AddRef,
1967 mfeventqueue_Release,
1968 mfeventqueue_GetEvent,
1969 mfeventqueue_BeginGetEvent,
1970 mfeventqueue_EndGetEvent,
1971 mfeventqueue_QueueEvent,
1972 mfeventqueue_QueueEventParamVar,
1973 mfeventqueue_QueueEventParamUnk,
1974 mfeventqueue_Shutdown
1975 };
1976
1977 /***********************************************************************
1978 * MFCreateEventQueue (mfplat.@)
1979 */
1980 HRESULT WINAPI MFCreateEventQueue(IMFMediaEventQueue **queue)
1981 {
1982 mfeventqueue *object;
1983
1984 TRACE("%p\n", queue);
1985
1986 object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
1987 if(!object)
1988 return E_OUTOFMEMORY;
1989
1990 object->ref = 1;
1991 object->IMFMediaEventQueue_iface.lpVtbl = &mfeventqueue_vtbl;
1992
1993 *queue = &object->IMFMediaEventQueue_iface;
1994
1995 return S_OK;
1996 }
1997
1998 typedef struct _mfdescriptor
1999 {
2000 mfattributes attributes;
2001 IMFStreamDescriptor IMFStreamDescriptor_iface;
2002 } mfdescriptor;
2003
2004 static inline mfdescriptor *impl_from_IMFStreamDescriptor(IMFStreamDescriptor *iface)
2005 {
2006 return CONTAINING_RECORD(iface, mfdescriptor, IMFStreamDescriptor_iface);
2007 }
2008
2009 static HRESULT WINAPI mfdescriptor_QueryInterface(IMFStreamDescriptor *iface, REFIID riid, void **out)
2010 {
2011 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2012
2013 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
2014
2015 if(IsEqualGUID(riid, &IID_IUnknown) ||
2016 IsEqualGUID(riid, &IID_IMFAttributes) ||
2017 IsEqualGUID(riid, &IID_IMFStreamDescriptor))
2018 {
2019 *out = &This->IMFStreamDescriptor_iface;
2020 }
2021 else
2022 {
2023 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
2024 *out = NULL;
2025 return E_NOINTERFACE;
2026 }
2027
2028 IUnknown_AddRef((IUnknown*)*out);
2029 return S_OK;
2030 }
2031
2032 static ULONG WINAPI mfdescriptor_AddRef(IMFStreamDescriptor *iface)
2033 {
2034 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2035 ULONG ref = InterlockedIncrement(&This->attributes.ref);
2036
2037 TRACE("(%p) ref=%u\n", This, ref);
2038
2039 return ref;
2040 }
2041
2042 static ULONG WINAPI mfdescriptor_Release(IMFStreamDescriptor *iface)
2043 {
2044 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2045 ULONG ref = InterlockedDecrement(&This->attributes.ref);
2046
2047 TRACE("(%p) ref=%u\n", This, ref);
2048
2049 if (!ref)
2050 {
2051 heap_free(This);
2052 }
2053
2054 return ref;
2055 }
2056
2057 static HRESULT WINAPI mfdescriptor_GetItem(IMFStreamDescriptor *iface, REFGUID key, PROPVARIANT *value)
2058 {
2059 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2060 return IMFAttributes_GetItem(&This->attributes.IMFAttributes_iface, key, value);
2061 }
2062
2063 static HRESULT WINAPI mfdescriptor_GetItemType(IMFStreamDescriptor *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2064 {
2065 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2066 return IMFAttributes_GetItemType(&This->attributes.IMFAttributes_iface, key, type);
2067 }
2068
2069 static HRESULT WINAPI mfdescriptor_CompareItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
2070 {
2071 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2072 return IMFAttributes_CompareItem(&This->attributes.IMFAttributes_iface, key, value, result);
2073 }
2074
2075 static HRESULT WINAPI mfdescriptor_Compare(IMFStreamDescriptor *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
2076 BOOL *result)
2077 {
2078 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2079 return IMFAttributes_Compare(&This->attributes.IMFAttributes_iface, theirs, type, result);
2080 }
2081
2082 static HRESULT WINAPI mfdescriptor_GetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 *value)
2083 {
2084 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2085 return IMFAttributes_GetUINT32(&This->attributes.IMFAttributes_iface, key, value);
2086 }
2087
2088 static HRESULT WINAPI mfdescriptor_GetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 *value)
2089 {
2090 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2091 return IMFAttributes_GetUINT64(&This->attributes.IMFAttributes_iface, key, value);
2092 }
2093
2094 static HRESULT WINAPI mfdescriptor_GetDouble(IMFStreamDescriptor *iface, REFGUID key, double *value)
2095 {
2096 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2097 return IMFAttributes_GetDouble(&This->attributes.IMFAttributes_iface, key, value);
2098 }
2099
2100 static HRESULT WINAPI mfdescriptor_GetGUID(IMFStreamDescriptor *iface, REFGUID key, GUID *value)
2101 {
2102 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2103 return IMFAttributes_GetGUID(&This->attributes.IMFAttributes_iface, key, value);
2104 }
2105
2106 static HRESULT WINAPI mfdescriptor_GetStringLength(IMFStreamDescriptor *iface, REFGUID key, UINT32 *length)
2107 {
2108 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2109 return IMFAttributes_GetStringLength(&This->attributes.IMFAttributes_iface, key, length);
2110 }
2111
2112 static HRESULT WINAPI mfdescriptor_GetString(IMFStreamDescriptor *iface, REFGUID key, WCHAR *value,
2113 UINT32 size, UINT32 *length)
2114 {
2115 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2116 return IMFAttributes_GetString(&This->attributes.IMFAttributes_iface, key, value, size, length);
2117 }
2118
2119 static HRESULT WINAPI mfdescriptor_GetAllocatedString(IMFStreamDescriptor *iface, REFGUID key,
2120 WCHAR **value, UINT32 *length)
2121 {
2122 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2123 return IMFAttributes_GetAllocatedString(&This->attributes.IMFAttributes_iface, key, value, length);
2124 }
2125
2126 static HRESULT WINAPI mfdescriptor_GetBlobSize(IMFStreamDescriptor *iface, REFGUID key, UINT32 *size)
2127 {
2128 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2129 return IMFAttributes_GetBlobSize(&This->attributes.IMFAttributes_iface, key, size);
2130 }
2131
2132 static HRESULT WINAPI mfdescriptor_GetBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 *buf,
2133 UINT32 bufsize, UINT32 *blobsize)
2134 {
2135 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2136 return IMFAttributes_GetBlob(&This->attributes.IMFAttributes_iface, key, buf, bufsize, blobsize);
2137 }
2138
2139 static HRESULT WINAPI mfdescriptor_GetAllocatedBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 **buf, UINT32 *size)
2140 {
2141 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2142 return IMFAttributes_GetAllocatedBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
2143 }
2144
2145 static HRESULT WINAPI mfdescriptor_GetUnknown(IMFStreamDescriptor *iface, REFGUID key, REFIID riid, void **ppv)
2146 {
2147 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2148 return IMFAttributes_GetUnknown(&This->attributes.IMFAttributes_iface, key, riid, ppv);
2149 }
2150
2151 static HRESULT WINAPI mfdescriptor_SetItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value)
2152 {
2153 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2154 return IMFAttributes_SetItem(&This->attributes.IMFAttributes_iface, key, value);
2155 }
2156
2157 static HRESULT WINAPI mfdescriptor_DeleteItem(IMFStreamDescriptor *iface, REFGUID key)
2158 {
2159 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2160 return IMFAttributes_DeleteItem(&This->attributes.IMFAttributes_iface, key);
2161 }
2162
2163 static HRESULT WINAPI mfdescriptor_DeleteAllItems(IMFStreamDescriptor *iface)
2164 {
2165 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2166 return IMFAttributes_DeleteAllItems(&This->attributes.IMFAttributes_iface);
2167 }
2168
2169 static HRESULT WINAPI mfdescriptor_SetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 value)
2170 {
2171 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2172 return IMFAttributes_SetUINT32(&This->attributes.IMFAttributes_iface, key, value);
2173 }
2174
2175 static HRESULT WINAPI mfdescriptor_SetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 value)
2176 {
2177 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2178 return IMFAttributes_SetUINT64(&This->attributes.IMFAttributes_iface, key, value);
2179 }
2180
2181 static HRESULT WINAPI mfdescriptor_SetDouble(IMFStreamDescriptor *iface, REFGUID key, double value)
2182 {
2183 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2184 return IMFAttributes_SetDouble(&This->attributes.IMFAttributes_iface, key, value);
2185 }
2186
2187 static HRESULT WINAPI mfdescriptor_SetGUID(IMFStreamDescriptor *iface, REFGUID key, REFGUID value)
2188 {
2189 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2190 return IMFAttributes_SetGUID(&This->attributes.IMFAttributes_iface, key, value);
2191 }
2192
2193 static HRESULT WINAPI mfdescriptor_SetString(IMFStreamDescriptor *iface, REFGUID key, const WCHAR *value)
2194 {
2195 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2196 return IMFAttributes_SetString(&This->attributes.IMFAttributes_iface, key, value);
2197 }
2198
2199 static HRESULT WINAPI mfdescriptor_SetBlob(IMFStreamDescriptor *iface, REFGUID key, const UINT8 *buf, UINT32 size)
2200 {
2201 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2202 return IMFAttributes_SetBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
2203 }
2204
2205 static HRESULT WINAPI mfdescriptor_SetUnknown(IMFStreamDescriptor *iface, REFGUID key, IUnknown *unknown)
2206 {
2207 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2208 return IMFAttributes_SetUnknown(&This->attributes.IMFAttributes_iface, key, unknown);
2209 }
2210
2211 static HRESULT WINAPI mfdescriptor_LockStore(IMFStreamDescriptor *iface)
2212 {
2213 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2214 return IMFAttributes_LockStore(&This->attributes.IMFAttributes_iface);
2215 }
2216
2217 static HRESULT WINAPI mfdescriptor_UnlockStore(IMFStreamDescriptor *iface)
2218 {
2219 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2220 return IMFAttributes_UnlockStore(&This->attributes.IMFAttributes_iface);
2221 }
2222
2223 static HRESULT WINAPI mfdescriptor_GetCount(IMFStreamDescriptor *iface, UINT32 *items)
2224 {
2225 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2226 return IMFAttributes_GetCount(&This->attributes.IMFAttributes_iface, items);
2227 }
2228
2229 static HRESULT WINAPI mfdescriptor_GetItemByIndex(IMFStreamDescriptor *iface, UINT32 index, GUID *key, PROPVARIANT *value)
2230 {
2231 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2232 return IMFAttributes_GetItemByIndex(&This->attributes.IMFAttributes_iface, index, key, value);
2233 }
2234
2235 static HRESULT WINAPI mfdescriptor_CopyAllItems(IMFStreamDescriptor *iface, IMFAttributes *dest)
2236 {
2237 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2238
2239 FIXME("%p, %p\n", This, dest);
2240
2241 return E_NOTIMPL;
2242 }
2243
2244 static HRESULT WINAPI mfdescriptor_GetStreamIdentifier(IMFStreamDescriptor *iface, DWORD *identifier)
2245 {
2246 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2247
2248 FIXME("%p, %p\n", This, identifier);
2249
2250 return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI mfdescriptor_GetMediaTypeHandler(IMFStreamDescriptor *iface, IMFMediaTypeHandler **handler)
2254 {
2255 mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2256
2257 FIXME("%p, %p\n", This, handler);
2258
2259 return E_NOTIMPL;
2260 }
2261
2262 static const IMFStreamDescriptorVtbl mfdescriptor_vtbl =
2263 {
2264 mfdescriptor_QueryInterface,
2265 mfdescriptor_AddRef,
2266 mfdescriptor_Release,
2267 mfdescriptor_GetItem,
2268 mfdescriptor_GetItemType,
2269 mfdescriptor_CompareItem,
2270 mfdescriptor_Compare,
2271 mfdescriptor_GetUINT32,
2272 mfdescriptor_GetUINT64,
2273 mfdescriptor_GetDouble,
2274 mfdescriptor_GetGUID,
2275 mfdescriptor_GetStringLength,
2276 mfdescriptor_GetString,
2277 mfdescriptor_GetAllocatedString,
2278 mfdescriptor_GetBlobSize,
2279 mfdescriptor_GetBlob,
2280 mfdescriptor_GetAllocatedBlob,
2281 mfdescriptor_GetUnknown,
2282 mfdescriptor_SetItem,
2283 mfdescriptor_DeleteItem,
2284 mfdescriptor_DeleteAllItems,
2285 mfdescriptor_SetUINT32,
2286 mfdescriptor_SetUINT64,
2287 mfdescriptor_SetDouble,
2288 mfdescriptor_SetGUID,
2289 mfdescriptor_SetString,
2290 mfdescriptor_SetBlob,
2291 mfdescriptor_SetUnknown,
2292 mfdescriptor_LockStore,
2293 mfdescriptor_UnlockStore,
2294 mfdescriptor_GetCount,
2295 mfdescriptor_GetItemByIndex,
2296 mfdescriptor_CopyAllItems,
2297 mfdescriptor_GetStreamIdentifier,
2298 mfdescriptor_GetMediaTypeHandler
2299 };
2300
2301 HRESULT WINAPI MFCreateStreamDescriptor(DWORD identifier, DWORD count,
2302 IMFMediaType **types, IMFStreamDescriptor **descriptor)
2303 {
2304 mfdescriptor *object;
2305
2306 TRACE("%d, %d, %p, %p\n", identifier, count, types, descriptor);
2307
2308 object = heap_alloc(sizeof(*object));
2309 if(!object)
2310 return E_OUTOFMEMORY;
2311
2312 init_attribute_object(&object->attributes, 0);
2313 object->IMFStreamDescriptor_iface.lpVtbl = &mfdescriptor_vtbl;
2314 *descriptor = &object->IMFStreamDescriptor_iface;
2315
2316 return S_OK;
2317 }
2318
2319
2320 typedef struct _mfbuffer
2321 {
2322 IMFMediaBuffer IMFMediaBuffer_iface;
2323 LONG ref;
2324
2325 BYTE *buffer;
2326 DWORD max_length;
2327 DWORD current;
2328 } mfbuffer;
2329
2330 static inline mfbuffer *impl_from_IMFMediaBuffer(IMFMediaBuffer *iface)
2331 {
2332 return CONTAINING_RECORD(iface, mfbuffer, IMFMediaBuffer_iface);
2333 }
2334
2335 static HRESULT WINAPI mfbuffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **out)
2336 {
2337 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2338
2339 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
2340
2341 if(IsEqualGUID(riid, &IID_IUnknown) ||
2342 IsEqualGUID(riid, &IID_IMFMediaBuffer))
2343 {
2344 *out = &This->IMFMediaBuffer_iface;
2345 }
2346 else
2347 {
2348 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
2349 *out = NULL;
2350 return E_NOINTERFACE;
2351 }
2352
2353 IUnknown_AddRef((IUnknown*)*out);
2354 return S_OK;
2355 }
2356
2357 static ULONG WINAPI mfbuffer_AddRef(IMFMediaBuffer *iface)
2358 {
2359 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2360 ULONG ref = InterlockedIncrement(&This->ref);
2361
2362 TRACE("(%p) ref=%u\n", This, ref);
2363
2364 return ref;
2365 }
2366
2367 static ULONG WINAPI mfbuffer_Release(IMFMediaBuffer *iface)
2368 {
2369 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2370 ULONG ref = InterlockedDecrement(&This->ref);
2371
2372 TRACE("(%p) ref=%u\n", This, ref);
2373
2374 if (!ref)
2375 {
2376 heap_free(This->buffer);
2377 heap_free(This);
2378 }
2379
2380 return ref;
2381 }
2382
2383 static HRESULT WINAPI mfbuffer_Lock(IMFMediaBuffer *iface, BYTE **buffer, DWORD *max, DWORD *current)
2384 {
2385 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2386
2387 TRACE("%p, %p %p, %p\n", This, buffer, max, current);
2388
2389 if(!buffer)
2390 return E_INVALIDARG;
2391
2392 *buffer = This->buffer;
2393 if(max)
2394 *max = This->max_length;
2395 if(current)
2396 *current = This->current;
2397
2398 return S_OK;
2399 }
2400
2401 static HRESULT WINAPI mfbuffer_Unlock(IMFMediaBuffer *iface)
2402 {
2403 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2404
2405 TRACE("%p\n", This);
2406
2407 return S_OK;
2408 }
2409
2410 static HRESULT WINAPI mfbuffer_GetCurrentLength(IMFMediaBuffer *iface, DWORD *current)
2411 {
2412 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2413
2414 TRACE("%p\n", This);
2415
2416 if(!current)
2417 return E_INVALIDARG;
2418
2419 *current = This->current;
2420
2421 return S_OK;
2422 }
2423
2424 static HRESULT WINAPI mfbuffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD current)
2425 {
2426 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2427
2428 TRACE("%p, %u\n", This, current);
2429
2430 if(current > This->max_length)
2431 return E_INVALIDARG;
2432
2433 This->current = current;
2434
2435 return S_OK;
2436 }
2437
2438 static HRESULT WINAPI mfbuffer_GetMaxLength(IMFMediaBuffer *iface, DWORD *max)
2439 {
2440 mfbuffer *This = impl_from_IMFMediaBuffer(iface);
2441
2442 TRACE("%p, %p\n", This, max);
2443
2444 if(!max)
2445 return E_INVALIDARG;
2446
2447 *max = This->max_length;
2448
2449 return S_OK;
2450 }
2451
2452 static const IMFMediaBufferVtbl mfbuffer_vtbl =
2453 {
2454 mfbuffer_QueryInterface,
2455 mfbuffer_AddRef,
2456 mfbuffer_Release,
2457 mfbuffer_Lock,
2458 mfbuffer_Unlock,
2459 mfbuffer_GetCurrentLength,
2460 mfbuffer_SetCurrentLength,
2461 mfbuffer_GetMaxLength
2462 };
2463
2464 HRESULT WINAPI MFCreateMemoryBuffer(DWORD max_length, IMFMediaBuffer **buffer)
2465 {
2466 mfbuffer *object;
2467 BYTE *bytes;
2468
2469 TRACE("%u, %p\n", max_length, buffer);
2470
2471 if(!buffer)
2472 return E_INVALIDARG;
2473
2474 object = heap_alloc( sizeof(*object) );
2475 if(!object)
2476 return E_OUTOFMEMORY;
2477
2478 bytes = heap_alloc( max_length );
2479 if(!bytes)
2480 {
2481 heap_free(object);
2482 return E_OUTOFMEMORY;
2483 }
2484
2485 object->ref = 1;
2486 object->max_length = max_length;
2487 object->current = 0;
2488 object->buffer = bytes;
2489 object->IMFMediaBuffer_iface.lpVtbl = &mfbuffer_vtbl;
2490 *buffer = &object->IMFMediaBuffer_iface;
2491
2492 return S_OK;
2493 }
2494
2495 typedef struct _mfsample
2496 {
2497 mfattributes attributes;
2498 IMFSample IMFSample_iface;
2499 } mfsample;
2500
2501 static inline mfsample *impl_from_IMFSample(IMFSample *iface)
2502 {
2503 return CONTAINING_RECORD(iface, mfsample, IMFSample_iface);
2504 }
2505
2506 static HRESULT WINAPI mfsample_QueryInterface(IMFSample *iface, REFIID riid, void **out)
2507 {
2508 mfsample *This = impl_from_IMFSample(iface);
2509
2510 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
2511
2512 if(IsEqualGUID(riid, &IID_IUnknown) ||
2513 IsEqualGUID(riid, &IID_IMFAttributes) ||
2514 IsEqualGUID(riid, &IID_IMFSample))
2515 {
2516 *out = &This->IMFSample_iface;
2517 }
2518 else
2519 {
2520 FIXME("(%s, %p)\n", debugstr_guid(riid), out);
2521 *out = NULL;
2522 return E_NOINTERFACE;
2523 }
2524
2525 IUnknown_AddRef((IUnknown*)*out);
2526 return S_OK;
2527 }
2528
2529 static ULONG WINAPI mfsample_AddRef(IMFSample *iface)
2530 {
2531 mfsample *This = impl_from_IMFSample(iface);
2532 ULONG ref = InterlockedIncrement(&This->attributes.ref);
2533
2534 TRACE("(%p) ref=%u\n", This, ref);
2535
2536 return ref;
2537 }
2538
2539 static ULONG WINAPI mfsample_Release(IMFSample *iface)
2540 {
2541 mfsample *This = impl_from_IMFSample(iface);
2542 ULONG ref = InterlockedDecrement(&This->attributes.ref);
2543
2544 TRACE("(%p) ref=%u\n", This, ref);
2545
2546 if (!ref)
2547 {
2548 heap_free(This);
2549 }
2550
2551 return ref;
2552 }
2553
2554 static HRESULT WINAPI mfsample_GetItem(IMFSample *iface, REFGUID key, PROPVARIANT *value)
2555 {
2556 mfsample *This = impl_from_IMFSample(iface);
2557 return IMFAttributes_GetItem(&This->attributes.IMFAttributes_iface, key, value);
2558 }
2559
2560 static HRESULT WINAPI mfsample_GetItemType(IMFSample *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2561 {
2562 mfsample *This = impl_from_IMFSample(iface);
2563 return IMFAttributes_GetItemType(&This->attributes.IMFAttributes_iface, key, type);
2564 }
2565
2566 static HRESULT WINAPI mfsample_CompareItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
2567 {
2568 mfsample *This = impl_from_IMFSample(iface);
2569 return IMFAttributes_CompareItem(&This->attributes.IMFAttributes_iface, key, value, result);
2570 }
2571
2572 static HRESULT WINAPI mfsample_Compare(IMFSample *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
2573 BOOL *result)
2574 {
2575 mfsample *This = impl_from_IMFSample(iface);
2576 return IMFAttributes_Compare(&This->attributes.IMFAttributes_iface, theirs, type, result);
2577 }
2578
2579 static HRESULT WINAPI mfsample_GetUINT32(IMFSample *iface, REFGUID key, UINT32 *value)
2580 {
2581 mfsample *This = impl_from_IMFSample(iface);
2582 return IMFAttributes_GetUINT32(&This->attributes.IMFAttributes_iface, key, value);
2583 }
2584
2585 static HRESULT WINAPI mfsample_GetUINT64(IMFSample *iface, REFGUID key, UINT64 *value)
2586 {
2587 mfsample *This = impl_from_IMFSample(iface);
2588 return IMFAttributes_GetUINT64(&This->attributes.IMFAttributes_iface, key, value);
2589 }
2590
2591 static HRESULT WINAPI mfsample_GetDouble(IMFSample *iface, REFGUID key, double *value)
2592 {
2593 mfsample *This = impl_from_IMFSample(iface);
2594 return IMFAttributes_GetDouble(&This->attributes.IMFAttributes_iface, key, value);
2595 }
2596
2597 static HRESULT WINAPI mfsample_GetGUID(IMFSample *iface, REFGUID key, GUID *value)
2598 {
2599 mfsample *This = impl_from_IMFSample(iface);
2600 return IMFAttributes_GetGUID(&This->attributes.IMFAttributes_iface, key, value);
2601 }
2602
2603 static HRESULT WINAPI mfsample_GetStringLength(IMFSample *iface, REFGUID key, UINT32 *length)
2604 {
2605 mfsample *This = impl_from_IMFSample(iface);
2606 return IMFAttributes_GetStringLength(&This->attributes.IMFAttributes_iface, key, length);
2607 }
2608
2609 static HRESULT WINAPI mfsample_GetString(IMFSample *iface, REFGUID key, WCHAR *value,
2610 UINT32 size, UINT32 *length)
2611 {
2612 mfsample *This = impl_from_IMFSample(iface);
2613 return IMFAttributes_GetString(&This->attributes.IMFAttributes_iface, key, value, size, length);
2614 }
2615
2616 static HRESULT WINAPI mfsample_GetAllocatedString(IMFSample *iface, REFGUID key,
2617 WCHAR **value, UINT32 *length)
2618 {
2619 mfsample *This = impl_from_IMFSample(iface);
2620 return IMFAttributes_GetAllocatedString(&This->attributes.IMFAttributes_iface, key, value, length);
2621 }
2622
2623 static HRESULT WINAPI mfsample_GetBlobSize(IMFSample *iface, REFGUID key, UINT32 *size)
2624 {
2625 mfsample *This = impl_from_IMFSample(iface);
2626 return IMFAttributes_GetBlobSize(&This->attributes.IMFAttributes_iface, key, size);
2627 }
2628
2629 static HRESULT WINAPI mfsample_GetBlob(IMFSample *iface, REFGUID key, UINT8 *buf,
2630 UINT32 bufsize, UINT32 *blobsize)
2631 {
2632 mfsample *This = impl_from_IMFSample(iface);
2633 return IMFAttributes_GetBlob(&This->attributes.IMFAttributes_iface, key, buf, bufsize, blobsize);
2634 }
2635
2636 static HRESULT WINAPI mfsample_GetAllocatedBlob(IMFSample *iface, REFGUID key, UINT8 **buf, UINT32 *size)
2637 {
2638 mfsample *This = impl_from_IMFSample(iface);
2639 return IMFAttributes_GetAllocatedBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
2640 }
2641
2642 static HRESULT WINAPI mfsample_GetUnknown(IMFSample *iface, REFGUID key, REFIID riid, void **ppv)
2643 {
2644 mfsample *This = impl_from_IMFSample(iface);
2645 return IMFAttributes_GetUnknown(&This->attributes.IMFAttributes_iface, key, riid, ppv);
2646 }
2647
2648 static HRESULT WINAPI mfsample_SetItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value)
2649 {
2650 mfsample *This = impl_from_IMFSample(iface);
2651 return IMFAttributes_SetItem(&This->attributes.IMFAttributes_iface, key, value);
2652 }
2653
2654 static HRESULT WINAPI mfsample_DeleteItem(IMFSample *iface, REFGUID key)
2655 {
2656 mfsample *This = impl_from_IMFSample(iface);
2657 return IMFAttributes_DeleteItem(&This->attributes.IMFAttributes_iface, key);
2658 }
2659
2660 static HRESULT WINAPI mfsample_DeleteAllItems(IMFSample *iface)
2661 {
2662 mfsample *This = impl_from_IMFSample(iface);
2663 return IMFAttributes_DeleteAllItems(&This->attributes.IMFAttributes_iface);
2664 }
2665
2666 static HRESULT WINAPI mfsample_SetUINT32(IMFSample *iface, REFGUID key, UINT32 value)
2667 {
2668 mfsample *This = impl_from_IMFSample(iface);
2669 return IMFAttributes_SetUINT32(&This->attributes.IMFAttributes_iface, key, value);
2670 }
2671
2672 static HRESULT WINAPI mfsample_SetUINT64(IMFSample *iface, REFGUID key, UINT64 value)
2673 {
2674 mfsample *This = impl_from_IMFSample(iface);
2675 return IMFAttributes_SetUINT64(&This->attributes.IMFAttributes_iface, key, value);
2676 }
2677
2678 static HRESULT WINAPI mfsample_SetDouble(IMFSample *iface, REFGUID key, double value)
2679 {
2680 mfsample *This = impl_from_IMFSample(iface);
2681 return IMFAttributes_SetDouble(&This->attributes.IMFAttributes_iface, key, value);
2682 }
2683
2684 static HRESULT WINAPI mfsample_SetGUID(IMFSample *iface, REFGUID key, REFGUID value)
2685 {
2686 mfsample *This = impl_from_IMFSample(iface);
2687 return IMFAttributes_SetGUID(&This->attributes.IMFAttributes_iface, key, value);
2688 }
2689
2690 static HRESULT WINAPI mfsample_SetString(IMFSample *iface, REFGUID key, const WCHAR *value)
2691 {
2692 mfsample *This = impl_from_IMFSample(iface);
2693 return IMFAttributes_SetString(&This->attributes.IMFAttributes_iface, key, value);
2694 }
2695
2696 static HRESULT WINAPI mfsample_SetBlob(IMFSample *iface, REFGUID key, const UINT8 *buf, UINT32 size)
2697 {
2698 mfsample *This = impl_from_IMFSample(iface);
2699 return IMFAttributes_SetBlob(&This->attributes.IMFAttributes_iface, key, buf, size);
2700 }
2701
2702 static HRESULT WINAPI mfsample_SetUnknown(IMFSample *iface, REFGUID key, IUnknown *unknown)
2703 {
2704 mfsample *This = impl_from_IMFSample(iface);
2705 return IMFAttributes_SetUnknown(&This->attributes.IMFAttributes_iface, key, unknown);
2706 }
2707
2708 static HRESULT WINAPI mfsample_LockStore(IMFSample *iface)
2709 {
2710 mfsample *This = impl_from_IMFSample(iface);
2711 return IMFAttributes_LockStore(&This->attributes.IMFAttributes_iface);
2712 }
2713
2714 static HRESULT WINAPI mfsample_UnlockStore(IMFSample *iface)
2715 {
2716 mfsample *This = impl_from_IMFSample(iface);
2717 return IMFAttributes_UnlockStore(&This->attributes.IMFAttributes_iface);
2718 }
2719
2720 static HRESULT WINAPI mfsample_GetCount(IMFSample *iface, UINT32 *items)
2721 {
2722 mfsample *This = impl_from_IMFSample(iface);
2723 return IMFAttributes_GetCount(&This->attributes.IMFAttributes_iface, items);
2724 }
2725
2726 static HRESULT WINAPI mfsample_GetItemByIndex(IMFSample *iface, UINT32 index, GUID *key, PROPVARIANT *value)
2727 {
2728 mfsample *This = impl_from_IMFSample(iface);
2729 return IMFAttributes_GetItemByIndex(&This->attributes.IMFAttributes_iface, index, key, value);
2730 }
2731
2732 static HRESULT WINAPI mfsample_CopyAllItems(IMFSample *iface, IMFAttributes *dest)
2733 {
2734 mfsample *This = impl_from_IMFSample(iface);
2735
2736 FIXME("%p, %p\n", This, dest);
2737
2738 return E_NOTIMPL;
2739 }
2740
2741 static HRESULT WINAPI mfsample_GetSampleFlags(IMFSample *iface, DWORD *flags)
2742 {
2743 mfsample *This = impl_from_IMFSample(iface);
2744
2745 FIXME("%p, %p\n", This, flags);
2746
2747 return E_NOTIMPL;
2748 }
2749
2750 static HRESULT WINAPI mfsample_SetSampleFlags(IMFSample *iface, DWORD flags)
2751 {
2752 mfsample *This = impl_from_IMFSample(iface);
2753
2754 FIXME("%p, %x\n", This, flags);
2755
2756 return E_NOTIMPL;
2757 }
2758
2759 static HRESULT WINAPI mfsample_GetSampleTime(IMFSample *iface, LONGLONG *sampletime)
2760 {
2761 mfsample *This = impl_from_IMFSample(iface);
2762
2763 FIXME("%p, %p\n", This, sampletime);
2764
2765 return E_NOTIMPL;
2766 }
2767
2768 static HRESULT WINAPI mfsample_SetSampleTime(IMFSample *iface, LONGLONG sampletime)
2769 {
2770 mfsample *This = impl_from_IMFSample(iface);
2771
2772 FIXME("%p, %s\n", This, wine_dbgstr_longlong(sampletime));
2773
2774 return E_NOTIMPL;
2775 }
2776
2777 static HRESULT WINAPI mfsample_GetSampleDuration(IMFSample *iface, LONGLONG *duration)
2778 {
2779 mfsample *This = impl_from_IMFSample(iface);
2780
2781 FIXME("%p, %p\n", This, duration);
2782
2783 return E_NOTIMPL;
2784 }
2785
2786 static HRESULT WINAPI mfsample_SetSampleDuration(IMFSample *iface, LONGLONG duration)
2787 {
2788 mfsample *This = impl_from_IMFSample(iface);
2789
2790 FIXME("%p, %s\n", This, wine_dbgstr_longlong(duration));
2791
2792 return E_NOTIMPL;
2793 }
2794
2795 static HRESULT WINAPI mfsample_GetBufferCount(IMFSample *iface, DWORD *count)
2796 {
2797 mfsample *This = impl_from_IMFSample(iface);
2798
2799 FIXME("%p, %p\n", This, count);
2800
2801 if(*count)
2802 *count = 0;
2803
2804 return S_OK;
2805 }
2806
2807 static HRESULT WINAPI mfsample_GetBufferByIndex(IMFSample *iface, DWORD index, IMFMediaBuffer **buffer)
2808 {
2809 mfsample *This = impl_from_IMFSample(iface);
2810
2811 FIXME("%p, %u, %p\n", This, index, buffer);
2812
2813 return E_NOTIMPL;
2814 }
2815
2816 static HRESULT WINAPI mfsample_ConvertToContiguousBuffer(IMFSample *iface, IMFMediaBuffer **buffer)
2817 {
2818 mfsample *This = impl_from_IMFSample(iface);
2819
2820 FIXME("%p, %p\n", This, buffer);
2821
2822 return E_NOTIMPL;
2823 }
2824
2825 static HRESULT WINAPI mfsample_AddBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
2826 {
2827 mfsample *This = impl_from_IMFSample(iface);
2828
2829 FIXME("%p, %p\n", This, buffer);
2830
2831 return E_NOTIMPL;
2832 }
2833
2834 static HRESULT WINAPI mfsample_RemoveBufferByIndex(IMFSample *iface, DWORD index)
2835 {
2836 mfsample *This = impl_from_IMFSample(iface);
2837
2838 FIXME("%p, %u\n", This, index);
2839
2840 return E_NOTIMPL;
2841 }
2842
2843 static HRESULT WINAPI mfsample_RemoveAllBuffers(IMFSample *iface)
2844 {
2845 mfsample *This = impl_from_IMFSample(iface);
2846
2847 FIXME("%p\n", This);
2848
2849 return E_NOTIMPL;
2850 }
2851
2852 static HRESULT WINAPI mfsample_GetTotalLength(IMFSample *iface, DWORD *length)
2853 {
2854 mfsample *This = impl_from_IMFSample(iface);
2855
2856 FIXME("%p, %p\n", This, length);
2857
2858 return E_NOTIMPL;
2859 }
2860
2861 static HRESULT WINAPI mfsample_CopyToBuffer(IMFSample *iface, IMFMediaBuffer *buffer)
2862 {
2863 mfsample *This = impl_from_IMFSample(iface);
2864
2865 FIXME("%p, %p\n", This, buffer);
2866
2867 return E_NOTIMPL;
2868 }
2869
2870 static const IMFSampleVtbl mfsample_vtbl =
2871 {
2872 mfsample_QueryInterface,
2873 mfsample_AddRef,
2874 mfsample_Release,
2875 mfsample_GetItem,
2876 mfsample_GetItemType,
2877 mfsample_CompareItem,
2878 mfsample_Compare,
2879 mfsample_GetUINT32,
2880 mfsample_GetUINT64,
2881 mfsample_GetDouble,
2882 mfsample_GetGUID,
2883 mfsample_GetStringLength,
2884 mfsample_GetString,
2885 mfsample_GetAllocatedString,
2886 mfsample_GetBlobSize,
2887 mfsample_GetBlob,
2888 mfsample_GetAllocatedBlob,
2889 mfsample_GetUnknown,
2890 mfsample_SetItem,
2891 mfsample_DeleteItem,
2892 mfsample_DeleteAllItems,
2893 mfsample_SetUINT32,
2894 mfsample_SetUINT64,
2895 mfsample_SetDouble,
2896 mfsample_SetGUID,
2897 mfsample_SetString,
2898 mfsample_SetBlob,
2899 mfsample_SetUnknown,
2900 mfsample_LockStore,
2901 mfsample_UnlockStore,
2902 mfsample_GetCount,
2903 mfsample_GetItemByIndex,
2904 mfsample_CopyAllItems,
2905 mfsample_GetSampleFlags,
2906 mfsample_SetSampleFlags,
2907 mfsample_GetSampleTime,
2908 mfsample_SetSampleTime,
2909 mfsample_GetSampleDuration,
2910 mfsample_SetSampleDuration,
2911 mfsample_GetBufferCount,
2912 mfsample_GetBufferByIndex,
2913 mfsample_ConvertToContiguousBuffer,
2914 mfsample_AddBuffer,
2915 mfsample_RemoveBufferByIndex,
2916 mfsample_RemoveAllBuffers,
2917 mfsample_GetTotalLength,
2918 mfsample_CopyToBuffer
2919 };
2920
2921 HRESULT WINAPI MFCreateSample(IMFSample **sample)
2922 {
2923 mfsample *object;
2924
2925 TRACE("%p\n", sample);
2926
2927 object = heap_alloc(sizeof(*object));
2928 if(!object)
2929 return E_OUTOFMEMORY;
2930
2931 init_attribute_object(&object->attributes, 0);
2932 object->IMFSample_iface.lpVtbl = &mfsample_vtbl;
2933 *sample = &object->IMFSample_iface;
2934
2935 return S_OK;
2936 }
Windows API implementation