dlls/quartz/filtermapper.c

   1 /*
   2  * IFilterMapper & IFilterMapper2 Implementations
   3  *
   4  * Copyright 2003 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "winreg.h"
  27 #include "winerror.h"
  28
  29 #include "quartz_private.h"
  30
  31 #define COM_NO_WINDOWS_H
  32 #include "ole2.h"
  33 #include "strmif.h"
  34 #include "wine/obj_property.h"
  35 #include "wine/unicode.h"
  36 #include "uuids.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  41
  42 typedef struct FilterMapper2Impl
  43 {
  44     ICOM_VFIELD(IFilterMapper2);
  45     ICOM_VTABLE(IFilterMapper) * lpVtblFilterMapper;
  46     ULONG refCount;
  47 } FilterMapper2Impl;
  48
  49 static struct ICOM_VTABLE(IFilterMapper2) fm2vtbl;
  50 static struct ICOM_VTABLE(IFilterMapper) fmvtbl;
  51
  52 #define _IFilterMapper_Offset ((int)(&(((FilterMapper2Impl*)0)->lpVtblFilterMapper)))
  53 #define ICOM_THIS_From_IFilterMapper(impl, iface) impl* This = (impl*)(((char*)iface)-_IFilterMapper_Offset)
  54
  55 static const WCHAR wszClsidSlash[] = {'C','L','S','I','D','\\',0};
  56 static const WCHAR wszSlashInstance[] = {'\\','I','n','s','t','a','n','c','e','\\',0};
  57
  58 /* CLSID property in media category Moniker */
  59 static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
  60 /* FriendlyName property in media category Moniker */
  61 static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
  62 /* Merit property in media category Moniker (CLSID_ActiveMovieCategories only) */
  63 static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};
  64 /* FilterData property in media category Moniker (not CLSID_ActiveMovieCategories) */
  65 static const WCHAR wszFilterDataName[] = {'F','i','l','t','e','r','D','a','t','a',0};
  66
  67 /* registry format for REGFILTER2 */
  68 struct REG_RF
  69 {
  70     DWORD dwVersion;
  71     DWORD dwMerit;
  72     DWORD dwPins;
  73     DWORD dwUnused;
  74 };
  75
  76 struct REG_RFP
  77 {
  78     BYTE signature[4]; /* e.g. "0pi3" */
  79     DWORD dwFlags;
  80     DWORD dwInstances;
  81     DWORD dwMediaTypes;
  82     DWORD dwMediums;
  83     DWORD bCategory; /* is there a category clsid? */
  84     /* optional: dwOffsetCategoryClsid */
  85 };
  86
  87 struct REG_TYPE
  88 {
  89     BYTE signature[4]; /* e.g. "0ty3" */
  90     DWORD dwUnused;
  91     DWORD dwOffsetMajor;
  92     DWORD dwOffsetMinor;
  93 };
  94
  95 struct MONIKER_MERIT
  96 {
  97     IMoniker * pMoniker;
  98     DWORD dwMerit;
  99 };
 100
 101 struct Vector
 102 {
 103     LPBYTE pData;
 104     int capacity; /* in bytes */
 105     int current; /* pointer to next free byte */
 106 };
 107
 108 /* returns the position it was added at */
 109 static int add_data(struct Vector * v, const BYTE * pData, int size)
 110 {
 111     int index = v->current;
 112     if (v->current + size > v->capacity)
 113     {
 114         LPBYTE pOldData = v->pData;
 115         v->capacity = (v->capacity + size) * 2;
 116         v->pData = CoTaskMemAlloc(v->capacity);
 117         memcpy(v->pData, pOldData, v->current);
 118         CoTaskMemFree(pOldData);
 119     }
 120     memcpy(v->pData + v->current, pData, size);
 121     v->current += size;
 122     return index;
 123 }
 124
 125 static int find_data(struct Vector * v, const BYTE * pData, int size)
 126 {
 127     int index;
 128     for (index = 0; index < v->current; index++)
 129         if (!memcmp(v->pData + index, pData, size))
 130             return index;
 131     /* not found */
 132     return -1;
 133 }
 134
 135 static void delete_vector(struct Vector * v)
 136 {
 137     if (v->pData)
 138         CoTaskMemFree(v->pData);
 139     v->current = 0;
 140     v->capacity = 0;
 141 }
 142
 143 HRESULT FilterMapper2_create(IUnknown *pUnkOuter, LPVOID *ppObj)
 144 {
 145     FilterMapper2Impl * pFM2impl;
 146
 147     TRACE("(%p, %p)\n", pUnkOuter, ppObj);
 148
 149     if (pUnkOuter)
 150         return CLASS_E_NOAGGREGATION;
 151
 152     pFM2impl = CoTaskMemAlloc(sizeof(*pFM2impl));
 153     if (!pFM2impl)
 154         return E_OUTOFMEMORY;
 155
 156     pFM2impl->lpVtbl = &fm2vtbl;
 157     pFM2impl->lpVtblFilterMapper = &fmvtbl;
 158     pFM2impl->refCount = 1;
 159
 160     *ppObj = pFM2impl;
 161
 162     TRACE("-- created at %p\n", pFM2impl);
 163
 164     return S_OK;
 165 }
 166
 167 /*** IUnknown methods ***/
 168
 169 static HRESULT WINAPI FilterMapper2_QueryInterface(IFilterMapper2 * iface, REFIID riid, LPVOID *ppv)
 170 {
 171     ICOM_THIS(FilterMapper2Impl, iface);
 172
 173     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 174
 175     *ppv = NULL;
 176
 177     if (IsEqualIID(riid, &IID_IUnknown))
 178         *ppv = iface;
 179     else if (IsEqualIID(riid, &IID_IFilterMapper2))
 180         *ppv = iface;
 181     else if (IsEqualIID(riid, &IID_IFilterMapper))
 182         *ppv = &This->lpVtblFilterMapper;
 183
 184     if (*ppv != NULL)
 185     {
 186         IUnknown_AddRef((IUnknown *)*ppv);
 187         return S_OK;
 188     }
 189
 190     FIXME("No interface for %s\n", debugstr_guid(riid));
 191     return E_NOINTERFACE;
 192 }
 193
 194 static ULONG WINAPI FilterMapper2_AddRef(IFilterMapper2 * iface)
 195 {
 196     ICOM_THIS(FilterMapper2Impl, iface);
 197
 198     TRACE("()\n");
 199
 200     return InterlockedIncrement(&This->refCount);
 201 }
 202
 203 static ULONG WINAPI FilterMapper2_Release(IFilterMapper2 * iface)
 204 {
 205     ICOM_THIS(FilterMapper2Impl, iface);
 206
 207     TRACE("()\n");
 208
 209     if (InterlockedDecrement(&This->refCount) == 0)
 210     {
 211         CoTaskMemFree(This);
 212         return 0;
 213     }
 214     return This->refCount;
 215 }
 216
 217 /*** IFilterMapper2 methods ***/
 218
 219 static HRESULT WINAPI FilterMapper2_CreateCategory(
 220     IFilterMapper2 * iface,
 221     REFCLSID clsidCategory,
 222     DWORD dwCategoryMerit,
 223     LPCWSTR szDescription)
 224 {
 225     LPWSTR wClsidAMCat = NULL;
 226     LPWSTR wClsidCategory = NULL;
 227     WCHAR wszKeyName[strlenW(wszClsidSlash) + strlenW(wszSlashInstance) + (CHARS_IN_GUID-1) * 2 + 1];
 228     HKEY hKey = NULL;
 229     HRESULT hr;
 230
 231     TRACE("(%s, %lx, %s)\n", debugstr_guid(clsidCategory), dwCategoryMerit, debugstr_w(szDescription));
 232
 233     hr = StringFromCLSID(&CLSID_ActiveMovieCategories, &wClsidAMCat);
 234
 235     if (SUCCEEDED(hr))
 236     {
 237         hr = StringFromCLSID(clsidCategory, &wClsidCategory);
 238     }
 239
 240     if (SUCCEEDED(hr))
 241     {
 242         strcpyW(wszKeyName, wszClsidSlash);
 243         strcatW(wszKeyName, wClsidAMCat);
 244         strcatW(wszKeyName, wszSlashInstance);
 245         strcatW(wszKeyName, wClsidCategory);
 246
 247         hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_CLASSES_ROOT, wszKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL));
 248     }
 249
 250     if (SUCCEEDED(hr))
 251     {
 252         hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszFriendlyName, 0, REG_SZ, (LPBYTE)szDescription, strlenW(szDescription) + 1));
 253     }
 254
 255     if (SUCCEEDED(hr))
 256     {
 257         hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszClsidName, 0, REG_SZ, (LPBYTE)wClsidCategory, strlenW(wClsidCategory) + 1));
 258     }
 259
 260     if (SUCCEEDED(hr))
 261     {
 262         hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, wszMeritName, 0, REG_DWORD, (LPBYTE)&dwCategoryMerit, sizeof(dwCategoryMerit)));
 263     }
 264
 265     CloseHandle(hKey);
 266
 267     if (wClsidCategory)
 268         CoTaskMemFree(wClsidCategory);
 269     if (wClsidAMCat)
 270         CoTaskMemFree(wClsidAMCat);
 271
 272     return hr;
 273 }
 274
 275 static HRESULT WINAPI FilterMapper2_UnregisterFilter(
 276     IFilterMapper2 * iface,
 277     const CLSID *pclsidCategory,
 278     const OLECHAR *szInstance,
 279     REFCLSID Filter)
 280 {
 281     WCHAR wszKeyName[MAX_PATH];
 282     LPWSTR wClsidCategory = NULL;
 283     LPWSTR wFilter = NULL;
 284     HRESULT hr;
 285
 286     TRACE("(%p, %s, %s)\n", pclsidCategory, debugstr_w(szInstance), debugstr_guid(Filter));
 287
 288     if (!pclsidCategory)
 289         pclsidCategory = &CLSID_LegacyAmFilterCategory;
 290
 291     hr = StringFromCLSID(pclsidCategory, &wClsidCategory);
 292
 293     if (SUCCEEDED(hr))
 294     {
 295         strcpyW(wszKeyName, wszClsidSlash);
 296         strcatW(wszKeyName, wClsidCategory);
 297         strcatW(wszKeyName, wszSlashInstance);
 298         if (szInstance)
 299             strcatW(wszKeyName, szInstance);
 300         else
 301         {
 302             hr = StringFromCLSID(Filter, &wFilter);
 303             if (SUCCEEDED(hr))
 304                 strcatW(wszKeyName, wFilter);
 305         }
 306     }
 307
 308     if (SUCCEEDED(hr))
 309     {
 310         hr = HRESULT_FROM_WIN32(RegDeleteKeyW(HKEY_CLASSES_ROOT, wszKeyName));
 311     }
 312
 313     if (wClsidCategory)
 314         CoTaskMemFree(wClsidCategory);
 315     if (wFilter)
 316         CoTaskMemFree(wFilter);
 317
 318     return hr;
 319 }
 320
 321 static HRESULT FM2_WriteFriendlyName(IPropertyBag * pPropBag, LPCWSTR szName)
 322 {
 323     VARIANT var;
 324
 325     V_VT(&var) = VT_BSTR;
 326     V_UNION(&var, bstrVal) = (BSTR)szName;
 327
 328     return IPropertyBag_Write(pPropBag, wszFriendlyName, &var);
 329 }
 330
 331 static HRESULT FM2_WriteClsid(IPropertyBag * pPropBag, REFCLSID clsid)
 332 {
 333     LPWSTR wszClsid = NULL;
 334     VARIANT var;
 335     HRESULT hr;
 336
 337     hr = StringFromCLSID(clsid, &wszClsid);
 338
 339     if (SUCCEEDED(hr))
 340     {
 341         V_VT(&var) = VT_BSTR;
 342         V_UNION(&var, bstrVal) = wszClsid;
 343         hr = IPropertyBag_Write(pPropBag, wszClsidName, &var);
 344     }
 345     if (wszClsid)
 346         CoTaskMemFree(wszClsid);
 347     return hr;
 348 }
 349
 350 static HRESULT FM2_WriteFilterData(IPropertyBag * pPropBag, const REGFILTER2 * prf2)
 351 {
 352     VARIANT var;
 353     int size = sizeof(struct REG_RF);
 354     int i;
 355     struct Vector mainStore = {NULL, 0, 0};
 356     struct Vector clsidStore = {NULL, 0, 0};
 357     struct REG_RF rrf;
 358     SAFEARRAY * psa;
 359     SAFEARRAYBOUND saBound;
 360     HRESULT hr = S_OK;
 361
 362     rrf.dwVersion = prf2->dwVersion;
 363     rrf.dwMerit = prf2->dwMerit;
 364     rrf.dwPins = prf2->u.s1.cPins2;
 365     rrf.dwUnused = 0;
 366
 367     add_data(&mainStore, (LPBYTE)&rrf, sizeof(rrf));
 368
 369     for (i = 0; i < prf2->u.s1.cPins2; i++)
 370     {
 371         size += sizeof(struct REG_RFP);
 372         if (prf2->u.s1.rgPins2[i].clsPinCategory)
 373             size += sizeof(DWORD);
 374         size += prf2->u.s1.rgPins2[i].nMediaTypes * sizeof(struct REG_TYPE);
 375         size += prf2->u.s1.rgPins2[i].nMediums * sizeof(DWORD);
 376     }
 377
 378     for (i = 0; i < prf2->u.s1.cPins2; i++)
 379     {
 380         struct REG_RFP rrfp;
 381         REGFILTERPINS2 rgPin2 = prf2->u.s1.rgPins2[i];
 382         int j;
 383
 384         rrfp.signature[0] = '0';
 385         rrfp.signature[1] = 'p';
 386         rrfp.signature[2] = 'i';
 387         rrfp.signature[3] = '3';
 388         rrfp.signature[0] += i;
 389         rrfp.dwFlags = rgPin2.dwFlags;
 390         rrfp.dwInstances = rgPin2.cInstances;
 391         rrfp.dwMediaTypes = rgPin2.nMediaTypes;
 392         rrfp.dwMediums = rgPin2.nMediums;
 393         rrfp.bCategory = rgPin2.clsPinCategory ? 1 : 0;
 394
 395         add_data(&mainStore, (LPBYTE)&rrfp, sizeof(rrfp));
 396         if (rrfp.bCategory)
 397         {
 398             DWORD index = find_data(&clsidStore, (LPBYTE)rgPin2.clsPinCategory, sizeof(CLSID));
 399             if (index == -1)
 400                 index = add_data(&clsidStore, (LPBYTE)rgPin2.clsPinCategory, sizeof(CLSID));
 401             index += size;
 402
 403             add_data(&mainStore, (LPBYTE)&index, sizeof(index));
 404         }
 405
 406         for (j = 0; j < rgPin2.nMediaTypes; j++)
 407         {
 408             struct REG_TYPE rt;
 409             rt.signature[0] = '0';
 410             rt.signature[1] = 't';
 411             rt.signature[2] = 'y';
 412             rt.signature[3] = '3';
 413             rt.signature[0] += j;
 414
 415             rt.dwUnused = 0;
 416             rt.dwOffsetMajor = find_data(&clsidStore, (LPBYTE)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
 417             if (rt.dwOffsetMajor == -1)
 418                 rt.dwOffsetMajor = add_data(&clsidStore, (LPBYTE)rgPin2.lpMediaType[j].clsMajorType, sizeof(CLSID));
 419             rt.dwOffsetMajor += size;
 420             rt.dwOffsetMinor = find_data(&clsidStore, (LPBYTE)rgPin2.lpMediaType[j].clsMinorType, sizeof(CLSID));
 421             if (rt.dwOffsetMinor == -1)
 422                 rt.dwOffsetMinor = add_data(&clsidStore, (LPBYTE)rgPin2.lpMediaType[j].clsMinorType, sizeof(CLSID));
 423             rt.dwOffsetMinor += size;
 424
 425             add_data(&mainStore, (LPBYTE)&rt, sizeof(rt));
 426         }
 427
 428         for (j = 0; j < rgPin2.nMediums; j++)
 429         {
 430             DWORD index = find_data(&clsidStore, (LPBYTE)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
 431             if (index == -1)
 432                 index = add_data(&clsidStore, (LPBYTE)(rgPin2.lpMedium + j), sizeof(REGPINMEDIUM));
 433             index += size;
 434
 435             add_data(&mainStore, (LPBYTE)&index, sizeof(index));
 436         }
 437     }
 438
 439     saBound.lLbound = 0;
 440     saBound.cElements = mainStore.current + clsidStore.current;
 441     psa = SafeArrayCreate(VT_UI1, 1, &saBound);
 442     if (!psa)
 443     {
 444         ERR("Couldn't create SAFEARRAY\n");
 445         hr = E_FAIL;
 446     }
 447
 448     if (SUCCEEDED(hr))
 449     {
 450         LPBYTE pbSAData;
 451         hr = SafeArrayAccessData(psa, (LPVOID *)&pbSAData);
 452         if (SUCCEEDED(hr))
 453         {
 454             memcpy(pbSAData, mainStore.pData, mainStore.current);
 455             memcpy(pbSAData + mainStore.current, clsidStore.pData, clsidStore.current);
 456             hr = SafeArrayUnaccessData(psa);
 457         }
 458     }
 459
 460     V_VT(&var) = VT_ARRAY | VT_UI1;
 461     V_UNION(&var, parray) = psa;
 462
 463     if (SUCCEEDED(hr))
 464         hr = IPropertyBag_Write(pPropBag, wszFilterDataName, &var);
 465
 466     if (psa)
 467         SafeArrayDestroy(psa);
 468
 469     delete_vector(&mainStore);
 470     delete_vector(&clsidStore);
 471     return hr;
 472 }
 473
 474 static HRESULT FM2_ReadFilterData(IPropertyBag * pPropBag, REGFILTER2 * prf2)
 475 {
 476     VARIANT var;
 477     HRESULT hr;
 478     LPBYTE pData = NULL;
 479     struct REG_RF * prrf;
 480     LPBYTE pCurrent;
 481     DWORD i;
 482     REGFILTERPINS2 * rgPins2;
 483
 484     VariantInit(&var);
 485     V_VT(&var) = VT_ARRAY | VT_UI1;
 486
 487     hr = IPropertyBag_Read(pPropBag, wszFilterDataName, &var, NULL);
 488
 489     if (SUCCEEDED(hr))
 490         hr = SafeArrayAccessData(V_UNION(&var, parray), (LPVOID*)&pData);
 491
 492     if (SUCCEEDED(hr))
 493     {
 494         prrf = (struct REG_RF *)pData;
 495         pCurrent = pData;
 496
 497         if (prrf->dwVersion != 2)
 498         {
 499             FIXME("Filter registry version %ld not supported\n", prrf->dwVersion);
 500             ZeroMemory(prf2, sizeof(*prf2));
 501             hr = E_FAIL;
 502         }
 503     }
 504
 505     if (SUCCEEDED(hr))
 506     {
 507         TRACE("version = %ld, merit = %lx, #pins = %ld, unused = %lx\n",
 508             prrf->dwVersion, prrf->dwMerit, prrf->dwPins, prrf->dwUnused);
 509
 510         prf2->dwVersion = prrf->dwVersion;
 511         prf2->dwMerit = prrf->dwMerit;
 512         prf2->u.s1.cPins2 = prrf->dwPins;
 513         rgPins2 = CoTaskMemAlloc(prrf->dwPins * sizeof(*rgPins2));
 514         prf2->u.s1.rgPins2 = rgPins2;
 515         pCurrent += sizeof(struct REG_RF);
 516
 517         for (i = 0; i < prrf->dwPins; i++)
 518         {
 519             struct REG_RFP * prrfp = (struct REG_RFP *)pCurrent;
 520             REGPINTYPES * lpMediaType;
 521             REGPINMEDIUM * lpMedium;
 522             UINT j;
 523
 524             /* FIXME: check signature */
 525
 526             TRACE("\tsignature = %s\n", debugstr_an(prrfp->signature, 4));
 527
 528             TRACE("\tpin[%ld]: flags = %lx, instances = %ld, media types = %ld, mediums = %ld\n",
 529                 i, prrfp->dwFlags, prrfp->dwInstances, prrfp->dwMediaTypes, prrfp->dwMediums);
 530
 531             rgPins2[i].dwFlags = prrfp->dwFlags;
 532             rgPins2[i].cInstances = prrfp->dwInstances;
 533             rgPins2[i].nMediaTypes = prrfp->dwMediaTypes;
 534             rgPins2[i].nMediums = prrfp->dwMediums;
 535             pCurrent += sizeof(struct REG_RFP);
 536             if (prrfp->bCategory)
 537             {
 538                 CLSID * clsCat = CoTaskMemAlloc(sizeof(CLSID));
 539                 memcpy(clsCat, pData + *(DWORD*)(pCurrent), sizeof(CLSID));
 540                 pCurrent += sizeof(DWORD);
 541                 rgPins2[i].clsPinCategory = clsCat;
 542             }
 543             else
 544                 rgPins2[i].clsPinCategory = NULL;
 545
 546             if (rgPins2[i].nMediaTypes > 0)
 547                 lpMediaType = CoTaskMemAlloc(rgPins2[i].nMediaTypes * sizeof(*lpMediaType));
 548             else
 549                 lpMediaType = NULL;
 550
 551             rgPins2[i].lpMediaType = lpMediaType;
 552
 553             for (j = 0; j < rgPins2[i].nMediaTypes; j++)
 554             {
 555                 struct REG_TYPE * prt = (struct REG_TYPE *)pCurrent;
 556                 CLSID * clsMajor = CoTaskMemAlloc(sizeof(CLSID));
 557                 CLSID * clsMinor = CoTaskMemAlloc(sizeof(CLSID));
 558
 559                 /* FIXME: check signature */
 560                 TRACE("\t\tsignature = %s\n", debugstr_an(prt->signature, 4));
 561
 562                 memcpy(clsMajor, pData + prt->dwOffsetMajor, sizeof(CLSID));
 563                 memcpy(clsMinor, pData + prt->dwOffsetMinor, sizeof(CLSID));
 564
 565                 lpMediaType[j].clsMajorType = clsMajor;
 566                 lpMediaType[j].clsMinorType = clsMinor;
 567
 568                 pCurrent += sizeof(*prt);
 569             }
 570
 571             if (rgPins2[i].nMediums > 0)
 572                 lpMedium = CoTaskMemAlloc(rgPins2[i].nMediums * sizeof(*lpMedium));
 573             else
 574                 lpMedium = NULL;
 575
 576             rgPins2[i].lpMedium = lpMedium;
 577
 578             for (j = 0; j < rgPins2[i].nMediums; j++)
 579             {
 580                 DWORD dwOffset = *(DWORD *)pCurrent;
 581
 582                 memcpy(lpMedium + j, pData + dwOffset, sizeof(REGPINMEDIUM));
 583
 584                 pCurrent += sizeof(dwOffset);
 585             }
 586         }
 587
 588     }
 589
 590     if (pData)
 591         SafeArrayUnaccessData(V_UNION(&var, parray));
 592
 593     VariantClear(&var);
 594
 595     return hr;
 596 }
 597
 598 static void FM2_DeleteRegFilter(REGFILTER2 * prf2)
 599 {
 600     UINT i;
 601     for (i = 0; i < prf2->u.s1.cPins2; i++)
 602     {
 603         UINT j;
 604         if (prf2->u.s1.rgPins2[i].clsPinCategory)
 605             CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].clsPinCategory);
 606
 607         for (j = 0; j < prf2->u.s1.rgPins2[i].nMediaTypes; j++)
 608         {
 609             CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMajorType);
 610             CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMediaType[j].clsMinorType);
 611         }
 612         CoTaskMemFree((LPVOID)prf2->u.s1.rgPins2[i].lpMedium);
 613     }
 614 }
 615
 616 static HRESULT WINAPI FilterMapper2_RegisterFilter(
 617     IFilterMapper2 * iface,
 618     REFCLSID clsidFilter,
 619     LPCWSTR szName,
 620     IMoniker **ppMoniker,
 621     const CLSID *pclsidCategory,
 622     const OLECHAR *szInstance,
 623     const REGFILTER2 *prf2)
 624 {
 625     IParseDisplayName * pParser = NULL;
 626     IBindCtx * pBindCtx = NULL;
 627     IMoniker * pMoniker = NULL;
 628     IPropertyBag * pPropBag = NULL;
 629     HRESULT hr = S_OK;
 630     LPWSTR pwszParseName = NULL;
 631     LPWSTR pCurrent;
 632     static const WCHAR wszDevice[] = {'@','d','e','v','i','c','e',':','s','w',':',0};
 633     int nameLen;
 634     ULONG ulEaten;
 635     LPWSTR szClsidTemp = NULL;
 636
 637     TRACE("(%s, %s, %p, %s, %s, %p)\n",
 638         debugstr_guid(clsidFilter),
 639         debugstr_w(szName),
 640         ppMoniker,
 641         debugstr_guid(pclsidCategory),
 642         debugstr_w(szInstance),
 643         prf2);
 644
 645     if (ppMoniker)
 646         FIXME("ppMoniker != NULL not supported at the moment\n");
 647
 648     if (prf2->dwVersion != 2)
 649     {
 650         FIXME("dwVersion != 2 not supported at the moment\n");
 651         return E_NOTIMPL;
 652     }
 653
 654     if (!pclsidCategory)
 655         pclsidCategory = &CLSID_ActiveMovieCategories;
 656
 657     /* sizeof... will include null terminator and
 658      * the + 1 is for the separator ('\\'). The -1 is
 659      * because CHARS_IN_GUID includes the null terminator
 660      */
 661     nameLen = sizeof(wszDevice)/sizeof(wszDevice[0]) + CHARS_IN_GUID - 1 + 1;
 662
 663     if (szInstance)
 664         nameLen += strlenW(szInstance);
 665     else
 666         nameLen += CHARS_IN_GUID - 1; /* CHARS_IN_GUID includes null terminator */
 667
 668     pwszParseName = CoTaskMemAlloc(nameLen);
 669     pCurrent = pwszParseName;
 670     if (!pwszParseName)
 671         return E_OUTOFMEMORY;
 672
 673     strcpyW(pwszParseName, wszDevice);
 674     pCurrent += strlenW(wszDevice);
 675
 676     hr = StringFromCLSID(pclsidCategory, &szClsidTemp);
 677     strcpyW(pCurrent, szClsidTemp);
 678     pCurrent += CHARS_IN_GUID - 1;
 679     pCurrent[0] = '\\';
 680
 681     if (SUCCEEDED(hr))
 682     {
 683         if (szInstance)
 684             strcpyW(pCurrent+1, szInstance);
 685         else
 686         {
 687             if (szClsidTemp)
 688             {
 689                 CoTaskMemFree(szClsidTemp);
 690                 szClsidTemp = NULL;
 691             }
 692             hr = StringFromCLSID(clsidFilter, &szClsidTemp);
 693             strcpyW(pCurrent+1, szClsidTemp);
 694         }
 695     }
 696
 697     if (SUCCEEDED(hr))
 698         hr = CoCreateInstance(&CLSID_CDeviceMoniker, NULL, CLSCTX_INPROC, &IID_IParseDisplayName, (LPVOID *)&pParser);
 699
 700     if (SUCCEEDED(hr))
 701         hr = CreateBindCtx(0, &pBindCtx);
 702
 703     if (SUCCEEDED(hr))
 704     {
 705         hr = IParseDisplayName_ParseDisplayName(pParser, pBindCtx, pwszParseName, &ulEaten, &pMoniker);
 706     }
 707
 708     if (pBindCtx)
 709         IBindCtx_Release(pBindCtx); pBindCtx = NULL;
 710
 711     if (pParser)
 712         IParseDisplayName_Release(pParser); pParser = NULL;
 713
 714     if (SUCCEEDED(hr))
 715         hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID)&pPropBag);
 716
 717     if (SUCCEEDED(hr))
 718         hr = FM2_WriteFriendlyName(pPropBag, szName);
 719
 720     if (SUCCEEDED(hr))
 721         hr = FM2_WriteClsid(pPropBag, clsidFilter);
 722
 723     if (SUCCEEDED(hr))
 724         hr = FM2_WriteFilterData(pPropBag, prf2);
 725
 726     if (pMoniker)
 727         IMoniker_Release(pMoniker); pMoniker = NULL;
 728
 729     if (pPropBag)
 730         IPropertyBag_Release(pPropBag); pPropBag = NULL;
 731
 732     if (szClsidTemp)
 733         CoTaskMemFree(szClsidTemp);
 734
 735     TRACE("-- returning %lx\n", hr);
 736
 737     return hr;
 738 }
 739
 740 /* internal helper function */
 741 static BOOL MatchTypes(
 742     BOOL bExactMatch,
 743     DWORD nPinTypes,
 744     const REGPINTYPES * pPinTypes,
 745     DWORD nMatchTypes,
 746     const GUID * pMatchTypes)
 747 {
 748     BOOL bMatch = FALSE;
 749     DWORD j;
 750
 751     if ((nMatchTypes == 0) && (nPinTypes > 0))
 752         bMatch = TRUE;
 753
 754     for (j = 0; j < nPinTypes; j++)
 755     {
 756         DWORD i;
 757         for (i = 0; i < nMatchTypes*2; i+=2)
 758         {
 759             if (((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMajorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMajorType, &pMatchTypes[i])) &&
 760                 ((!bExactMatch && IsEqualGUID(pPinTypes[j].clsMinorType, &GUID_NULL)) || IsEqualGUID(&pMatchTypes[i+1], &GUID_NULL) || IsEqualGUID(pPinTypes[j].clsMinorType, &pMatchTypes[i+1])))
 761             {
 762                 bMatch = TRUE;
 763                 break;
 764             }
 765         }
 766     }
 767     return bMatch;
 768 }
 769
 770 /* internal helper function for qsort of MONIKER_MERIT array */
 771 static int mm_compare(const void * left, const void * right)
 772 {
 773     const struct MONIKER_MERIT * mmLeft = (struct MONIKER_MERIT *)left;
 774     const struct MONIKER_MERIT * mmRight = (struct MONIKER_MERIT *)right;
 775
 776     if (mmLeft->dwMerit == mmRight->dwMerit)
 777         return 0;
 778     if (mmLeft->dwMerit > mmRight->dwMerit)
 779         return -1;
 780     return 1;
 781 }
 782
 783 /* NOTES:
 784  *   Exact match means whether or not to treat GUID_NULL's in filter data as wild cards
 785  *    (GUID_NULL's in input to function automatically treated as wild cards)
 786  *   Input/Output needed means match only on criteria if TRUE (with zero input types
 787  *    meaning match any input/output pin as long as one exists), otherwise match any
 788  *    filter that meets the rest of the requirements.
 789  */
 790 static HRESULT WINAPI FilterMapper2_EnumMatchingFilters(
 791     IFilterMapper2 * iface,
 792     IEnumMoniker **ppEnum,
 793     DWORD dwFlags,
 794     BOOL bExactMatch,
 795     DWORD dwMerit,
 796     BOOL bInputNeeded,
 797     DWORD cInputTypes,
 798     const GUID *pInputTypes,
 799     const REGPINMEDIUM *pMedIn,
 800     const CLSID *pPinCategoryIn,
 801     BOOL bRender,
 802     BOOL bOutputNeeded,
 803     DWORD cOutputTypes,
 804     const GUID *pOutputTypes,
 805     const REGPINMEDIUM *pMedOut,
 806     const CLSID *pPinCategoryOut)
 807 {
 808     ICreateDevEnum * pCreateDevEnum;
 809     IMoniker * pMonikerCat;
 810     IEnumMoniker * pEnumCat;
 811     HRESULT hr;
 812     struct Vector monikers = {NULL, 0, 0};
 813
 814     TRACE("(%p, %lx, %s, %lx, %s, %ld, %p, %p, %p, %s, %s, %p, %p, %p)\n",
 815         ppEnum,
 816         dwFlags,
 817         bExactMatch ? "true" : "false",
 818         dwMerit,
 819         bInputNeeded ? "true" : "false",
 820         cInputTypes,
 821         pInputTypes,
 822         pMedIn,
 823         pPinCategoryIn,
 824         bRender ? "true" : "false",
 825         bOutputNeeded ? "true" : "false",
 826         pOutputTypes,
 827         pMedOut,
 828         pPinCategoryOut);
 829
 830     if (dwFlags != 0)
 831     {
 832         FIXME("dwFlags = %lx not implemented\n", dwFlags);
 833     }
 834
 835     *ppEnum = NULL;
 836
 837     hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC, &IID_ICreateDevEnum, (LPVOID*)&pCreateDevEnum);
 838
 839     if (SUCCEEDED(hr))
 840         hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEnumCat, 0);
 841
 842     while (IEnumMoniker_Next(pEnumCat, 1, &pMonikerCat, NULL) == S_OK)
 843     {
 844         IPropertyBag * pPropBagCat = NULL;
 845         VARIANT var;
 846         HRESULT hrSub; /* this is so that one buggy filter
 847                           doesn't make the whole lot fail */
 848
 849         VariantInit(&var);
 850
 851         hrSub = IMoniker_BindToStorage(pMonikerCat, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
 852
 853         if (SUCCEEDED(hrSub))
 854             hrSub = IPropertyBag_Read(pPropBagCat, wszMeritName, &var, NULL);
 855
 856         if (SUCCEEDED(hrSub) && (V_UNION(&var, ulVal) >= dwMerit))
 857         {
 858             CLSID clsidCat;
 859             IEnumMoniker * pEnum;
 860             IMoniker * pMoniker;
 861
 862             VariantClear(&var);
 863
 864             if (TRACE_ON(quartz))
 865             {
 866                 VARIANT temp;
 867                 V_VT(&temp) = VT_EMPTY;
 868                 IPropertyBag_Read(pPropBagCat, wszFriendlyName, &temp, NULL);
 869                 TRACE("Considering category %s\n", debugstr_w(V_UNION(&temp, bstrVal)));
 870                 VariantClear(&temp);
 871             }
 872
 873             hrSub = IPropertyBag_Read(pPropBagCat, wszClsidName, &var, NULL);
 874
 875             if (SUCCEEDED(hrSub))
 876                 hrSub = CLSIDFromString(V_UNION(&var, bstrVal), &clsidCat);
 877
 878             if (SUCCEEDED(hrSub))
 879                 hrSub = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0);
 880
 881             if (SUCCEEDED(hrSub))
 882             {
 883                 while (IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL) == S_OK)
 884                 {
 885                     IPropertyBag * pPropBag = NULL;
 886                     REGFILTER2 rf2;
 887                     DWORD i;
 888                     BOOL bInputMatch = !bInputNeeded;
 889                     BOOL bOutputMatch = !bOutputNeeded;
 890
 891                     ZeroMemory(&rf2, sizeof(rf2));
 892
 893                     hrSub = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBag);
 894
 895                     if (SUCCEEDED(hrSub))
 896                         hrSub = FM2_ReadFilterData(pPropBag, &rf2);
 897
 898                     /* Logic used for bInputMatch expression:
 899                      * There exists some pin such that bInputNeeded implies (pin is an input and
 900                      * (bRender implies pin has render flag) and major/minor types members of
 901                      * pInputTypes )
 902                      * bOutputMatch is similar, but without the "bRender implies ..." part
 903                      * and substituting variables names containing input for output
 904                      */
 905
 906                     /* determine whether filter meets requirements */
 907                     if (SUCCEEDED(hrSub) && (rf2.dwMerit >= dwMerit))
 908                     {
 909                         for (i = 0; (i < rf2.u.s1.cPins2) && (!bInputMatch || !bOutputMatch); i++)
 910                         {
 911                             const REGFILTERPINS2 * rfp2 = rf2.u.s1.rgPins2 + i;
 912
 913                             bInputMatch = bInputMatch || (!(rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
 914                                 (!bRender || (rfp2->dwFlags & REG_PINFLAG_B_RENDERER)) &&
 915                                 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cInputTypes, pInputTypes));
 916                             bOutputMatch = bOutputMatch || ((rfp2->dwFlags & REG_PINFLAG_B_OUTPUT) &&
 917                                 MatchTypes(bExactMatch, rfp2->nMediaTypes, rfp2->lpMediaType, cOutputTypes, pOutputTypes));
 918                         }
 919
 920                         if (bInputMatch && bOutputMatch)
 921                         {
 922                             struct MONIKER_MERIT mm = {pMoniker, rf2.dwMerit};
 923                             IMoniker_AddRef(pMoniker);
 924                             add_data(&monikers, (LPBYTE)&mm, sizeof(mm));
 925                         }
 926                     }
 927
 928                     FM2_DeleteRegFilter(&rf2);
 929                     if (pPropBag)
 930                         IPropertyBag_Release(pPropBag);
 931                     IMoniker_Release(pMoniker);
 932                 }
 933                 IEnumMoniker_Release(pEnum);
 934             }
 935         }
 936
 937         VariantClear(&var);
 938         if (pPropBagCat)
 939             IPropertyBag_Release(pPropBagCat);
 940         IMoniker_Release(pMonikerCat);
 941     }
 942
 943
 944     if (SUCCEEDED(hr))
 945     {
 946         IMoniker ** ppMoniker;
 947         int i;
 948         ULONG nMonikerCount = monikers.current / sizeof(struct MONIKER_MERIT);
 949
 950         /* sort the monikers in descending merit order */
 951         qsort(monikers.pData, nMonikerCount,
 952               sizeof(struct MONIKER_MERIT),
 953               mm_compare);
 954
 955         /* construct an IEnumMoniker interface */
 956         ppMoniker = CoTaskMemAlloc(nMonikerCount * sizeof(IMoniker *));
 957         for (i = 0; i < nMonikerCount; i++)
 958         {
 959             /* no need to AddRef here as already AddRef'd above */
 960             ppMoniker[i] = ((struct MONIKER_MERIT *)monikers.pData)[i].pMoniker;
 961         }
 962         hr = EnumMonikerImpl_Create(ppMoniker, nMonikerCount, ppEnum);
 963         CoTaskMemFree(ppMoniker);
 964     }
 965
 966     delete_vector(&monikers);
 967     IEnumMoniker_Release(pEnumCat);
 968     ICreateDevEnum_Release(pCreateDevEnum);
 969
 970     return hr;
 971 }
 972
 973 static ICOM_VTABLE(IFilterMapper2) fm2vtbl =
 974 {
 975     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 976
 977     FilterMapper2_QueryInterface,
 978     FilterMapper2_AddRef,
 979     FilterMapper2_Release,
 980
 981     FilterMapper2_CreateCategory,
 982     FilterMapper2_UnregisterFilter,
 983     FilterMapper2_RegisterFilter,
 984     FilterMapper2_EnumMatchingFilters
 985 };
 986
 987 /*** IUnknown methods ***/
 988
 989 static HRESULT WINAPI FilterMapper_QueryInterface(IFilterMapper * iface, REFIID riid, LPVOID *ppv)
 990 {
 991     ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
 992
 993     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 994
 995     return FilterMapper2_QueryInterface((IFilterMapper2*)&This->lpVtbl, riid, ppv);
 996 }
 997
 998 static ULONG WINAPI FilterMapper_AddRef(IFilterMapper * iface)
 999 {
1000     ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1001
1002     return FilterMapper2_AddRef((IFilterMapper2*)This);
1003 }
1004
1005 static ULONG WINAPI FilterMapper_Release(IFilterMapper * iface)
1006 {
1007     ICOM_THIS_From_IFilterMapper(FilterMapper2Impl, iface);
1008
1009     return FilterMapper2_Release((IFilterMapper2*)This);
1010 }
1011
1012 /*** IFilterMapper methods ***/
1013
1014 static HRESULT WINAPI FilterMapper_EnumMatchingFilters(
1015     IFilterMapper * iface,
1016     IEnumRegFilters **ppEnum,
1017     DWORD dwMerit,
1018     BOOL bInputNeeded,
1019     CLSID clsInMaj,
1020     CLSID clsInSub,
1021     BOOL bRender,
1022     BOOL bOutputNeeded,
1023     CLSID clsOutMaj,
1024     CLSID clsOutSub)
1025 {
1026     FIXME("stub\n");
1027     return E_NOTIMPL;
1028 }
1029
1030
1031 static HRESULT WINAPI FilterMapper_RegisterFilter(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, DWORD dwMerit)
1032 {
1033     FIXME("stub\n");
1034     return E_NOTIMPL;
1035 }
1036
1037 static HRESULT WINAPI FilterMapper_RegisterFilterInstance(IFilterMapper * iface, CLSID clsid, LPCWSTR szName, CLSID *MRId)
1038 {
1039     FIXME("stub\n");
1040     return E_NOTIMPL;
1041 }
1042
1043 static HRESULT WINAPI FilterMapper_RegisterPin(
1044     IFilterMapper * iface,
1045     CLSID Filter,
1046     LPCWSTR szName,
1047     BOOL bRendered,
1048     BOOL bOutput,
1049     BOOL bZero,
1050     BOOL bMany,
1051     CLSID ConnectsToFilter,
1052     LPCWSTR ConnectsToPin)
1053 {
1054     FIXME("stub\n");
1055     return E_NOTIMPL;
1056 }
1057
1058
1059 static HRESULT WINAPI FilterMapper_RegisterPinType(
1060     IFilterMapper * iface,
1061     CLSID clsFilter,
1062     LPCWSTR szName,
1063     CLSID clsMajorType,
1064     CLSID clsSubType)
1065 {
1066     FIXME("stub\n");
1067     return E_NOTIMPL;
1068 }
1069
1070 static HRESULT WINAPI FilterMapper_UnregisterFilter(IFilterMapper * iface, CLSID Filter)
1071 {
1072     FIXME("stub\n");
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI FilterMapper_UnregisterFilterInstance(IFilterMapper * iface, CLSID MRId)
1077 {
1078     FIXME("stub\n");
1079     return E_NOTIMPL;
1080 }
1081
1082 static HRESULT WINAPI FilterMapper_UnregisterPin(IFilterMapper * iface, CLSID Filter, LPCWSTR Name)
1083 {
1084     FIXME("stub\n");
1085     return E_NOTIMPL;
1086 }
1087
1088 static ICOM_VTABLE(IFilterMapper) fmvtbl =
1089 {
1090     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1091
1092     FilterMapper_QueryInterface,
1093     FilterMapper_AddRef,
1094     FilterMapper_Release,
1095
1096     FilterMapper_RegisterFilter,
1097     FilterMapper_RegisterFilterInstance,
1098     FilterMapper_RegisterPin,
1099     FilterMapper_RegisterPinType,
1100     FilterMapper_UnregisterFilter,
1101     FilterMapper_UnregisterFilterInstance,
1102     FilterMapper_UnregisterPin,
1103     FilterMapper_EnumMatchingFilters
1104 };