reactos/dll/win32/mciavi32/mciavi.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 /* TODO list :
  23  *      - handling of palettes
  24  *      - recording (which input devices ?), a cam recorder ?
  25  *      - lots of messages still need to be handled (cf FIXME)
  26  *      - synchronization between audio and video (especially for interleaved
  27  *        files)
  28  *      - robustness when reading file can be enhanced
  29  *      - reimplement the AVI handling part with avifile DLL because
  30  *        "open @1122334 type avivideo alias a" expects an AVIFile/Stream
  31  *        and MCI_DGV_SET|STATUS_SPEED maps to Rate/Scale
  32  *      - some files appear to have more than one audio stream (we only play the
  33  *        first one)
  34  *      - some files contain an index of audio/video frame. Better use it,
  35  *        instead of rebuilding it (AVIFile does that already)
  36  *      - stopping while playing a file with sound blocks until all buffered
  37  *        audio is played... still should be stopped ASAP
  38  */
  39
  40 #include "private_mciavi.h"
  41
  42 #include <mciavi.h>
  43 #include <wine/unicode.h>
  44
  45 static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
  46
  47 /*======================================================================*
  48  *                          MCI AVI implementation                      *
  49  *======================================================================*/
  50
  51 HINSTANCE MCIAVI_hInstance = 0;
  52
  53 /***********************************************************************
  54  *              DllMain (MCIAVI.0)
  55  */
  56 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
  57 {
  58     switch (fdwReason) {
  59     case DLL_PROCESS_ATTACH:
  60         DisableThreadLibraryCalls(hInstDLL);
  61         MCIAVI_hInstance = hInstDLL;
  62         break;
  63     }
  64     return TRUE;
  65 }
  66
  67 /**************************************************************************
  68  *                              MCIAVI_drvOpen                  [internal]
  69  */
  70 static  DWORD   MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
  71 {
  72     WINE_MCIAVI*        wma;
  73     static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
  74
  75     TRACE("%s, %p\n", debugstr_w(str), modp);
  76
  77     /* session instance */
  78     if (!modp) return 0xFFFFFFFF;
  79
  80     if (!MCIAVI_RegisterClass()) return 0;
  81
  82     wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
  83     if (!wma)
  84         return 0;
  85
  86     InitializeCriticalSection(&wma->cs);
  87     wma->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_MCIAVI.cs");
  88     wma->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
  89     wma->wDevID = modp->wDeviceID;
  90     wma->wCommandTable = mciLoadCommandResource(MCIAVI_hInstance, mciAviWStr, 0);
  91     wma->dwStatus = MCI_MODE_NOT_READY;
  92     modp->wCustomCommandTable = wma->wCommandTable;
  93     modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
  94     mciSetDriverData(wma->wDevID, (DWORD_PTR)wma);
  95
  96     return modp->wDeviceID;
  97 }
  98
  99 /**************************************************************************
 100  *                              MCIAVI_drvClose         [internal]
 101  */
 102 static  DWORD   MCIAVI_drvClose(DWORD dwDevID)
 103 {
 104     WINE_MCIAVI *wma;
 105
 106     TRACE("%04x\n", dwDevID);
 107
 108     /* finish all outstanding things */
 109     MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
 110
 111     wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
 112
 113     if (wma) {
 114         MCIAVI_UnregisterClass();
 115
 116         EnterCriticalSection(&wma->cs);
 117
 118         mciSetDriverData(dwDevID, 0);
 119         mciFreeCommandResource(wma->wCommandTable);
 120
 121         CloseHandle(wma->hStopEvent);
 122
 123         LeaveCriticalSection(&wma->cs);
 124         wma->cs.DebugInfo->Spare[0] = 0;
 125         DeleteCriticalSection(&wma->cs);
 126
 127         HeapFree(GetProcessHeap(), 0, wma);
 128         return 1;
 129     }
 130     return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
 131 }
 132
 133 /**************************************************************************
 134  *                              MCIAVI_drvConfigure             [internal]
 135  */
 136 static  DWORD   MCIAVI_drvConfigure(DWORD dwDevID)
 137 {
 138     WINE_MCIAVI *wma;
 139
 140     TRACE("%04x\n", dwDevID);
 141
 142     MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
 143
 144     wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
 145
 146     if (wma) {
 147         MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
 148         return 1;
 149     }
 150     return 0;
 151 }
 152
 153 /**************************************************************************
 154  *                              MCIAVI_mciGetOpenDev            [internal]
 155  */
 156 WINE_MCIAVI*  MCIAVI_mciGetOpenDev(UINT wDevID)
 157 {
 158     WINE_MCIAVI*        wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
 159
 160     if (wma == NULL || wma->nUseCount == 0) {
 161         WARN("Invalid wDevID=%u\n", wDevID);
 162         return 0;
 163     }
 164     return wma;
 165 }
 166
 167 static void MCIAVI_CleanUp(WINE_MCIAVI* wma)
 168 {
 169     /* to prevent handling in WindowProc */
 170     wma->dwStatus = MCI_MODE_NOT_READY;
 171     if (wma->hFile) {
 172         mmioClose(wma->hFile, 0);
 173         wma->hFile = 0;
 174
 175         HeapFree(GetProcessHeap(), 0, wma->lpFileName);
 176         wma->lpFileName = NULL;
 177
 178         HeapFree(GetProcessHeap(), 0, wma->lpVideoIndex);
 179         wma->lpVideoIndex = NULL;
 180         HeapFree(GetProcessHeap(), 0, wma->lpAudioIndex);
 181         wma->lpAudioIndex = NULL;
 182         if (wma->hic)           ICClose(wma->hic);
 183         wma->hic = 0;
 184         HeapFree(GetProcessHeap(), 0, wma->inbih);
 185         wma->inbih = NULL;
 186         HeapFree(GetProcessHeap(), 0, wma->outbih);
 187         wma->outbih = NULL;
 188         HeapFree(GetProcessHeap(), 0, wma->indata);
 189         wma->indata = NULL;
 190         HeapFree(GetProcessHeap(), 0, wma->outdata);
 191         wma->outdata = NULL;
 192         if (wma->hbmFrame)      DeleteObject(wma->hbmFrame);
 193         wma->hbmFrame = 0;
 194         if (wma->hWnd)          DestroyWindow(wma->hWnd);
 195         wma->hWnd = 0;
 196
 197         HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
 198         wma->lpWaveFormat = 0;
 199
 200         memset(&wma->mah, 0, sizeof(wma->mah));
 201         memset(&wma->ash_video, 0, sizeof(wma->ash_video));
 202         memset(&wma->ash_audio, 0, sizeof(wma->ash_audio));
 203         wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
 204         wma->dwCachedFrame = -1;
 205     }
 206 }
 207
 208 /***************************************************************************
 209  *                              MCIAVI_mciOpen                  [internal]
 210  */
 211 static  DWORD   MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
 212                                LPMCI_DGV_OPEN_PARMSW lpOpenParms)
 213 {
 214     WINE_MCIAVI *wma;
 215     LRESULT             dwRet = 0;
 216
 217     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
 218
 219     if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
 220
 221     wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
 222     if (wma == NULL)                    return MCIERR_INVALID_DEVICE_ID;
 223
 224     EnterCriticalSection(&wma->cs);
 225
 226     if (wma->nUseCount > 0) {
 227         /* The driver is already open on this channel */
 228         /* If the driver was opened shareable before and this open specifies */
 229         /* shareable then increment the use count */
 230         if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 231             ++wma->nUseCount;
 232         else
 233         {
 234             LeaveCriticalSection(&wma->cs);
 235             return MCIERR_MUST_USE_SHAREABLE;
 236         }
 237     } else {
 238         wma->nUseCount = 1;
 239         wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 240     }
 241
 242     wma->dwStatus = MCI_MODE_NOT_READY;
 243
 244     if (dwFlags & MCI_OPEN_ELEMENT) {
 245         if (dwFlags & MCI_OPEN_ELEMENT_ID) {
 246             /* could it be that (DWORD)lpOpenParms->lpstrElementName
 247              * contains the hFile value ?
 248              */
 249             dwRet = MCIERR_UNRECOGNIZED_COMMAND;
 250         } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
 251             /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
 252             TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
 253
 254             wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
 255             strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
 256
 257             if (lpOpenParms->lpstrElementName[0] == '@') {
 258                 /* The file name @11223344 encodes an AVIFile handle in decimal notation
 259                  * in Win3.1 and w2k/NT, but this feature is absent in win95 (KB140750).
 260                  * wma->hFile = LongToHandle(strtolW(lpOpenParms->lpstrElementName+1, NULL, 10)); */
 261                 FIXME("Using AVIFile/Stream %s NIY\n", debugstr_w(lpOpenParms->lpstrElementName));
 262             }
 263             wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
 264                                    MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
 265
 266             if (wma->hFile == 0) {
 267                 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
 268                 dwRet = MCIERR_FILE_NOT_FOUND;
 269             } else {
 270                 if (!MCIAVI_GetInfo(wma))
 271                     dwRet = MCIERR_INVALID_FILE;
 272                 else if (!MCIAVI_OpenVideo(wma))
 273                     dwRet = MCIERR_CANNOT_LOAD_DRIVER;
 274                 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
 275                     dwRet = MCIERR_CREATEWINDOW;
 276             }
 277         } else {
 278             FIXME("Don't record yet\n");
 279             dwRet = MCIERR_UNSUPPORTED_FUNCTION;
 280         }
 281     }
 282
 283     if (dwRet == 0) {
 284         TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
 285
 286         wma->dwStatus = MCI_MODE_STOP;
 287         wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
 288     } else {
 289         MCIAVI_CleanUp(wma);
 290     }
 291
 292     LeaveCriticalSection(&wma->cs);
 293
 294     if (!dwRet && (dwFlags & MCI_NOTIFY)) {
 295         mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)),
 296                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 297     }
 298     return dwRet;
 299 }
 300
 301 /***************************************************************************
 302  *                              MCIAVI_mciClose                 [internal]
 303  */
 304 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 305 {
 306     WINE_MCIAVI *wma;
 307     DWORD               dwRet = 0;
 308
 309     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 310
 311     wma = MCIAVI_mciGetOpenDev(wDevID);
 312     if (wma == NULL)    return MCIERR_INVALID_DEVICE_ID;
 313
 314     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 315
 316     EnterCriticalSection(&wma->cs);
 317
 318     if (wma->nUseCount == 1) {
 319         MCIAVI_CleanUp(wma);
 320
 321         if ((dwFlags & MCI_NOTIFY) && lpParms) {
 322             mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 323                            wDevID,
 324                             MCI_NOTIFY_SUCCESSFUL);
 325         }
 326         LeaveCriticalSection(&wma->cs);
 327         return dwRet;
 328     }
 329     wma->nUseCount--;
 330
 331     LeaveCriticalSection(&wma->cs);
 332     return dwRet;
 333 }
 334
 335 static double currenttime_us(void)
 336 {
 337     LARGE_INTEGER lc, lf;
 338     QueryPerformanceCounter(&lc);
 339     QueryPerformanceFrequency(&lf);
 340     return (lc.QuadPart * 1000000) / lf.QuadPart;
 341 }
 342
 343 /***************************************************************************
 344  *                              MCIAVI_player                   [internal]
 345  */
 346 static  DWORD   MCIAVI_player(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 347 {
 348     DWORD               dwRet;
 349     LPWAVEHDR           waveHdr = NULL;
 350     unsigned            i, nHdr = 0;
 351     DWORD               numEvents = 1;
 352     HANDLE              events[2];
 353     double next_frame_us;
 354
 355     EnterCriticalSection(&wma->cs);
 356
 357     if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
 358     {
 359         dwRet = 0;
 360         goto mci_play_done;
 361     }
 362
 363     events[0] = wma->hStopEvent;
 364     if (wma->lpWaveFormat) {
 365        if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
 366         {
 367             /* can't play audio */
 368             HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
 369             wma->lpWaveFormat = NULL;
 370         }
 371        else
 372        {
 373             /* fill the queue with as many wave headers as possible */
 374             MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
 375             events[1] = wma->hEvent;
 376             numEvents = 2;
 377        }
 378     }
 379
 380     next_frame_us = currenttime_us();
 381     while (wma->dwStatus == MCI_MODE_PLAY)
 382     {
 383         HDC hDC;
 384         double tc, delta;
 385         DWORD ret;
 386
 387         tc = currenttime_us();
 388
 389         hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
 390         if (hDC)
 391         {
 392             while(next_frame_us <= tc && wma->dwCurrVideoFrame < wma->dwToVideoFrame){
 393                 double dur;
 394                 dur = MCIAVI_PaintFrame(wma, hDC);
 395                 ++wma->dwCurrVideoFrame;
 396                 if(!dur)
 397                     break;
 398                 next_frame_us += dur;
 399                 TRACE("next_frame: %f\n", next_frame_us);
 400             }
 401             ReleaseDC(wma->hWndPaint, hDC);
 402         }
 403         if (wma->dwCurrVideoFrame >= wma->dwToVideoFrame)
 404         {
 405             if (!(dwFlags & MCI_DGV_PLAY_REPEAT))
 406                 break;
 407             TRACE("repeat media as requested\n");
 408             wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
 409         }
 410
 411         if (wma->lpWaveFormat)
 412             MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
 413
 414         tc = currenttime_us();
 415         if (tc < next_frame_us)
 416             delta = next_frame_us - tc;
 417         else
 418             delta = 0;
 419
 420         LeaveCriticalSection(&wma->cs);
 421         ret = WaitForMultipleObjects(numEvents, events, FALSE, delta / 1000);
 422         EnterCriticalSection(&wma->cs);
 423         if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
 424     }
 425
 426     if (wma->lpWaveFormat) {
 427        while (wma->dwEventCount != nHdr - 1)
 428         {
 429             LeaveCriticalSection(&wma->cs);
 430             Sleep(100);
 431             EnterCriticalSection(&wma->cs);
 432         }
 433
 434         /* just to get rid of some race conditions between play, stop and pause */
 435         LeaveCriticalSection(&wma->cs);
 436         waveOutReset(wma->hWave);
 437         EnterCriticalSection(&wma->cs);
 438
 439         for (i = 0; i < nHdr; i++)
 440             waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
 441     }
 442
 443     dwRet = 0;
 444
 445     if (wma->lpWaveFormat) {
 446         HeapFree(GetProcessHeap(), 0, waveHdr);
 447
 448         if (wma->hWave) {
 449             LeaveCriticalSection(&wma->cs);
 450             waveOutClose(wma->hWave);
 451             EnterCriticalSection(&wma->cs);
 452             wma->hWave = 0;
 453         }
 454         CloseHandle(wma->hEvent);
 455     }
 456
 457 mci_play_done:
 458     wma->dwStatus = MCI_MODE_STOP;
 459
 460     if (dwFlags & MCI_NOTIFY) {
 461         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 462         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 463                        wma->wDevID, MCI_NOTIFY_SUCCESSFUL);
 464     }
 465     LeaveCriticalSection(&wma->cs);
 466     return dwRet;
 467 }
 468
 469 struct MCIAVI_play_data
 470 {
 471     WINE_MCIAVI *wma;
 472     DWORD flags;
 473     MCI_PLAY_PARMS params; /* FIXME: notify via wma->hCallback like the other MCI drivers */
 474 };
 475
 476 /*
 477  * MCIAVI_mciPlay_thread
 478  *
 479  * FIXME: probably should use a common worker thread created at the driver
 480  * load time and queue all async commands to it.
 481  */
 482 static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
 483 {
 484     struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
 485     DWORD ret;
 486
 487     TRACE("In thread before async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
 488     ret = MCIAVI_player(data->wma, data->flags, &data->params);
 489     TRACE("In thread after async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
 490
 491     HeapFree(GetProcessHeap(), 0, data);
 492     return ret;
 493 }
 494
 495 /*
 496  * MCIAVI_mciPlay_async
 497  */
 498 static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
 499 {
 500     HANDLE handle;
 501     struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
 502
 503     if (!data) return MCIERR_OUT_OF_MEMORY;
 504
 505     data->wma = wma;
 506     data->flags = dwFlags;
 507     if (dwFlags & MCI_NOTIFY)
 508         data->params.dwCallback = lpParams->dwCallback;
 509
 510     if (!(handle = CreateThread(NULL, 0, MCIAVI_mciPlay_thread, data, 0, NULL)))
 511     {
 512         WARN("Couldn't create thread for async play, playing synchronously\n");
 513         return MCIAVI_mciPlay_thread(data);
 514     }
 515     SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
 516     CloseHandle(handle);
 517     return 0;
 518 }
 519
 520 /***************************************************************************
 521  *                              MCIAVI_mciPlay                  [internal]
 522  */
 523 static  DWORD   MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 524 {
 525     WINE_MCIAVI *wma;
 526     DWORD               dwRet;
 527     DWORD               dwFromFrame, dwToFrame;
 528
 529     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 530
 531     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 532
 533     wma = MCIAVI_mciGetOpenDev(wDevID);
 534     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 535     if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION;
 536     if (dwFlags & MCI_TEST)     return 0;
 537
 538     if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN|MCI_MCIAVI_PLAY_FULLBY2))
 539         FIXME("Unsupported flag %08x\n", dwFlags);
 540
 541     EnterCriticalSection(&wma->cs);
 542
 543     if (!wma->hFile)
 544     {
 545         LeaveCriticalSection(&wma->cs);
 546         return MCIERR_FILE_NOT_FOUND;
 547     }
 548     if (!wma->hWndPaint)
 549     {
 550         LeaveCriticalSection(&wma->cs);
 551         return MCIERR_NO_WINDOW;
 552     }
 553
 554     dwFromFrame = wma->dwCurrVideoFrame;
 555     dwToFrame = wma->dwPlayableVideoFrames - 1;
 556
 557     if (dwFlags & MCI_FROM) {
 558         dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
 559     }
 560     if (dwFlags & MCI_TO) {
 561         dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
 562     }
 563     if (dwToFrame >= wma->dwPlayableVideoFrames)
 564         dwToFrame = wma->dwPlayableVideoFrames - 1;
 565
 566     TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
 567
 568     wma->dwCurrVideoFrame = dwFromFrame;
 569     wma->dwToVideoFrame = dwToFrame;
 570
 571     LeaveCriticalSection(&wma->cs);
 572
 573     if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
 574         ShowWindow(wma->hWndPaint, SW_SHOWNA);
 575
 576     EnterCriticalSection(&wma->cs);
 577
 578     /* if already playing exit */
 579     if (wma->dwStatus == MCI_MODE_PLAY)
 580     {
 581         LeaveCriticalSection(&wma->cs);
 582         return 0;
 583     }
 584
 585     wma->dwStatus = MCI_MODE_PLAY;
 586
 587     LeaveCriticalSection(&wma->cs);
 588
 589     if (dwFlags & MCI_WAIT)
 590         return MCIAVI_player(wma, dwFlags, lpParms);
 591
 592     dwRet = MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
 593
 594     if (dwRet) {
 595         EnterCriticalSection(&wma->cs);
 596         wma->dwStatus = MCI_MODE_STOP;
 597         LeaveCriticalSection(&wma->cs);
 598     }
 599     return dwRet;
 600 }
 601
 602 /***************************************************************************
 603  *                              MCIAVI_mciStop                  [internal]
 604  */
 605 static  DWORD   MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 606 {
 607     WINE_MCIAVI *wma;
 608     DWORD               dwRet = 0;
 609
 610     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 611
 612     wma = MCIAVI_mciGetOpenDev(wDevID);
 613     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 614     if (dwFlags & MCI_TEST)     return 0;
 615
 616     EnterCriticalSection(&wma->cs);
 617
 618     TRACE("current status %04x\n", wma->dwStatus);
 619
 620     switch (wma->dwStatus) {
 621     case MCI_MODE_PLAY:
 622     case MCI_MODE_RECORD:
 623         LeaveCriticalSection(&wma->cs);
 624         SetEvent(wma->hStopEvent);
 625         EnterCriticalSection(&wma->cs);
 626         /* fall through */
 627     case MCI_MODE_PAUSE:
 628         /* Since our wave notification callback takes the lock,
 629          * we must release it before resetting the device */
 630         LeaveCriticalSection(&wma->cs);
 631         dwRet = waveOutReset(wma->hWave);
 632         EnterCriticalSection(&wma->cs);
 633         /* fall through */
 634     default:
 635         do /* one more chance for an async thread to finish */
 636         {
 637             LeaveCriticalSection(&wma->cs);
 638             Sleep(10);
 639             EnterCriticalSection(&wma->cs);
 640         } while (wma->dwStatus != MCI_MODE_STOP);
 641
 642         break;
 643
 644     case MCI_MODE_NOT_READY:
 645         break;
 646     }
 647
 648     if ((dwFlags & MCI_NOTIFY) && lpParms) {
 649         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 650                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 651     }
 652     LeaveCriticalSection(&wma->cs);
 653     return dwRet;
 654 }
 655
 656 /***************************************************************************
 657  *                              MCIAVI_mciPause                 [internal]
 658  */
 659 static  DWORD   MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 660 {
 661     WINE_MCIAVI *wma;
 662
 663     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 664
 665     wma = MCIAVI_mciGetOpenDev(wDevID);
 666     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 667     if (dwFlags & MCI_TEST)     return 0;
 668
 669     EnterCriticalSection(&wma->cs);
 670
 671     if (wma->dwStatus == MCI_MODE_PLAY)
 672         wma->dwStatus = MCI_MODE_PAUSE;
 673
 674     if (wma->lpWaveFormat) {
 675         LeaveCriticalSection(&wma->cs);
 676         return waveOutPause(wma->hWave);
 677     }
 678
 679     LeaveCriticalSection(&wma->cs);
 680     return 0;
 681 }
 682
 683 /***************************************************************************
 684  *                              MCIAVI_mciResume                        [internal]
 685  */
 686 static  DWORD   MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 687 {
 688     WINE_MCIAVI *wma;
 689
 690     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 691
 692     wma = MCIAVI_mciGetOpenDev(wDevID);
 693     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 694     if (dwFlags & MCI_TEST)     return 0;
 695
 696     EnterCriticalSection(&wma->cs);
 697
 698     if (wma->dwStatus == MCI_MODE_PAUSE)
 699         wma->dwStatus = MCI_MODE_PLAY;
 700
 701     if (wma->lpWaveFormat) {
 702         LeaveCriticalSection(&wma->cs);
 703         return waveOutRestart(wma->hWave);
 704     }
 705
 706     LeaveCriticalSection(&wma->cs);
 707     return 0;
 708 }
 709
 710 /***************************************************************************
 711  *                              MCIAVI_mciSeek                  [internal]
 712  */
 713 static  DWORD   MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 714 {
 715     WINE_MCIAVI *wma;
 716     DWORD position;
 717
 718     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 719
 720     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 721
 722     wma = MCIAVI_mciGetOpenDev(wDevID);
 723     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 724
 725     position = dwFlags & (MCI_SEEK_TO_START|MCI_SEEK_TO_END|MCI_TO);
 726     if (!position)              return MCIERR_MISSING_PARAMETER;
 727     if (position&(position-1))  return MCIERR_FLAGS_NOT_COMPATIBLE;
 728
 729     if (dwFlags & MCI_TO) {
 730         position = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
 731         if (position >= wma->dwPlayableVideoFrames)
 732             return MCIERR_OUTOFRANGE;
 733     } else if (dwFlags & MCI_SEEK_TO_START) {
 734         position = 0;
 735     } else {
 736         position = wma->dwPlayableVideoFrames - 1;
 737     }
 738     if (dwFlags & MCI_TEST)     return 0;
 739
 740     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 741
 742     EnterCriticalSection(&wma->cs);
 743
 744     wma->dwCurrVideoFrame = position;
 745     TRACE("Seeking to frame=%u\n", wma->dwCurrVideoFrame);
 746
 747     if (dwFlags & MCI_NOTIFY) {
 748         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 749                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 750     }
 751     LeaveCriticalSection(&wma->cs);
 752     return 0;
 753 }
 754
 755 /*****************************************************************************
 756  *                              MCIAVI_mciLoad                  [internal]
 757  */
 758 static DWORD    MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
 759 {
 760     WINE_MCIAVI *wma;
 761
 762     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 763
 764     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 765
 766     wma = MCIAVI_mciGetOpenDev(wDevID);
 767     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 768
 769     return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
 770 }
 771
 772 /******************************************************************************
 773  *                              MCIAVI_mciRealize                       [internal]
 774  */
 775 static  DWORD   MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 776 {
 777     WINE_MCIAVI *wma;
 778
 779     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 780
 781     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 782
 783     wma = MCIAVI_mciGetOpenDev(wDevID);
 784     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 785     if (dwFlags & MCI_TEST)     return 0;
 786
 787     return 0;
 788 }
 789
 790 /******************************************************************************
 791  *                              MCIAVI_mciUpdate                        [internal]
 792  */
 793 static  DWORD   MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
 794 {
 795     WINE_MCIAVI *wma;
 796
 797     TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
 798
 799     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 800
 801     wma = MCIAVI_mciGetOpenDev(wDevID);
 802     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 803     /* Ignore MCI_TEST flag. */
 804
 805     EnterCriticalSection(&wma->cs);
 806
 807     if (dwFlags & MCI_DGV_UPDATE_HDC)
 808         MCIAVI_PaintFrame(wma, lpParms->hDC);
 809
 810     LeaveCriticalSection(&wma->cs);
 811
 812     return 0;
 813 }
 814
 815 /******************************************************************************
 816  *                              MCIAVI_mciStep                  [internal]
 817  */
 818 static  DWORD   MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
 819 {
 820     WINE_MCIAVI *wma;
 821     DWORD position;
 822     int delta = 1;
 823
 824     TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
 825
 826     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 827
 828     wma = MCIAVI_mciGetOpenDev(wDevID);
 829     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 830
 831     if (dwFlags & MCI_DGV_STEP_FRAMES)  delta = lpParms->dwFrames;
 832     if (dwFlags & MCI_DGV_STEP_REVERSE) delta = -delta;
 833     position = wma->dwCurrVideoFrame + delta;
 834     if (position >= wma->dwPlayableVideoFrames) return MCIERR_OUTOFRANGE;
 835     if (dwFlags & MCI_TEST)     return 0;
 836
 837     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 838
 839     EnterCriticalSection(&wma->cs);
 840
 841     wma->dwCurrVideoFrame = position;
 842     TRACE("Stepping to frame=%u\n", wma->dwCurrVideoFrame);
 843
 844     if (dwFlags & MCI_NOTIFY) {
 845         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 846                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 847     }
 848     LeaveCriticalSection(&wma->cs);
 849     return 0;
 850 }
 851
 852 /******************************************************************************
 853  *                              MCIAVI_mciCue                   [internal]
 854  */
 855 static  DWORD   MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
 856 {
 857     WINE_MCIAVI *wma;
 858
 859     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 860
 861     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 862
 863     wma = MCIAVI_mciGetOpenDev(wDevID);
 864     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 865     if (dwFlags & MCI_DGV_CUE_INPUT) return MCIERR_UNSUPPORTED_FUNCTION;
 866     if (dwFlags & MCI_TEST)     return 0;
 867
 868     return 0;
 869 }
 870
 871 /******************************************************************************
 872  *                              MCIAVI_mciSetAudio                      [internal]
 873  */
 874 static  DWORD   MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
 875 {
 876     WINE_MCIAVI *wma;
 877
 878     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 879
 880     FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETAUDIO_ITEM ? lpParms->dwItem : 0);
 881
 882     wma = MCIAVI_mciGetOpenDev(wDevID);
 883     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 884
 885     return 0;
 886 }
 887
 888 /******************************************************************************
 889  *                              MCIAVI_mciSignal                        [internal]
 890  */
 891 static  DWORD   MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
 892 {
 893     WINE_MCIAVI *wma;
 894
 895     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 896
 897     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 898
 899     wma = MCIAVI_mciGetOpenDev(wDevID);
 900     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 901
 902     return 0;
 903 }
 904
 905 /******************************************************************************
 906  *                              MCIAVI_mciSetVideo                      [internal]
 907  */
 908 static  DWORD   MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
 909 {
 910     WINE_MCIAVI *wma;
 911
 912     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 913
 914     FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETVIDEO_ITEM ? lpParms->dwItem : 0);
 915
 916     wma = MCIAVI_mciGetOpenDev(wDevID);
 917     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 918
 919     return 0;
 920 }
 921
 922 /******************************************************************************
 923  *                              MCIAVI_mciConfigure                     [internal]
 924  */
 925 static  DWORD   MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 926 {
 927     WINE_MCIAVI *wma;
 928
 929     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 930
 931     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 932
 933     wma = MCIAVI_mciGetOpenDev(wDevID);
 934     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 935     if (dwFlags & MCI_TEST)     return 0;
 936
 937     return 0;
 938 }
 939
 940 /*======================================================================*
 941  *                          MCI AVI entry points                        *
 942  *======================================================================*/
 943
 944 /**************************************************************************
 945  *                              DriverProc (MCIAVI.@)
 946  */
 947 LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 948                                    LPARAM dwParam1, LPARAM dwParam2)
 949 {
 950     TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
 951           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 952
 953     switch (wMsg) {
 954     case DRV_LOAD:              return 1;
 955     case DRV_FREE:              return 1;
 956     case DRV_OPEN:              return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
 957     case DRV_CLOSE:             return MCIAVI_drvClose(dwDevID);
 958     case DRV_ENABLE:            return 1;
 959     case DRV_DISABLE:           return 1;
 960     case DRV_QUERYCONFIGURE:    return 1;
 961     case DRV_CONFIGURE:         return MCIAVI_drvConfigure(dwDevID);
 962     case DRV_INSTALL:           return DRVCNF_RESTART;
 963     case DRV_REMOVE:            return DRVCNF_RESTART;
 964     }
 965
 966     /* session instance */
 967     if (dwDevID == 0xFFFFFFFF) return 1;
 968
 969     switch (wMsg) {
 970     case MCI_OPEN_DRIVER:       return MCIAVI_mciOpen      (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW)     dwParam2);
 971     case MCI_CLOSE_DRIVER:      return MCIAVI_mciClose     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 972     case MCI_PLAY:              return MCIAVI_mciPlay      (dwDevID, dwParam1, (LPMCI_PLAY_PARMS)          dwParam2);
 973     case MCI_STOP:              return MCIAVI_mciStop      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 974     case MCI_SET:               return MCIAVI_mciSet       (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS)       dwParam2);
 975     case MCI_PAUSE:             return MCIAVI_mciPause     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 976     case MCI_RESUME:            return MCIAVI_mciResume    (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 977     case MCI_STATUS:            return MCIAVI_mciStatus    (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW)   dwParam2);
 978     case MCI_GETDEVCAPS:        return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)    dwParam2);
 979     case MCI_INFO:              return MCIAVI_mciInfo      (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW)     dwParam2);
 980     case MCI_SEEK:              return MCIAVI_mciSeek      (dwDevID, dwParam1, (LPMCI_SEEK_PARMS)          dwParam2);
 981     case MCI_PUT:               return MCIAVI_mciPut       (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS)       dwParam2);
 982     case MCI_WINDOW:            return MCIAVI_mciWindow    (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)   dwParam2);
 983     case MCI_LOAD:              return MCIAVI_mciLoad      (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW)     dwParam2);
 984     case MCI_REALIZE:           return MCIAVI_mciRealize   (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 985     case MCI_UPDATE:            return MCIAVI_mciUpdate    (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)    dwParam2);
 986     case MCI_WHERE:             return MCIAVI_mciWhere     (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
 987     case MCI_STEP:              return MCIAVI_mciStep      (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS)      dwParam2);
 988     case MCI_CUE:               return MCIAVI_mciCue       (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS)       dwParam2);
 989         /* Digital Video specific */
 990     case MCI_SETAUDIO:          return MCIAVI_mciSetAudio  (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
 991     case MCI_SIGNAL:            return MCIAVI_mciSignal    (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS)    dwParam2);
 992     case MCI_SETVIDEO:          return MCIAVI_mciSetVideo  (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
 993     case MCI_CONFIGURE:         return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
 994
 995         /* no editing, recording, saving, locking without inputs */
 996     case MCI_CAPTURE:
 997     case MCI_COPY:
 998     case MCI_CUT:
 999     case MCI_DELETE:
1000     case MCI_FREEZE:
1001     case MCI_LIST:
1002     case MCI_MONITOR:
1003     case MCI_PASTE:
1004     case MCI_QUALITY:
1005     case MCI_RECORD:
1006     case MCI_RESERVE:
1007     case MCI_RESTORE:
1008     case MCI_SAVE:
1009     case MCI_UNDO:
1010     case MCI_UNFREEZE:
1011         TRACE("Unsupported function [0x%x] flags=%08x\n", wMsg, (DWORD)dwParam1);
1012         return MCIERR_UNSUPPORTED_FUNCTION;
1013     case MCI_SPIN:
1014     case MCI_ESCAPE:
1015         WARN("Unsupported command [0x%x] %08x\n", wMsg, (DWORD)dwParam1);
1016         break;
1017     case MCI_OPEN:
1018     case MCI_CLOSE:
1019         FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1020         break;
1021     default:
1022         TRACE("Sending msg [%u] to default driver proc\n", wMsg);
1023         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1024     }
1025     return MCIERR_UNRECOGNIZED_COMMAND;
1026 }