2 * Digital video MCI Wine Driver
4 * Copyright 1999, 2000 Eric POUECH
5 * Copyright 2003 Dmitry Timoshkov
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.
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.
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
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
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
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
39 #include "private_mciavi.h"
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
45 static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
47 /*======================================================================*
48 * MCI AVI implementation *
49 *======================================================================*/
51 HINSTANCE MCIAVI_hInstance = 0;
53 /***********************************************************************
56 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
59 case DLL_PROCESS_ATTACH:
60 DisableThreadLibraryCalls(hInstDLL);
61 MCIAVI_hInstance = hInstDLL;
67 /**************************************************************************
68 * MCIAVI_drvOpen [internal]
70 static DWORD MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
73 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
75 TRACE("%s, %p\n", debugstr_w(str), modp);
77 /* session instance */
78 if (!modp) return 0xFFFFFFFF;
80 if (!MCIAVI_RegisterClass()) return 0;
82 wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
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);
96 return modp->wDeviceID;
99 /**************************************************************************
100 * MCIAVI_drvClose [internal]
102 static DWORD MCIAVI_drvClose(DWORD dwDevID)
106 TRACE("%04x\n", dwDevID);
108 /* finish all outstanding things */
109 MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
111 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
114 MCIAVI_UnregisterClass();
116 EnterCriticalSection(&wma->cs);
118 mciSetDriverData(dwDevID, 0);
119 mciFreeCommandResource(wma->wCommandTable);
121 CloseHandle(wma->ack_event);
122 CloseHandle(wma->hStopEvent);
124 LeaveCriticalSection(&wma->cs);
125 wma->cs.DebugInfo->Spare[0] = 0;
126 DeleteCriticalSection(&wma->cs);
128 HeapFree(GetProcessHeap(), 0, wma);
131 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
134 /**************************************************************************
135 * MCIAVI_drvConfigure [internal]
137 static DWORD MCIAVI_drvConfigure(DWORD dwDevID)
141 TRACE("%04x\n", dwDevID);
143 MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
145 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
148 MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
154 /**************************************************************************
155 * MCIAVI_mciGetOpenDev [internal]
157 WINE_MCIAVI* MCIAVI_mciGetOpenDev(UINT wDevID)
159 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
161 if (wma == NULL || wma->nUseCount == 0) {
162 WARN("Invalid wDevID=%u\n", wDevID);
168 static void MCIAVI_CleanUp(WINE_MCIAVI* wma)
170 /* to prevent handling in WindowProc */
171 wma->dwStatus = MCI_MODE_NOT_READY;
173 mmioClose(wma->hFile, 0);
176 HeapFree(GetProcessHeap(), 0, wma->lpFileName);
177 wma->lpFileName = NULL;
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);
185 HeapFree(GetProcessHeap(), 0, wma->inbih);
187 HeapFree(GetProcessHeap(), 0, wma->outbih);
189 HeapFree(GetProcessHeap(), 0, wma->indata);
191 HeapFree(GetProcessHeap(), 0, wma->outdata);
193 if (wma->hbmFrame) DeleteObject(wma->hbmFrame);
195 if (wma->hWnd) DestroyWindow(wma->hWnd);
198 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
199 wma->lpWaveFormat = 0;
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;
209 /***************************************************************************
210 * MCIAVI_mciOpen [internal]
212 static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
213 LPMCI_DGV_OPEN_PARMSW lpOpenParms)
218 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
220 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
222 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
224 wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
225 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
227 EnterCriticalSection(&wma->cs);
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))
237 LeaveCriticalSection(&wma->cs);
238 return MCIERR_MUST_USE_SHAREABLE;
242 wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
245 wma->dwStatus = MCI_MODE_NOT_READY;
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 ?
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));
257 wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
258 strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
260 wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
261 MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
263 if (wma->hFile == 0) {
264 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
265 dwRet = MCIERR_FILE_NOT_FOUND;
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;
275 FIXME("Don't record yet\n");
276 dwRet = MCIERR_UNSUPPORTED_FUNCTION;
281 TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
283 wma->dwStatus = MCI_MODE_STOP;
284 wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
289 LeaveCriticalSection(&wma->cs);
293 /***************************************************************************
294 * MCIAVI_mciClose [internal]
296 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
301 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
303 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
305 wma = MCIAVI_mciGetOpenDev(wDevID);
306 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
308 EnterCriticalSection(&wma->cs);
310 if (wma->nUseCount == 1) {
311 if (wma->dwStatus != MCI_MODE_STOP)
312 dwRet = MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
315 if ((dwFlags & MCI_NOTIFY) && lpParms) {
316 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
318 MCI_NOTIFY_SUCCESSFUL);
320 LeaveCriticalSection(&wma->cs);
325 LeaveCriticalSection(&wma->cs);
329 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
331 struct MCIAVI_play_data
335 MCI_PLAY_PARMS params;
339 * MCIAVI_mciPlay_thread
341 * FIXME: probably should use a common worker thread created at the driver
342 * load time and queue all async commands to it.
344 static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
346 struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
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);
353 HeapFree(GetProcessHeap(), 0, data);
358 * MCIAVI_mciPlay_async
360 static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
362 HANDLE handle, ack_event = wma->ack_event;
363 struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
365 if (!data) return MCIERR_OUT_OF_MEMORY;
367 data->wDevID = wma->wDevID;
368 data->flags = dwFlags;
369 data->params = *lpParams;
371 if (!(handle = CreateThread(NULL, 0, MCIAVI_mciPlay_thread, data, 0, NULL)))
373 WARN("Couldn't create thread for async play, playing synchronously\n");
374 return MCIAVI_mciPlay_thread(data);
376 SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
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");
384 /***************************************************************************
385 * MCIAVI_mciPlay [internal]
387 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
392 LPWAVEHDR waveHdr = NULL;
393 unsigned i, nHdr = 0;
394 DWORD dwFromFrame, dwToFrame;
398 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
400 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
402 wma = MCIAVI_mciGetOpenDev(wDevID);
403 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
405 EnterCriticalSection(&wma->cs);
409 LeaveCriticalSection(&wma->cs);
410 return MCIERR_FILE_NOT_FOUND;
414 LeaveCriticalSection(&wma->cs);
415 return MCIERR_NO_WINDOW;
418 LeaveCriticalSection(&wma->cs);
420 if (!(dwFlags & MCI_WAIT))
421 return MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
423 if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
424 ShowWindow(wma->hWndPaint, SW_SHOWNA);
426 EnterCriticalSection(&wma->cs);
428 dwFromFrame = wma->dwCurrVideoFrame;
429 dwToFrame = wma->dwPlayableVideoFrames - 1;
431 if (lpParms && (dwFlags & MCI_FROM)) {
432 dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
434 if (lpParms && (dwFlags & MCI_TO)) {
435 dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
437 if (dwToFrame >= wma->dwPlayableVideoFrames)
438 dwToFrame = wma->dwPlayableVideoFrames - 1;
440 TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
442 wma->dwCurrVideoFrame = dwFromFrame;
443 wma->dwToVideoFrame = dwToFrame;
445 /* if already playing exit */
446 if (wma->dwStatus == MCI_MODE_PLAY)
448 LeaveCriticalSection(&wma->cs);
449 SetEvent(wma->ack_event);
453 if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
456 SetEvent(wma->ack_event);
460 wma->dwStatus = MCI_MODE_PLAY;
461 /* signal the state change */
462 SetEvent(wma->ack_event);
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);
467 /* time is in microseconds, we should convert it to milliseconds */
468 frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
470 events[0] = wma->hStopEvent;
471 if (wma->lpWaveFormat) {
472 if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
474 /* can't play audio */
475 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
476 wma->lpWaveFormat = NULL;
480 /* fill the queue with as many wave headers as possible */
481 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
482 events[1] = wma->hEvent;
487 while (wma->dwStatus == MCI_MODE_PLAY)
495 hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
498 MCIAVI_PaintFrame(wma, hDC);
499 ReleaseDC(wma->hWndPaint, hDC);
502 if (wma->lpWaveFormat)
503 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
505 delta = GetTickCount() - tc;
506 if (delta < frameTime)
507 delta = frameTime - delta;
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;
516 if (wma->dwCurrVideoFrame < dwToFrame)
517 wma->dwCurrVideoFrame++;
522 if (wma->lpWaveFormat) {
523 while (wma->dwEventCount != nHdr - 1)
525 LeaveCriticalSection(&wma->cs);
527 EnterCriticalSection(&wma->cs);
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);
535 for (i = 0; i < nHdr; i++)
536 waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
541 if (wma->lpWaveFormat) {
542 HeapFree(GetProcessHeap(), 0, waveHdr);
545 LeaveCriticalSection(&wma->cs);
546 waveOutClose(wma->hWave);
547 EnterCriticalSection(&wma->cs);
550 CloseHandle(wma->hEvent);
554 wma->dwStatus = MCI_MODE_STOP;
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);
561 LeaveCriticalSection(&wma->cs);
565 /***************************************************************************
566 * MCIAVI_mciStop [internal]
568 static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
573 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
575 wma = MCIAVI_mciGetOpenDev(wDevID);
576 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
578 EnterCriticalSection(&wma->cs);
580 TRACE("current status %04x\n", wma->dwStatus);
582 switch (wma->dwStatus) {
584 case MCI_MODE_RECORD:
585 LeaveCriticalSection(&wma->cs);
586 SetEvent(wma->hStopEvent);
587 EnterCriticalSection(&wma->cs);
590 /* Since our wave notification callback takes the lock,
591 * we must release it before resetting the device */
592 LeaveCriticalSection(&wma->cs);
593 dwRet = waveOutReset(wma->hWave);
594 EnterCriticalSection(&wma->cs);
597 do /* one more chance for an async thread to finish */
599 LeaveCriticalSection(&wma->cs);
601 EnterCriticalSection(&wma->cs);
602 } while (wma->dwStatus != MCI_MODE_STOP);
606 case MCI_MODE_NOT_READY:
610 if ((dwFlags & MCI_NOTIFY) && lpParms) {
611 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
612 wDevID, MCI_NOTIFY_SUCCESSFUL);
614 LeaveCriticalSection(&wma->cs);
618 /***************************************************************************
619 * MCIAVI_mciPause [internal]
621 static DWORD MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
625 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
627 wma = MCIAVI_mciGetOpenDev(wDevID);
628 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
630 EnterCriticalSection(&wma->cs);
632 if (wma->dwStatus == MCI_MODE_PLAY)
633 wma->dwStatus = MCI_MODE_PAUSE;
635 if (wma->lpWaveFormat) {
636 LeaveCriticalSection(&wma->cs);
637 return waveOutPause(wma->hWave);
640 LeaveCriticalSection(&wma->cs);
644 /***************************************************************************
645 * MCIAVI_mciResume [internal]
647 static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
651 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
653 wma = MCIAVI_mciGetOpenDev(wDevID);
654 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
656 EnterCriticalSection(&wma->cs);
658 if (wma->dwStatus == MCI_MODE_PAUSE)
659 wma->dwStatus = MCI_MODE_PLAY;
661 if (wma->lpWaveFormat) {
662 LeaveCriticalSection(&wma->cs);
663 return waveOutRestart(wma->hWave);
666 LeaveCriticalSection(&wma->cs);
670 /***************************************************************************
671 * MCIAVI_mciSeek [internal]
673 static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
677 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
679 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
681 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
683 wma = MCIAVI_mciGetOpenDev(wDevID);
684 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
686 EnterCriticalSection(&wma->cs);
688 if (dwFlags & MCI_SEEK_TO_START) {
689 wma->dwCurrVideoFrame = 0;
690 } else if (dwFlags & MCI_SEEK_TO_END) {
691 wma->dwCurrVideoFrame = wma->dwPlayableVideoFrames - 1;
692 } else if (dwFlags & MCI_TO) {
693 if (lpParms->dwTo > wma->dwPlayableVideoFrames - 1)
694 lpParms->dwTo = wma->dwPlayableVideoFrames - 1;
695 wma->dwCurrVideoFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
697 WARN("dwFlag doesn't tell where to seek to...\n");
698 LeaveCriticalSection(&wma->cs);
699 return MCIERR_MISSING_PARAMETER;
702 TRACE("Seeking to frame=%u bytes\n", wma->dwCurrVideoFrame);
704 if (dwFlags & MCI_NOTIFY) {
705 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
706 wDevID, MCI_NOTIFY_SUCCESSFUL);
708 LeaveCriticalSection(&wma->cs);
712 /*****************************************************************************
713 * MCIAVI_mciLoad [internal]
715 static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
719 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
721 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
723 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
725 wma = MCIAVI_mciGetOpenDev(wDevID);
726 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
731 /******************************************************************************
732 * MCIAVI_mciRealize [internal]
734 static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
738 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
740 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
742 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
744 wma = MCIAVI_mciGetOpenDev(wDevID);
745 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
750 /******************************************************************************
751 * MCIAVI_mciUpdate [internal]
753 static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
757 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
759 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
761 wma = MCIAVI_mciGetOpenDev(wDevID);
762 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
764 EnterCriticalSection(&wma->cs);
766 if (dwFlags & MCI_DGV_UPDATE_HDC)
767 MCIAVI_PaintFrame(wma, lpParms->hDC);
769 LeaveCriticalSection(&wma->cs);
774 /******************************************************************************
775 * MCIAVI_mciStep [internal]
777 static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
781 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
783 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
785 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
787 wma = MCIAVI_mciGetOpenDev(wDevID);
788 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
793 /******************************************************************************
794 * MCIAVI_mciCue [internal]
796 static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
800 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
802 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
804 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
806 wma = MCIAVI_mciGetOpenDev(wDevID);
807 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
812 /******************************************************************************
813 * MCIAVI_mciSetAudio [internal]
815 static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
819 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
821 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
823 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
825 wma = MCIAVI_mciGetOpenDev(wDevID);
826 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
831 /******************************************************************************
832 * MCIAVI_mciSignal [internal]
834 static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
838 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
840 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
842 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
844 wma = MCIAVI_mciGetOpenDev(wDevID);
845 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
850 /******************************************************************************
851 * MCIAVI_mciSetVideo [internal]
853 static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
857 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
859 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
861 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
863 wma = MCIAVI_mciGetOpenDev(wDevID);
864 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
869 /******************************************************************************
870 * MCIAVI_mciConfigure [internal]
872 static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
876 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
878 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
880 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
882 wma = MCIAVI_mciGetOpenDev(wDevID);
883 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
888 /*======================================================================*
889 * MCI AVI entry points *
890 *======================================================================*/
892 /**************************************************************************
893 * DriverProc (MCIAVI.@)
895 LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
896 LPARAM dwParam1, LPARAM dwParam2)
898 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
899 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
902 case DRV_LOAD: return 1;
903 case DRV_FREE: return 1;
904 case DRV_OPEN: return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
905 case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
906 case DRV_ENABLE: return 1;
907 case DRV_DISABLE: return 1;
908 case DRV_QUERYCONFIGURE: return 1;
909 case DRV_CONFIGURE: return MCIAVI_drvConfigure(dwDevID);
910 case DRV_INSTALL: return DRVCNF_RESTART;
911 case DRV_REMOVE: return DRVCNF_RESTART;
914 /* session instance */
915 if (dwDevID == 0xFFFFFFFF) return 1;
918 case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
919 case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
920 case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
921 case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
922 case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
923 case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
924 case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
925 case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
926 case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
927 case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW) dwParam2);
928 case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
929 case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
930 case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
931 case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
932 case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
933 case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
934 case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
935 case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
936 case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
937 /* Digital Video specific */
938 case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
939 case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
940 case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
941 case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
943 /* no editing, recording, saving, locking without inputs */
959 TRACE("Unsupported function [0x%x] flags=%08x\n", wMsg, (DWORD)dwParam1);
960 return MCIERR_UNSUPPORTED_FUNCTION;
963 WARN("Unsupported command [0x%x] %08x\n", wMsg, (DWORD)dwParam1);
967 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
970 TRACE("Sending msg [%u] to default driver proc\n", wMsg);
971 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
973 return MCIERR_UNRECOGNIZED_COMMAND;