diff src/crossfade/crossfade.c @ 3059:2e241e90494a

Import work in progress xmms-crossfade rewrite.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/crossfade/crossfade.c	Fri Apr 24 05:57:35 2009 -0500
@@ -0,0 +1,2548 @@
+/* 
+ *  XMMS Crossfade Plugin
+ *  Copyright (C) 2000-2007  Peter Eisenlohr <[e-mail]>
+ *
+ *  based on the original OSS Output Plugin
+ *  Copyright (C) 1998-2000  Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ *  USA.
+ */
+/* indent -i8 -ts8 -hnl -bli0 -l128 -npcs -cli8 */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "crossfade.h"
+#include "cfgutil.h"
+#include "format.h"
+#include "convert.h"
+#include "timing.h"
+
+#include "configure.h"
+#include "monitor.h"
+
+#include "interface-2.0.h"
+#include "support-2.0.h"
+
+#ifdef HAVE_LIBFFTW
+#  include "fft.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#ifdef HAVE_DLFCN_H
+#  include <dlfcn.h>
+#endif
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#undef  DEBUG_HARDCORE
+
+/* output plugin callback prototypes */
+static void xfade_init();
+static void xfade_cleanup();  /* audacious and patched only */
+static void xfade_set_volume(int l, int r);
+static void xfade_get_volume(int *l, int *r);
+static gint xfade_open_audio(AFormat fmt, int rate, int nch);
+static void xfade_write_audio(void *ptr, int length);
+static void xfade_close_audio();
+static void xfade_flush(int time);
+static void xfade_pause(short paused);
+static gint xfade_buffer_free();
+static gint xfade_buffer_playing();
+static gint xfade_written_time();
+static gint xfade_output_time();
+
+/* output plugin callback table (extended, needs patched player) */
+static struct
+{
+	OutputPlugin xfade_op;
+        void (*cleanup) (void);
+}
+xfade_op_private =
+{
+	{
+		.description    = "Crossfade Plugin",
+		.init           = xfade_init,
+		.cleanup        = xfade_cleanup,
+		.get_volume     = xfade_get_volume,
+		.set_volume     = xfade_set_volume,
+		.open_audio     = xfade_open_audio,
+		.write_audio    = xfade_write_audio,
+		.close_audio    = xfade_close_audio,
+		.flush          = xfade_flush,
+		.pause          = xfade_pause,
+		.buffer_free    = xfade_buffer_free,
+		.buffer_playing = xfade_buffer_playing,
+		.output_time    = xfade_output_time,
+		.written_time   = xfade_written_time,
+		.about          = xfade_about,
+		.configure      = xfade_configure,
+		.probe_priority = 2,
+	},
+	NULL
+};
+
+static OutputPlugin *xfade_op = &xfade_op_private.xfade_op;
+
+static OutputPlugin *xfade_oplist[] = { &xfade_op_private.xfade_op, NULL };
+DECLARE_PLUGIN(crossfade, NULL, NULL, NULL, xfade_oplist, NULL, NULL, NULL);
+
+/* internal prototypes */
+static void load_symbols();
+static void output_list_hack();
+static gint open_output();
+static void buffer_reset(buffer_t *buf, config_t *cfg);
+static void *buffer_thread_f(void *arg);
+static void sync_output();
+
+/* special XMMS symbols (dynamically looked up, see xfade_init) */
+static gboolean *xmms_playlist_get_info_going = NULL;   /* XMMS */
+static gboolean *xmms_is_quitting             = NULL;   /* XMMS */
+static gboolean *input_stopped_for_restart    = NULL;   /* XMMS */
+static char *  (*playlist_get_fadeinfo)(int)  = NULL;   /* XMMS patch */
+
+static void (*xmms_input_get_song_info)(gchar *, gchar **, gint *); /* XMMS */
+static gchar **xmms_gentitle_format = NULL;   /* XMMS private cfg */
+
+/* This function has been stolen from libxmms/util.c. */
+void xfade_usleep(gint usec)
+{
+#if defined(HAVE_G_USLEEP)
+	g_usleep(usec);
+#elif defined(HAVE_NANOSLEEP)
+	struct timespec req;
+
+	req.tv_sec = usec / 1000000;
+	usec -= req.tv_sec * 1000000;
+	req.tv_nsec = usec * 1000;
+
+	nanosleep(&req, NULL);
+#else
+	struct timeval tv;
+
+	tv.tv_sec = usec / 1000000;
+	usec -= tv.tv_sec * 1000000;
+	tv.tv_usec = usec;
+	select(0, NULL, NULL, NULL, &tv);
+#endif
+}
+
+
+/* local variables */
+static gboolean realtime;
+static gboolean is_http;
+
+static gint64 streampos;	/* position within current song (input bps) */
+static gboolean playing;
+gboolean opened;		/* TRUE between open_audio() and close_audio() */
+static gboolean paused;		/* TRUE: no playback (but still filling buffer) */
+static gboolean stopped;	/* TRUE: stop buffer thread ASAP */
+static gboolean eop;		/* TRUE: wait until buffer is empty then sync() */
+
+#ifdef HAVE_OSS			/* avoid 'defined but not used' compiler warning */
+static plugin_config_t default_op_config = DEFAULT_OP_CONFIG;
+#endif
+static plugin_config_t the_op_config = DEFAULT_OP_CONFIG;
+       OutputPlugin          *the_op = NULL;
+       gint                 the_rate = 44100;
+
+static gboolean input_playing = FALSE;
+
+       gboolean output_opened     = FALSE;
+       gboolean output_restart    = FALSE;  /* used by XMMS 'songchange' patch */
+static gint     output_flush_time = 0;
+       gint     output_offset     = 0;
+static gint64   output_written    = 0;
+       gint64   output_streampos  = 0;
+
+static gchar zero_4k[4096];
+
+#ifdef TIMING_COMMENTS
+typedef struct
+{
+	gboolean enable;
+	gint     len_ms, volume, skip_ms, ofs_ms;
+}
+timing_half_config_t;
+
+typedef struct
+{
+	timing_half_config_t in;
+	timing_half_config_t out;
+}
+timing_config_t;
+
+static timing_config_t last_timing, current_timing;
+#endif
+
+/*
+ *  Available fade configs:
+ * 
+ *  fc_start:       First song, only in_len and in_level are used
+ *  fc_xfade:       Automatic crossfade at end of song
+ *  fc_album:       Like xfade but for consecutive songs of the same album
+ *  fc_manual:      Manual crossfade (triggered by Next or Prev)
+ *  fc_stop:        Last song, only out_len and out_level are used
+ *  fc_eop:         Last song, only out_len and out_level are used
+ *
+ *  NOTE: As of version 0.2 of xmms-crossfade,
+ *        only xfade and manual are implemented.
+ *        
+ *        With version 0.2.3, fc_album has been added.
+ *
+ *        With 0.2.4, all configs are implemented:
+ *
+ *  Available parameters:
+ * 
+ *              | start | xfade | manual | album | stop |  eop
+ *  ------------+-------+-------+--------+-------+------+------
+ *  in_len      |   yes |   yes |    yes |    no |   no |   no
+ *  in_volume   |   yes |   yes |    yes |    no |   no |   no
+ *  offset      |    no |   yes |    yes |    no | +yes | +yes
+ *  out_len     |    no |   yes |    yes |    no |  yes |  yes
+ *  out_volume  |    no |   yes |    yes |    no |  yes |  yes
+ *  flush (*)   |    no |    no |    yes |    no |  yes |   no
+ *  ------------+-------+-------+--------+-------+------+------
+ *
+ *  Parameters marked with (*) are not configureable by the user
+ *
+ *  The offset parameters for 'stop' and 'eop' is used to store the
+ *  length of the additional silence to be added. It may be >= 0 only.
+ *
+ */
+
+static struct timeval last_close;
+static struct timeval last_write;
+
+static gchar *last_filename = NULL;
+
+static format_t  in_format;
+static format_t out_format;
+
+static buffer_t            the_buffer;
+       buffer_t *buffer = &the_buffer;
+
+static THREAD buffer_thread;
+       MUTEX  buffer_mutex = MUTEX_INITIALIZER;
+
+static convert_context_t convert_context;
+#ifdef HAVE_LIBFFTW
+static fft_context_t fft_context;
+#endif
+
+static config_t     the_config;
+       config_t        *config = &the_config;
+       config_t config_default = CONFIG_DEFAULT;
+
+static fade_config_t *fade_config = NULL;
+
+
+/* this is the entry point for XMMS */
+OutputPlugin *
+get_oplugin_info()
+{
+	return xfade_op;
+}
+
+OutputPlugin *
+get_crossfade_oplugin_info()
+{
+	return xfade_op;
+}
+
+static gboolean
+open_output_f(gpointer data)
+{
+	DEBUG(("[crossfade] open_output_f: pid=%d\n", getpid()));
+	open_output();
+	return FALSE;		/* FALSE = 'do not call me again' */
+}
+
+void
+xfade_realize_config()		/* also called by xfade_init() */
+{
+	/* 0.3.0: keep device opened */
+	if (config->output_keep_opened && !output_opened)
+	{
+		DEBUG(("[crossfade] realize_config: keeping output opened...\n"));
+
+		/* 0.3.1: HACK: this will make sure that we start playing silence after startup */
+		gettimeofday(&last_close, NULL);
+
+		/* 0.3.1: HACK: Somehow, if we open output here at XMMS startup, there
+		   will be leftover filedescriptors later when closing output again.
+		   Opening output in a timeout function seems to work around this... */
+		DEBUG(("[crossfade] realize_config: adding timeout (pid=%d)\n", (int) getpid()));
+		g_timeout_add(0, open_output_f, NULL);
+	}
+}
+
+static gint
+output_list_f(gconstpointer a, gconstpointer b)
+{
+	OutputPlugin *op = (OutputPlugin *) a;
+	gchar *name = (gchar *) b;
+
+	return strcmp(g_basename(op->filename), name);
+}
+
+static OutputPlugin *
+find_output()
+{
+	GList *list, *element;
+	OutputPlugin *op = NULL;
+
+	/* find output plugin */
+	{
+		if (config->op_name && (list = xfplayer_get_output_list()))
+			if ((element = g_list_find_custom(list, config->op_name, output_list_f)))
+				op = element->data;
+
+		if (op == xfade_op)
+		{
+			DEBUG(("[crossfade] find_output: can't use myself as output plugin!\n"));
+			op = NULL;
+		}
+		else if (!op)
+		{
+			DEBUG(("[crossfade] find_output: could not find output plugin \"%s\"\n",
+			       config->op_name ? config->op_name : "#NULL#"));
+		}
+		else		/* ok, we have a plugin. last, get its compatibility options */
+			xfade_load_plugin_config(config->op_config_string, config->op_name, &the_op_config);
+	}
+
+	return op;
+}
+
+static gint
+open_output()
+{
+	/* sanity check */
+	if (output_opened)
+		DEBUG(("[crossfade] open_output: WARNING: output_opened=TRUE!\n"));
+
+	/* reset output_* */
+	output_opened = FALSE;
+	output_flush_time = 0;
+	output_offset     = 0;
+	output_written    = 0;
+	output_streampos  = 0;
+
+	/* get output plugin (this will also init the_op_config) */
+	if (!(the_op = find_output()))
+	{
+		DEBUG(("[crossfade] open_output: could not find any output!\n"));
+		return -1;
+	}
+
+	/* print output plugin info */
+	DEBUG(("[crossfade] open_output: using \"%s\" for output", the_op->description ? the_op->description : "#NULL#"));
+
+	if (realtime)
+		DEBUG((" (RT)"));
+
+	if (the_op_config.throttle_enable)
+		DEBUG((realtime ? " (throttled (disabled with RT))" : " (throttled)"));
+
+	if (the_op_config.max_write_enable)
+		DEBUG((" (max_write=%d)", the_op_config.max_write_len));
+
+	DEBUG(("\n"));
+
+	/* setup sample rate (note that OUTPUT_RATE is #defined as the_rate) */
+	the_rate = config->output_rate;
+
+	/* setup out_format. use host byte order for easy math */
+	setup_format(FMT_S16_NE, OUTPUT_RATE, OUTPUT_NCH, &out_format);
+
+	/* open plugin */
+	if (!the_op->open_audio(out_format.fmt, out_format.rate, out_format.nch))
+	{
+		DEBUG(("[crossfade] open_output: open_audio() failed!\n"));
+		the_op = NULL;
+		return -1;
+	}
+
+	/* clear buffer struct */
+	memset(buffer, 0, sizeof(*buffer));
+
+	/* calculate buffer size */
+	buffer->mix_size     = MS2B(xfade_mix_size_ms(config)) & -4;
+	buffer->sync_size    = MS2B(config->sync_size_ms)      & -4;
+	buffer->preload_size = MS2B(config->preload_size_ms)   & -4;
+
+	buffer->size = (buffer->mix_size +      /* mixing area */
+	                buffer->sync_size +     /* additional sync */
+	                buffer->preload_size);  /* preload */
+
+	DEBUG(("[crossfade] open_output: buffer: size=%d (%d+%d+%d=%d ms) (%d Hz)\n",
+	       buffer->size,
+	       B2MS(buffer->mix_size),
+	       B2MS(buffer->preload_size),
+	       B2MS(buffer->sync_size),
+	       B2MS(buffer->size),
+	       the_rate));
+
+	/* allocate buffer */
+	if (!(buffer->data = g_malloc0(buffer->size)))
+	{
+		DEBUG(("[crossfade] open_output: error allocating buffer!\n"));
+		the_op->close_audio();
+		the_op = NULL;
+		return -1;
+	}
+
+	/* reset buffer */
+	buffer_reset(buffer, config);
+
+	/* make sure stopped is TRUE -- otherwise the buffer thread would
+	 * stop again immediatelly after it has been started. */
+	stopped = FALSE;
+
+	/* create and run buffer thread */
+	if (THREAD_CREATE(buffer_thread, buffer_thread_f))
+	{
+		PERROR("[crossfade] open_output: thread_create()");
+		g_free(buffer->data);
+		the_op->close_audio();
+		the_op = NULL;
+		return -1;
+	}
+	SCHED_YIELD;
+
+	/* start updating monitor */
+	xfade_start_monitor();
+
+	/* done */
+	output_opened = TRUE;
+	return 0;
+}
+
+static void
+xfade_init()
+{
+	/* load config */
+	memset(config, 0, sizeof(*config));
+	*config = config_default;
+	xfade_load_config();
+
+	/* set default strings if there is no existing config */
+	if (!config->oss_alt_audio_device) config->oss_alt_audio_device = g_strdup(DEFAULT_OSS_ALT_AUDIO_DEVICE);
+	if (!config->oss_alt_mixer_device) config->oss_alt_mixer_device = g_strdup(DEFAULT_OSS_ALT_MIXER_DEVICE);
+	if (!config->op_config_string)     config->op_config_string     = g_strdup(DEFAULT_OP_CONFIG_STRING);
+	if (!config->op_name)              config->op_name              = g_strdup(DEFAULT_OP_NAME);
+
+	/* check for realtime priority, it needs some special attention */
+	realtime = xfplayer_check_realtime_priority();
+
+	/* show monitor win if enabled in config */
+	xfade_check_monitor_win();
+
+	/* init contexts */
+	convert_init(&convert_context);
+#ifdef HAVE_LIBFFTW
+	fft_init(&fft_context);
+#endif
+
+	/* reset */
+	stopped = FALSE;
+
+	/* find current output plugin early so that volume control works
+	 * even if playback has not started yet. */
+	if (!(the_op = find_output()))
+		DEBUG(("[crossfade] init: could not find any output!\n"));
+
+	/* load any dynamic linked symbols */
+	load_symbols();
+
+	/* HACK: make sure we are at the beginning of XMMS' output plugin list */
+	output_list_hack();
+
+	/* realize config -- will also setup the pre-mixing effect plugin */
+	xfade_realize_config();
+}
+
+static void
+load_symbols()
+{
+#ifdef HAVE_DLFCN_H
+	void *handle;
+	char *error;
+	gchar **xmms_cfg;
+	gchar * (*get_gentitle_format)();
+
+	/* open ourselves (that is, the XMMS binary) */
+	handle = dlopen(NULL, RTLD_NOW);
+	if (!handle)
+	{
+		DEBUG(("[crossfade] init: dlopen(NULL) failed!\n"));
+		return;
+	}
+
+	/* check for XMMS patches */
+	DEBUG(("[crossfade] load_symbols: input_stopped_for_restart:"));
+	input_stopped_for_restart = dlsym(handle, "input_stopped_for_restart");
+	DEBUG((!(error = dlerror())? " found\n" : " missing\n"));
+
+	DEBUG(("[crossfade] load_symbols: is_quitting:"));
+	xmms_is_quitting = dlsym(handle, "is_quitting");
+	DEBUG((!(error = dlerror())? " found\n" : " missing\n"));
+
+	DEBUG(("[crossfade] load_symbols: playlist_get_fadeinfo:"));
+	playlist_get_fadeinfo = dlsym(handle, "playlist_get_fadeinfo");
+	DEBUG((!(error = dlerror())? " found\n" : " missing\n"));
+
+	/* check for some XMMS functions */
+	xmms_playlist_get_info_going = dlsym(handle, "playlist_get_info_going");
+	xmms_input_get_song_info     = dlsym(handle, "input_get_song_info");
+
+	/* HACK: direct access to XMMS' config 'gentitle_format' */
+	xmms_cfg = dlsym(handle, "cfg");
+	get_gentitle_format = dlsym(handle, "xmms_get_gentitle_format");
+	if (xmms_cfg && get_gentitle_format)
+	{
+		gchar *format = get_gentitle_format();
+
+		int i = 128;
+		gchar **p = (gchar **)xmms_cfg;
+		for (i = 128; i > 0 && *p != format; i--, p++);
+		if (*p == format)
+			xmms_gentitle_format = p;
+	}
+
+	dlclose(handle);
+#endif
+}
+
+/*
+  HACK: Try to move ourselves to the beginning of XMMS output plugin list,
+        so that we will be freed first when XMMS is quitting. This way, we
+        avoid the segfault when using ALSA as the output plugin.     
+*/
+static void
+output_list_hack()
+{
+	GList *output_list = xfplayer_get_output_list();
+	if (!output_list)
+		return;
+
+	int i0 = g_list_index(output_list, xfade_op), i1;
+
+	GList *first = g_list_first(output_list);
+	GList *xfade = g_list_find(output_list, xfade_op);
+	xfade->data = first->data;
+	first->data = xfade_op;
+
+	i1 = g_list_index(output_list, xfade_op);
+	if (i0 != i1)
+		DEBUG(("[crossfade] output_list_hack: crossfade moved from index %d to %d\n", i0, i1));
+}
+
+void
+xfade_get_volume(int *l, int *r)
+{
+	if (config->mixer_software)
+	{
+		*l = config->mixer_reverse
+		   ? config->mixer_vol_right
+		   : config->mixer_vol_left;
+		*r = config->mixer_reverse
+		   ? config->mixer_vol_left
+		   : config->mixer_vol_right;
+	}
+	else
+	{
+		if (the_op && the_op->get_volume)
+		{
+			if (config->mixer_reverse)
+				the_op->get_volume(r, l);
+			else
+				the_op->get_volume(l, r);
+		}
+	}
+
+	/* DEBUG(("[crossfade] xfade_get_volume: l=%d r=%d\n", *l, *r)); */
+}
+
+void
+xfade_set_volume(int l, int r)
+{
+	/* DEBUG(("[crossfade] xfade_set_volume: l=%d r=%d\n", l, r)); */
+
+	if (!config->enable_mixer)
+		return;
+
+	if (the_op && the_op->set_volume)
+	{
+		if (config->mixer_reverse)
+			the_op->set_volume(r, l);
+		else
+			the_op->set_volume(l, r);
+	}
+}
+
+/*** buffer stuff ***********************************************************/
+
+static void
+buffer_mfg_reset(buffer_t *buf, config_t *cfg)
+{
+	buf->mix        = 0;
+	buf->fade       = 0;
+	buf->gap        = (cfg->gap_lead_enable ? MS2B(cfg->gap_lead_len_ms) & -4 : 0);
+	buf->gap_len    = buf->gap;
+	buf->gap_level  = cfg->gap_lead_level;
+	buf->gap_killed = 0;
+	buf->skip       = 0;
+	buf->skip_len   = 0;
+}
+
+static void
+buffer_reset(buffer_t *buf, config_t *cfg)
+{
+	buffer_mfg_reset(buf, cfg);
+
+	buf->rd_index = 0;
+	buf->used     = 0;
+	buf->preload  = buf->preload_size;
+
+	buf->silence     =  0;
+	buf->silence_len =  0;
+	buf->reopen      = -1;
+	buf->pause       = -1;
+}
+
+/****************************************************************************/
+
+static void
+xfade_apply_fade_config(fade_config_t *fc)
+{
+	gint out_skip, in_skip;
+	gint avail, out_len, in_len, offset, preload;
+	gint index, length, fade, n;
+	gfloat out_scale, in_scale;
+	gboolean out_skip_clipped = FALSE;
+	gboolean out_len_clipped = FALSE;
+	gboolean offset_clipped = FALSE;
+
+	/* Overwrites mix and fade; may add silence */
+
+	/*
+	 * Example 1: offset < 0 --> mix streams together
+	 * Example 2: offset > 0 --> insert pause between streams
+	 * 
+	 *     |----- out_len -----|    *     |out_len|
+	 *     |                   |    *     |       |
+	 * ~~~~~-_        /T~~~~~~~T~~  * ~~~~~\      |               /T~~
+	 *        ~-_    / |       |    *       \     |              / |
+	 *           ~-_/  |       |    *        \    |             /  |
+	 *             /~-_|       |    *         \   |            /   |
+	 *            /    T-_     |    *          \  |           /    |
+	 *           /     |  ~-_  |    *           \ |          /     |
+	 * _________/______|_____~-|__  * ___________\__________/______|__
+	 *          |in_len|       |    *             |         |in_len|
+	 *          |<-- offset ---|    *             |offset-->|
+	 *
+	 *  a) avail:   max(0, used - preload)
+	 *  b) out_len: 0 .. avail
+	 *  c) in_len:  0 .. #
+	 *  d) offset:  -avail .. buffer->mix_size - out_size
+	 *  e) skip:    min(used, preload)
+	 *
+	 */
+
+	out_scale = 1.0f - (gfloat) xfade_cfg_fadeout_volume(fc) / 100.0f;
+	in_scale  = 1.0f - (gfloat) xfade_cfg_fadein_volume (fc) / 100.0f;
+
+	/* rules (see above) */
+	/* a: leave preload untouched */
+	avail = buffer->used - buffer->preload_size;
+	if (avail < 0)
+		avail = 0;
+
+	/* skip end of song */
+	out_skip = MS2B(xfade_cfg_out_skip(fc)) & -4;
+	if (out_skip > avail)
+	{
+		DEBUG(("[crossfade] apply_fade_config: WARNING: clipping out_skip (%d -> %d)!\n", B2MS(out_skip), B2MS(avail)));
+		out_skip = avail;
+		out_skip_clipped = TRUE;
+	}
+
+	if (out_skip > 0)
+	{
+		buffer->used -= out_skip;
+		avail -= out_skip;
+	}
+
+	/* b: fadeout */
+	out_len = MS2B(xfade_cfg_fadeout_len(fc)) & -4;
+	if (out_len > avail)
+	{
+		DEBUG(("[crossfade] apply_fade_config: WARNING: clipping out_len (%d -> %d)!\n", B2MS(out_len), B2MS(avail)));
+		out_len = avail;
+		out_len_clipped = TRUE;
+	}
+	else if (out_len < 0)
+		out_len = 0;
+
+	/* skip beginning of song */
+	in_skip = MS2B(xfade_cfg_in_skip(fc)) & -4;
+	if (in_skip < 0)
+		in_skip = 0;
+
+	/* c: fadein */
+	in_len = MS2B(xfade_cfg_fadein_len(fc)) & -4;
+	if (in_len < 0)
+		in_len = 0;
+
+	/* d: offset (mixing point) */
+	offset = MS2B(xfade_cfg_offset(fc)) & -4;
+	if (offset < -avail)
+	{
+		DEBUG(("[crossfade] apply_fade_config: WARNING: clipping offset (%d -> %d)!\n", B2MS(offset), -B2MS(avail)));
+		offset = -avail;
+		offset_clipped = TRUE;
+	}
+	if (offset > (buffer->mix_size - out_len))
+		offset = buffer->mix_size - out_len;
+
+	/* e */
+	preload = buffer->preload_size;
+	if (preload > buffer->used)
+		preload = buffer->used;
+
+	/* cut off rest of stream (decreases latency on manual songchange) */
+	if (fc->flush)
+	{
+		gint cutoff = avail - MAX(out_len, -offset);	/* MAX() -> glib.h */
+		if (cutoff > 0)
+		{
+			DEBUG(("[crossfade] apply_fade_config: %d ms flushed\n", B2MS(cutoff)));
+			buffer->used -= cutoff;
+			avail -= cutoff;
+		}
+
+		/* make sure there is no pending silence */
+		buffer->silence = 0;
+		buffer->silence_len = 0;
+	}
+
+	/* begin modifying buffer at index */
+	index = (buffer->rd_index + buffer->used - out_len) % buffer->size;
+
+	/* fade out (modifies buffer directly) */
+	fade = 0;
+	length = out_len;
+	while (length > 0)
+	{
+		gint16 *p = buffer->data + index;
+		gint blen = buffer->size - index;
+		if (blen > length) blen = length;
+
+		for (n = blen / 4; n > 0; n--)
+		{
+			gfloat factor = 1.0f - (((gfloat) fade / out_len) * out_scale);
+			*p = (gfloat)*p * factor; p++;
+			*p = (gfloat)*p * factor; p++;
+			fade += 4;
+		}
+
+		index = (index + blen) % buffer->size;
+		length -= blen;
+	}
+
+	/* Initialize fadein. Note that the actual fading / mixing will be done
+	 * on-the-fly when audio data is received by xfade_write_audio() */
+
+	/* start skipping */
+	if (in_skip > 0)
+	{
+		buffer->skip = in_skip;
+		buffer->skip_len = in_skip;
+	}
+	else
+		buffer->skip = 0;
+
+	/* start fading in */
+	if (in_len > 0)
+	{
+		buffer->fade = in_len;
+		buffer->fade_len = in_len;
+		buffer->fade_scale = in_scale;
+	}
+	else
+		buffer->fade = 0;
+
+	/* start mixing */
+	if (offset < 0)
+	{
+		length = -offset;
+		buffer->mix = length;
+		buffer->used -= length;
+	}
+	else
+		buffer->mix = 0;
+
+	/* start silence if applicable (will be applied in buffer_thread_f) */
+	if (offset > 0)
+	{
+		if ((buffer->silence > 0) || (buffer->silence_len > 0))
+			DEBUG(("[crossfade] apply_config: WARNING: silence in progress (%d/%d ms)\n",
+			       B2MS(buffer->silence), B2MS(buffer->silence_len)));
+
+		buffer->silence = buffer->used;
+		buffer->silence_len = offset;
+	}
+
+	/* done */
+	if (in_skip || out_skip)
+		DEBUG(("[crossfade] apply_fade_config: out_skip=%d in_skip=%d\n", B2MS(out_skip), B2MS(in_skip)));
+	DEBUG(("[crossfade] apply_fade_config: avail=%d out=%d in=%d offset=%d preload=%d\n",
+	       B2MS(avail), B2MS(out_len), B2MS(in_len), B2MS(offset), B2MS(preload)));
+}
+
+static gint
+extract_track(const gchar *name)
+{
+#if 1
+	/* skip non-digits at beginning */
+	while (*name && !isdigit(*name))
+		name++;
+		
+	return atoi(name);
+#else
+	/* Remove all but numbers.
+	 * Will not work if a filename has number in the title, like "track-03-U2.mp3" 
+	 * Ideally, should look into id3 track entry and fallback to filename
+	 * */
+	gchar temp[8];
+	int t = 0;
+
+	memset(temp, 0, sizeof(temp));
+	while (*name != '\0' && t < sizeof(temp))
+	{
+		if (strcmp(name, "mp3") == 0)
+			break;
+			
+		if (isdigit(*name))
+			temp[t++] = *name;
+			
+		name++;
+	}
+	return atoi(temp);
+#endif
+}
+
+static gint
+album_match(gchar *old, gchar *new)
+{
+	gchar *old_dir, *new_dir;
+	gboolean same_dir;
+	gint old_track = 0, new_track = 0;
+
+	if (!old || !new)
+		return 0;
+
+	old_dir = g_dirname(old);
+	new_dir = g_dirname(new);
+	same_dir = !strcmp(old_dir, new_dir);
+	g_free(old_dir);
+	g_free(new_dir);
+
+	if (!same_dir)
+	{
+		DEBUG(("[crossfade] album_match: no match (different dirs)\n"));
+		return 0;
+	}
+
+	old_track = extract_track(g_basename(old));
+	new_track = extract_track(g_basename(new));
+
+	if (new_track <= 0)
+	{
+		DEBUG(("[crossfade] album_match: can't parse track number:\n"));
+		DEBUG(("[crossfade] album_match: ... \"%s\"\n", g_basename(new)));
+		return 0;
+	}
+
+	if ((old_track < 0) || (old_track + 1 != new_track))
+	{
+		DEBUG(("[crossfade] album_match: no match (same dir, but non-successive (%d, %d))\n", old_track, new_track));
+		return 0;
+	}
+
+	DEBUG(("[crossfade] album_match: match detected (same dir, successive tracks (%d, %d))\n", old_track, new_track));
+
+	return old_track;
+}
+
+static gint
+xfade_open_audio(AFormat fmt, int rate, int nch)
+{
+	gint pos;
+	gchar *file, *title, *comment;
+#if defined(HAVE_ID3LIB)
+	id3_t id3;
+#endif
+
+	struct timeval tv;
+	glong dt;
+
+	DEBUG(("[crossfade]\n"));
+	DEBUG(("[crossfade] open_audio: pid=%d\n", (int) getpid()));
+
+	/* sanity... don't do anything about it */
+	if (opened)
+		DEBUG(("[crossfade] open_audio: WARNING: already opened!\n"));
+
+	/* get filename */
+	pos     = xfplaylist_get_position ();
+	file    = xfplaylist_get_filename (pos);
+	title   = xfplaylist_get_songtitle(pos);
+	comment = playlist_get_fadeinfo ? playlist_get_fadeinfo(pos) : NULL;
+
+	if (!file)
+		file = g_strdup(title);
+		
+	DEBUG(("[crossfade] open_audio: bname=\"%s\"\n", g_basename(file)));
+	DEBUG(("[crossfade] open_audio: title=\"%s\"\n", title));
+
+#if 0
+	/* HACK: try to get comment and track number from xmms by sneaking in a custom title format */
+	if (xmms_gentitle_format)
+	{
+		gchar *old_gentitle_format = *xmms_gentitle_format;
+
+		gchar *temp_title  = NULL;
+		gint   temp_length = 0;
+
+		xmms_input_get_song_info(file, &temp_title, &temp_length);
+		DEBUG(("[crossfade] open_audio: TITLE: %s\n", temp_title));
+		g_free(temp_title);
+		
+		*xmms_gentitle_format = "%n/%c";
+
+		xmms_input_get_song_info(file, &temp_title, &temp_length);
+		DEBUG(("[crossfade] open_audio: TRACK/COMMENT: %s\n", temp_title));
+		g_free(temp_title);
+
+		*xmms_gentitle_format = old_gentitle_format;
+	}
+#endif
+
+	/* try to read comment from ID3 tag */
+#if defined(HAVE_ID3LIB)
+	if (!comment && get_id3(file, &id3))
+		comment = g_strdup(id3.comment);
+#endif
+
+	if (comment)
+		DEBUG(("[crossfade] open_audio: comment=\"%s\"\n", comment))
+	else
+		DEBUG(("[crossfade] open_audio: comment=NULL\n"));
+
+	/* is this an automatic crossfade? */
+	if (last_filename && (fade_config == &config->fc[FADE_CONFIG_XFADE]))
+	{
+		/* check if next song is the same as the current one */
+		if (config->no_xfade_if_same_file && !strcmp(last_filename, file))
+		{
+			DEBUG(("[crossfade] open_audio: same file, disabling crossfade\n"));
+			fade_config = &config->fc[FADE_CONFIG_ALBUM];
+		}
+
+		/* check if next song is the next song from the same album */
+		else if (config->album_detection && album_match(last_filename, file))
+		{
+			gboolean use_fc_album = FALSE;
+			
+			if (xfade_cfg_gap_trail_enable(config))
+			{
+				DEBUG(("[crossfade] album_match: "
+				       "trailing gap: length=%d/%d ms\n", B2MS(buffer->gap_killed), B2MS(buffer->gap_len)));
+
+				if (buffer->gap_killed < buffer->gap_len)
+				{
+					DEBUG(("[crossfade] album_match: "
+					       "trailing gap: -> no silence, probably pre-faded\n"));
+					use_fc_album = TRUE;
+				}
+				else
+				{
+					DEBUG(("[crossfade] album_match: " "trailing gap: -> silence, sticking to XFADE\n"));
+				}
+			}
+			else
+			{
+				DEBUG(("[crossfade] album_match: " "trailing gap killer disabled\n"));
+				use_fc_album = TRUE;
+			}
+
+			if (use_fc_album)
+			{
+				DEBUG(("[crossfade] album_match: " "-> using FADE_CONFIG_ALBUM\n"));
+				fade_config = &config->fc[FADE_CONFIG_ALBUM];
+			}
+		}
+	}
+	g_free(last_filename);
+	last_filename = g_strdup(file);
+
+#if 0
+	/* FIXME: finish this */
+	/* Check if this is a short song. */
+	if (fade_config == &config->fc[FADE_CONFIG_XFADE])
+	{
+		DEBUG(("*** XFADE:\n"));
+		int current_length = playlist_get_current_length();
+		DEBUG(("*** length=%d\n", current_length));
+		if (current_length < 30 * 1000)
+			fade_config = &config->fc[FADE_CONFIG_ALBUM];
+	}
+#endif
+
+#ifdef TIMING_COMMENTS
+	last_timing = current_timing;
+	current_timing. in.enable = FALSE;
+	current_timing.out.enable = FALSE;
+	if (comment)
+	{
+		gchar *str;
+		if ((str = strstr(comment, "fadein=")))
+		{
+			current_timing.in.enable =
+			(3 == sscanf(str + 7, "%d,%d,%d",
+				&current_timing.in.len_ms,
+				&current_timing.in.volume,
+				&current_timing.in.skip_ms));
+			current_timing.in.ofs_ms = 0;  /* not used */
+		}
+
+		if ((str = strstr(comment, "fadeout=")))
+		{
+			current_timing.out.enable =
+			(4 == sscanf(str + 8, "%d,%d,%d,%d",
+				&current_timing.out.len_ms,
+				&current_timing.out.volume,
+				&current_timing.out.skip_ms,
+				&current_timing.out.ofs_ms));
+		}
+	}
+
+#if 0
+	//
+	// use the fade info only on a regular, non-manual songchange
+	//
+	if (fade_config && !((fade_config->config == FADE_CONFIG_XFADE) ||
+	                     (fade_config->config == FADE_CONFIG_ALBUM)))
+	      last_timing.out.enable = FALSE;
+#endif
+
+#if 1	
+	if (last_timing.out.enable || current_timing.in.enable)
+#else
+	if ((last_timing.out.enable || current_timing.in.enable) &&
+	   (!fade_config ||
+	    (fade_config->config == FADE_CONFIG_XFADE) ||
+	    (fade_config->config == FADE_CONFIG_ALBUM)))
+#endif
+	{
+		config->fc[FADE_CONFIG_TIMING].out_len_ms    = xfade_cfg_fadeout_len   (fade_config);
+		config->fc[FADE_CONFIG_TIMING].out_volume    = xfade_cfg_fadeout_volume(fade_config);
+		config->fc[FADE_CONFIG_TIMING].out_skip_ms   = 0;
+		config->fc[FADE_CONFIG_TIMING].ofs_custom_ms = xfade_cfg_offset        (fade_config);
+		config->fc[FADE_CONFIG_TIMING].in_skip_ms    = 0;
+		config->fc[FADE_CONFIG_TIMING].in_len_ms     = xfade_cfg_fadein_len    (fade_config);
+		config->fc[FADE_CONFIG_TIMING].in_volume     = xfade_cfg_fadein_volume (fade_config);
+		config->fc[FADE_CONFIG_TIMING].flush         = fade_config && fade_config->flush;
+
+		if (last_timing.out.enable && current_timing.in.enable)
+			config->fc[FADE_CONFIG_TIMING].ofs_custom_ms = 0;
+
+		if (last_timing.out.enable)
+		{
+			DEBUG(("[crossfade] open_audio: TIMING: out: enable=%d len=%d volume=%d skip=%d ofs=%d\n",
+				last_timing.out.enable,
+				last_timing.out.len_ms,
+				last_timing.out.volume,
+				last_timing.out.skip_ms,
+				last_timing.out.ofs_ms));
+
+			config->fc[FADE_CONFIG_TIMING].out_len_ms     = last_timing.out.len_ms;
+			config->fc[FADE_CONFIG_TIMING].out_volume     = last_timing.out.volume;
+			config->fc[FADE_CONFIG_TIMING].out_skip_ms    = last_timing.out.skip_ms;
+			config->fc[FADE_CONFIG_TIMING].ofs_custom_ms += last_timing.out.ofs_ms;
+		}
+		if (current_timing.in.enable)
+		{
+			DEBUG(("[crossfade] open_audio: TIMING:  in: enable=%d len=%d volume=%d skip=%d\n",
+				current_timing.in.enable,
+				current_timing.in.len_ms,
+				current_timing.in.volume,
+				current_timing.in.skip_ms));
+				
+			config->fc[FADE_CONFIG_TIMING].in_skip_ms     = current_timing.in.skip_ms;
+			config->fc[FADE_CONFIG_TIMING].in_len_ms      = current_timing.in.len_ms;
+			config->fc[FADE_CONFIG_TIMING].in_volume      = current_timing.in.volume;
+			config->fc[FADE_CONFIG_TIMING].ofs_custom_ms -= current_timing.in.ofs_ms; 
+			/* NOTE: in.ofs_ms is currently not used always 0 */
+		}
+		
+		fade_config = &config->fc[FADE_CONFIG_TIMING];
+	}
+#endif
+
+	/* cleanup */
+	g_free(file); file = NULL;
+	g_free(title); title = NULL;
+	g_free(comment); comment = NULL;
+
+	/* check for HTTP streaming */
+	if (config->enable_http_workaround && (0 == strncasecmp(file, "http://", 7)))
+	{
+		DEBUG(("[crossfade] open_audio: HTTP underrun workaround enabled.\n"));
+		is_http = TRUE;
+	}
+	else
+		is_http = FALSE;
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	/* reset writer timeout */
+	gettimeofday(&last_write, NULL);
+
+	/* calculate time since last close() (don't care about overflows at 24h) */
+	if (output_opened)
+	{
+		gettimeofday(&tv, NULL);
+		dt = (tv.tv_sec - last_close.tv_sec) * 1000 + (tv.tv_usec - last_close.tv_usec) / 1000;
+	}
+	else
+		dt = 0;
+
+	DEBUG(("[crossfade] open_audio: fmt=%s rate=%d nch=%d dt=%ld ms\n", format_name(fmt), rate, nch, dt));
+
+	/* check format */
+	if (setup_format(fmt, rate, nch, &in_format) < 0)
+	{
+		DEBUG(("[crossfade] open_audio: format not supported!\n"));
+		return 0;
+	}
+
+	/* (re)open the device if necessary */
+	if (!output_opened)
+	{
+		if (open_output())
+		{
+			DEBUG(("[crossfade] open_audio: error opening/configuring output!\n"));
+			MUTEX_UNLOCK(&buffer_mutex);
+			return 0;
+		}
+		fade_config = &config->fc[FADE_CONFIG_START];
+	}
+
+	/* reset */
+	streampos = 0;
+	playing   = TRUE;
+	opened    = TRUE;
+	paused    = FALSE;
+
+	/* reset mix/fade/gap */
+	buffer_mfg_reset(buffer, config);
+
+	/* enable gap killer / zero crossing only for automatic/album songchange */
+	switch (fade_config->config)
+	{
+		case FADE_CONFIG_XFADE:
+		case FADE_CONFIG_ALBUM:
+			break;
+
+		default:
+			buffer->gap = GAP_SKIPPING_DONE;
+	}
+
+	/* restart realtime throttling */
+	output_written = 0;
+
+	/* start mixing */
+	switch (fade_config ? fade_config->type : -1)
+	{
+		case FADE_TYPE_FLUSH:
+			DEBUG(("[crossfade] open_audio: FLUSH:\n"));
+
+			/* flush output plugin */
+			the_op->flush(0);
+			output_streampos = 0;
+
+			/* flush buffer */
+			buffer_reset(buffer, config);
+
+			/* apply fade config (pause/fadein after flush) */
+			xfade_apply_fade_config(fade_config);
+
+			/* also repopen device (if configured so in the plugin compat. options) */
+			if (the_op_config.force_reopen)
+			{
+				buffer->reopen = 0;
+				buffer->reopen_sync = FALSE;
+			}
+			break;
+
+		case FADE_TYPE_REOPEN:
+			DEBUG(("[crossfade] open_audio: REOPEN:\n"));
+
+			/* flush buffer if applicable */
+			if (fade_config->flush)
+				buffer_reset(buffer, config);
+
+			if (buffer->reopen >= 0)
+				DEBUG(("[crossfade] open_audio: REOPEN: WARNING: reopen in progress (%d ms)\n",
+				       B2MS(buffer->reopen)));
+
+			/* start reopen countdown (will be executed in buffer_thread_f) */
+			buffer->reopen = buffer->used;	/* may be 0 */
+			buffer->reopen_sync = FALSE;
+			break;
+
+		case FADE_TYPE_NONE:
+		case FADE_TYPE_PAUSE:
+		case FADE_TYPE_SIMPLE_XF:
+		case FADE_TYPE_ADVANCED_XF:
+		case FADE_TYPE_FADEIN:
+		case FADE_TYPE_FADEOUT:
+			DEBUG(("[crossfade] open_audio: XFADE:\n"));
+
+			/* apply fade config (do fadeout, init mix/fade/gap, add silence) */
+			xfade_apply_fade_config(fade_config);
+
+			/* set reopen countdown. after buffer_thread_f has written
+			 * buffer->reopen bytes, it will close/reopen the output plugin. */
+			if (the_op_config.force_reopen && !(fade_config->config == FADE_CONFIG_START))
+			{
+				if (buffer->reopen >= 0)
+					DEBUG(("[crossfade] open_audio: XFADE: WARNING: reopen in progress (%d ms)\n",
+					       B2MS(buffer->reopen)));
+				buffer->reopen = buffer->used;
+				buffer->reopen_sync = TRUE;
+			}
+			break;
+	}
+
+	/* calculate offset of the output plugin */
+	output_offset = the_op->written_time() + B2MS(buffer->used) + B2MS(buffer->silence_len);
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+
+	/* done */
+	return 1;
+}
+
+void
+xfade_write_audio(void *ptr, int length)
+{
+	gint free;
+	gint ofs = 0;
+	format_t format;
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] write_audio: ptr=0x%08lx, length=%d\n", (long) ptr, length));
+#endif
+
+	/* sanity */
+	if (length <= 0)
+		return;
+
+	if (length & 3)
+	{
+		DEBUG(("[crossfade] write_audio: truncating %d bytes!\n", length & 3));
+		length &= -4;
+	}
+
+	/* update input accumulator (using input format size) */
+	streampos += length;
+
+	/* convert sample format (signed-16bit-ne 44100hz stereo) */
+	format_copy(&format, &in_format);
+	length = convert_flow(&convert_context, (gpointer *) &ptr, length, &format);
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	/* check if device has been closed, reopen if necessary */
+	if (!output_opened)
+	{
+		if (open_output())
+		{
+			DEBUG(("[crossfade] write_audio: reopening failed!\n"));
+			MUTEX_UNLOCK(&buffer_mutex);
+			return;
+		}
+	}
+
+	/* reset timeout */
+	gettimeofday(&last_write, NULL);
+
+	/* calculate free buffer space, check for overflow (should never happen :) */
+	free = buffer->size - buffer->used;
+	if (length > free)
+	{
+		DEBUG(("[crossfade] write_audio: %d bytes truncated!\n", length - free));
+		length = free;
+	}
+
+	/* skip beginning of song */
+	if ((length > 0) && (buffer->skip > 0))
+	{
+		gint blen = MIN(length, buffer->skip);
+
+		buffer->skip -= blen;
+		length -= blen;
+		ptr += blen;
+	}
+
+	/* kill leading gap */
+	if ((length > 0) && (buffer->gap > 0))
+	{
+		gint blen = MIN(length, buffer->gap);
+		gint16 *p = ptr;
+		gint index = 0;
+
+		gint16 left, right;
+		while (index < blen)
+		{
+			left = *p++, right = *p++;
+			if (ABS(left)  >= buffer->gap_level) break;
+			if (ABS(right) >= buffer->gap_level) break;
+			index += 4;
+		}
+
+		buffer->gap -= index;
+		length -= index;
+		ptr += index;
+
+		if ((index < blen) || (buffer->gap <= 0))
+		{
+			buffer->gap_killed = buffer->gap_len - buffer->gap;
+			buffer->gap = 0;
+
+			DEBUG(("[crossfade] write_audio: leading gap size: %d/%d ms\n",
+			       B2MS(buffer->gap_killed), B2MS(buffer->gap_len)));
+
+			/* fix streampos */
+			streampos -= (gint64) buffer->gap_killed * in_format.bps / out_format.bps;
+		}
+	}
+
+	/* start skipping to next crossing (if enabled) */
+	if (buffer->gap == 0)
+	{
+		if (config->gap_crossing)
+		{
+			buffer->gap = GAP_SKIPPING_POSITIVE;
+			buffer->gap_skipped = 0;
+		}
+		else
+			buffer->gap = GAP_SKIPPING_DONE;
+	}
+
+	/* skip until next zero crossing (pos -> neg) */
+	if ((length > 0) && (buffer->gap == GAP_SKIPPING_POSITIVE))
+	{
+		gint16 *p = ptr;
+		gint index = 0;
+
+		gint16 left;
+		while (index < length)
+		{
+			left = *p++;
+			p++;
+			if (left < 0)
+				break;
+			index += 4;
+		}
+
+		buffer->gap_skipped += index;
+		length -= index;
+		ptr += index;
+
+		if (index < length)
+			buffer->gap = GAP_SKIPPING_NEGATIVE;
+	}
+
+	/* skip until next zero crossing (neg -> pos) */
+	if ((length > 0) && (buffer->gap == GAP_SKIPPING_NEGATIVE))
+	{
+		gint16 *p = ptr;
+		gint index = 0;
+
+		gint16 left;
+		while (index < length)
+		{
+			left = *p++;
+			p++;
+			if (left >= 0)
+				break;
+			index += 4;
+		}
+
+		buffer->gap_skipped += index;
+		length -= index;
+		ptr += index;
+
+		if (index < length)
+		{
+			DEBUG(("[crossfade] write_audio: %d samples to next crossing\n", buffer->gap_skipped));
+			buffer->gap = GAP_SKIPPING_DONE;
+		}
+	}
+
+	/* update preload. the buffer thread will not write any
+	 * data to the device before preload is decreased below 1. */
+	if ((length > 0) && (buffer->preload > 0))
+		buffer->preload -= length;
+
+	/* fadein -- FIXME: is modifying the input/effect buffer safe? */
+	if ((length > 0) && (buffer->fade > 0))
+	{
+		gint16 *p = ptr;
+		gint blen = MIN(length, buffer->fade);
+		gint n;
+
+		for (n = blen / 4; n > 0; n--)
+		{
+			gfloat factor = 1.0f - (((gfloat) buffer->fade / buffer->fade_len) * buffer->fade_scale);
+			*p = (gfloat)*p * factor; p++;
+			*p = (gfloat)*p * factor; p++;
+			buffer->fade -= 4;
+		}
+	}
+
+	/* mix */
+	while ((length > 0) && (buffer->mix > 0))
+	{
+		gint wr_index = (buffer->rd_index + buffer->used) % buffer->size;
+		gint     blen = buffer->size - wr_index;
+		gint16    *p1 = buffer->data + wr_index;
+		gint16    *p2 = ptr + ofs;
+		gint n;
+
+		if (blen > length)      blen = length;
+		if (blen > buffer->mix) blen = buffer->mix;
+
+		for (n = blen / 2; n > 0; n--)
+		{
+			gint out = (gint)*p1 + *p2++;  /* add */
+			if (out > 32767)               /* clamp */
+				*p1++ = 32767;
+			else if (out < -32768)
+				*p1++ = -32768;
+			else
+				*p1++ = out;
+		}
+
+		buffer->used += blen;
+		buffer->mix -= blen;
+		length -= blen;
+		ofs += blen;
+	}
+
+	/* normal write */
+	while (length > 0)
+	{
+		gint wr_index = (buffer->rd_index + buffer->used) % buffer->size;
+		gint blen = buffer->size - wr_index;
+
+		if (blen > length)
+			blen = length;
+
+		memcpy(buffer->data + wr_index, ptr + ofs, blen);
+
+		buffer->used += blen;
+		length -= blen;
+		ofs += blen;
+	}
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] write_audio: done.\n"));
+#endif
+}
+
+/* sync_output: wait for output plugin to finish playback  */
+/*              is only called from within buffer_thread_f */
+static void
+sync_output()
+{
+	glong dt, total;
+	gint opt, opt_last;
+	struct timeval tv, tv_start, tv_last_change;
+	gboolean was_closed = !opened;
+
+	if (!the_op->buffer_playing || !the_op->buffer_playing())
+	{
+		DEBUG(("[crossfade] sync_output: nothing to do\n"));
+		return;
+	}
+
+	DEBUG(("[crossfade] sync_output: waiting for plugin...\n"));
+
+	dt = 0;
+	opt_last = 0;
+	gettimeofday(&tv_start, NULL);
+	gettimeofday(&tv_last_change, NULL);
+
+	while ((dt < SYNC_OUTPUT_TIMEOUT)
+	       && !stopped && output_opened && !(was_closed && opened) && the_op && the_op->buffer_playing())
+	{
+
+		/* use output_time() to check if the output plugin is still active */
+		if (the_op->output_time)
+		{
+			opt = the_op->output_time();
+			if (opt != opt_last)
+			{
+				/* output_time has changed */
+				opt_last = opt;
+				gettimeofday(&tv_last_change, NULL);
+			}
+			else
+			{
+				/* calculate time since last change of the_op->output_time() */
+				gettimeofday(&tv, NULL);
+				dt = (tv.tv_sec - tv_last_change.tv_sec) * 1000 + (tv.tv_usec - tv_last_change.tv_usec) / 1000;
+			}
+		}
+
+		/* yield */
+		MUTEX_UNLOCK(&buffer_mutex);
+		xfade_usleep(10000);
+		MUTEX_LOCK(&buffer_mutex);
+	}
+
+	/* calculate total time we spent in here */
+	gettimeofday(&tv, NULL);
+	total = (tv.tv_sec - tv_start.tv_sec) * 1000 + (tv.tv_usec - tv_start.tv_usec) / 1000;
+
+	/* print some debug info */
+	/* *INDENT-OFF* */
+	if (stopped)
+		DEBUG(("[crossfade] sync_output: ... stopped\n"))
+	else if (was_closed && opened)
+		DEBUG(("[crossfade] sync_output: ... reopened\n"))
+	else if (dt >= SYNC_OUTPUT_TIMEOUT)
+		DEBUG(("[crossfade] sync_output: ... TIMEOUT! (%ld ms)\n", total))
+	else
+		DEBUG(("[crossfade] sync_output: ... done (%ld ms)\n", total));
+	/* *INDENT-ON* */
+}
+
+void *
+buffer_thread_f(void *arg)
+{
+	gpointer data;
+	gint sync;
+	gint op_free;
+	gint length_bak, length, blen;
+	glong timeout, dt;
+	gboolean stopping;
+
+	struct timeval tv;
+	struct timeval mark;
+
+	DEBUG(("[crossfade] buffer_thread_f: thread started (pid=%d)\n", (int) getpid()));
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	while (!stopped)
+	{
+		/* yield */
+#ifdef DEBUG_HARDCORE
+		DEBUG(("[crossfade] buffer_thread_f: yielding...\n"));
+#endif
+		MUTEX_UNLOCK(&buffer_mutex);
+		xfade_usleep(10000);
+		MUTEX_LOCK(&buffer_mutex);
+
+		/* --------------------------------------------------------------------- */
+
+		stopping = FALSE;
+
+		/* V0.3.0: New timeout detection */
+		if (!opened)
+		{
+			gboolean current = xfplayer_input_playing();
+
+			/* also see fini() */
+			if (last_close.tv_sec || last_close.tv_usec)
+			{
+				gettimeofday(&tv, NULL);
+				timeout = (tv.tv_sec  - last_close.tv_sec)  * 1000
+				        + (tv.tv_usec - last_close.tv_usec) / 1000;
+			}
+			else
+				timeout = -1;
+
+			if (current != input_playing)
+			{
+				input_playing = current;
+				
+				if (current)
+					DEBUG(("[crossfade] buffer_thread_f: input restarted after %ld ms\n", timeout))
+				else
+					DEBUG(("[crossfade] buffer_thread_f: input stopped after + %ld ms\n", timeout));
+			}
+
+			/* 0.3.0: HACK: output_keep_opened: play silence during prebuffering */
+			if (input_playing && config->output_keep_opened && (buffer->used == 0))
+			{
+				buffer->silence = 0;
+				buffer->silence_len = MS2B(100);
+			}
+
+			/* 0.3.9: Check for timeout only if we have not been stopped for restart */
+			/* 0.3.11: When using the songchange hack, depend on it's output_restart 
+			 *         flag. Without the hack, use the configuration's dialog songchange
+			 *         timeout setting instead of a fixed timeout value. */
+			if (input_stopped_for_restart && !output_restart)
+			{
+				if (playing)
+					DEBUG(("[crossfade] buffer_thread_f: timeout:"
+					       " stopping after %ld ms (songchange patch)\n", timeout));
+				stopping = TRUE;
+			}
+			else if (((timeout < 0) || (timeout >= config->songchange_timeout && !output_restart)) && !input_playing)
+			{
+				if (playing)
+					DEBUG(("[crossfade] buffer_thread_f: timeout:"
+					       " input did not restart after %ld ms\n", timeout));
+				stopping = TRUE;
+			}
+		}
+
+		/* V0.2.4: Moved the timeout checks in front of the buffer_free() check
+		 *         below. Before, buffer_thread_f could (theoretically) loop
+		 *         endlessly if buffer_free() returned 0 all the time. */
+
+		/* calculate time since last write to the buffer (ignore overflows) */
+		gettimeofday(&tv, NULL);
+		timeout = (tv.tv_sec  - last_write.tv_sec)  * 1000
+		        + (tv.tv_usec - last_write.tv_usec) / 1000;
+
+		/* check for timeout/eop (note this is the only way out of this loop) */
+		if (stopping)
+		{
+			if (playing)
+			{
+				DEBUG(("[crossfade] buffer_thread_f: timeout: manual stop\n"));
+
+				/* if CONFIG_STOP is of TYPE_NONE, immediatelly close the device... */
+				if ((config->fc[FADE_CONFIG_STOP].type == FADE_TYPE_NONE) && !config->output_keep_opened)
+					break;
+
+				/* special handling for pause */
+				if (paused)
+				{
+					DEBUG(("[crossfade] buffer_thread_f: timeout: paused, closing now...\n"));
+					paused = FALSE;
+					if (config->output_keep_opened)
+						the_op->pause(0);
+					else
+						break;
+				}
+				else if (buffer->pause >= 0)
+				{
+					DEBUG(("[crossfade] buffer_thread_f: timeout: cancelling pause countdown\n"));
+					buffer->pause = -1;
+				}
+
+				/* ...otherwise, do the fadeout first */
+				xfade_apply_fade_config(&config->fc[FADE_CONFIG_STOP]);
+
+				/* force CONFIG_START in case the user restarts playback during fadeout */
+				fade_config = &config->fc[FADE_CONFIG_START];
+				playing = FALSE;
+				eop = TRUE;
+			}
+			else
+			{
+				if (!eop)
+				{
+					DEBUG(("[crossfade] buffer_thread_f: timeout: end of playback\n"));
+
+					/* 0.3.3: undo trailing gap killer at end of playlist */
+					if (buffer->gap_killed)
+					{
+						buffer->used += buffer->gap_killed;
+						DEBUG(("[crossfade] buffer_thread_f: timeout:"
+						       " undoing trailing gap (%d ms)\n", B2MS(buffer->gap_killed)));
+					}
+
+					/* do the fadeout if applicable */
+					if (config->fc[FADE_CONFIG_EOP].type != FADE_TYPE_NONE)
+						xfade_apply_fade_config(&config->fc[FADE_CONFIG_EOP]);
+
+					fade_config = &config->fc[FADE_CONFIG_START];	/* see above */
+					eop = TRUE;
+				}
+
+				if (buffer->used == 0)
+				{
+					if (config->output_keep_opened)
+					{
+						/* 0.3.0: play silence while keeping the output opened */
+						buffer->silence = 0;
+						buffer->silence_len = MS2B(100);
+					}
+					else if (buffer->silence_len <= 0)
+					{
+						sync_output();
+						if (opened)
+						{
+							DEBUG(("[crossfade] buffer_thread_f: timeout, eop: device has been reopened\n"));
+							DEBUG(("[crossfade] buffer_thread_f: timeout, eop: -> continuing playback\n"));
+							eop = FALSE;
+						}
+						else
+						{
+							DEBUG(("[crossfade] buffer_thread_f: timeout, eop: closing output...\n"));
+							break;
+						}
+					}
+				}
+			}
+		}
+		else
+			eop = FALSE;
+
+		/* --------------------------------------------------------------------- */
+
+		/* get free space in device output buffer
+		 * NOTE: disk_writer always returns <big int> here */
+		op_free = the_op->buffer_free() & -4;
+
+		/* continue waiting if there is no room in the device buffer */
+		if (op_free == 0)
+			continue;
+
+		/* --- Limit OP buffer use (decreases latency) ------------------------- */
+
+		/* HACK: limit output plugin buffer usage to decrease latency */
+		if (config->enable_op_max_used)
+		{
+			gint output_time = the_op->output_time();
+			gint output_used = the_op->written_time() - output_time;
+			gint output_limit = MS2B(config->op_max_used_ms - MIN(output_used, config->op_max_used_ms));
+
+			if (output_flush_time != output_time)
+			{
+				/* slow down output, but always write _some_ data */
+				if (output_limit < in_format.bps / 100 / 2)
+					output_limit = in_format.bps / 100 / 2;
+
+				if (op_free > output_limit)
+					op_free = output_limit;
+			}
+		}
+
+		/* --- write silence --------------------------------------------------- */
+
+		if (!paused && (buffer->silence <= 0) && (buffer->silence_len >= 4))
+		{
+			/* write as much silence as a) there is left and b) the device can take */
+			length = buffer->silence_len;
+			if (length > op_free)
+				length = op_free;
+
+			/* make sure we always operate on stereo sample boundary */
+			length &= -4;
+
+			/* HACK: don't stay in here too long when in realtime mode (see below) */
+			if (realtime)
+				gettimeofday(&mark, NULL);
+
+			/* write length bytes to the device */
+			length_bak = length;
+			while (length > 0)
+			{
+				data = zero_4k;
+				blen = sizeof(zero_4k);
+				if (blen > length)
+					blen = length;
+
+				/* make sure zero_4k is cleared. The effect plugin within
+				 * the output plugin may have modified this buffer! (0.2.8) */
+				memset(zero_4k, 0, blen);
+
+				/* HACK: the original OSS plugin hangs when writing large
+				 * blocks (greater than device buffer size) in realtime mode */
+				if (the_op_config.max_write_enable && (blen > the_op_config.max_write_len))
+					blen = the_op_config.max_write_len;
+
+				/* finally, write data */
+				the_op->write_audio(data, blen);
+				length -= blen;
+
+				/* HACK: don't stay in here too long (force yielding every 10 ms) */
+				if (realtime)
+				{
+					gettimeofday(&tv, NULL);
+					dt = (tv.tv_sec  - mark.tv_sec)  * 1000
+					   + (tv.tv_usec - mark.tv_usec) / 1000;
+					if (dt >= 10)
+						break;
+				}
+			}
+
+			/* calculate how many bytes actually have been written */
+			length = length_bak - length;
+		}
+
+		/* --- write data ------------------------------------------------- */
+			
+		else if (!paused && (buffer->preload <= 0)  && (buffer->used >= 4))
+		{
+			/* write as much data as a) is available and b) the device can take */
+			length = buffer->used;
+			if (length > op_free)
+				length = op_free;
+
+			/* HACK: throttle output (used with fast output plugins) */
+			if (the_op_config.throttle_enable && !realtime && opened)
+			{
+				sync = buffer->sync_size - (buffer->size - buffer->used);
+				if      (sync < 0)      length = 0;
+				else if (sync < length) length = sync;
+			}
+
+			/* clip length to silence countdown (if applicable) */
+			if ((buffer->silence >= 4) && (length > buffer->silence))
+				length = buffer->silence;
+
+			/* clip length to reopen countdown (if applicable) */
+			if ((buffer->reopen >= 0) && (length > buffer->reopen))
+				length = buffer->reopen;
+
+			/* clip length to pause countdown (if applicable) */
+			if ((buffer->pause >= 0) && (length > buffer->pause))
+				length = buffer->pause;
+
+			/* make sure we always operate on stereo sample boundary */
+			length &= -4;
+
+			/* HACK: don't stay in here too long when in realtime mode (see below) */
+			if (realtime)
+				gettimeofday(&mark, NULL);
+
+			/* write length bytes to the device */
+			length_bak = length;
+			while (length > 0)
+			{
+				data = buffer->data + buffer->rd_index;
+				blen = buffer->size - buffer->rd_index;
+				if (blen > length)
+					blen = length;
+
+				/* HACK: the original OSS plugin hangs when writing large
+				 * blocks (greater than device buffer size) in realtime mode */
+				if (the_op_config.max_write_enable && (blen > the_op_config.max_write_len))
+					blen = the_op_config.max_write_len;
+
+#ifdef HAVE_LIBFFTW
+				/* fft playground */
+				fft_flow(&fft_context, (gpointer) data, blen);
+#endif
+				/* finally, write data */
+				the_op->write_audio(data, blen);
+
+				buffer->rd_index = (buffer->rd_index + blen) % buffer->size;
+				buffer->used -= blen;
+				length -= blen;
+
+				/* HACK: don't stay in here too long (force yielding every 10 ms) */
+				if (realtime)
+				{
+					gettimeofday(&tv, NULL);
+					dt = (tv.tv_sec - mark.tv_sec) * 1000 + (tv.tv_usec - mark.tv_usec) / 1000;
+					if (dt >= 10)
+						break;
+				}
+			}
+
+			/* calculate how many bytes actually have been written */
+			length = length_bak - length;
+		}
+		else
+			length = 0;
+
+		/* update realtime throttling */
+		output_written   += length;
+		output_streampos += length;
+
+		/* --- check countdowns ------------------------------------------------ */
+
+		if (buffer->silence > 0)
+		{
+			buffer->silence -= length;
+			if (buffer->silence < 0)
+				DEBUG(("[crossfade] buffer_thread_f: WARNING: silence overrun: %d\n", buffer->silence));
+		}
+		else if (buffer->silence_len > 0)
+		{
+			buffer->silence_len -= length;
+			if (buffer->silence_len <= 0)
+			{
+				if (buffer->silence_len < 0)
+					DEBUG(("[crossfade] buffer_thread_f: WARNING: silence_len overrun: %d\n",
+					       buffer->silence_len));
+			}
+		}
+
+		if ((buffer->reopen >= 0) && !((buffer->silence <= 0) && (buffer->silence_len > 0)))
+		{
+			buffer->reopen -= length;
+			if (buffer->reopen <= 0)
+			{
+				if (buffer->reopen < 0)
+					DEBUG(("[crossfade] buffer_thread_f: WARNING: reopen overrun: %d\n", buffer->reopen));
+
+				DEBUG(("[crossfade] buffer_thread_f: closing/reopening device\n"));
+				if (buffer->reopen_sync)
+					sync_output();
+
+				if (the_op->close_audio)
+					the_op->close_audio();
+					
+				if (!the_op->open_audio(out_format.fmt, out_format.rate, out_format.nch))
+				{
+					DEBUG(("[crossfade] buffer_thread_f: reopening output plugin failed!\n"));
+					g_free(buffer->data);
+					output_opened = FALSE;
+					MUTEX_UNLOCK(&buffer_mutex);
+					THREAD_EXIT(0);
+					return NULL;
+				}
+
+				output_flush_time = 0;
+				output_written    = 0;
+				output_streampos  = 0;
+
+				/* We need to take the leading gap killer into account here:
+				 * It will fix streampos only after gapkilling has finished.
+				 * So, if gapkilling is still in progress at this point, we
+				 * have to fix it ourselves. */
+				output_offset = buffer->used;
+				if ((buffer->gap_len > 0) && (buffer->gap > 0))
+					output_offset += buffer->gap_len - buffer->gap;
+				output_offset = B2MS(output_offset) - xfade_written_time();
+
+				/* make sure reopen is not 0 */
+				buffer->reopen = -1;
+			}
+		}
+
+		if (buffer->pause >= 0)
+		{
+			buffer->pause -= length;
+			if (buffer->pause <= 0)
+			{
+				if (buffer->pause < 0)
+					DEBUG(("[crossfade] buffer_thread_f: WARNING: pause overrun: %d\n", buffer->pause));
+
+				DEBUG(("[crossfade] buffer_thread_f: pausing output\n"));
+
+				paused = TRUE;
+				sync_output();
+
+				if (paused)
+					the_op->pause(1);
+				else
+					DEBUG(("[crossfade] buffer_thread_f: unpause during sync\n")) buffer->pause = -1;
+			}
+		}
+	}
+
+	/* ----------------------------------------------------------------------- */
+
+	/* cleanup: close output */
+	if (output_opened)
+	{
+		xfade_stop_monitor();
+
+		DEBUG(("[crossfade] buffer_thread_f: closing output...\n"));
+
+		if (the_op->close_audio)
+			the_op->close_audio();
+
+		DEBUG(("[crossfade] buffer_thread_f: closing output... done\n"));
+		
+		g_free(buffer->data);
+		output_opened = FALSE;
+	}
+	else
+		DEBUG(("[crossfade] buffer_thread_f: output already closed!\n"));
+
+	/* ----------------------------------------------------------------------- */
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+
+	/* done */
+	DEBUG(("[crossfade] buffer_thread_f: thread finished\n"));
+	THREAD_EXIT(0);
+	return NULL;
+}
+
+void
+xfade_close_audio()
+{
+	DEBUG(("[crossfade] close:\n"));
+	DEBUG(("[crossfade] close: playing=%d filename=%s\n",
+	       xfplayer_input_playing(), xfplaylist_get_filename(xfplaylist_get_position())));
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	/* sanity... the vorbis plugin likes to call close_audio() twice */
+	if (!opened)
+	{
+		DEBUG(("[crossfade] close: WARNING: not opened!\n"));
+		MUTEX_UNLOCK(&buffer_mutex);
+		return;
+	}
+
+#if defined(COMPILE_FOR_AUDACIOUS) && AUDACIOUS_ABI_VERSION >= 2
+	/* HACK: to distinguish between STOP and EOP, check Audacious'
+	   input_playing() variable. It seems to be TRUE at this point
+	   only when the end of the playlist is reached.
+	   
+	   Normally, 'playing' is constantly being updated in the
+	   xfade_buffer_playing() callback, but Audacious does not seem
+	   to use it. Therefore, we can set 'playing' to FALSE here,
+	   which later 'buffer_thread' will interpret as EOP (see above).
+	*/
+	if (xfplayer_input_playing())
+		playing = FALSE;
+#else
+	/* HACK: use patched XMMS 'input_stopped_for_restart' */
+	if (input_stopped_for_restart && *input_stopped_for_restart)
+	{
+		DEBUG(("[crossfade] close: playback will restart soon\n"));
+		output_restart = TRUE;
+	}
+	else
+		output_restart = FALSE;
+#endif
+
+	if (playing)
+	{
+		/* immediatelly close output when paused */
+		if (paused)
+		{
+			buffer->pause = -1;
+			paused = FALSE;
+			if (config->output_keep_opened)
+			{
+				buffer->used = 0;
+				the_op->flush(0);
+				the_op->pause(0);
+			}
+			else
+				stopped = TRUE;
+		}
+
+		/* HACK: If playlist_get_info_going is not true here,
+		 *       XMMS is about to exit. In this case, we stop
+		 *       the buffer thread before returning from this
+		 *       function. Otherwise, SEGFAULT may occur when
+		 *       XMMS tries to cleanup an output plugin which
+		 *       we are still using.
+		 *
+		 * NOTE: This hack has become obsolete as of 0.3.5.
+		 *       See output_list_hack().
+		 *
+		 * NOTE: Not quite. There still are some problems when
+		 *       XMMS is exitting while a song is playing. So
+		 *       this HACK has been enabled again.
+		 *
+		 * NOTE: Another thing: If output_keep_opened is enabled,
+		 *       close_audio() is never called, so that the patch
+		 *       can not work.
+		 */
+#if 1
+		if ((xmms_is_quitting && *xmms_is_quitting)
+		 || (xmms_playlist_get_info_going && !*xmms_playlist_get_info_going))
+		{
+			DEBUG(("[crossfade] close: stop (about to quit)\n"))
+
+			/* wait for buffer thread to clean up and terminate */
+			stopped = TRUE;
+#if 1
+			MUTEX_UNLOCK(&buffer_mutex);
+			if (THREAD_JOIN(buffer_thread))
+				PERROR("[crossfade] close: phtread_join()");
+			MUTEX_LOCK(&buffer_mutex);
+#else				
+			while (output_opened)
+			{
+				MUTEX_UNLOCK(&buffer_mutex);
+				xfade_usleep(10000);
+				MUTEX_LOCK(&buffer_mutex);
+			}
+#endif
+		}
+		else
+#endif
+			DEBUG(("[crossfade] close: stop\n"));
+
+		fade_config = &config->fc[FADE_CONFIG_MANUAL];
+	}
+	else
+	{
+		/* gint x = *((gint *)0); */  /* force SEGFAULT for debugging */
+		DEBUG(("[crossfade] close: songchange/eop\n"));
+
+		/* kill trailing gap (does not use buffer->gap_*) */
+		if (output_opened && xfade_cfg_gap_trail_enable(config))
+		{
+			gint gap_len   = MS2B(xfade_cfg_gap_trail_len(config)) & -4;
+			gint gap_level = xfade_cfg_gap_trail_level(config);
+			gint length    = MIN(gap_len, buffer->used);
+
+			/* DEBUG(("[crossfade] close: len=%d level=%d length=%d\n", gap_len, gap_level, length)); */
+
+			buffer->gap_killed = 0;
+			while (length > 0)
+			{
+				gint wr_xedni = (buffer->rd_index + buffer->used - 1) % buffer->size + 1;
+				gint     blen = MIN(length, wr_xedni);
+				gint16     *p = buffer->data + wr_xedni, left, right;
+				gint    index = 0;
+
+				while (index < blen)
+				{
+					right = *--p;
+					left  = *--p;
+					if (ABS(left)  >= gap_level) break;
+					if (ABS(right) >= gap_level) break;
+					index += 4;
+				}
+
+				buffer->used -= index;
+				buffer->gap_killed += index;
+
+				if (index < blen)
+					break;
+				length -= blen;
+			}
+
+			DEBUG(("[crossfade] close: trailing gap size: %d/%d ms\n", B2MS(buffer->gap_killed), B2MS(gap_len)));
+		}
+
+		/* skip to previous zero crossing */
+		if (output_opened && config->gap_crossing)
+		{
+			int crossing;
+
+			buffer->gap_skipped = 0;
+			for (crossing = 0; crossing < 4; crossing++)
+			{
+				while (buffer->used > 0)
+				{
+					gint wr_xedni = (buffer->rd_index + buffer->used - 1) % buffer->size + 1;
+					gint     blen = MIN(buffer->used, wr_xedni);
+					gint16     *p = buffer->data + wr_xedni, left;
+					gint    index = 0;
+
+					while (index < blen)
+					{
+						left = (--p, *--p);
+						if ((crossing & 1) ^ (left > 0))
+							break;
+						index += 4;
+					}
+
+					buffer->used -= index;
+					buffer->gap_skipped += index;
+
+					if (index < blen)
+						break;
+				}
+			}
+			DEBUG(("[crossfade] close: skipped %d bytes to previous zero crossing\n", buffer->gap_skipped));
+
+			/* update gap_killed (for undoing gap_killer in case of EOP) */
+			buffer->gap_killed += buffer->gap_skipped;
+		}
+
+		fade_config = &config->fc[FADE_CONFIG_XFADE];
+	}
+
+	/* XMMS has left the building */
+	opened = FALSE;
+
+	/* update last_close */
+	gettimeofday(&last_close, NULL);
+	input_playing = FALSE;
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+}
+
+void
+xfade_flush(gint time)
+{
+	gint pos;
+	gchar *file;
+
+	DEBUG(("[crossfade] flush: time=%d\n", time));
+
+	/* get filename */
+	pos  = xfplaylist_get_position();
+	file = xfplaylist_get_filename(pos);
+	
+	if (!file)
+		file = g_strdup(xfplaylist_get_songtitle(pos));
+
+#if defined(COMPILE_FOR_AUDACIOUS)
+	/* HACK: special handling for audacious, which just calls flush(0) on a songchange */
+	if (file && last_filename && strcmp(file, last_filename) != 0)
+	{
+		DEBUG(("[crossfade] flush: filename changed, forcing close/reopen...\n"));
+		xfade_close_audio();
+		/* 0.3.14: xfade_close_audio sets fade_config to FADE_CONFIG_MANUAL,
+		 *         but this is an automatic songchange */
+		fade_config = &config->fc[FADE_CONFIG_XFADE];
+		xfade_open_audio(in_format.fmt, in_format.rate, in_format.nch);
+		DEBUG(("[crossfade] flush: filename changed, forcing close/reopen... done\n"));
+		return;
+	}
+#endif
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	/* update streampos with new stream position (input format size) */
+	streampos = ((gint64) time * in_format.bps / 1000) & -4;
+
+	/* flush output device / apply seek crossfade */
+	if (config->fc[FADE_CONFIG_SEEK].type == FADE_TYPE_FLUSH)
+	{
+		/* flush output plugin */
+		the_op->flush(time);
+		output_flush_time = time;
+		output_streampos = MS2B(time);
+
+		/* flush buffer, disable leading gap killing */
+		buffer_reset(buffer, config);
+	}
+	else if (paused)
+	{
+		fade_config_t fc;
+
+		/* clear buffer */
+		buffer->used = 0;
+
+		/* apply only the fade_in part of FADE_CONFIG_PAUSE */
+		memcpy(&fc, &config->fc[FADE_CONFIG_PAUSE], sizeof(fc));
+		fc.out_len_ms    = 0;
+		fc.ofs_custom_ms = 0;
+		xfade_apply_fade_config(&fc);
+	}
+	else
+		xfade_apply_fade_config(&config->fc[FADE_CONFIG_SEEK]);
+
+	/* restart realtime throttling (should find another name for that var) */
+	output_written = 0;
+
+	/* make sure that the gapkiller is disabled */
+	buffer->gap = 0;
+
+	/* update output offset */
+	output_offset = the_op->written_time() - time + B2MS(buffer->used) + B2MS(buffer->silence_len);
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] flush: time=%d: done.\n", time));
+#endif
+}
+
+void
+xfade_pause(short p)
+{
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	if (p)
+	{
+		fade_config_t *fc = &config->fc[FADE_CONFIG_PAUSE];
+		if (fc->type == FADE_TYPE_PAUSE_ADV)
+		{
+			int fade, length, n;
+			int index = buffer->rd_index;
+			int out_len     = MS2B(xfade_cfg_fadeout_len(fc)) & -4;
+			int in_len      = MS2B(xfade_cfg_fadein_len(fc))  & -4;
+			int silence_len = MS2B(xfade_cfg_offset(fc))      & -4;
+
+			/* limit fadeout/fadein len to available data in buffer */
+			if ((out_len + in_len) > buffer->used)
+			{
+				out_len = (buffer->used / 2) & -4;
+				in_len = out_len;
+			}
+
+			DEBUG(("[crossfade] pause: paused=1 out=%d in=%d silence=%d\n",
+			       B2MS(out_len), B2MS(in_len), B2MS(silence_len)));
+
+			/* fade out (modifies buffer directly) */
+			fade = 0;
+			length = out_len;
+			while (length > 0)
+			{
+				gint16 *p = buffer->data + index;
+				gint blen = buffer->size - index;
+				if (blen > length)
+					blen = length;
+
+				for (n = blen / 4; n > 0; n--)
+				{
+					gfloat factor = 1.0f - ((gfloat) fade / out_len);
+					*p = (gfloat)*p * factor; p++;
+					*p = (gfloat)*p * factor; p++;
+					fade += 4;
+				}
+
+				index = (index + blen) % buffer->size;
+				length -= blen;
+			}
+
+			/* fade in (modifies buffer directly) */
+			fade = 0;
+			length = in_len;
+			while (length > 0)
+			{
+				gint16 *p = buffer->data + index;
+				gint blen = buffer->size - index;
+				if (blen > length)
+					blen = length;
+
+				for (n = blen / 4; n > 0; n--)
+				{
+					gfloat factor = (gfloat) fade / in_len;
+					*p = (gfloat)*p * factor; p++;
+					*p = (gfloat)*p * factor; p++;
+					fade += 4;
+				}
+
+				index = (index + blen) % buffer->size;
+				length -= blen;
+			}
+
+			/* start silence and pause countdowns */
+			buffer->silence = out_len;
+			buffer->silence_len = silence_len;
+			buffer->pause = out_len + silence_len;
+			paused = FALSE;	 /* (!) will be set to TRUE in buffer_thread_f */
+		}
+		else
+		{
+			the_op->pause(1);
+			paused = TRUE;
+			DEBUG(("[crossfade] pause: paused=1\n"));
+		}
+	}
+	else
+	{
+		the_op->pause(0);
+		buffer->pause = -1;
+		paused = FALSE;
+		DEBUG(("[crossfade] pause: paused=0\n"));
+	}
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+}
+
+gint
+xfade_buffer_free()
+{
+	gint size, free;
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] buffer_free:\n"));
+#endif
+
+	/* sanity check */
+	if (!output_opened)
+	{
+		DEBUG(("[crossfade] buffer_free: WARNING: output closed!\n"));
+		return buffer->sync_size;
+	}
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	size = buffer->size;
+
+	/* When running in realtime mode, we need to take special care here:
+	 * While XMMS is writing data to the output plugin, it will not yield
+	 * ANY processing time to the buffer thread. It will only stop when
+	 * xfade_buffer_free() no longer reports free buffer space. */
+	if (realtime)
+	{
+		gint64 wanted = output_written + buffer->preload_size;
+
+		/* Fix for XMMS misbehaviour (possibly a bug): If the free space as
+		 * returned by xfade_buffer_free() is below a certain minimum block size
+		 * (tests showed 2304 bytes), XMMS will not send more data until there
+		 * is enough room for one of those blocks.
+		 *
+		 * This breaks preloading in realtime mode. To make sure that the pre-
+		 * load buffer gets filled we request additional sync_size bytes. */
+		wanted += buffer->sync_size;
+
+		if (wanted <= size)
+			size = wanted;
+	}
+
+	free = size - buffer->used;
+	if (free < 0)
+		free = 0;
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+
+	/* Convert to input format size. For input rates > output rate this will
+	 * return less free space than actually is available, but we don't care. */
+	free /= (out_format.rate / (in_format.rate + 1)) + 1;
+	if (in_format.is_8bit)
+		free /= 2;
+	if (in_format.nch == 1)
+		free /= 2;
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] buffer_free: %d\n", free));
+#endif
+	return free;
+}
+
+gint
+xfade_buffer_playing()
+{
+	/*  always return FALSE here (if not in pause) so XMMS immediatelly
+	 *  starts playback of the next song */
+
+	/*
+	 *  NOTE: this causes trouble when playing HTTP audio streams.
+	 *
+	 *  mpg123.lib will start prebuffering (and thus stalling output) when both
+	 *  1) it's internal buffer is emptied (does happen all the time)
+	 *  2) the output plugin's buffer_playing() (this function) returns FALSE
+	 */
+
+	if (paused)
+		playing = TRUE;
+	else
+		playing =
+			(is_http && (buffer->used > 0) && the_op->buffer_playing())
+			|| (buffer->reopen >= 0)
+			|| (buffer->silence > 0)
+			|| (buffer->silence_len > 0);
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] buffer_playing: %d\n", playing));
+#endif
+	return playing;
+}
+
+gint
+xfade_written_time()
+{
+	if (!output_opened)
+		return 0;
+	return (gint) (streampos * 1000 / in_format.bps);
+}
+
+gint
+xfade_output_time()
+{
+	gint time;
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] output_time:\n"));
+#endif
+
+	/* sanity check (note: this one _does_ happen all the time) */
+	if (!output_opened)
+		return 0;
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+
+	time = the_op->output_time() - output_offset;
+	if (time < 0)
+		time = 0;
+
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+
+#ifdef DEBUG_HARDCORE
+	DEBUG(("[crossfade] output_time: time=%d\n", time));
+#endif
+	return time;
+}
+
+void
+xfade_cleanup()
+{
+	DEBUG(("[crossfade] cleanup:\n"));
+
+	/* lock buffer */
+	MUTEX_LOCK(&buffer_mutex);
+	
+	/* check if buffer thread is still running */
+	if (output_opened)
+	{
+		DEBUG(("[crossfade] cleanup: closing output\n"));
+		
+		stopped = TRUE;
+		
+		/* wait for buffer thread to clean up and terminate */
+		MUTEX_UNLOCK(&buffer_mutex);
+		if (THREAD_JOIN(buffer_thread))
+			PERROR("[crossfade] close: thread_join()");
+		MUTEX_LOCK(&buffer_mutex);
+	}
+	
+	/* unlock buffer */
+	MUTEX_UNLOCK(&buffer_mutex);
+		
+	DEBUG(("[crossfade] cleanup: done\n"));
+}