ReactOS 0.4.15-dev-5667-ged97270
mciavi.c
Go to the documentation of this file.
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
45
47
48/*======================================================================*
49 * MCI AVI implementation *
50 *======================================================================*/
51
53
54/***********************************************************************
55 * DllMain (MCIAVI.0)
56 */
58{
59 switch (fdwReason) {
62 MCIAVI_hInstance = hInstDLL;
63 break;
64 }
65 return TRUE;
66}
67
68/**************************************************************************
69 * MCIAVI_drvOpen [internal]
70 */
72{
73 WINE_MCIAVI* wma;
74 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
75
76 TRACE("%s, %p\n", debugstr_w(str), modp);
77
78 /* session instance */
79 if (!modp) return 0xFFFFFFFF;
80
81 if (!MCIAVI_RegisterClass()) return 0;
82
84 if (!wma)
85 return 0;
86
88 wma->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_MCIAVI.cs");
90 wma->wDevID = modp->wDeviceID;
96
97 return modp->wDeviceID;
98}
99
100/**************************************************************************
101 * MCIAVI_drvClose [internal]
102 */
104{
105 WINE_MCIAVI *wma;
106
107 TRACE("%04x\n", dwDevID);
108
109 /* finish all outstanding things */
110 MCIAVI_mciClose(dwDevID, MCI_WAIT, NULL);
111
112 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
113
114 if (wma) {
116
118
119 mciSetDriverData(dwDevID, 0);
121
123
125 wma->cs.DebugInfo->Spare[0] = 0;
127
128 HeapFree(GetProcessHeap(), 0, wma);
129 return 1;
130 }
131 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
132}
133
134/**************************************************************************
135 * MCIAVI_drvConfigure [internal]
136 */
138{
139 WINE_MCIAVI *wma;
140
141 TRACE("%04x\n", dwDevID);
142
143 MCIAVI_mciStop(dwDevID, MCI_WAIT, NULL);
144
145 wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
146
147 if (wma) {
148 MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK);
149 return 1;
150 }
151 return 0;
152}
153
154/**************************************************************************
155 * MCIAVI_mciGetOpenDev [internal]
156 */
158{
160
161 if (wma == NULL || wma->nUseCount == 0) {
162 WARN("Invalid wDevID=%u\n", wDevID);
163 return 0;
164 }
165 return wma;
166}
167
169{
170 /* to prevent handling in WindowProc */
172 if (wma->hFile) {
173 mmioClose(wma->hFile, 0);
174 wma->hFile = 0;
175
177 wma->lpFileName = NULL;
178
180 wma->lpVideoIndex = NULL;
182 wma->lpAudioIndex = NULL;
183 if (wma->hic) ICClose(wma->hic);
184 wma->hic = 0;
185 HeapFree(GetProcessHeap(), 0, wma->inbih);
186 wma->inbih = NULL;
187 HeapFree(GetProcessHeap(), 0, wma->outbih);
188 wma->outbih = NULL;
189 HeapFree(GetProcessHeap(), 0, wma->indata);
190 wma->indata = NULL;
191 HeapFree(GetProcessHeap(), 0, wma->outdata);
192 wma->outdata = NULL;
193 if (wma->hbmFrame) DeleteObject(wma->hbmFrame);
194 wma->hbmFrame = 0;
195 if (wma->hWnd) DestroyWindow(wma->hWnd);
196 wma->hWnd = 0;
197
199 wma->lpWaveFormat = 0;
200
201 memset(&wma->mah, 0, sizeof(wma->mah));
202 memset(&wma->ash_video, 0, sizeof(wma->ash_video));
203 memset(&wma->ash_audio, 0, sizeof(wma->ash_audio));
204 wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
205 wma->dwCachedFrame = -1;
206 }
207}
208
209/***************************************************************************
210 * MCIAVI_mciOpen [internal]
211 */
213 LPMCI_DGV_OPEN_PARMSW lpOpenParms)
214{
215 WINE_MCIAVI *wma;
216 LRESULT dwRet = 0;
217
218 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
219
220 if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
221
222 wma = (WINE_MCIAVI *)mciGetDriverData(wDevID);
223 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
224
226
227 if (wma->nUseCount > 0) {
228 /* The driver is already open on this channel */
229 /* If the driver was opened shareable before and this open specifies */
230 /* shareable then increment the use count */
231 if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
232 ++wma->nUseCount;
233 else
234 {
237 }
238 } else {
239 wma->nUseCount = 1;
241 }
242
244
247 /* could it be that (DWORD)lpOpenParms->lpstrElementName
248 * contains the hFile value ?
249 */
251 } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) {
252 /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */
253 TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName));
254
255 wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR));
256 lstrcpyW(wma->lpFileName, lpOpenParms->lpstrElementName);
257
258 if (lpOpenParms->lpstrElementName[0] == '@') {
259 /* The file name @11223344 encodes an AVIFile handle in decimal notation
260 * in Win3.1 and w2k/NT, but this feature is absent in win95 (KB140750).
261 * wma->hFile = LongToHandle(wcstol(lpOpenParms->lpstrElementName+1, NULL, 10)); */
262 FIXME("Using AVIFile/Stream %s NIY\n", debugstr_w(lpOpenParms->lpstrElementName));
263 }
264 wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL,
266
267 if (wma->hFile == 0) {
268 WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName));
269 dwRet = MCIERR_FILE_NOT_FOUND;
270 } else {
271 if (!MCIAVI_GetInfo(wma))
272 dwRet = MCIERR_INVALID_FILE;
273 else if (!MCIAVI_OpenVideo(wma))
275 else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms))
276 dwRet = MCIERR_CREATEWINDOW;
277 }
278 } else {
279 FIXME("Don't record yet\n");
281 }
282 }
283
284 if (dwRet == 0) {
285 TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID);
286
287 wma->dwStatus = MCI_MODE_STOP;
289 } else {
290 MCIAVI_CleanUp(wma);
291 }
292
294
295 if (!dwRet && (dwFlags & MCI_NOTIFY)) {
297 wDevID, MCI_NOTIFY_SUCCESSFUL);
298 }
299 return dwRet;
300}
301
302/***************************************************************************
303 * MCIAVI_mciClose [internal]
304 */
306{
307 WINE_MCIAVI *wma;
308 DWORD dwRet = 0;
309
310 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
311
312 wma = MCIAVI_mciGetOpenDev(wDevID);
313 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
314
315 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
316
318
319 if (wma->nUseCount == 1) {
320 MCIAVI_CleanUp(wma);
321
322 if ((dwFlags & MCI_NOTIFY) && lpParms) {
324 wDevID,
326 }
328 return dwRet;
329 }
330 wma->nUseCount--;
331
333 return dwRet;
334}
335
336static double currenttime_us(void)
337{
338 LARGE_INTEGER lc, lf;
341 return (lc.QuadPart * 1000000) / lf.QuadPart;
342}
343
344/***************************************************************************
345 * MCIAVI_player [internal]
346 */
348{
349 DWORD dwRet;
350 LPWAVEHDR waveHdr = NULL;
351 unsigned i, nHdr = 0;
352 DWORD numEvents = 1;
353 HANDLE events[2];
354 double next_frame_us;
355 BOOL wait_audio = TRUE;
356
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 */
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 dur = MCIAVI_PaintFrame(wma, hDC);
397 ++wma->dwCurrVideoFrame;
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 {
408 break;
409 TRACE("repeat media as requested\n");
410 wma->dwCurrVideoFrame = wma->dwCurrAudioBlock = 0;
411 }
412
413 if (wma->lpWaveFormat)
414 MCIAVI_PlayAudioBlocks(wma, nHdr, waveHdr);
415
416 tc = currenttime_us();
417 if (tc < next_frame_us)
418 delta = next_frame_us - tc;
419 else
420 delta = 0;
421
422 /* check if the playback was cancelled */
423 if ((wma->mci_break.flags & MCI_BREAK_KEY) &&
424 (GetAsyncKeyState(wma->mci_break.parms.nVirtKey) & 0x8000))
425 {
426 if (!(wma->mci_break.flags & MCI_BREAK_HWND) ||
427 GetForegroundWindow() == wma->mci_break.parms.hwndBreak)
428 {
429 /* we queue audio blocks ahead so ignore them otherwise the audio
430 * will keep playing until the buffer is empty */
431 wait_audio = FALSE;
432
433 TRACE("playback cancelled using break key\n");
434 break;
435 }
436 }
437
439 ret = WaitForMultipleObjects(numEvents, events, FALSE, delta / 1000);
441 if (ret == WAIT_OBJECT_0 || wma->dwStatus != MCI_MODE_PLAY) break;
442 }
443
444 if (wma->lpWaveFormat)
445 {
446 if (wait_audio)
447 while (wma->dwEventCount != nHdr - 1)
448 {
450 Sleep(100);
452 }
453
454 /* just to get rid of some race conditions between play, stop and pause */
456 waveOutReset(wma->hWave);
458
459 for (i = 0; i < nHdr; i++)
460 waveOutUnprepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR));
461 }
462
463 dwRet = 0;
464
465 if (wma->lpWaveFormat) {
466 HeapFree(GetProcessHeap(), 0, waveHdr);
467
468 if (wma->hWave) {
470 waveOutClose(wma->hWave);
472 wma->hWave = 0;
473 }
474 CloseHandle(wma->hEvent);
475 }
476
477mci_play_done:
478 wma->dwStatus = MCI_MODE_STOP;
479
480 if (dwFlags & MCI_NOTIFY) {
481 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
484 }
486 return dwRet;
487}
488
490{
493 MCI_PLAY_PARMS params; /* FIXME: notify via wma->hCallback like the other MCI drivers */
494};
495
496/*
497 * MCIAVI_mciPlay_thread
498 *
499 * FIXME: probably should use a common worker thread created at the driver
500 * load time and queue all async commands to it.
501 */
503{
504 struct MCIAVI_play_data *data = (struct MCIAVI_play_data *)arg;
505 DWORD ret;
506
507 TRACE("In thread before async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
508 ret = MCIAVI_player(data->wma, data->flags, &data->params);
509 TRACE("In thread after async play command (id %u, flags %08x)\n", data->wma->wDevID, data->flags);
510
512 return ret;
513}
514
515/*
516 * MCIAVI_mciPlay_async
517 */
519{
521 struct MCIAVI_play_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct MCIAVI_play_data));
522
523 if (!data) return MCIERR_OUT_OF_MEMORY;
524
525 data->wma = wma;
526 data->flags = dwFlags;
527 if (dwFlags & MCI_NOTIFY)
528 data->params.dwCallback = lpParams->dwCallback;
529
531 {
532 WARN("Couldn't create thread for async play, playing synchronously\n");
534 }
537 return 0;
538}
539
540/***************************************************************************
541 * MCIAVI_mciPlay [internal]
542 */
544{
546 DWORD dwRet;
547 DWORD dwFromFrame, dwToFrame;
548
549 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
550
551 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
552
553 wma = MCIAVI_mciGetOpenDev(wDevID);
554 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
556 if (dwFlags & MCI_TEST) return 0;
557
559 FIXME("Unsupported flag %08x\n", dwFlags);
560
562
563 if (!wma->hFile)
564 {
567 }
568 if (!wma->hWndPaint)
569 {
571 return MCIERR_NO_WINDOW;
572 }
573
574 dwFromFrame = wma->dwCurrVideoFrame;
575 dwToFrame = wma->dwPlayableVideoFrames - 1;
576
577 if (dwFlags & MCI_FROM) {
578 dwFromFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwFrom);
579 }
580 if (dwFlags & MCI_TO) {
581 dwToFrame = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
582 }
583 if (dwToFrame >= wma->dwPlayableVideoFrames)
584 dwToFrame = wma->dwPlayableVideoFrames - 1;
585
586 TRACE("Playing from frame=%u to frame=%u\n", dwFromFrame, dwToFrame);
587
588 wma->dwCurrVideoFrame = dwFromFrame;
589 wma->dwToVideoFrame = dwToFrame;
590
592
594 {
595 HMONITOR mon = MonitorFromWindow(wma->hWndPaint, MONITOR_DEFAULTTONEAREST);
597 mi.cbSize = sizeof(mi);
598 GetMonitorInfoA(mon, &mi);
601 NULL, NULL, NULL, 0);
602 }
603 /* if not fullscreen ensure the window is visible */
606
608
609 /* if already playing exit */
610 if (wma->dwStatus == MCI_MODE_PLAY)
611 {
613 return 0;
614 }
615
617
619
620 if (dwFlags & MCI_WAIT)
621 return MCIAVI_player(wma, dwFlags, lpParms);
622
623 dwRet = MCIAVI_mciPlay_async(wma, dwFlags, lpParms);
624
625 if (dwRet) {
629 }
630 return dwRet;
631}
632
633/***************************************************************************
634 * MCIAVI_mciStop [internal]
635 */
637{
639 DWORD dwRet = 0;
640
641 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
642
643 wma = MCIAVI_mciGetOpenDev(wDevID);
644 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
645 if (dwFlags & MCI_TEST) return 0;
646
648
649 TRACE("current status %04x\n", wma->dwStatus);
650
651 switch (wma->dwStatus) {
652 case MCI_MODE_PLAY:
653 case MCI_MODE_RECORD:
657 /* fall through */
658 case MCI_MODE_PAUSE:
659 /* Since our wave notification callback takes the lock,
660 * we must release it before resetting the device */
662 dwRet = waveOutReset(wma->hWave);
664 /* fall through */
665 default:
666 do /* one more chance for an async thread to finish */
667 {
669 Sleep(10);
671 } while (wma->dwStatus != MCI_MODE_STOP);
672
673 break;
674
676 break;
677 }
678
679 if ((dwFlags & MCI_NOTIFY) && lpParms) {
681 wDevID, MCI_NOTIFY_SUCCESSFUL);
682 }
684 return dwRet;
685}
686
687/***************************************************************************
688 * MCIAVI_mciPause [internal]
689 */
691{
693
694 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
695
696 wma = MCIAVI_mciGetOpenDev(wDevID);
697 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
698 if (dwFlags & MCI_TEST) return 0;
699
701
702 if (wma->dwStatus == MCI_MODE_PLAY)
704
705 if (wma->lpWaveFormat) {
707 return waveOutPause(wma->hWave);
708 }
709
711 return 0;
712}
713
714/***************************************************************************
715 * MCIAVI_mciResume [internal]
716 */
718{
720
721 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
722
723 wma = MCIAVI_mciGetOpenDev(wDevID);
724 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
725 if (dwFlags & MCI_TEST) return 0;
726
728
731
732 if (wma->lpWaveFormat) {
734 return waveOutRestart(wma->hWave);
735 }
736
738 return 0;
739}
740
741/***************************************************************************
742 * MCIAVI_mciSeek [internal]
743 */
745{
747 DWORD position;
748
749 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
750
751 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
752
753 wma = MCIAVI_mciGetOpenDev(wDevID);
754 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
755
757 if (!position) return MCIERR_MISSING_PARAMETER;
758 if (position&(position-1)) return MCIERR_FLAGS_NOT_COMPATIBLE;
759
760 if (dwFlags & MCI_TO) {
761 position = MCIAVI_ConvertTimeFormatToFrame(wma, lpParms->dwTo);
762 if (position >= wma->dwPlayableVideoFrames)
763 return MCIERR_OUTOFRANGE;
764 } else if (dwFlags & MCI_SEEK_TO_START) {
765 position = 0;
766 } else {
767 position = wma->dwPlayableVideoFrames - 1;
768 }
769 if (dwFlags & MCI_TEST) return 0;
770
771 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
772
774
775 wma->dwCurrVideoFrame = position;
776 TRACE("Seeking to frame=%u\n", wma->dwCurrVideoFrame);
777
778 if (dwFlags & MCI_NOTIFY) {
780 wDevID, MCI_NOTIFY_SUCCESSFUL);
781 }
783 return 0;
784}
785
786/*****************************************************************************
787 * MCIAVI_mciLoad [internal]
788 */
790{
792
793 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
794
795 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
796
797 wma = MCIAVI_mciGetOpenDev(wDevID);
798 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
799
800 return MCIERR_UNSUPPORTED_FUNCTION; /* like w2k */
801}
802
803/******************************************************************************
804 * MCIAVI_mciRealize [internal]
805 */
807{
809
810 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
811
812 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
813
814 wma = MCIAVI_mciGetOpenDev(wDevID);
815 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
816 if (dwFlags & MCI_TEST) return 0;
817
818 return 0;
819}
820
821/******************************************************************************
822 * MCIAVI_mciUpdate [internal]
823 */
825{
827
828 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
829
830 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
831
832 wma = MCIAVI_mciGetOpenDev(wDevID);
833 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
834 /* Ignore MCI_TEST flag. */
835
837
839 MCIAVI_PaintFrame(wma, lpParms->hDC);
840
842
843 return 0;
844}
845
846/******************************************************************************
847 * MCIAVI_mciStep [internal]
848 */
850{
852 DWORD position;
853 int delta = 1;
854
855 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
856
857 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
858
859 wma = MCIAVI_mciGetOpenDev(wDevID);
860 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
861
862 if (dwFlags & MCI_DGV_STEP_FRAMES) delta = lpParms->dwFrames;
863 if (dwFlags & MCI_DGV_STEP_REVERSE) delta = -delta;
864 position = wma->dwCurrVideoFrame + delta;
865 if (position >= wma->dwPlayableVideoFrames) return MCIERR_OUTOFRANGE;
866 if (dwFlags & MCI_TEST) return 0;
867
868 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
869
871
872 wma->dwCurrVideoFrame = position;
873 TRACE("Stepping to frame=%u\n", wma->dwCurrVideoFrame);
874
875 if (dwFlags & MCI_NOTIFY) {
877 wDevID, MCI_NOTIFY_SUCCESSFUL);
878 }
880 return 0;
881}
882
883/******************************************************************************
884 * MCIAVI_mciCue [internal]
885 */
887{
889
890 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
891
892 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
893
894 wma = MCIAVI_mciGetOpenDev(wDevID);
895 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
897 if (dwFlags & MCI_TEST) return 0;
898
899 return 0;
900}
901
902/******************************************************************************
903 * MCIAVI_mciBreak [internal]
904 */
906{
908
909 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
910
911 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
912
913 wma = MCIAVI_mciGetOpenDev(wDevID);
914 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
915
917
918 wma->mci_break.flags = dwFlags;
919 wma->mci_break.parms = *lpParms;
920
922
923 return 0;
924}
925
926/******************************************************************************
927 * MCIAVI_mciSetAudio [internal]
928 */
930{
932
933 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
934
935 FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETAUDIO_ITEM ? lpParms->dwItem : 0);
936
937 wma = MCIAVI_mciGetOpenDev(wDevID);
938 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
939
940 return 0;
941}
942
943/******************************************************************************
944 * MCIAVI_mciSignal [internal]
945 */
947{
949
950 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
951
952 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
953
954 wma = MCIAVI_mciGetOpenDev(wDevID);
955 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
956
957 return 0;
958}
959
960/******************************************************************************
961 * MCIAVI_mciSetVideo [internal]
962 */
964{
966
967 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
968
969 FIXME("(%04x, %08x, %p) Item %04x: stub\n", wDevID, dwFlags, lpParms, dwFlags & MCI_DGV_SETVIDEO_ITEM ? lpParms->dwItem : 0);
970
971 wma = MCIAVI_mciGetOpenDev(wDevID);
972 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
973
974 return 0;
975}
976
977/******************************************************************************
978 * MCIAVI_mciConfigure [internal]
979 */
981{
983
984 FIXME("(%04x, %08x, %p) : stub\n", wDevID, dwFlags, lpParms);
985
986 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
987
988 wma = MCIAVI_mciGetOpenDev(wDevID);
989 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
990 if (dwFlags & MCI_TEST) return 0;
991
992 return 0;
993}
994
995/*======================================================================*
996 * MCI AVI entry points *
997 *======================================================================*/
998
999/**************************************************************************
1000 * DriverProc (MCIAVI.@)
1001 */
1003 LPARAM dwParam1, LPARAM dwParam2)
1004{
1005 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1006 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1007
1008 switch (wMsg) {
1009 case DRV_LOAD: return 1;
1010 case DRV_FREE: return 1;
1011 case DRV_OPEN: return MCIAVI_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1012 case DRV_CLOSE: return MCIAVI_drvClose(dwDevID);
1013 case DRV_ENABLE: return 1;
1014 case DRV_DISABLE: return 1;
1015 case DRV_QUERYCONFIGURE: return 1;
1016 case DRV_CONFIGURE: return MCIAVI_drvConfigure(dwDevID);
1017 case DRV_INSTALL: return DRVCNF_RESTART;
1018 case DRV_REMOVE: return DRVCNF_RESTART;
1019 }
1020
1021 /* session instance */
1022 if (dwDevID == 0xFFFFFFFF) return 1;
1023
1024 switch (wMsg) {
1025 case MCI_OPEN_DRIVER: return MCIAVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1026 case MCI_CLOSE_DRIVER: return MCIAVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1027 case MCI_PLAY: return MCIAVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1028 case MCI_STOP: return MCIAVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1029 case MCI_SET: return MCIAVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1030 case MCI_PAUSE: return MCIAVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1031 case MCI_RESUME: return MCIAVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1032 case MCI_STATUS: return MCIAVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1033 case MCI_GETDEVCAPS: return MCIAVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1034 case MCI_INFO: return MCIAVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSW) dwParam2);
1035 case MCI_SEEK: return MCIAVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1036 case MCI_PUT: return MCIAVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
1037 case MCI_WINDOW: return MCIAVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW) dwParam2);
1038 case MCI_LOAD: return MCIAVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSW) dwParam2);
1039 case MCI_REALIZE: return MCIAVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1040 case MCI_UPDATE: return MCIAVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
1041 case MCI_WHERE: return MCIAVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1042 case MCI_STEP: return MCIAVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
1043 case MCI_CUE: return MCIAVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
1044 case MCI_BREAK: return MCIAVI_mciBreak (dwDevID, dwParam1, (LPMCI_BREAK_PARMS) dwParam2);
1045 /* Digital Video specific */
1046 case MCI_SETAUDIO: return MCIAVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1047 case MCI_SIGNAL: return MCIAVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
1048 case MCI_SETVIDEO: return MCIAVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSW) dwParam2);
1049 case MCI_CONFIGURE: return MCIAVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1050
1051 /* no editing, recording, saving, locking without inputs */
1052 case MCI_CAPTURE:
1053 case MCI_COPY:
1054 case MCI_CUT:
1055 case MCI_DELETE:
1056 case MCI_FREEZE:
1057 case MCI_LIST:
1058 case MCI_MONITOR:
1059 case MCI_PASTE:
1060 case MCI_QUALITY:
1061 case MCI_RECORD:
1062 case MCI_RESERVE:
1063 case MCI_RESTORE:
1064 case MCI_SAVE:
1065 case MCI_UNDO:
1066 case MCI_UNFREEZE:
1067 TRACE("Unsupported function [0x%x] flags=%08x\n", wMsg, (DWORD)dwParam1);
1069 case MCI_SPIN:
1070 case MCI_ESCAPE:
1071 WARN("Unsupported command [0x%x] %08x\n", wMsg, (DWORD)dwParam1);
1072 break;
1073 case MCI_OPEN:
1074 case MCI_CLOSE:
1075 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1076 break;
1077 default:
1078 TRACE("Sending msg [%u] to default driver proc\n", wMsg);
1079 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1080 }
1082}
static HDC hDC
Definition: 3dtext.c:33
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
DWORD LPVOID fImpLoad
Definition: misc.cpp:155
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define MCI_SETAUDIO
Definition: digitalv.h:39
#define MCI_DGV_SETAUDIO_ITEM
Definition: digitalv.h:296
#define MCI_MONITOR
Definition: digitalv.h:37
#define MCI_DGV_STEP_FRAMES
Definition: digitalv.h:431
#define MCI_LIST
Definition: digitalv.h:43
#define MCI_CAPTURE
Definition: digitalv.h:36
#define MCI_RESERVE
Definition: digitalv.h:38
#define MCI_SETVIDEO
Definition: digitalv.h:41
#define MCI_SIGNAL
Definition: digitalv.h:40
#define MCI_DGV_UPDATE_HDC
Definition: digitalv.h:439
#define MCI_DGV_STEP_REVERSE
Definition: digitalv.h:430
#define MCI_QUALITY
Definition: digitalv.h:42
#define MCI_DGV_CUE_INPUT
Definition: digitalv.h:141
#define MCI_RESTORE
Definition: digitalv.h:46
#define MCI_CONFIGURE
Definition: digitalv.h:45
#define MCI_TEST
Definition: digitalv.h:32
#define MCI_UNDO
Definition: digitalv.h:44
#define MCI_DGV_SETVIDEO_ITEM
Definition: digitalv.h:327
#define MCI_DGV_PLAY_REPEAT
Definition: digitalv.h:227
#define MCI_DGV_PLAY_REVERSE
Definition: digitalv.h:228
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
BOOL WINAPI QueryPerformanceFrequency(OUT PLARGE_INTEGER lpFrequency)
Definition: perfcnt.c:45
BOOL WINAPI QueryPerformanceCounter(OUT PLARGE_INTEGER lpPerformanceCount)
Definition: perfcnt.c:23
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:700
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
DWORD MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
Definition: info.c:363
DWORD MCIAVI_ConvertTimeFormatToFrame(WINE_MCIAVI *wma, DWORD val)
Definition: info.c:52
DWORD MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
Definition: info.c:73
DWORD MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
Definition: info.c:227
DWORD MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
Definition: info.c:188
BOOL WINAPI mciFreeCommandResource(UINT uTable)
Definition: mci.c:1681
UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName, UINT uType)
Definition: mci.c:1641
BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
Definition: mci.c:2223
BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData)
DWORD WINAPI mciGetDriverData(UINT uDeviceID)
Definition: mci.c:2233
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:554
MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
Definition: mmio.c:701
HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO *lpmmioinfo, DWORD dwOpenFlags)
Definition: mmio.c:669
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
pKey DeleteObject()
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
const GLfloat * tc
Definition: glext.h:8925
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define DRV_LOAD(x)
#define debugstr_w
Definition: kernel32.h:32
static DWORD MCIAVI_mciLoad(UINT wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSW lpParms)
Definition: mciavi.c:789
static DWORD MCIAVI_mciSetVideo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSW lpParms)
Definition: mciavi.c:963
static DWORD MCIAVI_drvClose(DWORD dwDevID)
Definition: mciavi.c:103
static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
Definition: mciavi.c:543
static DWORD MCIAVI_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
Definition: mciavi.c:929
static DWORD MCIAVI_mciPlay_async(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParams)
Definition: mciavi.c:518
static DWORD MCIAVI_mciRealize(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciavi.c:806
static DWORD MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciavi.c:717
static DWORD MCIAVI_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
Definition: mciavi.c:71
static DWORD MCIAVI_drvConfigure(DWORD dwDevID)
Definition: mciavi.c:137
HINSTANCE MCIAVI_hInstance
Definition: mciavi.c:52
DWORD MCIAVI_mciClose(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciavi.c:305
static DWORD MCIAVI_mciCue(UINT wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
Definition: mciavi.c:886
static DWORD MCIAVI_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
Definition: mciavi.c:824
static DWORD MCIAVI_mciSignal(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
Definition: mciavi.c:946
static DWORD MCIAVI_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciavi.c:690
static DWORD MCIAVI_mciBreak(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
Definition: mciavi.c:905
static DWORD MCIAVI_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
Definition: mciavi.c:744
static void MCIAVI_CleanUp(WINE_MCIAVI *wma)
Definition: mciavi.c:168
static double currenttime_us(void)
Definition: mciavi.c:336
static DWORD WINAPI MCIAVI_mciPlay_thread(LPVOID arg)
Definition: mciavi.c:502
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
Definition: mciavi.c:57
static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms)
Definition: mciavi.c:212
static DWORD MCIAVI_player(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
Definition: mciavi.c:347
static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS)
Definition: mciavi.c:636
static DWORD MCIAVI_mciConfigure(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciavi.c:980
static DWORD MCIAVI_mciStep(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
Definition: mciavi.c:849
WINE_MCIAVI * MCIAVI_mciGetOpenDev(UINT wDevID)
Definition: mciavi.c:157
LRESULT CALLBACK MCIAVI_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2)
Definition: mciavi.c:1002
#define MCI_MCIAVI_PLAY_FULLBY2
Definition: mciavi.h:6
#define MCI_MCIAVI_PLAY_WINDOW
Definition: mciavi.h:4
#define MCI_MCIAVI_PLAY_FULLSCREEN
Definition: mciavi.h:5
void MCIAVI_PlayAudioBlocks(WINE_MCIAVI *wma, unsigned nHdr, LPWAVEHDR waveHdr)
Definition: mmoutput.c:575
DWORD MCIAVI_OpenAudio(WINE_MCIAVI *wma, unsigned *nHdr, LPWAVEHDR *pWaveHdr)
Definition: mmoutput.c:525
double MCIAVI_PaintFrame(WINE_MCIAVI *wma, HDC hDC)
Definition: mmoutput.c:604
BOOL MCIAVI_GetInfo(WINE_MCIAVI *wma)
Definition: mmoutput.c:255
BOOL MCIAVI_OpenVideo(WINE_MCIAVI *wma)
Definition: mmoutput.c:426
#define MCI_CUT
Definition: mmsystem.h:671
#define MCI_SAVE
Definition: mmsystem.h:661
#define DRV_CLOSE
Definition: mmsystem.h:122
#define MCIERR_FLAGS_NOT_COMPATIBLE
Definition: mmsystem.h:593
#define MCI_OPEN_SHAREABLE
Definition: mmsystem.h:734
#define MCI_SEEK_TO_END
Definition: mmsystem.h:741
#define MCI_NOTIFY
Definition: mmsystem.h:729
#define MCI_TO
Definition: mmsystem.h:732
#define MMIO_ALLOCBUF
Definition: mmsystem.h:532
#define MCI_BREAK
Definition: mmsystem.h:660
#define DRV_QUERYCONFIGURE
Definition: mmsystem.h:126
#define MCI_GETDEVCAPS
Definition: mmsystem.h:654
#define MCI_OPEN_ELEMENT_ID
Definition: mmsystem.h:737
#define MCI_RESUME
Definition: mmsystem.h:675
#define MCI_OPEN_ELEMENT
Definition: mmsystem.h:735
#define MCI_DELETE
Definition: mmsystem.h:676
#define MCI_MODE_PLAY
Definition: mmsystem.h:696
#define MCI_FREEZE
Definition: mmsystem.h:668
#define MCIERR_FILE_NOT_FOUND
Definition: mmsystem.h:585
#define MCIERR_CANNOT_LOAD_DRIVER
Definition: mmsystem.h:576
#define DRVCNF_RESTART
Definition: mmsystem.h:135
#define MCI_WINDOW
Definition: mmsystem.h:665
#define MCI_STATUS
Definition: mmsystem.h:662
#define MCI_COPY
Definition: mmsystem.h:672
#define MCI_ESCAPE
Definition: mmsystem.h:648
#define MCI_BREAK_HWND
Definition: mmsystem.h:783
#define MCIERR_UNRECOGNIZED_COMMAND
Definition: mmsystem.h:571
#define MCI_SET
Definition: mmsystem.h:656
#define MCI_LOAD
Definition: mmsystem.h:670
#define MCI_UPDATE
Definition: mmsystem.h:674
#define DRV_REMOVE
Definition: mmsystem.h:128
#define DRV_ENABLE
Definition: mmsystem.h:120
#define MCI_STOP
Definition: mmsystem.h:651
#define MMIO_DENYWRITE
Definition: mmsystem.h:540
#define MCI_CLOSE
Definition: mmsystem.h:647
#define MCIERR_INVALID_DEVICE_ID
Definition: mmsystem.h:569
#define MCI_SEEK
Definition: mmsystem.h:650
#define DRV_CONFIGURE
Definition: mmsystem.h:125
#define MCIERR_INVALID_FILE
Definition: mmsystem.h:604
#define DRV_OPEN
Definition: mmsystem.h:121
#define MCIERR_MISSING_PARAMETER
Definition: mmsystem.h:583
#define MCI_WHERE
Definition: mmsystem.h:667
#define MCIERR_NULL_PARAMETER_BLOCK
Definition: mmsystem.h:605
#define MCIERR_NO_WINDOW
Definition: mmsystem.h:639
#define MCIERR_OUTOFRANGE
Definition: mmsystem.h:592
#define DRV_INSTALL
Definition: mmsystem.h:127
#define MCI_OPEN
Definition: mmsystem.h:646
#define MCIERR_CREATEWINDOW
Definition: mmsystem.h:640
#define MCI_UNFREEZE
Definition: mmsystem.h:669
#define MCIERR_OUT_OF_MEMORY
Definition: mmsystem.h:574
#define MCI_DEVTYPE_DIGITAL_VIDEO
Definition: mmsystem.h:687
#define MCI_MODE_RECORD
Definition: mmsystem.h:697
#define MCI_BREAK_KEY
Definition: mmsystem.h:782
#define MCI_PUT
Definition: mmsystem.h:666
#define MCI_SPIN
Definition: mmsystem.h:655
#define MCI_MODE_STOP
Definition: mmsystem.h:695
#define MCIERR_MUST_USE_SHAREABLE
Definition: mmsystem.h:599
#define MMIO_READ
Definition: mmsystem.h:535
#define MCI_SEEK_TO_START
Definition: mmsystem.h:740
#define MCI_WAIT
Definition: mmsystem.h:730
#define MCI_NOTIFY_SUCCESSFUL
Definition: mmsystem.h:725
#define MCI_CUE
Definition: mmsystem.h:663
#define MCI_PAUSE
Definition: mmsystem.h:652
#define MCI_FROM
Definition: mmsystem.h:731
#define MCI_INFO
Definition: mmsystem.h:653
#define MCI_MODE_NOT_READY
Definition: mmsystem.h:694
#define MCI_MODE_PAUSE
Definition: mmsystem.h:699
#define MCI_PASTE
Definition: mmsystem.h:673
#define DRV_FREE
Definition: mmsystem.h:124
#define MCIERR_UNSUPPORTED_FUNCTION
Definition: mmsystem.h:584
#define MCI_FORMAT_FRAMES
Definition: mmsystem.h:704
#define MCI_PLAY
Definition: mmsystem.h:649
#define MCI_STEP
Definition: mmsystem.h:657
#define MCI_REALIZE
Definition: mmsystem.h:664
#define MCI_RECORD
Definition: mmsystem.h:658
#define DRV_DISABLE
Definition: mmsystem.h:123
HANDLE events[2]
Definition: event.c:4
static HDC
Definition: imagelist.c:92
LRESULT WINAPI ICClose(HIC hic)
HMONITOR WINAPI MonitorFromWindow(HWND, DWORD)
unsigned int UINT
Definition: ndis.h:50
#define LOWORD(l)
Definition: pedump.c:82
#define WS_POPUP
Definition: pedump.c:616
#define WS_VISIBLE
Definition: pedump.c:620
BOOL MCIAVI_CreateWindow(WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms) DECLSPEC_HIDDEN
Definition: wnd.c:112
BOOL MCIAVI_RegisterClass(void) DECLSPEC_HIDDEN
Definition: wnd.c:93
DWORD MCIAVI_mciPut(UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms) DECLSPEC_HIDDEN
Definition: wnd.c:153
DWORD MCIAVI_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms) DECLSPEC_HIDDEN
Definition: wnd.c:277
DWORD MCIAVI_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms) DECLSPEC_HIDDEN
Definition: wnd.c:209
BOOL MCIAVI_UnregisterClass(void) DECLSPEC_HIDDEN
Definition: wnd.c:88
const WCHAR * str
#define MCI_OPEN_DRIVER
Definition: mmddk.h:338
#define MCI_CLOSE_DRIVER
Definition: mmddk.h:339
#define memset(x, y, z)
Definition: compat.h:39
#define TRACE(s)
Definition: solgame.cpp:4
MCI_PLAY_PARMS params
Definition: mciavi.c:493
WINE_MCIAVI * wma
Definition: mciavi.c:491
DWORD_PTR dwCallback
Definition: digitalv.h:604
LPWSTR lpstrElementName
Definition: digitalv.h:607
DWORD_PTR dwCallback
Definition: digitalv.h:822
UINT wCustomCommandTable
Definition: mmddk.h:438
DWORD dwToVideoFrame
MCIDEVICEID wDevID
HANDLE hStopEvent
LPWAVEFORMATEX lpWaveFormat
DWORD dwCurrAudioBlock
LPBITMAPINFOHEADER inbih
CRITICAL_SECTION cs
DWORD dwMciTimeFormat
DWORD dwCurrVideoFrame
LPWSTR lpFileName
HBITMAP hbmFrame
DWORD dwCachedFrame
LPVOID outdata
LPBITMAPINFOHEADER outbih
AVIStreamHeader ash_audio
struct MMIOPos * lpVideoIndex
WORD wCommandTable
DWORD dwPlayableVideoFrames
struct MMIOPos * lpAudioIndex
struct WINE_MCIAVI::@455 mci_break
AVIStreamHeader ash_video
MainAVIHeader mah
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
DWORD_PTR dwCallback
Definition: mmsystem.h:1517
DWORD_PTR dwCallback
Definition: mmsystem.h:1537
DWORD_PTR dwCallback
Definition: mmsystem.h:1543
RECT rcMonitor
Definition: winuser.h:3775
DWORD cbSize
Definition: winuser.h:3774
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
#define DWORD_PTR
Definition: treelist.c:76
uint32_t DWORD_PTR
Definition: typedefs.h:65
LONGLONG QuadPart
Definition: typedefs.h:114
int ret
static MONITORINFO mi
Definition: win.c:7338
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define WAIT_OBJECT_0
Definition: winbase.h:406
#define THREAD_PRIORITY_TIME_CRITICAL
Definition: winbase.h:281
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
#define WINAPI
Definition: msvc.h:6
UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
Definition: winmm.c:2388
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr, UINT uSize)
Definition: winmm.c:2310
UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
Definition: winmm.c:2402
UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
Definition: winmm.c:2374
UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
Definition: winmm.c:2260
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
HWND WINAPI GetForegroundWindow(void)
Definition: ntwrapper.h:392
#define CreateWindowA(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4305
int WINAPI MessageBoxA(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
#define SW_SHOWNA
Definition: winuser.h:772
BOOL WINAPI GetMonitorInfoA(_In_ HMONITOR, _Inout_ LPMONITORINFO)
HDC WINAPI GetDC(_In_opt_ HWND)
#define MB_OK
Definition: winuser.h:784
SHORT WINAPI GetAsyncKeyState(_In_ int)
#define GWL_STYLE
Definition: winuser.h:846
BOOL WINAPI DestroyWindow(_In_ HWND)
#define HWND_32(h16)
Definition: wownt32.h:29
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185