ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/multimedia/mcistring.c

2185 lines
64 KiB
C
Raw Blame History

/* -*- 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"
/* FIXME the following definitions must be moved to mmsystem.c */
extern struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
#define MCI_GetDrv(wDevID) (&mciDrv[MCI_DevIDToIndex(wDevID)])
#define MCI_GetOpenDrv(wDevID) (&(MCI_GetDrv(wDevID)->mop))
/* end of FIXME */
/* 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;
}
/**************************************************************************
* mciSendString32A [MMSYSTEM.702][WINMM.51]
*/
DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString,
UINT uReturnLength, HWND hwndCallback)
{
return mciSendString16(lpstrCommand, lpstrReturnString, uReturnLength, hwndCallback);
}
/**************************************************************************
* mciSendString32W [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;
}
Reference in New Issue View Git Blame Copy Permalink