SCI: Get rid around the first layer around the ScummVM audio mixer. Also resolve the FIXME about releasing the mixer channel we allocated

svn-id: r38949

1 files changed, 0 insertions, 926 deletions

diff --git a/engines/sci/sfx/mixer/soft.cpp b/engines/sci/sfx/mixer/soft.cpp
deleted file mode 100644
index 53e4d94399..0000000000
--- a/engines/sci/sfx/mixer/soft.cpp
+++ /dev/null
@@ -1,926 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/mutex.h"
-#include "common/system.h"
-
-#include "sci/tools.h"
-#include "sci/sfx/mixer.h"
-#include "sci/sci_memory.h"
-
-namespace Sci {
-
-/* Max. number of milliseconds in difference allowed between independent audio streams */
-#define TIMESTAMP_MAX_ALLOWED_DELTA 2
-
-/*#define DEBUG 3*/
-/* Set DEBUG to one of the following:
-** anything -- high-level debugging (feed subscriptions/deletions etc.)
-**     >= 1 -- rough input and output analysis (once per call)
-**     >= 2 -- more detailed input analysis (once per call and feed)
-**     >= 3 -- fully detailed input and output analysis (once per frame and feed)
-*/
-
-//#define DEBUG 1
-
-#define MIN_DELTA_OBSERVATIONS 100 /* Number of times the mixer is called before it starts trying to improve latency */
-#define MAX_DELTA_OBSERVATIONS 1000000 /* Number of times the mixer is called before we assume we truly understand timing */
-
-static int diagnosed_too_slow = 0;
-
-#define ACQUIRE_LOCK() P->_mixerLock.lock()
-#define RELEASE_LOCK() P->_mixerLock.unlock()
-
-struct mixer_private {
-	Common::Mutex _mixerLock;
-	byte *outbuf; /* Output buffer to write to the PCM device next time */
-	sfx_timestamp_t outbuf_timestamp; /* Timestamp associated with the output buffer */
-	int have_outbuf_timestamp; /* Whether we really _have_ an associated timestamp */
-	byte *writebuf; /* Buffer we're supposed to write to */
-	int32 *compbuf_l, *compbuf_r; /* Intermediate buffers for computation */
-	int lastbuf_len; /* Number of frames stored in the last buffer */
-
-	uint32 skew; /* Millisecond relative to which we compute time. This is the millisecond
-		   ** part of the first time we emitted sound, to simplify some computations.  */
-	uint32 lsec; /* Last point in time we updated buffers, if any (seconds since the epoch) */
-	int played_this_second; /* Number of frames emitted so far in second lsec */
-
-	int max_delta; /* maximum observed time delta (using 'frames' as a metric unit) */
-	int delta_observations; /* Number of times we played; confidence measure for max_delta */
-
-	/* Pause data */
-	int paused;
-};
-
-#define P ((struct mixer_private *)(self->private_bits))
-
-
-static int mix_init(sfx_pcm_mixer_t *self, sfx_pcm_device_t *device) {
-	self->dev = device;
-	self->private_bits = new mixer_private();
-	P->outbuf = P->writebuf = NULL;
-	P->lastbuf_len = 0;
-	P->compbuf_l = (int32*)sci_malloc(sizeof(int32) * device->buf_size);
-	P->compbuf_r = (int32*)sci_malloc(sizeof(int32) * device->buf_size);
-	P->played_this_second = 0;
-	P->paused = 0;
-
-	return SFX_OK;
-}
-
-static inline uint gcd(uint a, uint b) {
-	while (a) {
-		uint c = b % a;
-		b = a;
-		a = c;
-	}
-	return b;
-}
-
-static sfx_pcm_urat_t urat(unsigned int nom, unsigned int denom) {
-	sfx_pcm_urat_t rv;
-	unsigned int g;
-
-	rv.val = nom / denom;
-	nom -= rv.val * denom;
-	if (nom == 0)
-		g = 1;
-	else
-		g = gcd(nom, denom);
-
-	rv.nom = nom / g;
-	rv.den = denom / g;
-
-	return rv;
-}
-
-static void mix_subscribe(sfx_pcm_mixer_t *self, sfx_pcm_feed_t *feed) {
-	sfx_pcm_feed_state_t *fs;
-	ACQUIRE_LOCK();
-	if (!self->feeds) {
-		self->feeds_allocd = 2;
-		self->feeds = (sfx_pcm_feed_state_t*)sci_malloc(sizeof(sfx_pcm_feed_state_t)
-		              * self->feeds_allocd);
-	} else if (self->feeds_allocd == self->feeds_nr) {
-		self->feeds_allocd += 2;
-		self->feeds = (sfx_pcm_feed_state_t*)sci_realloc(self->feeds,
-		              sizeof(sfx_pcm_feed_state_t)
-		              * self->feeds_allocd);
-	}
-
-	fs = self->feeds + self->feeds_nr++;
-	fs->feed = feed;
-
-	feed->frame_size = SFX_PCM_FRAME_SIZE(feed->conf);
-
-	/*	fs->buf_size = (self->dev->buf_size
-			  * (feed->conf.rate
-			     + self->dev->conf.rate - 1))
-		/ self->dev->conf.rate;
-	*/
-	/* For the sake of people without 64 bit CPUs: */
-	fs->buf_size = 2 + /* Additional safety */
-	               (self->dev->buf_size *
-	                (1 + (feed->conf.rate / self->dev->conf.rate)));
-	fprintf(stderr, " ---> %d/%d/%d/%d = %d\n",
-	        self->dev->buf_size,
-	        feed->conf.rate,
-	        self->dev->conf.rate,
-	        feed->frame_size,
-	        fs->buf_size);
-
-	fs->buf = (byte*)sci_malloc(fs->buf_size * feed->frame_size);
-	fprintf(stderr, " ---> --> %d for %p at %p\n", fs->buf_size * feed->frame_size, (void *)fs, (void *)fs->buf);
-	{
-		int i;
-		for (i = 0; i < fs->buf_size * feed->frame_size; i++)
-			fs->buf[i] = 0xa5;
-	}
-	fs->scount = urat(0, 1);
-	fs->spd = urat(feed->conf.rate, self->dev->conf.rate);
-	fs->scount.den = fs->spd.den;
-	fs->ch_old.left = 0;
-	fs->ch_old.right = 0;
-	fs->ch_new.left = 0;
-	fs->ch_new.right = 0;
-	fs->mode = SFX_PCM_FEED_MODE_ALIVE;
-
-	/* If the feed can't provide us with timestamps, we don't need to wait for it to do so */
-	fs->pending_review = (feed->get_timestamp) ? 1 : 0;
-
-	fs->frame_bufstart = 0;
-
-#ifdef DEBUG
-	sciprintf("[soft-mixer] Subscribed %s-%x (%d Hz, %d/%x) at %d+%d/%d, buffer size %d\n",
-	          feed->debug_name, feed->debug_nr, feed->conf.rate, feed->conf.stereo, feed->conf.format,
-	          fs->spd.val, fs->spd.nom, fs->spd.den, fs->buf_size);
-#endif
-	RELEASE_LOCK();
-}
-
-
-static void _mix_unsubscribe(sfx_pcm_mixer_t *self, sfx_pcm_feed_t *feed) {
-	int i;
-#ifdef DEBUG
-	sciprintf("[soft-mixer] Unsubscribing %s-%x\n", feed->debug_name, feed->debug_nr);
-#endif
-	for (i = 0; i < self->feeds_nr; i++) {
-		sfx_pcm_feed_state_t *fs = self->feeds + i;
-
-		if (fs->feed == feed) {
-			feed->destroy(feed);
-
-			if (fs->buf)
-				free(fs->buf);
-
-			self->feeds_nr--;
-
-			/* Copy topmost into deleted so that we don't have any holes */
-			if (i != self->feeds_nr)
-				self->feeds[i] = self->feeds[self->feeds_nr];
-
-			if (self->feeds_allocd > 8 && self->feeds_allocd > (self->feeds_nr << 1)) {
-				/* Limit memory waste */
-				self->feeds_allocd >>= 1;
-				self->feeds
-				= (sfx_pcm_feed_state_t*)sci_realloc(self->feeds,
-				                                     sizeof(sfx_pcm_feed_state_t)
-				                                     * self->feeds_allocd);
-			}
-
-			for (i = 0; i < self->feeds_nr; i++)
-				fprintf(stderr, "  Feed #%d: %s-%x\n",
-				        i, self->feeds[i].feed->debug_name,
-				        self->feeds[i].feed->debug_nr);
-
-			return;
-		}
-	}
-
-	fprintf(stderr, "[sfx-mixer] Assertion failed: Deleting invalid feed %p out of %d\n",
-	        (void *)feed, self->feeds_nr);
-
-	BREAKPOINT();
-}
-
-static void mix_exit(sfx_pcm_mixer_t *self) {
-	ACQUIRE_LOCK();
-	while (self->feeds_nr)
-		_mix_unsubscribe(self, self->feeds[0].feed);
-	RELEASE_LOCK();
-
-	free(P->outbuf);
-	free(P->writebuf);
-
-	free(P->compbuf_l);
-	free(P->compbuf_r);
-
-	delete P;
-	self->private_bits = NULL;
-
-#ifdef DEBUG
-	sciprintf("[soft-mixer] Uninitialising mixer\n");
-#endif
-}
-
-
-#define LIMIT_16_BITS(v)			\
-		if (v < -32767)			\
-			v = -32768;		\
-		else if (v > 32766)		\
-			v = 32767
-
-static inline void mix_compute_output(sfx_pcm_mixer_t *self, int outplen) {
-	int frame_i;
-	sfx_pcm_config_t conf = self->dev->conf;
-	int use_16 = conf.format & SFX_PCM_FORMAT_16;
-	int bias = conf.format & ~SFX_PCM_FORMAT_LMASK;
-	byte *lchan, *rchan = NULL;
-	/* Don't see how this could possibly wind up being
-	** used w/o initialisation, but you never know... */
-	int32 *lsrc = P->compbuf_l;
-	int32 *rsrc = P->compbuf_r;
-	int frame_size = SFX_PCM_FRAME_SIZE(conf);
-
-
-	if (!P->writebuf)
-		P->writebuf = (byte*)sci_malloc(self->dev->buf_size * frame_size + 4);
-
-	if (conf.stereo) {
-		if (conf.stereo == SFX_PCM_STEREO_RL) {
-			lchan = P->writebuf + ((use_16) ? 2 : 1);
-			rchan = P->writebuf;
-		} else {
-			lchan = P->writebuf;
-			rchan = P->writebuf + ((use_16) ? 2 : 1);
-		}
-	} else
-		lchan = P->writebuf;
-
-
-	for (frame_i = 0; frame_i < outplen; frame_i++) {
-		int left = *lsrc++;
-		int right = *rsrc++;
-
-		if (conf.stereo) {
-			LIMIT_16_BITS(left);
-			LIMIT_16_BITS(right);
-
-			if (!use_16) {
-				left >>= 8;
-				right >>= 8;
-			}
-
-			left += bias;
-			right += bias;
-
-			if (use_16) {
-				if (SFX_PCM_FORMAT_LE == (conf.format & SFX_PCM_FORMAT_ENDIANNESS)) {
-					lchan[0] = left & 0xff;
-					lchan[1] = (left >> 8) & 0xff;
-					rchan[0] = right & 0xff;
-					rchan[1] = (right >> 8) & 0xff;
-				} else {
-					lchan[1] = left & 0xff;
-					lchan[0] = (left >> 8) & 0xff;
-					rchan[1] = right & 0xff;
-					rchan[0] = (right >> 8) & 0xff;
-				}
-
-				lchan += 4;
-				rchan += 4;
-			} else {
-				*lchan = left & 0xff;
-				*rchan = right & 0xff;
-
-				lchan += 2;
-				rchan += 2;
-			}
-
-		} else {
-			left += right;
-			left >>= 1;
-			LIMIT_16_BITS(left);
-			if (!use_16)
-				left >>= 8;
-
-			left += bias;
-
-			if (use_16) {
-				if (SFX_PCM_FORMAT_LE == (conf.format & SFX_PCM_FORMAT_ENDIANNESS)) {
-					lchan[0] = left & 0xff;
-					lchan[1] = (left >> 8) & 0xff;
-				} else {
-					lchan[1] = left & 0xff;
-					lchan[0] = (left >> 8) & 0xff;
-				}
-
-				lchan += 2;
-			} else {
-				*lchan = left & 0xff;
-				lchan += 1;
-			}
-		}
-	}
-}
-
-static inline void mix_swap_buffers(sfx_pcm_mixer_t *self) { /* Swap buffers */
-	byte *tmp = P->outbuf;
-	P->outbuf = P->writebuf;
-	P->writebuf = tmp;
-}
-
-static inline int mix_compute_buf_len(sfx_pcm_mixer_t *self, int *skip_frames) {
-/* Computes the number of frames we ought to write. It tries to minimise the number,
-** in order to reduce latency. */
-/* It sets 'skip_frames' to the number of frames to assume lost by latency, effectively
-** skipping them.  */
-	int free_frames;
-	int played_frames = 0; /* since the last call */
-	uint32 msecs;
-	int frame_pos;
-	int result_frames;
-
-	msecs = g_system->getMillis();
-
-	if (!P->outbuf) {
-		/* Called for the first time ever? */
-		P->skew = msecs % 1000;
-		P->lsec = msecs / 1000;
-		P->max_delta = 0;
-		P->delta_observations = 0;
-		P->played_this_second = 0;
-		*skip_frames = 0;
-
-		return self->dev->buf_size;
-	}
-
-	/*	fprintf(stderr, "[%d:%d]S%d ", secs, usecs, P->skew);*/
-
-	msecs -= P->skew;
-
-	frame_pos = (msecs % 1000) * self->dev->conf.rate / 1000;
-
-	played_frames = frame_pos - P->played_this_second
-	                + ((msecs / 1000 - P->lsec) * self->dev->conf.rate);
-	/*
-	fprintf(stderr, "%d:%d - %d:%d  => %d\n", secs, frame_pos,
-		P->lsec, P->played_this_second, played_frames);
-	*/
-
-	if (played_frames > self->dev->buf_size)
-		played_frames = self->dev->buf_size;
-
-	/*
-	fprintf(stderr, "Between %d:? offset=%d and %d:%d offset=%d: Played %d at %d\n", P->lsec, P->played_this_second,
-	secs, usecs, frame_pos, played_frames, self->dev->conf.rate);
-	*/
-
-
-	if (played_frames > P->max_delta)
-		P->max_delta = played_frames;
-
-	free_frames = played_frames;
-
-	if (free_frames > self->dev->buf_size) {
-		if (!diagnosed_too_slow) {
-			sciprintf("[sfx-mixer] Your timer is too slow for your PCM output device (%d/%d), free=%d.\n"
-			          "[sfx-mixer] You might want to try changing the device, timer, or mixer, if possible.\n",
-			          played_frames, self->dev->buf_size, free_frames);
-		}
-		diagnosed_too_slow = 1;
-
-		*skip_frames = free_frames - self->dev->buf_size;
-		free_frames = self->dev->buf_size;
-	} else
-		*skip_frames = 0;
-
-	++P->delta_observations;
-	if (P->delta_observations > MAX_DELTA_OBSERVATIONS)
-		P->delta_observations = MAX_DELTA_OBSERVATIONS;
-
-	/*	/\* Disabled, broken *\/ */
-	/*	if (0 && P->delta_observations > MIN_DELTA_OBSERVATIONS) { /\* Start improving after a while *\/ */
-	/*		int diff = self->dev->conf.rate - P->max_delta; */
-
-	/*		/\* log-approximate P->max_delta over time *\/ */
-	/*		recommended_frames = P->max_delta + */
-	/*			((diff * MIN_DELTA_OBSERVATIONS) / P->delta_observations); */
-	/* /\* WTF? *\/ */
-	/*	} else */
-	/*		recommended_frames = self->dev->buf_size; /\* Initially, keep the buffer full *\/ */
-
-#if (DEBUG >= 1)
-	sciprintf("[soft-mixer] played since last time: %d, free: %d\n",
-	          played_frames, free_frames);
-#endif
-
-	result_frames = free_frames;
-
-	if (result_frames < 0)
-		result_frames = 0;
-
-	P->played_this_second += result_frames;
-	while (P->played_this_second >= self->dev->conf.rate) {
-		/* Won't normally happen more than once */
-		P->played_this_second -= self->dev->conf.rate;
-		P->lsec++;
-	}
-
-	if (result_frames > self->dev->buf_size) {
-		fprintf(stderr, "[soft-mixer] Internal assertion failed: frames-to-write %d > %d\n",
-		        result_frames, self->dev->buf_size);
-	}
-	return result_frames;
-}
-
-
-
-#define READ_NEW_VALUES() \
-		if (frames_left > 0) {						\
-			if (bias) { /* unsigned data */					\
-				if (!use_16) {						\
-					c_new.left = (*lsrc) << 8;			\
-					c_new.right = (*rsrc) << 8;			\
-				} else {						\
-					if (conf.format & SFX_PCM_FORMAT_LE) {		\
-						c_new.left = lsrc[0] | lsrc[1] << 8;	\
-						c_new.right = rsrc[0] | rsrc[1] << 8;	\
-					} else {					\
-						c_new.left = lsrc[1] | lsrc[0] << 8;	\
-						c_new.right = rsrc[1] | rsrc[0] << 8;	\
-					}						\
-				}							\
-			} else { /* signed data */							\
-				if (!use_16) {								\
-					c_new.left = (*((signed char *)lsrc)) << 8;			\
-					c_new.right = (*((signed char *)rsrc)) << 8;			\
-				} else {								\
-					if (conf.format & SFX_PCM_FORMAT_LE) {				\
-						c_new.left = lsrc[0] | ((signed char *)lsrc)[1] << 8;	\
-						c_new.right = rsrc[0] | ((signed char *)rsrc)[1] << 8;	\
-					} else {							\
-						c_new.left = lsrc[1] | ((signed char *)lsrc)[0] << 8;	\
-						c_new.right = rsrc[1] | ((signed char *)rsrc)[0] << 8;	\
-					}								\
-				}									\
-			}										\
-										\
-			c_new.left -= bias;					\
-			c_new.right -= bias;					\
-										\
-			lsrc += frame_size;					\
-			rsrc += frame_size;					\
-		} else {							\
-			c_new.left = c_new.right = 0;				\
-			break;							\
-		}
-
-
-static volatile int xx_offset;
-static volatile int xx_size;
-
-static void mix_compute_input_linear(sfx_pcm_mixer_t *self, int add_result,
-									 int len, sfx_timestamp_t *ts, sfx_timestamp_t base_ts) {
-/* if add_result is non-zero, P->outbuf should be added to rather than overwritten. */
-/* base_ts is the timestamp for the first frame */
-	sfx_pcm_feed_state_t *fs = self->feeds + add_result;
-	sfx_pcm_feed_t *f = fs->feed;
-	sfx_pcm_config_t conf = f->conf;
-	int use_16 = conf.format & SFX_PCM_FORMAT_16;
-	int32 *lchan = P->compbuf_l;
-	int32 *rchan = P->compbuf_r;
-	int frame_size = f->frame_size;
-	byte *wr_dest = fs->buf + (frame_size * fs->frame_bufstart);
-	byte *lsrc = fs->buf;
-	byte *rsrc = fs->buf;
-	/* Location to write to */
-	int frames_nr;
-	int bias = (conf.format & ~SFX_PCM_FORMAT_LMASK) ? 0x8000 : 0;
-	/* We use this only on a 16 bit level here */
-
-	/* The two most extreme source frames we consider for a
-	** destination frame  */
-	struct twochannel_data c_old = fs->ch_old;
-	struct twochannel_data c_new = fs->ch_new;
-
-	int frames_read = 0;
-	int frames_left;
-	int write_offset; /* Iterator for translation */
-	int delay_frames = 0; /* Number of frames (dest buffer) at the beginning we skip */
-
-	/* First, compute the number of frames we want to retrieve */
-	frames_nr = fs->spd.val * len;
-	/* A little complicated since we must consider partial frames */
-	frames_nr += (fs->spd.nom * len
-	              + (fs->scount.den - fs->scount.nom) /* remember that we may have leftovers */
-	              + (fs->spd.den - 1 /* round up */)
-	             )
-	             / fs->spd.den;
-
-	ts->msecs = 0;
-
-	if (frames_nr > fs->buf_size) {
-		fprintf(stderr, "%d (%d*%d + somethign) bytes, but only %d allowed!!!!!\n",
-		        frames_nr * f->frame_size,
-		        fs->spd.val, len,
-		        fs->buf_size);
-		BREAKPOINT();
-	}
-
-	if (fs->pending_review) {
-		int newmode = PCM_FEED_EMPTY; /* empty unless a get_timestamp() tells otherwise */
-
-		RELEASE_LOCK();
-		/* Retrieve timestamp */
-		if (f->get_timestamp)
-			newmode = f->get_timestamp(f, ts);
-		ACQUIRE_LOCK();
-
-		fs = self->feeds + add_result;
-		/* Reset in case of status update */
-
-		switch (newmode) {
-
-		case PCM_FEED_TIMESTAMP: {
-			/* Compute the number of frames the returned timestamp is in the future: */
-			delay_frames =
-			    sfx_timestamp_frame_diff(sfx_timestamp_renormalise(*ts, base_ts.frame_rate),
-			                             base_ts);
-
-			if (delay_frames <= 0)
-				/* Start ASAP, even if it's too late */
-				delay_frames = 0;
-			else
-				if (delay_frames > len)
-					delay_frames = len;
-			fs->pending_review = 0;
-		}
-		break;
-
-		case PCM_FEED_EMPTY:
-			fs->mode = SFX_PCM_FEED_MODE_DEAD;
-
-			/* ...fall through... */
-
-		case PCM_FEED_IDLE:
-			/* Clear audio buffer, if neccessary, and return */
-			if (!add_result) {
-				memset(P->compbuf_l, 0, sizeof(int32) * len);
-				memset(P->compbuf_r, 0, sizeof(int32) * len);
-			}
-			return;
-
-		default:
-			error("[soft-mixer] Fatal: Invalid mode returned by PCM feed %s-%d's get_timestamp(): %d",
-			        f->debug_name, f->debug_nr, newmode);
-		}
-	}
-
-	RELEASE_LOCK();
-	/* Make sure we have sufficient information */
-	if (frames_nr > delay_frames + fs->frame_bufstart)
-		frames_read =
-		    f->poll(f, wr_dest,
-		            frames_nr
-		            - delay_frames
-		            - fs->frame_bufstart);
-
-	ACQUIRE_LOCK();
-	fs = self->feeds + add_result;
-
-	frames_read += fs->frame_bufstart;
-	frames_left = frames_read;
-
-	/* Reset in case of status update */
-
-	/* Skip at the beginning: */
-	if (delay_frames) {
-		if (!add_result) {
-			memset(lchan, 0, sizeof(int32) * delay_frames);
-			memset(rchan, 0, sizeof(int32) * delay_frames);
-		}
-		lchan += delay_frames;
-		rchan += delay_frames;
-
-		len -= delay_frames;
-	}
-
-
-#if (DEBUG >= 2)
-	sciprintf("[soft-mixer] Examining %s-%x (frame size %d); read %d/%d/%d, re-using %d frames\n",
-	          f->debug_name, f->debug_nr, frame_size, frames_read, frames_nr,
-	          fs->buf_size, fs->frame_bufstart);
-#endif
-
-
-	if (conf.stereo == SFX_PCM_STEREO_LR)
-		rsrc += (use_16) ? 2 : 1;
-	else if (conf.stereo == SFX_PCM_STEREO_RL)
-		lsrc += (use_16) ? 2 : 1;
-	/* Otherwise, we let both point to the same place */
-
-#if (DEBUG >= 2)
-	sciprintf("[soft-mixer] Stretching theoretical %d (physical %d) results to %d\n", frames_nr, frames_left, len);
-#endif
-	for (write_offset = 0; write_offset < len; write_offset++) {
-		int leftsum = 0; /* Sum of any complete frames we used */
-		int rightsum = 0;
-
-		int left; /* Sum of the two most extreme source frames
-			  ** we considered, i.e. the oldest and newest
-			  ** one corresponding to the output frame we are
-			  ** computing  */
-		int right;
-
-		int frame_steps = fs->spd.val;
-		int j;
-
-		if (fs->scount.nom >= fs->scount.den) {
-			fs->scount.nom -= fs->scount.den; /* Ensure fractional part < 1 */
-			++frame_steps;
-		}
-		if (frame_steps)
-			c_old = c_new;
-
-#if 0
-		if (write_offset == 0) {
-			READ_NEW_VALUES();
-			--frames_left;
-#if (DEBUG >= 3)
-			sciprintf("[soft-mixer] Initial read %d:%d\n", c_new.left, c_new.right);
-#endif
-			c_old = c_new;
-		}
-#endif
-
-		for (j = 0; j < frame_steps; j++) {
-			READ_NEW_VALUES();
-			--frames_left;
-#if (DEBUG >= 3)
-			sciprintf("[soft-mixer] Step %d/%d made %d:%d\n", j, frame_steps, c_new.left, c_new.right);
-#endif
-
-			/* The last frame will be subject to the fractional
-			** part analysis, so we add it to 'left' and 'right'
-			** later-- all others are added to (leftsum, rightsum).
-			*/
-			if (j + 1 < frame_steps) {
-				leftsum += c_new.left;
-				rightsum += c_new.right;
-			}
-		}
-
-		left = c_new.left * fs->scount.nom
-		       + c_old.left * (fs->scount.den - fs->scount.nom);
-		right = c_new.right * fs->scount.nom
-		        + c_old.right * (fs->scount.den - fs->scount.nom);
-
-		/* Normalise */
-		left  /= fs->spd.den;
-		right /= fs->spd.den;
-
-
-		leftsum += left;
-		rightsum += right;
-
-
-		/* Make sure to divide by the number of frames we added here */
-		if (frame_steps > 1) {
-			leftsum  /= (frame_steps);
-			rightsum /= (frame_steps);
-		}
-
-
-#if (DEBUG >= 3)
-		sciprintf("[soft-mixer] Ultimate result: %d:%d (frac %d:%d)\n", leftsum, rightsum, left, right);
-#endif
-
-		if (add_result) {
-			*(lchan++) += leftsum;
-			*(rchan++) += rightsum;
-		} else {
-			*(lchan++) = leftsum;
-			*(rchan++) = rightsum;
-		}
-
-		fs->scount.nom += fs->spd.nom; /* Count up fractional part */
-	}
-
-	fs->ch_old = c_old;
-	fs->ch_new = c_new;
-
-	/* If neccessary, zero out the rest */
-	if (write_offset < len && !add_result) {
-		memset(lchan, 0, sizeof(int32) * (len - write_offset));
-		memset(rchan, 0, sizeof(int32) * (len - write_offset));
-	}
-
-	/* Save whether we have a partial frame still stored */
-	fs->frame_bufstart = frames_left;
-
-	if (frames_left) {
-		xx_offset = ((frames_read - frames_left) * f->frame_size);
-		xx_size = frames_left * f->frame_size;
-		if (xx_offset + xx_size
-		        >= fs->buf_size * f->frame_size) {
-			fprintf(stderr, "offset %d >= max %d!\n",
-			        (xx_offset + xx_size), fs->buf_size * f->frame_size);
-			BREAKPOINT();
-		}
-
-		memmove(fs->buf,
-		        fs->buf + ((frames_read - frames_left) * f->frame_size),
-		        frames_left * f->frame_size);
-	}
-#if (DEBUG >= 2)
-	sciprintf("[soft-mixer] Leaving %d over\n", fs->frame_bufstart);
-#endif
-
-	if (frames_read + delay_frames < frames_nr) {
-		if (f->get_timestamp) /* Can resume? */
-			fs->pending_review = 1;
-		else
-			fs->mode = SFX_PCM_FEED_MODE_DEAD; /* Done. */
-	}
-}
-
-static int mix_process_linear(sfx_pcm_mixer_t *self) {
-	ACQUIRE_LOCK();
-	{
-		int src_i; /* source feed index counter */
-		int frames_skip; /* Number of frames to discard, rather than to emit */
-		int buflen = mix_compute_buf_len(self, &frames_skip); /* Compute # of frames we must compute and write */
-		int fake_buflen;
-		int timestamp_max_delta = 0;
-		int have_timestamp = 0;
-		sfx_timestamp_t start_timestamp; /* The timestamp at which the first frame will be played */
-		sfx_timestamp_t min_timestamp;
-		min_timestamp.msecs = 0;
-		sfx_timestamp_t timestamp;
-
-		if (self->dev->get_output_timestamp)
-			start_timestamp = self->dev->get_output_timestamp(self->dev);
-		else
-			start_timestamp = sfx_new_timestamp(g_system->getMillis(), self->dev->conf.rate);
-
-		if ((P->outbuf) && (P->lastbuf_len)) {
-			sfx_timestamp_t ts;
-			int rv;
-
-			if (P->have_outbuf_timestamp) {
-				ts = sfx_timestamp_renormalise(P->outbuf_timestamp, self->dev->conf.rate);
-			}
-
-			rv = self->dev->output(self->dev, P->outbuf,
-			                       P->lastbuf_len,
-			                       (P->have_outbuf_timestamp) ? &ts : NULL);
-
-			if (rv == SFX_ERROR) {
-				RELEASE_LOCK();
-				return rv; /* error */
-			}
-		}
-
-#if (DEBUG >= 1)
-		if (self->feeds_nr)
-			sciprintf("[soft-mixer] Mixing %d output frames on %d input feeds\n", buflen, self->feeds_nr);
-#endif
-		if (self->feeds_nr && !P->paused) {
-			/* Below, we read out all feeds in case we have to skip frames first, then get the
-			** most current sound. 'fake_buflen' is either the actual buflen (for the last iteration)
-			** or a fraction of the buf length to discard.  */
-			do {
-				if (frames_skip) {
-					if (frames_skip > self->dev->buf_size)
-						fake_buflen = self->dev->buf_size;
-					else
-						fake_buflen = frames_skip;
-
-					frames_skip -= fake_buflen;
-				} else {
-					fake_buflen = buflen;
-					frames_skip = -1; /* Mark us as being completely done */
-				}
-
-				for (src_i = 0; src_i < self->feeds_nr; src_i++) {
-					mix_compute_input_linear(self, src_i,
-					                         fake_buflen, &timestamp,
-					                         start_timestamp);
-
-					if (timestamp.msecs > 0) {
-						if (have_timestamp) {
-							int diff = sfx_timestamp_msecs_diff(min_timestamp, timestamp);
-							if (diff > 0) {
-								/* New earlier timestamp */
-								timestamp = min_timestamp;
-								timestamp_max_delta += diff;
-							} else if (diff > timestamp_max_delta)
-								timestamp_max_delta = diff;
-							/* New max delta for timestamp */
-						} else {
-							min_timestamp = timestamp;
-							have_timestamp = 1;
-						}
-					}
-				}
-				/* Destroy all feeds we finished */
-				for (src_i = 0; src_i < self->feeds_nr; src_i++)
-					if (self->feeds[src_i].mode == SFX_PCM_FEED_MODE_DEAD)
-						_mix_unsubscribe(self, self->feeds[src_i].feed);
-			} while (frames_skip >= 0);
-
-		} else { /* Zero it out */
-			memset(P->compbuf_l, 0, sizeof(int32) * buflen);
-			memset(P->compbuf_r, 0, sizeof(int32) * buflen);
-		}
-
-#if (DEBUG >= 1)
-		if (self->feeds_nr)
-			sciprintf("[soft-mixer] Done mixing for this session, the result will be our next output buffer\n");
-#endif
-
-#if (DEBUG >= 3)
-		if (self->feeds_nr) {
-			int i;
-			sciprintf("[soft-mixer] Intermediate representation:\n");
-			for (i = 0; i < buflen; i++)
-				sciprintf("[soft-mixer] Offset %d:\t[%04x:%04x]\t%d:%d\n", i,
-				          P->compbuf_l[i] & 0xffff, P->compbuf_r[i] & 0xffff,
-				          P->compbuf_l[i], P->compbuf_r[i]);
-		}
-#endif
-
-		if (timestamp_max_delta > TIMESTAMP_MAX_ALLOWED_DELTA)
-			sciprintf("[soft-mixer] Warning: Difference in timestamps between audio feeds is %d ms\n", timestamp_max_delta);
-
-		mix_compute_output(self, buflen);
-		P->lastbuf_len = buflen;
-
-		/* Finalize */
-		mix_swap_buffers(self);
-		if (have_timestamp)
-			P->outbuf_timestamp = sfx_timestamp_add(min_timestamp,
-			                                        timestamp_max_delta * 500);
-		P->have_outbuf_timestamp = have_timestamp;
-
-	}
-	RELEASE_LOCK();
-	return SFX_OK;
-}
-
-static void mix_pause(sfx_pcm_mixer_t *self) {
-	ACQUIRE_LOCK();
-	P->paused = 1;
-	RELEASE_LOCK();
-}
-
-static void mix_resume(sfx_pcm_mixer_t *self) {
-	ACQUIRE_LOCK();
-	P->paused = 0;
-	RELEASE_LOCK();
-}
-
-sfx_pcm_mixer_t sfx_pcm_mixer_soft_linear = {
-	"soft-linear",
-	"0.1",
-
-	mix_init,
-	mix_exit,
-	mix_subscribe,
-	mix_pause,
-	mix_resume,
-	mix_process_linear,
-
-	0,
-	0,
-	NULL,
-	NULL,
-	NULL
-};
-
-sfx_pcm_mixer_t *getMixer() { return &sfx_pcm_mixer_soft_linear; }
-
-} // End of namespace Sci