dlls/quartz/filtermapper.c

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