dlls/wineqtdecoder/qtsplitter.c

   1 /*
   2  * QuickTime splitter + decoder
   3  *
   4  * Copyright 2011 Aric Stewart for CodeWeavers
   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 #define ULONG CoreFoundation_ULONG
  24 #define HRESULT CoreFoundation_HRESULT
  25
  26 #define LoadResource __carbon_LoadResource
  27 #define CompareString __carbon_CompareString
  28 #define GetCurrentThread __carbon_GetCurrentThread
  29 #define GetCurrentProcess __carbon_GetCurrentProcess
  30 #define AnimatePalette __carbon_AnimatePalette
  31 #define EqualRgn __carbon_EqualRgn
  32 #define FillRgn __carbon_FillRgn
  33 #define FrameRgn __carbon_FrameRgn
  34 #define GetPixel __carbon_GetPixel
  35 #define InvertRgn __carbon_InvertRgn
  36 #define LineTo __carbon_LineTo
  37 #define OffsetRgn __carbon_OffsetRgn
  38 #define PaintRgn __carbon_PaintRgn
  39 #define Polygon __carbon_Polygon
  40 #define ResizePalette __carbon_ResizePalette
  41 #define SetRectRgn __carbon_SetRectRgn
  42
  43 #define CheckMenuItem __carbon_CheckMenuItem
  44 #define DeleteMenu __carbon_DeleteMenu
  45 #define DrawMenuBar __carbon_DrawMenuBar
  46 #define EnableMenuItem __carbon_EnableMenuItem
  47 #define EqualRect __carbon_EqualRect
  48 #define FillRect __carbon_FillRect
  49 #define FrameRect __carbon_FrameRect
  50 #define GetCursor __carbon_GetCursor
  51 #define GetMenu __carbon_GetMenu
  52 #define InvertRect __carbon_InvertRect
  53 #define IsWindowVisible __carbon_IsWindowVisible
  54 #define MoveWindow __carbon_MoveWindow
  55 #define OffsetRect __carbon_OffsetRect
  56 #define PtInRect __carbon_PtInRect
  57 #define SetCursor __carbon_SetCursor
  58 #define SetRect __carbon_SetRect
  59 #define ShowCursor __carbon_ShowCursor
  60 #define ShowWindow __carbon_ShowWindow
  61 #define UnionRect __carbon_UnionRect
  62
  63 #include <QuickTime/Movies.h>
  64 #include <QuickTime/QuickTimeComponents.h>
  65
  66 #undef LoadResource
  67 #undef CompareString
  68 #undef GetCurrentThread
  69 #undef _CDECL
  70 #undef DPRINTF
  71 #undef GetCurrentProcess
  72 #undef AnimatePalette
  73 #undef EqualRgn
  74 #undef FillRgn
  75 #undef FrameRgn
  76 #undef GetPixel
  77 #undef InvertRgn
  78 #undef LineTo
  79 #undef OffsetRgn
  80 #undef PaintRgn
  81 #undef Polygon
  82 #undef ResizePalette
  83 #undef SetRectRgn
  84 #undef CheckMenuItem
  85 #undef DeleteMenu
  86 #undef DrawMenuBar
  87 #undef EnableMenuItem
  88 #undef EqualRect
  89 #undef FillRect
  90 #undef FrameRect
  91 #undef GetCursor
  92 #undef GetMenu
  93 #undef InvertRect
  94 #undef IsWindowVisible
  95 #undef MoveWindow
  96 #undef OffsetRect
  97 #undef PtInRect
  98 #undef SetCursor
  99 #undef SetRect
 100 #undef ShowCursor
 101 #undef ShowWindow
 102 #undef UnionRect
 103
 104 #undef ULONG
 105 #undef HRESULT
 106 #undef DPRINTF
 107 #undef STDMETHODCALLTYPE
 108
 109 #include <assert.h>
 110 #include <stdio.h>
 111 #include <stdarg.h>
 112
 113 #define NONAMELESSSTRUCT
 114 #define NONAMELESSUNION
 115 #define COBJMACROS
 116
 117 #include "windef.h"
 118 #include "winbase.h"
 119 #include "wtypes.h"
 120 #include "winuser.h"
 121 #include "dshow.h"
 122
 123 #include "wine/unicode.h"
 124 #include "wine/debug.h"
 125 #include "wine/strmbase.h"
 126
 127 #include "qtprivate.h"
 128
 129 WINE_DEFAULT_DEBUG_CHANNEL(qtsplitter);
 130 extern CLSID CLSID_QTSplitter;
 131
 132 typedef struct QTOutPin {
 133     BaseOutputPin pin;
 134     IQualityControl IQualityControl_iface;
 135
 136     AM_MEDIA_TYPE * pmt;
 137     OutputQueue * queue;
 138 } QTOutPin;
 139
 140 typedef struct QTInPin {
 141     BasePin pin;
 142     GUID subType;
 143
 144     IAsyncReader *pReader;
 145     IMemAllocator *pAlloc;
 146 } QTInPin;
 147
 148 typedef struct QTSplitter {
 149     BaseFilter filter;
 150
 151     QTInPin pInputPin;
 152     QTOutPin *pVideo_Pin;
 153     QTOutPin *pAudio_Pin;
 154
 155     ALLOCATOR_PROPERTIES props;
 156
 157     Movie pQTMovie;
 158     QTVisualContextRef vContext;
 159
 160     MovieAudioExtractionRef aSession;
 161     HANDLE runEvent;
 162
 163     DWORD outputSize;
 164     FILTER_STATE state;
 165     CRITICAL_SECTION csReceive;
 166
 167     SourceSeeking sourceSeeking;
 168     TimeValue movie_time;
 169     TimeValue movie_start;
 170     TimeScale movie_scale;
 171
 172     HANDLE loaderThread;
 173     HANDLE splitterThread;
 174 } QTSplitter;
 175
 176 static const IPinVtbl QT_OutputPin_Vtbl;
 177 static const IPinVtbl QT_InputPin_Vtbl;
 178 static const IBaseFilterVtbl QT_Vtbl;
 179 static const IMediaSeekingVtbl QT_Seeking_Vtbl;
 180
 181 static HRESULT QT_AddPin(QTSplitter *This, const PIN_INFO *piOutput, const AM_MEDIA_TYPE *amt, BOOL video);
 182 static HRESULT QT_RemoveOutputPins(QTSplitter *This);
 183
 184 static HRESULT WINAPI QTSplitter_ChangeStart(IMediaSeeking *iface);
 185 static HRESULT WINAPI QTSplitter_ChangeStop(IMediaSeeking *iface);
 186 static HRESULT WINAPI QTSplitter_ChangeRate(IMediaSeeking *iface);
 187
 188 static inline QTSplitter *impl_from_IMediaSeeking( IMediaSeeking *iface )
 189 {
 190     return CONTAINING_RECORD(iface, QTSplitter, sourceSeeking.IMediaSeeking_iface);
 191 }
 192
 193 static inline QTSplitter *impl_from_BaseFilter( BaseFilter *iface )
 194 {
 195     return CONTAINING_RECORD(iface, QTSplitter, filter);
 196 }
 197
 198 static inline QTSplitter *impl_from_IBaseFilter( IBaseFilter *iface )
 199 {
 200     return CONTAINING_RECORD(iface, QTSplitter, filter.IBaseFilter_iface);
 201 }
 202
 203 /*
 204  * Base Filter
 205  */
 206
 207 static IPin* WINAPI QT_GetPin(BaseFilter *iface, int pos)
 208 {
 209     QTSplitter *This = impl_from_BaseFilter(iface);
 210     TRACE("Asking for pos %x\n", pos);
 211
 212     if (pos > 2 || pos < 0)
 213         return NULL;
 214     switch (pos)
 215     {
 216         case 0:
 217             IPin_AddRef(&This->pInputPin.pin.IPin_iface);
 218             return &This->pInputPin.pin.IPin_iface;
 219         case 1:
 220             if (This->pVideo_Pin)
 221                 IPin_AddRef(&This->pVideo_Pin->pin.pin.IPin_iface);
 222             return &This->pVideo_Pin->pin.pin.IPin_iface;
 223         case 2:
 224             if (This->pAudio_Pin)
 225                 IPin_AddRef(&This->pAudio_Pin->pin.pin.IPin_iface);
 226             return &This->pAudio_Pin->pin.pin.IPin_iface;
 227         default:
 228             return NULL;
 229     }
 230 }
 231
 232 static LONG WINAPI QT_GetPinCount(BaseFilter *iface)
 233 {
 234     QTSplitter *This = impl_from_BaseFilter(iface);
 235     int c = 1;
 236     if (This->pAudio_Pin) c++;
 237     if (This->pVideo_Pin) c++;
 238     return c;
 239 }
 240
 241 static const BaseFilterFuncTable BaseFuncTable = {
 242     QT_GetPin,
 243     QT_GetPinCount
 244 };
 245
 246 IUnknown * CALLBACK QTSplitter_create(IUnknown *punkout, HRESULT *phr)
 247 {
 248     IUnknown *obj = NULL;
 249     PIN_INFO *piInput;
 250     QTSplitter *This;
 251     static const WCHAR wcsInputPinName[] = {'I','n','p','u','t',' ','P','i','n',0};
 252
 253     EnterMovies();
 254
 255     RegisterWineDataHandler();
 256
 257     This = CoTaskMemAlloc(sizeof(*This));
 258     obj = (IUnknown*)This;
 259     if (!This)
 260     {
 261         *phr = E_OUTOFMEMORY;
 262         return NULL;
 263     }
 264     ZeroMemory(This,sizeof(*This));
 265
 266     BaseFilter_Init(&This->filter, &QT_Vtbl, &CLSID_QTSplitter, (DWORD_PTR)(__FILE__ ": QTSplitter.csFilter"), &BaseFuncTable);
 267
 268     InitializeCriticalSection(&This->csReceive);
 269     This->csReceive.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__": QTSplitter.csReceive");
 270
 271     This->pVideo_Pin = NULL;
 272     This->pAudio_Pin = NULL;
 273     This->state = State_Stopped;
 274     This->aSession = NULL;
 275     This->runEvent = CreateEventW(NULL, 0, 0, NULL);
 276
 277     piInput = &This->pInputPin.pin.pinInfo;
 278     piInput->dir = PINDIR_INPUT;
 279     piInput->pFilter = &This->filter.IBaseFilter_iface;
 280     lstrcpynW(piInput->achName, wcsInputPinName, sizeof(piInput->achName) / sizeof(piInput->achName[0]));
 281     This->pInputPin.pin.IPin_iface.lpVtbl = &QT_InputPin_Vtbl;
 282     This->pInputPin.pin.refCount = 1;
 283     This->pInputPin.pin.pConnectedTo = NULL;
 284     This->pInputPin.pin.pCritSec = &This->filter.csFilter;
 285
 286     SourceSeeking_Init(&This->sourceSeeking, &QT_Seeking_Vtbl, QTSplitter_ChangeStop, QTSplitter_ChangeStart, QTSplitter_ChangeRate,  &This->filter.csFilter);
 287
 288     *phr = S_OK;
 289     return obj;
 290 }
 291
 292 static void QT_Destroy(QTSplitter *This)
 293 {
 294     IPin *connected = NULL;
 295     ULONG pinref;
 296
 297     TRACE("Destroying\n");
 298
 299     EnterCriticalSection(&This->csReceive);
 300     /* Don't need to clean up output pins, disconnecting input pin will do that */
 301     IPin_ConnectedTo(&This->pInputPin.pin.IPin_iface, &connected);
 302     if (connected)
 303     {
 304         IPin_Disconnect(connected);
 305         IPin_Release(connected);
 306     }
 307     pinref = IPin_Release(&This->pInputPin.pin.IPin_iface);
 308     if (pinref)
 309     {
 310         ERR("pinref should be null, is %u, destroying anyway\n", pinref);
 311         assert((LONG)pinref > 0);
 312
 313         while (pinref)
 314             pinref = IPin_Release(&This->pInputPin.pin.IPin_iface);
 315     }
 316
 317     if (This->pQTMovie)
 318     {
 319         DisposeMovie(This->pQTMovie);
 320         This->pQTMovie = NULL;
 321     }
 322     if (This->vContext)
 323         QTVisualContextRelease(This->vContext);
 324     if (This->aSession)
 325         MovieAudioExtractionEnd(This->aSession);
 326
 327     ExitMovies();
 328     LeaveCriticalSection(&This->csReceive);
 329
 330     if (This->loaderThread)
 331     {
 332         WaitForSingleObject(This->loaderThread, INFINITE);
 333         CloseHandle(This->loaderThread);
 334     }
 335     if (This->splitterThread)
 336     {
 337         SetEvent(This->runEvent);
 338         WaitForSingleObject(This->splitterThread, INFINITE);
 339         CloseHandle(This->splitterThread);
 340     }
 341
 342     CloseHandle(This->runEvent);
 343
 344     This->csReceive.DebugInfo->Spare[0] = 0;
 345     DeleteCriticalSection(&This->csReceive);
 346     BaseFilter_Destroy(&This->filter);
 347
 348     CoTaskMemFree(This);
 349 }
 350
 351 static HRESULT WINAPI QT_QueryInterface(IBaseFilter *iface, REFIID riid, LPVOID *ppv)
 352 {
 353     QTSplitter *This = impl_from_IBaseFilter(iface);
 354     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 355
 356     *ppv = NULL;
 357
 358     if (IsEqualIID(riid, &IID_IUnknown))
 359         *ppv = This;
 360     else if (IsEqualIID(riid, &IID_IPersist))
 361         *ppv = This;
 362     else if (IsEqualIID(riid, &IID_IMediaFilter))
 363         *ppv = This;
 364     else if (IsEqualIID(riid, &IID_IBaseFilter))
 365         *ppv = This;
 366     else if (IsEqualIID(riid, &IID_IMediaSeeking))
 367         *ppv = &This->sourceSeeking;
 368
 369     if (*ppv)
 370     {
 371         IUnknown_AddRef((IUnknown *)(*ppv));
 372         return S_OK;
 373     }
 374
 375     if (!IsEqualIID(riid, &IID_IPin) && !IsEqualIID(riid, &IID_IVideoWindow) &&
 376         !IsEqualIID(riid, &IID_IAMFilterMiscFlags))
 377         FIXME("No interface for %s!\n", debugstr_guid(riid));
 378
 379     return E_NOINTERFACE;
 380 }
 381
 382 static ULONG WINAPI QT_Release(IBaseFilter *iface)
 383 {
 384     QTSplitter *This = impl_from_IBaseFilter(iface);
 385     ULONG refCount = InterlockedDecrement(&This->filter.refCount);
 386
 387     TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 388
 389     if (!refCount)
 390         QT_Destroy(This);
 391
 392     return refCount;
 393 }
 394
 395 static HRESULT WINAPI QT_Stop(IBaseFilter *iface)
 396 {
 397     QTSplitter *This = impl_from_IBaseFilter(iface);
 398
 399     TRACE("()\n");
 400
 401     EnterCriticalSection(&This->csReceive);
 402     IAsyncReader_BeginFlush(This->pInputPin.pReader);
 403     IAsyncReader_EndFlush(This->pInputPin.pReader);
 404     LeaveCriticalSection(&This->csReceive);
 405
 406     return S_OK;
 407 }
 408
 409 static HRESULT WINAPI QT_Pause(IBaseFilter *iface)
 410 {
 411     HRESULT hr = S_OK;
 412     TRACE("()\n");
 413
 414     return hr;
 415 }
 416
 417 static OSErr QT_Create_Extract_Session(QTSplitter *filter)
 418 {
 419     AudioStreamBasicDescription aDesc;
 420     OSErr err;
 421     WAVEFORMATEX* pvi;
 422
 423     pvi = (WAVEFORMATEX*)filter->pAudio_Pin->pmt->pbFormat;
 424
 425     err = MovieAudioExtractionBegin(filter->pQTMovie, 0, &filter->aSession);
 426     if (err != noErr)
 427     {
 428         ERR("Failed to begin Extraction session %i\n",err);
 429         return err;
 430     }
 431
 432     err = MovieAudioExtractionGetProperty(filter->aSession,
 433             kQTPropertyClass_MovieAudioExtraction_Audio,
 434 kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
 435             sizeof(AudioStreamBasicDescription), &aDesc, NULL);
 436
 437     if (err != noErr)
 438     {
 439         MovieAudioExtractionEnd(filter->aSession);
 440         filter->aSession = NULL;
 441         ERR("Failed to get session description %i\n",err);
 442         return err;
 443     }
 444
 445     aDesc.mFormatID = kAudioFormatLinearPCM;
 446     aDesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger +
 447         kAudioFormatFlagIsPacked;
 448     aDesc.mFramesPerPacket = 1;
 449     aDesc.mChannelsPerFrame = pvi->nChannels;
 450     aDesc.mBitsPerChannel = pvi->wBitsPerSample;
 451     aDesc.mSampleRate = pvi->nSamplesPerSec;
 452     aDesc.mBytesPerFrame = (aDesc.mBitsPerChannel * aDesc.mChannelsPerFrame) / 8;
 453     aDesc.mBytesPerPacket = aDesc.mBytesPerFrame * aDesc.mFramesPerPacket;
 454
 455     err = MovieAudioExtractionSetProperty(filter->aSession,
 456         kQTPropertyClass_MovieAudioExtraction_Audio,
 457 kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
 458         sizeof(AudioStreamBasicDescription), &aDesc);
 459
 460     if (aDesc.mFormatID != kAudioFormatLinearPCM)
 461     {
 462         ERR("Not PCM Wave\n");
 463         err = -1;
 464     }
 465     if (aDesc.mFormatFlags != kLinearPCMFormatFlagIsSignedInteger +
 466         kAudioFormatFlagIsPacked)
 467     {
 468         ERR("Unhandled Flags\n");
 469         err = -1;
 470     }
 471     if (aDesc.mFramesPerPacket != 1)
 472     {
 473         ERR("Unhandled Frames per packet %li\n",aDesc.mFramesPerPacket);
 474         err = -1;
 475     }
 476     if (aDesc.mChannelsPerFrame != pvi->nChannels)
 477     {
 478         ERR("Unhandled channel count %li\n",aDesc.mChannelsPerFrame);
 479         err = -1;
 480     }
 481     if (aDesc.mBitsPerChannel != pvi->wBitsPerSample)
 482     {
 483         ERR("Unhandled bits per channel %li\n",aDesc.mBitsPerChannel);
 484         err = -1;
 485     }
 486     if (aDesc.mSampleRate != pvi->nSamplesPerSec)
 487     {
 488         ERR("Unhandled sample rate %f\n",aDesc.mSampleRate);
 489         err = -1;
 490     }
 491
 492     if (err != noErr)
 493     {
 494         ERR("Failed to create Extraction Session\n");
 495         MovieAudioExtractionEnd(filter->aSession);
 496         filter->aSession = NULL;
 497     }
 498
 499     return err;
 500 }
 501
 502 static DWORD WINAPI QTSplitter_loading_thread(LPVOID data)
 503 {
 504     QTSplitter *This = (QTSplitter *)data;
 505
 506     if (This->pAudio_Pin)
 507     {
 508         /* according to QA1469 a movie has to be fully loaded before we
 509            can reliably start the Extraction session.
 510
 511            If loaded earlier, then we only get an extraction session for
 512            the part of the movie that is loaded at that time.
 513
 514             We are trying to load as much of the movie as we can before we
 515             start extracting.  However we can recreate the extraction session
 516             again when we run out of loaded extraction frames. But we want
 517             to try to minimize that.
 518          */
 519
 520         EnterCriticalSection(&This->csReceive);
 521         while(This->pQTMovie && GetMovieLoadState(This->pQTMovie) < kMovieLoadStateComplete)
 522         {
 523             MoviesTask(This->pQTMovie, 100);
 524             LeaveCriticalSection(&This->csReceive);
 525             Sleep(0);
 526             EnterCriticalSection(&This->csReceive);
 527         }
 528         LeaveCriticalSection(&This->csReceive);
 529     }
 530     return 0;
 531 }
 532
 533 static DWORD WINAPI QTSplitter_thread(LPVOID data)
 534 {
 535     QTSplitter *This = (QTSplitter *)data;
 536     HRESULT hr = S_OK;
 537     TimeValue next_time;
 538     CVPixelBufferRef pixelBuffer = NULL;
 539     OSStatus err;
 540     TimeRecord tr;
 541
 542     WaitForSingleObject(This->runEvent, -1);
 543
 544     EnterCriticalSection(&This->csReceive);
 545     if (!This->pQTMovie)
 546     {
 547         LeaveCriticalSection(&This->csReceive);
 548         return 0;
 549     }
 550
 551     This->state = State_Running;
 552     /* Prime the pump:  Needed for MPEG streams */
 553     GetMovieNextInterestingTime(This->pQTMovie, nextTimeEdgeOK | nextTimeStep, 0, NULL, This->movie_time, 1, &next_time, NULL);
 554
 555     GetMovieTime(This->pQTMovie, &tr);
 556
 557     if (This->pAudio_Pin)
 558         QT_Create_Extract_Session(This);
 559
 560     LeaveCriticalSection(&This->csReceive);
 561
 562     do
 563     {
 564         LONGLONG tStart=0, tStop=0;
 565         LONGLONG mStart=0, mStop=0;
 566         float time;
 567
 568         EnterCriticalSection(&This->csReceive);
 569         if (!This->pQTMovie)
 570         {
 571             LeaveCriticalSection(&This->csReceive);
 572             return 0;
 573         }
 574
 575         GetMovieNextInterestingTime(This->pQTMovie, nextTimeStep, 0, NULL, This->movie_time, 1, &next_time, NULL);
 576
 577         if (next_time == -1)
 578         {
 579             TRACE("No next time\n");
 580             LeaveCriticalSection(&This->csReceive);
 581             break;
 582         }
 583
 584         tr.value = SInt64ToWide(next_time);
 585         SetMovieTime(This->pQTMovie, &tr);
 586         MoviesTask(This->pQTMovie,0);
 587         QTVisualContextTask(This->vContext);
 588
 589         TRACE("In loop at time %ld\n",This->movie_time);
 590         TRACE("In Next time %ld\n",next_time);
 591
 592         mStart = This->movie_time;
 593         mStop = next_time;
 594
 595         time = (float)(This->movie_time - This->movie_start) / This->movie_scale;
 596         tStart = time * 10000000;
 597         time = (float)(next_time - This->movie_start) / This->movie_scale;
 598         tStop = time * 10000000;
 599
 600         /* Deliver Audio */
 601         if (This->pAudio_Pin && This->pAudio_Pin->pin.pin.pConnectedTo && This->aSession)
 602         {
 603             int data_size=0;
 604             BYTE* ptr;
 605             IMediaSample *sample = NULL;
 606             AudioBufferList aData;
 607             UInt32 flags;
 608             UInt32 frames;
 609             WAVEFORMATEX* pvi;
 610             float duration;
 611
 612             pvi = (WAVEFORMATEX*)This->pAudio_Pin->pmt->pbFormat;
 613
 614             hr = BaseOutputPinImpl_GetDeliveryBuffer(&This->pAudio_Pin->pin, &sample, NULL, NULL, 0);
 615
 616             if (FAILED(hr))
 617             {
 618                 ERR("Audio: Unable to get delivery buffer (%x)\n", hr);
 619                 goto audio_error;
 620             }
 621
 622             hr = IMediaSample_GetPointer(sample, &ptr);
 623             if (FAILED(hr))
 624             {
 625                 ERR("Audio: Unable to get pointer to buffer (%x)\n", hr);
 626                 goto audio_error;
 627             }
 628
 629             duration = (float)next_time / This->movie_scale;
 630             time = (float)This->movie_time / This->movie_scale;
 631             duration -= time;
 632             frames = pvi->nSamplesPerSec * duration;
 633             TRACE("Need audio for %f seconds (%li frames)\n",duration,frames);
 634
 635             data_size = IMediaSample_GetSize(sample);
 636             if (data_size < frames * pvi->nBlockAlign)
 637                 FIXME("Audio buffer is too small\n");
 638
 639             aData.mNumberBuffers = 1;
 640             aData.mBuffers[0].mNumberChannels = pvi->nChannels;
 641             aData.mBuffers[0].mDataByteSize = data_size;
 642             aData.mBuffers[0].mData = ptr;
 643
 644             err = MovieAudioExtractionFillBuffer(This->aSession, &frames, &aData, &flags);
 645             if (frames == 0)
 646             {
 647                 TimeRecord etr;
 648
 649                 /* Ran out of frames, Restart the extraction session */
 650                 TRACE("Restarting extraction session\n");
 651                 MovieAudioExtractionEnd(This->aSession);
 652                 This->aSession = NULL;
 653                 QT_Create_Extract_Session(This);
 654
 655                 etr = tr;
 656                 etr.value = SInt64ToWide(This->movie_time);
 657                 MovieAudioExtractionSetProperty(This->aSession,
 658                     kQTPropertyClass_MovieAudioExtraction_Movie,
 659                     kQTMovieAudioExtractionMoviePropertyID_CurrentTime,
 660                     sizeof(TimeRecord), &etr );
 661
 662                 frames = pvi->nSamplesPerSec * duration;
 663                 aData.mNumberBuffers = 1;
 664                 aData.mBuffers[0].mNumberChannels = pvi->nChannels;
 665                 aData.mBuffers[0].mDataByteSize = data_size;
 666                 aData.mBuffers[0].mData = ptr;
 667
 668                 MovieAudioExtractionFillBuffer(This->aSession, &frames, &aData, &flags);
 669             }
 670
 671             TRACE("Got %i frames\n",(int)frames);
 672
 673             IMediaSample_SetActualDataLength(sample, frames * pvi->nBlockAlign);
 674
 675             IMediaSample_SetMediaTime(sample, &mStart, &mStop);
 676             IMediaSample_SetTime(sample, &tStart, &tStop);
 677
 678             hr = OutputQueue_Receive(This->pAudio_Pin->queue, sample);
 679             TRACE("Audio Delivered (%x)\n",hr);
 680
 681 audio_error:
 682             if (sample)
 683                 IMediaSample_Release(sample);
 684         }
 685         else
 686             TRACE("Audio Pin not connected or no Audio\n");
 687
 688         /* Deliver Video */
 689         if (This->pVideo_Pin && QTVisualContextIsNewImageAvailable(This->vContext,0))
 690         {
 691             err = QTVisualContextCopyImageForTime(This->vContext, NULL, NULL, &pixelBuffer);
 692             if (err == noErr)
 693             {
 694                 int data_size=0;
 695                 BYTE* ptr;
 696                 IMediaSample *sample = NULL;
 697
 698                 hr = BaseOutputPinImpl_GetDeliveryBuffer(&This->pVideo_Pin->pin, &sample, NULL, NULL, 0);
 699                 if (FAILED(hr))
 700                 {
 701                     ERR("Video: Unable to get delivery buffer (%x)\n", hr);
 702                     goto video_error;
 703                 }
 704
 705                 data_size = IMediaSample_GetSize(sample);
 706                 if (data_size < This->outputSize)
 707                 {
 708                     ERR("Sample size is too small %d < %d\n", data_size, This->outputSize)
 709     ;
 710                     hr = E_FAIL;
 711                     goto video_error;
 712                 }
 713
 714                 hr = IMediaSample_GetPointer(sample, &ptr);
 715                 if (FAILED(hr))
 716                 {
 717                     ERR("Video: Unable to get pointer to buffer (%x)\n", hr);
 718                     goto video_error;
 719                 }
 720
 721                 hr = AccessPixelBufferPixels( pixelBuffer, ptr);
 722                 if (FAILED(hr))
 723                 {
 724                     ERR("Failed to access Pixels\n");
 725                     goto video_error;
 726                 }
 727
 728                 IMediaSample_SetActualDataLength(sample, This->outputSize);
 729
 730                 IMediaSample_SetMediaTime(sample, &mStart, &mStop);
 731                 IMediaSample_SetTime(sample, &tStart, &tStop);
 732
 733                 hr = OutputQueue_Receive(This->pVideo_Pin->queue, sample);
 734                 TRACE("Video Delivered (%x)\n",hr);
 735
 736     video_error:
 737                 if (sample)
 738                     IMediaSample_Release(sample);
 739                 if (pixelBuffer)
 740                     CVPixelBufferRelease(pixelBuffer);
 741             }
 742         }
 743         else
 744             TRACE("No video to deliver\n");
 745
 746         This->movie_time = next_time;
 747         LeaveCriticalSection(&This->csReceive);
 748     } while (hr == S_OK);
 749
 750     This->state = State_Stopped;
 751     if (This->pAudio_Pin)
 752         OutputQueue_EOS(This->pAudio_Pin->queue);
 753     if (This->pVideo_Pin)
 754         OutputQueue_EOS(This->pVideo_Pin->queue);
 755
 756     return hr;
 757 }
 758
 759 static HRESULT WINAPI QT_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
 760 {
 761     HRESULT hr = S_OK;
 762     QTSplitter *This = impl_from_IBaseFilter(iface);
 763     HRESULT hr_any = VFW_E_NOT_CONNECTED;
 764
 765     TRACE("(%s)\n", wine_dbgstr_longlong(tStart));
 766
 767     EnterCriticalSection(&This->csReceive);
 768     This->filter.rtStreamStart = tStart;
 769
 770     if (This->pVideo_Pin)
 771         hr = BaseOutputPinImpl_Active(&This->pVideo_Pin->pin);
 772     if (SUCCEEDED(hr))
 773         hr_any = hr;
 774     if (This->pAudio_Pin)
 775         hr = BaseOutputPinImpl_Active(&This->pAudio_Pin->pin);
 776     if (SUCCEEDED(hr))
 777         hr_any = hr;
 778
 779     hr = hr_any;
 780
 781     SetEvent(This->runEvent);
 782     LeaveCriticalSection(&This->csReceive);
 783
 784     return hr;
 785 }
 786
 787 static HRESULT WINAPI QT_GetState(IBaseFilter *iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 788 {
 789     QTSplitter *This = impl_from_IBaseFilter(iface);
 790     TRACE("(%d, %p)\n", dwMilliSecsTimeout, pState);
 791
 792     *pState = This->state;
 793
 794     return S_OK;
 795 }
 796
 797 static HRESULT WINAPI QT_FindPin(IBaseFilter *iface, LPCWSTR Id, IPin **ppPin)
 798 {
 799     FIXME("(%p)->(%s,%p) stub\n", iface, debugstr_w(Id), ppPin);
 800     return E_NOTIMPL;
 801 }
 802
 803 static const IBaseFilterVtbl QT_Vtbl = {
 804     QT_QueryInterface,
 805     BaseFilterImpl_AddRef,
 806     QT_Release,
 807     BaseFilterImpl_GetClassID,
 808     QT_Stop,
 809     QT_Pause,
 810     QT_Run,
 811     QT_GetState,
 812     BaseFilterImpl_SetSyncSource,
 813     BaseFilterImpl_GetSyncSource,
 814     BaseFilterImpl_EnumPins,
 815     QT_FindPin,
 816     BaseFilterImpl_QueryFilterInfo,
 817     BaseFilterImpl_JoinFilterGraph,
 818     BaseFilterImpl_QueryVendorInfo
 819 };
 820
 821 /*
 822  * Input Pin
 823  */
 824 static HRESULT QT_RemoveOutputPins(QTSplitter *This)
 825 {
 826     HRESULT hr;
 827     TRACE("(%p)\n", This);
 828
 829     if (This->pVideo_Pin)
 830     {
 831         OutputQueue_Destroy(This->pVideo_Pin->queue);
 832         hr = BaseOutputPinImpl_BreakConnect(&This->pVideo_Pin->pin);
 833         TRACE("Disconnect: %08x\n", hr);
 834         IPin_Release(&This->pVideo_Pin->pin.pin.IPin_iface);
 835         This->pVideo_Pin = NULL;
 836     }
 837     if (This->pAudio_Pin)
 838     {
 839         OutputQueue_Destroy(This->pAudio_Pin->queue);
 840         hr = BaseOutputPinImpl_BreakConnect(&This->pAudio_Pin->pin);
 841         TRACE("Disconnect: %08x\n", hr);
 842         IPin_Release(&This->pAudio_Pin->pin.pin.IPin_iface);
 843         This->pAudio_Pin = NULL;
 844     }
 845
 846     BaseFilterImpl_IncrementPinVersion(&This->filter);
 847     return S_OK;
 848 }
 849
 850 static inline QTInPin *impl_from_IPin( IPin *iface )
 851 {
 852     return CONTAINING_RECORD(iface, QTInPin, pin.IPin_iface);
 853 }
 854
 855 static ULONG WINAPI QTInPin_Release(IPin *iface)
 856 {
 857     QTInPin *This = impl_from_IPin(iface);
 858     ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 859
 860     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 861     if (!refCount)
 862     {
 863         FreeMediaType(&This->pin.mtCurrent);
 864         if (This->pAlloc)
 865             IMemAllocator_Release(This->pAlloc);
 866         This->pAlloc = NULL;
 867         This->pin.IPin_iface.lpVtbl = NULL;
 868         return 0;
 869     }
 870     else
 871         return refCount;
 872 }
 873
 874 static HRESULT QT_Process_Video_Track(QTSplitter* filter, Track trk)
 875 {
 876     AM_MEDIA_TYPE amt;
 877     VIDEOINFOHEADER * pvi;
 878     PIN_INFO piOutput;
 879     HRESULT hr = S_OK;
 880     OSErr err;
 881     static const WCHAR szwVideoOut[] = {'V','i','d','e','o',0};
 882     CFMutableDictionaryRef  pixelBufferOptions = NULL;
 883     CFMutableDictionaryRef  visualContextOptions = NULL;
 884     CFNumberRef n = NULL;
 885     int t;
 886     DWORD outputWidth, outputHeight, outputDepth;
 887     Fixed trackWidth, trackHeight;
 888     Media videoMedia;
 889     long sampleCount;
 890     TimeValue64 duration;
 891     TimeScale timeScale;
 892
 893     ZeroMemory(&amt, sizeof(amt));
 894     amt.formattype = FORMAT_VideoInfo;
 895     amt.majortype = MEDIATYPE_Video;
 896     amt.subtype = MEDIASUBTYPE_RGB24;
 897
 898     GetTrackDimensions(trk, &trackWidth, &trackHeight);
 899
 900     outputDepth = 3;
 901     outputWidth = Fix2Long(trackWidth);
 902     outputHeight = Fix2Long(trackHeight);
 903     TRACE("Width %i  Height %i\n",outputWidth, outputHeight);
 904
 905     amt.cbFormat = sizeof(VIDEOINFOHEADER);
 906     amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
 907     ZeroMemory(amt.pbFormat, amt.cbFormat);
 908     pvi = (VIDEOINFOHEADER *)amt.pbFormat;
 909     pvi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
 910     pvi->bmiHeader.biWidth = outputWidth;
 911     pvi->bmiHeader.biHeight = outputHeight;
 912     pvi->bmiHeader.biPlanes = 1;
 913     pvi->bmiHeader.biBitCount = 24;
 914     pvi->bmiHeader.biCompression = BI_RGB;
 915     pvi->bmiHeader.biSizeImage = outputWidth * outputHeight * outputDepth;
 916
 917     filter->outputSize = pvi->bmiHeader.biSizeImage;
 918     amt.lSampleSize = 0;
 919
 920     pixelBufferOptions = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 921
 922     t = k32ARGBPixelFormat;
 923     n = CFNumberCreate(NULL, kCFNumberIntType, &t);
 924     CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, n);
 925     CFRelease(n);
 926
 927     n = CFNumberCreate(NULL, kCFNumberIntType, &outputWidth);
 928     CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferWidthKey, n);
 929     CFRelease(n);
 930
 931     n = CFNumberCreate(NULL, kCFNumberIntType, &outputHeight);
 932     CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferHeightKey, n);
 933     CFRelease(n);
 934
 935     t = 16;
 936     n = CFNumberCreate(NULL, kCFNumberIntType, &t);
 937     CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferBytesPerRowAlignmentKey, n);
 938     CFRelease(n);
 939
 940     visualContextOptions = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 941
 942     CFDictionarySetValue(visualContextOptions, kQTVisualContextPixelBufferAttributesKey, pixelBufferOptions);
 943
 944     err = QTPixelBufferContextCreate(NULL, visualContextOptions,&filter->vContext);
 945     CFRelease(pixelBufferOptions);
 946     CFRelease(visualContextOptions);
 947     if (err != noErr)
 948     {
 949         ERR("Failed to create Visual Context\n");
 950         return E_FAIL;
 951     }
 952
 953     err = SetMovieVisualContext(filter->pQTMovie, filter->vContext);
 954     if (err != noErr)
 955     {
 956         ERR("Failed to set Visual Context\n");
 957         return E_FAIL;
 958     }
 959
 960     videoMedia = GetTrackMedia(trk);
 961     sampleCount = GetMediaSampleCount(videoMedia);
 962     timeScale = GetMediaTimeScale(videoMedia);
 963     duration = GetMediaDisplayDuration(videoMedia);
 964     pvi->AvgTimePerFrame = (100000.0 * sampleCount * timeScale) / duration;
 965
 966     piOutput.dir = PINDIR_OUTPUT;
 967     piOutput.pFilter = &filter->filter.IBaseFilter_iface;
 968     lstrcpyW(piOutput.achName,szwVideoOut);
 969
 970     hr = QT_AddPin(filter, &piOutput, &amt, TRUE);
 971     if (FAILED(hr))
 972         ERR("Failed to add Video Track\n");
 973      else
 974         TRACE("Video Pin %p\n",filter->pVideo_Pin);
 975
 976     return hr;
 977 }
 978
 979 static HRESULT QT_Process_Audio_Track(QTSplitter* filter, Track trk)
 980 {
 981     AM_MEDIA_TYPE amt;
 982     WAVEFORMATEX* pvi;
 983     PIN_INFO piOutput;
 984     HRESULT hr = S_OK;
 985     static const WCHAR szwAudioOut[] = {'A','u','d','i','o',0};
 986     Media audioMedia;
 987
 988     SoundDescriptionHandle  aDesc = (SoundDescriptionHandle) NewHandle(sizeof(SoundDescription));
 989
 990     audioMedia = GetTrackMedia(trk);
 991     GetMediaSampleDescription(audioMedia, 1, (SampleDescriptionHandle)aDesc);
 992
 993     ZeroMemory(&amt, sizeof(amt));
 994     amt.formattype = FORMAT_WaveFormatEx;
 995     amt.majortype = MEDIATYPE_Audio;
 996     amt.subtype = MEDIASUBTYPE_PCM;
 997     amt.bTemporalCompression = 0;
 998
 999     amt.cbFormat = sizeof(WAVEFORMATEX);
1000     amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
1001     ZeroMemory(amt.pbFormat, amt.cbFormat);
1002     pvi = (WAVEFORMATEX*)amt.pbFormat;
1003
1004     pvi->cbSize = sizeof(WAVEFORMATEX);
1005     pvi->wFormatTag = WAVE_FORMAT_PCM;
1006     pvi->nChannels = ((SoundDescription)**aDesc).numChannels;
1007     if (pvi->nChannels < 1 || pvi->nChannels > 2)
1008         pvi->nChannels = 2;
1009     pvi->nSamplesPerSec = (((SoundDescription)**aDesc).sampleRate/65536);
1010     if (pvi->nSamplesPerSec < 8000 || pvi->nChannels > 48000)
1011         pvi->nSamplesPerSec = 44100;
1012     pvi->wBitsPerSample = ((SoundDescription)**aDesc).sampleSize;
1013     if (pvi->wBitsPerSample < 8 || pvi->wBitsPerSample > 32)
1014         pvi->wBitsPerSample = 16;
1015     pvi->nBlockAlign = (pvi->nChannels * pvi->wBitsPerSample) / 8;
1016     pvi->nAvgBytesPerSec = pvi->nSamplesPerSec * pvi->nBlockAlign;
1017
1018     DisposeHandle((Handle)aDesc);
1019
1020     piOutput.dir = PINDIR_OUTPUT;
1021     piOutput.pFilter = &filter->filter.IBaseFilter_iface;
1022     lstrcpyW(piOutput.achName,szwAudioOut);
1023
1024     hr = QT_AddPin(filter, &piOutput, &amt, FALSE);
1025     if (FAILED(hr))
1026         ERR("Failed to add Audio Track\n");
1027     else
1028         TRACE("Audio Pin %p\n",filter->pAudio_Pin);
1029     return hr;
1030 }
1031
1032 static HRESULT QT_Process_Movie(QTSplitter* filter)
1033 {
1034     HRESULT hr = S_OK;
1035     OSErr err;
1036     WineDataRefRecord ptrDataRefRec;
1037     Handle dataRef = NULL;
1038     Track trk;
1039     short id = 0;
1040     DWORD tid;
1041     LONGLONG time;
1042
1043     TRACE("Trying movie connect\n");
1044
1045     ptrDataRefRec.pReader = filter->pInputPin.pReader;
1046     ptrDataRefRec.streamSubtype = filter->pInputPin.subType;
1047     PtrToHand( &ptrDataRefRec, &dataRef, sizeof(WineDataRefRecord));
1048
1049     err = NewMovieFromDataRef(&filter->pQTMovie, newMovieActive|newMovieDontInteractWithUser|newMovieDontAutoUpdateClock|newMovieDontAskUnresolvedDataRefs|newMovieAsyncOK, &id, dataRef, 'WINE');
1050
1051     DisposeHandle(dataRef);
1052
1053     if (err != noErr)
1054     {
1055         FIXME("QuickTime cannot handle media type(%i)\n",err);
1056         return VFW_E_TYPE_NOT_ACCEPTED;
1057     }
1058
1059     PrePrerollMovie(filter->pQTMovie, 0, fixed1, NULL, NULL);
1060     PrerollMovie(filter->pQTMovie, 0, fixed1);
1061     GoToBeginningOfMovie(filter->pQTMovie);
1062     SetMovieActive(filter->pQTMovie,TRUE);
1063
1064     if (GetMovieLoadState(filter->pQTMovie) < kMovieLoadStateLoaded)
1065         MoviesTask(filter->pQTMovie,100);
1066
1067     trk = GetMovieIndTrackType(filter->pQTMovie, 1, VisualMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly);
1068     TRACE("%p is a video track\n",trk);
1069     if (trk)
1070        hr = QT_Process_Video_Track(filter, trk);
1071
1072     if (FAILED(hr))
1073         return hr;
1074
1075     trk = GetMovieIndTrackType(filter->pQTMovie, 1, AudioMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly);
1076     TRACE("%p is an audio track\n",trk);
1077     if (trk)
1078         hr = QT_Process_Audio_Track(filter, trk);
1079
1080     time = GetMovieDuration(filter->pQTMovie);
1081     filter->movie_scale = GetMovieTimeScale(filter->pQTMovie);
1082     filter->sourceSeeking.llDuration = ((double)time / filter->movie_scale) * 10000000;
1083     filter->sourceSeeking.llStop = filter->sourceSeeking.llDuration;
1084
1085     TRACE("Movie duration is %s\n",wine_dbgstr_longlong(filter->sourceSeeking.llDuration));
1086
1087     filter->loaderThread = CreateThread(NULL, 0, QTSplitter_loading_thread, filter, 0, &tid);
1088     if (filter->loaderThread)
1089         TRACE("Created loading thread 0x%08x\n", tid);
1090     filter->splitterThread = CreateThread(NULL, 0, QTSplitter_thread, filter, 0, &tid);
1091     if (filter->splitterThread)
1092         TRACE("Created processing thread 0x%08x\n", tid);
1093     else
1094         hr = HRESULT_FROM_WIN32(GetLastError());
1095
1096     return hr;
1097 }
1098
1099 static HRESULT WINAPI QTInPin_ReceiveConnection(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
1100 {
1101     HRESULT hr = S_OK;
1102     ALLOCATOR_PROPERTIES props;
1103     QTInPin *This = impl_from_IPin(iface);
1104
1105     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
1106
1107     EnterCriticalSection(This->pin.pCritSec);
1108     This->pReader = NULL;
1109
1110     if (This->pin.pConnectedTo)
1111         hr = VFW_E_ALREADY_CONNECTED;
1112     else if (IPin_QueryAccept(iface, pmt) != S_OK)
1113         hr = VFW_E_TYPE_NOT_ACCEPTED;
1114     else
1115     {
1116         PIN_DIRECTION pindirReceive;
1117         IPin_QueryDirection(pReceivePin, &pindirReceive);
1118         if (pindirReceive != PINDIR_OUTPUT)
1119             hr = VFW_E_INVALID_DIRECTION;
1120     }
1121
1122     if (FAILED(hr))
1123     {
1124         LeaveCriticalSection(This->pin.pCritSec);
1125         return hr;
1126     }
1127
1128     hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
1129     if (FAILED(hr))
1130     {
1131         LeaveCriticalSection(This->pin.pCritSec);
1132         TRACE("Input source is not an AsyncReader\n");
1133         return hr;
1134     }
1135
1136     LeaveCriticalSection(This->pin.pCritSec);
1137     EnterCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
1138     hr = QT_Process_Movie(impl_from_IBaseFilter(This->pin.pinInfo.pFilter));
1139     if (FAILED(hr))
1140     {
1141         LeaveCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
1142         TRACE("Unable to process movie\n");
1143         return hr;
1144     }
1145
1146     This->pAlloc = NULL;
1147     props.cBuffers = 8;
1148     props.cbAlign = 1;
1149     props.cbBuffer = impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->outputSize + props.cbAlign;
1150     props.cbPrefix = 0;
1151
1152     hr = IAsyncReader_RequestAllocator(This->pReader, NULL, &props, &This->pAlloc);
1153     if (SUCCEEDED(hr))
1154     {
1155         CopyMediaType(&This->pin.mtCurrent, pmt);
1156         This->pin.pConnectedTo = pReceivePin;
1157         IPin_AddRef(pReceivePin);
1158         hr = IMemAllocator_Commit(This->pAlloc);
1159     }
1160     else
1161     {
1162         QT_RemoveOutputPins(impl_from_IBaseFilter(This->pin.pinInfo.pFilter));
1163         if (This->pReader)
1164             IAsyncReader_Release(This->pReader);
1165         This->pReader = NULL;
1166         if (This->pAlloc)
1167             IMemAllocator_Release(This->pAlloc);
1168         This->pAlloc = NULL;
1169     }
1170     TRACE("Size: %i\n", props.cbBuffer);
1171     LeaveCriticalSection(&impl_from_IBaseFilter(This->pin.pinInfo.pFilter)->filter.csFilter);
1172
1173     return hr;
1174 }
1175
1176 static HRESULT WINAPI QTInPin_Disconnect(IPin *iface)
1177 {
1178     HRESULT hr;
1179     QTInPin *This = impl_from_IPin(iface);
1180     FILTER_STATE state;
1181     TRACE("()\n");
1182
1183     hr = IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
1184     EnterCriticalSection(This->pin.pCritSec);
1185     if (This->pin.pConnectedTo)
1186     {
1187         QTSplitter *Parser = impl_from_IBaseFilter(This->pin.pinInfo.pFilter);
1188
1189         if (SUCCEEDED(hr) && state == State_Stopped)
1190         {
1191             IMemAllocator_Decommit(This->pAlloc);
1192             IPin_Disconnect(This->pin.pConnectedTo);
1193             This->pin.pConnectedTo = NULL;
1194             hr = QT_RemoveOutputPins(Parser);
1195         }
1196         else
1197             hr = VFW_E_NOT_STOPPED;
1198     }
1199     else
1200         hr = S_FALSE;
1201     LeaveCriticalSection(This->pin.pCritSec);
1202     return hr;
1203 }
1204
1205 static HRESULT WINAPI QTInPin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *pmt)
1206 {
1207     QTInPin *This = impl_from_IPin(iface);
1208
1209     TRACE("(%p)->(%p)\n", This, pmt);
1210
1211     if (IsEqualIID(&pmt->majortype, &MEDIATYPE_Stream))
1212     {
1213         This->subType = pmt->subtype;
1214         return S_OK;
1215     }
1216     return S_FALSE;
1217 }
1218
1219 static HRESULT WINAPI QTInPin_EndOfStream(IPin *iface)
1220 {
1221     QTInPin *pin = impl_from_IPin(iface);
1222     QTSplitter *This = impl_from_IBaseFilter(pin->pin.pinInfo.pFilter);
1223
1224     FIXME("Propagate message on %p\n", This);
1225     return S_OK;
1226 }
1227
1228 static HRESULT WINAPI QTInPin_BeginFlush(IPin *iface)
1229 {
1230     QTInPin *pin = impl_from_IPin(iface);
1231     QTSplitter *This = impl_from_IBaseFilter(pin->pin.pinInfo.pFilter);
1232
1233     FIXME("Propagate message on %p\n", This);
1234     return S_OK;
1235 }
1236
1237 static HRESULT WINAPI QTInPin_EndFlush(IPin *iface)
1238 {
1239     QTInPin *pin = impl_from_IPin(iface);
1240     QTSplitter *This = impl_from_IBaseFilter(pin->pin.pinInfo.pFilter);
1241
1242     FIXME("Propagate message on %p\n", This);
1243     return S_OK;
1244 }
1245
1246 static HRESULT WINAPI QTInPin_NewSegment(IPin *iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1247 {
1248     QTInPin *pin = impl_from_IPin(iface);
1249     QTSplitter *This = impl_from_IBaseFilter(pin->pin.pinInfo.pFilter);
1250
1251     BasePinImpl_NewSegment(iface, tStart, tStop, dRate);
1252     FIXME("Propagate message on %p\n", This);
1253     return S_OK;
1254 }
1255
1256 static HRESULT WINAPI QTInPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv)
1257 {
1258     QTInPin *This = impl_from_IPin(iface);
1259
1260     TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppv);
1261
1262     *ppv = NULL;
1263
1264     if (IsEqualIID(riid, &IID_IUnknown))
1265         *ppv = iface;
1266     else if (IsEqualIID(riid, &IID_IPin))
1267         *ppv = iface;
1268     else if (IsEqualIID(riid, &IID_IMediaSeeking))
1269         return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
1270
1271     if (*ppv)
1272     {
1273         IUnknown_AddRef((IUnknown *)(*ppv));
1274         return S_OK;
1275     }
1276
1277     FIXME("No interface for %s!\n", debugstr_guid(riid));
1278
1279     return E_NOINTERFACE;
1280 }
1281
1282 static HRESULT WINAPI QTInPin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **ppEnum)
1283 {
1284     QTInPin *This = impl_from_IPin(iface);
1285
1286     TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
1287
1288     return EnumMediaTypes_Construct(&This->pin, BasePinImpl_GetMediaType, BasePinImpl_GetMediaTypeVersion, ppEnum);
1289 }
1290
1291 static const IPinVtbl QT_InputPin_Vtbl = {
1292     QTInPin_QueryInterface,
1293     BasePinImpl_AddRef,
1294     QTInPin_Release,
1295     BaseInputPinImpl_Connect,
1296     QTInPin_ReceiveConnection,
1297     QTInPin_Disconnect,
1298     BasePinImpl_ConnectedTo,
1299     BasePinImpl_ConnectionMediaType,
1300     BasePinImpl_QueryPinInfo,
1301     BasePinImpl_QueryDirection,
1302     BasePinImpl_QueryId,
1303     QTInPin_QueryAccept,
1304     QTInPin_EnumMediaTypes,
1305     BasePinImpl_QueryInternalConnections,
1306     QTInPin_EndOfStream,
1307     QTInPin_BeginFlush,
1308     QTInPin_EndFlush,
1309     QTInPin_NewSegment
1310 };
1311
1312 /*
1313  * Output Pin
1314  */
1315 static inline QTOutPin *impl_QTOutPin_from_IPin( IPin *iface )
1316 {
1317     return CONTAINING_RECORD(iface, QTOutPin, pin.pin.IPin_iface);
1318 }
1319
1320 static inline QTOutPin *impl_QTOutPin_from_BasePin( BasePin *iface )
1321 {
1322     return CONTAINING_RECORD(iface, QTOutPin, pin.pin);
1323 }
1324
1325 static inline QTOutPin *impl_QTOutPin_from_BaseOutputPin( BaseOutputPin *iface )
1326 {
1327     return CONTAINING_RECORD(iface, QTOutPin, pin);
1328 }
1329
1330 static HRESULT WINAPI QTOutPin_QueryInterface(IPin *iface, REFIID riid, void **ppv)
1331 {
1332     QTOutPin *This = impl_QTOutPin_from_IPin(iface);
1333
1334     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1335
1336     *ppv = NULL;
1337
1338     if (IsEqualIID(riid, &IID_IUnknown))
1339         *ppv = iface;
1340     else if (IsEqualIID(riid, &IID_IPin))
1341         *ppv = iface;
1342     else if (IsEqualIID(riid, &IID_IMediaSeeking))
1343         return IBaseFilter_QueryInterface(This->pin.pin.pinInfo.pFilter, &IID_IMediaSeeking, ppv);
1344     else if (IsEqualIID(riid, &IID_IQualityControl))
1345         *ppv = &This->IQualityControl_iface;
1346
1347     if (*ppv)
1348     {
1349         IUnknown_AddRef((IUnknown *)(*ppv));
1350         return S_OK;
1351     }
1352     FIXME("No interface for %s!\n", debugstr_guid(riid));
1353     return E_NOINTERFACE;
1354 }
1355
1356 static ULONG WINAPI QTOutPin_Release(IPin *iface)
1357 {
1358     QTOutPin *This = impl_QTOutPin_from_IPin(iface);
1359     ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount);
1360     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
1361
1362     if (!refCount)
1363     {
1364         DeleteMediaType(This->pmt);
1365         FreeMediaType(&This->pin.pin.mtCurrent);
1366         if (This->pin.pAllocator)
1367             IMemAllocator_Release(This->pin.pAllocator);
1368         CoTaskMemFree(This);
1369         return 0;
1370     }
1371     return refCount;
1372 }
1373
1374 static HRESULT WINAPI QTOutPin_GetMediaType(BasePin *iface, int iPosition, AM_MEDIA_TYPE *pmt)
1375 {
1376     QTOutPin *This = impl_QTOutPin_from_BasePin(iface);
1377
1378     if (iPosition < 0)
1379         return E_INVALIDARG;
1380     if (iPosition > 0)
1381         return VFW_S_NO_MORE_ITEMS;
1382     CopyMediaType(pmt, This->pmt);
1383     return S_OK;
1384 }
1385
1386 static HRESULT WINAPI QTOutPin_DecideBufferSize(BaseOutputPin *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
1387 {
1388     /* Unused */
1389     return S_OK;
1390 }
1391
1392 static HRESULT WINAPI QTOutPin_DecideAllocator(BaseOutputPin *iface, IMemInputPin *pPin, IMemAllocator **pAlloc)
1393 {
1394     HRESULT hr;
1395     QTOutPin *This = impl_QTOutPin_from_BaseOutputPin(iface);
1396     QTSplitter *QTfilter = impl_from_IBaseFilter(This->pin.pin.pinInfo.pFilter);
1397
1398     *pAlloc = NULL;
1399     if (QTfilter->pInputPin.pAlloc)
1400     {
1401         hr = IMemInputPin_NotifyAllocator(pPin, QTfilter->pInputPin.pAlloc, FALSE);
1402         if (SUCCEEDED(hr))
1403         {
1404             *pAlloc = QTfilter->pInputPin.pAlloc;
1405             IMemAllocator_AddRef(*pAlloc);
1406         }
1407     }
1408     else
1409         hr = VFW_E_NO_ALLOCATOR;
1410
1411     return hr;
1412 }
1413
1414 static HRESULT WINAPI QTOutPin_BreakConnect(BaseOutputPin *This)
1415 {
1416     HRESULT hr;
1417
1418     TRACE("(%p)->()\n", This);
1419
1420     EnterCriticalSection(This->pin.pCritSec);
1421     if (!This->pin.pConnectedTo || !This->pMemInputPin)
1422         hr = VFW_E_NOT_CONNECTED;
1423     else
1424     {
1425         hr = IPin_Disconnect(This->pin.pConnectedTo);
1426         IPin_Disconnect(&This->pin.IPin_iface);
1427     }
1428     LeaveCriticalSection(This->pin.pCritSec);
1429
1430     return hr;
1431 }
1432
1433 static const IPinVtbl QT_OutputPin_Vtbl = {
1434     QTOutPin_QueryInterface,
1435     BasePinImpl_AddRef,
1436     QTOutPin_Release,
1437     BaseOutputPinImpl_Connect,
1438     BaseOutputPinImpl_ReceiveConnection,
1439     BaseOutputPinImpl_Disconnect,
1440     BasePinImpl_ConnectedTo,
1441     BasePinImpl_ConnectionMediaType,
1442     BasePinImpl_QueryPinInfo,
1443     BasePinImpl_QueryDirection,
1444     BasePinImpl_QueryId,
1445     BasePinImpl_QueryAccept,
1446     BasePinImpl_EnumMediaTypes,
1447     BasePinImpl_QueryInternalConnections,
1448     BaseOutputPinImpl_EndOfStream,
1449     BaseOutputPinImpl_BeginFlush,
1450     BaseOutputPinImpl_EndFlush,
1451     BasePinImpl_NewSegment
1452 };
1453
1454 static inline QTOutPin *impl_from_IQualityControl( IQualityControl *iface )
1455 {
1456     return CONTAINING_RECORD(iface, QTOutPin, IQualityControl_iface);
1457 }
1458
1459 HRESULT WINAPI QT_QualityControl_QueryInterface(IQualityControl *iface, REFIID riid, void **ppv)
1460 {
1461     QTOutPin *This = impl_from_IQualityControl(iface);
1462     return IPin_QueryInterface(&This->pin.pin.IPin_iface, riid, ppv);
1463 }
1464
1465 ULONG WINAPI QT_QualityControl_AddRef(IQualityControl *iface)
1466 {
1467     QTOutPin *This = impl_from_IQualityControl(iface);
1468     return IPin_AddRef(&This->pin.pin.IPin_iface);
1469 }
1470
1471 ULONG WINAPI QT_QualityControl_Release(IQualityControl *iface)
1472 {
1473     QTOutPin *This = impl_from_IQualityControl(iface);
1474     return IPin_Release(&This->pin.pin.IPin_iface);
1475 }
1476
1477 static HRESULT WINAPI QT_QualityControl_Notify(IQualityControl *iface, IBaseFilter *sender, Quality qm)
1478 {
1479     REFERENCE_TIME late = qm.Late;
1480     if (qm.Late < 0 && -qm.Late > qm.TimeStamp)
1481         late = -qm.TimeStamp;
1482     /* TODO: Do Something */
1483     return S_OK;
1484 }
1485
1486 HRESULT WINAPI QT_QualityControl_SetSink(IQualityControl *iface, IQualityControl *tonotify)
1487 {
1488     /* Do nothing */
1489     return S_OK;
1490 }
1491
1492 static const IQualityControlVtbl QTOutPin_QualityControl_Vtbl = {
1493     QT_QualityControl_QueryInterface,
1494     QT_QualityControl_AddRef,
1495     QT_QualityControl_Release,
1496     QT_QualityControl_Notify,
1497     QT_QualityControl_SetSink
1498 };
1499
1500 static const BaseOutputPinFuncTable output_BaseOutputFuncTable = {
1501     {
1502         NULL,
1503         BaseOutputPinImpl_AttemptConnection,
1504         BasePinImpl_GetMediaTypeVersion,
1505         QTOutPin_GetMediaType
1506     },
1507     QTOutPin_DecideBufferSize,
1508     QTOutPin_DecideAllocator,
1509     QTOutPin_BreakConnect
1510 };
1511
1512 static const OutputQueueFuncTable output_OutputQueueFuncTable = {
1513     OutputQueueImpl_ThreadProc
1514 };
1515
1516 static HRESULT QT_AddPin(QTSplitter *This, const PIN_INFO *piOutput, const AM_MEDIA_TYPE *amt, BOOL video)
1517 {
1518     HRESULT hr;
1519     IPin **target;
1520
1521     if (video)
1522         target = (IPin**)&This->pVideo_Pin;
1523     else
1524         target = (IPin**)&This->pAudio_Pin;
1525
1526     if (*target != NULL)
1527     {
1528         FIXME("We already have a %s pin\n",(video)?"video":"audio");
1529         return E_FAIL;
1530     }
1531
1532     hr = BaseOutputPin_Construct(&QT_OutputPin_Vtbl, sizeof(QTOutPin), piOutput, &output_BaseOutputFuncTable, &This->filter.csFilter, (IPin**)target);
1533     if (SUCCEEDED(hr))
1534     {
1535         QTOutPin *pin = (QTOutPin*)*target;
1536         pin->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
1537         CopyMediaType(pin->pmt, amt);
1538         pin->pin.pin.pinInfo.pFilter = (LPVOID)This;
1539         pin->IQualityControl_iface.lpVtbl = &QTOutPin_QualityControl_Vtbl;
1540
1541         BaseFilterImpl_IncrementPinVersion(&This->filter);
1542
1543         hr = OutputQueue_Construct(&pin->pin, TRUE, TRUE, 5, FALSE, THREAD_PRIORITY_NORMAL, &output_OutputQueueFuncTable, &pin->queue);
1544     }
1545     else
1546         ERR("Failed with error %x\n", hr);
1547     return hr;
1548 }
1549
1550 static HRESULT WINAPI QTSplitter_ChangeStart(IMediaSeeking *iface)
1551 {
1552     QTSplitter *This = impl_from_IMediaSeeking(iface);
1553     TRACE("(%p)\n", iface);
1554     EnterCriticalSection(&This->csReceive);
1555     This->movie_time = (This->sourceSeeking.llCurrent * This->movie_scale)/10000000;
1556     This->movie_start = This->movie_time;
1557     LeaveCriticalSection(&This->csReceive);
1558     return S_OK;
1559 }
1560
1561 static HRESULT WINAPI QTSplitter_ChangeStop(IMediaSeeking *iface)
1562 {
1563     FIXME("(%p) filter hasn't implemented stop position change!\n", iface);
1564     return S_OK;
1565 }
1566
1567 static HRESULT WINAPI QTSplitter_ChangeRate(IMediaSeeking *iface)
1568 {
1569     FIXME("(%p) filter hasn't implemented rate change!\n", iface);
1570     return S_OK;
1571 }
1572
1573 static HRESULT WINAPI QT_Seeking_QueryInterface(IMediaSeeking * iface, REFIID riid, LPVOID * ppv)
1574 {
1575     QTSplitter *This = impl_from_IMediaSeeking(iface);
1576
1577     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
1578 }
1579
1580 static ULONG WINAPI QT_Seeking_AddRef(IMediaSeeking * iface)
1581 {
1582     QTSplitter *This = impl_from_IMediaSeeking(iface);
1583
1584     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
1585 }
1586
1587 static ULONG WINAPI QT_Seeking_Release(IMediaSeeking * iface)
1588 {
1589     QTSplitter *This = impl_from_IMediaSeeking(iface);
1590
1591     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
1592 }
1593
1594 static const IMediaSeekingVtbl QT_Seeking_Vtbl =
1595 {
1596     QT_Seeking_QueryInterface,
1597     QT_Seeking_AddRef,
1598     QT_Seeking_Release,
1599     SourceSeekingImpl_GetCapabilities,
1600     SourceSeekingImpl_CheckCapabilities,
1601     SourceSeekingImpl_IsFormatSupported,
1602     SourceSeekingImpl_QueryPreferredFormat,
1603     SourceSeekingImpl_GetTimeFormat,
1604     SourceSeekingImpl_IsUsingTimeFormat,
1605     SourceSeekingImpl_SetTimeFormat,
1606     SourceSeekingImpl_GetDuration,
1607     SourceSeekingImpl_GetStopPosition,
1608     SourceSeekingImpl_GetCurrentPosition,
1609     SourceSeekingImpl_ConvertTimeFormat,
1610     SourceSeekingImpl_SetPositions,
1611     SourceSeekingImpl_GetPositions,
1612     SourceSeekingImpl_GetAvailable,
1613     SourceSeekingImpl_SetRate,
1614     SourceSeekingImpl_GetRate,
1615     SourceSeekingImpl_GetPreroll
1616 };