* based on the vplay program by Michael Beck.
*/
-#define BUFFER_SIZE 1000 * 1000
#define WAV_HEADER_LEN 44
#include <sys/time.h> /* gettimeofday */
#include "para.h"
+#include "fd.h"
#include "play.cmdline.h"
#include <alsa/asoundlib.h>
while (0)
static snd_pcm_t *handle;
-static unsigned char *audiobuf;
static snd_pcm_uframes_t chunk_size;
+static unsigned char *audiobuf;
static size_t bytes_per_frame;
static struct timeval *start_time;
static struct gengetopt_args_info conf;
+void para_log(__a_unused int ll, const char* fmt,...)
+{
+ va_list argp;
+
+ va_start(argp, fmt);
+ vfprintf(stderr, fmt, argp);
+ va_end(argp);
+}
+
/*
* read_wav_header - read WAV_HEADER_LEN bytes from stdin to audio buffer
*
}
/*
- * set_alsa_params - Prepare the PCM handle for writing
+ * open and prepare the PCM handle for writing
*
* Install PCM software and hardware configuration. Exit on errors.
*/
-static void set_alsa_params(void)
+static void alsa_init(void)
{
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
stop_threshold;
unsigned buffer_time = 0;
int err;
+ snd_pcm_info_t *info;
+ snd_output_t *log;
+
+ snd_pcm_info_alloca(&info);
+ if (snd_output_stdio_attach(&log, stderr, 0) < 0)
+ EXIT(E_LOG);
+ err = snd_pcm_open(&handle, conf.device_arg,
+ SND_PCM_STREAM_PLAYBACK, 0);
+ if (err < 0)
+ EXIT(E_PCM_OPEN);
+ if ((err = snd_pcm_info(handle, info)) < 0)
+ EXIT(E_SND_PCM_INFO);
snd_pcm_hw_params_alloca(&hwparams);
snd_pcm_sw_params_alloca(&swparams);
EXIT(E_SAMPLE_FORMAT);
if (snd_pcm_hw_params_set_channels(handle, hwparams, conf.channels_arg) < 0)
EXIT(E_CHANNEL_COUNT);
- if (snd_pcm_hw_params_set_rate_near(handle, hwparams, (unsigned int*) &conf.sample_rate_arg, 0) < 0)
+ if (snd_pcm_hw_params_set_rate_near(handle, hwparams,
+ (unsigned int*) &conf.sample_rate_arg, 0) < 0)
EXIT(E_SET_RATE);
err = snd_pcm_hw_params_get_buffer_time_max(hwparams, &buffer_time, 0);
if (err < 0 || !buffer_time)
EXIT(E_GET_BUFFER_TIME);
- if (buffer_time > 500000)
- buffer_time = 500000;
+ PARA_DEBUG_LOG("buffer time: %d\n", buffer_time);
if (snd_pcm_hw_params_set_buffer_time_near(handle, hwparams,
&buffer_time, 0) < 0)
EXIT(E_SET_BUFFER_TIME);
EXIT(E_HW_PARAMS);
snd_pcm_hw_params_get_period_size(hwparams, &chunk_size, 0);
snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
+ PARA_DEBUG_LOG("buffer size: %lu, period_size: %lu\n", buffer_size, chunk_size);
if (chunk_size == buffer_size)
EXIT(E_BAD_PERIOD);
snd_pcm_sw_params_current(handle, swparams);
err = snd_pcm_sw_params_get_xfer_align(swparams, &xfer_align);
if (err < 0 || !xfer_align)
EXIT(E_GET_XFER);
- snd_pcm_sw_params_set_sleep_min(handle, swparams, 0);
+// snd_pcm_sw_params_set_sleep_min(handle, swparams, 0);
snd_pcm_sw_params_set_avail_min(handle, swparams, chunk_size);
/* round to closest transfer boundary */
start_threshold = (buffer_size / xfer_align) * xfer_align;
bytes_per_frame = snd_pcm_format_physical_width(FORMAT) * conf.channels_arg / 8;
}
-/*
- * pcm_write - push out pcm frames
+/**
+ * push out pcm frames
* \param data pointer do data to be written
- * \param count number of frames
+ * \param nbytes number of bytes (not frames)
*
* \return Number of bytes written. Exit on errors.
*/
-static snd_pcm_sframes_t pcm_write(u_char *data, size_t count)
+int alsa_write(u_char *data, size_t nbytes)
{
+ size_t count = nbytes / bytes_per_frame;
snd_pcm_sframes_t r, result = 0;
while (count > 0) {
/* write interleaved frames */
r = snd_pcm_writei(handle, data, count);
if (r < 0)
- fprintf(stderr, "write error: %s\n", snd_strerror(r));
+ PARA_ERROR_LOG("write error: %s\n", snd_strerror(r));
if (r == -EAGAIN || (r >= 0 && r < count))
snd_pcm_wait(handle, 1);
else if (r == -EPIPE)
data += r * bytes_per_frame;
}
}
- return result;
+ return result * bytes_per_frame;
+}
+
+void alsa_shutdown(void)
+{
+ snd_pcm_drain(handle);
+ snd_pcm_close(handle);
+ snd_config_update_free_global();
}
/*
*/
static void do_initial_delay(struct timeval *delay)
{
- fprintf(stderr, "sleeping %lums\n", tv2ms(delay));
do
- select(1, NULL, NULL, NULL, delay);
+ para_select(1, NULL, NULL, delay);
while (start_time_in_future(delay));
}
*/
static void play_pcm(size_t loaded)
{
- size_t chunk_bytes, bufsize, written = 0;
+ size_t chunk_bytes, bufsize, written = 0, prebuf_size;
ssize_t ret;
unsigned char *p;
- int dont_write;
struct timeval delay;
- set_alsa_params();
+ alsa_init();
chunk_bytes = chunk_size * bytes_per_frame;
- bufsize = chunk_bytes * 1024;
+ bufsize = (conf.bufsize_arg * 1024 / chunk_bytes) * chunk_bytes;
audiobuf = realloc(audiobuf, bufsize);
if (!audiobuf)
EXIT(E_MEM);
+ prebuf_size = conf.prebuffer_arg * bufsize / 100;
again:
- dont_write = 0;
- if (!written && start_time)
- dont_write = start_time_in_future(&delay);
- if (!dont_write) {
- p = audiobuf;
- while (loaded >= chunk_bytes) {
- ret = (ssize_t) pcm_write(p, chunk_size) * bytes_per_frame;
- if (ret <= 0) {
- fprintf(stderr, "write error: %d\n", ret);
- EXIT(E_WRITE);
- }
- p += ret;
- written += ret;
- loaded -= ret;
- }
- if (loaded && p != audiobuf) {
- fprintf(stderr, "memcpy: %d\n", loaded);
- memcpy(audiobuf, p, loaded);
+ if (!written) {
+ if (loaded < prebuf_size)
+ goto read;
+ if (start_time && start_time_in_future(&delay)) {
+ do_initial_delay(&delay);
+ start_time = NULL;
}
}
- if (dont_write && loaded >= bufsize) {
- do_initial_delay(&delay);
- start_time = NULL;
- goto again;
+ p = audiobuf;
+ while (loaded >= chunk_bytes) {
+ ret = alsa_write(p, chunk_bytes);
+ p += ret;
+ written += ret;
+ loaded -= ret;
}
- ret = read(STDIN_FILENO, audiobuf, bufsize - loaded);
+ if (loaded && p != audiobuf)
+ memmove(audiobuf, p, loaded);
+read:
+ ret = read(STDIN_FILENO, audiobuf + loaded, bufsize - loaded);
if (ret < 0)
EXIT(E_READ);
if (ret) {
loaded += ret;
goto again;
}
- snd_pcm_drain(handle);
+ alsa_shutdown();
}
/*
return WAV_HEADER_LEN;
conf.channels_arg = (unsigned) a[22];
conf.sample_rate_arg = a[24] + (a[25] << 8) + (a[26] << 16) + (a[27] << 24);
-// fprintf(stderr, "channels: %d, rate: %d\n", conf.channels_arg,
-// conf.sample_rate_arg);
return 0;
}
int main(int argc, char *argv[])
{
- snd_pcm_info_t *info;
- snd_output_t *log;
struct timeval tv;
- int err;
cmdline_parser(argc, argv, &conf);
if (conf.start_time_given) {
EXIT(E_SYNTAX);
start_time = &tv;
}
-// fprintf(stderr, "argc=%d, argv[1]=%s\n",argc, argv[1]);
- snd_pcm_info_alloca(&info);
- if (snd_output_stdio_attach(&log, stderr, 0) < 0)
- EXIT(E_LOG);
- err = snd_pcm_open(&handle, conf.device_arg,
- SND_PCM_STREAM_PLAYBACK, 0);
- if (err < 0)
- EXIT(E_PCM_OPEN);
- if ((err = snd_pcm_info(handle, info)) < 0)
- EXIT(E_SND_PCM_INFO);
audiobuf = malloc(WAV_HEADER_LEN);
read_wav_header();
play_pcm(check_wave());
- snd_pcm_close(handle);
free(audiobuf);
-// snd_output_close(log);
- snd_config_update_free_global();
return EXIT_SUCCESS;
}
projects / paraslash.git / blobdiff