d3d10: Create shaders.
[wine] / dlls / comctl32 / animate.c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3  * Animation control
4  *
5  * Copyright 1998, 1999 Eric Kohl
6  * Copyright 1999 Eric Pouech
7  * Copyright 2005 Dimitrie O. Paun
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  *
23  * NOTES
24  *
25  * This code was audited for completeness against the documented features
26  * of Comctl32.dll version 6.0 on Mar. 15, 2005, by Dimitrie O. Paun.
27  * 
28  * Unless otherwise noted, we believe this code to be complete, as per
29  * the specification mentioned above.
30  * If you discover missing features, or bugs, please note them below.
31  * 
32  * TODO:
33  *   - check for the 'rec ' list in some AVI files
34  */
35
36 #include <stdarg.h>
37 #include <string.h>
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wingdi.h"
41 #include "winuser.h"
42 #include "winnls.h"
43 #include "commctrl.h"
44 #include "vfw.h"
45 #include "mmsystem.h"
46 #include "comctl32.h"
47 #include "wine/debug.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(animate);
50
51 static struct {
52     HMODULE     hModule;
53     HIC         (WINAPI *fnICOpen)(DWORD, DWORD, UINT);
54     LRESULT     (WINAPI *fnICClose)(HIC);
55     LRESULT     (WINAPI *fnICSendMessage)(HIC, UINT, DWORD_PTR, DWORD_PTR);
56     DWORD       (WINAPIV *fnICDecompress)(HIC,DWORD,LPBITMAPINFOHEADER,LPVOID,LPBITMAPINFOHEADER,LPVOID);
57 } fnIC;
58
59 typedef struct
60 {
61    /* reference to input stream (file or resource) */
62    HGLOBAL              hRes;
63    HMMIO                hMMio;  /* handle to mmio stream */
64    HWND                 hwndSelf;
65    HWND                 hwndNotify;
66    DWORD                dwStyle;
67    /* information on the loaded AVI file */
68    MainAVIHeader        mah;
69    AVIStreamHeader      ash;
70    LPBITMAPINFOHEADER   inbih;
71    LPDWORD              lpIndex;
72    /* data for the decompressor */
73    HIC                  hic;
74    LPBITMAPINFOHEADER   outbih;
75    LPVOID               indata;
76    LPVOID               outdata;
77    /* data for the background mechanism */
78    CRITICAL_SECTION     cs;
79    HANDLE               hStopEvent;
80    HANDLE               hThread;
81    DWORD                threadId;
82    UINT                 uTimer;
83    /* data for playing the file */
84    int                  nFromFrame;
85    int                  nToFrame;
86    int                  nLoop;
87    int                  currFrame;
88    /* transparency info*/
89    COLORREF             transparentColor;
90    HBRUSH               hbrushBG;
91    HBITMAP              hbmPrevFrame;
92 } ANIMATE_INFO;
93
94 #define ANIMATE_COLOR_NONE      0xffffffff
95
96 static void ANIMATE_Notify(const ANIMATE_INFO *infoPtr, UINT notif)
97 {
98     PostMessageW(infoPtr->hwndNotify, WM_COMMAND,
99                  MAKEWPARAM(GetDlgCtrlID(infoPtr->hwndSelf), notif),
100                  (LPARAM)infoPtr->hwndSelf);
101 }
102
103 static BOOL ANIMATE_LoadResW(ANIMATE_INFO *infoPtr, HINSTANCE hInst, LPCWSTR lpName)
104 {
105     static const WCHAR aviW[] = { 'A', 'V', 'I', 0 };
106     HRSRC       hrsrc;
107     MMIOINFO    mminfo;
108     LPVOID      lpAvi;
109
110     hrsrc = FindResourceW(hInst, lpName, aviW);
111     if (!hrsrc)
112         return FALSE;
113
114     infoPtr->hRes = LoadResource(hInst, hrsrc);
115     if (!infoPtr->hRes)
116         return FALSE;
117
118     lpAvi = LockResource(infoPtr->hRes);
119     if (!lpAvi)
120         return FALSE;
121
122     memset(&mminfo, 0, sizeof(mminfo));
123     mminfo.fccIOProc = FOURCC_MEM;
124     mminfo.pchBuffer = lpAvi;
125     mminfo.cchBuffer = SizeofResource(hInst, hrsrc);
126     infoPtr->hMMio = mmioOpenW(NULL, &mminfo, MMIO_READ);
127     if (!infoPtr->hMMio) 
128     {
129         FreeResource(infoPtr->hRes);
130         return FALSE;
131     }
132
133     return TRUE;
134 }
135
136
137 static BOOL ANIMATE_LoadFileW(ANIMATE_INFO *infoPtr, LPWSTR lpName)
138 {
139     infoPtr->hMMio = mmioOpenW(lpName, 0, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE);
140
141     if(!infoPtr->hMMio) return FALSE;
142     return TRUE;
143 }
144
145
146 static BOOL ANIMATE_DoStop(ANIMATE_INFO *infoPtr)
147 {
148     BOOL stopped = FALSE;
149
150     EnterCriticalSection(&infoPtr->cs);
151
152     /* should stop playing */
153     if (infoPtr->hThread)
154     {
155         HANDLE handle = infoPtr->hThread;
156
157         TRACE("stopping animation thread\n");
158         infoPtr->hThread = 0;
159         SetEvent( infoPtr->hStopEvent );
160
161         if (infoPtr->threadId != GetCurrentThreadId())
162         {
163             LeaveCriticalSection(&infoPtr->cs);  /* leave it a chance to run */
164             WaitForSingleObject( handle, INFINITE );
165             TRACE("animation thread stopped\n");
166             EnterCriticalSection(&infoPtr->cs);
167         }
168
169         CloseHandle( handle );
170         CloseHandle( infoPtr->hStopEvent );
171         infoPtr->hStopEvent = 0;
172         stopped = TRUE;
173     }
174     if (infoPtr->uTimer) {
175         KillTimer(infoPtr->hwndSelf, infoPtr->uTimer);
176         infoPtr->uTimer = 0;
177         stopped = TRUE;
178     }
179
180     LeaveCriticalSection(&infoPtr->cs);
181
182     if (stopped)
183         ANIMATE_Notify(infoPtr, ACN_STOP);
184
185     return TRUE;
186 }
187
188
189 static void ANIMATE_Free(ANIMATE_INFO *infoPtr)
190 {
191     if (infoPtr->hMMio) {
192         ANIMATE_DoStop(infoPtr);
193         mmioClose(infoPtr->hMMio, 0);
194         if (infoPtr->hRes) {
195             FreeResource(infoPtr->hRes);
196             infoPtr->hRes = 0;
197         }
198         Free (infoPtr->lpIndex);
199         infoPtr->lpIndex = NULL;
200         if (infoPtr->hic) {
201             fnIC.fnICClose(infoPtr->hic);
202             infoPtr->hic = 0;
203         }
204         Free (infoPtr->inbih);
205         infoPtr->inbih = NULL;
206         Free (infoPtr->outbih);
207         infoPtr->outbih = NULL;
208         Free (infoPtr->indata);
209         infoPtr->indata = NULL;
210         Free (infoPtr->outdata);
211         infoPtr->outdata = NULL;
212         if( infoPtr->hbmPrevFrame )
213         {
214             DeleteObject(infoPtr->hbmPrevFrame);
215             infoPtr->hbmPrevFrame = 0;
216         }
217
218         memset(&infoPtr->mah, 0, sizeof(infoPtr->mah));
219         memset(&infoPtr->ash, 0, sizeof(infoPtr->ash));
220         infoPtr->nFromFrame = infoPtr->nToFrame = infoPtr->nLoop = infoPtr->currFrame = 0;
221     }
222     infoPtr->transparentColor = ANIMATE_COLOR_NONE;
223 }
224
225 static void ANIMATE_TransparentBlt(ANIMATE_INFO const *infoPtr, HDC hdcDest, HDC hdcSource)
226 {
227     HDC hdcMask;
228     HBITMAP hbmMask;
229     HBITMAP hbmOld;
230
231     /* create a transparency mask */
232     hdcMask = CreateCompatibleDC(hdcDest);
233     hbmMask = CreateBitmap(infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, 1,1,NULL);
234     hbmOld = SelectObject(hdcMask, hbmMask);
235
236     SetBkColor(hdcSource,infoPtr->transparentColor);
237     BitBlt(hdcMask,0,0,infoPtr->inbih->biWidth, infoPtr->inbih->biHeight,hdcSource,0,0,SRCCOPY);
238
239     /* mask the source bitmap */
240     SetBkColor(hdcSource, RGB(0,0,0));
241     SetTextColor(hdcSource, RGB(255,255,255));
242     BitBlt(hdcSource, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
243
244     /* mask the destination bitmap */
245     SetBkColor(hdcDest, RGB(255,255,255));
246     SetTextColor(hdcDest, RGB(0,0,0));
247     BitBlt(hdcDest, 0, 0, infoPtr->inbih->biWidth, infoPtr->inbih->biHeight, hdcMask, 0, 0, SRCAND);
248
249     /* combine source and destination */
250     BitBlt(hdcDest,0,0,infoPtr->inbih->biWidth, infoPtr->inbih->biHeight,hdcSource,0,0,SRCPAINT);
251
252     SelectObject(hdcMask, hbmOld);
253     DeleteObject(hbmMask);
254     DeleteDC(hdcMask);
255 }
256
257 static BOOL ANIMATE_PaintFrame(ANIMATE_INFO* infoPtr, HDC hDC)
258 {
259     void const *pBitmapData;
260     BITMAPINFO const *pBitmapInfo;
261     HDC hdcMem;
262     HBITMAP hbmOld;
263     int nOffsetX = 0;
264     int nOffsetY = 0;
265     int nWidth;
266     int nHeight;
267
268     if (!hDC || !infoPtr->inbih)
269         return TRUE;
270
271     if (infoPtr->hic )
272     {
273         pBitmapData = infoPtr->outdata;
274         pBitmapInfo = (LPBITMAPINFO)infoPtr->outbih;
275
276         nWidth = infoPtr->outbih->biWidth;
277         nHeight = infoPtr->outbih->biHeight;
278     } 
279     else
280     {
281         pBitmapData = infoPtr->indata;
282         pBitmapInfo = (LPBITMAPINFO)infoPtr->inbih;
283
284         nWidth = infoPtr->inbih->biWidth;
285         nHeight = infoPtr->inbih->biHeight;
286     }
287
288     if(!infoPtr->hbmPrevFrame)
289     {
290         infoPtr->hbmPrevFrame=CreateCompatibleBitmap(hDC, nWidth,nHeight );
291     }
292
293     hdcMem = CreateCompatibleDC(hDC);
294     hbmOld = SelectObject(hdcMem, infoPtr->hbmPrevFrame);
295
296     SetDIBits(hdcMem, infoPtr->hbmPrevFrame, 0, nHeight, pBitmapData, pBitmapInfo, DIB_RGB_COLORS);
297
298     /*
299      * we need to get the transparent color even without ACS_TRANSPARENT,
300      * because the style can be changed later on and the color should always
301      * be obtained in the first frame
302      */
303     if(infoPtr->transparentColor == ANIMATE_COLOR_NONE)
304     {
305         infoPtr->transparentColor = GetPixel(hdcMem,0,0);
306     }
307
308     if(infoPtr->dwStyle & ACS_TRANSPARENT)
309     {
310         HDC hdcFinal = CreateCompatibleDC(hDC);
311         HBITMAP hbmFinal = CreateCompatibleBitmap(hDC,nWidth, nHeight);
312         HBITMAP hbmOld2 = SelectObject(hdcFinal, hbmFinal);
313         RECT rect;
314
315         rect.left = 0;
316         rect.top = 0;
317         rect.right = nWidth;
318         rect.bottom = nHeight;
319
320         if(!infoPtr->hbrushBG)
321             infoPtr->hbrushBG = GetCurrentObject(hDC, OBJ_BRUSH);
322
323         FillRect(hdcFinal, &rect, infoPtr->hbrushBG);
324         ANIMATE_TransparentBlt(infoPtr, hdcFinal, hdcMem);
325
326         SelectObject(hdcFinal, hbmOld2);
327         SelectObject(hdcMem, hbmFinal);
328         DeleteDC(hdcFinal);
329         DeleteObject(infoPtr->hbmPrevFrame);
330         infoPtr->hbmPrevFrame = hbmFinal;
331     }
332
333     if (infoPtr->dwStyle & ACS_CENTER)
334     {
335         RECT rect;
336
337         GetWindowRect(infoPtr->hwndSelf, &rect);
338         nOffsetX = ((rect.right - rect.left) - nWidth)/2;
339         nOffsetY = ((rect.bottom - rect.top) - nHeight)/2;
340     }
341     BitBlt(hDC, nOffsetX, nOffsetY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY);
342
343     SelectObject(hdcMem, hbmOld);
344     DeleteDC(hdcMem);
345     return TRUE;
346 }
347
348 static BOOL ANIMATE_DrawFrame(ANIMATE_INFO *infoPtr, HDC hDC)
349 {
350     TRACE("Drawing frame %d (loop %d)\n", infoPtr->currFrame, infoPtr->nLoop);
351
352     mmioSeek(infoPtr->hMMio, infoPtr->lpIndex[infoPtr->currFrame], SEEK_SET);
353     mmioRead(infoPtr->hMMio, infoPtr->indata, infoPtr->ash.dwSuggestedBufferSize);
354
355     if (infoPtr->hic &&
356         fnIC.fnICDecompress(infoPtr->hic, 0, infoPtr->inbih, infoPtr->indata,
357                      infoPtr->outbih, infoPtr->outdata) != ICERR_OK) {
358         WARN("Decompression error\n");
359         return FALSE;
360     }
361
362     ANIMATE_PaintFrame(infoPtr, hDC);
363
364     if (infoPtr->currFrame++ >= infoPtr->nToFrame) {
365         infoPtr->currFrame = infoPtr->nFromFrame;
366         if (infoPtr->nLoop != -1) {
367             if (--infoPtr->nLoop == 0) {
368                 ANIMATE_DoStop(infoPtr);
369             }
370         }
371     }
372
373     return TRUE;
374 }
375
376 static LRESULT ANIMATE_Timer(ANIMATE_INFO *infoPtr)
377 {
378     HDC hDC;
379
380     if ((hDC = GetDC(infoPtr->hwndSelf)) != 0)
381     {
382         EnterCriticalSection(&infoPtr->cs);
383         ANIMATE_DrawFrame(infoPtr, hDC);
384         LeaveCriticalSection(&infoPtr->cs);
385
386         ReleaseDC(infoPtr->hwndSelf, hDC);
387     }
388
389     return 0;
390 }
391
392 static DWORD CALLBACK ANIMATE_AnimationThread(LPVOID ptr_)
393 {
394     ANIMATE_INFO *infoPtr = ptr_;
395     HANDLE event;
396     DWORD timeout;
397
398     while(1)
399     {
400         HDC hDC = GetDC(infoPtr->hwndSelf);
401
402         EnterCriticalSection(&infoPtr->cs);
403         ANIMATE_DrawFrame(infoPtr, hDC);
404         timeout = infoPtr->mah.dwMicroSecPerFrame;
405         event = infoPtr->hStopEvent;
406         LeaveCriticalSection(&infoPtr->cs);
407
408         ReleaseDC(infoPtr->hwndSelf, hDC);
409
410         /* time is in microseconds, we should convert it to milliseconds */
411         if ((event == 0) || WaitForSingleObject( event, (timeout+500)/1000) == WAIT_OBJECT_0)
412             break;
413     }
414     return TRUE;
415 }
416
417 static LRESULT ANIMATE_Play(ANIMATE_INFO *infoPtr, UINT cRepeat, WORD wFrom, WORD wTo)
418 {
419     /* nothing opened */
420     if (!infoPtr->hMMio)
421         return FALSE;
422
423     if (infoPtr->hThread || infoPtr->uTimer) {
424         TRACE("Already playing\n");
425         return TRUE;
426     }
427
428     infoPtr->nFromFrame = wFrom;
429     infoPtr->nToFrame   = wTo;
430     infoPtr->nLoop      = cRepeat;
431
432     if (infoPtr->nToFrame == 0xFFFF)
433         infoPtr->nToFrame = infoPtr->mah.dwTotalFrames - 1;
434
435     TRACE("(repeat=%d from=%d to=%d);\n",
436           infoPtr->nLoop, infoPtr->nFromFrame, infoPtr->nToFrame);
437
438     if (infoPtr->nFromFrame >= infoPtr->mah.dwTotalFrames &&
439         (SHORT)infoPtr->nFromFrame < 0)
440         infoPtr->nFromFrame = 0;
441
442     if (infoPtr->nFromFrame > infoPtr->nToFrame ||
443         infoPtr->nToFrame >= infoPtr->mah.dwTotalFrames)
444         return FALSE;
445
446     infoPtr->currFrame = infoPtr->nFromFrame;
447
448     /* seek - doesn't need to start a thread or set a timer and neither
449      * does it send a notification */
450     if (infoPtr->nFromFrame == infoPtr->nToFrame)
451     {
452         HDC hDC;
453
454         if ((hDC = GetDC(infoPtr->hwndSelf)) != 0)
455         {
456             ANIMATE_DrawFrame(infoPtr, hDC);
457
458             ReleaseDC(infoPtr->hwndSelf, hDC);
459         }
460         return TRUE;
461     }
462
463     if (infoPtr->dwStyle & ACS_TIMER) 
464     {
465         TRACE("Using a timer\n");
466         /* create a timer to display AVI */
467         infoPtr->uTimer = SetTimer(infoPtr->hwndSelf, 1, 
468                                    infoPtr->mah.dwMicroSecPerFrame / 1000, NULL);
469     } 
470     else 
471     {
472         TRACE("Using an animation thread\n");
473         infoPtr->hStopEvent = CreateEventW( NULL, TRUE, FALSE, NULL );
474         infoPtr->hThread = CreateThread(0, 0, ANIMATE_AnimationThread,
475                                         infoPtr, 0, &infoPtr->threadId);
476         if(!infoPtr->hThread) return FALSE;
477
478     }
479
480     ANIMATE_Notify(infoPtr, ACN_START);
481
482     return TRUE;
483 }
484
485
486 static BOOL ANIMATE_GetAviInfo(ANIMATE_INFO *infoPtr)
487 {
488     MMCKINFO            ckMainRIFF;
489     MMCKINFO            mmckHead;
490     MMCKINFO            mmckList;
491     MMCKINFO            mmckInfo;
492     DWORD               numFrame;
493     DWORD               insize;
494
495     if (mmioDescend(infoPtr->hMMio, &ckMainRIFF, NULL, 0) != 0) {
496         WARN("Can't find 'RIFF' chunk\n");
497         return FALSE;
498     }
499
500     if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
501         (ckMainRIFF.fccType != mmioFOURCC('A', 'V', 'I', ' '))) {
502         WARN("Can't find 'AVI ' chunk\n");
503         return FALSE;
504     }
505
506     mmckHead.fccType = mmioFOURCC('h', 'd', 'r', 'l');
507     if (mmioDescend(infoPtr->hMMio, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
508         WARN("Can't find 'hdrl' list\n");
509         return FALSE;
510     }
511
512     mmckInfo.ckid = mmioFOURCC('a', 'v', 'i', 'h');
513     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
514         WARN("Can't find 'avih' chunk\n");
515         return FALSE;
516     }
517
518     mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->mah, sizeof(infoPtr->mah));
519
520     TRACE("mah.dwMicroSecPerFrame=%d\n",        infoPtr->mah.dwMicroSecPerFrame);
521     TRACE("mah.dwMaxBytesPerSec=%d\n",          infoPtr->mah.dwMaxBytesPerSec);
522     TRACE("mah.dwPaddingGranularity=%d\n",      infoPtr->mah.dwPaddingGranularity);
523     TRACE("mah.dwFlags=%d\n",                   infoPtr->mah.dwFlags);
524     TRACE("mah.dwTotalFrames=%d\n",             infoPtr->mah.dwTotalFrames);
525     TRACE("mah.dwInitialFrames=%d\n",           infoPtr->mah.dwInitialFrames);
526     TRACE("mah.dwStreams=%d\n",                 infoPtr->mah.dwStreams);
527     TRACE("mah.dwSuggestedBufferSize=%d\n",     infoPtr->mah.dwSuggestedBufferSize);
528     TRACE("mah.dwWidth=%d\n",                   infoPtr->mah.dwWidth);
529     TRACE("mah.dwHeight=%d\n",                  infoPtr->mah.dwHeight);
530
531     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
532
533     mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
534     if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) != 0) {
535         WARN("Can't find 'strl' list\n");
536         return FALSE;
537     }
538
539     mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'h');
540     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
541         WARN("Can't find 'strh' chunk\n");
542         return FALSE;
543     }
544
545     mmioRead(infoPtr->hMMio, (LPSTR)&infoPtr->ash, sizeof(infoPtr->ash));
546
547     TRACE("ash.fccType='%c%c%c%c'\n",           LOBYTE(LOWORD(infoPtr->ash.fccType)),
548                                                 HIBYTE(LOWORD(infoPtr->ash.fccType)),
549                                                 LOBYTE(HIWORD(infoPtr->ash.fccType)),
550                                                 HIBYTE(HIWORD(infoPtr->ash.fccType)));
551     TRACE("ash.fccHandler='%c%c%c%c'\n",        LOBYTE(LOWORD(infoPtr->ash.fccHandler)),
552                                                 HIBYTE(LOWORD(infoPtr->ash.fccHandler)),
553                                                 LOBYTE(HIWORD(infoPtr->ash.fccHandler)),
554                                                 HIBYTE(HIWORD(infoPtr->ash.fccHandler)));
555     TRACE("ash.dwFlags=%d\n",                   infoPtr->ash.dwFlags);
556     TRACE("ash.wPriority=%d\n",                 infoPtr->ash.wPriority);
557     TRACE("ash.wLanguage=%d\n",                 infoPtr->ash.wLanguage);
558     TRACE("ash.dwInitialFrames=%d\n",           infoPtr->ash.dwInitialFrames);
559     TRACE("ash.dwScale=%d\n",                   infoPtr->ash.dwScale);
560     TRACE("ash.dwRate=%d\n",                    infoPtr->ash.dwRate);
561     TRACE("ash.dwStart=%d\n",                   infoPtr->ash.dwStart);
562     TRACE("ash.dwLength=%d\n",                  infoPtr->ash.dwLength);
563     TRACE("ash.dwSuggestedBufferSize=%d\n",     infoPtr->ash.dwSuggestedBufferSize);
564     TRACE("ash.dwQuality=%d\n",                 infoPtr->ash.dwQuality);
565     TRACE("ash.dwSampleSize=%d\n",              infoPtr->ash.dwSampleSize);
566     TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",        infoPtr->ash.rcFrame.top, infoPtr->ash.rcFrame.left,
567           infoPtr->ash.rcFrame.bottom, infoPtr->ash.rcFrame.right);
568
569     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
570
571     mmckInfo.ckid = mmioFOURCC('s', 't', 'r', 'f');
572     if (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, MMIO_FINDCHUNK) != 0) {
573         WARN("Can't find 'strh' chunk\n");
574         return FALSE;
575     }
576
577     infoPtr->inbih = Alloc(mmckInfo.cksize);
578     if (!infoPtr->inbih) {
579         WARN("Can't alloc input BIH\n");
580         return FALSE;
581     }
582
583     mmioRead(infoPtr->hMMio, (LPSTR)infoPtr->inbih, mmckInfo.cksize);
584
585     TRACE("bih.biSize=%d\n",            infoPtr->inbih->biSize);
586     TRACE("bih.biWidth=%d\n",           infoPtr->inbih->biWidth);
587     TRACE("bih.biHeight=%d\n",          infoPtr->inbih->biHeight);
588     TRACE("bih.biPlanes=%d\n",          infoPtr->inbih->biPlanes);
589     TRACE("bih.biBitCount=%d\n",        infoPtr->inbih->biBitCount);
590     TRACE("bih.biCompression=%d\n",     infoPtr->inbih->biCompression);
591     TRACE("bih.biSizeImage=%d\n",       infoPtr->inbih->biSizeImage);
592     TRACE("bih.biXPelsPerMeter=%d\n",   infoPtr->inbih->biXPelsPerMeter);
593     TRACE("bih.biYPelsPerMeter=%d\n",   infoPtr->inbih->biYPelsPerMeter);
594     TRACE("bih.biClrUsed=%d\n",         infoPtr->inbih->biClrUsed);
595     TRACE("bih.biClrImportant=%d\n",    infoPtr->inbih->biClrImportant);
596
597     mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
598
599     mmioAscend(infoPtr->hMMio, &mmckList, 0);
600
601 #if 0
602     /* an AVI has 0 or 1 video stream, and to be animated should not contain
603      * an audio stream, so only one strl is allowed
604      */
605     mmckList.fccType = mmioFOURCC('s', 't', 'r', 'l');
606     if (mmioDescend(infoPtr->hMMio, &mmckList, &mmckHead, MMIO_FINDLIST) == 0) {
607         WARN("There should be a single 'strl' list\n");
608         return FALSE;
609     }
610 #endif
611
612     mmioAscend(infoPtr->hMMio, &mmckHead, 0);
613
614     /* no need to read optional JUNK chunk */
615
616     mmckList.fccType = mmioFOURCC('m', 'o', 'v', 'i');
617     if (mmioDescend(infoPtr->hMMio, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
618         WARN("Can't find 'movi' list\n");
619         return FALSE;
620     }
621
622     /* FIXME: should handle the 'rec ' LIST when present */
623
624     infoPtr->lpIndex = Alloc(infoPtr->mah.dwTotalFrames * sizeof(DWORD));
625     if (!infoPtr->lpIndex) 
626         return FALSE;
627
628     numFrame = insize = 0;
629     while (mmioDescend(infoPtr->hMMio, &mmckInfo, &mmckList, 0) == 0 &&
630            numFrame < infoPtr->mah.dwTotalFrames) {
631         infoPtr->lpIndex[numFrame] = mmckInfo.dwDataOffset;
632         if (insize < mmckInfo.cksize)
633             insize = mmckInfo.cksize;
634         numFrame++;
635         mmioAscend(infoPtr->hMMio, &mmckInfo, 0);
636     }
637     if (numFrame != infoPtr->mah.dwTotalFrames) {
638         WARN("Found %d frames (/%d)\n", numFrame, infoPtr->mah.dwTotalFrames);
639         return FALSE;
640     }
641     if (insize > infoPtr->ash.dwSuggestedBufferSize) {
642         WARN("insize=%d suggestedSize=%d\n", insize, infoPtr->ash.dwSuggestedBufferSize);
643         infoPtr->ash.dwSuggestedBufferSize = insize;
644     }
645
646     infoPtr->indata = Alloc(infoPtr->ash.dwSuggestedBufferSize);
647     if (!infoPtr->indata) 
648         return FALSE;
649
650     return TRUE;
651 }
652
653
654 static BOOL ANIMATE_GetAviCodec(ANIMATE_INFO *infoPtr)
655 {
656     DWORD       outSize;
657
658     /* check uncompressed AVI */
659     if ((infoPtr->ash.fccHandler == mmioFOURCC('D', 'I', 'B', ' ')) ||
660        (infoPtr->ash.fccHandler == mmioFOURCC('R', 'L', 'E', ' ')) ||
661        (infoPtr->ash.fccHandler == mmioFOURCC(0, 0, 0, 0)))
662     {
663         infoPtr->hic = 0;
664         return TRUE;
665     }
666
667     /* try to get a decompressor for that type */
668     infoPtr->hic = fnIC.fnICOpen(ICTYPE_VIDEO, infoPtr->ash.fccHandler, ICMODE_DECOMPRESS);
669     if (!infoPtr->hic) {
670         WARN("Can't load codec for the file\n");
671         return FALSE;
672     }
673
674     outSize = fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
675                             (DWORD_PTR)infoPtr->inbih, 0L);
676
677     infoPtr->outbih = Alloc(outSize);
678     if (!infoPtr->outbih)
679         return FALSE;
680
681     if (fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_GET_FORMAT,
682                       (DWORD_PTR)infoPtr->inbih, (DWORD_PTR)infoPtr->outbih) != ICERR_OK) 
683     {
684         WARN("Can't get output BIH\n");
685         return FALSE;
686     }
687
688     infoPtr->outdata = Alloc(infoPtr->outbih->biSizeImage);
689     if (!infoPtr->outdata) 
690         return FALSE;
691
692     if (fnIC.fnICSendMessage(infoPtr->hic, ICM_DECOMPRESS_BEGIN,
693                       (DWORD_PTR)infoPtr->inbih, (DWORD_PTR)infoPtr->outbih) != ICERR_OK) {
694         WARN("Can't begin decompression\n");
695         return FALSE;
696     }
697
698     return TRUE;
699 }
700
701
702 static BOOL ANIMATE_OpenW(ANIMATE_INFO *infoPtr, HINSTANCE hInstance, LPWSTR lpszName)
703 {
704     HDC hdc;
705
706     ANIMATE_Free(infoPtr);
707
708     if (!lpszName) 
709     {
710         TRACE("Closing avi!\n");
711         /* installer of thebat! v1.62 requires FALSE here */
712         return (infoPtr->hMMio != 0);
713     }
714
715     if (!hInstance)
716         hInstance = (HINSTANCE)GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_HINSTANCE);
717
718     TRACE("(%s)\n", debugstr_w(lpszName));
719
720     if (HIWORD(lpszName))
721     {
722         if (!ANIMATE_LoadResW(infoPtr, hInstance, lpszName)) 
723         {
724             TRACE("No AVI resource found!\n");
725             if (!ANIMATE_LoadFileW(infoPtr, lpszName)) 
726             {
727                 WARN("No AVI file found!\n");
728                 return FALSE;
729             }
730         }
731     } 
732     else 
733     {
734         if (!ANIMATE_LoadResW(infoPtr, hInstance, lpszName))
735         {
736             WARN("No AVI resource found!\n");
737             return FALSE;
738         }
739     }
740
741     if (!ANIMATE_GetAviInfo(infoPtr)) 
742     {
743         WARN("Can't get AVI information\n");
744         ANIMATE_Free(infoPtr);
745         return FALSE;
746     }
747
748     if (!ANIMATE_GetAviCodec(infoPtr)) 
749     {
750         WARN("Can't get AVI Codec\n");
751         ANIMATE_Free(infoPtr);
752         return FALSE;
753     }
754
755     hdc = GetDC(infoPtr->hwndSelf);
756     /* native looks at the top left pixel of the first frame here too. */
757     infoPtr->hbrushBG = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLORSTATIC,
758                                              (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
759     ReleaseDC(infoPtr->hwndSelf, hdc);
760
761     if (!(infoPtr->dwStyle & ACS_CENTER))
762         SetWindowPos(infoPtr->hwndSelf, 0, 0, 0, infoPtr->mah.dwWidth, infoPtr->mah.dwHeight,
763                      SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
764
765     if (infoPtr->dwStyle & ACS_AUTOPLAY) 
766         return ANIMATE_Play(infoPtr, -1, 0, infoPtr->mah.dwTotalFrames - 1);
767
768     return TRUE;
769 }
770
771
772 static BOOL ANIMATE_OpenA(ANIMATE_INFO *infoPtr, HINSTANCE hInstance, LPSTR lpszName)
773 {
774     LPWSTR lpwszName;
775     LRESULT result;
776     INT len;
777
778     if (!HIWORD(lpszName))
779         return ANIMATE_OpenW(infoPtr, hInstance, (LPWSTR)lpszName);
780
781     len = MultiByteToWideChar(CP_ACP, 0, lpszName, -1, NULL, 0);
782     lpwszName = Alloc(len * sizeof(WCHAR));
783     if (!lpwszName) return FALSE;
784     MultiByteToWideChar(CP_ACP, 0, lpszName, -1, lpwszName, len);
785
786     result = ANIMATE_OpenW(infoPtr, hInstance, lpwszName);
787     Free (lpwszName);
788     return result;
789 }
790
791
792 static BOOL ANIMATE_Stop(ANIMATE_INFO *infoPtr)
793 {
794     /* nothing opened */
795     if (!infoPtr->hMMio)
796         return FALSE;
797
798     ANIMATE_DoStop(infoPtr);
799     return TRUE;
800 }
801
802
803 static BOOL ANIMATE_Create(HWND hWnd, const CREATESTRUCTW *lpcs)
804 {
805     static const WCHAR msvfw32W[] = { 'm', 's', 'v', 'f', 'w', '3', '2', '.', 'd', 'l', 'l', 0 };
806     ANIMATE_INFO *infoPtr;
807
808     if (!fnIC.hModule)
809     {
810         fnIC.hModule = LoadLibraryW(msvfw32W);
811         if (!fnIC.hModule) return FALSE;
812
813         fnIC.fnICOpen        = (void*)GetProcAddress(fnIC.hModule, "ICOpen");
814         fnIC.fnICClose       = (void*)GetProcAddress(fnIC.hModule, "ICClose");
815         fnIC.fnICSendMessage = (void*)GetProcAddress(fnIC.hModule, "ICSendMessage");
816         fnIC.fnICDecompress  = (void*)GetProcAddress(fnIC.hModule, "ICDecompress");
817     }
818
819     /* allocate memory for info structure */
820     infoPtr = Alloc(sizeof(ANIMATE_INFO));
821     if (!infoPtr) return FALSE;
822
823     /* store crossref hWnd <-> info structure */
824     SetWindowLongPtrW(hWnd, 0, (DWORD_PTR)infoPtr);
825     infoPtr->hwndSelf = hWnd;
826     infoPtr->hwndNotify = lpcs->hwndParent;
827     infoPtr->transparentColor = ANIMATE_COLOR_NONE;
828     infoPtr->hbmPrevFrame = 0;
829     infoPtr->dwStyle = lpcs->style;
830
831     TRACE("Animate style=0x%08x, parent=%p\n", infoPtr->dwStyle, infoPtr->hwndNotify);
832
833     InitializeCriticalSection(&infoPtr->cs);
834     infoPtr->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ANIMATE_INFO*->cs");
835
836     return TRUE;
837 }
838
839
840 static LRESULT ANIMATE_Destroy(ANIMATE_INFO *infoPtr)
841 {
842     /* free avi data */
843     ANIMATE_Free(infoPtr);
844
845     /* free animate info data */
846     SetWindowLongPtrW(infoPtr->hwndSelf, 0, 0);
847
848     infoPtr->cs.DebugInfo->Spare[0] = 0;
849     DeleteCriticalSection(&infoPtr->cs);
850     Free(infoPtr);
851
852     return 0;
853 }
854
855
856 static BOOL ANIMATE_EraseBackground(ANIMATE_INFO const *infoPtr, HDC hdc)
857 {
858     RECT rect;
859     HBRUSH hBrush;
860
861     hBrush = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLORSTATIC,
862                                   (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
863     GetClientRect(infoPtr->hwndSelf, &rect);
864     FillRect(hdc, &rect, hBrush ? hBrush : GetCurrentObject(hdc, OBJ_BRUSH));
865
866     return TRUE;
867 }
868
869
870 static LRESULT ANIMATE_StyleChanged(ANIMATE_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
871 {
872     TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
873           wStyleType, lpss->styleOld, lpss->styleNew);
874
875     if (wStyleType != GWL_STYLE) return 0;
876   
877     infoPtr->dwStyle = lpss->styleNew;
878
879     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
880     return 0;
881 }
882
883
884 static LRESULT WINAPI ANIMATE_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
885 {
886     ANIMATE_INFO *infoPtr = (ANIMATE_INFO *)GetWindowLongPtrW(hWnd, 0);
887
888     TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hWnd, uMsg, wParam, lParam);
889     if (!infoPtr && (uMsg != WM_NCCREATE))
890         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
891     switch (uMsg)
892     {
893     case ACM_OPENA:
894         return ANIMATE_OpenA(infoPtr, (HINSTANCE)wParam, (LPSTR)lParam);
895
896     case ACM_OPENW:
897         return ANIMATE_OpenW(infoPtr, (HINSTANCE)wParam, (LPWSTR)lParam);
898
899     case ACM_PLAY:
900         return ANIMATE_Play(infoPtr, (INT)wParam, LOWORD(lParam), HIWORD(lParam));
901
902     case ACM_STOP:
903         return ANIMATE_Stop(infoPtr);
904
905     case WM_CLOSE:
906         ANIMATE_Free(infoPtr);
907         return 0;
908
909     case WM_NCCREATE:
910         return ANIMATE_Create(hWnd, (LPCREATESTRUCTW)lParam);
911
912     case WM_NCHITTEST:
913         return HTTRANSPARENT;
914
915     case WM_DESTROY:
916         return ANIMATE_Destroy(infoPtr);
917
918     case WM_ERASEBKGND:
919         return ANIMATE_EraseBackground(infoPtr, (HDC)wParam);
920
921     case WM_STYLECHANGED:
922         return ANIMATE_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
923
924     case WM_TIMER:
925         return ANIMATE_Timer(infoPtr);
926
927     case WM_PRINTCLIENT:
928     case WM_PAINT:
929         {
930             /* the animation has not decompressed
931              * (and displayed) the first frame yet, don't paint
932              */
933             if (!infoPtr->hbmPrevFrame)
934             {
935                 /* default paint handling */
936                 return DefWindowProcW(hWnd, uMsg, wParam, lParam);
937             }
938
939             if (wParam)
940             {
941                 EnterCriticalSection(&infoPtr->cs);
942                 ANIMATE_PaintFrame(infoPtr, (HDC)wParam);
943                 LeaveCriticalSection(&infoPtr->cs);
944             }
945             else
946             {
947                 PAINTSTRUCT ps;
948                 HDC hDC = BeginPaint(infoPtr->hwndSelf, &ps);
949
950                 EnterCriticalSection(&infoPtr->cs);
951                 ANIMATE_PaintFrame(infoPtr, hDC);
952                 LeaveCriticalSection(&infoPtr->cs);
953
954                 EndPaint(infoPtr->hwndSelf, &ps);
955             }
956         }
957         break;
958
959     case WM_SIZE:
960         if (infoPtr->dwStyle & ACS_CENTER) 
961             InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
962         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
963
964     default:
965         if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
966             ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
967
968         return DefWindowProcW(hWnd, uMsg, wParam, lParam);
969     }
970     return 0;
971 }
972
973 void ANIMATE_Register(void)
974 {
975     WNDCLASSW wndClass;
976
977     ZeroMemory(&wndClass, sizeof(WNDCLASSW));
978     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS;
979     wndClass.lpfnWndProc   = ANIMATE_WindowProc;
980     wndClass.cbClsExtra    = 0;
981     wndClass.cbWndExtra    = sizeof(ANIMATE_INFO *);
982     wndClass.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
983     wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
984     wndClass.lpszClassName = ANIMATE_CLASSW;
985
986     RegisterClassW(&wndClass);
987 }
988
989
990 void ANIMATE_Unregister(void)
991 {
992     UnregisterClassW(ANIMATE_CLASSW, NULL);
993 }