/***************************************************************************
* 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 HRESULT WINAPI
IBasicVideo_fnIsUsingDefaultDestination(IBasicVideo* iface)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_IsUsingDefaultDestination(pVideo);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnGetVideoPaletteEntries(IBasicVideo* iface,long lStart,long lCount,long* plRet,long* plPaletteEntry)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_GetVideoPaletteEntries(pVideo,lStart,lCount,plRet,plPaletteEntry);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnGetCurrentImage(IBasicVideo* iface,long* plBufferSize,long* plDIBBuffer)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_GetCurrentImage(pVideo,plBufferSize,plDIBBuffer);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnSetDestinationPosition(IBasicVideo* iface,long lLeft,long lTop,long lWidth,long lHeight)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_SetDestinationPosition(pVideo,lLeft,lTop,lWidth,lHeight);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnGetVideoSize(IBasicVideo* iface,long* plWidth,long* plHeight)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_GetVideoSize(pVideo,plWidth,plHeight);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnput_DestinationTop(IBasicVideo* iface,long lTop)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_put_DestinationTop(pVideo,lTop);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnget_DestinationHeight(IBasicVideo* iface,long* plHeight)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_get_DestinationHeight(pVideo,plHeight);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnput_SourceHeight(IBasicVideo* iface,long lHeight)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_put_SourceHeight(pVideo,lHeight);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnget_SourceTop(IBasicVideo* iface,long* plTop)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_get_SourceTop(pVideo,plTop);
IBasicVideo_Release(pVideo);
return hr;
}
static HRESULT WINAPI
IBasicVideo_fnget_AvgTimePerFrame(IBasicVideo* iface,REFTIME* prefTime)
{
CFilterGraph_THIS(iface,basvid);
QUERYBASICVIDEO
TRACE("(%p)->()\n",This);
hr = IBasicVideo_get_AvgTimePerFrame(pVideo,prefTime);
IBasicVideo_Release(pVideo);
return hr;
}
/***************************************************************************
* 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;
}
/******************************************************************************
* MCIAVI_mciUpdate [internal]
*/
static DWORD MCIQTZ_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
{
WINE_MCIQTZ *wma;
DWORD res = 0;
TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
if (!lpParms)
return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIQTZ_mciGetOpenDev(wDevID);
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_UPDATE_HDC) {
IBasicVideo *vidbasic;
IVideoWindow *vidwin;
res = MCIERR_INTERNAL;
IFilterGraph2_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&vidwin);
IFilterGraph2_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&vidbasic);
if (vidbasic && vidwin) {
LONG state, size;
BYTE *data;
BITMAPINFO *info;
HRESULT hr;
RECT src, dest;
/* If in stopped state, nothing has been drawn to screen
* moving to pause, which is needed for the old dib renderer, will result
* in a single frame drawn, so hide the window here */
IVideoWindow_put_Visible(vidwin, OAFALSE);
/* FIXME: Should we check the original state and restore it? */
IMediaControl_Pause(wma->pmctrl);
IMediaControl_GetState(wma->pmctrl, -1, &state);
if (FAILED(hr = IBasicVideo_GetCurrentImage(vidbasic, &size, NULL))) {
WARN("Could not get image size (hr = %x)\n", hr);
goto out;
}
data = HeapAlloc(GetProcessHeap(), 0, size);
info = (BITMAPINFO*)data;
IBasicVideo_GetCurrentImage(vidbasic, &size, (LONG*)data);
data += info->bmiHeader.biSize;
IBasicVideo_GetSourcePosition(vidbasic, &src.left, &src.top, &src.right, &src.bottom);
IBasicVideo_GetDestinationPosition(vidbasic, &dest.left, &dest.top, &dest.right, &dest.bottom);
StretchDIBits(lpParms->hDC,
dest.left, dest.top, dest.right + dest.left, dest.bottom + dest.top,
src.left, src.top, src.right + src.left, src.bottom + src.top,
data, info, DIB_RGB_COLORS, SRCCOPY);
HeapFree(GetProcessHeap(), 0, data);
}
res = 0;
out:
if (vidbasic)
IBasicVideo_Release(vidbasic);
if (vidwin) {
if (wma->parent)
IVideoWindow_put_Visible(vidwin, OATRUE);
IVideoWindow_Release(vidwin);
}
}
else if (dwFlags)
FIXME("Unhandled flags %x\n", dwFlags);
return res;
}
/***************************************************************************
* MCIQTZ_mciWhere [internal]
*/
static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
{
WINE_MCIQTZ* wma;
IVideoWindow* pVideoWindow;
IBasicVideo *pBasicVideo;
HRESULT hr;
HWND hWnd;
RECT rc;
DWORD ret = MCIERR_UNRECOGNIZED_COMMAND;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (!lpParms)
return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIQTZ_mciGetOpenDev(wDevID);
if (!wma)
return MCIERR_INVALID_DEVICE_ID;
/* Find if there is a video stream and get the display window */
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
if (FAILED(hr)) {
ERR("Cannot get IVideoWindow interface (hr = %x)\n", hr);
return MCIERR_INTERNAL;
}
hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
if (FAILED(hr)) {
ERR("Cannot get IBasicVideo interface (hr = %x)\n", hr);
IUnknown_Release(pVideoWindow);
return MCIERR_INTERNAL;
}
hr = IVideoWindow_get_Owner(pVideoWindow, (OAHWND*)&hWnd);
if (FAILED(hr)) {
TRACE("No video stream, returning no window error\n");
IUnknown_Release(pVideoWindow);
return MCIERR_NO_WINDOW;
}
if (dwFlags & MCI_DGV_WHERE_SOURCE) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("MCI_DGV_WHERE_SOURCE_MAX stub %s\n", wine_dbgstr_rect(&rc));
IBasicVideo_get_SourceLeft(pBasicVideo, &rc.left);
IBasicVideo_get_SourceTop(pBasicVideo, &rc.top);
IBasicVideo_get_SourceWidth(pBasicVideo, &rc.right);
IBasicVideo_get_SourceHeight(pBasicVideo, &rc.bottom);
/* Undo conversion done below */
rc.right += rc.left;
rc.bottom += rc.top;
TRACE("MCI_DGV_WHERE_SOURCE %s\n", wine_dbgstr_rect(&rc));
}
if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetClientRect(hWnd, &rc);
TRACE("MCI_DGV_WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
} else {
FIXME("MCI_DGV_WHERE_DESTINATION not supported yet\n");
goto out;
}
}
if (dwFlags & MCI_DGV_WHERE_FRAME) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
else
FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
goto out;
}
if (dwFlags & MCI_DGV_WHERE_VIDEO) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
else
FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
goto out;
}
if (dwFlags & MCI_DGV_WHERE_WINDOW) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetWindowRect(GetDesktopWindow(), &rc);
TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
} else {
GetWindowRect(hWnd, &rc);
TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
}
}
ret = 0;
out:
/* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
* So convert the normal RECT into a MCI RECT before returning */
IVideoWindow_Release(pVideoWindow);
IBasicVideo_Release(pBasicVideo);
lpParms->rc.left = rc.left;
lpParms->rc.top = rc.top;
lpParms->rc.right = rc.right - rc.left;
lpParms->rc.bottom = rc.bottom - rc.top;
return ret;
}
