/* -*- tab-width: 8; c-basic-offset: 4 -*- */

/*
 * MCI stringinterface
 *
 * Copyright 1995 Marcus Meissner
 */
/* FIXME: special commands of device drivers should be handled by those drivers
 */

/* FIXME: this current implementation does not allow commands like
 * capability <filename> can play
 * which is allowed by the MCI standard.
 */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "multimedia.h"
#include "heap.h"
#include "ldt.h"
#include "user.h"
#include "driver.h"
#include "callback.h"
#include "debug.h"
#include "xmalloc.h"

/* The reason why I just don't lowercase the keywords array in 
 * mciSendString is left as an exercise to the reader.
 */
#define STRCMP(x,y) lstrcmpiA(x,y)

/* standard function parameters for all functions */
#define _MCISTR_PROTO_ 				       		\
	WORD wDevID, WORD uDevTyp, LPSTR lpstrReturnString,	\
        UINT16 uReturnLength, LPCSTR dev, LPSTR *keywords,	\
	UINT16 nrofkeywords, DWORD dwFlags, HWND16 hwndCallback

/* copy string to return pointer including necessary checks 
 * for use in mciSendString()
 */
#define _MCI_STR(s) 						\
do {								\
    TRACE(mci, "->returns '%s'\n", s);				\
    if (lpstrReturnString) {					\
	lstrcpynA(lpstrReturnString, s, uReturnLength);		\
	TRACE(mci, "-->'%s'\n", lpstrReturnString);		\
    }								\
} while(0)

/* print a DWORD in the specified timeformat */
static void
_MCISTR_printtf(char *buf, UINT16 uDevType, DWORD timef, DWORD val) 
{
    *buf = '\0';
    switch (timef) {
    case MCI_FORMAT_MILLISECONDS:
    case MCI_FORMAT_FRAMES:
    case MCI_FORMAT_BYTES:
    case MCI_FORMAT_SAMPLES:
    case MCI_VD_FORMAT_TRACK:
	/*case MCI_SEQ_FORMAT_SONGPTR: sameas MCI_VD_FORMAT_TRACK */
	sprintf(buf, "%ld",val);
	break;
    case MCI_FORMAT_HMS:
	/* well, the macros have the same content*/
	/*FALLTRHOUGH*/
    case MCI_FORMAT_MSF:
	sprintf(buf, "%d:%d:%d", 
		MCI_HMS_HOUR(val),
		MCI_HMS_MINUTE(val),
		MCI_HMS_SECOND(val));
	break;
    case MCI_FORMAT_TMSF:
	sprintf(buf, "%d:%d:%d:%d",
		MCI_TMSF_TRACK(val),
		MCI_TMSF_MINUTE(val),
		MCI_TMSF_SECOND(val),
		MCI_TMSF_FRAME(val));
	break;
    default:
	FIXME(mci, "missing timeformat for %ld, report.\n",timef);
	strcpy(buf,"0"); /* hmm */
	break;
    }
    return;
}
/* possible different return types */
#define _MCISTR_int	1
#define _MCISTR_time	2
#define _MCISTR_bool	3
#define _MCISTR_tfname	4
#define _MCISTR_mode	5
#define _MCISTR_divtype	6
#define _MCISTR_seqtype	7
#define _MCISTR_vdmtype	8
#define _MCISTR_devtype	9

static void
_MCISTR_convreturn(int type, DWORD dwReturn, LPSTR lpstrReturnString,
		   WORD uReturnLength, WORD uDevTyp, int timef) 
{
    switch (type) {
    case _MCISTR_vdmtype:
	switch (dwReturn) {
	case MCI_VD_MEDIA_CLV:	_MCI_STR("CLV");	break;
	case MCI_VD_MEDIA_CAV:	_MCI_STR("CAV");	break;
	default:
	case MCI_VD_MEDIA_OTHER:_MCI_STR("other");	break;
	}
	break;
    case _MCISTR_seqtype:
	switch (dwReturn) {
	case MCI_SEQ_NONE:	_MCI_STR("none");	break;
	case MCI_SEQ_SMPTE:	_MCI_STR("smpte");	break;
	case MCI_SEQ_FILE:	_MCI_STR("file");	break;
	case MCI_SEQ_MIDI:	_MCI_STR("midi");	break;
	default:FIXME(mci,"missing sequencer mode %ld\n",dwReturn);
	}
	break;
    case _MCISTR_mode:
	switch (dwReturn) {
	case MCI_MODE_NOT_READY:_MCI_STR("not ready");	break;
	case MCI_MODE_STOP:	_MCI_STR("stopped");	break;
	case MCI_MODE_PLAY:	_MCI_STR("playing");	break;
	case MCI_MODE_RECORD:	_MCI_STR("recording");	break;
	case MCI_MODE_SEEK:	_MCI_STR("seeking");	break;
	case MCI_MODE_PAUSE:	_MCI_STR("paused");	break;
	case MCI_MODE_OPEN:	_MCI_STR("open");	break;
	default:break;
	}
	break;
    case _MCISTR_bool:
	if (dwReturn)
	    _MCI_STR("true");
	else
	    _MCI_STR("false");
	break;
    case _MCISTR_int:{
	char	buf[16];
	sprintf(buf,"%ld",dwReturn);
	_MCI_STR(buf);
	break;
    }
    case _MCISTR_time: {	
	char	buf[100];
	_MCISTR_printtf(buf,uDevTyp,timef,dwReturn);
	_MCI_STR(buf);
	break;
    }
    case _MCISTR_tfname:
	switch (timef) {
	case MCI_FORMAT_MILLISECONDS:	_MCI_STR("milliseconds");	break;
	case MCI_FORMAT_FRAMES:		_MCI_STR("frames");		break;
	case MCI_FORMAT_BYTES:		_MCI_STR("bytes");		break;
	case MCI_FORMAT_SAMPLES:	_MCI_STR("samples");		break;
	case MCI_FORMAT_HMS:		_MCI_STR("hms");		break;
	case MCI_FORMAT_MSF:		_MCI_STR("msf");		break;
	case MCI_FORMAT_TMSF:		_MCI_STR("tmsf");		break;
	default:
	    FIXME(mci,"missing timefmt for %d, report.\n",timef);
	    break;
	}
	break;
    case _MCISTR_divtype:
	switch (dwReturn) {
	case MCI_SEQ_DIV_PPQN:		_MCI_STR("PPQN");		break;
	case MCI_SEQ_DIV_SMPTE_24:	_MCI_STR("SMPTE 24 frame");	break;
	case MCI_SEQ_DIV_SMPTE_25:	_MCI_STR("SMPTE 25 frame");	break;
	case MCI_SEQ_DIV_SMPTE_30:	_MCI_STR("SMPTE 30 frame");	break;
	case MCI_SEQ_DIV_SMPTE_30DROP:	_MCI_STR("SMPTE 30 frame drop");break;
	}
    case _MCISTR_devtype:
	switch (dwReturn) {
	case MCI_DEVTYPE_VCR:		_MCI_STR("vcr");		break;
	case MCI_DEVTYPE_VIDEODISC:	_MCI_STR("videodisc");		break;
	case MCI_DEVTYPE_CD_AUDIO:	_MCI_STR("cd audio");		break;
	case MCI_DEVTYPE_OVERLAY:	_MCI_STR("overlay");		break;
	case MCI_DEVTYPE_DAT:		_MCI_STR("dat");		break;
	case MCI_DEVTYPE_SCANNER:	_MCI_STR("scanner");		break;
	case MCI_DEVTYPE_ANIMATION:	_MCI_STR("animation");		break;
	case MCI_DEVTYPE_DIGITAL_VIDEO:	_MCI_STR("digital video");	break;
	case MCI_DEVTYPE_OTHER:		_MCI_STR("other");		break;
	case MCI_DEVTYPE_WAVEFORM_AUDIO:_MCI_STR("waveform audio");	break;
	case MCI_DEVTYPE_SEQUENCER:	_MCI_STR("sequencer");		break;
	default:FIXME(mci,"unknown device type %ld, report.\n",
		      dwReturn);break;
	}
	break;
    default:
	FIXME(mci,"unknown resulttype %d, report.\n",type);
	break;
    }
}

#define FLAG1(str,flag) 			\
	if (!STRCMP(keywords[i],str)) {		\
		dwFlags |= flag;		\
		i++;				\
		continue;			\
	}

#define FLAG2(str1,str2,flag) 			\
	if (!STRCMP(keywords[i],str1) &&	\
	    (i+1<nrofkeywords) && 		\
            !STRCMP(keywords[i+1],str2)) {	\
		dwFlags |= flag;		\
		i+=2;				\
		continue;			\
	}

/* All known subcommands are implemented in single functions to avoid
 * bloat and a xxxx lines long mciSendString(). All commands are of the
 * format MCISTR_Cmd(_MCISTR_PROTO_) where _MCISTR_PROTO_ is the above
 * defined line of arguments. (This is just for easy enhanceability.)
 * All functions return the MCIERR_ errorvalue as DWORD. Returnvalues
 * for the calls are in lpstrReturnString (If I mention return values
 * in function headers, I mean returnvalues in lpstrReturnString.)
 * Integers are sprintf("%d")ed integers. Boolean values are 
 * "true" and "false". 
 * timeformat depending values are "%d" "%d:%d" "%d:%d:%d" "%d:%d:%d:%d"
 * FIXME: is above line correct?
 *
 * Preceding every function is a list of implemented/known arguments.
 * Feel free to add missing arguments.
 *
 */

/*
 * Opens the specified MCI driver. 
 * Arguments: <name> 
 * Optional:
 *	"shareable"
 *	"alias <aliasname>"
 * 	"element <elementname>"
 * Additional:
 * waveform audio:
 *	"buffer <nrBytesPerSec>"
 * Animation:
 *	"nostatic"	increaste nr of nonstatic colours
 *	"parent <windowhandle>"
 *	"style <mask>"	bitmask of WS_xxxxx (see windows.h)
 *	"style child"	WS_CHILD
 *	"style overlap"	WS_OVERLAPPED
 *	"style popup"	WS_POPUP
 * Overlay:
 *	"parent <windowhandle>"
 *	"style <mask>"	bitmask of WS_xxxxx (see windows.h)
 *	"style child"	WS_CHILD
 *	"style overlap"	WS_OVERLAPPED
 *	"style popup"	WS_POPUP
 * Returns nothing.
 */
static DWORD
MCISTR_Open(_MCISTR_PROTO_) 
{
    int			res,i;
    char		*s;
    union U {
	MCI_OPEN_PARMS16	openParams;
	MCI_WAVE_OPEN_PARMS16	waveopenParams;
	MCI_ANIM_OPEN_PARMS16	animopenParams;
	MCI_OVLY_OPEN_PARMS16	ovlyopenParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    
    pU->openParams.lpstrElementName = NULL;
    s = strchr(dev,'!');
    if (s != NULL) {
	*s++ = '\0';
	pU->openParams.lpstrElementName = strdup(s);
	dwFlags |= MCI_OPEN_ELEMENT;
    }
    uDevTyp = MCI_GetDevType(dev);
    if (uDevTyp == 0) {
	free(pU->openParams.lpstrElementName);
	free(pU);
	return MCIERR_INVALID_DEVICE_NAME;
    }

    pU->openParams.dwCallback	= hwndCallback;
    pU->openParams.wDeviceID	= wDevID;
    pU->openParams.wReserved0   = 0;
    pU->ovlyopenParams.dwStyle	= 0; 
    pU->animopenParams.dwStyle	= 0; 
    pU->openParams.lpstrDeviceType	= strdup(dev);
    pU->openParams.lpstrAlias	= NULL;
    dwFlags |= MCI_OPEN_TYPE;
    i = 0;
    while (i < nrofkeywords) {
	FLAG1("shareable",MCI_OPEN_SHAREABLE);
	if (!STRCMP(keywords[i],"alias") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_OPEN_ALIAS;
	    pU->openParams.lpstrAlias = strdup(keywords[i+1]);
	    i+=2;
	    continue;
	}
	if (!STRCMP(keywords[i],"element") && (i+1<nrofkeywords)) {
	    dwFlags |= MCI_OPEN_ELEMENT;
	    pU->openParams.lpstrElementName = strdup(keywords[i+1]);
	    i+=2;
	    continue;
	}
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	case MCI_DEVTYPE_DIGITAL_VIDEO:
	    FLAG1("nostatic",MCI_ANIM_OPEN_NOSTATIC);
	    if (!STRCMP(keywords[i],"parent") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_ANIM_OPEN_PARENT;
		sscanf(keywords[i+1], "%hu", &(pU->animopenParams.hWndParent));
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i], "style") && (i+1 < nrofkeywords)) {
		DWORD	st;
		
		dwFlags |= MCI_ANIM_OPEN_WS;
		if (!STRCMP(keywords[i+1],"popup")) {
		    pU->animopenParams.dwStyle |= WS_POPUP; 
		} else if (!STRCMP(keywords[i+1],"overlap")) {
		    pU->animopenParams.dwStyle |= WS_OVERLAPPED; 
		} else if (!STRCMP(keywords[i+1],"child")) {
		    pU->animopenParams.dwStyle |= WS_CHILD; 
		} else if (sscanf(keywords[i+1],"%ld",&st)) {
		    pU->animopenParams.dwStyle |= st; 
		} else
		    FIXME(mci, "unknown 'style' keyword %s, please report.\n", keywords[i+1]);
		i+=2;
		continue;
	    }
	    break;
	case MCI_DEVTYPE_WAVEFORM_AUDIO:
	    if (!STRCMP(keywords[i],"buffer") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_WAVE_OPEN_BUFFER;
		sscanf(keywords[i+1], "%ld", &(pU->waveopenParams.dwBufferSeconds));
	    }
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    /* looks just like anim, but without NOSTATIC */
	    if (!STRCMP(keywords[i], "parent") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_OVLY_OPEN_PARENT;
		sscanf(keywords[i+1], "%hd", &(pU->ovlyopenParams.hWndParent));
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i],"style") && (i+1 < nrofkeywords)) {
		DWORD	st;
		
		dwFlags |= MCI_OVLY_OPEN_WS;
		if (!STRCMP(keywords[i+1],"popup")) {
		    pU->ovlyopenParams.dwStyle |= WS_POPUP; 
		} else if (!STRCMP(keywords[i+1],"overlap")) {
		    pU->ovlyopenParams.dwStyle |= WS_OVERLAPPED; 
		} else if (!STRCMP(keywords[i+1],"child")) {
		    pU->ovlyopenParams.dwStyle |= WS_CHILD; 
		} else if (sscanf(keywords[i+1],"%ld",&st)) {
		    pU->ovlyopenParams.dwStyle |= st; 
		} else
		    FIXME(mci,"unknown 'style' keyword %s, please report.\n",keywords[i+1]);
		i+=2;
		continue;
	    }
	    break;
	}
	FIXME(mci,"unknown parameter passed %s, please report.\n",
	      keywords[i]);
	i++;
    }
    res = mciSendCommandA(0, MCI_OPEN, dwFlags, (DWORD)pU);

    free(pU->openParams.lpstrElementName);
    free(pU->openParams.lpstrDeviceType);
    free(pU->openParams.lpstrAlias);
    free(pU);
    return res;
}

/* A help function for a lot of others ... 
 * for instance status/play/record/seek etc.
 */
DWORD
_MCISTR_determine_timeformat(LPCSTR dev,WORD wDevID,WORD uDevTyp,int *timef)
{
    int			res;
    DWORD dwFlags = MCI_STATUS_ITEM;
    MCI_STATUS_PARMS *statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
    
    if (!statusParams) return 0;
    statusParams->dwItem	= MCI_STATUS_TIME_FORMAT;
    statusParams->dwReturn	= 0;
    res = mciSendCommandA(wDevID, MCI_STATUS, dwFlags, (DWORD)statusParams);

    if (res==0) *timef = statusParams->dwReturn;
    free(statusParams);
    return res;
}

/* query status of MCI drivers
 * Arguments:
 * Required: 
 *	"mode"	- returns "not ready" "paused" "playing" "stopped" "open" 
 *		  "parked" "recording" "seeking" ....
 * Basics:
 *	"current track"	- returns current track as integer
 *	"length [track <nr>]"	- returns length [of track <nr>] in current 
 *				timeformat
 *	"number of tracks" - returns number of tracks as integer
 *	"position [track <nr>]" - returns position [in track <nr>] in current 
 *				timeformat
 *	"ready"			- checks if device is ready to play, -> bool
 *	"start position"	- returns start position in timeformat
 *	"time format"		- returns timeformat (list of possible values:
 * 				"ms" "msf" "milliseconds" "hmsf" "tmsf" "frames"
 *				"bytes" "samples" "hms")
 *	"media present"		- returns if media is present as bool
 * Animation:
 *	"forward"		- returns "true" if device is playing forwards
 *	"speed"			- returns speed for device
 *	"palette handle"	- returns palette handle
 *	"window handle"		- returns window handle
 * 	"stretch"		- returns stretch bool
 * MIDI sequencer:
 *	"division type"		- ? returns "PPQN" "SMPTE 24 frame" 
 * 			"SMPTE 25 frame" "SMPTE 30 frame" "SMPTE 30 drop frame"
 *	"tempo"			- current tempo in (PPQN? speed in frames, SMPTE*? speed in hsmf)
 *	"offset"		- offset in dito.
 *	"port"			- midi port as integer
 * 	"slave"			- slave device ("midi","file","none","smpte")
 *	"master"		- masterdevice (dito.)
 * Overlay:
 *	"window handle"		- see animation
 *	"stretch"		- dito
 * Video Disc:
 *	"speed"			- speed as integer
 *	"forward"		- returns bool (when playing forward)
 *	"side"			- returns 1 or 2
 *	"media type"		- returns "CAV" "CLV" "other"
 *	"disc size"		- returns "8" or "12"
 * WAVEFORM audio:
 *	"input"			- base queries on input set
 *	"output"		- base queries on output set
 *	"format tag"		- return integer format tag
 *	"channels"		- return integer nr of channels
 *	"bytespersec"		- return average nr of bytes/sec
 *	"samplespersec"		- return nr of samples per sec
 *	"bitspersample"		- return bitspersample
 *	"alignment"		- return block alignment
 *	"level"			- return level?
 */

#define ITEM1(str,item,xtype) 			\
	if (!STRCMP(keywords[i],str)) {		\
		statusParams->dwItem = item;	\
		type = xtype;			\
		i++;				\
		continue;			\
	}
#define ITEM2(str1,str2,item,xtype) 		\
	if (	!STRCMP(keywords[i],str1) &&	\
		(i+1 < nrofkeywords) &&		\
		!STRCMP(keywords[i+1],str2)) {	\
		statusParams->dwItem = item;	\
		type = xtype;			\
		i+=2;				\
		continue;			\
	}
#define ITEM3(str1,str2,str3,item,xtype) 	\
	if (	!STRCMP(keywords[i],str1) &&	\
		(i+2 < nrofkeywords) &&		\
		!STRCMP(keywords[i+1],str2) &&	\
		!STRCMP(keywords[i+2],str3)) {	\
		statusParams->dwItem = item;	\
		type = xtype;			\
		i+=3;				\
		continue;			\
	}

static DWORD
MCISTR_Status(_MCISTR_PROTO_) {
    MCI_STATUS_PARMS	*statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
    int			type = 0,i,res,timef;
    
    statusParams->dwCallback = hwndCallback;
    dwFlags	|= MCI_STATUS_ITEM;
    res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
    if (res) return res;
    
    statusParams->dwReturn	= 0;
    statusParams->dwItem	= 0;
    i = 0;
    
    while (i < nrofkeywords) {
	if (!STRCMP(keywords[i],"track") && (i+1 < nrofkeywords)) {
	    sscanf(keywords[i+1],"%ld",&(statusParams->dwTrack));
	    dwFlags |= MCI_TRACK;
	    i+=2;
	    continue;
	}
	FLAG1("start",MCI_STATUS_START);
	/* generic things */
	ITEM2("current","track",MCI_STATUS_CURRENT_TRACK,_MCISTR_time);
	ITEM2("time","format",MCI_STATUS_TIME_FORMAT,_MCISTR_tfname);
	ITEM1("ready",MCI_STATUS_READY,_MCISTR_bool);
	ITEM1("mode",MCI_STATUS_MODE,_MCISTR_mode);
	ITEM3("number","of","tracks",MCI_STATUS_NUMBER_OF_TRACKS,_MCISTR_int);
	ITEM1("length",MCI_STATUS_LENGTH,_MCISTR_time);
	ITEM1("position",MCI_STATUS_POSITION,_MCISTR_time);
	ITEM2("media","present",MCI_STATUS_MEDIA_PRESENT,_MCISTR_bool);
	
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	case MCI_DEVTYPE_DIGITAL_VIDEO:
	    ITEM2("palette","handle",MCI_ANIM_STATUS_HPAL,_MCISTR_int);
	    ITEM2("window","handle",MCI_ANIM_STATUS_HWND,_MCISTR_int);
	    ITEM1("stretch",MCI_ANIM_STATUS_STRETCH,_MCISTR_bool);
	    ITEM1("speed",MCI_ANIM_STATUS_SPEED,_MCISTR_int);
	    ITEM1("forward",MCI_ANIM_STATUS_FORWARD,_MCISTR_bool);
	    break;
	case MCI_DEVTYPE_SEQUENCER:
	    /* just completing the list, not working correctly */
	    ITEM2("division","type",MCI_SEQ_STATUS_DIVTYPE,_MCISTR_divtype);
	    /* tempo ... PPQN in frames/second, SMPTE in hmsf */
	    ITEM1("tempo",MCI_SEQ_STATUS_TEMPO,_MCISTR_int);
	    ITEM1("port",MCI_SEQ_STATUS_PORT,_MCISTR_int);
	    ITEM1("slave",MCI_SEQ_STATUS_SLAVE,_MCISTR_seqtype);
	    ITEM1("master",MCI_SEQ_STATUS_SLAVE,_MCISTR_seqtype);
	    /* offset ... PPQN in frames/second, SMPTE in hmsf */
	    ITEM1("offset",MCI_SEQ_STATUS_SLAVE,_MCISTR_time);
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    ITEM2("window","handle",MCI_OVLY_STATUS_HWND,_MCISTR_int);
	    ITEM1("stretch",MCI_OVLY_STATUS_STRETCH,_MCISTR_bool);
	    break;
	case MCI_DEVTYPE_VIDEODISC:
	    ITEM1("speed",MCI_VD_STATUS_SPEED,_MCISTR_int);
	    ITEM1("forward",MCI_VD_STATUS_FORWARD,_MCISTR_bool);
	    ITEM1("side",MCI_VD_STATUS_SIDE,_MCISTR_int);
	    ITEM2("media","type",MCI_VD_STATUS_SIDE,_MCISTR_vdmtype);
	    /* returns 8 or 12 */
	    ITEM2("disc","size",MCI_VD_STATUS_DISC_SIZE,_MCISTR_int);
	    break;
	case MCI_DEVTYPE_WAVEFORM_AUDIO:
	    /* I am not quite sure if foll. 2 lines are right. */
	    FLAG1("input",MCI_WAVE_INPUT);
	    FLAG1("output",MCI_WAVE_OUTPUT);
	    
	    ITEM2("format","tag",MCI_WAVE_STATUS_FORMATTAG,_MCISTR_int);
	    ITEM1("channels",MCI_WAVE_STATUS_CHANNELS,_MCISTR_int);
	    ITEM1("bytespersec",MCI_WAVE_STATUS_AVGBYTESPERSEC,_MCISTR_int);
	    ITEM1("samplespersec",MCI_WAVE_STATUS_SAMPLESPERSEC,_MCISTR_int);
	    ITEM1("bitspersample",MCI_WAVE_STATUS_BITSPERSAMPLE,_MCISTR_int);
	    ITEM1("alignment",MCI_WAVE_STATUS_BLOCKALIGN,_MCISTR_int);
	    ITEM1("level",MCI_WAVE_STATUS_LEVEL,_MCISTR_int);
	    break;
	}
	FIXME(mci,"unknown keyword '%s'\n",keywords[i]);
	i++;
    }
    if (!statusParams->dwItem) 
	return MCIERR_MISSING_STRING_ARGUMENT;
    
    res = mciSendCommandA(wDevID, MCI_STATUS, dwFlags, (DWORD)statusParams);

    if (res==0)
	_MCISTR_convreturn(type,statusParams->dwReturn,lpstrReturnString,uReturnLength,uDevTyp,timef);
    free(statusParams);
    return res;
}
#undef ITEM1
#undef ITEM2
#undef ITEM3

/* set specified parameters in respective MCI drivers
 * Arguments:
 *	"door open"	eject media or somesuch
 *	"door close"	load media
 *	"time format <timeformatname>"	"ms" "milliseconds" "msf" "hmsf" 
 *					"tmsf" "SMPTE 24" "SMPTE 25" "SMPTE 30"
 *					"SMPTE drop 30"
 *	"audio [all|left|right] [on|off]" sets specified audiochannel on or off
 *	"video [on|off]"		sets video on/off
 * Waveform audio:
 *	"formattag pcm"		sets format to pcm
 *	"formattag <nr>"	sets integer formattag value
 *	"any input"		accept input from any known source
 *	"any output"		output to any known destination
 *	"input <nr>"		input from source <nr>
 *	"output <nr>"		output to destination <nr>
 *	"channels <nr>"		sets nr of channels 
 *	"bytespersec <nr>"	sets average bytes per second
 *	"samplespersec <nr>"	sets average samples per second (1 sample can
 *				be 2 bytes!) 
 *	"alignment <nr>"	sets the blockalignment to <nr>
 *	"bitspersample <nr>"	sets the nr of bits per sample
 * Sequencer:
 *	"master [midi|file|smpte|none]" sets the midi master device
 *	"slave [midi|file|smpte|none]" sets the midi master device
 *	"port mapper"		midioutput to portmapper
 *	"port <nr>"		midioutput to specified port
 *	"tempo <nr>"		tempo of track (depends on timeformat/divtype)
 *	"offset <nr>"		start offset?
 */
static DWORD
MCISTR_Set(_MCISTR_PROTO_) {
    union U {
	MCI_SET_PARMS		setParams;
	MCI_WAVE_SET_PARMS16	wavesetParams;
	MCI_SEQ_SET_PARMS	seqsetParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    int	i,res;
    
    pU->setParams.dwCallback = hwndCallback;
    i = 0;
    while (i < nrofkeywords) {
	FLAG2("door","open",MCI_SET_DOOR_OPEN);
	FLAG2("door","closed",MCI_SET_DOOR_CLOSED);
	
	if (	!STRCMP(keywords[i],"time") && 
		(i+2 < nrofkeywords) &&
		!STRCMP(keywords[i+1],"format")
		) {
	    dwFlags |= MCI_SET_TIME_FORMAT;
	    
	    /* FIXME:is this a shortcut for milliseconds or
	     *	 minutes:seconds? */
	    if (!STRCMP(keywords[i+2],"ms"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
	    
	    if (!STRCMP(keywords[i+2],"milliseconds"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
	    if (!STRCMP(keywords[i+2],"msf"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_MSF;
	    if (!STRCMP(keywords[i+2],"hms"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_HMS;
	    if (!STRCMP(keywords[i+2],"frames"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_FRAMES;
	    if (!STRCMP(keywords[i+2],"track"))
		pU->setParams.dwTimeFormat = MCI_VD_FORMAT_TRACK;
	    if (!STRCMP(keywords[i+2],"bytes"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_BYTES;
	    if (!STRCMP(keywords[i+2],"samples"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_SAMPLES;
	    if (!STRCMP(keywords[i+2],"tmsf"))
		pU->setParams.dwTimeFormat = MCI_FORMAT_TMSF;
	    if (	!STRCMP(keywords[i+2],"song") && 
			(i+3 < nrofkeywords) &&
			!STRCMP(keywords[i+3],"pointer")
			)
		pU->setParams.dwTimeFormat = MCI_SEQ_FORMAT_SONGPTR;
	    if (!STRCMP(keywords[i+2],"smpte") && (i+3 < nrofkeywords)) {
		if (!STRCMP(keywords[i+3],"24"))
		    pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_24;
		if (!STRCMP(keywords[i+3],"25"))
		    pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_25;
		if (!STRCMP(keywords[i+3],"30"))
		    pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_30;
		if (!STRCMP(keywords[i+3],"drop") && (i+4 < nrofkeywords) && !STRCMP(keywords[i+4],"30")) {
		    pU->setParams.dwTimeFormat = MCI_FORMAT_SMPTE_30DROP;
		    i++;
		}
		i++;
				/*FALLTHROUGH*/
	    }
	    i+=3;
	    continue;
	}
	if (!STRCMP(keywords[i],"audio") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_SET_AUDIO;
	    if (!STRCMP(keywords[i+1],"all"))
		pU->setParams.dwAudio = MCI_SET_AUDIO_ALL;
	    if (!STRCMP(keywords[i+1],"left"))
		pU->setParams.dwAudio = MCI_SET_AUDIO_LEFT;
	    if (!STRCMP(keywords[i+1],"right"))
		pU->setParams.dwAudio = MCI_SET_AUDIO_RIGHT;
	    i+=2;
	    continue;
	}
	FLAG1("video",MCI_SET_VIDEO);
	FLAG1("on",MCI_SET_ON);
	FLAG1("off",MCI_SET_OFF);
	switch (uDevTyp) {
	case MCI_DEVTYPE_WAVEFORM_AUDIO:
	    FLAG2("any","input",MCI_WAVE_SET_ANYINPUT);
	    FLAG2("any","output",MCI_WAVE_SET_ANYOUTPUT);
	    
	    if (	!STRCMP(keywords[i],"formattag") && 
			(i+1 < nrofkeywords) &&
			!STRCMP(keywords[i+1],"pcm")
			) {
		dwFlags |= MCI_WAVE_SET_FORMATTAG;
		pU->wavesetParams.wFormatTag = WAVE_FORMAT_PCM;
		i+=2;
		continue;
	    }
	    
	    /* <keyword> <integer> */
#define WII(str,flag,fmt,element) 		\
    if (!STRCMP(keywords[i],str) &&		\
	(i+1 < nrofkeywords)) {			\
        sscanf(keywords[i+1], fmt,		\
	       &(pU->wavesetParams. element));	\
	dwFlags |= flag;			\
	i+=2;					\
	continue;				\
    }
	    WII("formattag",MCI_WAVE_SET_FORMATTAG,"%hu",wFormatTag);
	    WII("channels",MCI_WAVE_SET_CHANNELS,"%hu",nChannels);
	    WII("bytespersec",MCI_WAVE_SET_AVGBYTESPERSEC,"%lu",nAvgBytesPerSec);
	    WII("samplespersec",MCI_WAVE_SET_SAMPLESPERSEC,"%lu",nSamplesPerSec);
	    WII("alignment",MCI_WAVE_SET_BLOCKALIGN,"%hu",nBlockAlign);
	    WII("bitspersample",MCI_WAVE_SET_BITSPERSAMPLE,"%hu",wBitsPerSample);
	    WII("input",MCI_WAVE_INPUT,"%hu",wInput);
	    WII("output",MCI_WAVE_OUTPUT,"%hu",wOutput);
#undef WII
	    break;
	case MCI_DEVTYPE_SEQUENCER:
	    if (!STRCMP(keywords[i],"master") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_SEQ_SET_MASTER;
		if (!STRCMP(keywords[i+1],"midi"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_MIDI;
		if (!STRCMP(keywords[i+1],"file"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_FILE;
		if (!STRCMP(keywords[i+1],"smpte"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_SMPTE;
		if (!STRCMP(keywords[i+1],"none"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_NONE;
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i],"slave") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_SEQ_SET_SLAVE;
		if (!STRCMP(keywords[i+1],"midi"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_MIDI;
		if (!STRCMP(keywords[i+1],"file"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_FILE;
		if (!STRCMP(keywords[i+1],"smpte"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_SMPTE;
		if (!STRCMP(keywords[i+1],"none"))
		    pU->seqsetParams.dwMaster = MCI_SEQ_NONE;
		i+=2;
		continue;
	    }
	    if (	!STRCMP(keywords[i],"port") && 
			(i+1 < nrofkeywords) &&
			!STRCMP(keywords[i+1],"mapper")
			) {
		pU->seqsetParams.dwPort=-1;/* FIXME:not sure*/
		dwFlags |= MCI_SEQ_SET_PORT;
		i+=2;
		continue;
	    }
#define SII(str,flag,element) \
	if (!STRCMP(keywords[i],str) && (i+1 < nrofkeywords)) {\
		sscanf(keywords[i+1],"%ld",&(pU->seqsetParams. element));\
		dwFlags |= flag;\
		i+=2;\
		continue;\
	}
	    SII("tempo",MCI_SEQ_SET_TEMPO,dwTempo);
	    SII("port",MCI_SEQ_SET_PORT,dwPort);
	    SII("offset",MCI_SEQ_SET_PORT,dwOffset);
	}
	i++;
    }
    if (!dwFlags)
	return MCIERR_MISSING_STRING_ARGUMENT;
    res = mciSendCommandA(wDevID, MCI_SET, dwFlags, (DWORD)pU);
    free(pU);
    return res;
}

/* specify break key
 * Arguments: 
 *	"off"		disable break
 *	"on <keyid>"	enable break on key with keyid
 * (I strongly suspect, that there is another parameter:
 *	"window <handle>"	
 * but I don't see it mentioned in my documentation.
 * Returns nothing.
 */
static DWORD
MCISTR_Break(_MCISTR_PROTO_)
{
    MCI_BREAK_PARMS16 *breakParams = xmalloc(sizeof(MCI_BREAK_PARMS16));
    int res,i;
    
    if (!breakParams) return 0;
    /*breakParams.hwndBreak ? */
    for (i = 0; i < nrofkeywords; i++) {
	FLAG1("off",MCI_BREAK_OFF);
	if (!strcmp(keywords[i],"on") && (nrofkeywords>i+1)) {
	    dwFlags&=~MCI_BREAK_OFF;
	    dwFlags|=MCI_BREAK_KEY;
	    sscanf(keywords[i+1],"%hd",&(breakParams->nVirtKey));
	    i+=2;
	    continue;
	}
    }
    res = mciSendCommandA(wDevID, MCI_BREAK, dwFlags, (DWORD)breakParams);
    free(breakParams);
    return res;
}

#define ITEM1(str,item,xtype) 			\
	if (!STRCMP(keywords[i],str)) {		\
		gdcParams->dwItem = item;	\
		type = xtype;			\
		i++;				\
		continue;			\
	}
#define ITEM2(str1,str2,item,xtype) 		\
	if (	!STRCMP(keywords[i],str1) &&	\
		(i+1 < nrofkeywords) &&		\
		!STRCMP(keywords[i+1],str2)) {	\
		gdcParams->dwItem = item;	\
		type = xtype;			\
		i+=2;				\
		continue;			\
	}
#define ITEM3(str1,str2,str3,item,xtype) 	\
	if (	!STRCMP(keywords[i],str1) &&	\
		(i+2 < nrofkeywords) &&		\
		!STRCMP(keywords[i+1],str2) &&	\
		!STRCMP(keywords[i+2],str3)) {	\
		gdcParams->dwItem = item;	\
		type = xtype;			\
		i+=3;				\
		continue;			\
	}

/* get device capabilities of MCI drivers
 * Arguments:
 * Generic:
 *	"device type"	returns device name as string
 *	"has audio"	returns bool
 *	"has video"	returns bool
 *	"uses files"	returns bool
 *	"compound device"	returns bool
 *	"can record"	returns bool
 *	"can play"	returns bool
 *	"can eject"	returns bool
 *	"can save"	returns bool
 * Animation:
 *	"palettes"	returns nr of available palette entries
 *	"windows"	returns nr of available windows
 *	"can reverse"	returns bool
 *	"can stretch"	returns bool
 *	"slow play rate"	returns the slow playrate
 *	"fast play rate"	returns the fast playrate
 *	"normal play rate"	returns the normal playrate
 * Overlay:
 *	"windows"	returns nr of available windows
 *	"can stretch"	returns bool
 *	"can freeze"	returns bool
 * Videodisc:
 *	"cav"		assume CAV discs (default if no disk inserted)
 *	"clv"		assume CLV discs 
 *	"can reverse"	returns bool
 *	"slow play rate"	returns the slow playrate
 *	"fast play rate"	returns the fast playrate
 *	"normal play rate"	returns the normal playrate
 * Waveform audio:
 *	"inputs"	returns nr of inputdevices
 *	"outputs"	returns nr of outputdevices
 */
static DWORD
MCISTR_Capability(_MCISTR_PROTO_) {
    MCI_GETDEVCAPS_PARMS *gdcParams = xmalloc(sizeof(MCI_GETDEVCAPS_PARMS));
    int	type=0,i,res;
    
    gdcParams->dwCallback = hwndCallback;
    if (!nrofkeywords)
	return MCIERR_MISSING_STRING_ARGUMENT;
    /* well , thats default */
    dwFlags |= MCI_GETDEVCAPS_ITEM;
    gdcParams->dwItem = 0;
    i=0;
    while (i < nrofkeywords) {
	ITEM2("device","type",MCI_GETDEVCAPS_DEVICE_TYPE,_MCISTR_devtype);
	ITEM2("has","audio",MCI_GETDEVCAPS_HAS_AUDIO,_MCISTR_bool);
	ITEM2("has","video",MCI_GETDEVCAPS_HAS_VIDEO,_MCISTR_bool);
	ITEM2("uses","files",MCI_GETDEVCAPS_USES_FILES,_MCISTR_bool);
	ITEM2("compound","device",MCI_GETDEVCAPS_COMPOUND_DEVICE,_MCISTR_bool);
	ITEM2("can","record",MCI_GETDEVCAPS_CAN_RECORD,_MCISTR_bool);
	ITEM2("can","play",MCI_GETDEVCAPS_CAN_PLAY,_MCISTR_bool);
	ITEM2("can","eject",MCI_GETDEVCAPS_CAN_EJECT,_MCISTR_bool);
	ITEM2("can","save",MCI_GETDEVCAPS_CAN_SAVE,_MCISTR_bool);
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    ITEM1("palettes",MCI_ANIM_GETDEVCAPS_PALETTES,_MCISTR_int);
	    ITEM1("windows",MCI_ANIM_GETDEVCAPS_MAX_WINDOWS,_MCISTR_int);
	    ITEM2("can","reverse",MCI_ANIM_GETDEVCAPS_CAN_REVERSE,_MCISTR_bool);
	    ITEM2("can","stretch",MCI_ANIM_GETDEVCAPS_CAN_STRETCH,_MCISTR_bool);
	    ITEM3("slow","play","rate",MCI_ANIM_GETDEVCAPS_SLOW_RATE,_MCISTR_int);
	    ITEM3("fast","play","rate",MCI_ANIM_GETDEVCAPS_FAST_RATE,_MCISTR_int);
	    ITEM3("normal","play","rate",MCI_ANIM_GETDEVCAPS_NORMAL_RATE,_MCISTR_int);
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    ITEM1("windows",MCI_OVLY_GETDEVCAPS_MAX_WINDOWS,_MCISTR_int);
	    ITEM2("can","freeze",MCI_OVLY_GETDEVCAPS_CAN_FREEZE,_MCISTR_bool);
	    ITEM2("can","stretch",MCI_OVLY_GETDEVCAPS_CAN_STRETCH,_MCISTR_bool);
	    break;
	case MCI_DEVTYPE_VIDEODISC:
	    FLAG1("cav",MCI_VD_GETDEVCAPS_CAV);
	    FLAG1("clv",MCI_VD_GETDEVCAPS_CLV);
	    ITEM2("can","reverse",MCI_VD_GETDEVCAPS_CAN_REVERSE,_MCISTR_bool);
	    ITEM3("slow","play","rate",MCI_VD_GETDEVCAPS_SLOW_RATE,_MCISTR_int);
	    ITEM3("fast","play","rate",MCI_VD_GETDEVCAPS_FAST_RATE,_MCISTR_int);
	    ITEM3("normal","play","rate",MCI_VD_GETDEVCAPS_NORMAL_RATE,_MCISTR_int);
	    break;
	case MCI_DEVTYPE_WAVEFORM_AUDIO:
	    ITEM1("inputs",MCI_WAVE_GETDEVCAPS_INPUTS,_MCISTR_int);
	    ITEM1("outputs",MCI_WAVE_GETDEVCAPS_OUTPUTS,_MCISTR_int);
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_GETDEVCAPS, dwFlags, (DWORD)gdcParams);

    /* no timeformat needed */
    if (res==0)
	_MCISTR_convreturn(type, gdcParams->dwReturn, lpstrReturnString,
			    uReturnLength, uDevTyp, 0);
    free(gdcParams);
    return res;
}
#undef ITEM1
#undef ITEM2
#undef ITEM3
/* resumes operation of device. no arguments, no return values */
static DWORD
MCISTR_Resume(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int	res;
    genParams->dwCallback = hwndCallback;
    res = mciSendCommandA(wDevID, MCI_RESUME, dwFlags, (DWORD)genParams);
    free(genParams);
    return res;
}

/* pauses operation of device. no arguments, no return values */
static DWORD
MCISTR_Pause(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int res;
    genParams->dwCallback = hwndCallback;
    res = mciSendCommandA(wDevID, MCI_PAUSE, dwFlags, (DWORD)genParams);
    free(genParams);
    return res;
}

/* stops operation of device. no arguments, no return values */
static DWORD
MCISTR_Stop(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int res;
    genParams->dwCallback = hwndCallback;
    res = mciSendCommandA(wDevID, MCI_STOP, dwFlags, (DWORD)genParams);
    free(genParams);
    return res;
}

/* starts recording.
 * Arguments:
 *	"overwrite"	overwrite existing things
 *	"insert"	insert at current position
 *	"to <time>"	record up to <time> (specified in timeformat)
 *	"from <time>"	record from <time> (specified in timeformat)
 */
static DWORD
MCISTR_Record(_MCISTR_PROTO_) {
    int			i,res,timef,nrargs,j,k,a[4];
    char			*parsestr;
    MCI_RECORD_PARMS	*recordParams = xmalloc(sizeof(MCI_RECORD_PARMS));
    
    res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
    if (res) return res;
    
    switch (timef) {
    case MCI_FORMAT_MILLISECONDS:
    case MCI_FORMAT_FRAMES:
    case MCI_FORMAT_BYTES:
    case MCI_FORMAT_SAMPLES:
	nrargs=1;
	parsestr="%d";
	break;
    case MCI_FORMAT_HMS:
    case MCI_FORMAT_MSF:
	parsestr="%d:%d:%d";
	nrargs=3;
	break;
    case MCI_FORMAT_TMSF:
	parsestr="%d:%d:%d:%d";
	nrargs=4;
	break;
    default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
	parsestr="%d";
	nrargs=1;
	break;
    }
    recordParams->dwCallback = hwndCallback;
    i = 0;
    while (i < nrofkeywords) {
	if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_TO;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* add up all integers we got, if we have more 
	     * shift them. (Well I should use the macros in 
	     * mmsystem.h, right).
	     */
	    recordParams->dwTo=0;
	    for (k=0;k < j;k++)
		recordParams->dwTo+=a[k] << (8*(nrargs-k));
	    i+=2;
	    continue;
	}
	if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_FROM;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* dito. */
	    recordParams->dwFrom=0;
	    for (k=0;k < j;k++)
		recordParams->dwFrom+=a[k]<<(8*(nrargs-k));
	    i+=2;
	    continue;
	}
	FLAG1("insert",MCI_RECORD_INSERT);
	FLAG1("overwrite",MCI_RECORD_OVERWRITE);
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_RECORD, dwFlags, (DWORD)recordParams);
    free(recordParams);
    return res;
}

/* play media
 * Arguments:
 * 	"to <time>"	play up to <time> (specified in set timeformat)
 * 	"from <time>"	play from <time> (specified in set timeformat)
 * Animation:
 *	"slow"		play slow
 *	"fast"		play fast 
 *	"scan"		play as fast as possible (with audio disabled perhaps)
 *	"reverse"	play reverse
 *	"speed <fps>"	play with specified frames per second
 * Videodisc:
 *	"slow"		play slow
 *	"fast"		play fast 
 *	"scan"		play as fast as possible (with audio disabled perhaps)
 *	"reverse"	play reverse
 *	"speed <fps>"	play with specified frames per second
 */
static DWORD
MCISTR_Play(_MCISTR_PROTO_) {
    int			i,res,timef,nrargs,j,k,a[4];
    char			*parsestr;
    union U {
	MCI_PLAY_PARMS		playParams;
	MCI_VD_PLAY_PARMS	vdplayParams;
	MCI_ANIM_PLAY_PARMS	animplayParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    
    res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
    if (res) return res;
    switch (timef) {
    case MCI_FORMAT_MILLISECONDS:
    case MCI_FORMAT_FRAMES:
    case MCI_FORMAT_BYTES:
    case MCI_FORMAT_SAMPLES:
	nrargs=1;
	parsestr="%d";
	break;
    case MCI_FORMAT_HMS:
    case MCI_FORMAT_MSF:
	parsestr="%d:%d:%d";
	nrargs=3;
	break;
    case MCI_FORMAT_TMSF:
	parsestr="%d:%d:%d:%d";
	nrargs=4;
	break;
    default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
	parsestr="%d";
	nrargs=1;
	break;
    }
    pU->playParams.dwCallback=hwndCallback;
    i=0;
    while (i < nrofkeywords) {
	if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_TO;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* add up all integers we got, if we have more 
	     * shift them. (Well I should use the macros in 
	     * mmsystem.h, right).
	     */
	    pU->playParams.dwTo=0;
	    for (k=0;k < j;k++)
		pU->playParams.dwTo+=a[k] << (8*(nrargs-k));
	    i+=2;
	    continue;
	}
	if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_FROM;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* dito. */
	    pU->playParams.dwFrom=0;
	    for (k=0;k < j;k++)
		pU->playParams.dwFrom+=a[k]<<(8*(nrargs-k));
	    i+=2;
	    continue;
	}
	switch (uDevTyp) {
	case MCI_DEVTYPE_VIDEODISC:
	    FLAG1("slow",MCI_VD_PLAY_SLOW);
	    FLAG1("fast",MCI_VD_PLAY_FAST);
	    FLAG1("scan",MCI_VD_PLAY_SCAN);
	    FLAG1("reverse",MCI_VD_PLAY_REVERSE);
	    if (!STRCMP(keywords[i],"speed") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_VD_PLAY_SPEED;
		sscanf(keywords[i+1],"%ld",&(pU->vdplayParams.dwSpeed));
		i+=2;
		continue;
	    }
	    break;
	case MCI_DEVTYPE_ANIMATION:
	    FLAG1("slow",MCI_ANIM_PLAY_SLOW);
	    FLAG1("fast",MCI_ANIM_PLAY_FAST);
	    FLAG1("scan",MCI_ANIM_PLAY_SCAN);
	    FLAG1("reverse",MCI_ANIM_PLAY_REVERSE);
	    if (!STRCMP(keywords[i],"speed") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_ANIM_PLAY_SPEED;
		sscanf(keywords[i+1],"%ld",&(pU->animplayParams.dwSpeed));
		i+=2;
		continue;
	    }
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_PLAY, dwFlags, (DWORD)pU);
    free(pU);
    return res;
}

/* seek to a specified position
 * Arguments:
 *	"to start"	seek to start of medium
 *	"to end"	seek to end of medium
 * 	"to <time>"	seek to <time> specified in current timeformat
 */
static DWORD
MCISTR_Seek(_MCISTR_PROTO_) {
    int		i,res,timef,nrargs,j,k,a[4];
    char		*parsestr;
    MCI_SEEK_PARMS	*seekParams = xmalloc(sizeof(MCI_SEEK_PARMS));
    
    res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
    if (res) return res;
    switch (timef) {
    case MCI_FORMAT_MILLISECONDS:
    case MCI_FORMAT_FRAMES:
    case MCI_FORMAT_BYTES:
    case MCI_FORMAT_SAMPLES:
	nrargs=1;
	parsestr="%d";
	break;
    case MCI_FORMAT_HMS:
    case MCI_FORMAT_MSF:
	parsestr="%d:%d:%d";
	nrargs=3;
	break;
    case MCI_FORMAT_TMSF:
	parsestr="%d:%d:%d:%d";
	nrargs=4;
	break;
    default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
	parsestr="%d";
	nrargs=1;
	break;
    }
    seekParams->dwCallback=hwndCallback;
    i=0;
    while (i < nrofkeywords) {
	if (	!STRCMP(keywords[i],"to") && (i+1 < nrofkeywords)) {
	    if (!STRCMP(keywords[i+1],"start")) {
		dwFlags|=MCI_SEEK_TO_START;
		seekParams->dwTo=0;
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i+1],"end")) {
		dwFlags|=MCI_SEEK_TO_END;
		seekParams->dwTo=0;
		i+=2;
		continue;
	    }
	    dwFlags|=MCI_TO;
	    i+=2;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    seekParams->dwTo=0;
	    for (k=0;k < j;k++)
		seekParams->dwTo+=a[k] << (8*(nrargs-k));
	    continue;
	}
	switch (uDevTyp) {
	case MCI_DEVTYPE_VIDEODISC:
	    FLAG1("reverse",MCI_VD_SEEK_REVERSE);
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_SEEK, dwFlags, (DWORD)seekParams);
    free(seekParams);
    return res;
}

/* close media/driver */
static DWORD
MCISTR_Close(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS*	closeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int res;
    
    res = mciSendCommandA(wDevID, MCI_CLOSE, dwFlags, (DWORD)closeParams);
    free(closeParams);
    return res;
}

/* return information.
 * Arguments:
 *	"product"	return product name (human readable)
 *	"file"		return filename
 * Animation:
 *	"text"		returns text?
 * Overlay:
 *	"text"		returns text?
 */
static DWORD
MCISTR_Info(_MCISTR_PROTO_)
{
    MCI_INFO_PARMS16*	infoParams = xmalloc(sizeof(MCI_INFO_PARMS16));
    DWORD		sflags;
    int		i,res;
    
    sflags = dwFlags;
    i=0;
    while (i < nrofkeywords) {
	FLAG1("product",MCI_INFO_PRODUCT);
	FLAG1("file",MCI_INFO_FILE);
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    FLAG1("text",MCI_ANIM_INFO_TEXT);
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    FLAG1("text",MCI_OVLY_INFO_TEXT);
	    break;
	}
	i++;
    }
    if (dwFlags == sflags)
	return MCIERR_MISSING_STRING_ARGUMENT;
    /* MCI driver will fill in lpstrReturn, dwRetSize.
     * FIXME: I don't know if this is correct behaviour
     */
    res = mciSendCommandA(wDevID, MCI_INFO, dwFlags, (DWORD)infoParams);
    if (res==0)
	_MCI_STR(infoParams->lpstrReturn);
    free(infoParams);
    return res;
}

/* query MCI driver itself for information
 * Arguments:
 *	"installname"	return install name of <device> (system.ini)
 *	"quantity"	return nr of installed drivers
 *	"open"		open drivers only (additional flag)
 *	"name <nr>"	return nr of devices with <devicetyp>
 *	"name all"	return nr of all devices
 *
 * FIXME: mciSysInfo16() is broken I think.
 */
static DWORD
MCISTR_Sysinfo(_MCISTR_PROTO_) {
    MCI_SYSINFO_PARMS16	sysinfoParams;
    int			i,res;
    
    sysinfoParams.lpstrReturn	= lpstrReturnString;
    sysinfoParams.dwRetSize	= uReturnLength;
    sysinfoParams.wDeviceType	= uDevTyp;
    
    for (i = 0; i < nrofkeywords; i++) {
	FLAG1("installname",MCI_SYSINFO_INSTALLNAME);
	FLAG1("quantity",MCI_SYSINFO_INSTALLNAME);
	FLAG1("open",MCI_SYSINFO_OPEN);
	if (!strcmp(keywords[i],"name") && (i+1 < nrofkeywords)) {
	    sscanf(keywords[i+1],"%ld",&(sysinfoParams.dwNumber));
	    dwFlags |= MCI_SYSINFO_NAME;
	    i++;
	}
    }
    res = mciSendCommand16(0, MCI_SYSINFO, dwFlags, (DWORD)&sysinfoParams);

    if (dwFlags & MCI_SYSINFO_QUANTITY) {
	char	buf[100];
	
	sprintf(buf,"%ld",*(long*)lpstrReturnString);
	_MCI_STR(buf);
    }
    /* no need to copy anything back, mciSysInfo did it for us */
    return res;
}

/* load file
 * Argument: "<filename>"
 * Overlay: "at <left> <top> <right> <bottom>" additional
 */
static DWORD
MCISTR_Load(_MCISTR_PROTO_) {
    union U {
	MCI_LOAD_PARMS16	loadParams;
	MCI_OVLY_LOAD_PARMS16	ovlyloadParams;
    };
    union 	U *pU = xmalloc(sizeof(union U));
    int		i,len,res;
    char	*s;
    
    i=len=0;
    while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_OVERLAY:
	    if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
		dwFlags |= MCI_OVLY_RECT;
		sscanf(keywords[i+1],"%hd",&(pU->ovlyloadParams.rc.left));
		sscanf(keywords[i+2],"%hd",&(pU->ovlyloadParams.rc.top));
		sscanf(keywords[i+3],"%hd",&(pU->ovlyloadParams.rc.right));
		sscanf(keywords[i+4],"%hd",&(pU->ovlyloadParams.rc.bottom));
		memcpy(keywords+i,keywords+(i+5),nrofkeywords-(i+5));
		continue;
	    }
	    break;
	}
	len+=strlen(keywords[i])+1;
	i++;
    }
    s=(char*)xmalloc(len);
    *s='\0';
    while (i < nrofkeywords) {
	strcat(s,keywords[i]);
	i++;
	if (i < nrofkeywords) strcat(s," ");
    }
    pU->loadParams.lpfilename=s;
    dwFlags |= MCI_LOAD_FILE;
    res = mciSendCommandA(wDevID, MCI_LOAD, dwFlags, (DWORD)pU);
    free(s);
    free(pU);
    return res;
}

/* save to file
 * Argument: "<filename>"
 * Overlay: "at <left> <top> <right> <bottom>" additional
 */
static DWORD
MCISTR_Save(_MCISTR_PROTO_) {
    union U {
	MCI_SAVE_PARMS	saveParams;
	MCI_OVLY_SAVE_PARMS16	ovlysaveParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    int		i,len,res;
    char		*s;
    
    i=0;len=0;
    while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_OVERLAY:
	    if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
		dwFlags |= MCI_OVLY_RECT;
		sscanf(keywords[i+1],"%hd",&(pU->ovlysaveParams.rc.left));
		sscanf(keywords[i+2],"%hd",&(pU->ovlysaveParams.rc.top));
		sscanf(keywords[i+3],"%hd",&(pU->ovlysaveParams.rc.right));
		sscanf(keywords[i+4],"%hd",&(pU->ovlysaveParams.rc.bottom));
		memcpy(keywords+i,keywords+(i+5),nrofkeywords-(i+5));
		continue;
	    }
	    break;
	}
	len+=strlen(keywords[i])+1;
	i++;
    }
    s=(char*)xmalloc(len);
    *s='\0';
    while (i < nrofkeywords) {
	strcat(s,keywords[i]);
	i++;
	if (i < nrofkeywords) strcat(s," ");
    }
    pU->saveParams.lpfilename=s;
    dwFlags |= MCI_LOAD_FILE;
    res = mciSendCommandA(wDevID, MCI_SAVE, dwFlags, (DWORD)pU);
    free(s);
    free(pU);
    return res;
}

/* prepare device for input/output
 * (only applyable to waveform audio)
 */
static DWORD
MCISTR_Cue(_MCISTR_PROTO_) {
    MCI_GENERIC_PARMS	*cueParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int			i,res;
    
    for (i = 0; i < nrofkeywords; i++) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_WAVEFORM_AUDIO:
	    FLAG1("input", MCI_WAVE_INPUT);
	    FLAG1("output", MCI_WAVE_OUTPUT);
	    break;
	}
    }
    res = mciSendCommandA(wDevID, MCI_CUE, dwFlags, (DWORD)cueParams);
    free(cueParams);
    return res;
}

/* delete information */
static DWORD
MCISTR_Delete(_MCISTR_PROTO_) {
    int	timef,nrargs,i,j,k,a[4],res;
    char	*parsestr;
    MCI_WAVE_DELETE_PARMS *deleteParams = xmalloc(sizeof(MCI_WAVE_DELETE_PARMS));
    
    /* only implemented for waveform audio */
    if (uDevTyp != MCI_DEVTYPE_WAVEFORM_AUDIO)
	return MCIERR_UNSUPPORTED_FUNCTION; /* well it fits */
    res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
    if (res) return res;
    switch (timef) {
    case MCI_FORMAT_MILLISECONDS:
    case MCI_FORMAT_FRAMES:
    case MCI_FORMAT_BYTES:
    case MCI_FORMAT_SAMPLES:
	nrargs=1;
	parsestr="%d";
	break;
    case MCI_FORMAT_HMS:
    case MCI_FORMAT_MSF:
	parsestr="%d:%d:%d";
	nrargs=3;
	break;
    case MCI_FORMAT_TMSF:
	parsestr="%d:%d:%d:%d";
	nrargs=4;
	break;
    default:FIXME(mci,"unknown timeformat %d, please report.\n",timef);
	parsestr="%d";
	nrargs=1;
	break;
    }
    i=0;
    while (i < nrofkeywords) {
	if (!strcmp(keywords[i],"to") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_TO;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* add up all integers we got, if we have more 
	     * shift them. (Well I should use the macros in 
	     * mmsystem.h, right).
	     */
	    deleteParams->dwTo=0;
	    for (k=0;k < j;k++)
		deleteParams->dwTo+=a[k]<<(8*(nrargs-k));
	    i+=2;
	    continue;
	}
	if (!strcmp(keywords[i],"from") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_FROM;
	    a[0]=a[1]=a[2]=a[3]=0;
	    j=sscanf(keywords[i+1],parsestr,&a[0],&a[1],&a[2],&a[3]);
	    /* dito. */
	    deleteParams->dwFrom=0;
	    for (k=0;k < j;k++)
		deleteParams->dwFrom+=a[k]<<(8*(nrargs-k));
	    i+=2;
	    continue;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_DELETE, dwFlags, (DWORD)deleteParams);
    free(deleteParams);
    return res;
}

/* send command to device. only applies to videodisc */
static DWORD
MCISTR_Escape(_MCISTR_PROTO_)
{
    MCI_VD_ESCAPE_PARMS16 *escapeParams = xmalloc(sizeof(MCI_VD_ESCAPE_PARMS16));
    int			i,len,res;
    char		*s;
    
    if (uDevTyp != MCI_DEVTYPE_VIDEODISC)
	return MCIERR_UNSUPPORTED_FUNCTION;
    i=0;len=0;
    while (i < nrofkeywords) {
	len+=strlen(keywords[i])+1;
	i++;
    }
    s=(char*)malloc(len);
    *s='\0';
    while (i < nrofkeywords) {
	strcat(s,keywords[i]);
	i++;
	if (i < nrofkeywords) strcat(s," ");
    }
    escapeParams->lpstrCommand = s;
    dwFlags |= MCI_VD_ESCAPE_STRING;
    res = mciSendCommandA(wDevID, MCI_ESCAPE, dwFlags, (DWORD)escapeParams);
    free(s);
    free(escapeParams);
    return res;
}

/* unfreeze [part of] the overlayed video 
 * only applyable to Overlay devices
 */
static DWORD
MCISTR_Unfreeze(_MCISTR_PROTO_)
{
    MCI_OVLY_RECT_PARMS16 *unfreezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
    int			i,res;
    
    if (uDevTyp != MCI_DEVTYPE_OVERLAY)
	return MCIERR_UNSUPPORTED_FUNCTION;
    i=0;while (i < nrofkeywords) {
	if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
	    sscanf(keywords[i+1],"%hd",&(unfreezeParams->rc.left));
	    sscanf(keywords[i+2],"%hd",&(unfreezeParams->rc.top));
	    sscanf(keywords[i+3],"%hd",&(unfreezeParams->rc.right));
	    sscanf(keywords[i+4],"%hd",&(unfreezeParams->rc.bottom));
	    dwFlags |= MCI_OVLY_RECT;
	    i+=5;
	    continue;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_UNFREEZE, dwFlags, (DWORD)unfreezeParams);
    free(unfreezeParams);
    return res;
}
/* freeze [part of] the overlayed video 
 * only applyable to Overlay devices
 */
static DWORD
MCISTR_Freeze(_MCISTR_PROTO_)
{
    MCI_OVLY_RECT_PARMS16 *freezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
    int			i,res;
    
    if (uDevTyp != MCI_DEVTYPE_OVERLAY)
	return MCIERR_UNSUPPORTED_FUNCTION;
    i=0;while (i < nrofkeywords) {
	if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
	    sscanf(keywords[i+1],"%hd",&(freezeParams->rc.left));
	    sscanf(keywords[i+2],"%hd",&(freezeParams->rc.top));
	    sscanf(keywords[i+3],"%hd",&(freezeParams->rc.right));
	    sscanf(keywords[i+4],"%hd",&(freezeParams->rc.bottom));
	    dwFlags |= MCI_OVLY_RECT;
	    i+=5;
	    continue;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_FREEZE, dwFlags, (DWORD)freezeParams);
    free(freezeParams);
    return res;
}

/* copy parts of image to somewhere else 
 * "source [at <left> <top> <right> <bottom>]"	source is framebuffer [or rect]
 * "destination [at <left> <top> <right> <bottom>]"	destination is framebuffer [or rect]
 * Overlay:
 * "frame [at <left> <top> <right> <bottom>]"	frame is framebuffer [or rect]
 * 						where the video input is placed
 * "video [at <left> <top> <right> <bottom>]"	video is whole video [or rect]
 *						(defining part of input to
 *						be displayed)
 *
 * FIXME: This whole junk is passing multiple rectangles.
 *	I don't know how to do that with the present interface.
 *	(Means code below is broken)
 */
static DWORD
MCISTR_Put(_MCISTR_PROTO_) {
    union U {
	MCI_OVLY_RECT_PARMS16	ovlyputParams;
	MCI_ANIM_RECT_PARMS16	animputParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    int	i,res;
    i=0;while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    FLAG1("source",MCI_ANIM_PUT_SOURCE);
	    FLAG1("destination",MCI_ANIM_PUT_DESTINATION);
	    if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
		sscanf(keywords[i+1],"%hd",&(pU->animputParams.rc.left));
		sscanf(keywords[i+2],"%hd",&(pU->animputParams.rc.top));
		sscanf(keywords[i+3],"%hd",&(pU->animputParams.rc.right));
		sscanf(keywords[i+4],"%hd",&(pU->animputParams.rc.bottom));
		dwFlags |= MCI_ANIM_RECT;
		i+=5;
		continue;
	    }
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    FLAG1("source",MCI_OVLY_PUT_SOURCE);
	    FLAG1("destination",MCI_OVLY_PUT_DESTINATION);
	    FLAG1("video",MCI_OVLY_PUT_VIDEO);
	    FLAG1("frame",MCI_OVLY_PUT_FRAME);
	    if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
		sscanf(keywords[i+1],"%hd",&(pU->ovlyputParams.rc.left));
		sscanf(keywords[i+2],"%hd",&(pU->ovlyputParams.rc.top));
		sscanf(keywords[i+3],"%hd",&(pU->ovlyputParams.rc.right));
		sscanf(keywords[i+4],"%hd",&(pU->ovlyputParams.rc.bottom));
		dwFlags |= MCI_OVLY_RECT;
		i+=5;
		continue;
	    }
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_PUT, dwFlags, (DWORD)pU);
    free(pU);
    return res;
}

/* palette behaviour changing
 * (Animation only)
 * 	"normal"	realize the palette normally
 * 	"background"	realize the palette as background palette
 */
static DWORD
MCISTR_Realize(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS	*realizeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int			i,res;
    
    if (uDevTyp != MCI_DEVTYPE_ANIMATION)
	return MCIERR_UNSUPPORTED_FUNCTION;
    i=0;
    while (i < nrofkeywords) {
	FLAG1("background",MCI_ANIM_REALIZE_BKGD);
	FLAG1("normal",MCI_ANIM_REALIZE_NORM);
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_REALIZE, dwFlags, (DWORD)realizeParams);
    free(realizeParams);
    return res;
}

/* videodisc spinning
 *	"up"
 *	"down"
 */
static DWORD
MCISTR_Spin(_MCISTR_PROTO_)
{
    MCI_GENERIC_PARMS	*spinParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
    int			i,res;
    
    if (uDevTyp != MCI_DEVTYPE_VIDEODISC)
	return MCIERR_UNSUPPORTED_FUNCTION;
    i=0;
    while (i < nrofkeywords) {
	FLAG1("up",MCI_VD_SPIN_UP);
	FLAG1("down",MCI_VD_SPIN_UP);
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_SPIN, dwFlags, (DWORD)spinParams);
    free(spinParams);
    return res;
}

/* step single frames
 * 	"reverse"	optional flag
 *	"by <nr>"	for <nr> frames
 */
static DWORD
MCISTR_Step(_MCISTR_PROTO_) {
    union U {
	MCI_ANIM_STEP_PARMS	animstepParams;
	MCI_VD_STEP_PARMS	vdstepParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    int	i,res;
    
    i=0;
    while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    FLAG1("reverse",MCI_ANIM_STEP_REVERSE);
	    if (!STRCMP(keywords[i],"by") && (i+1 < nrofkeywords)) {
		sscanf(keywords[i+1],"%ld",&(pU->animstepParams.dwFrames));
		dwFlags |= MCI_ANIM_STEP_FRAMES;
		i+=2;
		continue;
	    }
	    break;
	case MCI_DEVTYPE_VIDEODISC:
	    FLAG1("reverse",MCI_VD_STEP_REVERSE);
	    if (!STRCMP(keywords[i],"by") && (i+1 < nrofkeywords)) {
		sscanf(keywords[i+1],"%ld",&(pU->vdstepParams.dwFrames));
		dwFlags |= MCI_VD_STEP_FRAMES;
		i+=2;
		continue;
	    }
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_STEP, dwFlags, (DWORD)pU);
    free(pU);
    return res;
}

/* update animation window
 * Arguments:
 *	"at <left> <top> <right> <bottom>" only in this rectangle
 *	"hdc"		device context
 */
static DWORD
MCISTR_Update(_MCISTR_PROTO_) {
    int		i,res;
    MCI_ANIM_UPDATE_PARMS16 *updateParams = xmalloc(sizeof(MCI_ANIM_UPDATE_PARMS16));
    
    i=0;
    while (i<nrofkeywords) {
	if (!STRCMP(keywords[i],"at") && (i+4 < nrofkeywords)) {
	    sscanf(keywords[i+1],"%hd",&(updateParams->rc.left));
	    sscanf(keywords[i+2],"%hd",&(updateParams->rc.top));
	    sscanf(keywords[i+3],"%hd",&(updateParams->rc.right));
	    sscanf(keywords[i+4],"%hd",&(updateParams->rc.bottom));
	    dwFlags |= MCI_ANIM_RECT;
	    i+=5;
	    continue;
	}
	if (!STRCMP(keywords[i],"hdc") && (i+1 < nrofkeywords)) {
	    dwFlags |= MCI_ANIM_UPDATE_HDC;
	    sscanf(keywords[i+1],"%hd",&(updateParams->hDC));
	    i+=2;
	    continue;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_UPDATE, dwFlags, (DWORD)updateParams);
    free(updateParams);
    return res;
}

/* where command for animation and overlay drivers.
 * just returns the specified rectangle as a string
 * Arguments:
 *	"source"
 *	"destination"
 * Overlay special:
 *	"video"
 *	"frame"
 */
static DWORD
MCISTR_Where(_MCISTR_PROTO_) {
    union U {
	MCI_ANIM_RECT_PARMS16	animwhereParams;
	MCI_OVLY_RECT_PARMS16	ovlywhereParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    int	i,res;
    
    i=0;
    while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    FLAG1("source",MCI_ANIM_WHERE_SOURCE);
	    FLAG1("destination",MCI_ANIM_WHERE_DESTINATION);
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    FLAG1("source",MCI_OVLY_WHERE_SOURCE);
	    FLAG1("destination",MCI_OVLY_WHERE_DESTINATION);
	    FLAG1("video",MCI_OVLY_WHERE_VIDEO);
	    FLAG1("frame",MCI_OVLY_WHERE_FRAME);
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_WHERE, dwFlags, (DWORD)pU);
    if (res==0) {
	char	buf[100];
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    sprintf(buf,"%d %d %d %d",
		    pU->animwhereParams.rc.left,
		    pU->animwhereParams.rc.top,
		    pU->animwhereParams.rc.right,
		    pU->animwhereParams.rc.bottom
		   );
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    sprintf(buf,"%d %d %d %d",
		    pU->ovlywhereParams.rc.left,
		    pU->ovlywhereParams.rc.top,
		    pU->ovlywhereParams.rc.right,
		    pU->ovlywhereParams.rc.bottom
		   );
	    break;
	default:strcpy(buf,"0 0 0 0");break;
	}
	_MCI_STR(buf);
    }
    free(pU);
    return	res;
}

static DWORD
MCISTR_Window(_MCISTR_PROTO_) {
    int	i,res;
    char	*s;
    union U {
	MCI_ANIM_WINDOW_PARMS16	animwindowParams;
	MCI_OVLY_WINDOW_PARMS16	ovlywindowParams;
    };
    union U *pU = xmalloc(sizeof(union U));
    
    s=NULL;
    i=0;
    while (i < nrofkeywords) {
	switch (uDevTyp) {
	case MCI_DEVTYPE_ANIMATION:
	    if (!STRCMP(keywords[i],"handle") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_ANIM_WINDOW_HWND;
		if (!STRCMP(keywords[i+1],"default")) 
		    pU->animwindowParams.hWnd = MCI_OVLY_WINDOW_DEFAULT;
		else
		    sscanf(keywords[i+1],"%hd",&(pU->animwindowParams.hWnd));
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i],"state") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_ANIM_WINDOW_STATE;
		if (!STRCMP(keywords[i+1],"hide"))
		    pU->animwindowParams.nCmdShow = SW_HIDE;
		if (!STRCMP(keywords[i+1],"iconic"))
		    pU->animwindowParams.nCmdShow = SW_SHOWMINNOACTIVE; /* correct? */
		if (!STRCMP(keywords[i+1],"minimized"))
		    pU->animwindowParams.nCmdShow = SW_SHOWMINIMIZED;
		if (!STRCMP(keywords[i+1],"maximized"))
		    pU->animwindowParams.nCmdShow = SW_SHOWMAXIMIZED;
		if (!STRCMP(keywords[i+1],"minimize"))
		    pU->animwindowParams.nCmdShow = SW_MINIMIZE;
		if (!STRCMP(keywords[i+1],"normal"))
		    pU->animwindowParams.nCmdShow = SW_NORMAL;
		if (!STRCMP(keywords[i+1],"show"))
		    pU->animwindowParams.nCmdShow = SW_SHOW;
		if (!STRCMP(keywords[i+1],"no") && (i+2 < nrofkeywords)) {
		    if (!STRCMP(keywords[i+2],"active"))
			pU->animwindowParams.nCmdShow = SW_SHOWNOACTIVATE;
		    if (!STRCMP(keywords[i+2],"action"))
			pU->animwindowParams.nCmdShow = SW_SHOWNA;/* correct?*/
		    i++;
		}
		i+=2;
		continue;
	    }
	    /* text is enclosed in " ... " as it seems */
	    if (!STRCMP(keywords[i],"text")) {
		char	*t;
		int	len,j,k;
		
		if (keywords[i+1][0]!='"') {
		    i++;
		    continue;
		}
		dwFlags |= MCI_ANIM_WINDOW_TEXT;
		len	= strlen(keywords[i+1])+1;
		j	= i+2;
		while (j < nrofkeywords) {
		    len += strlen(keywords[j])+1;
		    if (strchr(keywords[j],'"'))
			break;
		    j++;
		}
		s=(char*)xmalloc(len);
		strcpy(s,keywords[i+1]+1);
		k=j;j=i+2;
		while (j <= k) {
		    strcat(s," ");
		    strcat(s,keywords[j]);
		}
		if ((t=strchr(s,'"'))) *t='\0';
				/* FIXME: segmented pointer? */
		pU->animwindowParams.lpstrText = s;
		i=k+1;
		continue;
	    }
	    FLAG1("stretch",MCI_ANIM_WINDOW_ENABLE_STRETCH);
	    break;
	case MCI_DEVTYPE_OVERLAY:
	    if (!STRCMP(keywords[i],"handle") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_OVLY_WINDOW_HWND;
		if (!STRCMP(keywords[i+1],"default")) 
		    pU->ovlywindowParams.hWnd = MCI_OVLY_WINDOW_DEFAULT;
		else
		    sscanf(keywords[i+1],"%hd",&(pU->ovlywindowParams.hWnd));
		i+=2;
		continue;
	    }
	    if (!STRCMP(keywords[i],"state") && (i+1 < nrofkeywords)) {
		dwFlags |= MCI_OVLY_WINDOW_STATE;
		if (!STRCMP(keywords[i+1],"hide"))
		    pU->ovlywindowParams.nCmdShow = SW_HIDE;
		if (!STRCMP(keywords[i+1],"iconic"))
		    pU->ovlywindowParams.nCmdShow = SW_SHOWMINNOACTIVE; /* correct? */
		if (!STRCMP(keywords[i+1],"minimized"))
		    pU->ovlywindowParams.nCmdShow = SW_SHOWMINIMIZED;
		if (!STRCMP(keywords[i+1],"maximized"))
		    pU->ovlywindowParams.nCmdShow = SW_SHOWMAXIMIZED;
		if (!STRCMP(keywords[i+1],"minimize"))
		    pU->ovlywindowParams.nCmdShow = SW_MINIMIZE;
		if (!STRCMP(keywords[i+1],"normal"))
		    pU->ovlywindowParams.nCmdShow = SW_NORMAL;
		if (!STRCMP(keywords[i+1],"show"))
		    pU->ovlywindowParams.nCmdShow = SW_SHOW;
		if (!STRCMP(keywords[i+1],"no") && (i+2 < nrofkeywords)) {
		    if (!STRCMP(keywords[i+2],"active"))
			pU->ovlywindowParams.nCmdShow = SW_SHOWNOACTIVATE;
		    if (!STRCMP(keywords[i+2],"action"))
			pU->ovlywindowParams.nCmdShow = SW_SHOWNA;/* correct?*/
		    i++;
		}
		i+=2;
		continue;
	    }
	    /* text is enclosed in " ... " as it seems */
	    if (!STRCMP(keywords[i],"text")) {
		char	*t;
		int	len,j,k;
		
		if (keywords[i+1][0]!='"') {
		    i++;
		    continue;
		}
		dwFlags |= MCI_OVLY_WINDOW_TEXT;
		len	= strlen(keywords[i+1])+1;
		j	= i+2;
		while (j < nrofkeywords) {
		    len += strlen(keywords[j])+1;
		    if (strchr(keywords[j],'"'))
			break;
		    j++;
		}
		s=(char*)xmalloc(len);
		strcpy(s,keywords[i+1]+1);
		k=j;j=i+2;
		while (j<=k) {
		    strcat(s," ");
		    strcat(s,keywords[j]);
		}
		if ((t=strchr(s,'"'))) *t='\0';
				/* FIXME: segmented pointer? */
		pU->ovlywindowParams.lpstrText = s;
		i=k+1;
		continue;
	    }
	    FLAG1("stretch",MCI_OVLY_WINDOW_ENABLE_STRETCH);
	    break;
	}
	i++;
    }
    res = mciSendCommandA(wDevID, MCI_WINDOW, dwFlags, (DWORD)pU);
    if (s) free(s);
    free(pU);
    return res;
}

struct	_MCISTR_cmdtable {
    char	*cmd;
    DWORD	(*fun)(_MCISTR_PROTO_);
} MCISTR_cmdtable[]={
    {"break",		MCISTR_Break},
    {"capability",	MCISTR_Capability},
    {"close",		MCISTR_Close},
    {"cue",		MCISTR_Cue},
    {"delete",		MCISTR_Delete},
    {"escape",		MCISTR_Escape},
    {"freeze",		MCISTR_Freeze},
    {"info",		MCISTR_Info},
    {"load",		MCISTR_Load},
    {"open",		MCISTR_Open},
    {"pause",		MCISTR_Pause},
    {"play",		MCISTR_Play},
    {"put",		MCISTR_Put},
    {"realize",		MCISTR_Realize},
    {"record",		MCISTR_Record},
    {"resume",		MCISTR_Resume},
    {"save",		MCISTR_Save},
    {"seek",		MCISTR_Seek},
    {"set",		MCISTR_Set},
    {"spin",		MCISTR_Spin},
    {"status",		MCISTR_Status},
    {"step",		MCISTR_Step},
    {"stop",		MCISTR_Stop},
    {"sysinfo",		MCISTR_Sysinfo},
    {"unfreeze",	MCISTR_Unfreeze},
    {"update",		MCISTR_Update},
    {"where",		MCISTR_Where},
    {"window",		MCISTR_Window},
    {NULL,		NULL}
};

/**************************************************************************
 * 				mciSendString16			[MMSYSTEM.702]
 */
/* The usercode sends a string with a command (and flags) expressed in 
 * words in it... We do our best to call aprobiate drivers,
 * and return a errorcode AND a readable string (if lpstrRS!=NULL)
 * Info gathered by watching cool134.exe and from Borland's mcistrwh.hlp
 */
/* FIXME: "all" is a valid devicetype and we should access all devices if
 * it is used. (imagine "close all"). Not implemented yet.
 */
DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrReturnString, 
			     UINT16 uReturnLength, HWND16 hwndCallback)
{
    char	*cmd,*dev,*args,**keywords,*filename;
    WORD	uDevTyp=0,wDevID=0;
    DWORD	dwFlags;
    int	res=0,i,nrofkeywords;
    
    TRACE(mci,"('%s', %p, %d, %X)\n", 
	  lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);

    /* format is <command> <device> <optargs> */
    cmd=strdup(lpstrCommand);
    dev=strchr(cmd,' ');
    if (dev==NULL) {
	free(cmd);
	return MCIERR_MISSING_DEVICE_NAME;
    }
    *dev++='\0';
    args=strchr(dev,' ');
    if (args!=NULL) *args++='\0';
    CharUpperA(dev);
    if (args!=NULL) {
	char	*s;
	i=1;/* nrofkeywords = nrofspaces+1 */
	s=args;
	while ((s=strchr(s,' '))!=NULL) i++,s++;
	keywords=(char**)xmalloc(sizeof(char*)*(i+2));
	nrofkeywords=i;
	s=args;i=0;
	while (s && i < nrofkeywords) {
	    keywords[i++]=s;
	    s=strchr(s,' ');
	    if (s) *s++='\0';
	}
	keywords[i]=NULL;
    } else {
	nrofkeywords=0;
	keywords=(char**)xmalloc(sizeof(char*));
    }
    dwFlags = 0; /* default flags */
    for (i=0;i < nrofkeywords;) {
	/* take care, there is also a "device type" capability */
	if ((!STRCMP(keywords[i],"type")) && (i < nrofkeywords-1)) {
	    filename = dev;
	    dev = keywords[i+1];
	    memcpy(keywords+i,keywords+(i+2),(nrofkeywords-i-2)*sizeof(char *));
	    nrofkeywords -= 2;
	    continue;
	}
	if (!STRCMP(keywords[i],"wait")) {
	    dwFlags |= MCI_WAIT;
	    memcpy(keywords+i,keywords+(i+1),(nrofkeywords-i-1)*sizeof(char *));
	    nrofkeywords--;
	    continue;
	}
	if (!STRCMP(keywords[i],"notify")) {
	    dwFlags |= MCI_NOTIFY;
	    memcpy(keywords+i,keywords+(i+1),(nrofkeywords-i-1)*sizeof(char *));
	    nrofkeywords--;
	    continue;
	}
	i++;
    }

    /* FIXME: this code should be moved to mmsystem.c */
    /* determine wDevID and uDevTyp for all commands except "open" */
    if (STRCMP(cmd,"open")!=0) {
	wDevID = MCI_FirstDevID();
	while (1) {
	    LPSTR	dname;
	    
	    dname=MCI_GetOpenDrv(wDevID)->lpstrAlias;
	    if (dname==NULL) 
		dname=MCI_GetOpenDrv(wDevID)->lpstrDeviceType;
	    if (dname != NULL && !STRCMP(dname,dev))
		break;
	    wDevID = MCI_NextDevID(wDevID);
	    if (!MCI_DevIDValid(wDevID)) {
		TRACE(mci, "MAXMCIDRIVERS reached!\n");
		free(keywords);free(cmd);
		return MCIERR_INVALID_DEVICE_NAME;
	    }
	}
	uDevTyp=MCI_GetDrv(wDevID)->modp.wType;
    }
    /* end of FIXME */

    for (i=0;MCISTR_cmdtable[i].cmd!=NULL;i++) {
	if (!STRCMP(MCISTR_cmdtable[i].cmd,cmd)) {
	    res=MCISTR_cmdtable[i].fun(
				       wDevID,uDevTyp,lpstrReturnString,
				       uReturnLength,dev,(LPSTR*)keywords,nrofkeywords,
				       dwFlags,hwndCallback
				       );
	    break;
	}
    }
    if (MCISTR_cmdtable[i].cmd!=NULL) {
	free(keywords);free(cmd);
	return	res;
    }
    FIXME(mci,"('%s', %p, %u, %X): unimplemented, please report.\n", 
	  lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
    free(keywords);free(cmd);
    return MCIERR_MISSING_COMMAND_STRING;
}

/**************************************************************************
 * 				mciSendStringA		[MMSYSTEM.702][WINMM.51]
 */
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString, 
			    UINT uReturnLength, HWND hwndCallback)
{
    return mciSendString16(lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
}

/**************************************************************************
 * 				mciSendStringW			[WINMM.52]
 */
DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrReturnString, 
			    UINT uReturnLength, HWND hwndCallback)
{
    LPSTR 	lpstrCommand;
    UINT	ret;

    /* FIXME: is there something to do with lpstrReturnString ? */
    lpstrCommand = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrCommand);
    ret = mciSendString16(lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
    HeapFree(GetProcessHeap(), 0, lpstrCommand);
    return ret;
}

/**************************************************************************
 * 				mciExecute			[WINMM.38]
 */
DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
{
    char	strRet[256];
    DWORD	ret;

    FIXME(mci, "(%s) stub!\n", lpstrCommand);

    ret = mciSendString16(lpstrCommand, strRet, sizeof(strRet), 0);
    if (ret != 0) {
	if (!mciGetErrorString16(ret, strRet, sizeof(strRet))) {
	    sprintf(strRet, "Unknown MCI Error (%ld)", ret);
	}
	MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK); 
    }
    return 0;
}