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