path: root/src/audio.c

#include "polyp.h"
#include "config.h"

#define PACKAGE_VERSION "0.1"

static struct pa_stream *stream = NULL;
static struct pa_context *context = NULL;
static struct pa_glib_mainloop *glib_mainloop = NULL;
static struct pa_mainloop_api *mainloop = NULL;

static gint fd = 0;
static gpointer buffer;
static gboolean going = FALSE, paused = FALSE, prebuffer, remove_prebuffer;
static gint buffer_size, prebuffer_size, blk_size = 4096;
static gint rd_index = 0, wr_index = 0;
static gint output_time_offset = 0;
static guint64 written = 0, output_bytes = 0;
static gint bps, ebps;
static gint flush;
static gint format, channels, frequency, latency;
static polyp_format_t polyp_format;
static gint input_bps, input_format, input_frequency, input_channels;
static pthread_t buffer_thread;
static gboolean realtime = FALSE;
static void *(*polyp_translate)(void *, gint);

static gint get_latency(void) {
}

static void polyp_setup_format(AFormat fmt,
                               gint rate, gint nch) {
    gboolean swap_sign = FALSE;
	gboolean swap_16 = FALSE;

	format = fmt;
	frequency = rate;
	channels = nch;
	switch (fmt)
	{
		case FMT_S8:
			swap_sign = TRUE;
		case FMT_U8:
			polyp_format = POLYP_BITS8;
			break;
		case FMT_U16_LE:
		case FMT_U16_BE:
		case FMT_U16_NE:
			swap_sign = TRUE;
		case FMT_S16_LE:
		case FMT_S16_BE:
		case FMT_S16_NE:
			polyp_format = POLYP_BITS16;
			break;
	}

#ifdef WORDS_BIGENDIAN
	if (fmt == FMT_U16_LE || fmt == FMT_S16_LE)
#else
	if (fmt == FMT_U16_BE || fmt == FMT_S16_BE)
#endif
		swap_16 = TRUE;

	polyp_translate = (void*(*)())NULL;
	if (polyp_format == POLYP_BITS8) {
		if (swap_sign == TRUE)
			polyp_translate = polyp_stou8;
	} else {
		if (swap_sign == TRUE) {
			if (swap_16 == TRUE)
				polyp_translate = polyp_utos16sw;
			else
				polyp_translate = polyp_utos16;
		} else {
			if (swap_16 == TRUE)
				polyp_translate = polyp_16sw;
		}
	}

	bps = rate * nch;
	if (polyp_format == POLYP_BITS16)
		bps *= 2;
	if(nch == 1)
		polyp_format |= POLYP_MONO;
	else
		polyp_format |= POLYP_STEREO;
	polyp_format |= POLYP_STREAM | POLYP_PLAY;
	
	latency = ((get_latency() * frequency) / 44100) * channels;
	if (format != FMT_U8 && format != FMT_S8)
		latency *= 2;
}
	

gint polyp_get_written_time(void)
{
	if (!going)
		return 0;
	return (gint) ((written * 1000) / input_bps);
}

gint polyp_get_output_time(void)
{
	guint64 bytes;

	if (!fd || !going)
		return 0;

	bytes = output_bytes;
	if (!paused)
		bytes -= (bytes < latency ? bytes : latency);
	
	return output_time_offset + (bytes * 1000) / ebps;
}

gint polyp_used(void)
{
	if (realtime)
		return 0;
	else
	{
		if (wr_index >= rd_index)
			return wr_index - rd_index;
		return buffer_size - (rd_index - wr_index);
	}
}

gint polyp_playing(void)
{
	if (!going)
		return FALSE;
	if (!polyp_used())
		return FALSE;

	return TRUE;
}

gint polyp_free(void)
{
	if (!realtime)
	{
		if (remove_prebuffer && prebuffer)
		{
			prebuffer = FALSE;
			remove_prebuffer = FALSE;
		}
		if (prebuffer)
			remove_prebuffer = TRUE;

		if (rd_index > wr_index)
			return (rd_index - wr_index) - 1;
		return (buffer_size - (wr_index - rd_index)) - 1;
	}
	else
	{
		if (paused)
			return 0;
		else
			return 1000000;
	}
}

static void polyp_write_audio(gpointer data,gint length)
{
	AFormat new_format;
	gint new_frequency,new_channels;
	EffectPlugin *ep;
	
	new_format = input_format;
	new_frequency = input_frequency;
	new_channels = input_channels;
	
	ep = get_current_effect_plugin();
	if(effects_enabled() && ep && ep->query_format)
	{
		ep->query_format(&new_format,&new_frequency,&new_channels);
	}
	
	if(new_format != format || new_frequency != frequency || new_channels != channels)
	{
		output_time_offset += (output_bytes * 1000) / ebps;
		output_bytes = 0;
		polyp_setup_format(new_format, new_frequency, new_channels);
		frequency = new_frequency;
		channels = new_channels;
		polyp_close(fd);
		polyp_set_audio_params();
	}
	if(effects_enabled() && ep && ep->mod_samples)
		length = ep->mod_samples(&data,length, input_format, input_frequency, input_channels);
        if (polyp_translate)
                output_bytes += write(fd,polyp_translate(data,length),length);
        else
                output_bytes += write(fd,data,length);
}


void polyp_write(gpointer ptr, gint length)
{
	gint cnt, off = 0;

	if (!realtime)
	{
		remove_prebuffer = FALSE;

		written += length;
		while (length > 0)
		{
			cnt = MIN(length, buffer_size - wr_index);
			memcpy((gchar *)buffer + wr_index, (gchar *)ptr + off, cnt);
			wr_index = (wr_index + cnt) % buffer_size;
			length -= cnt;
			off += cnt;

		}
	}
	else
	{
		if (paused)
			return;
		polyp_write_audio(ptr,length);
		written += length;
		
	}

}

void polyp_close(void)
{
	if (!going)
		return;

	going = 0;

	if (!realtime)
		pthread_join(buffer_thread, NULL);
	else
		polyp_close(fd);

	wr_index = 0;
	rd_index = 0;
	g_free(polyp_cfg.playername);
	polyp_cfg.playername = NULL;
	polyp_reset_playerid();
}

void polyp_flush(gint time)
{
	if (!realtime)
	{
		flush = time;
		while (flush != -1)
			xmms_usleep(10000);
	}
	else
	{
		output_time_offset = time;
		written = (guint64)(time / 10) * (guint64)(input_bps / 100);
		output_bytes = 0;
	}
}

void polyp_pause(short p)
{
	paused = p;
}

void *polyp_loop(void *arg)
{
	gint length, cnt;
	

	while (going)
	{
		if (polyp_used() > prebuffer_size)
			prebuffer = FALSE;
		if (polyp_used() > 0 && !paused && !prebuffer)
		{
			length = MIN(blk_size, polyp_used());
			while (length > 0)
			{
				cnt = MIN(length,buffer_size-rd_index);
				polyp_write_audio((gchar *)buffer + rd_index, cnt);
				rd_index=(rd_index+cnt)%buffer_size;
				length-=cnt;				
			}
		}
		else
			xmms_usleep(10000);

		if (flush != -1)
		{
			output_time_offset = flush;
			written = (guint64)(flush / 10) * (guint64)(input_bps / 100);
			rd_index = wr_index = output_bytes = 0;
			flush = -1;
			prebuffer = TRUE;
		}

	}

	polyp_close(fd);
	g_free(buffer);
	pthread_exit(NULL);
}

void polyp_set_audio_params(void)
{
	fd = polyp_play_stream(polyp_format, frequency,
			     polyp_cfg.hostname, polyp_cfg.playername);
	/* Set the stream's mixer */
	if (fd != -1)
		polyp_mixer_init();
	ebps = frequency * channels;
	if (format == FMT_U16_BE || format == FMT_U16_LE ||
	    format == FMT_S16_BE || format == FMT_S16_LE ||
	    format == FMT_S16_NE || format == FMT_U16_NE)
		ebps *= 2;
}

int polyp_open(AFormat fmt, int rate, int nch) {
	static unsigned int playercnt = 0;

	polyp_setup_format(fmt,rate,nch);
	
	input_format = format;
	input_channels = channels;
	input_frequency = frequency;
	input_bps = bps;

	realtime = xmms_check_realtime_priority();
	
	if (!realtime)
	{
		buffer_size = (polyp_cfg.buffer_size * input_bps) / 1000;
		if (buffer_size < 8192)
			buffer_size = 8192;
		prebuffer_size = (buffer_size * polyp_cfg.prebuffer) / 100;
		if (buffer_size - prebuffer_size < 4096)
			prebuffer_size = buffer_size - 4096;

		buffer = g_malloc0(buffer_size);
	}
	flush = -1;
	prebuffer = 1;
	wr_index = rd_index = output_time_offset = written = output_bytes = 0;
	paused = FALSE;
	remove_prebuffer = FALSE;

	polyp_cfg.playername = g_strdup_printf("xmms - plugin (%d-%u)",
					     getpid(), playercnt++);

	if (polyp_cfg.hostname)
		g_free(polyp_cfg.hostname);
	if (polyp_cfg.use_remote)
		polyp_cfg.hostname = g_strdup_printf("%s:%d", polyp_cfg.server, polyp_cfg.port);
	else
		polyp_cfg.hostname = NULL;
	
	polyp_set_audio_params();
	if (fd == -1)
	{
		g_free(polyp_cfg.playername);
		polyp_cfg.playername = NULL;
		g_free(buffer);
		return 0;
	}
	going = 1;

	if (!realtime)
		pthread_create(&buffer_thread, NULL, polyp_loop, NULL);
	return 1;
}


static void free_all_objects(void) {
    if (stream) {
        pa_stream_unref(stream);
        stream = NULL;
    }

    if (context) {
        pa_context_unref(context);
        context = NULL;
    }
    
    if (glib_mainloop) {
        pa_glib_mainloop_free(glib_mainloop);
        glib_mainloop = NULL;
    }

    mainloop = NULL;
}

static int polyp_open(AFormat fmt, int rate, int nch) {
    struct pa_sample_spec ss;

    free_all_objects();
    
    if (fmt == FMT_U8)
        ss.format = PA_SAMPLE_U8;
    else if (fmt == FMT_S16_LE)
        ss.format = PA_SAMPLE_S16LE;
    else if (fmt == FM_S16_BE)
        ss.format = PA_SAMPLE_S16BE;
    else if (fmt == FM_S16_NE)
        ss.format = PA_SAMPLE_S16NE;
    else
        return 0;

    ss.rate = rate;
    ss.channels = nch;

    if (!pa_sample_spec_valid(&ss))
        return 0;

    glib_mainloop = pa_glib_mainloop_new();
    g_assert(glib_mainloop);
    mainloop = pa_glib_mainloop_get_api(glib_mainloop);
    g_assert(mainloop);
    context = pa_context_new(mainloop, "xmms");
    assert(context);
    pa_context_set_state_callback(context, context_state_callback, NULL);
    pa_context_connect(context, NULL);

    if (wait_for_context_ready() < 0)
        goto fail;

    stream = pa_stream_new(context, polyp_plugin.filename);
    assert(stream);

    pa_stream_set_write_callback(stream, stream_state_callback, NULL);
    pa_stream_connect_playback(stream, NULL, NULL);

    if (wait_for_stream_ready() < 0)
        goto fail;

    return 1;
    
fail:
    free_all_objects();
}

static void polyp_close(void) {

    if (stream && pa_stream_get_state(stream) == PA_STREAM_READY) {
        struct pa_operation *o;
        o = pa_stream_drain(stream, NULL, NULL);
        assert(o);
        wait_for_operation(o);
    }

    if (context && pa_context_get_state(context) == PA_CONTEXT_READY) {
        struct pa_operation *o;
        if ((o = pa_context_drain(context, NULL, NULL)))
            wait_for_operation(o);
    }
            
    free_all_objects();
}

static void polyp_init(void) {
}

static OutputPlugin polyp_plugin = {
    NULL,
    NULL,
    "Polypaudio Output Plugin", /* Description */
    polyp_init,          
    NULL, /* polyp_about, */
    NULL, /* polyp_configure, */
    polyp_get_volume,
    polyp_set_volume,
    polyp_open,
    polyp_write,
    polyp_close,
    polyp_flush,
    polyp_pause,
    polyp_free,
    polyp_playing,
    polyp_get_output_time,
    polyp_get_written_time,
};

OutputPlugin *get_oplugin_info(void) {
    return &polyp_plugin;
}