mplay.mp3

mplay.mp3.c (12426B)

#include "mplay.h"

#define MINIMP3_IMPLEMENTATION
#include "minimp3_ex.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 <stdio.h>
#include <stdlib.h>

struct decoder {
	mp3dec_ex_t dec;
	size_t sample_next;
	size_t samples_max;
	size_t samples_read;

	int rate;
	int channels;

	bool seek;
	bool init;
	bool pause;
};

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 = { 0 };

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.mp3: ", 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 void
decoder_init(const char *filepath)
{
	if (mp3dec_ex_open(&decoder.dec, filepath, MP3D_SEEK_TO_SAMPLE))
		die("mp3dec_ex_open");

	decoder.sample_next = 0;
	decoder.samples_max = 0;
	decoder.samples_max = decoder.dec.samples / (size_t)decoder.dec.info.channels;

	decoder.channels = decoder.dec.info.channels;
	decoder.rate = decoder.dec.info.hz;

	decoder.seek = false;
	decoder.pause = false;
	decoder.init = true;
}

static void
decoder_seek(size_t sample_pos)
{
	mp3dec_ex_seek(&decoder.dec, sample_pos * (size_t)decoder.channels);
	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)
{
	mp3dec_frame_info_t info;
	mp3d_sample_t *samples;
	pa_operation *op;
	ssize_t remaining;
	size_t cnt;

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

		pa_stream_write(stream, samples,
			cnt * sizeof(mp3d_sample_t), NULL, 0,
			decoder.seek ? PA_SEEK_RELATIVE_ON_READ: PA_SEEK_RELATIVE);

		decoder.seek = false;
		decoder.sample_next += cnt / (size_t)decoder.channels;
		decoder.samples_read = decoder.sample_next;
		decoder.samples_max = MAX(decoder.samples_max, decoder.samples_read);
		remaining -= (ssize_t) (cnt * (size_t)decoder.channels * sizeof(mp3d_sample_t));
	}
}

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)
		/ ((size_t) decoder.channels * sizeof(mp3d_sample_t));

	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)
{
	ssize_t sample_pos;

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

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

static double
user_end(void)
{
	return (double) decoder.samples_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.mp3");
	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)
{
	pa_channel_map pa_chmap;
	pa_sample_spec pa_spec;
	int ret;

	pa_spec.format = PA_SAMPLE_S16LE;
	pa_spec.channels = (uint8_t) decoder.channels;
	pa_spec.rate = (uint32_t) decoder.rate;

	pa_channel_map_init_stereo(&pa_chmap);

	pa_strm = pa_stream_new(pa_ctx, "mplay.mp3", &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.mp3 [" 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;
}