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