X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=play.c;h=ab5413457b5609ef8dfb12dee2fdae88083b22da;hp=99c231697c76707008326ce2b587d4f5558b177f;hb=dbe43bcc5e084cce14dc83647eaba25099226929;hpb=2ed89c59f0efcd0a2763f47c7d3455663241e623 diff --git a/play.c b/play.c index 99c23169..ab541345 100644 --- a/play.c +++ b/play.c @@ -22,74 +22,60 @@ * based on the vplay program by Michael Beck. */ -#define BUFFER_SIZE 1000 * 1000 #define WAV_HEADER_LEN 44 #include /* gettimeofday */ #include "para.h" +#include "fd.h" #include "play.cmdline.h" #include - -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 */ -}; +#include "string.h" +#include "error.h" #define FORMAT SND_PCM_FORMAT_S16_LE -#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 unsigned char *audiobuf; static size_t bytes_per_frame; static struct timeval *start_time; static struct gengetopt_args_info conf; -/* - * read_wav_header - read WAV_HEADER_LEN bytes from stdin to audio buffer +INIT_PLAY_ERRLISTS; + +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_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_init(void) { snd_pcm_hw_params_t *hwparams; snd_pcm_sw_params_t *swparams; @@ -97,39 +83,52 @@ 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_info_alloca(&info); + if (snd_output_stdio_attach(&log, stderr, 0) < 0) + return -E_ALSA_LOG; + err = snd_pcm_open(&handle, conf.device_arg, + SND_PCM_STREAM_PLAYBACK, 0); + if (err < 0) + return -E_PCM_OPEN; + if ((err = snd_pcm_info(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); + return -E_BROKEN_CONF; if (snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) - EXIT(E_ACCESS_TYPE); + return -E_ACCESS_TYPE; if (snd_pcm_hw_params_set_format(handle, hwparams, FORMAT) < 0) - EXIT(E_SAMPLE_FORMAT); + return -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) - EXIT(E_SET_RATE); + return -E_CHANNEL_COUNT; + if (snd_pcm_hw_params_set_rate_near(handle, hwparams, + (unsigned int*) &conf.sample_rate_arg, 0) < 0) + 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); - if (buffer_time > 500000) - buffer_time = 500000; + 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, &buffer_time, 0) < 0) - EXIT(E_SET_BUFFER_TIME); + return -E_SET_BUFFER_TIME; if (snd_pcm_hw_params(handle, hwparams) < 0) - EXIT(E_HW_PARAMS); + return -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); + return -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); + return -E_GET_XFER; +// 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; @@ -137,57 +136,60 @@ static void set_alsa_params(void) start_threshold = 1; if (snd_pcm_sw_params_set_start_threshold(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, stop_threshold) < 0) - EXIT(E_STOP_THRESHOLD); + return -E_STOP_THRESHOLD; if (snd_pcm_sw_params_set_xfer_align(handle, swparams, xfer_align) < 0) - EXIT(E_SET_XFER); + return -E_SET_XFER; if (snd_pcm_sw_params(handle, swparams) < 0) - EXIT(E_SW_PARAMS); + return -E_SW_PARAMS; bytes_per_frame = snd_pcm_format_physical_width(FORMAT) * conf.channels_arg / 8; + return chunk_size * bytes_per_frame; } -/* - * pcm_write - push out pcm frames - * @data: pointer do data to be written - * @count: number of frames +/** + * push out pcm frames + * \param data pointer do data to be written + * \param nbytes number of bytes (not frames) * - * Return value: 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(u_char *data, size_t nbytes) { + size_t frames = nbytes / bytes_per_frame; snd_pcm_sframes_t r, result = 0; -#if 0 - if (count < chunk_size) { - snd_pcm_format_set_silence(FORMAT, data - + count * bytes_per_frame, - (chunk_size - count) * conf.channels_arg); - count = chunk_size; - } -#endif - while (count > 0) { + while (frames > 0) { /* write interleaved frames */ - r = snd_pcm_writei(handle, data, count); - if (r == -EAGAIN || (r >= 0 && r < count)) + r = snd_pcm_writei(handle, data, frames); + if (r < 0) + PARA_ERROR_LOG("write error: %s\n", snd_strerror(r)); + if (r == -EAGAIN || (r >= 0 && r < frames)) snd_pcm_wait(handle, 1); else if (r == -EPIPE) snd_pcm_prepare(handle); else if (r < 0) - EXIT(E_WRITE); + return -E_ALSA_WRITE; if (r > 0) { result += r; - count -= r; + frames -= r; data += r * bytes_per_frame; } } - return result; + return result * bytes_per_frame; } -/* - * start_time_in_future - check if current time is later than start_time - * @diff: pointer to write remaining time to +static void alsa_shutdown(void) +{ + snd_pcm_drain(handle); + snd_pcm_close(handle); + snd_config_update_free_global(); +} + +/** + * 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 * start_time, return 0. Otherwise, return 1 and write the time @@ -205,94 +207,84 @@ 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 * or if the given start time is in the past. * */ -static void do_initial_delay(void) +static void do_initial_delay(struct timeval *delay) { - struct timeval diff; - int ret; - - fprintf(stderr, "initial delay\n"); - if (!conf.start_time_given) - return; -again: - if (!start_time_in_future(&diff)) - return; - ret = select(1, NULL, NULL, NULL, &diff); - if (ret < 0 && errno == EINTR) - goto again; + do + para_select(1, NULL, NULL, delay); + while (start_time_in_future(delay)); } - -/* - * play_pcm - play raw pcm data - * @l: number of bytes already loaded +/** + * 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 l) +static int play_pcm(size_t loaded) { - ssize_t r, w; - unsigned long written = 0; - size_t chunk_bytes; + size_t bufsize, written = 0, prebuf_size; + unsigned char *p; + struct timeval delay; + int chunk_bytes, ret = alsa_init(); - set_alsa_params(); - chunk_bytes = chunk_size * bytes_per_frame; - audiobuf = realloc(audiobuf, BUFFER_SIZE); -// fprintf(stderr, "loaded: %d, chunk_bytes: %d\n", l, chunk_bytes); - if (!audiobuf) - EXIT(E_MEM); - for (;;) { - for (;;) { - if (l >= chunk_bytes) { - if (written) - break; - if (!start_time) - break; - if (!start_time_in_future(NULL)) - break; - if (l > BUFFER_SIZE) { - do_initial_delay(); - break; - } - } -// fprintf(stderr, "l = %d, chunk_Bytes = %d\n", l, chunk_bytes); - r = read(STDIN_FILENO, audiobuf + l, BUFFER_SIZE -l); - if (r < 0) - EXIT(E_READ); - l += r; -// fprintf(stderr, "loaded: %d, r= %d\n", l, r); - if (!r) - goto out;; + if (ret < 0) + goto out; + chunk_bytes = ret; + bufsize = (conf.bufsize_arg * 1024 / chunk_bytes) * chunk_bytes; + audiobuf = para_realloc(audiobuf, bufsize); + prebuf_size = conf.prebuffer_arg * bufsize / 100; +again: + if (!written) { + if (loaded < prebuf_size) + goto read; + if (start_time && start_time_in_future(&delay)) { + do_initial_delay(&delay); + start_time = NULL; } - w = MIN(chunk_bytes, l); -// fprintf(stderr, "play: writing %d\n", w); - r = (ssize_t) pcm_write(audiobuf, w / bytes_per_frame) * bytes_per_frame; -// fprintf(stderr, "wrote %d\n", r); - if (r < 0) - EXIT(E_WRITE); - written += r; - l -= r; - if (l) - memmove(audiobuf, audiobuf + r, l); -// fprintf(stderr, "written %lu, loaded : %d\n", written, l); } + p = audiobuf; + while (loaded >= chunk_bytes) { + ret = alsa_write(p, chunk_bytes); + if (ret < 0) + goto out; + p += ret; + written += ret; + loaded -= ret; + } + if (loaded && p != audiobuf) + memmove(audiobuf, p, loaded); +read: + ret = read(STDIN_FILENO, audiobuf + loaded, bufsize - loaded); + if (ret < 0) { + ret = -E_READ_STDIN; + goto out; + } + if (ret) { + loaded += ret; + goto again; + } + ret = 1; out: - snd_pcm_drain(handle); + alsa_shutdown(); + 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) @@ -302,41 +294,30 @@ static size_t check_wave(void) 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; + int ret; cmdline_parser(argc, argv, &conf); if (conf.start_time_given) { + ret = -E_PLAY_SYNTAX; if (sscanf(conf.start_time_arg, "%lu:%lu", &tv.tv_sec, &tv.tv_usec) != 2) - EXIT(E_SYNTAX); + goto out; 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, "plug:swmix", - 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); + 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; + if (ret < 0) + PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + return ret; }