Add support for WM_WINDOWPOSCHANGED to save new origin of window.
[wine] / dlls / quartz / fmap.c
1 /*
2  * Implementation of CLSID_FilterMapper and CLSID_FilterMapper2.
3  *
4  * FIXME - stub.
5  *
6  * Copyright (C) Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "winerror.h"
31 #include "strmif.h"
32 #include "uuids.h"
33
34 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
36
37 #include "quartz_private.h"
38 #include "fmap.h"
39 #include "regsvr.h"
40 #include "devenum.h"
41 #include "complist.h"
42 #include "enumunk.h"
43
44 /***************************************************************************/
45
46 typedef struct QUARTZ_REGFILTERDATA
47 {
48         DWORD   dwVersion; /* =2 */
49         DWORD   dwMerit;
50         DWORD   cPins; /* count of pins */
51         DWORD   dwZero; /* padding??? */
52 } QUARTZ_REGFILTERDATA;
53
54 typedef struct QUARTZ_REGPINDATA
55 {
56         CHAR    id[4]; /* '0pi3', '1pi3', ... */
57         DWORD   dwFlags; /* flags */
58         UINT    cInstances; /* FIXME - is this correct? */
59         UINT    nMediaTypes; /* count of media types('0ty3') */
60         UINT    nMediums; /* FIXME - is this correct? */
61         UINT    nOfsClsPinCategory; /* FIXME - is this correct? */
62 } QUARTZ_REGPINDATA;
63
64 typedef struct QUARTZ_REGMEDIATYPE
65 {
66         CHAR    id[4]; /* '0ty3', '1ty3', ... */
67         DWORD   nZero; /* padding??? */
68         UINT    nOfsMajorType;
69         UINT    nOfsMinorType;
70 } QUARTZ_REGMEDIATYPE;
71
72
73
74 /***************************************************************************/
75
76 static
77 REGFILTER2* QUARTZ_RegFilterV2FromFilterData(
78         const BYTE* pData, DWORD cbData )
79 {
80         REGFILTER2*     pFilter;
81         REGFILTERPINS2* pPin;
82         REGPINTYPES*    pTypes;
83         BYTE* pDst;
84         const QUARTZ_REGFILTERDATA*     pRegFilter;
85         const QUARTZ_REGPINDATA*        pRegPin;
86         const QUARTZ_REGMEDIATYPE*      pRegMediaType;
87         DWORD   cPins;
88         DWORD   cbBufSize;
89         UINT    n;
90
91         TRACE("(%p,%lu)\n",pData,cbData);
92
93         if ( cbData < sizeof(QUARTZ_REGFILTERDATA) )
94                 return NULL;
95
96         pRegFilter = (QUARTZ_REGFILTERDATA*)pData;
97
98         if ( pRegFilter->dwVersion != 2 ) return NULL; /* FIXME */
99
100         if ( cbData < (sizeof(QUARTZ_REGFILTERDATA)+sizeof(QUARTZ_REGPINDATA)*pRegFilter->cPins) )
101                 return NULL;
102
103         cbBufSize = sizeof(REGFILTER2);
104         cPins = pRegFilter->cPins;
105         pRegPin = (const QUARTZ_REGPINDATA*)(pRegFilter+1);
106         while ( cPins-- > 0 )
107         {
108                 if ( pRegPin->nMediums != 0 ||
109                          pRegPin->nOfsClsPinCategory != 0 )
110                         return NULL; /* FIXME */
111
112                 cbBufSize += sizeof(REGFILTERPINS2) +
113                         pRegPin->nMediaTypes * (sizeof(REGPINTYPES) + sizeof(GUID)*2) +
114                         pRegPin->nMediums * sizeof(REGPINMEDIUM) +
115                         sizeof(CLSID);
116                 pRegPin = (const QUARTZ_REGPINDATA*)( ((const BYTE*)pRegPin) +
117                         sizeof(QUARTZ_REGPINDATA) +
118                         sizeof(QUARTZ_REGMEDIATYPE) * pRegPin->nMediaTypes );
119         }
120
121         pFilter = (REGFILTER2*)QUARTZ_AllocMem( cbBufSize );
122         if ( pFilter == NULL ) return NULL;
123         ZeroMemory( pFilter, cbBufSize );
124         pPin = (REGFILTERPINS2*)(pFilter+1);
125         pDst = (BYTE*)(pPin + pRegFilter->cPins);
126
127         pFilter->dwVersion = 2;
128         pFilter->dwMerit = pRegFilter->dwMerit;
129         pFilter->u.s2.cPins2 = pRegFilter->cPins;
130         pFilter->u.s2.rgPins2 = pPin;
131
132         cPins = pRegFilter->cPins;
133         TRACE("cPins = %lu\n",cPins);
134
135         pRegPin = (const QUARTZ_REGPINDATA*)(pRegFilter+1);
136         while ( cPins-- > 0 )
137         {
138                 pPin->dwFlags = pRegPin->dwFlags;
139                 pPin->cInstances = pRegPin->cInstances;
140                 pPin->nMediaTypes = pRegPin->nMediaTypes;
141                 pPin->lpMediaType = NULL;
142                 pPin->nMediums = pRegPin->nMediums;
143                 pPin->lpMedium = NULL;
144                 pPin->clsPinCategory = NULL;
145
146                 pTypes = (REGPINTYPES*)pDst;
147                 pPin->lpMediaType = pTypes;
148                 pDst += sizeof(REGPINTYPES) * pRegPin->nMediaTypes;
149
150                 pRegPin = (const QUARTZ_REGPINDATA*)( ((const BYTE*)pRegPin) +
151                         sizeof(QUARTZ_REGPINDATA) );
152
153                 for ( n = 0; n < pPin->nMediaTypes; n++ )
154                 {
155                         pRegMediaType = ((const QUARTZ_REGMEDIATYPE*)pRegPin);
156                         TRACE("ofsMajor = %u, ofsMinor = %u\n", pRegMediaType->nOfsMajorType, pRegMediaType->nOfsMinorType);
157                         memcpy( pDst, pData+pRegMediaType->nOfsMajorType, sizeof(GUID) );
158                         pTypes->clsMajorType = (const GUID*)pDst; pDst += sizeof(GUID);
159                         memcpy( pDst, pData+pRegMediaType->nOfsMinorType, sizeof(GUID) );
160                         pTypes->clsMinorType = (const GUID*)pDst; pDst += sizeof(GUID);
161
162                         pRegPin = (const QUARTZ_REGPINDATA*)( ((const BYTE*)pRegPin) +
163                                 sizeof(QUARTZ_REGMEDIATYPE) );
164                         pTypes ++;
165                 }
166
167                 /* FIXME - pPin->lpMedium */
168                 /* FIXME - pPin->clsPinCategory */
169
170                 pPin ++;
171         }
172
173         return pFilter;
174 }
175
176 static
177 BYTE* QUARTZ_RegFilterV2ToFilterData(
178         const REGFILTER2* pFilter, DWORD* pcbData )
179 {
180         DWORD   cbData;
181         DWORD   cbPinData;
182         DWORD   cPins;
183         const REGFILTERPINS2*   pPin;
184         const REGPINTYPES*      pTypes;
185         BYTE*   pRet = NULL;
186         BYTE*   pDst;
187         QUARTZ_REGFILTERDATA*   pRegFilter;
188         QUARTZ_REGPINDATA*      pRegPin;
189         QUARTZ_REGMEDIATYPE*    pRegMediaType;
190         UINT    n;
191
192         if ( pFilter->dwVersion != 2 ) return NULL; /* FIXME */
193
194         cbData = sizeof(QUARTZ_REGFILTERDATA);
195         cPins = pFilter->u.s2.cPins2;
196         pPin = pFilter->u.s2.rgPins2;
197         if ( cPins > 10 ) return NULL; /* FIXME */
198
199         cbPinData = 0;
200         while ( cPins-- > 0 )
201         {
202                 if ( pPin->cInstances != 0 ||
203                          pPin->nMediaTypes > 10 ||
204                          pPin->nMediums != 0 ||
205                          pPin->clsPinCategory != 0 )
206                 {
207                         FIXME( "not implemented.\n" );
208                         return NULL; /* FIXME */
209                 }
210
211                 cbPinData += sizeof(QUARTZ_REGPINDATA) +
212                         pPin->nMediaTypes * sizeof(QUARTZ_REGMEDIATYPE);
213                 cbData += pPin->nMediaTypes * (sizeof(GUID)*2);
214                 pPin ++;
215         }
216         cbData += cbPinData;
217         TRACE("cbData %lu, cbPinData %lu\n",cbData,cbPinData);
218
219         pRet = (BYTE*)QUARTZ_AllocMem( cbData );
220         if ( pRet == NULL ) return NULL;
221         ZeroMemory( pRet, cbData );
222         pDst = pRet;
223
224         pRegFilter = (QUARTZ_REGFILTERDATA*)pDst;
225         pDst += sizeof(QUARTZ_REGFILTERDATA);
226
227         pRegFilter->dwVersion = 2;
228         pRegFilter->dwMerit = pFilter->dwMerit;
229         pRegFilter->cPins = pFilter->u.s2.cPins2;
230
231         pRegPin = (QUARTZ_REGPINDATA*)pDst;
232         pDst += cbPinData;
233
234         pPin = pFilter->u.s2.rgPins2;
235         for ( cPins = 0; cPins < pFilter->u.s2.cPins2; cPins++ )
236         {
237                 pRegPin->id[0] = '0'+cPins;
238                 pRegPin->id[1] = 'p';
239                 pRegPin->id[2] = 'i';
240                 pRegPin->id[3] = '3';
241                 pRegPin->dwFlags = pPin->dwFlags; /* flags */
242                 pRegPin->cInstances = pPin->cInstances;
243                 pRegPin->nMediaTypes = pPin->nMediaTypes;
244                 pRegPin->nMediums = pPin->nMediums;
245                 pRegPin->nOfsClsPinCategory = 0; /* FIXME */
246
247                 pTypes = pPin->lpMediaType;
248                 pRegPin = (QUARTZ_REGPINDATA*)( ((const BYTE*)pRegPin) +
249                         sizeof(QUARTZ_REGPINDATA) );
250                 for ( n = 0; n < pPin->nMediaTypes; n++ )
251                 {
252                         pRegMediaType = ((QUARTZ_REGMEDIATYPE*)pRegPin);
253
254                         pRegMediaType->id[0] = '0'+n;
255                         pRegMediaType->id[1] = 't';
256                         pRegMediaType->id[2] = 'y';
257                         pRegMediaType->id[3] = '3';
258
259                         /* FIXME - CLSID should be shared. */
260                         pRegMediaType->nOfsMajorType = pDst - pRet;
261                         memcpy( pDst, pTypes->clsMajorType, sizeof(GUID) );
262                         pDst += sizeof(GUID);
263                         pRegMediaType->nOfsMinorType = pDst - pRet;
264                         memcpy( pDst, pTypes->clsMinorType, sizeof(GUID) );
265                         pDst += sizeof(GUID);
266
267                         pRegPin = (QUARTZ_REGPINDATA*)( ((const BYTE*)pRegPin) +
268                                 sizeof(QUARTZ_REGMEDIATYPE) );
269                         pTypes ++;
270                 }
271                 pPin ++;
272         }
273
274         *pcbData = pDst - pRet;
275         TRACE("cbData %lu/%lu\n",*pcbData,cbData);
276
277         return pRet;
278 }
279
280 static
281 REGFILTER2* QUARTZ_RegFilterV1ToV2( const REGFILTER2* prfV1 )
282 {
283         REGFILTER2*     prfV2;
284         const REGFILTERPINS*    pPinV1;
285         REGFILTERPINS2* pPinV2;
286         DWORD   cPins;
287
288         if ( prfV1->dwVersion != 1 ) return NULL;
289
290         prfV2 = (REGFILTER2*)QUARTZ_AllocMem(
291                 sizeof(REGFILTER2) + sizeof(REGFILTERPINS2) * prfV1->u.s1.cPins );
292         if ( prfV2 == NULL ) return NULL;
293         ZeroMemory( prfV2, sizeof(REGFILTER2) + sizeof(REGFILTERPINS2) * prfV1->u.s1.cPins );
294         pPinV1 = prfV1->u.s1.rgPins;
295         pPinV2 = (REGFILTERPINS2*)(prfV2+1);
296         prfV2->dwVersion = 2;
297         prfV2->dwMerit = prfV1->dwMerit;
298         prfV2->u.s2.cPins2 = prfV1->u.s1.cPins;
299         prfV2->u.s2.rgPins2 = pPinV2;
300
301         cPins = prfV1->u.s1.cPins;
302         while ( cPins-- > 0 )
303         {
304                 pPinV2->dwFlags = 0;
305                 pPinV2->cInstances = 0;
306                 pPinV2->nMediaTypes = pPinV1->nMediaTypes;
307                 pPinV2->lpMediaType = pPinV1->lpMediaType;
308                 pPinV2->nMediums = 0;
309                 pPinV2->lpMedium = NULL;
310                 pPinV2->clsPinCategory = NULL;
311
312                 if ( pPinV1->bRendered )
313                         pPinV2->dwFlags |= REG_PINFLAG_B_RENDERER;
314                 if ( pPinV1->bOutput )
315                         pPinV2->dwFlags |= REG_PINFLAG_B_OUTPUT;
316                 if ( pPinV1->bZero )
317                         pPinV2->dwFlags |= REG_PINFLAG_B_ZERO;
318                 if ( pPinV1->bMany )
319                         pPinV2->dwFlags |= REG_PINFLAG_B_MANY;
320
321                 pPinV1 ++;
322                 pPinV2 ++;
323         }
324
325         return prfV2;
326 }
327
328 static
329 BYTE* QUARTZ_RegFilterToFilterData(
330         const REGFILTER2* pFilter, DWORD* pcbData )
331 {
332         REGFILTER2*     prfV2;
333         BYTE*   pRet = NULL;
334
335         *pcbData = 0;
336         switch ( pFilter->dwVersion )
337         {
338         case 1:
339                 prfV2 = QUARTZ_RegFilterV1ToV2( pFilter );
340                 if ( prfV2 != NULL )
341                 {
342                         pRet = QUARTZ_RegFilterV2ToFilterData( prfV2, pcbData );
343                         QUARTZ_FreeMem( prfV2 );
344                 }
345                 break;
346         case 2:
347                 pRet = QUARTZ_RegFilterV2ToFilterData( pFilter, pcbData );
348                 break;
349         default:
350                 FIXME( "unknown REGFILTER2 version - %08lu\n", pFilter->dwVersion );
351                 break;
352         }
353
354         return pRet;
355 }
356
357 /***************************************************************************/
358
359 static
360 BOOL QUARTZ_CheckPinType( BOOL bExactMatch, const REGFILTERPINS2* pPin, DWORD cTypes, const GUID* pTypes, const REGPINMEDIUM* pMedium, const CLSID* pCategory, BOOL bRender )
361 {
362         DWORD   n1, n2;
363         BOOL    bMatch;
364
365         if ( cTypes > 0 && pTypes != NULL )
366         {
367                 bMatch = FALSE;
368                 for ( n1 = 0; n1 < pPin->nMediaTypes; n1++ )
369                 {
370                         for ( n2 = 0; n2 < cTypes; n2++ )
371                         {
372                                 if ( IsEqualGUID(pPin->lpMediaType[n1].clsMajorType,&GUID_NULL) || IsEqualGUID(pPin->lpMediaType[n1].clsMajorType, &pTypes[n2*2+0]) || (!bExactMatch && IsEqualGUID(pPin->lpMediaType[n1].clsMajorType,&GUID_NULL)) )
373                                 {
374                                         if ( IsEqualGUID(pPin->lpMediaType[n1].clsMinorType,&GUID_NULL) || IsEqualGUID(pPin->lpMediaType[n1].clsMinorType, &pTypes[n2*2+1]) || (!bExactMatch && IsEqualGUID(pPin->lpMediaType[n1].clsMinorType,&GUID_NULL)) )
375                                         {
376                                                 bMatch = TRUE;
377                                                 break;
378                                         }
379                                 }
380                         }
381                 }
382                 if ( !bMatch )
383                         return FALSE;
384         }
385
386         if ( pMedium != NULL )
387         {
388                 bMatch = FALSE;
389                 for ( n1 = 0; n1 < pPin->nMediums; n1++ )
390                 {
391                         if ( IsEqualGUID( &pPin->lpMedium[n1].clsMedium, &pMedium->clsMedium ) && pPin->lpMedium[n1].dw1 == pMedium->dw1 && pPin->lpMedium[n1].dw2 == pMedium->dw2 )
392                         {
393                                 bMatch = TRUE;
394                                 break;
395                         }
396                 }
397                 if ( !bMatch )
398                         return FALSE;
399         }
400
401         if ( pCategory != NULL )
402         {
403                 if ( pPin->clsPinCategory == NULL )
404                         return FALSE;
405                 if ( (!bExactMatch && IsEqualGUID(pCategory,&GUID_NULL)) || IsEqualGUID(pCategory,pPin->clsPinCategory) )
406                         return TRUE;
407                 return FALSE;
408         }
409
410         if ( bRender && (!(pPin->dwFlags & REG_PINFLAG_B_RENDERER)) )
411                 return FALSE;
412
413         return TRUE;
414 }
415
416
417
418
419 /***************************************************************************
420  *
421  *      new/delete for CLSID_FilterMapper
422  *
423  */
424
425 /* can I use offsetof safely? - FIXME? */
426 static QUARTZ_IFEntry FMapIFEntries[] =
427 {
428   { &IID_IFilterMapper, offsetof(CFilterMapper,fmap)-offsetof(CFilterMapper,unk) },
429 };
430
431
432 static void QUARTZ_DestroyFilterMapper(IUnknown* punk)
433 {
434         CFilterMapper_THIS(punk,unk);
435
436         CFilterMapper_UninitIFilterMapper( This );
437 }
438
439 HRESULT QUARTZ_CreateFilterMapper(IUnknown* punkOuter,void** ppobj)
440 {
441         CFilterMapper*  pfm;
442         HRESULT hr;
443
444         TRACE("(%p,%p)\n",punkOuter,ppobj);
445
446         pfm = (CFilterMapper*)QUARTZ_AllocObj( sizeof(CFilterMapper) );
447         if ( pfm == NULL )
448                 return E_OUTOFMEMORY;
449
450         QUARTZ_IUnkInit( &pfm->unk, punkOuter );
451         hr = CFilterMapper_InitIFilterMapper( pfm );
452         if ( FAILED(hr) )
453         {
454                 QUARTZ_FreeObj( pfm );
455                 return hr;
456         }
457
458         pfm->unk.pEntries = FMapIFEntries;
459         pfm->unk.dwEntries = sizeof(FMapIFEntries)/sizeof(FMapIFEntries[0]);
460         pfm->unk.pOnFinalRelease = QUARTZ_DestroyFilterMapper;
461
462         *ppobj = (void*)(&pfm->unk);
463
464         return S_OK;
465 }
466
467 /***************************************************************************
468  *
469  *      CLSID_FilterMapper::IFilterMapper
470  *
471  */
472
473 static HRESULT WINAPI
474 IFilterMapper_fnQueryInterface(IFilterMapper* iface,REFIID riid,void** ppobj)
475 {
476         CFilterMapper_THIS(iface,fmap);
477
478         TRACE("(%p)->()\n",This);
479
480         return IUnknown_QueryInterface(This->unk.punkControl,riid,ppobj);
481 }
482
483 static ULONG WINAPI
484 IFilterMapper_fnAddRef(IFilterMapper* iface)
485 {
486         CFilterMapper_THIS(iface,fmap);
487
488         TRACE("(%p)->()\n",This);
489
490         return IUnknown_AddRef(This->unk.punkControl);
491 }
492
493 static ULONG WINAPI
494 IFilterMapper_fnRelease(IFilterMapper* iface)
495 {
496         CFilterMapper_THIS(iface,fmap);
497
498         TRACE("(%p)->()\n",This);
499
500         return IUnknown_Release(This->unk.punkControl);
501 }
502
503
504 static HRESULT WINAPI
505 IFilterMapper_fnRegisterFilter(IFilterMapper* iface,CLSID clsid,LPCWSTR lpwszName,DWORD dwMerit)
506 {
507         CFilterMapper_THIS(iface,fmap);
508
509         FIXME("(%p)->(%s,%s,%08lx)\n",This,
510                 debugstr_guid(&clsid),debugstr_w(lpwszName),dwMerit);
511
512         /* FIXME */
513         /* FIXME - handle dwMerit! */
514         return QUARTZ_RegisterAMovieFilter(
515                 &CLSID_LegacyAmFilterCategory,
516                 &clsid,
517                 NULL, 0,
518                 lpwszName, NULL, TRUE );
519 }
520
521 static HRESULT WINAPI
522 IFilterMapper_fnRegisterFilterInstance(IFilterMapper* iface,CLSID clsid,LPCWSTR lpwszName,CLSID* pclsidMedia)
523 {
524         CFilterMapper_THIS(iface,fmap);
525         HRESULT hr;
526
527         FIXME("(%p)->()\n",This);
528
529         if ( pclsidMedia == NULL )
530                 return E_POINTER;
531         hr = CoCreateGuid(pclsidMedia);
532         if ( FAILED(hr) )
533                 return hr;
534
535         /* FIXME */
536         /* this doesn't work. */
537         /* return IFilterMapper_RegisterFilter(iface,
538                 *pclsidMedia,lpwszName,0x60000000); */
539
540         return E_NOTIMPL;
541 }
542
543 static HRESULT WINAPI
544 IFilterMapper_fnRegisterPin(IFilterMapper* iface,CLSID clsidFilter,LPCWSTR lpwszName,BOOL bRendered,BOOL bOutput,BOOL bZero,BOOL bMany,CLSID clsidReserved,LPCWSTR lpwszReserved)
545 {
546         CFilterMapper_THIS(iface,fmap);
547
548         FIXME("(%p)->() stub!\n",This);
549
550         return E_NOTIMPL;
551 }
552
553 static HRESULT WINAPI
554 IFilterMapper_fnRegisterPinType(IFilterMapper* iface,CLSID clsidFilter,LPCWSTR lpwszName,CLSID clsidMajorType,CLSID clsidSubType)
555 {
556         CFilterMapper_THIS(iface,fmap);
557
558         FIXME("(%p)->() stub!\n",This);
559
560         return E_NOTIMPL;
561 }
562
563 static HRESULT WINAPI
564 IFilterMapper_fnUnregisterFilter(IFilterMapper* iface,CLSID clsidFilter)
565 {
566         CFilterMapper_THIS(iface,fmap);
567
568         FIXME("(%p)->(%s)\n",This,debugstr_guid(&clsidFilter));
569
570         /* FIXME */
571         return QUARTZ_RegisterAMovieFilter(
572                 &CLSID_LegacyAmFilterCategory,
573                 &clsidFilter,
574                 NULL, 0, NULL, NULL, FALSE );
575 }
576
577 static HRESULT WINAPI
578 IFilterMapper_fnUnregisterFilterInstance(IFilterMapper* iface,CLSID clsidMedia)
579 {
580         CFilterMapper_THIS(iface,fmap);
581
582         FIXME("(%p)->(%s)\n",This,debugstr_guid(&clsidMedia));
583
584         /* FIXME */
585         /* this doesn't work. */
586         /* return IFilterMapper_UnregisterFilter(iface,clsidMedia); */
587
588         return E_NOTIMPL;
589 }
590
591 static HRESULT WINAPI
592 IFilterMapper_fnUnregisterPin(IFilterMapper* iface,CLSID clsidPin,LPCWSTR lpwszName)
593 {
594         CFilterMapper_THIS(iface,fmap);
595
596         FIXME("(%p)->(%s,%s) stub!\n",This,
597                 debugstr_guid(&clsidPin),debugstr_w(lpwszName));
598
599         return E_NOTIMPL;
600 }
601
602 static HRESULT WINAPI
603 IFilterMapper_fnEnumMatchingFilters(IFilterMapper* iface,IEnumRegFilters** ppobj,DWORD dwMerit,BOOL bInputNeeded,CLSID clsInMajorType,CLSID clsidSubType,BOOL bRender,BOOL bOutputNeeded,CLSID clsOutMajorType,CLSID clsOutSubType)
604 {
605         CFilterMapper_THIS(iface,fmap);
606
607         FIXME("(%p)->() stub!\n",This);
608
609         return E_NOTIMPL;
610 }
611
612
613
614 static ICOM_VTABLE(IFilterMapper) ifmap =
615 {
616         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
617         /* IUnknown fields */
618         IFilterMapper_fnQueryInterface,
619         IFilterMapper_fnAddRef,
620         IFilterMapper_fnRelease,
621         /* IFilterMapper fields */
622         IFilterMapper_fnRegisterFilter,
623         IFilterMapper_fnRegisterFilterInstance,
624         IFilterMapper_fnRegisterPin,
625         IFilterMapper_fnRegisterPinType,
626         IFilterMapper_fnUnregisterFilter,
627         IFilterMapper_fnUnregisterFilterInstance,
628         IFilterMapper_fnUnregisterPin,
629         IFilterMapper_fnEnumMatchingFilters,
630 };
631
632
633 HRESULT CFilterMapper_InitIFilterMapper( CFilterMapper* pfm )
634 {
635         TRACE("(%p)\n",pfm);
636         ICOM_VTBL(&pfm->fmap) = &ifmap;
637
638         return NOERROR;
639 }
640
641 void CFilterMapper_UninitIFilterMapper( CFilterMapper* pfm )
642 {
643         TRACE("(%p)\n",pfm);
644 }
645
646
647 /***************************************************************************
648  *
649  *      new/delete for CLSID_FilterMapper2
650  *
651  */
652
653 /* can I use offsetof safely? - FIXME? */
654 static QUARTZ_IFEntry FMap2IFEntries[] =
655 {
656   { &IID_IFilterMapper2, offsetof(CFilterMapper2,fmap3)-offsetof(CFilterMapper2,unk) },
657   { &IID_IFilterMapper3, offsetof(CFilterMapper2,fmap3)-offsetof(CFilterMapper2,unk) },
658 };
659
660
661 static void QUARTZ_DestroyFilterMapper2(IUnknown* punk)
662 {
663         CFilterMapper2_THIS(punk,unk);
664
665         CFilterMapper2_UninitIFilterMapper3( This );
666 }
667
668 HRESULT QUARTZ_CreateFilterMapper2(IUnknown* punkOuter,void** ppobj)
669 {
670         CFilterMapper2* pfm;
671         HRESULT hr;
672
673         TRACE("(%p,%p)\n",punkOuter,ppobj);
674
675         pfm = (CFilterMapper2*)QUARTZ_AllocObj( sizeof(CFilterMapper2) );
676         if ( pfm == NULL )
677                 return E_OUTOFMEMORY;
678
679         QUARTZ_IUnkInit( &pfm->unk, punkOuter );
680         hr = CFilterMapper2_InitIFilterMapper3( pfm );
681         if ( FAILED(hr) )
682         {
683                 QUARTZ_FreeObj( pfm );
684                 return hr;
685         }
686
687         pfm->unk.pEntries = FMap2IFEntries;
688         pfm->unk.dwEntries = sizeof(FMap2IFEntries)/sizeof(FMap2IFEntries[0]);
689         pfm->unk.pOnFinalRelease = QUARTZ_DestroyFilterMapper2;
690
691         *ppobj = (void*)(&pfm->unk);
692
693         return S_OK;
694 }
695
696 /***************************************************************************
697  *
698  *      CLSID_FilterMapper2::IFilterMapper3
699  *
700  */
701
702
703 static HRESULT WINAPI
704 IFilterMapper3_fnQueryInterface(IFilterMapper3* iface,REFIID riid,void** ppobj)
705 {
706         CFilterMapper2_THIS(iface,fmap3);
707
708         TRACE("(%p)->()\n",This);
709
710         return IUnknown_QueryInterface(This->unk.punkControl,riid,ppobj);
711 }
712
713 static ULONG WINAPI
714 IFilterMapper3_fnAddRef(IFilterMapper3* iface)
715 {
716         CFilterMapper2_THIS(iface,fmap3);
717
718         TRACE("(%p)->()\n",This);
719
720         return IUnknown_AddRef(This->unk.punkControl);
721 }
722
723 static ULONG WINAPI
724 IFilterMapper3_fnRelease(IFilterMapper3* iface)
725 {
726         CFilterMapper2_THIS(iface,fmap3);
727
728         TRACE("(%p)->()\n",This);
729
730         return IUnknown_Release(This->unk.punkControl);
731 }
732
733 static HRESULT WINAPI
734 IFilterMapper3_fnCreateCategory(IFilterMapper3* iface,REFCLSID rclsidCategory,DWORD dwMerit,LPCWSTR lpwszDesc)
735 {
736         CFilterMapper2_THIS(iface,fmap3);
737
738         FIXME("(%p)->(%s,%lu,%s) stub!\n",This,
739                 debugstr_guid(rclsidCategory),
740                 (unsigned long)dwMerit,debugstr_w(lpwszDesc));
741
742         return E_NOTIMPL;
743 }
744
745
746 static HRESULT WINAPI
747 IFilterMapper3_fnUnregisterFilter(IFilterMapper3* iface,const CLSID* pclsidCategory,const OLECHAR* lpwszInst,REFCLSID rclsidFilter)
748 {
749         CFilterMapper2_THIS(iface,fmap3);
750         WCHAR*  pwszPath = NULL;
751         HRESULT hr;
752
753         TRACE("(%p)->(%s,%s,%s)\n",This,
754                 debugstr_guid(pclsidCategory),
755                 debugstr_w(lpwszInst),
756                 debugstr_guid(rclsidFilter));
757
758         if ( pclsidCategory == NULL )
759                 pclsidCategory = &CLSID_LegacyAmFilterCategory;
760
761         hr = QUARTZ_GetFilterRegPath(
762                 &pwszPath, pclsidCategory, rclsidFilter, lpwszInst );
763         if ( FAILED(hr) )
764                 return hr;
765
766         hr = QUARTZ_RegDeleteKey(HKEY_CLASSES_ROOT,pwszPath);
767         QUARTZ_FreeMem(pwszPath);
768
769         return hr;
770 }
771
772
773 static HRESULT WINAPI
774 IFilterMapper3_fnRegisterFilter(IFilterMapper3* iface,REFCLSID rclsidFilter,LPCWSTR lpName,IMoniker** ppMoniker,const CLSID* pclsidCategory,const OLECHAR* lpwszInst,const REGFILTER2* pRF2)
775 {
776         CFilterMapper2_THIS(iface,fmap3);
777         WCHAR*  pwszPath = NULL;
778         IMoniker*       pMoniker = NULL;
779         BYTE*   pFilterData = NULL;
780         DWORD   cbFilterData = 0;
781         HRESULT hr;
782
783         TRACE( "(%p)->(%s,%s,%p,%s,%s,%p) stub!\n",This,
784                 debugstr_guid(rclsidFilter),debugstr_w(lpName),
785                 ppMoniker,debugstr_guid(pclsidCategory),
786                 debugstr_w(lpwszInst),pRF2 );
787
788         if ( lpName == NULL || pRF2 == NULL )
789                 return E_POINTER;
790
791         if ( ppMoniker != NULL && *ppMoniker != NULL )
792         {
793                 FIXME( "ppMoniker != NULL - not implemented! *ppMoniker = %p\n",*ppMoniker );
794                 return E_NOTIMPL;
795         }
796
797         if ( pclsidCategory == NULL )
798                 pclsidCategory = &CLSID_LegacyAmFilterCategory;
799
800         if ( pMoniker == NULL )
801         {
802                 hr = QUARTZ_GetFilterRegPath(
803                         &pwszPath, pclsidCategory, rclsidFilter, lpwszInst );
804                 if ( FAILED(hr) )
805                         return hr;
806                 hr = QUARTZ_CreateDeviceMoniker(
807                         HKEY_CLASSES_ROOT,pwszPath,&pMoniker);
808                 QUARTZ_FreeMem(pwszPath);
809                 if ( FAILED(hr) )
810                         return hr;
811         }
812
813         pFilterData = QUARTZ_RegFilterToFilterData( pRF2, &cbFilterData );
814         if ( pFilterData == NULL || cbFilterData == 0 )
815         {
816                 hr = E_FAIL;
817                 goto err;
818         }
819
820         hr = QUARTZ_RegisterFilterToMoniker(
821                 pMoniker, rclsidFilter, lpName, pFilterData, cbFilterData );
822         if ( FAILED(hr) )
823                 goto err;
824
825         if ( ppMoniker != NULL )
826         {
827                 *ppMoniker = pMoniker;
828                 pMoniker = NULL;
829         }
830 err:
831         if ( pFilterData != NULL )
832                 QUARTZ_FreeMem(pFilterData);
833         if ( pMoniker != NULL )
834                 IMoniker_Release(pMoniker);
835
836         return hr;
837 }
838
839
840 static HRESULT WINAPI
841 IFilterMapper3_fnEnumMatchingFilters(IFilterMapper3* iface,
842         IEnumMoniker** ppEnumMoniker,DWORD dwFlags,BOOL bExactMatch,DWORD dwMerit,
843         BOOL bInputNeeded,DWORD cInputTypes,const GUID* pguidInputTypes,const REGPINMEDIUM* pPinMediumIn,const CLSID* pPinCategoryIn,BOOL bRender,
844         BOOL bOutputNeeded,DWORD cOutputTypes,const GUID* pguidOutputTypes,const REGPINMEDIUM* pPinMediumOut,const CLSID* pPinCategoryOut)
845 {
846         CFilterMapper2_THIS(iface,fmap3);
847         ICreateDevEnum* pEnum = NULL;
848         IEnumMoniker*   pCategories = NULL;
849         IMoniker*       pCat = NULL;
850         DWORD   dwCatMerit;
851         IEnumMoniker*   pCatFilters = NULL;
852         IMoniker*       pFilter = NULL;
853         CLSID   clsid;
854         ULONG   cReturned;
855         BYTE*   pbFilterData = NULL;
856         DWORD   cbFilterData = 0;
857         REGFILTER2*     prf2 = NULL;
858         QUARTZ_CompList*        pList = NULL;
859         const REGFILTERPINS2*   pRegFilterPin;
860         DWORD   n;
861         BOOL    bMatch;
862         HRESULT hr;
863
864         FIXME("(%p)->(%p,%08lx,%d,%08lx,%d,%lu,%p,%p,%p,%d,%d,%lu,%p,%p,%p)\n",This,ppEnumMoniker,dwFlags,bExactMatch,dwMerit,bInputNeeded,cInputTypes,pguidInputTypes,pPinMediumIn,pPinCategoryIn,bRender,bOutputNeeded,cOutputTypes,pguidOutputTypes,pPinMediumOut,pPinCategoryOut);
865
866         if ( ppEnumMoniker == NULL )
867                 return E_POINTER;
868         *ppEnumMoniker = NULL;
869         if ( dwFlags != 0 )
870                 return E_INVALIDARG;
871
872         hr = CoCreateInstance(
873                 &CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
874                 &IID_ICreateDevEnum, (void**)&pEnum );
875         if ( FAILED(hr) )
876                 goto err;
877
878         hr = ICreateDevEnum_CreateClassEnumerator(pEnum,&CLSID_ActiveMovieCategories,&pCategories,0);
879         if ( hr != S_OK )
880                 goto err;
881
882         while ( 1 )
883         {
884                 if ( pCat != NULL )
885                 {
886                         IMoniker_Release(pCat);
887                         pCat = NULL;
888                 }
889                 hr = IEnumMoniker_Next(pCategories,1,&pCat,&cReturned);
890                 if ( FAILED(hr) )
891                         goto err;
892                 if ( hr != S_OK )
893                         break;
894                 hr = QUARTZ_GetMeritFromMoniker(pCat,&dwCatMerit);
895                 if ( hr != S_OK || dwMerit > dwCatMerit )
896                         continue;
897                 hr = QUARTZ_GetCLSIDFromMoniker(pCat,&clsid);
898                 if ( hr != S_OK )
899                         continue;
900
901                 if ( pCatFilters != NULL )
902                 {
903                         IEnumMoniker_Release(pCatFilters);
904                         pCatFilters = NULL;
905                 }
906                 hr = ICreateDevEnum_CreateClassEnumerator(pEnum,&clsid,&pCatFilters,0);
907                 if ( FAILED(hr) )
908                         goto err;
909                 if ( hr != S_OK )
910                         continue;
911
912                 while ( 1 )
913                 {
914                         if ( pFilter != NULL )
915                         {
916                                 IMoniker_Release(pFilter);
917                                 pFilter = NULL;
918                         }
919                         hr = IEnumMoniker_Next(pCatFilters,1,&pFilter,&cReturned);
920                         if ( FAILED(hr) )
921                                 goto err;
922                         if ( hr != S_OK )
923                                 break;
924                         if ( pbFilterData != NULL )
925                         {
926                                 QUARTZ_FreeMem(pbFilterData);
927                                 pbFilterData = NULL;
928                         }
929                         hr = QUARTZ_GetFilterDataFromMoniker(pFilter,&pbFilterData,&cbFilterData);
930                         if ( hr != S_OK )
931                                 continue;
932
933                         if ( prf2 != NULL )
934                         {
935                                 QUARTZ_FreeMem(prf2);
936                                 prf2 = NULL;
937                         }
938                         prf2 = QUARTZ_RegFilterV2FromFilterData(pbFilterData,cbFilterData);
939                         if ( prf2 == NULL )
940                                 continue;
941                         TRACE("prf2 %p, Merit %lu\n",prf2,prf2->dwMerit);
942                         if ( prf2->dwMerit < dwMerit || prf2->dwVersion != 2 )
943                                 continue;
944
945                         /* check input pins. */
946                         if ( bInputNeeded )
947                         {
948                                 bMatch = FALSE;
949                                 for ( n = 0; n < prf2->u.s2.cPins2; n++ )
950                                 {
951                                         pRegFilterPin = &prf2->u.s2.rgPins2[n];
952                                         if ( pRegFilterPin->dwFlags & REG_PINFLAG_B_OUTPUT )
953                                                 continue;
954                                         bMatch = QUARTZ_CheckPinType( bExactMatch, pRegFilterPin, cInputTypes, pguidInputTypes, pPinMediumIn, pPinCategoryIn, bRender );
955                                         if ( bMatch )
956                                                 break;
957                                 }
958                                 if ( !bMatch )
959                                         continue;
960                         }
961
962                         /* check output pins. */
963                         if ( bOutputNeeded )
964                         {
965                                 bMatch = FALSE;
966                                 for ( n = 0; n < prf2->u.s2.cPins2; n++ )
967                                 {
968                                         pRegFilterPin = &prf2->u.s2.rgPins2[n];
969                                         if ( !(pRegFilterPin->dwFlags & REG_PINFLAG_B_OUTPUT) )
970                                                 continue;
971                                         bMatch = QUARTZ_CheckPinType( bExactMatch, pRegFilterPin, cOutputTypes, pguidOutputTypes, pPinMediumOut, pPinCategoryOut, FALSE );
972                                         if ( bMatch )
973                                                 break;
974                                 }
975                                 if ( !bMatch )
976                                         continue;
977                         }
978
979                         /* matched - add pFilter to the list. */
980                         if ( pList == NULL )
981                         {
982                                 pList = QUARTZ_CompList_Alloc();
983                                 if ( pList == NULL )
984                                 {
985                                         hr = E_OUTOFMEMORY;
986                                         goto err;
987                                 }
988                         }
989                         hr = QUARTZ_CompList_AddComp(
990                                 pList, (IUnknown*)pFilter, NULL, 0 );
991                         if ( FAILED(hr) )
992                                 goto err;
993                 }
994         }
995
996         if ( pList == NULL )
997         {
998                 hr = S_FALSE;
999                 goto err;
1000         }
1001
1002         FIXME("create IEnumMoniker - not sorted\n");
1003         /* FIXME - should be sorted?(in Merit order) */
1004         hr = QUARTZ_CreateEnumUnknown( &IID_IEnumMoniker, (void**)ppEnumMoniker, pList );
1005         if ( FAILED(hr) )
1006                 goto err;
1007
1008         hr = S_OK;
1009 err:
1010         if ( pEnum != NULL )
1011                 ICreateDevEnum_Release(pEnum);
1012         if ( pCategories != NULL )
1013                 IEnumMoniker_Release(pCategories);
1014         if ( pCat != NULL )
1015                 IMoniker_Release(pCat);
1016         if ( pCatFilters != NULL )
1017                 IEnumMoniker_Release(pCatFilters);
1018         if ( pFilter != NULL )
1019                 IMoniker_Release(pFilter);
1020         if ( pbFilterData != NULL )
1021                 QUARTZ_FreeMem(pbFilterData);
1022         if ( prf2 != NULL )
1023                 QUARTZ_FreeMem(prf2);
1024         if ( pList != NULL )
1025                 QUARTZ_CompList_Free( pList );
1026
1027         TRACE("returns %08lx\n",hr);
1028
1029         return hr;
1030 }
1031
1032 static HRESULT WINAPI
1033 IFilterMapper3_fnGetICreateDevEnum(IFilterMapper3* iface,ICreateDevEnum** ppDevEnum)
1034 {
1035         CFilterMapper2_THIS(iface,fmap3);
1036
1037         /* undocumented */
1038         FIXME("(%p)->() stub!\n",This);
1039
1040         return E_NOTIMPL;
1041 }
1042
1043
1044
1045
1046 static ICOM_VTABLE(IFilterMapper3) ifmap3 =
1047 {
1048         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1049         /* IUnknown fields */
1050         IFilterMapper3_fnQueryInterface,
1051         IFilterMapper3_fnAddRef,
1052         IFilterMapper3_fnRelease,
1053         /* IFilterMapper2 fields */
1054         IFilterMapper3_fnCreateCategory,
1055         IFilterMapper3_fnUnregisterFilter,
1056         IFilterMapper3_fnRegisterFilter,
1057         IFilterMapper3_fnEnumMatchingFilters,
1058         /* IFilterMapper3 fields */
1059         IFilterMapper3_fnGetICreateDevEnum,
1060 };
1061
1062
1063 HRESULT CFilterMapper2_InitIFilterMapper3( CFilterMapper2* pfm )
1064 {
1065         TRACE("(%p)\n",pfm);
1066         ICOM_VTBL(&pfm->fmap3) = &ifmap3;
1067
1068         return NOERROR;
1069 }
1070
1071 void CFilterMapper2_UninitIFilterMapper3( CFilterMapper2* pfm )
1072 {
1073         TRACE("(%p)\n",pfm);
1074 }
1075