519 lines
15 KiB
C
Executable File
519 lines
15 KiB
C
Executable File
/*
|
|
* This module provides sound access for QUISK using the portaudio library.
|
|
*/
|
|
#include <Python.h>
|
|
#include <complex.h>
|
|
#include <math.h>
|
|
#include <portaudio.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include "quisk.h"
|
|
|
|
/*
|
|
The sample rate is in frames per second. Each frame has a number of channels,
|
|
and each channel has a sample of size sample_bytes. The channels are interleaved:
|
|
(channel0, channel1), (channel0, channel1), ...
|
|
*/
|
|
|
|
extern struct sound_conf quisk_sound_state; // Current sound status
|
|
|
|
static float fbuffer[SAMP_BUFFER_SIZE]; // Buffer for float32 samples from sound
|
|
|
|
int quisk_read_portaudio(struct sound_dev * dev, complex double * cSamples)
|
|
{ // cSamples can be NULL to discard samples
|
|
// Read sound samples from the soundcard.
|
|
// Samples are converted to 32 bits with a range of +/- CLIP32 and placed into cSamples.
|
|
int i;
|
|
long avail;
|
|
int nSamples;
|
|
PaError error;
|
|
float fi, fq;
|
|
|
|
if (!dev->handle)
|
|
return -1;
|
|
|
|
avail = Pa_GetStreamReadAvailable((PaStream * )dev->handle);
|
|
dev->dev_latency = avail;
|
|
if (dev->read_frames == 0) { // non-blocking: read available frames
|
|
if (avail > SAMP_BUFFER_SIZE / dev->num_channels) // limit read request to buffer size
|
|
avail = SAMP_BUFFER_SIZE / dev->num_channels;
|
|
}
|
|
else { // size of read request
|
|
avail = dev->read_frames;
|
|
}
|
|
error = Pa_ReadStream ((PaStream * )dev->handle, fbuffer, avail);
|
|
if (error != paNoError) {
|
|
dev->dev_error++;
|
|
}
|
|
nSamples = 0;
|
|
for (i = 0; avail; i += dev->num_channels, avail--) {
|
|
fi = fbuffer[i + dev->channel_I];
|
|
fq = fbuffer[i + dev->channel_Q];
|
|
if (fi >= 1.0 || fi <= -1.0)
|
|
dev->overrange++; // assume overrange returns max int
|
|
if (fq >= 1.0 || fq <= -1.0)
|
|
dev->overrange++;
|
|
if (cSamples)
|
|
cSamples[nSamples] = (fi + I * fq) * CLIP32;
|
|
nSamples++;
|
|
if (nSamples > SAMP_BUFFER_SIZE * 8 / 10)
|
|
break;
|
|
|
|
}
|
|
return nSamples;
|
|
}
|
|
|
|
void quisk_play_portaudio(struct sound_dev * playdev, int nSamples, complex double * cSamples,
|
|
int report_latency, double volume)
|
|
{ // play the samples; write them to the portaudio soundcard
|
|
int i, n, index;
|
|
long delay;
|
|
float fi, fq;
|
|
PaError error;
|
|
|
|
if (!playdev->handle || nSamples <= 0)
|
|
return;
|
|
|
|
// "delay" is the number of samples left in the play buffer
|
|
delay = playdev->play_buf_size - Pa_GetStreamWriteAvailable(playdev->handle);
|
|
//printf ("play available %ld\n", Pa_GetStreamWriteAvailable(playdev->handle));
|
|
playdev->dev_latency = delay;
|
|
if (report_latency) { // Report for main playback device
|
|
quisk_sound_state.latencyPlay = delay;
|
|
}
|
|
//printf ("nSamples %d, delay %ld\n", nSamples, delay);
|
|
index = 0;
|
|
#if 0
|
|
// Timing is too crude to support this logic
|
|
if (nSamples + delay > playdev->latency_frames * 9 / 10) {
|
|
nSamples--;
|
|
#if DEBUG_IO
|
|
printf("Remove a sample %s nSamples %4d delay %4d total %4d\n", playdev->name, nSamples, (int)delay, nSamples + (int)delay);
|
|
#endif
|
|
}
|
|
else if(nSamples + delay < playdev->latency_frames * 5 / 10) {
|
|
cSamples[nSamples] = cSamples[nSamples - 1];
|
|
nSamples++;
|
|
#if DEBUG_IO
|
|
printf("Add a sample %s nSamples %4d delay %4d total %4d\n", playdev->name, nSamples, (int)delay, nSamples + (int)delay);
|
|
#endif
|
|
}
|
|
#endif
|
|
if (nSamples + delay > playdev->latency_frames) { // too many samples
|
|
index = nSamples + delay - playdev->latency_frames; // write only the most recent samples
|
|
if (index > nSamples)
|
|
index = nSamples;
|
|
quisk_sound_state.write_error++;
|
|
playdev->dev_error++;
|
|
#if DEBUG_IO
|
|
printf("Discard %d of %d samples at %d delay\n", index, nSamples, (int)delay);
|
|
#endif
|
|
if (nSamples == index) // no samples to play
|
|
return;
|
|
}
|
|
else if (delay < 16) { // Buffer is too empty; fill it back up with zeros.
|
|
n = playdev->latency_frames * 7 / 10 - nSamples;
|
|
#if DEBUG_IO
|
|
printf("Add %d zero samples at %ld delay\n", n, delay);
|
|
#endif
|
|
for (i = 0; i < n; i++)
|
|
cSamples[nSamples++] = 0;
|
|
}
|
|
for (i = 0, n = index; n < nSamples; i += playdev->num_channels, n++) {
|
|
fi = volume * creal(cSamples[n]);
|
|
fq = volume * cimag(cSamples[n]);
|
|
fbuffer[i + playdev->channel_I] = fi / CLIP32;
|
|
fbuffer[i + playdev->channel_Q] = fq / CLIP32;
|
|
}
|
|
error = Pa_WriteStream ((PaStream * )playdev->handle, fbuffer, nSamples - index);
|
|
//printf ("Write %d\n", nSamples - index);
|
|
if (error == paNoError)
|
|
;
|
|
else if (error == paOutputUnderflowed) {
|
|
quisk_sound_state.underrun_error++;
|
|
playdev->dev_underrun++;
|
|
}
|
|
else {
|
|
quisk_sound_state.write_error++;
|
|
playdev->dev_error++;
|
|
#if DEBUG_IO
|
|
printf ("Play error: %s\n", Pa_GetErrorText(error));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void info_portaudio (struct sound_dev * cDev, struct sound_dev * pDev)
|
|
{ // Return information about the device
|
|
const PaDeviceInfo * info;
|
|
PaStreamParameters params;
|
|
int index, rate;
|
|
|
|
if (cDev)
|
|
index = cDev->portaudio_index;
|
|
else if (pDev)
|
|
index = pDev->portaudio_index;
|
|
else
|
|
return;
|
|
info = Pa_GetDeviceInfo(index);
|
|
if ( ! info)
|
|
return;
|
|
|
|
params.device = index;
|
|
params.channelCount = 1;
|
|
params.sampleFormat = paFloat32;
|
|
params.suggestedLatency = 0.10;
|
|
params.hostApiSpecificStreamInfo = NULL;
|
|
|
|
if (cDev) {
|
|
cDev->chan_min = 1;
|
|
cDev->chan_max = info->maxInputChannels;
|
|
cDev->rate_min = cDev->rate_max = 0;
|
|
cDev->portaudio_latency = info->defaultHighInputLatency;
|
|
#if DEBUG_IO
|
|
printf ("Capture latency low %lf, high %lf\n",
|
|
info->defaultLowInputLatency, info->defaultHighInputLatency);
|
|
#endif
|
|
for (rate = 8000; rate <= 384000; rate += 8000) {
|
|
if (Pa_IsFormatSupported(¶ms, NULL, rate) == paFormatIsSupported) {
|
|
if (cDev->rate_min == 0)
|
|
cDev->rate_min = rate;
|
|
cDev->rate_max = rate;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pDev) {
|
|
pDev->chan_min = 1;
|
|
pDev->chan_max = info->maxOutputChannels;
|
|
pDev->rate_min = pDev->rate_max = 0;
|
|
pDev->portaudio_latency = quisk_sound_state.latency_millisecs / 1000.0 * 2.0;
|
|
if (pDev->portaudio_latency < info->defaultHighOutputLatency)
|
|
pDev->portaudio_latency = info->defaultHighOutputLatency;
|
|
#if DEBUG_IO
|
|
printf ("Play latency low %lf, high %lf\n",
|
|
info->defaultLowOutputLatency, info->defaultHighOutputLatency);
|
|
#endif
|
|
for (rate = 8000; rate <= 384000; rate += 8000) {
|
|
if (Pa_IsFormatSupported(¶ms, NULL, rate) == paFormatIsSupported) {
|
|
if (pDev->rate_min == 0)
|
|
pDev->rate_min = rate;
|
|
pDev->rate_max = rate;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int quisk_pa_name2index (struct sound_dev * dev, int is_capture)
|
|
{ // Based on the device name, set the portaudio index, or -1.
|
|
// Return non-zero for error. Not a portaudio device is not an error.
|
|
const PaDeviceInfo * pInfo;
|
|
int i, count;
|
|
|
|
if (strncmp (dev->name, "portaudio", 9)) {
|
|
dev->portaudio_index = -1; // Name does not start with "portaudio"
|
|
return 0; // Not a portaudio device, not an error
|
|
}
|
|
if ( ! strcmp (dev->name, "portaudiodefault")) {
|
|
if (is_capture) // Fill in the default device index
|
|
dev->portaudio_index = Pa_GetDefaultInputDevice();
|
|
else
|
|
dev->portaudio_index = Pa_GetDefaultOutputDevice();
|
|
strncpy (dev->msg1, "Using default portaudio device", QUISK_SC_SIZE);
|
|
return 0;
|
|
}
|
|
if ( ! strncmp (dev->name, "portaudio#", 10)) { // Integer index follows "#"
|
|
dev->portaudio_index = i = atoi(dev->name + 10);
|
|
pInfo = Pa_GetDeviceInfo(i);
|
|
if (pInfo) {
|
|
snprintf (dev->msg1, QUISK_SC_SIZE, "PortAudio device %s", pInfo->name);
|
|
return 0;
|
|
}
|
|
else {
|
|
snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE,
|
|
"Can not find portaudio device number %s", dev->name + 10);
|
|
}
|
|
return 1;
|
|
}
|
|
if ( ! strncmp (dev->name, "portaudio:", 10)) {
|
|
dev->portaudio_index = -1;
|
|
count = Pa_GetDeviceCount(); // Search for string in device name
|
|
for (i = 0; i < count; i++) {
|
|
pInfo = Pa_GetDeviceInfo(i);
|
|
if (pInfo && strstr(pInfo->name, dev->name + 10)) {
|
|
dev->portaudio_index = i;
|
|
snprintf (dev->msg1, QUISK_SC_SIZE, "PortAudio device %s", pInfo->name);
|
|
break;
|
|
}
|
|
}
|
|
if (dev->portaudio_index == -1) { // Error
|
|
snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE,
|
|
"Can not find portaudio device named %s", dev->name + 10);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE,
|
|
"Did not recognize portaudio device %.90s", dev->name);
|
|
return 1;
|
|
}
|
|
|
|
static int quisk_open_portaudio (struct sound_dev * cDev, struct sound_dev * pDev)
|
|
{ // Open the portaudio soundcard for capture on cDev and playback on pDev (or NULL).
|
|
// Return non-zero for error.
|
|
PaStreamParameters cParams, pParams;
|
|
PaError error;
|
|
PaStream * hndl;
|
|
|
|
info_portaudio (cDev, pDev);
|
|
|
|
if (pDev && cDev && pDev->sample_rate != cDev->sample_rate) {
|
|
strncpy(quisk_sound_state.err_msg, "Capture and Play sample rates must be equal.", QUISK_SC_SIZE);
|
|
return 1;
|
|
}
|
|
|
|
cParams.sampleFormat = paFloat32;
|
|
pParams.sampleFormat = paFloat32;
|
|
cParams.hostApiSpecificStreamInfo = NULL;
|
|
pParams.hostApiSpecificStreamInfo = NULL;
|
|
|
|
if (cDev) {
|
|
cDev->handle = NULL;
|
|
cParams.device = cDev->portaudio_index;
|
|
cParams.channelCount = cDev->num_channels;
|
|
cParams.suggestedLatency = cDev->portaudio_latency;
|
|
}
|
|
|
|
if (pDev) {
|
|
pDev->handle = NULL;
|
|
pParams.device = pDev->portaudio_index;
|
|
pParams.channelCount = pDev->num_channels;
|
|
pParams.suggestedLatency = pDev->portaudio_latency;
|
|
}
|
|
|
|
if (cDev && pDev) {
|
|
error = Pa_OpenStream (&hndl, &cParams, &pParams,
|
|
(double)cDev->sample_rate, cDev->read_frames, 0, NULL, NULL);
|
|
pDev->handle = cDev->handle = (void *)hndl;
|
|
}
|
|
else if (cDev) {
|
|
error = Pa_OpenStream (&hndl, &cParams, NULL,
|
|
(double)cDev->sample_rate, cDev->read_frames, 0, NULL, NULL);
|
|
cDev->handle = (void *)hndl;
|
|
}
|
|
else if (pDev) {
|
|
error = Pa_OpenStream (&hndl, NULL, &pParams,
|
|
(double)pDev->sample_rate, 0, 0, NULL, NULL);
|
|
pDev->handle = (void *)hndl;
|
|
}
|
|
else {
|
|
error = paNoError;
|
|
}
|
|
if (pDev) {
|
|
pDev->play_buf_size = Pa_GetStreamWriteAvailable(pDev->handle);
|
|
if (pDev->latency_frames > pDev->play_buf_size) {
|
|
#if DEBUG_IO
|
|
printf("Latency frames %d limited to buffer size %d\n",
|
|
pDev->latency_frames, pDev->play_buf_size);
|
|
#endif
|
|
pDev->latency_frames = pDev->play_buf_size;
|
|
}
|
|
}
|
|
#if DEBUG_IO
|
|
if (pDev) {
|
|
printf ("play_buf_size %d\n", pDev->play_buf_size);
|
|
printf ("latency_frames %d\n", pDev->latency_frames);
|
|
}
|
|
#endif
|
|
if (error == paNoError)
|
|
return 0;
|
|
strncpy(quisk_sound_state.err_msg, Pa_GetErrorText(error), QUISK_SC_SIZE);
|
|
return 1;
|
|
}
|
|
|
|
void quisk_start_sound_portaudio(struct sound_dev ** pCapture, struct sound_dev ** pPlayback)
|
|
{
|
|
int index, err, match;
|
|
struct sound_dev ** pCapt, ** pPlay;
|
|
|
|
Pa_Initialize();
|
|
// Set the portaudio index from the name. Return on error.
|
|
pCapt = pCapture;
|
|
while (*pCapt) {
|
|
if( (*pCapt)->driver == DEV_DRIVER_PORTAUDIO && quisk_pa_name2index (*pCapt, 1))
|
|
return; // Error
|
|
pCapt++;
|
|
}
|
|
pPlay = pPlayback;
|
|
while (*pPlay) {
|
|
if( (*pPlay)->driver == DEV_DRIVER_PORTAUDIO && quisk_pa_name2index (*pPlay, 0))
|
|
return;
|
|
pPlay++;
|
|
}
|
|
// Open the sound cards. If a capture device equals a playback device, they must be opened jointly.
|
|
pCapt = pCapture;
|
|
while (*pCapt) {
|
|
index = (*pCapt)->portaudio_index;
|
|
if((*pCapt)->driver == DEV_DRIVER_PORTAUDIO && index >= 0) { // This is a portaudio device
|
|
pPlay = pPlayback;
|
|
match = 0;
|
|
while (*pPlay) {
|
|
if((*pPlay)->driver == DEV_DRIVER_PORTAUDIO &&
|
|
(*pPlay)->portaudio_index == index) { // same device, open both
|
|
err = quisk_open_portaudio (*pCapt, *pPlay);
|
|
match = 1;
|
|
break;
|
|
}
|
|
pPlay++;
|
|
}
|
|
if ( ! match)
|
|
err = quisk_open_portaudio (*pCapt, NULL); // no matching device
|
|
if (err)
|
|
return; // error
|
|
}
|
|
pCapt++;
|
|
}
|
|
strncpy (quisk_sound_state.msg1, (*pCapture)->msg1, QUISK_SC_SIZE); // Primary capture device
|
|
// Open remaining portaudio devices
|
|
pPlay = pPlayback;
|
|
while (*pPlay) {
|
|
if ((*pPlay)->driver == DEV_DRIVER_PORTAUDIO
|
|
&& (*pPlay)->portaudio_index >= 0
|
|
&& ! (*pPlay)->handle
|
|
) {
|
|
err = quisk_open_portaudio (NULL, *pPlay);
|
|
if (err)
|
|
return; // error
|
|
}
|
|
pPlay++;
|
|
}
|
|
if ( ! quisk_sound_state.msg1[0]) // Primary playback device
|
|
strncpy (quisk_sound_state.msg1, (*pPlayback)->msg1, QUISK_SC_SIZE);
|
|
pCapt = pCapture;
|
|
while (*pCapt) {
|
|
if ((*pCapt)->handle)
|
|
Pa_StartStream((PaStream * )(*pCapt)->handle);
|
|
pCapt++;
|
|
}
|
|
pPlay = pPlayback;
|
|
while (*pPlay) {
|
|
if ((*pPlay)->handle && Pa_IsStreamStopped((PaStream * )(*pPlay)->handle))
|
|
Pa_StartStream((PaStream * )(*pPlay)->handle);
|
|
pPlay++;
|
|
}
|
|
}
|
|
|
|
void quisk_close_sound_portaudio(void)
|
|
{
|
|
Pa_Terminate();
|
|
}
|
|
|
|
// Changes for MacOS support (__MACH__) thanks to Mario, DL3LSM.
|
|
#if defined(__MACH__)
|
|
|
|
static int device_list(PyObject * py, int input)
|
|
{
|
|
int retNum = 0;
|
|
char buf100[100];
|
|
|
|
PaError err;
|
|
|
|
err = Pa_Initialize();
|
|
|
|
if ( err == paNoError ) {
|
|
PaDeviceIndex numDev = Pa_GetDeviceCount();
|
|
for (PaDeviceIndex dev = 0; dev < numDev; dev++) {
|
|
const PaDeviceInfo *info = Pa_GetDeviceInfo(dev);
|
|
#if (0)
|
|
printf("found audio device: %d, name=%s, #inp %d, #outp %d defsample %f\n", dev, info->name, info->maxInputChannels,
|
|
info->maxOutputChannels, info->defaultSampleRate);
|
|
#endif
|
|
if ((input && info->maxInputChannels > 0) ||
|
|
(!input && info->maxOutputChannels > 0)) { // check the available channels for the type)
|
|
// found one
|
|
if (py) {
|
|
snprintf(buf100, 100, "%s", info->name);
|
|
PyList_Append(py, PyString_FromString(buf100));
|
|
}
|
|
}
|
|
}
|
|
Pa_Terminate();
|
|
}
|
|
return retNum;
|
|
|
|
}
|
|
|
|
PyObject * quisk_sound_devices(PyObject * self, PyObject * args)
|
|
{ // Return a list of ALSA device names [pycapt, pyplay]
|
|
PyObject * pylist, * pycapt, * pyplay;
|
|
|
|
if (!PyArg_ParseTuple (args, ""))
|
|
return NULL;
|
|
// Each pycapt and pyplay is [pydev, pyname]
|
|
pylist = PyList_New(0); // list [pycapt, pyplay]
|
|
pycapt = PyList_New(0); // list of capture devices
|
|
pyplay = PyList_New(0); // list of play devices
|
|
PyList_Append(pylist, pycapt);
|
|
PyList_Append(pylist, pyplay);
|
|
device_list(pycapt, 1);
|
|
device_list(pyplay, 0);
|
|
return pylist;
|
|
}
|
|
|
|
void quisk_play_alsa(struct sound_dev * dev, int nSamples,
|
|
complex double * cSamples, int report_latency, double volume)
|
|
{
|
|
}
|
|
|
|
void quisk_start_sound_alsa(struct sound_dev ** pCapture, struct sound_dev ** pPlayback)
|
|
{
|
|
}
|
|
|
|
void quisk_close_sound_alsa(struct sound_dev ** pCapture, struct sound_dev ** pPlayback)
|
|
{
|
|
}
|
|
|
|
int quisk_read_alsa(struct sound_dev * dev, complex double * samp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void quisk_mixer_set(char * card_name, int numid, PyObject * value, char * err_msg, int err_size)
|
|
{
|
|
err_msg[0] = 0;
|
|
}
|
|
|
|
#if !defined USE_MACPORTS
|
|
int quisk_read_pulseaudio(struct sound_dev * dev, complex double * samp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void quisk_play_pulseaudio(struct sound_dev * dev, int j, complex double * samp, int i, double volume)
|
|
{
|
|
}
|
|
|
|
void quisk_start_sound_pulseaudio(struct sound_dev ** pCapture, struct sound_dev ** pPlayback)
|
|
{
|
|
}
|
|
|
|
void quisk_close_sound_pulseaudio()
|
|
{
|
|
}
|
|
|
|
|
|
PyObject * quisk_pa_sound_devices(PyObject * self, PyObject * args)
|
|
{ // Return a list of PulseAudio device names [pycapt, pyplay]
|
|
PyObject * pylist, * pycapt, * pyplay;
|
|
|
|
if (!PyArg_ParseTuple (args, ""))
|
|
return NULL;
|
|
pylist = PyList_New(0); // list [pycapt, pyplay]
|
|
pycapt = PyList_New(0); // list of capture devices
|
|
pyplay = PyList_New(0); // list of play devices
|
|
PyList_Append(pylist, pycapt);
|
|
PyList_Append(pylist, pyplay);
|
|
return pylist;
|
|
}
|
|
#endif
|
|
#endif
|