645 lines
14 KiB
C++
645 lines
14 KiB
C++
/* fhandler_dev_dsp: code to emulate OSS sound model /dev/dsp
|
|
|
|
Copyright 2001 Red Hat, Inc
|
|
|
|
Written by Andy Younger (andy@snoogie.demon.co.uk)
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include "cygerrno.h"
|
|
#include "fhandler.h"
|
|
#include <windows.h>
|
|
#include <sys/soundcard.h>
|
|
#include <sys/fcntl.h>
|
|
#include <mmsystem.h>
|
|
|
|
//------------------------------------------------------------------------
|
|
// Simple encapsulation of the win32 audio device.
|
|
//
|
|
static void CALLBACK wave_callback (HWAVE hWave, UINT msg, DWORD instance,
|
|
DWORD param1, DWORD param2);
|
|
class Audio
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
MAX_BLOCKS = 12,
|
|
BLOCK_SIZE = 16384,
|
|
TOT_BLOCK_SIZE = BLOCK_SIZE + sizeof (WAVEHDR)
|
|
};
|
|
|
|
Audio ();
|
|
~Audio ();
|
|
|
|
bool open (int rate, int bits, int channels, bool bCallback = false);
|
|
void close ();
|
|
int getvolume ();
|
|
void setvolume (int newVolume);
|
|
bool write (const void *pSampleData, int nBytes);
|
|
int blocks ();
|
|
void callback_sampledone (void *pData);
|
|
void setformat (int format) {formattype_ = format;}
|
|
int numbytesoutput ();
|
|
|
|
void *operator new (size_t, void *p) {return p;}
|
|
|
|
private:
|
|
char *initialisebuffer ();
|
|
void waitforcallback ();
|
|
bool flush ();
|
|
|
|
HWAVEOUT dev_;
|
|
volatile int nBlocksInQue_;
|
|
int nBytesWritten_;
|
|
char *buffer_;
|
|
int bufferIndex_;
|
|
CRITICAL_SECTION lock_;
|
|
char *freeblocks_[MAX_BLOCKS];
|
|
int formattype_;
|
|
|
|
char bigwavebuffer_[MAX_BLOCKS * TOT_BLOCK_SIZE];
|
|
};
|
|
|
|
static char audio_buf[sizeof (class Audio)];
|
|
|
|
Audio::Audio ()
|
|
{
|
|
InitializeCriticalSection (&lock_);
|
|
memset (bigwavebuffer_, 0, sizeof (bigwavebuffer_));
|
|
for (int i = 0; i < MAX_BLOCKS; i++)
|
|
freeblocks_[i] = &bigwavebuffer_[i * TOT_BLOCK_SIZE];
|
|
}
|
|
|
|
Audio::~Audio ()
|
|
{
|
|
if (dev_)
|
|
close ();
|
|
DeleteCriticalSection (&lock_);
|
|
}
|
|
|
|
bool
|
|
Audio::open (int rate, int bits, int channels, bool bCallback = false)
|
|
{
|
|
WAVEFORMATEX format;
|
|
int nDevices = waveOutGetNumDevs ();
|
|
|
|
nBytesWritten_ = 0L;
|
|
bufferIndex_ = 0;
|
|
buffer_ = 0L;
|
|
debug_printf ("number devices %d\n", nDevices);
|
|
if (nDevices <= 0)
|
|
return false;
|
|
|
|
debug_printf ("trying to map device freq %d, bits %d, "
|
|
"channels %d, callback %d\n", rate, bits, channels,
|
|
bCallback);
|
|
|
|
int bytesperSample = bits / 8;
|
|
|
|
memset (&format, 0, sizeof (format));
|
|
format.wFormatTag = WAVE_FORMAT_PCM;
|
|
format.wBitsPerSample = bits;
|
|
format.nChannels = channels;
|
|
format.nSamplesPerSec = rate;
|
|
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nChannels *
|
|
bytesperSample;
|
|
format.nBlockAlign = format.nChannels * bytesperSample;
|
|
|
|
nBlocksInQue_ = 0;
|
|
HRESULT res = waveOutOpen (&dev_, WAVE_MAPPER, &format, (DWORD) wave_callback,
|
|
(DWORD) this, bCallback ? CALLBACK_FUNCTION : 0);
|
|
if (res == S_OK)
|
|
{
|
|
debug_printf ("Sucessfully opened!");
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
debug_printf ("failed to open");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void
|
|
Audio::close ()
|
|
{
|
|
if (dev_)
|
|
{
|
|
flush (); // force out last block whatever size..
|
|
|
|
while (blocks ()) // block till finished..
|
|
waitforcallback ();
|
|
|
|
waveOutReset (dev_);
|
|
waveOutClose (dev_);
|
|
dev_ = 0L;
|
|
}
|
|
nBytesWritten_ = 0L;
|
|
}
|
|
|
|
int
|
|
Audio::numbytesoutput ()
|
|
{
|
|
return nBytesWritten_;
|
|
}
|
|
|
|
int
|
|
Audio::getvolume ()
|
|
{
|
|
DWORD volume;
|
|
|
|
waveOutGetVolume (dev_, &volume);
|
|
return ((volume >> 16) + (volume & 0xffff)) >> 1;
|
|
}
|
|
|
|
void
|
|
Audio::setvolume (int newVolume)
|
|
{
|
|
waveOutSetVolume (dev_, (newVolume << 16) | newVolume);
|
|
}
|
|
|
|
char *
|
|
Audio::initialisebuffer ()
|
|
{
|
|
EnterCriticalSection (&lock_);
|
|
WAVEHDR *pHeader = 0L;
|
|
for (int i = 0; i < MAX_BLOCKS; i++)
|
|
{
|
|
char *pData = freeblocks_[i];
|
|
if (pData)
|
|
{
|
|
pHeader = (WAVEHDR *) pData;
|
|
if (pHeader->dwFlags & WHDR_DONE)
|
|
{
|
|
waveOutUnprepareHeader (dev_, pHeader, sizeof (WAVEHDR));
|
|
}
|
|
freeblocks_[i] = 0L;
|
|
break;
|
|
}
|
|
}
|
|
LeaveCriticalSection (&lock_);
|
|
|
|
if (pHeader)
|
|
{
|
|
memset (pHeader, 0, sizeof (WAVEHDR));
|
|
pHeader->dwBufferLength = BLOCK_SIZE;
|
|
pHeader->lpData = (LPSTR) (&pHeader[1]);
|
|
return (char *) pHeader->lpData;
|
|
}
|
|
return 0L;
|
|
}
|
|
|
|
bool
|
|
Audio::write (const void *pSampleData, int nBytes)
|
|
{
|
|
// split up big blocks into smaller BLOCK_SIZE chunks
|
|
while (nBytes > BLOCK_SIZE)
|
|
{
|
|
write (pSampleData, BLOCK_SIZE);
|
|
nBytes -= BLOCK_SIZE;
|
|
pSampleData = (void *) ((char *) pSampleData + BLOCK_SIZE);
|
|
}
|
|
|
|
// Block till next sound is flushed
|
|
if (blocks () == MAX_BLOCKS)
|
|
waitforcallback ();
|
|
|
|
// Allocate new wave buffer if necessary
|
|
if (buffer_ == 0L)
|
|
{
|
|
buffer_ = initialisebuffer ();
|
|
if (buffer_ == 0L)
|
|
return false;
|
|
}
|
|
|
|
|
|
// Handle gathering blocks into larger buffer
|
|
int sizeleft = BLOCK_SIZE - bufferIndex_;
|
|
if (nBytes < sizeleft)
|
|
{
|
|
memcpy (&buffer_[bufferIndex_], pSampleData, nBytes);
|
|
bufferIndex_ += nBytes;
|
|
nBytesWritten_ += nBytes;
|
|
return true;
|
|
}
|
|
|
|
// flushing when we reach our limit of BLOCK_SIZE
|
|
memcpy (&buffer_[bufferIndex_], pSampleData, sizeleft);
|
|
bufferIndex_ += sizeleft;
|
|
nBytesWritten_ += sizeleft;
|
|
flush ();
|
|
|
|
// change pointer to rest of sample, and size accordingly
|
|
pSampleData = (void *) ((char *) pSampleData + sizeleft);
|
|
nBytes -= sizeleft;
|
|
|
|
// if we still have some sample left over write it out
|
|
if (nBytes)
|
|
return write (pSampleData, nBytes);
|
|
|
|
return true;
|
|
}
|
|
|
|
// return number of blocks back.
|
|
int
|
|
Audio::blocks ()
|
|
{
|
|
EnterCriticalSection (&lock_);
|
|
int ret = nBlocksInQue_;
|
|
LeaveCriticalSection (&lock_);
|
|
return ret;
|
|
}
|
|
|
|
// This is called on an interupt so use locking.. Note nBlocksInQue_ is
|
|
// modified by it so we should wrap all references to it in locks.
|
|
void
|
|
Audio::callback_sampledone (void *pData)
|
|
{
|
|
EnterCriticalSection (&lock_);
|
|
|
|
nBlocksInQue_--;
|
|
for (int i = 0; i < MAX_BLOCKS; i++)
|
|
if (!freeblocks_[i])
|
|
{
|
|
freeblocks_[i] = (char *) pData;
|
|
break;
|
|
}
|
|
|
|
LeaveCriticalSection (&lock_);
|
|
}
|
|
|
|
void
|
|
Audio::waitforcallback ()
|
|
{
|
|
int n = blocks ();
|
|
if (!n)
|
|
return;
|
|
do
|
|
{
|
|
Sleep (250);
|
|
}
|
|
while (n == blocks ());
|
|
}
|
|
|
|
bool
|
|
Audio::flush ()
|
|
{
|
|
if (!buffer_)
|
|
return false;
|
|
|
|
// Send internal buffer out to the soundcard
|
|
WAVEHDR *pHeader = ((WAVEHDR *) buffer_) - 1;
|
|
pHeader->dwBufferLength = bufferIndex_;
|
|
|
|
// Quick bit of sample buffer conversion
|
|
if (formattype_ == AFMT_S8)
|
|
{
|
|
unsigned char *p = ((unsigned char *) buffer_);
|
|
for (int i = 0; i < bufferIndex_; i++)
|
|
{
|
|
p[i] -= 0x7f;
|
|
}
|
|
}
|
|
|
|
if (waveOutPrepareHeader (dev_, pHeader, sizeof (WAVEHDR)) == S_OK &&
|
|
waveOutWrite (dev_, pHeader, sizeof (WAVEHDR)) == S_OK)
|
|
{
|
|
EnterCriticalSection (&lock_);
|
|
nBlocksInQue_++;
|
|
LeaveCriticalSection (&lock_);
|
|
bufferIndex_ = 0;
|
|
buffer_ = 0L;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
EnterCriticalSection (&lock_);
|
|
for (int i = 0; i < MAX_BLOCKS; i++)
|
|
if (!freeblocks_[i])
|
|
{
|
|
freeblocks_[i] = (char *) pHeader;
|
|
break;
|
|
}
|
|
LeaveCriticalSection (&lock_);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// Call back routine
|
|
static void CALLBACK
|
|
wave_callback (HWAVE hWave, UINT msg, DWORD instance, DWORD param1,
|
|
DWORD param2)
|
|
{
|
|
if (msg == WOM_DONE)
|
|
{
|
|
Audio *ptr = (Audio *) instance;
|
|
ptr->callback_sampledone ((void *) param1);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// /dev/dsp handler
|
|
static Audio *s_audio; // static instance of the Audio handler
|
|
|
|
//------------------------------------------------------------------------
|
|
// wav file detection..
|
|
#pragma pack(1)
|
|
struct wavchunk
|
|
{
|
|
char id[4];
|
|
unsigned int len;
|
|
};
|
|
struct wavformat
|
|
{
|
|
unsigned short wFormatTag;
|
|
unsigned short wChannels;
|
|
unsigned int dwSamplesPerSec;
|
|
unsigned int dwAvgBytesPerSec;
|
|
unsigned short wBlockAlign;
|
|
unsigned short wBitsPerSample;
|
|
};
|
|
#pragma pack()
|
|
|
|
bool
|
|
fhandler_dev_dsp::setupwav (const char *pData, int nBytes)
|
|
{
|
|
int len;
|
|
const char *end = pData + nBytes;
|
|
|
|
if (!(pData[0] == 'R' && pData[1] == 'I' &&
|
|
pData[2] == 'F' && pData[3] == 'F'))
|
|
return false;
|
|
if (!(pData[8] == 'W' && pData[9] == 'A' &&
|
|
pData[10] == 'V' && pData[11] == 'E'))
|
|
return false;
|
|
|
|
len = *(int *) &pData[4];
|
|
pData += 12;
|
|
while (len && pData < end)
|
|
{
|
|
wavchunk * pChunk = (wavchunk *) pData;
|
|
int blklen = pChunk-> len;
|
|
if (pChunk->id[0] == 'f' && pChunk->id[1] == 'm' &&
|
|
pChunk->id[2] == 't' && pChunk->id[3] == ' ')
|
|
{
|
|
wavformat *format = (wavformat *) (pChunk + 1);
|
|
if ((char *) (format + 1) > end)
|
|
return false;
|
|
|
|
// Open up audio device with correct frequency for wav file
|
|
//
|
|
// FIXME: should through away all the header & not output
|
|
// it to the soundcard.
|
|
s_audio->close ();
|
|
if (s_audio->open (format->dwSamplesPerSec, format->wBitsPerSample,
|
|
format->wChannels) == false)
|
|
{
|
|
s_audio->open (audiofreq_, audiobits_, audiochannels_);
|
|
}
|
|
else
|
|
{
|
|
audiofreq_ = format->dwSamplesPerSec;
|
|
audiobits_ = format->wBitsPerSample;
|
|
audiochannels_ = format->wChannels;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
pData += blklen + sizeof (wavchunk);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
fhandler_dev_dsp::fhandler_dev_dsp (const char *name):
|
|
fhandler_base (FH_OSS_DSP, name)
|
|
{
|
|
set_cb (sizeof *this);
|
|
}
|
|
|
|
fhandler_dev_dsp::~fhandler_dev_dsp ()
|
|
{
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::open (const char *path, int flags, mode_t mode = 0)
|
|
{
|
|
// currently we only support writing
|
|
if ((flags & (O_WRONLY | O_RDONLY | O_RDWR)) != O_WRONLY)
|
|
return 0;
|
|
|
|
set_flags (flags);
|
|
|
|
if (!s_audio)
|
|
s_audio = new (audio_buf) Audio;
|
|
|
|
// Work out initial sample format & frequency
|
|
if (strcmp (path, "/dev/dsp") == 0L)
|
|
{
|
|
// dev/dsp defaults
|
|
audioformat_ = AFMT_S8;
|
|
audiofreq_ = 8000;
|
|
audiobits_ = 8;
|
|
audiochannels_ = 1;
|
|
}
|
|
|
|
if (!s_audio->open (audiofreq_, audiobits_, audiochannels_))
|
|
debug_printf ("/dev/dsp: failed to open\n");
|
|
else
|
|
{
|
|
set_open_status ();
|
|
debug_printf ("/dev/dsp: successfully opened\n");
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::write (const void *ptr, size_t len)
|
|
{
|
|
if (s_audio->numbytesoutput () == 0)
|
|
{
|
|
// check for wave file & setup frequencys properly if possible.
|
|
setupwav ((const char *) ptr, len);
|
|
|
|
// Open audio device properly with callbacks.
|
|
s_audio->close ();
|
|
if (!s_audio->open (audiofreq_, audiobits_, audiochannels_, true))
|
|
return 0;
|
|
}
|
|
|
|
s_audio->write (ptr, len);
|
|
return len;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::read (void *ptr, size_t len)
|
|
{
|
|
return len;
|
|
}
|
|
|
|
off_t
|
|
fhandler_dev_dsp::lseek (off_t offset, int whence)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::close (void)
|
|
{
|
|
s_audio->close ();
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::dup (fhandler_base * child)
|
|
{
|
|
fhandler_dev_dsp *fhc = (fhandler_dev_dsp *) child;
|
|
|
|
fhc->set_flags (get_flags ());
|
|
fhc->audiochannels_ = audiochannels_;
|
|
fhc->audiobits_ = audiobits_;
|
|
fhc->audiofreq_ = audiofreq_;
|
|
fhc->audioformat_ = audioformat_;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fhandler_dev_dsp::ioctl (unsigned int cmd, void *ptr)
|
|
{
|
|
int *intptr = (int *) ptr;
|
|
switch (cmd)
|
|
{
|
|
#define CASE(a) case a : debug_printf("/dev/dsp: ioctl %s\n", #a);
|
|
|
|
CASE (SNDCTL_DSP_RESET)
|
|
audioformat_ = AFMT_S8;
|
|
audiofreq_ = 8000;
|
|
audiobits_ = 8;
|
|
audiochannels_ = 1;
|
|
return 0;
|
|
|
|
CASE (SNDCTL_DSP_GETBLKSIZE)
|
|
*intptr = Audio::BLOCK_SIZE;
|
|
break;
|
|
|
|
CASE (SNDCTL_DSP_SETFMT)
|
|
{
|
|
int nBits = 0;
|
|
if (*intptr == AFMT_S16_LE)
|
|
nBits = 16;
|
|
else if (*intptr == AFMT_U8)
|
|
nBits = 8;
|
|
else if (*intptr == AFMT_S8)
|
|
nBits = 8;
|
|
if (nBits)
|
|
{
|
|
s_audio->setformat (*intptr);
|
|
s_audio->close ();
|
|
if (s_audio->open (audiofreq_, nBits, audiochannels_) == true)
|
|
{
|
|
audiobits_ = nBits;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
s_audio->open (audiofreq_, audiobits_, audiochannels_);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
CASE (SNDCTL_DSP_SPEED)
|
|
s_audio->close ();
|
|
if (s_audio->open (*intptr, audiobits_, audiochannels_) == true)
|
|
{
|
|
audiofreq_ = *intptr;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
s_audio->open (audiofreq_, audiobits_, audiochannels_);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
CASE (SNDCTL_DSP_STEREO)
|
|
{
|
|
int nChannels = *intptr + 1;
|
|
|
|
s_audio->close ();
|
|
if (s_audio->open (audiofreq_, audiobits_, nChannels) == true)
|
|
{
|
|
audiochannels_ = nChannels;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
s_audio->open (audiofreq_, audiobits_, audiochannels_);
|
|
return -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
CASE (SNDCTL_DSP_GETOSPACE)
|
|
{
|
|
audio_buf_info *p = (audio_buf_info *) ptr;
|
|
|
|
int nBlocks = s_audio->blocks ();
|
|
int leftblocks = ((Audio::MAX_BLOCKS - nBlocks) - 1);
|
|
if (leftblocks < 0)
|
|
leftblocks = 0;
|
|
if (leftblocks > 1)
|
|
leftblocks = 1;
|
|
int left = leftblocks * Audio::BLOCK_SIZE;
|
|
|
|
p->fragments = leftblocks;
|
|
p->fragstotal = Audio::MAX_BLOCKS;
|
|
p->fragsize = Audio::BLOCK_SIZE;
|
|
p->bytes = left;
|
|
|
|
debug_printf ("ptr %p nblocks %d leftblocks %d left bytes %d ",
|
|
ptr, nBlocks, leftblocks, left);
|
|
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
CASE (SNDCTL_DSP_SETFRAGMENT)
|
|
{
|
|
// Fake!! esound & mikmod require this on non PowerPC platforms.
|
|
//
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
debug_printf ("/dev/dsp: ioctl not handled yet! FIXME:\n");
|
|
break;
|
|
|
|
#undef CASE
|
|
};
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
fhandler_dev_dsp::dump ()
|
|
{
|
|
paranoid_printf ("here, fhandler_dev_dsp");
|
|
}
|
|
|
|
void
|
|
fhandler_dev_dsp::fixup_after_exec (HANDLE)
|
|
{
|
|
/* FIXME: Is there a better way to do this? */
|
|
s_audio = new (audio_buf) Audio;
|
|
}
|