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