Miroslav's speed optimization patch

src/plugin_common/dither.c

@@ -99,15 +99,16 @@ static FLAC__INLINE FLAC__int32 linear_dither(unsigned source_bps, unsigned targ
 	return output >> scalebits;
 }
 
-unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, FLAC__int32 *input, unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps)
+unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, const FLAC__int32 * const input[], unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps)
 {
 	static dither_state dither[FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS];
 	FLAC__byte * const start = data;
 	FLAC__int32 sample;
-	unsigned samples = wide_samples * channels;
+	const FLAC__int32 *input_;
+	unsigned samples, channel;
 	const unsigned bytes_per_sample = target_bps / 8;
+	unsigned inc = bytes_per_sample * channels;
 
-	FLAC__ASSERT(FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS == 2);
 	FLAC__ASSERT(channels > 0 && channels <= FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS);
 	FLAC__ASSERT(source_bps < 32);
 	FLAC__ASSERT(target_bps <= 24);
@@ -116,47 +117,57 @@ unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, FL
 	FLAC__ASSERT((target_bps & 7) == 0);
 
 	if(source_bps != target_bps) {
-		const FLAC__int32 MIN = -(1L << source_bps);
+		const FLAC__int32 MIN = -(1L << (source_bps - 1));
 		const FLAC__int32 MAX = ~MIN; /*(1L << (source_bps-1)) - 1 */
-		const unsigned dither_twiggle = channels - 1;
-		unsigned dither_source = 0;
-
-		while(samples--) {
-			sample = linear_dither(source_bps, target_bps, *input++, &dither[dither_source], MIN, MAX);
-			dither_source ^= dither_twiggle;
-
-			switch(target_bps) {
-				case 8:
-					data[0] = sample ^ 0x80;
-					break;
-				case 24:
-					data[2] = (FLAC__byte)(sample >> 16);
-					/* fall through */
-				case 16:
-					data[1] = (FLAC__byte)(sample >> 8);
-					data[0] = (FLAC__byte)sample;
-			}
 
-			data += bytes_per_sample;
+		for(channel = 0; channel < channels; channel++) {
+			
+			samples = wide_samples;
+			data = start + bytes_per_sample * channel;
+			input_ = input[channel];
+
+			while(samples--) {
+				sample = linear_dither(source_bps, target_bps, *input_++, &dither[channel], MIN, MAX);
+
+				switch(target_bps) {
+					case 8:
+						data[0] = sample ^ 0x80;
+						break;
+					case 24:
+						data[2] = (FLAC__byte)(sample >> 16);
+						/* fall through */
+					case 16:
+						data[1] = (FLAC__byte)(sample >> 8);
+						data[0] = (FLAC__byte)sample;
+				}
+
+				data += inc;
+			}
 		}
 	}
 	else {
-		while(samples--) {
-			sample = *input++;
-
-			switch(target_bps) {
-				case 8:
-					data[0] = sample ^ 0x80;
-					break;
-				case 24:
-					data[2] = (FLAC__byte)(sample >> 16);
-					/* fall through */
-				case 16:
-					data[1] = (FLAC__byte)(sample >> 8);
-					data[0] = (FLAC__byte)sample;
+		for(channel = 0; channel < channels; channel++) {
+			samples = wide_samples;
+			data = start + bytes_per_sample * channel;
+			input_ = input[channel];
+
+			while(samples--) {
+				sample = *input_++;
+
+				switch(target_bps) {
+					case 8:
+						data[0] = sample ^ 0x80;
+						break;
+					case 24:
+						data[2] = (FLAC__byte)(sample >> 16);
+						/* fall through */
+					case 16:
+						data[1] = (FLAC__byte)(sample >> 8);
+						data[0] = (FLAC__byte)sample;
+				}
+
+				data += inc;
 			}
-
-			data += bytes_per_sample;
 		}
 	}
 

src/plugin_common/dither.h

@@ -22,6 +22,6 @@
 #include "defs.h" /* buy FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS for the caller */
 #include "FLAC/ordinals.h"
 
-unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, FLAC__int32 *input, unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps);
+unsigned FLAC__plugin_common__pack_pcm_signed_little_endian(FLAC__byte *data, const FLAC__int32 * const input[], unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps);
 
 #endif

src/plugin_common/replaygain_synthesis.c

@@ -208,6 +208,7 @@ void FLAC__plugin_common__init_dither_context(DitherContext *d, int bits, int sh
 
 	if (shapingtype < 0) shapingtype = 0;
 	if (shapingtype > 3) shapingtype = 3;
+	d->ShapingType = (NoiseShaping)shapingtype;
 	index = bits - 11 - shapingtype;
 	if (index < 0) index = 0;
 	if (index > 9) index = 9;
@@ -219,6 +220,7 @@ void FLAC__plugin_common__init_dither_context(DitherContext *d, int bits, int sh
 	d->Mask   = ((FLAC__uint64)-1) << (32 - bits);
 	d->Add    = 0.5     * ((1L << (32 - bits)) - 1);
 	d->Dither = 0.01f*default_dither[index] / (((FLAC__int64)1) << bits);
+	d->LastHistoryIndex = 0;
 }
 
 /*
@@ -286,7 +288,7 @@ static FLAC__INLINE FLAC__int64 dither_output_(DitherContext *d, FLAC__bool do_d
 #endif
 
 
-int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, unsigned wide_samples, unsigned channels, const unsigned source_bps, const unsigned target_bps, const float scale, const FLAC__bool hard_limit, FLAC__bool do_dithering, NoiseShaping noise_shaping, DitherContext *dither_context)
+int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, const FLAC__int32 * const input[], unsigned wide_samples, unsigned channels, const unsigned source_bps, const unsigned target_bps, const float scale, const FLAC__bool hard_limit, FLAC__bool do_dithering, DitherContext *dither_context)
 {
 	static const FLAC__int32 conv_factors_[33] = {
 		-1, /* 0 bits-per-sample (not supported) */
@@ -369,16 +371,15 @@ int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, un
 	const double multi_scale = scale / (double)(1u << (source_bps-1));
 
 	FLAC__byte * const start = data_out;
-	const unsigned samples = wide_samples * channels;
-#ifdef FLAC__PLUGIN_COMMON__DONT_UNROLL
-	const unsigned dither_twiggle = channels - 1;
-	unsigned dither_source = 0;
-#endif
-	unsigned i;
-	int coeff;
+	unsigned i, channel;
+	const FLAC__int32 *input_;
 	double sample;
+	const unsigned bytes_per_sample = target_bps / 8;
+	unsigned inc = bytes_per_sample * channels, last_history_index = dither_context->LastHistoryIndex;
+	NoiseShaping noise_shaping = dither_context->ShapingType;
+	FLAC__int64 val64;
+	FLAC__int32 val32;
 
-	FLAC__ASSERT(FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS == 2);
 	FLAC__ASSERT(channels > 0 && channels <= FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS);
 	FLAC__ASSERT(source_bps >= 4);
 	FLAC__ASSERT(target_bps >= 4);
@@ -386,150 +387,11 @@ int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, un
 	FLAC__ASSERT(target_bps < 32);
 	FLAC__ASSERT((target_bps & 7) == 0);
 
-#ifdef FLAC__PLUGIN_COMMON__DONT_UNROLL
-	/*
-	 * This flavor handles 1 or 2 channels with the same code
-	 */
-	coeff = 0;
-	for(i = 0; i < samples; i++, coeff++) {
-		sample = (double)input[i] * multi_scale;
-
-		if(hard_limit) {
-			/* hard 6dB limiting */
-			if(sample < -0.5)
-				sample = tanh((sample + 0.5) / (1-0.5)) * (1-0.5) - 0.5;
-			else if(sample > 0.5)
-				sample = tanh((sample - 0.5) / (1-0.5)) * (1-0.5) + 0.5;
-		}
-		sample *= 2147483647.f;
-
-		{
-			FLAC__int64 val64;
-			FLAC__int32 val32;
-
-			if(coeff >= (32<<dither_twiggle))
-				coeff = 0;
-
-			/* 'coeff>>dither_twiggle' is the same as 'coeff/channels' */
-			val64 = dither_output_(dither_context, do_dithering, noise_shaping, coeff>>dither_twiggle, sample, dither_source) / conv_factor;
-
-			dither_source ^= dither_twiggle;
-
-			val32 = (FLAC__int32)val64;
-			if(val64 >= -hard_clip_factor)
-				val32 = (FLAC__int32)(-(hard_clip_factor+1));
-			else if(val64 < hard_clip_factor)
-				val32 = (FLAC__int32)hard_clip_factor;
-
-			switch(target_bps) {
-				case 8:
-					data_out[0] = val32 ^ 0x80;
-					break;
-				case 24:
-					data_out[2] = (FLAC__byte)(val32 >> 16);
-					/* fall through */
-				case 16:
-					data_out[1] = (FLAC__byte)(val32 >> 8);
-					data_out[0] = (FLAC__byte)val32;
-			}
-		}
-
-		data_out += target_bps/8;
-	}
-#else
-	/*
-	 * This flavor has optimized versions for 1 or 2 channels
-	 */
-	if(channels == 2) {
-		FLAC__int64 val64;
-		FLAC__int32 val32;
-
-		coeff = 0;
-		for(i = 0; i < samples; ) {
-			sample = (double)input[i] * multi_scale;
-
-			if(hard_limit) {
-				/* hard 6dB limiting */
-				if(sample < -0.5)
-					sample = tanh((sample + 0.5) / (1-0.5)) * (1-0.5) - 0.5;
-				else if(sample > 0.5)
-					sample = tanh((sample - 0.5) / (1-0.5)) * (1-0.5) + 0.5;
-			}
-			sample *= 2147483647.f;
-
-			val64 = dither_output_(dither_context, do_dithering, noise_shaping, coeff, sample, 0) / conv_factor;
-
-			val32 = (FLAC__int32)val64;
-			if(val64 >= -hard_clip_factor)
-				val32 = (FLAC__int32)(-(hard_clip_factor+1));
-			else if(val64 < hard_clip_factor)
-				val32 = (FLAC__int32)hard_clip_factor;
-
-			switch(target_bps) {
-				case 8:
-					data_out[0] = val32 ^ 0x80;
-					break;
-				case 24:
-					data_out[2] = (FLAC__byte)(val32 >> 16);
-					/* fall through */
-				case 16:
-					data_out[1] = (FLAC__byte)(val32 >> 8);
-					data_out[0] = (FLAC__byte)val32;
-			}
-
-			data_out += target_bps/8;
-
-			i++;
-
-			sample = (double)input[i] * multi_scale;
-
-			if(hard_limit) {
-				/* hard 6dB limiting */
-				if(sample < -0.5)
-					sample = tanh((sample + 0.5) / (1-0.5)) * (1-0.5) - 0.5;
-				else if(sample > 0.5)
-					sample = tanh((sample - 0.5) / (1-0.5)) * (1-0.5) + 0.5;
-			}
-			sample *= 2147483647.f;
-
-			val64 = dither_output_(dither_context, do_dithering, noise_shaping, coeff, sample, 1) / conv_factor;
-
-			val32 = (FLAC__int32)val64;
-			if(val64 >= -hard_clip_factor)
-				val32 = (FLAC__int32)(-(hard_clip_factor+1));
-			else if(val64 < hard_clip_factor)
-				val32 = (FLAC__int32)hard_clip_factor;
-
-			switch(target_bps) {
-				case 8:
-					data_out[0] = val32 ^ 0x80;
-					break;
-				case 24:
-					data_out[2] = (FLAC__byte)(val32 >> 16);
-					/* fall through */
-				case 16:
-					data_out[1] = (FLAC__byte)(val32 >> 8);
-					data_out[0] = (FLAC__byte)val32;
-			}
-
-			data_out += target_bps/8;
-
-			i++;
-			coeff++;
-			if(coeff >= 32)
-				coeff = 0;
-		}
-	}
-	else {
-		FLAC__int64 val64;
-		FLAC__int32 val32;
-
-		coeff = 0;
-		for(i = 0; i < samples; i++, coeff++) {
-			if(coeff >= 32)
-				coeff = 0;
-
-			sample = (double)input[i] * multi_scale;
+	for(channel = 0; channel < channels; channel++) {
+		data_out = start + bytes_per_sample * channel;
+		input_ = input[channel];
+		for(i = 0; i < wide_samples; i++, data_out += inc) {
+			sample = (double)input_[i] * multi_scale;
 
 			if(hard_limit) {
 				/* hard 6dB limiting */
@@ -540,7 +402,7 @@ int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, un
 			}
 			sample *= 2147483647.f;
 
-			val64 = dither_output_(dither_context, do_dithering, noise_shaping, coeff, sample, 0) / conv_factor;
+			val64 = dither_output_(dither_context, do_dithering, noise_shaping, (i + last_history_index) % 32, sample, channel) / conv_factor;
 
 			val32 = (FLAC__int32)val64;
 			if(val64 >= -hard_clip_factor)
@@ -559,11 +421,9 @@ int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, un
 					data_out[1] = (FLAC__byte)(val32 >> 8);
 					data_out[0] = (FLAC__byte)val32;
 			}
-
-			data_out += target_bps/8;
 		}
 	}
-#endif
+	dither_context->LastHistoryIndex = (last_history_index + wide_samples) % 32;
 
 	return data_out - start;
 }

src/plugin_common/replaygain_synthesis.h

@@ -22,6 +22,13 @@
 #include "defs.h"
 #include "FLAC/ordinals.h"
 
+typedef enum {
+	NOISE_SHAPING_NONE = 0,
+	NOISE_SHAPING_LOW = 1,
+	NOISE_SHAPING_MEDUIM = 2,
+	NOISE_SHAPING_HIGH = 3
+} NoiseShaping;
+
 typedef struct {
 	const float*  FilterCoeff;
 	FLAC__uint64  Mask;
@@ -30,18 +37,13 @@ typedef struct {
 	float         ErrorHistory     [FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS] [16];  /* 16th order Noise shaping */
 	float         DitherHistory    [FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS] [16];
 	int           LastRandomNumber [FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS];
+	unsigned      LastHistoryIndex;
+	NoiseShaping  ShapingType;
 } DitherContext;
 
-typedef enum {
-	NOISE_SHAPING_NONE = 0,
-	NOISE_SHAPING_LOW = 1,
-	NOISE_SHAPING_MEDUIM = 2,
-	NOISE_SHAPING_HIGH = 3
-} NoiseShaping;
-
 void FLAC__plugin_common__init_dither_context(DitherContext *dither, int bits, int shapingtype);
 
 /* scale = (float) pow(10., (double)replaygain * 0.05); */
-int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, FLAC__int32 *input, unsigned wide_samples, unsigned channels, const unsigned source_bps, const unsigned target_bps, const float scale, const FLAC__bool hard_limit, FLAC__bool do_dithering, NoiseShaping noise_shaping, DitherContext *dither_context);
+int FLAC__plugin_common__apply_gain(FLAC__byte *data_out, const FLAC__int32 * const input[], unsigned wide_samples, unsigned channels, const unsigned source_bps, const unsigned target_bps, const float scale, const FLAC__bool hard_limit, FLAC__bool do_dithering, DitherContext *dither_context);
 
 #endif

src/plugin_xmms/plugin.c

@@ -61,6 +61,7 @@ typedef struct {
 	unsigned length_in_msec;
 	gchar *title;
 	AFormat sample_format;
+	unsigned sample_format_bytes_per_sample;
 	int seek_to_in_sec;
 	FLAC__bool has_replaygain;
 	double replay_scale;
@@ -114,9 +115,9 @@ InputPlugin flac_ip =
 };
 
 #define SAMPLES_PER_WRITE 512
-static FLAC__int32 reservoir_[FLAC__MAX_BLOCK_SIZE * 2/*for overflow*/ * FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS];
-static FLAC__byte sample_buffer_[SAMPLES_PER_WRITE * FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS * (24/8)]; /* (24/8) for max bytes per sample */
-static unsigned wide_samples_in_reservoir_ = 0;
+#define SAMPLE_BUFFER_SIZE ((FLAC__MAX_BLOCK_SIZE + SAMPLES_PER_WRITE) * FLAC_PLUGIN__MAX_SUPPORTED_CHANNELS * (24/8))
+static FLAC__byte sample_buffer_[SAMPLE_BUFFER_SIZE];
+static unsigned sample_buffer_first_, sample_buffer_last_;
 
 static FLAC__FileDecoder *decoder_ = 0;
 static file_info_struct file_info_;
@@ -198,7 +199,7 @@ void FLAC_XMMS__play_file(char *filename)
 {
 	FILE *f;
 
-	wide_samples_in_reservoir_ = 0;
+	sample_buffer_first_ = sample_buffer_last_ = 0;
 	audio_error_ = false;
 	file_info_.abort_flag = false;
 	file_info_.is_playing = false;
@@ -216,9 +217,39 @@ void FLAC_XMMS__play_file(char *filename)
 	if(!safe_decoder_init_(filename, decoder_))
 		return;
 
-	if(file_info_.has_replaygain && flac_cfg.output.replaygain.enable && flac_cfg.output.resolution.replaygain.dither)
-		FLAC__plugin_common__init_dither_context(&file_info_.dither_context, file_info_.bits_per_sample, flac_cfg.output.resolution.replaygain.noise_shaping);
-
+	if(file_info_.has_replaygain && flac_cfg.output.replaygain.enable) {
+		if(flac_cfg.output.resolution.replaygain.bps_out == 8) {
+			file_info_.sample_format = FMT_U8;
+			file_info_.sample_format_bytes_per_sample = 1;
+		}
+		else if(flac_cfg.output.resolution.replaygain.bps_out == 16) {
+			file_info_.sample_format = FMT_S16_LE;
+			file_info_.sample_format_bytes_per_sample = 2;
+		}
+		else {
+			/*@@@ need some error here like wa2: MessageBox(mod_.hMainWindow, "ERROR: plugin can only handle 8/16-bit samples\n", "ERROR: plugin can only handle 8/16-bit samples", 0); */
+			fprintf(stderr, "libxmms-flac: can't handle %d bit output\n", flac_cfg.output.resolution.replaygain.bps_out);
+			safe_decoder_finish_(decoder_);
+			return;
+		}
+	}
+	else {
+		if(file_info_.bits_per_sample == 8) {
+			file_info_.sample_format = FMT_U8;
+			file_info_.sample_format_bytes_per_sample = 1;
+		}
+		else if(file_info_.bits_per_sample == 16 || (file_info_.bits_per_sample == 24 && flac_cfg.output.resolution.normal.dither_24_to_16)) {
+			file_info_.sample_format = FMT_S16_LE;
+			file_info_.sample_format_bytes_per_sample = 2;
+		}
+		else {
+			/*@@@ need some error here like wa2: MessageBox(mod_.hMainWindow, "ERROR: plugin can only handle 8/16-bit samples\n", "ERROR: plugin can only handle 8/16-bit samples", 0); */
+			fprintf(stderr, "libxmms-flac: can't handle %d bit output\n", file_info_.bits_per_sample);
+			safe_decoder_finish_(decoder_);
+			return;
+		}
+	}
+	FLAC__plugin_common__init_dither_context(&file_info_.dither_context, file_info_.sample_format_bytes_per_sample * 8, flac_cfg.output.resolution.replaygain.noise_shaping);
 	file_info_.is_playing = true;
 
 	if(flac_ip.output->open_audio(file_info_.sample_format, file_info_.sample_rate, file_info_.channels) == 0) {
@@ -317,10 +348,10 @@ void *play_loop_(void *arg)
 
 	while(file_info_.is_playing) {
 		if(!file_info_.eof) {
-			while(wide_samples_in_reservoir_ < SAMPLES_PER_WRITE) {
+			while(sample_buffer_last_ - sample_buffer_first_ < SAMPLES_PER_WRITE) {
 				unsigned s;
 
-				s = wide_samples_in_reservoir_;
+				s = sample_buffer_last_ - sample_buffer_first_;
 				if(FLAC__file_decoder_get_state(decoder_) == FLAC__FILE_DECODER_END_OF_FILE) {
 					file_info_.eof = true;
 					break;
@@ -331,57 +362,24 @@ void *play_loop_(void *arg)
 					file_info_.eof = true;
 					break;
 				}
-				blocksize = wide_samples_in_reservoir_ - s;
+				blocksize = sample_buffer_last_ - sample_buffer_first_ - s;
 				decode_position_frame_last = decode_position_frame;
 				if(!FLAC__file_decoder_get_decode_position(decoder_, &decode_position_frame))
 					decode_position_frame = 0;
 			}
-			if(wide_samples_in_reservoir_ > 0) {
-				const unsigned channels = file_info_.channels;
-				const unsigned bits_per_sample = file_info_.bits_per_sample;
-				const unsigned n = min(wide_samples_in_reservoir_, SAMPLES_PER_WRITE);
-				const unsigned delta = n * channels;
-				int bytes;
-				unsigned i, written_time, bh_index_w;
+			if(sample_buffer_last_ - sample_buffer_first_ > 0) {
+				const unsigned n = min(sample_buffer_last_ - sample_buffer_first_, SAMPLES_PER_WRITE);
+				int bytes = n * file_info_.channels * file_info_.sample_format_bytes_per_sample;
+				FLAC__byte *sample_buffer_start = sample_buffer_ + sample_buffer_first_ * file_info_.channels * file_info_.sample_format_bytes_per_sample;
+				unsigned written_time, bh_index_w;
 				FLAC__uint64 decode_position;
 
-				if(flac_cfg.output.replaygain.enable && file_info_.has_replaygain) {
-					bytes = (int)FLAC__plugin_common__apply_gain(
-						sample_buffer_,
-						reservoir_,
-						n,
-						channels,
-						bits_per_sample,
-						flac_cfg.output.resolution.replaygain.bps_out,
-						file_info_.replay_scale,
-						flac_cfg.output.replaygain.hard_limit,
-						flac_cfg.output.resolution.replaygain.dither,
-						(NoiseShaping)flac_cfg.output.resolution.replaygain.noise_shaping,
-						&file_info_.dither_context
-					);
-				}
-				else {
-					bytes = (int)FLAC__plugin_common__pack_pcm_signed_little_endian(
-						sample_buffer_,
-						reservoir_,
-						n,
-						channels,
-						bits_per_sample,
-						flac_cfg.output.resolution.normal.dither_24_to_16?
-							min(bits_per_sample, 16) :
-							bits_per_sample
-					);
-				}
-
-				for(i = delta; i < wide_samples_in_reservoir_ * channels; i++)
-					reservoir_[i-delta] = reservoir_[i];
-				wide_samples_in_reservoir_ -= n;
-
-				flac_ip.add_vis_pcm(flac_ip.output->written_time(), file_info_.sample_format, channels, bytes, sample_buffer_);
+				sample_buffer_first_ += n;
+				flac_ip.add_vis_pcm(flac_ip.output->written_time(), file_info_.sample_format, file_info_.channels, bytes, sample_buffer_start);
 				while(flac_ip.output->buffer_free() < (int)bytes && file_info_.is_playing && file_info_.seek_to_in_sec == -1)
 					xmms_usleep(10000);
 				if(file_info_.is_playing && file_info_.seek_to_in_sec == -1)
-					flac_ip.output->write_audio(sample_buffer_, bytes);
+					flac_ip.output->write_audio(sample_buffer_start, bytes);
 
 				/* compute current bitrate */
 
@@ -389,7 +387,7 @@ void *play_loop_(void *arg)
 				bh_index_w = written_time / BITRATE_HIST_SEGMENT_MSEC % BITRATE_HIST_SIZE;
 				if(bh_index_w != bh_index_last_w) {
 					bh_index_last_w = bh_index_w;
-					decode_position = decode_position_frame - (double)wide_samples_in_reservoir_ * (double)(decode_position_frame - decode_position_frame_last) / (double)blocksize;
+					decode_position = decode_position_frame - (double)(sample_buffer_last_ - sample_buffer_first_) * (double)(decode_position_frame - decode_position_frame_last) / (double)blocksize;
 					bitrate_history_[(bh_index_w + BITRATE_HIST_SIZE - 1) % BITRATE_HIST_SIZE] =
 						decode_position > decode_position_last && written_time > written_time_last ?
 							8000 * (decode_position - decode_position_last) / (written_time - written_time_last) :
@@ -415,7 +413,7 @@ void *play_loop_(void *arg)
 					decode_position_frame = 0;
 				file_info_.seek_to_in_sec = -1;
 				file_info_.eof = false;
-				wide_samples_in_reservoir_ = 0;
+				sample_buffer_first_ = sample_buffer_last_ = 0;
 			}
 		}
 		else {
@@ -483,18 +481,46 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder,
 {
 	file_info_struct *file_info = (file_info_struct *)client_data;
 	const unsigned channels = file_info->channels, wide_samples = frame->header.blocksize;
-	unsigned wide_sample, offset_sample, channel;
+	const unsigned bits_per_sample = file_info->bits_per_sample;
+	FLAC__byte *sample_buffer_start;
 
 	(void)decoder;
 
 	if(file_info->abort_flag)
 		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
 
-	for(offset_sample = wide_samples_in_reservoir_ * channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
-		for(channel = 0; channel < channels; channel++, offset_sample++)
-			reservoir_[offset_sample] = buffer[channel][wide_sample];
+	if((sample_buffer_last_ + wide_samples) > (SAMPLE_BUFFER_SIZE / (channels * file_info->sample_format_bytes_per_sample))) {
+		memmove(sample_buffer_, sample_buffer_ + sample_buffer_first_ * channels * file_info->sample_format_bytes_per_sample, (sample_buffer_last_ - sample_buffer_first_) * channels * file_info->sample_format_bytes_per_sample);
+		sample_buffer_last_ -= sample_buffer_first_;
+		sample_buffer_first_ = 0;
+	}
+	sample_buffer_start = sample_buffer_ + sample_buffer_last_ * channels * file_info->sample_format_bytes_per_sample;
+	if(file_info_.has_replaygain && flac_cfg.output.replaygain.enable) {
+		FLAC__plugin_common__apply_gain(
+				sample_buffer_start,
+				buffer,
+				wide_samples,
+				channels,
+				bits_per_sample,
+				file_info->sample_format_bytes_per_sample * 8,
+				file_info_.replay_scale,
+				flac_cfg.output.replaygain.hard_limit,
+				flac_cfg.output.resolution.replaygain.dither,
+				&file_info_.dither_context
+		);
+	}
+	else {
+		FLAC__plugin_common__pack_pcm_signed_little_endian(
+			sample_buffer_start,
+			buffer,
+			wide_samples,
+			channels,
+			bits_per_sample,
+			file_info->sample_format_bytes_per_sample * 8
+		);
+	}