?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 950109
[wine/multimedia.git] / multimedia / mcianim.c
blob331ea5217dc2bd2a3b49765ab7c1f3ef9017e92f
1 /*
2 * Sample MCI ANIMATION Wine Driver for Linux
3 *
4 * Copyright 1994 Martin Ayotte
5 *
6 static char Copyright[] = "Copyright Martin Ayotte, 1994";
7 */
8 #ifndef WINELIB
9 #define BUILTIN_MMSYSTEM
10 #endif
11
12 #ifdef BUILTIN_MMSYSTEM
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17 #include <string.h>
18 #include <fcntl.h>
19 #include <sys/ioctl.h>
20 #include "win.h"
21 #include "user.h"
22 #include "driver.h"
23 #include "mmsystem.h"
24 #include "stddebug.h"
25 /* #define DEBUG_MCIANIM */
26 #define DEBUG_MCIANIM
27 #include "debug.h"
28
29 #define MAX_ANIMDRV 2
30
31 #define ANIMFRAMES_PERSEC 30
32 #define ANIMFRAMES_PERMIN 1800
33 #define SECONDS_PERMIN 60
34
35 #ifdef linux
36 typedef struct {
37 int nUseCount; /* Incremented for each shared open */
38 BOOL fShareable; /* TRUE if first open was shareable */
39 WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
40 HANDLE hCallback; /* Callback handle for pending notification */
41 MCI_OPEN_PARMS openParms;
42 DWORD dwTimeFormat;
43 int mode;
44 UINT nCurTrack;
45 DWORD dwCurFrame;
46 UINT nTracks;
47 DWORD dwTotalLen;
48 LPDWORD lpdwTrackLen;
49 LPDWORD lpdwTrackPos;
50 } LINUX_ANIM;
51
52 static LINUX_ANIM AnimDev[MAX_ANIMDRV];
53 #endif
54
55
56 DWORD ANIM_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame);
57 DWORD ANIM_CalcFrame(UINT wDevID, DWORD dwFormatType, DWORD dwTime);
58
59
60 /*-----------------------------------------------------------------------*/
61
62 /**************************************************************************
63 * ANIM_mciOpen [internal]
64 */
65 DWORD ANIM_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
66 {
67 #ifdef linux
68 UINT wDevID;
69 dprintf_mcianim(stddeb,"ANIM_mciOpen(%08lX, %p);\n", dwFlags, lpParms);
70 if (lpParms == NULL) return MCIERR_INTERNAL;
71 wDevID = lpParms->wDeviceID;
72 if (AnimDev[wDevID].nUseCount > 0) {
73 /* The driver already open on this channel */
74 /* If the driver was opened shareable before and this open specifies */
75 /* shareable then increment the use count */
76 if (AnimDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
77 ++AnimDev[wDevID].nUseCount;
78 else
79 return MCIERR_MUST_USE_SHAREABLE;
80 }
81 else {
82 AnimDev[wDevID].nUseCount = 1;
83 AnimDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
84 }
85 if (dwFlags & MCI_OPEN_ELEMENT) {
86 dprintf_mcianim(stddeb,"ANIM_mciOpen // MCI_OPEN_ELEMENT !\n");
87 printf("ANIM_mciOpen // MCI_OPEN_ELEMENT !\n");
88 /* return MCIERR_NO_ELEMENT_ALLOWED; */
89 }
90 memcpy(&AnimDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
91 AnimDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
92 AnimDev[wDevID].mode = 0;
93 AnimDev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF;
94 AnimDev[wDevID].nCurTrack = 0;
95 AnimDev[wDevID].nTracks = 0;
96 AnimDev[wDevID].dwTotalLen = 0;
97 AnimDev[wDevID].lpdwTrackLen = NULL;
98 AnimDev[wDevID].lpdwTrackPos = NULL;
99 if (dwFlags & MCI_NOTIFY) {
100 dprintf_mcianim(stddeb,
101 "ANIM_mciOpen // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
102 lpParms->dwCallback);
103 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
104 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
105 }
106 return 0;
107 #else
108 return MCIERR_HARDWARE;
109 #endif
110 }
111
112 /**************************************************************************
113 * ANIM_mciClose [internal]
114 */
115 DWORD ANIM_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
116 {
117 #ifdef linux
118 dprintf_mcianim(stddeb,"ANIM_mciClose(%u, %08lX, %p);\n",
119 wDevID, dwParam, lpParms);
120 if (AnimDev[wDevID].lpdwTrackLen != NULL) free(AnimDev[wDevID].lpdwTrackLen);
121 if (AnimDev[wDevID].lpdwTrackPos != NULL) free(AnimDev[wDevID].lpdwTrackPos);
122 #endif
123 return 0;
124 }
125
126 /**************************************************************************
127 * ANIM_mciGetDevCaps [internal]
128 */
129 DWORD ANIM_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
130 LPMCI_GETDEVCAPS_PARMS lpParms)
131 {
132 #ifdef linux
133 dprintf_mcianim(stddeb,"ANIM_mciGetDevCaps(%u, %08lX, %p);\n",
134 wDevID, dwFlags, lpParms);
135 if (lpParms == NULL) return MCIERR_INTERNAL;
136 if (dwFlags & MCI_GETDEVCAPS_ITEM) {
137 dprintf_mcianim(stddeb,
138 "ANIM_mciGetDevCaps // MCI_GETDEVCAPS_ITEM dwItem=%08lX;\n",
139 lpParms->dwItem);
140 switch(lpParms->dwItem) {
141 case MCI_GETDEVCAPS_CAN_RECORD:
142 lpParms->dwReturn = FALSE;
143 break;
144 case MCI_GETDEVCAPS_HAS_AUDIO:
145 lpParms->dwReturn = FALSE;
146 break;
147 case MCI_GETDEVCAPS_HAS_VIDEO:
148 lpParms->dwReturn = FALSE;
149 break;
150 case MCI_GETDEVCAPS_DEVICE_TYPE:
151 lpParms->dwReturn = MCI_DEVTYPE_ANIMATION;
152 break;
153 case MCI_GETDEVCAPS_USES_FILES:
154 lpParms->dwReturn = TRUE;
155 break;
156 case MCI_GETDEVCAPS_COMPOUND_DEVICE:
157 lpParms->dwReturn = FALSE;
158 break;
159 case MCI_GETDEVCAPS_CAN_EJECT:
160 lpParms->dwReturn = TRUE;
161 break;
162 case MCI_GETDEVCAPS_CAN_PLAY:
163 lpParms->dwReturn = FALSE;
164 break;
165 case MCI_GETDEVCAPS_CAN_SAVE:
166 lpParms->dwReturn = FALSE;
167 break;
168 default:
169 return MCIERR_UNRECOGNIZED_COMMAND;
170 }
171 }
172 dprintf_mcianim(stddeb,
173 "ANIM_mciGetDevCaps // lpParms->dwReturn=%08lX;\n",
174 lpParms->dwReturn);
175 return 0;
176 #else
177 return MCIERR_INTERNAL;
178 #endif
179 }
180
181 /**************************************************************************
182 * ANIM_mciInfo [internal]
183 */
184 DWORD ANIM_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
185 {
186 #ifdef linux
187 dprintf_mcianim(stddeb,"ANIM_mciInfo(%u, %08lX, %p);\n",
188 wDevID, dwFlags, lpParms);
189 if (lpParms == NULL) return MCIERR_INTERNAL;
190 lpParms->lpstrReturn = NULL;
191 switch(dwFlags) {
192 case MCI_INFO_PRODUCT:
193 lpParms->lpstrReturn = "Linux ANIMATION 0.5";
194 break;
195 case MCI_INFO_FILE:
196 lpParms->lpstrReturn =
197 (LPSTR)AnimDev[wDevID].openParms.lpstrElementName;
198 break;
199 case MCI_ANIM_INFO_TEXT:
200 lpParms->lpstrReturn = "Animation Window";
201 break;
202 default:
203 return MCIERR_UNRECOGNIZED_COMMAND;
204 }
205 if (lpParms->lpstrReturn != NULL)
206 lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
207 else
208 lpParms->dwRetSize = 0;
209 return 0;
210 #else
211 return MCIERR_INTERNAL;
212 #endif
213 }
214
215 /**************************************************************************
216 * ANIM_mciStatus [internal]
217 */
218 DWORD ANIM_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
219 {
220 #ifdef linux
221 dprintf_mcianim(stddeb,"ANIM_mciStatus(%u, %08lX, %p);\n",
222 wDevID, dwFlags, lpParms);
223 if (lpParms == NULL) return MCIERR_INTERNAL;
224 if (dwFlags & MCI_NOTIFY) {
225 dprintf_mcianim(stddeb,
226 "ANIM_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
227 lpParms->dwCallback);
228 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
229 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
230 }
231 if (dwFlags & MCI_STATUS_ITEM) {
232 switch(lpParms->dwItem) {
233 case MCI_STATUS_CURRENT_TRACK:
234 lpParms->dwReturn = AnimDev[wDevID].nCurTrack;
235 dprintf_mcianim(stddeb,"ANIM_mciStatus // CURRENT_TRACK=%lu!\n", lpParms->dwReturn);
236 return 0;
237 case MCI_STATUS_LENGTH:
238 if (dwFlags & MCI_TRACK) {
239 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_TRACK #%lu LENGTH=??? !\n",
240 lpParms->dwTrack);
241 if (lpParms->dwTrack > AnimDev[wDevID].nTracks)
242 return MCIERR_OUTOFRANGE;
243 lpParms->dwReturn = AnimDev[wDevID].lpdwTrackLen[lpParms->dwTrack];
244 }
245 else
246 lpParms->dwReturn = AnimDev[wDevID].dwTotalLen;
247 lpParms->dwReturn = ANIM_CalcTime(wDevID,
248 AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn);
249 dprintf_mcianim(stddeb,"ANIM_mciStatus // LENGTH=%lu !\n", lpParms->dwReturn);
250 return 0;
251 case MCI_STATUS_MODE:
252 lpParms->dwReturn = AnimDev[wDevID].mode;
253 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_MODE=%08lX !\n",
254 lpParms->dwReturn);
255 return 0;
256 case MCI_STATUS_MEDIA_PRESENT:
257 lpParms->dwReturn = TRUE;
258 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
259 return 0;
260 case MCI_STATUS_NUMBER_OF_TRACKS:
261 lpParms->dwReturn = 1;
262 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_NUMBER_OF_TRACKS = %lu !\n",
263 lpParms->dwReturn);
264 if (lpParms->dwReturn == (WORD)-1) return MCIERR_INTERNAL;
265 return 0;
266 case MCI_STATUS_POSITION:
267 lpParms->dwReturn = AnimDev[wDevID].dwCurFrame;
268 if (dwFlags & MCI_STATUS_START) {
269 lpParms->dwReturn = 0;
270 dprintf_mcianim(stddeb,"CDAUDIO_mciStatus // get MCI_STATUS_START !\n");
271 }
272 if (dwFlags & MCI_TRACK) {
273 if (lpParms->dwTrack > AnimDev[wDevID].nTracks)
274 return MCIERR_OUTOFRANGE;
275 lpParms->dwReturn = AnimDev[wDevID].lpdwTrackPos[lpParms->dwTrack - 1];
276 dprintf_mcianim(stddeb,"ANIM_mciStatus // get MCI_TRACK #%lu !\n", lpParms->dwTrack);
277 }
278 lpParms->dwReturn = ANIM_CalcTime(wDevID,
279 AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn);
280 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_POSITION=%08lX !\n",
281 lpParms->dwReturn);
282 return 0;
283 case MCI_STATUS_READY:
284 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_READY !\n");
285 lpParms->dwReturn = TRUE;
286 return 0;
287 case MCI_STATUS_TIME_FORMAT:
288 dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
289 lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
290 return 0;
291 default:
292 fprintf(stderr,"ANIM_mciStatus // unknown command %08lX !\n", lpParms->dwItem);
293 return MCIERR_UNRECOGNIZED_COMMAND;
294 }
295 }
296 fprintf(stderr,"ANIM_mciStatus // not MCI_STATUS_ITEM !\n");
297 return 0;
298 #else
299 return MMSYSERR_NOTENABLED;
300 #endif
301 }
302
303
304 /**************************************************************************
305 * ANIM_CalcTime [internal]
306 */
307 DWORD ANIM_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame)
308 {
309 DWORD dwTime = 0;
310 #ifdef linux
311 UINT wTrack;
312 UINT wMinutes;
313 UINT wSeconds;
314 UINT wFrames;
315 dprintf_mcianim(stddeb,"ANIM_CalcTime(%u, %08lX, %lu);\n",
316 wDevID, dwFormatType, dwFrame);
317 TryAGAIN:
318 switch (dwFormatType) {
319 case MCI_FORMAT_MILLISECONDS:
320 dwTime = dwFrame / ANIMFRAMES_PERSEC * 1000;
321 dprintf_mcianim(stddeb,
322 "ANIM_CalcTime // MILLISECONDS %lu\n", dwTime);
323 break;
324 case MCI_FORMAT_MSF:
325 wMinutes = dwFrame / ANIMFRAMES_PERMIN;
326 wSeconds = (dwFrame - ANIMFRAMES_PERMIN * wMinutes) / ANIMFRAMES_PERSEC;
327 wFrames = dwFrame - ANIMFRAMES_PERMIN * wMinutes -
328 ANIMFRAMES_PERSEC * wSeconds;
329 dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
330 dprintf_mcianim(stddeb,"ANIM_CalcTime // MSF %02u:%02u:%02u -> dwTime=%lu\n",
331 wMinutes, wSeconds, wFrames, dwTime);
332 break;
333 case MCI_FORMAT_TMSF:
334 for (wTrack = 0; wTrack < AnimDev[wDevID].nTracks; wTrack++) {
335 /* dwTime += AnimDev[wDevID].lpdwTrackLen[wTrack - 1];
336 printf("Adding trk#%u curpos=%u \n", dwTime);
337 if (dwTime >= dwFrame) break; */
338 if (AnimDev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break;
339 }
340 wMinutes = dwFrame / ANIMFRAMES_PERMIN;
341 wSeconds = (dwFrame - ANIMFRAMES_PERMIN * wMinutes) / ANIMFRAMES_PERSEC;
342 wFrames = dwFrame - ANIMFRAMES_PERMIN * wMinutes -
343 ANIMFRAMES_PERSEC * wSeconds;
344 dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
345 dprintf_mcianim(stddeb,
346 "ANIM_CalcTime // %02u-%02u:%02u:%02u\n",
347 wTrack, wMinutes, wSeconds, wFrames);
348 break;
349 default:
350 /* unknown format ! force TMSF ! ... */
351 dwFormatType = MCI_FORMAT_TMSF;
352 goto TryAGAIN;
353 }
354 #endif
355 return dwTime;
356 }
357
358
359 /**************************************************************************
360 * ANIM_CalcFrame [internal]
361 */
362 DWORD ANIM_CalcFrame(UINT wDevID, DWORD dwFormatType, DWORD dwTime)
363 {
364 DWORD dwFrame = 0;
365 #ifdef linux
366 UINT wTrack;
367 dprintf_mcianim(stddeb,"ANIM_CalcFrame(%u, %08lX, %lu);\n",
368 wDevID, dwFormatType, dwTime);
369 TryAGAIN:
370 switch (dwFormatType) {
371 case MCI_FORMAT_MILLISECONDS:
372 dwFrame = dwTime * ANIMFRAMES_PERSEC / 1000;
373 dprintf_mcianim(stddeb,
374 "ANIM_CalcFrame // MILLISECONDS %lu\n", dwFrame);
375 break;
376 case MCI_FORMAT_MSF:
377 dprintf_mcianim(stddeb,
378 "ANIM_CalcFrame // MSF %02u:%02u:%02u\n",
379 MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime),
380 MCI_MSF_FRAME(dwTime));
381 dwFrame += ANIMFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
382 dwFrame += ANIMFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
383 dwFrame += MCI_MSF_FRAME(dwTime);
384 break;
385 case MCI_FORMAT_TMSF:
386 wTrack = MCI_TMSF_TRACK(dwTime);
387 dprintf_mcianim(stddeb,
388 "ANIM_CalcFrame // TMSF %02u-%02u:%02u:%02u\n",
389 MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
390 MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
391 dprintf_mcianim(stddeb,
392 "ANIM_CalcFrame // TMSF trackpos[%u]=%lu\n",
393 wTrack, AnimDev[wDevID].lpdwTrackPos[wTrack - 1]);
394 dwFrame = AnimDev[wDevID].lpdwTrackPos[wTrack - 1];
395 dwFrame += ANIMFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime);
396 dwFrame += ANIMFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime);
397 dwFrame += MCI_TMSF_FRAME(dwTime);
398 break;
399 default:
400 /* unknown format ! force TMSF ! ... */
401 dwFormatType = MCI_FORMAT_TMSF;
402 goto TryAGAIN;
403 }
404 #endif
405 return dwFrame;
406 }
407
408
409
410 /**************************************************************************
411 * ANIM_mciPlay [internal]
412 */
413 DWORD ANIM_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
414 {
415 #ifdef linux
416 int start, end;
417 dprintf_mcianim(stddeb,"ANIM_mciPlay(%u, %08lX, %p);\n",
418 wDevID, dwFlags, lpParms);
419 if (lpParms == NULL) return MCIERR_INTERNAL;
420 start = 0; end = AnimDev[wDevID].dwTotalLen;
421 AnimDev[wDevID].nCurTrack = 1;
422 if (dwFlags & MCI_FROM) {
423 start = ANIM_CalcFrame(wDevID,
424 AnimDev[wDevID].dwTimeFormat, lpParms->dwFrom);
425 dprintf_mcianim(stddeb,"ANIM_mciPlay // MCI_FROM=%08lX -> %u \n",
426 lpParms->dwFrom, start);
427 }
428 if (dwFlags & MCI_TO) {
429 end = ANIM_CalcFrame(wDevID,
430 AnimDev[wDevID].dwTimeFormat, lpParms->dwTo);
431 dprintf_mcianim(stddeb,
432 "ANIM_mciPlay // MCI_TO=%08lX -> %u \n",
433 lpParms->dwTo, end);
434 }
435 AnimDev[wDevID].mode = MCI_MODE_PLAY;
436 if (dwFlags & MCI_NOTIFY) {
437 dprintf_mcianim(stddeb,
438 "ANIM_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
439 lpParms->dwCallback);
440 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
441 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
442 }
443 return 0;
444 #else
445 return MCIERR_HARDWARE;
446 #endif
447 }
448
449 /**************************************************************************
450 * ANIM_mciStop [internal]
451 */
452 DWORD ANIM_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
453 {
454 #ifdef linux
455 dprintf_mcianim(stddeb,"ANIM_mciStop(%u, %08lX, %p);\n",
456 wDevID, dwFlags, lpParms);
457 if (lpParms == NULL) return MCIERR_INTERNAL;
458 AnimDev[wDevID].mode = MCI_MODE_STOP;
459 if (dwFlags & MCI_NOTIFY) {
460 dprintf_mcianim(stddeb,
461 "ANIM_mciStop // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
462 lpParms->dwCallback);
463 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
464 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
465 }
466 return 0;
467 #else
468 return MCIERR_HARDWARE;
469 #endif
470 }
471
472 /**************************************************************************
473 * ANIM_mciPause [internal]
474 */
475 DWORD ANIM_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
476 {
477 #ifdef linux
478 dprintf_mcianim(stddeb,"ANIM_mciPause(%u, %08lX, %p);\n",
479 wDevID, dwFlags, lpParms);
480 if (lpParms == NULL) return MCIERR_INTERNAL;
481 AnimDev[wDevID].mode = MCI_MODE_PAUSE;
482 if (dwFlags & MCI_NOTIFY) {
483 dprintf_mcianim(stddeb,
484 "ANIM_mciPause // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
485 lpParms->dwCallback);
486 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
487 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
488 }
489 return 0;
490 #else
491 return MCIERR_HARDWARE;
492 #endif
493 }
494
495 /**************************************************************************
496 * ANIM_mciResume [internal]
497 */
498 DWORD ANIM_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
499 {
500 #ifdef linux
501 dprintf_mcianim(stddeb,"ANIM_mciResume(%u, %08lX, %p);\n",
502 wDevID, dwFlags, lpParms);
503 if (lpParms == NULL) return MCIERR_INTERNAL;
504 AnimDev[wDevID].mode = MCI_MODE_STOP;
505 if (dwFlags & MCI_NOTIFY) {
506 dprintf_mcianim(stddeb,
507 "ANIM_mciResume // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
508 lpParms->dwCallback);
509 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
510 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
511 }
512 return 0;
513 #else
514 return MCIERR_HARDWARE;
515 #endif
516 }
517
518 /**************************************************************************
519 * ANIM_mciSeek [internal]
520 */
521 DWORD ANIM_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
522 {
523 #ifdef linux
524 DWORD dwRet;
525 MCI_PLAY_PARMS PlayParms;
526 dprintf_mcianim(stddeb,"ANIM_mciSeek(%u, %08lX, %p);\n",
527 wDevID, dwFlags, lpParms);
528 if (lpParms == NULL) return MCIERR_INTERNAL;
529 AnimDev[wDevID].mode = MCI_MODE_SEEK;
530 switch(dwFlags) {
531 case MCI_SEEK_TO_START:
532 PlayParms.dwFrom = 0;
533 break;
534 case MCI_SEEK_TO_END:
535 PlayParms.dwFrom = AnimDev[wDevID].dwTotalLen;
536 break;
537 case MCI_TO:
538 PlayParms.dwFrom = lpParms->dwTo;
539 break;
540 }
541 dwRet = ANIM_mciPlay(wDevID, MCI_WAIT | MCI_FROM, &PlayParms);
542 if (dwRet != 0) return dwRet;
543 dwRet = ANIM_mciStop(wDevID, MCI_WAIT, (LPMCI_GENERIC_PARMS)&PlayParms);
544 if (dwFlags & MCI_NOTIFY) {
545 dprintf_mcianim(stddeb,
546 "ANIM_mciSeek // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
547 lpParms->dwCallback);
548 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
549 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
550 }
551 return dwRet;
552 #else
553 return MCIERR_HARDWARE;
554 #endif
555 }
556
557
558 /**************************************************************************
559 * ANIM_mciSet [internal]
560 */
561 DWORD ANIM_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
562 {
563 #ifdef linux
564 dprintf_mcianim(stddeb,"ANIM_mciSet(%u, %08lX, %p);\n",
565 wDevID, dwFlags, lpParms);
566 if (lpParms == NULL) return MCIERR_INTERNAL;
567 /*
568 printf("ANIM_mciSet // dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
569 printf("ANIM_mciSet // dwAudio=%08lX\n", lpParms->dwAudio);
570 */
571 if (dwFlags & MCI_SET_TIME_FORMAT) {
572 switch (lpParms->dwTimeFormat) {
573 case MCI_FORMAT_MILLISECONDS:
574 dprintf_mcianim(stddeb,
575 "ANIM_mciSet // MCI_FORMAT_MILLISECONDS !\n");
576 break;
577 case MCI_FORMAT_MSF:
578 dprintf_mcianim(stddeb,"ANIM_mciSet // MCI_FORMAT_MSF !\n");
579 break;
580 case MCI_FORMAT_TMSF:
581 dprintf_mcianim(stddeb,"ANIM_mciSet // MCI_FORMAT_TMSF !\n");
582 break;
583 default:
584 fprintf(stderr,"ANIM_mciSet // bad time format !\n");
585 return MCIERR_BAD_TIME_FORMAT;
586 }
587 AnimDev[wDevID].dwTimeFormat = lpParms->dwTimeFormat;
588 }
589 if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
590 if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
591 if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
592 if (dwFlags & MCI_NOTIFY) {
593 dprintf_mcianim(stddeb,
594 "ANIM_mciSet // MCI_NOTIFY_SUCCESSFUL %08lX !\n",
595 lpParms->dwCallback);
596 mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
597 AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
598 }
599 return 0;
600 #else
601 return MCIERR_HARDWARE;
602 #endif
603 }
604
605
606 /**************************************************************************
607 * ANIM_DriverProc [sample driver]
608 */
609 LRESULT ANIM_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
610 DWORD dwParam1, DWORD dwParam2)
611 {
612 #ifdef linux
613 switch(wMsg) {
614 case DRV_LOAD:
615 return (LRESULT)1L;
616 case DRV_FREE:
617 return (LRESULT)1L;
618 case DRV_OPEN:
619 case MCI_OPEN_DRIVER:
620 case MCI_OPEN:
621 return ANIM_mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
622 case DRV_CLOSE:
623 case MCI_CLOSE_DRIVER:
624 case MCI_CLOSE:
625 return ANIM_mciClose(dwDevID, dwParam1,
626 (LPMCI_GENERIC_PARMS)dwParam2);
627 case DRV_ENABLE:
628 return (LRESULT)1L;
629 case DRV_DISABLE:
630 return (LRESULT)1L;
631 case DRV_QUERYCONFIGURE:
632 return (LRESULT)1L;
633 case DRV_CONFIGURE:
634 MessageBox((HWND)NULL, "Sample MultiMedia Linux Driver !",
635 "MMLinux Driver", MB_OK);
636 return (LRESULT)1L;
637 case DRV_INSTALL:
638 return (LRESULT)DRVCNF_RESTART;
639 case DRV_REMOVE:
640 return (LRESULT)DRVCNF_RESTART;
641 case MCI_GETDEVCAPS:
642 return ANIM_mciGetDevCaps(dwDevID, dwParam1,
643 (LPMCI_GETDEVCAPS_PARMS)dwParam2);
644 case MCI_INFO:
645 return ANIM_mciInfo(dwDevID, dwParam1,
646 (LPMCI_INFO_PARMS)dwParam2);
647 case MCI_STATUS:
648 return ANIM_mciStatus(dwDevID, dwParam1,
649 (LPMCI_STATUS_PARMS)dwParam2);
650 case MCI_SET:
651 return ANIM_mciSet(dwDevID, dwParam1,
652 (LPMCI_SET_PARMS)dwParam2);
653 case MCI_PLAY:
654 return ANIM_mciPlay(dwDevID, dwParam1,
655 (LPMCI_PLAY_PARMS)dwParam2);
656 case MCI_STOP:
657 return ANIM_mciStop(dwDevID, dwParam1,
658 (LPMCI_GENERIC_PARMS)dwParam2);
659 case MCI_PAUSE:
660 return ANIM_mciPause(dwDevID, dwParam1,
661 (LPMCI_GENERIC_PARMS)dwParam2);
662 case MCI_RESUME:
663 return ANIM_mciResume(dwDevID, dwParam1,
664 (LPMCI_GENERIC_PARMS)dwParam2);
665 case MCI_SEEK:
666 return ANIM_mciSeek(dwDevID, dwParam1,
667 (LPMCI_SEEK_PARMS)dwParam2);
668 default:
669 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
670 }
671 #else
672 return MCIERR_HARDWARE;
673 #endif
674 }
675
676
677 /*-----------------------------------------------------------------------*/
678
679 #endif /* #ifdef BUILTIN_MMSYSTEM */
Maarten's multimedia branch