/***************************************************************************
* MCIAVI_mciClose [internal]
*/
DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD dwRet = 0;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
EnterCriticalSection(&wma->cs);
if (wma->nUseCount == 1) {
MCIAVI_CleanUp(wma);
if ((dwFlags & MCI_NOTIFY) && lpParms) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID,
MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return dwRet;
}
wma->nUseCount--;
LeaveCriticalSection(&wma->cs);
return dwRet;
}
/******************************************************************************
* MCIAVI_mciStep [internal]
*/
static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD position;
int delta = 1;
TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_STEP_FRAMES) delta = lpParms->dwFrames;
if (dwFlags & MCI_DGV_STEP_REVERSE) delta = -delta;
position = wma->dwCurrVideoFrame + delta;
if (position >= wma->dwPlayableVideoFrames) return MCIERR_OUTOFRANGE;
if (dwFlags & MCI_TEST) return 0;
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
EnterCriticalSection(&wma->cs);
wma->dwCurrVideoFrame = position;
TRACE("Stepping to frame=%u\n", wma->dwCurrVideoFrame);
if (dwFlags & MCI_NOTIFY) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciInfo [internal]
*/
DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
{
LPCWSTR str = 0;
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
static const WCHAR wszAviPlayer[] = {'W','i','n','e','\'','s',' ','A','V','I',' ','p','l','a','y','e','r',0};
if (lpParms == NULL || lpParms->lpstrReturn == NULL)
return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
TRACE("buf=%p, len=%u\n", lpParms->lpstrReturn, lpParms->dwRetSize);
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_INFO_PRODUCT)
str = wszAviPlayer;
else if (dwFlags & MCI_INFO_FILE)
str = wma->lpFileName;
else {
WARN("Don't know this info command (%u)\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
if (!ret) {
WCHAR zero = 0;
/* Only mciwave, mciseq and mcicda set dwRetSize (since NT). */
lstrcpynW(lpParms->lpstrReturn, str ? str : &zero, lpParms->dwRetSize);
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/***************************************************************************
* MCIAVI_mciWindow [internal]
*/
DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_WINDOW_HWND) {
if (IsWindow(lpParms->hWnd))
{
TRACE("Setting hWnd to %p\n", lpParms->hWnd);
if (wma->hWnd) ShowWindow(wma->hWnd, SW_HIDE);
wma->hWndPaint = (lpParms->hWnd == MCI_DGV_WINDOW_DEFAULT) ? wma->hWnd : lpParms->hWnd;
}
}
if (dwFlags & MCI_DGV_WINDOW_STATE) {
TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
ShowWindow(wma->hWndPaint, lpParms->nCmdShow);
}
if (dwFlags & MCI_DGV_WINDOW_TEXT) {
TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
SetWindowTextW(wma->hWndPaint, lpParms->lpstrText);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciPut [internal]
*/
DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
RECT rc;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_RECT) {
/* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
* So convert input MCI RECT into a normal RECT */
rc.left = lpParms->rc.left;
rc.top = lpParms->rc.top;
rc.right = lpParms->rc.left + lpParms->rc.right;
rc.bottom = lpParms->rc.top + lpParms->rc.bottom;
} else {
GetClientRect(wma->hWndPaint, &rc);
}
if (dwFlags & MCI_DGV_PUT_CLIENT) {
FIXME("PUT_CLIENT %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_DESTINATION) {
TRACE("PUT_DESTINATION %s\n", wine_dbgstr_rect(&rc));
wma->dest = rc;
}
if (dwFlags & MCI_DGV_PUT_FRAME) {
FIXME("PUT_FRAME %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_SOURCE) {
TRACE("PUT_SOURCE %s\n", wine_dbgstr_rect(&rc));
wma->source = rc;
}
if (dwFlags & MCI_DGV_PUT_VIDEO) {
FIXME("PUT_VIDEO %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_WINDOW) {
TRACE("PUT_WINDOW %s\n", wine_dbgstr_rect(&rc));
SetWindowPos(wma->hWndPaint, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/******************************************************************************
* MCIAVI_mciSetVideo [internal]
*/
static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
{
WINE_MCIAVI *wma;
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETVIDEO_ITEM ? lpParms->dwItem : 0);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/*****************************************************************************
* MCIAVI_mciLoad [internal]
*/
static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
}
/******************************************************************************
* MCIAVI_mciSignal [internal]
*/
static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
return 0;
}
/******************************************************************************
* MCIAVI_mciConfigure [internal]
*/
static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
return 0;
}
/***************************************************************************
* MCIAVI_mciStop [internal]
*/
static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD dwRet = 0;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
TRACE("current status %04x\n", wma->dwStatus);
switch (wma->dwStatus) {
case MCI_MODE_PLAY:
case MCI_MODE_RECORD:
LeaveCriticalSection(&wma->cs);
SetEvent(wma->hStopEvent);
EnterCriticalSection(&wma->cs);
/* fall through */
case MCI_MODE_PAUSE:
/* Since our wave notification callback takes the lock,
* we must release it before resetting the device */
LeaveCriticalSection(&wma->cs);
dwRet = waveOutReset(wma->hWave);
EnterCriticalSection(&wma->cs);
/* fall through */
default:
do /* one more chance for an async thread to finish */
{
LeaveCriticalSection(&wma->cs);
Sleep(10);
EnterCriticalSection(&wma->cs);
} while (wma->dwStatus != MCI_MODE_STOP);
break;
case MCI_MODE_NOT_READY:
break;
}
if ((dwFlags & MCI_NOTIFY) && lpParms) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return dwRet;
}
/***************************************************************************
* MCIAVI_mciPut [internal]
*/
DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
RECT rc;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_RECT) {
rc = lpParms->rc;
} else {
GetClientRect(wma->hWndPaint, &rc);
}
if (dwFlags & MCI_DGV_PUT_CLIENT) {
FIXME("PUT_CLIENT %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_DESTINATION) {
TRACE("PUT_DESTINATION %s\n", wine_dbgstr_rect(&rc));
wma->dest = rc;
}
if (dwFlags & MCI_DGV_PUT_FRAME) {
FIXME("PUT_FRAME %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_SOURCE) {
TRACE("PUT_SOURCE %s\n", wine_dbgstr_rect(&rc));
wma->source = rc;
}
if (dwFlags & MCI_DGV_PUT_VIDEO) {
FIXME("PUT_VIDEO %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_PUT_WINDOW) {
FIXME("PUT_WINDOW %s\n", wine_dbgstr_rect(&rc));
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/******************************************************************************
* MCIAVI_mciCue [internal]
*/
static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
{
WINE_MCIAVI *wma;
FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_CUE_INPUT) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
return 0;
}
/***************************************************************************
* MCIAVI_mciSeek [internal]
*/
static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD position;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
position = dwFlags & (MCI_SEEK_TO_START|MCI_SEEK_TO_END|MCI_TO);
if (!position) return MCIERR_MISSING_PARAMETER;
if (position&(position-1)) return MCIERR_FLAGS_NOT_COMPATIBLE;
if (dwFlags & MCI_TO) {
position = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
if (position >= wma->dwPlayableVideoFrames)
return MCIERR_OUTOFRANGE;
} else if (dwFlags & MCI_SEEK_TO_START) {
position = 0;
} else {
position = wma->dwPlayableVideoFrames - 1;
}
if (dwFlags & MCI_TEST) return 0;
MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
EnterCriticalSection(&wma->cs);
wma->dwCurrVideoFrame = position;
TRACE("Seeking to frame=%u\n", wma->dwCurrVideoFrame);
if (dwFlags & MCI_NOTIFY) {
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/******************************************************************************
* MCIAVI_mciUpdate [internal]
*/
static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
{
WINE_MCIAVI *wma;
TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
/* Ignore MCI_TEST flag. */
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_UPDATE_HDC)
MCIAVI_PaintFrame(wma, lpParms->hDC);
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciResume [internal]
*/
static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
WINE_MCIAVI *wma;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (wma->dwStatus == MCI_MODE_PAUSE)
wma->dwStatus = MCI_MODE_PLAY;
if (wma->lpWaveFormat) {
LeaveCriticalSection(&wma->cs);
return waveOutRestart(wma->hWave);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
static void CALLBACK MCIAVI_waveCallback(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
WINE_MCIAVI *wma = MCIAVI_mciGetOpenDev(dwInstance);
if (!wma) return;
EnterCriticalSection(&wma->cs);
switch (uMsg) {
case WOM_OPEN:
case WOM_CLOSE:
break;
case WOM_DONE:
InterlockedIncrement(&wma->dwEventCount);
TRACE("Returning waveHdr=%lx\n", dwParam1);
SetEvent(wma->hEvent);
break;
default:
ERR("Unknown uMsg=%d\n", uMsg);
}
LeaveCriticalSection(&wma->cs);
}
/***************************************************************************
* MCIAVI_mciInfo [internal]
*/
DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
{
LPCWSTR str = 0;
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
static const WCHAR wszAviPlayer[] = {'W','i','n','e','\'','s',' ','A','V','I',' ','p','l','a','y','e','r',0};
if (lpParms == NULL || lpParms->lpstrReturn == NULL)
return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_INFO_PRODUCT)
str = wszAviPlayer;
else if (dwFlags & MCI_INFO_FILE)
str = wma->lpFileName;
else {
WARN("Don't know this info command (%lu)\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
if (str) {
if (strlenW(str) + 1 > lpParms->dwRetSize) {
ret = MCIERR_PARAM_OVERFLOW;
} else {
lstrcpynW(lpParms->lpstrReturn, str, lpParms->dwRetSize);
}
} else {
lpParms->lpstrReturn[0] = 0;
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/***************************************************************************
* MCIAVI_mciPlay [internal]
*/
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD frameTime;
DWORD dwRet;
LPWAVEHDR waveHdr = NULL;
unsigned i, nHdr = 0;
DWORD dwFromFrame, dwToFrame;
DWORD numEvents = 1;
HANDLE events[2];
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (!wma->hFile)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_FILE_NOT_FOUND;
}
if (!wma->hWndPaint)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_NO_WINDOW;
}
LeaveCriticalSection(&wma->cs);
if (!(dwFlags & MCI_WAIT))
return MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
ShowWindow(wma->hWndPaint, SW_SHOWNA);
EnterCriticalSection(&wma->cs);
dwFromFrame = wma->dwCurrVideoFrame;
dwToFrame = wma->dwPlayableVideoFrames - 1;
if (lpParms && (dwFlags & MCI_FROM)) {
dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
}
if (lpParms && (dwFlags & MCI_TO)) {
dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
}
if (dwToFrame >= wma->dwPlayableVideoFrames)
dwToFrame = wma->dwPlayableVideoFrames - 1;
TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
wma->dwCurrVideoFrame = dwFromFrame;
wma->dwToVideoFrame = dwToFrame;
/* if already playing exit */
if (wma->dwStatus == MCI_MODE_PLAY)
{
LeaveCriticalSection(&wma->cs);
SetEvent(wma->ack_event);
return 0;
}
if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
{
dwRet = 0;
SetEvent(wma->ack_event);
goto mci_play_done;
}
wma->dwStatus = MCI_MODE_PLAY;
/* signal the state change */
SetEvent(wma->ack_event);
if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
FIXME("Unsupported flag %08x\n", dwFlags);
/* time is in microseconds, we should convert it to milliseconds */
frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
events[0] = wma->hStopEvent;
if (wma->lpWaveFormat) {
if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
{
/* can't play audio */
HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
wma->lpWaveFormat = NULL;
}
else
{
/* fill the queue with as many wave headers as possible */
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
events[1] = wma->hEvent;
numEvents = 2;
}
}
while (wma->dwStatus == MCI_MODE_PLAY)
{
HDC hDC;
DWORD tc, delta;
DWORD ret;
tc = GetTickCount();
hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
if (hDC)
{
MCIAVI_PaintFrame(wma, hDC);
ReleaseDC(wma->hWndPaint, hDC);
}
if (wma->lpWaveFormat)
MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
delta = GetTickCount() - tc;
if (delta < frameTime)
delta = frameTime - delta;
else
delta = 0;
LeaveCriticalSection(&wma->cs);
ret = WaitForMultipleObjects(numEvents, events, FALSE, delta);
EnterCriticalSection(&wma->cs);
if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
if (wma->dwCurrVideoFrame < dwToFrame)
wma->dwCurrVideoFrame++;
else
break;
}
if (wma->lpWaveFormat) {
while (wma->dwEventCount != nHdr - 1)
{
LeaveCriticalSection(&wma->cs);
Sleep(100);
EnterCriticalSection(&wma->cs);
}
/* just to get rid of some race conditions between play, stop and pause */
LeaveCriticalSection(&wma->cs);
waveOutReset(wma->hWave);
EnterCriticalSection(&wma->cs);
for (i = 0; i < nHdr; i++)
waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
}
dwRet = 0;
if (wma->lpWaveFormat) {
HeapFree(GetProcessHeap(), 0, waveHdr);
if (wma->hWave) {
LeaveCriticalSection(&wma->cs);
waveOutClose(wma->hWave);
EnterCriticalSection(&wma->cs);
wma->hWave = 0;
}
CloseHandle(wma->hEvent);
}
mci_play_done:
wma->dwStatus = MCI_MODE_STOP;
if (lpParms && (dwFlags & MCI_NOTIFY)) {
TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return dwRet;
}
/******************************************************************************
* MCIAVI_mciWhere [internal]
*/
DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
RECT rc;
TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
/* Ignore MCI_TEST flag. */
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetClientRect(wma->hWndPaint, &rc);
TRACE("WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
} else {
TRACE("WHERE_DESTINATION %s\n", wine_dbgstr_rect(&wma->dest));
rc = wma->dest;
}
}
if (dwFlags & MCI_DGV_WHERE_FRAME) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("MCI_DGV_WHERE_FRAME_MAX\n");
else
FIXME("MCI_DGV_WHERE_FRAME\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_WHERE_SOURCE) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
rc.left = 0;
rc.top = 0;
rc.right = wma->inbih->biWidth;
rc.bottom = wma->inbih->biHeight;
TRACE("WHERE_SOURCE_MAX %s\n", wine_dbgstr_rect(&rc));
} else {
TRACE("WHERE_SOURCE %s\n", wine_dbgstr_rect(&wma->source));
rc = wma->source;
}
}
if (dwFlags & MCI_DGV_WHERE_VIDEO) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("WHERE_VIDEO_MAX\n");
else
FIXME("WHERE_VIDEO\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_WHERE_WINDOW) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetWindowRect(GetDesktopWindow(), &rc);
TRACE("WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
} else {
GetWindowRect(wma->hWndPaint, &rc);
TRACE("WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
}
}
/* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
* So convert the normal RECT into a MCI RECT before returning */
lpParms->rc.left = rc.left;
lpParms->rc.top = rc.top;
lpParms->rc.right = rc.right - rc.left;
lpParms->rc.bottom = rc.bottom - rc.top;
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciPlay [internal]
*/
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
WINE_MCIAVI *wma;
DWORD dwRet;
DWORD dwFromFrame, dwToFrame;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
wma = MCIAVI_mciGetOpenDev(wDevID);
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_TEST) return 0;
if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN|MCI_MCIAVI_PLAY_FULLBY2))
FIXME("Unsupported flag %08x\n", dwFlags);
EnterCriticalSection(&wma->cs);
if (!wma->hFile)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_FILE_NOT_FOUND;
}
if (!wma->hWndPaint)
{
LeaveCriticalSection(&wma->cs);
return MCIERR_NO_WINDOW;
}
dwFromFrame = wma->dwCurrVideoFrame;
dwToFrame = wma->dwPlayableVideoFrames - 1;
if (dwFlags & MCI_FROM) {
dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
}
if (dwFlags & MCI_TO) {
dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
}
if (dwToFrame >= wma->dwPlayableVideoFrames)
dwToFrame = wma->dwPlayableVideoFrames - 1;
TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
wma->dwCurrVideoFrame = dwFromFrame;
wma->dwToVideoFrame = dwToFrame;
LeaveCriticalSection(&wma->cs);
if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
ShowWindow(wma->hWndPaint, SW_SHOWNA);
EnterCriticalSection(&wma->cs);
/* if already playing exit */
if (wma->dwStatus == MCI_MODE_PLAY)
{
LeaveCriticalSection(&wma->cs);
return 0;
}
wma->dwStatus = MCI_MODE_PLAY;
LeaveCriticalSection(&wma->cs);
if (dwFlags & MCI_WAIT)
return MCIAVI_player(wma, dwFlags, lpParms);
dwRet = MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
if (dwRet) {
EnterCriticalSection(&wma->cs);
wma->dwStatus = MCI_MODE_STOP;
LeaveCriticalSection(&wma->cs);
}
return dwRet;
}
/***************************************************************************
* MCIAVI_mciGetDevCaps [internal]
*/
DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret;
TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_GETDEVCAPS_ITEM) {
switch (lpParms->dwItem) {
case MCI_GETDEVCAPS_DEVICE_TYPE:
TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_HAS_AUDIO:
TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_HAS_VIDEO:
TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_USES_FILES:
TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_COMPOUND_DEVICE:
TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_EJECT:
TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_PLAY:
TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_RECORD:
TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_SAVE:
TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
default:
FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
ret = MCIERR_UNRECOGNIZED_COMMAND;
break;
}
} else {
WARN("No GetDevCaps-Item !\n");
ret = MCIERR_UNRECOGNIZED_COMMAND;
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/***************************************************************************
* MCIAVI_mciStatus [internal]
*/
DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_STATUS_ITEM) {
switch (lpParms->dwItem) {
case MCI_STATUS_CURRENT_TRACK:
lpParms->dwReturn = 1;
TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_LENGTH:
if (!wma->hFile) {
lpParms->dwReturn = 0;
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
/* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma, wma->mah.dwTotalFrames, &ret);
TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_MODE:
lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwStatus, wma->dwStatus);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
break;
case MCI_STATUS_MEDIA_PRESENT:
TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_STATUS_NUMBER_OF_TRACKS:
lpParms->dwReturn = 1;
TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_POSITION:
if (!wma->hFile) {
lpParms->dwReturn = 0;
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
/* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma,
(dwFlags & MCI_STATUS_START) ? 0 : wma->dwCurrVideoFrame,
&ret);
TRACE("MCI_STATUS_POSITION %s => %lu\n",
(dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
break;
case MCI_STATUS_READY:
lpParms->dwReturn = (wma->dwStatus == MCI_MODE_NOT_READY) ?
MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_STATUS_TIME_FORMAT:
lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwMciTimeFormat,
wma->dwMciTimeFormat + MCI_FORMAT_RETURN_BASE);
TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
ret = MCI_RESOURCE_RETURNED;
break;
#if 0
case MCI_AVI_STATUS_AUDIO_BREAKS:
case MCI_AVI_STATUS_FRAMES_SKIPPED:
case MCI_AVI_STATUS_LAST_PLAY_SPEED:
case MCI_DGV_STATUS_AUDIO:
case MCI_DGV_STATUS_AUDIO_INPUT:
case MCI_DGV_STATUS_AUDIO_RECORD:
case MCI_DGV_STATUS_AUDIO_SOURCE:
case MCI_DGV_SETAUDIO_AVERAGE:
case MCI_DGV_SETAUDIO_LEFT:
case MCI_DGV_SETAUDIO_RIGHT:
case MCI_DGV_SETAUDIO_STEREO:
case MCI_DGV_STATUS_AUDIO_STREAM:
case MCI_DGV_STATUS_AVGBYTESPERSEC:
case MCI_DGV_STATUS_BASS:
case MCI_DGV_STATUS_BITSPERPEL:
case MCI_DGV_STATUS_BITSPERSAMPLE:
case MCI_DGV_STATUS_BLOCKALIGN:
case MCI_DGV_STATUS_BRIGHTNESS:
case MCI_DGV_STATUS_COLOR:
case MCI_DGV_STATUS_CONTRAST:
case MCI_DGV_STATUS_FILEFORMAT:
case MCI_DGV_STATUS_FILE_MODE:
case MCI_DGV_STATUS_FILE_COMPLETION:
case MCI_DGV_STATUS_FORWARD:
case MCI_DGV_STATUS_FRAME_RATE:
case MCI_DGV_STATUS_GAMMA:
#endif
case MCI_DGV_STATUS_HPAL:
lpParms->dwReturn = 0;
TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_HWND:
lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
break;
#if 0
case MCI_DGV_STATUS_KEY_COLOR:
case MCI_DGV_STATUS_KEY_INDEX:
case MCI_DGV_STATUS_MONITOR:
case MCI_DGV_MONITOR_FILE:
case MCI_DGV_MONITOR_INPUT:
case MCI_DGV_STATUS_MONITOR_METHOD:
case MCI_DGV_STATUS_PAUSE_MODE:
case MCI_DGV_STATUS_SAMPLESPERSECOND:
case MCI_DGV_STATUS_SEEK_EXACTLY:
case MCI_DGV_STATUS_SHARPNESS:
case MCI_DGV_STATUS_SIZE:
case MCI_DGV_STATUS_SMPTE:
case MCI_DGV_STATUS_SPEED:
case MCI_DGV_STATUS_STILL_FILEFORMAT:
case MCI_DGV_STATUS_TINT:
case MCI_DGV_STATUS_TREBLE:
case MCI_DGV_STATUS_UNSAVED:
case MCI_DGV_STATUS_VIDEO:
case MCI_DGV_STATUS_VIDEO_RECORD:
case MCI_DGV_STATUS_VIDEO_SOURCE:
case MCI_DGV_STATUS_VIDEO_SRC_NUM:
case MCI_DGV_STATUS_VIDEO_STREAM:
case MCI_DGV_STATUS_VOLUME:
case MCI_DGV_STATUS_WINDOW_VISIBLE:
case MCI_DGV_STATUS_WINDOW_MINIMIZED:
case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
case MCI_STATUS_MEDIA_PRESENT:
#endif
default:
FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
} else {
WARN("No Status-Item!\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_NOTIFY) {
TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/***************************************************************************
* MCIAVI_mciSet [internal]
*/
DWORD MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_SET_TIME_FORMAT) {
switch (lpParms->dwTimeFormat) {
case MCI_FORMAT_MILLISECONDS:
TRACE("MCI_FORMAT_MILLISECONDS !\n");
wma->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
break;
case MCI_FORMAT_FRAMES:
TRACE("MCI_FORMAT_FRAMES !\n");
wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
break;
default:
WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
LeaveCriticalSection(&wma->cs);
return MCIERR_BAD_TIME_FORMAT;
}
}
if (dwFlags & MCI_SET_DOOR_OPEN) {
TRACE("No support for door open !\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
if (dwFlags & MCI_SET_DOOR_CLOSED) {
TRACE("No support for door close !\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
if (dwFlags & MCI_SET_ON) {
char buffer[256];
strcpy(buffer, "MCI_SET_ON:");
if (dwFlags & MCI_SET_VIDEO) {
strncat(buffer, " video", sizeof(buffer));
wma->dwSet |= 4;
}
if (dwFlags & MCI_SET_AUDIO) {
strncat(buffer, " audio", sizeof(buffer));
switch (lpParms->dwAudio) {
case MCI_SET_AUDIO_ALL:
strncat(buffer, " all", sizeof(buffer));
wma->dwSet |= 3;
break;
case MCI_SET_AUDIO_LEFT:
strncat(buffer, " left", sizeof(buffer));
wma->dwSet |= 1;
break;
case MCI_SET_AUDIO_RIGHT:
strncat(buffer, " right", sizeof(buffer));
wma->dwSet |= 2;
break;
default:
WARN("Unknown audio chanel %lu\n", lpParms->dwAudio);
break;
}
}
if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
strncat(buffer, " seek_exactly", sizeof(buffer));
}
FIXME("%s\n", buffer);
}
if (dwFlags & MCI_SET_OFF) {
char buffer[256];
strcpy(buffer, "MCI_SET_OFF:");
if (dwFlags & MCI_SET_VIDEO) {
strncat(buffer, " video", sizeof(buffer));
wma->dwSet &= ~4;
}
if (dwFlags & MCI_SET_AUDIO) {
strncat(buffer, " audio", sizeof(buffer));
switch (lpParms->dwAudio) {
case MCI_SET_AUDIO_ALL:
strncat(buffer, " all", sizeof(buffer));
wma->dwSet &= ~3;
break;
case MCI_SET_AUDIO_LEFT:
strncat(buffer, " left", sizeof(buffer));
wma->dwSet &= ~2;
break;
case MCI_SET_AUDIO_RIGHT:
strncat(buffer, " right", sizeof(buffer));
wma->dwSet &= ~2;
break;
default:
WARN("Unknown audio chanel %lu\n", lpParms->dwAudio);
break;
}
}
if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
strncat(buffer, " seek_exactly", sizeof(buffer));
}
FIXME("%s\n", buffer);
}
if (dwFlags & MCI_DGV_SET_FILEFORMAT) {
LPCSTR str = "save";
if (dwFlags & MCI_DGV_SET_STILL)
str = "capture";
switch (lpParms->dwFileFormat) {
case MCI_DGV_FF_AVI: FIXME("Setting file format (%s) to 'AVI'\n", str); break;
case MCI_DGV_FF_AVSS: FIXME("Setting file format (%s) to 'AVSS'\n", str); break;
case MCI_DGV_FF_DIB: FIXME("Setting file format (%s) to 'DIB'\n", str); break;
case MCI_DGV_FF_JFIF: FIXME("Setting file format (%s) to 'JFIF'\n", str); break;
case MCI_DGV_FF_JPEG: FIXME("Setting file format (%s) to 'JPEG'\n", str); break;
case MCI_DGV_FF_MPEG: FIXME("Setting file format (%s) to 'MPEG'\n", str); break;
case MCI_DGV_FF_RDIB: FIXME("Setting file format (%s) to 'RLE DIB'\n", str); break;
case MCI_DGV_FF_RJPEG: FIXME("Setting file format (%s) to 'RJPEG'\n", str); break;
default: FIXME("Setting unknown file format (%s): %ld\n", str, lpParms->dwFileFormat);
}
}
if (dwFlags & MCI_DGV_SET_SPEED) {
FIXME("Setting speed to %ld\n", lpParms->dwSpeed);
}
LeaveCriticalSection(&wma->cs);
return 0;
}
/***************************************************************************
* MCIAVI_mciGetDevCaps [internal]
*/
DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret;
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (!(dwFlags & MCI_GETDEVCAPS_ITEM)) return MCIERR_MISSING_PARAMETER;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_GETDEVCAPS_ITEM) {
switch (lpParms->dwItem) {
case MCI_GETDEVCAPS_DEVICE_TYPE:
TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_HAS_AUDIO:
TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_HAS_VIDEO:
TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_USES_FILES:
TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_COMPOUND_DEVICE:
TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_EJECT:
TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_PLAY:
TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_RECORD:
TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_GETDEVCAPS_CAN_SAVE:
TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_LOCK:
TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_HAS_STILL:
TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_CAN_TEST:
TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_GETDEVCAPS_PALETTES:
TRACE("MCI_DGV_GETDEVCAPS_PALETTES !\n");
lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
ret = MCI_RESOURCE_RETURNED;
break;
/* w2k does not know MAX_WINDOWS or MAX/MINIMUM_RATE */
default:
FIXME("Unknown capability (%08x) !\n", lpParms->dwItem);
ret = MCIERR_UNSUPPORTED_FUNCTION;
break;
}
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/***************************************************************************
* MCIAVI_mciStatus [internal]
*/
DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
DWORD ret = 0;
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
if (!(dwFlags & MCI_STATUS_ITEM)) return MCIERR_MISSING_PARAMETER;
if (dwFlags & MCI_TEST) return 0;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_STATUS_ITEM) {
switch (lpParms->dwItem) {
case MCI_STATUS_CURRENT_TRACK:
lpParms->dwReturn = 1;
TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_LENGTH:
if (!wma->hFile) {
lpParms->dwReturn = 0;
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
/* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma, wma->mah.dwTotalFrames, &ret);
TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_MODE:
lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwStatus, wma->dwStatus);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
break;
case MCI_STATUS_MEDIA_PRESENT:
TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_STATUS_NUMBER_OF_TRACKS:
lpParms->dwReturn = 1;
TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
break;
case MCI_STATUS_POSITION:
if (!wma->hFile) {
lpParms->dwReturn = 0;
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
/* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma,
(dwFlags & MCI_STATUS_START) ? 0 : wma->dwCurrVideoFrame,
&ret);
TRACE("MCI_STATUS_POSITION %s => %lu\n",
(dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
break;
case MCI_STATUS_READY:
lpParms->dwReturn = (wma->dwStatus == MCI_MODE_NOT_READY) ?
MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_STATUS_TIME_FORMAT:
lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwMciTimeFormat,
wma->dwMciTimeFormat + MCI_FORMAT_RETURN_BASE);
TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
ret = MCI_RESOURCE_RETURNED;
break;
case MCI_DGV_STATUS_AUDIO:
lpParms->dwReturn = (wma->dwSet & 3) ?
MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
TRACE("MCI_STATUS_AUDIO = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_VIDEO:
lpParms->dwReturn = (wma->dwSet & 4) ?
MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
TRACE("MCI_STATUS_VIDEO = %u\n", LOWORD(lpParms->dwReturn));
break;
#if 0
case MCI_AVI_STATUS_AUDIO_BREAKS:
case MCI_AVI_STATUS_FRAMES_SKIPPED:
case MCI_AVI_STATUS_LAST_PLAY_SPEED:
case MCI_DGV_STATUS_AUDIO_INPUT:
case MCI_DGV_STATUS_AUDIO_RECORD:
case MCI_DGV_STATUS_AUDIO_SOURCE:
case MCI_DGV_STATUS_AVGBYTESPERSEC:
case MCI_DGV_STATUS_BASS:
case MCI_DGV_STATUS_BITSPERSAMPLE:
case MCI_DGV_STATUS_BLOCKALIGN:
case MCI_DGV_STATUS_BRIGHTNESS:
case MCI_DGV_STATUS_COLOR:
case MCI_DGV_STATUS_CONTRAST:
case MCI_DGV_STATUS_FILEFORMAT:
case MCI_DGV_STATUS_FILE_MODE:
case MCI_DGV_STATUS_FILE_COMPLETION:
case MCI_DGV_STATUS_GAMMA:
#endif
case MCI_DGV_STATUS_BITSPERPEL:
lpParms->dwReturn = wma->inbih->biBitCount;
TRACE("MCI_DGV_STATUS_BITSPERPEL => %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_HPAL:
lpParms->dwReturn = 0;
TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_HWND:
lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
break;
case MCI_DGV_STATUS_WINDOW_VISIBLE:
lpParms->dwReturn = IsWindowVisible(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_VISIBLE = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_WINDOW_MINIMIZED:
lpParms->dwReturn = IsIconic(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_MINIMIZED = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
lpParms->dwReturn = IsZoomed(wma->hWndPaint) ?
MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_WINDOW_MMAXIMIZED = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_SPEED:
lpParms->dwReturn = 1000;
TRACE("MCI_DGV_STATUS_SPEED = %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_FRAME_RATE:
/* FIXME: 1000 is a settable speed multiplier */
lpParms->dwReturn = MulDiv(1000000,1000,wma->mah.dwMicroSecPerFrame);
TRACE("MCI_DGV_STATUS_FRAME_RATE = %lu\n", lpParms->dwReturn);
break;
case MCI_DGV_STATUS_FORWARD:
lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_DGV_STATUS_FORWARD = %u\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_PAUSE_MODE:
if (wma->dwStatus != MCI_MODE_PAUSE) {
LeaveCriticalSection(&wma->cs);
return MCIERR_NONAPPLICABLE_FUNCTION;
}
lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PLAY, MCI_MODE_PLAY);
ret = MCI_RESOURCE_RETURNED;
TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
break;
case MCI_DGV_STATUS_AUDIO_STREAM:
lpParms->dwReturn = wma->audio_stream_n;
TRACE("MCI_DGV_STATUS_AUDIO_STREAM => %lu\n", lpParms->dwReturn);
break;
#if 0
case MCI_DGV_STATUS_KEY_COLOR:
case MCI_DGV_STATUS_KEY_INDEX:
case MCI_DGV_STATUS_MONITOR:
case MCI_DGV_MONITOR_FILE:
case MCI_DGV_MONITOR_INPUT:
case MCI_DGV_STATUS_MONITOR_METHOD:
case MCI_DGV_STATUS_SAMPLESPERSECOND:
case MCI_DGV_STATUS_SEEK_EXACTLY:
case MCI_DGV_STATUS_SHARPNESS:
case MCI_DGV_STATUS_SIZE:
case MCI_DGV_STATUS_SMPTE:
case MCI_DGV_STATUS_STILL_FILEFORMAT:
case MCI_DGV_STATUS_TINT:
case MCI_DGV_STATUS_TREBLE:
case MCI_DGV_STATUS_UNSAVED:
case MCI_DGV_STATUS_VIDEO_RECORD:
case MCI_DGV_STATUS_VIDEO_SOURCE:
case MCI_DGV_STATUS_VIDEO_SRC_NUM:
case MCI_DGV_STATUS_VIDEO_STREAM:
case MCI_DGV_STATUS_VOLUME:
#endif
default:
FIXME("Unknown command %08X !\n", lpParms->dwItem);
TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
LeaveCriticalSection(&wma->cs);
return MCIERR_UNSUPPORTED_FUNCTION;
}
}
if (dwFlags & MCI_NOTIFY) {
TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
wDevID, MCI_NOTIFY_SUCCESSFUL);
}
LeaveCriticalSection(&wma->cs);
return ret;
}
/******************************************************************************
* MCIAVI_mciWhere [internal]
*/
DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
{
WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
EnterCriticalSection(&wma->cs);
if (dwFlags & MCI_DGV_WHERE_DESTINATION) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetClientRect(wma->hWndPaint, &lpParms->rc);
TRACE("WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&lpParms->rc));
} else {
TRACE("WHERE_DESTINATION %s\n", wine_dbgstr_rect(&wma->dest));
lpParms->rc = wma->dest;
}
}
if (dwFlags & MCI_DGV_WHERE_FRAME) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("MCI_DGV_WHERE_FRAME_MAX\n");
else
FIXME("MCI_DGV_WHERE_FRAME\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_WHERE_SOURCE) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = wma->inbih->biWidth;
rect.bottom = wma->inbih->biHeight;
TRACE("WHERE_SOURCE_MAX %s\n", wine_dbgstr_rect(&rect));
lpParms->rc = rect;
} else {
TRACE("WHERE_SOURCE %s\n", wine_dbgstr_rect(&wma->source));
lpParms->rc = wma->source;
}
}
if (dwFlags & MCI_DGV_WHERE_VIDEO) {
if (dwFlags & MCI_DGV_WHERE_MAX)
FIXME("WHERE_VIDEO_MAX\n");
else
FIXME("WHERE_VIDEO\n");
LeaveCriticalSection(&wma->cs);
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (dwFlags & MCI_DGV_WHERE_WINDOW) {
if (dwFlags & MCI_DGV_WHERE_MAX) {
GetWindowRect(GetDesktopWindow(), &lpParms->rc);
TRACE("WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&lpParms->rc));
} else {
GetWindowRect(wma->hWndPaint, &lpParms->rc);
TRACE("WHERE_WINDOW %s\n", wine_dbgstr_rect(&lpParms->rc));
}
}
LeaveCriticalSection(&wma->cs);
return 0;
}
