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