animate.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "commctrl.h"
#include "vfw.h"
#include "mmsystem.h"
#include "comctl32.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for animate.c:

Go to the source code of this file.

Classes
struct	ANIMATE_INFO

Macros
#define	ANIMATE_COLOR_NONE   0xffffffff

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (animate)
static void	ANIMATE_Notify (const ANIMATE_INFO *infoPtr, UINT notif)
static BOOL	ANIMATE_LoadResW (ANIMATE_INFO *infoPtr, HINSTANCE hInst, LPCWSTR lpName)
static BOOL	ANIMATE_LoadFileW (ANIMATE_INFO *infoPtr, LPWSTR lpName)
static BOOL	ANIMATE_DoStop (ANIMATE_INFO *infoPtr)
static void	ANIMATE_Free (ANIMATE_INFO *infoPtr)
static void	ANIMATE_TransparentBlt (ANIMATE_INFO const *infoPtr, HDC hdcDest, HDC hdcSource)
static BOOL	ANIMATE_PaintFrame (ANIMATE_INFO *infoPtr, HDC hDC)
static BOOL	ANIMATE_DrawFrame (ANIMATE_INFO *infoPtr, HDC hDC)
static LRESULT	ANIMATE_Timer (ANIMATE_INFO *infoPtr)
static DWORD CALLBACK	ANIMATE_AnimationThread (LPVOID ptr_)
static LRESULT	ANIMATE_Play (ANIMATE_INFO *infoPtr, UINT cRepeat, WORD wFrom, WORD wTo)
static BOOL	ANIMATE_GetAviInfo (ANIMATE_INFO *infoPtr)
static BOOL	ANIMATE_GetAviCodec (ANIMATE_INFO *infoPtr)
static BOOL	ANIMATE_OpenW (ANIMATE_INFO *infoPtr, HINSTANCE hInstance, LPWSTR lpszName)
static BOOL	ANIMATE_OpenA (ANIMATE_INFO *infoPtr, HINSTANCE hInstance, LPSTR lpszName)
static BOOL	ANIMATE_Stop (ANIMATE_INFO *infoPtr)
static BOOL	ANIMATE_Create (HWND hWnd, const CREATESTRUCTW *lpcs)
static LRESULT	ANIMATE_Destroy (ANIMATE_INFO *infoPtr)
static BOOL	ANIMATE_EraseBackground (ANIMATE_INFO const *infoPtr, HDC hdc)
static LRESULT	ANIMATE_StyleChanged (ANIMATE_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
static LRESULT WINAPI	ANIMATE_WindowProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	ANIMATE_Register (void)
void	ANIMATE_Unregister (void)

Variables
struct {
HMODULE   hModule
DWORD
UINT
DWORD_PTR
LPBITMAPINFOHEADER
LPVOID
}	fnIC

Macro Definition Documentation

ANIMATE_COLOR_NONE

#define ANIMATE_COLOR_NONE   0xffffffff

Definition at line 86 of file animate.c.

Function Documentation

ANIMATE_AnimationThread()

static DWORD CALLBACK ANIMATE_AnimationThread ( LPVOID  ptr_ )

static

Definition at line 384 of file animate.c.

{
    ANIMATE_INFO *infoPtr = ptr_;
    HANDLE event;
    DWORD timeout;
 
    while(1)
    {
        HDC hDC = GetDC(infoPtr->hwndSelf);
 
        EnterCriticalSection(&infoPtr->cs);
        ANIMATE_DrawFrame(infoPtr, hDC);
        timeout = infoPtr->mah.dwMicroSecPerFrame;
        event = infoPtr->hStopEvent;
        LeaveCriticalSection(&infoPtr->cs);
 
        ReleaseDC(infoPtr->hwndSelf, hDC);
 
        /* time is in microseconds, we should convert it to milliseconds */
        if ((event == 0) || WaitForSingleObject( event, (timeout+500)/1000) == WAIT_OBJECT_0)
            break;
    }
    return TRUE;
}

Referenced by ANIMATE_Play().

ANIMATE_Create()

static BOOL ANIMATE_Create ( HWND  hWnd, const CREATESTRUCTW *  lpcs  )

static

Definition at line 795 of file animate.c.

{
    static const WCHAR msvfw32W[] = { 'm', 's', 'v', 'f', 'w', '3', '2', '.', 'd', 'l', 'l', 0 };
    ANIMATE_INFO *infoPtr;
 
    if (!fnIC.hModule)
    {
    fnIC.hModule = LoadLibraryW(msvfw32W);
    if (!fnIC.hModule) return FALSE;
 
    fnIC.fnICOpen        = (void*)GetProcAddress(fnIC.hModule, "ICOpen");
    fnIC.fnICClose       = (void*)GetProcAddress(fnIC.hModule, "ICClose");
    fnIC.fnICSendMessage = (void*)GetProcAddress(fnIC.hModule, "ICSendMessage");
    fnIC.fnICDecompress  = (void*)GetProcAddress(fnIC.hModule, "ICDecompress");
    }
 
    /* allocate memory for info structure */
    infoPtr = heap_alloc_zero(sizeof(*infoPtr));
    if (!infoPtr) return FALSE;
 
    /* store crossref hWnd <-> info structure */
    SetWindowLongPtrW(hWnd, 0, (DWORD_PTR)infoPtr);
    infoPtr->hwndSelf = hWnd;
    infoPtr->hwndNotify = lpcs->hwndParent;
    infoPtr->transparentColor = ANIMATE_COLOR_NONE;
    infoPtr->hbmPrevFrame = 0;
    infoPtr->dwStyle = lpcs->style;
 
    TRACE("Animate style=0x%08x, parent=%p\n", infoPtr->dwStyle, infoPtr->hwndNotify);
 
    InitializeCriticalSection(&infoPtr->cs);
    infoPtr->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ANIMATE_INFO*->cs");
 
    return TRUE;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_Destroy()

static LRESULT ANIMATE_Destroy ( ANIMATE_INFO *  infoPtr )

static

Definition at line 832 of file animate.c.

{
    /* free avi data */
    ANIMATE_Free(infoPtr);
 
    /* free animate info data */
    SetWindowLongPtrW(infoPtr->hwndSelf, 0, 0);
 
    infoPtr->cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&infoPtr->cs);
    heap_free(infoPtr);
 
    return 0;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_DoStop()

static BOOL ANIMATE_DoStop ( ANIMATE_INFO *  infoPtr )

static

Definition at line 138 of file animate.c.

{
    BOOL stopped = FALSE;
 
    EnterCriticalSection(&infoPtr->cs);
 
    /* should stop playing */
    if (infoPtr->hThread)
    {
        HANDLE handle = infoPtr->hThread;
 
        TRACE("stopping animation thread\n");
        infoPtr->hThread = 0;
        SetEvent( infoPtr->hStopEvent );
 
        if (infoPtr->threadId != GetCurrentThreadId())
        {
            LeaveCriticalSection(&infoPtr->cs);  /* leave it a chance to run */
            WaitForSingleObject( handle, INFINITE );
            TRACE("animation thread stopped\n");
            EnterCriticalSection(&infoPtr->cs);
        }
 
        CloseHandle( handle );
        CloseHandle( infoPtr->hStopEvent );
        infoPtr->hStopEvent = 0;
        stopped = TRUE;
    }
    if (infoPtr->uTimer) {
    KillTimer(infoPtr->hwndSelf, infoPtr->uTimer);
    infoPtr->uTimer = 0;
    stopped = TRUE;
    }
 
    LeaveCriticalSection(&infoPtr->cs);
 
    if (stopped)
        ANIMATE_Notify(infoPtr, ACN_STOP);
 
    return TRUE;
}

Referenced by ANIMATE_DrawFrame(), ANIMATE_Free(), and ANIMATE_Stop().

ANIMATE_DrawFrame()

static BOOL ANIMATE_DrawFrame ( ANIMATE_INFO *  infoPtr, HDC  hDC  )

static

Definition at line 340 of file animate.c.

{
    TRACE("Drawing frame %d (loop %d)\n", infoPtr->currFrame, infoPtr->nLoop);
 
    mmioSeek(infoPtr->hMMio, infoPtr->lpIndex[infoPtr->currFrame], SEEK_SET);
    mmioRead(infoPtr->hMMio, infoPtr->indata, infoPtr->ash.dwSuggestedBufferSize);
 
    if (infoPtr->hic &&
    fnIC.fnICDecompress(infoPtr->hic, 0, infoPtr->inbih, infoPtr->indata,
             infoPtr->outbih, infoPtr->outdata) != ICERR_OK) {
    WARN("Decompression error\n");
    return FALSE;
    }
 
    ANIMATE_PaintFrame(infoPtr, hDC);
 
    if (infoPtr->currFrame++ >= infoPtr->nToFrame) {
    infoPtr->currFrame = infoPtr->nFromFrame;
    if (infoPtr->nLoop != -1) {
        if (--infoPtr->nLoop == 0) {
        ANIMATE_DoStop(infoPtr);
        }
    }
    }
 
    return TRUE;
}

Referenced by ANIMATE_AnimationThread(), ANIMATE_Play(), and ANIMATE_Timer().

ANIMATE_EraseBackground()

static BOOL ANIMATE_EraseBackground ( ANIMATE_INFO const *  infoPtr, HDC  hdc  )

static

Definition at line 848 of file animate.c.

{
    RECT rect;
    HBRUSH hBrush;
 
    hBrush = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLORSTATIC,
                                  (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
    GetClientRect(infoPtr->hwndSelf, &rect);
    FillRect(hdc, &rect, hBrush ? hBrush : GetCurrentObject(hdc, OBJ_BRUSH));
 
    return TRUE;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_Free()

static void ANIMATE_Free ( ANIMATE_INFO *  infoPtr )

static

Definition at line 181 of file animate.c.

{
    if (infoPtr->hMMio)
    {
        ANIMATE_DoStop(infoPtr);
        mmioClose(infoPtr->hMMio, 0);
        if (infoPtr->hRes)
        {
            FreeResource(infoPtr->hRes);
            infoPtr->hRes = 0;
        }
        heap_free (infoPtr->lpIndex);
        infoPtr->lpIndex = NULL;
        if (infoPtr->hic)
        {
            fnIC.fnICClose(infoPtr->hic);
            infoPtr->hic = 0;
        }
        heap_free (infoPtr->inbih);
        infoPtr->inbih = NULL;
        heap_free (infoPtr->outbih);
        infoPtr->outbih = NULL;
        heap_free (infoPtr->indata);
        infoPtr->indata = NULL;
        heap_free (infoPtr->outdata);
        infoPtr->outdata = NULL;
        if (infoPtr->hbmPrevFrame)
        {
            DeleteObject(infoPtr->hbmPrevFrame);
            infoPtr->hbmPrevFrame = 0;
        }
 
        memset(&infoPtr->mah, 0, sizeof(infoPtr->mah));
        memset(&infoPtr->ash, 0, sizeof(infoPtr->ash));
        infoPtr->nFromFrame = infoPtr->nToFrame = infoPtr->nLoop = infoPtr->currFrame = 0;
    }
    infoPtr->transparentColor = ANIMATE_COLOR_NONE;
}

Referenced by ANIMATE_Destroy(), ANIMATE_OpenW(), and ANIMATE_WindowProc().

ANIMATE_GetAviCodec()

static BOOL ANIMATE_GetAviCodec ( ANIMATE_INFO *  infoPtr )

static

Definition at line 646 of file animate.c.

{
    DWORD   outSize;
 
    /* check uncompressed AVI */
    if ((infoPtr->ash.fccHandler == mmioFOURCC('D', 'I', 'B', ' ')) ||
       (infoPtr->ash.fccHandler == mmioFOURCC('R', 'L', 'E', ' ')) ||
       (infoPtr->ash.fccHandler == mmioFOURCC(0, 0, 0, 0)))
    {
        infoPtr->hic = 0;
    return TRUE;
    }
 
    /* try to get a decompressor for that type */
    infoPtr->hic = fnIC.fnICOpen(ICTYPE_VIDEO, infoPtr->ash.fccHandler, ICMODE_DECOMPRESS);
    if (!infoPtr->hic) {
    WARN("Can't load codec for the file\n");
    return FALSE;
    }
 
    outSize = fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
                (DWORD_PTR)infoPtr->inbih, 0L);
 
    infoPtr->outbih = heap_alloc_zero(outSize);
    if (!infoPtr->outbih)
    return FALSE;
 
    if (fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
              (DWORD_PTR)infoPtr->inbih, (DWORD_PTR)infoPtr->outbih) != ICERR_OK) 
    {
    WARN("Can't get output BIH\n");
    return FALSE;
    }
 
    infoPtr->outdata = heap_alloc_zero(infoPtr->outbih->biSizeImage);
    if (!infoPtr->outdata) 
    return FALSE;
 
    if (fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_BEGIN,
              (DWORD_PTR)infoPtr->inbih, (DWORD_PTR)infoPtr->outbih) != ICERR_OK) {
    WARN("Can't begin decompression\n");
    return FALSE;
    }
 
    return TRUE;
}

Referenced by ANIMATE_OpenW().

ANIMATE_GetAviInfo()

static BOOL ANIMATE_GetAviInfo ( ANIMATE_INFO *  infoPtr )

static

Definition at line 478 of file animate.c.

{
    MMCKINFO        ckMainRIFF;
    MMCKINFO        mmckHead;
    MMCKINFO        mmckList;
    MMCKINFO        mmckInfo;
    DWORD       numFrame;
    DWORD       insize;
 
    if (mmioDescend(infoPtr->hMMio, &ckMainRIFF, NULL, 0) != 0) {
    WARN("Can't find 'RIFF' chunk\n");
    return FALSE;
    }
 
    if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
    (ckMainRIFF.fccType != mmioFOURCC('A', 'V', 'I', ' '))) {
    WARN("Can't find 'AVI ' chunk\n");
    return FALSE;
    }
 
    mmckHead.fccType = mmioFOURCC('h', 'd', 'r', 'l');
    if (mmioDescend(infoPtr->hMMio, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
    WARN("Can't find 'hdrl' list\n");
    return FALSE;
    }
 
    mmckInfo.ckid = mmioFOURCC('a', 'v', 'i', 'h');
    if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
    WARN("Can't find 'avih' chunk\n");
    return FALSE;
    }
 
    mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->mah, sizeof(infoPtr->mah));
 
    TRACE("mah.dwMicroSecPerFrame=%d\n",    infoPtr->mah.dwMicroSecPerFrame);
    TRACE("mah.dwMaxBytesPerSec=%d\n",      infoPtr->mah.dwMaxBytesPerSec);
    TRACE("mah.dwPaddingGranularity=%d\n",  infoPtr->mah.dwPaddingGranularity);
    TRACE("mah.dwFlags=%d\n",           infoPtr->mah.dwFlags);
    TRACE("mah.dwTotalFrames=%d\n",     infoPtr->mah.dwTotalFrames);
    TRACE("mah.dwInitialFrames=%d\n",       infoPtr->mah.dwInitialFrames);
    TRACE("mah.dwStreams=%d\n",         infoPtr->mah.dwStreams);
    TRACE("mah.dwSuggestedBufferSize=%d\n", infoPtr->mah.dwSuggestedBufferSize);
    TRACE("mah.dwWidth=%d\n",           infoPtr->mah.dwWidth);
    TRACE("mah.dwHeight=%d\n",          infoPtr->mah.dwHeight);
 
    mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
 
    mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
    if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) != 0) {
    WARN("Can't find 'strl' list\n");
    return FALSE;
    }
 
    mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'h');
    if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
    WARN("Can't find 'strh' chunk\n");
    return FALSE;
    }
 
    mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->ash, sizeof(infoPtr->ash));
 
    TRACE("ash.fccType='%c%c%c%c'\n",       LOBYTE(LOWORD(infoPtr->ash.fccType)),
                                            HIBYTE(LOWORD(infoPtr->ash.fccType)),
                                            LOBYTE(HIWORD(infoPtr->ash.fccType)),
                                            HIBYTE(HIWORD(infoPtr->ash.fccType)));
    TRACE("ash.fccHandler='%c%c%c%c'\n",    LOBYTE(LOWORD(infoPtr->ash.fccHandler)),
                                            HIBYTE(LOWORD(infoPtr->ash.fccHandler)),
                                            LOBYTE(HIWORD(infoPtr->ash.fccHandler)),
                                            HIBYTE(HIWORD(infoPtr->ash.fccHandler)));
    TRACE("ash.dwFlags=%d\n",           infoPtr->ash.dwFlags);
    TRACE("ash.wPriority=%d\n",         infoPtr->ash.wPriority);
    TRACE("ash.wLanguage=%d\n",         infoPtr->ash.wLanguage);
    TRACE("ash.dwInitialFrames=%d\n",       infoPtr->ash.dwInitialFrames);
    TRACE("ash.dwScale=%d\n",           infoPtr->ash.dwScale);
    TRACE("ash.dwRate=%d\n",            infoPtr->ash.dwRate);
    TRACE("ash.dwStart=%d\n",           infoPtr->ash.dwStart);
    TRACE("ash.dwLength=%d\n",          infoPtr->ash.dwLength);
    TRACE("ash.dwSuggestedBufferSize=%d\n",     infoPtr->ash.dwSuggestedBufferSize);
    TRACE("ash.dwQuality=%d\n",         infoPtr->ash.dwQuality);
    TRACE("ash.dwSampleSize=%d\n",      infoPtr->ash.dwSampleSize);
    TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",    infoPtr->ash.rcFrame.top, infoPtr->ash.rcFrame.left,
      infoPtr->ash.rcFrame.bottom, infoPtr->ash.rcFrame.right);
 
    mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
 
    mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'f');
    if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
    WARN("Can't find 'strh' chunk\n");
    return FALSE;
    }
 
    infoPtr->inbih = heap_alloc_zero(mmckInfo.cksize);
    if (!infoPtr->inbih) {
    WARN("Can't alloc input BIH\n");
    return FALSE;
    }
 
    mmioRead(infoPtr->hMMio, (LPSTR)infoPtr->inbih, mmckInfo.cksize);
 
    TRACE("bih.biSize=%d\n",        infoPtr->inbih->biSize);
    TRACE("bih.biWidth=%d\n",       infoPtr->inbih->biWidth);
    TRACE("bih.biHeight=%d\n",      infoPtr->inbih->biHeight);
    TRACE("bih.biPlanes=%d\n",      infoPtr->inbih->biPlanes);
    TRACE("bih.biBitCount=%d\n",    infoPtr->inbih->biBitCount);
    TRACE("bih.biCompression=%d\n",     infoPtr->inbih->biCompression);
    TRACE("bih.biSizeImage=%d\n",   infoPtr->inbih->biSizeImage);
    TRACE("bih.biXPelsPerMeter=%d\n",   infoPtr->inbih->biXPelsPerMeter);
    TRACE("bih.biYPelsPerMeter=%d\n",   infoPtr->inbih->biYPelsPerMeter);
    TRACE("bih.biClrUsed=%d\n",     infoPtr->inbih->biClrUsed);
    TRACE("bih.biClrImportant=%d\n",    infoPtr->inbih->biClrImportant);
 
    mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
 
    mmioAscend(infoPtr->hMMio, &mmckList, 0);
 
#if 0
    /* an AVI has 0 or 1 video stream, and to be animated should not contain
     * an audio stream, so only one strl is allowed
     */
    mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
    if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) == 0) {
    WARN("There should be a single 'strl' list\n");
    return FALSE;
    }
#endif
 
    mmioAscend(infoPtr->hMMio, &mmckHead, 0);
 
    /* no need to read optional JUNK chunk */
 
    mmckList.fccType = mmioFOURCC('m', 'o', 'v', 'i');
    if (mmioDescend(infoPtr->hMMio, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
    WARN("Can't find 'movi' list\n");
    return FALSE;
    }
 
    /* FIXME: should handle the 'rec ' LIST when present */
 
    infoPtr->lpIndex = heap_alloc_zero(infoPtr->mah.dwTotalFrames * sizeof(DWORD));
    if (!infoPtr->lpIndex) 
    return FALSE;
 
    numFrame = insize = 0;
    while (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, 0) == 0 &&
       numFrame < infoPtr->mah.dwTotalFrames) {
    infoPtr->lpIndex[numFrame] = mmckInfo.dwDataOffset;
    if (insize < mmckInfo.cksize)
        insize = mmckInfo.cksize;
    numFrame++;
    mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
    }
    if (numFrame != infoPtr->mah.dwTotalFrames) {
    WARN("Found %d frames (/%d)\n", numFrame, infoPtr->mah.dwTotalFrames);
    return FALSE;
    }
    if (insize > infoPtr->ash.dwSuggestedBufferSize) {
    WARN("insize=%d suggestedSize=%d\n", insize, infoPtr->ash.dwSuggestedBufferSize);
    infoPtr->ash.dwSuggestedBufferSize = insize;
    }
 
    infoPtr->indata = heap_alloc_zero(infoPtr->ash.dwSuggestedBufferSize);
    if (!infoPtr->indata) 
    return FALSE;
 
    return TRUE;
}

Referenced by ANIMATE_OpenW().

ANIMATE_LoadFileW()

static BOOL ANIMATE_LoadFileW ( ANIMATE_INFO *  infoPtr, LPWSTR  lpName  )

static

Definition at line 129 of file animate.c.

{
    infoPtr->hMMio = mmioOpenW(lpName, 0, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
 
    if(!infoPtr->hMMio) return FALSE;
    return TRUE;
}

Referenced by ANIMATE_OpenW().

ANIMATE_LoadResW()

static BOOL ANIMATE_LoadResW ( ANIMATE_INFO *  infoPtr, HINSTANCE  hInst, LPCWSTR  lpName  )

static

Definition at line 95 of file animate.c.

{
    static const WCHAR aviW[] = { 'A', 'V', 'I', 0 };
    HRSRC   hrsrc;
    MMIOINFO    mminfo;
    LPVOID  lpAvi;
 
    hrsrc = FindResourceW(hInst, lpName, aviW);
    if (!hrsrc)
    return FALSE;
 
    infoPtr->hRes = LoadResource(hInst, hrsrc);
    if (!infoPtr->hRes)
    return FALSE;
 
    lpAvi = LockResource(infoPtr->hRes);
    if (!lpAvi)
    return FALSE;
 
    memset(&mminfo, 0, sizeof(mminfo));
    mminfo.fccIOProc = FOURCC_MEM;
    mminfo.pchBuffer = lpAvi;
    mminfo.cchBuffer = SizeofResource(hInst, hrsrc);
    infoPtr->hMMio = mmioOpenW(NULL, &mminfo, MMIO_READ);
    if (!infoPtr->hMMio) 
    {
    FreeResource(infoPtr->hRes);
    return FALSE;
    }
 
    return TRUE;
}

Referenced by ANIMATE_OpenW().

ANIMATE_Notify()

static void ANIMATE_Notify ( const ANIMATE_INFO *  infoPtr, UINT  notif  )

static

Definition at line 88 of file animate.c.

{
    PostMessageW(infoPtr->hwndNotify, WM_COMMAND,
         MAKEWPARAM(GetDlgCtrlID(infoPtr->hwndSelf), notif),
         (LPARAM)infoPtr->hwndSelf);
}

Referenced by ANIMATE_DoStop(), and ANIMATE_Play().

ANIMATE_OpenA()

static BOOL ANIMATE_OpenA ( ANIMATE_INFO *  infoPtr, HINSTANCE  hInstance, LPSTR  lpszName  )

static

Definition at line 764 of file animate.c.

{
    LPWSTR lpwszName;
    LRESULT result;
    INT len;
 
    if (IS_INTRESOURCE(lpszName))
        return ANIMATE_OpenW(infoPtr, hInstance, (LPWSTR)lpszName);
 
    len = MultiByteToWideChar(CP_ACP, 0, lpszName, -1, NULL, 0);
    lpwszName = heap_alloc(len * sizeof(WCHAR));
    if (!lpwszName) return FALSE;
    MultiByteToWideChar(CP_ACP, 0, lpszName, -1, lpwszName, len);
 
    result = ANIMATE_OpenW(infoPtr, hInstance, lpwszName);
    heap_free (lpwszName);
    return result;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_OpenW()

static BOOL ANIMATE_OpenW ( ANIMATE_INFO *  infoPtr, HINSTANCE  hInstance, LPWSTR  lpszName  )

static

Definition at line 694 of file animate.c.

{
    HDC hdc;
 
    ANIMATE_Free(infoPtr);
 
    if (!lpszName) 
    {
    TRACE("Closing avi.\n");
        /* installer of thebat! v1.62 requires FALSE here */
    return (infoPtr->hMMio != 0);
    }
 
    if (!hInstance)
        hInstance = (HINSTANCE)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_HINSTANCE);
 
    TRACE("(%s)\n", debugstr_w(lpszName));
 
    if (!IS_INTRESOURCE(lpszName))
    {
    if (!ANIMATE_LoadResW(infoPtr, hInstance, lpszName)) 
        {
        TRACE("No AVI resource found.\n");
        if (!ANIMATE_LoadFileW(infoPtr, lpszName)) 
            {
        WARN("No AVI file found.\n");
        return FALSE;
        }
    }
    } 
    else 
    {
    if (!ANIMATE_LoadResW(infoPtr, hInstance, lpszName))
        {
        WARN("No AVI resource found.\n");
        return FALSE;
    }
    }
 
    if (!ANIMATE_GetAviInfo(infoPtr)) 
    {
    WARN("Can't get AVI information\n");
    ANIMATE_Free(infoPtr);
    return FALSE;
    }
 
    if (!ANIMATE_GetAviCodec(infoPtr)) 
    {
    WARN("Can't get AVI Codec\n");
    ANIMATE_Free(infoPtr);
    return FALSE;
    }
 
    hdc = GetDC(infoPtr->hwndSelf);
    /* native looks at the top left pixel of the first frame here too. */
    infoPtr->hbrushBG = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLORSTATIC,
                                             (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
    ReleaseDC(infoPtr->hwndSelf, hdc);
 
    if (!(infoPtr->dwStyle & ACS_CENTER))
    SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, infoPtr->mah.dwWidth, infoPtr->mah.dwHeight,
             SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
 
    if (infoPtr->dwStyle & ACS_AUTOPLAY) 
    return ANIMATE_Play(infoPtr, -1, 0, infoPtr->mah.dwTotalFrames - 1);
 
    return TRUE;
}

Referenced by ANIMATE_OpenA(), and ANIMATE_WindowProc().

ANIMATE_PaintFrame()

static BOOL ANIMATE_PaintFrame ( ANIMATE_INFO *  infoPtr, HDC  hDC  )

static

Definition at line 252 of file animate.c.

{
    void const *pBitmapData;
    BITMAPINFO const *pBitmapInfo;
    HDC hdcMem;
    HBITMAP hbmOld;
    int nOffsetX = 0;
    int nOffsetY = 0;
    int nWidth;
    int nHeight;
 
    if (!hDC || !infoPtr->inbih)
    return TRUE;
 
    if (infoPtr->hic )
    {
        pBitmapData = infoPtr->outdata;
        pBitmapInfo = (LPBITMAPINFO)infoPtr->outbih;
 
        nWidth = infoPtr->outbih->biWidth;
        nHeight = infoPtr->outbih->biHeight;
    } 
    else
    {
        pBitmapData = infoPtr->indata;
        pBitmapInfo = (LPBITMAPINFO)infoPtr->inbih;
 
        nWidth = infoPtr->inbih->biWidth;
        nHeight = infoPtr->inbih->biHeight;
    }
 
    if(!infoPtr->hbmPrevFrame)
    {
        infoPtr->hbmPrevFrame=CreateCompatibleBitmap(hDC, nWidth,nHeight );
    }
 
    hdcMem = CreateCompatibleDC(hDC);
    hbmOld = SelectObject(hdcMem, infoPtr->hbmPrevFrame);
 
    SetDIBits(hdcMem, infoPtr->hbmPrevFrame, 0, nHeight, pBitmapData, pBitmapInfo, DIB_RGB_COLORS);
 
    /*
     * we need to get the transparent color even without ACS_TRANSPARENT,
     * because the style can be changed later on and the color should always
     * be obtained in the first frame
     */
    if(infoPtr->transparentColor == ANIMATE_COLOR_NONE)
    {
        infoPtr->transparentColor = GetPixel(hdcMem,0,0);
    }
 
    if(infoPtr->dwStyle & ACS_TRANSPARENT)
    {
        HDC hdcFinal = CreateCompatibleDC(hDC);
        HBITMAP hbmFinal = CreateCompatibleBitmap(hDC,nWidth, nHeight);
        HBITMAP hbmOld2 = SelectObject(hdcFinal, hbmFinal);
        RECT rect;
 
        SetRect(&rect, 0, 0, nWidth, nHeight);
 
        if(!infoPtr->hbrushBG)
            infoPtr->hbrushBG = GetCurrentObject(hDC, OBJ_BRUSH);
 
        FillRect(hdcFinal, &rect, infoPtr->hbrushBG);
        ANIMATE_TransparentBlt(infoPtr, hdcFinal, hdcMem);
 
        SelectObject(hdcFinal, hbmOld2);
        SelectObject(hdcMem, hbmFinal);
        DeleteDC(hdcFinal);
        DeleteObject(infoPtr->hbmPrevFrame);
        infoPtr->hbmPrevFrame = hbmFinal;
    }
 
    if (infoPtr->dwStyle & ACS_CENTER)
    {
        RECT rect;
 
        GetWindowRect(infoPtr->hwndSelf, &rect);
        nOffsetX = ((rect.right - rect.left) - nWidth)/2;
        nOffsetY = ((rect.bottom - rect.top) - nHeight)/2;
    }
    BitBlt(hDC, nOffsetX, nOffsetY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY);
 
    SelectObject(hdcMem, hbmOld);
    DeleteDC(hdcMem);
    return TRUE;
}

Referenced by ANIMATE_DrawFrame(), and ANIMATE_WindowProc().

ANIMATE_Play()

static LRESULT ANIMATE_Play ( ANIMATE_INFO *  infoPtr, UINT  cRepeat, WORD  wFrom, WORD  wTo  )

static

Definition at line 409 of file animate.c.

{
    /* nothing opened */
    if (!infoPtr->hMMio)
    return FALSE;
 
    if (infoPtr->hThread || infoPtr->uTimer) {
    TRACE("Already playing\n");
    return TRUE;
    }
 
    infoPtr->nFromFrame = wFrom;
    infoPtr->nToFrame   = wTo;
    infoPtr->nLoop      = cRepeat;
 
    if (infoPtr->nToFrame == 0xFFFF)
    infoPtr->nToFrame = infoPtr->mah.dwTotalFrames - 1;
 
    TRACE("(repeat=%d from=%d to=%d);\n",
      infoPtr->nLoop, infoPtr->nFromFrame, infoPtr->nToFrame);
 
    if (infoPtr->nFromFrame >= infoPtr->mah.dwTotalFrames &&
        (SHORT)infoPtr->nFromFrame < 0)
        infoPtr->nFromFrame = 0;
 
    if (infoPtr->nFromFrame > infoPtr->nToFrame ||
    infoPtr->nToFrame >= infoPtr->mah.dwTotalFrames)
    return FALSE;
 
    infoPtr->currFrame = infoPtr->nFromFrame;
 
    /* seek - doesn't need to start a thread or set a timer and neither
     * does it send a notification */
    if (infoPtr->nFromFrame == infoPtr->nToFrame)
    {
        HDC hDC;
 
        if ((hDC = GetDC(infoPtr->hwndSelf)) != 0)
        {
            ANIMATE_DrawFrame(infoPtr, hDC);
 
        ReleaseDC(infoPtr->hwndSelf, hDC);
        }
        return TRUE;
    }
 
    if (infoPtr->dwStyle & ACS_TIMER) 
    {
    TRACE("Using a timer\n");
    /* create a timer to display AVI */
    infoPtr->uTimer = SetTimer(infoPtr->hwndSelf, 1, 
                                   infoPtr->mah.dwMicroSecPerFrame / 1000, NULL);
    } 
    else 
    {
    TRACE("Using an animation thread\n");
        infoPtr->hStopEvent = CreateEventW( NULL, TRUE, FALSE, NULL );
        infoPtr->hThread = CreateThread(0, 0, ANIMATE_AnimationThread,
                                        infoPtr, 0, &infoPtr->threadId);
        if(!infoPtr->hThread) return FALSE;
 
    }
 
    ANIMATE_Notify(infoPtr, ACN_START);
 
    return TRUE;
}

Referenced by ANIMATE_OpenW(), and ANIMATE_WindowProc().

ANIMATE_Register()

void ANIMATE_Register

(

void

)

Definition at line 965 of file animate.c.

{
    WNDCLASSW wndClass;
 
    ZeroMemory(&wndClass, sizeof(WNDCLASSW));
    wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
    wndClass.lpfnWndProc   = ANIMATE_WindowProc;
    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = sizeof(ANIMATE_INFO *);
    wndClass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
    wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wndClass.lpszClassName = ANIMATE_CLASSW;
 
    RegisterClassW(&wndClass);
}

Referenced by DllMain().

ANIMATE_Stop()

static BOOL ANIMATE_Stop ( ANIMATE_INFO *  infoPtr )

static

Definition at line 784 of file animate.c.

{
    /* nothing opened */
    if (!infoPtr->hMMio)
    return FALSE;
 
    ANIMATE_DoStop(infoPtr);
    return TRUE;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_StyleChanged()

static LRESULT ANIMATE_StyleChanged ( ANIMATE_INFO *  infoPtr, WPARAM  wStyleType, const STYLESTRUCT *  lpss  )

static

Definition at line 862 of file animate.c.

{
    TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
          wStyleType, lpss->styleOld, lpss->styleNew);
 
    if (wStyleType != GWL_STYLE) return 0;
  
    infoPtr->dwStyle = lpss->styleNew;
 
    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
    return 0;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_Timer()

static LRESULT ANIMATE_Timer ( ANIMATE_INFO *  infoPtr )

static

Definition at line 368 of file animate.c.

{
    HDC hDC;
 
    if ((hDC = GetDC(infoPtr->hwndSelf)) != 0)
    {
        EnterCriticalSection(&infoPtr->cs);
        ANIMATE_DrawFrame(infoPtr, hDC);
        LeaveCriticalSection(&infoPtr->cs);
 
    ReleaseDC(infoPtr->hwndSelf, hDC);
    }
 
    return 0;
}

Referenced by ANIMATE_WindowProc().

ANIMATE_TransparentBlt()

static void ANIMATE_TransparentBlt ( ANIMATE_INFO const *  infoPtr, HDC  hdcDest, HDC  hdcSource  )

static

Definition at line 220 of file animate.c.

{
    HDC hdcMask;
    HBITMAP hbmMask;
    HBITMAP hbmOld;
 
    /* create a transparency mask */
    hdcMask = CreateCompatibleDC(hdcDest);
    hbmMask = CreateBitmap(infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, 1,1,NULL);
    hbmOld = SelectObject(hdcMask, hbmMask);
 
    SetBkColor(hdcSource,infoPtr->transparentColor);
    BitBlt(hdcMask,0,0,infoPtr->inbih->biWidth, infoPtr->inbih->biHeight,hdcSource,0,0,SRCCOPY);
 
    /* mask the source bitmap */
    SetBkColor(hdcSource, RGB(0,0,0));
    SetTextColor(hdcSource, RGB(255,255,255));
    BitBlt(hdcSource, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
 
    /* mask the destination bitmap */
    SetBkColor(hdcDest, RGB(255,255,255));
    SetTextColor(hdcDest, RGB(0,0,0));
    BitBlt(hdcDest, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
 
    /* combine source and destination */
    BitBlt(hdcDest,0,0,infoPtr->inbih->biWidth, infoPtr->inbih->biHeight,hdcSource,0,0,SRCPAINT);
 
    SelectObject(hdcMask, hbmOld);
    DeleteObject(hbmMask);
    DeleteDC(hdcMask);
}

Referenced by ANIMATE_PaintFrame().

ANIMATE_Unregister()

void ANIMATE_Unregister

(

void

)

Definition at line 982 of file animate.c.

{
    UnregisterClassW(ANIMATE_CLASSW, NULL);
}

Referenced by DllMain().

ANIMATE_WindowProc()

static LRESULT WINAPI ANIMATE_WindowProc ( HWND  hWnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 876 of file animate.c.

{
    ANIMATE_INFO *infoPtr = (ANIMATE_INFO *)GetWindowLongPtrW(hWnd, 0);
 
    TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hWnd, uMsg, wParam, lParam);
    if (!infoPtr && (uMsg != WM_NCCREATE))
    return DefWindowProcW(hWnd, uMsg, wParam, lParam);
    switch (uMsg)
    {
    case ACM_OPENA:
    return ANIMATE_OpenA(infoPtr, (HINSTANCE)wParam, (LPSTR)lParam);
 
    case ACM_OPENW:
    return ANIMATE_OpenW(infoPtr, (HINSTANCE)wParam, (LPWSTR)lParam);
 
    case ACM_PLAY:
    return ANIMATE_Play(infoPtr, (INT)wParam, LOWORD(lParam), HIWORD(lParam));
 
    case ACM_STOP:
    return ANIMATE_Stop(infoPtr);
 
    case WM_CLOSE:
    ANIMATE_Free(infoPtr);
    return 0;
 
    case WM_NCCREATE:
    return ANIMATE_Create(hWnd, (LPCREATESTRUCTW)lParam);
 
    case WM_NCHITTEST:
    return HTTRANSPARENT;
 
    case WM_DESTROY:
    return ANIMATE_Destroy(infoPtr);
 
    case WM_ERASEBKGND:
    return ANIMATE_EraseBackground(infoPtr, (HDC)wParam);
 
    case WM_STYLECHANGED:
        return ANIMATE_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
 
    case WM_TIMER:
        return ANIMATE_Timer(infoPtr);
 
    case WM_PRINTCLIENT:
    case WM_PAINT:
        {
            /* the animation has not decompressed
             * (and displayed) the first frame yet, don't paint
             */
            if (!infoPtr->hbmPrevFrame)
            {
                /* default paint handling */
                return DefWindowProcW(hWnd, uMsg, wParam, lParam);
            }
 
            if (wParam)
            {
                EnterCriticalSection(&infoPtr->cs);
                ANIMATE_PaintFrame(infoPtr, (HDC)wParam);
                LeaveCriticalSection(&infoPtr->cs);
            }
            else
            {
                PAINTSTRUCT ps;
                HDC hDC = BeginPaint(infoPtr->hwndSelf, &ps);
 
                EnterCriticalSection(&infoPtr->cs);
                ANIMATE_PaintFrame(infoPtr, hDC);
                LeaveCriticalSection(&infoPtr->cs);
 
                EndPaint(infoPtr->hwndSelf, &ps);
            }
        }
        break;
 
    case WM_SIZE:
        if (infoPtr->dwStyle & ACS_CENTER) 
        InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
    return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 
    default:
    if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
        ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
 
    return DefWindowProcW(hWnd, uMsg, wParam, lParam);
    }
    return 0;
}

Referenced by ANIMATE_Register().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

animate

)

Variable Documentation

DWORD

DWORD

Definition at line 45 of file animate.c.

DWORD_PTR

DWORD_PTR

Definition at line 47 of file animate.c.

Referenced by ANIMATE_Create().

struct { ... } fnIC

Referenced by ANIMATE_Create(), ANIMATE_DrawFrame(), ANIMATE_Free(), and ANIMATE_GetAviCodec().

hModule

HMODULE hModule

Definition at line 44 of file animate.c.

LPBITMAPINFOHEADER

LPBITMAPINFOHEADER

Definition at line 48 of file animate.c.

LPVOID

LPVOID

Definition at line 48 of file animate.c.

UINT

UINT

Definition at line 45 of file animate.c.