2 * IFilterMapper & IFilterMapper3 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 #include "quartz_private.h"
28 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
30 typedef struct FilterMapper3Impl
32 IUnknown IUnknown_inner
;
33 IFilterMapper3 IFilterMapper3_iface
;
34 IFilterMapper IFilterMapper_iface
;
35 IAMFilterData IAMFilterData_iface
;
40 static inline FilterMapper3Impl
*impl_from_IFilterMapper3( IFilterMapper3
*iface
)
42 return CONTAINING_RECORD(iface
, FilterMapper3Impl
, IFilterMapper3_iface
);
45 static inline FilterMapper3Impl
*impl_from_IFilterMapper( IFilterMapper
*iface
)
47 return CONTAINING_RECORD(iface
, FilterMapper3Impl
, IFilterMapper_iface
);
50 static inline FilterMapper3Impl
*impl_from_IAMFilterData( IAMFilterData
*iface
)
52 return CONTAINING_RECORD(iface
, FilterMapper3Impl
, IAMFilterData_iface
);
55 static inline FilterMapper3Impl
*impl_from_IUnknown( IUnknown
*iface
)
57 return CONTAINING_RECORD(iface
, FilterMapper3Impl
, IUnknown_inner
);
60 static const WCHAR wszClsidSlash
[] = {'C','L','S','I','D','\\',0};
61 static const WCHAR wszSlashInstance
[] = {'\\','I','n','s','t','a','n','c','e','\\',0};
62 static const WCHAR wszSlash
[] = {'\\',0};
64 /* CLSID property in media category Moniker */
65 static const WCHAR wszClsidName
[] = {'C','L','S','I','D',0};
66 /* FriendlyName property in media category Moniker */
67 static const WCHAR wszFriendlyName
[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
68 /* Merit property in media category Moniker (CLSID_ActiveMovieCategories only) */
69 static const WCHAR wszMeritName
[] = {'M','e','r','i','t',0};
70 /* FilterData property in media category Moniker (not CLSID_ActiveMovieCategories) */
71 static const WCHAR wszFilterDataName
[] = {'F','i','l','t','e','r','D','a','t','a',0};
72 /* For filters registered with IFilterMapper */
73 static const WCHAR wszFilterSlash
[] = {'F','i','l','t','e','r','\\',0};
74 static const WCHAR wszFilter
[] = {'F','i','l','t','e','r',0};
75 /* For pins registered with IFilterMapper */
76 static const WCHAR wszPins
[] = {'P','i','n','s',0};
77 static const WCHAR wszAllowedMany
[] = {'A','l','l','o','w','e','d','M','a','n','y',0};
78 static const WCHAR wszAllowedZero
[] = {'A','l','l','o','w','e','d','Z','e','r','o',0};
79 static const WCHAR wszDirection
[] = {'D','i','r','e','c','t','i','o','n',0};
80 static const WCHAR wszIsRendered
[] = {'I','s','R','e','n','d','e','r','e','d',0};
81 /* For types registered with IFilterMapper */
82 static const WCHAR wszTypes
[] = {'T','y','p','e','s',0};
85 /* registry format for REGFILTER2 */
96 BYTE signature
[4]; /* e.g. "0pi3" */
101 DWORD bCategory
; /* is there a category clsid? */
102 /* optional: dwOffsetCategoryClsid */
107 BYTE signature
[4]; /* e.g. "0ty3" */
122 int capacity
; /* in bytes */
123 int current
; /* pointer to next free byte */
126 /* returns the position it was added at */
127 static int add_data(struct Vector
* v
, const BYTE
* pData
, int size
)
129 int index
= v
->current
;
130 if (v
->current
+ size
> v
->capacity
)
132 LPBYTE pOldData
= v
->pData
;
133 v
->capacity
= (v
->capacity
+ size
) * 2;
134 v
->pData
= CoTaskMemAlloc(v
->capacity
);
135 memcpy(v
->pData
, pOldData
, v
->current
);
136 CoTaskMemFree(pOldData
);
138 memcpy(v
->pData
+ v
->current
, pData
, size
);
143 static int find_data(const struct Vector
* v
, const BYTE
* pData
, int size
)
146 for (index
= 0; index
< v
->current
; index
++)
147 if (!memcmp(v
->pData
+ index
, pData
, size
))
153 static void delete_vector(struct Vector
* v
)
155 CoTaskMemFree(v
->pData
);
160 /*** IUnknown (inner) methods ***/
162 static HRESULT WINAPI
Inner_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
164 FilterMapper3Impl
*This
= impl_from_IUnknown(iface
);
166 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
169 if (IsEqualIID(riid
, &IID_IUnknown
))
170 *ppv
= &This
->IUnknown_inner
;
171 else if (IsEqualIID(riid
, &IID_IFilterMapper2
) || IsEqualIID(riid
, &IID_IFilterMapper3
))
172 *ppv
= &This
->IFilterMapper3_iface
;
173 else if (IsEqualIID(riid
, &IID_IFilterMapper
))
174 *ppv
= &This
->IFilterMapper_iface
;
175 else if (IsEqualIID(riid
, &IID_IAMFilterData
))
176 *ppv
= &This
->IAMFilterData_iface
;
180 IUnknown_AddRef((IUnknown
*)*ppv
);
184 FIXME("No interface for %s\n", debugstr_guid(riid
));
185 return E_NOINTERFACE
;
188 static ULONG WINAPI
Inner_AddRef(IUnknown
*iface
)
190 FilterMapper3Impl
*This
= impl_from_IUnknown(iface
);
191 ULONG ref
= InterlockedIncrement(&This
->ref
);
193 TRACE("(%p)->(): new ref = %d\n", This
, ref
);
198 static ULONG WINAPI
Inner_Release(IUnknown
*iface
)
200 FilterMapper3Impl
*This
= impl_from_IUnknown(iface
);
201 ULONG ref
= InterlockedDecrement(&This
->ref
);
203 TRACE("(%p)->(): new ref = %d\n", This
, ref
);
211 static const IUnknownVtbl IInner_VTable
=
213 Inner_QueryInterface
,
218 static HRESULT WINAPI
FilterMapper3_QueryInterface(IFilterMapper3
* iface
, REFIID riid
, LPVOID
*ppv
)
220 FilterMapper3Impl
*This
= impl_from_IFilterMapper3(iface
);
222 return IUnknown_QueryInterface(This
->outer_unk
, riid
, ppv
);
225 static ULONG WINAPI
FilterMapper3_AddRef(IFilterMapper3
* iface
)
227 FilterMapper3Impl
*This
= impl_from_IFilterMapper3(iface
);
229 return IUnknown_AddRef(This
->outer_unk
);
232 static ULONG WINAPI
FilterMapper3_Release(IFilterMapper3
* iface
)
234 FilterMapper3Impl
*This
= impl_from_IFilterMapper3(iface
);
236 return IUnknown_Release(This
->outer_unk
);
239 /*** IFilterMapper3 methods ***/
241 static HRESULT WINAPI
FilterMapper3_CreateCategory(
242 IFilterMapper3
* iface
,
243 REFCLSID clsidCategory
,
244 DWORD dwCategoryMerit
,
245 LPCWSTR szDescription
)
247 LPWSTR wClsidAMCat
= NULL
;
248 LPWSTR wClsidCategory
= NULL
;
249 WCHAR wszKeyName
[ARRAYSIZE(wszClsidSlash
)-1 + ARRAYSIZE(wszSlashInstance
)-1 + (CHARS_IN_GUID
-1) * 2 + 1];
254 TRACE("(%s, %x, %s)\n", debugstr_guid(clsidCategory
), dwCategoryMerit
, debugstr_w(szDescription
));
256 hr
= StringFromCLSID(&CLSID_ActiveMovieCategories
, &wClsidAMCat
);
260 hr
= StringFromCLSID(clsidCategory
, &wClsidCategory
);
265 strcpyW(wszKeyName
, wszClsidSlash
);
266 strcatW(wszKeyName
, wClsidAMCat
);
267 strcatW(wszKeyName
, wszSlashInstance
);
268 strcatW(wszKeyName
, wClsidCategory
);
270 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
271 hr
= HRESULT_FROM_WIN32(lRet
);
276 lRet
= RegSetValueExW(hKey
, wszFriendlyName
, 0, REG_SZ
, (const BYTE
*)szDescription
, (strlenW(szDescription
) + 1) * sizeof(WCHAR
));
277 hr
= HRESULT_FROM_WIN32(lRet
);
282 lRet
= RegSetValueExW(hKey
, wszClsidName
, 0, REG_SZ
, (LPBYTE
)wClsidCategory
, (strlenW(wClsidCategory
) + 1) * sizeof(WCHAR
));
283 hr
= HRESULT_FROM_WIN32(lRet
);
288 lRet
= RegSetValueExW(hKey
, wszMeritName
, 0, REG_DWORD
, (LPBYTE
)&dwCategoryMerit
, sizeof(dwCategoryMerit
));
289 hr
= HRESULT_FROM_WIN32(lRet
);
293 CoTaskMemFree(wClsidCategory
);
294 CoTaskMemFree(wClsidAMCat
);
299 static HRESULT WINAPI
FilterMapper3_UnregisterFilter(
300 IFilterMapper3
* iface
,
301 const CLSID
*pclsidCategory
,
302 const OLECHAR
*szInstance
,
305 WCHAR wszKeyName
[MAX_PATH
];
306 LPWSTR wClsidCategory
= NULL
;
307 LPWSTR wFilter
= NULL
;
310 TRACE("(%p, %s, %s)\n", pclsidCategory
, debugstr_w(szInstance
), debugstr_guid(Filter
));
313 pclsidCategory
= &CLSID_LegacyAmFilterCategory
;
315 hr
= StringFromCLSID(pclsidCategory
, &wClsidCategory
);
319 strcpyW(wszKeyName
, wszClsidSlash
);
320 strcatW(wszKeyName
, wClsidCategory
);
321 strcatW(wszKeyName
, wszSlashInstance
);
323 strcatW(wszKeyName
, szInstance
);
326 hr
= StringFromCLSID(Filter
, &wFilter
);
328 strcatW(wszKeyName
, wFilter
);
334 LONG lRet
= RegDeleteKeyW(HKEY_CLASSES_ROOT
, wszKeyName
);
335 hr
= HRESULT_FROM_WIN32(lRet
);
338 CoTaskMemFree(wClsidCategory
);
339 CoTaskMemFree(wFilter
);
344 static HRESULT
FM2_WriteFriendlyName(IPropertyBag
* pPropBag
, LPCWSTR szName
)
350 V_VT(&var
) = VT_BSTR
;
351 V_BSTR(&var
) = value
= SysAllocString(szName
);
353 ret
= IPropertyBag_Write(pPropBag
, wszFriendlyName
, &var
);
354 SysFreeString(value
);
359 static HRESULT
FM2_WriteClsid(IPropertyBag
* pPropBag
, REFCLSID clsid
)
361 LPWSTR wszClsid
= NULL
;
365 hr
= StringFromCLSID(clsid
, &wszClsid
);
369 V_VT(&var
) = VT_BSTR
;
370 V_BSTR(&var
) = wszClsid
;
371 hr
= IPropertyBag_Write(pPropBag
, wszClsidName
, &var
);
373 CoTaskMemFree(wszClsid
);
377 static HRESULT
FM2_WriteFilterData(const REGFILTER2
* prf2
, BYTE
**ppData
, ULONG
*pcbData
)
379 int size
= sizeof(struct REG_RF
);
381 struct Vector mainStore
= {NULL
, 0, 0};
382 struct Vector clsidStore
= {NULL
, 0, 0};
386 rrf
.dwVersion
= prf2
->dwVersion
;
387 rrf
.dwMerit
= prf2
->dwMerit
;
388 rrf
.dwPins
= prf2
->u
.s2
.cPins2
;
391 add_data(&mainStore
, (LPBYTE
)&rrf
, sizeof(rrf
));
393 for (i
= 0; i
< prf2
->u
.s2
.cPins2
; i
++)
395 size
+= sizeof(struct REG_RFP
);
396 if (prf2
->u
.s2
.rgPins2
[i
].clsPinCategory
)
397 size
+= sizeof(DWORD
);
398 size
+= prf2
->u
.s2
.rgPins2
[i
].nMediaTypes
* sizeof(struct REG_TYPE
);
399 size
+= prf2
->u
.s2
.rgPins2
[i
].nMediums
* sizeof(DWORD
);
402 for (i
= 0; i
< prf2
->u
.s2
.cPins2
; i
++)
405 REGFILTERPINS2 rgPin2
= prf2
->u
.s2
.rgPins2
[i
];
408 rrfp
.signature
[0] = '0';
409 rrfp
.signature
[1] = 'p';
410 rrfp
.signature
[2] = 'i';
411 rrfp
.signature
[3] = '3';
412 rrfp
.signature
[0] += i
;
413 rrfp
.dwFlags
= rgPin2
.dwFlags
;
414 rrfp
.dwInstances
= rgPin2
.cInstances
;
415 rrfp
.dwMediaTypes
= rgPin2
.nMediaTypes
;
416 rrfp
.dwMediums
= rgPin2
.nMediums
;
417 rrfp
.bCategory
= rgPin2
.clsPinCategory
? 1 : 0;
419 add_data(&mainStore
, (LPBYTE
)&rrfp
, sizeof(rrfp
));
422 DWORD index
= find_data(&clsidStore
, (const BYTE
*)rgPin2
.clsPinCategory
, sizeof(CLSID
));
424 index
= add_data(&clsidStore
, (const BYTE
*)rgPin2
.clsPinCategory
, sizeof(CLSID
));
427 add_data(&mainStore
, (LPBYTE
)&index
, sizeof(index
));
430 for (j
= 0; j
< rgPin2
.nMediaTypes
; j
++)
433 const CLSID
* clsMinorType
= rgPin2
.lpMediaType
[j
].clsMinorType
? rgPin2
.lpMediaType
[j
].clsMinorType
: &MEDIASUBTYPE_NULL
;
434 rt
.signature
[0] = '0';
435 rt
.signature
[1] = 't';
436 rt
.signature
[2] = 'y';
437 rt
.signature
[3] = '3';
438 rt
.signature
[0] += j
;
440 rt
.dwOffsetMajor
= find_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMajorType
, sizeof(CLSID
));
441 if (rt
.dwOffsetMajor
== -1)
442 rt
.dwOffsetMajor
= add_data(&clsidStore
, (const BYTE
*)rgPin2
.lpMediaType
[j
].clsMajorType
, sizeof(CLSID
));
443 rt
.dwOffsetMajor
+= size
;
444 rt
.dwOffsetMinor
= find_data(&clsidStore
, (const BYTE
*)clsMinorType
, sizeof(CLSID
));
445 if (rt
.dwOffsetMinor
== -1)
446 rt
.dwOffsetMinor
= add_data(&clsidStore
, (const BYTE
*)clsMinorType
, sizeof(CLSID
));
447 rt
.dwOffsetMinor
+= size
;
449 add_data(&mainStore
, (LPBYTE
)&rt
, sizeof(rt
));
452 for (j
= 0; j
< rgPin2
.nMediums
; j
++)
454 DWORD index
= find_data(&clsidStore
, (const BYTE
*)(rgPin2
.lpMedium
+ j
), sizeof(REGPINMEDIUM
));
456 index
= add_data(&clsidStore
, (const BYTE
*)(rgPin2
.lpMedium
+ j
), sizeof(REGPINMEDIUM
));
459 add_data(&mainStore
, (LPBYTE
)&index
, sizeof(index
));
465 *pcbData
= mainStore
.current
+ clsidStore
.current
;
466 *ppData
= CoTaskMemAlloc(*pcbData
);
473 memcpy(*ppData
, mainStore
.pData
, mainStore
.current
);
474 memcpy((*ppData
) + mainStore
.current
, clsidStore
.pData
, clsidStore
.current
);
477 delete_vector(&mainStore
);
478 delete_vector(&clsidStore
);
482 static HRESULT
FM2_ReadFilterData(BYTE
*pData
, REGFILTER2
* prf2
)
485 struct REG_RF
* prrf
;
488 REGFILTERPINS2
* rgPins2
;
490 prrf
= (struct REG_RF
*)pData
;
493 if (prrf
->dwVersion
!= 2)
495 FIXME("Filter registry version %d not supported\n", prrf
->dwVersion
);
496 ZeroMemory(prf2
, sizeof(*prf2
));
502 TRACE("version = %d, merit = %x, #pins = %d, unused = %x\n",
503 prrf
->dwVersion
, prrf
->dwMerit
, prrf
->dwPins
, prrf
->dwUnused
);
505 prf2
->dwVersion
= prrf
->dwVersion
;
506 prf2
->dwMerit
= prrf
->dwMerit
;
507 prf2
->u
.s2
.cPins2
= prrf
->dwPins
;
508 rgPins2
= CoTaskMemAlloc(prrf
->dwPins
* sizeof(*rgPins2
));
509 prf2
->u
.s2
.rgPins2
= rgPins2
;
510 pCurrent
+= sizeof(struct REG_RF
);
512 for (i
= 0; i
< prrf
->dwPins
; i
++)
514 struct REG_RFP
* prrfp
= (struct REG_RFP
*)pCurrent
;
515 REGPINTYPES
* lpMediaType
;
516 REGPINMEDIUM
* lpMedium
;
519 /* FIXME: check signature */
521 TRACE("\tsignature = %s\n", debugstr_an((const char*)prrfp
->signature
, 4));
523 TRACE("\tpin[%d]: flags = %x, instances = %d, media types = %d, mediums = %d\n",
524 i
, prrfp
->dwFlags
, prrfp
->dwInstances
, prrfp
->dwMediaTypes
, prrfp
->dwMediums
);
526 rgPins2
[i
].dwFlags
= prrfp
->dwFlags
;
527 rgPins2
[i
].cInstances
= prrfp
->dwInstances
;
528 rgPins2
[i
].nMediaTypes
= prrfp
->dwMediaTypes
;
529 rgPins2
[i
].nMediums
= prrfp
->dwMediums
;
530 pCurrent
+= sizeof(struct REG_RFP
);
531 if (prrfp
->bCategory
)
533 CLSID
* clsCat
= CoTaskMemAlloc(sizeof(CLSID
));
534 memcpy(clsCat
, pData
+ *(DWORD
*)(pCurrent
), sizeof(CLSID
));
535 pCurrent
+= sizeof(DWORD
);
536 rgPins2
[i
].clsPinCategory
= clsCat
;
539 rgPins2
[i
].clsPinCategory
= NULL
;
541 if (rgPins2
[i
].nMediaTypes
> 0)
542 lpMediaType
= CoTaskMemAlloc(rgPins2
[i
].nMediaTypes
* sizeof(*lpMediaType
));
546 rgPins2
[i
].lpMediaType
= lpMediaType
;
548 for (j
= 0; j
< rgPins2
[i
].nMediaTypes
; j
++)
550 struct REG_TYPE
* prt
= (struct REG_TYPE
*)pCurrent
;
551 CLSID
* clsMajor
= CoTaskMemAlloc(sizeof(CLSID
));
552 CLSID
* clsMinor
= CoTaskMemAlloc(sizeof(CLSID
));
554 /* FIXME: check signature */
555 TRACE("\t\tsignature = %s\n", debugstr_an((const char*)prt
->signature
, 4));
557 memcpy(clsMajor
, pData
+ prt
->dwOffsetMajor
, sizeof(CLSID
));
558 memcpy(clsMinor
, pData
+ prt
->dwOffsetMinor
, sizeof(CLSID
));
560 lpMediaType
[j
].clsMajorType
= clsMajor
;
561 lpMediaType
[j
].clsMinorType
= clsMinor
;
563 pCurrent
+= sizeof(*prt
);
566 if (rgPins2
[i
].nMediums
> 0)
567 lpMedium
= CoTaskMemAlloc(rgPins2
[i
].nMediums
* sizeof(*lpMedium
));
571 rgPins2
[i
].lpMedium
= lpMedium
;
573 for (j
= 0; j
< rgPins2
[i
].nMediums
; j
++)
575 DWORD dwOffset
= *(DWORD
*)pCurrent
;
577 memcpy(lpMedium
+ j
, pData
+ dwOffset
, sizeof(REGPINMEDIUM
));
579 pCurrent
+= sizeof(dwOffset
);
588 static void FM2_DeleteRegFilter(REGFILTER2
* prf2
)
591 for (i
= 0; i
< prf2
->u
.s2
.cPins2
; i
++)
594 if (prf2
->u
.s2
.rgPins2
[i
].clsPinCategory
)
595 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
[i
].clsPinCategory
);
597 for (j
= 0; j
< prf2
->u
.s2
.rgPins2
[i
].nMediaTypes
; j
++)
599 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
[i
].lpMediaType
[j
].clsMajorType
);
600 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
[i
].lpMediaType
[j
].clsMinorType
);
602 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
[i
].lpMediaType
);
603 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
[i
].lpMedium
);
605 CoTaskMemFree((LPVOID
)prf2
->u
.s2
.rgPins2
);
608 static HRESULT WINAPI
FilterMapper3_RegisterFilter(
609 IFilterMapper3
* iface
,
610 REFCLSID clsidFilter
,
612 IMoniker
**ppMoniker
,
613 const CLSID
*pclsidCategory
,
614 const OLECHAR
*szInstance
,
615 const REGFILTER2
*prf2
)
617 IParseDisplayName
* pParser
= NULL
;
618 IBindCtx
* pBindCtx
= NULL
;
619 IMoniker
* pMoniker
= NULL
;
620 IPropertyBag
* pPropBag
= NULL
;
622 LPWSTR pwszParseName
= NULL
;
624 static const WCHAR wszDevice
[] = {'@','d','e','v','i','c','e',':','s','w',':',0};
627 LPWSTR szClsidTemp
= NULL
;
628 REGFILTER2 regfilter2
;
629 REGFILTERPINS2
* pregfp2
= NULL
;
631 TRACE("(%s, %s, %p, %s, %s, %p)\n",
632 debugstr_guid(clsidFilter
),
635 debugstr_guid(pclsidCategory
),
636 debugstr_w(szInstance
),
639 if (prf2
->dwVersion
== 2)
643 else if (prf2
->dwVersion
== 1)
647 /* REGFILTER2 structure is converted from version 1 to 2. Tested on Win2k. */
648 regfilter2
.dwVersion
= 2;
649 regfilter2
.dwMerit
= prf2
->dwMerit
;
650 regfilter2
.u
.s2
.cPins2
= prf2
->u
.s1
.cPins
;
651 pregfp2
= CoTaskMemAlloc(prf2
->u
.s1
.cPins
* sizeof(REGFILTERPINS2
));
652 regfilter2
.u
.s2
.rgPins2
= pregfp2
;
653 for (i
= 0; i
< prf2
->u
.s1
.cPins
; i
++)
656 if (prf2
->u
.s1
.rgPins
[i
].bRendered
)
657 flags
|= REG_PINFLAG_B_RENDERER
;
658 if (prf2
->u
.s1
.rgPins
[i
].bOutput
)
659 flags
|= REG_PINFLAG_B_OUTPUT
;
660 if (prf2
->u
.s1
.rgPins
[i
].bZero
)
661 flags
|= REG_PINFLAG_B_ZERO
;
662 if (prf2
->u
.s1
.rgPins
[i
].bMany
)
663 flags
|= REG_PINFLAG_B_MANY
;
664 pregfp2
[i
].dwFlags
= flags
;
665 pregfp2
[i
].cInstances
= 1;
666 pregfp2
[i
].nMediaTypes
= prf2
->u
.s1
.rgPins
[i
].nMediaTypes
;
667 pregfp2
[i
].lpMediaType
= prf2
->u
.s1
.rgPins
[i
].lpMediaType
;
668 pregfp2
[i
].nMediums
= 0;
669 pregfp2
[i
].lpMedium
= NULL
;
670 pregfp2
[i
].clsPinCategory
= NULL
;
675 FIXME("dwVersion other that 1 or 2 not supported at the moment\n");
683 /* MSDN mentions the inexistent CLSID_ActiveMovieFilters GUID.
684 * In fact this is the CLSID_LegacyAmFilterCategory one */
685 pclsidCategory
= &CLSID_LegacyAmFilterCategory
;
687 /* sizeof... will include the null terminator and
688 * the + 1 is for the separator ('\\'). The -1 is
689 * because CHARS_IN_GUID includes the null terminator
691 nameLen
= sizeof(wszDevice
)/sizeof(wszDevice
[0]) + CHARS_IN_GUID
- 1 + 1;
694 nameLen
+= strlenW(szInstance
);
696 nameLen
+= CHARS_IN_GUID
- 1; /* CHARS_IN_GUID includes null terminator */
698 pCurrent
= pwszParseName
= CoTaskMemAlloc(nameLen
*sizeof(WCHAR
));
700 return E_OUTOFMEMORY
;
702 strcpyW(pwszParseName
, wszDevice
);
703 pCurrent
+= strlenW(wszDevice
);
705 hr
= StringFromCLSID(pclsidCategory
, &szClsidTemp
);
709 memcpy(pCurrent
, szClsidTemp
, CHARS_IN_GUID
* sizeof(WCHAR
));
710 pCurrent
+= CHARS_IN_GUID
- 1;
714 strcpyW(pCurrent
+1, szInstance
);
717 CoTaskMemFree(szClsidTemp
);
720 hr
= StringFromCLSID(clsidFilter
, &szClsidTemp
);
722 strcpyW(pCurrent
+1, szClsidTemp
);
727 hr
= CoCreateInstance(&CLSID_CDeviceMoniker
, NULL
, CLSCTX_INPROC
, &IID_IParseDisplayName
, (LPVOID
*)&pParser
);
730 hr
= CreateBindCtx(0, &pBindCtx
);
733 hr
= IParseDisplayName_ParseDisplayName(pParser
, pBindCtx
, pwszParseName
, &ulEaten
, &pMoniker
);
736 IBindCtx_Release(pBindCtx
);
738 IParseDisplayName_Release(pParser
);
741 hr
= IMoniker_BindToStorage(pMoniker
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
)&pPropBag
);
744 hr
= FM2_WriteFriendlyName(pPropBag
, szName
);
747 hr
= FM2_WriteClsid(pPropBag
, clsidFilter
);
754 hr
= FM2_WriteFilterData(®filter2
, &pData
, &cbData
);
759 SAFEARRAYBOUND saBound
;
762 saBound
.cElements
= cbData
;
763 psa
= SafeArrayCreate(VT_UI1
, 1, &saBound
);
766 ERR("Couldn't create SAFEARRAY\n");
773 hr
= SafeArrayAccessData(psa
, (LPVOID
*)&pbSAData
);
776 memcpy(pbSAData
, pData
, cbData
);
777 hr
= SafeArrayUnaccessData(psa
);
781 V_VT(&var
) = VT_ARRAY
| VT_UI1
;
785 hr
= IPropertyBag_Write(pPropBag
, wszFilterDataName
, &var
);
788 SafeArrayDestroy(psa
);
789 CoTaskMemFree(pData
);
794 IPropertyBag_Release(pPropBag
);
795 CoTaskMemFree(szClsidTemp
);
796 CoTaskMemFree(pwszParseName
);
798 if (SUCCEEDED(hr
) && ppMoniker
)
799 *ppMoniker
= pMoniker
;
801 IMoniker_Release(pMoniker
);
803 CoTaskMemFree(pregfp2
);
805 TRACE("-- returning %x\n", hr
);
810 /* internal helper function */
811 static BOOL
MatchTypes(
814 const REGPINTYPES
* pPinTypes
,
816 const GUID
* pMatchTypes
)
821 if ((nMatchTypes
== 0) && (nPinTypes
> 0))
824 for (j
= 0; j
< nPinTypes
; j
++)
827 for (i
= 0; i
< nMatchTypes
*2; i
+=2)
829 if (((!bExactMatch
&& IsEqualGUID(pPinTypes
[j
].clsMajorType
, &GUID_NULL
)) || IsEqualGUID(&pMatchTypes
[i
], &GUID_NULL
) || IsEqualGUID(pPinTypes
[j
].clsMajorType
, &pMatchTypes
[i
])) &&
830 ((!bExactMatch
&& IsEqualGUID(pPinTypes
[j
].clsMinorType
, &GUID_NULL
)) || IsEqualGUID(&pMatchTypes
[i
+1], &GUID_NULL
) || IsEqualGUID(pPinTypes
[j
].clsMinorType
, &pMatchTypes
[i
+1])))
840 /* internal helper function for qsort of MONIKER_MERIT array */
841 static int mm_compare(const void * left
, const void * right
)
843 const struct MONIKER_MERIT
* mmLeft
= left
;
844 const struct MONIKER_MERIT
* mmRight
= right
;
846 if (mmLeft
->dwMerit
== mmRight
->dwMerit
)
848 if (mmLeft
->dwMerit
> mmRight
->dwMerit
)
854 * Exact match means whether or not to treat GUID_NULL's in filter data as wild cards
855 * (GUID_NULL's in input to function automatically treated as wild cards)
856 * Input/Output needed means match only on criteria if TRUE (with zero input types
857 * meaning match any input/output pin as long as one exists), otherwise match any
858 * filter that meets the rest of the requirements.
860 static HRESULT WINAPI
FilterMapper3_EnumMatchingFilters(
861 IFilterMapper3
* iface
,
862 IEnumMoniker
**ppEnum
,
868 const GUID
*pInputTypes
,
869 const REGPINMEDIUM
*pMedIn
,
870 const CLSID
*pPinCategoryIn
,
874 const GUID
*pOutputTypes
,
875 const REGPINMEDIUM
*pMedOut
,
876 const CLSID
*pPinCategoryOut
)
878 ICreateDevEnum
* pCreateDevEnum
;
879 IMoniker
* pMonikerCat
;
880 IEnumMoniker
* pEnumCat
;
882 struct Vector monikers
= {NULL
, 0, 0};
884 TRACE("(%p, %x, %s, %x, %s, %d, %p, %p, %p, %s, %s, %p, %p, %p)\n",
887 bExactMatch
? "true" : "false",
889 bInputNeeded
? "true" : "false",
894 bRender
? "true" : "false",
895 bOutputNeeded
? "true" : "false",
902 FIXME("dwFlags = %x not implemented\n", dwFlags
);
907 hr
= CoCreateInstance(&CLSID_SystemDeviceEnum
, NULL
, CLSCTX_INPROC
, &IID_ICreateDevEnum
, (LPVOID
*)&pCreateDevEnum
);
911 hr
= ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum
, &CLSID_ActiveMovieCategories
, &pEnumCat
, 0);
913 ICreateDevEnum_Release(pCreateDevEnum
);
917 while (IEnumMoniker_Next(pEnumCat
, 1, &pMonikerCat
, NULL
) == S_OK
)
919 IPropertyBag
* pPropBagCat
= NULL
;
921 HRESULT hrSub
; /* this is so that one buggy filter
922 doesn't make the whole lot fail */
926 hrSub
= IMoniker_BindToStorage(pMonikerCat
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBagCat
);
928 if (SUCCEEDED(hrSub
))
929 hrSub
= IPropertyBag_Read(pPropBagCat
, wszMeritName
, &var
, NULL
);
931 if (SUCCEEDED(hrSub
) && (V_UI4(&var
) >= dwMerit
))
934 IEnumMoniker
* pEnum
;
939 if (TRACE_ON(quartz
))
942 V_VT(&temp
) = VT_EMPTY
;
943 IPropertyBag_Read(pPropBagCat
, wszFriendlyName
, &temp
, NULL
);
944 TRACE("Considering category %s\n", debugstr_w(V_BSTR(&temp
)));
948 hrSub
= IPropertyBag_Read(pPropBagCat
, wszClsidName
, &var
, NULL
);
950 if (SUCCEEDED(hrSub
))
951 hrSub
= CLSIDFromString(V_BSTR(&var
), &clsidCat
);
953 if (SUCCEEDED(hrSub
))
954 hrSub
= ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum
, &clsidCat
, &pEnum
, 0);
958 while (IEnumMoniker_Next(pEnum
, 1, &pMoniker
, NULL
) == S_OK
)
960 IPropertyBag
* pPropBag
= NULL
;
965 BOOL bInputMatch
= !bInputNeeded
;
966 BOOL bOutputMatch
= !bOutputNeeded
;
968 ZeroMemory(&rf2
, sizeof(rf2
));
971 hrSub
= IMoniker_BindToStorage(pMoniker
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBag
);
973 if (TRACE_ON(quartz
))
976 V_VT(&temp
) = VT_EMPTY
;
977 IPropertyBag_Read(pPropBag
, wszFriendlyName
, &temp
, NULL
);
978 TRACE("Considering filter %s\n", debugstr_w(V_BSTR(&temp
)));
982 if (SUCCEEDED(hrSub
))
984 hrSub
= IPropertyBag_Read(pPropBag
, wszFilterDataName
, &var
, NULL
);
987 if (SUCCEEDED(hrSub
))
988 hrSub
= SafeArrayAccessData(V_ARRAY(&var
), (LPVOID
*)&pData
);
990 if (SUCCEEDED(hrSub
))
991 hrSub
= FM2_ReadFilterData(pData
, &rf2
);
994 SafeArrayUnaccessData(V_ARRAY(&var
));
998 /* Logic used for bInputMatch expression:
999 * There exists some pin such that bInputNeeded implies (pin is an input and
1000 * (bRender implies pin has render flag) and major/minor types members of
1002 * bOutputMatch is similar, but without the "bRender implies ..." part
1003 * and substituting variables names containing input for output
1006 /* determine whether filter meets requirements */
1007 if (SUCCEEDED(hrSub
) && (rf2
.dwMerit
>= dwMerit
))
1009 for (i
= 0; (i
< rf2
.u
.s2
.cPins2
) && (!bInputMatch
|| !bOutputMatch
); i
++)
1011 const REGFILTERPINS2
* rfp2
= rf2
.u
.s2
.rgPins2
+ i
;
1013 bInputMatch
= bInputMatch
|| (!(rfp2
->dwFlags
& REG_PINFLAG_B_OUTPUT
) &&
1014 (!bRender
|| (rfp2
->dwFlags
& REG_PINFLAG_B_RENDERER
)) &&
1015 MatchTypes(bExactMatch
, rfp2
->nMediaTypes
, rfp2
->lpMediaType
, cInputTypes
, pInputTypes
));
1016 bOutputMatch
= bOutputMatch
|| ((rfp2
->dwFlags
& REG_PINFLAG_B_OUTPUT
) &&
1017 MatchTypes(bExactMatch
, rfp2
->nMediaTypes
, rfp2
->lpMediaType
, cOutputTypes
, pOutputTypes
));
1020 if (bInputMatch
&& bOutputMatch
)
1022 struct MONIKER_MERIT mm
= {pMoniker
, rf2
.dwMerit
};
1023 IMoniker_AddRef(pMoniker
);
1024 add_data(&monikers
, (LPBYTE
)&mm
, sizeof(mm
));
1028 FM2_DeleteRegFilter(&rf2
);
1030 IPropertyBag_Release(pPropBag
);
1031 IMoniker_Release(pMoniker
);
1033 IEnumMoniker_Release(pEnum
);
1039 IPropertyBag_Release(pPropBagCat
);
1040 IMoniker_Release(pMonikerCat
);
1045 IMoniker
** ppMoniker
;
1047 ULONG nMonikerCount
= monikers
.current
/ sizeof(struct MONIKER_MERIT
);
1049 /* sort the monikers in descending merit order */
1050 qsort(monikers
.pData
, nMonikerCount
,
1051 sizeof(struct MONIKER_MERIT
),
1054 /* construct an IEnumMoniker interface */
1055 ppMoniker
= CoTaskMemAlloc(nMonikerCount
* sizeof(IMoniker
*));
1056 for (i
= 0; i
< nMonikerCount
; i
++)
1058 /* no need to AddRef here as already AddRef'd above */
1059 ppMoniker
[i
] = ((struct MONIKER_MERIT
*)monikers
.pData
)[i
].pMoniker
;
1061 hr
= EnumMonikerImpl_Create(ppMoniker
, nMonikerCount
, ppEnum
);
1062 CoTaskMemFree(ppMoniker
);
1065 delete_vector(&monikers
);
1066 IEnumMoniker_Release(pEnumCat
);
1067 ICreateDevEnum_Release(pCreateDevEnum
);
1072 static HRESULT WINAPI
FilterMapper3_GetICreateDevEnum(IFilterMapper3
*iface
, ICreateDevEnum
**ppEnum
)
1074 TRACE("(%p, %p)\n", iface
, ppEnum
);
1077 return CoCreateInstance(&CLSID_SystemDeviceEnum
, NULL
, CLSCTX_INPROC
, &IID_ICreateDevEnum
, (void**)ppEnum
);
1080 static const IFilterMapper3Vtbl fm3vtbl
=
1083 FilterMapper3_QueryInterface
,
1084 FilterMapper3_AddRef
,
1085 FilterMapper3_Release
,
1087 FilterMapper3_CreateCategory
,
1088 FilterMapper3_UnregisterFilter
,
1089 FilterMapper3_RegisterFilter
,
1090 FilterMapper3_EnumMatchingFilters
,
1091 FilterMapper3_GetICreateDevEnum
1094 /*** IUnknown methods ***/
1096 static HRESULT WINAPI
FilterMapper_QueryInterface(IFilterMapper
* iface
, REFIID riid
, LPVOID
*ppv
)
1098 FilterMapper3Impl
*This
= impl_from_IFilterMapper(iface
);
1100 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
1102 return FilterMapper3_QueryInterface(&This
->IFilterMapper3_iface
, riid
, ppv
);
1105 static ULONG WINAPI
FilterMapper_AddRef(IFilterMapper
* iface
)
1107 FilterMapper3Impl
*This
= impl_from_IFilterMapper(iface
);
1109 return IUnknown_AddRef(This
->outer_unk
);
1112 static ULONG WINAPI
FilterMapper_Release(IFilterMapper
* iface
)
1114 FilterMapper3Impl
*This
= impl_from_IFilterMapper(iface
);
1116 return IUnknown_Release(This
->outer_unk
);
1119 /*** IFilterMapper methods ***/
1121 static HRESULT WINAPI
FilterMapper_EnumMatchingFilters(
1122 IFilterMapper
* iface
,
1123 IEnumRegFilters
**ppEnum
,
1133 FilterMapper3Impl
*This
= impl_from_IFilterMapper(iface
);
1136 IEnumMoniker
* ppEnumMoniker
;
1139 ULONG idx
= 0, nb_mon
= 0;
1140 REGFILTER
* regfilters
;
1143 TRACE("(%p/%p)->(%p, %x, %s, %s, %s, %s, %s, %s, %s) stub!\n",
1147 bInputNeeded
? "true" : "false",
1148 debugstr_guid(&clsInMaj
),
1149 debugstr_guid(&clsInSub
),
1150 bRender
? "true" : "false",
1151 bOutputNeeded
? "true" : "false",
1152 debugstr_guid(&clsOutMaj
),
1153 debugstr_guid(&clsOutSub
));
1155 InputType
[0] = clsInMaj
;
1156 InputType
[1] = clsInSub
;
1157 OutputType
[0] = clsOutMaj
;
1158 OutputType
[1] = clsOutSub
;
1162 hr
= IFilterMapper3_EnumMatchingFilters(&This
->IFilterMapper3_iface
, &ppEnumMoniker
, 0, TRUE
,
1163 dwMerit
, bInputNeeded
, 1, InputType
, NULL
, &GUID_NULL
, bRender
, bOutputNeeded
, 1,
1164 OutputType
, NULL
, &GUID_NULL
);
1169 while(IEnumMoniker_Next(ppEnumMoniker
, 1, &IMon
, &nb
) == S_OK
)
1171 IMoniker_Release(IMon
);
1177 IEnumMoniker_Release(ppEnumMoniker
);
1178 return IEnumRegFiltersImpl_Construct(NULL
, 0, ppEnum
);
1181 regfilters
= CoTaskMemAlloc(nb_mon
* sizeof(REGFILTER
));
1184 IEnumMoniker_Release(ppEnumMoniker
);
1185 return E_OUTOFMEMORY
;
1187 ZeroMemory(regfilters
, nb_mon
* sizeof(REGFILTER
)); /* will prevent bad free of Name in case of error. */
1189 IEnumMoniker_Reset(ppEnumMoniker
);
1190 while(IEnumMoniker_Next(ppEnumMoniker
, 1, &IMon
, &nb
) == S_OK
)
1192 IPropertyBag
* pPropBagCat
= NULL
;
1200 hrSub
= IMoniker_BindToStorage(IMon
, NULL
, NULL
, &IID_IPropertyBag
, (LPVOID
*)&pPropBagCat
);
1202 if (SUCCEEDED(hrSub
))
1203 hrSub
= IPropertyBag_Read(pPropBagCat
, wszClsidName
, &var
, NULL
);
1205 if (SUCCEEDED(hrSub
))
1206 hrSub
= CLSIDFromString(V_BSTR(&var
), &clsid
);
1210 if (SUCCEEDED(hrSub
))
1211 hrSub
= IPropertyBag_Read(pPropBagCat
, wszFriendlyName
, &var
, NULL
);
1213 if (SUCCEEDED(hrSub
))
1215 len
= (strlenW(V_BSTR(&var
))+1) * sizeof(WCHAR
);
1216 if (!(regfilters
[idx
].Name
= CoTaskMemAlloc(len
*2)))
1220 if (SUCCEEDED(hrSub
) && regfilters
[idx
].Name
)
1222 memcpy(regfilters
[idx
].Name
, V_BSTR(&var
), len
);
1223 regfilters
[idx
].Clsid
= clsid
;
1228 IPropertyBag_Release(pPropBagCat
);
1229 IMoniker_Release(IMon
);
1235 hr
= IEnumRegFiltersImpl_Construct(regfilters
, nb_mon
, ppEnum
);
1238 for (idx
= 0; idx
< nb_mon
; idx
++)
1239 CoTaskMemFree(regfilters
[idx
].Name
);
1240 CoTaskMemFree(regfilters
);
1241 IEnumMoniker_Release(ppEnumMoniker
);
1247 static HRESULT WINAPI
FilterMapper_RegisterFilter(IFilterMapper
* iface
, CLSID clsid
, LPCWSTR szName
, DWORD dwMerit
)
1250 LPWSTR wszClsid
= NULL
;
1253 WCHAR wszKeyName
[ARRAYSIZE(wszFilterSlash
)-1 + (CHARS_IN_GUID
-1) + 1];
1255 TRACE("(%p)->(%s, %s, %x)\n", iface
, debugstr_guid(&clsid
), debugstr_w(szName
), dwMerit
);
1257 hr
= StringFromCLSID(&clsid
, &wszClsid
);
1261 strcpyW(wszKeyName
, wszFilterSlash
);
1262 strcatW(wszKeyName
, wszClsid
);
1264 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
1265 hr
= HRESULT_FROM_WIN32(lRet
);
1270 lRet
= RegSetValueExW(hKey
, NULL
, 0, REG_SZ
, (const BYTE
*)szName
, (strlenW(szName
) + 1) * sizeof(WCHAR
));
1271 hr
= HRESULT_FROM_WIN32(lRet
);
1277 strcpyW(wszKeyName
, wszClsidSlash
);
1278 strcatW(wszKeyName
, wszClsid
);
1280 lRet
= RegCreateKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hKey
, NULL
);
1281 hr
= HRESULT_FROM_WIN32(lRet
);
1286 lRet
= RegSetValueExW(hKey
, wszMeritName
, 0, REG_DWORD
, (LPBYTE
)&dwMerit
, sizeof(dwMerit
));
1287 hr
= HRESULT_FROM_WIN32(lRet
);
1291 CoTaskMemFree(wszClsid
);
1296 static HRESULT WINAPI
FilterMapper_RegisterFilterInstance(IFilterMapper
* iface
, CLSID clsid
, LPCWSTR szName
, CLSID
*MRId
)
1298 TRACE("(%p)->(%s, %s, %p)\n", iface
, debugstr_guid(&clsid
), debugstr_w(szName
), MRId
);
1300 /* Not implemented in Windows (tested on Win2k) */
1305 static HRESULT WINAPI
FilterMapper_RegisterPin(
1306 IFilterMapper
* iface
,
1313 CLSID ConnectsToFilter
,
1314 LPCWSTR ConnectsToPin
)
1318 LPWSTR wszClsid
= NULL
;
1320 HKEY hPinsKey
= NULL
;
1321 WCHAR
* wszPinsKeyName
;
1322 WCHAR wszKeyName
[ARRAYSIZE(wszClsidSlash
)-1 + (CHARS_IN_GUID
-1) + 1];
1324 TRACE("(%p)->(%s, %s, %d, %d, %d, %d, %s, %s)\n", iface
, debugstr_guid(&Filter
), debugstr_w(szName
), bRendered
,
1325 bOutput
, bZero
, bMany
, debugstr_guid(&ConnectsToFilter
), debugstr_w(ConnectsToPin
));
1327 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1331 strcpyW(wszKeyName
, wszClsidSlash
);
1332 strcatW(wszKeyName
, wszClsid
);
1334 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1335 hr
= HRESULT_FROM_WIN32(lRet
);
1340 wszPinsKeyName
= CoTaskMemAlloc((strlenW(wszPins
) + 1 + strlenW(szName
) + 1) * 2);
1341 if (!wszPinsKeyName
)
1347 strcpyW(wszPinsKeyName
, wszPins
);
1348 strcatW(wszPinsKeyName
, wszSlash
);
1349 strcatW(wszPinsKeyName
, szName
);
1351 lRet
= RegCreateKeyExW(hKey
, wszPinsKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hPinsKey
, NULL
);
1352 hr
= HRESULT_FROM_WIN32(lRet
);
1353 CoTaskMemFree(wszPinsKeyName
);
1358 lRet
= RegSetValueExW(hPinsKey
, wszAllowedMany
, 0, REG_DWORD
, (LPBYTE
)&bMany
, sizeof(bMany
));
1359 hr
= HRESULT_FROM_WIN32(lRet
);
1364 lRet
= RegSetValueExW(hPinsKey
, wszAllowedZero
, 0, REG_DWORD
, (LPBYTE
)&bZero
, sizeof(bZero
));
1365 hr
= HRESULT_FROM_WIN32(lRet
);
1370 lRet
= RegSetValueExW(hPinsKey
, wszDirection
, 0, REG_DWORD
, (LPBYTE
)&bOutput
, sizeof(bOutput
));
1371 hr
= HRESULT_FROM_WIN32(lRet
);
1376 lRet
= RegSetValueExW(hPinsKey
, wszIsRendered
, 0, REG_DWORD
, (LPBYTE
)&bRendered
, sizeof(bRendered
));
1377 hr
= HRESULT_FROM_WIN32(lRet
);
1382 HKEY hkeyDummy
= NULL
;
1384 lRet
= RegCreateKeyExW(hPinsKey
, wszTypes
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hkeyDummy
, NULL
);
1385 hr
= HRESULT_FROM_WIN32(lRet
);
1387 if (hkeyDummy
) RegCloseKey(hkeyDummy
);
1390 CoTaskMemFree(wszClsid
);
1394 RegCloseKey(hPinsKey
);
1400 static HRESULT WINAPI
FilterMapper_RegisterPinType(
1401 IFilterMapper
* iface
,
1409 LPWSTR wszClsid
= NULL
;
1410 LPWSTR wszClsidMajorType
= NULL
;
1411 LPWSTR wszClsidSubType
= NULL
;
1413 WCHAR
* wszTypesKey
;
1414 WCHAR wszKeyName
[MAX_PATH
];
1416 TRACE("(%p)->(%s, %s, %s, %s)\n", iface
, debugstr_guid(&clsFilter
), debugstr_w(szName
),
1417 debugstr_guid(&clsMajorType
), debugstr_guid(&clsSubType
));
1419 hr
= StringFromCLSID(&clsFilter
, &wszClsid
);
1423 hr
= StringFromCLSID(&clsMajorType
, &wszClsidMajorType
);
1428 hr
= StringFromCLSID(&clsSubType
, &wszClsidSubType
);
1433 wszTypesKey
= CoTaskMemAlloc((strlenW(wszClsidSlash
) + strlenW(wszClsid
) + strlenW(wszPins
) +
1434 strlenW(szName
) + strlenW(wszTypes
) + 3 + 1) * 2);
1441 strcpyW(wszTypesKey
, wszClsidSlash
);
1442 strcatW(wszTypesKey
, wszClsid
);
1443 strcatW(wszTypesKey
, wszSlash
);
1444 strcatW(wszTypesKey
, wszPins
);
1445 strcatW(wszTypesKey
, wszSlash
);
1446 strcatW(wszTypesKey
, szName
);
1447 strcatW(wszTypesKey
, wszSlash
);
1448 strcatW(wszTypesKey
, wszTypes
);
1450 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszTypesKey
, 0, KEY_WRITE
, &hKey
);
1451 hr
= HRESULT_FROM_WIN32(lRet
);
1452 CoTaskMemFree(wszTypesKey
);
1457 HKEY hkeyDummy
= NULL
;
1459 strcpyW(wszKeyName
, wszClsidMajorType
);
1460 strcatW(wszKeyName
, wszSlash
);
1461 strcatW(wszKeyName
, wszClsidSubType
);
1463 lRet
= RegCreateKeyExW(hKey
, wszKeyName
, 0, NULL
, REG_OPTION_NON_VOLATILE
, KEY_WRITE
, NULL
, &hkeyDummy
, NULL
);
1464 hr
= HRESULT_FROM_WIN32(lRet
);
1467 if (hkeyDummy
) RegCloseKey(hkeyDummy
);
1470 CoTaskMemFree(wszClsid
);
1471 CoTaskMemFree(wszClsidMajorType
);
1472 CoTaskMemFree(wszClsidSubType
);
1477 static HRESULT WINAPI
FilterMapper_UnregisterFilter(IFilterMapper
* iface
, CLSID Filter
)
1481 LPWSTR wszClsid
= NULL
;
1483 WCHAR wszKeyName
[ARRAYSIZE(wszClsidSlash
)-1 + (CHARS_IN_GUID
-1) + 1];
1485 TRACE("(%p)->(%s)\n", iface
, debugstr_guid(&Filter
));
1487 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1491 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszFilter
, 0, KEY_WRITE
, &hKey
);
1492 hr
= HRESULT_FROM_WIN32(lRet
);
1497 lRet
= RegDeleteKeyW(hKey
, wszClsid
);
1498 hr
= HRESULT_FROM_WIN32(lRet
);
1504 strcpyW(wszKeyName
, wszClsidSlash
);
1505 strcatW(wszKeyName
, wszClsid
);
1507 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1508 hr
= HRESULT_FROM_WIN32(lRet
);
1513 lRet
= RegDeleteValueW(hKey
, wszMeritName
);
1514 if (lRet
!= ERROR_SUCCESS
)
1515 hr
= HRESULT_FROM_WIN32(lRet
);
1517 lRet
= RegDeleteTreeW(hKey
, wszPins
);
1518 if (lRet
!= ERROR_SUCCESS
)
1519 hr
= HRESULT_FROM_WIN32(lRet
);
1524 CoTaskMemFree(wszClsid
);
1529 static HRESULT WINAPI
FilterMapper_UnregisterFilterInstance(IFilterMapper
* iface
, CLSID MRId
)
1531 TRACE("(%p)->(%s)\n", iface
, debugstr_guid(&MRId
));
1533 /* Not implemented in Windows (tested on Win2k) */
1538 static HRESULT WINAPI
FilterMapper_UnregisterPin(IFilterMapper
* iface
, CLSID Filter
, LPCWSTR Name
)
1542 LPWSTR wszClsid
= NULL
;
1544 WCHAR
* wszPinNameKey
;
1545 WCHAR wszKeyName
[ARRAYSIZE(wszClsidSlash
)-1 + (CHARS_IN_GUID
-1) + 1];
1547 TRACE("(%p)->(%s, %s)\n", iface
, debugstr_guid(&Filter
), debugstr_w(Name
));
1550 return E_INVALIDARG
;
1552 hr
= StringFromCLSID(&Filter
, &wszClsid
);
1556 strcpyW(wszKeyName
, wszClsidSlash
);
1557 strcatW(wszKeyName
, wszClsid
);
1559 lRet
= RegOpenKeyExW(HKEY_CLASSES_ROOT
, wszKeyName
, 0, KEY_WRITE
, &hKey
);
1560 hr
= HRESULT_FROM_WIN32(lRet
);
1565 wszPinNameKey
= CoTaskMemAlloc((strlenW(wszPins
) + 1 + strlenW(Name
) + 1) * 2);
1572 strcpyW(wszPinNameKey
, wszPins
);
1573 strcatW(wszPinNameKey
, wszSlash
);
1574 strcatW(wszPinNameKey
, Name
);
1576 lRet
= RegDeleteTreeW(hKey
, wszPinNameKey
);
1577 hr
= HRESULT_FROM_WIN32(lRet
);
1578 CoTaskMemFree(wszPinNameKey
);
1581 CoTaskMemFree(wszClsid
);
1588 static const IFilterMapperVtbl fmvtbl
=
1591 FilterMapper_QueryInterface
,
1592 FilterMapper_AddRef
,
1593 FilterMapper_Release
,
1595 FilterMapper_RegisterFilter
,
1596 FilterMapper_RegisterFilterInstance
,
1597 FilterMapper_RegisterPin
,
1598 FilterMapper_RegisterPinType
,
1599 FilterMapper_UnregisterFilter
,
1600 FilterMapper_UnregisterFilterInstance
,
1601 FilterMapper_UnregisterPin
,
1602 FilterMapper_EnumMatchingFilters
1606 /*** IUnknown methods ***/
1607 static HRESULT WINAPI
AMFilterData_QueryInterface(IAMFilterData
* iface
, REFIID riid
, LPVOID
*ppv
)
1609 FilterMapper3Impl
*This
= impl_from_IAMFilterData(iface
);
1611 return IUnknown_QueryInterface(This
->outer_unk
, riid
, ppv
);
1614 static ULONG WINAPI
AMFilterData_AddRef(IAMFilterData
* iface
)
1616 FilterMapper3Impl
*This
= impl_from_IAMFilterData(iface
);
1618 return IUnknown_AddRef(This
->outer_unk
);
1621 static ULONG WINAPI
AMFilterData_Release(IAMFilterData
* iface
)
1623 FilterMapper3Impl
*This
= impl_from_IAMFilterData(iface
);
1625 return IUnknown_Release(This
->outer_unk
);
1628 /*** IAMFilterData methods ***/
1629 static HRESULT WINAPI
AMFilterData_ParseFilterData(IAMFilterData
* iface
,
1630 BYTE
*pData
, ULONG cb
,
1631 BYTE
**ppRegFilter2
)
1633 FilterMapper3Impl
*This
= impl_from_IAMFilterData(iface
);
1635 static REGFILTER2
*prf2
;
1637 TRACE("(%p/%p)->(%p, %d, %p)\n", This
, iface
, pData
, cb
, ppRegFilter2
);
1639 prf2
= CoTaskMemAlloc(sizeof(*prf2
));
1641 return E_OUTOFMEMORY
;
1642 *ppRegFilter2
= (BYTE
*)&prf2
;
1644 hr
= FM2_ReadFilterData(pData
, prf2
);
1647 CoTaskMemFree(prf2
);
1648 *ppRegFilter2
= NULL
;
1654 static HRESULT WINAPI
AMFilterData_CreateFilterData(IAMFilterData
* iface
,
1656 BYTE
**pRegFilterData
,
1659 FilterMapper3Impl
*This
= impl_from_IAMFilterData(iface
);
1661 TRACE("(%p/%p)->(%p, %p, %p)\n", This
, iface
, prf2
, pRegFilterData
, pcb
);
1663 return FM2_WriteFilterData(prf2
, pRegFilterData
, pcb
);
1666 static const IAMFilterDataVtbl AMFilterDataVtbl
= {
1667 AMFilterData_QueryInterface
,
1668 AMFilterData_AddRef
,
1669 AMFilterData_Release
,
1670 AMFilterData_ParseFilterData
,
1671 AMFilterData_CreateFilterData
1674 HRESULT
FilterMapper2_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
1676 FilterMapper3Impl
* pFM2impl
;
1678 TRACE("(%p, %p)\n", pUnkOuter
, ppObj
);
1680 pFM2impl
= CoTaskMemAlloc(sizeof(*pFM2impl
));
1682 return E_OUTOFMEMORY
;
1684 pFM2impl
->IUnknown_inner
.lpVtbl
= &IInner_VTable
;
1685 pFM2impl
->IFilterMapper3_iface
.lpVtbl
= &fm3vtbl
;
1686 pFM2impl
->IFilterMapper_iface
.lpVtbl
= &fmvtbl
;
1687 pFM2impl
->IAMFilterData_iface
.lpVtbl
= &AMFilterDataVtbl
;
1691 pFM2impl
->outer_unk
= pUnkOuter
;
1693 pFM2impl
->outer_unk
= &pFM2impl
->IUnknown_inner
;
1695 *ppObj
= &pFM2impl
->IUnknown_inner
;
1697 TRACE("-- created at %p\n", pFM2impl
);
1702 HRESULT
FilterMapper_create(IUnknown
*pUnkOuter
, LPVOID
*ppObj
)
1704 FilterMapper3Impl
*pFM2impl
;
1707 TRACE("(%p, %p)\n", pUnkOuter
, ppObj
);
1709 hr
= FilterMapper2_create(pUnkOuter
, (LPVOID
*)&pFM2impl
);
1713 *ppObj
= &pFM2impl
->IFilterMapper_iface
;