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