dlls/quartz/transform.c

   1 /*
   2  * Transform Filter (Base for decoders, etc...)
   3  *
   4  * Copyright 2005 Christian Costa
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "quartz_private.h"
  24 #include "control_private.h"
  25 #include "pin.h"
  26
  27 #include "amvideo.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "dshow.h"
  31 #include "strmif.h"
  32 #include "vfw.h"
  33
  34 #include <assert.h>
  35
  36 #include "wine/unicode.h"
  37 #include "wine/debug.h"
  38
  39 #include "transform.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  42
  43 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  44 static const WCHAR wcsOutputPinName[] = {'o','u','t','p','u','t',' ','p','i','n',0};
  45
  46 static const IBaseFilterVtbl TransformFilter_Vtbl;
  47 static const IPinVtbl TransformFilter_InputPin_Vtbl;
  48 static const IMemInputPinVtbl MemInputPin_Vtbl;
  49 static const IPinVtbl TransformFilter_OutputPin_Vtbl;
  50
  51 static HRESULT TransformFilter_Sample(LPVOID iface, IMediaSample * pSample)
  52 {
  53     TransformFilterImpl *This = (TransformFilterImpl *)iface;
  54
  55     TRACE("%p %p\n", iface, pSample);
  56
  57     return This->pFuncsTable->pfnProcessSampleData(This, pSample);
  58 }
  59
  60 static HRESULT TransformFilter_Input_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
  61 {
  62     TransformFilterImpl* This = (TransformFilterImpl*)iface;
  63     TRACE("%p\n", iface);
  64     dump_AM_MEDIA_TYPE(pmt);
  65
  66     if (This->pFuncsTable->pfnQueryConnect)
  67         return This->pFuncsTable->pfnQueryConnect(This, pmt);
  68     /* Assume OK if there's no query method (the connection will fail if
  69        needed) */
  70     return S_OK;
  71 }
  72
  73
  74 static HRESULT TransformFilter_Output_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
  75 {
  76     TransformFilterImpl* pTransformFilter = (TransformFilterImpl*)iface;
  77     AM_MEDIA_TYPE* outpmt = &((OutputPin*)pTransformFilter->ppPins[1])->pin.mtCurrent;
  78     TRACE("%p\n", iface);
  79
  80     if (IsEqualIID(&pmt->majortype, &outpmt->majortype) && IsEqualIID(&pmt->subtype, &outpmt->subtype))
  81         return S_OK;
  82     return S_FALSE;
  83 }
  84
  85
  86 static inline TransformFilterImpl *impl_from_IMediaSeeking( IMediaSeeking *iface )
  87 {
  88     return (TransformFilterImpl *)((char*)iface - FIELD_OFFSET(TransformFilterImpl, mediaSeeking.lpVtbl));
  89 }
  90
  91 static HRESULT WINAPI TransformFilter_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
  92 {
  93     TransformFilterImpl *This = impl_from_IMediaSeeking(iface);
  94
  95     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
  96 }
  97
  98 static ULONG WINAPI TransformFilter_Seeking_AddRef(IMediaSeeking * iface)
  99 {
 100     TransformFilterImpl *This = impl_from_IMediaSeeking(iface);
 101
 102     return IUnknown_AddRef((IUnknown *)This);
 103 }
 104
 105 static ULONG WINAPI TransformFilter_Seeking_Release(IMediaSeeking * iface)
 106 {
 107     TransformFilterImpl *This = impl_from_IMediaSeeking(iface);
 108
 109     return IUnknown_Release((IUnknown *)This);
 110 }
 111
 112 static const IMediaSeekingVtbl TransformFilter_Seeking_Vtbl =
 113 {
 114     TransformFilter_Seeking_QueryInterface,
 115     TransformFilter_Seeking_AddRef,
 116     TransformFilter_Seeking_Release,
 117     MediaSeekingImpl_GetCapabilities,
 118     MediaSeekingImpl_CheckCapabilities,
 119     MediaSeekingImpl_IsFormatSupported,
 120     MediaSeekingImpl_QueryPreferredFormat,
 121     MediaSeekingImpl_GetTimeFormat,
 122     MediaSeekingImpl_IsUsingTimeFormat,
 123     MediaSeekingImpl_SetTimeFormat,
 124     MediaSeekingImpl_GetDuration,
 125     MediaSeekingImpl_GetStopPosition,
 126     MediaSeekingImpl_GetCurrentPosition,
 127     MediaSeekingImpl_ConvertTimeFormat,
 128     MediaSeekingImpl_SetPositions,
 129     MediaSeekingImpl_GetPositions,
 130     MediaSeekingImpl_GetAvailable,
 131     MediaSeekingImpl_SetRate,
 132     MediaSeekingImpl_GetRate,
 133     MediaSeekingImpl_GetPreroll
 134 };
 135
 136 static HRESULT TransformFilter_ChangeCurrent(IBaseFilter *iface)
 137 {
 138     FIXME("(%p) filter hasn't implemented current position change!\n", iface);
 139     return S_OK;
 140 }
 141
 142 static HRESULT TransformFilter_ChangeStop(IBaseFilter *iface)
 143 {
 144     FIXME("(%p) filter hasn't implemented stop position change!\n", iface);
 145     return S_OK;
 146 }
 147
 148 static HRESULT TransformFilter_ChangeRate(IBaseFilter *iface)
 149 {
 150     FIXME("(%p) filter hasn't implemented rate change!\n", iface);
 151     return S_OK;
 152 }
 153
 154 HRESULT TransformFilter_Create(TransformFilterImpl* pTransformFilter, const CLSID* pClsid, const TransformFuncsTable* pFuncsTable, CHANGEPROC stop, CHANGEPROC current, CHANGEPROC rate)
 155 {
 156     HRESULT hr;
 157     PIN_INFO piInput;
 158     PIN_INFO piOutput;
 159
 160     /* pTransformFilter is already allocated */
 161     pTransformFilter->clsid = *pClsid;
 162     pTransformFilter->pFuncsTable = pFuncsTable;
 163
 164     pTransformFilter->lpVtbl = &TransformFilter_Vtbl;
 165
 166     pTransformFilter->refCount = 1;
 167     InitializeCriticalSection(&pTransformFilter->csFilter);
 168     pTransformFilter->csFilter.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": TransformFilterImpl.csFilter");
 169     pTransformFilter->state = State_Stopped;
 170     pTransformFilter->pClock = NULL;
 171     ZeroMemory(&pTransformFilter->filterInfo, sizeof(FILTER_INFO));
 172
 173     pTransformFilter->ppPins = CoTaskMemAlloc(2 * sizeof(IPin *));
 174
 175     /* construct input pin */
 176     piInput.dir = PINDIR_INPUT;
 177     piInput.pFilter = (IBaseFilter *)pTransformFilter;
 178     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 179     piOutput.dir = PINDIR_OUTPUT;
 180     piOutput.pFilter = (IBaseFilter *)pTransformFilter;
 181     lstrcpynW(piOutput.achName, wcsOutputPinName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
 182
 183     hr = InputPin_Construct(&TransformFilter_InputPin_Vtbl, &piInput, TransformFilter_Sample, pTransformFilter, TransformFilter_Input_QueryAccept, NULL, &pTransformFilter->csFilter, &pTransformFilter->ppPins[0]);
 184
 185     if (SUCCEEDED(hr))
 186     {
 187         ALLOCATOR_PROPERTIES props;
 188         props.cbAlign = 1;
 189         props.cbPrefix = 0;
 190         props.cbBuffer = 0; /* Will be updated at connection time */
 191         props.cBuffers = 2;
 192
 193         hr = OutputPin_Construct(&TransformFilter_OutputPin_Vtbl, sizeof(OutputPin), &piOutput, &props, pTransformFilter, TransformFilter_Output_QueryAccept, &pTransformFilter->csFilter, &pTransformFilter->ppPins[1]);
 194
 195         if (FAILED(hr))
 196             ERR("Cannot create output pin (%x)\n", hr);
 197         else
 198         {
 199             if (!stop)
 200                 stop = TransformFilter_ChangeStop;
 201             if (!current)
 202                 current = TransformFilter_ChangeCurrent;
 203             if (!rate)
 204                 rate = TransformFilter_ChangeRate;
 205
 206             MediaSeekingImpl_Init((IBaseFilter*)pTransformFilter, stop, current, rate, &pTransformFilter->mediaSeeking, &pTransformFilter->csFilter);
 207             pTransformFilter->mediaSeeking.lpVtbl = &TransformFilter_Seeking_Vtbl;
 208         }
 209     }
 210     else
 211     {
 212         CoTaskMemFree(pTransformFilter->ppPins);
 213         pTransformFilter->csFilter.DebugInfo->Spare[0] = 0;
 214         DeleteCriticalSection(&pTransformFilter->csFilter);
 215         CoTaskMemFree(pTransformFilter);
 216     }
 217
 218     return hr;
 219 }
 220
 221 static HRESULT WINAPI TransformFilter_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 222 {
 223     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 224     TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 225
 226     *ppv = NULL;
 227
 228     if (IsEqualIID(riid, &IID_IUnknown))
 229         *ppv = (LPVOID)This;
 230     else if (IsEqualIID(riid, &IID_IPersist))
 231         *ppv = (LPVOID)This;
 232     else if (IsEqualIID(riid, &IID_IMediaFilter))
 233         *ppv = (LPVOID)This;
 234     else if (IsEqualIID(riid, &IID_IBaseFilter))
 235         *ppv = (LPVOID)This;
 236     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 237         *ppv = &This->mediaSeeking;
 238
 239     if (*ppv)
 240     {
 241         IUnknown_AddRef((IUnknown *)(*ppv));
 242         return S_OK;
 243     }
 244
 245     if (!IsEqualIID(riid, &IID_IPin))
 246         FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 247
 248     return E_NOINTERFACE;
 249 }
 250
 251 static ULONG WINAPI TransformFilter_AddRef(IBaseFilter * iface)
 252 {
 253     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 254     ULONG refCount = InterlockedIncrement(&This->refCount);
 255
 256     TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1);
 257
 258     return refCount;
 259 }
 260
 261 static ULONG WINAPI TransformFilter_Release(IBaseFilter * iface)
 262 {
 263     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 264     ULONG refCount = InterlockedDecrement(&This->refCount);
 265
 266     TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
 267
 268     if (!refCount)
 269     {
 270         ULONG i;
 271
 272         if (This->pClock)
 273             IReferenceClock_Release(This->pClock);
 274
 275         for (i = 0; i < 2; i++)
 276         {
 277             IPin *pConnectedTo;
 278
 279             if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo)))
 280             {
 281                 IPin_Disconnect(pConnectedTo);
 282                 IPin_Release(pConnectedTo);
 283             }
 284             IPin_Disconnect(This->ppPins[i]);
 285
 286             IPin_Release(This->ppPins[i]);
 287         }
 288
 289         CoTaskMemFree(This->ppPins);
 290         This->lpVtbl = NULL;
 291
 292         This->csFilter.DebugInfo->Spare[0] = 0;
 293         DeleteCriticalSection(&This->csFilter);
 294
 295         TRACE("Destroying transform filter\n");
 296         CoTaskMemFree(This);
 297
 298         return 0;
 299     }
 300     else
 301         return refCount;
 302 }
 303
 304 /** IPersist methods **/
 305
 306 static HRESULT WINAPI TransformFilter_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 307 {
 308     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 309
 310     TRACE("(%p/%p)->(%p)\n", This, iface, pClsid);
 311
 312     *pClsid = This->clsid;
 313
 314     return S_OK;
 315 }
 316
 317 /** IMediaFilter methods **/
 318
 319 static HRESULT WINAPI TransformFilter_Stop(IBaseFilter * iface)
 320 {
 321     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 322
 323     TRACE("(%p/%p)\n", This, iface);
 324
 325     EnterCriticalSection(&This->csFilter);
 326     {
 327         This->state = State_Stopped;
 328         if (This->pFuncsTable->pfnProcessEnd)
 329             This->pFuncsTable->pfnProcessEnd(This);
 330     }
 331     LeaveCriticalSection(&This->csFilter);
 332
 333     return S_OK;
 334 }
 335
 336 static HRESULT WINAPI TransformFilter_Pause(IBaseFilter * iface)
 337 {
 338     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 339
 340     TRACE("(%p/%p)->()\n", This, iface);
 341
 342     EnterCriticalSection(&This->csFilter);
 343     {
 344         This->state = State_Paused;
 345     }
 346     LeaveCriticalSection(&This->csFilter);
 347
 348     return S_OK;
 349 }
 350
 351 static HRESULT WINAPI TransformFilter_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 352 {
 353     HRESULT hr = S_OK;
 354     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 355
 356     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 357
 358     EnterCriticalSection(&This->csFilter);
 359     {
 360         This->rtStreamStart = tStart;
 361         This->state = State_Running;
 362         OutputPin_CommitAllocator((OutputPin *)This->ppPins[1]);
 363         if (This->pFuncsTable->pfnProcessBegin)
 364             This->pFuncsTable->pfnProcessBegin(This);
 365     }
 366     LeaveCriticalSection(&This->csFilter);
 367
 368     return hr;
 369 }
 370
 371 static HRESULT WINAPI TransformFilter_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 372 {
 373     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 374
 375     TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState);
 376
 377     EnterCriticalSection(&This->csFilter);
 378     {
 379         *pState = This->state;
 380     }
 381     LeaveCriticalSection(&This->csFilter);
 382
 383     return S_OK;
 384 }
 385
 386 static HRESULT WINAPI TransformFilter_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 387 {
 388     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 389
 390     TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
 391
 392     EnterCriticalSection(&This->csFilter);
 393     {
 394         if (This->pClock)
 395             IReferenceClock_Release(This->pClock);
 396         This->pClock = pClock;
 397         if (This->pClock)
 398             IReferenceClock_AddRef(This->pClock);
 399     }
 400     LeaveCriticalSection(&This->csFilter);
 401
 402     return S_OK;
 403 }
 404
 405 static HRESULT WINAPI TransformFilter_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 406 {
 407     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 408
 409     TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
 410
 411     EnterCriticalSection(&This->csFilter);
 412     {
 413         *ppClock = This->pClock;
 414         IReferenceClock_AddRef(This->pClock);
 415     }
 416     LeaveCriticalSection(&This->csFilter);
 417
 418     return S_OK;
 419 }
 420
 421 /** IBaseFilter implementation **/
 422
 423 static HRESULT WINAPI TransformFilter_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 424 {
 425     ENUMPINDETAILS epd;
 426     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 427
 428     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 429
 430     epd.cPins = 2; /* input and output pins */
 431     epd.ppPins = This->ppPins;
 432     return IEnumPinsImpl_Construct(&epd, ppEnum);
 433 }
 434
 435 static HRESULT WINAPI TransformFilter_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 436 {
 437     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 438
 439     TRACE("(%p/%p)->(%p,%p)\n", This, iface, debugstr_w(Id), ppPin);
 440
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI TransformFilter_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 445 {
 446     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 447
 448     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 449
 450     strcpyW(pInfo->achName, This->filterInfo.achName);
 451     pInfo->pGraph = This->filterInfo.pGraph;
 452
 453     if (pInfo->pGraph)
 454         IFilterGraph_AddRef(pInfo->pGraph);
 455
 456     return S_OK;
 457 }
 458
 459 static HRESULT WINAPI TransformFilter_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 460 {
 461     HRESULT hr = S_OK;
 462     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 463
 464     TRACE("(%p/%p)->(%p, %s)\n", This, iface, pGraph, debugstr_w(pName));
 465
 466     EnterCriticalSection(&This->csFilter);
 467     {
 468         if (pName)
 469             strcpyW(This->filterInfo.achName, pName);
 470         else
 471             *This->filterInfo.achName = '\0';
 472         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 473     }
 474     LeaveCriticalSection(&This->csFilter);
 475
 476     return hr;
 477 }
 478
 479 static HRESULT WINAPI TransformFilter_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 480 {
 481     TransformFilterImpl *This = (TransformFilterImpl *)iface;
 482     TRACE("(%p/%p)->(%p)\n", This, iface, pVendorInfo);
 483     return E_NOTIMPL;
 484 }
 485
 486 static const IBaseFilterVtbl TransformFilter_Vtbl =
 487 {
 488     TransformFilter_QueryInterface,
 489     TransformFilter_AddRef,
 490     TransformFilter_Release,
 491     TransformFilter_GetClassID,
 492     TransformFilter_Stop,
 493     TransformFilter_Pause,
 494     TransformFilter_Run,
 495     TransformFilter_GetState,
 496     TransformFilter_SetSyncSource,
 497     TransformFilter_GetSyncSource,
 498     TransformFilter_EnumPins,
 499     TransformFilter_FindPin,
 500     TransformFilter_QueryFilterInfo,
 501     TransformFilter_JoinFilterGraph,
 502     TransformFilter_QueryVendorInfo
 503 };
 504
 505 static HRESULT WINAPI TransformFilter_InputPin_EndOfStream(IPin * iface)
 506 {
 507     InputPin* This = (InputPin*) iface;
 508     TransformFilterImpl* pTransform;
 509     IPin* ppin;
 510     HRESULT hr;
 511
 512     TRACE("(%p)->()\n", iface);
 513
 514     /* Since we process samples synchronously, just forward notification downstream */
 515     pTransform = (TransformFilterImpl*)This->pin.pinInfo.pFilter;
 516     if (!pTransform)
 517         hr = E_FAIL;
 518     else
 519         hr = IPin_ConnectedTo(pTransform->ppPins[1], &ppin);
 520     if (SUCCEEDED(hr))
 521     {
 522         hr = IPin_EndOfStream(ppin);
 523         IPin_Release(ppin);
 524     }
 525
 526     if (FAILED(hr))
 527         ERR("%x\n", hr);
 528     return hr;
 529 }
 530
 531 static HRESULT WINAPI TransformFilter_InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 532 {
 533     InputPin* This = (InputPin*) iface;
 534     TransformFilterImpl* pTransform;
 535     HRESULT hr;
 536
 537     TRACE("(%p)->(%p, %p)\n", iface, pReceivePin, pmt);
 538
 539     pTransform = (TransformFilterImpl*)This->pin.pinInfo.pFilter;
 540
 541     hr = pTransform->pFuncsTable->pfnConnectInput(pTransform, pmt);
 542     if (SUCCEEDED(hr))
 543     {
 544         hr = InputPin_ReceiveConnection(iface, pReceivePin, pmt);
 545         if (FAILED(hr))
 546             pTransform->pFuncsTable->pfnCleanup(pTransform);
 547     }
 548
 549     return hr;
 550 }
 551
 552 static HRESULT WINAPI TransformFilter_InputPin_Disconnect(IPin * iface)
 553 {
 554     InputPin* This = (InputPin*) iface;
 555     TransformFilterImpl* pTransform;
 556
 557     TRACE("(%p)->()\n", iface);
 558
 559     pTransform = (TransformFilterImpl*)This->pin.pinInfo.pFilter;
 560     pTransform->pFuncsTable->pfnCleanup(pTransform);
 561
 562     return IPinImpl_Disconnect(iface);
 563 }
 564
 565 static const IPinVtbl TransformFilter_InputPin_Vtbl =
 566 {
 567     InputPin_QueryInterface,
 568     IPinImpl_AddRef,
 569     InputPin_Release,
 570     InputPin_Connect,
 571     TransformFilter_InputPin_ReceiveConnection,
 572     TransformFilter_InputPin_Disconnect,
 573     IPinImpl_ConnectedTo,
 574     IPinImpl_ConnectionMediaType,
 575     IPinImpl_QueryPinInfo,
 576     IPinImpl_QueryDirection,
 577     IPinImpl_QueryId,
 578     IPinImpl_QueryAccept,
 579     IPinImpl_EnumMediaTypes,
 580     IPinImpl_QueryInternalConnections,
 581     TransformFilter_InputPin_EndOfStream,
 582     InputPin_BeginFlush,
 583     InputPin_EndFlush,
 584     InputPin_NewSegment
 585 };
 586
 587 static HRESULT WINAPI TransformFilter_Output_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
 588 {
 589     IPinImpl *This = (IPinImpl *)iface;
 590     ENUMMEDIADETAILS emd;
 591
 592     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 593
 594     emd.cMediaTypes = 1;
 595     emd.pMediaTypes = &This->mtCurrent;
 596
 597     return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
 598 }
 599
 600 static const IPinVtbl TransformFilter_OutputPin_Vtbl =
 601 {
 602     OutputPin_QueryInterface,
 603     IPinImpl_AddRef,
 604     OutputPin_Release,
 605     OutputPin_Connect,
 606     OutputPin_ReceiveConnection,
 607     OutputPin_Disconnect,
 608     IPinImpl_ConnectedTo,
 609     IPinImpl_ConnectionMediaType,
 610     IPinImpl_QueryPinInfo,
 611     IPinImpl_QueryDirection,
 612     IPinImpl_QueryId,
 613     IPinImpl_QueryAccept,
 614     TransformFilter_Output_EnumMediaTypes,
 615     IPinImpl_QueryInternalConnections,
 616     OutputPin_EndOfStream,
 617     OutputPin_BeginFlush,
 618     OutputPin_EndFlush,
 619     OutputPin_NewSegment
 620 };
 621
 622 static const IMemInputPinVtbl MemInputPin_Vtbl =
 623 {
 624     MemInputPin_QueryInterface,
 625     MemInputPin_AddRef,
 626     MemInputPin_Release,
 627     MemInputPin_GetAllocator,
 628     MemInputPin_NotifyAllocator,
 629     MemInputPin_GetAllocatorRequirements,
 630     MemInputPin_Receive,
 631     MemInputPin_ReceiveMultiple,
 632     MemInputPin_ReceiveCanBlock
 633 };