static HRESULT WINAPI TransformFilter_InputPin_EndOfStream(IPin * iface) { BaseInputPin* This = impl_BaseInputPin_from_IPin(iface); TransformFilter* pTransform; IPin* ppin; HRESULT hr; TRACE("(%p)->()\n", iface); /* Since we process samples synchronously, just forward notification downstream */ pTransform = impl_from_IBaseFilter(This->pin.pinInfo.pFilter); if (!pTransform) hr = E_FAIL; else hr = IPin_ConnectedTo(pTransform->ppPins[1], &ppin); if (SUCCEEDED(hr)) { hr = IPin_EndOfStream(ppin); IPin_Release(ppin); } if (FAILED(hr)) ERR("%x\n", hr); return hr; }
static ULONG WINAPI NullRendererInner_Release(IUnknown * iface) { ICOM_THIS_MULTI(NullRendererImpl, IInner_vtbl, iface); ULONG refCount = InterlockedDecrement(&This->refCount); TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1); if (!refCount) { IPin *pConnectedTo; if (This->pClock) IReferenceClock_Release(This->pClock); if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect((IPin *)This->pInputPin); IPin_Release((IPin *)This->pInputPin); This->lpVtbl = NULL; This->csFilter.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csFilter); TRACE("Destroying Null Renderer\n"); CoTaskMemFree(This); return 0; } else return refCount; }
static ULONG WINAPI unknown_inner_Release(IUnknown *iface) { VfwCapture *This = impl_from_IUnknown(iface); ULONG ref = InterlockedDecrement(&This->filter.refCount); TRACE("(%p) ref=%d\n", This, ref); if (!ref) { IPin *conn = NULL; TRACE("destroying everything\n"); if (This->init) { if (This->filter.state != State_Stopped) qcap_driver_stop(This->driver_info, &This->filter.state); qcap_driver_destroy(This->driver_info); } IPin_ConnectedTo(This->pOutputPin, &conn); if (conn) { IPin_Disconnect(conn); IPin_Disconnect(This->pOutputPin); IPin_Release(conn); } IPin_Release(This->pOutputPin); BaseFilter_Destroy(&This->filter); CoTaskMemFree(This); ObjectRefCount(FALSE); } return ref; }
void Parser_Destroy(ParserImpl *This) { IPin *connected = NULL; ULONG pinref; assert(!This->filter.refCount); PullPin_WaitForStateChange(This->pInputPin, INFINITE); /* Don't need to clean up output pins, freeing input pin will do that */ IPin_ConnectedTo(&This->pInputPin->pin.IPin_iface, &connected); if (connected) { assert(IPin_Disconnect(connected) == S_OK); IPin_Release(connected); assert(IPin_Disconnect(&This->pInputPin->pin.IPin_iface) == S_OK); } pinref = IPin_Release(&This->pInputPin->pin.IPin_iface); if (pinref) { /* Valgrind could find this, if I kill it here */ ERR("pinref should be null, is %u, destroying anyway\n", pinref); assert((LONG)pinref > 0); while (pinref) pinref = IPin_Release(&This->pInputPin->pin.IPin_iface); } CoTaskMemFree(This->ppPins); TRACE("Destroying parser\n"); CoTaskMemFree(This); }
ULONG WINAPI BaseRendererImpl_Release(IBaseFilter* iface) { BaseRenderer *This = impl_from_IBaseFilter(iface); ULONG refCount = BaseFilterImpl_Release(iface); if (!refCount) { IPin *pConnectedTo; if (SUCCEEDED(IPin_ConnectedTo(&This->pInputPin->pin.IPin_iface, &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect(&This->pInputPin->pin.IPin_iface); IPin_Release(&This->pInputPin->pin.IPin_iface); if (This->pPosition) IUnknown_Release(This->pPosition); This->csRenderLock.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csRenderLock); BaseRendererImpl_ClearPendingSample(This); CloseHandle(This->evComplete); CloseHandle(This->ThreadSignal); CloseHandle(This->RenderEvent); QualityControlImpl_Destroy(This->qcimpl); } return refCount; }
HRESULT WINAPI QualityControlImpl_Notify(IQualityControl *iface, IBaseFilter *sender, Quality qm) { QualityControlImpl *This = impl_from_IQualityControl(iface); HRESULT hr = S_FALSE; TRACE("%p %p { 0x%x %u " XTIME_FMT " " XTIME_FMT " }\n", This, sender, qm.Type, qm.Proportion, XTIME(qm.Late), XTIME(qm.TimeStamp)); if (This->tonotify) return IQualityControl_Notify(This->tonotify, This->self, qm); if (This->input) { IPin *to = NULL; IPin_ConnectedTo(This->input, &to); if (to) { IQualityControl *qc = NULL; IPin_QueryInterface(to, &IID_IQualityControl, (void**)&qc); if (qc) { hr = IQualityControl_Notify(qc, This->self, qm); IQualityControl_Release(qc); } IPin_Release(to); } } return hr; }
static BOOL pin_matches(IPin *pin, PIN_DIRECTION direction, const GUID *cat, const GUID *type, BOOL unconnected) { IPin *partner; PIN_DIRECTION pindir; IPin_QueryDirection(pin, &pindir); if (pindir != direction) { TRACE("No match, wrong direction\n"); return FALSE; } if (unconnected && IPin_ConnectedTo(pin, &partner) == S_OK) { IPin_Release(partner); TRACE("No match, %p already connected to %p\n", pin, partner); return FALSE; } if (cat || type) FIXME("Ignoring category/type\n"); TRACE("Match made in heaven\n"); return TRUE; }
static void QT_Destroy(QTSplitter *This) { IPin *connected = NULL; ULONG pinref; TRACE("Destroying\n"); EnterCriticalSection(&This->csReceive); /* Don't need to clean up output pins, disconnecting input pin will do that */ IPin_ConnectedTo(&This->pInputPin.pin.IPin_iface, &connected); if (connected) { IPin_Disconnect(connected); IPin_Release(connected); } pinref = IPin_Release(&This->pInputPin.pin.IPin_iface); if (pinref) { ERR("pinref should be null, is %u, destroying anyway\n", pinref); assert((LONG)pinref > 0); while (pinref) pinref = IPin_Release(&This->pInputPin.pin.IPin_iface); } if (This->pQTMovie) { DisposeMovie(This->pQTMovie); This->pQTMovie = NULL; } if (This->vContext) QTVisualContextRelease(This->vContext); if (This->aSession) MovieAudioExtractionEnd(This->aSession); ExitMoviesOnThread(); LeaveCriticalSection(&This->csReceive); if (This->loaderThread) { WaitForSingleObject(This->loaderThread, INFINITE); CloseHandle(This->loaderThread); } if (This->splitterThread) { SetEvent(This->runEvent); WaitForSingleObject(This->splitterThread, INFINITE); CloseHandle(This->splitterThread); } CloseHandle(This->runEvent); This->csReceive.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csReceive); BaseFilter_Destroy(&This->filter); CoTaskMemFree(This); }
HRESULT qcap_driver_stop(Capture *capBox, FILTER_STATE *state) { TRACE("%p -> (%p)\n", capBox, state); if (*state == State_Stopped) return S_OK; EnterCriticalSection(&capBox->CritSect); if (capBox->thread) { if (*state == State_Paused) ResumeThread(capBox->thread); capBox->stopped = 1; capBox->thread = 0; if (capBox->iscommitted) { IMemInputPin *pMem = NULL; IMemAllocator * pAlloc = NULL; IPin *pConnect = NULL; HRESULT hr; capBox->iscommitted = 0; hr = IPin_ConnectedTo(capBox->pOut, &pConnect); if (SUCCEEDED(hr)) hr = IPin_QueryInterface(pConnect, &IID_IMemInputPin, (void **) &pMem); if (SUCCEEDED(hr)) hr = IMemInputPin_GetAllocator(pMem, &pAlloc); if (SUCCEEDED(hr)) hr = IMemAllocator_Decommit(pAlloc); if (pAlloc) IMemAllocator_Release(pAlloc); if (pMem) IMemInputPin_Release(pMem); if (pConnect) IPin_Release(pConnect); if (hr != S_OK && hr != VFW_E_NOT_COMMITTED) WARN("Decommitting allocator: %x\n", hr); } V4l_Unprepare(capBox); } *state = State_Stopped; LeaveCriticalSection(&capBox->CritSect); return S_OK; }
static HRESULT get_connected(PassThruImpl *This, REFIID riid, LPVOID *ppvObj) { HRESULT hr; IPin *pin; *ppvObj = NULL; hr = IPin_ConnectedTo(This->pin, &pin); if (FAILED(hr)) return VFW_E_NOT_CONNECTED; hr = IPin_QueryInterface(pin, riid, ppvObj); IPin_Release(pin); if (FAILED(hr)) hr = E_NOTIMPL; return hr; }
static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface) { DSoundRenderImpl *This = (DSoundRenderImpl *)iface; ULONG refCount = InterlockedDecrement(&This->refCount); TRACE("(%p)->() Release from %d\n", This, refCount + 1); if (!refCount) { IPin *pConnectedTo; if (This->pClock) IReferenceClock_Release(This->pClock); if (This->dsbuffer) IDirectSoundBuffer_Release(This->dsbuffer); This->dsbuffer = NULL; if (This->dsound) IDirectSound_Release(This->dsound); This->dsound = NULL; if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect((IPin *)This->pInputPin); IPin_Release((IPin *)This->pInputPin); This->lpVtbl = NULL; This->IBasicAudio_vtbl = NULL; This->csFilter.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csFilter); CloseHandle(This->state_change); CloseHandle(This->blocked); TRACE("Destroying Audio Renderer\n"); CoTaskMemFree(This); return 0; } else return refCount; }
static ULONG WINAPI TransformFilter_Release(IBaseFilter * iface) { TransformFilterImpl *This = (TransformFilterImpl *)iface; ULONG refCount = InterlockedDecrement(&This->refCount); TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1); if (!refCount) { ULONG i; if (This->pClock) IReferenceClock_Release(This->pClock); for (i = 0; i < This->npins; i++) { IPin *pConnectedTo; if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect(This->ppPins[i]); IPin_Release(This->ppPins[i]); } CoTaskMemFree(This->ppPins); This->lpVtbl = NULL; This->csFilter.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csFilter); TRACE("Destroying transform filter\n"); FreeMediaType(&This->pmt); CoTaskMemFree(This); return 0; } else return refCount; }
static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface) { DSoundRenderImpl *This = (DSoundRenderImpl *)iface; ULONG refCount = BaseFilterImpl_Release(iface); TRACE("(%p)->() Release from %d\n", This, refCount + 1); if (!refCount) { IPin *pConnectedTo; if (This->dsbuffer) IDirectSoundBuffer_Release(This->dsbuffer); This->dsbuffer = NULL; if (This->dsound) IDirectSound_Release(This->dsound); This->dsound = NULL; if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect((IPin *)This->pInputPin); IPin_Release((IPin *)This->pInputPin); This->IBasicAudio_vtbl = NULL; if (This->seekthru_unk) IUnknown_Release(This->seekthru_unk); CloseHandle(This->state_change); CloseHandle(This->blocked); TRACE("Destroying Audio Renderer\n"); CoTaskMemFree(This); return 0; } else return refCount; }
HRESULT WINAPI QualityControlImpl_Notify(IQualityControl *iface, IBaseFilter *sender, Quality qm) { HRESULT hr = S_FALSE; QualityControlImpl *This = (QualityControlImpl*)iface; if (This->tonotify) return IQualityControl_Notify(This->tonotify, This->self, qm); if (This->input) { IPin *to = NULL; IPin_ConnectedTo(This->input, &to); if (to) { IQualityControl *qc = NULL; IPin_QueryInterface(to, &IID_IQualityControl, (void**)&qc); if (qc) { hr = IQualityControl_Notify(qc, This->self, qm); IQualityControl_Release(qc); } IPin_Release(to); } } return hr; }
ULONG WINAPI TransformFilterImpl_Release(IBaseFilter * iface) { TransformFilter *This = impl_from_IBaseFilter(iface); ULONG refCount = InterlockedDecrement(&This->filter.refCount); TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1); if (!refCount) { ULONG i; for (i = 0; i < This->npins; i++) { IPin *pConnectedTo; if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect(This->ppPins[i]); IPin_Release(This->ppPins[i]); } CoTaskMemFree(This->ppPins); TRACE("Destroying transform filter\n"); This->csReceive.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csReceive); FreeMediaType(&This->pmt); QualityControlImpl_Destroy(This->qcimpl); IUnknown_Release(This->seekthru_unk); BaseFilter_Destroy(&This->filter); CoTaskMemFree(This); return 0; } else return refCount; }
ULONG WINAPI TransformFilterImpl_Release(IBaseFilter * iface) { TransformFilter *This = (TransformFilter *)iface; ULONG refCount = BaseFilterImpl_Release(iface); TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1); if (!refCount) { ULONG i; for (i = 0; i < This->npins; i++) { IPin *pConnectedTo; if (SUCCEEDED(IPin_ConnectedTo(This->ppPins[i], &pConnectedTo))) { IPin_Disconnect(pConnectedTo); IPin_Release(pConnectedTo); } IPin_Disconnect(This->ppPins[i]); IPin_Release(This->ppPins[i]); } CoTaskMemFree(This->ppPins); TRACE("Destroying transform filter\n"); FreeMediaType(&This->pmt); CoTaskMemFree(This); return 0; } else return refCount; }
static void test_media_streams(void) { HRESULT hr; IMediaStream *video_stream = NULL; IMediaStream *audio_stream = NULL; IMediaStream *dummy_stream; IMediaStreamFilter* media_stream_filter = NULL; if (!create_ammultimediastream()) return; if (!create_directdraw()) { release_ammultimediastream(); return; } hr = IAMMultiMediaStream_Initialize(pams, STREAMTYPE_READ, 0, NULL); ok(hr == S_OK, "IAMMultiMediaStream_Initialize returned: %x\n", hr); /* Retrieve media stream filter */ hr = IAMMultiMediaStream_GetFilter(pams, NULL); ok(hr == E_POINTER, "IAMMultiMediaStream_GetFilter returned: %x\n", hr); hr = IAMMultiMediaStream_GetFilter(pams, &media_stream_filter); ok(hr == S_OK, "IAMMultiMediaStream_GetFilter returned: %x\n", hr); /* Verify behaviour with invalid purpose id */ hr = IAMMultiMediaStream_GetMediaStream(pams, &IID_IUnknown, &dummy_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_AddMediaStream(pams, NULL, &IID_IUnknown, 0, NULL); ok(hr == MS_E_PURPOSEID, "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); /* Verify there is no video media stream */ hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &video_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* Verify there is no default renderer for video stream */ hr = IAMMultiMediaStream_AddMediaStream(pams, (IUnknown*)pdd7, &MSPID_PrimaryVideo, AMMSF_ADDDEFAULTRENDERER, NULL); ok(hr == MS_E_PURPOSEID, "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &video_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_AddMediaStream(pams, NULL, &MSPID_PrimaryVideo, AMMSF_ADDDEFAULTRENDERER, NULL); ok(hr == MS_E_PURPOSEID, "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &video_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* Verify normal case for video stream */ hr = IAMMultiMediaStream_AddMediaStream(pams, NULL, &MSPID_PrimaryVideo, 0, NULL); ok(hr == S_OK, "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &video_stream); ok(hr == S_OK, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* Verify the video stream has been added to the media stream filter */ if (media_stream_filter) { hr = IMediaStreamFilter_GetMediaStream(media_stream_filter, &MSPID_PrimaryVideo, &dummy_stream); ok(hr == S_OK, "IMediaStreamFilter_GetMediaStream returned: %x\n", hr); ok(dummy_stream == video_stream, "Got wrong returned pointer %p, expected %p\n", dummy_stream, video_stream); if (SUCCEEDED(hr)) IMediaStream_Release(dummy_stream); } /* Check interfaces and samples for video */ if (video_stream) { IAMMediaStream* am_media_stream; IAudioMediaStream* audio_media_stream; IDirectDrawMediaStream *ddraw_stream = NULL; IDirectDrawStreamSample *ddraw_sample = NULL; hr = IMediaStream_QueryInterface(video_stream, &IID_IAMMediaStream, (LPVOID*)&am_media_stream); todo_wine ok(hr == S_OK, "IMediaStream_QueryInterface returned: %x\n", hr); todo_wine ok((void*)am_media_stream == (void*)video_stream, "Not same interface, got %p expected %p\n", am_media_stream, video_stream); if (hr == S_OK) IAMMediaStream_Release(am_media_stream); hr = IMediaStream_QueryInterface(video_stream, &IID_IAudioMediaStream, (LPVOID*)&audio_media_stream); ok(hr == E_NOINTERFACE, "IMediaStream_QueryInterface returned: %x\n", hr); hr = IMediaStream_QueryInterface(video_stream, &IID_IDirectDrawMediaStream, (LPVOID*)&ddraw_stream); ok(hr == S_OK, "IMediaStream_QueryInterface returned: %x\n", hr); if (SUCCEEDED(hr)) { DDSURFACEDESC current_format, desired_format; IDirectDrawPalette *palette; DWORD flags; hr = IDirectDrawMediaStream_GetFormat(ddraw_stream, ¤t_format, &palette, &desired_format, &flags); ok(hr == MS_E_NOSTREAM, "IDirectDrawoMediaStream_GetFormat returned: %x\n", hr); hr = IDirectDrawMediaStream_CreateSample(ddraw_stream, NULL, NULL, 0, &ddraw_sample); ok(hr == S_OK, "IDirectDrawMediaStream_CreateSample returned: %x\n", hr); } if (ddraw_sample) IDirectDrawStreamSample_Release(ddraw_sample); if (ddraw_stream) IDirectDrawMediaStream_Release(ddraw_stream); } /* Verify there is no audio media stream */ hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryAudio, &audio_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* Verify no stream is created when using the default renderer for audio stream */ hr = IAMMultiMediaStream_AddMediaStream(pams, NULL, &MSPID_PrimaryAudio, AMMSF_ADDDEFAULTRENDERER, NULL); ok((hr == S_OK) || (hr == VFW_E_NO_AUDIO_HARDWARE), "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); if (hr == S_OK) { IGraphBuilder* filtergraph = NULL; IBaseFilter* filter = NULL; const WCHAR name[] = {'0','0','0','1',0}; CLSID clsid; hr = IAMMultiMediaStream_GetFilterGraph(pams, &filtergraph); ok(hr == S_OK, "IAMMultiMediaStream_GetFilterGraph returned: %x\n", hr); if (hr == S_OK) { hr = IGraphBuilder_FindFilterByName(filtergraph, name, &filter); ok(hr == S_OK, "IGraphBuilder_FindFilterByName returned: %x\n", hr); } if (hr == S_OK) { hr = IBaseFilter_GetClassID(filter, &clsid); ok(hr == S_OK, "IGraphBuilder_FindFilterByName returned: %x\n", hr); } if (hr == S_OK) ok(IsEqualGUID(&clsid, &CLSID_DSoundRender), "Got wrong CLSID\n"); if (filter) IBaseFilter_Release(filter); if (filtergraph) IGraphBuilder_Release(filtergraph); } hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryAudio, &audio_stream); ok(hr == MS_E_NOSTREAM, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* Verify a stream is created when no default renderer is used */ hr = IAMMultiMediaStream_AddMediaStream(pams, NULL, &MSPID_PrimaryAudio, 0, NULL); ok(hr == S_OK, "IAMMultiMediaStream_AddMediaStream returned: %x\n", hr); hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryAudio, &audio_stream); ok(hr == S_OK, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); /* verify the audio stream has been added to the media stream filter */ if (media_stream_filter) { hr = IMediaStreamFilter_GetMediaStream(media_stream_filter, &MSPID_PrimaryAudio, &dummy_stream); ok(hr == S_OK, "IAMMultiMediaStream_GetMediaStream returned: %x\n", hr); ok(dummy_stream == audio_stream, "Got wrong returned pointer %p, expected %p\n", dummy_stream, audio_stream); if (SUCCEEDED(hr)) IMediaStream_Release(dummy_stream); } /* Check interfaces and samples for audio */ if (audio_stream) { IAMMediaStream* am_media_stream; IDirectDrawMediaStream* ddraw_stream = NULL; IAudioMediaStream* audio_media_stream = NULL; IAudioStreamSample *audio_sample = NULL; hr = IMediaStream_QueryInterface(audio_stream, &IID_IAMMediaStream, (LPVOID*)&am_media_stream); todo_wine ok(hr == S_OK, "IMediaStream_QueryInterface returned: %x\n", hr); todo_wine ok((void*)am_media_stream == (void*)audio_stream, "Not same interface, got %p expected %p\n", am_media_stream, video_stream); if (hr == S_OK) IAMMediaStream_Release(am_media_stream); hr = IMediaStream_QueryInterface(audio_stream, &IID_IDirectDrawMediaStream, (LPVOID*)&ddraw_stream); ok(hr == E_NOINTERFACE, "IMediaStream_QueryInterface returned: %x\n", hr); hr = IMediaStream_QueryInterface(audio_stream, &IID_IAudioMediaStream, (LPVOID*)&audio_media_stream); ok(hr == S_OK, "IMediaStream_QueryInterface returned: %x\n", hr); if (SUCCEEDED(hr)) { IAudioData* audio_data = NULL; WAVEFORMATEX format; hr = CoCreateInstance(&CLSID_AMAudioData, NULL, CLSCTX_INPROC_SERVER, &IID_IAudioData, (void **)&audio_data); ok(hr == S_OK, "CoCreateInstance returned: %x\n", hr); hr = IAudioMediaStream_GetFormat(audio_media_stream, NULL); ok(hr == E_POINTER, "IAudioMediaStream_GetFormat returned: %x\n", hr); hr = IAudioMediaStream_GetFormat(audio_media_stream, &format); ok(hr == MS_E_NOSTREAM, "IAudioMediaStream_GetFormat returned: %x\n", hr); hr = IAudioMediaStream_CreateSample(audio_media_stream, NULL, 0, &audio_sample); ok(hr == E_POINTER, "IAudioMediaStream_CreateSample returned: %x\n", hr); hr = IAudioMediaStream_CreateSample(audio_media_stream, audio_data, 0, &audio_sample); ok(hr == S_OK, "IAudioMediaStream_CreateSample returned: %x\n", hr); if (audio_data) IAudioData_Release(audio_data); if (audio_sample) IAudioStreamSample_Release(audio_sample); if (audio_media_stream) IAudioMediaStream_Release(audio_media_stream); } } if (media_stream_filter) { IEnumPins *enum_pins; hr = IMediaStreamFilter_EnumPins(media_stream_filter, &enum_pins); ok(hr == S_OK, "IBaseFilter_EnumPins returned: %x\n", hr); if (hr == S_OK) { IPin* pins[3] = { NULL, NULL, NULL }; ULONG nb_pins; ULONG expected_nb_pins = audio_stream ? 2 : 1; int i; hr = IEnumPins_Next(enum_pins, 3, pins, &nb_pins); ok(SUCCEEDED(hr), "IEnumPins_Next returned: %x\n", hr); ok(nb_pins == expected_nb_pins, "Number of pins is %u instead of %u\n", nb_pins, expected_nb_pins); for (i = 0; i < min(nb_pins, expected_nb_pins); i++) { IEnumMediaTypes* enum_media_types; AM_MEDIA_TYPE* media_types[10]; ULONG nb_media_types; IPin* pin; PIN_INFO info; WCHAR id[40]; /* Pin name is "I{guid MSPID_PrimaryVideo or MSPID_PrimaryAudio}" */ id[0] = 'I'; StringFromGUID2(i ? &MSPID_PrimaryAudio : &MSPID_PrimaryVideo, id + 1, 40); hr = IPin_ConnectedTo(pins[i], &pin); ok(hr == VFW_E_NOT_CONNECTED, "IPin_ConnectedTo returned: %x\n", hr); hr = IPin_QueryPinInfo(pins[i], &info); ok(hr == S_OK, "IPin_QueryPinInfo returned: %x\n", hr); IBaseFilter_Release(info.pFilter); ok(info.dir == PINDIR_INPUT, "Pin direction is %u instead of %u\n", info.dir, PINDIR_INPUT); ok(!lstrcmpW(info.achName, id), "Pin name is %s instead of %s\n", wine_dbgstr_w(info.achName), wine_dbgstr_w(id)); hr = IPin_EnumMediaTypes(pins[i], &enum_media_types); ok(hr == S_OK, "IPin_EnumMediaTypes returned: %x\n", hr); hr = IEnumMediaTypes_Next(enum_media_types, sizeof(media_types) / sizeof(AM_MEDIA_TYPE), media_types, &nb_media_types); ok(SUCCEEDED(hr), "IEnumMediaTypes_Next returned: %x\n", hr); ok(nb_media_types == 0, "nb_media_types should be 0 instead of %u\n", nb_media_types); IEnumMediaTypes_Release(enum_media_types); IPin_Release(pins[i]); } IEnumPins_Release(enum_pins); } } if (video_stream) IMediaStream_Release(video_stream); if (audio_stream) IMediaStream_Release(audio_stream); if (media_stream_filter) IMediaStreamFilter_Release(media_stream_filter); release_directdraw(); release_ammultimediastream(); }
/* This test doesn't use the quartz filtergraph because it makes it impossible * to be certain that a thread is really one owned by the avi splitter. * A lot of the decoder filters will also have their own thread, and Windows' * filtergraph has a separate thread for start/stop/seeking requests. * By avoiding the filtergraph altogether and connecting streams directly to * the null renderer I am sure that this is not the case here. */ static void test_threads(void) { IFileSourceFilter *pfile = NULL; IBaseFilter *preader = NULL, *pavi = NULL; IEnumPins *enumpins = NULL; IPin *filepin = NULL, *avipin = NULL; HRESULT hr; int baselevel, curlevel, expected; HANDLE file = NULL; PIN_DIRECTION dir = PINDIR_OUTPUT; char buffer[13]; DWORD readbytes; FILTER_STATE state; /* We need another way of counting threads on NT4. Skip these tests (for now) */ if (!pCreateToolhelp32Snapshot || !pThread32First || !pThread32Next) { win_skip("Needed thread functions are not available (NT4)\n"); return; } /* Before doing anything (the thread count at the start differs per OS) */ baselevel = count_threads(); file = CreateFileW(wfile, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); if (file == INVALID_HANDLE_VALUE) { skip("Could not read test file \"%s\", skipping test\n", afile); return; } memset(buffer, 0, 13); readbytes = 12; ReadFile(file, buffer, readbytes, &readbytes, NULL); CloseHandle(file); if (strncmp(buffer, "RIFF", 4) || strcmp(buffer + 8, "AVI ")) { skip("%s is not an avi riff file, not doing the avi splitter test\n", afile); return; } hr = IUnknown_QueryInterface(pAviSplitter, &IID_IFileSourceFilter, (void **)&pfile); ok(hr == E_NOINTERFACE, "Avi splitter returns unexpected error: %08x\n", hr); if (pfile) IFileSourceFilter_Release(pfile); pfile = NULL; hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&preader); ok(hr == S_OK, "Could not create asynchronous reader: %08x\n", hr); if (hr != S_OK) goto fail; hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (void**)&pfile); ok(hr == S_OK, "Could not get IFileSourceFilter: %08x\n", hr); if (hr != S_OK) goto fail; hr = IUnknown_QueryInterface(pAviSplitter, &IID_IBaseFilter, (void**)&pavi); ok(hr == S_OK, "Could not get base filter: %08x\n", hr); if (hr != S_OK) goto fail; hr = IFileSourceFilter_Load(pfile, wfile, NULL); if (hr != S_OK) { trace("Could not load file\n"); goto fail; } hr = IBaseFilter_EnumPins(preader, &enumpins); ok(hr == S_OK, "No enumpins: %08x\n", hr); if (hr != S_OK) goto fail; hr = IEnumPins_Next(enumpins, 1, &filepin, NULL); ok(hr == S_OK, "No pin: %08x\n", hr); if (hr != S_OK) goto fail; IEnumPins_Release(enumpins); enumpins = NULL; hr = IBaseFilter_EnumPins(pavi, &enumpins); ok(hr == S_OK, "No enumpins: %08x\n", hr); if (hr != S_OK) goto fail; hr = IEnumPins_Next(enumpins, 1, &avipin, NULL); ok(hr == S_OK, "No pin: %08x\n", hr); if (hr != S_OK) goto fail; curlevel = count_threads(); ok(curlevel == baselevel, "The thread count should be %d not %d\n", baselevel, curlevel); hr = IPin_Connect(filepin, avipin, NULL); ok(hr == S_OK, "Could not connect: %08x\n", hr); if (hr != S_OK) goto fail; expected = 1 + baselevel; curlevel = count_threads(); ok(curlevel == expected, "The thread count should be %d not %d\n", expected, curlevel); IPin_Release(avipin); avipin = NULL; IEnumPins_Reset(enumpins); /* Windows puts the pins in the order: Outputpins - Inputpin, * wine does the reverse, just don't test it for now * Hate to admit it, but windows way makes more sense */ while (IEnumPins_Next(enumpins, 1, &avipin, NULL) == S_OK) { IPin_QueryDirection(avipin, &dir); if (dir == PINDIR_OUTPUT) { /* Well, connect it to a null renderer! */ IBaseFilter *pnull = NULL; IEnumPins *nullenum = NULL; IPin *nullpin = NULL; hr = CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pnull); ok(hr == S_OK, "Could not create null renderer: %08x\n", hr); if (hr != S_OK) break; IBaseFilter_EnumPins(pnull, &nullenum); IEnumPins_Next(nullenum, 1, &nullpin, NULL); IEnumPins_Release(nullenum); IPin_QueryDirection(nullpin, &dir); hr = IPin_Connect(avipin, nullpin, NULL); ok(hr == S_OK, "Failed to connect output pin: %08x\n", hr); IPin_Release(nullpin); if (hr != S_OK) { IBaseFilter_Release(pnull); break; } IBaseFilter_Run(pnull, 0); ++expected; } IPin_Release(avipin); avipin = NULL; } if (avipin) IPin_Release(avipin); avipin = NULL; if (hr != S_OK) goto fail2; /* At this point there is a minimalistic connected avi splitter that can * be used for all sorts of source filter tests. However that still needs * to be written at a later time. * * Interesting tests: * - Can you disconnect an output pin while running? * Expecting: Yes * - Can you disconnect the pullpin while running? * Expecting: No * - Is the reference count incremented during playback or when connected? * Does this happen once for every output pin? Or is there something else * going on. * Expecting: You tell me */ IBaseFilter_Run(preader, 0); IBaseFilter_Run(pavi, 0); IBaseFilter_GetState(pavi, INFINITE, &state); curlevel = count_threads(); ok(curlevel == expected, "The thread count should be %d not %d\n", expected, curlevel); IBaseFilter_Pause(pavi); IBaseFilter_Pause(preader); IBaseFilter_Stop(pavi); IBaseFilter_Stop(preader); IBaseFilter_GetState(pavi, INFINITE, &state); IBaseFilter_GetState(preader, INFINITE, &state); fail2: IEnumPins_Reset(enumpins); while (IEnumPins_Next(enumpins, 1, &avipin, NULL) == S_OK) { IPin *to = NULL; IPin_QueryDirection(avipin, &dir); IPin_ConnectedTo(avipin, &to); if (to) { IPin_Release(to); if (dir == PINDIR_OUTPUT) { PIN_INFO info; IPin_QueryPinInfo(to, &info); /* Release twice: Once normal, second from the * previous while loop */ IBaseFilter_Stop(info.pFilter); IPin_Disconnect(to); IPin_Disconnect(avipin); IBaseFilter_Release(info.pFilter); IBaseFilter_Release(info.pFilter); } else { IPin_Disconnect(to); IPin_Disconnect(avipin); } } IPin_Release(avipin); avipin = NULL; } fail: if (hr != S_OK) skip("Prerequisites not matched, skipping remainder of test\n"); if (enumpins) IEnumPins_Release(enumpins); if (avipin) IPin_Release(avipin); if (filepin) { IPin *to = NULL; IPin_ConnectedTo(filepin, &to); if (to) { IPin_Disconnect(filepin); IPin_Disconnect(to); } IPin_Release(filepin); } if (preader) IBaseFilter_Release(preader); if (pavi) IBaseFilter_Release(pavi); if (pfile) IFileSourceFilter_Release(pfile); curlevel = count_threads(); todo_wine ok(curlevel == baselevel, "The thread count should be %d not %d\n", baselevel, curlevel); }
static void test_AviMux(void) { test_filter source_filter, sink_filter; VIDEOINFOHEADER videoinfoheader; IPin *avimux_in, *avimux_out, *pin; AM_MEDIA_TYPE source_media_type; AM_MEDIA_TYPE *media_type; PIN_DIRECTION dir; IBaseFilter *avimux; IEnumPins *ep; IEnumMediaTypes *emt; HRESULT hr; init_test_filter(&source_filter, PINDIR_OUTPUT, SOURCE_FILTER); init_test_filter(&sink_filter, PINDIR_INPUT, SINK_FILTER); hr = CoCreateInstance(&CLSID_AviDest, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void**)&avimux); ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG), "couldn't create AVI Mux filter, hr = %08x\n", hr); if(hr != S_OK) { win_skip("AVI Mux filter is not registered\n"); return; } hr = IBaseFilter_EnumPins(avimux, &ep); ok(hr == S_OK, "EnumPins returned %x\n", hr); hr = IEnumPins_Next(ep, 1, &avimux_out, NULL); ok(hr == S_OK, "Next returned %x\n", hr); hr = IPin_QueryDirection(avimux_out, &dir); ok(hr == S_OK, "QueryDirection returned %x\n", hr); ok(dir == PINDIR_OUTPUT, "dir = %d\n", dir); hr = IEnumPins_Next(ep, 1, &avimux_in, NULL); ok(hr == S_OK, "Next returned %x\n", hr); hr = IPin_QueryDirection(avimux_in, &dir); ok(hr == S_OK, "QueryDirection returned %x\n", hr); ok(dir == PINDIR_INPUT, "dir = %d\n", dir); IEnumPins_Release(ep); hr = IPin_EnumMediaTypes(avimux_out, &emt); ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr); hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL); ok(hr == S_OK, "Next returned %x\n", hr); ok(IsEqualIID(&media_type->majortype, &MEDIATYPE_Stream), "majortype = %s\n", debugstr_guid(&media_type->majortype)); ok(IsEqualIID(&media_type->subtype, &MEDIASUBTYPE_Avi), "subtype = %s\n", debugstr_guid(&media_type->subtype)); ok(media_type->bFixedSizeSamples, "bFixedSizeSamples = %x\n", media_type->bFixedSizeSamples); ok(!media_type->bTemporalCompression, "bTemporalCompression = %x\n", media_type->bTemporalCompression); ok(media_type->lSampleSize == 1, "lSampleSize = %d\n", media_type->lSampleSize); ok(IsEqualIID(&media_type->formattype, &GUID_NULL), "formattype = %s\n", debugstr_guid(&media_type->formattype)); ok(!media_type->pUnk, "pUnk = %p\n", media_type->pUnk); ok(!media_type->cbFormat, "cbFormat = %d\n", media_type->cbFormat); ok(!media_type->pbFormat, "pbFormat = %p\n", media_type->pbFormat); CoTaskMemFree(media_type); hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL); ok(hr == S_FALSE, "Next returned %x\n", hr); IEnumMediaTypes_Release(emt); hr = IPin_EnumMediaTypes(avimux_in, &emt); ok(hr == S_OK, "EnumMediaTypes returned %x\n", hr); hr = IEnumMediaTypes_Reset(emt); ok(hr == S_OK, "Reset returned %x\n", hr); hr = IEnumMediaTypes_Next(emt, 1, &media_type, NULL); ok(hr == S_FALSE, "Next returned %x\n", hr); IEnumMediaTypes_Release(emt); hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, NULL); ok(hr == E_POINTER, "ReceiveConnection returned %x\n", hr); current_calls_list = NULL; memset(&source_media_type, 0, sizeof(AM_MEDIA_TYPE)); memset(&videoinfoheader, 0, sizeof(VIDEOINFOHEADER)); source_media_type.majortype = MEDIATYPE_Video; source_media_type.subtype = MEDIASUBTYPE_RGB32; source_media_type.formattype = FORMAT_VideoInfo; source_media_type.bFixedSizeSamples = TRUE; source_media_type.lSampleSize = 40000; source_media_type.cbFormat = sizeof(VIDEOINFOHEADER); source_media_type.pbFormat = (BYTE*)&videoinfoheader; videoinfoheader.AvgTimePerFrame = 333333; videoinfoheader.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); videoinfoheader.bmiHeader.biWidth = 100; videoinfoheader.bmiHeader.biHeight = 100; videoinfoheader.bmiHeader.biPlanes = 1; videoinfoheader.bmiHeader.biBitCount = 32; videoinfoheader.bmiHeader.biSizeImage = 40000; videoinfoheader.bmiHeader.biClrImportant = 256; hr = IPin_ReceiveConnection(avimux_in, &source_filter.IPin_iface, &source_media_type); ok(hr == S_OK, "ReceiveConnection returned %x\n", hr); hr = IPin_ConnectedTo(avimux_in, &pin); ok(hr == S_OK, "ConnectedTo returned %x\n", hr); ok(pin == &source_filter.IPin_iface, "incorrect pin: %p, expected %p\n", pin, &source_filter.IPin_iface); hr = IPin_Connect(avimux_out, &source_filter.IPin_iface, NULL); todo_wine ok(hr == VFW_E_INVALID_DIRECTION, "Connect returned %x\n", hr); hr = IBaseFilter_JoinFilterGraph(avimux, (IFilterGraph*)&GraphBuilder, NULL); ok(hr == S_OK, "JoinFilterGraph returned %x\n", hr); SET_EXPECT(ReceiveConnection); SET_EXPECT(GetAllocatorRequirements); SET_EXPECT(NotifyAllocator); SET_EXPECT(Reconnect); hr = IPin_Connect(avimux_out, &sink_filter.IPin_iface, NULL); ok(hr == S_OK, "Connect returned %x\n", hr); CHECK_CALLED(ReceiveConnection); CHECK_CALLED(GetAllocatorRequirements); CHECK_CALLED(NotifyAllocator); CHECK_CALLED(Reconnect); hr = IPin_Disconnect(avimux_out); ok(hr == S_OK, "Disconnect returned %x\n", hr); IPin_Release(avimux_in); IPin_Release(avimux_out); IBaseFilter_Release(avimux); }