static void test_openfile(void)
{
HRESULT hr;
IGraphBuilder* pgraph;
if (!create_ammultimediastream())
return;
hr = IAMMultiMediaStream_GetFilterGraph(pams, &pgraph);
ok(hr==S_OK, "IAMMultiMediaStream_GetFilterGraph returned: %x\n", hr);
ok(pgraph==NULL, "Filtergraph should not be created yet\n");
if (pgraph)
IGraphBuilder_Release(pgraph);
hr = IAMMultiMediaStream_OpenFile(pams, filenameW, 0);
ok(hr==S_OK, "IAMMultiMediaStream_OpenFile returned: %x\n", hr);
hr = IAMMultiMediaStream_GetFilterGraph(pams, &pgraph);
ok(hr==S_OK, "IAMMultiMediaStream_GetFilterGraph returned: %x\n", hr);
ok(pgraph!=NULL, "Filtergraph should be created\n");
if (pgraph)
IGraphBuilder_Release(pgraph);
release_ammultimediastream();
}
static ULONG WINAPI IAMMultiMediaStreamImpl_Release(IAMMultiMediaStream* iface)
{
IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
ULONG ref = InterlockedDecrement(&This->ref);
ULONG i;
TRACE("(%p/%p)\n", iface, This);
if (!ref)
{
for(i = 0; i < This->nbStreams; i++)
IMediaStream_Release(This->pStreams[i]);
if (This->ipin)
IPin_Release(This->ipin);
if (This->media_stream_filter)
IBaseFilter_Release(This->media_stream_filter);
if (This->media_seeking)
IMediaSeeking_Release(This->media_seeking);
if (This->media_control)
IMediaControl_Release(This->media_control);
if (This->pFilterGraph)
IGraphBuilder_Release(This->pFilterGraph);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
}
/***************************************************************************
* MCIQTZ_mciClose [internal]
*/
static DWORD MCIQTZ_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIQTZ* wma;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
wma = MCIQTZ_mciGetOpenDev(wDevID);
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
if (wma->opened) {
IVideoWindow_Release(wma->vidwin);
IBasicVideo_Release(wma->vidbasic);
IMediaSeeking_Release(wma->seek);
IMediaEvent_Release(wma->mevent);
IGraphBuilder_Release(wma->pgraph);
IMediaControl_Release(wma->pmctrl);
if (wma->uninit)
CoUninitialize();
wma->opened = FALSE;
}
return 0;
}
static void releasefiltergraph(void)
{
HRESULT hr;
hr = IGraphBuilder_Release(pgraph);
ok(hr==0, "Releasing filtergraph returned: %lx\n", hr);
}
/*** IAMMultiMediaStream methods ***/
static HRESULT WINAPI IAMMultiMediaStreamImpl_Initialize(IAMMultiMediaStream* iface, STREAM_TYPE StreamType, DWORD dwFlags, IGraphBuilder* pFilterGraph)
{
IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
HRESULT hr = S_OK;
const WCHAR filternameW[] = {'M','e','d','i','a','S','t','r','e','a','m','F','i','l','t','e','r',0};
TRACE("(%p/%p)->(%x,%x,%p)\n", This, iface, (DWORD)StreamType, dwFlags, pFilterGraph);
if (pFilterGraph)
{
This->pFilterGraph = pFilterGraph;
IGraphBuilder_AddRef(This->pFilterGraph);
}
else
{
hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&This->pFilterGraph);
}
if (SUCCEEDED(hr))
{
This->StreamType = StreamType;
hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaSeeking, (void**)&This->media_seeking);
if (SUCCEEDED(hr))
IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaControl, (void**)&This->media_control);
if (SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MediaStreamFilter, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&This->media_stream_filter);
if (SUCCEEDED(hr))
IGraphBuilder_AddFilter(This->pFilterGraph, This->media_stream_filter, filternameW);
if (SUCCEEDED(hr))
{
IMediaEventEx* media_event = NULL;
hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaEventEx, (void**)&media_event);
if (SUCCEEDED(hr))
hr = IMediaEventEx_GetEventHandle(media_event, &This->event);
if (SUCCEEDED(hr))
hr = IMediaEventEx_SetNotifyFlags(media_event, AM_MEDIAEVENT_NONOTIFY);
if (media_event)
IMediaEventEx_Release(media_event);
}
}
if (FAILED(hr))
{
if (This->media_stream_filter)
IBaseFilter_Release(This->media_stream_filter);
This->media_stream_filter = NULL;
if (This->media_seeking)
IMediaSeeking_Release(This->media_seeking);
This->media_seeking = NULL;
if (This->media_control)
IMediaControl_Release(This->media_control);
This->media_control = NULL;
if (This->pFilterGraph)
IGraphBuilder_Release(This->pFilterGraph);
This->pFilterGraph = NULL;
}
return hr;
}
static void MD_cleanup(MediaDetImpl *This)
{
if (This->cur_pin) IPin_Release(This->cur_pin);
This->cur_pin = NULL;
if (This->source) IBaseFilter_Release(This->source);
This->source = NULL;
if (This->splitter) IBaseFilter_Release(This->splitter);
This->splitter = NULL;
if (This->graph) IGraphBuilder_Release(This->graph);
This->graph = NULL;
This->num_streams = -1;
This->cur_stream = 0;
}
static void test_openfile(void)
{
HANDLE h;
HRESULT hr;
WCHAR fileW[FILE_LEN];
IGraphBuilder* pgraph;
if (!create_ammultimediastream())
return;
h = CreateFileA(fileA, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
if (h == INVALID_HANDLE_VALUE) {
release_ammultimediastream();
return;
}
MultiByteToWideChar(CP_ACP, 0, fileA, -1, fileW, FILE_LEN);
hr = IAMMultiMediaStream_GetFilterGraph(pams, &pgraph);
ok(hr==S_OK, "IAMMultiMediaStream_GetFilterGraph returned: %x\n", hr);
ok(pgraph==NULL, "Filtergraph should not be created yet\n");
if (pgraph)
IGraphBuilder_Release(pgraph);
hr = IAMMultiMediaStream_OpenFile(pams, fileW, 0);
ok(hr==S_OK, "IAMMultiMediaStream_OpenFile returned: %x\n", hr);
hr = IAMMultiMediaStream_GetFilterGraph(pams, &pgraph);
ok(hr==S_OK, "IAMMultiMediaStream_GetFilterGraph returned: %x\n", hr);
ok(pgraph!=NULL, "Filtergraph should be created\n");
if (pgraph)
IGraphBuilder_Release(pgraph);
release_ammultimediastream();
}
static ULONG WINAPI fnCaptureGraphBuilder2_Release(ICaptureGraphBuilder2 * iface)
{
CaptureGraphImpl *This = impl_from_ICaptureGraphBuilder2(iface);
DWORD ref = InterlockedDecrement(&This->ref);
TRACE("(%p/%p)->() Release from %d\n", This, iface, ref + 1);
if (!ref)
{
This->csFilter.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&This->csFilter);
if (This->mygraph)
IGraphBuilder_Release(This->mygraph);
CoTaskMemFree(This);
ObjectRefCount(FALSE);
}
return ref;
}
static HRESULT WINAPI MediaDet_put_Filename(IMediaDet* iface, BSTR newVal)
{
static const WCHAR reader[] = {'R','e','a','d','e','r',0};
MediaDetImpl *This = impl_from_IMediaDet(iface);
IGraphBuilder *gb;
IBaseFilter *bf;
HRESULT hr;
TRACE("(%p)->(%s)\n", This, debugstr_w(newVal));
if (This->graph)
{
WARN("MSDN says not to call this method twice\n");
MD_cleanup(This);
}
hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
&IID_IGraphBuilder, (void **) &gb);
if (FAILED(hr))
return hr;
hr = IGraphBuilder_AddSourceFilter(gb, newVal, reader, &bf);
if (FAILED(hr))
{
IGraphBuilder_Release(gb);
return hr;
}
This->graph = gb;
This->source = bf;
hr = GetSplitter(This);
if (FAILED(hr))
return hr;
return MediaDet_put_CurrentStream(iface, 0);
}
static int
dshow_read_close(AVFormatContext *s)
{
struct dshow_ctx *ctx = s->priv_data;
AVPacketList *pktl;
if (ctx->control) {
IMediaControl_Stop(ctx->control);
IMediaControl_Release(ctx->control);
}
if (ctx->media_event)
IMediaEvent_Release(ctx->media_event);
if (ctx->graph) {
IEnumFilters *fenum;
int r;
r = IGraphBuilder_EnumFilters(ctx->graph, &fenum);
if (r == S_OK) {
IBaseFilter *f;
IEnumFilters_Reset(fenum);
while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK) {
if (IGraphBuilder_RemoveFilter(ctx->graph, f) == S_OK)
IEnumFilters_Reset(fenum); /* When a filter is removed,
* the list must be reset. */
IBaseFilter_Release(f);
}
IEnumFilters_Release(fenum);
}
IGraphBuilder_Release(ctx->graph);
}
if (ctx->capture_pin[VideoDevice])
libAVPin_Release(ctx->capture_pin[VideoDevice]);
if (ctx->capture_pin[AudioDevice])
libAVPin_Release(ctx->capture_pin[AudioDevice]);
if (ctx->capture_filter[VideoDevice])
libAVFilter_Release(ctx->capture_filter[VideoDevice]);
if (ctx->capture_filter[AudioDevice])
libAVFilter_Release(ctx->capture_filter[AudioDevice]);
if (ctx->device_pin[VideoDevice])
IPin_Release(ctx->device_pin[VideoDevice]);
if (ctx->device_pin[AudioDevice])
IPin_Release(ctx->device_pin[AudioDevice]);
if (ctx->device_filter[VideoDevice])
IBaseFilter_Release(ctx->device_filter[VideoDevice]);
if (ctx->device_filter[AudioDevice])
IBaseFilter_Release(ctx->device_filter[AudioDevice]);
if (ctx->device_name[0])
av_freep(&ctx->device_name[0]);
if (ctx->device_name[1])
av_freep(&ctx->device_name[1]);
if(ctx->mutex)
CloseHandle(ctx->mutex);
if(ctx->event[0])
CloseHandle(ctx->event[0]);
if(ctx->event[1])
CloseHandle(ctx->event[1]);
pktl = ctx->pktl;
while (pktl) {
AVPacketList *next = pktl->next;
av_packet_unref(&pktl->pkt);
av_free(pktl);
pktl = next;
}
CoUninitialize();
return 0;
}
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();
}
/***************************************************************************
* MCIQTZ_mciOpen [internal]
*/
static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags,
LPMCI_DGV_OPEN_PARMSW lpOpenParms)
{
WINE_MCIQTZ* wma;
HRESULT hr;
DWORD style = 0;
RECT rc = { 0, 0, 0, 0 };
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
if (!lpOpenParms)
return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIQTZ_mciGetOpenDev(wDevID);
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
wma->uninit = SUCCEEDED(hr);
hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&wma->pgraph);
if (FAILED(hr)) {
TRACE("Cannot create filtergraph (hr = %x)\n", hr);
goto err;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaControl, (LPVOID*)&wma->pmctrl);
if (FAILED(hr)) {
TRACE("Cannot get IMediaControl interface (hr = %x)\n", hr);
goto err;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaSeeking, (void**)&wma->seek);
if (FAILED(hr)) {
TRACE("Cannot get IMediaSeeking interface (hr = %x)\n", hr);
goto err;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaEvent, (void**)&wma->mevent);
if (FAILED(hr)) {
TRACE("Cannot get IMediaEvent interface (hr = %x)\n", hr);
goto err;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&wma->vidwin);
if (FAILED(hr)) {
TRACE("Cannot get IVideoWindow interface (hr = %x)\n", hr);
goto err;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&wma->vidbasic);
if (FAILED(hr)) {
TRACE("Cannot get IBasicVideo interface (hr = %x)\n", hr);
goto err;
}
if (!(dwFlags & MCI_OPEN_ELEMENT) || (dwFlags & MCI_OPEN_ELEMENT_ID)) {
TRACE("Wrong dwFlags %x\n", dwFlags);
goto err;
}
if (!lpOpenParms->lpstrElementName || !lpOpenParms->lpstrElementName[0]) {
TRACE("Invalid filename specified\n");
goto err;
}
TRACE("Open file %s\n", debugstr_w(lpOpenParms->lpstrElementName));
hr = IGraphBuilder_RenderFile(wma->pgraph, lpOpenParms->lpstrElementName, NULL);
if (FAILED(hr)) {
TRACE("Cannot render file (hr = %x)\n", hr);
goto err;
}
IVideoWindow_put_AutoShow(wma->vidwin, OAFALSE);
IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
if (dwFlags & MCI_DGV_OPEN_WS)
style = lpOpenParms->dwStyle;
if (dwFlags & MCI_DGV_OPEN_PARENT) {
IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
IVideoWindow_put_WindowState(wma->vidwin, SW_HIDE);
IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
GetClientRect(lpOpenParms->hWndParent, &rc);
IVideoWindow_SetWindowPosition(wma->vidwin, rc.left, rc.top, rc.right - rc.top, rc.bottom - rc.top);
wma->parent = (HWND)lpOpenParms->hWndParent;
}
else if (style)
IVideoWindow_put_WindowStyle(wma->vidwin, style);
IBasicVideo_GetVideoSize(wma->vidbasic, &rc.right, &rc.bottom);
wma->opened = TRUE;
if (dwFlags & MCI_NOTIFY)
mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL);
return 0;
err:
if (wma->vidbasic)
IBasicVideo_Release(wma->vidbasic);
wma->vidbasic = NULL;
if (wma->seek)
IMediaSeeking_Release(wma->seek);
wma->seek = NULL;
if (wma->vidwin)
IVideoWindow_Release(wma->vidwin);
wma->vidwin = NULL;
if (wma->pgraph)
IGraphBuilder_Release(wma->pgraph);
wma->pgraph = NULL;
if (wma->mevent)
IMediaEvent_Release(wma->mevent);
wma->mevent = NULL;
if (wma->pmctrl)
IMediaControl_Release(wma->pmctrl);
wma->pmctrl = NULL;
if (wma->uninit)
CoUninitialize();
wma->uninit = 0;
return MCIERR_INTERNAL;
}
