niansa-misc/wine
1
0
Fork 0
mirror of synced 2025-03-07 03:53:26 +01:00
Code Issues Projects Releases Packages Wiki Activity

Started coding 32 bit MCI handling.

Browse source 
Added Open/Close to low-level MCI drivers (audio, midi, anim, cda).
Wrote MCI MIDI support.
This commit is contained in:
Eric Pouech 1998-10-11 14:14:24 +00:00 • committed by Alexandre Julliard
parent 8077f1094b
commit 9f65a719fb
9 changed files with 5842 additions and 4966 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
include/mmsystem.h
View file

@ -2811,14 +2811,6 @@ BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
DWORD WINAPI auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
struct LINUX_MCIDRIVER {
HDRVR16 hdrv;
DRIVERPROC16 driverproc;
MCI_OPEN_DRIVER_PARMS modp;
MCI_OPEN_PARMS16 mop;
DWORD private;
};
#pragma pack(4)
DWORD WINAPI mixMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
@ -2832,4 +2824,21 @@ DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
#pragma pack(4)
LONG WAVE_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG WAVE_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG MIDI_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG MIDI_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG CDAUDIO_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG CDAUDIO_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG ANIM_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG ANIM_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2);
#endif /* __WINE_MMSYSTEM_H */

61
include/multimedia.h
View file

@ -38,60 +38,19 @@
#ifdef SOUND_VERSION
#define IOCTL(a,b,c) ioctl(a,b,&c)
#else
#define IOCTL(a,b,c) (c = ioctl(a,b,c) )
#define IOCTL(a,b,c) (c = ioctl(a,b,c))
#endif
typedef struct {
#ifndef HAVE_OSS
int unixdev;
#endif
int state;
DWORD bufsize;
LPMIDIOPENDESC midiDesc;
WORD wFlags;
LPMIDIHDR lpQueueHdr;
DWORD dwTotalPlayed;
#ifdef HAVE_OSS
unsigned char incoming[3];
unsigned char incPrev;
char incLen;
DWORD startTime;
#endif
} LINUX_MIDIIN;
typedef struct {
#ifndef HAVE_OSS
int unixdev;
#endif
int state;
DWORD bufsize;
LPMIDIOPENDESC midiDesc;
WORD wFlags;
LPMIDIHDR lpQueueHdr;
DWORD dwTotalPlayed;
#ifdef HAVE_OSS
void* lpExtra; /* according to port type (MIDI, FM...), extra data when needed */
#endif
} LINUX_MIDIOUT;
typedef struct {
int nUseCount; /* Incremented for each shared open */
BOOL16 fShareable; /* TRUE if first open was shareable */
WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
HANDLE16 hCallback; /* Callback handle for pending notification */
HMMIO16 hFile; /* mmio file handle open as Element */
DWORD dwBeginData;
DWORD dwTotalLen;
WORD wFormat;
WORD nTracks;
WORD nTempo;
MCI_OPEN_PARMS16 openParms;
/* MIDIHDR MidiHdr; */
HLOCAL16 hMidiHdr;
WORD dwStatus;
} LINUX_MCIMIDI;
struct WINE_MCIDRIVER {
HDRVR16 hDrv;
DRIVERPROC16 driverProc;
MCI_OPEN_DRIVER_PARMS modp;
MCI_OPEN_PARMS16 mop;
DWORD dwPrivate;
};
/* function prototypes */
extern BOOL32 MULTIMEDIA_Init( void );
extern BOOL32 MULTIMEDIA_Init(void);
extern DWORD mciSendCommandAsync32(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD dwParam2);
#endif /* __WINE_MULTIMEDIA_H */

264
multimedia/audio.c
View file

@ -1,3 +1,4 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* Sample Wine Driver for Open Sound System (featured in Linux and FreeBSD)
*
@ -57,7 +58,7 @@ typedef struct {
PCMWAVEFORMAT Format;
LPWAVEHDR lpQueueHdr;
DWORD dwTotalPlayed;
} LINUX_WAVEOUT;
} WINE_WAVEOUT;
typedef struct {
int unixdev;
@ -68,24 +69,23 @@ typedef struct {
PCMWAVEFORMAT Format;
LPWAVEHDR lpQueueHdr;
DWORD dwTotalRecorded;
} LINUX_WAVEIN;
} WINE_WAVEIN;
typedef struct {
int nUseCount; /* Incremented for each shared open */
BOOL16 fShareable; /* TRUE if first open was shareable */
WORD wNotifyDeviceID;/* MCI device ID with a pending notification */
HANDLE16 hCallback; /* Callback handle for pending notification */
HMMIO16 hFile; /* mmio file handle open as Element */
HMMIO32 hFile; /* mmio file handle open as Element */
MCI_WAVE_OPEN_PARMS16 openParms;
PCMWAVEFORMAT WaveFormat;
WAVEHDR WaveHdr;
BOOL16 fInput; /* FALSE = Output, TRUE = Input */
} LINUX_MCIWAVE;
static LINUX_WAVEOUT WOutDev[MAX_WAVOUTDRV];
static LINUX_WAVEIN WInDev[MAX_WAVOUTDRV];
static LINUX_MCIWAVE MCIWavDev[MAX_MCIWAVDRV];
} WINE_MCIWAVE;
static WINE_WAVEOUT WOutDev[MAX_WAVOUTDRV];
static WINE_WAVEIN WInDev[MAX_WAVOUTDRV];
static WINE_MCIWAVE MCIWavDev[MAX_MCIWAVDRV];
/**************************************************************************
* WAVE_NotifyClient [internal]
@ -135,17 +135,18 @@ static DWORD WAVE_NotifyClient(UINT16 wDevID, WORD wMsg,
/**************************************************************************
* WAVE_mciOpen [internal]
*/
static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS16 lpParms)
static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, void* lp, BOOL32 is32)
{
LPPCMWAVEFORMAT lpWaveFormat;
WAVEOPENDESC waveDesc;
LPSTR lpstrElementName;
DWORD dwRet;
char str[128];
DWORD dwDeviceID;
TRACE(mciwave,"(%04X, %08lX, %p)\n",
wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
TRACE(mciwave,"(%04X, %08lX, %p)\n", wDevID, dwFlags, lp);
if (lp == NULL) return MCIERR_INTERNAL;
if (is32) dwDeviceID = ((LPMCI_OPEN_PARMS32A)lp)->wDeviceID;
else dwDeviceID = ((LPMCI_OPEN_PARMS16)lp)->wDeviceID;
if (MCIWavDev[wDevID].nUseCount > 0) {
/* The driver already open on this channel */
@ -165,16 +166,17 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS16
TRACE(mciwave,"wDevID=%04X\n", wDevID);
TRACE(mciwave,"before OPEN_ELEMENT\n");
if (dwFlags & MCI_OPEN_ELEMENT) {
lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
TRACE(mciwave,"MCI_OPEN_ELEMENT '%s' !\n",
lpstrElementName);
if ( lpstrElementName && (strlen(lpstrElementName) > 0)) {
strcpy(str, lpstrElementName);
CharUpper32A(str);
MCIWavDev[wDevID].hFile = mmioOpen16(str, NULL,
LPSTR lpstrElementName;
if (is32) lpstrElementName = ((LPMCI_WAVE_OPEN_PARMS32A)lp)->lpstrElementName;
else lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(((LPMCI_WAVE_OPEN_PARMS16)lp)->lpstrElementName);
TRACE(mciwave,"MCI_OPEN_ELEMENT '%s' !\n", lpstrElementName);
if (lpstrElementName && (strlen(lpstrElementName) > 0)) {
MCIWavDev[wDevID].hFile = mmioOpen32A(lpstrElementName, NULL,
MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE);
if (MCIWavDev[wDevID].hFile == 0) {
WARN(mciwave, "can't find file='%s' !\n", str);
WARN(mciwave, "can't find file='%s' !\n", lpstrElementName);
return MCIERR_FILE_NOT_FOUND;
}
}
@ -182,19 +184,19 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS16
MCIWavDev[wDevID].hFile = 0;
}
TRACE(mciwave,"hFile=%u\n", MCIWavDev[wDevID].hFile);
memcpy(&MCIWavDev[wDevID].openParms, lpParms, sizeof(MCI_WAVE_OPEN_PARMS16));
MCIWavDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
memcpy(&MCIWavDev[wDevID].openParms, lp, sizeof(MCI_WAVE_OPEN_PARMS16));
MCIWavDev[wDevID].wNotifyDeviceID = dwDeviceID;
lpWaveFormat = &MCIWavDev[wDevID].WaveFormat;
waveDesc.hWave = 0;
/*
/*
lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
lpWaveFormat->wBitsPerSample = 8;
lpWaveFormat->wf.nChannels = 1;
lpWaveFormat->wf.nSamplesPerSec = 11025;
lpWaveFormat->wf.nAvgBytesPerSec = 11025;
lpWaveFormat->wf.nBlockAlign = 1;
*/
*/
if (MCIWavDev[wDevID].hFile != 0) {
MMCKINFO mmckInfo;
MMCKINFO ckMainRIFF;
@ -229,10 +231,10 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS16
lpWaveFormat->wf.nSamplesPerSec * lpWaveFormat->wf.nBlockAlign;
waveDesc.lpFormat = (LPWAVEFORMAT)lpWaveFormat;
/*
/*
By default the device will be opened for output, the MCI_CUE function is there to
change from output to input and back
*/
*/
dwRet=wodMessage(wDevID,WODM_OPEN,0,(DWORD)&waveDesc,CALLBACK_NULL);
return 0;
@ -244,7 +246,7 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS16
static DWORD WAVE_mciCue(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
{
/*
/*
FIXME
This routine is far from complete. At the moment only a check is done on the
@ -253,14 +255,14 @@ static DWORD WAVE_mciCue(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpPar
The flags MCI_NOTIFY (and the callback parameter in lpParms) and MCI_WAIT
are ignored
*/
*/
DWORD dwRet;
WAVEOPENDESC waveDesc;
TRACE(mciwave,"(%u, %08lX, %p);\n", wDevID, dwParam, lpParms);
/* always close elements ? */
/* always close elements ? */
if (MCIWavDev[wDevID].hFile != 0) {
mmioClose32(MCIWavDev[wDevID].hFile, 0);
@ -269,7 +271,7 @@ static DWORD WAVE_mciCue(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpPar
dwRet = MMSYSERR_NOERROR; /* assume success */
if ((dwParam & MCI_WAVE_INPUT) && !MCIWavDev[wDevID].fInput) {
/* FIXME this is just a hack WOutDev should be hidden here */
/* FIXME this is just a hack WOutDev should be hidden here */
memcpy(&waveDesc,&WOutDev[wDevID].waveDesc,sizeof(WAVEOPENDESC));
dwRet = wodMessage(wDevID, WODM_CLOSE, 0, 0L, 0L);
@ -278,7 +280,7 @@ static DWORD WAVE_mciCue(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpPar
MCIWavDev[wDevID].fInput = TRUE;
}
else if (MCIWavDev[wDevID].fInput) {
/* FIXME this is just a hack WInDev should be hidden here */
/* FIXME this is just a hack WInDev should be hidden here */
memcpy(&waveDesc,&WInDev[wDevID].waveDesc,sizeof(WAVEOPENDESC));
dwRet = widMessage(wDevID, WIDM_CLOSE, 0, 0L, 0L);
@ -374,7 +376,7 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
TRACE(mciwave,"mmioRead bufsize=%ld count=%ld\n", bufsize, count);
if (count < 1) break;
lpWaveHdr->dwBufferLength = count;
/* lpWaveHdr->dwBytesRecorded = count; */
/* lpWaveHdr->dwBytesRecorded = count; */
TRACE(mciwave,"before WODM_WRITE lpWaveHdr=%p dwBufferLength=%lu dwBytesRecorded=%lu\n",
lpWaveHdr, lpWaveHdr->dwBufferLength, lpWaveHdr->dwBytesRecorded);
dwRet=wodMessage(wDevID,WODM_WRITE,0,(DWORD)lpWaveHdr,sizeof(WAVEHDR));
@ -1707,103 +1709,118 @@ DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
/**************************************************************************
* AUDIO_DriverProc [sample driver]
* WAVE_DriverProc16 [sample driver]
*/
LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
LONG WAVE_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
TRACE(mciwave,"(%08lX, %04X, %04X, %08lX, %08lX)\n",
dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch(wMsg) {
case DRV_LOAD:
return 1;
case DRV_FREE:
return 1;
case DRV_OPEN:
return 1;
case DRV_CLOSE:
return 1;
case DRV_ENABLE:
return 1;
case DRV_DISABLE:
return 1;
case DRV_QUERYCONFIGURE:
return 1;
case DRV_CONFIGURE:
MessageBox16(0, "Sample MultiMedia Linux Driver !",
"MMLinux Driver", MB_OK);
return 1;
case DRV_INSTALL:
return DRVCNF_RESTART;
case DRV_REMOVE:
return DRVCNF_RESTART;
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return 1;
case DRV_CLOSE: return 1;
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_OPEN_DRIVER:
case MCI_OPEN:
return WAVE_mciOpen(dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_CUE:
return WAVE_mciCue(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_OPEN: return WAVE_mciOpen(dwDevID, dwParam1, PTR_SEG_TO_LIN(dwParam2), FALSE);
case MCI_CUE: return WAVE_mciCue(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_CLOSE_DRIVER:
case MCI_CLOSE:
return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY:
return WAVE_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RECORD:
return WAVE_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP:
return WAVE_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET:
return WAVE_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE:
return WAVE_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME:
return WAVE_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS:
return WAVE_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_GETDEVCAPS:
return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO:
return WAVE_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_LOAD:
return MMSYSERR_NOTSUPPORTED;
case MCI_SAVE:
return MMSYSERR_NOTSUPPORTED;
case MCI_SEEK:
return MMSYSERR_NOTSUPPORTED;
case MCI_FREEZE:
return MMSYSERR_NOTSUPPORTED;
case MCI_PUT:
return MMSYSERR_NOTSUPPORTED;
case MCI_REALIZE:
return MMSYSERR_NOTSUPPORTED;
case MCI_UNFREEZE:
return MMSYSERR_NOTSUPPORTED;
case MCI_UPDATE:
return MMSYSERR_NOTSUPPORTED;
case MCI_WHERE:
return MMSYSERR_NOTSUPPORTED;
case MCI_WINDOW:
return MMSYSERR_NOTSUPPORTED;
case MCI_STEP:
return MMSYSERR_NOTSUPPORTED;
case MCI_SPIN:
return MMSYSERR_NOTSUPPORTED;
case MCI_ESCAPE:
return MMSYSERR_NOTSUPPORTED;
case MCI_COPY:
return MMSYSERR_NOTSUPPORTED;
case MCI_CUT:
return MMSYSERR_NOTSUPPORTED;
case MCI_DELETE:
return MMSYSERR_NOTSUPPORTED;
case MCI_PASTE:
return MMSYSERR_NOTSUPPORTED;
case MCI_CLOSE: return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY: return WAVE_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RECORD: return WAVE_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP: return WAVE_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET: return WAVE_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE: return WAVE_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME: return WAVE_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS: return WAVE_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_GETDEVCAPS: return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO: return WAVE_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_LOAD: return MMSYSERR_NOTSUPPORTED;
case MCI_SAVE: return MMSYSERR_NOTSUPPORTED;
case MCI_SEEK: return MMSYSERR_NOTSUPPORTED;
case MCI_FREEZE: return MMSYSERR_NOTSUPPORTED;
case MCI_PUT: return MMSYSERR_NOTSUPPORTED;
case MCI_REALIZE: return MMSYSERR_NOTSUPPORTED;
case MCI_UNFREEZE: return MMSYSERR_NOTSUPPORTED;
case MCI_UPDATE: return MMSYSERR_NOTSUPPORTED;
case MCI_WHERE: return MMSYSERR_NOTSUPPORTED;
case MCI_WINDOW: return MMSYSERR_NOTSUPPORTED;
case MCI_STEP: return MMSYSERR_NOTSUPPORTED;
case MCI_SPIN: return MMSYSERR_NOTSUPPORTED;
case MCI_ESCAPE: return MMSYSERR_NOTSUPPORTED;
case MCI_COPY: return MMSYSERR_NOTSUPPORTED;
case MCI_CUT: return MMSYSERR_NOTSUPPORTED;
case MCI_DELETE: return MMSYSERR_NOTSUPPORTED;
case MCI_PASTE: return MMSYSERR_NOTSUPPORTED;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* WAVE_DriverProc32 [sample driver]
*/
LONG WAVE_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
TRACE(mciwave,"(%08lX, %04X, %08lX, %08lX, %08lX)\n",
dwDevID, hDriv, wMsg, dwParam1, dwParam2);
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN: return 1;
case DRV_CLOSE: return 1;
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_OPEN_DRIVER:
case MCI_OPEN: return WAVE_mciOpen(dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMS32A)dwParam2, TRUE);
case MCI_CUE: return WAVE_mciCue(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_CLOSE_DRIVER:
case MCI_CLOSE: return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_PLAY: return WAVE_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
case MCI_RECORD: return WAVE_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
case MCI_STOP: return WAVE_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_SET: return WAVE_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PAUSE: return WAVE_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_RESUME: return WAVE_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_STATUS: return WAVE_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_GETDEVCAPS: return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
case MCI_INFO: return WAVE_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)dwParam2);
case MCI_LOAD: return MMSYSERR_NOTSUPPORTED;
case MCI_SAVE: return MMSYSERR_NOTSUPPORTED;
case MCI_SEEK: return MMSYSERR_NOTSUPPORTED;
case MCI_FREEZE: return MMSYSERR_NOTSUPPORTED;
case MCI_PUT: return MMSYSERR_NOTSUPPORTED;
case MCI_REALIZE: return MMSYSERR_NOTSUPPORTED;
case MCI_UNFREEZE: return MMSYSERR_NOTSUPPORTED;
case MCI_UPDATE: return MMSYSERR_NOTSUPPORTED;
case MCI_WHERE: return MMSYSERR_NOTSUPPORTED;
case MCI_WINDOW: return MMSYSERR_NOTSUPPORTED;
case MCI_STEP: return MMSYSERR_NOTSUPPORTED;
case MCI_SPIN: return MMSYSERR_NOTSUPPORTED;
case MCI_ESCAPE: return MMSYSERR_NOTSUPPORTED;
case MCI_COPY: return MMSYSERR_NOTSUPPORTED;
case MCI_CUT: return MMSYSERR_NOTSUPPORTED;
case MCI_DELETE: return MMSYSERR_NOTSUPPORTED;
case MCI_PASTE: return MMSYSERR_NOTSUPPORTED;
default:
FIXME(mciwave, "is probably wrong\n");
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MMSYSERR_NOTENABLED;
}
#else /* !HAVE_OSS */
@ -1830,9 +1847,18 @@ DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
}
/**************************************************************************
* AUDIO_DriverProc [sample driver]
* WAVE_DriverProc16 [sample driver]
*/
LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
LONG WAVE_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* WAVE_DriverProc32 [sample driver]
*/
LONG WAVE_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
return MMSYSERR_NOTENABLED;

40
multimedia/init.c
View file

@ -59,12 +59,12 @@ int unixToWindowsDeviceType(int type)
#endif
/**************************************************************************
* MultimediaInit [internal]
* MULTIMEDIA_MidiInit [internal]
*
* Initializes the MIDI devices information variables
*
*/
BOOL32 MULTIMEDIA_Init(void)
BOOL32 MULTIMEDIA_MidiInit(void)
{
#ifdef HAVE_OSS
int i, status, numsynthdevs = 255, nummididevs = 255;
@ -247,3 +247,39 @@ BOOL32 MULTIMEDIA_Init(void)
return TRUE;
}
extern int mciInstalledCount;
extern int mciInstalledListLen;
extern LPSTR lpmciInstallNames;
BOOL32 MULTIMEDIA_MciInit(void)
{
int len;
LPSTR ptr;
LPSTR SysFile = "SYSTEM.INI";
mciInstalledCount = 0;
mciInstalledListLen = 0;
ptr = lpmciInstallNames = xmalloc(2048);
/* FIXME: should do also some registry diving here */
GetPrivateProfileString32A("mci", NULL, "", lpmciInstallNames, 2000, SysFile);
while (strlen(ptr) > 0) {
TRACE(mci, "---> '%s' \n", ptr);
len = strlen(ptr) + 1;
ptr += len;
mciInstalledListLen += len;
mciInstalledCount++;
}
return TRUE;
}
/**************************************************************************
* MULTIMEDIA_Init [internal]
*
* Initializes the multimedia information variables
*
*/
BOOL32 MULTIMEDIA_Init(void)
{
return MULTIMEDIA_MidiInit() && MULTIMEDIA_MciInit();
}

218
multimedia/mcianim.c
View file

@ -1,3 +1,4 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* Sample MCI ANIMATION Wine Driver for Linux
*
@ -35,24 +36,22 @@ typedef struct {
DWORD dwTotalLen;
LPDWORD lpdwTrackLen;
LPDWORD lpdwTrackPos;
} LINUX_ANIM;
} WINE_ANIM;
static LINUX_ANIM AnimDev[MAX_ANIMDRV];
static WINE_ANIM AnimDev[MAX_ANIMDRV];
/*-----------------------------------------------------------------------*/
/**************************************************************************
* ANIM_mciOpen [internal]
*/
static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpParms)
* ANIM_mciOpen [internal]
*/
static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, void* lp, BOOL32 is32)
{
LPSTR lpstrElementName;
char str[128];
DWORD dwDeviceID;
TRACE(mcianim,"(%04X, %08lX, %p);\n",
wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
TRACE(mcianim,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lp);
if (lp == NULL) return MCIERR_INTERNAL;
if (AnimDev[wDevID].nUseCount > 0) {
/* The driver already open on this channel */
/* If the driver was opened shareable before and this open specifies */
@ -66,20 +65,29 @@ static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpPar
AnimDev[wDevID].nUseCount = 1;
AnimDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
}
if (is32) dwDeviceID = ((LPMCI_OPEN_PARMS32A)lp)->wDeviceID;
else dwDeviceID = ((LPMCI_OPEN_PARMS16)lp)->wDeviceID;
TRACE(mcianim,"wDevID=%04X\n", wDevID);
lpParms->wDeviceID = wDevID;
TRACE(mcianim,"lpParms->wDevID=%04X\n", lpParms->wDeviceID);
/* FIXME this is not consistent with other implementations */
if (is32) ((LPMCI_OPEN_PARMS32A)lp)->wDeviceID = wDevID;
else ((LPMCI_OPEN_PARMS16)lp)->wDeviceID = wDevID;
/*TRACE(mcianim,"lpParms->wDevID=%04X\n", lpParms->wDeviceID);*/
if (dwFlags & MCI_OPEN_ELEMENT) {
lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName);
TRACE(mcianim,"MCI_OPEN_ELEMENT '%s' !\n",
lpstrElementName);
if (strlen(lpstrElementName) > 0) {
strcpy(str, lpstrElementName);
CharUpper32A(str);
LPSTR lpstrElementName;
if (is32) lpstrElementName = ((LPMCI_OPEN_PARMS32A)lp)->lpstrElementName;
else lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(((LPMCI_OPEN_PARMS16)lp)->lpstrElementName);
TRACE(mcianim,"MCI_OPEN_ELEMENT '%s' !\n", lpstrElementName);
if (lpstrElementName && strlen(lpstrElementName) > 0) {
}
FIXME(mcianim, "element is not opened\n");
}
memcpy(&AnimDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS16));
AnimDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
memcpy(&AnimDev[wDevID].openParms, lp, sizeof(MCI_OPEN_PARMS16));
AnimDev[wDevID].wNotifyDeviceID = dwDeviceID;
AnimDev[wDevID].mode = 0;
AnimDev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF;
AnimDev[wDevID].nCurTrack = 0;
@ -87,7 +95,7 @@ static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpPar
AnimDev[wDevID].dwTotalLen = 0;
AnimDev[wDevID].lpdwTrackLen = NULL;
AnimDev[wDevID].lpdwTrackPos = NULL;
/*
/*
Moved to mmsystem.c mciOpen routine
if (dwFlags & MCI_NOTIFY) {
@ -96,13 +104,13 @@ static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpPar
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
}
*/
*/
return 0;
}
/**************************************************************************
* ANIM_mciClose [internal]
*/
* ANIM_mciClose [internal]
*/
static DWORD ANIM_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -113,8 +121,8 @@ static DWORD ANIM_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpP
}
/**************************************************************************
* ANIM_mciGetDevCaps [internal]
*/
* ANIM_mciGetDevCaps [internal]
*/
static DWORD ANIM_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
LPMCI_GETDEVCAPS_PARMS lpParms)
{
@ -163,8 +171,8 @@ static DWORD ANIM_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
/**************************************************************************
* ANIM_CalcTime [internal]
*/
* ANIM_CalcTime [internal]
*/
static DWORD ANIM_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
{
DWORD dwTime = 0;
@ -194,7 +202,7 @@ static DWORD ANIM_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
dwFormatType = MCI_FORMAT_TMSF;
case MCI_FORMAT_TMSF:
for (wTrack = 0; wTrack < AnimDev[wDevID].nTracks; wTrack++) {
/* dwTime += AnimDev[wDevID].lpdwTrackLen[wTrack - 1];
/* dwTime += AnimDev[wDevID].lpdwTrackLen[wTrack - 1];
TRACE(mcianim, "Adding trk#%u curpos=%u \n", dwTime);
if (dwTime >= dwFrame) break; */
if (AnimDev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break;
@ -213,8 +221,8 @@ static DWORD ANIM_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
/**************************************************************************
* ANIM_CalcFrame [internal]
*/
* ANIM_CalcFrame [internal]
*/
static DWORD ANIM_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime)
{
DWORD dwFrame = 0;
@ -256,8 +264,8 @@ static DWORD ANIM_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime)
/**************************************************************************
* ANIM_mciInfo [internal]
*/
* ANIM_mciInfo [internal]
*/
static DWORD ANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -286,8 +294,8 @@ static DWORD ANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpPar
}
/**************************************************************************
* ANIM_mciStatus [internal]
*/
* ANIM_mciStatus [internal]
*/
static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -370,8 +378,8 @@ static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP
/**************************************************************************
* ANIM_mciPlay [internal]
*/
* ANIM_mciPlay [internal]
*/
static DWORD ANIM_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
int start, end;
@ -403,8 +411,8 @@ static DWORD ANIM_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms
}
/**************************************************************************
* ANIM_mciStop [internal]
*/
* ANIM_mciStop [internal]
*/
static DWORD ANIM_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -421,8 +429,8 @@ static DWORD ANIM_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpPa
}
/**************************************************************************
* ANIM_mciPause [internal]
*/
* ANIM_mciPause [internal]
*/
static DWORD ANIM_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -439,8 +447,8 @@ static DWORD ANIM_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpP
}
/**************************************************************************
* ANIM_mciResume [internal]
*/
* ANIM_mciResume [internal]
*/
static DWORD ANIM_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n",
@ -457,8 +465,8 @@ static DWORD ANIM_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lp
}
/**************************************************************************
* ANIM_mciSeek [internal]
*/
* ANIM_mciSeek [internal]
*/
static DWORD ANIM_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
{
DWORD dwRet;
@ -492,16 +500,16 @@ static DWORD ANIM_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms
/**************************************************************************
* ANIM_mciSet [internal]
*/
* ANIM_mciSet [internal]
*/
static DWORD ANIM_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
{
TRACE(mcianim,"(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
/*
/*
TRACE(mcianim,"(dwTimeFormat=%08lX)\n", lpParms->dwTimeFormat);
TRACE(mcianim,"(dwAudio=%08lX)\n", lpParms->dwAudio);
*/
*/
if (dwFlags & MCI_SET_TIME_FORMAT) {
switch (lpParms->dwTimeFormat) {
case MCI_FORMAT_MILLISECONDS:
@ -533,69 +541,69 @@ static DWORD ANIM_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
/**************************************************************************
* ANIM_DriverProc [sample driver]
*/
LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
* ANIM_DriverProc16 [sample driver]
*/
LONG ANIM_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
switch(wMsg) {
case DRV_LOAD:
return 1;
case DRV_FREE:
return 1;
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN:
case MCI_OPEN_DRIVER:
case MCI_OPEN:
return ANIM_mciOpen(dwDevID, dwParam1,
(LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_OPEN: return ANIM_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2), FALSE);
case DRV_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CLOSE:
return ANIM_mciClose(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case DRV_ENABLE:
return 1;
case DRV_DISABLE:
return 1;
case DRV_QUERYCONFIGURE:
return 1;
case DRV_CONFIGURE:
MessageBox16(0, "Sample MultiMedia Linux Driver !",
"MMLinux Driver", MB_OK);
return 1;
case DRV_INSTALL:
return DRVCNF_RESTART;
case DRV_REMOVE:
return DRVCNF_RESTART;
case MCI_GETDEVCAPS:
return ANIM_mciGetDevCaps(dwDevID, dwParam1,
(LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO:
return ANIM_mciInfo(dwDevID, dwParam1,
(LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS:
return ANIM_mciStatus(dwDevID, dwParam1,
(LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET:
return ANIM_mciSet(dwDevID, dwParam1,
(LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY:
return ANIM_mciPlay(dwDevID, dwParam1,
(LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP:
return ANIM_mciStop(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE:
return ANIM_mciPause(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME:
return ANIM_mciResume(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SEEK:
return ANIM_mciSeek(dwDevID, dwParam1,
(LPMCI_SEEK_PARMS)PTR_SEG_TO_LIN(dwParam2));
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
case MCI_CLOSE: return ANIM_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_GETDEVCAPS: return ANIM_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO: return ANIM_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS: return ANIM_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET: return ANIM_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY: return ANIM_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP: return ANIM_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE: return ANIM_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME: return ANIM_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SEEK: return ANIM_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)PTR_SEG_TO_LIN(dwParam2));
default: return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/**************************************************************************
* ANIM_DriverProc32 [sample driver]
*/
LONG ANIM_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN:
case MCI_OPEN_DRIVER:
case MCI_OPEN: return ANIM_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2, TRUE);
case DRV_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CLOSE: return ANIM_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_GETDEVCAPS: return ANIM_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
case MCI_INFO: return ANIM_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)dwParam2);
case MCI_STATUS: return ANIM_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return ANIM_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return ANIM_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
case MCI_STOP: return ANIM_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_PAUSE: return ANIM_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_RESUME: return ANIM_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_SEEK: return ANIM_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
default: return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}

246
multimedia/mcicda.c
View file

@ -1,3 +1,4 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* Sample MCI CDAUDIO Wine Driver for Linux
*
@ -66,18 +67,17 @@ typedef struct {
LPDWORD lpdwTrackLen;
LPDWORD lpdwTrackPos;
DWORD dwFirstOffset;
} LINUX_CDAUDIO;
} WINE_CDAUDIO;
static LINUX_CDAUDIO CDADev[MAX_CDAUDIODRV];
static WINE_CDAUDIO CDADev[MAX_CDAUDIODRV];
#endif
/*-----------------------------------------------------------------------*/
/**************************************************************************
* CDAUDIO_GetNumberOfTracks [internal]
*/
* CDAUDIO_GetNumberOfTracks [internal]
*/
static UINT16 CDAUDIO_GetNumberOfTracks(UINT16 wDevID)
{
#if defined(linux) || defined(__FreeBSD__)
@ -113,8 +113,8 @@ static UINT16 CDAUDIO_GetNumberOfTracks(UINT16 wDevID)
/**************************************************************************
* CDAUDIO_GetTracksInfo [internal]
*/
* CDAUDIO_GetTracksInfo [internal]
*/
static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID)
{
#if defined(linux) || defined(__FreeBSD__)
@ -219,14 +219,19 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID)
/**************************************************************************
* CDAUDIO_mciOpen [internal]
*/
static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpParms)
* CDAUDIO_mciOpen [internal]
*/
static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, void* lp, BOOL32 is32)
{
#if defined(linux) || defined(__FreeBSD__)
DWORD dwDeviceID;
TRACE(cdaudio,"(%04X, %08lX, %p);\n",
wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
wDevID, dwFlags, lp);
if (lp == NULL) return MCIERR_INTERNAL;
if (is32) dwDeviceID = ((LPMCI_OPEN_PARMS32A)lp)->wDeviceID;
else dwDeviceID = ((LPMCI_OPEN_PARMS16)lp)->wDeviceID;
if (CDADev[wDevID].nUseCount > 0) {
/* The driver already open on this channel */
@ -236,17 +241,16 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lp
++CDADev[wDevID].nUseCount;
else
return MCIERR_MUST_USE_SHAREABLE;
}
else {
} else {
CDADev[wDevID].nUseCount = 1;
CDADev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
}
if (dwFlags & MCI_OPEN_ELEMENT) {
TRACE(cdaudio,"MCI_OPEN_ELEMENT !\n");
/* return MCIERR_NO_ELEMENT_ALLOWED; */
/* return MCIERR_NO_ELEMENT_ALLOWED; */
}
memcpy(&CDADev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS16));
CDADev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
memcpy(&CDADev[wDevID].openParms, lp, sizeof(MCI_OPEN_PARMS16));
CDADev[wDevID].wNotifyDeviceID = dwDeviceID;
CDADev[wDevID].unixdev = open (CDAUDIO_DEV, O_RDONLY, 0);
if (CDADev[wDevID].unixdev == -1) {
WARN(cdaudio,"can't open '%s' !\n", CDAUDIO_DEV);
@ -262,10 +266,10 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lp
CDADev[wDevID].lpdwTrackPos = NULL;
if (!CDAUDIO_GetTracksInfo(wDevID)) {
WARN(cdaudio,"error reading TracksInfo !\n");
/* return MCIERR_INTERNAL; */
/* return MCIERR_INTERNAL; */
}
/*
/*
Moved to mmsystem.c mciOpen routine
if (dwFlags & MCI_NOTIFY) {
@ -274,7 +278,7 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lp
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
}
*/
*/
return 0;
#else
return MCIERR_HARDWARE;
@ -282,23 +286,25 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lp
}
/**************************************************************************
* CDAUDIO_mciClose [internal]
*/
* CDAUDIO_mciClose [internal]
*/
static DWORD CDAUDIO_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
TRACE(cdaudio,"(%04X, %08lX, %p);\n",
wDevID, dwParam, lpParms);
if (--CDADev[wDevID].nUseCount == 0) {
if (CDADev[wDevID].lpdwTrackLen != NULL) free(CDADev[wDevID].lpdwTrackLen);
if (CDADev[wDevID].lpdwTrackPos != NULL) free(CDADev[wDevID].lpdwTrackPos);
close(CDADev[wDevID].unixdev);
}
#endif
return 0;
}
/**************************************************************************
* CDAUDIO_mciGetDevCaps [internal]
*/
* CDAUDIO_mciGetDevCaps [internal]
*/
static DWORD CDAUDIO_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
LPMCI_GETDEVCAPS_PARMS lpParms)
{
@ -350,8 +356,8 @@ static DWORD CDAUDIO_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
}
/**************************************************************************
* CDAUDIO_mciInfo [internal]
*/
* CDAUDIO_mciInfo [internal]
*/
static DWORD CDAUDIO_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -378,8 +384,8 @@ static DWORD CDAUDIO_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lp
/**************************************************************************
* CDAUDIO_CalcFrame [internal]
*/
* CDAUDIO_CalcFrame [internal]
*/
static DWORD CDAUDIO_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime)
{
DWORD dwFrame = 0;
@ -425,8 +431,8 @@ static DWORD CDAUDIO_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime)
/**************************************************************************
* CDAUDIO_GetCDStatus [internal]
*/
* CDAUDIO_GetCDStatus [internal]
*/
static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID)
{
#if defined(linux) || defined(__FreeBSD__)
@ -546,8 +552,8 @@ static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID)
/**************************************************************************
* CDAUDIO_CalcTime [internal]
*/
* CDAUDIO_CalcTime [internal]
*/
static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
{
DWORD dwTime = 0;
@ -580,7 +586,7 @@ static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
dwFormatType = MCI_FORMAT_TMSF;
case MCI_FORMAT_TMSF:
for (wTrack = 0; wTrack < CDADev[wDevID].nTracks; wTrack++) {
/* dwTime += CDADev[wDevID].lpdwTrackLen[wTrack - 1];
/* dwTime += CDADev[wDevID].lpdwTrackLen[wTrack - 1];
TRACE(cdaudio, "Adding trk#%u curpos=%u \n", dwTime);
if (dwTime >= dwFrame) break; */
if (CDADev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break;
@ -600,8 +606,8 @@ static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame)
/**************************************************************************
* CDAUDIO_mciStatus [internal]
*/
* CDAUDIO_mciStatus [internal]
*/
static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -701,8 +707,8 @@ static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS
/**************************************************************************
* CDAUDIO_mciPlay [internal]
*/
* CDAUDIO_mciPlay [internal]
*/
static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -781,10 +787,10 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa
if (dwFlags & MCI_NOTIFY) {
TRACE(cdaudio, "MCI_NOTIFY_SUCCESSFUL %08lX !\n",
lpParms->dwCallback);
/*
/*
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
*/
*/
}
return 0;
#else
@ -793,8 +799,8 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa
}
/**************************************************************************
* CDAUDIO_mciStop [internal]
*/
* CDAUDIO_mciStop [internal]
*/
static DWORD CDAUDIO_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -822,8 +828,8 @@ static DWORD CDAUDIO_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS l
}
/**************************************************************************
* CDAUDIO_mciPause [internal]
*/
* CDAUDIO_mciPause [internal]
*/
static DWORD CDAUDIO_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -851,8 +857,8 @@ static DWORD CDAUDIO_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS
}
/**************************************************************************
* CDAUDIO_mciResume [internal]
*/
* CDAUDIO_mciResume [internal]
*/
static DWORD CDAUDIO_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -880,8 +886,8 @@ static DWORD CDAUDIO_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS
}
/**************************************************************************
* CDAUDIO_mciSeek [internal]
*/
* CDAUDIO_mciSeek [internal]
*/
static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
@ -929,17 +935,17 @@ static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpPa
/**************************************************************************
* CDAUDIO_mciSet [internal]
*/
* CDAUDIO_mciSet [internal]
*/
static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
{
#if defined(linux) || defined(__FreeBSD__)
TRACE(cdaudio,"(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
/*
/*
TRACE(cdaudio,"dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
TRACE(cdaudio,"dwAudio=%08lX\n", lpParms->dwAudio);
*/
*/
if (dwFlags & MCI_SET_TIME_FORMAT) {
switch (lpParms->dwTimeFormat) {
case MCI_FORMAT_MILLISECONDS:
@ -997,68 +1003,37 @@ static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParm
/**************************************************************************
* CDAUDIO_DriverProc [sample driver]
*/
LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
* CDAUDIO_DriverProc16 [sample driver]
*/
LONG CDAUDIO_DriverProc16(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
#if defined(linux) || defined(__FreeBSD__)
switch(wMsg) {
case DRV_LOAD:
return 1;
case DRV_FREE:
return 1;
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN:
case MCI_OPEN_DRIVER:
case MCI_OPEN:
return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_OPEN: return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2), FALSE);
case DRV_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CLOSE:
return CDAUDIO_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case DRV_ENABLE:
return 1;
case DRV_DISABLE:
return 1;
case DRV_QUERYCONFIGURE:
return 1;
case DRV_CONFIGURE:
MessageBox16(0, "Sample MultiMedia Linux Driver !",
"MMLinux Driver", MB_OK);
return 1;
case DRV_INSTALL:
return DRVCNF_RESTART;
case DRV_REMOVE:
return DRVCNF_RESTART;
case MCI_GETDEVCAPS:
return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1,
(LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO:
return CDAUDIO_mciInfo(dwDevID, dwParam1,
(LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS:
return CDAUDIO_mciStatus(dwDevID, dwParam1,
(LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET:
return CDAUDIO_mciSet(dwDevID, dwParam1,
(LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY:
return CDAUDIO_mciPlay(dwDevID, dwParam1,
(LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP:
return CDAUDIO_mciStop(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE:
return CDAUDIO_mciPause(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME:
return CDAUDIO_mciResume(dwDevID, dwParam1,
(LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SEEK:
return CDAUDIO_mciSeek(dwDevID, dwParam1,
(LPMCI_SEEK_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET_DOOR_OPEN:
TRACE(cdaudio, "MCI_SET_DOOR_OPEN !\n");
case MCI_CLOSE: return CDAUDIO_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_GETDEVCAPS: return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_INFO: return CDAUDIO_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2));
case MCI_STATUS: return CDAUDIO_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET: return CDAUDIO_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PLAY: return CDAUDIO_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_STOP: return CDAUDIO_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_PAUSE: return CDAUDIO_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_RESUME: return CDAUDIO_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SEEK: return CDAUDIO_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)PTR_SEG_TO_LIN(dwParam2));
case MCI_SET_DOOR_OPEN: TRACE(cdaudio, "MCI_SET_DOOR_OPEN !\n");
#ifdef __FreeBSD__
if (ioctl(CDADev[dwDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCEJECT)) return MCIERR_HARDWARE;
@ -1068,8 +1043,65 @@ LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
#endif
CDADev[dwDevID].nTracks = 0;
return 0;
case MCI_SET_DOOR_CLOSED:
TRACE(cdaudio,"MCI_SET_DOOR_CLOSED !\n");
case MCI_SET_DOOR_CLOSED: TRACE(cdaudio,"MCI_SET_DOOR_CLOSED !\n");
#ifdef __FreeBSD__
if (ioctl(CDADev[dwDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCCLOSE)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE;
#elif linux
if (ioctl(CDADev[dwDevID].unixdev, CDROMEJECT, 1)) return MCIERR_HARDWARE;
#endif
CDADev[dwDevID].nTracks = 0;
return 0;
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
#else
return MCIERR_HARDWARE;
#endif
}
/**************************************************************************
* CDAUDIO_DriverProc32 [sample driver]
*/
LONG CDAUDIO_DriverProc32(DWORD dwDevID, HDRVR16 hDriv, DWORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
#if defined(linux) || defined(__FreeBSD__)
switch(wMsg) {
case DRV_LOAD: return 1;
case DRV_FREE: return 1;
case DRV_OPEN:
case MCI_OPEN_DRIVER:
case MCI_OPEN: return CDAUDIO_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS32A)dwParam2, TRUE);
case DRV_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CLOSE: return CDAUDIO_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case DRV_ENABLE: return 1;
case DRV_DISABLE: return 1;
case DRV_QUERYCONFIGURE: return 1;
case DRV_CONFIGURE: MessageBox16(0, "Sample MultiMedia Linux Driver !", "MMLinux Driver", MB_OK); return 1;
case DRV_INSTALL: return DRVCNF_RESTART;
case DRV_REMOVE: return DRVCNF_RESTART;
case MCI_GETDEVCAPS: return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
case MCI_INFO: return CDAUDIO_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)dwParam2);
case MCI_STATUS: return CDAUDIO_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
case MCI_SET: return CDAUDIO_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
case MCI_PLAY: return CDAUDIO_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
case MCI_STOP: return CDAUDIO_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_PAUSE: return CDAUDIO_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_RESUME: return CDAUDIO_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
case MCI_SEEK: return CDAUDIO_mciSeek(dwDevID, dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
case MCI_SET_DOOR_OPEN: TRACE(cdaudio, "MCI_SET_DOOR_OPEN !\n");
#ifdef __FreeBSD__
if (ioctl(CDADev[dwDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCEJECT)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE;
#elif linux
if (ioctl(CDADev[dwDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE;
#endif
CDADev[dwDevID].nTracks = 0;
return 0;
case MCI_SET_DOOR_CLOSED: TRACE(cdaudio,"MCI_SET_DOOR_CLOSED !\n");
#ifdef __FreeBSD__
if (ioctl(CDADev[dwDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE;
if (ioctl(CDADev[dwDevID].unixdev, CDIOCCLOSE)) return MCIERR_HARDWARE;

279
multimedia/mcistring.c
View file

@ -1,3 +1,5 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* MCI stringinterface
*
@ -22,15 +24,16 @@
#include "user.h"
#include "driver.h"
#include "mmsystem.h"
#include "multimedia.h"
#include "callback.h"
#include "debug.h"
#include "xmalloc.h"
extern struct LINUX_MCIDRIVER mciDrv[MAXMCIDRIVERS];
extern struct WINE_MCIDRIVER mciDrv[MAXMCIDRIVERS];
#define GetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)])
#define GetOpenDrv(wDevID) (&(GetDrv(wDevID)->mop))
#define mciGetDrv(wDevID) (&mciDrv[MMSYSTEM_DevIDToIndex(wDevID)])
#define mciGetOpenDrv(wDevID) (&(mciGetDrv(wDevID)->mop))
extern int MMSYSTEM_DevIDToIndex(UINT16 wDevID);
extern UINT16 MMSYSTEM_FirstDevID(void);
@ -40,15 +43,6 @@ extern BOOL32 MMSYSTEM_DevIDValid(UINT16 wDevID);
LONG WINAPI DrvDefDriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG CDAUDIO_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2);
/* The reason why I just don't lowercase the keywords array in
* mciSendString is left as an exercise to the reader.
*/
@ -71,27 +65,27 @@ LONG ANIM_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg,
}\
} while(0)
/* calling DriverProc. We need to pass the struct as SEGMENTED POINTER. */
/* calling DriverProc. We need to pass the struct as linear pointer. */
#define _MCI_CALL_DRIVER(cmd,params) \
switch(uDevTyp) {\
case MCI_DEVTYPE_CD_AUDIO:\
res=CDAUDIO_DriverProc(GetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags, (DWORD)(params));\
res=CDAUDIO_DriverProc32(mciGetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags, (DWORD)(params));\
break;\
case MCI_DEVTYPE_WAVEFORM_AUDIO:\
res=WAVE_DriverProc(GetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
res=WAVE_DriverProc32(mciGetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
break;\
case MCI_DEVTYPE_SEQUENCER:\
res=MIDI_DriverProc(GetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
res=MIDI_DriverProc32(mciGetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
break;\
case MCI_DEVTYPE_ANIMATION:\
res=ANIM_DriverProc(GetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
res=ANIM_DriverProc32(mciGetDrv(wDevID)->modp.wDeviceID,0,cmd,dwFlags,(DWORD)(params));\
break;\
case MCI_DEVTYPE_DIGITAL_VIDEO:\
FIXME(mci,"_MCI_CALL_DRIVER: No DIGITAL_VIDEO yet !\n");\
res=MCIERR_DEVICE_NOT_INSTALLED;\
break;\
default:\
/*res = Callbacks->CallDriverProc(GetDrv(wDevID)->driverproc,GetDrv(wDevID)->modp.wDeviceID,GetDrv(wDevID)->hdrv,cmd,dwFlags,(DWORD)(params));\
/*res = Callbacks->CallDriverProc(mciGetDrv(wDevID)->driverproc,mciGetDrv(wDevID)->modp.wDeviceID,mciGetDrv(wDevID)->hdrv,cmd,dwFlags,(DWORD)(params));\
break;*/\
res = MCIERR_DEVICE_NOT_INSTALLED;\
break;\
@ -148,7 +142,7 @@ _MCISTR_printtf(char *buf,UINT16 uDevType,DWORD timef,DWORD val) {
static void
_MCISTR_convreturn(int type,DWORD dwReturn,LPSTR lpstrReturnString,
WORD uReturnLength,WORD uDevTyp,int timef
) {
) {
switch (type) {
case _MCISTR_vdmtype:
switch (dwReturn) {
@ -307,13 +301,13 @@ MCISTR_Open(_MCISTR_PROTO_) {
MCI_ANIM_OPEN_PARMS16 animopenParams;
MCI_OVLY_OPEN_PARMS16 ovlyopenParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
pU->openParams.lpstrElementName = NULL;
s=strchr(dev,'!');
if (s!=NULL) {
*s++='\0';
pU->openParams.lpstrElementName=(LPSTR)SEGPTR_GET(SEGPTR_STRDUP(s));
pU->openParams.lpstrElementName=strdup(s);
dwFlags |= MCI_OPEN_ELEMENT;
}
if (!STRCMP(dev,"cdaudio")) {
@ -327,27 +321,28 @@ MCISTR_Open(_MCISTR_PROTO_) {
} else if (!STRCMP(dev,"avivideo")) {
uDevTyp=MCI_DEVTYPE_DIGITAL_VIDEO;
} else {
SEGPTR_FREE(PTR_SEG_TO_LIN(pU->openParams.lpstrElementName));
SEGPTR_FREE(pU);
free(pU->openParams.lpstrElementName);
free(pU);
return MCIERR_INVALID_DEVICE_NAME;
}
wDevID=MMSYSTEM_FirstDevID();
while(GetDrv(wDevID)->modp.wType) {
while(mciGetDrv(wDevID)->modp.wType) {
wDevID = MMSYSTEM_NextDevID(wDevID);
if (!MMSYSTEM_DevIDValid(wDevID)) {
TRACE(mci, "MAXMCIDRIVERS reached (%x) !\n", wDevID);
SEGPTR_FREE(PTR_SEG_TO_LIN(pU->openParams.lpstrElementName));
SEGPTR_FREE(pU);
free(pU->openParams.lpstrElementName);
free(pU);
return MCIERR_INTERNAL;
}
}
GetDrv(wDevID)->modp.wType = uDevTyp;
GetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
mciGetDrv(wDevID)->modp.wType = uDevTyp;
mciGetDrv(wDevID)->modp.wDeviceID = 0; /* FIXME? for multiple devices */
pU->openParams.dwCallback = hwndCallback ;
pU->openParams.wDeviceID = wDevID;
pU->openParams.wReserved0 = 0;
pU->ovlyopenParams.dwStyle = 0;
pU->animopenParams.dwStyle = 0;
pU->openParams.lpstrDeviceType = (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(dev));
pU->openParams.lpstrDeviceType = strdup(dev);
pU->openParams.lpstrAlias = NULL;
dwFlags |= MCI_OPEN_TYPE;
i=0;
@ -355,13 +350,13 @@ MCISTR_Open(_MCISTR_PROTO_) {
FLAG1("shareable",MCI_OPEN_SHAREABLE);
if (!STRCMP(keywords[i],"alias") && (i+1<nrofkeywords)) {
dwFlags |= MCI_OPEN_ALIAS;
pU->openParams.lpstrAlias=(LPSTR)SEGPTR_GET(SEGPTR_STRDUP(keywords[i+1]));
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=(LPSTR)SEGPTR_GET(SEGPTR_STRDUP(keywords[i+1]));
pU->openParams.lpstrElementName=strdup(keywords[i+1]);
i+=2;
continue;
}
@ -430,15 +425,15 @@ MCISTR_Open(_MCISTR_PROTO_) {
keywords[i]);
i++;
}
_MCI_CALL_DRIVER( MCI_OPEN, SEGPTR_GET(pU) );
_MCI_CALL_DRIVER(MCI_OPEN, pU);
if (res==0)
memcpy(GetOpenDrv(wDevID),&pU->openParams,sizeof(MCI_OPEN_PARMS16));
memcpy(mciGetOpenDrv(wDevID),&pU->openParams,sizeof(MCI_OPEN_PARMS16));
else {
SEGPTR_FREE(PTR_SEG_TO_LIN(pU->openParams.lpstrElementName));
SEGPTR_FREE(PTR_SEG_TO_LIN(pU->openParams.lpstrDeviceType));
SEGPTR_FREE(PTR_SEG_TO_LIN(pU->openParams.lpstrAlias));
free(pU->openParams.lpstrElementName);
free(pU->openParams.lpstrDeviceType);
free(pU->openParams.lpstrAlias);
}
SEGPTR_FREE(pU);
free(pU);
return res;
}
@ -450,14 +445,14 @@ _MCISTR_determine_timeformat(LPCSTR dev,WORD wDevID,WORD uDevTyp,int *timef)
{
int res;
DWORD dwFlags = MCI_STATUS_ITEM;
MCI_STATUS_PARMS *statusParams = SEGPTR_NEW(MCI_STATUS_PARMS);
MCI_STATUS_PARMS *statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
if (!statusParams) return 0;
statusParams->dwItem = MCI_STATUS_TIME_FORMAT;
statusParams->dwReturn = 0;
_MCI_CALL_DRIVER( MCI_STATUS, SEGPTR_GET(statusParams) );
_MCI_CALL_DRIVER( MCI_STATUS, statusParams );
if (res==0) *timef = statusParams->dwReturn;
SEGPTR_FREE(statusParams);
free(statusParams);
return res;
}
@ -544,7 +539,7 @@ _MCISTR_determine_timeformat(LPCSTR dev,WORD wDevID,WORD uDevTyp,int *timef)
}
static DWORD
MCISTR_Status(_MCISTR_PROTO_) {
MCI_STATUS_PARMS *statusParams = SEGPTR_NEW(MCI_STATUS_PARMS);
MCI_STATUS_PARMS *statusParams = xmalloc(sizeof(MCI_STATUS_PARMS));
int type = 0,i,res,timef;
statusParams->dwCallback = hwndCallback;
@ -626,10 +621,10 @@ MCISTR_Status(_MCISTR_PROTO_) {
if (!statusParams->dwItem)
return MCIERR_MISSING_STRING_ARGUMENT;
_MCI_CALL_DRIVER( MCI_STATUS, SEGPTR_GET(statusParams) );
_MCI_CALL_DRIVER( MCI_STATUS, statusParams );
if (res==0)
_MCISTR_convreturn(type,statusParams->dwReturn,lpstrReturnString,uReturnLength,uDevTyp,timef);
SEGPTR_FREE(statusParams);
free(statusParams);
return res;
}
#undef ITEM1
@ -673,7 +668,7 @@ MCISTR_Set(_MCISTR_PROTO_) {
MCI_WAVE_SET_PARMS16 wavesetParams;
MCI_SEQ_SET_PARMS seqsetParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,res;
pU->setParams.dwCallback = hwndCallback;
@ -829,8 +824,8 @@ MCISTR_Set(_MCISTR_PROTO_) {
}
if (!dwFlags)
return MCIERR_MISSING_STRING_ARGUMENT;
_MCI_CALL_DRIVER( MCI_SET, SEGPTR_GET(pU) );
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_SET, pU );
free(pU);
return res;
}
@ -846,13 +841,12 @@ MCISTR_Set(_MCISTR_PROTO_) {
static DWORD
MCISTR_Break(_MCISTR_PROTO_)
{
MCI_BREAK_PARMS16 *breakParams = SEGPTR_NEW(MCI_BREAK_PARMS16);
MCI_BREAK_PARMS16 *breakParams = xmalloc(sizeof(MCI_BREAK_PARMS16));
int res,i;
if (!breakParams) return 0;
/*breakParams.hwndBreak ? */
for (i = 0; i < nrofkeywords; i++)
{
for (i = 0; i < nrofkeywords; i++) {
FLAG1("off",MCI_BREAK_OFF);
if (!strcmp(keywords[i],"on") && (nrofkeywords>i+1)) {
dwFlags&=~MCI_BREAK_OFF;
@ -862,8 +856,8 @@ MCISTR_Break(_MCISTR_PROTO_)
continue;
}
}
_MCI_CALL_DRIVER( MCI_BREAK, SEGPTR_GET(breakParams) );
SEGPTR_FREE(breakParams);
_MCI_CALL_DRIVER( MCI_BREAK, breakParams );
free(breakParams);
return res;
}
@ -932,7 +926,7 @@ MCISTR_Break(_MCISTR_PROTO_)
*/
static DWORD
MCISTR_Capability(_MCISTR_PROTO_) {
MCI_GETDEVCAPS_PARMS *gdcParams = SEGPTR_NEW(MCI_GETDEVCAPS_PARMS);
MCI_GETDEVCAPS_PARMS *gdcParams = xmalloc(sizeof(MCI_GETDEVCAPS_PARMS));
int type=0,i,res;
gdcParams->dwCallback = hwndCallback;
@ -982,12 +976,12 @@ MCISTR_Capability(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_GETDEVCAPS, SEGPTR_GET(gdcParams) );
_MCI_CALL_DRIVER( MCI_GETDEVCAPS, gdcParams );
/* no timeformat needed */
if (res==0)
_MCISTR_convreturn( type, gdcParams->dwReturn, lpstrReturnString,
uReturnLength, uDevTyp, 0 );
SEGPTR_FREE(gdcParams);
free(gdcParams);
return res;
}
#undef ITEM1
@ -997,10 +991,10 @@ MCISTR_Capability(_MCISTR_PROTO_) {
static DWORD
MCISTR_Resume(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *genParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int res;
genParams->dwCallback = hwndCallback;
_MCI_CALL_DRIVER( MCI_RESUME, SEGPTR_GET(genParams) );
_MCI_CALL_DRIVER( MCI_RESUME, genParams );
return res;
}
@ -1008,10 +1002,10 @@ MCISTR_Resume(_MCISTR_PROTO_)
static DWORD
MCISTR_Pause(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *genParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int res;
genParams->dwCallback = hwndCallback;
_MCI_CALL_DRIVER( MCI_PAUSE, SEGPTR_GET(genParams) );
_MCI_CALL_DRIVER( MCI_PAUSE, genParams );
return res;
}
@ -1019,10 +1013,10 @@ MCISTR_Pause(_MCISTR_PROTO_)
static DWORD
MCISTR_Stop(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *genParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *genParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int res;
genParams->dwCallback = hwndCallback;
_MCI_CALL_DRIVER( MCI_STOP, SEGPTR_GET(genParams) );
_MCI_CALL_DRIVER( MCI_STOP, genParams );
return res;
}
@ -1037,7 +1031,7 @@ static DWORD
MCISTR_Record(_MCISTR_PROTO_) {
int i,res,timef,nrargs,j,k,a[4];
char *parsestr;
MCI_RECORD_PARMS *recordParams = SEGPTR_NEW(MCI_RECORD_PARMS);
MCI_RECORD_PARMS *recordParams = xmalloc(sizeof(MCI_RECORD_PARMS));
res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
if (res) return res;
@ -1096,8 +1090,8 @@ MCISTR_Record(_MCISTR_PROTO_) {
FLAG1("overwrite",MCI_RECORD_OVERWRITE);
i++;
}
_MCI_CALL_DRIVER( MCI_RECORD, SEGPTR_GET(recordParams) );
SEGPTR_FREE(recordParams);
_MCI_CALL_DRIVER( MCI_RECORD, recordParams );
free(recordParams);
return res;
}
@ -1127,7 +1121,7 @@ MCISTR_Play(_MCISTR_PROTO_) {
MCI_VD_PLAY_PARMS vdplayParams;
MCI_ANIM_PLAY_PARMS animplayParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
if (res) return res;
@ -1209,8 +1203,8 @@ MCISTR_Play(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_PLAY, SEGPTR_GET(pU) );
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_PLAY, pU );
free(pU);
return res;
}
@ -1224,7 +1218,7 @@ static DWORD
MCISTR_Seek(_MCISTR_PROTO_) {
int i,res,timef,nrargs,j,k,a[4];
char *parsestr;
MCI_SEEK_PARMS *seekParams = SEGPTR_NEW(MCI_SEEK_PARMS);
MCI_SEEK_PARMS *seekParams = xmalloc(sizeof(MCI_SEEK_PARMS));
res = _MCISTR_determine_timeformat(dev,wDevID,uDevTyp,&timef);
if (res) return res;
@ -1282,8 +1276,8 @@ MCISTR_Seek(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_SEEK, SEGPTR_GET(seekParams) );
SEGPTR_FREE(seekParams);
_MCI_CALL_DRIVER( MCI_SEEK, seekParams );
free(seekParams);
return res;
}
@ -1291,10 +1285,10 @@ MCISTR_Seek(_MCISTR_PROTO_) {
static DWORD
MCISTR_Close(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *closeParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *closeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int res;
_MCI_CALL_DRIVER( MCI_CLOSE, SEGPTR_GET(closeParams) );
SEGPTR_FREE(closeParams);
_MCI_CALL_DRIVER( MCI_CLOSE, closeParams );
free(closeParams);
return res;
}
@ -1310,7 +1304,7 @@ MCISTR_Close(_MCISTR_PROTO_)
static DWORD
MCISTR_Info(_MCISTR_PROTO_)
{
MCI_INFO_PARMS16 *infoParams = SEGPTR_NEW(MCI_INFO_PARMS16);
MCI_INFO_PARMS16 *infoParams = xmalloc(sizeof(MCI_INFO_PARMS16));
DWORD sflags;
int i,res;
@ -1333,15 +1327,13 @@ MCISTR_Info(_MCISTR_PROTO_)
/* MCI driver will fill in lpstrReturn, dwRetSize.
* FIXME: I don't know if this is correct behaviour
*/
_MCI_CALL_DRIVER( MCI_INFO, SEGPTR_GET(infoParams) );
_MCI_CALL_DRIVER( MCI_INFO, infoParams );
if (res==0)
_MCI_STR(infoParams->lpstrReturn);
SEGPTR_FREE(infoParams);
free(infoParams);
return res;
}
DWORD mciSysInfo(DWORD dwFlags,LPMCI_SYSINFO_PARMS16 lpParms);
/* query MCI driver itself for information
* Arguments:
* "installname" return install name of <device> (system.ini)
@ -1350,7 +1342,7 @@ DWORD mciSysInfo(DWORD dwFlags,LPMCI_SYSINFO_PARMS16 lpParms);
* "name <nr>" return nr of devices with <devicetyp>
* "name all" return nr of all devices
*
* FIXME: mciSysInfo() is broken I think.
* FIXME: mciSysInfo16() is broken I think.
*/
static DWORD
MCISTR_Sysinfo(_MCISTR_PROTO_) {
@ -1360,24 +1352,23 @@ MCISTR_Sysinfo(_MCISTR_PROTO_) {
sysinfoParams.lpstrReturn = lpstrReturnString;
sysinfoParams.dwRetSize = uReturnLength;
sysinfoParams.wDeviceType = uDevTyp;
i=0;
while (i<nrofkeywords) {
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+=2;
continue;
}
i++;
}
res=mciSysInfo(dwFlags,&sysinfoParams);
}
res = mciSendCommand(0, MCI_SYSINFO, dwFlags, (DWORD)&sysinfoParams);
if (dwFlags & MCI_SYSINFO_QUANTITY) {
char buf[100];
sprintf(buf,"%ld",*(long*)PTR_SEG_TO_LIN(lpstrReturnString));
sprintf(buf,"%ld",*(long*)lpstrReturnString);
_MCI_STR(buf);
}
/* no need to copy anything back, mciSysInfo did it for us */
@ -1394,7 +1385,7 @@ MCISTR_Load(_MCISTR_PROTO_) {
MCI_LOAD_PARMS16 loadParams;
MCI_OVLY_LOAD_PARMS16 ovlyloadParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,len,res;
char *s;
@ -1416,18 +1407,18 @@ MCISTR_Load(_MCISTR_PROTO_) {
len+=strlen(keywords[i])+1;
i++;
}
s=(char*)SEGPTR_ALLOC(len);
s=(char*)xmalloc(len);
*s='\0';
while (i<nrofkeywords) {
strcat(s,keywords[i]);
i++;
if (i<nrofkeywords) strcat(s," ");
}
pU->loadParams.lpfilename=(LPSTR)SEGPTR_GET(s);
pU->loadParams.lpfilename=s;
dwFlags |= MCI_LOAD_FILE;
_MCI_CALL_DRIVER( MCI_LOAD, SEGPTR_GET(pU) );
SEGPTR_FREE(s);
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_LOAD, pU );
free(s);
free(pU);
return res;
}
@ -1441,7 +1432,7 @@ MCISTR_Save(_MCISTR_PROTO_) {
MCI_SAVE_PARMS saveParams;
MCI_OVLY_SAVE_PARMS16 ovlysaveParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,len,res;
char *s;
@ -1463,18 +1454,18 @@ MCISTR_Save(_MCISTR_PROTO_) {
len+=strlen(keywords[i])+1;
i++;
}
s=(char*)SEGPTR_ALLOC(len);
s=(char*)xmalloc(len);
*s='\0';
while (i<nrofkeywords) {
strcat(s,keywords[i]);
i++;
if (i<nrofkeywords) strcat(s," ");
}
pU->saveParams.lpfilename=(LPSTR)SEGPTR_GET(s);
pU->saveParams.lpfilename=s;
dwFlags |= MCI_LOAD_FILE;
_MCI_CALL_DRIVER( MCI_SAVE, SEGPTR_GET(pU) );
SEGPTR_FREE(s);
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_SAVE, pU );
free(s);
free(pU);
return res;
}
@ -1483,7 +1474,7 @@ MCISTR_Save(_MCISTR_PROTO_) {
*/
static DWORD
MCISTR_Cue(_MCISTR_PROTO_) {
MCI_GENERIC_PARMS *cueParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *cueParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int i,res;
i=0;
@ -1496,8 +1487,8 @@ MCISTR_Cue(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_CUE, SEGPTR_GET(cueParams) );
SEGPTR_FREE(cueParams);
_MCI_CALL_DRIVER( MCI_CUE, cueParams );
free(cueParams);
return res;
}
@ -1506,7 +1497,7 @@ static DWORD
MCISTR_Delete(_MCISTR_PROTO_) {
int timef,nrargs,i,j,k,a[4],res;
char *parsestr;
MCI_WAVE_DELETE_PARMS *deleteParams = SEGPTR_NEW(MCI_WAVE_DELETE_PARMS);
MCI_WAVE_DELETE_PARMS *deleteParams = xmalloc(sizeof(MCI_WAVE_DELETE_PARMS));
/* only implemented for waveform audio */
if (uDevTyp != MCI_DEVTYPE_WAVEFORM_AUDIO)
@ -1564,8 +1555,8 @@ MCISTR_Delete(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_DELETE, SEGPTR_GET(deleteParams) );
SEGPTR_FREE(deleteParams);
_MCI_CALL_DRIVER( MCI_DELETE, deleteParams );
free(deleteParams);
return res;
}
@ -1573,7 +1564,7 @@ MCISTR_Delete(_MCISTR_PROTO_) {
static DWORD
MCISTR_Escape(_MCISTR_PROTO_)
{
MCI_VD_ESCAPE_PARMS16 *escapeParams = SEGPTR_NEW(MCI_VD_ESCAPE_PARMS16);
MCI_VD_ESCAPE_PARMS16 *escapeParams = xmalloc(sizeof(MCI_VD_ESCAPE_PARMS16));
int i,len,res;
char *s;
@ -1584,18 +1575,18 @@ MCISTR_Escape(_MCISTR_PROTO_)
len+=strlen(keywords[i])+1;
i++;
}
s=(char*)SEGPTR_ALLOC(len);
s=(char*)malloc(len);
*s='\0';
while (i<nrofkeywords) {
strcat(s,keywords[i]);
i++;
if (i<nrofkeywords) strcat(s," ");
}
escapeParams->lpstrCommand = (LPSTR)SEGPTR_GET(s);
escapeParams->lpstrCommand = s;
dwFlags |= MCI_VD_ESCAPE_STRING;
_MCI_CALL_DRIVER( MCI_ESCAPE, SEGPTR_GET(escapeParams) );
SEGPTR_FREE(s);
SEGPTR_FREE(escapeParams);
_MCI_CALL_DRIVER( MCI_ESCAPE, escapeParams );
free(s);
free(escapeParams);
return res;
}
@ -1605,7 +1596,7 @@ MCISTR_Escape(_MCISTR_PROTO_)
static DWORD
MCISTR_Unfreeze(_MCISTR_PROTO_)
{
MCI_OVLY_RECT_PARMS16 *unfreezeParams = SEGPTR_NEW(MCI_OVLY_RECT_PARMS16);
MCI_OVLY_RECT_PARMS16 *unfreezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
int i,res;
if (uDevTyp != MCI_DEVTYPE_OVERLAY)
@ -1622,8 +1613,8 @@ MCISTR_Unfreeze(_MCISTR_PROTO_)
}
i++;
}
_MCI_CALL_DRIVER( MCI_UNFREEZE, SEGPTR_GET(unfreezeParams) );
SEGPTR_FREE(unfreezeParams);
_MCI_CALL_DRIVER( MCI_UNFREEZE, unfreezeParams );
free(unfreezeParams);
return res;
}
/* freeze [part of] the overlayed video
@ -1632,7 +1623,7 @@ MCISTR_Unfreeze(_MCISTR_PROTO_)
static DWORD
MCISTR_Freeze(_MCISTR_PROTO_)
{
MCI_OVLY_RECT_PARMS16 *freezeParams = SEGPTR_NEW(MCI_OVLY_RECT_PARMS16);
MCI_OVLY_RECT_PARMS16 *freezeParams = xmalloc(sizeof(MCI_OVLY_RECT_PARMS16));
int i,res;
if (uDevTyp != MCI_DEVTYPE_OVERLAY)
@ -1649,8 +1640,8 @@ MCISTR_Freeze(_MCISTR_PROTO_)
}
i++;
}
_MCI_CALL_DRIVER( MCI_FREEZE, SEGPTR_GET(freezeParams) );
SEGPTR_FREE(freezeParams);
_MCI_CALL_DRIVER( MCI_FREEZE, freezeParams );
free(freezeParams);
return res;
}
@ -1674,7 +1665,7 @@ MCISTR_Put(_MCISTR_PROTO_) {
MCI_OVLY_RECT_PARMS16 ovlyputParams;
MCI_ANIM_RECT_PARMS16 animputParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,res;
i=0;while (i<nrofkeywords) {
switch (uDevTyp) {
@ -1709,8 +1700,8 @@ MCISTR_Put(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_PUT, SEGPTR_GET(pU) );
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_PUT, pU );
free(pU);
return res;
}
@ -1722,7 +1713,7 @@ MCISTR_Put(_MCISTR_PROTO_) {
static DWORD
MCISTR_Realize(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *realizeParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *realizeParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int i,res;
if (uDevTyp != MCI_DEVTYPE_ANIMATION)
@ -1733,8 +1724,8 @@ MCISTR_Realize(_MCISTR_PROTO_)
FLAG1("normal",MCI_ANIM_REALIZE_NORM);
i++;
}
_MCI_CALL_DRIVER( MCI_REALIZE, SEGPTR_GET(realizeParams) );
SEGPTR_FREE(realizeParams);
_MCI_CALL_DRIVER( MCI_REALIZE, realizeParams );
free(realizeParams);
return res;
}
@ -1745,7 +1736,7 @@ MCISTR_Realize(_MCISTR_PROTO_)
static DWORD
MCISTR_Spin(_MCISTR_PROTO_)
{
MCI_GENERIC_PARMS *spinParams = SEGPTR_NEW(MCI_GENERIC_PARMS);
MCI_GENERIC_PARMS *spinParams = xmalloc(sizeof(MCI_GENERIC_PARMS));
int i,res;
if (uDevTyp != MCI_DEVTYPE_VIDEODISC)
@ -1756,8 +1747,8 @@ MCISTR_Spin(_MCISTR_PROTO_)
FLAG1("down",MCI_VD_SPIN_UP);
i++;
}
_MCI_CALL_DRIVER( MCI_SPIN, SEGPTR_GET(spinParams) );
SEGPTR_FREE(spinParams);
_MCI_CALL_DRIVER( MCI_SPIN, spinParams );
free(spinParams);
return res;
}
@ -1771,7 +1762,7 @@ MCISTR_Step(_MCISTR_PROTO_) {
MCI_ANIM_STEP_PARMS animstepParams;
MCI_VD_STEP_PARMS vdstepParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,res;
i=0;
@ -1798,8 +1789,8 @@ MCISTR_Step(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_STEP, SEGPTR_GET(pU) );
SEGPTR_FREE(pU);
_MCI_CALL_DRIVER( MCI_STEP, pU );
free(pU);
return res;
}
@ -1811,7 +1802,7 @@ MCISTR_Step(_MCISTR_PROTO_) {
static DWORD
MCISTR_Update(_MCISTR_PROTO_) {
int i,res;
MCI_ANIM_UPDATE_PARMS16 *updateParams = SEGPTR_NEW(MCI_ANIM_UPDATE_PARMS16);
MCI_ANIM_UPDATE_PARMS16 *updateParams = xmalloc(sizeof(MCI_ANIM_UPDATE_PARMS16));
i=0;
while (i<nrofkeywords) {
@ -1832,8 +1823,8 @@ MCISTR_Update(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_UPDATE, SEGPTR_GET(updateParams) );
SEGPTR_FREE(updateParams);
_MCI_CALL_DRIVER( MCI_UPDATE, updateParams );
free(updateParams);
return res;
}
@ -1852,7 +1843,7 @@ MCISTR_Where(_MCISTR_PROTO_) {
MCI_ANIM_RECT_PARMS16 animwhereParams;
MCI_OVLY_RECT_PARMS16 ovlywhereParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
int i,res;
i=0;
@ -1871,7 +1862,7 @@ MCISTR_Where(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_WHERE, SEGPTR_GET(pU) );
_MCI_CALL_DRIVER( MCI_WHERE, pU );
if (res==0) {
char buf[100];
switch (uDevTyp) {
@ -1895,7 +1886,7 @@ MCISTR_Where(_MCISTR_PROTO_) {
}
_MCI_STR(buf);
}
SEGPTR_FREE(pU);
free(pU);
return res;
}
@ -1907,7 +1898,7 @@ MCISTR_Window(_MCISTR_PROTO_) {
MCI_ANIM_WINDOW_PARMS16 animwindowParams;
MCI_OVLY_WINDOW_PARMS16 ovlywindowParams;
};
union U *pU = SEGPTR_NEW(union U);
union U *pU = xmalloc(sizeof(union U));
s=NULL;
i=0;
@ -2054,9 +2045,9 @@ MCISTR_Window(_MCISTR_PROTO_) {
}
i++;
}
_MCI_CALL_DRIVER( MCI_WINDOW, SEGPTR_GET(pU) );
_MCI_CALL_DRIVER( MCI_WINDOW, pU );
if (s) free(s);
SEGPTR_FREE(pU);
free(pU);
return res;
}
@ -2095,8 +2086,8 @@ struct _MCISTR_cmdtable {
{NULL, NULL}
};
/**************************************************************************
* mciSendString [MMSYSTEM.702]
*/
* mciSendString [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)
@ -2174,12 +2165,12 @@ DWORD WINAPI mciSendString (LPCSTR lpstrCommand, LPSTR lpstrReturnString,
if (STRCMP(cmd,"open")!=0) {
wDevID = MMSYSTEM_FirstDevID();
while (1) {
SEGPTR dname;
LPSTR dname;
dname=(SEGPTR)GetOpenDrv(wDevID)->lpstrAlias;
if (dname==(SEGPTR)NULL)
dname=(SEGPTR)GetOpenDrv(wDevID)->lpstrDeviceType;
if ((dname!=(SEGPTR)NULL)&&(!STRCMP(PTR_SEG_TO_LIN(dname),dev)))
dname=mciGetOpenDrv(wDevID)->lpstrAlias;
if (dname==NULL)
dname=mciGetOpenDrv(wDevID)->lpstrDeviceType;
if (dname != NULL && !STRCMP(dname,dev))
break;
wDevID = MMSYSTEM_NextDevID(wDevID);
if (!MMSYSTEM_DevIDValid(wDevID)) {
@ -2188,7 +2179,7 @@ DWORD WINAPI mciSendString (LPCSTR lpstrCommand, LPSTR lpstrReturnString,
return MCIERR_INVALID_DEVICE_NAME;
}
}
uDevTyp=GetDrv(wDevID)->modp.wType;
uDevTyp=mciGetDrv(wDevID)->modp.wType;
}
for (i=0;MCISTR_cmdtable[i].cmd!=NULL;i++) {

963
multimedia/midi.c
View file

File diff suppressed because it is too large Load diff

756
multimedia/mmsystem.c
View file

File diff suppressed because it is too large Load diff