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