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

1867 lines
61 KiB
C
Raw Blame History

/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*
* Sample Wine Driver for Open Sound System (featured in Linux and FreeBSD)
*
* Copyright 1994 Martin Ayotte
*/
/*
* FIXME:
* - record/play should and must be done asynchronous
* - segmented/linear pointer problems (lpData in waveheaders,W*_DONE cbs)
*/
#define EMULATE_SB16
#define DEBUG_MCIWAVE
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "windows.h"
#include "user.h"
#include "driver.h"
#include "mmsystem.h"
#include "heap.h"
#include "ldt.h"
#include "debug.h"
#ifdef HAVE_OSS
#ifdef HAVE_MACHINE_SOUNDCARD_H
# include <machine/soundcard.h>
#endif
#ifdef HAVE_SYS_SOUNDCARD_H
# include <sys/soundcard.h>
#endif
#define SOUND_DEV "/dev/dsp"
#define MIXER_DEV "/dev/mixer"
#ifdef SOUND_VERSION
#define IOCTL(a,b,c) ((-1==ioctl(a,b,&c))&&(perror("ioctl:"#b":"#c),0))
#else
#define IOCTL(a,b,c) (c = ioctl(a,b,c) )
#endif
#define MAX_WAVOUTDRV (1)
#define MAX_WAVINDRV (1)
#define MAX_MCIWAVDRV (1)
typedef struct {
int unixdev;
int state;
DWORD bufsize;
WAVEOPENDESC waveDesc;
WORD wFlags;
PCMWAVEFORMAT Format;
LPWAVEHDR lpQueueHdr;
DWORD dwTotalPlayed;
} WINE_WAVEOUT;
typedef struct {
int unixdev;
int state;
DWORD bufsize; /* OpenSound '/dev/dsp' give us that size */
WAVEOPENDESC waveDesc;
WORD wFlags;
PCMWAVEFORMAT Format;
LPWAVEHDR lpQueueHdr;
DWORD dwTotalRecorded;
} 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 */
HMMIO32 hFile; /* mmio file handle open as Element */
MCI_WAVE_OPEN_PARMS16 openParms;
PCMWAVEFORMAT WaveFormat;
WAVEHDR WaveHdr;
BOOL16 fInput; /* FALSE = Output, TRUE = Input */
} WINE_MCIWAVE;
static WINE_WAVEOUT WOutDev[MAX_WAVOUTDRV];
static WINE_WAVEIN WInDev[MAX_WAVOUTDRV];
static WINE_MCIWAVE MCIWavDev[MAX_MCIWAVDRV];
/**************************************************************************
* WAVE_NotifyClient [internal]
*/
static DWORD WAVE_NotifyClient(UINT16 wDevID, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
TRACE(mciwave,"wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",wDevID, wMsg, dwParam1, dwParam2);
switch (wMsg) {
case WOM_OPEN:
case WOM_CLOSE:
case WOM_DONE:
if (wDevID > MAX_WAVOUTDRV) return MCIERR_INTERNAL;
if (WOutDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
WOutDev[wDevID].waveDesc.dwCallBack,
WOutDev[wDevID].wFlags,
WOutDev[wDevID].waveDesc.hWave,
wMsg,
WOutDev[wDevID].waveDesc.dwInstance,
dwParam1,
dwParam2)) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_NOERROR;
}
break;
case WIM_OPEN:
case WIM_CLOSE:
case WIM_DATA:
if (wDevID > MAX_WAVINDRV) return MCIERR_INTERNAL;
if (WInDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
WInDev[wDevID].waveDesc.dwCallBack, WInDev[wDevID].wFlags,
WInDev[wDevID].waveDesc.hWave, wMsg,
WInDev[wDevID].waveDesc.dwInstance, dwParam1, dwParam2)) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_NOERROR;
}
break;
}
return 0;
}
/**************************************************************************
* WAVE_mciOpen [internal]
*/
static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, void* lp, BOOL32 is32)
{
LPPCMWAVEFORMAT lpWaveFormat;
WAVEOPENDESC waveDesc;
DWORD dwRet;
DWORD dwDeviceID;
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 */
/* If the driver was opened shareable before and this open specifies */
/* shareable then increment the use count */
if (MCIWavDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
++MCIWavDev[wDevID].nUseCount;
else
return MCIERR_MUST_USE_SHAREABLE;
} else {
MCIWavDev[wDevID].nUseCount = 1;
MCIWavDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
}
MCIWavDev[wDevID].fInput = FALSE;
TRACE(mciwave,"wDevID=%04X\n", wDevID);
TRACE(mciwave,"before OPEN_ELEMENT\n");
if (dwFlags & MCI_OPEN_ELEMENT) {
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", lpstrElementName);
return MCIERR_FILE_NOT_FOUND;
}
}
else
MCIWavDev[wDevID].hFile = 0;
}
TRACE(mciwave,"hFile=%u\n", MCIWavDev[wDevID].hFile);
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;
if (mmioDescend(MCIWavDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0)
return MCIERR_INTERNAL;
TRACE(mciwave, "ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n",
(LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType,
ckMainRIFF.cksize);
if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
(ckMainRIFF.fccType != mmioFOURCC('W', 'A', 'V', 'E')))
return MCIERR_INTERNAL;
mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');
if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0)
return MCIERR_INTERNAL;
TRACE(mciwave, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
mmckInfo.cksize);
if (mmioRead32(MCIWavDev[wDevID].hFile, (HPSTR) lpWaveFormat,
(long) sizeof(PCMWAVEFORMAT)) != (long) sizeof(PCMWAVEFORMAT))
return MCIERR_INTERNAL;
mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');
if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0)
return MCIERR_INTERNAL;
TRACE(mciwave,"Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n",
(LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType,
mmckInfo.cksize);
TRACE(mciwave, "nChannels=%d nSamplesPerSec=%ld\n",
lpWaveFormat->wf.nChannels, lpWaveFormat->wf.nSamplesPerSec);
lpWaveFormat->wBitsPerSample = 0;
}
lpWaveFormat->wf.nAvgBytesPerSec =
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;
}
/**************************************************************************
* WAVE_mciCue [internal]
*/
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
MCI_WAVE_INPUT flag. No explicit check on MCI_WAVE_OUTPUT is done since that
is the default.
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 ? */
if (MCIWavDev[wDevID].hFile != 0) {
mmioClose32(MCIWavDev[wDevID].hFile, 0);
MCIWavDev[wDevID].hFile = 0;
}
dwRet = MMSYSERR_NOERROR; /* assume success */
if ((dwParam & MCI_WAVE_INPUT) && !MCIWavDev[wDevID].fInput) {
/* 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);
if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
dwRet = widMessage(wDevID, WIDM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
MCIWavDev[wDevID].fInput = TRUE;
}
else if (MCIWavDev[wDevID].fInput) {
/* 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);
if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
dwRet = wodMessage(wDevID, WODM_OPEN, 0, (DWORD)&waveDesc, CALLBACK_NULL);
MCIWavDev[wDevID].fInput = FALSE;
}
return dwRet;
}
/**************************************************************************
* WAVE_mciClose [internal]
*/
static DWORD WAVE_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
{
DWORD dwRet;
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwParam, lpParms);
MCIWavDev[wDevID].nUseCount--;
if (MCIWavDev[wDevID].nUseCount == 0) {
if (MCIWavDev[wDevID].hFile != 0) {
mmioClose32(MCIWavDev[wDevID].hFile, 0);
MCIWavDev[wDevID].hFile = 0;
}
if (MCIWavDev[wDevID].fInput)
dwRet = widMessage(wDevID, WIDM_CLOSE, 0, 0L, 0L);
else
dwRet = wodMessage(wDevID, WODM_CLOSE, 0, 0L, 0L);
if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
}
return 0;
}
/**************************************************************************
* WAVE_mciPlay [internal]
*/
static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
{
int start, end;
LONG bufsize, count;
HGLOBAL16 hData;
LPWAVEHDR lpWaveHdr;
DWORD dwRet;
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (MCIWavDev[wDevID].fInput) {
WARN(mciwave, "cannot play on input device\n");
return MCIERR_NONAPPLICABLE_FUNCTION;
}
if (MCIWavDev[wDevID].hFile == 0) {
WARN(mciwave, "can't find file='%08lx' !\n",
MCIWavDev[wDevID].openParms.lpstrElementName);
return MCIERR_FILE_NOT_FOUND;
}
start = 1; end = 99999;
if (dwFlags & MCI_FROM) {
start = lpParms->dwFrom;
TRACE(mciwave, "MCI_FROM=%d \n", start);
}
if (dwFlags & MCI_TO) {
end = lpParms->dwTo;
TRACE(mciwave,"MCI_TO=%d \n", end);
}
#if 0
if (dwFlags & MCI_NOTIFY) {
TRACE(mciwave, "MCI_NOTIFY %08lX !\n", lpParms->dwCallback);
switch(fork()) {
case -1:
WARN(mciwave, "Can't 'fork' process !\n");
break;
case 0:
break;
default:
TRACE(mciwave,"process started ! return to caller...\n");
return 0;
}
}
#endif
bufsize = 64000;
lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
lpWaveHdr->lpData = (LPSTR) GlobalLock16(hData);
lpWaveHdr->dwUser = 0L;
lpWaveHdr->dwFlags = 0L;
lpWaveHdr->dwLoops = 0L;
dwRet=wodMessage(wDevID,WODM_PREPARE,0,(DWORD)lpWaveHdr,sizeof(WAVEHDR));
while(TRUE) {
count = mmioRead32(MCIWavDev[wDevID].hFile, lpWaveHdr->lpData, bufsize);
TRACE(mciwave,"mmioRead bufsize=%ld count=%ld\n", bufsize, count);
if (count < 1) break;
lpWaveHdr->dwBufferLength = 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));
}
dwRet = wodMessage(wDevID,WODM_UNPREPARE,0,(DWORD)lpWaveHdr,sizeof(WAVEHDR));
if (lpWaveHdr->lpData != NULL) {
GlobalUnlock16(hData);
GlobalFree16(hData);
lpWaveHdr->lpData = NULL;
}
if (dwFlags & MCI_NOTIFY) {
TRACE(mciwave,"MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
}
return 0;
}
/**************************************************************************
* WAVE_mciRecord [internal]
*/
static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
{
int start, end;
LONG bufsize;
HGLOBAL16 hData;
LPWAVEHDR lpWaveHdr;
DWORD dwRet;
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (!MCIWavDev[wDevID].fInput) {
WARN(mciwave, "cannot record on output device\n");
return MCIERR_NONAPPLICABLE_FUNCTION;
}
if (MCIWavDev[wDevID].hFile == 0) {
WARN(mciwave, "can't find file='%08lx' !\n",
MCIWavDev[wDevID].openParms.lpstrElementName);
return MCIERR_FILE_NOT_FOUND;
}
start = 1; end = 99999;
if (dwFlags & MCI_FROM) {
start = lpParms->dwFrom;
TRACE(mciwave, "MCI_FROM=%d \n", start);
}
if (dwFlags & MCI_TO) {
end = lpParms->dwTo;
TRACE(mciwave,"MCI_TO=%d \n", end);
}
bufsize = 64000;
lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize);
lpWaveHdr->lpData = (LPSTR)GlobalLock16(hData);
lpWaveHdr->dwBufferLength = bufsize;
lpWaveHdr->dwUser = 0L;
lpWaveHdr->dwFlags = 0L;
lpWaveHdr->dwLoops = 0L;
dwRet=widMessage(wDevID,WIDM_PREPARE,0,(DWORD)lpWaveHdr,sizeof(WAVEHDR));
TRACE(mciwave,"after WIDM_PREPARE \n");
while(TRUE) {
lpWaveHdr->dwBytesRecorded = 0;
dwRet = widMessage(wDevID, WIDM_START, 0, 0L, 0L);
TRACE(mciwave, "after WIDM_START lpWaveHdr=%p dwBytesRecorded=%lu\n",
lpWaveHdr, lpWaveHdr->dwBytesRecorded);
if (lpWaveHdr->dwBytesRecorded == 0) break;
}
TRACE(mciwave,"before WIDM_UNPREPARE \n");
dwRet = widMessage(wDevID,WIDM_UNPREPARE,0,(DWORD)lpWaveHdr,sizeof(WAVEHDR));
TRACE(mciwave,"after WIDM_UNPREPARE \n");
if (lpWaveHdr->lpData != NULL) {
GlobalUnlock16(hData);
GlobalFree16(hData);
lpWaveHdr->lpData = NULL;
}
if (dwFlags & MCI_NOTIFY) {
TRACE(mciwave,"MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
}
return 0;
}
/**************************************************************************
* WAVE_mciStop [internal]
*/
static DWORD WAVE_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
DWORD dwRet;
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
if (MCIWavDev[wDevID].fInput)
dwRet = widMessage(wDevID, WIDM_STOP, 0, dwFlags, (DWORD)lpParms);
else
dwRet = wodMessage(wDevID, WODM_STOP, 0, dwFlags, (DWORD)lpParms);
return dwRet;
}
/**************************************************************************
* WAVE_mciPause [internal]
*/
static DWORD WAVE_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
DWORD dwRet;
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
if (MCIWavDev[wDevID].fInput)
dwRet = widMessage(wDevID, WIDM_PAUSE, 0, dwFlags, (DWORD)lpParms);
else
dwRet = wodMessage(wDevID, WODM_PAUSE, 0, dwFlags, (DWORD)lpParms);
return dwRet;
}
/**************************************************************************
* WAVE_mciResume [internal]
*/
static DWORD WAVE_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
{
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
return 0;
}
/**************************************************************************
* WAVE_mciSet [internal]
*/
static DWORD WAVE_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
{
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
TRACE(mciwave, "dwTimeFormat=%08lX\n", lpParms->dwTimeFormat);
TRACE(mciwave, "dwAudio=%08lX\n", lpParms->dwAudio);
if (dwFlags & MCI_SET_TIME_FORMAT) {
switch (lpParms->dwTimeFormat) {
case MCI_FORMAT_MILLISECONDS:
TRACE(mciwave, "MCI_FORMAT_MILLISECONDS !\n");
break;
case MCI_FORMAT_BYTES:
TRACE(mciwave, "MCI_FORMAT_BYTES !\n");
break;
case MCI_FORMAT_SAMPLES:
TRACE(mciwave, "MCI_FORMAT_SAMPLES !\n");
break;
default:
WARN(mciwave, "bad time format !\n");
return MCIERR_BAD_TIME_FORMAT;
}
}
if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_SET_AUDIO)
TRACE(mciwave,"MCI_SET_AUDIO !\n");
if (dwFlags && MCI_SET_ON) {
TRACE(mciwave,"MCI_SET_ON !\n");
if (dwFlags && MCI_SET_AUDIO_LEFT)
TRACE(mciwave,"MCI_SET_AUDIO_LEFT !\n");
if (dwFlags && MCI_SET_AUDIO_RIGHT)
TRACE(mciwave,"MCI_SET_AUDIO_RIGHT !\n");
}
if (dwFlags & MCI_SET_OFF)
TRACE(mciwave,"MCI_SET_OFF !\n");
if (dwFlags & MCI_WAVE_INPUT)
TRACE(mciwave,"MCI_WAVE_INPUT !\n");
if (dwFlags & MCI_WAVE_OUTPUT)
TRACE(mciwave,"MCI_WAVE_OUTPUT !\n");
if (dwFlags & MCI_WAVE_SET_ANYINPUT)
TRACE(mciwave,"MCI_WAVE_SET_ANYINPUT !\n");
if (dwFlags & MCI_WAVE_SET_ANYOUTPUT)
TRACE(mciwave,"MCI_WAVE_SET_ANYOUTPUT !\n");
if (dwFlags & MCI_WAVE_SET_AVGBYTESPERSEC)
TRACE(mciwave, "MCI_WAVE_SET_AVGBYTESPERSEC !\n");
if (dwFlags & MCI_WAVE_SET_BITSPERSAMPLE)
TRACE(mciwave, "MCI_WAVE_SET_BITSPERSAMPLE !\n");
if (dwFlags & MCI_WAVE_SET_BLOCKALIGN)
TRACE(mciwave,"MCI_WAVE_SET_BLOCKALIGN !\n");
if (dwFlags & MCI_WAVE_SET_CHANNELS)
TRACE(mciwave,"MCI_WAVE_SET_CHANNELS !\n");
if (dwFlags & MCI_WAVE_SET_FORMATTAG)
TRACE(mciwave,"MCI_WAVE_SET_FORMATTAG !\n");
if (dwFlags & MCI_WAVE_SET_SAMPLESPERSEC)
TRACE(mciwave, "MCI_WAVE_SET_SAMPLESPERSEC !\n");
return 0;
}
/**************************************************************************
* WAVE_mciStatus [internal]
*/
static DWORD WAVE_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
{
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
if (dwFlags & MCI_STATUS_ITEM) {
switch(lpParms->dwItem) {
case MCI_STATUS_CURRENT_TRACK:
lpParms->dwReturn = 1;
break;
case MCI_STATUS_LENGTH:
lpParms->dwReturn = 5555;
if (dwFlags & MCI_TRACK) {
lpParms->dwTrack = 1;
lpParms->dwReturn = 2222;
}
break;
case MCI_STATUS_MODE:
lpParms->dwReturn = MCI_MODE_STOP;
break;
case MCI_STATUS_MEDIA_PRESENT:
TRACE(mciwave,"MCI_STATUS_MEDIA_PRESENT !\n");
lpParms->dwReturn = TRUE;
break;
case MCI_STATUS_NUMBER_OF_TRACKS:
lpParms->dwReturn = 1;
break;
case MCI_STATUS_POSITION:
lpParms->dwReturn = 3333;
if (dwFlags & MCI_STATUS_START)
lpParms->dwItem = 1;
if (dwFlags & MCI_TRACK) {
lpParms->dwTrack = 1;
lpParms->dwReturn = 777;
}
break;
case MCI_STATUS_READY:
TRACE(mciwave,"MCI_STATUS_READY !\n");
lpParms->dwReturn = TRUE;
break;
case MCI_STATUS_TIME_FORMAT:
TRACE(mciwave,"MCI_STATUS_TIME_FORMAT !\n");
lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
break;
case MCI_WAVE_INPUT:
TRACE(mciwave,"MCI_WAVE_INPUT !\n");
lpParms->dwReturn = 0;
break;
case MCI_WAVE_OUTPUT:
TRACE(mciwave,"MCI_WAVE_OUTPUT !\n");
lpParms->dwReturn = 0;
break;
case MCI_WAVE_STATUS_AVGBYTESPERSEC:
TRACE(mciwave,"MCI_WAVE_STATUS_AVGBYTESPERSEC !\n");
lpParms->dwReturn = 22050;
break;
case MCI_WAVE_STATUS_BITSPERSAMPLE:
TRACE(mciwave,"MCI_WAVE_STATUS_BITSPERSAMPLE !\n");
lpParms->dwReturn = 8;
break;
case MCI_WAVE_STATUS_BLOCKALIGN:
TRACE(mciwave,"MCI_WAVE_STATUS_BLOCKALIGN !\n");
lpParms->dwReturn = 1;
break;
case MCI_WAVE_STATUS_CHANNELS:
TRACE(mciwave,"MCI_WAVE_STATUS_CHANNELS !\n");
lpParms->dwReturn = 1;
break;
case MCI_WAVE_STATUS_FORMATTAG:
TRACE(mciwave,"MCI_WAVE_FORMATTAG !\n");
lpParms->dwReturn = WAVE_FORMAT_PCM;
break;
case MCI_WAVE_STATUS_LEVEL:
TRACE(mciwave,"MCI_WAVE_STATUS_LEVEL !\n");
lpParms->dwReturn = 0xAAAA5555;
break;
case MCI_WAVE_STATUS_SAMPLESPERSEC:
TRACE(mciwave,"MCI_WAVE_STATUS_SAMPLESPERSEC !\n");
lpParms->dwReturn = 22050;
break;
default:
WARN(mciwave,"unknown command %08lX !\n", lpParms->dwItem);
return MCIERR_UNRECOGNIZED_COMMAND;
}
}
if (dwFlags & MCI_NOTIFY) {
TRACE(mciwave,"MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback),
MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
}
return 0;
}
/**************************************************************************
* WAVE_mciGetDevCaps [internal]
*/
static DWORD WAVE_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags,
LPMCI_GETDEVCAPS_PARMS lpParms)
{
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
if (dwFlags & MCI_GETDEVCAPS_ITEM) {
switch(lpParms->dwItem) {
case MCI_GETDEVCAPS_CAN_RECORD:
lpParms->dwReturn = TRUE;
break;
case MCI_GETDEVCAPS_HAS_AUDIO:
lpParms->dwReturn = TRUE;
break;
case MCI_GETDEVCAPS_HAS_VIDEO:
lpParms->dwReturn = FALSE;
break;
case MCI_GETDEVCAPS_DEVICE_TYPE:
lpParms->dwReturn = MCI_DEVTYPE_WAVEFORM_AUDIO;
break;
case MCI_GETDEVCAPS_USES_FILES:
lpParms->dwReturn = TRUE;
break;
case MCI_GETDEVCAPS_COMPOUND_DEVICE:
lpParms->dwReturn = TRUE;
break;
case MCI_GETDEVCAPS_CAN_EJECT:
lpParms->dwReturn = FALSE;
break;
case MCI_GETDEVCAPS_CAN_PLAY:
lpParms->dwReturn = TRUE;
break;
case MCI_GETDEVCAPS_CAN_SAVE:
lpParms->dwReturn = TRUE;
break;
case MCI_WAVE_GETDEVCAPS_INPUTS:
lpParms->dwReturn = 1;
break;
case MCI_WAVE_GETDEVCAPS_OUTPUTS:
lpParms->dwReturn = 1;
break;
default:
return MCIERR_UNRECOGNIZED_COMMAND;
}
}
return 0;
}
/**************************************************************************
* WAVE_mciInfo [internal]
*/
static DWORD WAVE_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpParms)
{
TRACE(mciwave, "(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
lpParms->lpstrReturn = NULL;
switch(dwFlags) {
case MCI_INFO_PRODUCT:
lpParms->lpstrReturn = "Open Sound System 0.5";
break;
case MCI_INFO_FILE:
lpParms->lpstrReturn =
(LPSTR)MCIWavDev[wDevID].openParms.lpstrElementName;
break;
case MCI_WAVE_INPUT:
lpParms->lpstrReturn = "Open Sound System 0.5";
break;
case MCI_WAVE_OUTPUT:
lpParms->lpstrReturn = "Open Sound System 0.5";
break;
default:
return MCIERR_UNRECOGNIZED_COMMAND;
}
if (lpParms->lpstrReturn != NULL)
lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
else
lpParms->dwRetSize = 0;
return 0;
}
/*-----------------------------------------------------------------------*/
/**************************************************************************
* wodGetDevCaps [internal]
*/
static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPS16 lpCaps, DWORD dwSize)
{
int audio;
int smplrate;
int samplesize = 16;
int dsp_stereo = 1;
int bytespersmpl;
TRACE(mciwave, "(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED;
audio = open (SOUND_DEV, O_WRONLY, 0);
if (audio == -1) return MMSYSERR_ALLOCATED ;
#ifdef EMULATE_SB16
lpCaps->wMid = 0x0002;
lpCaps->wPid = 0x0104;
strcpy(lpCaps->szPname, "SB16 Wave Out");
#else
lpCaps->wMid = 0x00FF; /* Manufac ID */
lpCaps->wPid = 0x0001; /* Product ID */
strcpy(lpCaps->szPname, "OpenSoundSystem WAVOUT Driver");
#endif
lpCaps->vDriverVersion = 0x0100;
lpCaps->dwFormats = 0x00000000;
lpCaps->dwSupport = WAVECAPS_VOLUME;
/* First bytespersampl, then stereo */
bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
if (lpCaps->wChannels > 1) lpCaps->dwSupport |= WAVECAPS_LRVOLUME;
smplrate = 44100;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_4M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_4S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_4M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_4S16;
}
}
smplrate = 22050;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_2M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_2S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_2M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_2S16;
}
}
smplrate = 11025;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_1M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_1S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_1M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_1S16;
}
}
close(audio);
TRACE(mciwave, "dwFormats = %08lX\n", lpCaps->dwFormats);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodOpen [internal]
*/
static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
{
int audio,abuf_size,smplrate,samplesize,dsp_stereo;
LPWAVEFORMAT lpFormat;
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
if (lpDesc == NULL) {
WARN(mciwave, "Invalid Parameter !\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= MAX_WAVOUTDRV) {
TRACE(mciwave,"MAX_WAVOUTDRV reached !\n");
return MMSYSERR_ALLOCATED;
}
WOutDev[wDevID].unixdev = 0;
if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED;
audio = open (SOUND_DEV, O_WRONLY, 0);
if (audio == -1) {
WARN(mciwave, "can't open !\n");
return MMSYSERR_ALLOCATED ;
}
IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
if (abuf_size < 1024 || abuf_size > 65536) {
if (abuf_size == -1)
WARN(mciwave, "IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
else
WARN(mciwave, "SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
return MMSYSERR_NOTENABLED;
}
WOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
switch(WOutDev[wDevID].wFlags) {
case DCB_NULL:
TRACE(mciwave, "CALLBACK_NULL !\n");
break;
case DCB_WINDOW:
TRACE(mciwave, "CALLBACK_WINDOW !\n");
break;
case DCB_TASK:
TRACE(mciwave, "CALLBACK_TASK !\n");
break;
case DCB_FUNCTION:
TRACE(mciwave, "CALLBACK_FUNCTION !\n");
break;
}
WOutDev[wDevID].lpQueueHdr = NULL;
WOutDev[wDevID].unixdev = audio;
WOutDev[wDevID].dwTotalPlayed = 0;
WOutDev[wDevID].bufsize = abuf_size;
/* FIXME: copy lpFormat too? */
memcpy(&WOutDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
TRACE(mciwave,"lpDesc->lpFormat = %p\n",lpDesc->lpFormat);
lpFormat = lpDesc->lpFormat;
TRACE(mciwave,"lpFormat = %p\n",lpFormat);
if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
WARN(mciwave,"Bad format %04X !\n",
lpFormat->wFormatTag);
WARN(mciwave,"Bad nChannels %d !\n",
lpFormat->nChannels);
WARN(mciwave,"Bad nSamplesPerSec %ld !\n",
lpFormat->nSamplesPerSec);
return WAVERR_BADFORMAT;
}
memcpy(&WOutDev[wDevID].Format, lpFormat, sizeof(PCMWAVEFORMAT));
if (WOutDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
if (WOutDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
TRACE(mciwave,"wBitsPerSample=%u !\n",
WOutDev[wDevID].Format.wBitsPerSample);
if (WOutDev[wDevID].Format.wBitsPerSample == 0) {
WOutDev[wDevID].Format.wBitsPerSample = 8 *
(WOutDev[wDevID].Format.wf.nAvgBytesPerSec /
WOutDev[wDevID].Format.wf.nSamplesPerSec) /
WOutDev[wDevID].Format.wf.nChannels;
}
samplesize = WOutDev[wDevID].Format.wBitsPerSample;
smplrate = WOutDev[wDevID].Format.wf.nSamplesPerSec;
dsp_stereo = (WOutDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
/* First size and stereo then samplerate */
IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
TRACE(mciwave,"wBitsPerSample=%u !\n",
WOutDev[wDevID].Format.wBitsPerSample);
TRACE(mciwave,"nAvgBytesPerSec=%lu !\n",
WOutDev[wDevID].Format.wf.nAvgBytesPerSec);
TRACE(mciwave,"nSamplesPerSec=%lu !\n",
WOutDev[wDevID].Format.wf.nSamplesPerSec);
TRACE(mciwave,"nChannels=%u !\n",
WOutDev[wDevID].Format.wf.nChannels);
if (WAVE_NotifyClient(wDevID, WOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodClose [internal]
*/
static DWORD wodClose(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (wDevID > MAX_WAVOUTDRV) return MMSYSERR_INVALPARAM;
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't close !\n");
return MMSYSERR_NOTENABLED;
}
if (WOutDev[wDevID].lpQueueHdr != NULL) {
WARN(mciwave, "still buffers open !\n");
/* Don't care. Who needs those buffers anyway */
/*return WAVERR_STILLPLAYING; */
}
close(WOutDev[wDevID].unixdev);
WOutDev[wDevID].unixdev = 0;
WOutDev[wDevID].bufsize = 0;
WOutDev[wDevID].lpQueueHdr = NULL;
if (WAVE_NotifyClient(wDevID, WOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodWrite [internal]
* FIXME: this should _APPEND_ the lpWaveHdr to the output queue of the
* device, and initiate async playing.
*/
static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
int count;
LPSTR lpData;
LPWAVEHDR xwavehdr;
TRACE(mciwave,"(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't play !\n");
return MMSYSERR_NOTENABLED;
}
if (lpWaveHdr->lpData == NULL) return WAVERR_UNPREPARED;
if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) return WAVERR_UNPREPARED;
if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
lpWaveHdr->dwFlags &= ~WHDR_DONE;
lpWaveHdr->dwFlags |= WHDR_INQUEUE;
TRACE(mciwave, "dwBufferLength %lu !\n",
lpWaveHdr->dwBufferLength);
TRACE(mciwave, "WOutDev[%u].unixdev %u !\n",
wDevID, WOutDev[wDevID].unixdev);
lpData = lpWaveHdr->lpData;
count = write (WOutDev[wDevID].unixdev, lpData, lpWaveHdr->dwBufferLength);
TRACE(mciwave,"write returned count %u !\n",count);
if (count != lpWaveHdr->dwBufferLength) {
WARN(mciwave, " error writting !\n");
return MMSYSERR_NOTENABLED;
}
WOutDev[wDevID].dwTotalPlayed += count;
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
if ((DWORD)lpWaveHdr->lpData!=lpWaveHdr->reserved) {
/* FIXME: what if it expects it's OWN lpwavehdr back? */
xwavehdr = SEGPTR_NEW(WAVEHDR);
memcpy(xwavehdr,lpWaveHdr,sizeof(WAVEHDR));
xwavehdr->lpData = (LPBYTE)xwavehdr->reserved;
if (WAVE_NotifyClient(wDevID, WOM_DONE, (DWORD)SEGPTR_GET(xwavehdr), count) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
SEGPTR_FREE(xwavehdr);
return MMSYSERR_INVALPARAM;
}
SEGPTR_FREE(xwavehdr);
} else {
if (WAVE_NotifyClient(wDevID, WOM_DONE, (DWORD)lpWaveHdr, count) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodPrepare [internal]
*/
static DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't prepare !\n");
return MMSYSERR_NOTENABLED;
}
/* don't append to queue, wodWrite does that */
WOutDev[wDevID].dwTotalPlayed = 0;
if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
return WAVERR_STILLPLAYING;
lpWaveHdr->dwFlags |= WHDR_PREPARED;
lpWaveHdr->dwFlags &= ~WHDR_DONE;
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodUnprepare [internal]
*/
static DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't unprepare !\n");
return MMSYSERR_NOTENABLED;
}
if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
return WAVERR_STILLPLAYING;
lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
lpWaveHdr->dwFlags |= WHDR_DONE;
TRACE(mciwave, "all headers unprepared !\n");
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodRestart [internal]
*/
static DWORD wodRestart(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't restart !\n");
return MMSYSERR_NOTENABLED;
}
/* FIXME: is NotifyClient with WOM_DONE right ? (Comet Busters 1.3.3 needs this notification) */
/* FIXME: Myst crashes with this ... hmm -MM
if (WAVE_NotifyClient(wDevID, WOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
*/
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodReset [internal]
*/
static DWORD wodReset(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't reset !\n");
return MMSYSERR_NOTENABLED;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodGetPosition [internal]
*/
static DWORD wodGetPosition(WORD wDevID, LPMMTIME16 lpTime, DWORD uSize)
{
int time;
TRACE(mciwave,"(%u, %p, %lu);\n", wDevID, lpTime, uSize);
if (WOutDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't get pos !\n");
return MMSYSERR_NOTENABLED;
}
if (lpTime == NULL) return MMSYSERR_INVALPARAM;
TRACE(mciwave,"wType=%04X !\n",
lpTime->wType);
TRACE(mciwave,"wBitsPerSample=%u\n",
WOutDev[wDevID].Format.wBitsPerSample);
TRACE(mciwave,"nSamplesPerSec=%lu\n",
WOutDev[wDevID].Format.wf.nSamplesPerSec);
TRACE(mciwave,"nChannels=%u\n",
WOutDev[wDevID].Format.wf.nChannels);
TRACE(mciwave,"nAvgBytesPerSec=%lu\n",
WOutDev[wDevID].Format.wf.nAvgBytesPerSec);
switch(lpTime->wType) {
case TIME_BYTES:
lpTime->u.cb = WOutDev[wDevID].dwTotalPlayed;
TRACE(mciwave,"TIME_BYTES=%lu\n", lpTime->u.cb);
break;
case TIME_SAMPLES:
TRACE(mciwave,"dwTotalPlayed=%lu\n",
WOutDev[wDevID].dwTotalPlayed);
TRACE(mciwave,"wBitsPerSample=%u\n",
WOutDev[wDevID].Format.wBitsPerSample);
lpTime->u.sample = WOutDev[wDevID].dwTotalPlayed * 8 /
WOutDev[wDevID].Format.wBitsPerSample;
TRACE(mciwave,"TIME_SAMPLES=%lu\n", lpTime->u.sample);
break;
case TIME_SMPTE:
time = WOutDev[wDevID].dwTotalPlayed /
(WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
lpTime->u.smpte.hour = time / 108000;
time -= lpTime->u.smpte.hour * 108000;
lpTime->u.smpte.min = time / 1800;
time -= lpTime->u.smpte.min * 1800;
lpTime->u.smpte.sec = time / 30;
time -= lpTime->u.smpte.sec * 30;
lpTime->u.smpte.frame = time;
lpTime->u.smpte.fps = 30;
TRACE(mciwave,
"wodGetPosition // TIME_SMPTE=%02u:%02u:%02u:%02u\n",
lpTime->u.smpte.hour, lpTime->u.smpte.min,
lpTime->u.smpte.sec, lpTime->u.smpte.frame);
break;
default:
FIXME(mciwave, "wodGetPosition() format %d not supported ! use TIME_MS !\n",lpTime->wType);
lpTime->wType = TIME_MS;
case TIME_MS:
lpTime->u.ms = WOutDev[wDevID].dwTotalPlayed /
(WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
TRACE(mciwave,"wodGetPosition // TIME_MS=%lu\n", lpTime->u.ms);
break;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodGetVolume [internal]
*/
static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
{
int mixer;
int volume, left, right;
TRACE(mciwave,"(%u, %p);\n", wDevID, lpdwVol);
if (lpdwVol == NULL) return MMSYSERR_NOTENABLED;
if ((mixer = open(MIXER_DEV, O_RDONLY)) < 0) {
WARN(mciwave, "mixer device not available !\n");
return MMSYSERR_NOTENABLED;
}
if (ioctl(mixer, SOUND_MIXER_READ_PCM, &volume) == -1) {
WARN(mciwave, "unable read mixer !\n");
return MMSYSERR_NOTENABLED;
}
close(mixer);
left = volume & 0x7F;
right = (volume >> 8) & 0x7F;
TRACE(mciwave,"left=%d right=%d !\n", left, right);
*lpdwVol = MAKELONG(left << 9, right << 9);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodSetVolume [internal]
*/
static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
{
int mixer;
int volume;
TRACE(mciwave,"(%u, %08lX);\n", wDevID, dwParam);
volume = (LOWORD(dwParam) >> 9 & 0x7F) +
((HIWORD(dwParam) >> 9 & 0x7F) << 8);
if ((mixer = open(MIXER_DEV, O_WRONLY)) < 0) {
WARN(mciwave, "mixer device not available !\n");
return MMSYSERR_NOTENABLED;
}
if (ioctl(mixer, SOUND_MIXER_WRITE_PCM, &volume) == -1) {
WARN(mciwave, "unable set mixer !\n");
return MMSYSERR_NOTENABLED;
}
close(mixer);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* wodMessage [sample driver]
*/
DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
int audio;
TRACE(mciwave,"wodMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
wDevID, wMsg, dwUser, dwParam1, dwParam2);
switch(wMsg) {
case WODM_OPEN:
return wodOpen(wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
case WODM_CLOSE:
return wodClose(wDevID);
case WODM_WRITE:
return wodWrite(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WODM_PAUSE:
return MMSYSERR_NOTSUPPORTED;
case WODM_STOP:
return MMSYSERR_NOTSUPPORTED;
case WODM_GETPOS:
return wodGetPosition(wDevID, (LPMMTIME16)dwParam1, dwParam2);
case WODM_BREAKLOOP:
return MMSYSERR_NOTSUPPORTED;
case WODM_PREPARE:
return wodPrepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WODM_UNPREPARE:
return wodUnprepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WODM_GETDEVCAPS:
return wodGetDevCaps(wDevID,(LPWAVEOUTCAPS16)dwParam1,dwParam2);
case WODM_GETNUMDEVS:
/* FIXME: For now, only one sound device (SOUND_DEV) is allowed */
audio = open (SOUND_DEV, O_WRONLY, 0);
if (audio == -1)
if (errno == EBUSY)
return 1;
else
return 0;
close (audio);
return 1;
case WODM_GETPITCH:
return MMSYSERR_NOTSUPPORTED;
case WODM_SETPITCH:
return MMSYSERR_NOTSUPPORTED;
case WODM_GETPLAYBACKRATE:
return MMSYSERR_NOTSUPPORTED;
case WODM_SETPLAYBACKRATE:
return MMSYSERR_NOTSUPPORTED;
case WODM_GETVOLUME:
return wodGetVolume(wDevID, (LPDWORD)dwParam1);
case WODM_SETVOLUME:
return wodSetVolume(wDevID, dwParam1);
case WODM_RESTART:
return wodRestart(wDevID);
case WODM_RESET:
return wodReset(wDevID);
default:
WARN(mciwave,"unknown message !\n");
}
return MMSYSERR_NOTSUPPORTED;
}
/*-----------------------------------------------------------------------*/
/**************************************************************************
* widGetDevCaps [internal]
*/
static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPS16 lpCaps, DWORD dwSize)
{
int audio,smplrate,samplesize=16,dsp_stereo=1,bytespersmpl;
TRACE(mciwave, "(%u, %p, %lu);\n", wDevID, lpCaps, dwSize);
if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED;
audio = open (SOUND_DEV, O_RDONLY, 0);
if (audio == -1) return MMSYSERR_ALLOCATED ;
#ifdef EMULATE_SB16
lpCaps->wMid = 0x0002;
lpCaps->wPid = 0x0004;
strcpy(lpCaps->szPname, "SB16 Wave In");
#else
lpCaps->wMid = 0x00FF; /* Manufac ID */
lpCaps->wPid = 0x0001; /* Product ID */
strcpy(lpCaps->szPname, "OpenSoundSystem WAVIN Driver");
#endif
lpCaps->dwFormats = 0x00000000;
lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
smplrate = 44100;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_4M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_4S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_4M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_4S16;
}
}
smplrate = 22050;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_2M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_2S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_2M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_2S16;
}
}
smplrate = 11025;
if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
lpCaps->dwFormats |= WAVE_FORMAT_1M08;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_1S08;
if (bytespersmpl > 1) {
lpCaps->dwFormats |= WAVE_FORMAT_1M16;
if (lpCaps->wChannels > 1)
lpCaps->dwFormats |= WAVE_FORMAT_1S16;
}
}
close(audio);
TRACE(mciwave, "dwFormats = %08lX\n", lpCaps->dwFormats);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widOpen [internal]
*/
static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
{
int audio,abuf_size,smplrate,samplesize,dsp_stereo;
LPWAVEFORMAT lpFormat;
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpDesc, dwFlags);
if (lpDesc == NULL) {
WARN(mciwave, "Invalid Parameter !\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= MAX_WAVINDRV) {
TRACE(mciwave,"MAX_WAVINDRV reached !\n");
return MMSYSERR_ALLOCATED;
}
WInDev[wDevID].unixdev = 0;
if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED;
audio = open (SOUND_DEV, O_RDONLY, 0);
if (audio == -1) {
WARN(mciwave,"can't open !\n");
return MMSYSERR_ALLOCATED;
}
IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
if (abuf_size < 1024 || abuf_size > 65536) {
if (abuf_size == -1)
WARN(mciwave, "IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
else
WARN(mciwave, "SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
return MMSYSERR_NOTENABLED;
}
WInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
switch(WInDev[wDevID].wFlags) {
case DCB_NULL:
TRACE(mciwave,"CALLBACK_NULL!\n");
break;
case DCB_WINDOW:
TRACE(mciwave,"CALLBACK_WINDOW!\n");
break;
case DCB_TASK:
TRACE(mciwave,"CALLBACK_TASK!\n");
break;
case DCB_FUNCTION:
TRACE(mciwave,"CALLBACK_FUNCTION!\n");
break;
}
if (WInDev[wDevID].lpQueueHdr) {
HeapFree(GetProcessHeap(),0,WInDev[wDevID].lpQueueHdr);
WInDev[wDevID].lpQueueHdr = NULL;
}
WInDev[wDevID].unixdev = audio;
WInDev[wDevID].bufsize = abuf_size;
WInDev[wDevID].dwTotalRecorded = 0;
memcpy(&WInDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
lpFormat = (LPWAVEFORMAT) lpDesc->lpFormat;
if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
WARN(mciwave, "Bad format %04X !\n",
lpFormat->wFormatTag);
return WAVERR_BADFORMAT;
}
memcpy(&WInDev[wDevID].Format, lpFormat, sizeof(PCMWAVEFORMAT));
WInDev[wDevID].Format.wBitsPerSample = 8; /* <-------------- */
if (WInDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
if (WInDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
if (WInDev[wDevID].Format.wBitsPerSample == 0) {
WInDev[wDevID].Format.wBitsPerSample = 8 *
(WInDev[wDevID].Format.wf.nAvgBytesPerSec /
WInDev[wDevID].Format.wf.nSamplesPerSec) /
WInDev[wDevID].Format.wf.nChannels;
}
samplesize = WInDev[wDevID].Format.wBitsPerSample;
smplrate = WInDev[wDevID].Format.wf.nSamplesPerSec;
dsp_stereo = (WInDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
TRACE(mciwave,"wBitsPerSample=%u !\n",
WInDev[wDevID].Format.wBitsPerSample);
TRACE(mciwave,"nSamplesPerSec=%lu !\n",
WInDev[wDevID].Format.wf.nSamplesPerSec);
TRACE(mciwave,"nChannels=%u !\n",
WInDev[wDevID].Format.wf.nChannels);
TRACE(mciwave,"nAvgBytesPerSec=%lu\n",
WInDev[wDevID].Format.wf.nAvgBytesPerSec);
if (WAVE_NotifyClient(wDevID, WIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
WARN(mciwave,"can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widClose [internal]
*/
static DWORD widClose(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (wDevID > MAX_WAVINDRV) return MMSYSERR_INVALPARAM;
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't close !\n");
return MMSYSERR_NOTENABLED;
}
if (WInDev[wDevID].lpQueueHdr != NULL) {
WARN(mciwave, "still buffers open !\n");
return WAVERR_STILLPLAYING;
}
close(WInDev[wDevID].unixdev);
WInDev[wDevID].unixdev = 0;
WInDev[wDevID].bufsize = 0;
if (WAVE_NotifyClient(wDevID, WIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
WARN(mciwave,"can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widAddBuffer [internal]
*/
static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
int count = 1;
LPWAVEHDR lpWIHdr;
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't do it !\n");
return MMSYSERR_NOTENABLED;
}
if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
TRACE(mciwave, "never been prepared !\n");
return WAVERR_UNPREPARED;
}
if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
TRACE(mciwave, "header already in use !\n");
return WAVERR_STILLPLAYING;
}
lpWaveHdr->dwFlags |= WHDR_PREPARED;
lpWaveHdr->dwFlags |= WHDR_INQUEUE;
lpWaveHdr->dwFlags &= ~WHDR_DONE;
lpWaveHdr->dwBytesRecorded = 0;
if (WInDev[wDevID].lpQueueHdr == NULL) {
WInDev[wDevID].lpQueueHdr = lpWaveHdr;
} else {
lpWIHdr = WInDev[wDevID].lpQueueHdr;
while (lpWIHdr->lpNext != NULL) {
lpWIHdr = lpWIHdr->lpNext;
count++;
}
lpWIHdr->lpNext = lpWaveHdr;
lpWaveHdr->lpNext = NULL;
count++;
}
TRACE(mciwave, "buffer added ! (now %u in queue)\n", count);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widPrepare [internal]
*/
static DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't prepare !\n");
return MMSYSERR_NOTENABLED;
}
if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
return WAVERR_STILLPLAYING;
lpWaveHdr->dwFlags |= WHDR_PREPARED;
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags &= ~WHDR_DONE;
lpWaveHdr->dwBytesRecorded = 0;
TRACE(mciwave,"header prepared !\n");
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widUnprepare [internal]
*/
static DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
{
TRACE(mciwave, "(%u, %p, %08lX);\n", wDevID, lpWaveHdr, dwSize);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't unprepare !\n");
return MMSYSERR_NOTENABLED;
}
lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
lpWaveHdr->dwFlags |= WHDR_DONE;
TRACE(mciwave, "all headers unprepared !\n");
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widStart [internal]
*/
static DWORD widStart(WORD wDevID)
{
int count = 1;
int bytesRead;
LPWAVEHDR lpWIHdr;
LPWAVEHDR *lpWaveHdr;
TRACE(mciwave,"(%u);\n", wDevID);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave, "can't start recording !\n");
return MMSYSERR_NOTENABLED;
}
lpWaveHdr = &(WInDev[wDevID].lpQueueHdr);
TRACE(mciwave,"lpWaveHdr = %08lx\n",(DWORD)lpWaveHdr);
if (!*lpWaveHdr || !(*lpWaveHdr)->lpData) {
TRACE(mciwave,"never been prepared !\n");
return WAVERR_UNPREPARED;
}
while(*lpWaveHdr != NULL) {
lpWIHdr = *lpWaveHdr;
TRACE(mciwave, "recording buf#%u=%p size=%lu \n",
count, lpWIHdr->lpData, lpWIHdr->dwBufferLength);
fflush(stddeb);
bytesRead = read (WInDev[wDevID].unixdev,
lpWIHdr->lpData,
lpWIHdr->dwBufferLength);
if (bytesRead==-1)
perror("read from audio device");
TRACE(mciwave,"bytesread=%d (%ld)\n",
bytesRead,lpWIHdr->dwBufferLength);
lpWIHdr->dwBytesRecorded = bytesRead;
WInDev[wDevID].dwTotalRecorded += lpWIHdr->dwBytesRecorded;
lpWIHdr->dwFlags &= ~WHDR_INQUEUE;
lpWIHdr->dwFlags |= WHDR_DONE;
/* FIXME: should pass segmented pointer here, do we need that?*/
if (WAVE_NotifyClient(wDevID, WIM_DATA, (DWORD)lpWaveHdr, lpWIHdr->dwBytesRecorded) != MMSYSERR_NOERROR) {
WARN(mciwave, "can't notify client !\n");
return MMSYSERR_INVALPARAM;
}
/* removes the current block from the queue */
*lpWaveHdr = lpWIHdr->lpNext;
count++;
}
TRACE(mciwave,"end of recording !\n");
fflush(stddeb);
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widStop [internal]
*/
static DWORD widStop(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't stop !\n");
return MMSYSERR_NOTENABLED;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widReset [internal]
*/
static DWORD widReset(WORD wDevID)
{
TRACE(mciwave,"(%u);\n", wDevID);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't reset !\n");
return MMSYSERR_NOTENABLED;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widGetPosition [internal]
*/
static DWORD widGetPosition(WORD wDevID, LPMMTIME16 lpTime, DWORD uSize)
{
int time;
TRACE(mciwave, "(%u, %p, %lu);\n", wDevID, lpTime, uSize);
if (WInDev[wDevID].unixdev == 0) {
WARN(mciwave,"can't get pos !\n");
return MMSYSERR_NOTENABLED;
}
if (lpTime == NULL) return MMSYSERR_INVALPARAM;
TRACE(mciwave,"wType=%04X !\n",
lpTime->wType);
TRACE(mciwave,"wBitsPerSample=%u\n",
WInDev[wDevID].Format.wBitsPerSample);
TRACE(mciwave,"nSamplesPerSec=%lu\n",
WInDev[wDevID].Format.wf.nSamplesPerSec);
TRACE(mciwave,"nChannels=%u\n",
WInDev[wDevID].Format.wf.nChannels);
TRACE(mciwave,"nAvgBytesPerSec=%lu\n",
WInDev[wDevID].Format.wf.nAvgBytesPerSec);
fflush(stddeb);
switch(lpTime->wType) {
case TIME_BYTES:
lpTime->u.cb = WInDev[wDevID].dwTotalRecorded;
TRACE(mciwave,"TIME_BYTES=%lu\n", lpTime->u.cb);
break;
case TIME_SAMPLES:
lpTime->u.sample = WInDev[wDevID].dwTotalRecorded * 8 /
WInDev[wDevID].Format.wBitsPerSample;
TRACE(mciwave, "TIME_SAMPLES=%lu\n", lpTime->u.sample);
break;
case TIME_SMPTE:
time = WInDev[wDevID].dwTotalRecorded /
(WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
lpTime->u.smpte.hour = time / 108000;
time -= lpTime->u.smpte.hour * 108000;
lpTime->u.smpte.min = time / 1800;
time -= lpTime->u.smpte.min * 1800;
lpTime->u.smpte.sec = time / 30;
time -= lpTime->u.smpte.sec * 30;
lpTime->u.smpte.frame = time;
lpTime->u.smpte.fps = 30;
TRACE(mciwave,"TIME_SMPTE=%02u:%02u:%02u:%02u\n",
lpTime->u.smpte.hour, lpTime->u.smpte.min,
lpTime->u.smpte.sec, lpTime->u.smpte.frame);
break;
default:
FIXME(mciwave, "format not supported ! use TIME_MS !\n");
lpTime->wType = TIME_MS;
case TIME_MS:
lpTime->u.ms = WInDev[wDevID].dwTotalRecorded /
(WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
TRACE(mciwave, "TIME_MS=%lu\n", lpTime->u.ms);
break;
}
return MMSYSERR_NOERROR;
}
/**************************************************************************
* widMessage [sample driver]
*/
DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
int audio;
TRACE(mciwave,"widMessage(%u, %04X, %08lX, %08lX, %08lX);\n",
wDevID, wMsg, dwUser, dwParam1, dwParam2);
switch(wMsg) {
case WIDM_OPEN:
return widOpen(wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
case WIDM_CLOSE:
return widClose(wDevID);
case WIDM_ADDBUFFER:
return widAddBuffer(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WIDM_PREPARE:
return widPrepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WIDM_UNPREPARE:
return widUnprepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
case WIDM_GETDEVCAPS:
return widGetDevCaps(wDevID, (LPWAVEINCAPS16)dwParam1,dwParam2);
case WIDM_GETNUMDEVS:
/* FIXME: For now, only one sound device (SOUND_DEV) is allowed */
audio = open (SOUND_DEV, O_RDONLY, 0);
if (audio == -1)
if (errno == EBUSY)
return 1;
else
return 0;
close (audio);
return 1;
case WIDM_GETPOS:
return widGetPosition(wDevID, (LPMMTIME16)dwParam1, dwParam2);
case WIDM_RESET:
return widReset(wDevID);
case WIDM_START:
return widStart(wDevID);
case WIDM_PAUSE:
return widStop(wDevID);
case WIDM_STOP:
return widStop(wDevID);
default:
WARN(mciwave,"unknown message !\n");
}
return MMSYSERR_NOTSUPPORTED;
}
/**************************************************************************
* WAVE_DriverProc16 [sample driver]
*/
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 MCI_OPEN_DRIVER:
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;
default:
return DefDriverProc16(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 DefDriverProc32(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
return MMSYSERR_NOTENABLED;
}
#else /* !HAVE_OSS */
/**************************************************************************
* wodMessage [sample driver]
*/
DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
FIXME(mciwave,"(%u, %04X, %08lX, %08lX, %08lX):stub\n",
wDevID, wMsg, dwUser, dwParam1, dwParam2);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* widMessage [sample driver]
*/
DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
FIXME(mciwave,"(%u, %04X, %08lX, %08lX, %08lX):stub\n",
wDevID, wMsg, dwUser, dwParam1, dwParam2);
return MMSYSERR_NOTENABLED;
}
/**************************************************************************
* WAVE_DriverProc16 [sample driver]
*/
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;
}
#endif /* HAVE_OSS */
Reference in New Issue View Git Blame Copy Permalink