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