git.oblomov.eu Git - wine/blob - multimedia/mcistring.c

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