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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
32 #include "quartz_private.h"
37 #include "wine/unicode.h"
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(quartz
);
44 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
46 /* Unexposed IAMFilterData interface */
47 typedef struct IAMFilterData IAMFilterData
;
49 typedef struct IAMFilterDataVtbl
53 /*** IUnknown methods ***/
54 HRESULT (STDMETHODCALLTYPE
*QueryInterface
)(
59 ULONG (STDMETHODCALLTYPE
*AddRef
)(
62 ULONG (STDMETHODCALLTYPE
*Release
)(
65 /*** IAMFilterData methods ***/
66 HRESULT (STDMETHODCALLTYPE
*ParseFilterData
)(
72 HRESULT (STDMETHODCALLTYPE
*CreateFilterData
)(
75 BYTE
**pRegFilterData
,
82 const IAMFilterDataVtbl
*lpVtbl
;
84 const GUID IID_IAMFilterData
= {
85 0x97f7c4d4, 0x547b, 0x4a5f, { 0x83,0x32, 0x53,0x64,0x30,0xad,0x2e,0x4d }
89 typedef struct FilterMapper2Impl
91 const IFilterMapper2Vtbl
*lpVtbl
;
92 const IFilterMapperVtbl
*lpVtblFilterMapper
;
93 const IAMFilterDataVtbl
*lpVtblAMFilterData
;
97 static const IFilterMapper2Vtbl fm2vtbl
;
98 static const IFilterMapperVtbl fmvtbl
;
99 static const IAMFilterDataVtbl AMFilterDataVtbl
;
101 static inline FilterMapper2Impl
*impl_from_IFilterMapper( IFilterMapper
*iface
)
103 return (FilterMapper2Impl
*)((char*)iface
- FIELD_OFFSET(FilterMapper2Impl
, lpVtblFilterMapper
));
106 static inline FilterMapper2Impl
*impl_from_IAMFilterData( IAMFilterData
*iface
)
108 return (FilterMapper2Impl
*)((char*)iface
- FIELD_OFFSET(FilterMapper2Impl
, lpVtblAMFilterData
));
111 static const WCHAR wszClsidSlash
[] = {'C','L','S','I','D','\\',0};
112 static const WCHAR wszSlashInstance
[] = {'\\','I','n','s','t','a','n','c','e','\\',0};
113 static const WCHAR wszSlash
[] = {'\\',0};
115 /* CLSID property in media category Moniker */
116 static const WCHAR wszClsidName
[] = {'C','L','S','I','D',0};
117 /* FriendlyName property in media category Moniker */
118 static const WCHAR wszFriendlyName
[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
119 /* Merit property in media category Moniker (CLSID_ActiveMovieCategories only) */
120 static const WCHAR wszMeritName
[] = {'M','e','r','i','t',0};
121 /* FilterData property in media category Moniker (not CLSID_ActiveMovieCategories) */
122 static const WCHAR wszFilterDataName
[] = {'F','i','l','t','e','r','D','a','t','a',0};
123 /* For filters registered with IFilterMapper */
124 static const WCHAR wszFilterSlash
[] = {'F','i','l','t','e','r','\\',0};
125 static const WCHAR wszFilter
[] = {'F','i','l','t','e','r',0};
126 /* For pins registered with IFilterMapper */
127 static const WCHAR wszPins
[] = {'P','i','n','s',0};
128 static const WCHAR wszAllowedMany
[] = {'A','l','l','o','w','e','d','M','a','n','y',0};
129 static const WCHAR wszAllowedZero
[] = {'A','l','l','o','w','e','d','Z','e','r','o',0};
130 static const WCHAR wszDirection
[] = {'D','i','r','e','c','t','i','o','n',0};
131 static const WCHAR wszIsRendered
[] = {'I','s','R','e','n','d','e','r','e','d',0};
132 /* For types registered with IFilterMapper */
133 static const WCHAR wszTypes
[] = {'T','y','p','e','s',0};
136 /* registry format for REGFILTER2 */
147 BYTE signature
[4]; /* e.g. "0pi3" */
152 DWORD bCategory
; /* is there a category clsid? */
153 /* optional: dwOffsetCategoryClsid */
158 BYTE signature
[4]; /* e.g. "0ty3" */
173 int capacity
; /* in bytes */
174 int current
; /* pointer to next free byte */
177 /* returns the position it was added at */
178 static int add_data(struct Vector
* v
, const BYTE
* pData
, int size
)
180 int index
= v
->current
;
181 if (v
->current
+ size
> v
->capacity
)
183 LPBYTE pOldData
= v
->pData
;
184 v
->capacity
= (v
->capacity
+ size
) * 2;
185 v
->pData
= CoTaskMemAlloc(v
->capacity
);
186 memcpy(v
->pData
, pOldData
, v
->current
);
187 CoTaskMemFree(pOldData
);
189 memcpy(v
->pData
+ v
->current
, pData
, size
);
194 static int find_data(const struct Vector
* v
, const BYTE
* pData
, int size
)
197 for (index
= 0; index
< v
->current
; index
++)
198 if (!memcmp(v
->pData
+ index
, pData
, size
))
204 static void delete_vector(struct Vector
* v
)
206 CoTaskMemFree(v
->pData
);
211 HRESULT
FilterMapper2_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
213 FilterMapper2Impl
* pFM2impl
;
215 TRACE("(%p, %p)\n", pUnkOuter
, ppObj
);
218 return CLASS_E_NOAGGREGATION
;
220 pFM2impl
= CoTaskMemAlloc(sizeof(*pFM2impl
));
222 return E_OUTOFMEMORY
;
224 pFM2impl
->lpVtbl
= &fm2vtbl
;
225 pFM2impl
->lpVtblFilterMapper
= &fmvtbl
;
226 pFM2impl
->lpVtblAMFilterData
= &AMFilterDataVtbl
;
227 pFM2impl
->refCount
= 1;
231 TRACE("-- created at %p\n", pFM2impl
);
236 HRESULT
FilterMapper_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
238 FilterMapper2Impl
*pFM2impl
;
241 TRACE("(%p, %p)\n", pUnkOuter
, ppObj
);
243 hr
= FilterMapper2_create(pUnkOuter
, (LPVOID
*)&pFM2impl
);
247 *ppObj
= &pFM2impl
->lpVtblFilterMapper
;
252 /*** IUnknown methods ***/
254 static HRESULT WINAPI
FilterMapper2_QueryInterface(IFilterMapper2
* iface
, REFIID riid
, LPVOID
*ppv
)
256 FilterMapper2Impl
*This
= (FilterMapper2Impl
*)iface
;
258 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
262 if (IsEqualIID(riid
, &IID_IUnknown
))
264 else if (IsEqualIID(riid
, &IID_IFilterMapper2
))
266 else if (IsEqualIID(riid
, &IID_IFilterMapper
))
267 *ppv
= &This
->lpVtblFilterMapper
;
268 else if (IsEqualIID(riid
, &IID_IAMFilterData
))
269 *ppv
= &This
->lpVtblAMFilterData
;
273 IUnknown_AddRef((IUnknown
*)*ppv
);
277 FIXME("No interface for %s\n", debugstr_guid(riid
));
278 return E_NOINTERFACE
;
281 static ULONG WINAPI
FilterMapper2_AddRef(IFilterMapper2
* iface
)
283 FilterMapper2Impl
*This
= (FilterMapper2Impl
*)iface
;
284 ULONG refCount
= InterlockedIncrement(&This
->refCount
);
286 TRACE("(%p)->() AddRef from %d\n", This
, refCount
- 1);
291 static ULONG WINAPI
FilterMapper2_Release(IFilterMapper2
* iface
)
293 FilterMapper2Impl
*This
= (FilterMapper2Impl
*)iface
;
294 ULONG refCount
= InterlockedDecrement(&This
->refCount
);
296 TRACE("(%p)->() Release from %d\n", This
, refCount
+ 1);
306 /*** IFilterMapper2 methods ***/
308 static HRESULT WINAPI
FilterMapper2_CreateCategory(
309 IFilterMapper2
* iface
,
310 REFCLSID clsidCategory
,
311 DWORD dwCategoryMerit
,
312 LPCWSTR szDescription
)
314 LPWSTR wClsidAMCat
= NULL
;
315 LPWSTR wClsidCategory
= NULL
;
316 WCHAR wszKeyName
[ARRAYSIZE(wszClsidSlash
)-1 + ARRAYSIZE(wszSlashInstance
)-1 + (CHARS_IN_GUID
-1) * 2 + 1];
321 TRACE("(%s, %x, %s)\n", debugstr_guid(clsidCategory
), dwCategoryMerit
, debugstr_w(szDescription
));
323 hr
= StringFromCLSID(&CLSID_ActiveMovieCategories
, &wClsidAMCat
);
327 hr
= StringFromCLSID(clsidCategory
, &wClsidCategory
);
332 strcpyW(wszKeyName
, wszClsidSlash
);
333 strcatW(wszKeyName
, wClsidAMCat
);
334 strcatW(wszKeyName
, wszSlashInstance
);
335 strcatW(wszKeyName
, wClsidCategory
);
337 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
338 hr
= HRESULT_FROM_WIN32(lRet
);
343 lRet
= RegSetValueExW(hKey
, wszFriendlyName
, 0, REG_SZ
, (const BYTE
*)szDescription
, (strlenW(szDescription
) + 1) * sizeof(WCHAR
));
344 hr
= HRESULT_FROM_WIN32(lRet
);
349 lRet
= RegSetValueExW(hKey
, wszClsidName
, 0, REG_SZ
, (LPBYTE
)wClsidCategory
, (strlenW(wClsidCategory
) + 1) * sizeof(WCHAR
));
350 hr
= HRESULT_FROM_WIN32(lRet
);
355 lRet
= RegSetValueExW(hKey
, wszMeritName
, 0, REG_DWORD
, (LPBYTE
)&dwCategoryMerit
, sizeof(dwCategoryMerit
));
356 hr
= HRESULT_FROM_WIN32(lRet
);
360 CoTaskMemFree(wClsidCategory
);
361 CoTaskMemFree(wClsidAMCat
);
366 static HRESULT WINAPI
FilterMapper2_UnregisterFilter(
367 IFilterMapper2
* iface
,
368 const CLSID
*pclsidCategory
,
369 const OLECHAR
*szInstance
,
372 WCHAR wszKeyName
[MAX_PATH
];
373 LPWSTR wClsidCategory
= NULL
;
374 LPWSTR wFilter
= NULL
;
377 TRACE("(%p, %s, %s)\n", pclsidCategory
, debugstr_w(szInstance
), debugstr_guid(Filter
));
380 pclsidCategory
= &CLSID_LegacyAmFilterCategory
;
382 hr
= StringFromCLSID(pclsidCategory
, &wClsidCategory
);
386 strcpyW(wszKeyName
, wszClsidSlash
);
387 strcatW(wszKeyName
, wClsidCategory
);
388 strcatW(wszKeyName
, wszSlashInstance
);
390 strcatW(wszKeyName
, szInstance
);
393 hr
= StringFromCLSID(Filter
, &wFilter
);
395 strcatW(wszKeyName
, wFilter
);
401 LONG lRet
= RegDeleteKeyW(HKEY_CLASSES_ROOT
, wszKeyName
);
402 hr
= HRESULT_FROM_WIN32(lRet
);
405 CoTaskMemFree(wClsidCategory
);
406 CoTaskMemFree(wFilter
);
411 static HRESULT
FM2_WriteFriendlyName(IPropertyBag
* pPropBag
, LPCWSTR szName
)
415 V_VT(&var
) = VT_BSTR
;
416 V_UNION(&var
, bstrVal
) = (BSTR
)szName
;
418 return IPropertyBag_Write(pPropBag
, wszFriendlyName
, &var
);
421 static HRESULT
FM2_WriteClsid(IPropertyBag
* pPropBag
, REFCLSID clsid
)
423 LPWSTR wszClsid
= NULL
;
427 hr
= StringFromCLSID(clsid
, &wszClsid
);
431 V_VT(&var
) = VT_BSTR
;
432 V_UNION(&var
, bstrVal
) = wszClsid
;
433 hr
= IPropertyBag_Write(pPropBag
, wszClsidName
, &var
);
435 CoTaskMemFree(wszClsid
);
439 static HRESULT
FM2_WriteFilterData(const REGFILTER2
* prf2
, BYTE
**ppData
, ULONG
*pcbData
)
441 int size
= sizeof(struct REG_RF
);
443 struct Vector mainStore
= {NULL
, 0, 0};
444 struct Vector clsidStore
= {NULL
, 0, 0};
448 rrf
.dwVersion
= prf2
->dwVersion
;
449 rrf
.dwMerit
= prf2
->dwMerit
;
450 rrf
.dwPins
= prf2
->u
.s1
.cPins2
;
453 add_data(&mainStore
, (LPBYTE
)&rrf
, sizeof(rrf
));
455 for (i
= 0; i
< prf2
->u
.s1
.cPins2
; i
++)
457 size
+= sizeof(struct REG_RFP
);
458 if (prf2
->u
.s1
.rgPins2
[i
].clsPinCategory
)
459 size
+= sizeof(DWORD
);
460 size
+= prf2
->u
.s1
.rgPins2
[i
].nMediaTypes
* sizeof(struct REG_TYPE
);
461 size
+= prf2
->u
.s1
.rgPins2
[i
].nMediums
* sizeof(DWORD
);
464 for (i
= 0; i
< prf2
->u
.s1
.cPins2
; i
++)
467 REGFILTERPINS2 rgPin2
= prf2
->u
.s1
.rgPins2
[i
];
470 rrfp
.signature
[0] = '0';
471 rrfp
.signature
[1] = 'p';
472 rrfp
.signature
[2] = 'i';
473 rrfp
.signature
[3] = '3';
474 rrfp
.signature
[0] += i
;
475 rrfp
.dwFlags
= rgPin2
.dwFlags
;
476 rrfp
.dwInstances
= rgPin2
.cInstances
;
477 rrfp
.dwMediaTypes
= rgPin2
.nMediaTypes
;
478 rrfp
.dwMediums
= rgPin2
.nMediums
;
479 rrfp
.bCategory
= rgPin2
.clsPinCategory
? 1 : 0;
481 add_data(&mainStore
, (LPBYTE
)&rrfp
, sizeof(rrfp
));
484 DWORD index
= find_data(&clsidStore
, (const BYTE
*)rgPin2
.clsPinCategory
, sizeof(CLSID
));
486 index
= add_data(&clsidStore
, (const BYTE
*)rgPin2
.clsPinCategory
, sizeof(CLSID
));
489 add_data(&mainStore
, (LPBYTE
)&index
, sizeof(index
));
492 for (j
= 0; j
< rgPin2
.nMediaTypes
; j
++)
495 rt
.signature
[0] = '0';
496 rt
.signature
[1] = 't';
497 rt
.signature
[2] = 'y';
498 rt
.signature
[3] = '3';
499 rt
.signature
[0] += j
;
502 rt
.dwOffsetMajor
= find_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMajorType
, sizeof(CLSID
));
503 if (rt
.dwOffsetMajor
== -1)
504 rt
.dwOffsetMajor
= add_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMajorType
, sizeof(CLSID
));
505 rt
.dwOffsetMajor
+= size
;
506 rt
.dwOffsetMinor
= find_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMinorType
, sizeof(CLSID
));
507 if (rt
.dwOffsetMinor
== -1)
508 rt
.dwOffsetMinor
= add_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMinorType
, sizeof(CLSID
));
509 rt
.dwOffsetMinor
+= size
;
511 add_data(&mainStore
, (LPBYTE
)&rt
, sizeof(rt
));
514 for (j
= 0; j
< rgPin2
.nMediums
; j
++)
516 DWORD index
= find_data(&clsidStore
, (const BYTE
*)(rgPin2
.lpMedium
+ j
), sizeof(REGPINMEDIUM
));
518 index
= add_data(&clsidStore
, (const BYTE
*)(rgPin2
.lpMedium
+ j
), sizeof(REGPINMEDIUM
));
521 add_data(&mainStore
, (LPBYTE
)&index
, sizeof(index
));
527 *pcbData
= mainStore
.current
+ clsidStore
.current
;
528 *ppData
= CoTaskMemAlloc(*pcbData
);
535 memcpy(*ppData
, mainStore
.pData
, mainStore
.current
);
536 memcpy((*ppData
) + mainStore
.current
, clsidStore
.pData
, clsidStore
.current
);
539 delete_vector(&mainStore
);
540 delete_vector(&clsidStore
);
544 static HRESULT
FM2_ReadFilterData(BYTE
*pData
, REGFILTER2
* prf2
)
547 struct REG_RF
* prrf
;
550 REGFILTERPINS2
* rgPins2
;
552 prrf
= (struct REG_RF
*)pData
;
555 if (prrf
->dwVersion
!= 2)
557 FIXME("Filter registry version %d not supported\n", prrf
->dwVersion
);
558 ZeroMemory(prf2
, sizeof(*prf2
));
564 TRACE("version = %d, merit = %x, #pins = %d, unused = %x\n",
565 prrf
->dwVersion
, prrf
->dwMerit
, prrf
->dwPins
, prrf
->dwUnused
);
567 prf2
->dwVersion
= prrf
->dwVersion
;
568 prf2
->dwMerit
= prrf
->dwMerit
;
569 prf2
->u
.s1
.cPins2
= prrf
->dwPins
;
570 rgPins2
= CoTaskMemAlloc(prrf
->dwPins
* sizeof(*rgPins2
));
571 prf2
->u
.s1
.rgPins2
= rgPins2
;
572 pCurrent
+= sizeof(struct REG_RF
);
574 for (i
= 0; i
< prrf
->dwPins
; i
++)
576 struct REG_RFP
* prrfp
= (struct REG_RFP
*)pCurrent
;
577 REGPINTYPES
* lpMediaType
;
578 REGPINMEDIUM
* lpMedium
;
581 /* FIXME: check signature */
583 TRACE("\tsignature = %s\n", debugstr_an((const char*)prrfp
->signature
, 4));
585 TRACE("\tpin[%d]: flags = %x, instances = %d, media types = %d, mediums = %d\n",
586 i
, prrfp
->dwFlags
, prrfp
->dwInstances
, prrfp
->dwMediaTypes
, prrfp
->dwMediums
);
588 rgPins2
[i
].dwFlags
= prrfp
->dwFlags
;
589 rgPins2
[i
].cInstances
= prrfp
->dwInstances
;
590 rgPins2
[i
].nMediaTypes
= prrfp
->dwMediaTypes
;
591 rgPins2
[i
].nMediums
= prrfp
->dwMediums
;
592 pCurrent
+= sizeof(struct REG_RFP
);
593 if (prrfp
->bCategory
)
595 CLSID
* clsCat
= CoTaskMemAlloc(sizeof(CLSID
));
596 memcpy(clsCat
, pData
+ *(DWORD
*)(pCurrent
), sizeof(CLSID
));
597 pCurrent
+= sizeof(DWORD
);
598 rgPins2
[i
].clsPinCategory
= clsCat
;
601 rgPins2
[i
].clsPinCategory
= NULL
;
603 if (rgPins2
[i
].nMediaTypes
> 0)
604 lpMediaType
= CoTaskMemAlloc(rgPins2
[i
].nMediaTypes
* sizeof(*lpMediaType
));
608 rgPins2
[i
].lpMediaType
= lpMediaType
;
610 for (j
= 0; j
< rgPins2
[i
].nMediaTypes
; j
++)
612 struct REG_TYPE
* prt
= (struct REG_TYPE
*)pCurrent
;
613 CLSID
* clsMajor
= CoTaskMemAlloc(sizeof(CLSID
));
614 CLSID
* clsMinor
= CoTaskMemAlloc(sizeof(CLSID
));
616 /* FIXME: check signature */
617 TRACE("\t\tsignature = %s\n", debugstr_an((const char*)prt
->signature
, 4));
619 memcpy(clsMajor
, pData
+ prt
->dwOffsetMajor
, sizeof(CLSID
));
620 memcpy(clsMinor
, pData
+ prt
->dwOffsetMinor
, sizeof(CLSID
));
622 lpMediaType
[j
].clsMajorType
= clsMajor
;
623 lpMediaType
[j
].clsMinorType
= clsMinor
;
625 pCurrent
+= sizeof(*prt
);
628 if (rgPins2
[i
].nMediums
> 0)
629 lpMedium
= CoTaskMemAlloc(rgPins2
[i
].nMediums
* sizeof(*lpMedium
));
633 rgPins2
[i
].lpMedium
= lpMedium
;
635 for (j
= 0; j
< rgPins2
[i
].nMediums
; j
++)
637 DWORD dwOffset
= *(DWORD
*)pCurrent
;
639 memcpy(lpMedium
+ j
, pData
+ dwOffset
, sizeof(REGPINMEDIUM
));
641 pCurrent
+= sizeof(dwOffset
);
650 static void FM2_DeleteRegFilter(REGFILTER2
* prf2
)
653 for (i
= 0; i
< prf2
->u
.s1
.cPins2
; i
++)
656 if (prf2
->u
.s1
.rgPins2
[i
].clsPinCategory
)
657 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
[i
].clsPinCategory
);
659 for (j
= 0; j
< prf2
->u
.s1
.rgPins2
[i
].nMediaTypes
; j
++)
661 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
[i
].lpMediaType
[j
].clsMajorType
);
662 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
[i
].lpMediaType
[j
].clsMinorType
);
664 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
[i
].lpMediaType
);
665 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
[i
].lpMedium
);
667 CoTaskMemFree((LPVOID
)prf2
->u
.s1
.rgPins2
);
670 static HRESULT WINAPI
FilterMapper2_RegisterFilter(
671 IFilterMapper2
* iface
,
672 REFCLSID clsidFilter
,
674 IMoniker
**ppMoniker
,
675 const CLSID
*pclsidCategory
,
676 const OLECHAR
*szInstance
,
677 const REGFILTER2
*prf2
)
679 IParseDisplayName
* pParser
= NULL
;
680 IBindCtx
* pBindCtx
= NULL
;
681 IMoniker
* pMoniker
= NULL
;
682 IPropertyBag
* pPropBag
= NULL
;
684 LPWSTR pwszParseName
= NULL
;
686 static const WCHAR wszDevice
[] = {'@','d','e','v','i','c','e',':','s','w',':',0};
689 LPWSTR szClsidTemp
= NULL
;
690 REGFILTER2 regfilter2
;
691 REGFILTERPINS2
* pregfp2
= NULL
;
693 TRACE("(%s, %s, %p, %s, %s, %p)\n",
694 debugstr_guid(clsidFilter
),
697 debugstr_guid(pclsidCategory
),
698 debugstr_w(szInstance
),
701 if (prf2
->dwVersion
== 2)
705 else if (prf2
->dwVersion
== 1)
709 /* REGFILTER2 structure is converted from version 1 to 2. Tested on Win2k. */
710 regfilter2
.dwVersion
= 2;
711 regfilter2
.dwMerit
= prf2
->dwMerit
;
712 regfilter2
.u
.s1
.cPins2
= prf2
->u
.s
.cPins
;
713 pregfp2
= CoTaskMemAlloc(prf2
->u
.s
.cPins
* sizeof(REGFILTERPINS2
));
714 regfilter2
.u
.s1
.rgPins2
= pregfp2
;
715 for (i
= 0; i
< prf2
->u
.s
.cPins
; i
++)
718 if (prf2
->u
.s
.rgPins
[i
].bRendered
)
719 flags
|= REG_PINFLAG_B_RENDERER
;
720 if (prf2
->u
.s
.rgPins
[i
].bOutput
)
721 flags
|= REG_PINFLAG_B_OUTPUT
;
722 if (prf2
->u
.s
.rgPins
[i
].bZero
)
723 flags
|= REG_PINFLAG_B_ZERO
;
724 if (prf2
->u
.s
.rgPins
[i
].bMany
)
725 flags
|= REG_PINFLAG_B_MANY
;
726 pregfp2
[i
].dwFlags
= flags
;
727 pregfp2
[i
].cInstances
= 1;
728 pregfp2
[i
].nMediaTypes
= prf2
->u
.s
.rgPins
[i
].nMediaTypes
;
729 pregfp2
[i
].lpMediaType
= prf2
->u
.s
.rgPins
[i
].lpMediaType
;
730 pregfp2
[i
].nMediums
= 0;
731 pregfp2
[i
].lpMedium
= NULL
;
732 pregfp2
[i
].clsPinCategory
= NULL
;
737 FIXME("dwVersion other that 1 or 2 not supported at the moment\n");
745 /* MSDN mentions the inexistent CLSID_ActiveMovieFilters GUID.
746 * In fact this is the CLSID_LegacyAmFilterCategory one */
747 pclsidCategory
= &CLSID_LegacyAmFilterCategory
;
749 /* sizeof... will include the null terminator and
750 * the + 1 is for the separator ('\\'). The -1 is
751 * because CHARS_IN_GUID includes the null terminator
753 nameLen
= sizeof(wszDevice
)/sizeof(wszDevice
[0]) + CHARS_IN_GUID
- 1 + 1;
756 nameLen
+= strlenW(szInstance
);
758 nameLen
+= CHARS_IN_GUID
- 1; /* CHARS_IN_GUID includes null terminator */
760 pCurrent
= pwszParseName
= CoTaskMemAlloc(nameLen
*sizeof(WCHAR
));
762 return E_OUTOFMEMORY
;
764 strcpyW(pwszParseName
, wszDevice
);
765 pCurrent
+= strlenW(wszDevice
);
767 hr
= StringFromCLSID(pclsidCategory
, &szClsidTemp
);
771 memcpy(pCurrent
, szClsidTemp
, CHARS_IN_GUID
* sizeof(WCHAR
));
772 pCurrent
+= CHARS_IN_GUID
- 1;
776 strcpyW(pCurrent
+1, szInstance
);
779 CoTaskMemFree(szClsidTemp
);
782 hr
= StringFromCLSID(clsidFilter
, &szClsidTemp
);
784 strcpyW(pCurrent
+1, szClsidTemp
);
789 hr
= CoCreateInstance(&CLSID_CDeviceMoniker
, NULL
, CLSCTX_INPROC
, &IID_IParseDisplayName
, (LPVOID
*)&pParser
);
792 hr
= CreateBindCtx(0, &pBindCtx
);
795 hr
= IParseDisplayName_ParseDisplayName(pParser
, pBindCtx
, pwszParseName
, &ulEaten
, &pMoniker
);
798 IBindCtx_Release(pBindCtx
);
800 IParseDisplayName_Release(pParser
);
803 hr
= IMoniker_BindToStorage(pMoniker
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
)&pPropBag
);
806 hr
= FM2_WriteFriendlyName(pPropBag
, szName
);
809 hr
= FM2_WriteClsid(pPropBag
, clsidFilter
);
816 hr
= FM2_WriteFilterData(®filter2
, &pData
, &cbData
);
821 SAFEARRAYBOUND saBound
;
824 saBound
.cElements
= cbData
;
825 psa
= SafeArrayCreate(VT_UI1
, 1, &saBound
);
828 ERR("Couldn't create SAFEARRAY\n");
835 hr
= SafeArrayAccessData(psa
, (LPVOID
*)&pbSAData
);
838 memcpy(pbSAData
, pData
, cbData
);
839 hr
= SafeArrayUnaccessData(psa
);
843 V_VT(&var
) = VT_ARRAY
| VT_UI1
;
844 V_UNION(&var
, parray
) = psa
;
847 hr
= IPropertyBag_Write(pPropBag
, wszFilterDataName
, &var
);
850 SafeArrayDestroy(psa
);
851 CoTaskMemFree(pData
);
856 IPropertyBag_Release(pPropBag
);
857 CoTaskMemFree(szClsidTemp
);
858 CoTaskMemFree(pwszParseName
);
860 if (SUCCEEDED(hr
) && ppMoniker
)
861 *ppMoniker
= pMoniker
;
863 IMoniker_Release(pMoniker
);
865 CoTaskMemFree(pregfp2
);
867 TRACE("-- returning %x\n", hr
);
872 /* internal helper function */
873 static BOOL
MatchTypes(
876 const REGPINTYPES
* pPinTypes
,
878 const GUID
* pMatchTypes
)
883 if ((nMatchTypes
== 0) && (nPinTypes
> 0))
886 for (j
= 0; j
< nPinTypes
; j
++)
889 for (i
= 0; i
< nMatchTypes
*2; i
+=2)
891 if (((!bExactMatch
&& IsEqualGUID(pPinTypes
[j
].clsMajorType
, &GUID_NULL
)) || IsEqualGUID(&pMatchTypes
[i
], &GUID_NULL
) || IsEqualGUID(pPinTypes
[j
].clsMajorType
, &pMatchTypes
[i
])) &&
892 ((!bExactMatch
&& IsEqualGUID(pPinTypes
[j
].clsMinorType
, &GUID_NULL
)) || IsEqualGUID(&pMatchTypes
[i
+1], &GUID_NULL
) || IsEqualGUID(pPinTypes
[j
].clsMinorType
, &pMatchTypes
[i
+1])))
902 /* internal helper function for qsort of MONIKER_MERIT array */
903 static int mm_compare(const void * left
, const void * right
)
905 const struct MONIKER_MERIT
* mmLeft
= (const struct MONIKER_MERIT
*)left
;
906 const struct MONIKER_MERIT
* mmRight
= (const struct MONIKER_MERIT
*)right
;
908 if (mmLeft
->dwMerit
== mmRight
->dwMerit
)
910 if (mmLeft
->dwMerit
> mmRight
->dwMerit
)
916 * Exact match means whether or not to treat GUID_NULL's in filter data as wild cards
917 * (GUID_NULL's in input to function automatically treated as wild cards)
918 * Input/Output needed means match only on criteria if TRUE (with zero input types
919 * meaning match any input/output pin as long as one exists), otherwise match any
920 * filter that meets the rest of the requirements.
922 static HRESULT WINAPI
FilterMapper2_EnumMatchingFilters(
923 IFilterMapper2
* iface
,
924 IEnumMoniker
**ppEnum
,
930 const GUID
*pInputTypes
,
931 const REGPINMEDIUM
*pMedIn
,
932 const CLSID
*pPinCategoryIn
,
936 const GUID
*pOutputTypes
,
937 const REGPINMEDIUM
*pMedOut
,
938 const CLSID
*pPinCategoryOut
)
940 ICreateDevEnum
* pCreateDevEnum
;
941 IMoniker
* pMonikerCat
;
942 IEnumMoniker
* pEnumCat
;
944 struct Vector monikers
= {NULL
, 0, 0};
946 TRACE("(%p, %x, %s, %x, %s, %d, %p, %p, %p, %s, %s, %p, %p, %p)\n",
949 bExactMatch
? "true" : "false",
951 bInputNeeded
? "true" : "false",
956 bRender
? "true" : "false",
957 bOutputNeeded
? "true" : "false",
964 FIXME("dwFlags = %x not implemented\n", dwFlags
);
969 hr
= CoCreateInstance(&CLSID_SystemDeviceEnum
, NULL
, CLSCTX_INPROC
, &IID_ICreateDevEnum
, (LPVOID
*)&pCreateDevEnum
);
973 hr
= ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum
, &CLSID_ActiveMovieCategories
, &pEnumCat
, 0);
975 ICreateDevEnum_Release(pCreateDevEnum
);
979 while (IEnumMoniker_Next(pEnumCat
, 1, &pMonikerCat
, NULL
) == S_OK
)
981 IPropertyBag
* pPropBagCat
= NULL
;
983 HRESULT hrSub
; /* this is so that one buggy filter
984 doesn't make the whole lot fail */
988 hrSub
= IMoniker_BindToStorage(pMonikerCat
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBagCat
);
990 if (SUCCEEDED(hrSub
))
991 hrSub
= IPropertyBag_Read(pPropBagCat
, wszMeritName
, &var
, NULL
);
993 if (SUCCEEDED(hrSub
) && (V_UNION(&var
, ulVal
) >= dwMerit
))
996 IEnumMoniker
* pEnum
;
1001 if (TRACE_ON(quartz
))
1004 V_VT(&temp
) = VT_EMPTY
;
1005 IPropertyBag_Read(pPropBagCat
, wszFriendlyName
, &temp
, NULL
);
1006 TRACE("Considering category %s\n", debugstr_w(V_UNION(&temp
, bstrVal
)));
1007 VariantClear(&temp
);
1010 hrSub
= IPropertyBag_Read(pPropBagCat
, wszClsidName
, &var
, NULL
);
1012 if (SUCCEEDED(hrSub
))
1013 hrSub
= CLSIDFromString(V_UNION(&var
, bstrVal
), &clsidCat
);
1015 if (SUCCEEDED(hrSub
))
1016 hrSub
= ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum
, &clsidCat
, &pEnum
, 0);
1020 while (IEnumMoniker_Next(pEnum
, 1, &pMoniker
, NULL
) == S_OK
)
1022 IPropertyBag
* pPropBag
= NULL
;
1027 BOOL bInputMatch
= !bInputNeeded
;
1028 BOOL bOutputMatch
= !bOutputNeeded
;
1030 ZeroMemory(&rf2
, sizeof(rf2
));
1033 hrSub
= IMoniker_BindToStorage(pMoniker
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBag
);
1035 if (TRACE_ON(quartz
))
1038 V_VT(&temp
) = VT_EMPTY
;
1039 IPropertyBag_Read(pPropBag
, wszFriendlyName
, &temp
, NULL
);
1040 TRACE("Considering filter %s\n", debugstr_w(V_UNION(&temp
, bstrVal
)));
1041 VariantClear(&temp
);
1044 if (SUCCEEDED(hrSub
))
1046 hrSub
= IPropertyBag_Read(pPropBag
, wszFilterDataName
, &var
, NULL
);
1049 if (SUCCEEDED(hrSub
))
1050 hrSub
= SafeArrayAccessData(V_UNION(&var
, parray
), (LPVOID
*)&pData
);
1052 if (SUCCEEDED(hrSub
))
1053 hrSub
= FM2_ReadFilterData(pData
, &rf2
);
1056 SafeArrayUnaccessData(V_UNION(&var
, parray
));
1060 /* Logic used for bInputMatch expression:
1061 * There exists some pin such that bInputNeeded implies (pin is an input and
1062 * (bRender implies pin has render flag) and major/minor types members of
1064 * bOutputMatch is similar, but without the "bRender implies ..." part
1065 * and substituting variables names containing input for output
1068 /* determine whether filter meets requirements */
1069 if (SUCCEEDED(hrSub
) && (rf2
.dwMerit
>= dwMerit
))
1071 for (i
= 0; (i
< rf2
.u
.s1
.cPins2
) && (!bInputMatch
|| !bOutputMatch
); i
++)
1073 const REGFILTERPINS2
* rfp2
= rf2
.u
.s1
.rgPins2
+ i
;
1075 bInputMatch
= bInputMatch
|| (!(rfp2
->dwFlags
& REG_PINFLAG_B_OUTPUT
) &&
1076 (!bRender
|| (rfp2
->dwFlags
& REG_PINFLAG_B_RENDERER
)) &&
1077 MatchTypes(bExactMatch
, rfp2
->nMediaTypes
, rfp2
->lpMediaType
, cInputTypes
, pInputTypes
));
1078 bOutputMatch
= bOutputMatch
|| ((rfp2
->dwFlags
& REG_PINFLAG_B_OUTPUT
) &&
1079 MatchTypes(bExactMatch
, rfp2
->nMediaTypes
, rfp2
->lpMediaType
, cOutputTypes
, pOutputTypes
));
1082 if (bInputMatch
&& bOutputMatch
)
1084 struct MONIKER_MERIT mm
= {pMoniker
, rf2
.dwMerit
};
1085 IMoniker_AddRef(pMoniker
);
1086 add_data(&monikers
, (LPBYTE
)&mm
, sizeof(mm
));
1090 FM2_DeleteRegFilter(&rf2
);
1092 IPropertyBag_Release(pPropBag
);
1093 IMoniker_Release(pMoniker
);
1095 IEnumMoniker_Release(pEnum
);
1101 IPropertyBag_Release(pPropBagCat
);
1102 IMoniker_Release(pMonikerCat
);
1107 IMoniker
** ppMoniker
;
1109 ULONG nMonikerCount
= monikers
.current
/ sizeof(struct MONIKER_MERIT
);
1111 /* sort the monikers in descending merit order */
1112 qsort(monikers
.pData
, nMonikerCount
,
1113 sizeof(struct MONIKER_MERIT
),
1116 /* construct an IEnumMoniker interface */
1117 ppMoniker
= CoTaskMemAlloc(nMonikerCount
* sizeof(IMoniker
*));
1118 for (i
= 0; i
< nMonikerCount
; i
++)
1120 /* no need to AddRef here as already AddRef'd above */
1121 ppMoniker
[i
] = ((struct MONIKER_MERIT
*)monikers
.pData
)[i
].pMoniker
;
1123 hr
= EnumMonikerImpl_Create(ppMoniker
, nMonikerCount
, ppEnum
);
1124 CoTaskMemFree(ppMoniker
);
1127 delete_vector(&monikers
);
1128 IEnumMoniker_Release(pEnumCat
);
1129 ICreateDevEnum_Release(pCreateDevEnum
);
1134 static const IFilterMapper2Vtbl fm2vtbl
=
1137 FilterMapper2_QueryInterface
,
1138 FilterMapper2_AddRef
,
1139 FilterMapper2_Release
,
1141 FilterMapper2_CreateCategory
,
1142 FilterMapper2_UnregisterFilter
,
1143 FilterMapper2_RegisterFilter
,
1144 FilterMapper2_EnumMatchingFilters
1147 /*** IUnknown methods ***/
1149 static HRESULT WINAPI
FilterMapper_QueryInterface(IFilterMapper
* iface
, REFIID riid
, LPVOID
*ppv
)
1151 FilterMapper2Impl
*This
= impl_from_IFilterMapper(iface
);
1153 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
1155 return FilterMapper2_QueryInterface((IFilterMapper2
*)&This
->lpVtbl
, riid
, ppv
);
1158 static ULONG WINAPI
FilterMapper_AddRef(IFilterMapper
* iface
)
1160 FilterMapper2Impl
*This
= impl_from_IFilterMapper(iface
);
1162 return FilterMapper2_AddRef((IFilterMapper2
*)This
);
1165 static ULONG WINAPI
FilterMapper_Release(IFilterMapper
* iface
)
1167 FilterMapper2Impl
*This
= impl_from_IFilterMapper(iface
);
1169 return FilterMapper2_Release((IFilterMapper2
*)This
);
1172 /*** IFilterMapper methods ***/
1174 static HRESULT WINAPI
FilterMapper_EnumMatchingFilters(
1175 IFilterMapper
* iface
,
1176 IEnumRegFilters
**ppEnum
,
1186 FilterMapper2Impl
*This
= impl_from_IFilterMapper(iface
);
1189 IEnumMoniker
* ppEnumMoniker
;
1192 ULONG idx
= 0, nb_mon
= 0;
1193 REGFILTER
* regfilters
;
1196 TRACE("(%p/%p)->(%p, %x, %s, %s, %s, %s, %s, %s, %s) stub!\n",
1200 bInputNeeded
? "true" : "false",
1201 debugstr_guid(&clsInMaj
),
1202 debugstr_guid(&clsInSub
),
1203 bRender
? "true" : "false",
1204 bOutputNeeded
? "true" : "false",
1205 debugstr_guid(&clsOutMaj
),
1206 debugstr_guid(&clsOutSub
));
1208 InputType
[0] = clsInMaj
;
1209 InputType
[1] = clsInSub
;
1210 OutputType
[0] = clsOutMaj
;
1211 OutputType
[1] = clsOutSub
;
1215 hr
= IFilterMapper2_EnumMatchingFilters((IFilterMapper2
*)This
,
1235 while(IEnumMoniker_Next(ppEnumMoniker
, 1, &IMon
, &nb
) == S_OK
)
1237 IMoniker_Release(IMon
);
1243 IEnumMoniker_Release(ppEnumMoniker
);
1244 return IEnumRegFiltersImpl_Construct(NULL
, 0, ppEnum
);
1247 regfilters
= CoTaskMemAlloc(nb_mon
* sizeof(REGFILTER
));
1250 IEnumMoniker_Release(ppEnumMoniker
);
1251 return E_OUTOFMEMORY
;
1253 ZeroMemory(regfilters
, nb_mon
* sizeof(REGFILTER
)); /* will prevent bad free of Name in case of error. */
1255 IEnumMoniker_Reset(ppEnumMoniker
);
1256 while(IEnumMoniker_Next(ppEnumMoniker
, 1, &IMon
, &nb
) == S_OK
)
1258 IPropertyBag
* pPropBagCat
= NULL
;
1266 hrSub
= IMoniker_BindToStorage(IMon
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBagCat
);
1268 if (SUCCEEDED(hrSub
))
1269 hrSub
= IPropertyBag_Read(pPropBagCat
, wszClsidName
, &var
, NULL
);
1271 if (SUCCEEDED(hrSub
))
1272 hrSub
= CLSIDFromString(V_UNION(&var
, bstrVal
), &clsid
);
1276 if (SUCCEEDED(hrSub
))
1277 hrSub
= IPropertyBag_Read(pPropBagCat
, wszFriendlyName
, &var
, NULL
);
1279 if (SUCCEEDED(hrSub
))
1281 len
= (strlenW((WCHAR
*)V_UNION(&var
, bstrVal
))+1) * sizeof(WCHAR
);
1282 if (!(regfilters
[idx
].Name
= CoTaskMemAlloc(len
*2)))
1286 if (SUCCEEDED(hrSub
) && regfilters
[idx
].Name
)
1288 memcpy(regfilters
[idx
].Name
, V_UNION(&var
, bstrVal
), len
);
1289 regfilters
[idx
].Clsid
= clsid
;
1294 IPropertyBag_Release(pPropBagCat
);
1295 IMoniker_Release(IMon
);
1301 hr
= IEnumRegFiltersImpl_Construct(regfilters
, nb_mon
, ppEnum
);
1304 for (idx
= 0; idx
< nb_mon
; idx
++)
1305 CoTaskMemFree(regfilters
[idx
].Name
);
1306 CoTaskMemFree(regfilters
);
1307 IEnumMoniker_Release(ppEnumMoniker
);
1313 static HRESULT WINAPI
FilterMapper_RegisterFilter(IFilterMapper
* iface
, CLSID clsid
, LPCWSTR szName
, DWORD dwMerit
)
1316 LPWSTR wszClsid
= NULL
;
1319 WCHAR wszKeyName
[strlenW(wszFilterSlash
) + (CHARS_IN_GUID
-1) + 1];
1321 TRACE("(%p)->(%s, %s, %x)\n", iface
, debugstr_guid(&clsid
), debugstr_w(szName
), dwMerit
);
1323 hr
= StringFromCLSID(&clsid
, &wszClsid
);
1327 strcpyW(wszKeyName
, wszFilterSlash
);
1328 strcatW(wszKeyName
, wszClsid
);
1330 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
1331 hr
= HRESULT_FROM_WIN32(lRet
);
1336 lRet
= RegSetValueExW(hKey
, NULL
, 0, REG_SZ
, (const BYTE
*)szName
, (strlenW(szName
) + 1) * sizeof(WCHAR
));
1337 hr
= HRESULT_FROM_WIN32(lRet
);
1343 strcpyW(wszKeyName
, wszClsidSlash
);
1344 strcatW(wszKeyName
, wszClsid
);
1346 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
1347 hr
= HRESULT_FROM_WIN32(lRet
);
1352 lRet
= RegSetValueExW(hKey
, wszMeritName
, 0, REG_DWORD
, (LPBYTE
)&dwMerit
, sizeof(dwMerit
));
1353 hr
= HRESULT_FROM_WIN32(lRet
);
1357 CoTaskMemFree(wszClsid
);
1362 static HRESULT WINAPI
FilterMapper_RegisterFilterInstance(IFilterMapper
* iface
, CLSID clsid
, LPCWSTR szName
, CLSID
*MRId
)
1364 TRACE("(%p)->(%s, %s, %p)\n", iface
, debugstr_guid(&clsid
), debugstr_w(szName
), MRId
);
1366 /* Not implemented in Windows (tested on Win2k) */
1371 static HRESULT WINAPI
FilterMapper_RegisterPin(
1372 IFilterMapper
* iface
,
1379 CLSID ConnectsToFilter
,
1380 LPCWSTR ConnectsToPin
)
1384 LPWSTR wszClsid
= NULL
;
1386 HKEY hPinsKey
= NULL
;
1387 WCHAR
* wszPinsKeyName
;
1388 WCHAR wszKeyName
[strlenW(wszClsidSlash
) + (CHARS_IN_GUID
-1) + 1];
1390 TRACE("(%p)->(%s, %s, %d, %d, %d, %d, %s, %s)\n", iface
, debugstr_guid(&Filter
), debugstr_w(szName
), bRendered
,
1391 bOutput
, bZero
, bMany
, debugstr_guid(&ConnectsToFilter
), debugstr_w(ConnectsToPin
));
1393 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1397 strcpyW(wszKeyName
, wszClsidSlash
);
1398 strcatW(wszKeyName
, wszClsid
);
1400 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1401 hr
= HRESULT_FROM_WIN32(lRet
);
1406 wszPinsKeyName
= CoTaskMemAlloc((strlenW(wszPins
) + 1 + strlenW(szName
) + 1) * 2);
1407 if (!wszPinsKeyName
)
1413 strcpyW(wszPinsKeyName
, wszPins
);
1414 strcatW(wszPinsKeyName
, wszSlash
);
1415 strcatW(wszPinsKeyName
, szName
);
1417 lRet
= RegCreateKeyExW(hKey
, wszPinsKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hPinsKey
, NULL
);
1418 hr
= HRESULT_FROM_WIN32(lRet
);
1419 CoTaskMemFree(wszPinsKeyName
);
1424 lRet
= RegSetValueExW(hPinsKey
, wszAllowedMany
, 0, REG_DWORD
, (LPBYTE
)&bMany
, sizeof(bMany
));
1425 hr
= HRESULT_FROM_WIN32(lRet
);
1430 lRet
= RegSetValueExW(hPinsKey
, wszAllowedZero
, 0, REG_DWORD
, (LPBYTE
)&bZero
, sizeof(bZero
));
1431 hr
= HRESULT_FROM_WIN32(lRet
);
1436 lRet
= RegSetValueExW(hPinsKey
, wszDirection
, 0, REG_DWORD
, (LPBYTE
)&bOutput
, sizeof(bOutput
));
1437 hr
= HRESULT_FROM_WIN32(lRet
);
1442 lRet
= RegSetValueExW(hPinsKey
, wszIsRendered
, 0, REG_DWORD
, (LPBYTE
)&bRendered
, sizeof(bRendered
));
1443 hr
= HRESULT_FROM_WIN32(lRet
);
1448 HKEY hkeyDummy
= NULL
;
1450 lRet
= RegCreateKeyExW(hPinsKey
, wszTypes
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hkeyDummy
, NULL
);
1451 hr
= HRESULT_FROM_WIN32(lRet
);
1453 if (hkeyDummy
) RegCloseKey(hkeyDummy
);
1456 CoTaskMemFree(wszClsid
);
1460 CloseHandle(hPinsKey
);
1466 static HRESULT WINAPI
FilterMapper_RegisterPinType(
1467 IFilterMapper
* iface
,
1475 LPWSTR wszClsid
= NULL
;
1476 LPWSTR wszClsidMajorType
= NULL
;
1477 LPWSTR wszClsidSubType
= NULL
;
1479 WCHAR
* wszTypesKey
;
1480 WCHAR wszKeyName
[MAX_PATH
];
1482 TRACE("(%p)->(%s, %s, %s, %s)\n", iface
, debugstr_guid(&clsFilter
), debugstr_w(szName
),
1483 debugstr_guid(&clsMajorType
), debugstr_guid(&clsSubType
));
1485 hr
= StringFromCLSID(&clsFilter
, &wszClsid
);
1489 hr
= StringFromCLSID(&clsMajorType
, &wszClsidMajorType
);
1494 hr
= StringFromCLSID(&clsSubType
, &wszClsidSubType
);
1499 wszTypesKey
= CoTaskMemAlloc((strlenW(wszClsidSlash
) + strlenW(wszClsid
) + strlenW(wszPins
) +
1500 strlenW(szName
) + strlenW(wszTypes
) + 3 + 1) * 2);
1507 strcpyW(wszTypesKey
, wszClsidSlash
);
1508 strcatW(wszTypesKey
, wszClsid
);
1509 strcatW(wszTypesKey
, wszSlash
);
1510 strcatW(wszTypesKey
, wszPins
);
1511 strcatW(wszTypesKey
, wszSlash
);
1512 strcatW(wszTypesKey
, szName
);
1513 strcatW(wszTypesKey
, wszSlash
);
1514 strcatW(wszTypesKey
, wszTypes
);
1516 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszTypesKey
, 0, KEY_WRITE
, &hKey
);
1517 hr
= HRESULT_FROM_WIN32(lRet
);
1518 CoTaskMemFree(wszTypesKey
);
1523 HKEY hkeyDummy
= NULL
;
1525 strcpyW(wszKeyName
, wszClsidMajorType
);
1526 strcatW(wszKeyName
, wszSlash
);
1527 strcatW(wszKeyName
, wszClsidSubType
);
1529 lRet
= RegCreateKeyExW(hKey
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hkeyDummy
, NULL
);
1530 hr
= HRESULT_FROM_WIN32(lRet
);
1533 if (hkeyDummy
) RegCloseKey(hkeyDummy
);
1536 CoTaskMemFree(wszClsid
);
1537 CoTaskMemFree(wszClsidMajorType
);
1538 CoTaskMemFree(wszClsidSubType
);
1543 static HRESULT WINAPI
FilterMapper_UnregisterFilter(IFilterMapper
* iface
, CLSID Filter
)
1547 LPWSTR wszClsid
= NULL
;
1549 WCHAR wszKeyName
[strlenW(wszClsidSlash
) + (CHARS_IN_GUID
-1) + 1];
1551 TRACE("(%p)->(%s)\n", iface
, debugstr_guid(&Filter
));
1553 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1557 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszFilter
, 0, KEY_WRITE
, &hKey
);
1558 hr
= HRESULT_FROM_WIN32(lRet
);
1563 lRet
= RegDeleteKeyW(hKey
, wszClsid
);
1564 hr
= HRESULT_FROM_WIN32(lRet
);
1570 strcpyW(wszKeyName
, wszClsidSlash
);
1571 strcatW(wszKeyName
, wszClsid
);
1573 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1574 hr
= HRESULT_FROM_WIN32(lRet
);
1579 lRet
= RegDeleteValueW(hKey
, wszMeritName
);
1580 if (lRet
!= ERROR_SUCCESS
)
1581 hr
= HRESULT_FROM_WIN32(lRet
);
1583 lRet
= RegDeleteTreeW(hKey
, wszPins
);
1584 if (lRet
!= ERROR_SUCCESS
)
1585 hr
= HRESULT_FROM_WIN32(lRet
);
1590 CoTaskMemFree(wszClsid
);
1595 static HRESULT WINAPI
FilterMapper_UnregisterFilterInstance(IFilterMapper
* iface
, CLSID MRId
)
1597 TRACE("(%p)->(%s)\n", iface
, debugstr_guid(&MRId
));
1599 /* Not implemented in Windows (tested on Win2k) */
1604 static HRESULT WINAPI
FilterMapper_UnregisterPin(IFilterMapper
* iface
, CLSID Filter
, LPCWSTR Name
)
1608 LPWSTR wszClsid
= NULL
;
1610 WCHAR
* wszPinNameKey
;
1611 WCHAR wszKeyName
[strlenW(wszClsidSlash
) + (CHARS_IN_GUID
-1) + 1];
1613 TRACE("(%p)->(%s, %s)\n", iface
, debugstr_guid(&Filter
), debugstr_w(Name
));
1616 return E_INVALIDARG
;
1618 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1622 strcpyW(wszKeyName
, wszClsidSlash
);
1623 strcatW(wszKeyName
, wszClsid
);
1625 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1626 hr
= HRESULT_FROM_WIN32(lRet
);
1631 wszPinNameKey
= CoTaskMemAlloc((strlenW(wszPins
) + 1 + strlenW(Name
) + 1) * 2);
1638 strcpyW(wszPinNameKey
, wszPins
);
1639 strcatW(wszPinNameKey
, wszSlash
);
1640 strcatW(wszPinNameKey
, Name
);
1642 lRet
= RegDeleteTreeW(hKey
, wszPinNameKey
);
1643 hr
= HRESULT_FROM_WIN32(lRet
);
1644 CoTaskMemFree(wszPinNameKey
);
1647 CoTaskMemFree(wszClsid
);
1654 static const IFilterMapperVtbl fmvtbl
=
1657 FilterMapper_QueryInterface
,
1658 FilterMapper_AddRef
,
1659 FilterMapper_Release
,
1661 FilterMapper_RegisterFilter
,
1662 FilterMapper_RegisterFilterInstance
,
1663 FilterMapper_RegisterPin
,
1664 FilterMapper_RegisterPinType
,
1665 FilterMapper_UnregisterFilter
,
1666 FilterMapper_UnregisterFilterInstance
,
1667 FilterMapper_UnregisterPin
,
1668 FilterMapper_EnumMatchingFilters
1672 /*** IUnknown methods ***/
1673 static HRESULT WINAPI
AMFilterData_QueryInterface(IAMFilterData
* iface
, REFIID riid
, LPVOID
*ppv
)
1675 FilterMapper2Impl
*This
= impl_from_IAMFilterData(iface
);
1677 return FilterMapper2_QueryInterface((IFilterMapper2
*)This
, riid
, ppv
);
1680 static ULONG WINAPI
AMFilterData_AddRef(IAMFilterData
* iface
)
1682 FilterMapper2Impl
*This
= impl_from_IAMFilterData(iface
);
1684 return FilterMapper2_AddRef((IFilterMapper2
*)This
);
1687 static ULONG WINAPI
AMFilterData_Release(IAMFilterData
* iface
)
1689 FilterMapper2Impl
*This
= impl_from_IAMFilterData(iface
);
1691 return FilterMapper2_Release((IFilterMapper2
*)This
);
1694 /*** IAMFilterData methods ***/
1695 static HRESULT WINAPI
AMFilterData_ParseFilterData(IAMFilterData
* iface
,
1696 BYTE
*pData
, ULONG cb
,
1697 BYTE
**ppRegFilter2
)
1699 FilterMapper2Impl
*This
= impl_from_IAMFilterData(iface
);
1703 TRACE("(%p/%p)->(%p, %d, %p)\n", This
, iface
, pData
, cb
, ppRegFilter2
);
1705 prf2
= CoTaskMemAlloc(sizeof(*prf2
));
1707 return E_OUTOFMEMORY
;
1708 *ppRegFilter2
= (BYTE
*)&prf2
;
1710 hr
= FM2_ReadFilterData(pData
, prf2
);
1713 CoTaskMemFree(prf2
);
1714 *ppRegFilter2
= NULL
;
1720 static HRESULT WINAPI
AMFilterData_CreateFilterData(IAMFilterData
* iface
,
1722 BYTE
**pRegFilterData
,
1725 FilterMapper2Impl
*This
= impl_from_IAMFilterData(iface
);
1727 TRACE("(%p/%p)->(%p, %p, %p)\n", This
, iface
, prf2
, pRegFilterData
, pcb
);
1729 return FM2_WriteFilterData(prf2
, pRegFilterData
, pcb
);
1732 static const IAMFilterDataVtbl AMFilterDataVtbl
= {
1733 AMFilterData_QueryInterface
,
1734 AMFilterData_AddRef
,
1735 AMFilterData_Release
,
1736 AMFilterData_ParseFilterData
,
1737 AMFilterData_CreateFilterData