X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=play.c;h=5d32df7cad66d05726c1cff1256171bf7e6b32c3;hb=6597f6cdccfd678eca2fecc0ed95dc35039413d9;hp=ad522a9521a95d75e954697ed7b0e0244dfade53;hpb=d6aab2f273e8b54bf351c3b73b4a50168c8be917;p=paraslash.git diff --git a/play.c b/play.c index ad522a95..5d32df7c 100644 --- a/play.c +++ b/play.c @@ -28,77 +28,77 @@ #include "fd.h" #include "play.cmdline.h" #include +#include "string.h" +#include "error.h" -enum { E_BROKEN_CONF, /* Broken configuration for this PCM */ - E_ACCESS_TYPE, /* Access type not available */ - E_SAMPLE_FORMAT, /* Sample format not available */ - E_CHANNEL_COUNT, /* Channels count not available */ - E_HW_PARAMS, /* Unable to install hw params */ - E_SW_PARAMS, /* Unable to install sw params */ - E_BAD_PERIOD, /* Can't use period equal to buffer size */ - E_GET_XFER, /* Unable to obtain xfer align */ - E_SET_XFER, /* snd_pcm_sw_params_set_xfer_align failed */ - E_MEM, /* not enough memory */ - E_READ, /* read error */ - E_WRITE, /* write error */ - E_PIPE, /* write to pipe with other side closed */ - E_PCM_OPEN, /* unable to open pcm */ - E_SND_PCM_INFO, /* pcm info error */ - E_GET_BUFFER_TIME, /* snd_pcm_hw_params_get_buffer_time_max failed */ - E_SET_BUFFER_TIME, /* snd_pcm_hw_params_set_buffer_time_near failed */ - E_SET_RATE, /* snd_pcm_hw_params_set_rate_near failed */ - E_START_THRESHOLD, /* snd_pcm_sw_params_set_start_threshold failed */ - E_STOP_THRESHOLD, /* snd_pcm_sw_params_set_stop_threshold failed */ - E_LOG, /* snd_output_stdio_attach failed */ - E_SYNTAX /* could not parse start_time option */ +#define FORMAT SND_PCM_FORMAT_S16_LE + +struct private_alsa_data { + snd_pcm_t *handle; + size_t bytes_per_frame; }; -#define FORMAT SND_PCM_FORMAT_S16_LE +struct writer_node { + struct writer *writer; + void *private_data; + int chunk_bytes; +}; + +struct writer { + int (*open)(struct writer_node *); + int (*write)(char *data, size_t nbytes, struct writer_node *); + void (*close)(struct writer_node *); + void (*shutdown)(struct writer_node *); +}; + +#define NUM_WRITERS 1 +static struct writer writers[NUM_WRITERS]; +#define FOR_EACH_WRITER(i) for (i = 0; i < NUM_WRITERS, i++) +static struct writer_node *writer_nodes; -#define EXIT(EXP) \ -do { if (EXP) \ - fprintf (stderr, "error: " #EXP "\n"); exit(EXP);} \ -while (0) -static snd_pcm_t *handle; static unsigned char *audiobuf; -static snd_pcm_uframes_t chunk_size; -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,...) +INIT_PLAY_ERRLISTS; + +void para_log(int ll, const char* fmt,...) { va_list argp; + if (ll < conf.loglevel_arg) + return; va_start(argp, fmt); vfprintf(stderr, fmt, argp); va_end(argp); } -/* - * read_wav_header - read WAV_HEADER_LEN bytes from stdin to audio buffer +/** + * read WAV_HEADER_LEN bytes from stdin to audio buffer * - * Exit on errors and on eof before WAV_HEADER_LEN could be read. + * \return -E_READ_HDR on errors and on eof before WAV_HEADER_LEN could be + * read. A positive return value indicates success. */ -static void read_wav_header(void) +static int read_wav_header(void) { ssize_t ret, count = 0; while (count < WAV_HEADER_LEN) { ret = read(STDIN_FILENO, audiobuf + count, WAV_HEADER_LEN - count); if (ret <= 0) - EXIT(E_READ); + return -E_READ_HDR; count += ret; } + return 1; } /* - * 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 int alsa_open(struct writer_node *w) { snd_pcm_hw_params_t *hwparams; snd_pcm_sw_params_t *swparams; @@ -106,91 +106,132 @@ static void set_alsa_params(void) stop_threshold; unsigned buffer_time = 0; int err; + snd_pcm_info_t *info; + snd_output_t *log; + snd_pcm_uframes_t period_size; + struct private_alsa_data *pad = para_malloc(sizeof(struct private_alsa_data)); + w->private_data = pad; + + snd_pcm_info_alloca(&info); + if (snd_output_stdio_attach(&log, stderr, 0) < 0) + return -E_ALSA_LOG; + err = snd_pcm_open(&pad->handle, conf.device_arg, + SND_PCM_STREAM_PLAYBACK, 0); + if (err < 0) + return -E_PCM_OPEN; + if ((err = snd_pcm_info(pad->handle, info)) < 0) + return -E_SND_PCM_INFO; snd_pcm_hw_params_alloca(&hwparams); snd_pcm_sw_params_alloca(&swparams); - if (snd_pcm_hw_params_any(handle, hwparams) < 0) - EXIT(E_BROKEN_CONF); - if (snd_pcm_hw_params_set_access(handle, hwparams, + if (snd_pcm_hw_params_any(pad->handle, hwparams) < 0) + return -E_BROKEN_CONF; + if (snd_pcm_hw_params_set_access(pad->handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) - EXIT(E_ACCESS_TYPE); - if (snd_pcm_hw_params_set_format(handle, hwparams, FORMAT) < 0) - 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, + return -E_ACCESS_TYPE; + if (snd_pcm_hw_params_set_format(pad->handle, hwparams, FORMAT) < 0) + return -E_SAMPLE_FORMAT; + if (snd_pcm_hw_params_set_channels(pad->handle, hwparams, + conf.channels_arg) < 0) + return -E_CHANNEL_COUNT; + if (snd_pcm_hw_params_set_rate_near(pad->handle, hwparams, (unsigned int*) &conf.sample_rate_arg, 0) < 0) - EXIT(E_SET_RATE); + return -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); + return -E_GET_BUFFER_TIME; PARA_DEBUG_LOG("buffer time: %d\n", buffer_time); - if (snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, + if (snd_pcm_hw_params_set_buffer_time_near(pad->handle, hwparams, &buffer_time, 0) < 0) - EXIT(E_SET_BUFFER_TIME); - if (snd_pcm_hw_params(handle, hwparams) < 0) - EXIT(E_HW_PARAMS); - snd_pcm_hw_params_get_period_size(hwparams, &chunk_size, 0); + return -E_SET_BUFFER_TIME; + if (snd_pcm_hw_params(pad->handle, hwparams) < 0) + return -E_HW_PARAMS; + snd_pcm_hw_params_get_period_size(hwparams, &period_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); + PARA_DEBUG_LOG("buffer size: %lu, period_size: %lu\n", buffer_size, + period_size); + if (period_size == buffer_size) + return -E_BAD_PERIOD; + snd_pcm_sw_params_current(pad->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_avail_min(handle, swparams, chunk_size); + return -E_GET_XFER; + snd_pcm_sw_params_set_avail_min(pad->handle, swparams, period_size); /* round to closest transfer boundary */ start_threshold = (buffer_size / xfer_align) * xfer_align; if (start_threshold < 1) start_threshold = 1; - if (snd_pcm_sw_params_set_start_threshold(handle, swparams, + if (snd_pcm_sw_params_set_start_threshold(pad->handle, swparams, start_threshold) < 0) - EXIT(E_START_THRESHOLD); + return -E_START_THRESHOLD; stop_threshold = buffer_size; - if (snd_pcm_sw_params_set_stop_threshold(handle, swparams, + if (snd_pcm_sw_params_set_stop_threshold(pad->handle, swparams, stop_threshold) < 0) - EXIT(E_STOP_THRESHOLD); - if (snd_pcm_sw_params_set_xfer_align(handle, swparams, xfer_align) < 0) - EXIT(E_SET_XFER); - if (snd_pcm_sw_params(handle, swparams) < 0) - EXIT(E_SW_PARAMS); - bytes_per_frame = snd_pcm_format_physical_width(FORMAT) * conf.channels_arg / 8; + return -E_STOP_THRESHOLD; + if (snd_pcm_sw_params_set_xfer_align(pad->handle, swparams, + xfer_align) < 0) + return -E_SET_XFER; + if (snd_pcm_sw_params(pad->handle, swparams) < 0) + return -E_SW_PARAMS; + pad->bytes_per_frame = snd_pcm_format_physical_width(FORMAT) + * conf.channels_arg / 8; + return period_size * pad->bytes_per_frame; } -/* - * 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. + * \return Number of bytes written, -E_ALSA_WRITE on errors. */ -static snd_pcm_sframes_t pcm_write(u_char *data, size_t count) +static int alsa_write(char *data, size_t nbytes, struct writer_node *wn) { + struct private_alsa_data *pad = wn->private_data; + size_t frames = nbytes / pad->bytes_per_frame; + unsigned char *d = data; snd_pcm_sframes_t r, result = 0; - while (count > 0) { + + while (frames > 0) { /* write interleaved frames */ - r = snd_pcm_writei(handle, data, count); + r = snd_pcm_writei(pad->handle, d, frames); if (r < 0) PARA_ERROR_LOG("write error: %s\n", snd_strerror(r)); - if (r == -EAGAIN || (r >= 0 && r < count)) - snd_pcm_wait(handle, 1); + if (r == -EAGAIN || (r >= 0 && r < frames)) + snd_pcm_wait(pad->handle, 1); else if (r == -EPIPE) - snd_pcm_prepare(handle); + snd_pcm_prepare(pad->handle); else if (r < 0) - EXIT(E_WRITE); + return -E_ALSA_WRITE; if (r > 0) { result += r; - count -= r; - data += r * bytes_per_frame; + frames -= r; + d += r * pad->bytes_per_frame; } } - return result; + return result * pad->bytes_per_frame; } -/* - * start_time_in_future - check if current time is later than start_time +static void alsa_close(struct writer_node *wn) +{ + struct private_alsa_data *pad = wn->private_data; + snd_pcm_drain(pad->handle); + snd_pcm_close(pad->handle); + snd_config_update_free_global(); + free(pad); +} + +void alsa_writer_init(struct writer *w) +{ + w->open = alsa_open; + w->write = alsa_write; + w->close = alsa_close; + w->shutdown = NULL; /* nothing to do */ +} + + +/** + * check if current time is later than start_time * \param diff pointer to write remaining time to * * If start_time was not given, or current time is later than given @@ -209,8 +250,8 @@ static int start_time_in_future(struct timeval *diff) return tv_diff(start_time, &now, diff) > 0? 1 : 0; } -/* - * do_initial_delay - sleep until time given at command line +/** + * sleep until time given at command line * * This is called if the initial buffer is filled. It returns * immediately if no start_time was given at the command line @@ -224,61 +265,127 @@ static void do_initial_delay(struct timeval *delay) while (start_time_in_future(delay)); } -/* - * play_pcm - play raw pcm data +static int read_stdin(char *buf, size_t bytes_to_load, size_t *loaded) +{ + ssize_t ret; + + while (*loaded < bytes_to_load) { + ret = read(STDIN_FILENO, buf + *loaded, bytes_to_load - *loaded); + if (ret <= 0) { + if (ret < 0) + ret = -E_READ_STDIN; + return ret; + } + *loaded += ret; + } + return 1; +} + +/** + * play raw pcm data * \param loaded number of bytes already loaded * * If start_time was given, prebuffer data until buffer is full or * start_time is reached. In any case, do not start playing before * start_time. + * + * \return positive on success, negative on errors. */ -static void play_pcm(size_t loaded) +static int play_pcm(size_t loaded) { - size_t chunk_bytes, bufsize, written = 0, prebuf_size; - ssize_t ret; - unsigned char *p; + size_t bufsize, min_written = 0, prebuf_size, bytes_to_load; struct timeval delay; + int i, max_chunk_bytes = 0, ret, not_yet_started = 1, need_more_writes; + struct writer_node *wn; + size_t *written = para_calloc(1 * sizeof(size_t)); - set_alsa_params(); - chunk_bytes = chunk_size * bytes_per_frame; - bufsize = (conf.bufsize_arg * 1024 / chunk_bytes) * chunk_bytes; - audiobuf = realloc(audiobuf, bufsize); - if (!audiobuf) - EXIT(E_MEM); + for (i = 0; i < 1; i++) { + wn = &writer_nodes[i]; + ret = wn->writer->open(wn); + if (ret < 0) + goto out; + wn->chunk_bytes = ret; + max_chunk_bytes = PARA_MAX(max_chunk_bytes, ret); + } + PARA_INFO_LOG("max chunk_bytes: %d\n", max_chunk_bytes); + bufsize = (conf.bufsize_arg * 1024 / max_chunk_bytes) * max_chunk_bytes; + audiobuf = para_realloc(audiobuf, bufsize); prebuf_size = conf.prebuffer_arg * bufsize / 100; + bytes_to_load = PARA_MAX(prebuf_size, max_chunk_bytes); + ret = read_stdin(audiobuf, bytes_to_load, &loaded); + if (ret <= 0 || loaded < bytes_to_load) { + if (ret >= 0) + ret = -E_PREMATURE_END; + goto out; + } + if (not_yet_started && start_time && start_time_in_future(&delay)) + do_initial_delay(&delay); + not_yet_started = 0; again: - if (!written) { - if (loaded < prebuf_size) - goto read; - if (start_time && start_time_in_future(&delay)) { - do_initial_delay(&delay); - start_time = NULL; + need_more_writes = 1; + while (need_more_writes) { + need_more_writes = 0; + for (i = 0; i < 1; i++) { + unsigned char *p = audiobuf + written[i]; + wn = &writer_nodes[i]; + if (!i) + min_written = written[i]; + else + min_written = PARA_MIN(min_written, written[i]); + if (loaded < wn->chunk_bytes + written[i]) + continue; + ret = wn->writer->write(p, wn->chunk_bytes, wn); + if (ret < 0) + goto out; + if (ret != wn->chunk_bytes) + PARA_WARNING_LOG("short write: %d/%d", ret, + wn->chunk_bytes); + written[i] += ret; + need_more_writes = 1; } } - p = audiobuf; - while (loaded >= chunk_bytes) { - ret = pcm_write(p, chunk_size) * bytes_per_frame; - p += ret; - written += ret; - loaded -= ret; + loaded -= min_written; + if (loaded > 0) { + if (loaded >= bufsize) { + ret = -E_PLAY_OVERRUN; + goto out; + } + memmove(audiobuf, audiobuf + min_written, loaded); } - if (loaded && p != audiobuf) - memmove(audiobuf, p, loaded); -read: - ret = read(STDIN_FILENO, audiobuf + loaded, bufsize - loaded); + for (i = 0; i < 1; i++) + written[i] -= min_written; + bytes_to_load = PARA_MIN(max_chunk_bytes, bufsize); + ret = read_stdin(audiobuf, bytes_to_load, &loaded); if (ret < 0) - EXIT(E_READ); - if (ret) { - loaded += ret; + goto out; + if (ret) goto again; + for (i = 0; i < 1; i++) { + unsigned char *p = audiobuf + written[i]; + wn = &writer_nodes[i]; + int bytes_to_write; + if (written[i] >= loaded) + continue; + bytes_to_write = PARA_MIN(wn->chunk_bytes, loaded - written[i]); + ret = wn->writer->write(p, bytes_to_write, wn); + if (ret < 0) + goto out; + written[i] += ret; } - snd_pcm_drain(handle); + ret = 0; +out: + free(written); + for (i = 0; i < 1; i++) { + wn = &writer_nodes[i]; + wn->writer->close(wn); + } + return ret; } -/* - * check_wave - test if audio buffer contains a valid wave header +/** + * test if audio buffer contains a valid wave header * - * If not, return 0, otherwise, store number of channels and sample rate + * \return If not, return 0, otherwise, store number of channels and sample rate * in struct conf and return WAV_HEADER_LEN. */ static size_t check_wave(void) @@ -293,33 +400,33 @@ static size_t check_wave(void) int main(int argc, char *argv[]) { - snd_pcm_info_t *info; - snd_output_t *log; struct timeval tv; - int err; + int ret = -E_PLAY_SYNTAX; cmdline_parser(argc, argv, &conf); + if (conf.prebuffer_arg < 0 || conf.prebuffer_arg > 100) + goto out; if (conf.start_time_given) { if (sscanf(conf.start_time_arg, "%lu:%lu", &tv.tv_sec, &tv.tv_usec) != 2) - EXIT(E_SYNTAX); + goto out; start_time = &tv; } - 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); + /* call init for each supported writer */ + alsa_writer_init(&writers[0]); + /* one for each given writer */ + writer_nodes = para_calloc(2 * sizeof(struct writer_node)); + writer_nodes[0].writer = &writers[0]; /* alsa */ + + audiobuf = para_malloc(WAV_HEADER_LEN); + ret = read_wav_header(); + if (ret < 0) + goto out; + ret = play_pcm(check_wave()); +out: free(audiobuf); -// snd_output_close(log); - snd_config_update_free_global(); - return EXIT_SUCCESS; + free(writer_nodes); + if (ret < 0) + PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + return ret; }