dlls/strmbase/transform.c

   1 /*
   2  * Transform Filter (Base for decoders, etc...)
   3  *
   4  * Copyright 2005 Christian Costa
   5  * Copyright 2010 Aric Stewart, CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #include "config.h"
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "dshow.h"
  29 #include "amvideo.h"
  30 #include "strmif.h"
  31 #include "vfw.h"
  32
  33 #include <assert.h>
  34
  35 #include "wine/unicode.h"
  36 #include "wine/debug.h"
  37 #include "wine/strmbase.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  40
  41 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  42 static const WCHAR wcsOutputPinName[] = {'o','u','t','p','u','t',' ','p','i','n',0};
  43
  44 static const IBaseFilterVtbl TransformFilter_Vtbl;
  45 static const IPinVtbl TransformFilter_InputPin_Vtbl;
  46 static const IPinVtbl TransformFilter_OutputPin_Vtbl;
  47 static const IQualityControlVtbl TransformFilter_QualityControl_Vtbl;
  48
  49 static inline BaseInputPin *impl_BaseInputPin_from_BasePin( BasePin *iface )
  50 {
  51     return CONTAINING_RECORD(iface, BaseInputPin, pin);
  52 }
  53
  54 static inline BasePin *impl_BasePin_from_IPin( IPin *iface )
  55 {
  56     return CONTAINING_RECORD(iface, BasePin, IPin_iface);
  57 }
  58
  59 static inline BaseInputPin *impl_BaseInputPin_from_IPin( IPin *iface )
  60 {
  61     return CONTAINING_RECORD(iface, BaseInputPin, pin.IPin_iface);
  62 }
  63
  64 static inline BaseOutputPin *impl_BaseOutputPin_from_IPin( IPin *iface )
  65 {
  66     return CONTAINING_RECORD(iface, BaseOutputPin, pin.IPin_iface);
  67 }
  68
  69 static inline TransformFilter *impl_from_IBaseFilter( IBaseFilter *iface )
  70 {
  71     return CONTAINING_RECORD(iface, TransformFilter, filter.IBaseFilter_iface);
  72 }
  73
  74 static inline TransformFilter *impl_from_BaseFilter( BaseFilter *iface )
  75 {
  76     return CONTAINING_RECORD(iface, TransformFilter, filter);
  77 }
  78
  79 static HRESULT WINAPI TransformFilter_Input_CheckMediaType(BasePin *iface, const AM_MEDIA_TYPE * pmt)
  80 {
  81     BaseInputPin* This = impl_BaseInputPin_from_BasePin(iface);
  82     TransformFilter * pTransform;
  83
  84     TRACE("%p\n", iface);
  85     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
  86
  87     if (pTransform->pFuncsTable->pfnCheckInputType)
  88         return pTransform->pFuncsTable->pfnCheckInputType(pTransform, pmt);
  89     /* Assume OK if there's no query method (the connection will fail if
  90        needed) */
  91     return S_OK;
  92 }
  93
  94 static HRESULT WINAPI TransformFilter_Input_Receive(BaseInputPin *This, IMediaSample *pInSample)
  95 {
  96     HRESULT hr = S_FALSE;
  97     TransformFilter * pTransform;
  98     TRACE("%p\n", This);
  99     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 100
 101     EnterCriticalSection(&pTransform->csReceive);
 102     if (pTransform->filter.state == State_Stopped)
 103     {
 104         LeaveCriticalSection(&pTransform->csReceive);
 105         return VFW_E_WRONG_STATE;
 106     }
 107
 108     if (This->end_of_stream || This->flushing)
 109     {
 110         LeaveCriticalSection(&pTransform->csReceive);
 111         return S_FALSE;
 112     }
 113
 114     LeaveCriticalSection(&pTransform->csReceive);
 115     if (pTransform->pFuncsTable->pfnReceive)
 116         hr = pTransform->pFuncsTable->pfnReceive(pTransform, pInSample);
 117     else
 118         hr = S_FALSE;
 119
 120     return hr;
 121 }
 122
 123 static HRESULT WINAPI TransformFilter_Output_QueryAccept(IPin *iface, const AM_MEDIA_TYPE * pmt)
 124 {
 125     BasePin *This = impl_BasePin_from_IPin(iface);
 126     TransformFilter *pTransformFilter = impl_from_IBaseFilter(This->pinInfo.pFilter);
 127     AM_MEDIA_TYPE* outpmt = &pTransformFilter->pmt;
 128     TRACE("%p\n", iface);
 129
 130     if (IsEqualIID(&pmt->majortype, &outpmt->majortype)
 131         && (IsEqualIID(&pmt->subtype, &outpmt->subtype) || IsEqualIID(&outpmt->subtype, &GUID_NULL)))
 132         return S_OK;
 133     return S_FALSE;
 134 }
 135
 136 static HRESULT WINAPI TransformFilter_Output_DecideBufferSize(BaseOutputPin *This, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
 137 {
 138     TransformFilter *pTransformFilter = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 139     return pTransformFilter->pFuncsTable->pfnDecideBufferSize(pTransformFilter, pAlloc, ppropInputRequest);
 140 }
 141
 142 static HRESULT WINAPI TransformFilter_Output_GetMediaType(BasePin *This, int iPosition, AM_MEDIA_TYPE *pmt)
 143 {
 144     TransformFilter *pTransform = impl_from_IBaseFilter(This->pinInfo.pFilter);
 145
 146     if (iPosition < 0)
 147         return E_INVALIDARG;
 148     if (iPosition > 0)
 149         return VFW_S_NO_MORE_ITEMS;
 150     CopyMediaType(pmt, &pTransform->pmt);
 151     return S_OK;
 152 }
 153
 154 static IPin* WINAPI TransformFilter_GetPin(BaseFilter *iface, int pos)
 155 {
 156     TransformFilter *This = impl_from_BaseFilter(iface);
 157
 158     if (pos >= This->npins || pos < 0)
 159         return NULL;
 160
 161     IPin_AddRef(This->ppPins[pos]);
 162     return This->ppPins[pos];
 163 }
 164
 165 static LONG WINAPI TransformFilter_GetPinCount(BaseFilter *iface)
 166 {
 167     TransformFilter *This = impl_from_BaseFilter(iface);
 168
 169     return (This->npins+1);
 170 }
 171
 172 static const BaseFilterFuncTable tfBaseFuncTable = {
 173     TransformFilter_GetPin,
 174     TransformFilter_GetPinCount
 175 };
 176
 177 static const  BasePinFuncTable tf_input_BaseFuncTable = {
 178     TransformFilter_Input_CheckMediaType,
 179     NULL,
 180     BasePinImpl_GetMediaTypeVersion,
 181     BasePinImpl_GetMediaType
 182 };
 183
 184 static const BaseInputPinFuncTable tf_input_BaseInputFuncTable = {
 185     TransformFilter_Input_Receive
 186 };
 187
 188 static const  BasePinFuncTable tf_output_BaseFuncTable = {
 189     NULL,
 190     BaseOutputPinImpl_AttemptConnection,
 191     BasePinImpl_GetMediaTypeVersion,
 192     TransformFilter_Output_GetMediaType
 193 };
 194
 195 static const BaseOutputPinFuncTable tf_output_BaseOutputFuncTable = {
 196     TransformFilter_Output_DecideBufferSize,
 197     BaseOutputPinImpl_DecideAllocator,
 198     BaseOutputPinImpl_BreakConnect
 199 };
 200
 201 static HRESULT TransformFilter_Init(const IBaseFilterVtbl *pVtbl, const CLSID* pClsid, const TransformFilterFuncTable* pFuncsTable, TransformFilter* pTransformFilter)
 202 {
 203     HRESULT hr;
 204     PIN_INFO piInput;
 205     PIN_INFO piOutput;
 206
 207     BaseFilter_Init(&pTransformFilter->filter, pVtbl, pClsid, (DWORD_PTR)(__FILE__ ": TransformFilter.csFilter"), &tfBaseFuncTable);
 208
 209     InitializeCriticalSection(&pTransformFilter->csReceive);
 210     pTransformFilter->csReceive.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__": TransformFilter.csReceive");
 211
 212     /* pTransformFilter is already allocated */
 213     pTransformFilter->pFuncsTable = pFuncsTable;
 214     ZeroMemory(&pTransformFilter->pmt, sizeof(pTransformFilter->pmt));
 215     pTransformFilter->npins = 2;
 216
 217     pTransformFilter->ppPins = CoTaskMemAlloc(2 * sizeof(IPin *));
 218
 219     /* construct input pin */
 220     piInput.dir = PINDIR_INPUT;
 221     piInput.pFilter = &pTransformFilter->filter.IBaseFilter_iface;
 222     lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 223     piOutput.dir = PINDIR_OUTPUT;
 224     piOutput.pFilter = &pTransformFilter->filter.IBaseFilter_iface;
 225     lstrcpynW(piOutput.achName, wcsOutputPinName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
 226
 227     hr = BaseInputPin_Construct(&TransformFilter_InputPin_Vtbl, &piInput, &tf_input_BaseFuncTable, &tf_input_BaseInputFuncTable, &pTransformFilter->filter.csFilter, NULL, &pTransformFilter->ppPins[0]);
 228
 229     if (SUCCEEDED(hr))
 230     {
 231         hr = BaseOutputPin_Construct(&TransformFilter_OutputPin_Vtbl, sizeof(BaseOutputPin), &piOutput, &tf_output_BaseFuncTable, &tf_output_BaseOutputFuncTable, &pTransformFilter->filter.csFilter, &pTransformFilter->ppPins[1]);
 232
 233         if (FAILED(hr))
 234             ERR("Cannot create output pin (%x)\n", hr);
 235         else {
 236             QualityControlImpl_init(&pTransformFilter->qcimpl, pTransformFilter->ppPins[0], &pTransformFilter->filter.IBaseFilter_iface);
 237             pTransformFilter->qcimpl.lpVtbl = &TransformFilter_QualityControl_Vtbl;
 238         }
 239     }
 240     if (FAILED(hr))
 241     {
 242         CoTaskMemFree(pTransformFilter->ppPins);
 243         BaseFilterImpl_Release(&pTransformFilter->filter.IBaseFilter_iface);
 244     }
 245
 246     return hr;
 247 }
 248
 249 HRESULT TransformFilter_Construct(const IBaseFilterVtbl *pVtbl, LONG filter_size, const CLSID* pClsid, const TransformFilterFuncTable* pFuncsTable, IBaseFilter ** ppTransformFilter)
 250 {
 251     TransformFilter* pTf;
 252
 253     *ppTransformFilter = NULL;
 254
 255     assert(filter_size >= sizeof(TransformFilter));
 256
 257     pTf = CoTaskMemAlloc(filter_size);
 258
 259     if (!pTf)
 260         return E_OUTOFMEMORY;
 261
 262     ZeroMemory(pTf, filter_size);
 263
 264     if (SUCCEEDED(TransformFilter_Init(pVtbl, pClsid, pFuncsTable, pTf)))
 265     {
 266         *ppTransformFilter = &pTf->filter.IBaseFilter_iface;
 267         return S_OK;
 268     }
 269
 270     CoTaskMemFree(pTf);
 271     return E_FAIL;
 272 }
 273
 274 HRESULT WINAPI TransformFilterImpl_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 275 {
 276     HRESULT hr;
 277     TransformFilter *This = impl_from_IBaseFilter(iface);
 278     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv);
 279
 280     if (IsEqualIID(riid, &IID_IQualityControl))  {
 281         *ppv = (IQualityControl*)&This->qcimpl;
 282         IUnknown_AddRef((IUnknown*)*ppv);
 283         return S_OK;
 284     }
 285     hr = BaseFilterImpl_QueryInterface(iface, riid, ppv);
 286
 287     if (FAILED(hr) && !IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow) &&
 288         !IsEqualIID(riid, &IID_IAMFilterMiscFlags))
 289         FIXME("No interface for %s!\n", debugstr_guid(riid));
 290
 291     return hr;
 292 }
 293
 294 ULONG WINAPI TransformFilterImpl_Release(IBaseFilter * iface)
 295 {
 296     TransformFilter *This = impl_from_IBaseFilter(iface);
 297     ULONG refCount = BaseFilterImpl_Release(iface);
 298
 299     TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
 300
 301     if (!refCount)
 302     {
 303         ULONG i;
 304
 305         for (i = 0; i < This->npins; i++)
 306         {
 307             IPin *pConnectedTo;
 308
 309             if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo)))
 310             {
 311                 IPin_Disconnect(pConnectedTo);
 312                 IPin_Release(pConnectedTo);
 313             }
 314             IPin_Disconnect(This->ppPins[i]);
 315
 316             IPin_Release(This->ppPins[i]);
 317         }
 318
 319         CoTaskMemFree(This->ppPins);
 320
 321         TRACE("Destroying transform filter\n");
 322         This->csReceive.DebugInfo->Spare[0] = 0;
 323         DeleteCriticalSection(&This->csReceive);
 324         FreeMediaType(&This->pmt);
 325         CoTaskMemFree(This);
 326
 327         return 0;
 328     }
 329     else
 330         return refCount;
 331 }
 332
 333 /** IMediaFilter methods **/
 334
 335 HRESULT WINAPI TransformFilterImpl_Stop(IBaseFilter * iface)
 336 {
 337     TransformFilter *This = impl_from_IBaseFilter(iface);
 338     HRESULT hr = S_OK;
 339
 340     TRACE("(%p/%p)\n", This, iface);
 341
 342     EnterCriticalSection(&This->csReceive);
 343     {
 344         This->filter.state = State_Stopped;
 345         if (This->pFuncsTable->pfnStopStreaming)
 346             hr = This->pFuncsTable->pfnStopStreaming(This);
 347     }
 348     LeaveCriticalSection(&This->csReceive);
 349
 350     return hr;
 351 }
 352
 353 HRESULT WINAPI TransformFilterImpl_Pause(IBaseFilter * iface)
 354 {
 355     TransformFilter *This = impl_from_IBaseFilter(iface);
 356     HRESULT hr;
 357
 358     TRACE("(%p/%p)->()\n", This, iface);
 359
 360     EnterCriticalSection(&This->csReceive);
 361     {
 362         if (This->filter.state == State_Stopped)
 363             hr = IBaseFilter_Run(iface, -1);
 364         else
 365             hr = S_OK;
 366
 367         if (SUCCEEDED(hr))
 368             This->filter.state = State_Paused;
 369     }
 370     LeaveCriticalSection(&This->csReceive);
 371
 372     return hr;
 373 }
 374
 375 HRESULT WINAPI TransformFilterImpl_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 376 {
 377     HRESULT hr = S_OK;
 378     TransformFilter *This = impl_from_IBaseFilter(iface);
 379
 380     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart));
 381
 382     EnterCriticalSection(&This->csReceive);
 383     {
 384         if (This->filter.state == State_Stopped)
 385         {
 386             impl_BaseInputPin_from_IPin(This->ppPins[0])->end_of_stream = 0;
 387             if (This->pFuncsTable->pfnStartStreaming)
 388                 hr = This->pFuncsTable->pfnStartStreaming(This);
 389             if (SUCCEEDED(hr))
 390                 hr = BaseOutputPinImpl_Active(impl_BaseOutputPin_from_IPin(This->ppPins[1]));
 391         }
 392
 393         if (SUCCEEDED(hr))
 394         {
 395             This->filter.rtStreamStart = tStart;
 396             This->filter.state = State_Running;
 397         }
 398     }
 399     LeaveCriticalSection(&This->csReceive);
 400
 401     return hr;
 402 }
 403
 404 /** IBaseFilter implementation **/
 405
 406 HRESULT WINAPI TransformFilterImpl_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 407 {
 408     TransformFilter *This = impl_from_IBaseFilter(iface);
 409
 410     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_w(Id), ppPin);
 411
 412     return E_NOTIMPL;
 413 }
 414
 415 static const IBaseFilterVtbl TransformFilter_Vtbl =
 416 {
 417     TransformFilterImpl_QueryInterface,
 418     BaseFilterImpl_AddRef,
 419     TransformFilterImpl_Release,
 420     BaseFilterImpl_GetClassID,
 421     TransformFilterImpl_Stop,
 422     TransformFilterImpl_Pause,
 423     TransformFilterImpl_Run,
 424     BaseFilterImpl_GetState,
 425     BaseFilterImpl_SetSyncSource,
 426     BaseFilterImpl_GetSyncSource,
 427     BaseFilterImpl_EnumPins,
 428     TransformFilterImpl_FindPin,
 429     BaseFilterImpl_QueryFilterInfo,
 430     BaseFilterImpl_JoinFilterGraph,
 431     BaseFilterImpl_QueryVendorInfo
 432 };
 433
 434 static HRESULT WINAPI TransformFilter_InputPin_EndOfStream(IPin * iface)
 435 {
 436     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 437     TransformFilter* pTransform;
 438     IPin* ppin;
 439     HRESULT hr;
 440
 441     TRACE("(%p)->()\n", iface);
 442
 443     /* Since we process samples synchronously, just forward notification downstream */
 444     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 445     if (!pTransform)
 446         hr = E_FAIL;
 447     else
 448         hr = IPin_ConnectedTo(pTransform->ppPins[1], &ppin);
 449     if (SUCCEEDED(hr))
 450     {
 451         hr = IPin_EndOfStream(ppin);
 452         IPin_Release(ppin);
 453     }
 454
 455     if (FAILED(hr))
 456         ERR("%x\n", hr);
 457     return hr;
 458 }
 459
 460 static HRESULT WINAPI TransformFilter_InputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 461 {
 462     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 463     TransformFilter* pTransform;
 464     HRESULT hr = S_OK;
 465
 466     TRACE("(%p)->(%p, %p)\n", iface, pReceivePin, pmt);
 467
 468     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 469
 470     if (pTransform->pFuncsTable->pfnSetMediaType)
 471         hr = pTransform->pFuncsTable->pfnSetMediaType(pTransform, PINDIR_INPUT, pmt);
 472
 473     if (SUCCEEDED(hr) && pTransform->pFuncsTable->pfnCompleteConnect)
 474         hr = pTransform->pFuncsTable->pfnCompleteConnect(pTransform, PINDIR_INPUT, pReceivePin);
 475
 476     if (SUCCEEDED(hr))
 477     {
 478         hr = BaseInputPinImpl_ReceiveConnection(iface, pReceivePin, pmt);
 479         if (FAILED(hr) && pTransform->pFuncsTable->pfnBreakConnect)
 480             pTransform->pFuncsTable->pfnBreakConnect(pTransform, PINDIR_INPUT);
 481     }
 482
 483     return hr;
 484 }
 485
 486 static HRESULT WINAPI TransformFilter_InputPin_Disconnect(IPin * iface)
 487 {
 488     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 489     TransformFilter* pTransform;
 490
 491     TRACE("(%p)->()\n", iface);
 492
 493     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 494     if (pTransform->pFuncsTable->pfnBreakConnect)
 495         pTransform->pFuncsTable->pfnBreakConnect(pTransform, PINDIR_INPUT);
 496
 497     return BasePinImpl_Disconnect(iface);
 498 }
 499
 500 static HRESULT WINAPI TransformFilter_InputPin_BeginFlush(IPin * iface)
 501 {
 502     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 503     TransformFilter* pTransform;
 504     HRESULT hr = S_OK;
 505
 506     TRACE("(%p)->()\n", iface);
 507
 508     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 509     EnterCriticalSection(&pTransform->filter.csFilter);
 510     if (pTransform->pFuncsTable->pfnBeginFlush)
 511         hr = pTransform->pFuncsTable->pfnBeginFlush(pTransform);
 512     if (SUCCEEDED(hr))
 513         hr = BaseInputPinImpl_BeginFlush(iface);
 514     LeaveCriticalSection(&pTransform->filter.csFilter);
 515     return hr;
 516 }
 517
 518 static HRESULT WINAPI TransformFilter_InputPin_EndFlush(IPin * iface)
 519 {
 520     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 521     TransformFilter* pTransform;
 522     HRESULT hr = S_OK;
 523
 524     TRACE("(%p)->()\n", iface);
 525
 526     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 527     EnterCriticalSection(&pTransform->filter.csFilter);
 528     if (pTransform->pFuncsTable->pfnEndFlush)
 529         hr = pTransform->pFuncsTable->pfnEndFlush(pTransform);
 530     if (SUCCEEDED(hr))
 531         hr = BaseInputPinImpl_EndFlush(iface);
 532     LeaveCriticalSection(&pTransform->filter.csFilter);
 533     return hr;
 534 }
 535
 536 static HRESULT WINAPI TransformFilter_InputPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 537 {
 538     BaseInputPin* This = impl_BaseInputPin_from_IPin(iface);
 539     TransformFilter* pTransform;
 540     HRESULT hr = S_OK;
 541
 542     TRACE("(%p)->()\n", iface);
 543
 544     pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
 545     EnterCriticalSection(&pTransform->filter.csFilter);
 546     if (pTransform->pFuncsTable->pfnNewSegment)
 547         hr = pTransform->pFuncsTable->pfnNewSegment(pTransform, tStart, tStop, dRate);
 548     if (SUCCEEDED(hr))
 549         hr = BaseInputPinImpl_NewSegment(iface, tStart, tStop, dRate);
 550     LeaveCriticalSection(&pTransform->filter.csFilter);
 551     return hr;
 552 }
 553
 554 static const IPinVtbl TransformFilter_InputPin_Vtbl =
 555 {
 556     BaseInputPinImpl_QueryInterface,
 557     BasePinImpl_AddRef,
 558     BaseInputPinImpl_Release,
 559     BaseInputPinImpl_Connect,
 560     TransformFilter_InputPin_ReceiveConnection,
 561     TransformFilter_InputPin_Disconnect,
 562     BasePinImpl_ConnectedTo,
 563     BasePinImpl_ConnectionMediaType,
 564     BasePinImpl_QueryPinInfo,
 565     BasePinImpl_QueryDirection,
 566     BasePinImpl_QueryId,
 567     BaseInputPinImpl_QueryAccept,
 568     BasePinImpl_EnumMediaTypes,
 569     BasePinImpl_QueryInternalConnections,
 570     TransformFilter_InputPin_EndOfStream,
 571     TransformFilter_InputPin_BeginFlush,
 572     TransformFilter_InputPin_EndFlush,
 573     TransformFilter_InputPin_NewSegment
 574 };
 575
 576 static const IPinVtbl TransformFilter_OutputPin_Vtbl =
 577 {
 578     BaseOutputPinImpl_QueryInterface,
 579     BasePinImpl_AddRef,
 580     BaseOutputPinImpl_Release,
 581     BaseOutputPinImpl_Connect,
 582     BaseOutputPinImpl_ReceiveConnection,
 583     BaseOutputPinImpl_Disconnect,
 584     BasePinImpl_ConnectedTo,
 585     BasePinImpl_ConnectionMediaType,
 586     BasePinImpl_QueryPinInfo,
 587     BasePinImpl_QueryDirection,
 588     BasePinImpl_QueryId,
 589     TransformFilter_Output_QueryAccept,
 590     BasePinImpl_EnumMediaTypes,
 591     BasePinImpl_QueryInternalConnections,
 592     BaseOutputPinImpl_EndOfStream,
 593     BaseOutputPinImpl_BeginFlush,
 594     BaseOutputPinImpl_EndFlush,
 595     BasePinImpl_NewSegment
 596 };
 597
 598 static HRESULT WINAPI TransformFilter_QualityControlImpl_Notify(IQualityControl *iface, IBaseFilter *sender, Quality qm) {
 599     QualityControlImpl *qc = (QualityControlImpl*)iface;
 600     TransformFilter *This = impl_from_IBaseFilter(qc->self);
 601
 602     if (This->pFuncsTable->pfnNotify)
 603         return This->pFuncsTable->pfnNotify(This, sender, qm);
 604     else
 605         return QualityControlImpl_Notify(iface, sender, qm);
 606 }
 607
 608 static const IQualityControlVtbl TransformFilter_QualityControl_Vtbl = {
 609     QualityControlImpl_QueryInterface,
 610     QualityControlImpl_AddRef,
 611     QualityControlImpl_Release,
 612     TransformFilter_QualityControlImpl_Notify,
 613     QualityControlImpl_SetSink
 614 };