git.oblomov.eu Git - wine/blob - dlls/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  *      - better move the AVI handling part to avifile DLL and make use of it
  30  *      - some files appear to have more than one audio stream (we only play the
  31  *        first one)
  32  *      - some files contain an index of audio/video frame. Better use it,
  33  *        instead of rebuilding it
  34  *      - stopping while playing a file with sound blocks until all buffered
  35  *        audio is played... still should be stopped ASAP
  36  */
  37
  38 #include <string.h>
  39 #include "private_mciavi.h"
  40 #include "wine/debug.h"
  41 #include "wine/unicode.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
  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->ack_event = CreateEventW(NULL, FALSE, FALSE, NULL);
  89     wma->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
  90     wma->wDevID = modp->wDeviceID;
  91     wma->wCommandTable = mciLoadCommandResource(MCIAVI_hInstance, mciAviWStr, 0);
  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->ack_event);
 122         CloseHandle(wma->hStopEvent);
 123
 124         LeaveCriticalSection(&wma->cs);
 125         wma->cs.DebugInfo->Spare[0] = 0;
 126         DeleteCriticalSection(&wma->cs);
 127
 128         HeapFree(GetProcessHeap(), 0, wma);
 129         return 1;
 130     }
 131     return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
 132 }
 133
 134 /**************************************************************************
 135  *                              MCIAVI_drvConfigure             [internal]
 136  */
 137 static  DWORD   MCIAVI_drvConfigure(DWORD dwDevID)
 138 {
 139     WINE_MCIAVI *wma;
 140
 141     TRACE("%04x\n", dwDevID);
 142
 143     MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
 144
 145     wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
 146
 147     if (wma) {
 148         MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
 149         return 1;
 150     }
 151     return 0;
 152 }
 153
 154 /**************************************************************************
 155  *                              MCIAVI_mciGetOpenDev            [internal]
 156  */
 157 WINE_MCIAVI*  MCIAVI_mciGetOpenDev(UINT wDevID)
 158 {
 159     WINE_MCIAVI*        wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
 160
 161     if (wma == NULL || wma->nUseCount == 0) {
 162         WARN("Invalid wDevID=%u\n", wDevID);
 163         return 0;
 164     }
 165     return wma;
 166 }
 167
 168 static void MCIAVI_CleanUp(WINE_MCIAVI* wma)
 169 {
 170     /* to prevent handling in WindowProc */
 171     wma->dwStatus = MCI_MODE_NOT_READY;
 172     if (wma->hFile) {
 173         mmioClose(wma->hFile, 0);
 174         wma->hFile = 0;
 175
 176         HeapFree(GetProcessHeap(), 0, wma->lpFileName);
 177         wma->lpFileName = NULL;
 178
 179         HeapFree(GetProcessHeap(), 0, wma->lpVideoIndex);
 180         wma->lpVideoIndex = NULL;
 181         HeapFree(GetProcessHeap(), 0, wma->lpAudioIndex);
 182         wma->lpAudioIndex = NULL;
 183         if (wma->hic)           ICClose(wma->hic);
 184         wma->hic = 0;
 185         HeapFree(GetProcessHeap(), 0, wma->inbih);
 186         wma->inbih = NULL;
 187         HeapFree(GetProcessHeap(), 0, wma->outbih);
 188         wma->outbih = NULL;
 189         HeapFree(GetProcessHeap(), 0, wma->indata);
 190         wma->indata = NULL;
 191         HeapFree(GetProcessHeap(), 0, wma->outdata);
 192         wma->outdata = NULL;
 193         if (wma->hbmFrame)      DeleteObject(wma->hbmFrame);
 194         wma->hbmFrame = 0;
 195         if (wma->hWnd)          DestroyWindow(wma->hWnd);
 196         wma->hWnd = 0;
 197
 198         HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
 199         wma->lpWaveFormat = 0;
 200
 201         memset(&wma->mah, 0, sizeof(wma->mah));
 202         memset(&wma->ash_video, 0, sizeof(wma->ash_video));
 203         memset(&wma->ash_audio, 0, sizeof(wma->ash_audio));
 204         wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
 205         wma->dwCachedFrame = -1;
 206     }
 207 }
 208
 209 /***************************************************************************
 210  *                              MCIAVI_mciOpen                  [internal]
 211  */
 212 static  DWORD   MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
 213                                LPMCI_DGV_OPEN_PARMSW lpOpenParms)
 214 {
 215     WINE_MCIAVI *wma;
 216     LRESULT             dwRet = 0;
 217
 218     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
 219
 220     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 221
 222     if (lpOpenParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
 223
 224     wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
 225     if (wma == NULL)                    return MCIERR_INVALID_DEVICE_ID;
 226
 227     EnterCriticalSection(&wma->cs);
 228
 229     if (wma->nUseCount > 0) {
 230         /* The driver is already open on this channel */
 231         /* If the driver was opened shareable before and this open specifies */
 232         /* shareable then increment the use count */
 233         if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
 234             ++wma->nUseCount;
 235         else
 236         {
 237             LeaveCriticalSection(&wma->cs);
 238             return MCIERR_MUST_USE_SHAREABLE;
 239         }
 240     } else {
 241         wma->nUseCount = 1;
 242         wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
 243     }
 244
 245     wma->dwStatus = MCI_MODE_NOT_READY;
 246
 247     if (dwFlags & MCI_OPEN_ELEMENT) {
 248         if (dwFlags & MCI_OPEN_ELEMENT_ID) {
 249             /* could it be that (DWORD)lpOpenParms->lpstrElementName
 250              * contains the hFile value ?
 251              */
 252             dwRet = MCIERR_UNRECOGNIZED_COMMAND;
 253         } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
 254             /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
 255             TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
 256
 257             wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
 258             strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
 259
 260             wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
 261                                    MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
 262
 263             if (wma->hFile == 0) {
 264                 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
 265                 dwRet = MCIERR_FILE_NOT_FOUND;
 266             } else {
 267                 if (!MCIAVI_GetInfo(wma))
 268                     dwRet = MCIERR_INVALID_FILE;
 269                 else if (!MCIAVI_OpenVideo(wma))
 270                     dwRet = MCIERR_CANNOT_LOAD_DRIVER;
 271                 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
 272                     dwRet = MCIERR_CREATEWINDOW;
 273             }
 274         } else {
 275             FIXME("Don't record yet\n");
 276             dwRet = MCIERR_UNSUPPORTED_FUNCTION;
 277         }
 278     }
 279
 280     if (dwRet == 0) {
 281         TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
 282
 283         wma->dwStatus = MCI_MODE_STOP;
 284         wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
 285     } else {
 286         MCIAVI_CleanUp(wma);
 287     }
 288
 289     LeaveCriticalSection(&wma->cs);
 290     return dwRet;
 291 }
 292
 293 /***************************************************************************
 294  *                              MCIAVI_mciClose                 [internal]
 295  */
 296 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 297 {
 298     WINE_MCIAVI *wma;
 299     DWORD               dwRet = 0;
 300
 301     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 302
 303     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 304
 305     wma = MCIAVI_mciGetOpenDev(wDevID);
 306     if (wma == NULL)    return MCIERR_INVALID_DEVICE_ID;
 307
 308     EnterCriticalSection(&wma->cs);
 309
 310     if (wma->nUseCount == 1) {
 311         if (wma->dwStatus != MCI_MODE_STOP)
 312            dwRet = MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 313         MCIAVI_CleanUp(wma);
 314
 315         if ((dwFlags & MCI_NOTIFY) && lpParms) {
 316             mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 317                            wDevID,
 318                             MCI_NOTIFY_SUCCESSFUL);
 319         }
 320         LeaveCriticalSection(&wma->cs);
 321         return dwRet;
 322     }
 323     wma->nUseCount--;
 324
 325     LeaveCriticalSection(&wma->cs);
 326     return dwRet;
 327 }
 328
 329 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
 330
 331 struct MCIAVI_play_data
 332 {
 333     MCIDEVICEID wDevID;
 334     DWORD flags;
 335     MCI_PLAY_PARMS params;
 336 };
 337
 338 /*
 339  * MCIAVI_mciPlay_thread
 340  *
 341  * FIXME: probably should use a common worker thread created at the driver
 342  * load time and queue all async commands to it.
 343  */
 344 static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
 345 {
 346     struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
 347     DWORD ret;
 348
 349     TRACE("In thread before async play command (id %08x, flags %08x)\n", data->wDevID, data->flags);
 350     ret = MCIAVI_mciPlay(data->wDevID, data->flags | MCI_WAIT, &data->params);
 351     TRACE("In thread after async play command (id %08x, flags %08x)\n", data->wDevID, data->flags);
 352
 353     HeapFree(GetProcessHeap(), 0, data);
 354     return ret;
 355 }
 356
 357 /*
 358  * MCIAVI_mciPlay_async
 359  */
 360 static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
 361 {
 362     HANDLE handle, ack_event = wma->ack_event;
 363     struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
 364
 365     if (!data) return MCIERR_OUT_OF_MEMORY;
 366
 367     data->wDevID = wma->wDevID;
 368     data->flags = dwFlags;
 369     data->params = *lpParams;
 370
 371     if (!(handle = CreateThread(NULL, 0, MCIAVI_mciPlay_thread, data, 0, NULL)))
 372     {
 373         WARN("Couldn't create thread for async play, playing synchronously\n");
 374         return MCIAVI_mciPlay_thread(data);
 375     }
 376     SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
 377     CloseHandle(handle);
 378     /* wait until the thread starts up, so the app could see a changed status */
 379     WaitForSingleObject(ack_event, INFINITE);
 380     TRACE("Async play has started\n");
 381     return 0;
 382 }
 383
 384 /***************************************************************************
 385  *                              MCIAVI_mciPlay                  [internal]
 386  */
 387 static  DWORD   MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 388 {
 389     WINE_MCIAVI *wma;
 390     DWORD               frameTime;
 391     DWORD               dwRet;
 392     LPWAVEHDR           waveHdr = NULL;
 393     unsigned            i, nHdr = 0;
 394     DWORD               dwFromFrame, dwToFrame;
 395     DWORD               numEvents = 1;
 396     HANDLE              events[2];
 397
 398     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 399
 400     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 401
 402     wma = MCIAVI_mciGetOpenDev(wDevID);
 403     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 404
 405     EnterCriticalSection(&wma->cs);
 406
 407     if (!wma->hFile)
 408     {
 409         LeaveCriticalSection(&wma->cs);
 410         return MCIERR_FILE_NOT_FOUND;
 411     }
 412     if (!wma->hWndPaint)
 413     {
 414         LeaveCriticalSection(&wma->cs);
 415         return MCIERR_NO_WINDOW;
 416     }
 417
 418     LeaveCriticalSection(&wma->cs);
 419
 420     if (!(dwFlags & MCI_WAIT))
 421         return MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
 422
 423     if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
 424         ShowWindow(wma->hWndPaint, SW_SHOWNA);
 425
 426     EnterCriticalSection(&wma->cs);
 427
 428     dwFromFrame = wma->dwCurrVideoFrame;
 429     dwToFrame = wma->dwPlayableVideoFrames - 1;
 430
 431     if (lpParms && (dwFlags & MCI_FROM)) {
 432         dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
 433     }
 434     if (lpParms && (dwFlags & MCI_TO)) {
 435         dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
 436     }
 437     if (dwToFrame >= wma->dwPlayableVideoFrames)
 438         dwToFrame = wma->dwPlayableVideoFrames - 1;
 439
 440     TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
 441
 442     wma->dwCurrVideoFrame = dwFromFrame;
 443     wma->dwToVideoFrame = dwToFrame;
 444
 445     /* if already playing exit */
 446     if (wma->dwStatus == MCI_MODE_PLAY)
 447     {
 448         LeaveCriticalSection(&wma->cs);
 449         SetEvent(wma->ack_event);
 450         return 0;
 451     }
 452
 453     if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
 454     {
 455         dwRet = 0;
 456         SetEvent(wma->ack_event);
 457         goto mci_play_done;
 458     }
 459
 460     wma->dwStatus = MCI_MODE_PLAY;
 461     /* signal the state change */
 462     SetEvent(wma->ack_event);
 463
 464     if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_DGV_PLAY_REVERSE|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
 465         FIXME("Unsupported flag %08x\n", dwFlags);
 466
 467     /* time is in microseconds, we should convert it to milliseconds */
 468     frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
 469
 470     events[0] = wma->hStopEvent;
 471     if (wma->lpWaveFormat) {
 472        if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
 473         {
 474             /* can't play audio */
 475             HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
 476             wma->lpWaveFormat = NULL;
 477         }
 478        else
 479        {
 480             /* fill the queue with as many wave headers as possible */
 481             MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
 482             events[1] = wma->hEvent;
 483             numEvents = 2;
 484        }
 485     }
 486
 487     while (wma->dwStatus == MCI_MODE_PLAY)
 488     {
 489         HDC hDC;
 490         DWORD tc, delta;
 491         DWORD ret;
 492
 493         tc = GetTickCount();
 494
 495         hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
 496         if (hDC)
 497         {
 498             MCIAVI_PaintFrame(wma, hDC);
 499             ReleaseDC(wma->hWndPaint, hDC);
 500         }
 501
 502         if (wma->lpWaveFormat)
 503             MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
 504
 505         delta = GetTickCount() - tc;
 506         if (delta < frameTime)
 507             delta = frameTime - delta;
 508         else
 509             delta = 0;
 510
 511         LeaveCriticalSection(&wma->cs);
 512         ret = WaitForMultipleObjects(numEvents, events, FALSE, delta);
 513         EnterCriticalSection(&wma->cs);
 514         if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
 515
 516        if (wma->dwCurrVideoFrame < dwToFrame)
 517            wma->dwCurrVideoFrame++;
 518         else
 519             break;
 520     }
 521
 522     if (wma->lpWaveFormat) {
 523        while (wma->dwEventCount != nHdr - 1)
 524         {
 525             LeaveCriticalSection(&wma->cs);
 526             Sleep(100);
 527             EnterCriticalSection(&wma->cs);
 528         }
 529
 530         /* just to get rid of some race conditions between play, stop and pause */
 531         LeaveCriticalSection(&wma->cs);
 532         waveOutReset(wma->hWave);
 533         EnterCriticalSection(&wma->cs);
 534
 535         for (i = 0; i < nHdr; i++)
 536             waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
 537     }
 538
 539     dwRet = 0;
 540
 541     if (wma->lpWaveFormat) {
 542         HeapFree(GetProcessHeap(), 0, waveHdr);
 543
 544         if (wma->hWave) {
 545             LeaveCriticalSection(&wma->cs);
 546             waveOutClose(wma->hWave);
 547             EnterCriticalSection(&wma->cs);
 548             wma->hWave = 0;
 549         }
 550         CloseHandle(wma->hEvent);
 551     }
 552
 553 mci_play_done:
 554     wma->dwStatus = MCI_MODE_STOP;
 555
 556     if (lpParms && (dwFlags & MCI_NOTIFY)) {
 557         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 558         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 559                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 560     }
 561     LeaveCriticalSection(&wma->cs);
 562     return dwRet;
 563 }
 564
 565 /***************************************************************************
 566  *                              MCIAVI_mciRecord                        [internal]
 567  */
 568 static  DWORD   MCIAVI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
 569 {
 570     WINE_MCIAVI *wma;
 571
 572     FIXME("(%04x, %08X, %p) : stub\n", wDevID, dwFlags, lpParms);
 573
 574     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 575
 576     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 577
 578     wma = MCIAVI_mciGetOpenDev(wDevID);
 579     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 580
 581     EnterCriticalSection(&wma->cs);
 582     wma->dwStatus = MCI_MODE_RECORD;
 583     LeaveCriticalSection(&wma->cs);
 584     return 0;
 585 }
 586
 587 /***************************************************************************
 588  *                              MCIAVI_mciStop                  [internal]
 589  */
 590 static  DWORD   MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 591 {
 592     WINE_MCIAVI *wma;
 593     DWORD               dwRet = 0;
 594
 595     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 596
 597     wma = MCIAVI_mciGetOpenDev(wDevID);
 598     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 599
 600     EnterCriticalSection(&wma->cs);
 601
 602     TRACE("current status %04x\n", wma->dwStatus);
 603
 604     switch (wma->dwStatus) {
 605     case MCI_MODE_PLAY:
 606     case MCI_MODE_RECORD:
 607         LeaveCriticalSection(&wma->cs);
 608         SetEvent(wma->hStopEvent);
 609         EnterCriticalSection(&wma->cs);
 610         /* fall through */
 611     case MCI_MODE_PAUSE:
 612         /* Since our wave notification callback takes the lock,
 613          * we must release it before resetting the device */
 614         LeaveCriticalSection(&wma->cs);
 615         dwRet = waveOutReset(wma->hWave);
 616         EnterCriticalSection(&wma->cs);
 617         /* fall through */
 618     default:
 619         do /* one more chance for an async thread to finish */
 620         {
 621             LeaveCriticalSection(&wma->cs);
 622             Sleep(10);
 623             EnterCriticalSection(&wma->cs);
 624         } while (wma->dwStatus != MCI_MODE_STOP);
 625
 626         break;
 627
 628     case MCI_MODE_NOT_READY:
 629         break;
 630     }
 631
 632     if ((dwFlags & MCI_NOTIFY) && lpParms) {
 633         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 634                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 635     }
 636     LeaveCriticalSection(&wma->cs);
 637     return dwRet;
 638 }
 639
 640 /***************************************************************************
 641  *                              MCIAVI_mciPause                 [internal]
 642  */
 643 static  DWORD   MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 644 {
 645     WINE_MCIAVI *wma;
 646
 647     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 648
 649     wma = MCIAVI_mciGetOpenDev(wDevID);
 650     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 651
 652     EnterCriticalSection(&wma->cs);
 653
 654     if (wma->dwStatus == MCI_MODE_PLAY)
 655         wma->dwStatus = MCI_MODE_PAUSE;
 656
 657     if (wma->lpWaveFormat) {
 658         LeaveCriticalSection(&wma->cs);
 659         return waveOutPause(wma->hWave);
 660     }
 661
 662     LeaveCriticalSection(&wma->cs);
 663     return 0;
 664 }
 665
 666 /***************************************************************************
 667  *                              MCIAVI_mciResume                        [internal]
 668  */
 669 static  DWORD   MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 670 {
 671     WINE_MCIAVI *wma;
 672
 673     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 674
 675     wma = MCIAVI_mciGetOpenDev(wDevID);
 676     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 677
 678     EnterCriticalSection(&wma->cs);
 679
 680     if (wma->dwStatus == MCI_MODE_PAUSE)
 681         wma->dwStatus = MCI_MODE_PLAY;
 682
 683     if (wma->lpWaveFormat) {
 684         LeaveCriticalSection(&wma->cs);
 685         return waveOutRestart(wma->hWave);
 686     }
 687
 688     LeaveCriticalSection(&wma->cs);
 689     return 0;
 690 }
 691
 692 /***************************************************************************
 693  *                              MCIAVI_mciSeek                  [internal]
 694  */
 695 static  DWORD   MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 696 {
 697     WINE_MCIAVI *wma;
 698
 699     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
 700
 701     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 702
 703     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 704
 705     wma = MCIAVI_mciGetOpenDev(wDevID);
 706     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 707
 708     EnterCriticalSection(&wma->cs);
 709
 710     if (dwFlags & MCI_SEEK_TO_START) {
 711         wma->dwCurrVideoFrame = 0;
 712     } else if (dwFlags & MCI_SEEK_TO_END) {
 713         wma->dwCurrVideoFrame = wma->dwPlayableVideoFrames - 1;
 714     } else if (dwFlags & MCI_TO) {
 715         if (lpParms->dwTo > wma->dwPlayableVideoFrames - 1)
 716             lpParms->dwTo = wma->dwPlayableVideoFrames - 1;
 717         wma->dwCurrVideoFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
 718     } else {
 719         WARN("dwFlag doesn't tell where to seek to...\n");
 720         LeaveCriticalSection(&wma->cs);
 721         return MCIERR_MISSING_PARAMETER;
 722     }
 723
 724     TRACE("Seeking to frame=%u bytes\n", wma->dwCurrVideoFrame);
 725
 726     if (dwFlags & MCI_NOTIFY) {
 727         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 728                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 729     }
 730     LeaveCriticalSection(&wma->cs);
 731     return 0;
 732 }
 733
 734 /*****************************************************************************
 735  *                              MCIAVI_mciLoad                  [internal]
 736  */
 737 static DWORD    MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
 738 {
 739     WINE_MCIAVI *wma;
 740
 741     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 742
 743     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 744
 745     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 746
 747     wma = MCIAVI_mciGetOpenDev(wDevID);
 748     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 749
 750     return 0;
 751 }
 752
 753 /******************************************************************************
 754  *                              MCIAVI_mciSave                  [internal]
 755  */
 756 static  DWORD   MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSW lpParms)
 757 {
 758     WINE_MCIAVI *wma;
 759
 760     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 761
 762     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 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 0;
 770 }
 771
 772 /******************************************************************************
 773  *                              MCIAVI_mciFreeze                        [internal]
 774  */
 775 static  DWORD   MCIAVI_mciFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 776 {
 777     WINE_MCIAVI *wma;
 778
 779     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 780
 781     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 782
 783     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 784
 785     wma = MCIAVI_mciGetOpenDev(wDevID);
 786     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 787
 788     return 0;
 789 }
 790
 791 /******************************************************************************
 792  *                              MCIAVI_mciRealize                       [internal]
 793  */
 794 static  DWORD   MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 795 {
 796     WINE_MCIAVI *wma;
 797
 798     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 799
 800     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 801
 802     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 803
 804     wma = MCIAVI_mciGetOpenDev(wDevID);
 805     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 806
 807     return 0;
 808 }
 809
 810 /******************************************************************************
 811  *                              MCIAVI_mciUnFreeze                      [internal]
 812  */
 813 static  DWORD   MCIAVI_mciUnFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 814 {
 815     WINE_MCIAVI *wma;
 816
 817     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 818
 819     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 820
 821     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 822
 823     wma = MCIAVI_mciGetOpenDev(wDevID);
 824     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 825
 826     return 0;
 827 }
 828
 829 /******************************************************************************
 830  *                              MCIAVI_mciUpdate                        [internal]
 831  */
 832 static  DWORD   MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
 833 {
 834     WINE_MCIAVI *wma;
 835
 836     TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
 837
 838     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 839
 840     wma = MCIAVI_mciGetOpenDev(wDevID);
 841     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 842
 843     EnterCriticalSection(&wma->cs);
 844
 845     if (dwFlags & MCI_DGV_UPDATE_HDC)
 846         MCIAVI_PaintFrame(wma, lpParms->hDC);
 847
 848     LeaveCriticalSection(&wma->cs);
 849
 850     return 0;
 851 }
 852
 853 /******************************************************************************
 854  *                              MCIAVI_mciStep                  [internal]
 855  */
 856 static  DWORD   MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
 857 {
 858     WINE_MCIAVI *wma;
 859
 860     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 861
 862     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 863
 864     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 865
 866     wma = MCIAVI_mciGetOpenDev(wDevID);
 867     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 868
 869     return 0;
 870 }
 871
 872 /******************************************************************************
 873  *                              MCIAVI_mciCopy                  [internal]
 874  */
 875 static  DWORD   MCIAVI_mciCopy(UINT wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
 876 {
 877     WINE_MCIAVI *wma;
 878
 879     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 880
 881     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 882
 883     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 884
 885     wma = MCIAVI_mciGetOpenDev(wDevID);
 886     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 887
 888     return 0;
 889 }
 890
 891 /******************************************************************************
 892  *                              MCIAVI_mciCut                   [internal]
 893  */
 894 static  DWORD   MCIAVI_mciCut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
 895 {
 896     WINE_MCIAVI *wma;
 897
 898     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 899
 900     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 901
 902     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 903
 904     wma = MCIAVI_mciGetOpenDev(wDevID);
 905     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 906
 907     return 0;
 908 }
 909
 910 /******************************************************************************
 911  *                              MCIAVI_mciDelete                        [internal]
 912  */
 913 static  DWORD   MCIAVI_mciDelete(UINT wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
 914 {
 915     WINE_MCIAVI *wma;
 916
 917     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 918
 919     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 920
 921     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 922
 923     wma = MCIAVI_mciGetOpenDev(wDevID);
 924     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 925
 926     return 0;
 927 }
 928
 929 /******************************************************************************
 930  *                              MCIAVI_mciPaste                 [internal]
 931  */
 932 static  DWORD   MCIAVI_mciPaste(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
 933 {
 934     WINE_MCIAVI *wma;
 935
 936     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 937
 938     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 939
 940     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 941
 942     wma = MCIAVI_mciGetOpenDev(wDevID);
 943     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 944
 945     return 0;
 946 }
 947
 948 /******************************************************************************
 949  *                              MCIAVI_mciCue                   [internal]
 950  */
 951 static  DWORD   MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
 952 {
 953     WINE_MCIAVI *wma;
 954
 955     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 956
 957     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 958
 959     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 960
 961     wma = MCIAVI_mciGetOpenDev(wDevID);
 962     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 963
 964     return 0;
 965 }
 966
 967 /******************************************************************************
 968  *                              MCIAVI_mciCapture                       [internal]
 969  */
 970 static  DWORD   MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSW lpParms)
 971 {
 972     WINE_MCIAVI *wma;
 973
 974     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 975
 976     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 977
 978     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 979
 980     wma = MCIAVI_mciGetOpenDev(wDevID);
 981     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 982
 983     return 0;
 984 }
 985
 986 /******************************************************************************
 987  *                              MCIAVI_mciMonitor                       [internal]
 988  */
 989 static  DWORD   MCIAVI_mciMonitor(UINT wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
 990 {
 991     WINE_MCIAVI *wma;
 992
 993     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
 994
 995     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
 996
 997     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 998
 999     wma = MCIAVI_mciGetOpenDev(wDevID);
1000     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1001
1002     return 0;
1003 }
1004
1005 /******************************************************************************
1006  *                              MCIAVI_mciReserve                       [internal]
1007  */
1008 static  DWORD   MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSW lpParms)
1009 {
1010     WINE_MCIAVI *wma;
1011
1012     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1013
1014     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1015
1016     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1017
1018     wma = MCIAVI_mciGetOpenDev(wDevID);
1019     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1020
1021     return 0;
1022 }
1023
1024 /******************************************************************************
1025  *                              MCIAVI_mciSetAudio                      [internal]
1026  */
1027 static  DWORD   MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
1028 {
1029     WINE_MCIAVI *wma;
1030
1031     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1032
1033     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1034
1035     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1036
1037     wma = MCIAVI_mciGetOpenDev(wDevID);
1038     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1039
1040     return 0;
1041 }
1042
1043 /******************************************************************************
1044  *                              MCIAVI_mciSignal                        [internal]
1045  */
1046 static  DWORD   MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
1047 {
1048     WINE_MCIAVI *wma;
1049
1050     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1051
1052     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1053
1054     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1055
1056     wma = MCIAVI_mciGetOpenDev(wDevID);
1057     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1058
1059     return 0;
1060 }
1061
1062 /******************************************************************************
1063  *                              MCIAVI_mciSetVideo                      [internal]
1064  */
1065 static  DWORD   MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
1066 {
1067     WINE_MCIAVI *wma;
1068
1069     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1070
1071     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1072
1073     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1074
1075     wma = MCIAVI_mciGetOpenDev(wDevID);
1076     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1077
1078     return 0;
1079 }
1080
1081 /******************************************************************************
1082  *                              MCIAVI_mciQuality                       [internal]
1083  */
1084 static  DWORD   MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSW lpParms)
1085 {
1086     WINE_MCIAVI *wma;
1087
1088     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1089
1090     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1091
1092     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1093
1094     wma = MCIAVI_mciGetOpenDev(wDevID);
1095     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1096
1097     return 0;
1098 }
1099
1100 /******************************************************************************
1101  *                              MCIAVI_mciList                  [internal]
1102  */
1103 static  DWORD   MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSW lpParms)
1104 {
1105     WINE_MCIAVI *wma;
1106
1107     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1108
1109     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1110
1111     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1112
1113     wma = MCIAVI_mciGetOpenDev(wDevID);
1114     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1115
1116     return 0;
1117 }
1118
1119 /******************************************************************************
1120  *                              MCIAVI_mciUndo                  [internal]
1121  */
1122 static  DWORD   MCIAVI_mciUndo(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1123 {
1124     WINE_MCIAVI *wma;
1125
1126     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1127
1128     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1129
1130     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1131
1132     wma = MCIAVI_mciGetOpenDev(wDevID);
1133     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1134
1135     return 0;
1136 }
1137
1138 /******************************************************************************
1139  *                              MCIAVI_mciConfigure                     [internal]
1140  */
1141 static  DWORD   MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1142 {
1143     WINE_MCIAVI *wma;
1144
1145     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1146
1147     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1148
1149     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1150
1151     wma = MCIAVI_mciGetOpenDev(wDevID);
1152     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1153
1154     return 0;
1155 }
1156
1157 /******************************************************************************
1158  *                              MCIAVI_mciRestore                       [internal]
1159  */
1160 static  DWORD   MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSW lpParms)
1161 {
1162     WINE_MCIAVI *wma;
1163
1164     FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
1165
1166     MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1167
1168     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
1169
1170     wma = MCIAVI_mciGetOpenDev(wDevID);
1171     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
1172
1173     return 0;
1174 }
1175
1176 /*======================================================================*
1177  *                          MCI AVI entry points                        *
1178  *======================================================================*/
1179
1180 /**************************************************************************
1181  *                              DriverProc (MCIAVI.@)
1182  */
1183 LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1184                                    LPARAM dwParam1, LPARAM dwParam2)
1185 {
1186     TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1187           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1188
1189     switch (wMsg) {
1190     case DRV_LOAD:              return 1;
1191     case DRV_FREE:              return 1;
1192     case DRV_OPEN:              return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1193     case DRV_CLOSE:             return MCIAVI_drvClose(dwDevID);
1194     case DRV_ENABLE:            return 1;
1195     case DRV_DISABLE:           return 1;
1196     case DRV_QUERYCONFIGURE:    return 1;
1197     case DRV_CONFIGURE:         return MCIAVI_drvConfigure(dwDevID);
1198     case DRV_INSTALL:           return DRVCNF_RESTART;
1199     case DRV_REMOVE:            return DRVCNF_RESTART;
1200     }
1201
1202     /* session instance */
1203     if (dwDevID == 0xFFFFFFFF) return 1;
1204
1205     switch (wMsg) {
1206     case MCI_OPEN_DRIVER:       return MCIAVI_mciOpen      (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW)     dwParam2);
1207     case MCI_CLOSE_DRIVER:      return MCIAVI_mciClose     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1208     case MCI_PLAY:              return MCIAVI_mciPlay      (dwDevID, dwParam1, (LPMCI_PLAY_PARMS)          dwParam2);
1209     case MCI_RECORD:            return MCIAVI_mciRecord    (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS)    dwParam2);
1210     case MCI_STOP:              return MCIAVI_mciStop      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1211     case MCI_SET:               return MCIAVI_mciSet       (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS)       dwParam2);
1212     case MCI_PAUSE:             return MCIAVI_mciPause     (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1213     case MCI_RESUME:            return MCIAVI_mciResume    (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1214     case MCI_STATUS:            return MCIAVI_mciStatus    (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW)   dwParam2);
1215     case MCI_GETDEVCAPS:        return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)    dwParam2);
1216     case MCI_INFO:              return MCIAVI_mciInfo      (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW)     dwParam2);
1217     case MCI_SEEK:              return MCIAVI_mciSeek      (dwDevID, dwParam1, (LPMCI_SEEK_PARMS)          dwParam2);
1218     case MCI_PUT:               return MCIAVI_mciPut       (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS)       dwParam2);
1219     case MCI_WINDOW:            return MCIAVI_mciWindow    (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)   dwParam2);
1220     case MCI_LOAD:              return MCIAVI_mciLoad      (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW)     dwParam2);
1221     case MCI_SAVE:              return MCIAVI_mciSave      (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSW)     dwParam2);
1222     case MCI_FREEZE:            return MCIAVI_mciFreeze    (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1223     case MCI_REALIZE:           return MCIAVI_mciRealize   (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1224     case MCI_UNFREEZE:          return MCIAVI_mciUnFreeze  (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1225     case MCI_UPDATE:            return MCIAVI_mciUpdate    (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)    dwParam2);
1226     case MCI_WHERE:             return MCIAVI_mciWhere     (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS)      dwParam2);
1227     case MCI_STEP:              return MCIAVI_mciStep      (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS)      dwParam2);
1228     case MCI_COPY:              return MCIAVI_mciCopy      (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS)      dwParam2);
1229     case MCI_CUT:               return MCIAVI_mciCut       (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS)       dwParam2);
1230     case MCI_DELETE:            return MCIAVI_mciDelete    (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS)    dwParam2);
1231     case MCI_PASTE:             return MCIAVI_mciPaste     (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS)     dwParam2);
1232     case MCI_CUE:               return MCIAVI_mciCue       (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS)       dwParam2);
1233         /* Digital Video specific */
1234     case MCI_CAPTURE:           return MCIAVI_mciCapture   (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSW)  dwParam2);
1235     case MCI_MONITOR:           return MCIAVI_mciMonitor   (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS)   dwParam2);
1236     case MCI_RESERVE:           return MCIAVI_mciReserve   (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSW)  dwParam2);
1237     case MCI_SETAUDIO:          return MCIAVI_mciSetAudio  (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1238     case MCI_SIGNAL:            return MCIAVI_mciSignal    (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS)    dwParam2);
1239     case MCI_SETVIDEO:          return MCIAVI_mciSetVideo  (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
1240     case MCI_QUALITY:           return MCIAVI_mciQuality   (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSW)  dwParam2);
1241     case MCI_LIST:              return MCIAVI_mciList      (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSW)     dwParam2);
1242     case MCI_UNDO:              return MCIAVI_mciUndo      (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1243     case MCI_CONFIGURE:         return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)       dwParam2);
1244     case MCI_RESTORE:           return MCIAVI_mciRestore   (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSW)  dwParam2);
1245
1246     case MCI_SPIN:
1247     case MCI_ESCAPE:
1248         WARN("Unsupported command [%u]\n", wMsg);
1249         break;
1250     case MCI_OPEN:
1251     case MCI_CLOSE:
1252         FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1253         break;
1254     default:
1255         TRACE("Sending msg [%u] to default driver proc\n", wMsg);
1256         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1257     }
1258     return MCIERR_UNRECOGNIZED_COMMAND;
1259 }