?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Define new propsheet messages.
[wine/multimedia.git] / dlls / winmm / mciavi / mciavi.c
blob382b483b6ae98207bda40bff187ebe89d599d765
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * Digital video MCI Wine Driver
5 *
6 * Copyright 1999, 2000 Eric POUECH
7 * Copyright 2003 Dmitry Timoshkov
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 /* TODO list :
25 * - handling of palettes
26 * - recording (which input devices ?), a cam recorder ?
27 * - lots of messages still need to be handled (cf FIXME)
28 * - synchronization between audio and video (especially for interleaved
29 * files)
30 * - robustness when reading file can be enhanced
31 * - better move the AVI handling part to avifile DLL and make use of it
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
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 <string.h>
41 #include "private_mciavi.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
45
46 static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS);
47
48 /* ===================================================================
49 * ===================================================================
50 * FIXME: should be using the new mmThreadXXXX functions from WINMM
51 * instead of those
52 * it would require to add a wine internal flag to mmThreadCreate
53 * in order to pass a 32 bit function instead of a 16 bit one
54 * ===================================================================
55 * =================================================================== */
56
57 struct SCA {
58 MCIDEVICEID wDevID;
59 UINT wMsg;
60 DWORD_PTR dwParam1;
61 DWORD_PTR dwParam2;
62 };
63
64 /**************************************************************************
65 * MCI_SCAStarter [internal]
66 */
67 static DWORD CALLBACK MCI_SCAStarter(LPVOID arg)
68 {
69 struct SCA* sca = (struct SCA*)arg;
70 DWORD ret;
71
72 TRACE("In thread before async command (%08x,%04x,%08lx,%08lx)\n",
73 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
74 ret = mciSendCommandA(sca->wDevID, sca->wMsg, sca->dwParam1 | MCI_WAIT, sca->dwParam2);
75 TRACE("In thread after async command (%08x,%04x,%08lx,%08lx)\n",
76 sca->wDevID, sca->wMsg, sca->dwParam1, sca->dwParam2);
77 HeapFree(GetProcessHeap(), 0, sca);
78 return ret;
79 }
80
81 /**************************************************************************
82 * MCI_SendCommandAsync [internal]
83 */
84 static DWORD MCI_SendCommandAsync(UINT wDevID, UINT wMsg, DWORD dwParam1,
85 DWORD_PTR dwParam2, UINT size)
86 {
87 HANDLE handle;
88 struct SCA* sca = HeapAlloc(GetProcessHeap(), 0, sizeof(struct SCA) + size);
89
90 if (sca == 0)
91 return MCIERR_OUT_OF_MEMORY;
92
93 sca->wDevID = wDevID;
94 sca->wMsg = wMsg;
95 sca->dwParam1 = dwParam1;
96
97 if (size && dwParam2) {
98 sca->dwParam2 = (DWORD_PTR)sca + sizeof(struct SCA);
99 /* copy structure passed by program in dwParam2 to be sure
100 * we can still use it whatever the program does
101 */
102 memcpy((LPVOID)sca->dwParam2, (LPVOID)dwParam2, size);
103 } else {
104 sca->dwParam2 = dwParam2;
105 }
106
107 if ((handle = CreateThread(NULL, 0, MCI_SCAStarter, sca, 0, NULL)) == 0) {
108 WARN("Couldn't allocate thread for async command handling, sending synchronously\n");
109 return MCI_SCAStarter(&sca);
110 }
111 CloseHandle(handle);
112 return 0;
113 }
114
115 /*======================================================================*
116 * MCI AVI implemantation *
117 *======================================================================*/
118
119 HINSTANCE MCIAVI_hInstance = 0;
120
121 /***********************************************************************
122 * DllMain (MCIAVI.0)
123 */
124 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
125 {
126 switch (fdwReason) {
127 case DLL_PROCESS_ATTACH:
128 DisableThreadLibraryCalls(hInstDLL);
129 MCIAVI_hInstance = hInstDLL;
130 break;
131 }
132 return TRUE;
133 }
134
135 /**************************************************************************
136 * MCIAVI_drvOpen [internal]
137 */
138 static DWORD MCIAVI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
139 {
140 WINE_MCIAVI* wma;
141 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
142
143 TRACE("%s, %p\n", debugstr_a(str), modp);
144
145 /* session instance */
146 if (!modp) return 0xFFFFFFFF;
147
148 if (!MCIAVI_RegisterClass()) return 0;
149
150 wma = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
151 if (!wma)
152 return 0;
153
154 InitializeCriticalSection(&wma->cs);
155 wma->hStopEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
156 wma->wDevID = modp->wDeviceID;
157 wma->wCommandTable = mciLoadCommandResource(MCIAVI_hInstance, mciAviWStr, 0);
158 modp->wCustomCommandTable = wma->wCommandTable;
159 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
160 mciSetDriverData(wma->wDevID, (DWORD)wma);
161
162 return modp->wDeviceID;
163 }
164
165 /**************************************************************************
166 * MCIAVI_drvClose [internal]
167 */
168 static DWORD MCIAVI_drvClose(DWORD dwDevID)
169 {
170 WINE_MCIAVI *wma;
171
172 TRACE("%04lx\n", dwDevID);
173
174 /* finish all outstanding things */
175 MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
176
177 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
178
179 if (wma) {
180 MCIAVI_UnregisterClass();
181
182 EnterCriticalSection(&wma->cs);
183
184 mciSetDriverData(dwDevID, 0);
185 mciFreeCommandResource(wma->wCommandTable);
186
187 CloseHandle(wma->hStopEvent);
188
189 LeaveCriticalSection(&wma->cs);
190 DeleteCriticalSection(&wma->cs);
191
192 HeapFree(GetProcessHeap(), 0, wma);
193 return 1;
194 }
195 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
196 }
197
198 /**************************************************************************
199 * MCIAVI_drvConfigure [internal]
200 */
201 static DWORD MCIAVI_drvConfigure(DWORD dwDevID)
202 {
203 WINE_MCIAVI *wma;
204
205 TRACE("%04lx\n", dwDevID);
206
207 MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
208
209 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
210
211 if (wma) {
212 MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
213 return 1;
214 }
215 return 0;
216 }
217
218 /**************************************************************************
219 * MCIAVI_mciGetOpenDev [internal]
220 */
221 WINE_MCIAVI* MCIAVI_mciGetOpenDev(UINT wDevID)
222 {
223 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
224
225 if (wma == NULL || wma->nUseCount == 0) {
226 WARN("Invalid wDevID=%u\n", wDevID);
227 return 0;
228 }
229 return wma;
230 }
231
232 static void MCIAVI_CleanUp(WINE_MCIAVI* wma)
233 {
234 /* to prevent handling in WindowProc */
235 wma->dwStatus = MCI_MODE_NOT_READY;
236 if (wma->hFile) {
237 mmioClose(wma->hFile, 0);
238 wma->hFile = 0;
239
240 if (wma->lpFileName) HeapFree(GetProcessHeap(), 0, wma->lpFileName);
241 wma->lpFileName = NULL;
242
243 if (wma->lpVideoIndex) HeapFree(GetProcessHeap(), 0, wma->lpVideoIndex);
244 wma->lpVideoIndex = NULL;
245 if (wma->lpAudioIndex) HeapFree(GetProcessHeap(), 0, wma->lpAudioIndex);
246 wma->lpAudioIndex = NULL;
247 if (wma->hic) ICClose(wma->hic);
248 wma->hic = 0;
249 if (wma->inbih) HeapFree(GetProcessHeap(), 0, wma->inbih);
250 wma->inbih = NULL;
251 if (wma->outbih) HeapFree(GetProcessHeap(), 0, wma->outbih);
252 wma->outbih = NULL;
253 if (wma->indata) HeapFree(GetProcessHeap(), 0, wma->indata);
254 wma->indata = NULL;
255 if (wma->outdata) HeapFree(GetProcessHeap(), 0, wma->outdata);
256 wma->outdata = NULL;
257 if (wma->hbmFrame) DeleteObject(wma->hbmFrame);
258 wma->hbmFrame = 0;
259 if (wma->hWnd) DestroyWindow(wma->hWnd);
260 wma->hWnd = 0;
261
262 if (wma->lpWaveFormat) HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
263 wma->lpWaveFormat = 0;
264
265 memset(&wma->mah, 0, sizeof(wma->mah));
266 memset(&wma->ash_video, 0, sizeof(wma->ash_video));
267 memset(&wma->ash_audio, 0, sizeof(wma->ash_audio));
268 wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
269 wma->dwCachedFrame = -1;
270 }
271 }
272
273 /***************************************************************************
274 * MCIAVI_mciOpen [internal]
275 */
276 static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags,
277 LPMCI_DGV_OPEN_PARMSA lpOpenParms)
278 {
279 WINE_MCIAVI *wma;
280 LRESULT dwRet = 0;
281
282 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpOpenParms);
283
284 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
285
286 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
287
288 wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
289 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
290
291 EnterCriticalSection(&wma->cs);
292
293 if (wma->nUseCount > 0) {
294 /* The driver is already open on this channel */
295 /* If the driver was opened shareable before and this open specifies */
296 /* shareable then increment the use count */
297 if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
298 ++wma->nUseCount;
299 else
300 {
301 LeaveCriticalSection(&wma->cs);
302 return MCIERR_MUST_USE_SHAREABLE;
303 }
304 } else {
305 wma->nUseCount = 1;
306 wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
307 }
308
309 wma->dwStatus = MCI_MODE_NOT_READY;
310
311 if (dwFlags & MCI_OPEN_ELEMENT) {
312 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
313 /* could it be that (DWORD)lpOpenParms->lpstrElementName
314 * contains the hFile value ?
315 */
316 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
317 } else if (strlen(lpOpenParms->lpstrElementName) > 0) {
318 /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
319 TRACE("MCI_OPEN_ELEMENT '%s' !\n", lpOpenParms->lpstrElementName);
320
321 if (lpOpenParms->lpstrElementName && (strlen(lpOpenParms->lpstrElementName) > 0))
322 {
323 wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, strlen(lpOpenParms->lpstrElementName) + 1);
324 strcpy(wma->lpFileName, lpOpenParms->lpstrElementName);
325
326 wma->hFile = mmioOpenA(lpOpenParms->lpstrElementName, NULL,
327 MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ);
328
329 if (wma->hFile == 0) {
330 WARN("can't find file='%s' !\n", lpOpenParms->lpstrElementName);
331 dwRet = MCIERR_FILE_NOT_FOUND;
332 } else {
333 if (!MCIAVI_GetInfo(wma))
334 dwRet = MCIERR_INVALID_FILE;
335 else if (!MCIAVI_OpenVideo(wma))
336 dwRet = MCIERR_CANNOT_LOAD_DRIVER;
337 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
338 dwRet = MCIERR_CREATEWINDOW;
339 }
340 }
341 } else {
342 FIXME("Don't record yet\n");
343 dwRet = MCIERR_UNSUPPORTED_FUNCTION;
344 }
345 }
346
347 if (dwRet == 0) {
348 TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
349
350 wma->dwStatus = MCI_MODE_STOP;
351 wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
352 } else {
353 MCIAVI_CleanUp(wma);
354 }
355
356 LeaveCriticalSection(&wma->cs);
357 return dwRet;
358 }
359
360 /***************************************************************************
361 * MCIAVI_mciClose [internal]
362 */
363 DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
364 {
365 WINE_MCIAVI *wma;
366 DWORD dwRet = 0;
367
368 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
369
370 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
371
372 wma = (WINE_MCIAVI *)MCIAVI_mciGetOpenDev(wDevID);
373 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
374
375 EnterCriticalSection(&wma->cs);
376
377 if (wma->nUseCount == 1) {
378 if (wma->dwStatus != MCI_MODE_STOP)
379 dwRet = MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
380 MCIAVI_CleanUp(wma);
381
382 if ((dwFlags & MCI_NOTIFY) && lpParms) {
383 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
384 wDevID,
385 MCI_NOTIFY_SUCCESSFUL);
386 }
387 LeaveCriticalSection(&wma->cs);
388 return dwRet;
389 }
390 wma->nUseCount--;
391
392 LeaveCriticalSection(&wma->cs);
393 return dwRet;
394 }
395
396 /***************************************************************************
397 * MCIAVI_mciPlay [internal]
398 */
399 static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
400 {
401 WINE_MCIAVI *wma;
402 DWORD tc;
403 DWORD frameTime;
404 DWORD delta;
405 DWORD dwRet;
406 LPWAVEHDR waveHdr = NULL;
407 unsigned i, nHdr = 0;
408 DWORD dwFromFrame, dwToFrame;
409
410 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
411
412 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
413
414 wma = (WINE_MCIAVI *)MCIAVI_mciGetOpenDev(wDevID);
415 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
416
417 EnterCriticalSection(&wma->cs);
418
419 if (!wma->hFile)
420 {
421 LeaveCriticalSection(&wma->cs);
422 return MCIERR_FILE_NOT_FOUND;
423 }
424 if (!wma->hWndPaint)
425 {
426 LeaveCriticalSection(&wma->cs);
427 return MCIERR_NO_WINDOW;
428 }
429
430 LeaveCriticalSection(&wma->cs);
431
432 if (!(dwFlags & MCI_WAIT)) {
433 return MCI_SendCommandAsync(wDevID, MCI_PLAY, dwFlags,
434 (DWORD_PTR)lpParms, sizeof(MCI_PLAY_PARMS));
435 }
436
437 if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE))
438 ShowWindow(wma->hWndPaint, SW_SHOWNA);
439
440 EnterCriticalSection(&wma->cs);
441
442 dwFromFrame = wma->dwCurrVideoFrame;
443 dwToFrame = wma->dwPlayableVideoFrames - 1;
444
445 if (lpParms && (dwFlags & MCI_FROM)) {
446 dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
447 }
448 if (lpParms && (dwFlags & MCI_TO)) {
449 dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
450 }
451 if (dwToFrame >= wma->dwPlayableVideoFrames)
452 dwToFrame = wma->dwPlayableVideoFrames - 1;
453
454 TRACE("Playing from frame=%lu to frame=%lu\n", dwFromFrame, dwToFrame);
455
456 wma->dwCurrVideoFrame = dwFromFrame;
457 wma->dwToVideoFrame = dwToFrame;
458
459 /* if already playing exit */
460 if (wma->dwStatus == MCI_MODE_PLAY)
461 {
462 LeaveCriticalSection(&wma->cs);
463 return 0;
464 }
465
466 if (wma->dwToVideoFrame <= wma->dwCurrVideoFrame)
467 {
468 dwRet = 0;
469 goto mci_play_done;
470 }
471
472 wma->dwStatus = MCI_MODE_PLAY;
473
474 if (dwFlags & (MCI_DGV_PLAY_REPEAT|MCI_DGV_PLAY_REVERSE|MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN))
475 FIXME("Unsupported flag %08lx\n", dwFlags);
476
477 /* time is in microseconds, we should convert it to milliseconds */
478 frameTime = (wma->mah.dwMicroSecPerFrame + 500) / 1000;
479
480 if (wma->lpWaveFormat) {
481 if (MCIAVI_OpenAudio(wma, &nHdr, &waveHdr) != 0)
482 {
483 /* can't play audio */
484 HeapFree(GetProcessHeap(), 0, wma->lpWaveFormat);
485 wma->lpWaveFormat = NULL;
486 }
487 else
488 /* fill the queue with as many wave headers as possible */
489 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
490 }
491
492 while (wma->dwStatus == MCI_MODE_PLAY)
493 {
494 HDC hDC;
495
496 tc = GetTickCount();
497
498 hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
499 if (hDC)
500 {
501 MCIAVI_PaintFrame(wma, hDC);
502 ReleaseDC(wma->hWndPaint, hDC);
503 }
504
505 if (wma->lpWaveFormat) {
506 HANDLE events[2];
507 DWORD ret;
508
509 events[0] = wma->hStopEvent;
510 events[1] = wma->hEvent;
511
512 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
513 delta = GetTickCount() - tc;
514
515 LeaveCriticalSection(&wma->cs);
516 ret = MsgWaitForMultipleObjects(2, events, FALSE,
517 (delta >= frameTime) ? 0 : frameTime - delta, MWMO_INPUTAVAILABLE);
518 EnterCriticalSection(&wma->cs);
519
520 if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
521 }
522
523 delta = GetTickCount() - tc;
524 if (delta < frameTime)
525 {
526 DWORD ret;
527
528 LeaveCriticalSection(&wma->cs);
529 ret = MsgWaitForMultipleObjects(1, &wma->hStopEvent, FALSE, frameTime - delta, MWMO_INPUTAVAILABLE);
530 EnterCriticalSection(&wma->cs);
531 if (ret == WAIT_OBJECT_0) break;
532 }
533
534 if (wma->dwCurrVideoFrame < dwToFrame)
535 wma->dwCurrVideoFrame++;
536 else
537 break;
538 }
539
540 if (wma->lpWaveFormat) {
541 while (wma->dwEventCount != nHdr - 1)
542 {
543 LeaveCriticalSection(&wma->cs);
544 Sleep(100);
545 EnterCriticalSection(&wma->cs);
546 }
547
548 /* just to get rid of some race conditions between play, stop and pause */
549 LeaveCriticalSection(&wma->cs);
550 waveOutReset(wma->hWave);
551 EnterCriticalSection(&wma->cs);
552
553 for (i = 0; i < nHdr; i++)
554 waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
555 }
556
557 dwRet = 0;
558
559 if (wma->lpWaveFormat) {
560 HeapFree(GetProcessHeap(), 0, waveHdr);
561
562 if (wma->hWave) {
563 LeaveCriticalSection(&wma->cs);
564 waveOutClose(wma->hWave);
565 EnterCriticalSection(&wma->cs);
566 wma->hWave = 0;
567 }
568 CloseHandle(wma->hEvent);
569 }
570
571 mci_play_done:
572 wma->dwStatus = MCI_MODE_STOP;
573
574 if (lpParms && (dwFlags & MCI_NOTIFY)) {
575 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
576 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
577 wDevID, MCI_NOTIFY_SUCCESSFUL);
578 }
579 LeaveCriticalSection(&wma->cs);
580 return dwRet;
581 }
582
583 /***************************************************************************
584 * MCIAVI_mciRecord [internal]
585 */
586 static DWORD MCIAVI_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
587 {
588 WINE_MCIAVI *wma;
589
590 FIXME("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
591
592 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
593
594 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
595
596 wma = MCIAVI_mciGetOpenDev(wDevID);
597 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
598
599 EnterCriticalSection(&wma->cs);
600 wma->dwStatus = MCI_MODE_RECORD;
601 LeaveCriticalSection(&wma->cs);
602 return 0;
603 }
604
605 /***************************************************************************
606 * MCIAVI_mciStop [internal]
607 */
608 static DWORD MCIAVI_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
609 {
610 WINE_MCIAVI *wma;
611 DWORD dwRet = 0;
612
613 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
614
615 wma = MCIAVI_mciGetOpenDev(wDevID);
616 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
617
618 EnterCriticalSection(&wma->cs);
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, %08lX, %p)\n", wDevID, dwFlags, lpParms);
664
665 wma = MCIAVI_mciGetOpenDev(wDevID);
666 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
667
668 EnterCriticalSection(&wma->cs);
669
670 if (wma->dwStatus == MCI_MODE_PLAY)
671 wma->dwStatus = MCI_MODE_PAUSE;
672
673 if (wma->lpWaveFormat) {
674 LeaveCriticalSection(&wma->cs);
675 return waveOutPause(wma->hWave);
676 }
677
678 LeaveCriticalSection(&wma->cs);
679 return 0;
680 }
681
682 /***************************************************************************
683 * MCIAVI_mciResume [internal]
684 */
685 static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
686 {
687 WINE_MCIAVI *wma;
688
689 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
690
691 wma = MCIAVI_mciGetOpenDev(wDevID);
692 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
693
694 EnterCriticalSection(&wma->cs);
695
696 if (wma->dwStatus == MCI_MODE_PAUSE)
697 wma->dwStatus = MCI_MODE_PLAY;
698
699 if (wma->lpWaveFormat) {
700 LeaveCriticalSection(&wma->cs);
701 return waveOutRestart(wma->hWave);
702 }
703
704 LeaveCriticalSection(&wma->cs);
705 return 0;
706 }
707
708 /***************************************************************************
709 * MCIAVI_mciSeek [internal]
710 */
711 static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
712 {
713 WINE_MCIAVI *wma;
714
715 TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
716
717 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
718
719 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
720
721 wma = MCIAVI_mciGetOpenDev(wDevID);
722 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
723
724 EnterCriticalSection(&wma->cs);
725
726 if (dwFlags & MCI_SEEK_TO_START) {
727 wma->dwCurrVideoFrame = 0;
728 } else if (dwFlags & MCI_SEEK_TO_END) {
729 wma->dwCurrVideoFrame = wma->dwPlayableVideoFrames - 1;
730 } else if (dwFlags & MCI_TO) {
731 if (lpParms->dwTo > wma->dwPlayableVideoFrames - 1)
732 lpParms->dwTo = wma->dwPlayableVideoFrames - 1;
733 wma->dwCurrVideoFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
734 } else {
735 WARN("dwFlag doesn't tell where to seek to...\n");
736 LeaveCriticalSection(&wma->cs);
737 return MCIERR_MISSING_PARAMETER;
738 }
739
740 TRACE("Seeking to frame=%lu bytes\n", wma->dwCurrVideoFrame);
741
742 if (dwFlags & MCI_NOTIFY) {
743 mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
744 wDevID, MCI_NOTIFY_SUCCESSFUL);
745 }
746 LeaveCriticalSection(&wma->cs);
747 return 0;
748 }
749
750 /*****************************************************************************
751 * MCIAVI_mciLoad [internal]
752 */
753 static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSA lpParms)
754 {
755 WINE_MCIAVI *wma;
756
757 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
758
759 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
760
761 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
762
763 wma = MCIAVI_mciGetOpenDev(wDevID);
764 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
765
766 return 0;
767 }
768
769 /******************************************************************************
770 * MCIAVI_mciSave [internal]
771 */
772 static DWORD MCIAVI_mciSave(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSA lpParms)
773 {
774 WINE_MCIAVI *wma;
775
776 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
777
778 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
779
780 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
781
782 wma = MCIAVI_mciGetOpenDev(wDevID);
783 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
784
785 return 0;
786 }
787
788 /******************************************************************************
789 * MCIAVI_mciFreeze [internal]
790 */
791 static DWORD MCIAVI_mciFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
792 {
793 WINE_MCIAVI *wma;
794
795 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
796
797 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
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
804 return 0;
805 }
806
807 /******************************************************************************
808 * MCIAVI_mciRealize [internal]
809 */
810 static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
811 {
812 WINE_MCIAVI *wma;
813
814 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
815
816 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
817
818 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
819
820 wma = MCIAVI_mciGetOpenDev(wDevID);
821 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
822
823 return 0;
824 }
825
826 /******************************************************************************
827 * MCIAVI_mciUnFreeze [internal]
828 */
829 static DWORD MCIAVI_mciUnFreeze(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
830 {
831 WINE_MCIAVI *wma;
832
833 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
834
835 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
836
837 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
838
839 wma = MCIAVI_mciGetOpenDev(wDevID);
840 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
841
842 return 0;
843 }
844
845 /******************************************************************************
846 * MCIAVI_mciUpdate [internal]
847 */
848 static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
849 {
850 WINE_MCIAVI *wma;
851
852 TRACE("%04x, %08lx, %p\n", wDevID, dwFlags, lpParms);
853
854 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
855
856 wma = MCIAVI_mciGetOpenDev(wDevID);
857 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
858
859 EnterCriticalSection(&wma->cs);
860
861 if (dwFlags & MCI_DGV_UPDATE_HDC)
862 MCIAVI_PaintFrame(wma, lpParms->hDC);
863
864 LeaveCriticalSection(&wma->cs);
865
866 return 0;
867 }
868
869 /******************************************************************************
870 * MCIAVI_mciStep [internal]
871 */
872 static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
873 {
874 WINE_MCIAVI *wma;
875
876 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
877
878 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
879
880 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
881
882 wma = MCIAVI_mciGetOpenDev(wDevID);
883 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
884
885 return 0;
886 }
887
888 /******************************************************************************
889 * MCIAVI_mciCopy [internal]
890 */
891 static DWORD MCIAVI_mciCopy(UINT wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
892 {
893 WINE_MCIAVI *wma;
894
895 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
896
897 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
898
899 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
900
901 wma = MCIAVI_mciGetOpenDev(wDevID);
902 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
903
904 return 0;
905 }
906
907 /******************************************************************************
908 * MCIAVI_mciCut [internal]
909 */
910 static DWORD MCIAVI_mciCut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
911 {
912 WINE_MCIAVI *wma;
913
914 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
915
916 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
917
918 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
919
920 wma = MCIAVI_mciGetOpenDev(wDevID);
921 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
922
923 return 0;
924 }
925
926 /******************************************************************************
927 * MCIAVI_mciDelete [internal]
928 */
929 static DWORD MCIAVI_mciDelete(UINT wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
930 {
931 WINE_MCIAVI *wma;
932
933 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
934
935 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
936
937 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
938
939 wma = MCIAVI_mciGetOpenDev(wDevID);
940 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
941
942 return 0;
943 }
944
945 /******************************************************************************
946 * MCIAVI_mciPaste [internal]
947 */
948 static DWORD MCIAVI_mciPaste(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
949 {
950 WINE_MCIAVI *wma;
951
952 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
953
954 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
955
956 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
957
958 wma = MCIAVI_mciGetOpenDev(wDevID);
959 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
960
961 return 0;
962 }
963
964 /******************************************************************************
965 * MCIAVI_mciCue [internal]
966 */
967 static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
968 {
969 WINE_MCIAVI *wma;
970
971 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
972
973 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
974
975 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
976
977 wma = MCIAVI_mciGetOpenDev(wDevID);
978 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
979
980 return 0;
981 }
982
983 /******************************************************************************
984 * MCIAVI_mciCapture [internal]
985 */
986 static DWORD MCIAVI_mciCapture(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSA lpParms)
987 {
988 WINE_MCIAVI *wma;
989
990 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
991
992 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
993
994 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
995
996 wma = MCIAVI_mciGetOpenDev(wDevID);
997 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
998
999 return 0;
1000 }
1001
1002 /******************************************************************************
1003 * MCIAVI_mciMonitor [internal]
1004 */
1005 static DWORD MCIAVI_mciMonitor(UINT wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
1006 {
1007 WINE_MCIAVI *wma;
1008
1009 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1010
1011 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1012
1013 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1014
1015 wma = MCIAVI_mciGetOpenDev(wDevID);
1016 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1017
1018 return 0;
1019 }
1020
1021 /******************************************************************************
1022 * MCIAVI_mciReserve [internal]
1023 */
1024 static DWORD MCIAVI_mciReserve(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSA lpParms)
1025 {
1026 WINE_MCIAVI *wma;
1027
1028 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1029
1030 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1031
1032 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1033
1034 wma = MCIAVI_mciGetOpenDev(wDevID);
1035 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1036
1037 return 0;
1038 }
1039
1040 /******************************************************************************
1041 * MCIAVI_mciSetAudio [internal]
1042 */
1043 static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSA lpParms)
1044 {
1045 WINE_MCIAVI *wma;
1046
1047 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1048
1049 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1050
1051 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1052
1053 wma = MCIAVI_mciGetOpenDev(wDevID);
1054 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1055
1056 return 0;
1057 }
1058
1059 /******************************************************************************
1060 * MCIAVI_mciSignal [internal]
1061 */
1062 static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
1063 {
1064 WINE_MCIAVI *wma;
1065
1066 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1067
1068 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1069
1070 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1071
1072 wma = MCIAVI_mciGetOpenDev(wDevID);
1073 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1074
1075 return 0;
1076 }
1077
1078 /******************************************************************************
1079 * MCIAVI_mciSetVideo [internal]
1080 */
1081 static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSA lpParms)
1082 {
1083 WINE_MCIAVI *wma;
1084
1085 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1086
1087 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1088
1089 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1090
1091 wma = MCIAVI_mciGetOpenDev(wDevID);
1092 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1093
1094 return 0;
1095 }
1096
1097 /******************************************************************************
1098 * MCIAVI_mciQuality [internal]
1099 */
1100 static DWORD MCIAVI_mciQuality(UINT wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSA lpParms)
1101 {
1102 WINE_MCIAVI *wma;
1103
1104 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1105
1106 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1107
1108 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1109
1110 wma = MCIAVI_mciGetOpenDev(wDevID);
1111 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1112
1113 return 0;
1114 }
1115
1116 /******************************************************************************
1117 * MCIAVI_mciList [internal]
1118 */
1119 static DWORD MCIAVI_mciList(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSA lpParms)
1120 {
1121 WINE_MCIAVI *wma;
1122
1123 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1124
1125 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1126
1127 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1128
1129 wma = MCIAVI_mciGetOpenDev(wDevID);
1130 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1131
1132 return 0;
1133 }
1134
1135 /******************************************************************************
1136 * MCIAVI_mciUndo [internal]
1137 */
1138 static DWORD MCIAVI_mciUndo(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1139 {
1140 WINE_MCIAVI *wma;
1141
1142 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1143
1144 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1145
1146 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1147
1148 wma = MCIAVI_mciGetOpenDev(wDevID);
1149 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1150
1151 return 0;
1152 }
1153
1154 /******************************************************************************
1155 * MCIAVI_mciConfigure [internal]
1156 */
1157 static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
1158 {
1159 WINE_MCIAVI *wma;
1160
1161 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1162
1163 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1164
1165 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1166
1167 wma = MCIAVI_mciGetOpenDev(wDevID);
1168 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1169
1170 return 0;
1171 }
1172
1173 /******************************************************************************
1174 * MCIAVI_mciRestore [internal]
1175 */
1176 static DWORD MCIAVI_mciRestore(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSA lpParms)
1177 {
1178 WINE_MCIAVI *wma;
1179
1180 FIXME("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
1181
1182 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
1183
1184 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
1185
1186 wma = MCIAVI_mciGetOpenDev(wDevID);
1187 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
1188
1189 return 0;
1190 }
1191
1192 /*======================================================================*
1193 * MCI AVI entry points *
1194 *======================================================================*/
1195
1196 /**************************************************************************
1197 * DriverProc (MCIAVI.@)
1198 */
1199 LONG CALLBACK MCIAVI_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
1200 DWORD dwParam1, DWORD dwParam2)
1201 {
1202 TRACE("(%08lX, %p, %08lX, %08lX, %08lX)\n",
1203 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1204
1205 switch (wMsg) {
1206 case DRV_LOAD: return 1;
1207 case DRV_FREE: return 1;
1208 case DRV_OPEN: return MCIAVI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
1209 case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
1210 case DRV_ENABLE: return 1;
1211 case DRV_DISABLE: return 1;
1212 case DRV_QUERYCONFIGURE: return 1;
1213 case DRV_CONFIGURE: return MCIAVI_drvConfigure(dwDevID);
1214 case DRV_INSTALL: return DRVCNF_RESTART;
1215 case DRV_REMOVE: return DRVCNF_RESTART;
1216 }
1217
1218 /* session instance */
1219 if (dwDevID == 0xFFFFFFFF) return 1;
1220
1221 switch (wMsg) {
1222 case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSA) dwParam2);
1223 case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1224 case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1225 case MCI_RECORD: return MCIAVI_mciRecord (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS) dwParam2);
1226 case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1227 case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1228 case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1229 case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1230 case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSA) dwParam2);
1231 case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1232 case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSA) dwParam2);
1233 case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1234 case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
1235 case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSA) dwParam2);
1236 case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSA) dwParam2);
1237 case MCI_SAVE: return MCIAVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSA) dwParam2);
1238 case MCI_FREEZE: return MCIAVI_mciFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1239 case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1240 case MCI_UNFREEZE: return MCIAVI_mciUnFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1241 case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
1242 case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1243 case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
1244 case MCI_COPY: return MCIAVI_mciCopy (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS) dwParam2);
1245 case MCI_CUT: return MCIAVI_mciCut (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS) dwParam2);
1246 case MCI_DELETE: return MCIAVI_mciDelete (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS) dwParam2);
1247 case MCI_PASTE: return MCIAVI_mciPaste (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS) dwParam2);
1248 case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
1249 /* Digital Video specific */
1250 case MCI_CAPTURE: return MCIAVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSA) dwParam2);
1251 case MCI_MONITOR: return MCIAVI_mciMonitor (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS) dwParam2);
1252 case MCI_RESERVE: return MCIAVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSA) dwParam2);
1253 case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSA) dwParam2);
1254 case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
1255 case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSA) dwParam2);
1256 case MCI_QUALITY: return MCIAVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSA) dwParam2);
1257 case MCI_LIST: return MCIAVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSA) dwParam2);
1258 case MCI_UNDO: return MCIAVI_mciUndo (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1259 case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1260 case MCI_RESTORE: return MCIAVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSA) dwParam2);
1261
1262 case MCI_SPIN:
1263 case MCI_ESCAPE:
1264 WARN("Unsupported command [%lu]\n", wMsg);
1265 break;
1266 case MCI_OPEN:
1267 case MCI_CLOSE:
1268 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1269 break;
1270 default:
1271 TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
1272 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1273 }
1274 return MCIERR_UNRECOGNIZED_COMMAND;
1275 }
Maarten's multimedia branch