dlls/quartz/avisplit.c

   1 /*
   2  * AVI Splitter Filter
   3  *
   4  * Copyright 2003 Robert Shearman
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 /* FIXME:
  21  * - we don't do anything with indices yet (we could use them when seeking)
  22  * - we don't support multiple RIFF sections (i.e. large AVI files > 2Gb)
  23  */
  24
  25 #include "quartz_private.h"
  26 #include "control_private.h"
  27 #include "pin.h"
  28
  29 #include "uuids.h"
  30 #include "aviriff.h"
  31 #include "mmreg.h"
  32 #include "vfwmsgs.h"
  33 #include "amvideo.h"
  34
  35 #include "fourcc.h"
  36
  37 #include "wine/unicode.h"
  38 #include "wine/debug.h"
  39
  40 #include <math.h>
  41 #include <assert.h>
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  44
  45 static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0};
  46 static const struct IBaseFilterVtbl AVISplitter_Vtbl;
  47 static const struct IMediaSeekingVtbl AVISplitter_Seeking_Vtbl;
  48 static const struct IPinVtbl AVISplitter_OutputPin_Vtbl;
  49 static const struct IPinVtbl AVISplitter_InputPin_Vtbl;
  50
  51 static HRESULT AVISplitter_Sample(LPVOID iface, IMediaSample * pSample);
  52 static HRESULT AVISplitter_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt);
  53 static HRESULT AVISplitter_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt);
  54 static HRESULT AVISplitter_InputPin_PreConnect(IPin * iface, IPin * pConnectPin);
  55 static HRESULT AVISplitter_ChangeStart(LPVOID iface);
  56 static HRESULT AVISplitter_ChangeStop(LPVOID iface);
  57 static HRESULT AVISplitter_ChangeRate(LPVOID iface);
  58
  59 static HRESULT AVISplitter_InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin);
  60
  61 typedef struct AVISplitter
  62 {
  63     const IBaseFilterVtbl * lpVtbl;
  64
  65     ULONG refCount;
  66     CRITICAL_SECTION csFilter;
  67     FILTER_STATE state;
  68     REFERENCE_TIME rtStreamStart;
  69     IReferenceClock * pClock;
  70     FILTER_INFO filterInfo;
  71
  72     PullPin * pInputPin;
  73     ULONG cStreams;
  74     IPin ** ppPins;
  75     IMediaSample * pCurrentSample;
  76     RIFFCHUNK CurrentChunk;
  77     LONGLONG CurrentChunkOffset; /* in media time */
  78     LONGLONG EndOfFile;
  79     AVIMAINHEADER AviHeader;
  80 } AVISplitter;
  81
  82 typedef struct AVISplitter_OutputPin
  83 {
  84     OutputPin pin;
  85
  86     AM_MEDIA_TYPE * pmt;
  87     float fSamplesPerSec;
  88     DWORD dwSamplesProcessed;
  89     DWORD dwSampleSize;
  90     DWORD dwLength;
  91     MediaSeekingImpl mediaSeeking;
  92 } AVISplitter_OutputPin;
  93
  94
  95 #define _IMediaSeeking_Offset ((int)(&(((AVISplitter_OutputPin*)0)->mediaSeeking)))
  96 #define ICOM_THIS_From_IMediaSeeking(impl, iface) impl* This = (impl*)(((char*)iface)-_IMediaSeeking_Offset);
  97
  98 HRESULT AVISplitter_create(IUnknown * pUnkOuter, LPVOID * ppv)
  99 {
 100     HRESULT hr;
 101     PIN_INFO piInput;
 102     AVISplitter * pAviSplit;
 103
 104     TRACE("(%p, %p)\n", pUnkOuter, ppv);
 105
 106     *ppv = NULL;
 107
 108     if (pUnkOuter)
 109         return CLASS_E_NOAGGREGATION;
 110
 111     pAviSplit = CoTaskMemAlloc(sizeof(AVISplitter));
 112
 113     pAviSplit->lpVtbl = &AVISplitter_Vtbl;
 114     pAviSplit->refCount = 1;
 115     InitializeCriticalSection(&pAviSplit->csFilter);
 116     pAviSplit->state = State_Stopped;
 117     pAviSplit->pClock = NULL;
 118     pAviSplit->pCurrentSample = NULL;
 119     ZeroMemory(&pAviSplit->filterInfo, sizeof(FILTER_INFO));
 120
 121     pAviSplit->cStreams = 0;
 122     pAviSplit->ppPins = CoTaskMemAlloc(1 * sizeof(IPin *));
 123
 124     /* construct input pin */
 125     piInput.dir = PINDIR_INPUT;
 126     piInput.pFilter = (IBaseFilter *)pAviSplit;
 127     strncpyW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0]));
 128
 129     hr = AVISplitter_InputPin_Construct(&piInput, AVISplitter_Sample, (LPVOID)pAviSplit, AVISplitter_QueryAccept, &pAviSplit->csFilter, (IPin **)&pAviSplit->pInputPin);
 130
 131     if (SUCCEEDED(hr))
 132     {
 133         pAviSplit->ppPins[0] = (IPin *)pAviSplit->pInputPin;
 134         pAviSplit->pInputPin->fnPreConnect = AVISplitter_InputPin_PreConnect;
 135         *ppv = (LPVOID)pAviSplit;
 136     }
 137     else
 138     {
 139         CoTaskMemFree(pAviSplit->ppPins);
 140         DeleteCriticalSection(&pAviSplit->csFilter);
 141         CoTaskMemFree(pAviSplit);
 142     }
 143
 144     return hr;
 145 }
 146
 147 static HRESULT AVISplitter_OutputPin_Init(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, const AM_MEDIA_TYPE * pmt, float fSamplesPerSec, LPCRITICAL_SECTION pCritSec, AVISplitter_OutputPin * pPinImpl)
 148 {
 149     pPinImpl->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 150     CopyMediaType(pPinImpl->pmt, pmt);
 151     pPinImpl->dwSamplesProcessed = 0;
 152     pPinImpl->dwSampleSize = 0;
 153     pPinImpl->fSamplesPerSec = fSamplesPerSec;
 154
 155     MediaSeekingImpl_Init((LPVOID)pPinInfo->pFilter, AVISplitter_ChangeStop, AVISplitter_ChangeStart, AVISplitter_ChangeRate, &pPinImpl->mediaSeeking);
 156     pPinImpl->mediaSeeking.lpVtbl = &AVISplitter_Seeking_Vtbl;
 157
 158     return OutputPin_Init(pPinInfo, props, pUserData, pQueryAccept, pCritSec, &pPinImpl->pin);
 159 }
 160
 161 static HRESULT AVISplitter_OutputPin_Construct(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, const AM_MEDIA_TYPE * pmt, float fSamplesPerSec, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
 162 {
 163     AVISplitter_OutputPin * pPinImpl;
 164
 165     *ppPin = NULL;
 166
 167     assert(pPinInfo->dir == PINDIR_OUTPUT);
 168
 169     pPinImpl = CoTaskMemAlloc(sizeof(AVISplitter_OutputPin));
 170
 171     if (!pPinImpl)
 172         return E_OUTOFMEMORY;
 173
 174     if (SUCCEEDED(AVISplitter_OutputPin_Init(pPinInfo, props, pUserData, pQueryAccept, pmt, fSamplesPerSec, pCritSec, pPinImpl)))
 175     {
 176         pPinImpl->pin.pin.lpVtbl = &AVISplitter_OutputPin_Vtbl;
 177
 178         *ppPin = (IPin *)pPinImpl;
 179         return S_OK;
 180     }
 181     return E_FAIL;
 182 }
 183
 184 static HRESULT WINAPI AVISplitter_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv)
 185 {
 186     AVISplitter *This = (AVISplitter *)iface;
 187     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
 188
 189     *ppv = NULL;
 190
 191     if (IsEqualIID(riid, &IID_IUnknown))
 192         *ppv = (LPVOID)This;
 193     else if (IsEqualIID(riid, &IID_IPersist))
 194         *ppv = (LPVOID)This;
 195     else if (IsEqualIID(riid, &IID_IMediaFilter))
 196         *ppv = (LPVOID)This;
 197     else if (IsEqualIID(riid, &IID_IBaseFilter))
 198         *ppv = (LPVOID)This;
 199
 200     if (*ppv)
 201     {
 202         IUnknown_AddRef((IUnknown *)(*ppv));
 203         return S_OK;
 204     }
 205
 206     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 207
 208     return E_NOINTERFACE;
 209 }
 210
 211 static ULONG WINAPI AVISplitter_AddRef(IBaseFilter * iface)
 212 {
 213     AVISplitter *This = (AVISplitter *)iface;
 214
 215     TRACE("(%p/%p)->() AddRef from %ld\n", This, iface, This->refCount);
 216
 217     return InterlockedIncrement(&This->refCount);
 218 }
 219
 220 static ULONG WINAPI AVISplitter_Release(IBaseFilter * iface)
 221 {
 222     AVISplitter *This = (AVISplitter *)iface;
 223
 224     TRACE("(%p/%p)->() Release from %ld\n", This, iface, This->refCount);
 225
 226     if (!InterlockedDecrement(&This->refCount))
 227     {
 228         ULONG i;
 229
 230         DeleteCriticalSection(&This->csFilter);
 231         if (This->pClock)
 232             IReferenceClock_Release(This->pClock);
 233
 234         for (i = 0; i < This->cStreams + 1; i++)
 235             IPin_Release(This->ppPins[i]);
 236
 237         HeapFree(GetProcessHeap(), 0, This->ppPins);
 238         This->lpVtbl = NULL;
 239
 240         TRACE("Destroying AVI splitter\n");
 241         CoTaskMemFree(This);
 242
 243         return 0;
 244     }
 245     else
 246         return This->refCount;
 247 }
 248
 249 /** IPersist methods **/
 250
 251 static HRESULT WINAPI AVISplitter_GetClassID(IBaseFilter * iface, CLSID * pClsid)
 252 {
 253     TRACE("(%p)\n", pClsid);
 254
 255     *pClsid = CLSID_AviSplitter;
 256
 257     return S_OK;
 258 }
 259
 260 /** IMediaFilter methods **/
 261
 262 static HRESULT WINAPI AVISplitter_Stop(IBaseFilter * iface)
 263 {
 264     HRESULT hr;
 265     AVISplitter *This = (AVISplitter *)iface;
 266
 267     TRACE("()\n");
 268
 269     EnterCriticalSection(&This->csFilter);
 270     {
 271         hr = PullPin_StopProcessing(This->pInputPin);
 272         This->state = State_Stopped;
 273     }
 274     LeaveCriticalSection(&This->csFilter);
 275
 276     return hr;
 277 }
 278
 279 static HRESULT WINAPI AVISplitter_Pause(IBaseFilter * iface)
 280 {
 281     HRESULT hr = S_OK;
 282     BOOL bInit;
 283     AVISplitter *This = (AVISplitter *)iface;
 284
 285     TRACE("()\n");
 286
 287     EnterCriticalSection(&This->csFilter);
 288     {
 289         bInit = (This->state == State_Stopped);
 290         This->state = State_Paused;
 291     }
 292     LeaveCriticalSection(&This->csFilter);
 293
 294     if (bInit)
 295     {
 296         unsigned int i;
 297
 298         hr = PullPin_Seek(This->pInputPin, This->CurrentChunkOffset, This->EndOfFile);
 299
 300         if (SUCCEEDED(hr))
 301             hr = PullPin_InitProcessing(This->pInputPin);
 302
 303         if (SUCCEEDED(hr))
 304         {
 305             for (i = 1; i < This->cStreams + 1; i++)
 306             {
 307                 AVISplitter_OutputPin* StreamPin = (AVISplitter_OutputPin *)This->ppPins[i];
 308                 OutputPin_DeliverNewSegment((OutputPin *)This->ppPins[i], 0, (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec), 1.0);
 309                 StreamPin->mediaSeeking.llDuration = (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec);
 310                 StreamPin->mediaSeeking.llStop = (LONGLONG)ceil(10000000.0 * (float)StreamPin->dwLength / StreamPin->fSamplesPerSec);
 311                 OutputPin_CommitAllocator((OutputPin *)This->ppPins[i]);
 312             }
 313
 314             /* FIXME: this is a little hacky: we have to deliver (at least?) one sample
 315              * to each renderer before they will complete their transitions. We should probably
 316              * seek through the stream for the first of each, rather than do it this way which is
 317              * probably a bit prone to deadlocking */
 318             hr = PullPin_StartProcessing(This->pInputPin);
 319         }
 320     }
 321     /* FIXME: else pause thread */
 322
 323     return hr;
 324 }
 325
 326 static HRESULT WINAPI AVISplitter_Run(IBaseFilter * iface, REFERENCE_TIME tStart)
 327 {
 328     HRESULT hr = S_OK;
 329     AVISplitter *This = (AVISplitter *)iface;
 330     int i;
 331
 332     TRACE("(%s)\n", wine_dbgstr_longlong(tStart));
 333
 334     EnterCriticalSection(&This->csFilter);
 335     {
 336         This->rtStreamStart = tStart;
 337         This->state = State_Running;
 338
 339         hr = PullPin_InitProcessing(This->pInputPin);
 340
 341         if (SUCCEEDED(hr))
 342         {
 343             for (i = 1; i < This->cStreams + 1; i++)
 344             {
 345                 OutputPin_CommitAllocator((OutputPin *)This->ppPins[i]);
 346             }
 347             hr = PullPin_StartProcessing(This->pInputPin);
 348         }
 349     }
 350     LeaveCriticalSection(&This->csFilter);
 351
 352     return hr;
 353 }
 354
 355 static HRESULT WINAPI AVISplitter_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 356 {
 357     AVISplitter *This = (AVISplitter *)iface;
 358
 359     TRACE("(%ld, %p)\n", dwMilliSecsTimeout, pState);
 360
 361     EnterCriticalSection(&This->csFilter);
 362     {
 363         *pState = This->state;
 364     }
 365     LeaveCriticalSection(&This->csFilter);
 366
 367     /* FIXME: this is a little bit unsafe, but I don't see that we can do this
 368      * while in the critical section. Maybe we could copy the pointer and addref in the
 369      * critical section and then release after this.
 370      */
 371     if (This->pInputPin && (PullPin_WaitForStateChange(This->pInputPin, dwMilliSecsTimeout) == S_FALSE))
 372         return VFW_S_STATE_INTERMEDIATE;
 373
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI AVISplitter_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock)
 378 {
 379     AVISplitter *This = (AVISplitter *)iface;
 380
 381     TRACE("(%p)\n", pClock);
 382
 383     EnterCriticalSection(&This->csFilter);
 384     {
 385         if (This->pClock)
 386             IReferenceClock_Release(This->pClock);
 387         This->pClock = pClock;
 388         if (This->pClock)
 389             IReferenceClock_AddRef(This->pClock);
 390     }
 391     LeaveCriticalSection(&This->csFilter);
 392
 393     return S_OK;
 394 }
 395
 396 static HRESULT WINAPI AVISplitter_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock)
 397 {
 398     AVISplitter *This = (AVISplitter *)iface;
 399
 400     TRACE("(%p)\n", ppClock);
 401
 402     EnterCriticalSection(&This->csFilter);
 403     {
 404         *ppClock = This->pClock;
 405         if (This->pClock)
 406             IReferenceClock_AddRef(This->pClock);
 407     }
 408     LeaveCriticalSection(&This->csFilter);
 409
 410     return S_OK;
 411 }
 412
 413 /** IBaseFilter implementation **/
 414
 415 static HRESULT WINAPI AVISplitter_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum)
 416 {
 417     ENUMPINDETAILS epd;
 418     AVISplitter *This = (AVISplitter *)iface;
 419
 420     TRACE("(%p)\n", ppEnum);
 421
 422     epd.cPins = This->cStreams + 1; /* +1 for input pin */
 423     epd.ppPins = This->ppPins;
 424     return IEnumPinsImpl_Construct(&epd, ppEnum);
 425 }
 426
 427 static HRESULT WINAPI AVISplitter_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin)
 428 {
 429     FIXME("AVISplitter::FindPin(...)\n");
 430
 431     /* FIXME: critical section */
 432
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI AVISplitter_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo)
 437 {
 438     AVISplitter *This = (AVISplitter *)iface;
 439
 440     TRACE("(%p)\n", pInfo);
 441
 442     strcpyW(pInfo->achName, This->filterInfo.achName);
 443     pInfo->pGraph = This->filterInfo.pGraph;
 444
 445     if (pInfo->pGraph)
 446         IFilterGraph_AddRef(pInfo->pGraph);
 447
 448     return S_OK;
 449 }
 450
 451 static HRESULT WINAPI AVISplitter_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 452 {
 453     HRESULT hr = S_OK;
 454     AVISplitter *This = (AVISplitter *)iface;
 455
 456     TRACE("(%p, %s)\n", pGraph, debugstr_w(pName));
 457
 458     EnterCriticalSection(&This->csFilter);
 459     {
 460         if (pName)
 461             strcpyW(This->filterInfo.achName, pName);
 462         else
 463             *This->filterInfo.achName = '\0';
 464         This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */
 465     }
 466     LeaveCriticalSection(&This->csFilter);
 467
 468     return hr;
 469 }
 470
 471 static HRESULT WINAPI AVISplitter_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo)
 472 {
 473     TRACE("(%p)\n", pVendorInfo);
 474     return E_NOTIMPL;
 475 }
 476
 477 static const IBaseFilterVtbl AVISplitter_Vtbl =
 478 {
 479     AVISplitter_QueryInterface,
 480     AVISplitter_AddRef,
 481     AVISplitter_Release,
 482     AVISplitter_GetClassID,
 483     AVISplitter_Stop,
 484     AVISplitter_Pause,
 485     AVISplitter_Run,
 486     AVISplitter_GetState,
 487     AVISplitter_SetSyncSource,
 488     AVISplitter_GetSyncSource,
 489     AVISplitter_EnumPins,
 490     AVISplitter_FindPin,
 491     AVISplitter_QueryFilterInfo,
 492     AVISplitter_JoinFilterGraph,
 493     AVISplitter_QueryVendorInfo
 494 };
 495
 496 static HRESULT AVISplitter_NextChunk(LONGLONG * pllCurrentChunkOffset, RIFFCHUNK * pCurrentChunk, const REFERENCE_TIME * tStart, const REFERENCE_TIME * tStop, const BYTE * pbSrcStream)
 497 {
 498     *pllCurrentChunkOffset += MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK) + RIFFROUND(pCurrentChunk->cb));
 499
 500     if (*pllCurrentChunkOffset > *tStop)
 501         return S_FALSE; /* no more data - we couldn't even get the next chunk header! */
 502     else if (*pllCurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) >= *tStop)
 503     {
 504         memcpy(pCurrentChunk, pbSrcStream + (DWORD)BYTES_FROM_MEDIATIME(*pllCurrentChunkOffset - *tStart), (DWORD)BYTES_FROM_MEDIATIME(*tStop - *pllCurrentChunkOffset));
 505         return S_FALSE; /* no more data */
 506     }
 507     else
 508         memcpy(pCurrentChunk, pbSrcStream + (DWORD)BYTES_FROM_MEDIATIME(*pllCurrentChunkOffset - *tStart), sizeof(RIFFCHUNK));
 509
 510     return S_OK;
 511 }
 512
 513 static HRESULT AVISplitter_Sample(LPVOID iface, IMediaSample * pSample)
 514 {
 515     AVISplitter *This = (AVISplitter *)iface;
 516     LPBYTE pbSrcStream = NULL;
 517     long cbSrcStream = 0;
 518     REFERENCE_TIME tStart, tStop;
 519     HRESULT hr;
 520     BOOL bMoreData = TRUE;
 521
 522     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 523
 524     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 525
 526     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 527
 528     /* trace removed for performance reasons */
 529 /*  TRACE("(%p)\n", pSample); */
 530
 531     assert(BYTES_FROM_MEDIATIME(tStop - tStart) == cbSrcStream);
 532
 533     if (This->CurrentChunkOffset <= tStart && This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) > tStart)
 534     {
 535         DWORD offset = (DWORD)BYTES_FROM_MEDIATIME(tStart - This->CurrentChunkOffset);
 536         assert(offset <= sizeof(RIFFCHUNK));
 537         memcpy((BYTE *)&This->CurrentChunk + offset, pbSrcStream, sizeof(RIFFCHUNK) - offset);
 538     }
 539     else if (This->CurrentChunkOffset > tStart)
 540     {
 541         DWORD offset = (DWORD)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart);
 542         if (offset >= (DWORD)cbSrcStream)
 543         {
 544             FIXME("large offset\n");
 545             return S_OK;
 546         }
 547
 548         memcpy(&This->CurrentChunk, pbSrcStream + offset, sizeof(RIFFCHUNK));
 549     }
 550
 551     assert(This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(sizeof(RIFFCHUNK)) < tStop);
 552
 553     while (bMoreData)
 554     {
 555         BYTE * pbDstStream;
 556         long cbDstStream;
 557         long chunk_remaining_bytes = 0;
 558         long offset_src;
 559         WORD streamId;
 560         AVISplitter_OutputPin * pOutputPin;
 561         BOOL bSyncPoint = TRUE;
 562
 563         if (This->CurrentChunkOffset >= tStart)
 564             offset_src = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart) + sizeof(RIFFCHUNK);
 565         else
 566             offset_src = 0;
 567
 568         switch (This->CurrentChunk.fcc)
 569         {
 570         case ckidJUNK:
 571         case aviFCC('i','d','x','1'): /* Index is not handled */
 572             /* silently ignore */
 573             if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream))
 574                 bMoreData = FALSE;
 575             continue;
 576         case ckidLIST:
 577             /* We only handle the 'rec ' list which contains the stream data */
 578             if ((*(DWORD*)(pbSrcStream + BYTES_FROM_MEDIATIME(This->CurrentChunkOffset-tStart) + sizeof(RIFFCHUNK))) == aviFCC('r','e','c',' '))
 579             {
 580                 /* FIXME: We only advanced to the first chunk inside the list without keeping track that we are in it.
 581                  *        This is not clean and the parser should be improved for that but it is enough for most AVI files. */
 582                 This->CurrentChunkOffset = MEDIATIME_FROM_BYTES(BYTES_FROM_MEDIATIME(This->CurrentChunkOffset) + sizeof(RIFFLIST));
 583                 This->CurrentChunk = *(RIFFCHUNK*) (pbSrcStream + BYTES_FROM_MEDIATIME(This->CurrentChunkOffset-tStart));
 584                 offset_src = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset - tStart) + sizeof(RIFFCHUNK);
 585                 break;
 586             }
 587             else if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream))
 588                 bMoreData = FALSE;
 589             continue;
 590         default:
 591             break;
 592 #if 0 /* According to the AVI specs, a stream data chunk should be ABXX where AB is the stream number and X means don't care */
 593             switch (TWOCCFromFOURCC(This->CurrentChunk.fcc))
 594             {
 595             case cktypeDIBcompressed:
 596                 bSyncPoint = FALSE;
 597                 /* fall-through */
 598             case cktypeDIBbits:
 599                 /* FIXME: check that pin is of type video */
 600                 break;
 601             case cktypeWAVEbytes:
 602                 /* FIXME: check that pin is of type audio */
 603                 break;
 604             case cktypePALchange:
 605                 FIXME("handle palette change\n");
 606                 break;
 607             default:
 608                 FIXME("Skipping unknown chunk type: %s at file offset 0x%lx\n", debugstr_an((LPSTR)&This->CurrentChunk.fcc, 4), (DWORD)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset));
 609                 if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream))
 610                     bMoreData = FALSE;
 611                 continue;
 612             }
 613 #endif
 614         }
 615
 616         streamId = StreamFromFOURCC(This->CurrentChunk.fcc);
 617
 618         if (streamId > This->cStreams)
 619         {
 620             ERR("Corrupted AVI file (contains stream id %d, but supposed to only have %ld streams)\n", streamId, This->cStreams);
 621             return E_FAIL;
 622         }
 623
 624         pOutputPin = (AVISplitter_OutputPin *)This->ppPins[streamId + 1];
 625
 626         if (!This->pCurrentSample)
 627         {
 628             /* cache media sample until it is ready to be despatched
 629              * (i.e. we reach the end of the chunk) */
 630             hr = OutputPin_GetDeliveryBuffer(&pOutputPin->pin, &This->pCurrentSample, NULL, NULL, 0);
 631
 632             if (SUCCEEDED(hr))
 633             {
 634                 hr = IMediaSample_SetActualDataLength(This->pCurrentSample, 0);
 635                 assert(hr == S_OK);
 636             }
 637             else
 638             {
 639                 TRACE("Skipping sending sample for stream %02d due to error (%lx)\n", streamId, hr);
 640                 This->pCurrentSample = NULL;
 641                 if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream))
 642                     bMoreData = FALSE;
 643                 continue;
 644             }
 645         }
 646
 647         hr = IMediaSample_GetPointer(This->pCurrentSample, &pbDstStream);
 648
 649         if (SUCCEEDED(hr))
 650         {
 651             cbDstStream = IMediaSample_GetSize(This->pCurrentSample);
 652
 653             chunk_remaining_bytes = (long)BYTES_FROM_MEDIATIME(This->CurrentChunkOffset + MEDIATIME_FROM_BYTES(This->CurrentChunk.cb + sizeof(RIFFCHUNK)) - tStart) - offset_src;
 654
 655             assert(chunk_remaining_bytes >= 0);
 656             assert(chunk_remaining_bytes <= cbDstStream - IMediaSample_GetActualDataLength(This->pCurrentSample));
 657
 658             /* trace removed for performance reasons */
 659 /*          TRACE("chunk_remaining_bytes: 0x%lx, cbSrcStream: 0x%lx, offset_src: 0x%lx\n", chunk_remaining_bytes, cbSrcStream, offset_src); */
 660         }
 661
 662         if (chunk_remaining_bytes <= cbSrcStream - offset_src)
 663         {
 664             if (SUCCEEDED(hr))
 665             {
 666                 memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, chunk_remaining_bytes);
 667                 hr = IMediaSample_SetActualDataLength(This->pCurrentSample, chunk_remaining_bytes + IMediaSample_GetActualDataLength(This->pCurrentSample));
 668                 assert(hr == S_OK);
 669             }
 670
 671             if (SUCCEEDED(hr))
 672             {
 673                 REFERENCE_TIME tAviStart, tAviStop;
 674
 675                 /* FIXME: hack */
 676                 if (pOutputPin->dwSamplesProcessed == 0)
 677                     IMediaSample_SetDiscontinuity(This->pCurrentSample, TRUE);
 678
 679                 IMediaSample_SetSyncPoint(This->pCurrentSample, bSyncPoint);
 680
 681                 pOutputPin->dwSamplesProcessed++;
 682
 683                 if (pOutputPin->dwSampleSize)
 684                     tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec));
 685                 else
 686                     tAviStart = (LONGLONG)ceil(10000000.0 * (float)(pOutputPin->dwSamplesProcessed - 1) / (float)pOutputPin->fSamplesPerSec);
 687                 if (pOutputPin->dwSampleSize)
 688                     tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed * (float)IMediaSample_GetActualDataLength(This->pCurrentSample) / ((float)pOutputPin->dwSampleSize * pOutputPin->fSamplesPerSec));
 689                 else
 690                     tAviStop = (LONGLONG)ceil(10000000.0 * (float)pOutputPin->dwSamplesProcessed / (float)pOutputPin->fSamplesPerSec);
 691
 692                 IMediaSample_SetTime(This->pCurrentSample, &tAviStart, &tAviStop);
 693
 694                 hr = OutputPin_SendSample(&pOutputPin->pin, This->pCurrentSample);
 695                 if (hr != S_OK && hr != VFW_E_NOT_CONNECTED)
 696                     ERR("Error sending sample (%lx)\n", hr);
 697             }
 698
 699             if (This->pCurrentSample)
 700                 IMediaSample_Release(This->pCurrentSample);
 701
 702             This->pCurrentSample = NULL;
 703
 704             if (S_FALSE == AVISplitter_NextChunk(&This->CurrentChunkOffset, &This->CurrentChunk, &tStart, &tStop, pbSrcStream))
 705                 bMoreData = FALSE;
 706         }
 707         else
 708         {
 709             if (SUCCEEDED(hr))
 710             {
 711                 memcpy(pbDstStream + IMediaSample_GetActualDataLength(This->pCurrentSample), pbSrcStream + offset_src, cbSrcStream - offset_src);
 712                 IMediaSample_SetActualDataLength(This->pCurrentSample, cbSrcStream - offset_src + IMediaSample_GetActualDataLength(This->pCurrentSample));
 713             }
 714             bMoreData = FALSE;
 715         }
 716     }
 717     return hr;
 718 }
 719
 720 static HRESULT AVISplitter_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
 721 {
 722     if (IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream) && IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_Avi))
 723         return S_OK;
 724     return S_FALSE;
 725 }
 726
 727 static HRESULT AVISplitter_ProcessStreamList(AVISplitter * This, const BYTE * pData, DWORD cb)
 728 {
 729     PIN_INFO piOutput;
 730     const RIFFCHUNK * pChunk;
 731     IPin ** ppOldPins;
 732     HRESULT hr;
 733     AM_MEDIA_TYPE amt;
 734     float fSamplesPerSec = 0.0f;
 735     DWORD dwSampleSize = 0;
 736     DWORD dwLength = 0;
 737     ALLOCATOR_PROPERTIES props;
 738     static const WCHAR wszStreamTemplate[] = {'S','t','r','e','a','m',' ','%','0','2','d',0};
 739
 740     props.cbAlign = 1;
 741     props.cbPrefix = 0;
 742     props.cbBuffer = 0x20000;
 743     props.cBuffers = 2;
 744
 745     ZeroMemory(&amt, sizeof(amt));
 746     piOutput.dir = PINDIR_OUTPUT;
 747     piOutput.pFilter = (IBaseFilter *)This;
 748     wsprintfW(piOutput.achName, wszStreamTemplate, This->cStreams);
 749
 750     for (pChunk = (const RIFFCHUNK *)pData;
 751          ((const BYTE *)pChunk >= pData) && ((const BYTE *)pChunk + sizeof(RIFFCHUNK) < pData + cb) && (pChunk->cb > 0);
 752          pChunk = (const RIFFCHUNK *)((const BYTE*)pChunk + sizeof(RIFFCHUNK) + pChunk->cb)
 753         )
 754     {
 755         switch (pChunk->fcc)
 756         {
 757         case ckidSTREAMHEADER:
 758             {
 759                 const AVISTREAMHEADER * pStrHdr = (const AVISTREAMHEADER *)pChunk;
 760                 TRACE("processing stream header\n");
 761
 762                 fSamplesPerSec = (float)pStrHdr->dwRate / (float)pStrHdr->dwScale;
 763
 764                 switch (pStrHdr->fccType)
 765                 {
 766                 case streamtypeVIDEO:
 767                     memcpy(&amt.formattype, &FORMAT_VideoInfo, sizeof(GUID));
 768                     amt.pbFormat = NULL;
 769                     amt.cbFormat = 0;
 770                     break;
 771                 case streamtypeAUDIO:
 772                     memcpy(&amt.formattype, &FORMAT_WaveFormatEx, sizeof(GUID));
 773                     break;
 774                 default:
 775                     memcpy(&amt.formattype, &FORMAT_None, sizeof(GUID));
 776                 }
 777                 memcpy(&amt.majortype, &MEDIATYPE_Video, sizeof(GUID));
 778                 amt.majortype.Data1 = pStrHdr->fccType;
 779                 memcpy(&amt.subtype, &MEDIATYPE_Video, sizeof(GUID));
 780                 amt.subtype.Data1 = pStrHdr->fccHandler;
 781                 TRACE("Subtype FCC: %.04s\n", (LPCSTR)&pStrHdr->fccHandler);
 782                 amt.lSampleSize = pStrHdr->dwSampleSize;
 783                 amt.bFixedSizeSamples = (amt.lSampleSize != 0);
 784
 785                 /* FIXME: Is this right? */
 786                 if (!amt.lSampleSize)
 787                 {
 788                     amt.lSampleSize = 1;
 789                     dwSampleSize = 1;
 790                 }
 791
 792                 amt.bTemporalCompression = IsEqualGUID(&amt.majortype, &MEDIATYPE_Video); /* FIXME? */
 793                 dwSampleSize = pStrHdr->dwSampleSize;
 794                 dwLength = pStrHdr->dwLength;
 795                 if (!dwLength)
 796                     dwLength = This->AviHeader.dwTotalFrames;
 797
 798                 if (pStrHdr->dwSuggestedBufferSize)
 799                     props.cbBuffer = pStrHdr->dwSuggestedBufferSize;
 800
 801                 break;
 802             }
 803         case ckidSTREAMFORMAT:
 804             TRACE("processing stream format data\n");
 805             if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo))
 806             {
 807                 VIDEOINFOHEADER * pvi;
 808                 /* biCompression member appears to override the value in the stream header.
 809                  * i.e. the stream header can say something completely contradictory to what
 810                  * is in the BITMAPINFOHEADER! */
 811                 if (pChunk->cb < sizeof(BITMAPINFOHEADER))
 812                 {
 813                     ERR("Not enough bytes for BITMAPINFOHEADER\n");
 814                     return E_FAIL;
 815                 }
 816                 amt.cbFormat = sizeof(VIDEOINFOHEADER) - sizeof(BITMAPINFOHEADER) + pChunk->cb;
 817                 amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
 818                 ZeroMemory(amt.pbFormat, amt.cbFormat);
 819                 pvi = (VIDEOINFOHEADER *)amt.pbFormat;
 820                 pvi->AvgTimePerFrame = (LONGLONG)(10000000.0 / fSamplesPerSec);
 821                 CopyMemory(&pvi->bmiHeader, (const BYTE *)(pChunk + 1), pChunk->cb);
 822                 if (pvi->bmiHeader.biCompression)
 823                     amt.subtype.Data1 = pvi->bmiHeader.biCompression;
 824             }
 825             else
 826             {
 827                 amt.cbFormat = pChunk->cb;
 828                 amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
 829                 CopyMemory(amt.pbFormat, (const BYTE *)(pChunk + 1), amt.cbFormat);
 830             }
 831             break;
 832         case ckidSTREAMNAME:
 833             TRACE("processing stream name\n");
 834             /* FIXME: this doesn't exactly match native version (we omit the "##)" prefix), but hey... */
 835             MultiByteToWideChar(CP_ACP, 0, (LPCSTR)(pChunk + 1), pChunk->cb, piOutput.achName, sizeof(piOutput.achName) / sizeof(piOutput.achName[0]));
 836             break;
 837         case ckidSTREAMHANDLERDATA:
 838             FIXME("process stream handler data\n");
 839             break;
 840         case ckidJUNK:
 841             TRACE("JUNK chunk ignored\n");
 842             break;
 843         default:
 844             FIXME("unknown chunk type \"%.04s\" ignored\n", (LPCSTR)&pChunk->fcc);
 845         }
 846     }
 847
 848     if (IsEqualGUID(&amt.formattype, &FORMAT_WaveFormatEx))
 849     {
 850         memcpy(&amt.subtype, &MEDIATYPE_Video, sizeof(GUID));
 851         amt.subtype.Data1 = ((WAVEFORMATEX *)amt.pbFormat)->wFormatTag;
 852     }
 853
 854     dump_AM_MEDIA_TYPE(&amt);
 855     TRACE("fSamplesPerSec = %f\n", (double)fSamplesPerSec);
 856     TRACE("dwSampleSize = %lx\n", dwSampleSize);
 857     TRACE("dwLength = %lx\n", dwLength);
 858
 859     ppOldPins = This->ppPins;
 860
 861     This->ppPins = HeapAlloc(GetProcessHeap(), 0, (This->cStreams + 2) * sizeof(IPin *));
 862     memcpy(This->ppPins, ppOldPins, (This->cStreams + 1) * sizeof(IPin *));
 863
 864     hr = AVISplitter_OutputPin_Construct(&piOutput, &props, NULL, AVISplitter_OutputPin_QueryAccept, &amt, fSamplesPerSec, &This->csFilter, This->ppPins + This->cStreams + 1);
 865
 866     if (SUCCEEDED(hr))
 867     {
 868         ((AVISplitter_OutputPin *)(This->ppPins[This->cStreams + 1]))->dwSampleSize = dwSampleSize;
 869         ((AVISplitter_OutputPin *)(This->ppPins[This->cStreams + 1]))->dwLength = dwLength;
 870         ((AVISplitter_OutputPin *)(This->ppPins[This->cStreams + 1]))->pin.pin.pUserData = (LPVOID)This->ppPins[This->cStreams + 1];
 871         This->cStreams++;
 872         HeapFree(GetProcessHeap(), 0, ppOldPins);
 873     }
 874     else
 875     {
 876         HeapFree(GetProcessHeap(), 0, This->ppPins);
 877         This->ppPins = ppOldPins;
 878         ERR("Failed with error %lx\n", hr);
 879     }
 880
 881     return hr;
 882 }
 883
 884 static HRESULT AVISplitter_RemoveOutputPins(AVISplitter * This)
 885 {
 886     /* NOTE: should be in critical section when calling this function */
 887
 888     ULONG i;
 889     IPin ** ppOldPins = This->ppPins;
 890
 891     /* reduce the pin array down to 1 (just our input pin) */
 892     This->ppPins = HeapAlloc(GetProcessHeap(), 0, sizeof(IPin *) * 1);
 893     memcpy(This->ppPins, ppOldPins, sizeof(IPin *) * 1);
 894
 895     for (i = 0; i < This->cStreams; i++)
 896     {
 897         OutputPin_DeliverDisconnect((OutputPin *)ppOldPins[i + 1]);
 898         IPin_Release(ppOldPins[i + 1]);
 899     }
 900
 901     This->cStreams = 0;
 902     HeapFree(GetProcessHeap(), 0, ppOldPins);
 903
 904     return S_OK;
 905 }
 906
 907 /* FIXME: fix leaks on failure here */
 908 static HRESULT AVISplitter_InputPin_PreConnect(IPin * iface, IPin * pConnectPin)
 909 {
 910     PullPin *This = (PullPin *)iface;
 911     HRESULT hr;
 912     RIFFLIST list;
 913     LONGLONG pos = 0; /* in bytes */
 914     BYTE * pBuffer;
 915     RIFFCHUNK * pCurrentChunk;
 916     AVISplitter * pAviSplit = (AVISplitter *)This->pin.pinInfo.pFilter;
 917
 918     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
 919     pos += sizeof(list);
 920
 921     if (list.fcc != ckidRIFF)
 922     {
 923         ERR("Input stream not a RIFF file\n");
 924         return E_FAIL;
 925     }
 926     if (list.cb > 1 * 1024 * 1024 * 1024) /* cannot be more than 1Gb in size */
 927     {
 928         ERR("Input stream violates RIFF spec\n");
 929         return E_FAIL;
 930     }
 931     if (list.fccListType != ckidAVI)
 932     {
 933         ERR("Input stream not an AVI RIFF file\n");
 934         return E_FAIL;
 935     }
 936
 937     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
 938     if (list.fcc != ckidLIST)
 939     {
 940         ERR("Expected LIST chunk, but got %.04s\n", (LPSTR)&list.fcc);
 941         return E_FAIL;
 942     }
 943     if (list.fccListType != ckidHEADERLIST)
 944     {
 945         ERR("Header list expected. Got: %.04s\n", (LPSTR)&list.fccListType);
 946         return E_FAIL;
 947     }
 948
 949     pBuffer = HeapAlloc(GetProcessHeap(), 0, list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK));
 950     hr = IAsyncReader_SyncRead(This->pReader, pos + sizeof(list), list.cb - sizeof(RIFFLIST) + sizeof(RIFFCHUNK), pBuffer);
 951
 952     pAviSplit->AviHeader.cb = 0;
 953
 954     for (pCurrentChunk = (RIFFCHUNK *)pBuffer; (BYTE *)pCurrentChunk + sizeof(*pCurrentChunk) < pBuffer + list.cb; pCurrentChunk = (RIFFCHUNK *)(((BYTE *)pCurrentChunk) + sizeof(*pCurrentChunk) + pCurrentChunk->cb))
 955     {
 956         RIFFLIST * pList;
 957
 958         switch (pCurrentChunk->fcc)
 959         {
 960         case ckidMAINAVIHEADER:
 961             /* AVIMAINHEADER includes the structure that is pCurrentChunk at the moment */
 962             memcpy(&pAviSplit->AviHeader, pCurrentChunk, sizeof(pAviSplit->AviHeader));
 963             break;
 964         case ckidLIST:
 965             pList = (RIFFLIST *)pCurrentChunk;
 966             switch (pList->fccListType)
 967             {
 968             case ckidSTREAMLIST:
 969                 hr = AVISplitter_ProcessStreamList(pAviSplit, (BYTE *)pCurrentChunk + sizeof(RIFFLIST), pCurrentChunk->cb + sizeof(RIFFCHUNK) - sizeof(RIFFLIST));
 970                 break;
 971             case ckidODML:
 972                 FIXME("process ODML header\n");
 973                 break;
 974             }
 975             break;
 976         case ckidJUNK:
 977             /* ignore */
 978             break;
 979         default:
 980             FIXME("unrecognised header list type: %.04s\n", (LPSTR)&pCurrentChunk->fcc);
 981         }
 982     }
 983     HeapFree(GetProcessHeap(), 0, pBuffer);
 984
 985     if (pAviSplit->AviHeader.cb != sizeof(pAviSplit->AviHeader) - sizeof(RIFFCHUNK))
 986     {
 987         ERR("Avi Header wrong size!\n");
 988         return E_FAIL;
 989     }
 990
 991     pos += sizeof(RIFFCHUNK) + list.cb;
 992     hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
 993
 994     if (list.fcc == ckidJUNK)
 995     {
 996         pos += sizeof(RIFFCHUNK) + list.cb;
 997         hr = IAsyncReader_SyncRead(This->pReader, pos, sizeof(list), (BYTE *)&list);
 998     }
 999
1000     if (list.fcc != ckidLIST)
1001     {
1002         ERR("Expected LIST, but got %.04s\n", (LPSTR)&list.fcc);
1003         return E_FAIL;
1004     }
1005     if (list.fccListType != ckidAVIMOVIE)
1006     {
1007         ERR("Expected AVI movie list, but got %.04s\n", (LPSTR)&list.fccListType);
1008         return E_FAIL;
1009     }
1010
1011     if (hr == S_OK)
1012     {
1013         pAviSplit->CurrentChunkOffset = MEDIATIME_FROM_BYTES(pos + sizeof(RIFFLIST));
1014         pAviSplit->EndOfFile = MEDIATIME_FROM_BYTES(pos + list.cb + sizeof(RIFFLIST));
1015         hr = IAsyncReader_SyncRead(This->pReader, BYTES_FROM_MEDIATIME(pAviSplit->CurrentChunkOffset), sizeof(pAviSplit->CurrentChunk), (BYTE *)&pAviSplit->CurrentChunk);
1016     }
1017
1018     if (hr != S_OK)
1019         return E_FAIL;
1020
1021     TRACE("AVI File ok\n");
1022
1023     return hr;
1024 }
1025
1026 static HRESULT AVISplitter_ChangeStart(LPVOID iface)
1027 {
1028     FIXME("(%p)\n", iface);
1029     return S_OK;
1030 }
1031
1032 static HRESULT AVISplitter_ChangeStop(LPVOID iface)
1033 {
1034     FIXME("(%p)\n", iface);
1035     return S_OK;
1036 }
1037
1038 static HRESULT AVISplitter_ChangeRate(LPVOID iface)
1039 {
1040     FIXME("(%p)\n", iface);
1041     return S_OK;
1042 }
1043
1044
1045 static HRESULT WINAPI AVISplitter_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
1046 {
1047     ICOM_THIS_From_IMediaSeeking(AVISplitter_OutputPin, iface);
1048
1049     return IUnknown_QueryInterface((IUnknown *)This, riid, ppv);
1050 }
1051
1052 static ULONG WINAPI AVISplitter_Seeking_AddRef(IMediaSeeking * iface)
1053 {
1054     ICOM_THIS_From_IMediaSeeking(AVISplitter_OutputPin, iface);
1055
1056     return IUnknown_AddRef((IUnknown *)This);
1057 }
1058
1059 static ULONG WINAPI AVISplitter_Seeking_Release(IMediaSeeking * iface)
1060 {
1061     ICOM_THIS_From_IMediaSeeking(AVISplitter_OutputPin, iface);
1062
1063     return IUnknown_Release((IUnknown *)This);
1064 }
1065
1066 static const IMediaSeekingVtbl AVISplitter_Seeking_Vtbl =
1067 {
1068     AVISplitter_Seeking_QueryInterface,
1069     AVISplitter_Seeking_AddRef,
1070     AVISplitter_Seeking_Release,
1071     MediaSeekingImpl_GetCapabilities,
1072     MediaSeekingImpl_CheckCapabilities,
1073     MediaSeekingImpl_IsFormatSupported,
1074     MediaSeekingImpl_QueryPreferredFormat,
1075     MediaSeekingImpl_GetTimeFormat,
1076     MediaSeekingImpl_IsUsingTimeFormat,
1077     MediaSeekingImpl_SetTimeFormat,
1078     MediaSeekingImpl_GetDuration,
1079     MediaSeekingImpl_GetStopPosition,
1080     MediaSeekingImpl_GetCurrentPosition,
1081     MediaSeekingImpl_ConvertTimeFormat,
1082     MediaSeekingImpl_SetPositions,
1083     MediaSeekingImpl_GetPositions,
1084     MediaSeekingImpl_GetAvailable,
1085     MediaSeekingImpl_SetRate,
1086     MediaSeekingImpl_GetRate,
1087     MediaSeekingImpl_GetPreroll
1088 };
1089
1090 HRESULT WINAPI AVISplitter_OutputPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
1091 {
1092     AVISplitter_OutputPin *This = (AVISplitter_OutputPin *)iface;
1093
1094     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
1095
1096     *ppv = NULL;
1097
1098     if (IsEqualIID(riid, &IID_IUnknown))
1099         *ppv = (LPVOID)iface;
1100     else if (IsEqualIID(riid, &IID_IPin))
1101         *ppv = (LPVOID)iface;
1102     else if (IsEqualIID(riid, &IID_IMediaSeeking))
1103         *ppv = (LPVOID)&This->mediaSeeking;
1104
1105     if (*ppv)
1106     {
1107         IUnknown_AddRef((IUnknown *)(*ppv));
1108         return S_OK;
1109     }
1110
1111     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
1112
1113     return E_NOINTERFACE;
1114 }
1115
1116 static ULONG WINAPI AVISplitter_OutputPin_Release(IPin * iface)
1117 {
1118     AVISplitter_OutputPin *This = (AVISplitter_OutputPin *)iface;
1119
1120     TRACE("()\n");
1121
1122     if (!InterlockedDecrement(&This->pin.pin.refCount))
1123     {
1124         DeleteMediaType(This->pmt);
1125         CoTaskMemFree(This->pmt);
1126         DeleteMediaType(&This->pin.pin.mtCurrent);
1127         CoTaskMemFree(This);
1128         return 0;
1129     }
1130     return This->pin.pin.refCount;
1131 }
1132
1133 static HRESULT WINAPI AVISplitter_OutputPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum)
1134 {
1135     ENUMMEDIADETAILS emd;
1136     AVISplitter_OutputPin *This = (AVISplitter_OutputPin *)iface;
1137
1138     TRACE("(%p)\n", ppEnum);
1139
1140     /* override this method to allow enumeration of your types */
1141     emd.cMediaTypes = 1;
1142     emd.pMediaTypes = This->pmt;
1143
1144     return IEnumMediaTypesImpl_Construct(&emd, ppEnum);
1145 }
1146
1147 static HRESULT AVISplitter_OutputPin_QueryAccept(LPVOID iface, const AM_MEDIA_TYPE * pmt)
1148 {
1149     AVISplitter_OutputPin *This = (AVISplitter_OutputPin *)iface;
1150
1151     TRACE("()\n");
1152     dump_AM_MEDIA_TYPE(pmt);
1153
1154     return (memcmp(This->pmt, pmt, sizeof(AM_MEDIA_TYPE)) == 0);
1155 }
1156
1157 static const IPinVtbl AVISplitter_OutputPin_Vtbl =
1158 {
1159     AVISplitter_OutputPin_QueryInterface,
1160     IPinImpl_AddRef,
1161     AVISplitter_OutputPin_Release,
1162     OutputPin_Connect,
1163     OutputPin_ReceiveConnection,
1164     OutputPin_Disconnect,
1165     IPinImpl_ConnectedTo,
1166     IPinImpl_ConnectionMediaType,
1167     IPinImpl_QueryPinInfo,
1168     IPinImpl_QueryDirection,
1169     IPinImpl_QueryId,
1170     IPinImpl_QueryAccept,
1171     AVISplitter_OutputPin_EnumMediaTypes,
1172     IPinImpl_QueryInternalConnections,
1173     OutputPin_EndOfStream,
1174     OutputPin_BeginFlush,
1175     OutputPin_EndFlush,
1176     OutputPin_NewSegment
1177 };
1178
1179 static HRESULT AVISplitter_InputPin_Construct(const PIN_INFO * pPinInfo, SAMPLEPROC pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, IPin ** ppPin)
1180 {
1181     PullPin * pPinImpl;
1182
1183     *ppPin = NULL;
1184
1185     if (pPinInfo->dir != PINDIR_INPUT)
1186     {
1187         ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
1188         return E_INVALIDARG;
1189     }
1190
1191     pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
1192
1193     if (!pPinImpl)
1194         return E_OUTOFMEMORY;
1195
1196     if (SUCCEEDED(PullPin_Init(pPinInfo, pSampleProc, pUserData, pQueryAccept, pCritSec, pPinImpl)))
1197     {
1198         pPinImpl->pin.lpVtbl = &AVISplitter_InputPin_Vtbl;
1199
1200         *ppPin = (IPin *)(&pPinImpl->pin.lpVtbl);
1201         return S_OK;
1202     }
1203     return E_FAIL;
1204 }
1205
1206 static HRESULT WINAPI AVISplitter_InputPin_Disconnect(IPin * iface)
1207 {
1208     HRESULT hr;
1209     IPinImpl *This = (IPinImpl *)iface;
1210
1211     TRACE("()\n");
1212
1213     EnterCriticalSection(This->pCritSec);
1214     {
1215         if (This->pConnectedTo)
1216         {
1217             FILTER_STATE state;
1218
1219             hr = IBaseFilter_GetState(This->pinInfo.pFilter, 0, &state);
1220
1221             if (SUCCEEDED(hr) && (state == State_Stopped))
1222             {
1223                 IPin_Release(This->pConnectedTo);
1224                 This->pConnectedTo = NULL;
1225                 hr = AVISplitter_RemoveOutputPins((AVISplitter *)This->pinInfo.pFilter);
1226             }
1227             else
1228                 hr = VFW_E_NOT_STOPPED;
1229         }
1230         else
1231             hr = S_FALSE;
1232     }
1233     LeaveCriticalSection(This->pCritSec);
1234
1235     return hr;
1236 }
1237
1238 static const IPinVtbl AVISplitter_InputPin_Vtbl =
1239 {
1240     PullPin_QueryInterface,
1241     IPinImpl_AddRef,
1242     PullPin_Release,
1243     OutputPin_Connect,
1244     PullPin_ReceiveConnection,
1245     AVISplitter_InputPin_Disconnect,
1246     IPinImpl_ConnectedTo,
1247     IPinImpl_ConnectionMediaType,
1248     IPinImpl_QueryPinInfo,
1249     IPinImpl_QueryDirection,
1250     IPinImpl_QueryId,
1251     IPinImpl_QueryAccept,
1252     IPinImpl_EnumMediaTypes,
1253     IPinImpl_QueryInternalConnections,
1254     PullPin_EndOfStream,
1255     PullPin_BeginFlush,
1256     PullPin_EndFlush,
1257     PullPin_NewSegment
1258 };