sync with trunk r46493
[reactos.git] / dll / directx / quartz / filtermapper.c
1 /*
2 * IFilterMapper & IFilterMapper2 Implementations
3 *
4 * Copyright 2003 Robert Shearman
5 * Copyright 2004 Christian Costa
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
24 #include <stdarg.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "winerror.h"
31
32 #include "quartz_private.h"
33
34 #include "ole2.h"
35 #include "olectl.h"
36 #include "strmif.h"
37 #include "wine/unicode.h"
38 #include "uuids.h"
39
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
43
44 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
45
46 /* Unexposed IAMFilterData interface */
47 typedef struct IAMFilterData IAMFilterData;
48
49 typedef struct IAMFilterDataVtbl
50 {
51 BEGIN_INTERFACE
52
53 /*** IUnknown methods ***/
54 HRESULT (STDMETHODCALLTYPE *QueryInterface)(
55 IAMFilterData *This,
56 REFIID riid,
57 void **ppvObject);
58
59 ULONG (STDMETHODCALLTYPE *AddRef)(
60 IAMFilterData *This);
61
62 ULONG (STDMETHODCALLTYPE *Release)(
63 IAMFilterData *This);
64
65 /*** IAMFilterData methods ***/
66 HRESULT (STDMETHODCALLTYPE *ParseFilterData)(
67 IAMFilterData *This,
68 BYTE *pData,
69 ULONG cb,
70 BYTE **ppRegFilter2);
71
72 HRESULT (STDMETHODCALLTYPE *CreateFilterData)(
73 IAMFilterData* This,
74 REGFILTER2 *prf2,
75 BYTE **pRegFilterData,
76 ULONG *pcb);
77
78 END_INTERFACE
79 } IAMFilterDataVtbl;
80 struct IAMFilterData
81 {
82 const IAMFilterDataVtbl *lpVtbl;
83 };
84 static const GUID IID_IAMFilterData = {
85 0x97f7c4d4, 0x547b, 0x4a5f, { 0x83,0x32, 0x53,0x64,0x30,0xad,0x2e,0x4d }
86 };
87
88
89 typedef struct FilterMapper2Impl
90 {
91 const IFilterMapper2Vtbl *lpVtbl;
92 const IFilterMapperVtbl *lpVtblFilterMapper;
93 const IAMFilterDataVtbl *lpVtblAMFilterData;
94 const IUnknownVtbl *IInner_vtbl;
95 LONG refCount;
96 IUnknown * pUnkOuter;
97 BOOL bUnkOuterValid;
98 BOOL bAggregatable;
99 } FilterMapper2Impl;
100
101 static const IUnknownVtbl IInner_VTable;
102 static const IFilterMapper2Vtbl fm2vtbl;
103 static const IFilterMapperVtbl fmvtbl;
104 static const IAMFilterDataVtbl AMFilterDataVtbl;
105
106 static inline FilterMapper2Impl *impl_from_IFilterMapper( IFilterMapper *iface )
107 {
108 return (FilterMapper2Impl *)((char*)iface - FIELD_OFFSET(FilterMapper2Impl, lpVtblFilterMapper));
109 }
110
111 static inline FilterMapper2Impl *impl_from_IAMFilterData( IAMFilterData *iface )
112 {
113 return (FilterMapper2Impl *)((char*)iface - FIELD_OFFSET(FilterMapper2Impl, lpVtblAMFilterData));
114 }
115
116 static inline FilterMapper2Impl *impl_from_inner_IUnknown( IUnknown *iface )
117 {
118 return (FilterMapper2Impl *)((char*)iface - FIELD_OFFSET(FilterMapper2Impl, IInner_vtbl));
119 }
120
121 static const WCHAR wszClsidSlash[] = {'C','L','S','I','D','\\',0};
122 static const WCHAR wszSlashInstance[] = {'\\','I','n','s','t','a','n','c','e','\\',0};
123 static const WCHAR wszSlash[] = {'\\',0};
124
125 /* CLSID property in media category Moniker */
126 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
127 /* FriendlyName property in media category Moniker */
128 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
129 /* Merit property in media category Moniker (CLSID_ActiveMovieCategories only) */
130 static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};
131 /* FilterData property in media category Moniker (not CLSID_ActiveMovieCategories) */
132 static const WCHAR wszFilterDataName[] = {'F','i','l','t','e','r','D','a','t','a',0};
133 /* For filters registered with IFilterMapper */
134 static const WCHAR wszFilterSlash[] = {'F','i','l','t','e','r','\\',0};
135 static const WCHAR wszFilter[] = {'F','i','l','t','e','r',0};
136 /* For pins registered with IFilterMapper */
137 static const WCHAR wszPins[] = {'P','i','n','s',0};
138 static const WCHAR wszAllowedMany[] = {'A','l','l','o','w','e','d','M','a','n','y',0};
139 static const WCHAR wszAllowedZero[] = {'A','l','l','o','w','e','d','Z','e','r','o',0};
140 static const WCHAR wszDirection[] = {'D','i','r','e','c','t','i','o','n',0};
141 static const WCHAR wszIsRendered[] = {'I','s','R','e','n','d','e','r','e','d',0};
142 /* For types registered with IFilterMapper */
143 static const WCHAR wszTypes[] = {'T','y','p','e','s',0};
144
145
146 /* registry format for REGFILTER2 */
147 struct REG_RF
148 {
149 DWORD dwVersion;
150 DWORD dwMerit;
151 DWORD dwPins;
152 DWORD dwUnused;
153 };
154
155 struct REG_RFP
156 {
157 BYTE signature[4]; /* e.g. "0pi3" */
158 DWORD dwFlags;
159 DWORD dwInstances;
160 DWORD dwMediaTypes;
161 DWORD dwMediums;
162 DWORD bCategory; /* is there a category clsid? */
163 /* optional: dwOffsetCategoryClsid */
164 };
165
166 struct REG_TYPE
167 {
168 BYTE signature[4]; /* e.g. "0ty3" */
169 DWORD dwUnused;
170 DWORD dwOffsetMajor;
171 DWORD dwOffsetMinor;
172 };
173
174 struct MONIKER_MERIT
175 {
176 IMoniker * pMoniker;
177 DWORD dwMerit;
178 };
179
180 struct Vector
181 {
182 LPBYTE pData;
183 int capacity; /* in bytes */
184 int current; /* pointer to next free byte */
185 };
186
187 /* returns the position it was added at */
188 static int add_data(struct Vector * v, const BYTE * pData, int size)
189 {
190 int index = v->current;
191 if (v->current + size > v->capacity)
192 {
193 LPBYTE pOldData = v->pData;
194 v->capacity = (v->capacity + size) * 2;
195 v->pData = CoTaskMemAlloc(v->capacity);
196 memcpy(v->pData, pOldData, v->current);
197 CoTaskMemFree(pOldData);
198 }
199 memcpy(v->pData + v->current, pData, size);
200 v->current += size;
201 return index;
202 }
203
204 static int find_data(const struct Vector * v, const BYTE * pData, int size)
205 {
206 int index;
207 for (index = 0; index < v->current; index++)
208 if (!memcmp(v->pData + index, pData, size))
209 return index;
210 /* not found */
211 return -1;
212 }
213
214 static void delete_vector(struct Vector * v)
215 {
216 CoTaskMemFree(v->pData);
217 v->current = 0;
218 v->capacity = 0;
219 }
220
221 HRESULT FilterMapper2_create(IUnknown *pUnkOuter, LPVOID *ppObj)
222 {
223 FilterMapper2Impl * pFM2impl;
224
225 TRACE("(%p, %p)\n", pUnkOuter, ppObj);
226
227 pFM2impl = CoTaskMemAlloc(sizeof(*pFM2impl));
228 if (!pFM2impl)
229 return E_OUTOFMEMORY;
230
231 pFM2impl->pUnkOuter = pUnkOuter;
232 pFM2impl->bUnkOuterValid = FALSE;
233 pFM2impl->bAggregatable = FALSE;
234 pFM2impl->IInner_vtbl = &IInner_VTable;
235 pFM2impl->lpVtbl = &fm2vtbl;
236 pFM2impl->lpVtblFilterMapper = &fmvtbl;
237 pFM2impl->lpVtblAMFilterData = &AMFilterDataVtbl;
238 pFM2impl->refCount = 1;
239
240 *ppObj = pFM2impl;
241
242 TRACE("-- created at %p\n", pFM2impl);
243
244 return S_OK;
245 }
246
247 HRESULT FilterMapper_create(IUnknown *pUnkOuter, LPVOID *ppObj)
248 {
249 FilterMapper2Impl *pFM2impl;
250 HRESULT hr;
251
252 TRACE("(%p, %p)\n", pUnkOuter, ppObj);
253
254 hr = FilterMapper2_create(pUnkOuter, (LPVOID*)&pFM2impl);
255 if (FAILED(hr))
256 return hr;
257
258 *ppObj = &pFM2impl->lpVtblFilterMapper;
259
260 return hr;
261 }
262
263 /*** IUnknown (inner) methods ***/
264
265 static HRESULT WINAPI Inner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv)
266 {
267 FilterMapper2Impl *This = impl_from_inner_IUnknown(iface);
268 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
269
270 if (This->bAggregatable)
271 This->bUnkOuterValid = TRUE;
272
273 *ppv = NULL;
274
275 if (IsEqualIID(riid, &IID_IUnknown))
276 *ppv = &This->IInner_vtbl;
277 else if (IsEqualIID(riid, &IID_IFilterMapper2))
278 *ppv = This;
279 else if (IsEqualIID(riid, &IID_IFilterMapper))
280 *ppv = &This->lpVtblFilterMapper;
281 else if (IsEqualIID(riid, &IID_IAMFilterData))
282 *ppv = &This->lpVtblAMFilterData;
283
284 if (*ppv != NULL)
285 {
286 IUnknown_AddRef((IUnknown *)*ppv);
287 return S_OK;
288 }
289
290 FIXME("No interface for %s\n", debugstr_guid(riid));
291 return E_NOINTERFACE;
292 }
293
294 static ULONG WINAPI Inner_AddRef(IUnknown * iface)
295 {
296 FilterMapper2Impl *This = impl_from_inner_IUnknown(iface);
297 ULONG refCount = InterlockedIncrement(&This->refCount);
298
299 TRACE("(%p)->() AddRef from %d\n", This, refCount - 1);
300
301 return refCount;
302 }
303
304 static ULONG WINAPI Inner_Release(IUnknown * iface)
305 {
306 FilterMapper2Impl *This = impl_from_inner_IUnknown(iface);
307 ULONG refCount = InterlockedDecrement(&This->refCount);
308
309 TRACE("(%p)->() Release from %d\n", This, refCount + 1);
310
311 if (refCount == 0)
312 {
313 CoTaskMemFree(This);
314 return 0;
315 }
316 return refCount;
317 }
318
319 static const IUnknownVtbl IInner_VTable =
320 {
321 Inner_QueryInterface,
322 Inner_AddRef,
323 Inner_Release
324 };
325
326 static HRESULT WINAPI FilterMapper2_QueryInterface(IFilterMapper2 * iface, REFIID riid, LPVOID *ppv)
327 {
328 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
329
330 if (This->bAggregatable)
331 This->bUnkOuterValid = TRUE;
332
333 if (This->pUnkOuter)
334 {
335 if (This->bAggregatable)
336 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
337
338 if (IsEqualIID(riid, &IID_IUnknown))
339 {
340 HRESULT hr;
341
342 IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
343 hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
344 IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
345 This->bAggregatable = TRUE;
346 return hr;
347 }
348
349 *ppv = NULL;
350 return E_NOINTERFACE;
351 }
352
353 return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv);
354 }
355
356 static ULONG WINAPI FilterMapper2_AddRef(IFilterMapper2 * iface)
357 {
358 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
359
360 if (This->pUnkOuter && This->bUnkOuterValid)
361 return IUnknown_AddRef(This->pUnkOuter);
362 return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl));
363 }
364
365 static ULONG WINAPI FilterMapper2_Release(IFilterMapper2 * iface)
366 {
367 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
368
369 if (This->pUnkOuter && This->bUnkOuterValid)
370 return IUnknown_Release(This->pUnkOuter);
371 return IUnknown_Release((IUnknown *)&(This->IInner_vtbl));
372 }
373
374 /*** IFilterMapper2 methods ***/
375
376 static HRESULT WINAPI FilterMapper2_CreateCategory(
377 IFilterMapper2 * iface,
378 REFCLSID clsidCategory,
379 DWORD dwCategoryMerit,
380 LPCWSTR szDescription)
381 {
382 LPWSTR wClsidAMCat = NULL;
383 LPWSTR wClsidCategory = NULL;
384 WCHAR wszKeyName[ARRAYSIZE(wszClsidSlash)-1 + ARRAYSIZE(wszSlashInstance)-1 + (CHARS_IN_GUID-1) * 2 + 1];
385 HKEY hKey = NULL;
386 LONG lRet;
387 HRESULT hr;
388
389 TRACE("(%s, %x, %s)\n", debugstr_guid(clsidCategory), dwCategoryMerit, debugstr_w(szDescription));
390
391 hr = StringFromCLSID(&CLSID_ActiveMovieCategories, &wClsidAMCat);
392
393 if (SUCCEEDED(hr))
394 {
395 hr = StringFromCLSID(clsidCategory, &wClsidCategory);
396 }
397
398 if (SUCCEEDED(hr))
399 {
400 strcpyW(wszKeyName, wszClsidSlash);
401 strcatW(wszKeyName, wClsidAMCat);
402 strcatW(wszKeyName, wszSlashInstance);
403 strcatW(wszKeyName, wClsidCategory);
404
405 lRet = RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
406 hr = HRESULT_FROM_WIN32(lRet);
407 }
408
409 if (SUCCEEDED(hr))
410 {
411 lRet = RegSetValueExW(hKey, wszFriendlyName, 0, REG_SZ, (const BYTE*)szDescription, (strlenW(szDescription) + 1) * sizeof(WCHAR));
412 hr = HRESULT_FROM_WIN32(lRet);
413 }
414
415 if (SUCCEEDED(hr))
416 {
417 lRet = RegSetValueExW(hKey, wszClsidName, 0, REG_SZ, (LPBYTE)wClsidCategory, (strlenW(wClsidCategory) + 1) * sizeof(WCHAR));
418 hr = HRESULT_FROM_WIN32(lRet);
419 }
420
421 if (SUCCEEDED(hr))
422 {
423 lRet = RegSetValueExW(hKey, wszMeritName, 0, REG_DWORD, (LPBYTE)&dwCategoryMerit, sizeof(dwCategoryMerit));
424 hr = HRESULT_FROM_WIN32(lRet);
425 }
426
427 CloseHandle(hKey);
428 CoTaskMemFree(wClsidCategory);
429 CoTaskMemFree(wClsidAMCat);
430
431 return hr;
432 }
433
434 static HRESULT WINAPI FilterMapper2_UnregisterFilter(
435 IFilterMapper2 * iface,
436 const CLSID *pclsidCategory,
437 const OLECHAR *szInstance,
438 REFCLSID Filter)
439 {
440 WCHAR wszKeyName[MAX_PATH];
441 LPWSTR wClsidCategory = NULL;
442 LPWSTR wFilter = NULL;
443 HRESULT hr;
444
445 TRACE("(%p, %s, %s)\n", pclsidCategory, debugstr_w(szInstance), debugstr_guid(Filter));
446
447 if (!pclsidCategory)
448 pclsidCategory = &CLSID_LegacyAmFilterCategory;
449
450 hr = StringFromCLSID(pclsidCategory, &wClsidCategory);
451
452 if (SUCCEEDED(hr))
453 {
454 strcpyW(wszKeyName, wszClsidSlash);
455 strcatW(wszKeyName, wClsidCategory);
456 strcatW(wszKeyName, wszSlashInstance);
457 if (szInstance)
458 strcatW(wszKeyName, szInstance);
459 else
460 {
461 hr = StringFromCLSID(Filter, &wFilter);
462 if (SUCCEEDED(hr))
463 strcatW(wszKeyName, wFilter);
464 }
465 }
466
467 if (SUCCEEDED(hr))
468 {
469 LONG lRet = RegDeleteKeyW(HKEY_CLASSES_ROOT, wszKeyName);
470 hr = HRESULT_FROM_WIN32(lRet);
471 }
472
473 CoTaskMemFree(wClsidCategory);
474 CoTaskMemFree(wFilter);
475
476 return hr;
477 }
478
479 static HRESULT FM2_WriteFriendlyName(IPropertyBag * pPropBag, LPCWSTR szName)
480 {
481 VARIANT var;
482 HRESULT ret;
483 BSTR value;
484
485 V_VT(&var) = VT_BSTR;
486 V_UNION(&var, bstrVal) = value = SysAllocString(szName);
487
488 ret = IPropertyBag_Write(pPropBag, wszFriendlyName, &var);
489 SysFreeString(value);
490
491 return ret;
492 }
493
494 static HRESULT FM2_WriteClsid(IPropertyBag * pPropBag, REFCLSID clsid)
495 {
496 LPWSTR wszClsid = NULL;
497 VARIANT var;
498 HRESULT hr;
499
500 hr = StringFromCLSID(clsid, &wszClsid);
501
502 if (SUCCEEDED(hr))
503 {
504 V_VT(&var) = VT_BSTR;
505 V_UNION(&var, bstrVal) = wszClsid;
506 hr = IPropertyBag_Write(pPropBag, wszClsidName, &var);
507 }
508 CoTaskMemFree(wszClsid);
509 return hr;
510 }
511
512 static HRESULT FM2_WriteFilterData(const REGFILTER2 * prf2, BYTE **ppData, ULONG *pcbData)
513 {
514 int size = sizeof(struct REG_RF);
515 unsigned int i;
516 struct Vector mainStore = {NULL, 0, 0};
517 struct Vector clsidStore = {NULL, 0, 0};
518 struct REG_RF rrf;
519 HRESULT hr = S_OK;
520
521 rrf.dwVersion = prf2->dwVersion;
522 rrf.dwMerit = prf2->dwMerit;
523 rrf.dwPins = prf2->u.s1.cPins2;
524 rrf.dwUnused = 0;
525
526 add_data(&mainStore, (LPBYTE)&rrf, sizeof(rrf));
527
528 for (i = 0; i < prf2->u.s1.cPins2; i++)
529 {
530 size += sizeof(struct REG_RFP);
531 if (prf2->u.s1.rgPins2[i].clsPinCategory)
532 size += sizeof(DWORD);
533 size += prf2->u.s1.rgPins2[i].nMediaTypes * sizeof(struct REG_TYPE);
534 size += prf2->u.s1.rgPins2[i].nMediums * sizeof(DWORD);
535 }
536
537 for (i = 0; i < prf2->u.s1.cPins2; i++)
538 {
539 struct REG_RFP rrfp;
540 REGFILTERPINS2 rgPin2 = prf2->u.s1.rgPins2[i];
541 unsigned int j;
542
543 rrfp.signature[0] = '0';
544 rrfp.signature[1] = 'p';
545 rrfp.signature[2] = 'i';
546 rrfp.signature[3] = '3';
547 rrfp.signature[0] += i;
548 rrfp.dwFlags = rgPin2.dwFlags;
549 rrfp.dwInstances = rgPin2.cInstances;
550 rrfp.dwMediaTypes = rgPin2.nMediaTypes;
551 rrfp.dwMediums = rgPin2.nMediums;
552 rrfp.bCategory = rgPin2.clsPinCategory ? 1 : 0;
553
554 add_data(&mainStore, (LPBYTE)&rrfp, sizeof(rrfp));
555 if (rrfp.bCategory)
556 {
557 DWORD index = find_data(&clsidStore, (const BYTE*)rgPin2.clsPinCategory, sizeof(CLSID));
558 if (index == -1)
559 index = add_data(&clsidStore, (const BYTE*)rgPin2.clsPinCategory, sizeof(CLSID));
560 index += size;
561
562 add_data(&mainStore, (LPBYTE)&index, sizeof(index));
563 }
564
565 for (j = 0; j < rgPin2.nMediaTypes; j++)
566 {
567 struct REG_TYPE rt;
568 const CLSID * clsMinorType = rgPin2.lpMediaType[j].clsMinorType ? rgPin2.lpMediaType[j].clsMinorType : &MEDIASUBTYPE_NULL;
569 rt.signature[0] = '0';
570 rt.signature[1] = 't';
571 rt.signature[2] = 'y';
572 rt.signature[3] = '3';
573 rt.signature[0] += j;
574 rt.dwUnused = 0;
575 rt.dwOffsetMajor = find_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
576 if (rt.dwOffsetMajor == -1)
577 rt.dwOffsetMajor = add_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
578 rt.dwOffsetMajor += size;
579 rt.dwOffsetMinor = find_data(&clsidStore, (const BYTE*)clsMinorType, sizeof(CLSID));
580 if (rt.dwOffsetMinor == -1)
581 rt.dwOffsetMinor = add_data(&clsidStore, (const BYTE*)clsMinorType, sizeof(CLSID));
582 rt.dwOffsetMinor += size;
583
584 add_data(&mainStore, (LPBYTE)&rt, sizeof(rt));
585 }
586
587 for (j = 0; j < rgPin2.nMediums; j++)
588 {
589 DWORD index = find_data(&clsidStore, (const BYTE*)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
590 if (index == -1)
591 index = add_data(&clsidStore, (const BYTE*)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
592 index += size;
593
594 add_data(&mainStore, (LPBYTE)&index, sizeof(index));
595 }
596 }
597
598 if (SUCCEEDED(hr))
599 {
600 *pcbData = mainStore.current + clsidStore.current;
601 *ppData = CoTaskMemAlloc(*pcbData);
602 if (!*ppData)
603 hr = E_OUTOFMEMORY;
604 }
605
606 if (SUCCEEDED(hr))
607 {
608 memcpy(*ppData, mainStore.pData, mainStore.current);
609 memcpy((*ppData) + mainStore.current, clsidStore.pData, clsidStore.current);
610 }
611
612 delete_vector(&mainStore);
613 delete_vector(&clsidStore);
614 return hr;
615 }
616
617 static HRESULT FM2_ReadFilterData(BYTE *pData, REGFILTER2 * prf2)
618 {
619 HRESULT hr = S_OK;
620 struct REG_RF * prrf;
621 LPBYTE pCurrent;
622 DWORD i;
623 REGFILTERPINS2 * rgPins2;
624
625 prrf = (struct REG_RF *)pData;
626 pCurrent = pData;
627
628 if (prrf->dwVersion != 2)
629 {
630 FIXME("Filter registry version %d not supported\n", prrf->dwVersion);
631 ZeroMemory(prf2, sizeof(*prf2));
632 hr = E_FAIL;
633 }
634
635 if (SUCCEEDED(hr))
636 {
637 TRACE("version = %d, merit = %x, #pins = %d, unused = %x\n",
638 prrf->dwVersion, prrf->dwMerit, prrf->dwPins, prrf->dwUnused);
639
640 prf2->dwVersion = prrf->dwVersion;
641 prf2->dwMerit = prrf->dwMerit;
642 prf2->u.s1.cPins2 = prrf->dwPins;
643 rgPins2 = CoTaskMemAlloc(prrf->dwPins * sizeof(*rgPins2));
644 prf2->u.s1.rgPins2 = rgPins2;
645 pCurrent += sizeof(struct REG_RF);
646
647 for (i = 0; i < prrf->dwPins; i++)
648 {
649 struct REG_RFP * prrfp = (struct REG_RFP *)pCurrent;
650 REGPINTYPES * lpMediaType;
651 REGPINMEDIUM * lpMedium;
652 UINT j;
653
654 /* FIXME: check signature */
655
656 TRACE("\tsignature = %s\n", debugstr_an((const char*)prrfp->signature, 4));
657
658 TRACE("\tpin[%d]: flags = %x, instances = %d, media types = %d, mediums = %d\n",
659 i, prrfp->dwFlags, prrfp->dwInstances, prrfp->dwMediaTypes, prrfp->dwMediums);
660
661 rgPins2[i].dwFlags = prrfp->dwFlags;
662 rgPins2[i].cInstances = prrfp->dwInstances;
663 rgPins2[i].nMediaTypes = prrfp->dwMediaTypes;
664 rgPins2[i].nMediums = prrfp->dwMediums;
665 pCurrent += sizeof(struct REG_RFP);
666 if (prrfp->bCategory)
667 {
668 CLSID * clsCat = CoTaskMemAlloc(sizeof(CLSID));
669 memcpy(clsCat, pData + *(DWORD*)(pCurrent), sizeof(CLSID));
670 pCurrent += sizeof(DWORD);
671 rgPins2[i].clsPinCategory = clsCat;
672 }
673 else
674 rgPins2[i].clsPinCategory = NULL;
675
676 if (rgPins2[i].nMediaTypes > 0)
677 lpMediaType = CoTaskMemAlloc(rgPins2[i].nMediaTypes * sizeof(*lpMediaType));
678 else
679 lpMediaType = NULL;
680
681 rgPins2[i].lpMediaType = lpMediaType;
682
683 for (j = 0; j < rgPins2[i].nMediaTypes; j++)
684 {
685 struct REG_TYPE * prt = (struct REG_TYPE *)pCurrent;
686 CLSID * clsMajor = CoTaskMemAlloc(sizeof(CLSID));
687 CLSID * clsMinor = CoTaskMemAlloc(sizeof(CLSID));
688
689 /* FIXME: check signature */
690 TRACE("\t\tsignature = %s\n", debugstr_an((const char*)prt->signature, 4));
691
692 memcpy(clsMajor, pData + prt->dwOffsetMajor, sizeof(CLSID));
693 memcpy(clsMinor, pData + prt->dwOffsetMinor, sizeof(CLSID));
694
695 lpMediaType[j].clsMajorType = clsMajor;
696 lpMediaType[j].clsMinorType = clsMinor;
697
698 pCurrent += sizeof(*prt);
699 }
700
701 if (rgPins2[i].nMediums > 0)
702 lpMedium = CoTaskMemAlloc(rgPins2[i].nMediums * sizeof(*lpMedium));
703 else
704 lpMedium = NULL;
705
706 rgPins2[i].lpMedium = lpMedium;
707
708 for (j = 0; j < rgPins2[i].nMediums; j++)
709 {
710 DWORD dwOffset = *(DWORD *)pCurrent;
711
712 memcpy(lpMedium + j, pData + dwOffset, sizeof(REGPINMEDIUM));
713
714 pCurrent += sizeof(dwOffset);
715 }
716 }
717
718 }
719
720 return hr;
721 }
722
723 static void FM2_DeleteRegFilter(REGFILTER2 * prf2)
724 {
725 UINT i;
726 for (i = 0; i < prf2->u.s1.cPins2; i++)
727 {
728 UINT j;
729 if (prf2->u.s1.rgPins2[i].clsPinCategory)
730 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].clsPinCategory);
731
732 for (j = 0; j < prf2->u.s1.rgPins2[i].nMediaTypes; j++)
733 {
734 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMajorType);
735 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMinorType);
736 }
737 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType);
738 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMedium);
739 }
740 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2);
741 }
742
743 static HRESULT WINAPI FilterMapper2_RegisterFilter(
744 IFilterMapper2 * iface,
745 REFCLSID clsidFilter,
746 LPCWSTR szName,
747 IMoniker **ppMoniker,
748 const CLSID *pclsidCategory,
749 const OLECHAR *szInstance,
750 const REGFILTER2 *prf2)
751 {
752 IParseDisplayName * pParser = NULL;
753 IBindCtx * pBindCtx = NULL;
754 IMoniker * pMoniker = NULL;
755 IPropertyBag * pPropBag = NULL;
756 HRESULT hr;
757 LPWSTR pwszParseName = NULL;
758 LPWSTR pCurrent;
759 static const WCHAR wszDevice[] = {'@','d','e','v','i','c','e',':','s','w',':',0};
760 int nameLen;
761 ULONG ulEaten;
762 LPWSTR szClsidTemp = NULL;
763 REGFILTER2 regfilter2;
764 REGFILTERPINS2* pregfp2 = NULL;
765
766 TRACE("(%s, %s, %p, %s, %s, %p)\n",
767 debugstr_guid(clsidFilter),
768 debugstr_w(szName),
769 ppMoniker,
770 debugstr_guid(pclsidCategory),
771 debugstr_w(szInstance),
772 prf2);
773
774 if (prf2->dwVersion == 2)
775 {
776 regfilter2 = *prf2;
777 }
778 else if (prf2->dwVersion == 1)
779 {
780 ULONG i;
781 DWORD flags;
782 /* REGFILTER2 structure is converted from version 1 to 2. Tested on Win2k. */
783 regfilter2.dwVersion = 2;
784 regfilter2.dwMerit = prf2->dwMerit;
785 regfilter2.u.s1.cPins2 = prf2->u.s.cPins;
786 pregfp2 = CoTaskMemAlloc(prf2->u.s.cPins * sizeof(REGFILTERPINS2));
787 regfilter2.u.s1.rgPins2 = pregfp2;
788 for (i = 0; i < prf2->u.s.cPins; i++)
789 {
790 flags = 0;
791 if (prf2->u.s.rgPins[i].bRendered)
792 flags |= REG_PINFLAG_B_RENDERER;
793 if (prf2->u.s.rgPins[i].bOutput)
794 flags |= REG_PINFLAG_B_OUTPUT;
795 if (prf2->u.s.rgPins[i].bZero)
796 flags |= REG_PINFLAG_B_ZERO;
797 if (prf2->u.s.rgPins[i].bMany)
798 flags |= REG_PINFLAG_B_MANY;
799 pregfp2[i].dwFlags = flags;
800 pregfp2[i].cInstances = 1;
801 pregfp2[i].nMediaTypes = prf2->u.s.rgPins[i].nMediaTypes;
802 pregfp2[i].lpMediaType = prf2->u.s.rgPins[i].lpMediaType;
803 pregfp2[i].nMediums = 0;
804 pregfp2[i].lpMedium = NULL;
805 pregfp2[i].clsPinCategory = NULL;
806 }
807 }
808 else
809 {
810 FIXME("dwVersion other that 1 or 2 not supported at the moment\n");
811 return E_NOTIMPL;
812 }
813
814 if (ppMoniker)
815 *ppMoniker = NULL;
816
817 if (!pclsidCategory)
818 /* MSDN mentions the inexistent CLSID_ActiveMovieFilters GUID.
819 * In fact this is the CLSID_LegacyAmFilterCategory one */
820 pclsidCategory = &CLSID_LegacyAmFilterCategory;
821
822 /* sizeof... will include the null terminator and
823 * the + 1 is for the separator ('\\'). The -1 is
824 * because CHARS_IN_GUID includes the null terminator
825 */
826 nameLen = sizeof(wszDevice)/sizeof(wszDevice[0]) + CHARS_IN_GUID - 1 + 1;
827
828 if (szInstance)
829 nameLen += strlenW(szInstance);
830 else
831 nameLen += CHARS_IN_GUID - 1; /* CHARS_IN_GUID includes null terminator */
832
833 pCurrent = pwszParseName = CoTaskMemAlloc(nameLen*sizeof(WCHAR));
834 if (!pwszParseName)
835 return E_OUTOFMEMORY;
836
837 strcpyW(pwszParseName, wszDevice);
838 pCurrent += strlenW(wszDevice);
839
840 hr = StringFromCLSID(pclsidCategory, &szClsidTemp);
841
842 if (SUCCEEDED(hr))
843 {
844 memcpy(pCurrent, szClsidTemp, CHARS_IN_GUID * sizeof(WCHAR));
845 pCurrent += CHARS_IN_GUID - 1;
846 pCurrent[0] = '\\';
847
848 if (szInstance)
849 strcpyW(pCurrent+1, szInstance);
850 else
851 {
852 CoTaskMemFree(szClsidTemp);
853 szClsidTemp = NULL;
854
855 hr = StringFromCLSID(clsidFilter, &szClsidTemp);
856 if (SUCCEEDED(hr))
857 strcpyW(pCurrent+1, szClsidTemp);
858 }
859 }
860
861 if (SUCCEEDED(hr))
862 hr = CoCreateInstance(&CLSID_CDeviceMoniker, NULL, CLSCTX_INPROC, &IID_IParseDisplayName, (LPVOID *)&pParser);
863
864 if (SUCCEEDED(hr))
865 hr = CreateBindCtx(0, &pBindCtx);
866
867 if (SUCCEEDED(hr))
868 hr = IParseDisplayName_ParseDisplayName(pParser, pBindCtx, pwszParseName, &ulEaten, &pMoniker);
869
870 if (pBindCtx)
871 IBindCtx_Release(pBindCtx);
872 if (pParser)
873 IParseDisplayName_Release(pParser);
874
875 if (SUCCEEDED(hr))
876 hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID)&pPropBag);
877
878 if (SUCCEEDED(hr))
879 hr = FM2_WriteFriendlyName(pPropBag, szName);
880
881 if (SUCCEEDED(hr))
882 hr = FM2_WriteClsid(pPropBag, clsidFilter);
883
884 if (SUCCEEDED(hr))
885 {
886 BYTE *pData;
887 ULONG cbData;
888
889 hr = FM2_WriteFilterData(&regfilter2, &pData, &cbData);
890 if (SUCCEEDED(hr))
891 {
892 VARIANT var;
893 SAFEARRAY *psa;
894 SAFEARRAYBOUND saBound;
895
896 saBound.lLbound = 0;
897 saBound.cElements = cbData;
898 psa = SafeArrayCreate(VT_UI1, 1, &saBound);
899 if (!psa)
900 {
901 ERR("Couldn't create SAFEARRAY\n");
902 hr = E_FAIL;
903 }
904
905 if (SUCCEEDED(hr))
906 {
907 LPBYTE pbSAData;
908 hr = SafeArrayAccessData(psa, (LPVOID *)&pbSAData);
909 if (SUCCEEDED(hr))
910 {
911 memcpy(pbSAData, pData, cbData);
912 hr = SafeArrayUnaccessData(psa);
913 }
914 }
915
916 V_VT(&var) = VT_ARRAY | VT_UI1;
917 V_UNION(&var, parray) = psa;
918
919 if (SUCCEEDED(hr))
920 hr = IPropertyBag_Write(pPropBag, wszFilterDataName, &var);
921
922 if (psa)
923 SafeArrayDestroy(psa);
924 CoTaskMemFree(pData);
925 }
926 }
927
928 if (pPropBag)
929 IPropertyBag_Release(pPropBag);
930 CoTaskMemFree(szClsidTemp);
931 CoTaskMemFree(pwszParseName);
932
933 if (SUCCEEDED(hr) && ppMoniker)
934 *ppMoniker = pMoniker;
935 else if (pMoniker)
936 IMoniker_Release(pMoniker);
937
938 CoTaskMemFree(pregfp2);
939
940 TRACE("-- returning %x\n", hr);
941
942 return hr;
943 }
944
945 /* internal helper function */
946 static BOOL MatchTypes(
947 BOOL bExactMatch,
948 DWORD nPinTypes,
949 const REGPINTYPES * pPinTypes,
950 DWORD nMatchTypes,
951 const GUID * pMatchTypes)
952 {
953 BOOL bMatch = FALSE;
954 DWORD j;
955
956 if ((nMatchTypes == 0) && (nPinTypes > 0))
957 bMatch = TRUE;
958
959 for (j = 0; j < nPinTypes; j++)
960 {
961 DWORD i;
962 for (i = 0; i < nMatchTypes*2; i+=2)
963 {
964 if (((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMajorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMajorType, &pMatchTypes[i])) &&
965 ((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMinorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i+1], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMinorType, &pMatchTypes[i+1])))
966 {
967 bMatch = TRUE;
968 break;
969 }
970 }
971 }
972 return bMatch;
973 }
974
975 /* internal helper function for qsort of MONIKER_MERIT array */
976 static int mm_compare(const void * left, const void * right)
977 {
978 const struct MONIKER_MERIT * mmLeft = left;
979 const struct MONIKER_MERIT * mmRight = right;
980
981 if (mmLeft->dwMerit == mmRight->dwMerit)
982 return 0;
983 if (mmLeft->dwMerit > mmRight->dwMerit)
984 return -1;
985 return 1;
986 }
987
988 /* NOTES:
989 * Exact match means whether or not to treat GUID_NULL's in filter data as wild cards
990 * (GUID_NULL's in input to function automatically treated as wild cards)
991 * Input/Output needed means match only on criteria if TRUE (with zero input types
992 * meaning match any input/output pin as long as one exists), otherwise match any
993 * filter that meets the rest of the requirements.
994 */
995 static HRESULT WINAPI FilterMapper2_EnumMatchingFilters(
996 IFilterMapper2 * iface,
997 IEnumMoniker **ppEnum,
998 DWORD dwFlags,
999 BOOL bExactMatch,
1000 DWORD dwMerit,
1001 BOOL bInputNeeded,
1002 DWORD cInputTypes,
1003 const GUID *pInputTypes,
1004 const REGPINMEDIUM *pMedIn,
1005 const CLSID *pPinCategoryIn,
1006 BOOL bRender,
1007 BOOL bOutputNeeded,
1008 DWORD cOutputTypes,
1009 const GUID *pOutputTypes,
1010 const REGPINMEDIUM *pMedOut,
1011 const CLSID *pPinCategoryOut)
1012 {
1013 ICreateDevEnum * pCreateDevEnum;
1014 IMoniker * pMonikerCat;
1015 IEnumMoniker * pEnumCat;
1016 HRESULT hr;
1017 struct Vector monikers = {NULL, 0, 0};
1018
1019 TRACE("(%p, %x, %s, %x, %s, %d, %p, %p, %p, %s, %s, %p, %p, %p)\n",
1020 ppEnum,
1021 dwFlags,
1022 bExactMatch ? "true" : "false",
1023 dwMerit,
1024 bInputNeeded ? "true" : "false",
1025 cInputTypes,
1026 pInputTypes,
1027 pMedIn,
1028 pPinCategoryIn,
1029 bRender ? "true" : "false",
1030 bOutputNeeded ? "true" : "false",
1031 pOutputTypes,
1032 pMedOut,
1033 pPinCategoryOut);
1034
1035 if (dwFlags != 0)
1036 {
1037 FIXME("dwFlags = %x not implemented\n", dwFlags);
1038 }
1039
1040 *ppEnum = NULL;
1041
1042 hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC, &IID_ICreateDevEnum, (LPVOID*)&pCreateDevEnum);
1043 if (FAILED(hr))
1044 return hr;
1045
1046 hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEnumCat, 0);
1047 if (FAILED(hr)) {
1048 ICreateDevEnum_Release(pCreateDevEnum);
1049 return hr;
1050 }
1051
1052 while (IEnumMoniker_Next(pEnumCat, 1, &pMonikerCat, NULL) == S_OK)
1053 {
1054 IPropertyBag * pPropBagCat = NULL;
1055 VARIANT var;
1056 HRESULT hrSub; /* this is so that one buggy filter
1057 doesn't make the whole lot fail */
1058
1059 VariantInit(&var);
1060
1061 hrSub = IMoniker_BindToStorage(pMonikerCat, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
1062
1063 if (SUCCEEDED(hrSub))
1064 hrSub = IPropertyBag_Read(pPropBagCat, wszMeritName, &var, NULL);
1065
1066 if (SUCCEEDED(hrSub) && (V_UNION(&var, ulVal) >= dwMerit))
1067 {
1068 CLSID clsidCat;
1069 IEnumMoniker * pEnum;
1070 IMoniker * pMoniker;
1071
1072 VariantClear(&var);
1073
1074 if (TRACE_ON(quartz))
1075 {
1076 VARIANT temp;
1077 V_VT(&temp) = VT_EMPTY;
1078 IPropertyBag_Read(pPropBagCat, wszFriendlyName, &temp, NULL);
1079 TRACE("Considering category %s\n", debugstr_w(V_UNION(&temp, bstrVal)));
1080 VariantClear(&temp);
1081 }
1082
1083 hrSub = IPropertyBag_Read(pPropBagCat, wszClsidName, &var, NULL);
1084
1085 if (SUCCEEDED(hrSub))
1086 hrSub = CLSIDFromString(V_UNION(&var, bstrVal), &clsidCat);
1087
1088 if (SUCCEEDED(hrSub))
1089 hrSub = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0);
1090
1091 if (hrSub == S_OK)
1092 {
1093 while (IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL) == S_OK)
1094 {
1095 IPropertyBag * pPropBag = NULL;
1096 VARIANT var;
1097 BYTE *pData = NULL;
1098 REGFILTER2 rf2;
1099 DWORD i;
1100 BOOL bInputMatch = !bInputNeeded;
1101 BOOL bOutputMatch = !bOutputNeeded;
1102
1103 ZeroMemory(&rf2, sizeof(rf2));
1104 VariantInit(&var);
1105
1106 hrSub = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBag);
1107
1108 if (TRACE_ON(quartz))
1109 {
1110 VARIANT temp;
1111 V_VT(&temp) = VT_EMPTY;
1112 IPropertyBag_Read(pPropBag, wszFriendlyName, &temp, NULL);
1113 TRACE("Considering filter %s\n", debugstr_w(V_UNION(&temp, bstrVal)));
1114 VariantClear(&temp);
1115 }
1116
1117 if (SUCCEEDED(hrSub))
1118 {
1119 hrSub = IPropertyBag_Read(pPropBag, wszFilterDataName, &var, NULL);
1120 }
1121
1122 if (SUCCEEDED(hrSub))
1123 hrSub = SafeArrayAccessData(V_UNION(&var, parray), (LPVOID*)&pData);
1124
1125 if (SUCCEEDED(hrSub))
1126 hrSub = FM2_ReadFilterData(pData, &rf2);
1127
1128 if (pData)
1129 SafeArrayUnaccessData(V_UNION(&var, parray));
1130
1131 VariantClear(&var);
1132
1133 /* Logic used for bInputMatch expression:
1134 * There exists some pin such that bInputNeeded implies (pin is an input and
1135 * (bRender implies pin has render flag) and major/minor types members of
1136 * pInputTypes )
1137 * bOutputMatch is similar, but without the "bRender implies ..." part
1138 * and substituting variables names containing input for output
1139 */
1140
1141 /* determine whether filter meets requirements */
1142 if (SUCCEEDED(hrSub) && (rf2.dwMerit >= dwMerit))
1143 {
1144 for (i = 0; (i < rf2.u.s1.cPins2) && (!bInputMatch || !bOutputMatch); i++)
1145 {
1146 const REGFILTERPINS2 * rfp2 = rf2.u.s1.rgPins2 + i;
1147
1148 bInputMatch = bInputMatch || (!(rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
1149 (!bRender || (rfp2->dwFlags & REG_PINFLAG_B_RENDERER)) &&
1150 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cInputTypes, pInputTypes));
1151 bOutputMatch = bOutputMatch || ((rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
1152 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cOutputTypes, pOutputTypes));
1153 }
1154
1155 if (bInputMatch && bOutputMatch)
1156 {
1157 struct MONIKER_MERIT mm = {pMoniker, rf2.dwMerit};
1158 IMoniker_AddRef(pMoniker);
1159 add_data(&monikers, (LPBYTE)&mm, sizeof(mm));
1160 }
1161 }
1162
1163 FM2_DeleteRegFilter(&rf2);
1164 if (pPropBag)
1165 IPropertyBag_Release(pPropBag);
1166 IMoniker_Release(pMoniker);
1167 }
1168 IEnumMoniker_Release(pEnum);
1169 }
1170 }
1171
1172 VariantClear(&var);
1173 if (pPropBagCat)
1174 IPropertyBag_Release(pPropBagCat);
1175 IMoniker_Release(pMonikerCat);
1176 }
1177
1178 if (SUCCEEDED(hr))
1179 {
1180 IMoniker ** ppMoniker;
1181 unsigned int i;
1182 ULONG nMonikerCount = monikers.current / sizeof(struct MONIKER_MERIT);
1183
1184 /* sort the monikers in descending merit order */
1185 qsort(monikers.pData, nMonikerCount,
1186 sizeof(struct MONIKER_MERIT),
1187 mm_compare);
1188
1189 /* construct an IEnumMoniker interface */
1190 ppMoniker = CoTaskMemAlloc(nMonikerCount * sizeof(IMoniker *));
1191 for (i = 0; i < nMonikerCount; i++)
1192 {
1193 /* no need to AddRef here as already AddRef'd above */
1194 ppMoniker[i] = ((struct MONIKER_MERIT *)monikers.pData)[i].pMoniker;
1195 }
1196 hr = EnumMonikerImpl_Create(ppMoniker, nMonikerCount, ppEnum);
1197 CoTaskMemFree(ppMoniker);
1198 }
1199
1200 delete_vector(&monikers);
1201 IEnumMoniker_Release(pEnumCat);
1202 ICreateDevEnum_Release(pCreateDevEnum);
1203
1204 return hr;
1205 }
1206
1207 static const IFilterMapper2Vtbl fm2vtbl =
1208 {
1209
1210 FilterMapper2_QueryInterface,
1211 FilterMapper2_AddRef,
1212 FilterMapper2_Release,
1213
1214 FilterMapper2_CreateCategory,
1215 FilterMapper2_UnregisterFilter,
1216 FilterMapper2_RegisterFilter,
1217 FilterMapper2_EnumMatchingFilters
1218 };
1219
1220 /*** IUnknown methods ***/
1221
1222 static HRESULT WINAPI FilterMapper_QueryInterface(IFilterMapper * iface, REFIID riid, LPVOID *ppv)
1223 {
1224 FilterMapper2Impl *This = impl_from_IFilterMapper(iface);
1225
1226 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1227
1228 return FilterMapper2_QueryInterface((IFilterMapper2*)&This->lpVtbl, riid, ppv);
1229 }
1230
1231 static ULONG WINAPI FilterMapper_AddRef(IFilterMapper * iface)
1232 {
1233 FilterMapper2Impl *This = impl_from_IFilterMapper(iface);
1234
1235 return FilterMapper2_AddRef((IFilterMapper2*)This);
1236 }
1237
1238 static ULONG WINAPI FilterMapper_Release(IFilterMapper * iface)
1239 {
1240 FilterMapper2Impl *This = impl_from_IFilterMapper(iface);
1241
1242 return FilterMapper2_Release((IFilterMapper2*)This);
1243 }
1244
1245 /*** IFilterMapper methods ***/
1246
1247 static HRESULT WINAPI FilterMapper_EnumMatchingFilters(
1248 IFilterMapper * iface,
1249 IEnumRegFilters **ppEnum,
1250 DWORD dwMerit,
1251 BOOL bInputNeeded,
1252 CLSID clsInMaj,
1253 CLSID clsInSub,
1254 BOOL bRender,
1255 BOOL bOutputNeeded,
1256 CLSID clsOutMaj,
1257 CLSID clsOutSub)
1258 {
1259 FilterMapper2Impl *This = impl_from_IFilterMapper(iface);
1260 GUID InputType[2];
1261 GUID OutputType[2];
1262 IEnumMoniker* ppEnumMoniker;
1263 IMoniker* IMon;
1264 ULONG nb;
1265 ULONG idx = 0, nb_mon = 0;
1266 REGFILTER* regfilters;
1267 HRESULT hr;
1268
1269 TRACE("(%p/%p)->(%p, %x, %s, %s, %s, %s, %s, %s, %s) stub!\n",
1270 iface,This,
1271 ppEnum,
1272 dwMerit,
1273 bInputNeeded ? "true" : "false",
1274 debugstr_guid(&clsInMaj),
1275 debugstr_guid(&clsInSub),
1276 bRender ? "true" : "false",
1277 bOutputNeeded ? "true" : "false",
1278 debugstr_guid(&clsOutMaj),
1279 debugstr_guid(&clsOutSub));
1280
1281 InputType[0] = clsInMaj;
1282 InputType[1] = clsInSub;
1283 OutputType[0] = clsOutMaj;
1284 OutputType[1] = clsOutSub;
1285
1286 *ppEnum = NULL;
1287
1288 hr = IFilterMapper2_EnumMatchingFilters((IFilterMapper2*)This,
1289 &ppEnumMoniker,
1290 0,
1291 TRUE,
1292 dwMerit,
1293 bInputNeeded,
1294 1,
1295 InputType,
1296 NULL,
1297 &GUID_NULL,
1298 bRender,
1299 bOutputNeeded,
1300 1,
1301 OutputType,
1302 NULL,
1303 &GUID_NULL);
1304
1305 if (FAILED(hr))
1306 return hr;
1307
1308 while(IEnumMoniker_Next(ppEnumMoniker, 1, &IMon, &nb) == S_OK)
1309 {
1310 IMoniker_Release(IMon);
1311 nb_mon++;
1312 }
1313
1314 if (!nb_mon)
1315 {
1316 IEnumMoniker_Release(ppEnumMoniker);
1317 return IEnumRegFiltersImpl_Construct(NULL, 0, ppEnum);
1318 }
1319
1320 regfilters = CoTaskMemAlloc(nb_mon * sizeof(REGFILTER));
1321 if (!regfilters)
1322 {
1323 IEnumMoniker_Release(ppEnumMoniker);
1324 return E_OUTOFMEMORY;
1325 }
1326 ZeroMemory(regfilters, nb_mon * sizeof(REGFILTER)); /* will prevent bad free of Name in case of error. */
1327
1328 IEnumMoniker_Reset(ppEnumMoniker);
1329 while(IEnumMoniker_Next(ppEnumMoniker, 1, &IMon, &nb) == S_OK)
1330 {
1331 IPropertyBag * pPropBagCat = NULL;
1332 VARIANT var;
1333 HRESULT hrSub;
1334 GUID clsid;
1335 int len;
1336
1337 VariantInit(&var);
1338
1339 hrSub = IMoniker_BindToStorage(IMon, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
1340
1341 if (SUCCEEDED(hrSub))
1342 hrSub = IPropertyBag_Read(pPropBagCat, wszClsidName, &var, NULL);
1343
1344 if (SUCCEEDED(hrSub))
1345 hrSub = CLSIDFromString(V_UNION(&var, bstrVal), &clsid);
1346
1347 VariantClear(&var);
1348
1349 if (SUCCEEDED(hrSub))
1350 hrSub = IPropertyBag_Read(pPropBagCat, wszFriendlyName, &var, NULL);
1351
1352 if (SUCCEEDED(hrSub))
1353 {
1354 len = (strlenW(V_UNION(&var, bstrVal))+1) * sizeof(WCHAR);
1355 if (!(regfilters[idx].Name = CoTaskMemAlloc(len*2)))
1356 hr = E_OUTOFMEMORY;
1357 }
1358
1359 if (SUCCEEDED(hrSub) && regfilters[idx].Name)
1360 {
1361 memcpy(regfilters[idx].Name, V_UNION(&var, bstrVal), len);
1362 regfilters[idx].Clsid = clsid;
1363 idx++;
1364 }
1365
1366 if (pPropBagCat)
1367 IPropertyBag_Release(pPropBagCat);
1368 IMoniker_Release(IMon);
1369 VariantClear(&var);
1370 }
1371
1372 if (SUCCEEDED(hr))
1373 {
1374 hr = IEnumRegFiltersImpl_Construct(regfilters, nb_mon, ppEnum);
1375 }
1376
1377 for (idx = 0; idx < nb_mon; idx++)
1378 CoTaskMemFree(regfilters[idx].Name);
1379 CoTaskMemFree(regfilters);
1380 IEnumMoniker_Release(ppEnumMoniker);
1381
1382 return hr;
1383 }
1384
1385
1386 static HRESULT WINAPI FilterMapper_RegisterFilter(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, DWORD dwMerit)
1387 {
1388 HRESULT hr;
1389 LPWSTR wszClsid = NULL;
1390 HKEY hKey;
1391 LONG lRet;
1392 WCHAR wszKeyName[ARRAYSIZE(wszFilterSlash)-1 + (CHARS_IN_GUID-1) + 1];
1393
1394 TRACE("(%p)->(%s, %s, %x)\n", iface, debugstr_guid(&clsid), debugstr_w(szName), dwMerit);
1395
1396 hr = StringFromCLSID(&clsid, &wszClsid);
1397
1398 if (SUCCEEDED(hr))
1399 {
1400 strcpyW(wszKeyName, wszFilterSlash);
1401 strcatW(wszKeyName, wszClsid);
1402
1403 lRet = RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
1404 hr = HRESULT_FROM_WIN32(lRet);
1405 }
1406
1407 if (SUCCEEDED(hr))
1408 {
1409 lRet = RegSetValueExW(hKey, NULL, 0, REG_SZ, (const BYTE*)szName, (strlenW(szName) + 1) * sizeof(WCHAR));
1410 hr = HRESULT_FROM_WIN32(lRet);
1411 CloseHandle(hKey);
1412 }
1413
1414 if (SUCCEEDED(hr))
1415 {
1416 strcpyW(wszKeyName, wszClsidSlash);
1417 strcatW(wszKeyName, wszClsid);
1418
1419 lRet = RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
1420 hr = HRESULT_FROM_WIN32(lRet);
1421 }
1422
1423 if (SUCCEEDED(hr))
1424 {
1425 lRet = RegSetValueExW(hKey, wszMeritName, 0, REG_DWORD, (LPBYTE)&dwMerit, sizeof(dwMerit));
1426 hr = HRESULT_FROM_WIN32(lRet);
1427 CloseHandle(hKey);
1428 }
1429
1430 CoTaskMemFree(wszClsid);
1431
1432 return hr;
1433 }
1434
1435 static HRESULT WINAPI FilterMapper_RegisterFilterInstance(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, CLSID *MRId)
1436 {
1437 TRACE("(%p)->(%s, %s, %p)\n", iface, debugstr_guid(&clsid), debugstr_w(szName), MRId);
1438
1439 /* Not implemented in Windows (tested on Win2k) */
1440
1441 return E_NOTIMPL;
1442 }
1443
1444 static HRESULT WINAPI FilterMapper_RegisterPin(
1445 IFilterMapper * iface,
1446 CLSID Filter,
1447 LPCWSTR szName,
1448 BOOL bRendered,
1449 BOOL bOutput,
1450 BOOL bZero,
1451 BOOL bMany,
1452 CLSID ConnectsToFilter,
1453 LPCWSTR ConnectsToPin)
1454 {
1455 HRESULT hr;
1456 LONG lRet;
1457 LPWSTR wszClsid = NULL;
1458 HKEY hKey = NULL;
1459 HKEY hPinsKey = NULL;
1460 WCHAR * wszPinsKeyName;
1461 WCHAR wszKeyName[ARRAYSIZE(wszClsidSlash)-1 + (CHARS_IN_GUID-1) + 1];
1462
1463 TRACE("(%p)->(%s, %s, %d, %d, %d, %d, %s, %s)\n", iface, debugstr_guid(&Filter), debugstr_w(szName), bRendered,
1464 bOutput, bZero, bMany, debugstr_guid(&ConnectsToFilter), debugstr_w(ConnectsToPin));
1465
1466 hr = StringFromCLSID(&Filter, &wszClsid);
1467
1468 if (SUCCEEDED(hr))
1469 {
1470 strcpyW(wszKeyName, wszClsidSlash);
1471 strcatW(wszKeyName, wszClsid);
1472
1473 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey);
1474 hr = HRESULT_FROM_WIN32(lRet);
1475 }
1476
1477 if (SUCCEEDED(hr))
1478 {
1479 wszPinsKeyName = CoTaskMemAlloc((strlenW(wszPins) + 1 + strlenW(szName) + 1) * 2);
1480 if (!wszPinsKeyName)
1481 hr = E_OUTOFMEMORY;
1482 }
1483
1484 if (SUCCEEDED(hr))
1485 {
1486 strcpyW(wszPinsKeyName, wszPins);
1487 strcatW(wszPinsKeyName, wszSlash);
1488 strcatW(wszPinsKeyName, szName);
1489
1490 lRet = RegCreateKeyExW(hKey, wszPinsKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hPinsKey, NULL);
1491 hr = HRESULT_FROM_WIN32(lRet);
1492 CoTaskMemFree(wszPinsKeyName);
1493 }
1494
1495 if (SUCCEEDED(hr))
1496 {
1497 lRet = RegSetValueExW(hPinsKey, wszAllowedMany, 0, REG_DWORD, (LPBYTE)&bMany, sizeof(bMany));
1498 hr = HRESULT_FROM_WIN32(lRet);
1499 }
1500
1501 if (SUCCEEDED(hr))
1502 {
1503 lRet = RegSetValueExW(hPinsKey, wszAllowedZero, 0, REG_DWORD, (LPBYTE)&bZero, sizeof(bZero));
1504 hr = HRESULT_FROM_WIN32(lRet);
1505 }
1506
1507 if (SUCCEEDED(hr))
1508 {
1509 lRet = RegSetValueExW(hPinsKey, wszDirection, 0, REG_DWORD, (LPBYTE)&bOutput, sizeof(bOutput));
1510 hr = HRESULT_FROM_WIN32(lRet);
1511 }
1512
1513 if (SUCCEEDED(hr))
1514 {
1515 lRet = RegSetValueExW(hPinsKey, wszIsRendered, 0, REG_DWORD, (LPBYTE)&bRendered, sizeof(bRendered));
1516 hr = HRESULT_FROM_WIN32(lRet);
1517 }
1518
1519 if (SUCCEEDED(hr))
1520 {
1521 HKEY hkeyDummy = NULL;
1522
1523 lRet = RegCreateKeyExW(hPinsKey, wszTypes, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkeyDummy, NULL);
1524 hr = HRESULT_FROM_WIN32(lRet);
1525
1526 if (hkeyDummy) RegCloseKey(hkeyDummy);
1527 }
1528
1529 CoTaskMemFree(wszClsid);
1530 if (hKey)
1531 CloseHandle(hKey);
1532 if (hPinsKey)
1533 CloseHandle(hPinsKey);
1534
1535 return hr;
1536 }
1537
1538
1539 static HRESULT WINAPI FilterMapper_RegisterPinType(
1540 IFilterMapper * iface,
1541 CLSID clsFilter,
1542 LPCWSTR szName,
1543 CLSID clsMajorType,
1544 CLSID clsSubType)
1545 {
1546 HRESULT hr;
1547 LONG lRet;
1548 LPWSTR wszClsid = NULL;
1549 LPWSTR wszClsidMajorType = NULL;
1550 LPWSTR wszClsidSubType = NULL;
1551 HKEY hKey = NULL;
1552 WCHAR * wszTypesKey;
1553 WCHAR wszKeyName[MAX_PATH];
1554
1555 TRACE("(%p)->(%s, %s, %s, %s)\n", iface, debugstr_guid(&clsFilter), debugstr_w(szName),
1556 debugstr_guid(&clsMajorType), debugstr_guid(&clsSubType));
1557
1558 hr = StringFromCLSID(&clsFilter, &wszClsid);
1559
1560 if (SUCCEEDED(hr))
1561 {
1562 hr = StringFromCLSID(&clsMajorType, &wszClsidMajorType);
1563 }
1564
1565 if (SUCCEEDED(hr))
1566 {
1567 hr = StringFromCLSID(&clsSubType, &wszClsidSubType);
1568 }
1569
1570 if (SUCCEEDED(hr))
1571 {
1572 wszTypesKey = CoTaskMemAlloc((strlenW(wszClsidSlash) + strlenW(wszClsid) + strlenW(wszPins) +
1573 strlenW(szName) + strlenW(wszTypes) + 3 + 1) * 2);
1574 if (!wszTypesKey)
1575 hr = E_OUTOFMEMORY;
1576 }
1577
1578 if (SUCCEEDED(hr))
1579 {
1580 strcpyW(wszTypesKey, wszClsidSlash);
1581 strcatW(wszTypesKey, wszClsid);
1582 strcatW(wszTypesKey, wszSlash);
1583 strcatW(wszTypesKey, wszPins);
1584 strcatW(wszTypesKey, wszSlash);
1585 strcatW(wszTypesKey, szName);
1586 strcatW(wszTypesKey, wszSlash);
1587 strcatW(wszTypesKey, wszTypes);
1588
1589 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszTypesKey, 0, KEY_WRITE, &hKey);
1590 hr = HRESULT_FROM_WIN32(lRet);
1591 CoTaskMemFree(wszTypesKey);
1592 }
1593
1594 if (SUCCEEDED(hr))
1595 {
1596 HKEY hkeyDummy = NULL;
1597
1598 strcpyW(wszKeyName, wszClsidMajorType);
1599 strcatW(wszKeyName, wszSlash);
1600 strcatW(wszKeyName, wszClsidSubType);
1601
1602 lRet = RegCreateKeyExW(hKey, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkeyDummy, NULL);
1603 hr = HRESULT_FROM_WIN32(lRet);
1604 CloseHandle(hKey);
1605
1606 if (hkeyDummy) RegCloseKey(hkeyDummy);
1607 }
1608
1609 CoTaskMemFree(wszClsid);
1610 CoTaskMemFree(wszClsidMajorType);
1611 CoTaskMemFree(wszClsidSubType);
1612
1613 return hr;
1614 }
1615
1616 static HRESULT WINAPI FilterMapper_UnregisterFilter(IFilterMapper * iface, CLSID Filter)
1617 {
1618 HRESULT hr;
1619 LONG lRet;
1620 LPWSTR wszClsid = NULL;
1621 HKEY hKey;
1622 WCHAR wszKeyName[ARRAYSIZE(wszClsidSlash)-1 + (CHARS_IN_GUID-1) + 1];
1623
1624 TRACE("(%p)->(%s)\n", iface, debugstr_guid(&Filter));
1625
1626 hr = StringFromCLSID(&Filter, &wszClsid);
1627
1628 if (SUCCEEDED(hr))
1629 {
1630 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszFilter, 0, KEY_WRITE, &hKey);
1631 hr = HRESULT_FROM_WIN32(lRet);
1632 }
1633
1634 if (SUCCEEDED(hr))
1635 {
1636 lRet = RegDeleteKeyW(hKey, wszClsid);
1637 hr = HRESULT_FROM_WIN32(lRet);
1638 CloseHandle(hKey);
1639 }
1640
1641 if (SUCCEEDED(hr))
1642 {
1643 strcpyW(wszKeyName, wszClsidSlash);
1644 strcatW(wszKeyName, wszClsid);
1645
1646 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey);
1647 hr = HRESULT_FROM_WIN32(lRet);
1648 }
1649
1650 if (SUCCEEDED(hr))
1651 {
1652 lRet = RegDeleteValueW(hKey, wszMeritName);
1653 if (lRet != ERROR_SUCCESS)
1654 hr = HRESULT_FROM_WIN32(lRet);
1655
1656 lRet = RegDeleteTreeW(hKey, wszPins);
1657 if (lRet != ERROR_SUCCESS)
1658 hr = HRESULT_FROM_WIN32(lRet);
1659
1660 CloseHandle(hKey);
1661 }
1662
1663 CoTaskMemFree(wszClsid);
1664
1665 return hr;
1666 }
1667
1668 static HRESULT WINAPI FilterMapper_UnregisterFilterInstance(IFilterMapper * iface, CLSID MRId)
1669 {
1670 TRACE("(%p)->(%s)\n", iface, debugstr_guid(&MRId));
1671
1672 /* Not implemented in Windows (tested on Win2k) */
1673
1674 return E_NOTIMPL;
1675 }
1676
1677 static HRESULT WINAPI FilterMapper_UnregisterPin(IFilterMapper * iface, CLSID Filter, LPCWSTR Name)
1678 {
1679 HRESULT hr;
1680 LONG lRet;
1681 LPWSTR wszClsid = NULL;
1682 HKEY hKey = NULL;
1683 WCHAR * wszPinNameKey;
1684 WCHAR wszKeyName[ARRAYSIZE(wszClsidSlash)-1 + (CHARS_IN_GUID-1) + 1];
1685
1686 TRACE("(%p)->(%s, %s)\n", iface, debugstr_guid(&Filter), debugstr_w(Name));
1687
1688 if (!Name)
1689 return E_INVALIDARG;
1690
1691 hr = StringFromCLSID(&Filter, &wszClsid);
1692
1693 if (SUCCEEDED(hr))
1694 {
1695 strcpyW(wszKeyName, wszClsidSlash);
1696 strcatW(wszKeyName, wszClsid);
1697
1698 lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey);
1699 hr = HRESULT_FROM_WIN32(lRet);
1700 }
1701
1702 if (SUCCEEDED(hr))
1703 {
1704 wszPinNameKey = CoTaskMemAlloc((strlenW(wszPins) + 1 + strlenW(Name) + 1) * 2);
1705 if (!wszPinNameKey)
1706 hr = E_OUTOFMEMORY;
1707 }
1708
1709 if (SUCCEEDED(hr))
1710 {
1711 strcpyW(wszPinNameKey, wszPins);
1712 strcatW(wszPinNameKey, wszSlash);
1713 strcatW(wszPinNameKey, Name);
1714
1715 lRet = RegDeleteTreeW(hKey, wszPinNameKey);
1716 hr = HRESULT_FROM_WIN32(lRet);
1717 CoTaskMemFree(wszPinNameKey);
1718 }
1719
1720 CoTaskMemFree(wszClsid);
1721 if (hKey)
1722 CloseHandle(hKey);
1723
1724 return hr;
1725 }
1726
1727 static const IFilterMapperVtbl fmvtbl =
1728 {
1729
1730 FilterMapper_QueryInterface,
1731 FilterMapper_AddRef,
1732 FilterMapper_Release,
1733
1734 FilterMapper_RegisterFilter,
1735 FilterMapper_RegisterFilterInstance,
1736 FilterMapper_RegisterPin,
1737 FilterMapper_RegisterPinType,
1738 FilterMapper_UnregisterFilter,
1739 FilterMapper_UnregisterFilterInstance,
1740 FilterMapper_UnregisterPin,
1741 FilterMapper_EnumMatchingFilters
1742 };
1743
1744
1745 /*** IUnknown methods ***/
1746 static HRESULT WINAPI AMFilterData_QueryInterface(IAMFilterData * iface, REFIID riid, LPVOID *ppv)
1747 {
1748 FilterMapper2Impl *This = impl_from_IAMFilterData(iface);
1749
1750 return FilterMapper2_QueryInterface((IFilterMapper2*)This, riid, ppv);
1751 }
1752
1753 static ULONG WINAPI AMFilterData_AddRef(IAMFilterData * iface)
1754 {
1755 FilterMapper2Impl *This = impl_from_IAMFilterData(iface);
1756
1757 return FilterMapper2_AddRef((IFilterMapper2*)This);
1758 }
1759
1760 static ULONG WINAPI AMFilterData_Release(IAMFilterData * iface)
1761 {
1762 FilterMapper2Impl *This = impl_from_IAMFilterData(iface);
1763
1764 return FilterMapper2_Release((IFilterMapper2*)This);
1765 }
1766
1767 /*** IAMFilterData methods ***/
1768 static HRESULT WINAPI AMFilterData_ParseFilterData(IAMFilterData* iface,
1769 BYTE *pData, ULONG cb,
1770 BYTE **ppRegFilter2)
1771 {
1772 FilterMapper2Impl *This = impl_from_IAMFilterData(iface);
1773 HRESULT hr = S_OK;
1774 REGFILTER2 *prf2;
1775
1776 TRACE("(%p/%p)->(%p, %d, %p)\n", This, iface, pData, cb, ppRegFilter2);
1777
1778 prf2 = CoTaskMemAlloc(sizeof(*prf2));
1779 if (!prf2)
1780 return E_OUTOFMEMORY;
1781 *ppRegFilter2 = (BYTE *)&prf2;
1782
1783 hr = FM2_ReadFilterData(pData, prf2);
1784 if (FAILED(hr))
1785 {
1786 CoTaskMemFree(prf2);
1787 *ppRegFilter2 = NULL;
1788 }
1789
1790 return hr;
1791 }
1792
1793 static HRESULT WINAPI AMFilterData_CreateFilterData(IAMFilterData* iface,
1794 REGFILTER2 *prf2,
1795 BYTE **pRegFilterData,
1796 ULONG *pcb)
1797 {
1798 FilterMapper2Impl *This = impl_from_IAMFilterData(iface);
1799
1800 TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, prf2, pRegFilterData, pcb);
1801
1802 return FM2_WriteFilterData(prf2, pRegFilterData, pcb);
1803 }
1804
1805 static const IAMFilterDataVtbl AMFilterDataVtbl = {
1806 AMFilterData_QueryInterface,
1807 AMFilterData_AddRef,
1808 AMFilterData_Release,
1809 AMFilterData_ParseFilterData,
1810 AMFilterData_CreateFilterData
1811 };