/* oss.c
*
* Open Sound System Sound Devicee
*
* $Id: oss.c,v 1.11 1996/11/09 21:08:04 jpaana Exp $
*
* Copyright 1996 Petteri Kangaslampi and Jarno Paananen
*
* This file is part of the MIDAS Sound System, and may only be
* used, modified and distributed under the terms of the MIDAS
* Sound System license, LICENSE.TXT. By continuing to use,
* modify or distribute this file you indicate that you have
* read the license and understand and accept it fully.
*/
#include <stdio.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/soundcard.h>
#include "lang.h"
#include "mtypes.h"
#include "errors.h"
#include "sdevice.h"
#include "mmem.h"
#include "dsm.h"
#include "mglobals.h"
RCSID(char const *oss_rcsid = "$Id: oss.c,v 1.11 1996/11/09 21:08:04 jpaana Exp $";)
#define DEVICE_NAME "/dev/dsp"
#define open_mode O_WRONLY
static int audio_fd;
static int format_16bits = AFMT_S16_LE;
static int format_8bits = AFMT_U8;
static int format_stereo;
static int format_mixingrate;
static audio_buf_info info;
static uchar *audioBuffer;
static int audioBufferSize;
/* Make that "e" smaller (to c or even a) if you have small DMA buffer */
static int numFragments = 0xffff000e;
//#define DUMPBUFFER
#define OSSVERSION 1.02
#define OSSVERSTR "1.02"
/* Number of bits of accuracy in mixing for 8-bit output: */
#define MIX8BITS 12
/* Sound Device information */
/* Sound Card names: */
static char *ossCardName = "Unix Sound System output";
/* Sound Device internal static variables */
static unsigned mixRate, outputMode;
static unsigned mixElemSize;
static unsigned amplification;
static unsigned updateMix; /* number of elements to mix between
two updates */
static unsigned mixLeft; /* number of elements to mix before
next update */
static unsigned bufferPos; /* mixing position inside buffer */
static uchar *ppTable; /* post-processing table for 8-bit
output */
#ifdef DUMPBUFFER
static FILE *buff;
#endif
/****************************************************************************\
* enum ossFunctIDs
* -----------------
* Description: ID numbers for OSS Sound Device functions
\****************************************************************************/
enum ossFunctIDs
{
ID_ossDetect = ID_oss,
ID_ossInit,
ID_ossClose,
ID_ossGetMode,
ID_ossOpenChannels,
ID_ossSetAmplification,
ID_ossGetAmplification,
ID_ossSetUpdRate,
ID_ossStartPlay,
ID_ossPlay
};
/* Local prototypes: */
int CALLING ossSetAmplification(unsigned _amplification);
int CALLING ossGetAmplification(unsigned *_amplification);
int CALLING ossSetUpdRate(unsigned updRate);
/****************************************************************************\
*
* Function: static unsigned CALLING (*postProc)(unsigned numElements,
* uchar *bufStart, unsigned mixPos, unsigned *mixBuffer,
* uchar *ppTable);
*
* Description: Pointer to the actual post-processing routine. Takes
* DSM output elements from dsmMixBuffer and writes them to
* output buffer at *bufStart in a format suitable for the Sound
* Device.
*
* Input: unsigned numElements number of elements to process
* (guaranteed to be even)
* uchar *bufStart pointer to start of output buffer
* unsigned mixPos mixing position in output buffer
* unsigned *mixBuffer source mixing buffer
* uchar *ppTable pointer to post-processing table
*
* Returns: New mixing position in output buffer. Can not fail.
*
\****************************************************************************/
static unsigned CALLING (*postProc)(unsigned numElements, uchar *bufStart,
unsigned mixPos, unsigned *mixBuffer, uchar *ppTable);
/****************************************************************************\
*
* Function: unsigned pp16Mono();
*
* Description: 16-bit mono post-processing routine
*
\****************************************************************************/
unsigned CALLING pp16Mono(unsigned numElements, uchar *bufStart,
unsigned mixPos, unsigned *mixBuffer, uchar *ppTable);
/****************************************************************************\
*
* Function: unsigned pp8Mono();
*
* Description: 8-bit mono post-processing routine
*
\****************************************************************************/
unsigned CALLING pp8Mono(unsigned numElements, uchar *bufStart,
unsigned mixPos, unsigned *mixBuffer, uchar *ppTable);
/****************************************************************************\
*
* Function: unsigned pp16Stereo();
*
* Description: 16-bit stereo post-processing routine
*
\****************************************************************************/
unsigned CALLING pp16Stereo(unsigned numElements, uchar *bufStart,
unsigned mixPos, unsigned *mixBuffer, uchar *ppTable);
/****************************************************************************\
*
* Function: unsigned pp8Stereo();
*
* Description: 8-bit stereo post-processing routine
*
\****************************************************************************/
unsigned CALLING pp8Stereo(unsigned numElements, uchar *bufStart,
unsigned mixPos, unsigned *mixBuffer, uchar *ppTable);
/****************************************************************************\
*
* Function: int ossDetect(int *result)
*
* Description: Detects a OSS Sound Device
*
* Input: int *result pointer to detection result
*
* Returns: MIDAS error code. Detection result (1 if detected, 0 if not)
* is written to *result.
*
* Notes: OSS Sound Device is always detected.
*
\****************************************************************************/
int CALLING ossDetect(int *result)
{
*result = 1;
return OK;
}
/****************************************************************************\
*
* Function: int ossInit(unsigned mixRate, unsigned mode)
*
* Description: Initializes OSS Sound Device
*
* Input: unsigned mixRate mixing rate in Hz
* unsigned mode output mode
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING ossInit(unsigned _mixRate, unsigned mode)
{
int error;
int mixMode;
int *modetag;
mixRate = _mixRate;
/* Determine the actual output mode: */
if ( mode & sdMono )
format_stereo = 0;
else
format_stereo = 1;
if ( mode & sd8bit )
modetag = &format_8bits;
else
modetag = &format_16bits;
/* Open output device using the format just set up: */
if (( audio_fd = open(DEVICE_NAME, open_mode, 0 )) == -1 )
{
perror(DEVICE_NAME);
return errDeviceNotAvailable;
}
if ( ((int)mode = ioctl(audio_fd, SNDCTL_DSP_SETFMT, modetag)) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_SETFMT");
return(errSDFailure);
}
if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &format_stereo) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_STEREO");
return(errSDFailure);
}
if (format_stereo)
outputMode = sdStereo;
else
outputMode = sdMono;
if ( *modetag == AFMT_U8 )
outputMode |= sd8bit;
else
{
if ( *modetag == AFMT_S16_LE )
outputMode |= sd16bit;
else
return(errSDFailure);
}
format_mixingrate = mixRate;
if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &format_mixingrate) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_SPEED");
return(errSDFailure);
}
mixRate = format_mixingrate;
/* Calculate one mixing element size: */
if ( outputMode & sd16bit )
mixElemSize = 2;
else
mixElemSize = 1;
if ( outputMode & sdStereo )
mixElemSize <<= 1;
/* Allocate memory for post-processing table if necessary: */
if ( outputMode & sd8bit )
{
/* Allocate memory for 8-bit output mode post-processing table: */
if ( (error = memAlloc((1 << MIX8BITS), (void**)&ppTable)) != OK )
PASSERROR(ID_ossInit);
}
else
ppTable = NULL;
/* Check correct mixing mode: */
if ( outputMode & sdStereo )
mixMode = dsmMixStereo;
else
mixMode = dsmMixMono;
/* Initialize Digital Sound Mixer: */
if ( outputMode & sd16bit )
{
if ( (error = dsmInit(mixRate, mixMode, 16)) != OK )
PASSERROR(ID_ossInit)
}
else
{
if ( (error = dsmInit(mixRate, mixMode, MIX8BITS)) != OK )
PASSERROR(ID_ossInit)
}
/* Set update rate to 50Hz: */
if ( (error = ossSetUpdRate(5000)) != OK )
PASSERROR(ID_ossInit)
/* Allocate memory for audiobuffer: */
if (ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &numFragments) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_SETFRAGMENT");
return(errSDFailure);
}
if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_GETOSPACE");
return(errSDFailure);
}
// printf("Fragment size: %i, total fragments: %i\n", info.fragsize, info.fragstotal);
// audioBufferSize = mixRate * mixElemSize * mBufferLength / 1000;
audioBufferSize = dsmMixBufferSize;
// audioBufferSize = info.fragsize;
if ( (error = memAlloc(audioBufferSize, (void**)&audioBuffer)) != OK )
PASSERROR(ID_ossInit);
/* Point postProc() to correct post-processing routine: */
switch ( outputMode )
{
case (sd16bit | sdMono):
postProc = &pp16Mono;
break;
case (sd8bit | sdMono):
postProc = &pp8Mono;
break;
case (sd16bit | sdStereo):
postProc = &pp16Stereo;
break;
case (sd8bit | sdStereo):
postProc = &pp8Stereo;
break;
default:
ERROR(errInvalidArguments, ID_ossInit);
return errInvalidArguments;
}
amplification = 64;
#ifdef DUMPBUFFER
buff = fopen("buffer.raw", "wb");
#endif
return OK;
}
/****************************************************************************\
*
* Function: ossClose(void)
*
* Description: Uninitializes OSS Sound Device
*
* Returns: MIDAS error code
*
\****************************************************************************/
int ossClose(void)
{
int error;
#ifdef DUMPBUFFER
fclose(buff);
#endif
/* Uninitialize Digital Sound Mixer: */
if ( (error = dsmClose()) != OK )
PASSERROR(ID_ossClose)
/* Deallocate post-processing table if necessary: */
if ( outputMode & sd8bit )
{
if ( (error = memFree(ppTable)) != OK )
PASSERROR(ID_ossClose);
}
/* Deallocate audio buffer */
if ( (error = memFree(audioBuffer)) != OK )
PASSERROR(ID_ossClose);
close(audio_fd);
return OK;
}
/****************************************************************************\
*
* Function: int ossGetMode(unsigned *mode)
*
* Description: Reads the current output mode
*
* Input: unsigned *mode pointer to output mode
*
* Returns: MIDAS error code. Output mode is written to *mode.
*
\****************************************************************************/
int CALLING ossGetMode(unsigned *mode)
{
*mode = outputMode;
return OK;
}
/****************************************************************************\
*
* Function: int ossOpenChannels(unsigned channels)
*
* Description: Opens sound channels for output. Prepares post-processing
* tables, takes care of default amplification and finally opens
* DSM channels. Channels can be closed by simply calling
* dsmCloseChannels().
*
* Input: unsigned channels number of channels to open
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING ossOpenChannels(unsigned channels)
{
int error;
/* Open DSM channels: */
if ( (error = dsmOpenChannels(channels)) != OK )
PASSERROR(ID_ossOpenChannels)
/* Take care of default amplification and calculate new post-processing
table if necessary: */
if ( channels < 5 )
ossSetAmplification(64);
else
ossSetAmplification(14*channels);
return OK;
}
/****************************************************************************\
*
* Function: void CalcPP8Table(void)
*
* Description: Calculates a new 8-bit output post-processing table using
* current amplification level
*
\****************************************************************************/
static void CalcPP8Table(void)
{
uchar *tbl;
int val;
long temp;
tbl = ppTable; /* tbl points to current table pos */
/* Calculate post-processing table for all possible DSM values:
(table must be used with unsigned numbers - add (1 << MIX8BITS)/2 to
DSM output values first) */
for ( val = -(1 << MIX8BITS)/2; val < (1 << MIX8BITS)/2; val++ )
{
/* Calculate 8-bit unsigned output value corresponding to the
current DSM output value (val), taking amplification into
account: */
temp = 128 + ((((long) amplification) * ((long) val) / 64L) >>
(MIX8BITS-8));
/* Clip the value to fit between 0 and 255 inclusive: */
if ( temp < 0 )
temp = 0;
if ( temp > 255 )
temp = 255;
/* Write the value to the post-processing table: */
*(tbl++) = (uchar) temp;
}
}
/****************************************************************************\
*
* Function: int ossSetAmplification(unsigned amplification)
*
* Description: Sets the amplification level. Calculates new post-processing
* tables and calls dsmSetAmplification() as necessary.
*
* Input: unsigned amplification amplification value
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING ossSetAmplification(unsigned _amplification)
{
int error;
amplification = _amplification;
if ( outputMode & sd8bit )
{
/* 8-bit output mode - do not set amplification level using DSM,
but calculate a new post-processing table instead: */
CalcPP8Table();
}
else
{
/* Set amplification level to DSM: */
if ( (error = dsmSetAmplification(amplification)) != OK )
PASSERROR(ID_ossSetAmplification)
}
return OK;
}
/****************************************************************************\
*
* Function: int ossGetAmplification(unsigned *amplification);
*
* Description: Reads the current amplification level. (DSM doesn't
* necessarily know the actual amplification level if
* post-processing takes care of amplification)
*
* Input: unsigned *amplification pointer to amplification level
*
* Returns: MIDAS error code. Amplification level is written to
* *amplification.
*
\****************************************************************************/
int CALLING ossGetAmplification(unsigned *_amplification)
{
*_amplification = amplification;
return OK;
}
/****************************************************************************\
*
* Function: int ossSetUpdRate(unsigned updRate);
*
* Description: Sets the channel value update rate (depends on song tempo)
*
* Input: unsigned updRate update rate in 100*Hz (eg. 50Hz
* becomes 5000).
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING ossSetUpdRate(unsigned updRate)
{
/* Calculate number of elements to mix between two updates: (even) */
mixLeft = updateMix = ((unsigned) ((100L * (ulong) mixRate) /
((ulong) updRate)) + 1) & 0xFFFFFFFE;
return OK;
}
/****************************************************************************\
*
* Function: int ossStartPlay(void)
*
* Description: Prepares for playing - doesn't actually do anything here...
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING ossStartPlay(void)
{
return OK;
}
/****************************************************************************\
*
* Function: int ossPlay(int *callMP);
*
* Description: Plays the sound - mixes the correct amount of data with DSM
* and copies it to output buffer with post-processing.
* Also takes care of sending fully mixed buffer to the
* output device.
*
* Input: int *callMP pointer to music player calling flag
*
* Returns: MIDAS error code. If enough data was mixed for one updating
* round and music player should be called, 1 is written to
* *callMP, otherwise 0 is written there. Note that if music
* player can be called, ossPlay() should be called again
* with a new check for music playing to ensure the mixing buffer
* gets filled with new data.
*
\****************************************************************************/
int CALLING ossPlay(int *callMP)
{
int error;
unsigned bufferLeft, numElems;
unsigned dsmBufSize;
// uchar *temp;
if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info) == -1)
{ /* Fatal error */
perror("SNDCTL_DSP_GETOSPACE");
return(errSDFailure);
}
// printf("avail frags: %i\n", info.fragments);
if ( info.fragments == 0 )
{
*callMP = 0;
return OK;
}
/* Calculate DSM mixing buffer size in elements: (FIXME) */
dsmBufSize = dsmMixBufferSize;
dsmBufSize >>= 2;
if ( outputMode & sdStereo )
dsmBufSize >>= 1;
/* Calculate number of bytes of buffer left: */
bufferLeft = audioBufferSize - bufferPos;
/* Calculate number of mixing elements left: */
numElems = bufferLeft / mixElemSize;
/* Check that we won't mix more data than there is to the next
update: */
if ( numElems > mixLeft )
numElems = mixLeft;
/* Check that we won't mix more data than fits to DSM mixing
buffer: */
if ( numElems > dsmBufSize )
numElems = dsmBufSize;
/* Decrease number of elements before next update: */
mixLeft -= numElems;
/* Mix the data to DSM mixing buffer: */
if ( (error = dsmMixData(numElems)) != OK )
PASSERROR(ID_ossPlay)
/* Write the mixed data to output buffer: */
bufferPos = postProc(numElems, audioBuffer, 0,
dsmMixBuffer, ppTable);
#ifdef DUMPBUFFER
fwrite(&audioBuffer[oldPos], numElems * mixElemSize, 1, buff);
#endif
/* Check if the buffer is full - if so, write it to the output
device and start over: */
write(audio_fd, audioBuffer, bufferPos);
/* Check if the music player should be called: */
if ( mixLeft == 0)
{
mixLeft = updateMix;
*callMP = 1;
return OK;
}
/* No more data fits to the mixing buffers - just return without
update: */
*callMP = 0;
return OK;
}
/* OSS Sound Device structure: */
SoundDevice OSS = {
0, /* tempoPoll = 0 */
sdUseMixRate | sdUseOutputMode | sdUseDSM, /* configBits */
0, /* port */
0, /* IRQ */
0, /* DMA */
1, /* cardType */
1, /* numCardTypes */
sdMono | sdStereo | sd8bit | sd16bit, /* modes */
"Open Sound System Sound Device " OSSVERSTR, /* name */
&ossCardName, /* cardNames */
0, /* numPortAddresses */
NULL, /* portAddresses */
&ossDetect,
&ossInit,
&ossClose,
&dsmGetMixRate,
&ossGetMode,
&ossOpenChannels,
&dsmCloseChannels,
&dsmClearChannels,
&dsmMute,
&dsmPause,
&dsmSetMasterVolume,
&dsmGetMasterVolume,
&ossSetAmplification,
&ossGetAmplification,
&dsmPlaySound,
&dsmReleaseSound,
&dsmStopSound,
&dsmSetRate,
&dsmGetRate,
&dsmSetVolume,
&dsmGetVolume,
&dsmSetSample,
&dsmGetSample,
&dsmSetPosition,
&dsmGetPosition,
&dsmGetDirection,
&dsmSetPanning,
&dsmGetPanning,
&dsmMuteChannel,
&dsmAddSample,
&dsmRemoveSample,
&ossSetUpdRate,
&ossStartPlay,
&ossPlay
};
/*
* $Log: oss.c,v $
* Revision 1.11 1996/11/09 21:08:04 jpaana
* Fixed some "comparison between signed and unsigned" warnings
*
* Revision 1.10 1996/09/22 17:11:56 jpaana
* Still tweaking...
*
* Revision 1.9 1996/09/21 17:18:01 jpaana
* Misc Fixes
*
* Revision 1.8 1996/09/21 16:40:26 jpaana
* Fixed some typos
*
* Revision 1.7 1996/09/21 16:38:00 jpaana
* Renamed to Open Sound System Sound Device (blah)
*
* Revision 1.6 1996/09/15 09:18:28 jpaana
* Removed some debug texts
*
* Revision 1.5 1996/09/09 09:52:12 jpaana
* Added some more fragments
*
* Revision 1.4 1996/09/08 20:32:32 jpaana
* Misc. tweaking (most commented out now)
*
* Revision 1.3 1996/08/03 13:16:42 jpaana
* Fixed to work without Pthreads ;)
*
* Revision 1.1 1996/06/05 19:40:35 jpaana
* Initial revision
*
* Revision 1.2 1996/05/25 15:49:57 jpaana
* Cleaned up
*
* Revision 1.1 1996/05/24 20:40:12 jpaana
* Initial revision
*
*
*/
