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