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