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