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