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