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