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