mplay.flac

mplay.flac.c (15933B)

#include "mplay.h"

#include <FLAC/format.h>
#include <FLAC/stream_decoder.h>
#include <pulse/sample.h>
#include <pulse/introspect.h>
#include <pulse/operation.h>
#include <pulse/stream.h>
#include <pulse/thread-mainloop.h>
#include <pulse/volume.h>
#include <pulse/pulseaudio.h>
#include <pulse/def.h>

#include <sys/mman.h>
#include <sys/stat.h>
#include <pthread.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>

#include <stdarg.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

struct decoder {
	FLAC__StreamDecoder *flac;
	uint8_t *samples;
	size_t sample_cnt;
	size_t sample_cap;
	size_t sample_size;
	size_t sample_max;

	size_t sample_next;

	bool seek;

	uint32_t rate;
	uint8_t channels;
	pa_sample_format_t format;

	bool init;
	bool pause;
	bool done;
	bool end;
};

static pa_buffer_attr pa_buf = {
	.fragsize = UINT32_MAX,
	.maxlength = UINT32_MAX,
	.tlength = UINT32_MAX,
	.prebuf = UINT32_MAX,
	.minreq = UINT32_MAX,
};

static pa_stream_flags_t pa_stream_flags = PA_STREAM_START_CORKED
	| PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY;

static pa_threaded_mainloop *pa_mloop;
static pa_context *pa_ctx;
static pa_stream *pa_strm;
static pa_sink_input_info pa_strm_sink;
static bool pa_strm_sink_update;

static struct decoder decoder;

static pthread_t input_worker_thread;
static bool input_worker_alive = false;

static struct termios term_old;
static struct termios term_new;
static bool term_set = false;

static bool headless = false;
static bool verbose = false;
static bool istty = false;

static void
__attribute__((noreturn))
__attribute__((format(printf, 1, 2)))
die(const char *fmt, ...)
{
	va_list ap;

	fputs("mplay.flac: ", stderr);
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	if (*fmt && fmt[strlen(fmt)-1] == ':') {
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}

	exit(1);
}

static void
term_set_canonical(void)
{
	term_new.c_lflag |= ICANON;
	term_new.c_lflag |= ECHO;
	if (tcsetattr(0, TCSANOW, &term_new))
		die("tcsetattr:");
}

static void
term_set_raw(void)
{
	term_new.c_lflag &= ~(0U | ICANON);
	term_new.c_lflag &= ~(0U | ECHO);
	if (tcsetattr(0, TCSANOW, &term_new))
		die("tcsetattr:");
}

static void
get_line(char *buf, int size)
{
	char *c;

	if (istty) putc('>', stderr);
	if (istty) term_set_canonical();
	fgets(buf, size, stdin);
	if ((c = strchr(buf, '\n'))) *c = '\0';
	if (istty) term_set_raw();
}

static FLAC__StreamDecoderWriteStatus
decoder_write_callback(const FLAC__StreamDecoder *flac,
	const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *user)
{
	uint32_t si, ch;

	assert(decoder.sample_next == decoder.sample_cnt);

	if (decoder.sample_cnt + frame->header.blocksize > decoder.sample_cap) {
		decoder.sample_cap = MAX(decoder.sample_cap * 2,
			decoder.sample_cnt + frame->header.blocksize);
		decoder.samples = realloc(decoder.samples, decoder.sample_cap
				* decoder.channels * decoder.sample_size);
		if (!decoder.samples) die("realloc:");
	}

	if (decoder.format == PA_SAMPLE_S16LE) {
		uint16_t *sample = (uint16_t *)decoder.samples
			+ decoder.sample_cnt * decoder.channels;
		for (si = 0; si < frame->header.blocksize; si++) {
			for (ch = 0; ch < frame->header.channels; ch++) {
				*sample++ = (uint16_t)htole32((uint32_t)buffer[ch][si]);
			}
		}
	} else if (decoder.format == PA_SAMPLE_S32LE) {
		uint32_t *sample = (uint32_t *)decoder.samples
			+ decoder.sample_cnt * decoder.channels;
		for (si = 0; si < frame->header.blocksize; si++) {
			for (ch = 0; ch < frame->header.channels; ch++) {
				*sample++ = htole32((uint32_t)buffer[ch][si]);
			}
		}
	}

	decoder.sample_cnt += frame->header.blocksize;
	decoder.sample_max = MAX(decoder.sample_max, decoder.sample_cnt);

	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}

static void
decoder_metadata_callback(const FLAC__StreamDecoder *flac,
	const FLAC__StreamMetadata *metadata, void *user)
{
	if (!decoder.init && metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
		decoder.sample_cnt = 0;
		decoder.rate = metadata->data.stream_info.sample_rate;
		decoder.channels = (uint8_t) metadata->data.stream_info.channels;
		decoder.sample_size = metadata->data.stream_info.bits_per_sample / 8;
		decoder.sample_max = metadata->data.stream_info.total_samples;
		if (decoder.sample_size == 2) {
			decoder.format = PA_SAMPLE_S16LE;
		} else if (decoder.sample_size == 4) {
			decoder.format = PA_SAMPLE_S32LE;
		} else {
			die("unsupported sample size");
		}
		decoder.init = true;
	}
}

static void
decoder_error_callback(const FLAC__StreamDecoder *flac,
	FLAC__StreamDecoderErrorStatus status, void *user)
{
	die("flac decoding error: %s", FLAC__StreamDecoderErrorStatusString[status]);
}

static void
decoder_flac_decode_next(void)
{
	bool ok;

	ok = FLAC__stream_decoder_process_single(decoder.flac);
	FLAC__StreamDecoderState state =
		FLAC__stream_decoder_get_state(decoder.flac);
	if (!ok) {
		die("decode process failed: %s",
			FLAC__StreamDecoderStateString[state]);
	}
	decoder.done = state == FLAC__STREAM_DECODER_END_OF_STREAM;
}

static uint8_t *
decoder_process_frame(size_t *cnt)
{
	size_t _cnt;

	if (decoder.sample_next < decoder.sample_cnt) {
		_cnt = decoder.sample_cnt - decoder.sample_next;
	} else {
		if (decoder.done) {
			decoder.end = true;
			_cnt = 0;
		} else {
			decoder_flac_decode_next();
			_cnt = decoder.sample_cnt - decoder.sample_next;
		}
	}

	if (cnt) *cnt = _cnt;

	return decoder.samples + decoder.sample_next \
		* decoder.channels * decoder.sample_size;
}

static void
decoder_init(const char *file)
{
	FLAC__StreamDecoderInitStatus init_status;

	decoder.sample_cnt = 0;
	decoder.sample_next = 0;
	decoder.sample_cap = 0;
	decoder.sample_size = 0;
	decoder.samples = NULL;

	decoder.seek = false;
	decoder.pause = false;
	decoder.done = false;
	decoder.end = false;

	decoder.flac = FLAC__stream_decoder_new();
	init_status = FLAC__stream_decoder_init_file(decoder.flac, file,
		decoder_write_callback, decoder_metadata_callback,
		decoder_error_callback, NULL);
	if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
		die("flac decoder init failed: %s",
			FLAC__StreamDecoderInitStatusString[init_status]);
	}

	/* decode channel specs */
	decoder.init = false;
	decoder_process_frame(NULL);
	assert(decoder.init);
}

static void
decoder_seek(size_t sample_pos)
{
	size_t cnt;

	while (decoder.sample_next < sample_pos) {
		decoder_process_frame(&cnt);
		if (decoder.end) {
			mplay_status(MPLAY_INFO_EXIT, "from seek");
			exit(0);
		}
		decoder.sample_next += cnt;
	}
	decoder.sample_next = sample_pos;
}


static void
pa_stream_drain_callback(pa_stream *stream, int success, void *data)
{
	mplay_status(MPLAY_INFO_EXIT, NULL);
	exit(0);
}

static void
pa_stream_write_callback(pa_stream *stream, size_t requested, void *data)
{
	uint8_t *samples;
	pa_operation *op;
	ssize_t remaining;
	size_t cnt, size;

	remaining = (ssize_t) requested;
	while (remaining > 0) {
		samples = decoder_process_frame(&cnt);
		if (decoder.end) {
			op = pa_stream_drain(pa_strm,
				pa_stream_drain_callback, NULL);
			pa_operation_unref(op);
			return;
		}
		if (!cnt) continue;

		cnt = MIN(cnt, (size_t) remaining);
		size = cnt * decoder.channels * decoder.sample_size;
		pa_stream_write(stream, samples, size, NULL, 0,
			decoder.seek ? PA_SEEK_RELATIVE_ON_READ : PA_SEEK_RELATIVE);
		decoder.sample_next += cnt;

		decoder.seek = false;
		remaining -= (ssize_t) size;
	}
}

static void
pa_stream_underflow_callback(struct pa_stream *stream, void *data)
{
	fprintf(stderr, "pulseaudio underflow!\n");
}

static void
pa_stream_overflow_callback(struct pa_stream *stream, void *data)
{
	fprintf(stderr, "pulseaudio overflow!\n");
}

static void
update_sink_input_info_callback(struct pa_context *ctx,
	const pa_sink_input_info *info, int eol, void *data)
{
	if (eol) return;
	memcpy(&pa_strm_sink, info, sizeof(pa_sink_input_info));
	pa_strm_sink_update = true;
	pa_threaded_mainloop_signal(pa_mloop, true);
}

static void
update_sink_input_info(void)
{
	pa_operation *op;

	pa_strm_sink_update = false;
	op = pa_context_get_sink_input_info(pa_ctx,
		pa_stream_get_index(pa_strm),
		update_sink_input_info_callback, NULL);
	if (!op) die("pa_context_get_sink_input_info failed");

	while (!pa_strm_sink_update) {
		pa_threaded_mainloop_unlock(pa_mloop);
		pa_threaded_mainloop_wait(pa_mloop);
		pa_threaded_mainloop_lock(pa_mloop);
	}

	pa_threaded_mainloop_accept(pa_mloop);

	pa_operation_unref(op);
}

static size_t
stream_samples_buffered(void)
{
	static size_t last_read_index = 0, last_write_index = 0;
	const pa_timing_info *info;
	size_t buffered;

	info = pa_stream_get_timing_info(pa_strm);
	if (!info || info->write_index_corrupt || info->read_index_corrupt)
		return 0;

	if (info->read_index != last_read_index)
		last_write_index = (size_t) MAX(0, info->write_index);

	buffered = (last_write_index - last_read_index)
		/ (decoder.sample_size * decoder.channels);

	last_read_index = (size_t) MAX(0, info->read_index);

	return buffered;
}

static double
user_vol(void)
{
	pa_volume_t vol;

	update_sink_input_info();
	if (!pa_strm_sink.has_volume)
		return -1;

	vol = pa_cvolume_avg(&pa_strm_sink.volume);

	return (double) vol * 100.F / (double) PA_VOLUME_NORM;
}

static double
user_pos(void)
{
	size_t sample_pos;

	sample_pos = (size_t) MAX(0,
		(ssize_t) decoder.sample_next - (ssize_t) stream_samples_buffered());

	return (double) sample_pos * 1.F / (double) decoder.rate;
}

static double
user_end(void)
{
	return (double) decoder.sample_max * 1.F / (double) decoder.rate;
}

static void
cmd_setvol(double vol, double delta)
{
	pa_operation *op;

	pa_threaded_mainloop_lock(pa_mloop);

	if (delta != 0) {
		vol = user_vol() + delta;
	}

	update_sink_input_info();
	pa_cvolume_set(&pa_strm_sink.volume, 2,
		(pa_volume_t) (vol * PA_VOLUME_NORM / 100.F));
	if (pa_cvolume_avg(&pa_strm_sink.volume) > 2 * PA_VOLUME_NORM)
		pa_cvolume_set(&pa_strm_sink.volume, 2, 2 * PA_VOLUME_NORM);

	op = pa_context_set_sink_input_volume(pa_ctx,
		pa_stream_get_index(pa_strm),
		&pa_strm_sink.volume, NULL, NULL);
	pa_operation_unref(op);

	mplay_status(MPLAY_INFO_VOLUME, "%02.2f", (double) pa_cvolume_avg(&pa_strm_sink.volume)
		* 100.f / (double) PA_VOLUME_NORM);
	
	pa_threaded_mainloop_unlock(pa_mloop);
}

static void
cmd_seek(double time_sec, double delta)
{
	size_t sample_pos;
	pa_operation *op;

	pa_threaded_mainloop_lock(pa_mloop);

	if (delta != 0) {
		time_sec = user_pos() + delta;
	}

	if (time_sec < 0) time_sec = 0;
	sample_pos = (size_t) (time_sec * decoder.rate);
	decoder_seek(sample_pos);

	op = pa_stream_flush(pa_strm, NULL, NULL);
	pa_operation_unref(op);
	decoder.seek = true;

	mplay_status(MPLAY_INFO_SEEK, "%02.2f", user_pos());

	pa_threaded_mainloop_unlock(pa_mloop);
}

static void
cmd_playpause(void)
{
	pa_operation *op;

	pa_threaded_mainloop_lock(pa_mloop);

	decoder.pause ^= 1;
	op = pa_stream_cork(pa_strm, decoder.pause, NULL, NULL);
	pa_operation_unref(op);

	mplay_status(MPLAY_INFO_PAUSE, "%i", decoder.pause);

	pa_threaded_mainloop_unlock(pa_mloop);
}

static void
cmd_status(void)
{
	pa_threaded_mainloop_lock(pa_mloop);

	update_sink_input_info();

	mplay_status(MPLAY_INFO_STATUS,
		"volume=%02.2f,pos=%02.2f,end=%02.2f,pause=%i",
		user_vol(), user_pos(), user_end(), decoder.pause);

	pa_threaded_mainloop_unlock(pa_mloop);
}

static bool
key_input(void)
{
	char linebuf[16], *end;
	float fval;
	int key;

	while ((key = mplay_getkey()) == MPLAY_KEY_INV);

	if (key == MPLAY_KEY_EOF) return false;

	switch (mplay_action(key)) {
	case MPLAY_ACTION_VOLUME:
		get_line(linebuf, sizeof(linebuf));
		fval = strtof(linebuf, &end);
		if (!end || *end) {
			mplay_status(MPLAY_INFO_VOLUME, "fail:bad float");
			break;
		}
		cmd_setvol(fval, 0);
		break;
	case MPLAY_ACTION_VOLUME_UP:
		cmd_setvol(0, 5);
		break;
	case MPLAY_ACTION_VOLUME_DOWN:
		cmd_setvol(0, -5);
		break;
	case MPLAY_ACTION_SEEK:
		get_line(linebuf, sizeof(linebuf));
		fval = strtof(linebuf, &end);
		if (!end || *end) {
			mplay_status(MPLAY_INFO_SEEK, "fail:bad float");
			break;
		}
		cmd_seek(fval, 0);
		break;
	case MPLAY_ACTION_SEEK_BWD:
		cmd_seek(0, -5);
		break;
	case MPLAY_ACTION_SEEK_FWD:
		cmd_seek(0, 5);
		break;
	case MPLAY_ACTION_PAUSE:
		cmd_playpause();
		break;
	case MPLAY_ACTION_STATUS:
		cmd_status();
		break;
	default:
		mplay_status(MPLAY_INFO_INPUT, "fail");
		break;
	}

	return true;
}

static void *
input_worker(void *arg)
{
	input_worker_alive = true;

	setvbuf(stdin, NULL, _IONBF, 0);
	setvbuf(stdout, NULL, _IONBF, 0);
	setvbuf(stderr, NULL, _IONBF, 0);

	if (istty) {
		if (tcgetattr(0, &term_old))
			die("tcgetattr:");
		term_new = term_old;
		term_new.c_iflag |= BRKINT;
		term_new.c_iflag &= ~(0U | IGNBRK);
		term_set = true;

		term_set_raw();
	}

	mplay_status(MPLAY_INFO_READY, NULL);

	while (key_input());

	return NULL;
}

static void
pulse_context_init(void)
{
	pa_mainloop_api *pa_mloop_api;
	int ret;

	pa_mloop_api = pa_threaded_mainloop_get_api(pa_mloop);
	if (!pa_mloop_api) die("pa_threaded_mainloop_get_api");

	pa_ctx = pa_context_new(pa_mloop_api, "mplay.flac");
	if (!pa_ctx) die("pa_context_new");

	ret = pa_context_connect(pa_ctx, NULL, 0, NULL);
	if (ret) die("pa_context_connect: %s",
		pa_strerror(pa_context_errno(pa_ctx)));

	while (pa_context_get_state(pa_ctx) != PA_CONTEXT_READY) {
		pa_threaded_mainloop_unlock(pa_mloop);
		pa_threaded_mainloop_wait(pa_mloop);
		pa_threaded_mainloop_lock(pa_mloop);
	}
}

static void
pulse_stream_init(void)
{
	struct pa_sample_spec pa_spec;
	pa_channel_map pa_chmap;
	int ret;

	pa_channel_map_init_stereo(&pa_chmap);

	pa_spec.channels = decoder.channels;
	pa_spec.rate = decoder.rate;
	pa_spec.format = decoder.format;

	pa_strm = pa_stream_new(pa_ctx, "mplay.flac", &pa_spec, &pa_chmap);
	if (!pa_strm) die("pa_stream_new: %s",
		pa_strerror(pa_context_errno(pa_ctx)));

	pa_stream_set_write_callback(pa_strm, pa_stream_write_callback, NULL);

	if (verbose) {
		pa_stream_set_underflow_callback(pa_strm,
			pa_stream_underflow_callback, NULL);
		pa_stream_set_overflow_callback(pa_strm,
			pa_stream_overflow_callback, NULL);
	}

	ret = pa_stream_connect_playback(pa_strm, NULL,
		&pa_buf, pa_stream_flags, NULL, NULL);
	if (ret) die("pa_stream_connect_playback failed");

	while (pa_stream_get_state(pa_strm) != PA_STREAM_READY) {
		pa_threaded_mainloop_unlock(pa_mloop);
		pa_threaded_mainloop_wait(pa_mloop);
		pa_threaded_mainloop_lock(pa_mloop);
	}
}

static void
sigint_handler(int sig)
{
	exit(0);
}

static void
cleanup(void)
{
	if (term_set) tcsetattr(0, TCSANOW, &term_old);

	pa_stream_disconnect(pa_strm);
	pa_stream_unref(pa_strm);

	pa_context_disconnect(pa_ctx);
	pa_context_unref(pa_ctx);

	if (input_worker_alive)
		pthread_kill(input_worker_thread, SIGINT);
}

static void
usage(void)
{
	fprintf(stderr, "Usage: mplay.flac [-v] [" MPLAY_FLAG_HEADLESS "] FILE\n");
	exit(1);
}

int
main(int argc, const char **argv)
{
	pthread_mutex_t lock;
	const char **arg;
	const char *file;

	file = NULL;
	for (arg = argv + 1; *arg; arg++) {
		if (!strcmp(*arg, MPLAY_FLAG_HEADLESS)) {
			headless = true;
		} else if (!strcmp(*arg, "-v")) {
			verbose = true;
		} else {
			if (file) usage();
			file = *arg;
		}
	}
	if (!file) usage();

	istty = isatty(0);

	decoder_init(file);

	pa_mloop = pa_threaded_mainloop_new();
	if (!pa_mloop) die("pa_threaded_mainloop_new");

	pa_threaded_mainloop_start(pa_mloop);

	pa_threaded_mainloop_lock(pa_mloop);
	pulse_context_init();
	pulse_stream_init();
	pa_stream_cork(pa_strm, 0, NULL, NULL);
	pa_threaded_mainloop_unlock(pa_mloop);

	atexit(cleanup);
	signal(SIGINT, sigint_handler);

	if (!headless) {
		if (pthread_create(&input_worker_thread, NULL, input_worker, NULL))
			die("pthread_create");
		pthread_join(input_worker_thread, NULL);
	} else {
		pthread_mutex_init(&lock, NULL);
		pthread_mutex_lock(&lock);
		pthread_mutex_lock(&lock);
	}

	return 0;
}