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