dll/win32/mciavi32/mmoutput.c

   1 /*
   2  * Digital video MCI Wine Driver
   3  *
   4  * Copyright 1999, 2000 Eric POUECH
   5  * Copyright 2003 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "private_mciavi.h"
  23
  24 static BOOL MCIAVI_GetInfoAudio(WINE_MCIAVI* wma, const MMCKINFO* mmckList, MMCKINFO *mmckStream)
  25 {
  26     MMCKINFO    mmckInfo;
  27
  28     TRACE("ash.fccType='%c%c%c%c'\n",           LOBYTE(LOWORD(wma->ash_audio.fccType)),
  29                                                 HIBYTE(LOWORD(wma->ash_audio.fccType)),
  30                                                 LOBYTE(HIWORD(wma->ash_audio.fccType)),
  31                                                 HIBYTE(HIWORD(wma->ash_audio.fccType)));
  32     if (wma->ash_audio.fccHandler) /* not all streams specify a handler */
  33         TRACE("ash.fccHandler='%c%c%c%c'\n",    LOBYTE(LOWORD(wma->ash_audio.fccHandler)),
  34                                                 HIBYTE(LOWORD(wma->ash_audio.fccHandler)),
  35                                                 LOBYTE(HIWORD(wma->ash_audio.fccHandler)),
  36                                                 HIBYTE(HIWORD(wma->ash_audio.fccHandler)));
  37     else
  38         TRACE("ash.fccHandler=0, no handler specified\n");
  39     TRACE("ash.dwFlags=%d\n",                   wma->ash_audio.dwFlags);
  40     TRACE("ash.wPriority=%d\n",                 wma->ash_audio.wPriority);
  41     TRACE("ash.wLanguage=%d\n",                 wma->ash_audio.wLanguage);
  42     TRACE("ash.dwInitialFrames=%d\n",           wma->ash_audio.dwInitialFrames);
  43     TRACE("ash.dwScale=%d\n",                   wma->ash_audio.dwScale);
  44     TRACE("ash.dwRate=%d\n",                    wma->ash_audio.dwRate);
  45     TRACE("ash.dwStart=%d\n",                   wma->ash_audio.dwStart);
  46     TRACE("ash.dwLength=%d\n",          wma->ash_audio.dwLength);
  47     TRACE("ash.dwSuggestedBufferSize=%d\n",     wma->ash_audio.dwSuggestedBufferSize);
  48     TRACE("ash.dwQuality=%d\n",                 wma->ash_audio.dwQuality);
  49     TRACE("ash.dwSampleSize=%d\n",              wma->ash_audio.dwSampleSize);
  50     TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",        wma->ash_audio.rcFrame.top, wma->ash_audio.rcFrame.left,
  51           wma->ash_audio.rcFrame.bottom, wma->ash_audio.rcFrame.right);
  52
  53     /* rewind to the start of the stream */
  54     mmioAscend(wma->hFile, mmckStream, 0);
  55
  56     mmckInfo.ckid = ckidSTREAMFORMAT;
  57     if (mmioDescend(wma->hFile, &mmckInfo, mmckList, MMIO_FINDCHUNK) != 0) {
  58        WARN("Can't find 'strf' chunk\n");
  59         return FALSE;
  60     }
  61     if (mmckInfo.cksize < sizeof(WAVEFORMAT)) {
  62         WARN("Size of strf chunk (%d) < audio format struct\n", mmckInfo.cksize);
  63         return FALSE;
  64     }
  65     wma->lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
  66     if (!wma->lpWaveFormat) {
  67         WARN("Can't alloc WaveFormat\n");
  68         return FALSE;
  69     }
  70
  71     mmioRead(wma->hFile, (LPSTR)wma->lpWaveFormat, mmckInfo.cksize);
  72
  73     TRACE("waveFormat.wFormatTag=%d\n",         wma->lpWaveFormat->wFormatTag);
  74     TRACE("waveFormat.nChannels=%d\n",          wma->lpWaveFormat->nChannels);
  75     TRACE("waveFormat.nSamplesPerSec=%d\n",     wma->lpWaveFormat->nSamplesPerSec);
  76     TRACE("waveFormat.nAvgBytesPerSec=%d\n",    wma->lpWaveFormat->nAvgBytesPerSec);
  77     TRACE("waveFormat.nBlockAlign=%d\n",        wma->lpWaveFormat->nBlockAlign);
  78     TRACE("waveFormat.wBitsPerSample=%d\n",     wma->lpWaveFormat->wBitsPerSample);
  79     if (mmckInfo.cksize >= sizeof(WAVEFORMATEX))
  80         TRACE("waveFormat.cbSize=%d\n",                 wma->lpWaveFormat->cbSize);
  81
  82     return TRUE;
  83 }
  84
  85 static BOOL MCIAVI_GetInfoVideo(WINE_MCIAVI* wma, const MMCKINFO* mmckList, MMCKINFO* mmckStream)
  86 {
  87     MMCKINFO    mmckInfo;
  88
  89     TRACE("ash.fccType='%c%c%c%c'\n",           LOBYTE(LOWORD(wma->ash_video.fccType)),
  90                                                 HIBYTE(LOWORD(wma->ash_video.fccType)),
  91                                                 LOBYTE(HIWORD(wma->ash_video.fccType)),
  92                                                 HIBYTE(HIWORD(wma->ash_video.fccType)));
  93     TRACE("ash.fccHandler='%c%c%c%c'\n",        LOBYTE(LOWORD(wma->ash_video.fccHandler)),
  94                                                 HIBYTE(LOWORD(wma->ash_video.fccHandler)),
  95                                                 LOBYTE(HIWORD(wma->ash_video.fccHandler)),
  96                                                 HIBYTE(HIWORD(wma->ash_video.fccHandler)));
  97     TRACE("ash.dwFlags=%d\n",                   wma->ash_video.dwFlags);
  98     TRACE("ash.wPriority=%d\n",                 wma->ash_video.wPriority);
  99     TRACE("ash.wLanguage=%d\n",                 wma->ash_video.wLanguage);
 100     TRACE("ash.dwInitialFrames=%d\n",           wma->ash_video.dwInitialFrames);
 101     TRACE("ash.dwScale=%d\n",                   wma->ash_video.dwScale);
 102     TRACE("ash.dwRate=%d\n",                    wma->ash_video.dwRate);
 103     TRACE("ash.dwStart=%d\n",                   wma->ash_video.dwStart);
 104     TRACE("ash.dwLength=%d\n",          wma->ash_video.dwLength);
 105     TRACE("ash.dwSuggestedBufferSize=%d\n",     wma->ash_video.dwSuggestedBufferSize);
 106     TRACE("ash.dwQuality=%d\n",                 wma->ash_video.dwQuality);
 107     TRACE("ash.dwSampleSize=%d\n",              wma->ash_video.dwSampleSize);
 108     TRACE("ash.rcFrame=(%d,%d,%d,%d)\n",        wma->ash_video.rcFrame.top, wma->ash_video.rcFrame.left,
 109           wma->ash_video.rcFrame.bottom, wma->ash_video.rcFrame.right);
 110
 111     /* rewind to the start of the stream */
 112     mmioAscend(wma->hFile, mmckStream, 0);
 113
 114     mmckInfo.ckid = ckidSTREAMFORMAT;
 115     if (mmioDescend(wma->hFile, &mmckInfo, mmckList, MMIO_FINDCHUNK) != 0) {
 116        WARN("Can't find 'strf' chunk\n");
 117         return FALSE;
 118     }
 119
 120     wma->inbih = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
 121     if (!wma->inbih) {
 122         WARN("Can't alloc input BIH\n");
 123         return FALSE;
 124     }
 125
 126     mmioRead(wma->hFile, (LPSTR)wma->inbih, mmckInfo.cksize);
 127
 128     TRACE("bih.biSize=%d\n",            wma->inbih->biSize);
 129     TRACE("bih.biWidth=%d\n",           wma->inbih->biWidth);
 130     TRACE("bih.biHeight=%d\n",  wma->inbih->biHeight);
 131     TRACE("bih.biPlanes=%d\n",          wma->inbih->biPlanes);
 132     TRACE("bih.biBitCount=%d\n",        wma->inbih->biBitCount);
 133     TRACE("bih.biCompression=%x\n",     wma->inbih->biCompression);
 134     TRACE("bih.biSizeImage=%d\n",       wma->inbih->biSizeImage);
 135     TRACE("bih.biXPelsPerMeter=%d\n",   wma->inbih->biXPelsPerMeter);
 136     TRACE("bih.biYPelsPerMeter=%d\n",   wma->inbih->biYPelsPerMeter);
 137     TRACE("bih.biClrUsed=%d\n",         wma->inbih->biClrUsed);
 138     TRACE("bih.biClrImportant=%d\n",    wma->inbih->biClrImportant);
 139
 140     SetRect(&wma->source, 0, 0, wma->inbih->biWidth, wma->inbih->biHeight);
 141     wma->dest = wma->source;
 142
 143     return TRUE;
 144 }
 145
 146 struct AviListBuild {
 147     DWORD       numVideoFrames;
 148     DWORD       numAudioAllocated;
 149     DWORD       numAudioBlocks;
 150     DWORD       inVideoSize;
 151     DWORD       inAudioSize;
 152 };
 153
 154 static BOOL     MCIAVI_AddFrame(WINE_MCIAVI* wma, LPMMCKINFO mmck,
 155                                 struct AviListBuild* alb)
 156 {
 157     const BYTE *p;
 158     DWORD stream_n;
 159     DWORD twocc;
 160
 161     if (mmck->ckid == ckidAVIPADDING) return TRUE;
 162
 163     p = (const BYTE *)&mmck->ckid;
 164
 165     if (!isxdigit(p[0]) || !isxdigit(p[1]))
 166     {
 167         WARN("wrongly encoded stream #\n");
 168         return FALSE;
 169     }
 170
 171     stream_n = (p[0] <= '9') ? (p[0] - '0') : (tolower(p[0]) - 'a' + 10);
 172     stream_n <<= 4;
 173     stream_n |= (p[1] <= '9') ? (p[1] - '0') : (tolower(p[1]) - 'a' + 10);
 174
 175     TRACE("ckid %4.4s (stream #%d)\n", (LPSTR)&mmck->ckid, stream_n);
 176
 177     /* Some (rare?) AVI files have video streams name XXYY where XX = stream number and YY = TWOCC
 178      * of the last 2 characters of the biCompression member of the BITMAPINFOHEADER structure.
 179      * Ex: fccHandler = IV32 & biCompression = IV32 => stream name = XX32
 180      *     fccHandler = MSVC & biCompression = CRAM => stream name = XXAM
 181      * Another possibility is that these TWOCC are simply ignored.
 182      * Default to cktypeDIBcompressed when this case happens.
 183      */
 184     twocc = TWOCCFromFOURCC(mmck->ckid);
 185     if (twocc == TWOCCFromFOURCC(wma->inbih->biCompression))
 186         twocc = cktypeDIBcompressed;
 187     /* Also detect some chunks that seem to be used by Indeo videos where the chunk is named
 188      * after the codec. */
 189     else if (twocc == LOWORD(wma->ash_video.fccHandler))
 190         twocc = cktypeDIBcompressed;
 191     switch (twocc) {
 192     case cktypeDIBbits:
 193     case cktypeDIBcompressed:
 194     case cktypePALchange:
 195         if (stream_n != wma->video_stream_n)
 196         {
 197             TRACE("data belongs to another video stream #%d\n", stream_n);
 198             return FALSE;
 199         }
 200
 201         TRACE("Adding video frame[%d]: %d bytes\n",
 202               alb->numVideoFrames, mmck->cksize);
 203
 204         if (alb->numVideoFrames < wma->dwPlayableVideoFrames) {
 205             wma->lpVideoIndex[alb->numVideoFrames].dwOffset = mmck->dwDataOffset;
 206             wma->lpVideoIndex[alb->numVideoFrames].dwSize = mmck->cksize;
 207             if (alb->inVideoSize < mmck->cksize)
 208                 alb->inVideoSize = mmck->cksize;
 209             alb->numVideoFrames++;
 210         } else {
 211             WARN("Too many video frames\n");
 212         }
 213         break;
 214     case cktypeWAVEbytes:
 215         if (stream_n != wma->audio_stream_n)
 216         {
 217             TRACE("data belongs to another audio stream #%d\n", stream_n);
 218             return FALSE;
 219         }
 220
 221         TRACE("Adding audio frame[%d]: %d bytes\n",
 222               alb->numAudioBlocks, mmck->cksize);
 223         if (wma->lpWaveFormat) {
 224             if (alb->numAudioBlocks >= alb->numAudioAllocated) {
 225                 DWORD newsize = alb->numAudioAllocated + 32;
 226                 struct MMIOPos* newindex;
 227
 228                 if (!wma->lpAudioIndex)
 229                     newindex = HeapAlloc(GetProcessHeap(), 0, newsize * sizeof(struct MMIOPos));
 230                 else
 231                     newindex = HeapReAlloc(GetProcessHeap(), 0, wma->lpAudioIndex, newsize * sizeof(struct MMIOPos));
 232                 if (!newindex) return FALSE;
 233                 alb->numAudioAllocated = newsize;
 234                 wma->lpAudioIndex = newindex;
 235             }
 236             wma->lpAudioIndex[alb->numAudioBlocks].dwOffset = mmck->dwDataOffset;
 237             wma->lpAudioIndex[alb->numAudioBlocks].dwSize = mmck->cksize;
 238             if (alb->inAudioSize < mmck->cksize)
 239                 alb->inAudioSize = mmck->cksize;
 240             alb->numAudioBlocks++;
 241         } else {
 242             WARN("Wave chunk without wave format... discarding\n");
 243         }
 244         break;
 245     default:
 246         WARN("Unknown frame type %4.4s\n", (LPSTR)&mmck->ckid);
 247         break;
 248     }
 249     return TRUE;
 250 }
 251
 252 BOOL MCIAVI_GetInfo(WINE_MCIAVI* wma)
 253 {
 254     MMCKINFO            ckMainRIFF;
 255     MMCKINFO            mmckHead;
 256     MMCKINFO            mmckList;
 257     MMCKINFO            mmckInfo;
 258     AVIStreamHeader strh;
 259     struct AviListBuild alb;
 260     DWORD stream_n;
 261
 262     if (mmioDescend(wma->hFile, &ckMainRIFF, NULL, 0) != 0) {
 263         WARN("Can't find 'RIFF' chunk\n");
 264         return FALSE;
 265     }
 266
 267     if ((ckMainRIFF.ckid != FOURCC_RIFF) || (ckMainRIFF.fccType != formtypeAVI)) {
 268         WARN("Can't find 'AVI ' chunk\n");
 269         return FALSE;
 270     }
 271
 272     mmckHead.fccType = listtypeAVIHEADER;
 273     if (mmioDescend(wma->hFile, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
 274         WARN("Can't find 'hdrl' list\n");
 275         return FALSE;
 276     }
 277
 278     mmckInfo.ckid = ckidAVIMAINHDR;
 279     if (mmioDescend(wma->hFile, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
 280         WARN("Can't find 'avih' chunk\n");
 281         return FALSE;
 282     }
 283
 284     mmioRead(wma->hFile, (LPSTR)&wma->mah, sizeof(wma->mah));
 285
 286     TRACE("mah.dwMicroSecPerFrame=%d\n",        wma->mah.dwMicroSecPerFrame);
 287     TRACE("mah.dwMaxBytesPerSec=%d\n",  wma->mah.dwMaxBytesPerSec);
 288     TRACE("mah.dwPaddingGranularity=%d\n",      wma->mah.dwPaddingGranularity);
 289     TRACE("mah.dwFlags=%d\n",                   wma->mah.dwFlags);
 290     TRACE("mah.dwTotalFrames=%d\n",             wma->mah.dwTotalFrames);
 291     TRACE("mah.dwInitialFrames=%d\n",           wma->mah.dwInitialFrames);
 292     TRACE("mah.dwStreams=%d\n",                 wma->mah.dwStreams);
 293     TRACE("mah.dwSuggestedBufferSize=%d\n",     wma->mah.dwSuggestedBufferSize);
 294     TRACE("mah.dwWidth=%d\n",                   wma->mah.dwWidth);
 295     TRACE("mah.dwHeight=%d\n",          wma->mah.dwHeight);
 296
 297     mmioAscend(wma->hFile, &mmckInfo, 0);
 298
 299     TRACE("Start of streams\n");
 300     wma->video_stream_n = 0;
 301     wma->audio_stream_n = 0;
 302
 303     for (stream_n = 0; stream_n < wma->mah.dwStreams; stream_n++)
 304     {
 305         MMCKINFO mmckStream;
 306
 307         mmckList.fccType = listtypeSTREAMHEADER;
 308         if (mmioDescend(wma->hFile, &mmckList, &mmckHead, MMIO_FINDLIST) != 0)
 309             break;
 310
 311         mmckStream.ckid = ckidSTREAMHEADER;
 312         if (mmioDescend(wma->hFile, &mmckStream, &mmckList, MMIO_FINDCHUNK) != 0)
 313         {
 314             WARN("Can't find 'strh' chunk\n");
 315             continue;
 316         }
 317
 318         mmioRead(wma->hFile, (LPSTR)&strh, sizeof(strh));
 319
 320         TRACE("Stream #%d fccType %4.4s\n", stream_n, (LPSTR)&strh.fccType);
 321
 322         if (strh.fccType == streamtypeVIDEO)
 323         {
 324             TRACE("found video stream\n");
 325             if (wma->inbih)
 326                 WARN("ignoring another video stream\n");
 327             else
 328             {
 329                 wma->ash_video = strh;
 330
 331                 if (!MCIAVI_GetInfoVideo(wma, &mmckList, &mmckStream))
 332                     return FALSE;
 333                 wma->video_stream_n = stream_n;
 334                 wma->dwSet |= 4;
 335             }
 336         }
 337         else if (strh.fccType == streamtypeAUDIO)
 338         {
 339             TRACE("found audio stream\n");
 340             if (wma->lpWaveFormat)
 341                 WARN("ignoring another audio stream\n");
 342             else
 343             {
 344                 wma->ash_audio = strh;
 345
 346                 if (!MCIAVI_GetInfoAudio(wma, &mmckList, &mmckStream))
 347                     return FALSE;
 348                 wma->audio_stream_n = stream_n;
 349                 wma->dwSet |= 3;
 350             }
 351         }
 352         else
 353             TRACE("Unsupported stream type %4.4s\n", (LPSTR)&strh.fccType);
 354
 355         mmioAscend(wma->hFile, &mmckList, 0);
 356     }
 357
 358     TRACE("End of streams\n");
 359
 360     mmioAscend(wma->hFile, &mmckHead, 0);
 361
 362     /* no need to read optional JUNK chunk */
 363
 364     mmckList.fccType = listtypeAVIMOVIE;
 365     if (mmioDescend(wma->hFile, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
 366         WARN("Can't find 'movi' list\n");
 367         return FALSE;
 368     }
 369
 370     wma->dwPlayableVideoFrames = wma->mah.dwTotalFrames;
 371     wma->lpVideoIndex = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 372                                   wma->dwPlayableVideoFrames * sizeof(struct MMIOPos));
 373     if (!wma->lpVideoIndex) {
 374         WARN("Can't alloc video index array\n");
 375         return FALSE;
 376     }
 377     wma->dwPlayableAudioBlocks = 0;
 378     wma->lpAudioIndex = NULL;
 379
 380     alb.numAudioBlocks = alb.numVideoFrames = 0;
 381     alb.inVideoSize = alb.inAudioSize = 0;
 382     alb.numAudioAllocated = 0;
 383
 384     while (mmioDescend(wma->hFile, &mmckInfo, &mmckList, 0) == 0) {
 385         if (mmckInfo.fccType == listtypeAVIRECORD) {
 386             MMCKINFO    tmp;
 387
 388             while (mmioDescend(wma->hFile, &tmp, &mmckInfo, 0) == 0) {
 389                 MCIAVI_AddFrame(wma, &tmp, &alb);
 390                 mmioAscend(wma->hFile, &tmp, 0);
 391             }
 392         } else {
 393             MCIAVI_AddFrame(wma, &mmckInfo, &alb);
 394         }
 395
 396         mmioAscend(wma->hFile, &mmckInfo, 0);
 397     }
 398     if (alb.numVideoFrames != wma->dwPlayableVideoFrames) {
 399         WARN("AVI header says %d frames, we found %d video frames, reducing playable frames\n",
 400              wma->dwPlayableVideoFrames, alb.numVideoFrames);
 401         wma->dwPlayableVideoFrames = alb.numVideoFrames;
 402     }
 403     wma->dwPlayableAudioBlocks = alb.numAudioBlocks;
 404
 405     if (alb.inVideoSize > wma->ash_video.dwSuggestedBufferSize) {
 406         WARN("inVideoSize=%d suggestedSize=%d\n", alb.inVideoSize, wma->ash_video.dwSuggestedBufferSize);
 407         wma->ash_video.dwSuggestedBufferSize = alb.inVideoSize;
 408     }
 409     if (alb.inAudioSize > wma->ash_audio.dwSuggestedBufferSize) {
 410         WARN("inAudioSize=%d suggestedSize=%d\n", alb.inAudioSize, wma->ash_audio.dwSuggestedBufferSize);
 411         wma->ash_audio.dwSuggestedBufferSize = alb.inAudioSize;
 412     }
 413
 414     wma->indata = HeapAlloc(GetProcessHeap(), 0, wma->ash_video.dwSuggestedBufferSize);
 415     if (!wma->indata) {
 416         WARN("Can't alloc input buffer\n");
 417         return FALSE;
 418     }
 419
 420     return TRUE;
 421 }
 422
 423 BOOL    MCIAVI_OpenVideo(WINE_MCIAVI* wma)
 424 {
 425     HDC hDC;
 426     DWORD       outSize;
 427     FOURCC      fcc = wma->ash_video.fccHandler;
 428
 429     TRACE("fcc %4.4s\n", (LPSTR)&fcc);
 430
 431     wma->dwCachedFrame = -1;
 432
 433     /* get the right handle */
 434     if (fcc == mmioFOURCC('C','R','A','M')) fcc = mmioFOURCC('M','S','V','C');
 435
 436     /* try to get a decompressor for that type */
 437     wma->hic = ICLocate(ICTYPE_VIDEO, fcc, wma->inbih, NULL, ICMODE_DECOMPRESS);
 438     if (!wma->hic) {
 439         /* check for builtin DIB compressions */
 440         fcc = wma->inbih->biCompression;
 441         if ((fcc == mmioFOURCC('D','I','B',' ')) ||
 442             (fcc == mmioFOURCC('R','L','E',' ')) ||
 443             (fcc == BI_RGB) || (fcc == BI_RLE8) ||
 444             (fcc == BI_RLE4) || (fcc == BI_BITFIELDS))
 445             goto paint_frame;
 446
 447         WARN("Can't locate codec for the file\n");
 448         return FALSE;
 449     }
 450
 451     outSize = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
 452
 453     wma->outbih = HeapAlloc(GetProcessHeap(), 0, outSize);
 454     if (!wma->outbih) {
 455         WARN("Can't alloc output BIH\n");
 456         return FALSE;
 457     }
 458     if (!ICGetDisplayFormat(wma->hic, wma->inbih, wma->outbih, 0, 0, 0)) {
 459         WARN("Can't open decompressor\n");
 460         return FALSE;
 461     }
 462
 463     TRACE("bih.biSize=%d\n",            wma->outbih->biSize);
 464     TRACE("bih.biWidth=%d\n",           wma->outbih->biWidth);
 465     TRACE("bih.biHeight=%d\n",  wma->outbih->biHeight);
 466     TRACE("bih.biPlanes=%d\n",          wma->outbih->biPlanes);
 467     TRACE("bih.biBitCount=%d\n",        wma->outbih->biBitCount);
 468     TRACE("bih.biCompression=%x\n",     wma->outbih->biCompression);
 469     TRACE("bih.biSizeImage=%d\n",       wma->outbih->biSizeImage);
 470     TRACE("bih.biXPelsPerMeter=%d\n",   wma->outbih->biXPelsPerMeter);
 471     TRACE("bih.biYPelsPerMeter=%d\n",   wma->outbih->biYPelsPerMeter);
 472     TRACE("bih.biClrUsed=%d\n",         wma->outbih->biClrUsed);
 473     TRACE("bih.biClrImportant=%d\n",    wma->outbih->biClrImportant);
 474
 475     wma->outdata = HeapAlloc(GetProcessHeap(), 0, wma->outbih->biSizeImage);
 476     if (!wma->outdata) {
 477         WARN("Can't alloc output buffer\n");
 478         return FALSE;
 479     }
 480
 481     if (ICSendMessage(wma->hic, ICM_DECOMPRESS_BEGIN,
 482                       (DWORD_PTR)wma->inbih, (DWORD_PTR)wma->outbih) != ICERR_OK) {
 483         WARN("Can't begin decompression\n");
 484         return FALSE;
 485     }
 486
 487 paint_frame:
 488     hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
 489     if (hDC)
 490     {
 491         MCIAVI_PaintFrame(wma, hDC);
 492         ReleaseDC(wma->hWndPaint, hDC);
 493     }
 494     return TRUE;
 495 }
 496
 497 static void CALLBACK MCIAVI_waveCallback(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance,
 498                                         DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 499 {
 500     WINE_MCIAVI *wma = MCIAVI_mciGetOpenDev(dwInstance);
 501
 502     if (!wma) return;
 503
 504     EnterCriticalSection(&wma->cs);
 505
 506     switch (uMsg) {
 507     case WOM_OPEN:
 508     case WOM_CLOSE:
 509         break;
 510     case WOM_DONE:
 511         InterlockedIncrement(&wma->dwEventCount);
 512         TRACE("Returning waveHdr=%lx\n", dwParam1);
 513         SetEvent(wma->hEvent);
 514         break;
 515     default:
 516         ERR("Unknown uMsg=%d\n", uMsg);
 517     }
 518
 519     LeaveCriticalSection(&wma->cs);
 520 }
 521
 522 DWORD MCIAVI_OpenAudio(WINE_MCIAVI* wma, unsigned* nHdr, LPWAVEHDR* pWaveHdr)
 523 {
 524     DWORD       dwRet;
 525     LPWAVEHDR   waveHdr;
 526     unsigned    i;
 527
 528     dwRet = waveOutOpen((HWAVEOUT *)&wma->hWave, WAVE_MAPPER, wma->lpWaveFormat,
 529                        (DWORD_PTR)MCIAVI_waveCallback, wma->wDevID, CALLBACK_FUNCTION);
 530     if (dwRet != 0) {
 531         TRACE("Can't open low level audio device %d\n", dwRet);
 532         dwRet = MCIERR_DEVICE_OPEN;
 533         wma->hWave = 0;
 534         goto cleanUp;
 535     }
 536
 537     /* FIXME: should set up a heuristic to compute the number of wave headers
 538      * to be used...
 539      */
 540     *nHdr = 7;
 541     waveHdr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 542                         *nHdr * (sizeof(WAVEHDR) + wma->ash_audio.dwSuggestedBufferSize));
 543     if (!waveHdr) {
 544         TRACE("Can't alloc wave headers\n");
 545         dwRet = MCIERR_DEVICE_OPEN;
 546         goto cleanUp;
 547     }
 548
 549     for (i = 0; i < *nHdr; i++) {
 550         /* other fields are zero:ed on allocation */
 551         waveHdr[i].lpData = (char*)waveHdr +
 552             *nHdr * sizeof(WAVEHDR) + i * wma->ash_audio.dwSuggestedBufferSize;
 553         waveHdr[i].dwBufferLength = wma->ash_audio.dwSuggestedBufferSize;
 554         if (waveOutPrepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR))) {
 555             dwRet = MCIERR_INTERNAL;
 556             goto cleanUp;
 557         }
 558     }
 559
 560     if (wma->dwCurrVideoFrame != 0 && wma->lpWaveFormat) {
 561         FIXME("Should recompute dwCurrAudioBlock, except unsynchronized sound & video\n");
 562     }
 563     wma->dwCurrAudioBlock = 0;
 564
 565     wma->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 566     wma->dwEventCount = *nHdr - 1;
 567     *pWaveHdr = waveHdr;
 568  cleanUp:
 569     return dwRet;
 570 }
 571
 572 void MCIAVI_PlayAudioBlocks(WINE_MCIAVI* wma, unsigned nHdr, LPWAVEHDR waveHdr)
 573 {
 574     if (!wma->lpAudioIndex)
 575         return;
 576     TRACE("%d (ec=%u)\n", wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, wma->dwEventCount);
 577
 578     /* push as many blocks as possible => audio gets priority */
 579     while (wma->dwStatus != MCI_MODE_STOP && wma->dwStatus != MCI_MODE_NOT_READY &&
 580            wma->dwCurrAudioBlock < wma->dwPlayableAudioBlocks) {
 581         unsigned        whidx = wma->dwCurrAudioBlock % nHdr;
 582
 583         ResetEvent(wma->hEvent);
 584         if (InterlockedDecrement(&wma->dwEventCount) < 0 ||
 585             !wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset)
 586         {
 587             InterlockedIncrement(&wma->dwEventCount);
 588             break;
 589         }
 590
 591         mmioSeek(wma->hFile, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, SEEK_SET);
 592         mmioRead(wma->hFile, waveHdr[whidx].lpData, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize);
 593
 594         waveHdr[whidx].dwFlags &= ~WHDR_DONE;
 595         waveHdr[whidx].dwBufferLength = wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize;
 596         waveOutWrite(wma->hWave, &waveHdr[whidx], sizeof(WAVEHDR));
 597         wma->dwCurrAudioBlock++;
 598     }
 599 }
 600
 601 double MCIAVI_PaintFrame(WINE_MCIAVI* wma, HDC hDC)
 602 {
 603     void*               pBitmapData;
 604     LPBITMAPINFO        pBitmapInfo;
 605
 606     if (!hDC || !wma->inbih)
 607         return 0;
 608
 609     TRACE("Painting frame %u (cached %u)\n", wma->dwCurrVideoFrame, wma->dwCachedFrame);
 610
 611     if (wma->dwCurrVideoFrame != wma->dwCachedFrame)
 612     {
 613         if (!wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset)
 614             return 0;
 615
 616         if (wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize)
 617         {
 618             mmioSeek(wma->hFile, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset, SEEK_SET);
 619             mmioRead(wma->hFile, wma->indata, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize);
 620
 621             wma->inbih->biSizeImage = wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize;
 622
 623             if (wma->hic && ICDecompress(wma->hic, 0, wma->inbih, wma->indata,
 624                                          wma->outbih, wma->outdata) != ICERR_OK)
 625             {
 626                 WARN("Decompression error\n");
 627                 return 0;
 628             }
 629         }
 630
 631         wma->dwCachedFrame = wma->dwCurrVideoFrame;
 632     }
 633
 634     if (wma->hic) {
 635         pBitmapData = wma->outdata;
 636         pBitmapInfo = (LPBITMAPINFO)wma->outbih;
 637     } else {
 638         pBitmapData = wma->indata;
 639         pBitmapInfo = (LPBITMAPINFO)wma->inbih;
 640     }
 641
 642     StretchDIBits(hDC,
 643                   wma->dest.left, wma->dest.top,
 644                   wma->dest.right - wma->dest.left, wma->dest.bottom - wma->dest.top,
 645                   wma->source.left, wma->source.top,
 646                   wma->source.right - wma->source.left, wma->source.bottom - wma->source.top,
 647                   pBitmapData, pBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
 648
 649     return (wma->ash_video.dwScale / (double)wma->ash_video.dwRate) * 1000000;
 650 }