3D Audio GSoC:

Changed Readers to top-down architecture instead of bottom-up.

intern/audaspace/FX/AUD_BaseIIRFilterReader.cpp

@@ -55,24 +55,15 @@ AUD_BaseIIRFilterReader::~AUD_BaseIIRFilterReader()
 	delete[] m_y;
 }
 
-void AUD_BaseIIRFilterReader::read(int & length, sample_t* & buffer)
+void AUD_BaseIIRFilterReader::read(int & length, sample_t* buffer)
 {
-	sample_t* buf;
+	m_reader->read(length, buffer);
-
-	int samplesize = AUD_SAMPLE_SIZE(m_reader->getSpecs());
-
-	m_reader->read(length, buf);
-
-	if(m_buffer.getSize() < length * samplesize)
-		m_buffer.resize(length * samplesize);
-
-	buffer = m_buffer.getBuffer();
 
 	for(m_channel = 0; m_channel < m_channels; m_channel++)
 	{
 		for(int i = 0; i < length; i++)
 		{
-			m_x[m_xpos * CC] = buf[i * CC];
+			m_x[m_xpos * CC] = buffer[i * CC];
 			m_y[m_ypos * CC] = buffer[i * CC] = filter();
 
 			m_xpos = (m_xpos + 1) % m_xlen;

intern/audaspace/FX/AUD_BaseIIRFilterReader.h

@@ -56,11 +56,6 @@ private:
 	 */
 	const int m_ylen;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The last in samples array.
 	 */
@@ -112,7 +107,7 @@ public:
 
 	virtual ~AUD_BaseIIRFilterReader();
 
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 
 	virtual sample_t filter()=0;
 };

intern/audaspace/FX/AUD_DelayReader.cpp

@@ -36,8 +36,7 @@
 AUD_DelayReader::AUD_DelayReader(AUD_Reference<AUD_IReader> reader, float delay) :
 		AUD_EffectReader(reader),
 		m_delay(int(delay * reader->getSpecs().rate)),
-		m_remdelay(int(delay * reader->getSpecs().rate)),
+		m_remdelay(int(delay * reader->getSpecs().rate))
-		m_empty(true)
 {
 }
 
@@ -70,46 +69,28 @@ int AUD_DelayReader::getPosition() const
 	return m_reader->getPosition() + m_delay;
 }
 
-void AUD_DelayReader::read(int & length, sample_t* & buffer)
+void AUD_DelayReader::read(int & length, sample_t* buffer)
 {
 	if(m_remdelay > 0)
 	{
 		AUD_Specs specs = m_reader->getSpecs();
 		int samplesize = AUD_SAMPLE_SIZE(specs);
 
-		if(m_buffer.getSize() < length * samplesize)
-		{
-			m_buffer.resize(length * samplesize);
-			m_empty = false;
-		}
-
-		buffer = m_buffer.getBuffer();
-
 		if(length > m_remdelay)
 		{
-			if(!m_empty)
+			memset(buffer, 0, m_remdelay * samplesize);
-				memset(buffer, 0, m_remdelay * samplesize);
 
 			int len = length - m_remdelay;
-			sample_t* buf;
+			m_reader->read(len, buffer + m_remdelay * specs.channels);
-			m_reader->read(len, buf);
-
-			memcpy(buffer + m_remdelay * specs.channels,
-				   buf, len * samplesize);
 
 			if(len < length-m_remdelay)
 				length = m_remdelay + len;
 
 			m_remdelay = 0;
-			m_empty = false;
 		}
 		else
 		{
-			if(!m_empty)
+			memset(buffer, 0, length * samplesize);
-			{
-				memset(buffer, 0, length * samplesize);
-				m_empty = true;
-			}
 			m_remdelay -= length;
 		}
 	}

intern/audaspace/FX/AUD_DelayReader.h

@@ -41,11 +41,6 @@
 class AUD_DelayReader : public AUD_EffectReader
 {
 private:
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The delay level.
 	 */
@@ -56,11 +51,6 @@ private:
 	 */
 	int m_remdelay;
 
-	/**
-	 * Whether the buffer is currently filled with zeros.
-	 */
-	bool m_empty;
-
 	// hide copy constructor and operator=
 	AUD_DelayReader(const AUD_DelayReader&);
 	AUD_DelayReader& operator=(const AUD_DelayReader&);
@@ -76,7 +66,7 @@ public:
 	virtual void seek(int position);
 	virtual int getLength() const;
 	virtual int getPosition() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_DELAYREADER

intern/audaspace/FX/AUD_DoubleReader.cpp

@@ -89,7 +89,7 @@ AUD_Specs AUD_DoubleReader::getSpecs() const
 	return m_reader1->getSpecs();
 }
 
-void AUD_DoubleReader::read(int & length, sample_t* & buffer)
+void AUD_DoubleReader::read(int & length, sample_t* buffer)
 {
 	if(!m_finished1)
 	{
@@ -98,23 +98,12 @@ void AUD_DoubleReader::read(int & length, sample_t* & buffer)
 
 		if(len < length)
 		{
-			AUD_Specs specs = m_reader1->getSpecs();
+			const AUD_Specs specs = m_reader1->getSpecs();
-			int samplesize = AUD_SAMPLE_SIZE(specs);
-
-			if(m_buffer.getSize() < length * samplesize)
-				m_buffer.resize(length * samplesize);
-
-			sample_t* buf = buffer;
-			buffer = m_buffer.getBuffer();
-
-			memcpy(buffer, buf, len * samplesize);
 
 			len = length - len;
 			length -= len;
-			m_reader2->read(len, buf);
 
-			memcpy(buffer + length * specs.channels, buf,
+			m_reader2->read(len, buffer + length * specs.channels);
-				   len * samplesize);
 
 			length += len;
 

intern/audaspace/FX/AUD_DoubleReader.h

@@ -85,7 +85,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_DOUBLEREADER

intern/audaspace/FX/AUD_EffectReader.cpp

@@ -65,7 +65,7 @@ AUD_Specs AUD_EffectReader::getSpecs() const
 	return m_reader->getSpecs();
 }
 
-void AUD_EffectReader::read(int & length, sample_t* & buffer)
+void AUD_EffectReader::read(int & length, sample_t* buffer)
 {
 	m_reader->read(length, buffer);
 }

intern/audaspace/FX/AUD_EffectReader.h

@@ -69,7 +69,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_EFFECTREADER

intern/audaspace/FX/AUD_FaderReader.cpp

@@ -38,12 +38,11 @@ AUD_FaderReader::AUD_FaderReader(AUD_Reference<AUD_IReader> reader, AUD_FadeType
 		AUD_EffectReader(reader),
 		m_type(type),
 		m_start(start),
-		m_length(length),
+		m_length(length)
-		m_empty(true)
 {
 }
 
-void AUD_FaderReader::read(int & length, sample_t* & buffer)
+void AUD_FaderReader::read(int & length, sample_t* buffer)
 {
 	int position = m_reader->getPosition();
 	AUD_Specs specs = m_reader->getSpecs();
@@ -55,46 +54,18 @@ void AUD_FaderReader::read(int & length, sample_t* & buffer)
 	{
 		if(m_type != AUD_FADE_OUT)
 		{
-			if(m_buffer.getSize() < length * samplesize)
+			memset(buffer, 0, length * samplesize);
-			{
-				m_buffer.resize(length * samplesize);
-				m_empty = false;
-			}
-
-			buffer = m_buffer.getBuffer();
-
-			if(!m_empty)
-			{
-				memset(buffer, 0, length * samplesize);
-				m_empty = true;
-			}
 		}
 	}
 	else if(position / (float)specs.rate >= m_start+m_length)
 	{
 		if(m_type == AUD_FADE_OUT)
 		{
-			if(m_buffer.getSize() < length * samplesize)
+			memset(buffer, 0, length * samplesize);
-			{
-				m_buffer.resize(length * samplesize);
-				m_empty = false;
-			}
-
-			buffer = m_buffer.getBuffer();
-
-			if(!m_empty)
-			{
-				memset(buffer, 0, length * samplesize);
-				m_empty = true;
-			}
 		}
 	}
 	else
 	{
-		if(m_buffer.getSize() < length * samplesize)
-			m_buffer.resize(length * samplesize);
-
-		sample_t* buf = m_buffer.getBuffer();
 		float volume = 1.0f;
 
 		for(int i = 0; i < length * specs.channels; i++)
@@ -111,10 +82,7 @@ void AUD_FaderReader::read(int & length, sample_t* & buffer)
 					volume = 1.0f - volume;
 			}
 
-			buf[i] = buffer[i] * volume;
+			buffer[i] = buffer[i] * volume;
 		}
-
-		buffer = buf;
-		m_empty = false;
 	}
 }

intern/audaspace/FX/AUD_FaderReader.h

@@ -58,16 +58,6 @@ private:
 	 */
 	const float m_length;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
-	/**
-	 * Whether the buffer is empty.
-	 */
-	bool m_empty;
-
 	// hide copy constructor and operator=
 	AUD_FaderReader(const AUD_FaderReader&);
 	AUD_FaderReader& operator=(const AUD_FaderReader&);
@@ -82,7 +72,7 @@ public:
 	AUD_FaderReader(AUD_Reference<AUD_IReader> reader, AUD_FadeType type,
 					float start,float length);
 
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_FADERREADER

intern/audaspace/FX/AUD_LimiterReader.cpp

@@ -48,14 +48,14 @@ AUD_LimiterReader::AUD_LimiterReader(AUD_Reference<AUD_IReader> reader,
 		{
 			// skip first m_start samples by reading them
 			int length = AUD_DEFAULT_BUFFER_SIZE;
-			sample_t* buffer;
+			AUD_Buffer buffer(AUD_DEFAULT_BUFFER_SIZE * AUD_SAMPLE_SIZE(m_reader->getSpecs()));
 			for(int len = m_start;
 				length == AUD_DEFAULT_BUFFER_SIZE;
 				len -= AUD_DEFAULT_BUFFER_SIZE)
 			{
 				if(len < AUD_DEFAULT_BUFFER_SIZE)
 					length = len;
-				m_reader->read(length, buffer);
+				m_reader->read(length, buffer.getBuffer());
 			}
 		}
 	}
@@ -80,7 +80,7 @@ int AUD_LimiterReader::getPosition() const
 	return AUD_MIN(pos, m_end) - m_start;
 }
 
-void AUD_LimiterReader::read(int & length, sample_t* & buffer)
+void AUD_LimiterReader::read(int & length, sample_t* buffer)
 {
 	if(m_end >= 0)
 	{

intern/audaspace/FX/AUD_LimiterReader.h

@@ -67,7 +67,7 @@ public:
 	virtual void seek(int position);
 	virtual int getLength() const;
 	virtual int getPosition() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_LIMITERREADER

intern/audaspace/FX/AUD_LoopReader.cpp

@@ -68,10 +68,9 @@ int AUD_LoopReader::getPosition() const
 	return m_reader->getPosition() * (m_count < 0 ? 1 : m_count);
 }
 
-void AUD_LoopReader::read(int & length, sample_t* & buffer)
+void AUD_LoopReader::read(int & length, sample_t* buffer)
 {
 	AUD_Specs specs = m_reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
 
 	int len = length;
 
@@ -81,13 +80,6 @@ void AUD_LoopReader::read(int & length, sample_t* & buffer)
 	{
 		int pos = 0;
 
-		if(m_buffer.getSize() < length * samplesize)
-			m_buffer.resize(length * samplesize);
-
-		sample_t* buf = m_buffer.getBuffer();
-
-		memcpy(buf + pos * specs.channels, buffer, len * samplesize);
-
 		pos += len;
 
 		while(pos < length && m_left)
@@ -98,19 +90,16 @@ void AUD_LoopReader::read(int & length, sample_t* & buffer)
 			m_reader->seek(0);
 
 			len = length - pos;
-			m_reader->read(len, buffer);
+			m_reader->read(len, buffer + pos * specs.channels);
 
 			// prevent endless loop
 			if(!len)
 				break;
 
-			memcpy(buf + pos * specs.channels, buffer, len * samplesize);
-
 			pos += len;
 		}
 
 		length = pos;
-		buffer = buf;
 	}
 	else
 		length = len;

intern/audaspace/FX/AUD_LoopReader.h

@@ -42,11 +42,6 @@
 class AUD_LoopReader : public AUD_EffectReader
 {
 private:
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The loop count.
 	 */
@@ -73,7 +68,7 @@ public:
 	virtual void seek(int position);
 	virtual int getLength() const;
 	virtual int getPosition() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_LOOPREADER

intern/audaspace/FX/AUD_ReverseReader.cpp

@@ -60,7 +60,7 @@ int AUD_ReverseReader::getPosition() const
 	return m_position;
 }
 
-void AUD_ReverseReader::read(int & length, sample_t* & buffer)
+void AUD_ReverseReader::read(int & length, sample_t* buffer)
 {
 	// first correct the length
 	if(m_position + length > m_length)
@@ -72,36 +72,34 @@ void AUD_ReverseReader::read(int & length, sample_t* & buffer)
 		return;
 	}
 
-	AUD_Specs specs = getSpecs();
+	const AUD_Specs specs = getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
+	const int samplesize = AUD_SAMPLE_SIZE(specs);
 
-	// resize buffer if needed
+	sample_t temp[specs.channels];
-	if(m_buffer.getSize() < length * samplesize)
-		m_buffer.resize(length * samplesize);
 
-	buffer = m_buffer.getBuffer();
-
-	sample_t* buf;
 	int len = length;
 
 	// read from reader
 	m_reader->seek(m_length - m_position - len);
-	m_reader->read(len, buf);
+	m_reader->read(len, buffer);
 
 	// set null if reader didn't give enough data
 	if(len < length)
-	{
 		memset(buffer, 0, (length - len) * samplesize);
-		buffer += (length - len) * specs.channels;
-	}
 
 	// copy the samples reverted
-	for(int i = 0; i < len; i++)
+	for(int i = 0; i < length / 2; i++)
-		memcpy(buffer + i * specs.channels,
+	{
-			   buf + (len - 1 - i) * specs.channels,
+		memcpy(temp,
+			   buffer + (len - 1 - i) * specs.channels,
 			   samplesize);
+		memcpy(buffer + (len - 1 - i) * specs.channels,
+			   buffer + i * specs.channels,
+			   samplesize);
+		memcpy(buffer + i * specs.channels,
+			   temp,
+			   samplesize);
+	}
 
 	m_position += length;
-
-	buffer = m_buffer.getBuffer();
 }

intern/audaspace/FX/AUD_ReverseReader.h

@@ -52,11 +52,6 @@ private:
 	 */
 	int m_position;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	// hide copy constructor and operator=
 	AUD_ReverseReader(const AUD_ReverseReader&);
 	AUD_ReverseReader& operator=(const AUD_ReverseReader&);
@@ -73,7 +68,7 @@ public:
 	virtual void seek(int position);
 	virtual int getLength() const;
 	virtual int getPosition() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_REVERSEREADER

intern/audaspace/FX/AUD_SuperposeReader.cpp

@@ -82,24 +82,22 @@ AUD_Specs AUD_SuperposeReader::getSpecs() const
 	return m_reader1->getSpecs();
 }
 
-void AUD_SuperposeReader::read(int & length, sample_t* & buffer)
+void AUD_SuperposeReader::read(int & length, sample_t* buffer)
 {
 	AUD_Specs specs = m_reader1->getSpecs();
 	int samplesize = AUD_SAMPLE_SIZE(specs);
 
 	if(m_buffer.getSize() < length * samplesize)
 		m_buffer.resize(length * samplesize);
-	buffer = m_buffer.getBuffer();
 
 	int len1 = length;
-	sample_t* buf;
+	m_reader1->read(len1, buffer);
-	m_reader1->read(len1, buf);
-	memcpy(buffer, buf, len1 * samplesize);
 
 	if(len1 < length)
 		memset(buffer + len1 * specs.channels, 0, (length - len1) * samplesize);
 
 	int len2 = length;
+	sample_t* buf = m_buffer.getBuffer();
 	m_reader2->read(len2, buf);
 
 	for(int i = 0; i < len2 * specs.channels; i++)

intern/audaspace/FX/AUD_SuperposeReader.h

@@ -80,7 +80,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SUPERPOSEREADER

intern/audaspace/OpenAL/AUD_OpenALDevice.cpp

@@ -130,7 +130,6 @@ void AUD_OpenALDevice::updateStreams()
 	AUD_OpenALHandle* sound;
 
 	int length;
-	sample_t* buffer;
 
 	ALint info;
 	AUD_DeviceSpecs specs = m_specs;
@@ -161,6 +160,8 @@ void AUD_OpenALDevice::updateStreams()
 					if(info)
 					{
 						specs.specs = sound->reader->getSpecs();
+						if(m_buffer.getSize() < m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs))
+							m_buffer.resize(m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs));
 
 						// for all empty buffers
 						while(info--)
@@ -170,7 +171,7 @@ void AUD_OpenALDevice::updateStreams()
 							{
 								// read data
 								length = m_buffersize;
-								sound->reader->read(length, buffer);
+								sound->reader->read(length, m_buffer.getBuffer());
 
 								// looping necessary?
 								if(length == 0 && sound->loopcount)
@@ -181,7 +182,7 @@ void AUD_OpenALDevice::updateStreams()
 									sound->reader->seek(0);
 
 									length = m_buffersize;
-									sound->reader->read(length, buffer);
+									sound->reader->read(length, m_buffer.getBuffer());
 								}
 
 								// read nothing?
@@ -204,7 +205,7 @@ void AUD_OpenALDevice::updateStreams()
 								// fill with new data
 								alBufferData(sound->buffers[sound->current],
 											 sound->format,
-											 buffer, length *
+											 m_buffer.getBuffer(), length *
 											 AUD_DEVICE_SAMPLE_SIZE(specs),
 											 specs.rate);
 
@@ -581,14 +582,15 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_Reference<AUD_IReader> reader, bool keep)
 
 		try
 		{
-			sample_t* buf;
+			if(m_buffer.getSize() < m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs))
+				m_buffer.resize(m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs));
 			int length;
 
 			for(int i = 0; i < AUD_OPENAL_CYCLE_BUFFERS; i++)
 			{
 				length = m_buffersize;
-				reader->read(length, buf);
+				reader->read(length, m_buffer.getBuffer());
-				alBufferData(sound->buffers[i], sound->format, buf,
+				alBufferData(sound->buffers[i], sound->format, m_buffer.getBuffer(),
 							 length * AUD_DEVICE_SAMPLE_SIZE(specs),
 							 specs.rate);
 				if(alGetError() != AL_NO_ERROR)
@@ -879,17 +881,18 @@ bool AUD_OpenALDevice::seek(AUD_Handle* handle, float position)
 				ALenum err;
 				if((err = alGetError()) == AL_NO_ERROR)
 				{
-					sample_t* buf;
 					int length;
 					AUD_DeviceSpecs specs = m_specs;
 					specs.specs = alhandle->reader->getSpecs();
+					if(m_buffer.getSize() < m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs))
+						m_buffer.resize(m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs));
 
 					for(int i = 0; i < AUD_OPENAL_CYCLE_BUFFERS; i++)
 					{
 						length = m_buffersize;
-						alhandle->reader->read(length, buf);
+						alhandle->reader->read(length, m_buffer.getBuffer());
 						alBufferData(alhandle->buffers[i], alhandle->format,
-									 buf,
+									 m_buffer.getBuffer(),
 									 length * AUD_DEVICE_SAMPLE_SIZE(specs),
 									 specs.rate);
 

intern/audaspace/OpenAL/AUD_OpenALDevice.h

@@ -34,6 +34,7 @@
 
 #include "AUD_IDevice.h"
 #include "AUD_I3DDevice.h"
+#include "AUD_Buffer.h"
 struct AUD_OpenALHandle;
 struct AUD_OpenALBufferedFactory;
 
@@ -103,6 +104,11 @@ private:
 	 */
 	int m_buffersize;
 
+	/**
+	 * Device buffer.
+	 */
+	AUD_Buffer m_buffer;
+
 	/**
 	 * Starts the streaming thread.
 	 */

intern/audaspace/SRC/AUD_SRCResampleReader.cpp

@@ -75,11 +75,10 @@ AUD_SRCResampleReader::~AUD_SRCResampleReader()
 long AUD_SRCResampleReader::doCallback(float** data)
 {
 	int length = m_buffer.getSize() / AUD_SAMPLE_SIZE(m_tspecs);
-	sample_t* buffer;
 
-	m_reader->read(length, buffer);
+	*data = m_buffer.getBuffer();
+	m_reader->read(length, *data);
 
-	*data = buffer;
 	return length;
 }
 
@@ -105,15 +104,13 @@ AUD_Specs AUD_SRCResampleReader::getSpecs() const
 	return m_tspecs;
 }
 
-void AUD_SRCResampleReader::read(int & length, sample_t* & buffer)
+void AUD_SRCResampleReader::read(int & length, sample_t* buffer)
 {
 	int size = length * AUD_SAMPLE_SIZE(m_tspecs);
 
 	if(m_buffer.getSize() < size)
 		m_buffer.resize(size);
 
-	buffer = m_buffer.getBuffer();
-
 	length = src_callback_read(m_src, m_factor, length, buffer);
 
 	m_position += length;

intern/audaspace/SRC/AUD_SRCResampleReader.h

@@ -104,7 +104,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SRCRESAMPLEREADER

intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp

@@ -341,14 +341,14 @@ void AUD_FFMPEGReader::seek(int position)
 						{
 							// read until we're at the right position
 							int length = AUD_DEFAULT_BUFFER_SIZE;
-							sample_t* buffer;
+							AUD_Buffer buffer(length * AUD_SAMPLE_SIZE(m_specs));
 							for(int len = position - m_position;
 								length == AUD_DEFAULT_BUFFER_SIZE;
 								len -= AUD_DEFAULT_BUFFER_SIZE)
 							{
 								if(len < AUD_DEFAULT_BUFFER_SIZE)
 									length = len;
-								read(length, buffer);
+								read(length, buffer.getBuffer());
 							}
 						}
 					}
@@ -381,7 +381,7 @@ AUD_Specs AUD_FFMPEGReader::getSpecs() const
 	return m_specs.specs;
 }
 
-void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
+void AUD_FFMPEGReader::read(int & length, sample_t* buffer)
 {
 	// read packages and decode them
 	AVPacket packet;
@@ -390,11 +390,7 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 	int left = length;
 	int sample_size = AUD_DEVICE_SAMPLE_SIZE(m_specs);
 
-	// resize output buffer if necessary
+	sample_t* buf = buffer;
-	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs))
-		m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs));
-
-	buffer = m_buffer.getBuffer();
 	pkgbuf_pos = m_pkgbuf_left;
 	m_pkgbuf_left = 0;
 
@@ -402,9 +398,9 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 	if(pkgbuf_pos > 0)
 	{
 		data_size = AUD_MIN(pkgbuf_pos, left * sample_size);
-		m_convert((data_t*) buffer, (data_t*) m_pkgbuf.getBuffer(),
+		m_convert((data_t*) buf, (data_t*) m_pkgbuf.getBuffer(),
 				  data_size / AUD_FORMAT_SIZE(m_specs.format));
-		buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
+		buf += data_size / AUD_FORMAT_SIZE(m_specs.format);
 		left -= data_size/sample_size;
 	}
 
@@ -419,9 +415,9 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 
 			// copy to output buffer
 			data_size = AUD_MIN(pkgbuf_pos, left * sample_size);
-			m_convert((data_t*) buffer, (data_t*) m_pkgbuf.getBuffer(),
+			m_convert((data_t*) buf, (data_t*) m_pkgbuf.getBuffer(),
 					  data_size / AUD_FORMAT_SIZE(m_specs.format));
-			buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
+			buf += data_size / AUD_FORMAT_SIZE(m_specs.format);
 			left -= data_size/sample_size;
 		}
 		av_free_packet(&packet);
@@ -435,8 +431,6 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 				pkgbuf_pos-data_size);
 	}
 
-	buffer = m_buffer.getBuffer();
-
 	if(left > 0)
 		length -= left;
 	m_position += length;

intern/audaspace/ffmpeg/AUD_FFMPEGReader.h

@@ -60,11 +60,6 @@ private:
 	 */
 	int m_position;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The specification of the audio data.
 	 */
@@ -167,7 +162,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_FFMPEGREADER

intern/audaspace/intern/AUD_BufferReader.cpp

@@ -33,6 +33,8 @@
 #include "AUD_Buffer.h"
 #include "AUD_Space.h"
 
+#include <cstring>
+
 AUD_BufferReader::AUD_BufferReader(AUD_Reference<AUD_Buffer> buffer,
 								   AUD_Specs specs) :
 	m_position(0), m_buffer(buffer), m_specs(specs)
@@ -64,17 +66,22 @@ AUD_Specs AUD_BufferReader::getSpecs() const
 	return m_specs;
 }
 
-void AUD_BufferReader::read(int & length, sample_t* & buffer)
+void AUD_BufferReader::read(int & length, sample_t* buffer)
 {
 	int sample_size = AUD_SAMPLE_SIZE(m_specs);
 
-	buffer = m_buffer->getBuffer() + m_position * m_specs.channels;
+	sample_t* buf = m_buffer->getBuffer() + m_position * m_specs.channels;
 
 	// in case the end of the buffer is reached
 	if(m_buffer->getSize() < (m_position + length) * sample_size)
 		length = m_buffer->getSize() / sample_size - m_position;
 
 	if(length < 0)
+	{
 		length = 0;
+		return;
+	}
+
 	m_position += length;
+	memcpy(buffer, buf, length * sample_size);
 }

intern/audaspace/intern/AUD_BufferReader.h

@@ -76,7 +76,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_BUFFERREADER

intern/audaspace/intern/AUD_C-API.cpp

@@ -778,13 +778,11 @@ float* AUD_readSoundBuffer(const char* filename, float low, float high,
 
 	int len;
 	int position = 0;
-	sample_t* readbuffer;
 	do
 	{
 		len = samplerate;
 		buffer.resize((position + len) * sizeof(float), true);
-		reader->read(len, readbuffer);
+		reader->read(len, buffer.getBuffer() + position);
-		memcpy(buffer.getBuffer() + position, readbuffer, len * sizeof(float));
 		position += len;
 	} while(len != 0);
 
@@ -868,6 +866,7 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length)
 {
 	AUD_DeviceSpecs specs;
 	sample_t* buf;
+	AUD_Buffer aBuffer;
 
 	specs.rate = AUD_RATE_INVALID;
 	specs.channels = AUD_CHANNELS_MONO;
@@ -882,6 +881,13 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length)
 	for(int i = 0; i < length; i++)
 	{
 		len = floor(samplejump * (i+1)) - floor(samplejump * i);
+
+		if(aBuffer.getSize() < len * AUD_SAMPLE_SIZE(reader->getSpecs()))
+		{
+			aBuffer.resize(len * AUD_SAMPLE_SIZE(reader->getSpecs()));
+			buf = aBuffer.getBuffer();
+		}
+
 		reader->read(len, buf);
 
 		if(len < 1)

intern/audaspace/intern/AUD_ChannelMapperReader.cpp

@@ -76,16 +76,15 @@ AUD_Specs AUD_ChannelMapperReader::getSpecs() const
 	return m_specs;
 }
 
-void AUD_ChannelMapperReader::read(int & length, sample_t* & buffer)
+void AUD_ChannelMapperReader::read(int & length, sample_t* buffer)
 {
-	sample_t* in = buffer;
+	if(m_buffer.getSize() < length * m_rch * sizeof(sample_t))
+		m_buffer.resize(length * m_rch * sizeof(sample_t));
+
+	sample_t* in = m_buffer.getBuffer();
 
 	m_reader->read(length, in);
 
-	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs))
-		m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs));
-
-	buffer = m_buffer.getBuffer();
 	sample_t sum;
 
 	for(int i = 0; i < length; i++)

intern/audaspace/intern/AUD_ChannelMapperReader.h

@@ -43,7 +43,7 @@ class AUD_ChannelMapperReader : public AUD_EffectReader
 {
 private:
 	/**
-	 * The sound output buffer.
+	 * The sound reading buffer.
 	 */
 	AUD_Buffer m_buffer;
 
@@ -80,7 +80,7 @@ public:
 	~AUD_ChannelMapperReader();
 
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_CHANNELMAPPERREADER

intern/audaspace/intern/AUD_ConverterReader.cpp

@@ -75,17 +75,15 @@ AUD_Specs AUD_ConverterReader::getSpecs() const
 	return m_specs.specs;
 }
 
-void AUD_ConverterReader::read(int & length, sample_t* & buffer)
+void AUD_ConverterReader::read(int & length, sample_t* buffer)
 {
-	m_reader->read(length, buffer);
+	int samplesize = AUD_SAMPLE_SIZE(m_reader->getSpecs());
-
-	int samplesize = AUD_SAMPLE_SIZE(m_specs);
 
 	if(m_buffer.getSize() < length * samplesize)
 		m_buffer.resize(length * samplesize);
 
-	m_convert((data_t*)m_buffer.getBuffer(), (data_t*)buffer,
+	m_reader->read(length, m_buffer.getBuffer());
-			  length * m_specs.channels);
 
-	buffer = m_buffer.getBuffer();
+	m_convert((data_t*)buffer, (data_t*)m_buffer.getBuffer(),
+			  length * m_specs.channels);
 }

intern/audaspace/intern/AUD_ConverterReader.h

@@ -70,7 +70,7 @@ public:
 	AUD_ConverterReader(AUD_Reference<AUD_IReader> reader, AUD_DeviceSpecs specs);
 
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_CONVERTERREADER

intern/audaspace/intern/AUD_IReader.h

@@ -100,7 +100,7 @@ public:
 	 *                A smaller value also indicates the end of the reader.
 	 * \param[out] buffer The pointer to the buffer with the samples.
 	 */
-	virtual void read(int & length, sample_t* & buffer)=0;
+	virtual void read(int & length, sample_t* buffer)=0;
 };
 
 #endif //AUD_IREADER

intern/audaspace/intern/AUD_LinearResampleReader.cpp

@@ -71,18 +71,17 @@ AUD_Specs AUD_LinearResampleReader::getSpecs() const
 	return m_tspecs;
 }
 
-void AUD_LinearResampleReader::read(int & length, sample_t* & buffer)
+void AUD_LinearResampleReader::read(int & length, sample_t* buffer)
 {
 	int samplesize = AUD_SAMPLE_SIZE(m_tspecs);
-	int size = length * samplesize;
+	int size = length * AUD_SAMPLE_SIZE(m_sspecs);
 
 	if(m_buffer.getSize() < size)
 		m_buffer.resize(size);
 
 	int need = ceil((m_position + length) / m_factor) + 1 - m_sposition;
 	int len = need;
-	sample_t* buf;
+	sample_t* buf = m_buffer.getBuffer();
-	buffer = m_buffer.getBuffer();
 
 	m_reader->read(len, buf);
 

intern/audaspace/intern/AUD_LinearResampleReader.h

@@ -92,7 +92,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_LINEARRESAMPLEREADER

intern/audaspace/intern/AUD_Mixer.cpp

@@ -73,43 +73,33 @@ AUD_DeviceSpecs AUD_Mixer::getSpecs() const
 	return m_specs;
 }
 
-void AUD_Mixer::add(sample_t* buffer, int start, int length, float volume)
+void AUD_Mixer::clear(int length)
 {
-	AUD_MixerBuffer buf;
+	if(m_buffer.getSize() < length * m_specs.channels * AUD_SAMPLE_SIZE(m_specs))
-	buf.buffer = buffer;
+		m_buffer.resize(length * m_specs.channels * AUD_SAMPLE_SIZE(m_specs));
-	buf.start = start;
+
-	buf.length = length;
+	m_length = length;
-	buf.volume = volume;
+
-	m_buffers.push_back(buf);
+	memset(m_buffer.getBuffer(), 0, length * m_specs.channels * AUD_SAMPLE_SIZE(m_specs));
 }
 
-void AUD_Mixer::superpose(data_t* buffer, int length, float volume)
+void AUD_Mixer::mix(sample_t* buffer, int start, int length, float volume)
 {
-	AUD_MixerBuffer buf;
-
-	int channels = m_specs.channels;
-
-	if(m_buffer.getSize() < length * channels * 4)
-		m_buffer.resize(length * channels * 4);
-
 	sample_t* out = m_buffer.getBuffer();
-	sample_t* in;
 
-	memset(out, 0, length * channels * 4);
+	length = (AUD_MIN(m_length, length + start) - start) * m_specs.channels;
+	start += m_specs.channels;
 
-	int end;
+	for(int i = 0; i < length; i++)
-
+		out[i + start] += buffer[i] * volume;
-	while(!m_buffers.empty())
+}
-	{
+
-		buf = m_buffers.front();
+void AUD_Mixer::read(data_t* buffer, float volume)
-		m_buffers.pop_front();
+{
-
+	sample_t* out = m_buffer.getBuffer();
-		end = buf.length * channels;
+
-		in = buf.buffer;
+	for(int i = 0; i < m_length * m_specs.channels; i++)
-
+		out[i] *= volume;
-		for(int i = 0; i < end; i++)
+
-			out[i + buf.start * channels] += in[i] * buf.volume * volume;
+	m_convert(buffer, (data_t*) out, m_length * m_specs.channels);
-	}
-
-	m_convert(buffer, (data_t*) out, length * channels);
 }

intern/audaspace/intern/AUD_Mixer.h

@@ -36,15 +36,6 @@
 #include "AUD_Buffer.h"
 #include "AUD_Reference.h"
 class AUD_IReader;
-#include <list>
-
-struct AUD_MixerBuffer
-{
-	sample_t* buffer;
-	int start;
-	int length;
-	float volume;
-};
 
 /**
  * This abstract class is able to mix audiosignals of different channel count
@@ -53,18 +44,18 @@ struct AUD_MixerBuffer
 class AUD_Mixer
 {
 protected:
-	/**
-	 * The list of buffers to superpose.
-	 */
-	std::list<AUD_MixerBuffer> m_buffers;
-
 	/**
 	 * The output specification.
 	 */
 	const AUD_DeviceSpecs m_specs;
 
 	/**
-	 * The temporary mixing buffer.
+	 * The length of the mixing buffer.
+	 */
+	int m_length;
+
+	/**
+	 * The mixing buffer.
 	 */
 	AUD_Buffer m_buffer;
 
@@ -98,21 +89,26 @@ public:
 	virtual AUD_Reference<AUD_IReader> prepare(AUD_Reference<AUD_IReader> reader)=0;
 
 	/**
-	 * Adds a buffer for superposition.
+	 * Mixes a buffer.
 	 * \param buffer The buffer to superpose.
 	 * \param start The start sample of the buffer.
 	 * \param length The length of the buffer in samples.
 	 * \param volume The mixing volume. Must be a value between 0.0 and 1.0.
 	 */
-	virtual void add(sample_t* buffer, int start, int length, float volume);
+	virtual void mix(sample_t* buffer, int start, int length, float volume);
 
 	/**
-	 * Superposes all added buffers into an output buffer.
+	 * Writes the mixing buffer into an output buffer.
 	 * \param buffer The target buffer for superposing.
-	 * \param length The length of the buffer in samples.
 	 * \param volume The mixing volume. Must be a value between 0.0 and 1.0.
 	 */
-	virtual void superpose(data_t* buffer, int length, float volume);
+	virtual void read(data_t* buffer, float volume);
+
+	/**
+	 * Clears the mixing buffer.
+	 * \param length The length of the buffer in samples.
+	 */
+	virtual void clear(int length);
 };
 
 #endif //AUD_MIXER

intern/audaspace/intern/AUD_SequencerReader.cpp

@@ -113,21 +113,17 @@ AUD_Specs AUD_SequencerReader::getSpecs() const
 	return m_mixer->getSpecs().specs;
 }
 
-void AUD_SequencerReader::read(int & length, sample_t* & buffer)
+void AUD_SequencerReader::read(int & length, sample_t* buffer)
 {
 	AUD_DeviceSpecs specs = m_mixer->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
 	int rate = specs.rate;
 
-	int size = length * samplesize;
-
 	int start, end, current, skip, len;
 	AUD_Reference<AUD_SequencerStrip> strip;
-	sample_t* buf;
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	if(m_buffer.getSize() < size)
+	m_mixer->clear(length);
-		m_buffer.resize(size);
-	buffer = m_buffer.getBuffer();
 
 	if(!m_factory->getMute())
 	{
@@ -176,8 +172,8 @@ void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 							len -= skip;
 							if(strip->reader->getPosition() != current)
 								strip->reader->seek(current);
-							strip->reader->read(len, buf);
+							strip->reader->read(len, m_buffer.getBuffer());
-							m_mixer->add(buf, skip, len, m_volume(m_data, strip->entry->data, (float)m_position / (float)rate));
+							m_mixer->mix(m_buffer.getBuffer(), skip, len, m_volume(m_data, strip->entry->data, (float)m_position / (float)rate));
 						}
 					}
 				}
@@ -185,7 +181,7 @@ void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 		}
 	}
 
-	m_mixer->superpose((data_t*)buffer, length, 1.0f);
+	m_mixer->read((data_t*)buffer, 1.0f);
 
 	m_position += length;
 }

intern/audaspace/intern/AUD_SequencerReader.h

@@ -56,7 +56,7 @@ private:
 	int m_position;
 
 	/**
-	 * The sound output buffer.
+	 * The reading buffer.
 	 */
 	AUD_Buffer m_buffer;
 
@@ -100,7 +100,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SEQUENCERREADER

intern/audaspace/intern/AUD_SilenceReader.cpp

@@ -66,15 +66,8 @@ AUD_Specs AUD_SilenceReader::getSpecs() const
 	return specs;
 }
 
-void AUD_SilenceReader::read(int & length, sample_t* & buffer)
+void AUD_SilenceReader::read(int & length, sample_t* buffer)
 {
-	// resize if necessary
+	memset(buffer, 0, length * sizeof(sample_t));
-	if(m_buffer.getSize() < length * sizeof(sample_t))
-	{
-		m_buffer.resize(length * sizeof(sample_t));
-		memset(m_buffer.getBuffer(), 0, m_buffer.getSize());
-	}
-
-	buffer = m_buffer.getBuffer();
 	m_position += length;
 }

intern/audaspace/intern/AUD_SilenceReader.h

@@ -51,11 +51,6 @@ private:
 	 */
 	int m_position;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	// hide copy constructor and operator=
 	AUD_SilenceReader(const AUD_SilenceReader&);
 	AUD_SilenceReader& operator=(const AUD_SilenceReader&);
@@ -71,7 +66,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SILENCEREADER

intern/audaspace/intern/AUD_SinusReader.cpp

@@ -72,14 +72,9 @@ AUD_Specs AUD_SinusReader::getSpecs() const
 	return specs;
 }
 
-void AUD_SinusReader::read(int & length, sample_t* & buffer)
+void AUD_SinusReader::read(int & length, sample_t* buffer)
 {
-	// resize if necessary
-	if(m_buffer.getSize() < length * sizeof(sample_t))
-		m_buffer.resize(length * sizeof(sample_t));
-
 	// fill with sine data
-	buffer = m_buffer.getBuffer();
 	for(int i = 0; i < length; i++)
 	{
 		buffer[i] = sin((m_position + i) * 2 * M_PI * m_frequency /

intern/audaspace/intern/AUD_SinusReader.h

@@ -56,11 +56,6 @@ private:
 	 */
 	int m_position;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The sample rate for the output.
 	 */
@@ -83,7 +78,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SINUSREADER

intern/audaspace/intern/AUD_SoftwareDevice.cpp

@@ -104,17 +104,19 @@ void AUD_SoftwareDevice::destroy()
 
 void AUD_SoftwareDevice::mix(data_t* buffer, int length)
 {
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs));
+
 	lock();
 
 	{
 		AUD_SoftwareHandle* sound;
 		int len;
 		int pos;
-		sample_t* buf;
 		std::list<AUD_SoftwareHandle*> stopSounds;
-		std::list<AUD_Buffer*> tempBufs;
+		sample_t* buf = m_buffer.getBuffer();
-		AUD_Buffer* tempbuf;
+
-		int samplesize = AUD_SAMPLE_SIZE(m_specs);
+		m_mixer->clear(length);
 
 		// for all sounds
 		AUD_HandleIterator it = m_playingSounds.begin();
@@ -128,15 +130,13 @@ void AUD_SoftwareDevice::mix(data_t* buffer, int length)
 			// get the buffer from the source
 			pos = 0;
 			len = length;
+
 			sound->reader->read(len, buf);
 
 			// in case of looping
 			while(pos + len < length && sound->loopcount)
 			{
-				tempbuf = new AUD_Buffer(len * samplesize);
+				m_mixer->mix(buf, pos, len, sound->volume);
-				memcpy(tempbuf->getBuffer(), buf, len * samplesize);
-				tempBufs.push_back(tempbuf);
-				m_mixer->add(tempbuf->getBuffer(), pos, len, sound->volume);
 
 				pos += len;
 
@@ -153,7 +153,7 @@ void AUD_SoftwareDevice::mix(data_t* buffer, int length)
 					break;
 			}
 
-			m_mixer->add(buf, pos, len, sound->volume);
+			m_mixer->mix(buf, pos, len, sound->volume);
 			pos += len;
 
 			// in case the end of the sound is reached
@@ -170,7 +170,7 @@ void AUD_SoftwareDevice::mix(data_t* buffer, int length)
 		}
 
 		// superpose
-		m_mixer->superpose(buffer, length, m_volume);
+		m_mixer->read(buffer, m_volume);
 
 		// cleanup
 		while(!stopSounds.empty())
@@ -179,13 +179,6 @@ void AUD_SoftwareDevice::mix(data_t* buffer, int length)
 			stopSounds.pop_front();
 			stop(sound);
 		}
-
-		while(!tempBufs.empty())
-		{
-			tempbuf = tempBufs.front();
-			tempBufs.pop_front();
-			delete tempbuf;
-		}
 	}
 
 	unlock();

intern/audaspace/intern/AUD_SoftwareDevice.h

@@ -34,8 +34,8 @@
 
 #include "AUD_IDevice.h"
 #include "AUD_Mixer.h"
+#include "AUD_Buffer.h"
 struct AUD_SoftwareHandle;
-class AUD_Buffer;
 
 #include <list>
 #include <pthread.h>
@@ -85,6 +85,11 @@ protected:
 	virtual void playing(bool playing)=0;
 
 private:
+	/**
+	 * The reading buffer.
+	 */
+	AUD_Buffer m_buffer;
+
 	/**
 	 * The list of sounds that are currently playing.
 	 */

intern/audaspace/intern/AUD_StreamBufferFactory.cpp

@@ -45,7 +45,6 @@ AUD_StreamBufferFactory::AUD_StreamBufferFactory(AUD_Reference<AUD_IFactory> fac
 	int sample_size = AUD_SAMPLE_SIZE(m_specs);
 	int length;
 	int index = 0;
-	sample_t* buffer;
 
 	// get an approximated size if possible
 	int size = reader->getLength();
@@ -63,10 +62,7 @@ AUD_StreamBufferFactory::AUD_StreamBufferFactory(AUD_Reference<AUD_IFactory> fac
 
 		// read more
 		length = size-index;
-		reader->read(length, buffer);
+		reader->read(length, m_buffer->getBuffer() + index * m_specs.channels);
-		memcpy(m_buffer->getBuffer() + index * m_specs.channels,
-			   buffer,
-			   length * sample_size);
 		size += AUD_BUFFER_RESIZE_BYTES / sample_size;
 		index += length;
 	}

intern/audaspace/jack/AUD_JackDevice.cpp

@@ -28,8 +28,6 @@
  *  \ingroup audjack
  */
 
-
-#include "AUD_Mixer.h"
 #include "AUD_JackDevice.h"
 #include "AUD_IReader.h"
 

intern/audaspace/sndfile/AUD_SndFileReader.cpp

@@ -161,16 +161,8 @@ AUD_Specs AUD_SndFileReader::getSpecs() const
 	return m_specs;
 }
 
-void AUD_SndFileReader::read(int & length, sample_t* & buffer)
+void AUD_SndFileReader::read(int & length, sample_t* buffer)
 {
-	int sample_size = AUD_SAMPLE_SIZE(m_specs);
-
-	// resize output buffer if necessary
-	if(m_buffer.getSize() < length*sample_size)
-		m_buffer.resize(length*sample_size);
-
-	buffer = m_buffer.getBuffer();
-
 	length = sf_readf_float(m_sndfile, buffer, length);
 
 	m_position += length;

intern/audaspace/sndfile/AUD_SndFileReader.h

@@ -67,11 +67,6 @@ private:
 	 */
 	AUD_Specs m_specs;
 
-	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer m_buffer;
-
 	/**
 	 * The sndfile.
 	 */
@@ -129,7 +124,7 @@ public:
 	virtual int getLength() const;
 	virtual int getPosition() const;
 	virtual AUD_Specs getSpecs() const;
-	virtual void read(int & length, sample_t* & buffer);
+	virtual void read(int & length, sample_t* buffer);
 };
 
 #endif //AUD_SNDFILEREADER