?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Authors: Chris Morgan <cmorgan@wpi.edu>, James Abbatiello <abbejy@wpi.edu>
[wine/multimedia.git] / multimedia / mcistring.c
blobb471e3d535a454be36c06c28815dcd313f599836
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MCI stringinterface
5 *
6 * Copyright 1995 Marcus Meissner
7 */
8 /* FIXME: special commands of device drivers should be handled by those drivers
9 */
10
11 /* FIXME: this current implementation does not allow commands like
12 * capability <filename> can play
13 * which is allowed by the MCI standard.
14 */
15
16 #include <unistd.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <fcntl.h>
20 #include <sys/ioctl.h>
21 #include "multimedia.h"
22 #include "heap.h"
23 #include "ldt.h"
24 #include "user.h"
25 #include "driver.h"
26 #include "callback.h"
27 #include "debug.h"
28 #include "xmalloc.h"
29
30 DEFAULT_DEBUG_CHANNEL(mci)
31
32 /* The reason why I just don't lowercase the keywords array in
33 * mciSendString is left as an exercise to the reader.
34 */
35 #define STRCMP(x,y) lstrcmpiA(x,y)
36
37 /* standard function parameters for all functions */
38 #define _MCISTR_PROTO_ \
39 WORD wDevID, WORD uDevTyp, LPSTR lpstrReturnString, \
40 UINT16 uReturnLength, LPCSTR dev, LPSTR *keywords, \
41 UINT16 nrofkeywords, DWORD dwFlags, HWND16 hwndCallback
42
43 /* copy string to return pointer including necessary checks
44 * for use in mciSendString()
45 */
46 #define _MCI_STR(s) \
47 do { \
48 TRACE(mci, "->returns '%s'\n", s); \
49 if (lpstrReturnString) { \
50 lstrcpynA(lpstrReturnString, s, uReturnLength); \
51 TRACE(mci, "-->'%s'\n", lpstrReturnString); \
52 } \
53 } while(0)
54
55 /* print a DWORD in the specified timeformat */
56 static void
57 _MCISTR_printtf(char *buf, UINT16 uDevType, DWORD timef, DWORD val)
58 {
59 *buf = '\0';
60 switch (timef) {
61 case MCI_FORMAT_MILLISECONDS:
62 case MCI_FORMAT_FRAMES:
63 case MCI_FORMAT_BYTES:
64 case MCI_FORMAT_SAMPLES:
65 case MCI_VD_FORMAT_TRACK:
66 /*case MCI_SEQ_FORMAT_SONGPTR: sameas MCI_VD_FORMAT_TRACK */
67 sprintf(buf, "%ld",val);
68 break;
69 case MCI_FORMAT_HMS:
70 /* well, the macros have the same content*/
71 /*FALLTRHOUGH*/
72 case MCI_FORMAT_MSF:
73 sprintf(buf, "%d:%d:%d",
74 MCI_HMS_HOUR(val),
75 MCI_HMS_MINUTE(val),
76 MCI_HMS_SECOND(val));
77 break;
78 case MCI_FORMAT_TMSF:
79 sprintf(buf, "%d:%d:%d:%d",
80 MCI_TMSF_TRACK(val),
81 MCI_TMSF_MINUTE(val),
82 MCI_TMSF_SECOND(val),
83 MCI_TMSF_FRAME(val));
84 break;
85 default:
86 FIXME(mci, "missing timeformat for %ld, report.\n",timef);
87 strcpy(buf,"0"); /* hmm */
88 break;
89 }
90 return;
91 }
92 /* possible different return types */
93 #define _MCISTR_int 1
94 #define _MCISTR_time 2
95 #define _MCISTR_bool 3
96 #define _MCISTR_tfname 4
97 #define _MCISTR_mode 5
98 #define _MCISTR_divtype 6
99 #define _MCISTR_seqtype 7
100 #define _MCISTR_vdmtype 8
101 #define _MCISTR_devtype 9
102
103 static void
104 _MCISTR_convreturn(int type, DWORD dwReturn, LPSTR lpstrReturnString,
105 WORD uReturnLength, WORD uDevTyp, int timef)
106 {
107 switch (type) {
108 case _MCISTR_vdmtype:
109 switch (dwReturn) {
110 case MCI_VD_MEDIA_CLV: _MCI_STR("CLV"); break;
111 case MCI_VD_MEDIA_CAV: _MCI_STR("CAV"); break;
112 default:
113 case MCI_VD_MEDIA_OTHER:_MCI_STR("other"); break;
114 }
115 break;
116 case _MCISTR_seqtype:
117 switch (dwReturn) {
118 case MCI_SEQ_NONE: _MCI_STR("none"); break;
119 case MCI_SEQ_SMPTE: _MCI_STR("smpte"); break;
120 case MCI_SEQ_FILE: _MCI_STR("file"); break;
121 case MCI_SEQ_MIDI: _MCI_STR("midi"); break;
122 default:FIXME(mci,"missing sequencer mode %ld\n",dwReturn);
123 }
124 break;
125 case _MCISTR_mode:
126 switch (dwReturn) {
127 case MCI_MODE_NOT_READY:_MCI_STR("not ready"); break;
128 case MCI_MODE_STOP: _MCI_STR("stopped"); break;
129 case MCI_MODE_PLAY: _MCI_STR("playing"); break;
130 case MCI_MODE_RECORD: _MCI_STR("recording"); break;
131 case MCI_MODE_SEEK: _MCI_STR("seeking"); break;
132 case MCI_MODE_PAUSE: _MCI_STR("paused"); break;
133 case MCI_MODE_OPEN: _MCI_STR("open"); break;
134 default:break;
135 }
136 break;
137 case _MCISTR_bool:
138 if (dwReturn)
139 _MCI_STR("true");
140 else
141 _MCI_STR("false");
142 break;
143 case _MCISTR_int:{
144 char buf[16];
145 sprintf(buf,"%ld",dwReturn);
146 _MCI_STR(buf);
147 break;
148 }
149 case _MCISTR_time: {
150 char buf[100];
151 _MCISTR_printtf(buf,uDevTyp,timef,dwReturn);
152 _MCI_STR(buf);
153 break;
154 }
155 case _MCISTR_tfname:
156 switch (timef) {
157 case MCI_FORMAT_MILLISECONDS: _MCI_STR("milliseconds"); break;
158 case MCI_FORMAT_FRAMES: _MCI_STR("frames"); break;
159 case MCI_FORMAT_BYTES: _MCI_STR("bytes"); break;
160 case MCI_FORMAT_SAMPLES: _MCI_STR("samples"); break;
161 case MCI_FORMAT_HMS: _MCI_STR("hms"); break;
162 case MCI_FORMAT_MSF: _MCI_STR("msf"); break;
163 case MCI_FORMAT_TMSF: _MCI_STR("tmsf"); break;
164 default:
165 FIXME(mci,"missing timefmt for %d, report.\n",timef);
166 break;
167 }
168 break;
169 case _MCISTR_divtype:
170 switch (dwReturn) {
171 case MCI_SEQ_DIV_PPQN: _MCI_STR("PPQN"); break;
172 case MCI_SEQ_DIV_SMPTE_24: _MCI_STR("SMPTE 24 frame"); break;
173 case MCI_SEQ_DIV_SMPTE_25: _MCI_STR("SMPTE 25 frame"); break;
174 case MCI_SEQ_DIV_SMPTE_30: _MCI_STR("SMPTE 30 frame"); break;
175 case MCI_SEQ_DIV_SMPTE_30DROP: _MCI_STR("SMPTE 30 frame drop");break;
176 }
177 case _MCISTR_devtype:
178 switch (dwReturn) {
179 case MCI_DEVTYPE_VCR: _MCI_STR("vcr"); break;
180 case MCI_DEVTYPE_VIDEODISC: _MCI_STR("videodisc"); break;
181 case MCI_DEVTYPE_CD_AUDIO: _MCI_STR("cd audio"); break;
182 case MCI_DEVTYPE_OVERLAY: _MCI_STR("overlay"); break;
183 case MCI_DEVTYPE_DAT: _MCI_STR("dat"); break;
184 case MCI_DEVTYPE_SCANNER: _MCI_STR("scanner"); break;
185 case MCI_DEVTYPE_ANIMATION: _MCI_STR("animation"); break;
186 case MCI_DEVTYPE_DIGITAL_VIDEO: _MCI_STR("digital video"); break;
187 case MCI_DEVTYPE_OTHER: _MCI_STR("other"); break;
188 case MCI_DEVTYPE_WAVEFORM_AUDIO:_MCI_STR("waveform audio"); break;
189 case MCI_DEVTYPE_SEQUENCER: _MCI_STR("sequencer"); break;
190 default:FIXME(mci,"unknown device type %ld, report.\n",
191 dwReturn);break;
192 }
193 break;
194 default:
195 FIXME(mci,"unknown resulttype %d, report.\n",type);
196 break;
197 }
198 }
199
200 #define FLAG1(str,flag) \
201 if (!STRCMP(keywords[i],str)) { \
202 dwFlags |= flag; \
203 i++; \
204 continue; \
205 }
206
207 #define FLAG2(str1,str2,flag) \
208 if (!STRCMP(keywords[i],str1) && \
209 (i+1<nrofkeywords) && \
210 !STRCMP(keywords[i+1],str2)) { \
211 dwFlags |= flag; \
212 i+=2; \
213 continue; \
214 }
215
216 /* All known subcommands are implemented in single functions to avoid
217 * bloat and a xxxx lines long mciSendString(). All commands are of the
218 * format MCISTR_Cmd(_MCISTR_PROTO_) where _MCISTR_PROTO_ is the above
219 * defined line of arguments. (This is just for easy enhanceability.)
220 * All functions return the MCIERR_ errorvalue as DWORD. Returnvalues
221 * for the calls are in lpstrReturnString (If I mention return values
222 * in function headers, I mean returnvalues in lpstrReturnString.)
223 * Integers are sprintf("%d")ed integers. Boolean values are
224 * "true" and "false".
225 * timeformat depending values are "%d" "%d:%d" "%d:%d:%d" "%d:%d:%d:%d"
226 * FIXME: is above line correct?
227 *
228 * Preceding every function is a list of implemented/known arguments.
229 * Feel free to add missing arguments.
230 *
231 */
232
233 /*
234 * Opens the specified MCI driver.
235 * Arguments: <name>
236 * Optional:
237 * "shareable"
238 * "alias <aliasname>"
239 * "element <elementname>"
240 * Additional:
241 * waveform audio:
242 * "buffer <nrBytesPerSec>"
243 * Animation:
244 * "nostatic" increaste nr of nonstatic colours
245 * "parent <windowhandle>"
246 * "style <mask>" bitmask of WS_xxxxx (see windows.h)
247 * "style child" WS_CHILD
248 * "style overlap" WS_OVERLAPPED
249 * "style popup" WS_POPUP
250 * Overlay:
251 * "parent <windowhandle>"
252 * "style <mask>" bitmask of WS_xxxxx (see windows.h)
253 * "style child" WS_CHILD
254 * "style overlap" WS_OVERLAPPED
255 * "style popup" WS_POPUP
256 * Returns nothing.
257 */
258 static DWORD
259 MCISTR_Open(_MCISTR_PROTO_)
260 {
261 int res,i;
262 char *s;
263 union U {
264 MCI_OPEN_PARMS16 openParams;
265 MCI_WAVE_OPEN_PARMS16 waveopenParams;
266 MCI_ANIM_OPEN_PARMS16 animopenParams;
267 MCI_OVLY_OPEN_PARMS16 ovlyopenParams;
268 };
269 union U *pU = xmalloc(sizeof(union U));
270
271 pU->openParams.lpstrElementName = NULL;
272 s = strchr(dev,'!');
273 if (s != NULL) {
274 *s++ = '\0';
275 pU->openParams.lpstrElementName = strdup(s);
276 dwFlags |= MCI_OPEN_ELEMENT;
277 }
278 uDevTyp = MCI_GetDevType(dev);
279 if (uDevTyp == 0) {
280 free(pU->openParams.lpstrElementName);
281 free(pU);
282 return MCIERR_INVALID_DEVICE_NAME;
283 }
284
285 pU->openParams.dwCallback = hwndCallback;
286 pU->openParams.wDeviceID = wDevID;
287 pU->openParams.wReserved0 = 0;
288 pU->ovlyopenParams.dwStyle = 0;
289 pU->animopenParams.dwStyle = 0;
290 pU->openParams.lpstrDeviceType = strdup(dev);
291 pU->openParams.lpstrAlias = NULL;
292 dwFlags |= MCI_OPEN_TYPE;
293 i = 0;
294 while (i < nrofkeywords) {
295 FLAG1("shareable",MCI_OPEN_SHAREABLE);
296 if (!STRCMP(keywords[i],"alias") && (i+1 < nrofkeywords)) {
297 dwFlags |= MCI_OPEN_ALIAS;
298 pU->openParams.lpstrAlias = strdup(keywords[i+1]);
299 i+=2;
300 continue;
301 }
302 if (!STRCMP(keywords[i],"element") && (i+1<nrofkeywords)) {
303 dwFlags |= MCI_OPEN_ELEMENT;
304 pU->openParams.lpstrElementName = strdup(keywords[i+1]);
305 i+=2;
306 continue;
307 }
308 switch (uDevTyp) {
309 case MCI_DEVTYPE_ANIMATION:
310 case MCI_DEVTYPE_DIGITAL_VIDEO:
311 FLAG1("nostatic",MCI_ANIM_OPEN_NOSTATIC);
312 if (!STRCMP(keywords[i],"parent") && (i+1 < nrofkeywords)) {
313 dwFlags |= MCI_ANIM_OPEN_PARENT;
314 sscanf(keywords[i+1], "%hu", &(pU->animopenParams.hWndParent));
315 i+=2;
316 continue;
317 }
318 if (!STRCMP(keywords[i], "style") && (i+1 < nrofkeywords)) {
319 DWORD st;
320
321 dwFlags |= MCI_ANIM_OPEN_WS;
322 if (!STRCMP(keywords[i+1],"popup")) {
323 pU->animopenParams.dwStyle |= WS_POPUP;
324 } else if (!STRCMP(keywords[i+1],"overlap")) {
325 pU->animopenParams.dwStyle |= WS_OVERLAPPED;
326 } else if (!STRCMP(keywords[i+1],"child")) {
327 pU->animopenParams.dwStyle |= WS_CHILD;
328 } else if (sscanf(keywords[i+1],"%ld",&st)) {
329 pU->animopenParams.dwStyle |= st;
330 } else
331 FIXME(mci, "unknown 'style' keyword %s, please report.\n", keywords[i+1]);
332 i+=2;
333 continue;
334 }
335 break;
336 case MCI_DEVTYPE_WAVEFORM_AUDIO:
337 if (!STRCMP(keywords[i],"buffer") && (i+1 < nrofkeywords)) {
338 dwFlags |= MCI_WAVE_OPEN_BUFFER;
339 sscanf(keywords[i+1], "%ld", &(pU->waveopenParams.dwBufferSeconds));
340 }
341 break;
342 case MCI_DEVTYPE_OVERLAY:
343 /* looks just like anim, but without NOSTATIC */
344 if (!STRCMP(keywords[i], "parent") && (i+1 < nrofkeywords)) {
345 dwFlags |= MCI_OVLY_OPEN_PARENT;
346 sscanf(keywords[i+1], "%hd", &(pU->ovlyopenParams.hWndParent));
347 i+=2;
348 continue;
349 }
350 if (!STRCMP(keywords[i],"style") && (i+1 < nrofkeywords)) {
351 DWORD st;
352
353 dwFlags |= MCI_OVLY_OPEN_WS;
354 if (!STRCMP(keywords[i+1],"popup")) {
355 pU->ovlyopenParams.dwStyle |= WS_POPUP;
356 } else if (!STRCMP(keywords[i+1],"overlap")) {
357 pU->ovlyopenParams.dwStyle |= WS_OVERLAPPED;
358 } else if (!STRCMP(keywords[i+1],"child")) {
359 pU->ovlyopenParams.dwStyle |= WS_CHILD;
360 } else if (sscanf(keywords[i+1],"%ld",&st)) {
361 pU->ovlyopenParams.dwStyle |= st;
362 } else
363 FIXME(mci,"unknown 'style' keyword %s, please report.\n",keywords[i+1]);
364 i+=2;
365 continue;
366 }
367 break;
368 }
369 FIXME(mci,"unknown parameter passed %s, please report.\n",
370 keywords[i]);
371 i++;
372 }
373 res = mciSendCommandA(0, MCI_OPEN, dwFlags, (DWORD)pU);
374
375 free(pU->openParams.lpstrElementName);
376 free(pU->openParams.lpstrDeviceType);
377 free(pU->openParams.lpstrAlias);
378 free(pU);
379 return res;
380 }
381
382 /* A help function for a lot of others ...
383 * for instance status/play/record/seek etc.
384 */
385 DWORD
386 _MCISTR_determine_timeformat(LPCSTR dev,WORD wDevID,WORD uDevTyp,int *timef)
387 {
388 int res;
389 DWORD dwFlags = MCI_STATUS_ITEM;
390 MCI_STATUS_PARMS *statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
391
392 if (!statusParams) return 0;
393 statusParams->dwItem = MCI_STATUS_TIME_FORMAT;
394 statusParams->dwReturn = 0;
395 res = mciSendCommandA(wDevID, MCI_STATUS, dwFlags, (DWORD)statusParams);
396
397 if (res==0) *timef = statusParams->dwReturn;
398 free(statusParams);
399 return res;
400 }
401
402 /* query status of MCI drivers
403 * Arguments:
404 * Required:
405 * "mode" - returns "not ready" "paused" "playing" "stopped" "open"
406 * "parked" "recording" "seeking" ....
407 * Basics:
408 * "current track" - returns current track as integer
409 * "length [track <nr>]" - returns length [of track <nr>] in current
410 * timeformat
411 * "number of tracks" - returns number of tracks as integer
412 * "position [track <nr>]" - returns position [in track <nr>] in current
413 * timeformat
414 * "ready" - checks if device is ready to play, -> bool
415 * "start position" - returns start position in timeformat
416 * "time format" - returns timeformat (list of possible values:
417 * "ms" "msf" "milliseconds" "hmsf" "tmsf" "frames"
418 * "bytes" "samples" "hms")
419 * "media present" - returns if media is present as bool
420 * Animation:
421 * "forward" - returns "true" if device is playing forwards
422 * "speed" - returns speed for device
423 * "palette handle" - returns palette handle
424 * "window handle" - returns window handle
425 * "stretch" - returns stretch bool
426 * MIDI sequencer:
427 * "division type" - ? returns "PPQN" "SMPTE 24 frame"
428 * "SMPTE 25 frame" "SMPTE 30 frame" "SMPTE 30 drop frame"
429 * "tempo" - current tempo in (PPQN? speed in frames, SMPTE*? speed in hsmf)
430 * "offset" - offset in dito.
431 * "port" - midi port as integer
432 * "slave" - slave device ("midi","file","none","smpte")
433 * "master" - masterdevice (dito.)
434 * Overlay:
435 * "window handle" - see animation
436 * "stretch" - dito
437 * Video Disc:
438 * "speed" - speed as integer
439 * "forward" - returns bool (when playing forward)
440 * "side" - returns 1 or 2
441 * "media type" - returns "CAV" "CLV" "other"
442 * "disc size" - returns "8" or "12"
443 * WAVEFORM audio:
444 * "input" - base queries on input set
445 * "output" - base queries on output set
446 * "format tag" - return integer format tag
447 * "channels" - return integer nr of channels
448 * "bytespersec" - return average nr of bytes/sec
449 * "samplespersec" - return nr of samples per sec
450 * "bitspersample" - return bitspersample
451 * "alignment" - return block alignment
452 * "level" - return level?
453 */
454
455 #define ITEM1(str,item,xtype) \
456 if (!STRCMP(keywords[i],str)) { \
457 statusParams->dwItem = item; \
458 type = xtype; \
459 i++; \
460 continue; \
461 }
462 #define ITEM2(str1,str2,item,xtype) \
463 if ( !STRCMP(keywords[i],str1) && \
464 (i+1 < nrofkeywords) && \
465 !STRCMP(keywords[i+1],str2)) { \
466 statusParams->dwItem = item; \
467 type = xtype; \
468 i+=2; \
469 continue; \
470 }
471 #define ITEM3(str1,str2,str3,item,xtype) \
472 if ( !STRCMP(keywords[i],str1) && \
473 (i+2 < nrofkeywords) && \
474 !STRCMP(keywords[i+1],str2) && \
475 !STRCMP(keywords[i+2],str3)) { \
476 statusParams->dwItem = item; \
477 type = xtype; \
478 i+=3; \
479 continue; \
480 }
481
482 static DWORD
483 MCISTR_Status(_MCISTR_PROTO_) {
484 MCI_STATUS_PARMS *statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
485 int type = 0,i,res,timef;
486
487 statusParams->dwCallback = hwndCallback;
488 dwFlags |= MCI_STATUS_ITEM;
489 res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
490 if (res) return res;
491
492 statusParams->dwReturn = 0;
493 statusParams->dwItem = 0;
494 i = 0;
495
496 while (i < nrofkeywords) {
497 if (!STRCMP(keywords[i],"track") && (i+1 < nrofkeywords)) {
498 sscanf(keywords[i+1],"%ld",&(statusParams->dwTrack));
499 dwFlags |= MCI_TRACK;
500 i+=2;
501 continue;
502 }
503 FLAG1("start",MCI_STATUS_START);
504 /* generic things */
505 ITEM2("current","track",MCI_STATUS_CURRENT_TRACK,_MCISTR_time);
506 ITEM2("time","format",MCI_STATUS_TIME_FORMAT,_MCISTR_tfname);
507 ITEM1("ready",MCI_STATUS_READY,_MCISTR_bool);
508 ITEM1("mode",MCI_STATUS_MODE,_MCISTR_mode);
509 ITEM3("number","of","tracks",MCI_STATUS_NUMBER_OF_TRACKS,_MCISTR_int);
510 ITEM1("length",MCI_STATUS_LENGTH,_MCISTR_time);
511 ITEM1("position",MCI_STATUS_POSITION,_MCISTR_time);
512 ITEM2("media","present",MCI_STATUS_MEDIA_PRESENT,_MCISTR_bool);
513
514 switch (uDevTyp) {
515 case MCI_DEVTYPE_ANIMATION:
516 case MCI_DEVTYPE_DIGITAL_VIDEO:
517 ITEM2("palette","handle",MCI_ANIM_STATUS_HPAL,_MCISTR_int);
518 ITEM2("window","handle",MCI_ANIM_STATUS_HWND,_MCISTR_int);
519 ITEM1("stretch",MCI_ANIM_STATUS_STRETCH,_MCISTR_bool);
520 ITEM1("speed",MCI_ANIM_STATUS_SPEED,_MCISTR_int);
521 ITEM1("forward",MCI_ANIM_STATUS_FORWARD,_MCISTR_bool);
522 break;
523 case MCI_DEVTYPE_SEQUENCER:
524 /* just completing the list, not working correctly */
525 ITEM2("division","type",MCI_SEQ_STATUS_DIVTYPE,_MCISTR_divtype);
526 /* tempo ... PPQN in frames/second, SMPTE in hmsf */
527 ITEM1("tempo",MCI_SEQ_STATUS_TEMPO,_MCISTR_int);
528 ITEM1("port",MCI_SEQ_STATUS_PORT,_MCISTR_int);
529 ITEM1("slave",MCI_SEQ_STATUS_SLAVE,_MCISTR_seqtype);
530 ITEM1("master",MCI_SEQ_STATUS_SLAVE,_MCISTR_seqtype);
531 /* offset ... PPQN in frames/second, SMPTE in hmsf */
532 ITEM1("offset",MCI_SEQ_STATUS_SLAVE,_MCISTR_time);
533 break;
534 case MCI_DEVTYPE_OVERLAY:
535 ITEM2("window","handle",MCI_OVLY_STATUS_HWND,_MCISTR_int);
536 ITEM1("stretch",MCI_OVLY_STATUS_STRETCH,_MCISTR_bool);
537 break;
538 case MCI_DEVTYPE_VIDEODISC:
539 ITEM1("speed",MCI_VD_STATUS_SPEED,_MCISTR_int);
540 ITEM1("forward",MCI_VD_STATUS_FORWARD,_MCISTR_bool);
541 ITEM1("side",MCI_VD_STATUS_SIDE,_MCISTR_int);
542 ITEM2("media","type",MCI_VD_STATUS_SIDE,_MCISTR_vdmtype);
543 /* returns 8 or 12 */
544 ITEM2("disc","size",MCI_VD_STATUS_DISC_SIZE,_MCISTR_int);
545 break;
546 case MCI_DEVTYPE_WAVEFORM_AUDIO:
547 /* I am not quite sure if foll. 2 lines are right. */
548 FLAG1("input",MCI_WAVE_INPUT);
549 FLAG1("output",MCI_WAVE_OUTPUT);
550
551 ITEM2("format","tag",MCI_WAVE_STATUS_FORMATTAG,_MCISTR_int);
552 ITEM1("channels",MCI_WAVE_STATUS_CHANNELS,_MCISTR_int);
553 ITEM1("bytespersec",MCI_WAVE_STATUS_AVGBYTESPERSEC,_MCISTR_int);
554 ITEM1("samplespersec",MCI_WAVE_STATUS_SAMPLESPERSEC,_MCISTR_int);
555 ITEM1("bitspersample",MCI_WAVE_STATUS_BITSPERSAMPLE,_MCISTR_int);
556 ITEM1("alignment",MCI_WAVE_STATUS_BLOCKALIGN,_MCISTR_int);
557 ITEM1("level",MCI_WAVE_STATUS_LEVEL,_MCISTR_int);
558 break;
559 }
560 FIXME(mci,"unknown keyword '%s'\n",keywords[i]);
561 i++;
562 }
563 if (!statusParams->dwItem)
564 return MCIERR_MISSING_STRING_ARGUMENT;
565
566 res = mciSendCommandA(wDevID, MCI_STATUS, dwFlags, (DWORD)statusParams);
567
568 if (res==0)
569 _MCISTR_convreturn(type,statusParams->dwReturn,lpstrReturnString,uReturnLength,uDevTyp,timef);
570 free(statusParams);
571 return res;
572 }
573 #undef ITEM1
574 #undef ITEM2
575 #undef ITEM3
576
577 /* set specified parameters in respective MCI drivers
578 * Arguments:
579 * "door open" eject media or somesuch
580 * "door close" load media
581 * "time format <timeformatname>" "ms" "milliseconds" "msf" "hmsf"
582 * "tmsf" "SMPTE 24" "SMPTE 25" "SMPTE 30"
583 * "SMPTE drop 30"
584 * "audio [all|left|right] [on|off]" sets specified audiochannel on or off
585 * "video [on|off]" sets video on/off
586 * Waveform audio:
587 * "formattag pcm" sets format to pcm
588 * "formattag <nr>" sets integer formattag value
589 * "any input" accept input from any known source
590 * "any output" output to any known destination
591 * "input <nr>" input from source <nr>
592 * "output <nr>" output to destination <nr>
593 * "channels <nr>" sets nr of channels
594 * "bytespersec <nr>" sets average bytes per second
595 * "samplespersec <nr>" sets average samples per second (1 sample can
596 * be 2 bytes!)
597 * "alignment <nr>" sets the blockalignment to <nr>
598 * "bitspersample <nr>" sets the nr of bits per sample
599 * Sequencer:
600 * "master [midi|file|smpte|none]" sets the midi master device
601 * "slave [midi|file|smpte|none]" sets the midi master device
602 * "port mapper" midioutput to portmapper
603 * "port <nr>" midioutput to specified port
604 * "tempo <nr>" tempo of track (depends on timeformat/divtype)
605 * "offset <nr>" start offset?
606 */
607 static DWORD
608 MCISTR_Set(_MCISTR_PROTO_) {
609 union U {
610 MCI_SET_PARMS setParams;
611 MCI_WAVE_SET_PARMS16 wavesetParams;
612 MCI_SEQ_SET_PARMS seqsetParams;
613 };
614 union U *pU = xmalloc(sizeof(union U));
615 int i,res;
616
617 pU->setParams.dwCallback = hwndCallback;
618 i = 0;
619 while (i < nrofkeywords) {
620 FLAG2("door","open",MCI_SET_DOOR_OPEN);
621 FLAG2("door","closed",MCI_SET_DOOR_CLOSED);
622
623 if ( !STRCMP(keywords[i],"time") &&
624 (i+2 < nrofkeywords) &&
625 !STRCMP(keywords[i+1],"format")
626 ) {
627 dwFlags |= MCI_SET_TIME_FORMAT;
628
629 /* FIXME:is this a shortcut for milliseconds or
630 * minutes:seconds? */
631 if (!STRCMP(keywords[i+2],"ms"))
632 pU->setParams.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
633
634 if (!STRCMP(keywords[i+2],"milliseconds"))
635 pU->setParams.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
636 if (!STRCMP(keywords[i+2],"msf"))
637 pU->setParams.dwTimeFormat = MCI_FORMAT_MSF;
638 if (!STRCMP(keywords[i+2],"hms"))
639 pU->setParams.dwTimeFormat = MCI_FORMAT_HMS;
640 if (!STRCMP(keywords[i+2],"frames"))
641 pU->setParams.dwTimeFormat = MCI_FORMAT_FRAMES;
642 if (!STRCMP(keywords[i+2],"track"))
643 pU->setParams.dwTimeFormat = MCI_VD_FORMAT_TRACK;
644 if (!STRCMP(keywords[i+2],"bytes"))
645 pU->setParams.dwTimeFormat = MCI_FORMAT_BYTES;
646 if (!STRCMP(keywords[i+2],"samples"))
647 pU->setParams.dwTimeFormat = MCI_FORMAT_SAMPLES;
648 if (!STRCMP(keywords[i+2],"tmsf"))
649 pU->setParams.dwTimeFormat = MCI_FORMAT_TMSF;
650 if ( !STRCMP(keywords[i+2],"song") &&
651 (i+3 < nrofkeywords) &&
652 !STRCMP(keywords[i+3],"pointer")
653 )
654 pU->setParams.dwTimeFormat = MCI_SEQ_FORMAT_SONGPTR;
655 if (!STRCMP(keywords[i+2],"smpte") && (i+3 < nrofkeywords)) {
656 if (!STRCMP(keywords[i+3],"24"))
657 pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_24;
658 if (!STRCMP(keywords[i+3],"25"))
659 pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_25;
660 if (!STRCMP(keywords[i+3],"30"))
661 pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_30;
662 if (!STRCMP(keywords[i+3],"drop") && (i+4 < nrofkeywords) && !STRCMP(keywords[i+4],"30")) {
663 pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_30DROP;
664 i++;
665 }
666 i++;
667 /*FALLTHROUGH*/
668 }
669 i+=3;
670 continue;
671 }
672 if (!STRCMP(keywords[i],"audio") && (i+1 < nrofkeywords)) {
673 dwFlags |= MCI_SET_AUDIO;
674 if (!STRCMP(keywords[i+1],"all"))
675 pU->setParams.dwAudio = MCI_SET_AUDIO_ALL;
676 if (!STRCMP(keywords[i+1],"left"))
677 pU->setParams.dwAudio = MCI_SET_AUDIO_LEFT;
678 if (!STRCMP(keywords[i+1],"right"))
679 pU->setParams.dwAudio = MCI_SET_AUDIO_RIGHT;
680 i+=2;
681 continue;
682 }
683 FLAG1("video",MCI_SET_VIDEO);
684 FLAG1("on",MCI_SET_ON);
685 FLAG1("off",MCI_SET_OFF);
686 switch (uDevTyp) {
687 case MCI_DEVTYPE_WAVEFORM_AUDIO:
688 FLAG2("any","input",MCI_WAVE_SET_ANYINPUT);
689 FLAG2("any","output",MCI_WAVE_SET_ANYOUTPUT);
690
691 if ( !STRCMP(keywords[i],"formattag") &&
692 (i+1 < nrofkeywords) &&
693 !STRCMP(keywords[i+1],"pcm")
694 ) {
695 dwFlags |= MCI_WAVE_SET_FORMATTAG;
696 pU->wavesetParams.wFormatTag = WAVE_FORMAT_PCM;
697 i+=2;
698 continue;
699 }
700
701 /* <keyword> <integer> */
702 #define WII(str,flag,fmt,element) \
703 if (!STRCMP(keywords[i],str) && \
704 (i+1 < nrofkeywords)) { \
705 sscanf(keywords[i+1], fmt, \
706 &(pU->wavesetParams. element)); \
707 dwFlags |= flag; \
708 i+=2; \
709 continue; \
710 }
711 WII("formattag",MCI_WAVE_SET_FORMATTAG,"%hu",wFormatTag);
712 WII("channels",MCI_WAVE_SET_CHANNELS,"%hu",nChannels);
713 WII("bytespersec",MCI_WAVE_SET_AVGBYTESPERSEC,"%lu",nAvgBytesPerSec);
714 WII("samplespersec",MCI_WAVE_SET_SAMPLESPERSEC,"%lu",nSamplesPerSec);
715 WII("alignment",MCI_WAVE_SET_BLOCKALIGN,"%hu",nBlockAlign);
716 WII("bitspersample",MCI_WAVE_SET_BITSPERSAMPLE,"%hu",wBitsPerSample);
717 WII("input",MCI_WAVE_INPUT,"%hu",wInput);
718 WII("output",MCI_WAVE_OUTPUT,"%hu",wOutput);
719 #undef WII
720 break;
721 case MCI_DEVTYPE_SEQUENCER:
722 if (!STRCMP(keywords[i],"master") && (i+1 < nrofkeywords)) {
723 dwFlags |= MCI_SEQ_SET_MASTER;
724 if (!STRCMP(keywords[i+1],"midi"))
725 pU->seqsetParams.dwMaster = MCI_SEQ_MIDI;
726 if (!STRCMP(keywords[i+1],"file"))
727 pU->seqsetParams.dwMaster = MCI_SEQ_FILE;
728 if (!STRCMP(keywords[i+1],"smpte"))
729 pU->seqsetParams.dwMaster = MCI_SEQ_SMPTE;
730 if (!STRCMP(keywords[i+1],"none"))
731 pU->seqsetParams.dwMaster = MCI_SEQ_NONE;
732 i+=2;
733 continue;
734 }
735 if (!STRCMP(keywords[i],"slave") && (i+1 < nrofkeywords)) {
736 dwFlags |= MCI_SEQ_SET_SLAVE;
737 if (!STRCMP(keywords[i+1],"midi"))
738 pU->seqsetParams.dwMaster = MCI_SEQ_MIDI;
739 if (!STRCMP(keywords[i+1],"file"))
740 pU->seqsetParams.dwMaster = MCI_SEQ_FILE;
741 if (!STRCMP(keywords[i+1],"smpte"))
742 pU->seqsetParams.dwMaster = MCI_SEQ_SMPTE;
743 if (!STRCMP(keywords[i+1],"none"))
744 pU->seqsetParams.dwMaster = MCI_SEQ_NONE;
745 i+=2;
746 continue;
747 }
748 if ( !STRCMP(keywords[i],"port") &&
749 (i+1 < nrofkeywords) &&
750 !STRCMP(keywords[i+1],"mapper")
751 ) {
752 pU->seqsetParams.dwPort=-1;/* FIXME:not sure*/
753 dwFlags |= MCI_SEQ_SET_PORT;
754 i+=2;
755 continue;
756 }
757 #define SII(str,flag,element) \
758 if (!STRCMP(keywords[i],str) && (i+1 < nrofkeywords)) {\
759 sscanf(keywords[i+1],"%ld",&(pU->seqsetParams. element));\
760 dwFlags |= flag;\
761 i+=2;\
762 continue;\
763 }
764 SII("tempo",MCI_SEQ_SET_TEMPO,dwTempo);
765 SII("port",MCI_SEQ_SET_PORT,dwPort);
766 SII("offset",MCI_SEQ_SET_PORT,dwOffset);
767 }
768 i++;
769 }
770 if (!dwFlags)
771 return MCIERR_MISSING_STRING_ARGUMENT;
772 res = mciSendCommandA(wDevID, MCI_SET, dwFlags, (DWORD)pU);
773 free(pU);
774 return res;
775 }
776
777 /* specify break key
778 * Arguments:
779 * "off" disable break
780 * "on <keyid>" enable break on key with keyid
781 * (I strongly suspect, that there is another parameter:
782 * "window <handle>"
783 * but I don't see it mentioned in my documentation.
784 * Returns nothing.
785 */
786 static DWORD
787 MCISTR_Break(_MCISTR_PROTO_)
788 {
789 MCI_BREAK_PARMS16 *breakParams = xmalloc(sizeof(MCI_BREAK_PARMS16));
790 int res,i;
791
792 if (!breakParams) return 0;
793 /*breakParams.hwndBreak ? */
794 for (i = 0; i < nrofkeywords; i++) {
795 FLAG1("off",MCI_BREAK_OFF);
796 if (!strcmp(keywords[i],"on") && (nrofkeywords>i+1)) {
797 dwFlags&=~MCI_BREAK_OFF;
798 dwFlags|=MCI_BREAK_KEY;
799 sscanf(keywords[i+1],"%hd",&(breakParams->nVirtKey));
800 i+=2;
801 continue;
802 }
803 }
804 res = mciSendCommandA(wDevID, MCI_BREAK, dwFlags, (DWORD)breakParams);
805 free(breakParams);
806 return res;
807 }
808
809 #define ITEM1(str,item,xtype) \
810 if (!STRCMP(keywords[i],str)) { \
811 gdcParams->dwItem = item; \
812 type = xtype; \
813 i++; \
814 continue; \
815 }
816 #define ITEM2(str1,str2,item,xtype) \
817 if ( !STRCMP(keywords[i],str1) && \
818 (i+1 < nrofkeywords) && \
819 !STRCMP(keywords[i+1],str2)) { \
820 gdcParams->dwItem = item; \
821 type = xtype; \
822 i+=2; \
823 continue; \
824 }
825 #define ITEM3(str1,str2,str3,item,xtype) \
826 if ( !STRCMP(keywords[i],str1) && \
827 (i+2 < nrofkeywords) && \
828 !STRCMP(keywords[i+1],str2) && \
829 !STRCMP(keywords[i+2],str3)) { \
830 gdcParams->dwItem = item; \
831 type = xtype; \
832 i+=3; \
833 continue; \
834 }
835
836 /* get device capabilities of MCI drivers
837 * Arguments:
838 * Generic:
839 * "device type" returns device name as string
840 * "has audio" returns bool
841 * "has video" returns bool
842 * "uses files" returns bool
843 * "compound device" returns bool
844 * "can record" returns bool
845 * "can play" returns bool
846 * "can eject" returns bool
847 * "can save" returns bool
848 * Animation:
849 * "palettes" returns nr of available palette entries
850 * "windows" returns nr of available windows
851 * "can reverse" returns bool
852 * "can stretch" returns bool
853 * "slow play rate" returns the slow playrate
854 * "fast play rate" returns the fast playrate
855 * "normal play rate" returns the normal playrate
856 * Overlay:
857 * "windows" returns nr of available windows
858 * "can stretch" returns bool
859 * "can freeze" returns bool
860 * Videodisc:
861 * "cav" assume CAV discs (default if no disk inserted)
862 * "clv" assume CLV discs
863 * "can reverse" returns bool
864 * "slow play rate" returns the slow playrate
865 * "fast play rate" returns the fast playrate
866 * "normal play rate" returns the normal playrate
867 * Waveform audio:
868 * "inputs" returns nr of inputdevices
869 * "outputs" returns nr of outputdevices
870 */
871 static DWORD
872 MCISTR_Capability(_MCISTR_PROTO_) {
873 MCI_GETDEVCAPS_PARMS *gdcParams = xmalloc(sizeof(MCI_GETDEVCAPS_PARMS));
874 int type=0,i,res;
875
876 gdcParams->dwCallback = hwndCallback;
877 if (!nrofkeywords)
878 return MCIERR_MISSING_STRING_ARGUMENT;
879 /* well , thats default */
880 dwFlags |= MCI_GETDEVCAPS_ITEM;
881 gdcParams->dwItem = 0;
882 i=0;
883 while (i < nrofkeywords) {
884 ITEM2("device","type",MCI_GETDEVCAPS_DEVICE_TYPE,_MCISTR_devtype);
885 ITEM2("has","audio",MCI_GETDEVCAPS_HAS_AUDIO,_MCISTR_bool);
886 ITEM2("has","video",MCI_GETDEVCAPS_HAS_VIDEO,_MCISTR_bool);
887 ITEM2("uses","files",MCI_GETDEVCAPS_USES_FILES,_MCISTR_bool);
888 ITEM2("compound","device",MCI_GETDEVCAPS_COMPOUND_DEVICE,_MCISTR_bool);
889 ITEM2("can","record",MCI_GETDEVCAPS_CAN_RECORD,_MCISTR_bool);
890 ITEM2("can","play",MCI_GETDEVCAPS_CAN_PLAY,_MCISTR_bool);
891 ITEM2("can","eject",MCI_GETDEVCAPS_CAN_EJECT,_MCISTR_bool);
892 ITEM2("can","save",MCI_GETDEVCAPS_CAN_SAVE,_MCISTR_bool);
893 switch (uDevTyp) {
894 case MCI_DEVTYPE_ANIMATION:
895 ITEM1("palettes",MCI_ANIM_GETDEVCAPS_PALETTES,_MCISTR_int);
896 ITEM1("windows",MCI_ANIM_GETDEVCAPS_MAX_WINDOWS,_MCISTR_int);
897 ITEM2("can","reverse",MCI_ANIM_GETDEVCAPS_CAN_REVERSE,_MCISTR_bool);
898 ITEM2("can","stretch",MCI_ANIM_GETDEVCAPS_CAN_STRETCH,_MCISTR_bool);
899 ITEM3("slow","play","rate",MCI_ANIM_GETDEVCAPS_SLOW_RATE,_MCISTR_int);
900 ITEM3("fast","play","rate",MCI_ANIM_GETDEVCAPS_FAST_RATE,_MCISTR_int);
901 ITEM3("normal","play","rate",MCI_ANIM_GETDEVCAPS_NORMAL_RATE,_MCISTR_int);
902 break;
903 case MCI_DEVTYPE_OVERLAY:
904 ITEM1("windows",MCI_OVLY_GETDEVCAPS_MAX_WINDOWS,_MCISTR_int);
905 ITEM2("can","freeze",MCI_OVLY_GETDEVCAPS_CAN_FREEZE,_MCISTR_bool);
906 ITEM2("can","stretch",MCI_OVLY_GETDEVCAPS_CAN_STRETCH,_MCISTR_bool);
907 break;
908 case MCI_DEVTYPE_VIDEODISC:
909 FLAG1("cav",MCI_VD_GETDEVCAPS_CAV);
910 FLAG1("clv",MCI_VD_GETDEVCAPS_CLV);
911 ITEM2("can","reverse",MCI_VD_GETDEVCAPS_CAN_REVERSE,_MCISTR_bool);
912 ITEM3("slow","play","rate",MCI_VD_GETDEVCAPS_SLOW_RATE,_MCISTR_int);
913 ITEM3("fast","play","rate",MCI_VD_GETDEVCAPS_FAST_RATE,_MCISTR_int);
914 ITEM3("normal","play","rate",MCI_VD_GETDEVCAPS_NORMAL_RATE,_MCISTR_int);
915 break;
916 case MCI_DEVTYPE_WAVEFORM_AUDIO:
917 ITEM1("inputs",MCI_WAVE_GETDEVCAPS_INPUTS,_MCISTR_int);
918 ITEM1("outputs",MCI_WAVE_GETDEVCAPS_OUTPUTS,_MCISTR_int);
919 break;
920 }
921 i++;
922 }
923 res = mciSendCommandA(wDevID, MCI_GETDEVCAPS, dwFlags, (DWORD)gdcParams);
924
925 /* no timeformat needed */
926 if (res==0)
927 _MCISTR_convreturn(type, gdcParams->dwReturn, lpstrReturnString,
928 uReturnLength, uDevTyp, 0);
929 free(gdcParams);
930 return res;
931 }
932 #undef ITEM1
933 #undef ITEM2
934 #undef ITEM3
935 /* resumes operation of device. no arguments, no return values */
936 static DWORD
937 MCISTR_Resume(_MCISTR_PROTO_)
938 {
939 MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
940 int res;
941 genParams->dwCallback = hwndCallback;
942 res = mciSendCommandA(wDevID, MCI_RESUME, dwFlags, (DWORD)genParams);
943 free(genParams);
944 return res;
945 }
946
947 /* pauses operation of device. no arguments, no return values */
948 static DWORD
949 MCISTR_Pause(_MCISTR_PROTO_)
950 {
951 MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
952 int res;
953 genParams->dwCallback = hwndCallback;
954 res = mciSendCommandA(wDevID, MCI_PAUSE, dwFlags, (DWORD)genParams);
955 free(genParams);
956 return res;
957 }
958
959 /* stops operation of device. no arguments, no return values */
960 static DWORD
961 MCISTR_Stop(_MCISTR_PROTO_)
962 {
963 MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
964 int res;
965 genParams->dwCallback = hwndCallback;
966 res = mciSendCommandA(wDevID, MCI_STOP, dwFlags, (DWORD)genParams);
967 free(genParams);
968 return res;
969 }
970
971 /* starts recording.
972 * Arguments:
973 * "overwrite" overwrite existing things
974 * "insert" insert at current position
975 * "to <time>" record up to <time> (specified in timeformat)
976 * "from <time>" record from <time> (specified in timeformat)
977 */
978 static DWORD
979 MCISTR_Record(_MCISTR_PROTO_) {
980 int i,res,timef,nrargs,j,k,a[4];
981 char *parsestr;
982 MCI_RECORD_PARMS *recordParams = xmalloc(sizeof(MCI_RECORD_PARMS));
983
984 res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
985 if (res) return res;
986
987 switch (timef) {
988 case MCI_FORMAT_MILLISECONDS:
989 case MCI_FORMAT_FRAMES:
990 case MCI_FORMAT_BYTES:
991 case MCI_FORMAT_SAMPLES:
992 nrargs=1;
993 parsestr="%d";
994 break;
995 case MCI_FORMAT_HMS:
996 case MCI_FORMAT_MSF:
997 parsestr="%d:%d:%d";
998 nrargs=3;
999 break;
1000 case MCI_FORMAT_TMSF:
1001 parsestr="%d:%d:%d:%d";
1002 nrargs=4;
1003 break;
1004 default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
1005 parsestr="%d";
1006 nrargs=1;
1007 break;
1008 }
1009 recordParams->dwCallback = hwndCallback;
1010 i = 0;
1011 while (i < nrofkeywords) {
1012 if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
1013 dwFlags |= MCI_TO;
1014 a[0]=a[1]=a[2]=a[3]=0;
1015 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1016 /* add up all integers we got, if we have more
1017 * shift them. (Well I should use the macros in
1018 * mmsystem.h, right).
1019 */
1020 recordParams->dwTo=0;
1021 for (k=0;k < j;k++)
1022 recordParams->dwTo+=a[k] << (8*(nrargs-k));
1023 i+=2;
1024 continue;
1025 }
1026 if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
1027 dwFlags |= MCI_FROM;
1028 a[0]=a[1]=a[2]=a[3]=0;
1029 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1030 /* dito. */
1031 recordParams->dwFrom=0;
1032 for (k=0;k < j;k++)
1033 recordParams->dwFrom+=a[k]<<(8*(nrargs-k));
1034 i+=2;
1035 continue;
1036 }
1037 FLAG1("insert",MCI_RECORD_INSERT);
1038 FLAG1("overwrite",MCI_RECORD_OVERWRITE);
1039 i++;
1040 }
1041 res = mciSendCommandA(wDevID, MCI_RECORD, dwFlags, (DWORD)recordParams);
1042 free(recordParams);
1043 return res;
1044 }
1045
1046 /* play media
1047 * Arguments:
1048 * "to <time>" play up to <time> (specified in set timeformat)
1049 * "from <time>" play from <time> (specified in set timeformat)
1050 * Animation:
1051 * "slow" play slow
1052 * "fast" play fast
1053 * "scan" play as fast as possible (with audio disabled perhaps)
1054 * "reverse" play reverse
1055 * "speed <fps>" play with specified frames per second
1056 * Videodisc:
1057 * "slow" play slow
1058 * "fast" play fast
1059 * "scan" play as fast as possible (with audio disabled perhaps)
1060 * "reverse" play reverse
1061 * "speed <fps>" play with specified frames per second
1062 */
1063 static DWORD
1064 MCISTR_Play(_MCISTR_PROTO_) {
1065 int i,res,timef,nrargs,j,k,a[4];
1066 char *parsestr;
1067 union U {
1068 MCI_PLAY_PARMS playParams;
1069 MCI_VD_PLAY_PARMS vdplayParams;
1070 MCI_ANIM_PLAY_PARMS animplayParams;
1071 };
1072 union U *pU = xmalloc(sizeof(union U));
1073
1074 res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
1075 if (res) return res;
1076 switch (timef) {
1077 case MCI_FORMAT_MILLISECONDS:
1078 case MCI_FORMAT_FRAMES:
1079 case MCI_FORMAT_BYTES:
1080 case MCI_FORMAT_SAMPLES:
1081 nrargs=1;
1082 parsestr="%d";
1083 break;
1084 case MCI_FORMAT_HMS:
1085 case MCI_FORMAT_MSF:
1086 parsestr="%d:%d:%d";
1087 nrargs=3;
1088 break;
1089 case MCI_FORMAT_TMSF:
1090 parsestr="%d:%d:%d:%d";
1091 nrargs=4;
1092 break;
1093 default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
1094 parsestr="%d";
1095 nrargs=1;
1096 break;
1097 }
1098 pU->playParams.dwCallback=hwndCallback;
1099 i=0;
1100 while (i < nrofkeywords) {
1101 if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
1102 dwFlags |= MCI_TO;
1103 a[0]=a[1]=a[2]=a[3]=0;
1104 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1105 /* add up all integers we got, if we have more
1106 * shift them. (Well I should use the macros in
1107 * mmsystem.h, right).
1108 */
1109 pU->playParams.dwTo=0;
1110 for (k=0;k < j;k++)
1111 pU->playParams.dwTo+=a[k] << (8*(nrargs-k));
1112 i+=2;
1113 continue;
1114 }
1115 if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
1116 dwFlags |= MCI_FROM;
1117 a[0]=a[1]=a[2]=a[3]=0;
1118 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1119 /* dito. */
1120 pU->playParams.dwFrom=0;
1121 for (k=0;k < j;k++)
1122 pU->playParams.dwFrom+=a[k]<<(8*(nrargs-k));
1123 i+=2;
1124 continue;
1125 }
1126 switch (uDevTyp) {
1127 case MCI_DEVTYPE_VIDEODISC:
1128 FLAG1("slow",MCI_VD_PLAY_SLOW);
1129 FLAG1("fast",MCI_VD_PLAY_FAST);
1130 FLAG1("scan",MCI_VD_PLAY_SCAN);
1131 FLAG1("reverse",MCI_VD_PLAY_REVERSE);
1132 if (!STRCMP(keywords[i],"speed") && (i+1 < nrofkeywords)) {
1133 dwFlags |= MCI_VD_PLAY_SPEED;
1134 sscanf(keywords[i+1],"%ld",&(pU->vdplayParams.dwSpeed));
1135 i+=2;
1136 continue;
1137 }
1138 break;
1139 case MCI_DEVTYPE_ANIMATION:
1140 FLAG1("slow",MCI_ANIM_PLAY_SLOW);
1141 FLAG1("fast",MCI_ANIM_PLAY_FAST);
1142 FLAG1("scan",MCI_ANIM_PLAY_SCAN);
1143 FLAG1("reverse",MCI_ANIM_PLAY_REVERSE);
1144 if (!STRCMP(keywords[i],"speed") && (i+1 < nrofkeywords)) {
1145 dwFlags |= MCI_ANIM_PLAY_SPEED;
1146 sscanf(keywords[i+1],"%ld",&(pU->animplayParams.dwSpeed));
1147 i+=2;
1148 continue;
1149 }
1150 break;
1151 }
1152 i++;
1153 }
1154 res = mciSendCommandA(wDevID, MCI_PLAY, dwFlags, (DWORD)pU);
1155 free(pU);
1156 return res;
1157 }
1158
1159 /* seek to a specified position
1160 * Arguments:
1161 * "to start" seek to start of medium
1162 * "to end" seek to end of medium
1163 * "to <time>" seek to <time> specified in current timeformat
1164 */
1165 static DWORD
1166 MCISTR_Seek(_MCISTR_PROTO_) {
1167 int i,res,timef,nrargs,j,k,a[4];
1168 char *parsestr;
1169 MCI_SEEK_PARMS *seekParams = xmalloc(sizeof(MCI_SEEK_PARMS));
1170
1171 res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
1172 if (res) return res;
1173 switch (timef) {
1174 case MCI_FORMAT_MILLISECONDS:
1175 case MCI_FORMAT_FRAMES:
1176 case MCI_FORMAT_BYTES:
1177 case MCI_FORMAT_SAMPLES:
1178 nrargs=1;
1179 parsestr="%d";
1180 break;
1181 case MCI_FORMAT_HMS:
1182 case MCI_FORMAT_MSF:
1183 parsestr="%d:%d:%d";
1184 nrargs=3;
1185 break;
1186 case MCI_FORMAT_TMSF:
1187 parsestr="%d:%d:%d:%d";
1188 nrargs=4;
1189 break;
1190 default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
1191 parsestr="%d";
1192 nrargs=1;
1193 break;
1194 }
1195 seekParams->dwCallback=hwndCallback;
1196 i=0;
1197 while (i < nrofkeywords) {
1198 if ( !STRCMP(keywords[i],"to") && (i+1 < nrofkeywords)) {
1199 if (!STRCMP(keywords[i+1],"start")) {
1200 dwFlags|=MCI_SEEK_TO_START;
1201 seekParams->dwTo=0;
1202 i+=2;
1203 continue;
1204 }
1205 if (!STRCMP(keywords[i+1],"end")) {
1206 dwFlags|=MCI_SEEK_TO_END;
1207 seekParams->dwTo=0;
1208 i+=2;
1209 continue;
1210 }
1211 dwFlags|=MCI_TO;
1212 i+=2;
1213 a[0]=a[1]=a[2]=a[3]=0;
1214 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1215 seekParams->dwTo=0;
1216 for (k=0;k < j;k++)
1217 seekParams->dwTo+=a[k] << (8*(nrargs-k));
1218 continue;
1219 }
1220 switch (uDevTyp) {
1221 case MCI_DEVTYPE_VIDEODISC:
1222 FLAG1("reverse",MCI_VD_SEEK_REVERSE);
1223 break;
1224 }
1225 i++;
1226 }
1227 res = mciSendCommandA(wDevID, MCI_SEEK, dwFlags, (DWORD)seekParams);
1228 free(seekParams);
1229 return res;
1230 }
1231
1232 /* close media/driver */
1233 static DWORD
1234 MCISTR_Close(_MCISTR_PROTO_)
1235 {
1236 MCI_GENERIC_PARMS* closeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
1237 int res;
1238
1239 res = mciSendCommandA(wDevID, MCI_CLOSE, dwFlags, (DWORD)closeParams);
1240 free(closeParams);
1241 return res;
1242 }
1243
1244 /* return information.
1245 * Arguments:
1246 * "product" return product name (human readable)
1247 * "file" return filename
1248 * Animation:
1249 * "text" returns text?
1250 * Overlay:
1251 * "text" returns text?
1252 */
1253 static DWORD
1254 MCISTR_Info(_MCISTR_PROTO_)
1255 {
1256 MCI_INFO_PARMS16* infoParams = xmalloc(sizeof(MCI_INFO_PARMS16));
1257 DWORD sflags;
1258 int i,res;
1259
1260 sflags = dwFlags;
1261 i=0;
1262 while (i < nrofkeywords) {
1263 FLAG1("product",MCI_INFO_PRODUCT);
1264 FLAG1("file",MCI_INFO_FILE);
1265 switch (uDevTyp) {
1266 case MCI_DEVTYPE_ANIMATION:
1267 FLAG1("text",MCI_ANIM_INFO_TEXT);
1268 break;
1269 case MCI_DEVTYPE_OVERLAY:
1270 FLAG1("text",MCI_OVLY_INFO_TEXT);
1271 break;
1272 }
1273 i++;
1274 }
1275 if (dwFlags == sflags)
1276 return MCIERR_MISSING_STRING_ARGUMENT;
1277 /* MCI driver will fill in lpstrReturn, dwRetSize.
1278 * FIXME: I don't know if this is correct behaviour
1279 */
1280 res = mciSendCommandA(wDevID, MCI_INFO, dwFlags, (DWORD)infoParams);
1281 if (res==0)
1282 _MCI_STR(infoParams->lpstrReturn);
1283 free(infoParams);
1284 return res;
1285 }
1286
1287 /* query MCI driver itself for information
1288 * Arguments:
1289 * "installname" return install name of <device> (system.ini)
1290 * "quantity" return nr of installed drivers
1291 * "open" open drivers only (additional flag)
1292 * "name <nr>" return nr of devices with <devicetyp>
1293 * "name all" return nr of all devices
1294 *
1295 * FIXME: mciSysInfo16() is broken I think.
1296 */
1297 static DWORD
1298 MCISTR_Sysinfo(_MCISTR_PROTO_) {
1299 MCI_SYSINFO_PARMS16 sysinfoParams;
1300 int i,res;
1301
1302 sysinfoParams.lpstrReturn = lpstrReturnString;
1303 sysinfoParams.dwRetSize = uReturnLength;
1304 sysinfoParams.wDeviceType = uDevTyp;
1305
1306 for (i = 0; i < nrofkeywords; i++) {
1307 FLAG1("installname",MCI_SYSINFO_INSTALLNAME);
1308 FLAG1("quantity",MCI_SYSINFO_INSTALLNAME);
1309 FLAG1("open",MCI_SYSINFO_OPEN);
1310 if (!strcmp(keywords[i],"name") && (i+1 < nrofkeywords)) {
1311 sscanf(keywords[i+1],"%ld",&(sysinfoParams.dwNumber));
1312 dwFlags |= MCI_SYSINFO_NAME;
1313 i++;
1314 }
1315 }
1316 res = mciSendCommand16(0, MCI_SYSINFO, dwFlags, (DWORD)&sysinfoParams);
1317
1318 if (dwFlags & MCI_SYSINFO_QUANTITY) {
1319 char buf[100];
1320
1321 sprintf(buf,"%ld",*(long*)lpstrReturnString);
1322 _MCI_STR(buf);
1323 }
1324 /* no need to copy anything back, mciSysInfo did it for us */
1325 return res;
1326 }
1327
1328 /* load file
1329 * Argument: "<filename>"
1330 * Overlay: "at <left> <top> <right> <bottom>" additional
1331 */
1332 static DWORD
1333 MCISTR_Load(_MCISTR_PROTO_) {
1334 union U {
1335 MCI_LOAD_PARMS16 loadParams;
1336 MCI_OVLY_LOAD_PARMS16 ovlyloadParams;
1337 };
1338 union U *pU = xmalloc(sizeof(union U));
1339 int i,len,res;
1340 char *s;
1341
1342 i=len=0;
1343 while (i < nrofkeywords) {
1344 switch (uDevTyp) {
1345 case MCI_DEVTYPE_OVERLAY:
1346 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1347 dwFlags |= MCI_OVLY_RECT;
1348 sscanf(keywords[i+1],"%hd",&(pU->ovlyloadParams.rc.left));
1349 sscanf(keywords[i+2],"%hd",&(pU->ovlyloadParams.rc.top));
1350 sscanf(keywords[i+3],"%hd",&(pU->ovlyloadParams.rc.right));
1351 sscanf(keywords[i+4],"%hd",&(pU->ovlyloadParams.rc.bottom));
1352 memcpy(keywords+i,keywords+(i+5),nrofkeywords-(i+5));
1353 continue;
1354 }
1355 break;
1356 }
1357 len+=strlen(keywords[i])+1;
1358 i++;
1359 }
1360 s=(char*)xmalloc(len);
1361 *s='\0';
1362 while (i < nrofkeywords) {
1363 strcat(s,keywords[i]);
1364 i++;
1365 if (i < nrofkeywords) strcat(s," ");
1366 }
1367 pU->loadParams.lpfilename=s;
1368 dwFlags |= MCI_LOAD_FILE;
1369 res = mciSendCommandA(wDevID, MCI_LOAD, dwFlags, (DWORD)pU);
1370 free(s);
1371 free(pU);
1372 return res;
1373 }
1374
1375 /* save to file
1376 * Argument: "<filename>"
1377 * Overlay: "at <left> <top> <right> <bottom>" additional
1378 */
1379 static DWORD
1380 MCISTR_Save(_MCISTR_PROTO_) {
1381 union U {
1382 MCI_SAVE_PARMS saveParams;
1383 MCI_OVLY_SAVE_PARMS16 ovlysaveParams;
1384 };
1385 union U *pU = xmalloc(sizeof(union U));
1386 int i,len,res;
1387 char *s;
1388
1389 i=0;len=0;
1390 while (i < nrofkeywords) {
1391 switch (uDevTyp) {
1392 case MCI_DEVTYPE_OVERLAY:
1393 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1394 dwFlags |= MCI_OVLY_RECT;
1395 sscanf(keywords[i+1],"%hd",&(pU->ovlysaveParams.rc.left));
1396 sscanf(keywords[i+2],"%hd",&(pU->ovlysaveParams.rc.top));
1397 sscanf(keywords[i+3],"%hd",&(pU->ovlysaveParams.rc.right));
1398 sscanf(keywords[i+4],"%hd",&(pU->ovlysaveParams.rc.bottom));
1399 memcpy(keywords+i,keywords+(i+5),nrofkeywords-(i+5));
1400 continue;
1401 }
1402 break;
1403 }
1404 len+=strlen(keywords[i])+1;
1405 i++;
1406 }
1407 s=(char*)xmalloc(len);
1408 *s='\0';
1409 while (i < nrofkeywords) {
1410 strcat(s,keywords[i]);
1411 i++;
1412 if (i < nrofkeywords) strcat(s," ");
1413 }
1414 pU->saveParams.lpfilename=s;
1415 dwFlags |= MCI_LOAD_FILE;
1416 res = mciSendCommandA(wDevID, MCI_SAVE, dwFlags, (DWORD)pU);
1417 free(s);
1418 free(pU);
1419 return res;
1420 }
1421
1422 /* prepare device for input/output
1423 * (only applyable to waveform audio)
1424 */
1425 static DWORD
1426 MCISTR_Cue(_MCISTR_PROTO_) {
1427 MCI_GENERIC_PARMS *cueParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
1428 int i,res;
1429
1430 for (i = 0; i < nrofkeywords; i++) {
1431 switch (uDevTyp) {
1432 case MCI_DEVTYPE_WAVEFORM_AUDIO:
1433 FLAG1("input", MCI_WAVE_INPUT);
1434 FLAG1("output", MCI_WAVE_OUTPUT);
1435 break;
1436 }
1437 }
1438 res = mciSendCommandA(wDevID, MCI_CUE, dwFlags, (DWORD)cueParams);
1439 free(cueParams);
1440 return res;
1441 }
1442
1443 /* delete information */
1444 static DWORD
1445 MCISTR_Delete(_MCISTR_PROTO_) {
1446 int timef,nrargs,i,j,k,a[4],res;
1447 char *parsestr;
1448 MCI_WAVE_DELETE_PARMS *deleteParams = xmalloc(sizeof(MCI_WAVE_DELETE_PARMS));
1449
1450 /* only implemented for waveform audio */
1451 if (uDevTyp != MCI_DEVTYPE_WAVEFORM_AUDIO)
1452 return MCIERR_UNSUPPORTED_FUNCTION; /* well it fits */
1453 res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
1454 if (res) return res;
1455 switch (timef) {
1456 case MCI_FORMAT_MILLISECONDS:
1457 case MCI_FORMAT_FRAMES:
1458 case MCI_FORMAT_BYTES:
1459 case MCI_FORMAT_SAMPLES:
1460 nrargs=1;
1461 parsestr="%d";
1462 break;
1463 case MCI_FORMAT_HMS:
1464 case MCI_FORMAT_MSF:
1465 parsestr="%d:%d:%d";
1466 nrargs=3;
1467 break;
1468 case MCI_FORMAT_TMSF:
1469 parsestr="%d:%d:%d:%d";
1470 nrargs=4;
1471 break;
1472 default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
1473 parsestr="%d";
1474 nrargs=1;
1475 break;
1476 }
1477 i=0;
1478 while (i < nrofkeywords) {
1479 if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
1480 dwFlags |= MCI_TO;
1481 a[0]=a[1]=a[2]=a[3]=0;
1482 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1483 /* add up all integers we got, if we have more
1484 * shift them. (Well I should use the macros in
1485 * mmsystem.h, right).
1486 */
1487 deleteParams->dwTo=0;
1488 for (k=0;k < j;k++)
1489 deleteParams->dwTo+=a[k]<<(8*(nrargs-k));
1490 i+=2;
1491 continue;
1492 }
1493 if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
1494 dwFlags |= MCI_FROM;
1495 a[0]=a[1]=a[2]=a[3]=0;
1496 j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
1497 /* dito. */
1498 deleteParams->dwFrom=0;
1499 for (k=0;k < j;k++)
1500 deleteParams->dwFrom+=a[k]<<(8*(nrargs-k));
1501 i+=2;
1502 continue;
1503 }
1504 i++;
1505 }
1506 res = mciSendCommandA(wDevID, MCI_DELETE, dwFlags, (DWORD)deleteParams);
1507 free(deleteParams);
1508 return res;
1509 }
1510
1511 /* send command to device. only applies to videodisc */
1512 static DWORD
1513 MCISTR_Escape(_MCISTR_PROTO_)
1514 {
1515 MCI_VD_ESCAPE_PARMS16 *escapeParams = xmalloc(sizeof(MCI_VD_ESCAPE_PARMS16));
1516 int i,len,res;
1517 char *s;
1518
1519 if (uDevTyp != MCI_DEVTYPE_VIDEODISC)
1520 return MCIERR_UNSUPPORTED_FUNCTION;
1521 i=0;len=0;
1522 while (i < nrofkeywords) {
1523 len+=strlen(keywords[i])+1;
1524 i++;
1525 }
1526 s=(char*)malloc(len);
1527 *s='\0';
1528 while (i < nrofkeywords) {
1529 strcat(s,keywords[i]);
1530 i++;
1531 if (i < nrofkeywords) strcat(s," ");
1532 }
1533 escapeParams->lpstrCommand = s;
1534 dwFlags |= MCI_VD_ESCAPE_STRING;
1535 res = mciSendCommandA(wDevID, MCI_ESCAPE, dwFlags, (DWORD)escapeParams);
1536 free(s);
1537 free(escapeParams);
1538 return res;
1539 }
1540
1541 /* unfreeze [part of] the overlayed video
1542 * only applyable to Overlay devices
1543 */
1544 static DWORD
1545 MCISTR_Unfreeze(_MCISTR_PROTO_)
1546 {
1547 MCI_OVLY_RECT_PARMS16 *unfreezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
1548 int i,res;
1549
1550 if (uDevTyp != MCI_DEVTYPE_OVERLAY)
1551 return MCIERR_UNSUPPORTED_FUNCTION;
1552 i=0;while (i < nrofkeywords) {
1553 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1554 sscanf(keywords[i+1],"%hd",&(unfreezeParams->rc.left));
1555 sscanf(keywords[i+2],"%hd",&(unfreezeParams->rc.top));
1556 sscanf(keywords[i+3],"%hd",&(unfreezeParams->rc.right));
1557 sscanf(keywords[i+4],"%hd",&(unfreezeParams->rc.bottom));
1558 dwFlags |= MCI_OVLY_RECT;
1559 i+=5;
1560 continue;
1561 }
1562 i++;
1563 }
1564 res = mciSendCommandA(wDevID, MCI_UNFREEZE, dwFlags, (DWORD)unfreezeParams);
1565 free(unfreezeParams);
1566 return res;
1567 }
1568 /* freeze [part of] the overlayed video
1569 * only applyable to Overlay devices
1570 */
1571 static DWORD
1572 MCISTR_Freeze(_MCISTR_PROTO_)
1573 {
1574 MCI_OVLY_RECT_PARMS16 *freezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
1575 int i,res;
1576
1577 if (uDevTyp != MCI_DEVTYPE_OVERLAY)
1578 return MCIERR_UNSUPPORTED_FUNCTION;
1579 i=0;while (i < nrofkeywords) {
1580 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1581 sscanf(keywords[i+1],"%hd",&(freezeParams->rc.left));
1582 sscanf(keywords[i+2],"%hd",&(freezeParams->rc.top));
1583 sscanf(keywords[i+3],"%hd",&(freezeParams->rc.right));
1584 sscanf(keywords[i+4],"%hd",&(freezeParams->rc.bottom));
1585 dwFlags |= MCI_OVLY_RECT;
1586 i+=5;
1587 continue;
1588 }
1589 i++;
1590 }
1591 res = mciSendCommandA(wDevID, MCI_FREEZE, dwFlags, (DWORD)freezeParams);
1592 free(freezeParams);
1593 return res;
1594 }
1595
1596 /* copy parts of image to somewhere else
1597 * "source [at <left> <top> <right> <bottom>]" source is framebuffer [or rect]
1598 * "destination [at <left> <top> <right> <bottom>]" destination is framebuffer [or rect]
1599 * Overlay:
1600 * "frame [at <left> <top> <right> <bottom>]" frame is framebuffer [or rect]
1601 * where the video input is placed
1602 * "video [at <left> <top> <right> <bottom>]" video is whole video [or rect]
1603 * (defining part of input to
1604 * be displayed)
1605 *
1606 * FIXME: This whole junk is passing multiple rectangles.
1607 * I don't know how to do that with the present interface.
1608 * (Means code below is broken)
1609 */
1610 static DWORD
1611 MCISTR_Put(_MCISTR_PROTO_) {
1612 union U {
1613 MCI_OVLY_RECT_PARMS16 ovlyputParams;
1614 MCI_ANIM_RECT_PARMS16 animputParams;
1615 };
1616 union U *pU = xmalloc(sizeof(union U));
1617 int i,res;
1618 i=0;while (i < nrofkeywords) {
1619 switch (uDevTyp) {
1620 case MCI_DEVTYPE_ANIMATION:
1621 FLAG1("source",MCI_ANIM_PUT_SOURCE);
1622 FLAG1("destination",MCI_ANIM_PUT_DESTINATION);
1623 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1624 sscanf(keywords[i+1],"%hd",&(pU->animputParams.rc.left));
1625 sscanf(keywords[i+2],"%hd",&(pU->animputParams.rc.top));
1626 sscanf(keywords[i+3],"%hd",&(pU->animputParams.rc.right));
1627 sscanf(keywords[i+4],"%hd",&(pU->animputParams.rc.bottom));
1628 dwFlags |= MCI_ANIM_RECT;
1629 i+=5;
1630 continue;
1631 }
1632 break;
1633 case MCI_DEVTYPE_OVERLAY:
1634 FLAG1("source",MCI_OVLY_PUT_SOURCE);
1635 FLAG1("destination",MCI_OVLY_PUT_DESTINATION);
1636 FLAG1("video",MCI_OVLY_PUT_VIDEO);
1637 FLAG1("frame",MCI_OVLY_PUT_FRAME);
1638 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1639 sscanf(keywords[i+1],"%hd",&(pU->ovlyputParams.rc.left));
1640 sscanf(keywords[i+2],"%hd",&(pU->ovlyputParams.rc.top));
1641 sscanf(keywords[i+3],"%hd",&(pU->ovlyputParams.rc.right));
1642 sscanf(keywords[i+4],"%hd",&(pU->ovlyputParams.rc.bottom));
1643 dwFlags |= MCI_OVLY_RECT;
1644 i+=5;
1645 continue;
1646 }
1647 break;
1648 }
1649 i++;
1650 }
1651 res = mciSendCommandA(wDevID, MCI_PUT, dwFlags, (DWORD)pU);
1652 free(pU);
1653 return res;
1654 }
1655
1656 /* palette behaviour changing
1657 * (Animation only)
1658 * "normal" realize the palette normally
1659 * "background" realize the palette as background palette
1660 */
1661 static DWORD
1662 MCISTR_Realize(_MCISTR_PROTO_)
1663 {
1664 MCI_GENERIC_PARMS *realizeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
1665 int i,res;
1666
1667 if (uDevTyp != MCI_DEVTYPE_ANIMATION)
1668 return MCIERR_UNSUPPORTED_FUNCTION;
1669 i=0;
1670 while (i < nrofkeywords) {
1671 FLAG1("background",MCI_ANIM_REALIZE_BKGD);
1672 FLAG1("normal",MCI_ANIM_REALIZE_NORM);
1673 i++;
1674 }
1675 res = mciSendCommandA(wDevID, MCI_REALIZE, dwFlags, (DWORD)realizeParams);
1676 free(realizeParams);
1677 return res;
1678 }
1679
1680 /* videodisc spinning
1681 * "up"
1682 * "down"
1683 */
1684 static DWORD
1685 MCISTR_Spin(_MCISTR_PROTO_)
1686 {
1687 MCI_GENERIC_PARMS *spinParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
1688 int i,res;
1689
1690 if (uDevTyp != MCI_DEVTYPE_VIDEODISC)
1691 return MCIERR_UNSUPPORTED_FUNCTION;
1692 i=0;
1693 while (i < nrofkeywords) {
1694 FLAG1("up",MCI_VD_SPIN_UP);
1695 FLAG1("down",MCI_VD_SPIN_UP);
1696 i++;
1697 }
1698 res = mciSendCommandA(wDevID, MCI_SPIN, dwFlags, (DWORD)spinParams);
1699 free(spinParams);
1700 return res;
1701 }
1702
1703 /* step single frames
1704 * "reverse" optional flag
1705 * "by <nr>" for <nr> frames
1706 */
1707 static DWORD
1708 MCISTR_Step(_MCISTR_PROTO_) {
1709 union U {
1710 MCI_ANIM_STEP_PARMS animstepParams;
1711 MCI_VD_STEP_PARMS vdstepParams;
1712 };
1713 union U *pU = xmalloc(sizeof(union U));
1714 int i,res;
1715
1716 i=0;
1717 while (i < nrofkeywords) {
1718 switch (uDevTyp) {
1719 case MCI_DEVTYPE_ANIMATION:
1720 FLAG1("reverse",MCI_ANIM_STEP_REVERSE);
1721 if (!STRCMP(keywords[i],"by") && (i+1 < nrofkeywords)) {
1722 sscanf(keywords[i+1],"%ld",&(pU->animstepParams.dwFrames));
1723 dwFlags |= MCI_ANIM_STEP_FRAMES;
1724 i+=2;
1725 continue;
1726 }
1727 break;
1728 case MCI_DEVTYPE_VIDEODISC:
1729 FLAG1("reverse",MCI_VD_STEP_REVERSE);
1730 if (!STRCMP(keywords[i],"by") && (i+1 < nrofkeywords)) {
1731 sscanf(keywords[i+1],"%ld",&(pU->vdstepParams.dwFrames));
1732 dwFlags |= MCI_VD_STEP_FRAMES;
1733 i+=2;
1734 continue;
1735 }
1736 break;
1737 }
1738 i++;
1739 }
1740 res = mciSendCommandA(wDevID, MCI_STEP, dwFlags, (DWORD)pU);
1741 free(pU);
1742 return res;
1743 }
1744
1745 /* update animation window
1746 * Arguments:
1747 * "at <left> <top> <right> <bottom>" only in this rectangle
1748 * "hdc" device context
1749 */
1750 static DWORD
1751 MCISTR_Update(_MCISTR_PROTO_) {
1752 int i,res;
1753 MCI_ANIM_UPDATE_PARMS16 *updateParams = xmalloc(sizeof(MCI_ANIM_UPDATE_PARMS16));
1754
1755 i=0;
1756 while (i<nrofkeywords) {
1757 if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
1758 sscanf(keywords[i+1],"%hd",&(updateParams->rc.left));
1759 sscanf(keywords[i+2],"%hd",&(updateParams->rc.top));
1760 sscanf(keywords[i+3],"%hd",&(updateParams->rc.right));
1761 sscanf(keywords[i+4],"%hd",&(updateParams->rc.bottom));
1762 dwFlags |= MCI_ANIM_RECT;
1763 i+=5;
1764 continue;
1765 }
1766 if (!STRCMP(keywords[i],"hdc") && (i+1 < nrofkeywords)) {
1767 dwFlags |= MCI_ANIM_UPDATE_HDC;
1768 sscanf(keywords[i+1],"%hd",&(updateParams->hDC));
1769 i+=2;
1770 continue;
1771 }
1772 i++;
1773 }
1774 res = mciSendCommandA(wDevID, MCI_UPDATE, dwFlags, (DWORD)updateParams);
1775 free(updateParams);
1776 return res;
1777 }
1778
1779 /* where command for animation and overlay drivers.
1780 * just returns the specified rectangle as a string
1781 * Arguments:
1782 * "source"
1783 * "destination"
1784 * Overlay special:
1785 * "video"
1786 * "frame"
1787 */
1788 static DWORD
1789 MCISTR_Where(_MCISTR_PROTO_) {
1790 union U {
1791 MCI_ANIM_RECT_PARMS16 animwhereParams;
1792 MCI_OVLY_RECT_PARMS16 ovlywhereParams;
1793 };
1794 union U *pU = xmalloc(sizeof(union U));
1795 int i,res;
1796
1797 i=0;
1798 while (i < nrofkeywords) {
1799 switch (uDevTyp) {
1800 case MCI_DEVTYPE_ANIMATION:
1801 FLAG1("source",MCI_ANIM_WHERE_SOURCE);
1802 FLAG1("destination",MCI_ANIM_WHERE_DESTINATION);
1803 break;
1804 case MCI_DEVTYPE_OVERLAY:
1805 FLAG1("source",MCI_OVLY_WHERE_SOURCE);
1806 FLAG1("destination",MCI_OVLY_WHERE_DESTINATION);
1807 FLAG1("video",MCI_OVLY_WHERE_VIDEO);
1808 FLAG1("frame",MCI_OVLY_WHERE_FRAME);
1809 break;
1810 }
1811 i++;
1812 }
1813 res = mciSendCommandA(wDevID, MCI_WHERE, dwFlags, (DWORD)pU);
1814 if (res==0) {
1815 char buf[100];
1816 switch (uDevTyp) {
1817 case MCI_DEVTYPE_ANIMATION:
1818 sprintf(buf,"%d %d %d %d",
1819 pU->animwhereParams.rc.left,
1820 pU->animwhereParams.rc.top,
1821 pU->animwhereParams.rc.right,
1822 pU->animwhereParams.rc.bottom
1823 );
1824 break;
1825 case MCI_DEVTYPE_OVERLAY:
1826 sprintf(buf,"%d %d %d %d",
1827 pU->ovlywhereParams.rc.left,
1828 pU->ovlywhereParams.rc.top,
1829 pU->ovlywhereParams.rc.right,
1830 pU->ovlywhereParams.rc.bottom
1831 );
1832 break;
1833 default:strcpy(buf,"0 0 0 0");break;
1834 }
1835 _MCI_STR(buf);
1836 }
1837 free(pU);
1838 return res;
1839 }
1840
1841 static DWORD
1842 MCISTR_Window(_MCISTR_PROTO_) {
1843 int i,res;
1844 char *s;
1845 union U {
1846 MCI_ANIM_WINDOW_PARMS16 animwindowParams;
1847 MCI_OVLY_WINDOW_PARMS16 ovlywindowParams;
1848 };
1849 union U *pU = xmalloc(sizeof(union U));
1850
1851 s=NULL;
1852 i=0;
1853 while (i < nrofkeywords) {
1854 switch (uDevTyp) {
1855 case MCI_DEVTYPE_ANIMATION:
1856 if (!STRCMP(keywords[i],"handle") && (i+1 < nrofkeywords)) {
1857 dwFlags |= MCI_ANIM_WINDOW_HWND;
1858 if (!STRCMP(keywords[i+1],"default"))
1859 pU->animwindowParams.hWnd = MCI_OVLY_WINDOW_DEFAULT;
1860 else
1861 sscanf(keywords[i+1],"%hd",&(pU->animwindowParams.hWnd));
1862 i+=2;
1863 continue;
1864 }
1865 if (!STRCMP(keywords[i],"state") && (i+1 < nrofkeywords)) {
1866 dwFlags |= MCI_ANIM_WINDOW_STATE;
1867 if (!STRCMP(keywords[i+1],"hide"))
1868 pU->animwindowParams.nCmdShow = SW_HIDE;
1869 if (!STRCMP(keywords[i+1],"iconic"))
1870 pU->animwindowParams.nCmdShow = SW_SHOWMINNOACTIVE; /* correct? */
1871 if (!STRCMP(keywords[i+1],"minimized"))
1872 pU->animwindowParams.nCmdShow = SW_SHOWMINIMIZED;
1873 if (!STRCMP(keywords[i+1],"maximized"))
1874 pU->animwindowParams.nCmdShow = SW_SHOWMAXIMIZED;
1875 if (!STRCMP(keywords[i+1],"minimize"))
1876 pU->animwindowParams.nCmdShow = SW_MINIMIZE;
1877 if (!STRCMP(keywords[i+1],"normal"))
1878 pU->animwindowParams.nCmdShow = SW_NORMAL;
1879 if (!STRCMP(keywords[i+1],"show"))
1880 pU->animwindowParams.nCmdShow = SW_SHOW;
1881 if (!STRCMP(keywords[i+1],"no") && (i+2 < nrofkeywords)) {
1882 if (!STRCMP(keywords[i+2],"active"))
1883 pU->animwindowParams.nCmdShow = SW_SHOWNOACTIVATE;
1884 if (!STRCMP(keywords[i+2],"action"))
1885 pU->animwindowParams.nCmdShow = SW_SHOWNA;/* correct?*/
1886 i++;
1887 }
1888 i+=2;
1889 continue;
1890 }
1891 /* text is enclosed in " ... " as it seems */
1892 if (!STRCMP(keywords[i],"text")) {
1893 char *t;
1894 int len,j,k;
1895
1896 if (keywords[i+1][0]!='"') {
1897 i++;
1898 continue;
1899 }
1900 dwFlags |= MCI_ANIM_WINDOW_TEXT;
1901 len = strlen(keywords[i+1])+1;
1902 j = i+2;
1903 while (j < nrofkeywords) {
1904 len += strlen(keywords[j])+1;
1905 if (strchr(keywords[j],'"'))
1906 break;
1907 j++;
1908 }
1909 s=(char*)xmalloc(len);
1910 strcpy(s,keywords[i+1]+1);
1911 k=j;j=i+2;
1912 while (j <= k) {
1913 strcat(s," ");
1914 strcat(s,keywords[j]);
1915 }
1916 if ((t=strchr(s,'"'))) *t='\0';
1917 /* FIXME: segmented pointer? */
1918 pU->animwindowParams.lpstrText = s;
1919 i=k+1;
1920 continue;
1921 }
1922 FLAG1("stretch",MCI_ANIM_WINDOW_ENABLE_STRETCH);
1923 break;
1924 case MCI_DEVTYPE_OVERLAY:
1925 if (!STRCMP(keywords[i],"handle") && (i+1 < nrofkeywords)) {
1926 dwFlags |= MCI_OVLY_WINDOW_HWND;
1927 if (!STRCMP(keywords[i+1],"default"))
1928 pU->ovlywindowParams.hWnd = MCI_OVLY_WINDOW_DEFAULT;
1929 else
1930 sscanf(keywords[i+1],"%hd",&(pU->ovlywindowParams.hWnd));
1931 i+=2;
1932 continue;
1933 }
1934 if (!STRCMP(keywords[i],"state") && (i+1 < nrofkeywords)) {
1935 dwFlags |= MCI_OVLY_WINDOW_STATE;
1936 if (!STRCMP(keywords[i+1],"hide"))
1937 pU->ovlywindowParams.nCmdShow = SW_HIDE;
1938 if (!STRCMP(keywords[i+1],"iconic"))
1939 pU->ovlywindowParams.nCmdShow = SW_SHOWMINNOACTIVE; /* correct? */
1940 if (!STRCMP(keywords[i+1],"minimized"))
1941 pU->ovlywindowParams.nCmdShow = SW_SHOWMINIMIZED;
1942 if (!STRCMP(keywords[i+1],"maximized"))
1943 pU->ovlywindowParams.nCmdShow = SW_SHOWMAXIMIZED;
1944 if (!STRCMP(keywords[i+1],"minimize"))
1945 pU->ovlywindowParams.nCmdShow = SW_MINIMIZE;
1946 if (!STRCMP(keywords[i+1],"normal"))
1947 pU->ovlywindowParams.nCmdShow = SW_NORMAL;
1948 if (!STRCMP(keywords[i+1],"show"))
1949 pU->ovlywindowParams.nCmdShow = SW_SHOW;
1950 if (!STRCMP(keywords[i+1],"no") && (i+2 < nrofkeywords)) {
1951 if (!STRCMP(keywords[i+2],"active"))
1952 pU->ovlywindowParams.nCmdShow = SW_SHOWNOACTIVATE;
1953 if (!STRCMP(keywords[i+2],"action"))
1954 pU->ovlywindowParams.nCmdShow = SW_SHOWNA;/* correct?*/
1955 i++;
1956 }
1957 i+=2;
1958 continue;
1959 }
1960 /* text is enclosed in " ... " as it seems */
1961 if (!STRCMP(keywords[i],"text")) {
1962 char *t;
1963 int len,j,k;
1964
1965 if (keywords[i+1][0]!='"') {
1966 i++;
1967 continue;
1968 }
1969 dwFlags |= MCI_OVLY_WINDOW_TEXT;
1970 len = strlen(keywords[i+1])+1;
1971 j = i+2;
1972 while (j < nrofkeywords) {
1973 len += strlen(keywords[j])+1;
1974 if (strchr(keywords[j],'"'))
1975 break;
1976 j++;
1977 }
1978 s=(char*)xmalloc(len);
1979 strcpy(s,keywords[i+1]+1);
1980 k=j;j=i+2;
1981 while (j<=k) {
1982 strcat(s," ");
1983 strcat(s,keywords[j]);
1984 }
1985 if ((t=strchr(s,'"'))) *t='\0';
1986 /* FIXME: segmented pointer? */
1987 pU->ovlywindowParams.lpstrText = s;
1988 i=k+1;
1989 continue;
1990 }
1991 FLAG1("stretch",MCI_OVLY_WINDOW_ENABLE_STRETCH);
1992 break;
1993 }
1994 i++;
1995 }
1996 res = mciSendCommandA(wDevID, MCI_WINDOW, dwFlags, (DWORD)pU);
1997 if (s) free(s);
1998 free(pU);
1999 return res;
2000 }
2001
2002 struct _MCISTR_cmdtable {
2003 char *cmd;
2004 DWORD (*fun)(_MCISTR_PROTO_);
2005 } MCISTR_cmdtable[]={
2006 {"break", MCISTR_Break},
2007 {"capability", MCISTR_Capability},
2008 {"close", MCISTR_Close},
2009 {"cue", MCISTR_Cue},
2010 {"delete", MCISTR_Delete},
2011 {"escape", MCISTR_Escape},
2012 {"freeze", MCISTR_Freeze},
2013 {"info", MCISTR_Info},
2014 {"load", MCISTR_Load},
2015 {"open", MCISTR_Open},
2016 {"pause", MCISTR_Pause},
2017 {"play", MCISTR_Play},
2018 {"put", MCISTR_Put},
2019 {"realize", MCISTR_Realize},
2020 {"record", MCISTR_Record},
2021 {"resume", MCISTR_Resume},
2022 {"save", MCISTR_Save},
2023 {"seek", MCISTR_Seek},
2024 {"set", MCISTR_Set},
2025 {"spin", MCISTR_Spin},
2026 {"status", MCISTR_Status},
2027 {"step", MCISTR_Step},
2028 {"stop", MCISTR_Stop},
2029 {"sysinfo", MCISTR_Sysinfo},
2030 {"unfreeze", MCISTR_Unfreeze},
2031 {"update", MCISTR_Update},
2032 {"where", MCISTR_Where},
2033 {"window", MCISTR_Window},
2034 {NULL, NULL}
2035 };
2036
2037 /**************************************************************************
2038 * mciSendString16 [MMSYSTEM.702]
2039 */
2040 /* The usercode sends a string with a command (and flags) expressed in
2041 * words in it... We do our best to call aprobiate drivers,
2042 * and return a errorcode AND a readable string (if lpstrRS!=NULL)
2043 * Info gathered by watching cool134.exe and from Borland's mcistrwh.hlp
2044 */
2045 /* FIXME: "all" is a valid devicetype and we should access all devices if
2046 * it is used. (imagine "close all"). Not implemented yet.
2047 */
2048 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
2049 UINT16 uReturnLength, HWND16 hwndCallback)
2050 {
2051 char *cmd,*dev,*args,**keywords,*filename;
2052 WORD uDevTyp=0,wDevID=0;
2053 DWORD dwFlags;
2054 int res=0,i,nrofkeywords;
2055
2056 TRACE(mci,"('%s', %p, %d, %X)\n",
2057 lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
2058
2059 /* format is <command> <device> <optargs> */
2060 cmd=strdup(lpstrCommand);
2061 dev=strchr(cmd,' ');
2062 if (dev==NULL) {
2063 free(cmd);
2064 return MCIERR_MISSING_DEVICE_NAME;
2065 }
2066 *dev++='\0';
2067 args=strchr(dev,' ');
2068 if (args!=NULL) *args++='\0';
2069 CharUpperA(dev);
2070 if (args!=NULL) {
2071 char *s;
2072 i=1;/* nrofkeywords = nrofspaces+1 */
2073 s=args;
2074 while ((s=strchr(s,' '))!=NULL) i++,s++;
2075 keywords=(char**)xmalloc(sizeof(char*)*(i+2));
2076 nrofkeywords=i;
2077 s=args;i=0;
2078 while (s && i < nrofkeywords) {
2079 keywords[i++]=s;
2080 s=strchr(s,' ');
2081 if (s) *s++='\0';
2082 }
2083 keywords[i]=NULL;
2084 } else {
2085 nrofkeywords=0;
2086 keywords=(char**)xmalloc(sizeof(char*));
2087 }
2088 dwFlags = 0; /* default flags */
2089 for (i=0;i < nrofkeywords;) {
2090 /* take care, there is also a "device type" capability */
2091 if ((!STRCMP(keywords[i],"type")) && (i < nrofkeywords-1)) {
2092 filename = dev;
2093 dev = keywords[i+1];
2094 memcpy(keywords+i,keywords+(i+2),(nrofkeywords-i-2)*sizeof(char *));
2095 nrofkeywords -= 2;
2096 continue;
2097 }
2098 if (!STRCMP(keywords[i],"wait")) {
2099 dwFlags |= MCI_WAIT;
2100 memcpy(keywords+i,keywords+(i+1),(nrofkeywords-i-1)*sizeof(char *));
2101 nrofkeywords--;
2102 continue;
2103 }
2104 if (!STRCMP(keywords[i],"notify")) {
2105 dwFlags |= MCI_NOTIFY;
2106 memcpy(keywords+i,keywords+(i+1),(nrofkeywords-i-1)*sizeof(char *));
2107 nrofkeywords--;
2108 continue;
2109 }
2110 i++;
2111 }
2112
2113 /* FIXME: this code should be moved to mmsystem.c */
2114 /* determine wDevID and uDevTyp for all commands except "open" */
2115 if (STRCMP(cmd,"open")!=0) {
2116 wDevID = MCI_FirstDevID();
2117 while (1) {
2118 LPSTR dname;
2119
2120 dname=MCI_GetOpenDrv(wDevID)->lpstrAlias;
2121 if (dname==NULL)
2122 dname=MCI_GetOpenDrv(wDevID)->lpstrDeviceType;
2123 if (dname != NULL && !STRCMP(dname,dev))
2124 break;
2125 wDevID = MCI_NextDevID(wDevID);
2126 if (!MCI_DevIDValid(wDevID)) {
2127 TRACE(mci, "MAXMCIDRIVERS reached!\n");
2128 free(keywords);free(cmd);
2129 return MCIERR_INVALID_DEVICE_NAME;
2130 }
2131 }
2132 uDevTyp=MCI_GetDrv(wDevID)->modp.wType;
2133 }
2134 /* end of FIXME */
2135
2136 for (i=0;MCISTR_cmdtable[i].cmd!=NULL;i++) {
2137 if (!STRCMP(MCISTR_cmdtable[i].cmd,cmd)) {
2138 res=MCISTR_cmdtable[i].fun(
2139 wDevID,uDevTyp,lpstrReturnString,
2140 uReturnLength,dev,(LPSTR*)keywords,nrofkeywords,
2141 dwFlags,hwndCallback
2142 );
2143 break;
2144 }
2145 }
2146 if (MCISTR_cmdtable[i].cmd!=NULL) {
2147 free(keywords);free(cmd);
2148 return res;
2149 }
2150 FIXME(mci,"('%s', %p, %u, %X): unimplemented, please report.\n",
2151 lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
2152 free(keywords);free(cmd);
2153 return MCIERR_MISSING_COMMAND_STRING;
2154 }
2155
2156 /**************************************************************************
2157 * mciSendStringA [MMSYSTEM.702][WINMM.51]
2158 */
2159 DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
2160 UINT uReturnLength, HWND hwndCallback)
2161 {
2162 return mciSendString16(lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
2163 }
2164
2165 /**************************************************************************
2166 * mciSendStringW [WINMM.52]
2167 */
2168 DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrReturnString,
2169 UINT uReturnLength, HWND hwndCallback)
2170 {
2171 LPSTR lpstrCommand;
2172 UINT ret;
2173
2174 /* FIXME: is there something to do with lpstrReturnString ? */
2175 lpstrCommand = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrCommand);
2176 ret = mciSendString16(lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
2177 HeapFree(GetProcessHeap(), 0, lpstrCommand);
2178 return ret;
2179 }
2180
2181 /**************************************************************************
2182 * mciExecute [WINMM.38]
2183 */
2184 DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
2185 {
2186 char strRet[256];
2187 DWORD ret;
2188
2189 FIXME(mci, "(%s) stub!\n", lpstrCommand);
2190
2191 ret = mciSendString16(lpstrCommand, strRet, sizeof(strRet), 0);
2192 if (ret != 0) {
2193 if (!mciGetErrorString16(ret, strRet, sizeof(strRet))) {
2194 sprintf(strRet, "Unknown MCI Error (%ld)", ret);
2195 }
2196 MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
2197 }
2198 return 0;
2199 }
Maarten's multimedia branch