source: trunk/src/winmm/mciavi32/mciavi32.cpp

Last change on this file was 2308, checked in by sandervl, 26 years ago

JW: Ported Wine mci dlls
File size: 35.4 KB
RevLine 
[2308]1/* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3/*
4 * Digital video MCI Wine Driver
5 *
6 * Copyright 1999 Eric POUECH
7 */
8
9#include <os2win.h>
10#include <string.h>
11#include "winuser.h"
12#include "mmddk.h"
13#include "user.h"
14#include "driver.h"
15#include "digitalv.h"
16#include "debugtools.h"
17
18DEFAULT_DEBUG_CHANNEL(mciavi)
19
20typedef struct {
21 UINT wDevID;
22 int nUseCount; /* Incremented for each shared open */
23 BOOL16 fShareable; /* TRUE if first open was shareable */
24 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
25 HANDLE16 hCallback; /* Callback handle for pending notification */
26 HMMIO hFile; /* mmio file handle open as Element */
27 WORD wStatus; /* One of MCI_MODE_XXX */
28 MCI_OPEN_PARMSA openParms;
29 DWORD dwTimeFormat;
30} WINE_MCIAVI;
31
32/*======================================================================*
33 * MCI AVI implemantation *
34 *======================================================================*/
35
36/**************************************************************************
37 * AVI_drvOpen [internal]
38 */
39static DWORD AVI_drvOpen(LPSTR str, LPMCI_OPEN_DRIVER_PARMSA modp)
40{
41 WINE_MCIAVI* wma = (WINE_MCIAVI*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MCIAVI));
42
43 if (!wma)
44 return 0;
45
46 wma->wDevID = modp->wDeviceID;
47 mciSetDriverData(wma->wDevID, (DWORD)wma);
48 modp->wCustomCommandTable = MCI_NO_COMMAND_TABLE;
49 modp->wType = MCI_DEVTYPE_DIGITAL_VIDEO;
50 return modp->wDeviceID;
51}
52
53/**************************************************************************
54 * MCIAVI_drvClose [internal]
55 */
56static DWORD AVI_drvClose(DWORD dwDevID)
57{
58 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(dwDevID);
59
60 if (wma) {
61 HeapFree(GetProcessHeap(), 0, wma);
62 mciSetDriverData(dwDevID, 0);
63 return 1;
64 }
65 return 0;
66}
67
68/**************************************************************************
69 * AVI_mciGetOpenDev [internal]
70 */
71static WINE_MCIAVI* AVI_mciGetOpenDev(UINT16 wDevID)
72{
73 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
74
75 if (wma == NULL || wma->nUseCount == 0) {
76 WARN("Invalid wDevID=%u\n", wDevID);
77 return 0;
78 }
79 return wma;
80}
81
82static DWORD AVI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
83
84/***************************************************************************
85 * AVI_mciOpen [internal]
86 */
87static DWORD AVI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSA lpParms)
88{
89 WINE_MCIAVI* wma = (WINE_MCIAVI*)mciGetDriverData(wDevID);
90
91 TRACE("(%04x, %08lX, %p) : semi-stub\n", wDevID, dwFlags, lpParms);
92
93 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
94 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
95
96 if (wma->nUseCount > 0) {
97 /* The driver is already open on this channel */
98 /* If the driver was opened shareable before and this open specifies */
99 /* shareable then increment the use count */
100 if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
101 ++wma->nUseCount;
102 else
103 return MCIERR_MUST_USE_SHAREABLE;
104 } else {
105 wma->nUseCount = 1;
106 wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE;
107 }
108 if (dwFlags & MCI_OPEN_ELEMENT) {
109 TRACE("MCI_OPEN_ELEMENT !\n");
110 /* return MCIERR_NO_ELEMENT_ALLOWED; */
111 }
112
113 wma->openParms.dwCallback = lpParms->dwCallback;
114 wma->openParms.wDeviceID = (WORD)lpParms->wDeviceID;
115 wma->openParms.lpstrDeviceType = lpParms->lpstrDeviceType;
116 wma->openParms.lpstrElementName = lpParms->lpstrElementName;
117 wma->openParms.lpstrAlias = lpParms->lpstrAlias;
118
119 wma->wNotifyDeviceID = lpParms->wDeviceID;
120 /* FIXME: do real open */
121 wma->wStatus = MCI_MODE_STOP;
122 wma->dwTimeFormat = MCI_FORMAT_TMSF;
123
124 return 0;
125
126}
127
128/***************************************************************************
129 * AVI_mciClose [internal]
130 */
131static DWORD AVI_mciClose(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
132{
133 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
134
135 TRACE("(%04x, %08lX, %p) : semi-stub\n", wDevID, dwFlags, lpParms);
136
137 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
138
139 if (wma->nUseCount == 1) {
140 AVI_mciStop(wDevID, 0, NULL);
141 /* FIXME: do real closing */
142 }
143 wma->nUseCount--;
144 return 0;
145}
146
147/***************************************************************************
148 * AVI_mciPlay [internal]
149 */
150static DWORD AVI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
151{
152 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
153
154 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
155
156 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
157 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
158
159 wma->wStatus = MCI_MODE_PLAY;
160 if (lpParms && (dwFlags & MCI_NOTIFY)) {
161 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
162 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
163 wma->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
164 }
165 return 0;
166}
167
168/***************************************************************************
169 * AVI_mciRecord [internal]
170 */
171static DWORD AVI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECORD_PARMS lpParms)
172{
173 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
174
175 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
176
177 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
178 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
179
180 wma->wStatus = MCI_MODE_RECORD;
181 return 0;
182}
183
184/***************************************************************************
185 * AVI_mciStop [internal]
186 */
187static DWORD AVI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
188{
189 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
190
191 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
192
193 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
194 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
195
196 wma->wStatus = MCI_MODE_STOP;
197 return 0;
198}
199
200/***************************************************************************
201 * AVI_mciPause [internal]
202 */
203static DWORD AVI_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
204{
205 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
206
207 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
208
209 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
210 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
211
212 wma->wStatus = MCI_MODE_PAUSE;
213 return 0;
214}
215
216/***************************************************************************
217 * AVI_mciResume [internal]
218 */
219static DWORD AVI_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
220{
221 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
222
223 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
224
225 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
226 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
227
228 wma->wStatus = MCI_MODE_PLAY;
229 return 0;
230}
231
232/***************************************************************************
233 * AVI_mciSeek [internal]
234 */
235static DWORD AVI_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
236{
237 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
238
239 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
240
241 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
242 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
243
244 return 0;
245}
246
247/***************************************************************************
248 * AVI_mciSet [internal]
249 */
250static DWORD AVI_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
251{
252 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
253
254 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
255
256 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
257 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
258
259 if (dwFlags & MCI_SET_TIME_FORMAT) {
260 switch (lpParms->dwTimeFormat) {
261 case MCI_FORMAT_MILLISECONDS:
262 TRACE("MCI_FORMAT_MILLISECONDS !\n");
263 wma->dwTimeFormat = MCI_FORMAT_MILLISECONDS;
264 break;
265 case MCI_FORMAT_FRAMES:
266 TRACE("MCI_FORMAT_FRAMES !\n");
267 wma->dwTimeFormat = MCI_FORMAT_FRAMES;
268 break;
269 default:
270 WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
271 return MCIERR_BAD_TIME_FORMAT;
272 }
273 }
274
275 if (dwFlags & MCI_SET_DOOR_OPEN) {
276 TRACE("No support for door open !\n");
277 return MCIERR_UNSUPPORTED_FUNCTION;
278 }
279 if (dwFlags & MCI_SET_DOOR_CLOSED) {
280 TRACE("No support for door close !\n");
281 return MCIERR_UNSUPPORTED_FUNCTION;
282 }
283 if (dwFlags & MCI_SET_ON) {
284 char buffer[256];
285
286 strcpy(buffer, "MCI_SET_ON:");
287
288 if (dwFlags & MCI_SET_VIDEO) {
289 strncat(buffer, " video", sizeof(buffer));
290 }
291 if (dwFlags & MCI_SET_AUDIO) {
292 strncat(buffer, " audio", sizeof(buffer));
293 if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
294 strncat(buffer, " all", sizeof(buffer));
295 if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
296 strncat(buffer, " left", sizeof(buffer));
297 if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
298 strncat(buffer, " right", sizeof(buffer));
299 }
300 if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
301 strncat(buffer, " seek_exactly", sizeof(buffer));
302 }
303 TRACE("%s\n", buffer);
304 }
305
306 if (dwFlags & MCI_SET_OFF) {
307 char buffer[256];
308
309 strcpy(buffer, "MCI_SET_OFF:");
310 if (dwFlags & MCI_SET_VIDEO) {
311 strncat(buffer, " video", sizeof(buffer));
312 }
313 if (dwFlags & MCI_SET_AUDIO) {
314 strncat(buffer, " audio", sizeof(buffer));
315 if (lpParms->dwAudio & MCI_SET_AUDIO_ALL)
316 strncat(buffer, " all", sizeof(buffer));
317 if (lpParms->dwAudio & MCI_SET_AUDIO_LEFT)
318 strncat(buffer, " left", sizeof(buffer));
319 if (lpParms->dwAudio & MCI_SET_AUDIO_RIGHT)
320 strncat(buffer, " right", sizeof(buffer));
321 }
322 if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
323 strncat(buffer, " seek_exactly", sizeof(buffer));
324 }
325 TRACE("%s\n", buffer);
326 }
327 if (dwFlags & MCI_DGV_SET_FILEFORMAT) {
328 LPSTR str = "save";
329 if (dwFlags & MCI_DGV_SET_STILL)
330 str = "capture";
331
332 switch (lpParms->dwFileFormat) {
333 case MCI_DGV_FF_AVI: TRACE("Setting file format (%s) to 'AVI'\n", str); break;
334 case MCI_DGV_FF_AVSS: TRACE("Setting file format (%s) to 'AVSS'\n", str); break;
335 case MCI_DGV_FF_DIB: TRACE("Setting file format (%s) to 'DIB'\n", str); break;
336 case MCI_DGV_FF_JFIF: TRACE("Setting file format (%s) to 'JFIF'\n", str); break;
337 case MCI_DGV_FF_JPEG: TRACE("Setting file format (%s) to 'JPEG'\n", str); break;
338 case MCI_DGV_FF_MPEG: TRACE("Setting file format (%s) to 'MPEG'\n", str); break;
339 case MCI_DGV_FF_RDIB: TRACE("Setting file format (%s) to 'RLE DIB'\n", str); break;
340 case MCI_DGV_FF_RJPEG: TRACE("Setting file format (%s) to 'RJPEG'\n", str); break;
341 default: TRACE("Setting unknown file format (%s): %ld\n", str, lpParms->dwFileFormat);
342 }
343 }
344
345 if (dwFlags & MCI_DGV_SET_SPEED) {
346 TRACE("Setting speed to %ld\n", lpParms->dwSpeed);
347 }
348
349 return 0;
350}
351
352/***************************************************************************
353 * AVI_mciStatus [internal]
354 */
355static DWORD AVI_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSA lpParms)
356{
357 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
358 DWORD ret = 0;
359
360 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
361
362 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
363 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
364
365 if (dwFlags & MCI_STATUS_ITEM) {
366 switch (lpParms->dwItem) {
367 case MCI_STATUS_CURRENT_TRACK:
368 lpParms->dwReturn = 1;
369 TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
370 break;
371 case MCI_STATUS_LENGTH:
372 if (dwFlags & MCI_TRACK) {
373 /* lpParms->dwTrack contains track # */
374 lpParms->dwReturn = 0x1234;
375 } else {
376 lpParms->dwReturn = 0x4321;
377 }
378 TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
379 break;
380 case MCI_STATUS_MODE:
381 lpParms->dwReturn = MAKEMCIRESOURCE(wma->wStatus, wma->wStatus);
382 ret = MCI_RESOURCE_RETURNED;
383 TRACE("MCI_STATUS_MODE => %u\n", LOWORD(lpParms->dwReturn));
384 break;
385 case MCI_STATUS_MEDIA_PRESENT:
386 TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
387 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
388 ret = MCI_RESOURCE_RETURNED;
389 break;
390 case MCI_STATUS_NUMBER_OF_TRACKS:
391 lpParms->dwReturn = 3;
392 TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
393 break;
394 case MCI_STATUS_POSITION:
395 /* FIXME: do I need to use MCI_TRACK ? */
396 lpParms->dwReturn = 0x0123;
397 TRACE("MCI_STATUS_POSITION %s => %lu\n",
398 (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
399 break;
400 case MCI_STATUS_READY:
401 lpParms->dwReturn = (wma->wStatus == MCI_MODE_NOT_READY) ?
402 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
403 ret = MCI_RESOURCE_RETURNED;
404 TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
405 break;
406 case MCI_STATUS_TIME_FORMAT:
407 lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwTimeFormat, wma->dwTimeFormat);
408 TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
409 ret = MCI_RESOURCE_RETURNED;
410 break;
411 default:
412 FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
413 return MCIERR_UNRECOGNIZED_COMMAND;
414 }
415 } else {
416 WARN("No Status-Item!\n");
417 return MCIERR_UNRECOGNIZED_COMMAND;
418 }
419 if (dwFlags & MCI_NOTIFY) {
420 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
421 mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
422 wma->wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
423 }
424
425 return ret;
426}
427
428/***************************************************************************
429 * AVI_mciGetDevCaps [internal]
430 */
431static DWORD AVI_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
432{
433 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
434 DWORD ret;
435
436 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
437
438 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
439 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
440
441 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
442 switch (lpParms->dwItem) {
443 case MCI_GETDEVCAPS_DEVICE_TYPE:
444 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
445 lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
446 ret = MCI_RESOURCE_RETURNED;
447 break;
448 case MCI_GETDEVCAPS_HAS_AUDIO:
449 TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
450 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
451 ret = MCI_RESOURCE_RETURNED;
452 break;
453 case MCI_GETDEVCAPS_HAS_VIDEO:
454 TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
455 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
456 ret = MCI_RESOURCE_RETURNED;
457 break;
458 case MCI_GETDEVCAPS_USES_FILES:
459 TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
460 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
461 ret = MCI_RESOURCE_RETURNED;
462 break;
463 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
464 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
465 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
466 ret = MCI_RESOURCE_RETURNED;
467 break;
468 case MCI_GETDEVCAPS_CAN_EJECT:
469 TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
470 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
471 ret = MCI_RESOURCE_RETURNED;
472 break;
473 case MCI_GETDEVCAPS_CAN_PLAY:
474 TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
475 lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
476 ret = MCI_RESOURCE_RETURNED;
477 break;
478 case MCI_GETDEVCAPS_CAN_RECORD:
479 TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
480 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
481 ret = MCI_RESOURCE_RETURNED;
482 break;
483 case MCI_GETDEVCAPS_CAN_SAVE:
484 TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
485 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
486 ret = MCI_RESOURCE_RETURNED;
487 break;
488 default:
489 FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
490 return MCIERR_UNRECOGNIZED_COMMAND;
491 }
492 } else {
493 WARN("No GetDevCaps-Item !\n");
494 return MCIERR_UNRECOGNIZED_COMMAND;
495 }
496 return ret;
497}
498
499/***************************************************************************
500 * AVI_mciInfo [internal]
501 */
502static DWORD AVI_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSA lpParms)
503{
504 LPSTR str = 0;
505 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
506 DWORD ret = 0;
507
508 TRACE("(%04X, %08lX, %p) : stub;\n", wDevID, dwFlags, lpParms);
509
510 if (lpParms == NULL || lpParms->lpstrReturn == NULL)
511 return MCIERR_NULL_PARAMETER_BLOCK;
512 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
513
514 TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
515
516 switch (dwFlags) {
517 case MCI_INFO_PRODUCT:
518 str = "Wine's AVI player";
519 break;
520 case MCI_INFO_FILE:
521 str = "";
522 break;
523#if 0
524 /* FIXME: the following manifest constants are not defined in <WINE>/include/mmsystem.h */
525 case MCI_INFO_COPYRIGHT:
526 break;
527 case MCI_INFO_NAME:
528 break;
529#endif
530 default:
531 WARN("Don't know this info command (%lu)\n", dwFlags);
532 return MCIERR_UNRECOGNIZED_COMMAND;
533 }
534 if (str) {
535 if (lpParms->dwRetSize <= strlen(str)) {
536 lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize - 1);
537 ret = MCIERR_PARAM_OVERFLOW;
538 } else {
539 strcpy(lpParms->lpstrReturn, str);
540 }
541 } else {
542 *lpParms->lpstrReturn = 0;
543 }
544 return ret;
545}
546
547/***************************************************************************
548 * AVI_mciPut [internal]
549 */
550static DWORD AVI_mciPut(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms)
551{
552 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
553 RECT rc;
554 char buffer[256];
555
556 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
557
558 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
559 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
560
561 if (dwFlags & MCI_DGV_RECT) {
562 rc = lpParms->rc;
563 } else {
564 SetRectEmpty(&rc);
565 }
566
567 *buffer = 0;
568 if (dwFlags & MCI_DGV_PUT_CLIENT) {
569 strncat(buffer, "PUT_CLIENT", sizeof(buffer));
570 }
571 if (dwFlags & MCI_DGV_PUT_DESTINATION) {
572 strncat(buffer, "PUT_DESTINATION", sizeof(buffer));
573 }
574 if (dwFlags & MCI_DGV_PUT_FRAME) {
575 strncat(buffer, "PUT_FRAME", sizeof(buffer));
576 }
577 if (dwFlags & MCI_DGV_PUT_SOURCE) {
578 strncat(buffer, "PUT_SOURCE", sizeof(buffer));
579 }
580 if (dwFlags & MCI_DGV_PUT_VIDEO) {
581 strncat(buffer, "PUT_VIDEO", sizeof(buffer));
582 }
583 if (dwFlags & MCI_DGV_PUT_WINDOW) {
584 strncat(buffer, "PUT_WINDOW", sizeof(buffer));
585 }
586 TRACE("%s (%d,%d,%d,%d)\n", buffer, rc.left, rc.top, rc.right, rc.bottom);
587
588 return 0;
589}
590
591/***************************************************************************
592 * AVI_mciWindow [internal]
593 */
594static DWORD AVI_mciWindow(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSA lpParms)
595{
596 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
597
598 TRACE("(%04x, %08lX, %p) : stub\n", wDevID, dwFlags, lpParms);
599
600 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
601 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
602
603 if (dwFlags & MCI_DGV_WINDOW_HWND) {
604 TRACE("Setting hWnd to %08lx\n", (DWORD)lpParms->hWnd);
605 }
606 if (dwFlags & MCI_DGV_WINDOW_STATE) {
607 TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
608 }
609 if (dwFlags & MCI_DGV_WINDOW_TEXT) {
610 TRACE("Setting caption to '%s'\n", lpParms->lpstrText);
611 }
612
613 return 0;
614}
615
616/*****************************************************************************
617 * AVI_mciLoad [internal]
618 */
619static DWORD AVI_mciLoad(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_LOAD_PARMSA lpParms)
620{
621 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
622
623 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
624
625 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
626 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
627
628 return 0;
629}
630
631/******************************************************************************
632 * AVI_mciSave [internal]
633 */
634static DWORD AVI_mciSave(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SAVE_PARMSA lpParms)
635{
636 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
637
638 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
639
640 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
641 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
642
643 return 0;
644}
645
646/******************************************************************************
647 * AVI_mciFreeze [internal]
648 */
649static DWORD AVI_mciFreeze(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
650{
651 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
652
653 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
654
655 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
656 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
657
658 return 0;
659}
660
661/******************************************************************************
662 * AVI_mciRealize [internal]
663 */
664static DWORD AVI_mciRealize(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
665{
666 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
667
668 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
669
670 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
671 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
672
673 return 0;
674}
675
676/******************************************************************************
677 * AVI_mciUnFreeze [internal]
678 */
679static DWORD AVI_mciUnFreeze(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
680{
681 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
682
683 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
684
685 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
686 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
687
688 return 0;
689}
690
691/******************************************************************************
692 * AVI_mciUpdate [internal]
693 */
694static DWORD AVI_mciUpdate(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
695{
696 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
697
698 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
699
700 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
701 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
702
703 return 0;
704}
705
706/******************************************************************************
707 * AVI_mciWhere [internal]
708 */
709static DWORD AVI_mciWhere(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
710{
711 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
712
713 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
714
715 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
716 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
717
718 return 0;
719}
720
721/******************************************************************************
722 * AVI_mciStep [internal]
723 */
724static DWORD AVI_mciStep(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_STEP_PARMS lpParms)
725{
726 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
727
728 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
729
730 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
731 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
732
733 return 0;
734}
735
736/******************************************************************************
737 * AVI_mciCopy [internal]
738 */
739static DWORD AVI_mciCopy(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_COPY_PARMS lpParms)
740{
741 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
742
743 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
744
745 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
746 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
747
748 return 0;
749}
750
751/******************************************************************************
752 * AVI_mciCut [internal]
753 */
754static DWORD AVI_mciCut(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CUT_PARMS lpParms)
755{
756 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
757
758 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
759
760 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
761 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
762
763 return 0;
764}
765
766/******************************************************************************
767 * AVI_mciDelete [internal]
768 */
769static DWORD AVI_mciDelete(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_DELETE_PARMS lpParms)
770{
771 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
772
773 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
774
775 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
776 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
777
778 return 0;
779}
780
781/******************************************************************************
782 * AVI_mciPaste [internal]
783 */
784static DWORD AVI_mciPaste(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_PASTE_PARMS lpParms)
785{
786 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
787
788 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
789
790 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
791 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
792
793 return 0;
794}
795
796/******************************************************************************
797 * AVI_mciCue [internal]
798 */
799static DWORD AVI_mciCue(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CUE_PARMS lpParms)
800{
801 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
802
803 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
804
805 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
806 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
807
808 return 0;
809}
810
811/******************************************************************************
812 * AVI_mciCapture [internal]
813 */
814static DWORD AVI_mciCapture(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_CAPTURE_PARMSA lpParms)
815{
816 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
817
818 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
819
820 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
821 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
822
823 return 0;
824}
825
826/******************************************************************************
827 * AVI_mciMonitor [internal]
828 */
829static DWORD AVI_mciMonitor(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_MONITOR_PARMS lpParms)
830{
831 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
832
833 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
834
835 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
836 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
837
838 return 0;
839}
840
841/******************************************************************************
842 * AVI_mciReserve [internal]
843 */
844static DWORD AVI_mciReserve(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RESERVE_PARMSA lpParms)
845{
846 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
847
848 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
849
850 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
851 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
852
853 return 0;
854}
855
856/******************************************************************************
857 * AVI_mciSetAudio [internal]
858 */
859static DWORD AVI_mciSetAudio(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSA lpParms)
860{
861 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
862
863 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
864
865 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
866 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
867
868 return 0;
869}
870
871/******************************************************************************
872 * AVI_mciSignal [internal]
873 */
874static DWORD AVI_mciSignal(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SIGNAL_PARMS lpParms)
875{
876 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
877
878 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
879
880 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
881 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
882
883 return 0;
884}
885
886/******************************************************************************
887 * AVI_mciSetVideo [internal]
888 */
889static DWORD AVI_mciSetVideo(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_SETVIDEO_PARMSA lpParms)
890{
891 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
892
893 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
894
895 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
896 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
897
898 return 0;
899}
900
901/******************************************************************************
902 * AVI_mciQuality [internal]
903 */
904static DWORD AVI_mciQuality(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_QUALITY_PARMSA lpParms)
905{
906 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
907
908 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
909
910 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
911 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
912
913 return 0;
914}
915
916/******************************************************************************
917 * AVI_mciList [internal]
918 */
919static DWORD AVI_mciList(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_LIST_PARMSA lpParms)
920{
921 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
922
923 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
924
925 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
926 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
927
928 return 0;
929}
930
931/******************************************************************************
932 * AVI_mciUndo [internal]
933 */
934static DWORD AVI_mciUndo(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
935{
936 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
937
938 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
939
940 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
941 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
942
943 return 0;
944}
945
946/******************************************************************************
947 * AVI_mciConfigure [internal]
948 */
949static DWORD AVI_mciConfigure(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
950{
951 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
952
953 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
954
955 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
956 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
957
958 return 0;
959}
960
961/******************************************************************************
962 * AVI_mciRestore [internal]
963 */
964static DWORD AVI_mciRestore(UINT16 wDevID, DWORD dwFlags, LPMCI_DGV_RESTORE_PARMSA lpParms)
965{
966 WINE_MCIAVI* wma = AVI_mciGetOpenDev(wDevID);
967
968 TRACE("(%04x, %08lx, %p) : stub\n", wDevID, dwFlags, lpParms);
969
970 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
971 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
972
973 return 0;
974}
975
976/*======================================================================*
977 * MCI AVI entry points *
978 *======================================================================*/
979
980/**************************************************************************
981 * MCIAVI_DriverProc [sample driver]
982 */
983LONG CALLBACK MCIAVI_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
984 DWORD dwParam1, DWORD dwParam2)
985{
986 switch (wMsg) {
987 case DRV_LOAD: return 1;
988 case DRV_FREE: return 1;
989 case DRV_OPEN: return AVI_drvOpen((LPSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSA)dwParam2);
990 case DRV_CLOSE: return AVI_drvClose(dwDevID);
991 case DRV_ENABLE: return 1;
992 case DRV_DISABLE: return 1;
993 case DRV_QUERYCONFIGURE: return 1;
994 case DRV_CONFIGURE: MessageBoxA(0, "Sample AVI Wine Driver !", "MM-Wine Driver", MB_OK); return 1;
995 case DRV_INSTALL: return DRVCNF_RESTART;
996 case DRV_REMOVE: return DRVCNF_RESTART;
997
998 case MCI_OPEN_DRIVER: return AVI_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSA) dwParam2);
999 case MCI_CLOSE_DRIVER: return AVI_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1000 case MCI_PLAY: return AVI_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1001 case MCI_RECORD: return AVI_mciRecord (dwDevID, dwParam1, (LPMCI_DGV_RECORD_PARMS) dwParam2);
1002 case MCI_STOP: return AVI_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1003 case MCI_SET: return AVI_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1004 case MCI_PAUSE: return AVI_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1005 case MCI_RESUME: return AVI_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1006 case MCI_STATUS: return AVI_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSA) dwParam2);
1007 case MCI_GETDEVCAPS: return AVI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1008 case MCI_INFO: return AVI_mciInfo (dwDevID, dwParam1, (LPMCI_DGV_INFO_PARMSA) dwParam2);
1009 case MCI_SEEK: return AVI_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1010 case MCI_PUT: return AVI_mciPut (dwDevID, dwParam1, (LPMCI_DGV_PUT_PARMS) dwParam2);
1011 case MCI_WINDOW: return AVI_mciWindow (dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSA) dwParam2);
1012 case MCI_LOAD: return AVI_mciLoad (dwDevID, dwParam1, (LPMCI_DGV_LOAD_PARMSA) dwParam2);
1013 case MCI_SAVE: return AVI_mciSave (dwDevID, dwParam1, (LPMCI_DGV_SAVE_PARMSA) dwParam2);
1014 case MCI_FREEZE: return AVI_mciFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1015 case MCI_REALIZE: return AVI_mciRealize (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1016 case MCI_UNFREEZE: return AVI_mciUnFreeze (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1017 case MCI_UPDATE: return AVI_mciUpdate (dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS) dwParam2);
1018 case MCI_WHERE: return AVI_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1019 case MCI_STEP: return AVI_mciStep (dwDevID, dwParam1, (LPMCI_DGV_STEP_PARMS) dwParam2);
1020 case MCI_COPY: return AVI_mciCopy (dwDevID, dwParam1, (LPMCI_DGV_COPY_PARMS) dwParam2);
1021 case MCI_CUT: return AVI_mciCut (dwDevID, dwParam1, (LPMCI_DGV_CUT_PARMS) dwParam2);
1022 case MCI_DELETE: return AVI_mciDelete (dwDevID, dwParam1, (LPMCI_DGV_DELETE_PARMS) dwParam2);
1023 case MCI_PASTE: return AVI_mciPaste (dwDevID, dwParam1, (LPMCI_DGV_PASTE_PARMS) dwParam2);
1024 case MCI_CUE: return AVI_mciCue (dwDevID, dwParam1, (LPMCI_DGV_CUE_PARMS) dwParam2);
1025 /* Digital Video specific */
1026 case MCI_CAPTURE: return AVI_mciCapture (dwDevID, dwParam1, (LPMCI_DGV_CAPTURE_PARMSA) dwParam2);
1027 case MCI_MONITOR: return AVI_mciMonitor (dwDevID, dwParam1, (LPMCI_DGV_MONITOR_PARMS) dwParam2);
1028 case MCI_RESERVE: return AVI_mciReserve (dwDevID, dwParam1, (LPMCI_DGV_RESERVE_PARMSA) dwParam2);
1029 case MCI_SETAUDIO: return AVI_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSA) dwParam2);
1030 case MCI_SIGNAL: return AVI_mciSignal (dwDevID, dwParam1, (LPMCI_DGV_SIGNAL_PARMS) dwParam2);
1031 case MCI_SETVIDEO: return AVI_mciSetVideo (dwDevID, dwParam1, (LPMCI_DGV_SETVIDEO_PARMSA) dwParam2);
1032 case MCI_QUALITY: return AVI_mciQuality (dwDevID, dwParam1, (LPMCI_DGV_QUALITY_PARMSA) dwParam2);
1033 case MCI_LIST: return AVI_mciList (dwDevID, dwParam1, (LPMCI_DGV_LIST_PARMSA) dwParam2);
1034 case MCI_UNDO: return AVI_mciUndo (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1035 case MCI_CONFIGURE: return AVI_mciConfigure (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1036 case MCI_RESTORE: return AVI_mciRestore (dwDevID, dwParam1, (LPMCI_DGV_RESTORE_PARMSA) dwParam2);
1037
1038 case MCI_SPIN:
1039 case MCI_ESCAPE:
1040 WARN("Unsupported command [%lu]\n", wMsg);
1041 break;
1042 case MCI_OPEN:
1043 case MCI_CLOSE:
1044 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1045 break;
1046 default:
1047 TRACE("Sending msg [%lu] to default driver proc\n", wMsg);
1048 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1049 }
1050 return MCIERR_UNRECOGNIZED_COMMAND;
1051}
1052
1053
Note: See TracBrowser for help on using the repository browser.