private_mciavi.h File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmddk.h"
#include "digitalv.h"
#include "vfw.h"
#include "wownt32.h"
#include "mciavi.h"

Include dependency graph for private_mciavi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MMIOPos
struct	WINE_MCIAVI

Functions
DWORD	MCIAVI_ConvertTimeFormatToFrame (WINE_MCIAVI *wma, DWORD val) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciGetDevCaps (UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciInfo (UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciSet (UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciStatus (UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms) DECLSPEC_HIDDEN
BOOL	MCIAVI_GetInfo (WINE_MCIAVI *wma) DECLSPEC_HIDDEN
DWORD	MCIAVI_OpenAudio (WINE_MCIAVI *wma, unsigned *nHdr, LPWAVEHDR *pWaveHdr) DECLSPEC_HIDDEN
BOOL	MCIAVI_OpenVideo (WINE_MCIAVI *wma) DECLSPEC_HIDDEN
void	MCIAVI_PlayAudioBlocks (WINE_MCIAVI *wma, unsigned nHdr, LPWAVEHDR waveHdr) DECLSPEC_HIDDEN
double	MCIAVI_PaintFrame (WINE_MCIAVI *wma, HDC hDC) DECLSPEC_HIDDEN
WINE_MCIAVI *	MCIAVI_mciGetOpenDev (UINT wDevID) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciClose (UINT, DWORD, LPMCI_GENERIC_PARMS) DECLSPEC_HIDDEN
BOOL	MCIAVI_RegisterClass (void) DECLSPEC_HIDDEN
BOOL	MCIAVI_UnregisterClass (void) DECLSPEC_HIDDEN
BOOL	MCIAVI_CreateWindow (WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciPut (UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciWhere (UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms) DECLSPEC_HIDDEN
DWORD	MCIAVI_mciWindow (UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms) DECLSPEC_HIDDEN

Variables
HINSTANCE MCIAVI_hInstance	DECLSPEC_HIDDEN

Function Documentation

MCIAVI_ConvertTimeFormatToFrame()

DWORD MCIAVI_ConvertTimeFormatToFrame	(	WINE_MCIAVI *	wma,
		DWORD	val
	)

Definition at line 52 of file info.c.

{
    DWORD   ret = 0;
 
    switch (wma->dwMciTimeFormat) {
    case MCI_FORMAT_MILLISECONDS:
    ret = (val * 1000) / wma->mah.dwMicroSecPerFrame;
    break;
    case MCI_FORMAT_FRAMES:
    ret = val;
    break;
    default:
    WARN("Bad time format %u!\n", wma->dwMciTimeFormat);
    }
    TRACE("val=%u=0x%08x [tf=%u] => ret=%u\n", val, val, wma->dwMciTimeFormat, ret);
    return ret;
}

Referenced by MCIAVI_mciPlay(), and MCIAVI_mciSeek().

MCIAVI_CreateWindow()

BOOL MCIAVI_CreateWindow	(	WINE_MCIAVI *	wma,
		DWORD	dwFlags,
		LPMCI_DGV_OPEN_PARMSW	lpOpenParms
	)

Definition at line 112 of file wnd.c.

{
    static const WCHAR captionW[] = {'W','i','n','e',' ','M','C','I','-','A','V','I',' ','p','l','a','y','e','r',0};
    HWND    hParent = 0;
    DWORD   dwStyle = WS_OVERLAPPEDWINDOW;
    RECT        rc;
 
    /* what should be done ? */
    if (wma->hWnd) return TRUE;
 
    if (dwFlags & MCI_DGV_OPEN_PARENT)  hParent = lpParms->hWndParent;
    if (dwFlags & MCI_DGV_OPEN_WS)  dwStyle = lpParms->dwStyle;
 
    if (wma->hic)
        SetRect(&rc, 0, 0, wma->outbih->biWidth, wma->outbih->biHeight);
    else
        SetRect(&rc, 0, 0, wma->inbih->biWidth, wma->inbih->biHeight);
 
    AdjustWindowRect(&rc, dwStyle, FALSE);
    if (!(dwStyle & (WS_CHILD|WS_POPUP))) /* overlapped window ? */
    {
        rc.right -= rc.left;
        rc.bottom -= rc.top;
        rc.left = rc.top = CW_USEDEFAULT;
    }
 
    wma->hWnd = CreateWindowW(mciaviW, captionW,
                              dwStyle, rc.left, rc.top,
                              rc.right, rc.bottom,
                              hParent, 0, MCIAVI_hInstance,
                              ULongToPtr(wma->wDevID));
    wma->hWndPaint = wma->hWnd;
 
    TRACE("(%04x, %08X, %p, style %x, parent %p, dimensions %dx%d, hwnd %p)\n", wma->wDevID,
          dwFlags, lpParms, dwStyle, hParent, rc.right - rc.left, rc.bottom - rc.top, wma->hWnd);
    return wma->hWnd != 0;
}

Referenced by MCIAVI_mciOpen().

MCIAVI_GetInfo()

BOOL MCIAVI_GetInfo

(

WINE_MCIAVI *

wma

)

Definition at line 255 of file mmoutput.c.

{
    MMCKINFO        ckMainRIFF;
    MMCKINFO        mmckHead;
    MMCKINFO        mmckList;
    MMCKINFO        mmckInfo;
    AVIStreamHeader strh;
    struct AviListBuild alb;
    DWORD stream_n;
 
    if (mmioDescend(wma->hFile, &ckMainRIFF, NULL, 0) != 0) {
    WARN("Can't find 'RIFF' chunk\n");
    return FALSE;
    }
 
    if ((ckMainRIFF.ckid != FOURCC_RIFF) || (ckMainRIFF.fccType != formtypeAVI)) {
    WARN("Can't find 'AVI ' chunk\n");
    return FALSE;
    }
 
    mmckHead.fccType = listtypeAVIHEADER;
    if (mmioDescend(wma->hFile, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
    WARN("Can't find 'hdrl' list\n");
    return FALSE;
    }
 
    mmckInfo.ckid = ckidAVIMAINHDR;
    if (mmioDescend(wma->hFile, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
    WARN("Can't find 'avih' chunk\n");
    return FALSE;
    }
 
    mmioRead(wma->hFile, (LPSTR)&wma->mah, sizeof(wma->mah));
 
    TRACE("mah.dwMicroSecPerFrame=%d\n",    wma->mah.dwMicroSecPerFrame);
    TRACE("mah.dwMaxBytesPerSec=%d\n",  wma->mah.dwMaxBytesPerSec);
    TRACE("mah.dwPaddingGranularity=%d\n",  wma->mah.dwPaddingGranularity);
    TRACE("mah.dwFlags=%d\n",           wma->mah.dwFlags);
    TRACE("mah.dwTotalFrames=%d\n",         wma->mah.dwTotalFrames);
    TRACE("mah.dwInitialFrames=%d\n",       wma->mah.dwInitialFrames);
    TRACE("mah.dwStreams=%d\n",         wma->mah.dwStreams);
    TRACE("mah.dwSuggestedBufferSize=%d\n", wma->mah.dwSuggestedBufferSize);
    TRACE("mah.dwWidth=%d\n",           wma->mah.dwWidth);
    TRACE("mah.dwHeight=%d\n",      wma->mah.dwHeight);
 
    mmioAscend(wma->hFile, &mmckInfo, 0);
 
    TRACE("Start of streams\n");
    wma->video_stream_n = 0;
    wma->audio_stream_n = 0;
 
    for (stream_n = 0; stream_n < wma->mah.dwStreams; stream_n++)
    {
        MMCKINFO mmckStream;
 
        mmckList.fccType = listtypeSTREAMHEADER;
        if (mmioDescend(wma->hFile, &mmckList, &mmckHead, MMIO_FINDLIST) != 0)
            break;
 
        mmckStream.ckid = ckidSTREAMHEADER;
        if (mmioDescend(wma->hFile, &mmckStream, &mmckList, MMIO_FINDCHUNK) != 0)
        {
            WARN("Can't find 'strh' chunk\n");
            continue;
        }
 
        mmioRead(wma->hFile, (LPSTR)&strh, sizeof(strh));
 
        TRACE("Stream #%d fccType %4.4s\n", stream_n, (LPSTR)&strh.fccType);
 
        if (strh.fccType == streamtypeVIDEO)
        {
            TRACE("found video stream\n");
            if (wma->inbih)
                WARN("ignoring another video stream\n");
            else
            {
                wma->ash_video = strh;
 
                if (!MCIAVI_GetInfoVideo(wma, &mmckList, &mmckStream))
                    return FALSE;
                wma->video_stream_n = stream_n;
                wma->dwSet |= 4;
            }
        }
        else if (strh.fccType == streamtypeAUDIO)
        {
            TRACE("found audio stream\n");
            if (wma->lpWaveFormat)
                WARN("ignoring another audio stream\n");
            else
            {
                wma->ash_audio = strh;
 
                if (!MCIAVI_GetInfoAudio(wma, &mmckList, &mmckStream))
                    return FALSE;
                wma->audio_stream_n = stream_n;
                wma->dwSet |= 3;
            }
        }
        else
            TRACE("Unsupported stream type %4.4s\n", (LPSTR)&strh.fccType);
 
        mmioAscend(wma->hFile, &mmckList, 0);
    }
 
    TRACE("End of streams\n");
 
    mmioAscend(wma->hFile, &mmckHead, 0);
 
    /* no need to read optional JUNK chunk */
 
    mmckList.fccType = listtypeAVIMOVIE;
    if (mmioDescend(wma->hFile, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
    WARN("Can't find 'movi' list\n");
    return FALSE;
    }
 
    wma->dwPlayableVideoFrames = wma->mah.dwTotalFrames;
    wma->lpVideoIndex = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                  wma->dwPlayableVideoFrames * sizeof(struct MMIOPos));
    if (!wma->lpVideoIndex) {
    WARN("Can't alloc video index array\n");
    return FALSE;
    }
    wma->dwPlayableAudioBlocks = 0;
    wma->lpAudioIndex = NULL;
 
    alb.numAudioBlocks = alb.numVideoFrames = 0;
    alb.inVideoSize = alb.inAudioSize = 0;
    alb.numAudioAllocated = 0;
 
    while (mmioDescend(wma->hFile, &mmckInfo, &mmckList, 0) == 0) {
    if (mmckInfo.fccType == listtypeAVIRECORD) {
        MMCKINFO    tmp;
 
        while (mmioDescend(wma->hFile, &tmp, &mmckInfo, 0) == 0) {
        MCIAVI_AddFrame(wma, &tmp, &alb);
        mmioAscend(wma->hFile, &tmp, 0);
        }
    } else {
        MCIAVI_AddFrame(wma, &mmckInfo, &alb);
    }
 
    mmioAscend(wma->hFile, &mmckInfo, 0);
    }
 
#ifdef __REACTOS__
    /* Empty file */
    if (alb.numVideoFrames == 0) {
        WARN("NumVideoFrames: %u, Empty or possibly corrupt video file");
        return FALSE;
    }
#endif
 
    if (alb.numVideoFrames != wma->dwPlayableVideoFrames) {
    WARN("AVI header says %d frames, we found %d video frames, reducing playable frames\n",
         wma->dwPlayableVideoFrames, alb.numVideoFrames);
    wma->dwPlayableVideoFrames = alb.numVideoFrames;
    }
    wma->dwPlayableAudioBlocks = alb.numAudioBlocks;
 
    if (alb.inVideoSize > wma->ash_video.dwSuggestedBufferSize) {
    WARN("inVideoSize=%d suggestedSize=%d\n", alb.inVideoSize, wma->ash_video.dwSuggestedBufferSize);
    wma->ash_video.dwSuggestedBufferSize = alb.inVideoSize;
    }
    if (alb.inAudioSize > wma->ash_audio.dwSuggestedBufferSize) {
    WARN("inAudioSize=%d suggestedSize=%d\n", alb.inAudioSize, wma->ash_audio.dwSuggestedBufferSize);
    wma->ash_audio.dwSuggestedBufferSize = alb.inAudioSize;
    }
 
    wma->indata = HeapAlloc(GetProcessHeap(), 0, wma->ash_video.dwSuggestedBufferSize);
    if (!wma->indata) {
    WARN("Can't alloc input buffer\n");
    return FALSE;
    }
 
    return TRUE;
}

Referenced by MCIAVI_mciOpen().

MCIAVI_mciClose()

DWORD MCIAVI_mciClose	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_GENERIC_PARMS	lpParms
	)

Definition at line 305 of file mciavi.c.

{
    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;
}

Referenced by MCIAVI_DriverProc(), MCIAVI_drvClose(), and MCIAVI_WindowProc().

MCIAVI_mciGetDevCaps()

DWORD MCIAVI_mciGetDevCaps	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_GETDEVCAPS_PARMS	lpParms
	)

Definition at line 73 of file info.c.

{
    WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
    DWORD       ret = MCIERR_UNSUPPORTED_FUNCTION;
 
    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);
            break;
    }
    }
 
    LeaveCriticalSection(&wma->cs);
    return ret;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciGetOpenDev()

WINE_MCIAVI * MCIAVI_mciGetOpenDev

(

UINT

wDevID

)

Definition at line 157 of file mciavi.c.

{
    WINE_MCIAVI*    wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
 
    if (wma == NULL || wma->nUseCount == 0) {
    WARN("Invalid wDevID=%u\n", wDevID);
    return 0;
    }
    return wma;
}

Referenced by MCIAVI_mciBreak(), MCIAVI_mciClose(), MCIAVI_mciConfigure(), MCIAVI_mciCue(), MCIAVI_mciGetDevCaps(), MCIAVI_mciInfo(), MCIAVI_mciLoad(), MCIAVI_mciPause(), MCIAVI_mciPlay(), MCIAVI_mciPut(), MCIAVI_mciRealize(), MCIAVI_mciResume(), MCIAVI_mciSeek(), MCIAVI_mciSet(), MCIAVI_mciSetAudio(), MCIAVI_mciSetVideo(), MCIAVI_mciSignal(), MCIAVI_mciStatus(), MCIAVI_mciStep(), MCIAVI_mciStop(), MCIAVI_mciUpdate(), MCIAVI_mciWhere(), MCIAVI_mciWindow(), and MCIAVI_waveCallback().

MCIAVI_mciInfo()

DWORD MCIAVI_mciInfo	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_INFO_PARMSW	lpParms
	)

Definition at line 188 of file info.c.

{
    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};
    static const WCHAR wszVersion[] = {'1','.','1',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_VERSION)
    str = wszVersion;
    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;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciPut()

DWORD MCIAVI_mciPut	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_PUT_PARMS	lpParms
	)

Definition at line 153 of file wnd.c.

{
    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 */
        SetRect(&rc, lpParms->rc.left, lpParms->rc.top, lpParms->rc.left + lpParms->rc.right,
                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;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciSet()

DWORD MCIAVI_mciSet	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_SET_PARMS	lpParms
	)

Definition at line 227 of file info.c.

{
    WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
 
    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_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 %u!\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) {
    const char *szVideo="";
    const char *szAudio="";
    const char *szSeek="";
 
    if (dwFlags & MCI_SET_VIDEO) {
        szVideo = " video";
        wma->dwSet |= 4;
    }
    if (dwFlags & MCI_SET_AUDIO) {
        switch (lpParms->dwAudio) {
        case MCI_SET_AUDIO_ALL:
        szAudio = " audio all";
        wma->dwSet |= 3;
        break;
        case MCI_SET_AUDIO_LEFT:
        szAudio = " audio left";
        wma->dwSet |= 1;
        break;
        case MCI_SET_AUDIO_RIGHT:
        szAudio = " audio right";
        wma->dwSet |= 2;
        break;
        default:
        szAudio = " audio unknown";
        WARN("Unknown audio channel %u\n", lpParms->dwAudio);
        break;
        }
    }
    if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
        szSeek = " seek_exactly";
    }
    FIXME("MCI_SET_ON:%s%s%s\n", szVideo, szAudio, szSeek);
    }
 
    if (dwFlags & MCI_SET_OFF) {
    const char *szVideo="";
    const char *szAudio="";
    const char *szSeek="";
 
    if (dwFlags & MCI_SET_VIDEO) {
        szVideo = " video";
        wma->dwSet &= ~4;
    }
    if (dwFlags & MCI_SET_AUDIO) {
        switch (lpParms->dwAudio) {
        case MCI_SET_AUDIO_ALL:
        szAudio = " audio all";
        wma->dwSet &= ~3;
        break;
        case MCI_SET_AUDIO_LEFT:
        szAudio = " audio left";
        wma->dwSet &= ~2;
        break;
        case MCI_SET_AUDIO_RIGHT:
        szAudio = " audio right";
        wma->dwSet &= ~2;
        break;
        default:
        szAudio = " audio unknown";
        WARN("Unknown audio channel %u\n", lpParms->dwAudio);
        break;
        }
    }
    if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
        szSeek = " seek_exactly";
    }
    FIXME("MCI_SET_OFF:%s%s%s\n", szVideo, szAudio, szSeek);
    }
    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): %d\n", str, lpParms->dwFileFormat);
    }
    }
 
    if (dwFlags & MCI_DGV_SET_SPEED) {
    FIXME("Setting speed to %d\n", lpParms->dwSpeed);
    }
 
    LeaveCriticalSection(&wma->cs);
    return 0;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciStatus()

DWORD MCIAVI_mciStatus	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_STATUS_PARMSW	lpParms
	)

Definition at line 363 of file info.c.

{
    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;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciWhere()

DWORD MCIAVI_mciWhere	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_RECT_PARMS	lpParms
	)

Definition at line 209 of file wnd.c.

{
    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) {
            SetRect(&rc, 0, 0, wma->inbih->biWidth, 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 */
    SetRect(&lpParms->rc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
 
    LeaveCriticalSection(&wma->cs);
    return 0;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_mciWindow()

DWORD MCIAVI_mciWindow	(	UINT	wDevID,
		DWORD	dwFlags,
		LPMCI_DGV_WINDOW_PARMSW	lpParms
	)

Definition at line 277 of file wnd.c.

{
    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;
}

Referenced by MCIAVI_DriverProc().

MCIAVI_OpenAudio()

DWORD MCIAVI_OpenAudio	(	WINE_MCIAVI *	wma,
		unsigned *	nHdr,
		LPWAVEHDR *	pWaveHdr
	)

Definition at line 534 of file mmoutput.c.

{
    DWORD   dwRet;
    LPWAVEHDR   waveHdr;
    unsigned    i;
 
    dwRet = waveOutOpen((HWAVEOUT *)&wma->hWave, WAVE_MAPPER, wma->lpWaveFormat,
                       (DWORD_PTR)MCIAVI_waveCallback, wma->wDevID, CALLBACK_FUNCTION);
    if (dwRet != 0) {
    TRACE("Can't open low level audio device %d\n", dwRet);
    dwRet = MCIERR_DEVICE_OPEN;
    wma->hWave = 0;
    goto cleanUp;
    }
 
    /* FIXME: should set up a heuristic to compute the number of wave headers
     * to be used...
     */
    *nHdr = 7;
    waveHdr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            *nHdr * (sizeof(WAVEHDR) + wma->ash_audio.dwSuggestedBufferSize));
    if (!waveHdr) {
    TRACE("Can't alloc wave headers\n");
    dwRet = MCIERR_DEVICE_OPEN;
    goto cleanUp;
    }
 
    for (i = 0; i < *nHdr; i++) {
    /* other fields are zero:ed on allocation */
    waveHdr[i].lpData = (char*)waveHdr +
        *nHdr * sizeof(WAVEHDR) + i * wma->ash_audio.dwSuggestedBufferSize;
    waveHdr[i].dwBufferLength = wma->ash_audio.dwSuggestedBufferSize;
    if (waveOutPrepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR))) {
        dwRet = MCIERR_INTERNAL;
        goto cleanUp;
    }
    }
 
    if (wma->dwCurrVideoFrame != 0 && wma->lpWaveFormat) {
    FIXME("Should recompute dwCurrAudioBlock, except unsynchronized sound & video\n");
    }
    wma->dwCurrAudioBlock = 0;
 
    wma->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
    wma->dwEventCount = *nHdr - 1;
    *pWaveHdr = waveHdr;
 cleanUp:
    return dwRet;
}

Referenced by MCIAVI_player().

MCIAVI_OpenVideo()

BOOL MCIAVI_OpenVideo

(

WINE_MCIAVI *

wma

)

Definition at line 435 of file mmoutput.c.

{
    HDC hDC;
    DWORD   outSize;
    FOURCC  fcc = wma->ash_video.fccHandler;
 
    TRACE("fcc %4.4s\n", (LPSTR)&fcc);
 
    wma->dwCachedFrame = -1;
 
    /* get the right handle */
    if (fcc == mmioFOURCC('C','R','A','M')) fcc = mmioFOURCC('M','S','V','C');
 
    /* try to get a decompressor for that type */
    wma->hic = ICLocate(ICTYPE_VIDEO, fcc, wma->inbih, NULL, ICMODE_DECOMPRESS);
    if (!wma->hic) {
        /* check for builtin DIB compressions */
        fcc = wma->inbih->biCompression;
        if ((fcc == mmioFOURCC('D','I','B',' ')) ||
            (fcc == mmioFOURCC('R','L','E',' ')) ||
            (fcc == BI_RGB) || (fcc == BI_RLE8) ||
            (fcc == BI_RLE4) || (fcc == BI_BITFIELDS))
            goto paint_frame;
 
    WARN("Can't locate codec for the file\n");
    return FALSE;
    }
 
    outSize = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
 
    wma->outbih = HeapAlloc(GetProcessHeap(), 0, outSize);
    if (!wma->outbih) {
    WARN("Can't alloc output BIH\n");
    return FALSE;
    }
    if (!ICGetDisplayFormat(wma->hic, wma->inbih, wma->outbih, 0, 0, 0)) {
    WARN("Can't open decompressor\n");
    return FALSE;
    }
 
    TRACE("bih.biSize=%d\n",        wma->outbih->biSize);
    TRACE("bih.biWidth=%d\n",       wma->outbih->biWidth);
    TRACE("bih.biHeight=%d\n",  wma->outbih->biHeight);
    TRACE("bih.biPlanes=%d\n",      wma->outbih->biPlanes);
    TRACE("bih.biBitCount=%d\n",    wma->outbih->biBitCount);
    TRACE("bih.biCompression=%x\n",     wma->outbih->biCompression);
    TRACE("bih.biSizeImage=%d\n",   wma->outbih->biSizeImage);
    TRACE("bih.biXPelsPerMeter=%d\n",   wma->outbih->biXPelsPerMeter);
    TRACE("bih.biYPelsPerMeter=%d\n",   wma->outbih->biYPelsPerMeter);
    TRACE("bih.biClrUsed=%d\n",     wma->outbih->biClrUsed);
    TRACE("bih.biClrImportant=%d\n",    wma->outbih->biClrImportant);
 
    wma->outdata = HeapAlloc(GetProcessHeap(), 0, wma->outbih->biSizeImage);
    if (!wma->outdata) {
    WARN("Can't alloc output buffer\n");
    return FALSE;
    }
 
    if (ICSendMessage(wma->hic, ICM_DECOMPRESS_BEGIN,
              (DWORD_PTR)wma->inbih, (DWORD_PTR)wma->outbih) != ICERR_OK) {
    WARN("Can't begin decompression\n");
    return FALSE;
    }
 
paint_frame:
    hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
    if (hDC)
    {
        MCIAVI_PaintFrame(wma, hDC);
        ReleaseDC(wma->hWndPaint, hDC);
    }
    return TRUE;
}

Referenced by MCIAVI_mciOpen().

MCIAVI_PaintFrame()

double MCIAVI_PaintFrame	(	WINE_MCIAVI *	wma,
		HDC	hDC
	)

Definition at line 613 of file mmoutput.c.

{
    void*       pBitmapData;
    LPBITMAPINFO    pBitmapInfo;
 
    if (!hDC || !wma->inbih)
    return 0;
 
    TRACE("Painting frame %u (cached %u)\n", wma->dwCurrVideoFrame, wma->dwCachedFrame);
 
    if (wma->dwCurrVideoFrame != wma->dwCachedFrame)
    {
#ifdef __REACTOS__
        if (wma->dwCurrVideoFrame >= wma->dwPlayableVideoFrames) {
            ERR("Invalid frame requested. Current : %u Total Playable %u\n", wma->dwCurrVideoFrame, wma->dwPlayableVideoFrames);
            return 0;
        }
#endif
 
        if (!wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset)
        return 0;
 
        if (wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize)
        {
            mmioSeek(wma->hFile, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset, SEEK_SET);
            mmioRead(wma->hFile, wma->indata, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize);
 
            wma->inbih->biSizeImage = wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize;
 
            if (wma->hic && ICDecompress(wma->hic, 0, wma->inbih, wma->indata,
                                         wma->outbih, wma->outdata) != ICERR_OK)
            {
                WARN("Decompression error\n");
                return 0;
            }
        }
 
        wma->dwCachedFrame = wma->dwCurrVideoFrame;
    }
 
    if (wma->hic) {
        pBitmapData = wma->outdata;
        pBitmapInfo = (LPBITMAPINFO)wma->outbih;
    } else {
        pBitmapData = wma->indata;
        pBitmapInfo = (LPBITMAPINFO)wma->inbih;
    }
 
    StretchDIBits(hDC,
                  wma->dest.left, wma->dest.top,
                  wma->dest.right - wma->dest.left, wma->dest.bottom - wma->dest.top,
                  wma->source.left, wma->source.top,
                  wma->source.right - wma->source.left, wma->source.bottom - wma->source.top,
                  pBitmapData, pBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
 
    return (wma->ash_video.dwScale / (double)wma->ash_video.dwRate) * 1000000;
}

Referenced by MCIAVI_mciUpdate(), MCIAVI_OpenVideo(), MCIAVI_player(), and MCIAVI_WindowProc().

MCIAVI_PlayAudioBlocks()

void MCIAVI_PlayAudioBlocks	(	WINE_MCIAVI *	wma,
		unsigned	nHdr,
		LPWAVEHDR	waveHdr
	)

Definition at line 584 of file mmoutput.c.

{
    if (!wma->lpAudioIndex) 
        return;
    TRACE("%d (ec=%u)\n", wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, wma->dwEventCount);
 
    /* push as many blocks as possible => audio gets priority */
    while (wma->dwStatus != MCI_MODE_STOP && wma->dwStatus != MCI_MODE_NOT_READY &&
       wma->dwCurrAudioBlock < wma->dwPlayableAudioBlocks) {
    unsigned    whidx = wma->dwCurrAudioBlock % nHdr;
 
    ResetEvent(wma->hEvent);
    if (InterlockedDecrement(&wma->dwEventCount) < 0 ||
        !wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset)
        {
            InterlockedIncrement(&wma->dwEventCount);
        break;
        }
 
    mmioSeek(wma->hFile, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, SEEK_SET);
    mmioRead(wma->hFile, waveHdr[whidx].lpData, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize);
 
    waveHdr[whidx].dwFlags &= ~WHDR_DONE;
    waveHdr[whidx].dwBufferLength = wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize;
    waveOutWrite(wma->hWave, &waveHdr[whidx], sizeof(WAVEHDR));
    wma->dwCurrAudioBlock++;
    }
}

Referenced by MCIAVI_player().

MCIAVI_RegisterClass()

BOOL MCIAVI_RegisterClass

(

void

)

Definition at line 93 of file wnd.c.

{
    WNDCLASSW wndClass;
 
    ZeroMemory(&wndClass, sizeof(WNDCLASSW));
    wndClass.style         = CS_DBLCLKS;
    wndClass.lpfnWndProc   = MCIAVI_WindowProc;
    wndClass.cbWndExtra    = sizeof(MCIDEVICEID);
    wndClass.hInstance     = MCIAVI_hInstance;
    wndClass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
    wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
    wndClass.lpszClassName = mciaviW;
 
    if (RegisterClassW(&wndClass)) return TRUE;
    if (GetLastError() == ERROR_CLASS_ALREADY_EXISTS) return TRUE;
 
    return FALSE;
}

Referenced by MCIAVI_drvOpen().

MCIAVI_UnregisterClass()

BOOL MCIAVI_UnregisterClass

(

void

)

Definition at line 88 of file wnd.c.

{
    return UnregisterClassW(mciaviW, MCIAVI_hInstance);
}

Referenced by MCIAVI_drvClose().

Variable Documentation

DECLSPEC_HIDDEN

HINSTANCE MCIAVI_hInstance DECLSPEC_HIDDEN

extern

Definition at line 289 of file d3dcompiler_private.h.