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