2 * IFilterMapper & IFilterMapper2 Implementations
4 * Copyright 2003 Robert Shearman
5 * Copyright 2004 Christian Costa
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
32 #include "quartz_private.h"
34 #define COM_NO_WINDOWS_H
38 #include "wine/unicode.h"
41 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
45 typedef struct FilterMapper2Impl
47 IFilterMapper2Vtbl *lpVtbl;
48 IFilterMapperVtbl *lpVtblFilterMapper;
52 static struct IFilterMapper2Vtbl fm2vtbl;
53 static struct IFilterMapperVtbl fmvtbl;
55 #define _IFilterMapper_Offset ((int)(&(((FilterMapper2Impl*)0)->lpVtblFilterMapper)))
56 #define ICOM_THIS_From_IFilterMapper(impl, iface) impl* This = (impl*)(((char*)iface)-_IFilterMapper_Offset)
58 static const WCHAR wszClsidSlash[] = {'C','L','S','I','D','\\',0};
59 static const WCHAR wszSlashInstance[] = {'\\','I','n','s','t','a','n','c','e','\\',0};
60 static const WCHAR wszSlash[] = {'\\',0};
62 /* CLSID property in media category Moniker */
63 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
64 /* FriendlyName property in media category Moniker */
65 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
66 /* Merit property in media category Moniker (CLSID_ActiveMovieCategories only) */
67 static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};
68 /* FilterData property in media category Moniker (not CLSID_ActiveMovieCategories) */
69 static const WCHAR wszFilterDataName[] = {'F','i','l','t','e','r','D','a','t','a',0};
70 /* For filters registered with IFilterMapper */
71 static const WCHAR wszFilterSlash[] = {'F','i','l','t','e','r','\\',0};
72 static const WCHAR wszFilter[] = {'F','i','l','t','e','r',0};
73 /* For pins registered with IFilterMapper */
74 static const WCHAR wszPins[] = {'P','i','n','s',0};
75 static const WCHAR wszAllowedMany[] = {'A','l','l','o','w','e','d','M','a','n','y',0};
76 static const WCHAR wszAllowedZero[] = {'A','l','l','o','w','e','d','Z','e','r','o',0};
77 static const WCHAR wszDirection[] = {'D','i','r','e','c','t','i','o','n',0};
78 static const WCHAR wszIsRendered[] = {'I','s','R','e','n','d','e','r','e','d',0};
79 /* For types registered with IFilterMapper */
80 static const WCHAR wszTypes[] = {'T','y','p','e','s',0};
83 /* registry format for REGFILTER2 */
94 BYTE signature[4]; /* e.g. "0pi3" */
99 DWORD bCategory; /* is there a category clsid? */
100 /* optional: dwOffsetCategoryClsid */
105 BYTE signature[4]; /* e.g. "0ty3" */
120 int capacity; /* in bytes */
121 int current; /* pointer to next free byte */
124 /* returns the position it was added at */
125 static int add_data(struct Vector * v, const BYTE * pData, int size)
127 int index = v->current;
128 if (v->current + size > v->capacity)
130 LPBYTE pOldData = v->pData;
131 v->capacity = (v->capacity + size) * 2;
132 v->pData = CoTaskMemAlloc(v->capacity);
133 memcpy(v->pData, pOldData, v->current);
134 CoTaskMemFree(pOldData);
136 memcpy(v->pData + v->current, pData, size);
141 static int find_data(struct Vector * v, const BYTE * pData, int size)
144 for (index = 0; index < v->current; index++)
145 if (!memcmp(v->pData + index, pData, size))
151 static void delete_vector(struct Vector * v)
154 CoTaskMemFree(v->pData);
159 HRESULT FilterMapper2_create(IUnknown *pUnkOuter, LPVOID *ppObj)
161 FilterMapper2Impl * pFM2impl;
163 TRACE("(%p, %p)\n", pUnkOuter, ppObj);
166 return CLASS_E_NOAGGREGATION;
168 pFM2impl = CoTaskMemAlloc(sizeof(*pFM2impl));
170 return E_OUTOFMEMORY;
172 pFM2impl->lpVtbl = &fm2vtbl;
173 pFM2impl->lpVtblFilterMapper = &fmvtbl;
174 pFM2impl->refCount = 1;
178 TRACE("-- created at %p\n", pFM2impl);
183 /*** IUnknown methods ***/
185 static HRESULT WINAPI FilterMapper2_QueryInterface(IFilterMapper2 * iface, REFIID riid, LPVOID *ppv)
187 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
189 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
193 if (IsEqualIID(riid, &IID_IUnknown))
195 else if (IsEqualIID(riid, &IID_IFilterMapper2))
197 else if (IsEqualIID(riid, &IID_IFilterMapper))
198 *ppv = &This->lpVtblFilterMapper;
202 IUnknown_AddRef((IUnknown *)*ppv);
206 FIXME("No interface for %s\n", debugstr_guid(riid));
207 return E_NOINTERFACE;
210 static ULONG WINAPI FilterMapper2_AddRef(IFilterMapper2 * iface)
212 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
213 ULONG refCount = InterlockedIncrement(&This->refCount);
215 TRACE("(%p)->()\n", iface);
220 static ULONG WINAPI FilterMapper2_Release(IFilterMapper2 * iface)
222 FilterMapper2Impl *This = (FilterMapper2Impl *)iface;
223 ULONG refCount = InterlockedDecrement(&This->refCount);
225 TRACE("(%p)->()\n", iface);
235 /*** IFilterMapper2 methods ***/
237 static HRESULT WINAPI FilterMapper2_CreateCategory(
238 IFilterMapper2 * iface,
239 REFCLSID clsidCategory,
240 DWORD dwCategoryMerit,
241 LPCWSTR szDescription)
243 LPWSTR wClsidAMCat = NULL;
244 LPWSTR wClsidCategory = NULL;
245 WCHAR wszKeyName[strlenW(wszClsidSlash) + strlenW(wszSlashInstance) + (CHARS_IN_GUID-1) * 2 + 1];
249 TRACE("(%s, %lx, %s)\n", debugstr_guid(clsidCategory), dwCategoryMerit, debugstr_w(szDescription));
251 hr = StringFromCLSID(&CLSID_ActiveMovieCategories, &wClsidAMCat);
255 hr = StringFromCLSID(clsidCategory, &wClsidCategory);
260 strcpyW(wszKeyName, wszClsidSlash);
261 strcatW(wszKeyName, wClsidAMCat);
262 strcatW(wszKeyName, wszSlashInstance);
263 strcatW(wszKeyName, wClsidCategory);
265 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL));
270 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszFriendlyName, 0, REG_SZ, (const BYTE*)szDescription, (strlenW(szDescription) + 1) * sizeof(WCHAR)));
275 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszClsidName, 0, REG_SZ, (LPBYTE)wClsidCategory, (strlenW(wClsidCategory) + 1) * sizeof(WCHAR)));
280 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszMeritName, 0, REG_DWORD, (LPBYTE)&dwCategoryMerit, sizeof(dwCategoryMerit)));
286 CoTaskMemFree(wClsidCategory);
288 CoTaskMemFree(wClsidAMCat);
293 static HRESULT WINAPI FilterMapper2_UnregisterFilter(
294 IFilterMapper2 * iface,
295 const CLSID *pclsidCategory,
296 const OLECHAR *szInstance,
299 WCHAR wszKeyName[MAX_PATH];
300 LPWSTR wClsidCategory = NULL;
301 LPWSTR wFilter = NULL;
304 TRACE("(%p, %s, %s)\n", pclsidCategory, debugstr_w(szInstance), debugstr_guid(Filter));
307 pclsidCategory = &CLSID_LegacyAmFilterCategory;
309 hr = StringFromCLSID(pclsidCategory, &wClsidCategory);
313 strcpyW(wszKeyName, wszClsidSlash);
314 strcatW(wszKeyName, wClsidCategory);
315 strcatW(wszKeyName, wszSlashInstance);
317 strcatW(wszKeyName, szInstance);
320 hr = StringFromCLSID(Filter, &wFilter);
322 strcatW(wszKeyName, wFilter);
328 hr = HRESULT_FROM_WIN32(RegDeleteKeyW(HKEY_CLASSES_ROOT, wszKeyName));
332 CoTaskMemFree(wClsidCategory);
334 CoTaskMemFree(wFilter);
339 static HRESULT FM2_WriteFriendlyName(IPropertyBag * pPropBag, LPCWSTR szName)
343 V_VT(&var) = VT_BSTR;
344 V_UNION(&var, bstrVal) = (BSTR)szName;
346 return IPropertyBag_Write(pPropBag, wszFriendlyName, &var);
349 static HRESULT FM2_WriteClsid(IPropertyBag * pPropBag, REFCLSID clsid)
351 LPWSTR wszClsid = NULL;
355 hr = StringFromCLSID(clsid, &wszClsid);
359 V_VT(&var) = VT_BSTR;
360 V_UNION(&var, bstrVal) = wszClsid;
361 hr = IPropertyBag_Write(pPropBag, wszClsidName, &var);
364 CoTaskMemFree(wszClsid);
368 static HRESULT FM2_WriteFilterData(IPropertyBag * pPropBag, const REGFILTER2 * prf2)
371 int size = sizeof(struct REG_RF);
373 struct Vector mainStore = {NULL, 0, 0};
374 struct Vector clsidStore = {NULL, 0, 0};
377 SAFEARRAYBOUND saBound;
380 rrf.dwVersion = prf2->dwVersion;
381 rrf.dwMerit = prf2->dwMerit;
382 rrf.dwPins = prf2->u.s1.cPins2;
385 add_data(&mainStore, (LPBYTE)&rrf, sizeof(rrf));
387 for (i = 0; i < prf2->u.s1.cPins2; i++)
389 size += sizeof(struct REG_RFP);
390 if (prf2->u.s1.rgPins2[i].clsPinCategory)
391 size += sizeof(DWORD);
392 size += prf2->u.s1.rgPins2[i].nMediaTypes * sizeof(struct REG_TYPE);
393 size += prf2->u.s1.rgPins2[i].nMediums * sizeof(DWORD);
396 for (i = 0; i < prf2->u.s1.cPins2; i++)
399 REGFILTERPINS2 rgPin2 = prf2->u.s1.rgPins2[i];
402 rrfp.signature[0] = '0';
403 rrfp.signature[1] = 'p';
404 rrfp.signature[2] = 'i';
405 rrfp.signature[3] = '3';
406 rrfp.signature[0] += i;
407 rrfp.dwFlags = rgPin2.dwFlags;
408 rrfp.dwInstances = rgPin2.cInstances;
409 rrfp.dwMediaTypes = rgPin2.nMediaTypes;
410 rrfp.dwMediums = rgPin2.nMediums;
411 rrfp.bCategory = rgPin2.clsPinCategory ? 1 : 0;
413 add_data(&mainStore, (LPBYTE)&rrfp, sizeof(rrfp));
416 DWORD index = find_data(&clsidStore, (const BYTE*)rgPin2.clsPinCategory, sizeof(CLSID));
418 index = add_data(&clsidStore, (const BYTE*)rgPin2.clsPinCategory, sizeof(CLSID));
421 add_data(&mainStore, (LPBYTE)&index, sizeof(index));
424 for (j = 0; j < rgPin2.nMediaTypes; j++)
427 rt.signature[0] = '0';
428 rt.signature[1] = 't';
429 rt.signature[2] = 'y';
430 rt.signature[3] = '3';
431 rt.signature[0] += j;
434 rt.dwOffsetMajor = find_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
435 if (rt.dwOffsetMajor == -1)
436 rt.dwOffsetMajor = add_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
437 rt.dwOffsetMajor += size;
438 rt.dwOffsetMinor = find_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMinorType, sizeof(CLSID));
439 if (rt.dwOffsetMinor == -1)
440 rt.dwOffsetMinor = add_data(&clsidStore, (const BYTE*)rgPin2.lpMediaType[j].clsMinorType, sizeof(CLSID));
441 rt.dwOffsetMinor += size;
443 add_data(&mainStore, (LPBYTE)&rt, sizeof(rt));
446 for (j = 0; j < rgPin2.nMediums; j++)
448 DWORD index = find_data(&clsidStore, (const BYTE*)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
450 index = add_data(&clsidStore, (const BYTE*)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
453 add_data(&mainStore, (LPBYTE)&index, sizeof(index));
458 saBound.cElements = mainStore.current + clsidStore.current;
459 psa = SafeArrayCreate(VT_UI1, 1, &saBound);
462 ERR("Couldn't create SAFEARRAY\n");
469 hr = SafeArrayAccessData(psa, (LPVOID *)&pbSAData);
472 memcpy(pbSAData, mainStore.pData, mainStore.current);
473 memcpy(pbSAData + mainStore.current, clsidStore.pData, clsidStore.current);
474 hr = SafeArrayUnaccessData(psa);
478 V_VT(&var) = VT_ARRAY | VT_UI1;
479 V_UNION(&var, parray) = psa;
482 hr = IPropertyBag_Write(pPropBag, wszFilterDataName, &var);
485 SafeArrayDestroy(psa);
487 delete_vector(&mainStore);
488 delete_vector(&clsidStore);
492 static HRESULT FM2_ReadFilterData(IPropertyBag * pPropBag, REGFILTER2 * prf2)
497 struct REG_RF * prrf;
500 REGFILTERPINS2 * rgPins2;
503 V_VT(&var) = VT_ARRAY | VT_UI1;
505 hr = IPropertyBag_Read(pPropBag, wszFilterDataName, &var, NULL);
508 hr = SafeArrayAccessData(V_UNION(&var, parray), (LPVOID*)&pData);
512 prrf = (struct REG_RF *)pData;
515 if (prrf->dwVersion != 2)
517 FIXME("Filter registry version %ld not supported\n", prrf->dwVersion);
518 ZeroMemory(prf2, sizeof(*prf2));
525 TRACE("version = %ld, merit = %lx, #pins = %ld, unused = %lx\n",
526 prrf->dwVersion, prrf->dwMerit, prrf->dwPins, prrf->dwUnused);
528 prf2->dwVersion = prrf->dwVersion;
529 prf2->dwMerit = prrf->dwMerit;
530 prf2->u.s1.cPins2 = prrf->dwPins;
531 rgPins2 = CoTaskMemAlloc(prrf->dwPins * sizeof(*rgPins2));
532 prf2->u.s1.rgPins2 = rgPins2;
533 pCurrent += sizeof(struct REG_RF);
535 for (i = 0; i < prrf->dwPins; i++)
537 struct REG_RFP * prrfp = (struct REG_RFP *)pCurrent;
538 REGPINTYPES * lpMediaType;
539 REGPINMEDIUM * lpMedium;
542 /* FIXME: check signature */
544 TRACE("\tsignature = %s\n", debugstr_an(prrfp->signature, 4));
546 TRACE("\tpin[%ld]: flags = %lx, instances = %ld, media types = %ld, mediums = %ld\n",
547 i, prrfp->dwFlags, prrfp->dwInstances, prrfp->dwMediaTypes, prrfp->dwMediums);
549 rgPins2[i].dwFlags = prrfp->dwFlags;
550 rgPins2[i].cInstances = prrfp->dwInstances;
551 rgPins2[i].nMediaTypes = prrfp->dwMediaTypes;
552 rgPins2[i].nMediums = prrfp->dwMediums;
553 pCurrent += sizeof(struct REG_RFP);
554 if (prrfp->bCategory)
556 CLSID * clsCat = CoTaskMemAlloc(sizeof(CLSID));
557 memcpy(clsCat, pData + *(DWORD*)(pCurrent), sizeof(CLSID));
558 pCurrent += sizeof(DWORD);
559 rgPins2[i].clsPinCategory = clsCat;
562 rgPins2[i].clsPinCategory = NULL;
564 if (rgPins2[i].nMediaTypes > 0)
565 lpMediaType = CoTaskMemAlloc(rgPins2[i].nMediaTypes * sizeof(*lpMediaType));
569 rgPins2[i].lpMediaType = lpMediaType;
571 for (j = 0; j < rgPins2[i].nMediaTypes; j++)
573 struct REG_TYPE * prt = (struct REG_TYPE *)pCurrent;
574 CLSID * clsMajor = CoTaskMemAlloc(sizeof(CLSID));
575 CLSID * clsMinor = CoTaskMemAlloc(sizeof(CLSID));
577 /* FIXME: check signature */
578 TRACE("\t\tsignature = %s\n", debugstr_an(prt->signature, 4));
580 memcpy(clsMajor, pData + prt->dwOffsetMajor, sizeof(CLSID));
581 memcpy(clsMinor, pData + prt->dwOffsetMinor, sizeof(CLSID));
583 lpMediaType[j].clsMajorType = clsMajor;
584 lpMediaType[j].clsMinorType = clsMinor;
586 pCurrent += sizeof(*prt);
589 if (rgPins2[i].nMediums > 0)
590 lpMedium = CoTaskMemAlloc(rgPins2[i].nMediums * sizeof(*lpMedium));
594 rgPins2[i].lpMedium = lpMedium;
596 for (j = 0; j < rgPins2[i].nMediums; j++)
598 DWORD dwOffset = *(DWORD *)pCurrent;
600 memcpy(lpMedium + j, pData + dwOffset, sizeof(REGPINMEDIUM));
602 pCurrent += sizeof(dwOffset);
609 SafeArrayUnaccessData(V_UNION(&var, parray));
616 static void FM2_DeleteRegFilter(REGFILTER2 * prf2)
619 for (i = 0; i < prf2->u.s1.cPins2; i++)
622 if (prf2->u.s1.rgPins2[i].clsPinCategory)
623 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].clsPinCategory);
625 for (j = 0; j < prf2->u.s1.rgPins2[i].nMediaTypes; j++)
627 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMajorType);
628 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMinorType);
630 CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMedium);
634 static HRESULT WINAPI FilterMapper2_RegisterFilter(
635 IFilterMapper2 * iface,
636 REFCLSID clsidFilter,
638 IMoniker **ppMoniker,
639 const CLSID *pclsidCategory,
640 const OLECHAR *szInstance,
641 const REGFILTER2 *prf2)
643 IParseDisplayName * pParser = NULL;
644 IBindCtx * pBindCtx = NULL;
645 IMoniker * pMoniker = NULL;
646 IPropertyBag * pPropBag = NULL;
648 LPWSTR pwszParseName = NULL;
650 static const WCHAR wszDevice[] = {'@','d','e','v','i','c','e',':','s','w',':',0};
653 LPWSTR szClsidTemp = NULL;
654 REGFILTER2 regfilter2;
655 REGFILTERPINS2* pregfp2 = NULL;
657 TRACE("(%s, %s, %p, %s, %s, %p)\n",
658 debugstr_guid(clsidFilter),
661 debugstr_guid(pclsidCategory),
662 debugstr_w(szInstance),
665 if (prf2->dwVersion == 2)
669 else if (prf2->dwVersion == 1)
673 /* REGFILTER2 structure is converted from version 1 to 2. Tested on Win2k. */
674 regfilter2.dwVersion = 2;
675 regfilter2.dwMerit = prf2->dwMerit;
676 regfilter2.u.s1.cPins2 = prf2->u.s.cPins;
677 pregfp2 = (REGFILTERPINS2*) CoTaskMemAlloc(prf2->u.s.cPins * sizeof(REGFILTERPINS2));
678 regfilter2.u.s1.rgPins2 = pregfp2;
679 for (i = 0; i < prf2->u.s.cPins; i++)
682 if (prf2->u.s.rgPins[i].bRendered)
683 flags |= REG_PINFLAG_B_RENDERER;
684 if (prf2->u.s.rgPins[i].bOutput)
685 flags |= REG_PINFLAG_B_OUTPUT;
686 if (prf2->u.s.rgPins[i].bZero)
687 flags |= REG_PINFLAG_B_ZERO;
688 if (prf2->u.s.rgPins[i].bMany)
689 flags |= REG_PINFLAG_B_MANY;
690 pregfp2[i].dwFlags = flags;
691 pregfp2[i].cInstances = 1;
692 pregfp2[i].nMediaTypes = prf2->u.s.rgPins[i].nMediaTypes;
693 pregfp2[i].lpMediaType = prf2->u.s.rgPins[i].lpMediaType;
694 pregfp2[i].nMediums = 0;
695 pregfp2[i].lpMedium = NULL;
696 pregfp2[i].clsPinCategory = NULL;
701 FIXME("dwVersion other that 1 or 2 not supported at the moment\n");
709 /* MSDN mentions the inexistent CLSID_ActiveMovieFilters GUID.
710 * In fact this is the CLSID_LegacyAmFilterCategory one */
711 pclsidCategory = &CLSID_LegacyAmFilterCategory;
713 /* sizeof... will include the null terminator and
714 * the + 1 is for the separator ('\\'). The -1 is
715 * because CHARS_IN_GUID includes the null terminator
717 nameLen = sizeof(wszDevice)/sizeof(wszDevice[0]) + CHARS_IN_GUID - 1 + 1;
720 nameLen += strlenW(szInstance);
722 nameLen += CHARS_IN_GUID - 1; /* CHARS_IN_GUID includes null terminator */
724 pCurrent = pwszParseName = CoTaskMemAlloc(nameLen*sizeof(WCHAR));
726 return E_OUTOFMEMORY;
728 strcpyW(pwszParseName, wszDevice);
729 pCurrent += strlenW(wszDevice);
731 hr = StringFromCLSID(pclsidCategory, &szClsidTemp);
735 memcpy(pCurrent, szClsidTemp, CHARS_IN_GUID * sizeof(WCHAR));
736 pCurrent += CHARS_IN_GUID - 1;
740 strcpyW(pCurrent+1, szInstance);
745 CoTaskMemFree(szClsidTemp);
748 hr = StringFromCLSID(clsidFilter, &szClsidTemp);
750 strcpyW(pCurrent+1, szClsidTemp);
755 hr = CoCreateInstance(&CLSID_CDeviceMoniker, NULL, CLSCTX_INPROC, &IID_IParseDisplayName, (LPVOID *)&pParser);
758 hr = CreateBindCtx(0, &pBindCtx);
761 hr = IParseDisplayName_ParseDisplayName(pParser, pBindCtx, pwszParseName, &ulEaten, &pMoniker);
764 IBindCtx_Release(pBindCtx);
766 IParseDisplayName_Release(pParser);
769 hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID)&pPropBag);
772 hr = FM2_WriteFriendlyName(pPropBag, szName);
775 hr = FM2_WriteClsid(pPropBag, clsidFilter);
778 hr = FM2_WriteFilterData(pPropBag, ®filter2);
781 IPropertyBag_Release(pPropBag);
783 CoTaskMemFree(szClsidTemp);
785 if (SUCCEEDED(hr) && ppMoniker)
786 *ppMoniker = pMoniker;
788 IMoniker_Release(pMoniker);
791 CoTaskMemFree(pregfp2);
793 TRACE("-- returning %lx\n", hr);
798 /* internal helper function */
799 static BOOL MatchTypes(
802 const REGPINTYPES * pPinTypes,
804 const GUID * pMatchTypes)
809 if ((nMatchTypes == 0) && (nPinTypes > 0))
812 for (j = 0; j < nPinTypes; j++)
815 for (i = 0; i < nMatchTypes*2; i+=2)
817 if (((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMajorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMajorType, &pMatchTypes[i])) &&
818 ((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMinorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i+1], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMinorType, &pMatchTypes[i+1])))
828 /* internal helper function for qsort of MONIKER_MERIT array */
829 static int mm_compare(const void * left, const void * right)
831 const struct MONIKER_MERIT * mmLeft = (const struct MONIKER_MERIT *)left;
832 const struct MONIKER_MERIT * mmRight = (const struct MONIKER_MERIT *)right;
834 if (mmLeft->dwMerit == mmRight->dwMerit)
836 if (mmLeft->dwMerit > mmRight->dwMerit)
842 * Exact match means whether or not to treat GUID_NULL's in filter data as wild cards
843 * (GUID_NULL's in input to function automatically treated as wild cards)
844 * Input/Output needed means match only on criteria if TRUE (with zero input types
845 * meaning match any input/output pin as long as one exists), otherwise match any
846 * filter that meets the rest of the requirements.
848 static HRESULT WINAPI FilterMapper2_EnumMatchingFilters(
849 IFilterMapper2 * iface,
850 IEnumMoniker **ppEnum,
856 const GUID *pInputTypes,
857 const REGPINMEDIUM *pMedIn,
858 const CLSID *pPinCategoryIn,
862 const GUID *pOutputTypes,
863 const REGPINMEDIUM *pMedOut,
864 const CLSID *pPinCategoryOut)
866 ICreateDevEnum * pCreateDevEnum;
867 IMoniker * pMonikerCat;
868 IEnumMoniker * pEnumCat;
870 struct Vector monikers = {NULL, 0, 0};
872 TRACE("(%p, %lx, %s, %lx, %s, %ld, %p, %p, %p, %s, %s, %p, %p, %p)\n",
875 bExactMatch ? "true" : "false",
877 bInputNeeded ? "true" : "false",
882 bRender ? "true" : "false",
883 bOutputNeeded ? "true" : "false",
890 FIXME("dwFlags = %lx not implemented\n", dwFlags);
895 hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC, &IID_ICreateDevEnum, (LPVOID*)&pCreateDevEnum);
898 hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEnumCat, 0);
900 while (IEnumMoniker_Next(pEnumCat, 1, &pMonikerCat, NULL) == S_OK)
902 IPropertyBag * pPropBagCat = NULL;
904 HRESULT hrSub; /* this is so that one buggy filter
905 doesn't make the whole lot fail */
909 hrSub = IMoniker_BindToStorage(pMonikerCat, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
911 if (SUCCEEDED(hrSub))
912 hrSub = IPropertyBag_Read(pPropBagCat, wszMeritName, &var, NULL);
914 if (SUCCEEDED(hrSub) && (V_UNION(&var, ulVal) >= dwMerit))
917 IEnumMoniker * pEnum;
922 if (TRACE_ON(quartz))
925 V_VT(&temp) = VT_EMPTY;
926 IPropertyBag_Read(pPropBagCat, wszFriendlyName, &temp, NULL);
927 TRACE("Considering category %s\n", debugstr_w(V_UNION(&temp, bstrVal)));
931 hrSub = IPropertyBag_Read(pPropBagCat, wszClsidName, &var, NULL);
933 if (SUCCEEDED(hrSub))
934 hrSub = CLSIDFromString(V_UNION(&var, bstrVal), &clsidCat);
936 if (SUCCEEDED(hrSub))
937 hrSub = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0);
941 while (IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL) == S_OK)
943 IPropertyBag * pPropBag = NULL;
946 BOOL bInputMatch = !bInputNeeded;
947 BOOL bOutputMatch = !bOutputNeeded;
949 ZeroMemory(&rf2, sizeof(rf2));
951 hrSub = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBag);
953 if (TRACE_ON(quartz))
956 V_VT(&temp) = VT_EMPTY;
957 IPropertyBag_Read(pPropBag, wszFriendlyName, &temp, NULL);
958 TRACE("Considering filter %s\n", debugstr_w(V_UNION(&temp, bstrVal)));
962 if (SUCCEEDED(hrSub))
963 hrSub = FM2_ReadFilterData(pPropBag, &rf2);
965 /* Logic used for bInputMatch expression:
966 * There exists some pin such that bInputNeeded implies (pin is an input and
967 * (bRender implies pin has render flag) and major/minor types members of
969 * bOutputMatch is similar, but without the "bRender implies ..." part
970 * and substituting variables names containing input for output
973 /* determine whether filter meets requirements */
974 if (SUCCEEDED(hrSub) && (rf2.dwMerit >= dwMerit))
976 for (i = 0; (i < rf2.u.s1.cPins2) && (!bInputMatch || !bOutputMatch); i++)
978 const REGFILTERPINS2 * rfp2 = rf2.u.s1.rgPins2 + i;
980 bInputMatch = bInputMatch || (!(rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
981 (!bRender || (rfp2->dwFlags & REG_PINFLAG_B_RENDERER)) &&
982 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cInputTypes, pInputTypes));
983 bOutputMatch = bOutputMatch || ((rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
984 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cOutputTypes, pOutputTypes));
987 if (bInputMatch && bOutputMatch)
989 struct MONIKER_MERIT mm = {pMoniker, rf2.dwMerit};
990 IMoniker_AddRef(pMoniker);
991 add_data(&monikers, (LPBYTE)&mm, sizeof(mm));
995 FM2_DeleteRegFilter(&rf2);
997 IPropertyBag_Release(pPropBag);
998 IMoniker_Release(pMoniker);
1000 IEnumMoniker_Release(pEnum);
1006 IPropertyBag_Release(pPropBagCat);
1007 IMoniker_Release(pMonikerCat);
1012 IMoniker ** ppMoniker;
1014 ULONG nMonikerCount = monikers.current / sizeof(struct MONIKER_MERIT);
1016 /* sort the monikers in descending merit order */
1017 qsort(monikers.pData, nMonikerCount,
1018 sizeof(struct MONIKER_MERIT),
1021 /* construct an IEnumMoniker interface */
1022 ppMoniker = CoTaskMemAlloc(nMonikerCount * sizeof(IMoniker *));
1023 for (i = 0; i < nMonikerCount; i++)
1025 /* no need to AddRef here as already AddRef'd above */
1026 ppMoniker[i] = ((struct MONIKER_MERIT *)monikers.pData)[i].pMoniker;
1028 hr = EnumMonikerImpl_Create(ppMoniker, nMonikerCount, ppEnum);
1029 CoTaskMemFree(ppMoniker);
1032 delete_vector(&monikers);
1033 IEnumMoniker_Release(pEnumCat);
1034 ICreateDevEnum_Release(pCreateDevEnum);
1039 static IFilterMapper2Vtbl fm2vtbl =
1042 FilterMapper2_QueryInterface,
1043 FilterMapper2_AddRef,
1044 FilterMapper2_Release,
1046 FilterMapper2_CreateCategory,
1047 FilterMapper2_UnregisterFilter,
1048 FilterMapper2_RegisterFilter,
1049 FilterMapper2_EnumMatchingFilters
1052 /*** IUnknown methods ***/
1054 static HRESULT WINAPI FilterMapper_QueryInterface(IFilterMapper * iface, REFIID riid, LPVOID *ppv)
1056 ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1058 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1060 return FilterMapper2_QueryInterface((IFilterMapper2*)&This->lpVtbl, riid, ppv);
1063 static ULONG WINAPI FilterMapper_AddRef(IFilterMapper * iface)
1065 ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1067 return FilterMapper2_AddRef((IFilterMapper2*)This);
1070 static ULONG WINAPI FilterMapper_Release(IFilterMapper * iface)
1072 ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1074 return FilterMapper2_Release((IFilterMapper2*)This);
1077 /*** IFilterMapper methods ***/
1079 static HRESULT WINAPI FilterMapper_EnumMatchingFilters(
1080 IFilterMapper * iface,
1081 IEnumRegFilters **ppEnum,
1091 ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1094 IEnumMoniker* ppEnumMoniker;
1097 ULONG idx = 0, nb_mon = 0;
1098 REGFILTER* regfilters;
1101 TRACE("(%p/%p)->(%p, %lx, %s, %s, %s, %s, %s, %s, %s) stub!\n",
1105 bInputNeeded ? "true" : "false",
1106 debugstr_guid(&clsInMaj),
1107 debugstr_guid(&clsInSub),
1108 bRender ? "true" : "false",
1109 bOutputNeeded ? "true" : "false",
1110 debugstr_guid(&clsOutMaj),
1111 debugstr_guid(&clsOutSub));
1113 InputType[0] = clsInMaj;
1114 InputType[1] = clsInSub;
1115 OutputType[0] = clsOutMaj;
1116 OutputType[1] = clsOutSub;
1118 hr = IFilterMapper2_EnumMatchingFilters((IFilterMapper2*)This,
1138 while(IEnumMoniker_Next(ppEnumMoniker, 1, &IMon, &nb) == S_OK)
1140 IMoniker_Release(IMon);
1147 IEnumMoniker_Release(ppEnumMoniker);
1148 return IEnumRegFiltersImpl_Construct(NULL, 0, ppEnum);
1151 regfilters = CoTaskMemAlloc(nb_mon * sizeof(REGFILTER));
1154 IEnumMoniker_Release(ppEnumMoniker);
1155 return E_OUTOFMEMORY;
1158 IEnumMoniker_Reset(ppEnumMoniker);
1159 while(IEnumMoniker_Next(ppEnumMoniker, 1, &IMon, &nb) == S_OK)
1161 IPropertyBag * pPropBagCat = NULL;
1168 V_VT(&var) = VT_BSTR;
1170 hrSub = IMoniker_BindToStorage(IMon, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
1172 if (SUCCEEDED(hrSub))
1173 hrSub = IPropertyBag_Read(pPropBagCat, wszClsidName, &var, NULL);
1175 if (SUCCEEDED(hrSub))
1176 hrSub = CLSIDFromString(V_UNION(&var, bstrVal), &clsid);
1178 if (SUCCEEDED(hrSub))
1179 hrSub = IPropertyBag_Read(pPropBagCat, wszFriendlyName, &var, NULL);
1181 if (SUCCEEDED(hrSub))
1183 len = (strlenW((WCHAR*)&V_UNION(&var, bstrVal))+1) * sizeof(WCHAR);
1184 if (!(regfilters[idx].Name = CoTaskMemAlloc(len*2)))
1188 if (SUCCEEDED(hrSub))
1190 memcpy(regfilters[idx].Name, &V_UNION(&var, bstrVal), len);
1191 regfilters[idx].Clsid = clsid;
1196 IPropertyBag_Release(pPropBagCat);
1197 IMoniker_Release(IMon);
1200 /* In case of release all resources */
1203 for (idx = 0; idx < nb_mon; idx++)
1204 CoTaskMemFree(regfilters[idx].Name);
1205 CoTaskMemFree(regfilters);
1206 IEnumMoniker_Release(ppEnumMoniker);
1210 hr = IEnumRegFiltersImpl_Construct(regfilters, nb_mon, ppEnum);
1211 CoTaskMemFree(regfilters);
1212 IEnumMoniker_Release(ppEnumMoniker);
1218 static HRESULT WINAPI FilterMapper_RegisterFilter(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, DWORD dwMerit)
1221 LPWSTR wszClsid = NULL;
1223 WCHAR wszKeyName[strlenW(wszFilterSlash) + (CHARS_IN_GUID-1) + 1];
1225 TRACE("(%p)->(%s, %s, %lx)\n", iface, debugstr_guid(&clsid), debugstr_w(szName), dwMerit);
1227 hr = StringFromCLSID(&clsid, &wszClsid);
1231 strcpyW(wszKeyName, wszFilterSlash);
1232 strcatW(wszKeyName, wszClsid);
1234 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL));
1239 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, NULL, 0, REG_SZ, (const BYTE*)szName, strlenW(szName) + 1));
1245 strcpyW(wszKeyName, wszClsidSlash);
1246 strcatW(wszKeyName, wszClsid);
1248 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL));
1253 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszMeritName, 0, REG_DWORD, (LPBYTE)&dwMerit, sizeof(dwMerit)));
1260 static HRESULT WINAPI FilterMapper_RegisterFilterInstance(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, CLSID *MRId)
1262 TRACE("(%p)->(%s, %s, %p)\n", iface, debugstr_guid(&clsid), debugstr_w(szName), MRId);
1264 /* Not implemented in Windows (tested on Win2k) */
1269 static HRESULT WINAPI FilterMapper_RegisterPin(
1270 IFilterMapper * iface,
1277 CLSID ConnectsToFilter,
1278 LPCWSTR ConnectsToPin)
1281 LPWSTR wszClsid = NULL;
1283 HKEY hPinsKey = NULL;
1284 WCHAR * wszPinsKeyName;
1285 WCHAR wszKeyName[strlenW(wszClsidSlash) + (CHARS_IN_GUID-1) + 1];
1287 TRACE("(%p)->(%s, %s, %d, %d, %d, %d, %s, %s)\n", iface, debugstr_guid(&Filter), debugstr_w(szName), bRendered,
1288 bOutput, bZero, bMany, debugstr_guid(&ConnectsToFilter), debugstr_w(ConnectsToPin));
1290 hr = StringFromCLSID(&Filter, &wszClsid);
1294 strcpyW(wszKeyName, wszClsidSlash);
1295 strcatW(wszKeyName, wszClsid);
1297 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey));
1302 wszPinsKeyName = CoTaskMemAlloc((strlenW(wszPins) + 1 + strlenW(szName) + 1) * 2);
1303 if (!wszPinsKeyName)
1309 strcpyW(wszPinsKeyName, wszPins);
1310 strcatW(wszPinsKeyName, wszSlash);
1311 strcatW(wszPinsKeyName, szName);
1313 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(hKey, wszPinsKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hPinsKey, NULL));
1314 CoTaskMemFree(wszPinsKeyName);
1319 hr = HRESULT_FROM_WIN32(RegSetValueExW(hPinsKey, wszAllowedMany, 0, REG_DWORD, (LPBYTE)&bMany, sizeof(bMany)));
1324 hr = HRESULT_FROM_WIN32(RegSetValueExW(hPinsKey, wszAllowedZero, 0, REG_DWORD, (LPBYTE)&bZero, sizeof(bZero)));
1329 hr = HRESULT_FROM_WIN32(RegSetValueExW(hPinsKey, wszDirection, 0, REG_DWORD, (LPBYTE)&bOutput, sizeof(bOutput)));
1334 hr = HRESULT_FROM_WIN32(RegSetValueExW(hPinsKey, wszIsRendered, 0, REG_DWORD, (LPBYTE)&bRendered, sizeof(bRendered)));
1339 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(hPinsKey, wszTypes, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, NULL, NULL));
1343 CoTaskMemFree(wszClsid);
1347 CloseHandle(hPinsKey);
1353 static HRESULT WINAPI FilterMapper_RegisterPinType(
1354 IFilterMapper * iface,
1361 LPWSTR wszClsid = NULL;
1362 LPWSTR wszClsidMajorType = NULL;
1363 LPWSTR wszClsidSubType = NULL;
1365 WCHAR * wszTypesKey;
1366 WCHAR wszKeyName[strlenW(wszClsidSlash) + (CHARS_IN_GUID-1) + 1];
1368 TRACE("(%p)->(%s, %s, %s, %s)\n", iface, debugstr_guid(&clsFilter), debugstr_w(szName),
1369 debugstr_guid(&clsMajorType), debugstr_guid(&clsSubType));
1371 hr = StringFromCLSID(&clsFilter, &wszClsid);
1375 hr = StringFromCLSID(&clsMajorType, &wszClsidMajorType);
1380 hr = StringFromCLSID(&clsSubType, &wszClsidSubType);
1385 wszTypesKey = CoTaskMemAlloc((strlenW(wszClsidSlash) + strlenW(wszClsid) + strlenW(wszPins) +
1386 strlenW(szName) + strlenW(wszTypes) + 3 + 1) * 2);
1393 strcpyW(wszTypesKey, wszClsidSlash);
1394 strcatW(wszTypesKey, wszClsid);
1395 strcatW(wszTypesKey, wszSlash);
1396 strcatW(wszTypesKey, wszPins);
1397 strcatW(wszTypesKey, wszSlash);
1398 strcatW(wszTypesKey, szName);
1399 strcatW(wszTypesKey, wszSlash);
1400 strcatW(wszTypesKey, wszTypes);
1402 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_CLASSES_ROOT, wszTypesKey, 0, KEY_WRITE, &hKey));
1403 CoTaskMemFree(wszTypesKey);
1408 strcpyW(wszKeyName, wszClsidMajorType);
1409 strcatW(wszKeyName, wszSlash);
1410 strcatW(wszKeyName, wszClsidSubType);
1412 hr = HRESULT_FROM_WIN32(RegCreateKeyExW(hKey, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, NULL, NULL));
1417 CoTaskMemFree(wszClsid);
1418 if (wszClsidMajorType)
1419 CoTaskMemFree(wszClsidMajorType);
1420 if (wszClsidSubType)
1421 CoTaskMemFree(wszClsidSubType);
1426 static HRESULT WINAPI FilterMapper_UnregisterFilter(IFilterMapper * iface, CLSID Filter)
1429 LPWSTR wszClsid = NULL;
1431 WCHAR wszKeyName[strlenW(wszClsidSlash) + (CHARS_IN_GUID-1) + 1];
1433 TRACE("(%p)->(%s)\n", iface, debugstr_guid(&Filter));
1435 hr = StringFromCLSID(&Filter, &wszClsid);
1439 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_CLASSES_ROOT, wszFilter, 0, KEY_WRITE, &hKey));
1444 hr = HRESULT_FROM_WIN32(RegDeleteKeyW(hKey, wszClsid));
1450 strcpyW(wszKeyName, wszClsidSlash);
1451 strcatW(wszKeyName, wszClsid);
1453 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey));
1458 hr = HRESULT_FROM_WIN32(RegDeleteKeyW(hKey, wszMeritName));
1463 CoTaskMemFree(wszClsid);
1468 static HRESULT WINAPI FilterMapper_UnregisterFilterInstance(IFilterMapper * iface, CLSID MRId)
1470 TRACE("(%p)->(%s)\n", iface, debugstr_guid(&MRId));
1472 /* Not implemented in Windows (tested on Win2k) */
1477 static HRESULT WINAPI FilterMapper_UnregisterPin(IFilterMapper * iface, CLSID Filter, LPCWSTR Name)
1480 LPWSTR wszClsid = NULL;
1482 WCHAR * wszPinNameKey;
1483 WCHAR wszKeyName[strlenW(wszClsidSlash) + (CHARS_IN_GUID-1) + 1];
1485 TRACE("(%p)->(%s, %s)\n", iface, debugstr_guid(&Filter), debugstr_w(Name));
1488 return E_INVALIDARG;
1490 hr = StringFromCLSID(&Filter, &wszClsid);
1494 strcpyW(wszKeyName, wszClsidSlash);
1495 strcatW(wszKeyName, wszClsid);
1497 hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, KEY_WRITE, &hKey));
1502 wszPinNameKey = CoTaskMemAlloc((strlenW(wszPins) + 1 + strlenW(Name) + 1) * 2);
1509 strcpyW(wszPinNameKey, wszPins);
1510 strcatW(wszPinNameKey, wszSlash);
1511 strcatW(wszPinNameKey, Name);
1513 hr = HRESULT_FROM_WIN32(RegDeleteKeyW(hKey, wszPinNameKey));
1514 CoTaskMemFree(wszPinNameKey);
1518 CoTaskMemFree(wszClsid);
1525 static IFilterMapperVtbl fmvtbl =
1528 FilterMapper_QueryInterface,
1529 FilterMapper_AddRef,
1530 FilterMapper_Release,
1532 FilterMapper_RegisterFilter,
1533 FilterMapper_RegisterFilterInstance,
1534 FilterMapper_RegisterPin,
1535 FilterMapper_RegisterPinType,
1536 FilterMapper_UnregisterFilter,
1537 FilterMapper_UnregisterFilterInstance,
1538 FilterMapper_UnregisterPin,
1539 FilterMapper_EnumMatchingFilters