PierMesh
/
direwolf
mirror of https://github.com/wb2osz/direwolf.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
direwolf/audio.c

1432 lines
38 KiB
C
Raw Blame History

//
// This file is part of Dire Wolf, an amateur radio packet TNC.
//
// Copyright (C) 2011, 2012, 2013, 2014, 2015 John Langner, WB2OSZ
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
/*------------------------------------------------------------------
*
* Module: audio.c
*
* Purpose: Interface to audio device commonly called a "sound card" for
* historical reasons.
*
* This version is for Linux and Cygwin.
*
* Two different types of sound interfaces are supported:
*
* * OSS - For Cygwin or Linux versions with /dev/dsp.
*
* * ALSA - For Linux versions without /dev/dsp.
* In this case, define preprocessor symbol USE_ALSA.
*
* References: Some tips on on using Linux sound devices.
*
* http://www.oreilly.de/catalog/multilinux/excerpt/ch14-05.htm
* http://cygwin.com/ml/cygwin-patches/2004-q1/msg00116/devdsp.c
* http://manuals.opensound.com/developer/fulldup.c.html
*
* "Introduction to Sound Programming with ALSA"
* http://www.linuxjournal.com/article/6735?page=0,1
*
* http://www.alsa-project.org/main/index.php/Asoundrc
*
* Credits: Release 1.0: Fabrice FAURE contributed code for the SDR UDP interface.
*
* Discussion here: http://gqrx.dk/doc/streaming-audio-over-udp
*
* Release 1.1: Gabor Berczi provided fixes for the OSS code
* which had fallen into decay.
*
* Major Revisions:
*
* 1.2 - Add ability to use more than one audio device.
*
*---------------------------------------------------------------*/
#include "direwolf.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#if USE_ALSA
#include <alsa/asoundlib.h>
#else
#include <errno.h>
#ifdef __OpenBSD__
#include <soundcard.h>
#else
#include <sys/soundcard.h>
#endif
#endif
#include "audio.h"
#include "audio_stats.h"
#include "textcolor.h"
#include "dtime_now.h"
#include "demod.h" /* for alevel_t & demod_get_audio_level() */
/* Audio configuration. */
static struct audio_s *save_audio_config_p;
/* Current state for each of the audio devices. */
static struct adev_s {
#if USE_ALSA
snd_pcm_t *audio_in_handle;
snd_pcm_t *audio_out_handle;
int bytes_per_frame; /* number of bytes for a sample from all channels. */
/* e.g. 4 for stereo 16 bit. */
#else
int oss_audio_device_fd; /* Single device, both directions. */
#endif
int inbuf_size_in_bytes; /* number of bytes allocated */
unsigned char *inbuf_ptr;
int inbuf_len; /* number byte of actual data available. */
int inbuf_next; /* index of next to remove. */
int outbuf_size_in_bytes;
unsigned char *outbuf_ptr;
int outbuf_len;
enum audio_in_type_e g_audio_in_type;
int udp_sock; /* UDP socket for receiving data */
} adev[MAX_ADEVS];
// Originally 40. Version 1.2, try 10 for lower latency.
#define ONE_BUF_TIME 10
#if USE_ALSA
static int set_alsa_params (int a, snd_pcm_t *handle, struct audio_s *pa, char *name, char *dir);
//static void alsa_select_device (char *pick_dev, int direction, char *result);
#else
static int set_oss_params (int a, int fd, struct audio_s *pa);
#endif
#define roundup1k(n) (((n) + 0x3ff) & ~0x3ff)
static int calcbufsize(int rate, int chans, int bits)
{
int size1 = (rate * chans * bits / 8 * ONE_BUF_TIME) / 1000;
int size2 = roundup1k(size1);
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_open: calcbufsize (rate=%d, chans=%d, bits=%d) calc size=%d, round up to %d\n",
rate, chans, bits, size1, size2);
#endif
return (size2);
}
/*------------------------------------------------------------------
*
* Name: audio_open
*
* Purpose: Open the digital audio device.
* For "OSS", the device name is typically "/dev/dsp".
* For "ALSA", it's a lot more complicated. See User Guide.
*
* New in version 1.0, we recognize "udp:" optionally
* followed by a port number.
*
* Inputs: pa - Address of structure of type audio_s.
*
* Using a structure, rather than separate arguments
* seemed to make sense because we often pass around
* the same set of parameters various places.
*
* The fields that we care about are:
* num_channels
* samples_per_sec
* bits_per_sample
* If zero, reasonable defaults will be provided.
*
* The device names are in adevice_in and adevice_out.
* - For "OSS", the device name is typically "/dev/dsp".
* - For "ALSA", the device names are hw:c,d
* where c is the "card" (for historical purposes)
* and d is the "device" within the "card."
*
*
* Outputs: pa - The ACTUAL values are returned here.
*
* These might not be exactly the same as what was requested.
*
* Example: ask for stereo, 16 bits, 22050 per second.
* An ordinary desktop/laptop PC should be able to handle this.
* However, some other sort of smaller device might be
* more restrictive in its capabilities.
* It might say, the best I can do is mono, 8 bit, 8000/sec.
*
* The sofware modem must use this ACTUAL information
* that the device is supplying, that could be different
* than what the user specified.
*
* Returns: 0 for success, -1 for failure.
*
*
*----------------------------------------------------------------*/
int audio_open (struct audio_s *pa)
{
int err;
int chan;
int a;
char audio_in_name[30];
char audio_out_name[30];
save_audio_config_p = pa;
memset (adev, 0, sizeof(adev));
for (a=0; a<MAX_ADEVS; a++) {
#ifndef USE_ALSA
adev[a].oss_audio_device_fd = -1;
#endif
adev[a].udp_sock = -1;
}
/*
* Fill in defaults for any missing values.
*/
for (a=0; a<MAX_ADEVS; a++) {
if (pa->adev[a].num_channels == 0)
pa->adev[a].num_channels = DEFAULT_NUM_CHANNELS;
if (pa->adev[a].samples_per_sec == 0)
pa->adev[a].samples_per_sec = DEFAULT_SAMPLES_PER_SEC;
if (pa->adev[a].bits_per_sample == 0)
pa->adev[a].bits_per_sample = DEFAULT_BITS_PER_SAMPLE;
for (chan=0; chan<MAX_CHANS; chan++) {
if (pa->achan[chan].mark_freq == 0)
pa->achan[chan].mark_freq = DEFAULT_MARK_FREQ;
if (pa->achan[chan].space_freq == 0)
pa->achan[chan].space_freq = DEFAULT_SPACE_FREQ;
if (pa->achan[chan].baud == 0)
pa->achan[chan].baud = DEFAULT_BAUD;
if (pa->achan[chan].num_subchan == 0)
pa->achan[chan].num_subchan = 1;
}
}
/*
* Open audio device(s).
*/
for (a=0; a<MAX_ADEVS; a++) {
if (pa->adev[a].defined) {
adev[a].inbuf_size_in_bytes = 0;
adev[a].inbuf_ptr = NULL;
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
adev[a].outbuf_size_in_bytes = 0;
adev[a].outbuf_ptr = NULL;
adev[a].outbuf_len = 0;
/*
* Determine the type of audio input.
*/
adev[a].g_audio_in_type = AUDIO_IN_TYPE_SOUNDCARD;
if (strcasecmp(pa->adev[a].adevice_in, "stdin") == 0 || strcmp(pa->adev[a].adevice_in, "-") == 0) {
adev[a].g_audio_in_type = AUDIO_IN_TYPE_STDIN;
/* Change "-" to stdin for readability. */
strlcpy (pa->adev[a].adevice_in, "stdin", sizeof(pa->adev[a].adevice_in));
}
if (strncasecmp(pa->adev[a].adevice_in, "udp:", 4) == 0) {
adev[a].g_audio_in_type = AUDIO_IN_TYPE_SDR_UDP;
/* Supply default port if none specified. */
if (strcasecmp(pa->adev[a].adevice_in,"udp") == 0 ||
strcasecmp(pa->adev[a].adevice_in,"udp:") == 0) {
snprintf (pa->adev[a].adevice_in, sizeof(pa->adev[a].adevice_in), "udp:%d", DEFAULT_UDP_AUDIO_PORT);
}
}
/* Let user know what is going on. */
/* If not specified, the device names should be "default". */
strlcpy (audio_in_name, pa->adev[a].adevice_in, sizeof(audio_in_name));
strlcpy (audio_out_name, pa->adev[a].adevice_out, sizeof(audio_out_name));
char ctemp[40];
if (pa->adev[a].num_channels == 2) {
snprintf (ctemp, sizeof(ctemp), " (channels %d & %d)", ADEVFIRSTCHAN(a), ADEVFIRSTCHAN(a)+1);
}
else {
snprintf (ctemp, sizeof(ctemp), " (channel %d)", ADEVFIRSTCHAN(a));
}
text_color_set(DW_COLOR_INFO);
if (strcmp(audio_in_name,audio_out_name) == 0) {
dw_printf ("Audio device for both receive and transmit: %s %s\n", audio_in_name, ctemp);
}
else {
dw_printf ("Audio input device for receive: %s %s\n", audio_in_name, ctemp);
dw_printf ("Audio out device for transmit: %s %s\n", audio_out_name, ctemp);
}
/*
* Now attempt actual opens.
*/
/*
* Input device.
*/
switch (adev[a].g_audio_in_type) {
/*
* Soundcard - ALSA.
*/
case AUDIO_IN_TYPE_SOUNDCARD:
#if USE_ALSA
err = snd_pcm_open (&(adev[a].audio_in_handle), audio_in_name, SND_PCM_STREAM_CAPTURE, 0);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not open audio device %s for input\n%s\n",
audio_in_name, snd_strerror(err));
return (-1);
}
adev[a].inbuf_size_in_bytes = set_alsa_params (a, adev[a].audio_in_handle, pa, audio_in_name, "input");
#else // OSS
adev[a].oss_audio_device_fd = open (pa->adev[a].adevice_in, O_RDWR);
if (adev[a].oss_audio_device_fd < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("%s:\n", pa->adev[a].adevice_in);
// snprintf (message, sizeof(message), "Could not open audio device %s", pa->adev[a].adevice_in);
// perror (message);
return (-1);
}
adev[a].outbuf_size_in_bytes = adev[a].inbuf_size_in_bytes = set_oss_params (a, adev[a].oss_audio_device_fd, pa);
if (adev[a].inbuf_size_in_bytes <= 0 || adev[a].outbuf_size_in_bytes <= 0) {
return (-1);
}
#endif
break;
/*
* UDP.
*/
case AUDIO_IN_TYPE_SDR_UDP:
//Create socket and bind socket
{
struct sockaddr_in si_me;
//int slen=sizeof(si_me);
//int data_size = 0;
//Create UDP Socket
if ((adev[a].udp_sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Couldn't create socket, errno %d\n", errno);
return -1;
}
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons((short)atoi(audio_in_name+4));
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
//Bind to the socket
if (bind(adev[a].udp_sock, (const struct sockaddr *) &si_me, sizeof(si_me))==-1) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Couldn't bind socket, errno %d\n", errno);
return -1;
}
}
adev[a].inbuf_size_in_bytes = SDR_UDP_BUF_MAXLEN;
break;
/*
* stdin.
*/
case AUDIO_IN_TYPE_STDIN:
/* Do we need to adjust any properties of stdin? */
adev[a].inbuf_size_in_bytes = 1024;
break;
default:
text_color_set(DW_COLOR_ERROR);
dw_printf ("Internal error, invalid audio_in_type\n");
return (-1);
}
/*
* Output device. Only "soundcard" is supported at this time.
*/
#if USE_ALSA
err = snd_pcm_open (&(adev[a].audio_out_handle), audio_out_name, SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not open audio device %s for output\n%s\n",
audio_out_name, snd_strerror(err));
return (-1);
}
adev[a].outbuf_size_in_bytes = set_alsa_params (a, adev[a].audio_out_handle, pa, audio_out_name, "output");
if (adev[a].inbuf_size_in_bytes <= 0 || adev[a].outbuf_size_in_bytes <= 0) {
return (-1);
}
#endif
/*
* Finally allocate buffer for each direction.
*/
adev[a].inbuf_ptr = malloc(adev[a].inbuf_size_in_bytes);
assert (adev[a].inbuf_ptr != NULL);
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
adev[a].outbuf_ptr = malloc(adev[a].outbuf_size_in_bytes);
assert (adev[a].outbuf_ptr != NULL);
adev[a].outbuf_len = 0;
} /* end of audio device defined */
} /* end of for each audio device */
return (0);
} /* end audio_open */
#if USE_ALSA
/*
* Set parameters for sound card.
*
* See ?? for details.
*/
/*
* Terminology:
* Sample - for one channel. e.g. 2 bytes for 16 bit.
* Frame - one sample for all channels. e.g. 4 bytes for 16 bit stereo
* Period - size of one transfer.
*/
static int set_alsa_params (int a, snd_pcm_t *handle, struct audio_s *pa, char *devname, char *inout)
{
snd_pcm_hw_params_t *hw_params;
snd_pcm_uframes_t fpp; /* Frames per period. */
unsigned int val;
int dir;
int err;
int buf_size_in_bytes; /* result, number of bytes per transfer. */
err = snd_pcm_hw_params_malloc (&hw_params);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not alloc hw param structure.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
err = snd_pcm_hw_params_any (handle, hw_params);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not init hw param structure.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
/* Interleaved data: L, R, L, R, ... */
err = snd_pcm_hw_params_set_access (handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set interleaved mode.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
/* Signed 16 bit little endian or unsigned 8 bit. */
err = snd_pcm_hw_params_set_format (handle, hw_params,
pa->adev[a].bits_per_sample == 8 ? SND_PCM_FORMAT_U8 : SND_PCM_FORMAT_S16_LE);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set bits per sample.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
/* Number of audio channels. */
err = snd_pcm_hw_params_set_channels (handle, hw_params, pa->adev[a].num_channels);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set number of audio channels.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
/* Audio sample rate. */
val = pa->adev[a].samples_per_sec;
dir = 0;
err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &val, &dir);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set audio sample rate.\n%s\n",
snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
if (val != pa->adev[a].samples_per_sec) {
text_color_set(DW_COLOR_INFO);
dw_printf ("Asked for %d samples/sec but got %d.\n",
pa->adev[a].samples_per_sec, val);
dw_printf ("for %s %s.\n", devname, inout);
pa->adev[a].samples_per_sec = val;
}
/* Original: */
/* Guessed around 20 reads/sec might be good. */
/* Period too long = too much latency. */
/* Period too short = more overhead of many small transfers. */
/* fpp = pa->adev[a].samples_per_sec / 20; */
/* The suggested period size was 2205 frames. */
/* I thought the later "...set_period_size_near" might adjust it to be */
/* some more optimal nearby value based hardware buffer sizes but */
/* that didn't happen. We ended up with a buffer size of 4410 bytes. */
/* In version 1.2, let's take a different approach. */
/* Reduce the latency and round up to a multiple of 1 Kbyte. */
/* For the typical case of 44100 sample rate, 1 channel, 16 bits, we calculate */
/* a buffer size of 882 and round it up to 1k. This results in 512 frames per period. */
/* A period comes out to be about 80 periods per second or about 12.5 mSec each. */
buf_size_in_bytes = calcbufsize(pa->adev[a].samples_per_sec, pa->adev[a].num_channels, pa->adev[a].bits_per_sample);
#if __arm__
/* Ugly hack for RPi. */
/* Reducing buffer size is fine for input but not so good for output. */
if (*inout == 'o') {
buf_size_in_bytes = buf_size_in_bytes * 4;
}
#endif
fpp = buf_size_in_bytes / (pa->adev[a].num_channels * pa->adev[a].bits_per_sample / 8);
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("suggest period size of %d frames\n", (int)fpp);
#endif
dir = 0;
err = snd_pcm_hw_params_set_period_size_near (handle, hw_params, &fpp, &dir);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set period size\n%s\n", snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
err = snd_pcm_hw_params (handle, hw_params);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not set hw params\n%s\n", snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
/* Driver might not like our suggested period size */
/* and might have another idea. */
err = snd_pcm_hw_params_get_period_size (hw_params, &fpp, NULL);
if (err < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Could not get audio period size.\n%s\n", snd_strerror(err));
dw_printf ("for %s %s.\n", devname, inout);
return (-1);
}
snd_pcm_hw_params_free (hw_params);
/* A "frame" is one sample for all channels. */
/* The read and write use units of frames, not bytes. */
adev[a].bytes_per_frame = snd_pcm_frames_to_bytes (handle, 1);
assert (adev[a].bytes_per_frame == pa->adev[a].num_channels * pa->adev[a].bits_per_sample / 8);
buf_size_in_bytes = fpp * adev[a].bytes_per_frame;
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio buffer size = %d (bytes per frame) x %d (frames per period) = %d \n", adev[a].bytes_per_frame, (int)fpp, buf_size_in_bytes);
#endif
/* Version 1.3 - after a report of this situation for Mac OSX version. */
if (buf_size_in_bytes < 256 || buf_size_in_bytes > 32768) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio buffer has unexpected extreme size of %d bytes.\n", buf_size_in_bytes);
dw_printf ("Detected at %s, line %d.\n", __FILE__, __LINE__);
dw_printf ("This might be caused by unusual audio device configuration values.\n");
buf_size_in_bytes = 2048;
dw_printf ("Using %d to attempt recovery.\n", buf_size_in_bytes);
}
return (buf_size_in_bytes);
} /* end alsa_set_params */
#else
/*
* Set parameters for sound card. (OSS only)
*
* See /usr/include/sys/soundcard.h for details.
*/
static int set_oss_params (int a, int fd, struct audio_s *pa)
{
int err;
int devcaps;
int asked_for;
char message[100];
int ossbuf_size_in_bytes;
err = ioctl (fd, SNDCTL_DSP_CHANNELS, &(pa->adev[a].num_channels));
if (err == -1) {
text_color_set(DW_COLOR_ERROR);
perror("Not able to set audio device number of channels");
return (-1);
}
asked_for = pa->adev[a].samples_per_sec;
err = ioctl (fd, SNDCTL_DSP_SPEED, &(pa->adev[a].samples_per_sec));
if (err == -1) {
text_color_set(DW_COLOR_ERROR);
perror("Not able to set audio device sample rate");
return (-1);
}
if (pa->adev[a].samples_per_sec != asked_for) {
text_color_set(DW_COLOR_INFO);
dw_printf ("Asked for %d samples/sec but actually using %d.\n",
asked_for, pa->adev[a].samples_per_sec);
}
/* This is actually a bit mask but it happens that */
/* 0x8 is unsigned 8 bit samples and */
/* 0x10 is signed 16 bit little endian. */
err = ioctl (fd, SNDCTL_DSP_SETFMT, &(pa->adev[a].bits_per_sample));
if (err == -1) {
text_color_set(DW_COLOR_ERROR);
perror("Not able to set audio device sample size");
return (-1);
}
/*
* Determine capabilities.
*/
err = ioctl (fd, SNDCTL_DSP_GETCAPS, &devcaps);
if (err == -1) {
text_color_set(DW_COLOR_ERROR);
perror("Not able to get audio device capabilities");
// Is this fatal? // return (-1);
}
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_open(): devcaps = %08x\n", devcaps);
if (devcaps & DSP_CAP_DUPLEX) dw_printf ("Full duplex record/playback.\n");
if (devcaps & DSP_CAP_BATCH) dw_printf ("Device has some kind of internal buffers which may cause delays.\n");
if (devcaps & ~ (DSP_CAP_DUPLEX | DSP_CAP_BATCH)) dw_printf ("Others...\n");
#endif
if (!(devcaps & DSP_CAP_DUPLEX)) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio device does not support full duplex\n");
// Do we care? // return (-1);
}
err = ioctl (fd, SNDCTL_DSP_SETDUPLEX, NULL);
if (err == -1) {
// text_color_set(DW_COLOR_ERROR);
// perror("Not able to set audio full duplex mode");
// Unfortunate but not a disaster.
}
/*
* Get preferred block size.
* Presumably this will provide the most efficient transfer.
*
* In my particular situation, this turned out to be
* 2816 for 11025 Hz 16 bit mono
* 5568 for 11025 Hz 16 bit stereo
* 11072 for 44100 Hz 16 bit mono
*
* This was long ago under different conditions.
* Should study this again some day.
*
* Your milage may vary.
*/
err = ioctl (fd, SNDCTL_DSP_GETBLKSIZE, &ossbuf_size_in_bytes);
if (err == -1) {
text_color_set(DW_COLOR_ERROR);
perror("Not able to get audio block size");
ossbuf_size_in_bytes = 2048; /* pick something reasonable */
}
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_open(): suggestd block size is %d\n", ossbuf_size_in_bytes);
#endif
/*
* That's 1/8 of a second which seems rather long if we want to
* respond quickly.
*/
ossbuf_size_in_bytes = calcbufsize(pa->adev[a].samples_per_sec, pa->adev[a].num_channels, pa->adev[a].bits_per_sample);
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_open(): using block size of %d\n", ossbuf_size_in_bytes);
#endif
#if 0
/* Original - dies without good explanation. */
assert (ossbuf_size_in_bytes >= 256 && ossbuf_size_in_bytes <= 32768);
#else
/* Version 1.3 - after a report of this situation for Mac OSX version. */
if (ossbuf_size_in_bytes < 256 || ossbuf_size_in_bytes > 32768) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio buffer has unexpected extreme size of %d bytes.\n", ossbuf_size_in_bytes);
dw_printf ("Detected at %s, line %d.\n", __FILE__, __LINE__);
dw_printf ("This might be caused by unusual audio device configuration values.\n");
ossbuf_size_in_bytes = 2048;
dw_printf ("Using %d to attempt recovery.\n", ossbuf_size_in_bytes);
}
#endif
return (ossbuf_size_in_bytes);
} /* end set_oss_params */
#endif
/*------------------------------------------------------------------
*
* Name: audio_get
*
* Purpose: Get one byte from the audio device.
*
* Inputs: a - Our number for audio device.
*
* Returns: 0 - 255 for a valid sample.
* -1 for any type of error.
*
* Description: The caller must deal with the details of mono/stereo
* and number of bytes per sample.
*
* This will wait if no data is currently available.
*
*----------------------------------------------------------------*/
// Use hot attribute for all functions called for every audio sample.
__attribute__((hot))
int audio_get (int a)
{
int n;
int retries = 0;
#if STATISTICS
/* Gather numbers for read from audio device. */
#define duration 100 /* report every 100 seconds. */
static time_t last_time[MAX_ADEVS];
time_t this_time[MAX_ADEVS];
static int sample_count[MAX_ADEVS];
static int error_count[MAX_ADEVS];
#endif
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_get():\n");
#endif
assert (adev[a].inbuf_size_in_bytes >= 100 && adev[a].inbuf_size_in_bytes <= 32768);
switch (adev[a].g_audio_in_type) {
/*
* Soundcard - ALSA
*/
case AUDIO_IN_TYPE_SOUNDCARD:
#if USE_ALSA
while (adev[a].inbuf_next >= adev[a].inbuf_len) {
assert (adev[a].audio_in_handle != NULL);
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_get(): readi asking for %d frames\n", adev[a].inbuf_size_in_bytes / adev[a].bytes_per_frame);
#endif
n = snd_pcm_readi (adev[a].audio_in_handle, adev[a].inbuf_ptr, adev[a].inbuf_size_in_bytes / adev[a].bytes_per_frame);
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_get(): readi asked for %d and got %d frames\n",
adev[a].inbuf_size_in_bytes / adev[a].bytes_per_frame, n);
#endif
if (n > 0) {
/* Success */
adev[a].inbuf_len = n * adev[a].bytes_per_frame; /* convert to number of bytes */
adev[a].inbuf_next = 0;
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
n,
save_audio_config_p->statistics_interval);
}
else if (n == 0) {
/* Didn't expect this, but it's not a problem. */
/* Wait a little while and try again. */
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio input got zero bytes: %s\n", snd_strerror(n));
SLEEP_MS(10);
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
}
else {
/* Error */
// TODO: Needs more study and testing.
// Only expected error conditions:
// -EBADFD PCM is not in the right state (SND_PCM_STATE_PREPARED or SND_PCM_STATE_RUNNING)
// -EPIPE an overrun occurred
// -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
// Data overrun is displayed as "broken pipe" which seems a little misleading.
// Add our own message which says something about CPU being too slow.
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio input device %d error code %d: %s\n", a, n, snd_strerror(n));
if (n == (-EPIPE)) {
dw_printf ("This is most likely caused by the CPU being too slow to keep up with the audio stream.\n");
dw_printf ("Use the \"top\" command, in another command window, to look at CPU usage.\n");
dw_printf ("This might be a temporary condition so we will attempt to recover a few times before giving up.\n");
}
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
0,
save_audio_config_p->statistics_interval);
/* Try to recover a few times and eventually give up. */
if (++retries > 10) {
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
return (-1);
}
if (n == -EPIPE) {
/* EPIPE means overrun */
snd_pcm_recover (adev[a].audio_in_handle, n, 1);
}
else {
/* Could be some temporary condition. */
/* Wait a little then try again. */
/* Sometimes I get "Resource temporarily available" */
/* when the Update Manager decides to run. */
SLEEP_MS (250);
snd_pcm_recover (adev[a].audio_in_handle, n, 1);
}
}
}
#else /* end ALSA, begin OSS */
/* Fixed in 1.2. This was formerly outside of the switch */
/* so the OSS version did not process stdin or UDP. */
while (adev[a].g_audio_in_type == AUDIO_IN_TYPE_SOUNDCARD && adev[a].inbuf_next >= adev[a].inbuf_len) {
assert (adev[a].oss_audio_device_fd > 0);
n = read (adev[a].oss_audio_device_fd, adev[a].inbuf_ptr, adev[a].inbuf_size_in_bytes);
//text_color_set(DW_COLOR_DEBUG);
// dw_printf ("audio_get(): read %d returns %d\n", adev[a].inbuf_size_in_bytes, n);
if (n < 0) {
text_color_set(DW_COLOR_ERROR);
perror("Can't read from audio device");
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
0,
save_audio_config_p->statistics_interval);
return (-1);
}
adev[a].inbuf_len = n;
adev[a].inbuf_next = 0;
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
n / (save_audio_config_p->adev[a].num_channels * save_audio_config_p->adev[a].bits_per_sample / 8),
save_audio_config_p->statistics_interval);
}
#endif /* USE_ALSA */
break;
/*
* UDP.
*/
case AUDIO_IN_TYPE_SDR_UDP:
while (adev[a].inbuf_next >= adev[a].inbuf_len) {
int res;
assert (adev[a].udp_sock > 0);
res = recv(adev[a].udp_sock, adev[a].inbuf_ptr, adev[a].inbuf_size_in_bytes, 0);
if (res < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Can't read from udp socket, res=%d", res);
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
0,
save_audio_config_p->statistics_interval);
return (-1);
}
adev[a].inbuf_len = res;
adev[a].inbuf_next = 0;
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
res / (save_audio_config_p->adev[a].num_channels * save_audio_config_p->adev[a].bits_per_sample / 8),
save_audio_config_p->statistics_interval);
}
break;
/*
* stdin.
*/
case AUDIO_IN_TYPE_STDIN:
while (adev[a].inbuf_next >= adev[a].inbuf_len) {
//int ch, res,i;
int res;
res = read(STDIN_FILENO, adev[a].inbuf_ptr, (size_t)adev[a].inbuf_size_in_bytes);
if (res <= 0) {
text_color_set(DW_COLOR_INFO);
dw_printf ("\nEnd of file on stdin. Exiting.\n");
exit (0);
}
audio_stats (a,
save_audio_config_p->adev[a].num_channels,
res / (save_audio_config_p->adev[a].num_channels * save_audio_config_p->adev[a].bits_per_sample / 8),
save_audio_config_p->statistics_interval);
adev[a].inbuf_len = res;
adev[a].inbuf_next = 0;
}
break;
}
if (adev[a].inbuf_next < adev[a].inbuf_len)
n = adev[a].inbuf_ptr[adev[a].inbuf_next++];
//No data to read, avoid reading outside buffer
else
n = 0;
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_get(): returns %d\n", n);
#endif
return (n);
} /* end audio_get */
/*------------------------------------------------------------------
*
* Name: audio_put
*
* Purpose: Send one byte to the audio device.
*
* Inputs: a
*
* c - One byte in range of 0 - 255.
*
* Returns: Normally non-negative.
* -1 for any type of error.
*
* Description: The caller must deal with the details of mono/stereo
* and number of bytes per sample.
*
* See Also: audio_flush
* audio_wait
*
*----------------------------------------------------------------*/
int audio_put (int a, int c)
{
/* Should never be full at this point. */
assert (adev[a].outbuf_len < adev[a].outbuf_size_in_bytes);
adev[a].outbuf_ptr[adev[a].outbuf_len++] = c;
if (adev[a].outbuf_len == adev[a].outbuf_size_in_bytes) {
return (audio_flush(a));
}
return (0);
} /* end audio_put */
/*------------------------------------------------------------------
*
* Name: audio_flush
*
* Purpose: Push out any partially filled output buffer.
*
* Returns: Normally non-negative.
* -1 for any type of error.
*
* See Also: audio_flush
* audio_wait
*
*----------------------------------------------------------------*/
int audio_flush (int a)
{
#if USE_ALSA
int k;
unsigned char *psound;
int retries = 10;
snd_pcm_status_t *status;
assert (adev[a].audio_out_handle != NULL);
/*
* Trying to set the automatic start threshold didn't have the desired
* effect. After the first transmitted packet, they are saved up
* for a few minutes and then all come out together.
*
* "Prepare" it if not already in the running state.
* We stop it at the end of each transmitted packet.
*/
snd_pcm_status_alloca(&status);
k = snd_pcm_status (adev[a].audio_out_handle, status);
if (k != 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio output get status error.\n%s\n", snd_strerror(k));
}
if ((k = snd_pcm_status_get_state(status)) != SND_PCM_STATE_RUNNING) {
//text_color_set(DW_COLOR_DEBUG);
//dw_printf ("Audio output state = %d. Try to start.\n", k);
k = snd_pcm_prepare (adev[a].audio_out_handle);
if (k != 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio output start error.\n%s\n", snd_strerror(k));
}
}
psound = adev[a].outbuf_ptr;
while (retries-- > 0) {
k = snd_pcm_writei (adev[a].audio_out_handle, psound, adev[a].outbuf_len / adev[a].bytes_per_frame);
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_flush(): snd_pcm_writei %d frames returns %d\n",
adev[a].outbuf_len / adev[a].bytes_per_frame, k);
fflush (stdout);
#endif
if (k == -EPIPE) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio output data underrun.\n");
/* No problemo. Recover and go around again. */
snd_pcm_recover (adev[a].audio_out_handle, k, 1);
}
else if (k == -ESTRPIPE) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Driver suspended, recovering\n");
snd_pcm_recover(adev[a].audio_out_handle, k, 1);
}
else if (k == -EBADFD) {
k = snd_pcm_prepare (adev[a].audio_out_handle);
if(k < 0) {
dw_printf ("Error preparing after bad state: %s\n", snd_strerror(k));
}
}
else if (k < 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio write error: %s\n", snd_strerror(k));
/* Some other error condition. */
/* Try again. What do we have to lose? */
k = snd_pcm_prepare (adev[a].audio_out_handle);
if(k < 0) {
dw_printf ("Error preparing after error: %s\n", snd_strerror(k));
}
}
else if (k != adev[a].outbuf_len / adev[a].bytes_per_frame) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio write took %d frames rather than %d.\n",
k, adev[a].outbuf_len / adev[a].bytes_per_frame);
/* Go around again with the rest of it. */
psound += k * adev[a].bytes_per_frame;
adev[a].outbuf_len -= k * adev[a].bytes_per_frame;
}
else {
/* Success! */
adev[a].outbuf_len = 0;
return (0);
}
}
text_color_set(DW_COLOR_ERROR);
dw_printf ("Audio write error retry count exceeded.\n");
adev[a].outbuf_len = 0;
return (-1);
#else /* OSS */
int k;
unsigned char *ptr;
int len;
ptr = adev[a].outbuf_ptr;
len = adev[a].outbuf_len;
while (len > 0) {
assert (adev[a].oss_audio_device_fd > 0);
k = write (adev[a].oss_audio_device_fd, ptr, len);
#if DEBUGx
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_flush(): write %d returns %d\n", len, k);
fflush (stdout);
#endif
if (k < 0) {
text_color_set(DW_COLOR_ERROR);
perror("Can't write to audio device");
adev[a].outbuf_len = 0;
return (-1);
}
if (k < len) {
/* presumably full but didn't block. */
usleep (10000);
}
ptr += k;
len -= k;
}
adev[a].outbuf_len = 0;
return (0);
#endif
} /* end audio_flush */
/*------------------------------------------------------------------
*
* Name: audio_wait
*
* Purpose: Finish up audio output before turning PTT off.
*
* Inputs: a - Index for audio device (not channel!)
*
* Returns: None.
*
* Description: Flush out any partially filled audio output buffer.
* Wait until all the queued up audio out has been played.
* Take any other necessary actions to stop audio output.
*
* In an ideal world:
*
* We would like to ask the hardware when all the queued
* up sound has actually come out the speaker.
*
* In reality:
*
* This has been found to be less than reliable in practice.
*
* Caller does the following:
*
* (1) Make note of when PTT is turned on.
* (2) Calculate how long it will take to transmit the
* frame including TXDELAY, frame (including
* "flags", data, FCS and bit stuffing), and TXTAIL.
* (3) Call this function, which might or might not wait long enough.
* (4) Add (1) and (2) resulting in when PTT should be turned off.
* (5) Take difference between current time and desired PPT off time
* and wait for additoinal time if required.
*
*----------------------------------------------------------------*/
void audio_wait (int a)
{
audio_flush (a);
#if USE_ALSA
/* For playback, this should wait for all pending frames */
/* to be played and then stop. */
snd_pcm_drain (adev[a].audio_out_handle);
/*
* When this was first implemented, I observed:
*
* "Experimentation reveals that snd_pcm_drain doesn't
* actually wait. It returns immediately.
* However it does serve a useful purpose of stopping
* the playback after all the queued up data is used."
*
*
* Now that I take a closer look at the transmit timing, for
* version 1.2, it seems that snd_pcm_drain DOES wait until all
* all pending frames have been played.
* Either way, the caller will now compensate for it.
*/
#else
assert (adev[a].oss_audio_device_fd > 0);
// This caused a crash later on Cygwin.
// Haven't tried it on other (non-Linux) Unix yet.
// err = ioctl (adev[a].oss_audio_device_fd, SNDCTL_DSP_SYNC, NULL);
#endif
#if DEBUG
text_color_set(DW_COLOR_DEBUG);
dw_printf ("audio_wait(): after sync, status=%d\n", err);
#endif
} /* end audio_wait */
/*------------------------------------------------------------------
*
* Name: audio_close
*
* Purpose: Close the audio device(s).
*
* Returns: Normally non-negative.
* -1 for any type of error.
*
*
*----------------------------------------------------------------*/
int audio_close (void)
{
int err = 0;
int a;
for (a = 0; a < MAX_ADEVS; a++) {
#if USE_ALSA
if (adev[a].audio_in_handle != NULL && adev[a].audio_out_handle != NULL) {
audio_wait (a);
snd_pcm_close (adev[a].audio_in_handle);
snd_pcm_close (adev[a].audio_out_handle);
#else
if (adev[a].oss_audio_device_fd > 0) {
audio_wait (a);
close (adev[a].oss_audio_device_fd);
adev[a].oss_audio_device_fd = -1;
#endif
free (adev[a].inbuf_ptr);
free (adev[a].outbuf_ptr);
adev[a].inbuf_size_in_bytes = 0;
adev[a].inbuf_ptr = NULL;
adev[a].inbuf_len = 0;
adev[a].inbuf_next = 0;
adev[a].outbuf_size_in_bytes = 0;
adev[a].outbuf_ptr = NULL;
adev[a].outbuf_len = 0;
}
}
return (err);
} /* end audio_close */
/* end audio.c */
Reference in New Issue View Git Blame Copy Permalink