Audaspace: HUGE Refactor.

Some points of the refactor not sorted by importance:

* Fixed immutability of readers and factories (there are exceptions...)
* Fixed copy constructors and = operators
* Removed messaging system
* Removed reader types
* Added const where possible
* Using initalisers when possible
* Avoided use of pointers when possible
* Removed AUD_NEW and AUD_DELETE macros
* Removed useless NULL pointer checks
* Fixed exception catching
* Fixed some yet unknown bugs
* Lots of other stuff

139 files changed, 1468 insertions, 2394 deletions

diff --git a/intern/audaspace/FX/AUD_AccumulatorFactory.cpp b/intern/audaspace/FX/AUD_AccumulatorFactory.cpp
index 20709c57ee5..6e9130d174b 100644
--- a/intern/audaspace/FX/AUD_AccumulatorFactory.cpp
+++ b/intern/audaspace/FX/AUD_AccumulatorFactory.cpp
@@ -29,21 +29,11 @@
 AUD_AccumulatorFactory::AUD_AccumulatorFactory(AUD_IFactory* factory,
 											   bool additive) :
 		AUD_EffectFactory(factory),
-		m_additive(additive) {}
-
-AUD_AccumulatorFactory::AUD_AccumulatorFactory(bool additive) :
-		AUD_EffectFactory(0),
-		m_additive(additive) {}
-
-AUD_IReader* AUD_AccumulatorFactory::createReader()
+		m_additive(additive)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_AccumulatorReader(reader, m_additive);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_AccumulatorFactory::createReader() const
+{
+	return new AUD_AccumulatorReader(getReader(), m_additive);
 }
diff --git a/intern/audaspace/FX/AUD_AccumulatorFactory.h b/intern/audaspace/FX/AUD_AccumulatorFactory.h
index e475a19ccf6..2b90fa43bdf 100644
--- a/intern/audaspace/FX/AUD_AccumulatorFactory.h
+++ b/intern/audaspace/FX/AUD_AccumulatorFactory.h
@@ -37,7 +37,11 @@ private:
 	/**
 	 * Whether the accumulator is additive.
 	 */
-	bool m_additive;
+	const bool m_additive;
+
+	// hide copy constructor and operator=
+	AUD_AccumulatorFactory(const AUD_AccumulatorFactory&);
+	AUD_AccumulatorFactory& operator=(const AUD_AccumulatorFactory&);
 
 public:
 	/**
@@ -47,13 +51,7 @@ public:
 	 */
 	AUD_AccumulatorFactory(AUD_IFactory* factory, bool additive = false);
 
-	/**
-	 * Creates a new accumulator factory.
-	 * \param additive Whether the accumulator is additive.
-	 */
-	AUD_AccumulatorFactory(bool additive = false);
-
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_ACCUMULATORFACTORY
diff --git a/intern/audaspace/FX/AUD_AccumulatorReader.cpp b/intern/audaspace/FX/AUD_AccumulatorReader.cpp
index 67ab4157f9c..a8964edcac7 100644
--- a/intern/audaspace/FX/AUD_AccumulatorReader.cpp
+++ b/intern/audaspace/FX/AUD_AccumulatorReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_AccumulatorReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -33,25 +32,12 @@
 AUD_AccumulatorReader::AUD_AccumulatorReader(AUD_IReader* reader,
 											 bool additive) :
 		AUD_EffectReader(reader),
-		m_additive(additive)
+		m_additive(additive),
+		m_sums(AUD_SAMPLE_SIZE(reader->getSpecs())),
+		m_prevs(AUD_SAMPLE_SIZE(reader->getSpecs()))
 {
-	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_sums = new AUD_Buffer(samplesize); AUD_NEW("buffer")
-	memset(m_sums->getBuffer(), 0, samplesize);
-
-	m_prevs = new AUD_Buffer(samplesize); AUD_NEW("buffer")
-	memset(m_prevs->getBuffer(), 0, samplesize);
-}
-
-AUD_AccumulatorReader::~AUD_AccumulatorReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-	delete m_sums; AUD_DELETE("buffer")
-	delete m_prevs; AUD_DELETE("buffer")
+	memset(m_sums.getBuffer(), 0, m_sums.getSize());
+	memset(m_prevs.getBuffer(), 0, m_prevs.getSize());
 }
 
 void AUD_AccumulatorReader::read(int & length, sample_t* & buffer)
@@ -59,16 +45,16 @@ void AUD_AccumulatorReader::read(int & length, sample_t* & buffer)
 	sample_t* buf;
 	sample_t* sums;
 	sample_t* prevs;
-	sums = m_sums->getBuffer();
-	prevs = m_prevs->getBuffer();
+	sums = m_sums.getBuffer();
+	prevs = m_prevs.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	if(m_additive)
 	{
@@ -87,7 +73,7 @@ void AUD_AccumulatorReader::read(int & length, sample_t* & buffer)
 	{
 		for(int channel = 0; channel < specs.channels; channel++)
 		{
-			for(int i = 0; i < length * specs.channels; i++)
+			for(int i = 0; i < length; i++)
 			{
 				if(buf[i * CC] > prevs[channel])
 					sums[channel] += buf[i * CC] - prevs[channel];
diff --git a/intern/audaspace/FX/AUD_AccumulatorReader.h b/intern/audaspace/FX/AUD_AccumulatorReader.h
index 8ad1dda30f6..68c1360731d 100644
--- a/intern/audaspace/FX/AUD_AccumulatorReader.h
+++ b/intern/audaspace/FX/AUD_AccumulatorReader.h
@@ -27,7 +27,7 @@
 #define AUD_ACCUMULATORREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class represents an accumulator.
@@ -36,39 +36,37 @@ class AUD_AccumulatorReader : public AUD_EffectReader
 {
 private:
 	/**
+	 * Whether the accumulator is additive.
+	 */
+	const bool m_additive;
+
+	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The sums of the specific channels.
 	 */
-	AUD_Buffer *m_sums;
+	AUD_Buffer m_sums;
 
 	/**
 	 * The previous results of the specific channels.
 	 */
-	AUD_Buffer *m_prevs;
+	AUD_Buffer m_prevs;
 
-	/**
-	 * Whether the accumulator is additive.
-	 */
-	bool m_additive;
+	// hide copy constructor and operator=
+	AUD_AccumulatorReader(const AUD_AccumulatorReader&);
+	AUD_AccumulatorReader& operator=(const AUD_AccumulatorReader&);
 
 public:
 	/**
 	 * Creates a new accumulator reader.
 	 * \param reader The reader to read from.
 	 * \param additive Whether the accumulator is additive.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_AccumulatorReader(AUD_IReader* reader, bool additive);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_AccumulatorReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_ButterworthFactory.cpp b/intern/audaspace/FX/AUD_ButterworthFactory.cpp
index fd0a53def7c..1bb1d726a98 100644
--- a/intern/audaspace/FX/AUD_ButterworthFactory.cpp
+++ b/intern/audaspace/FX/AUD_ButterworthFactory.cpp
@@ -29,21 +29,11 @@
 AUD_ButterworthFactory::AUD_ButterworthFactory(AUD_IFactory* factory,
 											   float frequency) :
 		AUD_EffectFactory(factory),
-		m_frequency(frequency) {}
-
-AUD_ButterworthFactory::AUD_ButterworthFactory(float frequency) :
-		AUD_EffectFactory(0),
-		m_frequency(frequency) {}
-
-AUD_IReader* AUD_ButterworthFactory::createReader()
+		m_frequency(frequency)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_ButterworthReader(reader, m_frequency);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_ButterworthFactory::createReader() const
+{
+	return new AUD_ButterworthReader(getReader(), m_frequency);
 }
diff --git a/intern/audaspace/FX/AUD_ButterworthFactory.h b/intern/audaspace/FX/AUD_ButterworthFactory.h
index 69169531d70..30b7a402c57 100644
--- a/intern/audaspace/FX/AUD_ButterworthFactory.h
+++ b/intern/audaspace/FX/AUD_ButterworthFactory.h
@@ -37,7 +37,11 @@ private:
 	/**
 	 * The attack value in seconds.
 	 */
-	float m_frequency;
+	const float m_frequency;
+
+	// hide copy constructor and operator=
+	AUD_ButterworthFactory(const AUD_ButterworthFactory&);
+	AUD_ButterworthFactory& operator=(const AUD_ButterworthFactory&);
 
 public:
 	/**
@@ -47,13 +51,7 @@ public:
 	 */
 	AUD_ButterworthFactory(AUD_IFactory* factory, float frequency);
 
-	/**
-	 * Creates a new butterworth factory.
-	 * \param frequency The cutoff frequency.
-	 */
-	AUD_ButterworthFactory(float frequency);
-
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_BUTTERWORTHFACTORY
diff --git a/intern/audaspace/FX/AUD_ButterworthReader.cpp b/intern/audaspace/FX/AUD_ButterworthReader.cpp
index 2129dfef798..cfe4205c7f8 100644
--- a/intern/audaspace/FX/AUD_ButterworthReader.cpp
+++ b/intern/audaspace/FX/AUD_ButterworthReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_ButterworthReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 #include <cmath>
@@ -39,20 +38,14 @@
 
 AUD_ButterworthReader::AUD_ButterworthReader(AUD_IReader* reader,
 											 float frequency) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_outvalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * 5),
+		m_invalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * 5),
+		m_position(0)
 {
 	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_outvalues = new AUD_Buffer(samplesize * 5); AUD_NEW("buffer")
-	memset(m_outvalues->getBuffer(), 0, samplesize * 5);
-
-	m_invalues = new AUD_Buffer(samplesize * 5); AUD_NEW("buffer")
-	memset(m_invalues->getBuffer(), 0, samplesize * 5);
-
-	m_position = 0;
+	memset(m_outvalues.getBuffer(), 0, m_outvalues.getSize());
+	memset(m_invalues.getBuffer(), 0, m_invalues.getSize());
 
 	// calculate coefficients
 	float omega = 2 * tan(frequency * M_PI / specs.rate);
@@ -74,31 +67,23 @@ AUD_ButterworthReader::AUD_ButterworthReader(AUD_IReader* reader,
 	m_coeff[1][2] = 6 * o4 / norm;
 }
 
-AUD_ButterworthReader::~AUD_ButterworthReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-
-	delete m_outvalues; AUD_DELETE("buffer")
-	delete m_invalues; AUD_DELETE("buffer");
-}
-
 void AUD_ButterworthReader::read(int & length, sample_t* & buffer)
 {
 	sample_t* buf;
 	sample_t* outvalues;
 	sample_t* invalues;
 
-	outvalues = m_outvalues->getBuffer();
-	invalues = m_invalues->getBuffer();
+	outvalues = m_outvalues.getBuffer();
+	invalues = m_invalues.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
 
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	int channels = specs.channels;
 
 	for(int channel = 0; channel < channels; channel++)
diff --git a/intern/audaspace/FX/AUD_ButterworthReader.h b/intern/audaspace/FX/AUD_ButterworthReader.h
index b1cbd4e3820..52cbb642540 100644
--- a/intern/audaspace/FX/AUD_ButterworthReader.h
+++ b/intern/audaspace/FX/AUD_ButterworthReader.h
@@ -27,7 +27,7 @@
 #define AUD_BUTTERWORTHREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class represents a butterworth filter.
@@ -38,17 +38,17 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The last out values buffer.
 	 */
-	AUD_Buffer *m_outvalues;
+	AUD_Buffer m_outvalues;
 
 	/**
 	 * The last in values buffer.
 	 */
-	AUD_Buffer *m_invalues;
+	AUD_Buffer m_invalues;
 
 	/**
 	 * The position for buffer cycling.
@@ -60,6 +60,10 @@ private:
 	 */
 	float m_coeff[2][5];
 
+	// hide copy constructor and operator=
+	AUD_ButterworthReader(const AUD_ButterworthReader&);
+	AUD_ButterworthReader& operator=(const AUD_ButterworthReader&);
+
 public:
 	/**
 	 * Creates a new butterworth reader.
@@ -68,15 +72,9 @@ public:
 	 * \param release The release value in seconds.
 	 * \param threshold The threshold value.
 	 * \param arthreshold The attack/release threshold value.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_ButterworthReader(AUD_IReader* reader, float frequency);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_ButterworthReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_DelayFactory.cpp b/intern/audaspace/FX/AUD_DelayFactory.cpp
index 25ce4faed4c..f98743d6fb7 100644
--- a/intern/audaspace/FX/AUD_DelayFactory.cpp
+++ b/intern/audaspace/FX/AUD_DelayFactory.cpp
@@ -29,30 +29,16 @@
 
 AUD_DelayFactory::AUD_DelayFactory(AUD_IFactory* factory, float delay) :
 		AUD_EffectFactory(factory),
-		m_delay(delay) {}
-
-AUD_DelayFactory::AUD_DelayFactory(float delay) :
-		AUD_EffectFactory(0),
-		m_delay(delay) {}
-
-float AUD_DelayFactory::getDelay()
+		m_delay(delay)
 {
-	return m_delay;
 }
 
-void AUD_DelayFactory::setDelay(float delay)
+float AUD_DelayFactory::getDelay() const
 {
-	m_delay = delay;
+	return m_delay;
 }
 
-AUD_IReader* AUD_DelayFactory::createReader()
+AUD_IReader* AUD_DelayFactory::createReader() const
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_DelayReader(reader, m_delay); AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_DelayReader(getReader(), m_delay);
 }
diff --git a/intern/audaspace/FX/AUD_DelayFactory.h b/intern/audaspace/FX/AUD_DelayFactory.h
index 5ad4b9ab996..721262fb73f 100644
--- a/intern/audaspace/FX/AUD_DelayFactory.h
+++ b/intern/audaspace/FX/AUD_DelayFactory.h
@@ -37,7 +37,11 @@ private:
 	/**
 	 * The delay in samples.
 	 */
-	float m_delay;
+	const float m_delay;
+
+	// hide copy constructor and operator=
+	AUD_DelayFactory(const AUD_DelayFactory&);
+	AUD_DelayFactory& operator=(const AUD_DelayFactory&);
 
 public:
 	/**
@@ -45,26 +49,14 @@ public:
 	 * \param factory The input factory.
 	 * \param delay The desired delay in seconds.
 	 */
-	AUD_DelayFactory(AUD_IFactory* factory = 0, float delay = 0);
-
-	/**
-	 * Creates a new delay factory.
-	 * \param delay The desired delay in seconds.
-	 */
-	AUD_DelayFactory(float delay);
+	AUD_DelayFactory(AUD_IFactory* factory, float delay = 0);
 
 	/**
 	 * Returns the delay in seconds.
 	 */
-	float getDelay();
-
-	/**
-	 * Sets the delay.
-	 * \param delay The new delay value in seconds.
-	 */
-	void setDelay(float delay);
+	float getDelay() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_DELAYFACTORY
diff --git a/intern/audaspace/FX/AUD_DelayReader.cpp b/intern/audaspace/FX/AUD_DelayReader.cpp
index f2521f645aa..e9f0c15b9b4 100644
--- a/intern/audaspace/FX/AUD_DelayReader.cpp
+++ b/intern/audaspace/FX/AUD_DelayReader.cpp
@@ -24,28 +24,19 @@
  */
 
 #include "AUD_DelayReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
 AUD_DelayReader::AUD_DelayReader(AUD_IReader* reader, float delay) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_delay(int(delay * reader->getSpecs().rate)),
+		m_remdelay(int(delay * reader->getSpecs().rate)),
+		m_empty(true)
 {
-	m_delay = (int)(delay * reader->getSpecs().rate);
-	m_remdelay = m_delay;
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_DelayReader::~AUD_DelayReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
 void AUD_DelayReader::seek(int position)
 {
-	if(position < 0)
-		return;
-
 	if(position < m_delay)
 	{
 		m_remdelay = m_delay - position;
@@ -58,18 +49,18 @@ void AUD_DelayReader::seek(int position)
 	}
 }
 
-int AUD_DelayReader::getLength()
+int AUD_DelayReader::getLength() const
 {
 	int len = m_reader->getLength();
 	if(len < 0)
 		return len;
-	return len+m_delay;
+	return len + m_delay;
 }
 
-int AUD_DelayReader::getPosition()
+int AUD_DelayReader::getPosition() const
 {
 	if(m_remdelay > 0)
-		return m_delay-m_remdelay;
+		return m_delay - m_remdelay;
 	return m_reader->getPosition() + m_delay;
 }
 
@@ -80,26 +71,41 @@ void AUD_DelayReader::read(int & length, sample_t* & buffer)
 		AUD_Specs specs = m_reader->getSpecs();
 		int samplesize = AUD_SAMPLE_SIZE(specs);
 
-		if(m_buffer->getSize() < length * samplesize)
-			m_buffer->resize(length * samplesize);
+		if(m_buffer.getSize() < length * samplesize)
+		{
+			m_buffer.resize(length * samplesize);
+			m_empty = false;
+		}
+
+		buffer = m_buffer.getBuffer();
 
 		if(length > m_remdelay)
 		{
-			memset(m_buffer->getBuffer(), 0, m_remdelay * samplesize);
+			if(!m_empty)
+				memset(buffer, 0, m_remdelay * samplesize);
+
 			int len = length - m_remdelay;
-			m_reader->read(len, buffer);
-			memcpy(m_buffer->getBuffer() + m_remdelay * specs.channels,
-				   buffer, len * samplesize);
+			sample_t* buf;
+			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
 		{
-			memset(m_buffer->getBuffer(), 0, length * samplesize);
+			if(!m_empty)
+			{
+				memset(buffer, 0, length * samplesize);
+				m_empty = true;
+			}
 			m_remdelay -= length;
 		}
-		buffer = m_buffer->getBuffer();
 	}
 	else
 		m_reader->read(length, buffer);
diff --git a/intern/audaspace/FX/AUD_DelayReader.h b/intern/audaspace/FX/AUD_DelayReader.h
index 4662b455dfc..121842b0c6b 100644
--- a/intern/audaspace/FX/AUD_DelayReader.h
+++ b/intern/audaspace/FX/AUD_DelayReader.h
@@ -27,7 +27,7 @@
 #define AUD_DELAYREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class reads another reader and changes it's delay.
@@ -38,35 +38,38 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The delay level.
 	 */
-	int m_delay;
+	const int m_delay;
 
 	/**
 	 * The remaining delay for playback.
 	 */
 	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&);
+
 public:
 	/**
 	 * Creates a new delay reader.
 	 * \param reader The reader to read from.
 	 * \param delay The delay in seconds.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_DelayReader(AUD_IReader* reader, float delay);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_DelayReader();
-
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
+	virtual int getLength() const;
+	virtual int getPosition() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_DoubleFactory.cpp b/intern/audaspace/FX/AUD_DoubleFactory.cpp
index 402d884be9f..9f625d0763f 100644
--- a/intern/audaspace/FX/AUD_DoubleFactory.cpp
+++ b/intern/audaspace/FX/AUD_DoubleFactory.cpp
@@ -27,29 +27,24 @@
 #include "AUD_DoubleReader.h"
 
 AUD_DoubleFactory::AUD_DoubleFactory(AUD_IFactory* factory1, AUD_IFactory* factory2) :
-		m_factory1(factory1), m_factory2(factory2) {}
+		m_factory1(factory1), m_factory2(factory2)
+{
+}
 
-AUD_IReader* AUD_DoubleFactory::createReader()
+AUD_IReader* AUD_DoubleFactory::createReader() const
 {
 	AUD_IReader* reader1 = m_factory1->createReader();
-	if(!reader1)
-		return 0;
 	AUD_IReader* reader2;
+
 	try
 	{
 		reader2 = m_factory2->createReader();
-		if(!reader2)
-		{
-			delete reader1; AUD_DELETE("reader")
-			return 0;
-		}
 	}
 	catch(AUD_Exception&)
 	{
-		delete reader1; AUD_DELETE("reader")
+		delete reader1;
 		throw;
 	}
 
-	AUD_IReader* reader = new AUD_DoubleReader(reader1, reader2);
-	return reader;
+	return new AUD_DoubleReader(reader1, reader2);
 }
diff --git a/intern/audaspace/FX/AUD_DoubleFactory.h b/intern/audaspace/FX/AUD_DoubleFactory.h
index 03c7de19f06..f2e83b2e27a 100644
--- a/intern/audaspace/FX/AUD_DoubleFactory.h
+++ b/intern/audaspace/FX/AUD_DoubleFactory.h
@@ -45,6 +45,10 @@ private:
 	 */
 	AUD_IFactory* m_factory2;
 
+	// hide copy constructor and operator=
+	AUD_DoubleFactory(const AUD_DoubleFactory&);
+	AUD_DoubleFactory& operator=(const AUD_DoubleFactory&);
+
 public:
 	/**
 	 * Creates a new double factory.
@@ -53,7 +57,7 @@ public:
 	 */
 	AUD_DoubleFactory(AUD_IFactory* factory1, AUD_IFactory* factory2);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_DOUBLEFACTORY
diff --git a/intern/audaspace/FX/AUD_DoubleReader.cpp b/intern/audaspace/FX/AUD_DoubleReader.cpp
index 1e51a094427..6b39e01270f 100644
--- a/intern/audaspace/FX/AUD_DoubleReader.cpp
+++ b/intern/audaspace/FX/AUD_DoubleReader.cpp
@@ -24,80 +24,48 @@
  */
 
 #include "AUD_DoubleReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
 AUD_DoubleReader::AUD_DoubleReader(AUD_IReader* reader1,
 								   AUD_IReader* reader2) :
-		m_reader1(reader1), m_reader2(reader2)
+		m_reader1(reader1), m_reader2(reader2), m_finished1(false)
 {
-	try
+	AUD_Specs s1, s2;
+	s1 = reader1->getSpecs();
+	s2 = reader2->getSpecs();
+	if(memcmp(&s1, &s2, sizeof(AUD_Specs)) != 0)
 	{
-		if(!reader1)
-			AUD_THROW(AUD_ERROR_READER);
-
-		if(!reader2)
-			AUD_THROW(AUD_ERROR_READER);
-
-		AUD_Specs s1, s2;
-		s1 = reader1->getSpecs();
-		s2 = reader2->getSpecs();
-		if(memcmp(&s1, &s2, sizeof(AUD_Specs)) != 0)
-			AUD_THROW(AUD_ERROR_READER);
-	}
-
-	catch(AUD_Exception)
-	{
-		if(reader1)
-		{
-			delete reader1; AUD_DELETE("reader")
-		}
-		if(reader2)
-		{
-			delete reader2; AUD_DELETE("reader")
-		}
-
-		throw;
+		delete reader1;
+		delete reader2;
+		AUD_THROW(AUD_ERROR_READER);
 	}
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-	m_finished1 = false;
 }
 
 AUD_DoubleReader::~AUD_DoubleReader()
 {
-	delete m_reader1; AUD_DELETE("reader")
-	delete m_reader2; AUD_DELETE("reader")
-	delete m_buffer; AUD_DELETE("buffer")
+	delete m_reader1;
+	delete m_reader2;
 }
 
-bool AUD_DoubleReader::isSeekable()
+bool AUD_DoubleReader::isSeekable() const
 {
-	return false;
+	return m_reader1->isSeekable() && m_reader2->isSeekable();
 }
 
 void AUD_DoubleReader::seek(int position)
 {
-	int length1 = m_reader1->getLength();
+	m_reader1->seek(position);
 
-	if(position < 0)
-		position = 0;
+	int pos1 = m_reader1->getPosition();
 
-	if(position < length1)
-	{
-		m_reader1->seek(position);
-		m_reader2->seek(0);
-		m_finished1 = false;
-	}
+	if((m_finished1 = (pos1 < position)))
+		m_reader2->seek(position - pos1);
 	else
-	{
-		m_reader2->seek(position-length1);
-		m_finished1 = true;
-	}
+		m_reader2->seek(0);
 }
 
-int AUD_DoubleReader::getLength()
+int AUD_DoubleReader::getLength() const
 {
 	int len1 = m_reader1->getLength();
 	int len2 = m_reader2->getLength();
@@ -106,49 +74,45 @@ int AUD_DoubleReader::getLength()
 	return len1 + len2;
 }
 
-int AUD_DoubleReader::getPosition()
+int AUD_DoubleReader::getPosition() const
 {
 	return m_reader1->getPosition() + m_reader2->getPosition();
 }
 
-AUD_Specs AUD_DoubleReader::getSpecs()
+AUD_Specs AUD_DoubleReader::getSpecs() const
 {
 	return m_reader1->getSpecs();
 }
 
-AUD_ReaderType AUD_DoubleReader::getType()
-{
-	if(m_reader1->getType() == AUD_TYPE_BUFFER &&
-	   m_reader2->getType() == AUD_TYPE_BUFFER)
-		return AUD_TYPE_BUFFER;
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_DoubleReader::notify(AUD_Message &message)
-{
-	return m_reader1->notify(message) | m_reader2->notify(message);
-}
-
 void AUD_DoubleReader::read(int & length, sample_t* & buffer)
 {
 	if(!m_finished1)
 	{
 		int len = length;
 		m_reader1->read(len, buffer);
+
 		if(len < length)
 		{
 			AUD_Specs specs = m_reader1->getSpecs();
 			int samplesize = AUD_SAMPLE_SIZE(specs);
-			if(m_buffer->getSize() < length * samplesize)
-				m_buffer->resize(length * samplesize);
-			memcpy(m_buffer->getBuffer(), buffer, len * samplesize);
+
+			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, buffer);
-			memcpy(m_buffer->getBuffer() + length * specs.channels, buffer,
+			m_reader2->read(len, buf);
+
+			memcpy(buffer + length * specs.channels, buf,
 				   len * samplesize);
+
 			length += len;
-			buffer = m_buffer->getBuffer();
+
 			m_finished1 = true;
 		}
 	}
diff --git a/intern/audaspace/FX/AUD_DoubleReader.h b/intern/audaspace/FX/AUD_DoubleReader.h
index d82b81ec0ba..d80ba33dfe3 100644
--- a/intern/audaspace/FX/AUD_DoubleReader.h
+++ b/intern/audaspace/FX/AUD_DoubleReader.h
@@ -27,7 +27,7 @@
 #define AUD_DOUBLEREADER
 
 #include "AUD_IReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This reader plays two readers with the same specs sequently.
@@ -53,15 +53,18 @@ private:
 	/**
 	 * The playback buffer for the intersecting part.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
+
+	// hide copy constructor and operator=
+	AUD_DoubleReader(const AUD_DoubleReader&);
+	AUD_DoubleReader& operator=(const AUD_DoubleReader&);
 
 public:
 	/**
 	 * Creates a new ping pong reader.
 	 * \param reader1 The first reader to read from.
 	 * \param reader2 The second reader to read from.
-	 * \exception AUD_Exception Thrown if one of the reader specified is NULL
-	 *             or the specs from the readers differ.
+	 * \exception AUD_Exception Thrown if the specs from the readers differ.
 	 */
 	AUD_DoubleReader(AUD_IReader* reader1, AUD_IReader* reader2);
 
@@ -70,13 +73,11 @@ public:
 	 */
 	virtual ~AUD_DoubleReader();
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_EffectFactory.cpp b/intern/audaspace/FX/AUD_EffectFactory.cpp
index 882499416b7..eda4e4e04b2 100644
--- a/intern/audaspace/FX/AUD_EffectFactory.cpp
+++ b/intern/audaspace/FX/AUD_EffectFactory.cpp
@@ -26,25 +26,16 @@
 #include "AUD_EffectFactory.h"
 #include "AUD_IReader.h"
 
-AUD_IReader* AUD_EffectFactory::getReader()
-{
-	if(m_factory != 0)
-		return m_factory->createReader();
-
-	return 0;
-}
-
 AUD_EffectFactory::AUD_EffectFactory(AUD_IFactory* factory)
 {
 	m_factory = factory;
 }
 
-void AUD_EffectFactory::setFactory(AUD_IFactory* factory)
+AUD_EffectFactory::~AUD_EffectFactory()
 {
-	m_factory = factory;
 }
 
-AUD_IFactory* AUD_EffectFactory::getFactory()
+AUD_IFactory* AUD_EffectFactory::getFactory() const
 {
 	return m_factory;
 }
diff --git a/intern/audaspace/FX/AUD_EffectFactory.h b/intern/audaspace/FX/AUD_EffectFactory.h
index 67259b9e6c3..fd3746d0da3 100644
--- a/intern/audaspace/FX/AUD_EffectFactory.h
+++ b/intern/audaspace/FX/AUD_EffectFactory.h
@@ -34,6 +34,11 @@
  */
 class AUD_EffectFactory : public AUD_IFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_EffectFactory(const AUD_EffectFactory&);
+	AUD_EffectFactory& operator=(const AUD_EffectFactory&);
+
 protected:
 	/**
 	 * If there is no reader it is created out of this factory.
@@ -44,9 +49,12 @@ protected:
 	 * Returns the reader created out of the factory.
 	 * This method can be used for the createReader function of the implementing
 	 * classes.
-	 * \return The reader created out of the factory or NULL if there is none.
+	 * \return The reader created out of the factory.
 	 */
-	AUD_IReader* getReader();
+	inline AUD_IReader* getReader() const
+	{
+		return m_factory->createReader();
+	}
 
 public:
 	/**
@@ -58,19 +66,13 @@ public:
 	/**
 	 * Destroys the factory.
 	 */
-	virtual ~AUD_EffectFactory() {}
-
-	/**
-	 * Sets the input factory.
-	 * \param factory The input factory.
-	 */
-	void setFactory(AUD_IFactory* factory);
+	virtual ~AUD_EffectFactory();
 
 	/**
 	 * Returns the saved factory.
 	 * \return The factory or NULL if there has no factory been saved.
 	 */
-	AUD_IFactory* getFactory();
+	AUD_IFactory* getFactory() const;
 };
 
 #endif //AUD_EFFECTFACTORY
diff --git a/intern/audaspace/FX/AUD_EffectReader.cpp b/intern/audaspace/FX/AUD_EffectReader.cpp
index 47026b88440..b54ca279088 100644
--- a/intern/audaspace/FX/AUD_EffectReader.cpp
+++ b/intern/audaspace/FX/AUD_EffectReader.cpp
@@ -27,17 +27,15 @@
 
 AUD_EffectReader::AUD_EffectReader(AUD_IReader* reader)
 {
-	if(!reader)
-		AUD_THROW(AUD_ERROR_READER);
 	m_reader = reader;
 }
 
 AUD_EffectReader::~AUD_EffectReader()
 {
-	delete m_reader; AUD_DELETE("reader")
+	delete m_reader;
 }
 
-bool AUD_EffectReader::isSeekable()
+bool AUD_EffectReader::isSeekable() const
 {
 	return m_reader->isSeekable();
 }
@@ -47,31 +45,21 @@ void AUD_EffectReader::seek(int position)
 	m_reader->seek(position);
 }
 
-int AUD_EffectReader::getLength()
+int AUD_EffectReader::getLength() const
 {
 	return m_reader->getLength();
 }
 
-int AUD_EffectReader::getPosition()
+int AUD_EffectReader::getPosition() const
 {
 	return m_reader->getPosition();
 }
 
-AUD_Specs AUD_EffectReader::getSpecs()
+AUD_Specs AUD_EffectReader::getSpecs() const
 {
 	return m_reader->getSpecs();
 }
 
-AUD_ReaderType AUD_EffectReader::getType()
-{
-	return m_reader->getType();
-}
-
-bool AUD_EffectReader::notify(AUD_Message &message)
-{
-	return m_reader->notify(message);
-}
-
 void AUD_EffectReader::read(int & length, sample_t* & buffer)
 {
 	m_reader->read(length, buffer);
diff --git a/intern/audaspace/FX/AUD_EffectReader.h b/intern/audaspace/FX/AUD_EffectReader.h
index f64bf34077d..c447f79bc6e 100644
--- a/intern/audaspace/FX/AUD_EffectReader.h
+++ b/intern/audaspace/FX/AUD_EffectReader.h
@@ -34,6 +34,11 @@
  */
 class AUD_EffectReader : public AUD_IReader
 {
+private:
+	// hide copy constructor and operator=
+	AUD_EffectReader(const AUD_EffectReader&);
+	AUD_EffectReader& operator=(const AUD_EffectReader&);
+
 protected:
 	/**
 	 * The reader to read from.
@@ -44,7 +49,6 @@ public:
 	/**
 	 * Creates a new effect reader.
 	 * \param reader The reader to read from.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_EffectReader(AUD_IReader* reader);
 
@@ -53,13 +57,11 @@ public:
 	 */
 	virtual ~AUD_EffectReader();
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_EnvelopeFactory.cpp b/intern/audaspace/FX/AUD_EnvelopeFactory.cpp
index c3b2c3f24fe..1c625067f1c 100644
--- a/intern/audaspace/FX/AUD_EnvelopeFactory.cpp
+++ b/intern/audaspace/FX/AUD_EnvelopeFactory.cpp
@@ -33,26 +33,12 @@ AUD_EnvelopeFactory::AUD_EnvelopeFactory(AUD_IFactory* factory, float attack,
 		m_attack(attack),
 		m_release(release),
 		m_threshold(threshold),
-		m_arthreshold(arthreshold) {}
-
-AUD_EnvelopeFactory::AUD_EnvelopeFactory(float attack, float release,
-										 float threshold, float arthreshold) :
-		AUD_EffectFactory(0),
-		m_attack(attack),
-		m_release(release),
-		m_threshold(threshold),
-		m_arthreshold(arthreshold) {}
-
-AUD_IReader* AUD_EnvelopeFactory::createReader()
+		m_arthreshold(arthreshold)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_EnvelopeReader(reader, m_attack, m_release,
-										m_threshold, m_arthreshold);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_EnvelopeFactory::createReader() const
+{
+	return new AUD_EnvelopeReader(getReader(), m_attack, m_release, m_threshold,
+								  m_arthreshold);
 }
diff --git a/intern/audaspace/FX/AUD_EnvelopeFactory.h b/intern/audaspace/FX/AUD_EnvelopeFactory.h
index c79e5472e30..c31c6727d03 100644
--- a/intern/audaspace/FX/AUD_EnvelopeFactory.h
+++ b/intern/audaspace/FX/AUD_EnvelopeFactory.h
@@ -37,22 +37,26 @@ private:
 	/**
 	 * The attack value in seconds.
 	 */
-	float m_attack;
+	const float m_attack;
 
 	/**
 	 * The release value in seconds.
 	 */
-	float m_release;
+	const float m_release;
 
 	/**
 	 * The threshold value.
 	 */
-	float m_threshold;
+	const float m_threshold;
 
 	/**
 	 * The attack/release threshold value.
 	 */
-	float m_arthreshold;
+	const float m_arthreshold;
+
+	// hide copy constructor and operator=
+	AUD_EnvelopeFactory(const AUD_EnvelopeFactory&);
+	AUD_EnvelopeFactory& operator=(const AUD_EnvelopeFactory&);
 
 public:
 	/**
@@ -66,17 +70,7 @@ public:
 	AUD_EnvelopeFactory(AUD_IFactory* factory, float attack, float release,
 						float threshold, float arthreshold);
 
-	/**
-	 * Creates a new envelope factory.
-	 * \param attack The attack value in seconds.
-	 * \param release The release value in seconds.
-	 * \param threshold The threshold value.
-	 * \param arthreshold The attack/release threshold value.
-	 */
-	AUD_EnvelopeFactory(float attack, float release, float threshold,
-						float arthreshold);
-
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_ENVELOPEFACTORY
diff --git a/intern/audaspace/FX/AUD_EnvelopeReader.cpp b/intern/audaspace/FX/AUD_EnvelopeReader.cpp
index 71ccbfd6503..ef64b6fa4eb 100644
--- a/intern/audaspace/FX/AUD_EnvelopeReader.cpp
+++ b/intern/audaspace/FX/AUD_EnvelopeReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_EnvelopeReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 #include <cmath>
@@ -33,40 +32,27 @@ AUD_EnvelopeReader::AUD_EnvelopeReader(AUD_IReader* reader, float attack,
 									   float release, float threshold,
 									   float arthreshold) :
 		AUD_EffectReader(reader),
-		m_threshold(threshold)
+		m_bAttack(pow(arthreshold, 1.0f/(reader->getSpecs().rate * attack))),
+		m_bRelease(pow(arthreshold, 1.0f/(reader->getSpecs().rate * release))),
+		m_threshold(threshold),
+		m_envelopes(AUD_SAMPLE_SIZE(reader->getSpecs()))
 {
-	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_envelopes = new AUD_Buffer(samplesize);
-	AUD_NEW("buffer")
-	memset(m_envelopes->getBuffer(), 0, samplesize);
-
-	m_bAttack = pow(arthreshold, 1.0f/(specs.rate * attack));
-	m_bRelease = pow(arthreshold, 1.0f/(specs.rate * release));
-}
-
-AUD_EnvelopeReader::~AUD_EnvelopeReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-	delete m_envelopes; AUD_DELETE("buffer")
+	memset(m_envelopes.getBuffer(), 0, m_envelopes.getSize());
 }
 
 void AUD_EnvelopeReader::read(int & length, sample_t* & buffer)
 {
 	sample_t* buf;
 	sample_t* envelopes;
-	envelopes = m_envelopes->getBuffer();
+	envelopes = m_envelopes.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	sample_t value;
 
diff --git a/intern/audaspace/FX/AUD_EnvelopeReader.h b/intern/audaspace/FX/AUD_EnvelopeReader.h
index ff9dd23d34c..b452ee2119a 100644
--- a/intern/audaspace/FX/AUD_EnvelopeReader.h
+++ b/intern/audaspace/FX/AUD_EnvelopeReader.h
@@ -27,7 +27,7 @@
 #define AUD_ENVELOPEREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class represents an envelope follower.
@@ -36,29 +36,33 @@ class AUD_EnvelopeReader : public AUD_EffectReader
 {
 private:
 	/**
-	 * The playback buffer.
+	 * Attack b value.
 	 */
-	AUD_Buffer *m_buffer;
+	const float m_bAttack;
 
 	/**
-	 * The last envelopes buffer.
+	 * Release b value.
 	 */
-	AUD_Buffer *m_envelopes;
+	const float m_bRelease;
 
 	/**
-	 * Attack b value.
+	 * Threshold value.
 	 */
-	float m_bAttack;
+	const float m_threshold;
 
 	/**
-	 * Release b value.
+	 * The playback buffer.
 	 */
-	float m_bRelease;
+	AUD_Buffer m_buffer;
 
 	/**
-	 * Threshold value.
+	 * The last envelopes buffer.
 	 */
-	float m_threshold;
+	AUD_Buffer m_envelopes;
+
+	// hide copy constructor and operator=
+	AUD_EnvelopeReader(const AUD_EnvelopeReader&);
+	AUD_EnvelopeReader& operator=(const AUD_EnvelopeReader&);
 
 public:
 	/**
@@ -68,16 +72,10 @@ public:
 	 * \param release The release value in seconds.
 	 * \param threshold The threshold value.
 	 * \param arthreshold The attack/release threshold value.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_EnvelopeReader(AUD_IReader* reader, float attack, float release,
 					   float threshold, float arthreshold);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_EnvelopeReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_FaderFactory.cpp b/intern/audaspace/FX/AUD_FaderFactory.cpp
index 4357e11bd43..bbe9319c928 100644
--- a/intern/audaspace/FX/AUD_FaderFactory.cpp
+++ b/intern/audaspace/FX/AUD_FaderFactory.cpp
@@ -31,54 +31,26 @@ AUD_FaderFactory::AUD_FaderFactory(AUD_IFactory* factory, AUD_FadeType type,
 		AUD_EffectFactory(factory),
 		m_type(type),
 		m_start(start),
-		m_length(length) {}
-
-AUD_FaderFactory::AUD_FaderFactory(AUD_FadeType type,
-								   float start, float length) :
-		AUD_EffectFactory(0),
-		m_type(type),
-		m_start(start),
-		m_length(length) {}
-
-AUD_FadeType AUD_FaderFactory::getType()
+		m_length(length)
 {
-	return m_type;
 }
 
-void AUD_FaderFactory::setType(AUD_FadeType type)
+AUD_FadeType AUD_FaderFactory::getType() const
 {
-	m_type = type;
+	return m_type;
 }
 
-float AUD_FaderFactory::getStart()
+float AUD_FaderFactory::getStart() const
 {
 	return m_start;
 }
 
-void AUD_FaderFactory::setStart(float start)
-{
-	m_start = start;
-}
-
-float AUD_FaderFactory::getLength()
+float AUD_FaderFactory::getLength() const
 {
 	return m_length;
 }
 
-void AUD_FaderFactory::setLength(float length)
+AUD_IReader* AUD_FaderFactory::createReader() const
 {
-	m_length = length;
-}
-
-AUD_IReader* AUD_FaderFactory::createReader()
-{
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_FaderReader(reader, m_type, m_start, m_length);
-		AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_FaderReader(getReader(), m_type, m_start, m_length);
 }
diff --git a/intern/audaspace/FX/AUD_FaderFactory.h b/intern/audaspace/FX/AUD_FaderFactory.h
index 4999ccac8f1..af5d18538ea 100644
--- a/intern/audaspace/FX/AUD_FaderFactory.h
+++ b/intern/audaspace/FX/AUD_FaderFactory.h
@@ -39,17 +39,21 @@ private:
 	/**
 	 * The fading type.
 	 */
-	AUD_FadeType m_type;
+	const AUD_FadeType m_type;
 
 	/**
 	 * The fading start.
 	 */
-	float m_start;
+	const float m_start;
 
 	/**
 	 * The fading length.
 	 */
-	float m_length;
+	const float m_length;
+
+	// hide copy constructor and operator=
+	AUD_FaderFactory(const AUD_FaderFactory&);
+	AUD_FaderFactory& operator=(const AUD_FaderFactory&);
 
 public:
 	/**
@@ -59,53 +63,26 @@ public:
 	 * \param start The time where fading should start in seconds.
 	 * \param length How long fading should last in seconds.
 	 */
-	AUD_FaderFactory(AUD_IFactory* factory = 0,
+	AUD_FaderFactory(AUD_IFactory* factory,
 					  AUD_FadeType type = AUD_FADE_IN,
 					  float start = 0.0f, float length = 1.0f);
 
 	/**
-	 * Creates a new fader factory.
-	 * \param type The fading type.
-	 * \param start The time where fading should start in seconds.
-	 * \param length How long fading should last in seconds.
-	 */
-	AUD_FaderFactory(AUD_FadeType type = AUD_FADE_IN,
-					  float start = 0.0f, float length = 1.0f);
-
-	/**
 	 * Returns the fading type.
 	 */
-	AUD_FadeType getType();
-
-	/**
-	 * Sets the fading type.
-	 * \param type The new fading type: AUD_FADE_IN or AUD_FADE_OUT.
-	 */
-	void setType(AUD_FadeType type);
+	AUD_FadeType getType() const;
 
 	/**
 	 * Returns the fading start.
 	 */
-	float getStart();
-
-	/**
-	 * Sets the fading start.
-	 * \param start The new fading start.
-	 */
-	void setStart(float start);
+	float getStart() const;
 
 	/**
 	 * Returns the fading length.
 	 */
-	float getLength();
-
-	/**
-	 * Sets the fading length.
-	 * \param start The new fading length.
-	 */
-	void setLength(float length);
+	float getLength() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_FADERFACTORY
diff --git a/intern/audaspace/FX/AUD_FaderReader.cpp b/intern/audaspace/FX/AUD_FaderReader.cpp
index 4e919fff323..2292fa06102 100644
--- a/intern/audaspace/FX/AUD_FaderReader.cpp
+++ b/intern/audaspace/FX/AUD_FaderReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_FaderReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -33,19 +32,9 @@ AUD_FaderReader::AUD_FaderReader(AUD_IReader* reader, AUD_FadeType type,
 		AUD_EffectReader(reader),
 		m_type(type),
 		m_start(start),
-		m_length(length)
+		m_length(length),
+		m_empty(true)
 {
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_FaderReader::~AUD_FaderReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-}
-
-bool AUD_FaderReader::notify(AUD_Message &message)
-{
-	return m_reader->notify(message);
 }
 
 void AUD_FaderReader::read(int & length, sample_t* & buffer)
@@ -56,28 +45,50 @@ void AUD_FaderReader::read(int & length, sample_t* & buffer)
 
 	m_reader->read(length, buffer);
 
-	if(m_buffer->getSize() < length * samplesize)
-		m_buffer->resize(length * samplesize);
-
 	if((position + length) / (float)specs.rate <= m_start)
 	{
 		if(m_type != AUD_FADE_OUT)
 		{
-			buffer = m_buffer->getBuffer();
-			memset(buffer, 0, length * samplesize);
+			if(m_buffer.getSize() < 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)
 		{
-			buffer = m_buffer->getBuffer();
-			memset(buffer, 0, length * samplesize);
+			if(m_buffer.getSize() < 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
 	{
-		sample_t* buf = m_buffer->getBuffer();
+		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++)
@@ -98,5 +109,6 @@ void AUD_FaderReader::read(int & length, sample_t* & buffer)
 		}
 
 		buffer = buf;
+		m_empty = false;
 	}
 }
diff --git a/intern/audaspace/FX/AUD_FaderReader.h b/intern/audaspace/FX/AUD_FaderReader.h
index a75ac6e7a47..d9d685af956 100644
--- a/intern/audaspace/FX/AUD_FaderReader.h
+++ b/intern/audaspace/FX/AUD_FaderReader.h
@@ -27,7 +27,7 @@
 #define AUD_FADERREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class fades another reader.
@@ -38,24 +38,33 @@ class AUD_FaderReader : public AUD_EffectReader
 {
 private:
 	/**
-	 * The playback buffer.
-	 */
-	AUD_Buffer *m_buffer;
-
-	/**
 	 * The fading type.
 	 */
-	AUD_FadeType m_type;
+	const AUD_FadeType m_type;
 
 	/**
 	 * The fading start.
 	 */
-	float m_start;
+	const float m_start;
 
 	/**
 	 * The fading length.
 	 */
-	float m_length;
+	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&);
 
 public:
 	/**
@@ -63,17 +72,10 @@ public:
 	 * \param type The fading type.
 	 * \param start The time where fading should start in seconds.
 	 * \param length How long fading should last in seconds.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_FaderReader(AUD_IReader* reader, AUD_FadeType type,
 					float start,float length);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_FaderReader();
-
-	virtual bool notify(AUD_Message &message);
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_HighpassFactory.cpp b/intern/audaspace/FX/AUD_HighpassFactory.cpp
index 384d36beab7..1ab5237c8ff 100644
--- a/intern/audaspace/FX/AUD_HighpassFactory.cpp
+++ b/intern/audaspace/FX/AUD_HighpassFactory.cpp
@@ -30,22 +30,11 @@ AUD_HighpassFactory::AUD_HighpassFactory(AUD_IFactory* factory, float frequency,
 										 float Q) :
 		AUD_EffectFactory(factory),
 		m_frequency(frequency),
-		m_Q(Q) {}
-
-AUD_HighpassFactory::AUD_HighpassFactory(float frequency, float Q) :
-		AUD_EffectFactory(0),
-		m_frequency(frequency),
-		m_Q(Q) {}
-
-AUD_IReader* AUD_HighpassFactory::createReader()
+		m_Q(Q)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_HighpassReader(reader, m_frequency, m_Q);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_HighpassFactory::createReader() const
+{
+	return new AUD_HighpassReader(getReader(), m_frequency, m_Q);
 }
diff --git a/intern/audaspace/FX/AUD_HighpassFactory.h b/intern/audaspace/FX/AUD_HighpassFactory.h
index 5e31053ed6c..1220157a776 100644
--- a/intern/audaspace/FX/AUD_HighpassFactory.h
+++ b/intern/audaspace/FX/AUD_HighpassFactory.h
@@ -37,12 +37,16 @@ private:
 	/**
 	 * The attack value in seconds.
 	 */
-	float m_frequency;
+	const float m_frequency;
 
 	/**
 	 * The Q factor.
 	 */
-	float m_Q;
+	const float m_Q;
+
+	// hide copy constructor and operator=
+	AUD_HighpassFactory(const AUD_HighpassFactory&);
+	AUD_HighpassFactory& operator=(const AUD_HighpassFactory&);
 
 public:
 	/**
@@ -53,14 +57,7 @@ public:
 	 */
 	AUD_HighpassFactory(AUD_IFactory* factory, float frequency, float Q = 1.0f);
 
-	/**
-	 * Creates a new highpass factory.
-	 * \param frequency The cutoff frequency.
-	 * \param Q The Q factor.
-	 */
-	AUD_HighpassFactory(float frequency, float Q = 1.0f);
-
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_HIGHPASSFACTORY
diff --git a/intern/audaspace/FX/AUD_HighpassReader.cpp b/intern/audaspace/FX/AUD_HighpassReader.cpp
index 36b1bb8082e..904d6a95867 100644
--- a/intern/audaspace/FX/AUD_HighpassReader.cpp
+++ b/intern/audaspace/FX/AUD_HighpassReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_HighpassReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 #include <cmath>
@@ -37,22 +36,15 @@
 
 AUD_HighpassReader::AUD_HighpassReader(AUD_IReader* reader, float frequency,
 									   float Q) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_outvalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * AUD_HIGHPASS_ORDER),
+		m_invalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * AUD_HIGHPASS_ORDER),
+		m_position(0)
 {
-	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_outvalues = new AUD_Buffer(samplesize * AUD_HIGHPASS_ORDER);
-	AUD_NEW("buffer")
-	memset(m_outvalues->getBuffer(), 0, samplesize * AUD_HIGHPASS_ORDER);
+	memset(m_outvalues.getBuffer(), 0, m_outvalues.getSize());
+	memset(m_invalues.getBuffer(), 0, m_invalues.getSize());
 
-	m_invalues = new AUD_Buffer(samplesize * AUD_HIGHPASS_ORDER);
-	AUD_NEW("buffer")
-	memset(m_invalues->getBuffer(), 0, samplesize * AUD_HIGHPASS_ORDER);
-
-	m_position = 0;
+	AUD_Specs specs = reader->getSpecs();
 
 	// calculate coefficients
 	float w0 = 2 * M_PI * frequency / specs.rate;
@@ -65,31 +57,23 @@ AUD_HighpassReader::AUD_HighpassReader(AUD_IReader* reader, float frequency,
 	m_coeff[1][1] = (-1 - cos(w0)) / norm;
 }
 
-AUD_HighpassReader::~AUD_HighpassReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-
-	delete m_outvalues; AUD_DELETE("buffer")
-	delete m_invalues; AUD_DELETE("buffer");
-}
-
 void AUD_HighpassReader::read(int & length, sample_t* & buffer)
 {
 	sample_t* buf;
 	sample_t* outvalues;
 	sample_t* invalues;
 
-	outvalues = m_outvalues->getBuffer();
-	invalues = m_invalues->getBuffer();
+	outvalues = m_outvalues.getBuffer();
+	invalues = m_invalues.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
 
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	int channels = specs.channels;
 
 	for(int channel = 0; channel < channels; channel++)
diff --git a/intern/audaspace/FX/AUD_HighpassReader.h b/intern/audaspace/FX/AUD_HighpassReader.h
index dc28a62e45b..845e764ac9f 100644
--- a/intern/audaspace/FX/AUD_HighpassReader.h
+++ b/intern/audaspace/FX/AUD_HighpassReader.h
@@ -27,7 +27,7 @@
 #define AUD_HIGHPASSREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 #define AUD_HIGHPASS_ORDER 3
 
@@ -40,17 +40,17 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The last out values buffer.
 	 */
-	AUD_Buffer *m_outvalues;
+	AUD_Buffer m_outvalues;
 
 	/**
 	 * The last in values buffer.
 	 */
-	AUD_Buffer *m_invalues;
+	AUD_Buffer m_invalues;
 
 	/**
 	 * The position for buffer cycling.
@@ -62,21 +62,19 @@ private:
 	 */
 	float m_coeff[2][AUD_HIGHPASS_ORDER];
 
+	// hide copy constructor and operator=
+	AUD_HighpassReader(const AUD_HighpassReader&);
+	AUD_HighpassReader& operator=(const AUD_HighpassReader&);
+
 public:
 	/**
 	 * Creates a new highpass reader.
 	 * \param reader The reader to read from.
 	 * \param frequency The cutoff frequency.
 	 * \param Q The Q factor.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_HighpassReader(AUD_IReader* reader, float frequency, float Q);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_HighpassReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_LimiterFactory.cpp b/intern/audaspace/FX/AUD_LimiterFactory.cpp
index 6f19575240a..75501afcec3 100644
--- a/intern/audaspace/FX/AUD_LimiterFactory.cpp
+++ b/intern/audaspace/FX/AUD_LimiterFactory.cpp
@@ -31,37 +31,21 @@ AUD_LimiterFactory::AUD_LimiterFactory(AUD_IFactory* factory,
 									   float start, float end) :
 		AUD_EffectFactory(factory),
 		m_start(start),
-		m_end(end) {}
-
-float AUD_LimiterFactory::getStart()
+		m_end(end)
 {
-	return m_start;
 }
 
-void AUD_LimiterFactory::setStart(float start)
+float AUD_LimiterFactory::getStart() const
 {
-	m_start = start;
+	return m_start;
 }
 
-float AUD_LimiterFactory::getEnd()
+float AUD_LimiterFactory::getEnd() const
 {
 	return m_end;
 }
 
-void AUD_LimiterFactory::setEnd(float end)
-{
-	m_end = end;
-}
-
-AUD_IReader* AUD_LimiterFactory::createReader()
+AUD_IReader* AUD_LimiterFactory::createReader() const
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_LimiterReader(reader, m_start, m_end);
-		AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_LimiterReader(getReader(), m_start, m_end);
 }
diff --git a/intern/audaspace/FX/AUD_LimiterFactory.h b/intern/audaspace/FX/AUD_LimiterFactory.h
index 588fea6eb4b..5d9491f60aa 100644
--- a/intern/audaspace/FX/AUD_LimiterFactory.h
+++ b/intern/audaspace/FX/AUD_LimiterFactory.h
@@ -37,12 +37,16 @@ private:
 	/**
 	 * The start time.
 	 */
-	float m_start;
+	const float m_start;
 
 	/**
 	 * The end time.
 	 */
-	float m_end;
+	const float m_end;
+
+	// hide copy constructor and operator=
+	AUD_LimiterFactory(const AUD_LimiterFactory&);
+	AUD_LimiterFactory& operator=(const AUD_LimiterFactory&);
 
 public:
 	/**
@@ -52,33 +56,20 @@ public:
 	 * \param end The desired end time, a negative value signals that it should
 	 *            play to the end.
 	 */
-	AUD_LimiterFactory(AUD_IFactory* factory = 0,
+	AUD_LimiterFactory(AUD_IFactory* factory,
 					   float start = 0, float end = -1);
 
 	/**
 	 * Returns the start time.
 	 */
-	float getStart();
-
-	/**
-	 * Sets the start time.
-	 * \param start The new start time.
-	 */
-	void setStart(float start);
+	float getStart() const;
 
 	/**
 	 * Returns the end time.
 	 */
-	float getEnd();
-
-	/**
-	 * Sets the end time.
-	 * \param end The new end time, a negative value signals that it should play
-	 *            to the end.
-	 */
-	void setEnd(float end);
+	float getEnd() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_LIMITERFACTORY
diff --git a/intern/audaspace/FX/AUD_LimiterReader.cpp b/intern/audaspace/FX/AUD_LimiterReader.cpp
index 05882369001..dd7301213c9 100644
--- a/intern/audaspace/FX/AUD_LimiterReader.cpp
+++ b/intern/audaspace/FX/AUD_LimiterReader.cpp
@@ -30,31 +30,27 @@
 
 AUD_LimiterReader::AUD_LimiterReader(AUD_IReader* reader,
 									 float start, float end) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_start(int(start * reader->getSpecs().rate)),
+		m_end(int(end * reader->getSpecs().rate))
 {
-	m_end = (int)(end * reader->getSpecs().rate);
-
-	if(start <= 0)
-		m_start = 0;
-	else
+	if(m_start > 0)
 	{
-		m_start = (int)(start * reader->getSpecs().rate);
 		if(m_reader->isSeekable())
 			m_reader->seek(m_start);
 		else
 		{
 			// skip first m_start samples by reading them
-			int length;
+			int length = AUD_DEFAULT_BUFFER_SIZE;
 			sample_t* buffer;
-			for(int i = m_start;
-				i >= AUD_DEFAULT_BUFFER_SIZE;
-				i -= AUD_DEFAULT_BUFFER_SIZE)
+			for(int len = m_start;
+				length == AUD_DEFAULT_BUFFER_SIZE;
+				len -= AUD_DEFAULT_BUFFER_SIZE)
 			{
-				length = AUD_DEFAULT_BUFFER_SIZE;
+				if(len < AUD_DEFAULT_BUFFER_SIZE)
+					length = len;
 				m_reader->read(length, buffer);
-				length = i;
 			}
-			m_reader->read(length, buffer);
 		}
 	}
 }
@@ -64,18 +60,18 @@ void AUD_LimiterReader::seek(int position)
 	m_reader->seek(position + m_start);
 }
 
-int AUD_LimiterReader::getLength()
+int AUD_LimiterReader::getLength() const
 {
 	int len = m_reader->getLength();
-	if(m_reader->getType() != AUD_TYPE_BUFFER || len < 0 ||
-	   (len > m_end && m_end >= 0))
+	if(len < 0 || (len > m_end && m_end >= 0))
 		len = m_end;
 	return len - m_start;
 }
 
-int AUD_LimiterReader::getPosition()
+int AUD_LimiterReader::getPosition() const
 {
-	return m_reader->getPosition() - m_start;
+	int pos = m_reader->getPosition();
+	return AUD_MIN(pos, m_end) - m_start;
 }
 
 void AUD_LimiterReader::read(int & length, sample_t* & buffer)
@@ -83,7 +79,7 @@ void AUD_LimiterReader::read(int & length, sample_t* & buffer)
 	if(m_end >= 0)
 	{
 		int position = m_reader->getPosition();
-		if(position+length > m_end)
+		if(position + length > m_end)
 			length = m_end - position;
 		if(length < 0)
 		{
diff --git a/intern/audaspace/FX/AUD_LimiterReader.h b/intern/audaspace/FX/AUD_LimiterReader.h
index 9921f5ee1b0..59d6096dcba 100644
--- a/intern/audaspace/FX/AUD_LimiterReader.h
+++ b/intern/audaspace/FX/AUD_LimiterReader.h
@@ -37,12 +37,16 @@ private:
 	/**
 	 * The start sample: inclusive.
 	 */
-	int m_start;
+	const int m_start;
 
 	/**
 	 * The end sample: exlusive.
 	 */
-	int m_end;
+	const int m_end;
+
+	// hide copy constructor and operator=
+	AUD_LimiterReader(const AUD_LimiterReader&);
+	AUD_LimiterReader& operator=(const AUD_LimiterReader&);
 
 public:
 	/**
@@ -51,13 +55,12 @@ public:
 	 * \param start The desired start sample (inclusive).
 	 * \param end The desired end sample (exklusive), a negative value signals
 	 *            that it should play to the end.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_LimiterReader(AUD_IReader* reader, float start = 0, float end = -1);
 
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
+	virtual int getLength() const;
+	virtual int getPosition() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_LoopFactory.cpp b/intern/audaspace/FX/AUD_LoopFactory.cpp
index 90186f623ff..6805a8e4b42 100644
--- a/intern/audaspace/FX/AUD_LoopFactory.cpp
+++ b/intern/audaspace/FX/AUD_LoopFactory.cpp
@@ -28,30 +28,16 @@
 
 AUD_LoopFactory::AUD_LoopFactory(AUD_IFactory* factory, int loop) :
 		AUD_EffectFactory(factory),
-		m_loop(loop) {}
-
-AUD_LoopFactory::AUD_LoopFactory(int loop) :
-		AUD_EffectFactory(0),
-		m_loop(loop) {}
-
-int AUD_LoopFactory::getLoop()
+		m_loop(loop)
 {
-	return m_loop;
 }
 
-void AUD_LoopFactory::setLoop(int loop)
+int AUD_LoopFactory::getLoop() const
 {
-	m_loop = loop;
+	return m_loop;
 }
 
-AUD_IReader* AUD_LoopFactory::createReader()
+AUD_IReader* AUD_LoopFactory::createReader() const
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_LoopReader(reader, m_loop); AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_LoopReader(getReader(), m_loop);
 }
diff --git a/intern/audaspace/FX/AUD_LoopFactory.h b/intern/audaspace/FX/AUD_LoopFactory.h
index c81d906b82e..f9e358af52d 100644
--- a/intern/audaspace/FX/AUD_LoopFactory.h
+++ b/intern/audaspace/FX/AUD_LoopFactory.h
@@ -38,7 +38,11 @@ private:
 	/**
 	 * The loop count.
 	 */
-	int m_loop;
+	const int m_loop;
+
+	// hide copy constructor and operator=
+	AUD_LoopFactory(const AUD_LoopFactory&);
+	AUD_LoopFactory& operator=(const AUD_LoopFactory&);
 
 public:
 	/**
@@ -47,28 +51,14 @@ public:
 	 * \param loop The desired loop count, negative values result in endless
 	 *        looping.
 	 */
-	AUD_LoopFactory(AUD_IFactory* factory = 0, int loop = -1);
-
-	/**
-	 * Creates a new loop factory.
-	 * \param loop The desired loop count, negative values result in endless
-	 *        looping.
-	 */
-	AUD_LoopFactory(int loop);
+	AUD_LoopFactory(AUD_IFactory* factory, int loop = -1);
 
 	/**
 	 * Returns the loop count.
 	 */
-	int getLoop();
-
-	/**
-	 * Sets the loop count.
-	 * \param loop The desired loop count, negative values result in endless
-	 *        looping.
-	 */
-	void setLoop(int loop);
+	int getLoop() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_LOOPFACTORY
diff --git a/intern/audaspace/FX/AUD_LoopReader.cpp b/intern/audaspace/FX/AUD_LoopReader.cpp
index 3bcd8c2f9d3..7521f914a5c 100644
--- a/intern/audaspace/FX/AUD_LoopReader.cpp
+++ b/intern/audaspace/FX/AUD_LoopReader.cpp
@@ -29,36 +29,37 @@
 #include <cstring>
 
 AUD_LoopReader::AUD_LoopReader(AUD_IReader* reader, int loop) :
-		AUD_EffectReader(reader), m_loop(loop)
+		AUD_EffectReader(reader), m_count(loop), m_left(loop)
 {
-	m_samples = -1;
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
-AUD_LoopReader::~AUD_LoopReader()
+void AUD_LoopReader::seek(int position)
 {
-	delete m_buffer; AUD_DELETE("buffer")
+	int len = m_reader->getLength();
+	if(len < 0)
+		m_reader->seek(position);
+	else
+	{
+		if(m_count >= 0)
+		{
+			m_left = m_count - (position / len);
+			if(m_left < 0)
+				m_left = 0;
+		}
+		m_reader->seek(position % len);
+	}
 }
 
-AUD_ReaderType AUD_LoopReader::getType()
+int AUD_LoopReader::getLength() const
 {
-	if(m_loop < 0)
-		return AUD_TYPE_STREAM;
-	return m_reader->getType();
+	if(m_count < 0)
+		return -1;
+	return m_reader->getLength() * m_count;
 }
 
-bool AUD_LoopReader::notify(AUD_Message &message)
+int AUD_LoopReader::getPosition() const
 {
-	if(message.type == AUD_MSG_LOOP)
-	{
-		m_loop = message.loopcount;
-		m_samples = message.time * m_reader->getSpecs().rate;
-
-		m_reader->notify(message);
-
-		return true;
-	}
-	return m_reader->notify(message);
+	return m_reader->getPosition() * (m_count < 0 ? 1 : m_count);
 }
 
 void AUD_LoopReader::read(int & length, sample_t* & buffer)
@@ -66,50 +67,44 @@ void AUD_LoopReader::read(int & length, sample_t* & buffer)
 	AUD_Specs specs = m_reader->getSpecs();
 	int samplesize = AUD_SAMPLE_SIZE(specs);
 
-	if(m_samples >= 0)
-	{
-		if(length > m_samples)
-			length = m_samples;
-		m_samples -= length;
-	}
-
 	int len = length;
 
 	m_reader->read(len, buffer);
 
-	if(len < length && m_loop != 0)
+	if(len < length && m_left)
 	{
 		int pos = 0;
 
-		if(m_buffer->getSize() < length * samplesize)
-			m_buffer->resize(length * samplesize);
+		if(m_buffer.getSize() < length * samplesize)
+			m_buffer.resize(length * samplesize);
+
+		sample_t* buf = m_buffer.getBuffer();
 
-		memcpy(m_buffer->getBuffer() + pos * specs.channels,
-			   buffer, len * samplesize);
+		memcpy(buf + pos * specs.channels, buffer, len * samplesize);
 
 		pos += len;
 
-		while(pos < length && m_loop != 0)
+		while(pos < length && m_left)
 		{
-			if(m_loop > 0)
-				m_loop--;
+			if(m_left > 0)
+				m_left--;
 
 			m_reader->seek(0);
 
 			len = length - pos;
 			m_reader->read(len, buffer);
+
 			// prevent endless loop
 			if(!len)
 				break;
 
-			memcpy(m_buffer->getBuffer() + pos * specs.channels,
-				   buffer, len * samplesize);
+			memcpy(buf + pos * specs.channels, buffer, len * samplesize);
 
 			pos += len;
 		}
 
 		length = pos;
-		buffer = m_buffer->getBuffer();
+		buffer = buf;
 	}
 	else
 		length = len;
diff --git a/intern/audaspace/FX/AUD_LoopReader.h b/intern/audaspace/FX/AUD_LoopReader.h
index e61a49cb0db..e0ed4cb6bf3 100644
--- a/intern/audaspace/FX/AUD_LoopReader.h
+++ b/intern/audaspace/FX/AUD_LoopReader.h
@@ -27,7 +27,7 @@
 #define AUD_LOOPREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class reads another reader and loops it.
@@ -39,17 +39,21 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
-	 * The left loop count.
+	 * The loop count.
 	 */
-	int m_loop;
+	const int m_count;
 
 	/**
-	 * The left samples.
+	 * The left loop count.
 	 */
-	int m_samples;
+	int m_left;
+
+	// hide copy constructor and operator=
+	AUD_LoopReader(const AUD_LoopReader&);
+	AUD_LoopReader& operator=(const AUD_LoopReader&);
 
 public:
 	/**
@@ -57,17 +61,12 @@ public:
 	 * \param reader The reader to read from.
 	 * \param loop The desired loop count, negative values result in endless
 	 *        looping.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_LoopReader(AUD_IReader* reader, int loop);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_LoopReader();
-
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual void seek(int position);
+	virtual int getLength() const;
+	virtual int getPosition() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_LowpassFactory.cpp b/intern/audaspace/FX/AUD_LowpassFactory.cpp
index 05dc5ff3994..dfef0f6f7c3 100644
--- a/intern/audaspace/FX/AUD_LowpassFactory.cpp
+++ b/intern/audaspace/FX/AUD_LowpassFactory.cpp
@@ -30,22 +30,11 @@ AUD_LowpassFactory::AUD_LowpassFactory(AUD_IFactory* factory, float frequency,
 									   float Q) :
 		AUD_EffectFactory(factory),
 		m_frequency(frequency),
-		m_Q(Q) {}
-
-AUD_LowpassFactory::AUD_LowpassFactory(float frequency, float Q) :
-		AUD_EffectFactory(0),
-		m_frequency(frequency),
-		m_Q(Q) {}
-
-AUD_IReader* AUD_LowpassFactory::createReader()
+		m_Q(Q)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_LowpassReader(reader, m_frequency, m_Q);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_LowpassFactory::createReader() const
+{
+	return new AUD_LowpassReader(getReader(), m_frequency, m_Q);
 }
diff --git a/intern/audaspace/FX/AUD_LowpassFactory.h b/intern/audaspace/FX/AUD_LowpassFactory.h
index 8a419823de0..61b76510a9e 100644
--- a/intern/audaspace/FX/AUD_LowpassFactory.h
+++ b/intern/audaspace/FX/AUD_LowpassFactory.h
@@ -37,12 +37,16 @@ private:
 	/**
 	 * The attack value in seconds.
 	 */
-	float m_frequency;
+	const float m_frequency;
 
 	/**
 	 * The Q factor.
 	 */
-	float m_Q;
+	const float m_Q;
+
+	// hide copy constructor and operator=
+	AUD_LowpassFactory(const AUD_LowpassFactory&);
+	AUD_LowpassFactory& operator=(const AUD_LowpassFactory&);
 
 public:
 	/**
@@ -53,14 +57,7 @@ public:
 	 */
 	AUD_LowpassFactory(AUD_IFactory* factory, float frequency, float Q = 1.0f);
 
-	/**
-	 * Creates a new lowpass factory.
-	 * \param frequency The cutoff frequency.
-	 * \param Q The Q factor.
-	 */
-	AUD_LowpassFactory(float frequency, float Q = 1.0f);
-
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_LOWPASSFACTORY
diff --git a/intern/audaspace/FX/AUD_LowpassReader.cpp b/intern/audaspace/FX/AUD_LowpassReader.cpp
index 6dc0bf66a96..71b5de1234d 100644
--- a/intern/audaspace/FX/AUD_LowpassReader.cpp
+++ b/intern/audaspace/FX/AUD_LowpassReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_LowpassReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 #include <cmath>
@@ -37,22 +36,15 @@
 
 AUD_LowpassReader::AUD_LowpassReader(AUD_IReader* reader, float frequency,
 									 float Q) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_outvalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * AUD_LOWPASS_ORDER),
+		m_invalues(AUD_SAMPLE_SIZE(reader->getSpecs()) * AUD_LOWPASS_ORDER),
+		m_position(0)
 {
-	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_outvalues = new AUD_Buffer(samplesize * AUD_LOWPASS_ORDER);
-	AUD_NEW("buffer")
-	memset(m_outvalues->getBuffer(), 0, samplesize * AUD_LOWPASS_ORDER);
+	memset(m_outvalues.getBuffer(), 0, m_outvalues.getSize());
+	memset(m_invalues.getBuffer(), 0, m_invalues.getSize());
 
-	m_invalues = new AUD_Buffer(samplesize * AUD_LOWPASS_ORDER);
-	AUD_NEW("buffer")
-	memset(m_invalues->getBuffer(), 0, samplesize * AUD_LOWPASS_ORDER);
-
-	m_position = 0;
+	AUD_Specs specs = reader->getSpecs();
 
 	// calculate coefficients
 	float w0 = 2 * M_PI * frequency / specs.rate;
@@ -65,31 +57,23 @@ AUD_LowpassReader::AUD_LowpassReader(AUD_IReader* reader, float frequency,
 	m_coeff[1][1] = (1 - cos(w0)) / norm;
 }
 
-AUD_LowpassReader::~AUD_LowpassReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-
-	delete m_outvalues; AUD_DELETE("buffer")
-	delete m_invalues; AUD_DELETE("buffer");
-}
-
 void AUD_LowpassReader::read(int & length, sample_t* & buffer)
 {
 	sample_t* buf;
 	sample_t* outvalues;
 	sample_t* invalues;
 
-	outvalues = m_outvalues->getBuffer();
-	invalues = m_invalues->getBuffer();
+	outvalues = m_outvalues.getBuffer();
+	invalues = m_invalues.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
 
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	int channels = specs.channels;
 
 	for(int channel = 0; channel < channels; channel++)
diff --git a/intern/audaspace/FX/AUD_LowpassReader.h b/intern/audaspace/FX/AUD_LowpassReader.h
index a490ba52c1c..66e4b91b783 100644
--- a/intern/audaspace/FX/AUD_LowpassReader.h
+++ b/intern/audaspace/FX/AUD_LowpassReader.h
@@ -27,7 +27,7 @@
 #define AUD_LOWPASSREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 #define AUD_LOWPASS_ORDER 3
 
@@ -40,17 +40,17 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The last out values buffer.
 	 */
-	AUD_Buffer *m_outvalues;
+	AUD_Buffer m_outvalues;
 
 	/**
 	 * The last in values buffer.
 	 */
-	AUD_Buffer *m_invalues;
+	AUD_Buffer m_invalues;
 
 	/**
 	 * The position for buffer cycling.
@@ -62,21 +62,19 @@ private:
 	 */
 	float m_coeff[2][AUD_LOWPASS_ORDER];
 
+	// hide copy constructor and operator=
+	AUD_LowpassReader(const AUD_LowpassReader&);
+	AUD_LowpassReader& operator=(const AUD_LowpassReader&);
+
 public:
 	/**
 	 * Creates a new lowpass reader.
 	 * \param reader The reader to read from.
 	 * \param frequency The cutoff frequency.
 	 * \param Q The Q factor.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_LowpassReader(AUD_IReader* reader, float frequency, float Q);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_LowpassReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_PingPongFactory.cpp b/intern/audaspace/FX/AUD_PingPongFactory.cpp
index 8b72afe05e7..b3aaa9e80a4 100644
--- a/intern/audaspace/FX/AUD_PingPongFactory.cpp
+++ b/intern/audaspace/FX/AUD_PingPongFactory.cpp
@@ -28,40 +28,25 @@
 #include "AUD_ReverseFactory.h"
 
 AUD_PingPongFactory::AUD_PingPongFactory(AUD_IFactory* factory) :
-		AUD_EffectFactory(factory) {}
-
-AUD_IReader* AUD_PingPongFactory::createReader()
+		AUD_EffectFactory(factory)
 {
-	if(m_factory == 0)
-		return 0;
+}
 
-	AUD_IReader* reader = m_factory->createReader();
+AUD_IReader* AUD_PingPongFactory::createReader() const
+{
+	AUD_IReader* reader = getReader();
+	AUD_IReader* reader2;
+	AUD_ReverseFactory factory(m_factory);
 
-	if(reader != 0)
+	try
 	{
-		AUD_IReader* reader2;
-		AUD_ReverseFactory factory(m_factory);
-
-		try
-		{
-			reader2 = factory.createReader();
-		}
-		catch(AUD_Exception)
-		{
-			reader2 = 0;
-		}
-
-		if(reader2 != 0)
-		{
-			reader = new AUD_DoubleReader(reader, reader2);
-			AUD_NEW("reader")
-		}
-		else
-		{
-			delete reader; AUD_DELETE("reader")
-			reader = 0;
-		}
+		reader2 = factory.createReader();
+	}
+	catch(AUD_Exception&)
+	{
+		delete reader;
+		throw;
 	}
 
-	return reader;
+	return new AUD_DoubleReader(reader, reader2);
 }
diff --git a/intern/audaspace/FX/AUD_PingPongFactory.h b/intern/audaspace/FX/AUD_PingPongFactory.h
index 1bf5d5e2508..82aedca8f7f 100644
--- a/intern/audaspace/FX/AUD_PingPongFactory.h
+++ b/intern/audaspace/FX/AUD_PingPongFactory.h
@@ -34,14 +34,19 @@
  */
 class AUD_PingPongFactory : public AUD_EffectFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_PingPongFactory(const AUD_PingPongFactory&);
+	AUD_PingPongFactory& operator=(const AUD_PingPongFactory&);
+
 public:
 	/**
 	 * Creates a new ping pong factory.
 	 * \param factory The input factory.
 	 */
-	AUD_PingPongFactory(AUD_IFactory* factory = 0);
+	AUD_PingPongFactory(AUD_IFactory* factory);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_PINGPONGFACTORY
diff --git a/intern/audaspace/FX/AUD_PitchFactory.cpp b/intern/audaspace/FX/AUD_PitchFactory.cpp
index 5f814283c12..be285562db3 100644
--- a/intern/audaspace/FX/AUD_PitchFactory.cpp
+++ b/intern/audaspace/FX/AUD_PitchFactory.cpp
@@ -29,20 +29,11 @@
 
 AUD_PitchFactory::AUD_PitchFactory(AUD_IFactory* factory, float pitch) :
 		AUD_EffectFactory(factory),
-		m_pitch(pitch) {}
-
-AUD_PitchFactory::AUD_PitchFactory(float pitch) :
-		AUD_EffectFactory(0),
-		m_pitch(pitch) {}
-
-AUD_IReader* AUD_PitchFactory::createReader()
+		m_pitch(pitch)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_PitchReader(reader, m_pitch); AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_PitchFactory::createReader() const
+{
+	return new AUD_PitchReader(getReader(), m_pitch);
 }
diff --git a/intern/audaspace/FX/AUD_PitchFactory.h b/intern/audaspace/FX/AUD_PitchFactory.h
index 96c4d0d7e92..52b9b7d99e5 100644
--- a/intern/audaspace/FX/AUD_PitchFactory.h
+++ b/intern/audaspace/FX/AUD_PitchFactory.h
@@ -37,7 +37,11 @@ private:
 	/**
 	 * The pitch.
 	 */
-	float m_pitch;
+	const float m_pitch;
+
+	// hide copy constructor and operator=
+	AUD_PitchFactory(const AUD_PitchFactory&);
+	AUD_PitchFactory& operator=(const AUD_PitchFactory&);
 
 public:
 	/**
@@ -45,26 +49,9 @@ public:
 	 * \param factory The input factory.
 	 * \param pitch The desired pitch.
 	 */
-	AUD_PitchFactory(AUD_IFactory* factory = 0, float pitch = 1.0f);
-
-	/**
-	 * Creates a new pitch factory.
-	 * \param pitch The desired pitch.
-	 */
-	AUD_PitchFactory(float pitch);
-
-	/**
-	 * Returns the pitch.
-	 */
-	float getPitch();
-
-	/**
-	 * Sets the pitch.
-	 * \param pitch The new pitch value. Should be between 0.0 and 1.0.
-	 */
-	void setPitch(float pitch);
+	AUD_PitchFactory(AUD_IFactory* factory, float pitch);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_PITCHFACTORY
diff --git a/intern/audaspace/FX/AUD_PitchReader.cpp b/intern/audaspace/FX/AUD_PitchReader.cpp
index c53264e1350..19c3be31968 100644
--- a/intern/audaspace/FX/AUD_PitchReader.cpp
+++ b/intern/audaspace/FX/AUD_PitchReader.cpp
@@ -26,12 +26,11 @@
 #include "AUD_PitchReader.h"
 
 AUD_PitchReader::AUD_PitchReader(AUD_IReader* reader, float pitch) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader), m_pitch(pitch)
 {
-	m_pitch = pitch;
 }
 
-AUD_Specs AUD_PitchReader::getSpecs()
+AUD_Specs AUD_PitchReader::getSpecs() const
 {
 	AUD_Specs specs = m_reader->getSpecs();
 	specs.rate = (AUD_SampleRate)((int)(specs.rate * m_pitch));
diff --git a/intern/audaspace/FX/AUD_PitchReader.h b/intern/audaspace/FX/AUD_PitchReader.h
index 440e9cc843c..cc188cf0ee4 100644
--- a/intern/audaspace/FX/AUD_PitchReader.h
+++ b/intern/audaspace/FX/AUD_PitchReader.h
@@ -37,18 +37,21 @@ private:
 	/**
 	 * The pitch level.
 	 */
-	float m_pitch;
+	const float m_pitch;
+
+	// hide copy constructor and operator=
+	AUD_PitchReader(const AUD_PitchReader&);
+	AUD_PitchReader& operator=(const AUD_PitchReader&);
 
 public:
 	/**
 	 * Creates a new pitch reader.
 	 * \param reader The reader to read from.
 	 * \param pitch The size of the buffer.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_PitchReader(AUD_IReader* reader, float pitch);
 
-	virtual AUD_Specs getSpecs();
+	virtual AUD_Specs getSpecs() const;
 };
 
 #endif //AUD_PITCHREADER
diff --git a/intern/audaspace/FX/AUD_RectifyFactory.cpp b/intern/audaspace/FX/AUD_RectifyFactory.cpp
index f97defd793b..52608c3177b 100644
--- a/intern/audaspace/FX/AUD_RectifyFactory.cpp
+++ b/intern/audaspace/FX/AUD_RectifyFactory.cpp
@@ -27,19 +27,11 @@
 #include "AUD_RectifyReader.h"
 
 AUD_RectifyFactory::AUD_RectifyFactory(AUD_IFactory* factory) :
-		AUD_EffectFactory(factory) {}
-
-AUD_RectifyFactory::AUD_RectifyFactory() :
-		AUD_EffectFactory(0) {}
-
-AUD_IReader* AUD_RectifyFactory::createReader()
+		AUD_EffectFactory(factory)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_RectifyReader(reader); AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_RectifyFactory::createReader() const
+{
+	return new AUD_RectifyReader(getReader());
 }
diff --git a/intern/audaspace/FX/AUD_RectifyFactory.h b/intern/audaspace/FX/AUD_RectifyFactory.h
index ed00620d318..d8b39e83fdf 100644
--- a/intern/audaspace/FX/AUD_RectifyFactory.h
+++ b/intern/audaspace/FX/AUD_RectifyFactory.h
@@ -33,19 +33,19 @@
  */
 class AUD_RectifyFactory : public AUD_EffectFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_RectifyFactory(const AUD_RectifyFactory&);
+	AUD_RectifyFactory& operator=(const AUD_RectifyFactory&);
+
 public:
 	/**
 	 * Creates a new rectify factory.
 	 * \param factory The input factory.
 	 */
-	AUD_RectifyFactory(AUD_IFactory* factory = 0);
-
-	/**
-	 * Creates a new rectify factory.
-	 */
-	AUD_RectifyFactory();
+	AUD_RectifyFactory(AUD_IFactory* factory);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_RECTIFYFACTORY
diff --git a/intern/audaspace/FX/AUD_RectifyReader.cpp b/intern/audaspace/FX/AUD_RectifyReader.cpp
index 5d3ce80e811..c5bf73fac03 100644
--- a/intern/audaspace/FX/AUD_RectifyReader.cpp
+++ b/intern/audaspace/FX/AUD_RectifyReader.cpp
@@ -24,19 +24,12 @@
  */
 
 #include "AUD_RectifyReader.h"
-#include "AUD_Buffer.h"
 
 #include <cmath>
 
 AUD_RectifyReader::AUD_RectifyReader(AUD_IReader* reader) :
 		AUD_EffectReader(reader)
 {
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_RectifyReader::~AUD_RectifyReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
 void AUD_RectifyReader::read(int & length, sample_t* & buffer)
@@ -45,10 +38,10 @@ void AUD_RectifyReader::read(int & length, sample_t* & buffer)
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	for(int i = 0; i < length * specs.channels; i++)
 		buffer[i] = fabs(buf[i]);
diff --git a/intern/audaspace/FX/AUD_RectifyReader.h b/intern/audaspace/FX/AUD_RectifyReader.h
index afbe2e59cab..498f18e5041 100644
--- a/intern/audaspace/FX/AUD_RectifyReader.h
+++ b/intern/audaspace/FX/AUD_RectifyReader.h
@@ -27,7 +27,7 @@
 #define AUD_RECTIFYREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class reads another reader and rectifies it.
@@ -38,21 +38,19 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
+
+	// hide copy constructor and operator=
+	AUD_RectifyReader(const AUD_RectifyReader&);
+	AUD_RectifyReader& operator=(const AUD_RectifyReader&);
 
 public:
 	/**
 	 * Creates a new rectify reader.
 	 * \param reader The reader to read from.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_RectifyReader(AUD_IReader* reader);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_RectifyReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_ReverseFactory.cpp b/intern/audaspace/FX/AUD_ReverseFactory.cpp
index 1242641c350..1002e2de87e 100644
--- a/intern/audaspace/FX/AUD_ReverseFactory.cpp
+++ b/intern/audaspace/FX/AUD_ReverseFactory.cpp
@@ -28,16 +28,11 @@
 #include "AUD_Space.h"
 
 AUD_ReverseFactory::AUD_ReverseFactory(AUD_IFactory* factory) :
-		AUD_EffectFactory(factory) {}
-
-AUD_IReader* AUD_ReverseFactory::createReader()
+		AUD_EffectFactory(factory)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_ReverseReader(reader); AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_ReverseFactory::createReader() const
+{
+	return new AUD_ReverseReader(getReader());
 }
diff --git a/intern/audaspace/FX/AUD_ReverseFactory.h b/intern/audaspace/FX/AUD_ReverseFactory.h
index 4b664c47281..a1995ee68f9 100644
--- a/intern/audaspace/FX/AUD_ReverseFactory.h
+++ b/intern/audaspace/FX/AUD_ReverseFactory.h
@@ -34,17 +34,19 @@
  */
 class AUD_ReverseFactory : public AUD_EffectFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_ReverseFactory(const AUD_ReverseFactory&);
+	AUD_ReverseFactory& operator=(const AUD_ReverseFactory&);
+
 public:
 	/**
 	 * Creates a new reverse factory.
 	 * \param factory The input factory.
 	 */
-	AUD_ReverseFactory(AUD_IFactory* factory = 0);
+	AUD_ReverseFactory(AUD_IFactory* factory);
 
-	/**
-	 * Destroys the factory.
-	 */
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_REVERSEFACTORY
diff --git a/intern/audaspace/FX/AUD_ReverseReader.cpp b/intern/audaspace/FX/AUD_ReverseReader.cpp
index 82d6c70ce53..a17a4a64a18 100644
--- a/intern/audaspace/FX/AUD_ReverseReader.cpp
+++ b/intern/audaspace/FX/AUD_ReverseReader.cpp
@@ -24,27 +24,16 @@
  */
 
 #include "AUD_ReverseReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
 AUD_ReverseReader::AUD_ReverseReader(AUD_IReader* reader) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_length(reader->getLength()),
+		m_position(0)
 {
-	if(reader->getType() != AUD_TYPE_BUFFER)
+	if(m_length < 0 || !reader->isSeekable())
 		AUD_THROW(AUD_ERROR_READER);
-
-	m_length = reader->getLength();
-	if(m_length < 0)
-		AUD_THROW(AUD_ERROR_READER);
-
-	m_position = 0;
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_ReverseReader::~AUD_ReverseReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
 void AUD_ReverseReader::seek(int position)
@@ -52,12 +41,12 @@ void AUD_ReverseReader::seek(int position)
 	m_position = position;
 }
 
-int AUD_ReverseReader::getLength()
+int AUD_ReverseReader::getLength() const
 {
 	return m_length;
 }
 
-int AUD_ReverseReader::getPosition()
+int AUD_ReverseReader::getPosition() const
 {
 	return m_position;
 }
@@ -66,7 +55,7 @@ void AUD_ReverseReader::read(int & length, sample_t* & buffer)
 {
 	// first correct the length
 	if(m_position + length > m_length)
-		length = m_length-m_position;
+		length = m_length - m_position;
 
 	if(length <= 0)
 	{
@@ -78,10 +67,10 @@ void AUD_ReverseReader::read(int & length, sample_t* & buffer)
 	int samplesize = AUD_SAMPLE_SIZE(specs);
 
 	// resize buffer if needed
-	if(m_buffer->getSize() < length * samplesize)
-		m_buffer->resize(length * samplesize);
+	if(m_buffer.getSize() < length * samplesize)
+		m_buffer.resize(length * samplesize);
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	sample_t* buf;
 	int len = length;
@@ -105,5 +94,5 @@ void AUD_ReverseReader::read(int & length, sample_t* & buffer)
 
 	m_position += length;
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 }
diff --git a/intern/audaspace/FX/AUD_ReverseReader.h b/intern/audaspace/FX/AUD_ReverseReader.h
index 045d2ac5a8e..8eb960a5dee 100644
--- a/intern/audaspace/FX/AUD_ReverseReader.h
+++ b/intern/audaspace/FX/AUD_ReverseReader.h
@@ -27,7 +27,7 @@
 #define AUD_REVERSEREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class reads another reader from back to front.
@@ -37,37 +37,36 @@ class AUD_ReverseReader : public AUD_EffectReader
 {
 private:
 	/**
-	 * The current position.
+	 * The sample count.
 	 */
-	int m_position;
+	const int m_length;
 
 	/**
-	 * The sample count.
+	 * The current position.
 	 */
-	int m_length;
+	int m_position;
 
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
+
+	// hide copy constructor and operator=
+	AUD_ReverseReader(const AUD_ReverseReader&);
+	AUD_ReverseReader& operator=(const AUD_ReverseReader&);
 
 public:
 	/**
 	 * Creates a new reverse reader.
 	 * \param reader The reader to read from.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL or not
-	 *            a buffer.
+	 * \exception AUD_Exception Thrown if the reader specified has an
+	 *            undeterminable/infinite length or is not seekable.
 	 */
 	AUD_ReverseReader(AUD_IReader* reader);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_ReverseReader();
-
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
+	virtual int getLength() const;
+	virtual int getPosition() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_SquareFactory.cpp b/intern/audaspace/FX/AUD_SquareFactory.cpp
index 638acaa9a32..b95c9d9bb0f 100644
--- a/intern/audaspace/FX/AUD_SquareFactory.cpp
+++ b/intern/audaspace/FX/AUD_SquareFactory.cpp
@@ -28,30 +28,16 @@
 
 AUD_SquareFactory::AUD_SquareFactory(AUD_IFactory* factory, float threshold) :
 		AUD_EffectFactory(factory),
-		m_threshold(threshold) {}
-
-AUD_SquareFactory::AUD_SquareFactory(float threshold) :
-		AUD_EffectFactory(0),
-		m_threshold(threshold) {}
-
-float AUD_SquareFactory::getThreshold()
+		m_threshold(threshold)
 {
-	return m_threshold;
 }
 
-void AUD_SquareFactory::setThreshold(float threshold)
+float AUD_SquareFactory::getThreshold() const
 {
-	m_threshold = threshold;
+	return m_threshold;
 }
 
-AUD_IReader* AUD_SquareFactory::createReader()
+AUD_IReader* AUD_SquareFactory::createReader() const
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_SquareReader(reader, m_threshold); AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_SquareReader(getReader(), m_threshold);
 }
diff --git a/intern/audaspace/FX/AUD_SquareFactory.h b/intern/audaspace/FX/AUD_SquareFactory.h
index dfbe5ae2887..da87dc6f888 100644
--- a/intern/audaspace/FX/AUD_SquareFactory.h
+++ b/intern/audaspace/FX/AUD_SquareFactory.h
@@ -37,7 +37,11 @@ private:
 	/**
 	 * The threshold.
 	 */
-	float m_threshold;
+	const float m_threshold;
+
+	// hide copy constructor and operator=
+	AUD_SquareFactory(const AUD_SquareFactory&);
+	AUD_SquareFactory& operator=(const AUD_SquareFactory&);
 
 public:
 	/**
@@ -45,26 +49,14 @@ public:
 	 * \param factory The input factory.
 	 * \param threshold The threshold.
 	 */
-	AUD_SquareFactory(AUD_IFactory* factory = 0, float threshold = 0.0f);
-
-	/**
-	 * Creates a new square factory.
-	 * \param threshold The threshold.
-	 */
-	AUD_SquareFactory(float threshold);
+	AUD_SquareFactory(AUD_IFactory* factory, float threshold = 0.0f);
 
 	/**
 	 * Returns the threshold.
 	 */
-	float getThreshold();
-
-	/**
-	 * Sets the threshold.
-	 * \param threshold The new threshold value. Should be between 0.0 and 1.0.
-	 */
-	void setThreshold(float threshold);
+	float getThreshold() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SQUAREFACTORY
diff --git a/intern/audaspace/FX/AUD_SquareReader.cpp b/intern/audaspace/FX/AUD_SquareReader.cpp
index 2d4dc52fe27..4bf0d87f99b 100644
--- a/intern/audaspace/FX/AUD_SquareReader.cpp
+++ b/intern/audaspace/FX/AUD_SquareReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_SquareReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -32,12 +31,6 @@ AUD_SquareReader::AUD_SquareReader(AUD_IReader* reader, float threshold) :
 		AUD_EffectReader(reader),
 		m_threshold(threshold)
 {
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_SquareReader::~AUD_SquareReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
 void AUD_SquareReader::read(int & length, sample_t* & buffer)
@@ -46,10 +39,11 @@ void AUD_SquareReader::read(int & length, sample_t* & buffer)
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
+
+	buffer = m_buffer.getBuffer();
 
 	for(int i = 0; i < length * specs.channels; i++)
 	{
diff --git a/intern/audaspace/FX/AUD_SquareReader.h b/intern/audaspace/FX/AUD_SquareReader.h
index 63dda351445..d3a5331b0e8 100644
--- a/intern/audaspace/FX/AUD_SquareReader.h
+++ b/intern/audaspace/FX/AUD_SquareReader.h
@@ -27,7 +27,7 @@
 #define AUD_SQUAREREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class changes another signal into a square signal.
@@ -38,27 +38,25 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The threshold level.
 	 */
-	float m_threshold;
+	const float m_threshold;
+
+	// hide copy constructor and operator=
+	AUD_SquareReader(const AUD_SquareReader&);
+	AUD_SquareReader& operator=(const AUD_SquareReader&);
 
 public:
 	/**
 	 * Creates a new square reader.
 	 * \param reader The reader to read from.
 	 * \param threshold The size of the buffer.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_SquareReader(AUD_IReader* reader, float threshold);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_SquareReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_SumFactory.cpp b/intern/audaspace/FX/AUD_SumFactory.cpp
index f7990aab8a1..96ad286bf5c 100644
--- a/intern/audaspace/FX/AUD_SumFactory.cpp
+++ b/intern/audaspace/FX/AUD_SumFactory.cpp
@@ -27,17 +27,11 @@
 #include "AUD_SumReader.h"
 
 AUD_SumFactory::AUD_SumFactory(AUD_IFactory* factory) :
-		AUD_EffectFactory(factory) {}
-
-AUD_IReader* AUD_SumFactory::createReader()
+		AUD_EffectFactory(factory)
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_SumReader(reader);
-		AUD_NEW("reader")
-	}
+}
 
-	return reader;
+AUD_IReader* AUD_SumFactory::createReader() const
+{
+	return new AUD_SumReader(getReader());
 }
diff --git a/intern/audaspace/FX/AUD_SumFactory.h b/intern/audaspace/FX/AUD_SumFactory.h
index 5cb48e26b10..045a0a3a625 100644
--- a/intern/audaspace/FX/AUD_SumFactory.h
+++ b/intern/audaspace/FX/AUD_SumFactory.h
@@ -33,14 +33,19 @@
  */
 class AUD_SumFactory : public AUD_EffectFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_SumFactory(const AUD_SumFactory&);
+	AUD_SumFactory& operator=(const AUD_SumFactory&);
+
 public:
 	/**
 	 * Creates a new sum factory.
 	 * \param factory The input factory.
 	 */
-	AUD_SumFactory(AUD_IFactory* factory = 0);
+	AUD_SumFactory(AUD_IFactory* factory);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SUMFACTORY
diff --git a/intern/audaspace/FX/AUD_SumReader.cpp b/intern/audaspace/FX/AUD_SumReader.cpp
index 08747790fc9..13f0e2271a6 100644
--- a/intern/audaspace/FX/AUD_SumReader.cpp
+++ b/intern/audaspace/FX/AUD_SumReader.cpp
@@ -24,43 +24,32 @@
  */
 
 #include "AUD_SumReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
 #define CC specs.channels + channel
 
 AUD_SumReader::AUD_SumReader(AUD_IReader* reader) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_sums(AUD_SAMPLE_SIZE(reader->getSpecs()))
 {
-	AUD_Specs specs = reader->getSpecs();
-	int samplesize = AUD_SAMPLE_SIZE(specs);
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_sums = new AUD_Buffer(samplesize); AUD_NEW("buffer")
-	memset(m_sums->getBuffer(), 0, samplesize);
-}
-
-AUD_SumReader::~AUD_SumReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-	delete m_sums; AUD_DELETE("buffer")
+	memset(m_sums.getBuffer(), 0, m_sums.getSize());
 }
 
 void AUD_SumReader::read(int & length, sample_t* & buffer)
 {
 	sample_t* buf;
 	sample_t* sums;
-	sums = m_sums->getBuffer();
+	sums = m_sums.getBuffer();
 
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
+
+	buffer = m_buffer.getBuffer();
 
 	for(int channel = 0; channel < specs.channels; channel++)
 		for(int i = 0; i < length * specs.channels; i++)
diff --git a/intern/audaspace/FX/AUD_SumReader.h b/intern/audaspace/FX/AUD_SumReader.h
index 76ccf2f863a..0bb470bac97 100644
--- a/intern/audaspace/FX/AUD_SumReader.h
+++ b/intern/audaspace/FX/AUD_SumReader.h
@@ -27,7 +27,7 @@
 #define AUD_SUMREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class represents an summer.
@@ -38,26 +38,24 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The sums of the specific channels.
 	 */
-	AUD_Buffer *m_sums;
+	AUD_Buffer m_sums;
+
+	// hide copy constructor and operator=
+	AUD_SumReader(const AUD_SumReader&);
+	AUD_SumReader& operator=(const AUD_SumReader&);
 
 public:
 	/**
 	 * Creates a new sum reader.
 	 * \param reader The reader to read from.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_SumReader(AUD_IReader* reader);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_SumReader();
-
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_SuperposeFactory.cpp b/intern/audaspace/FX/AUD_SuperposeFactory.cpp
index afd1ec18efb..6bfc1125ca6 100644
--- a/intern/audaspace/FX/AUD_SuperposeFactory.cpp
+++ b/intern/audaspace/FX/AUD_SuperposeFactory.cpp
@@ -27,29 +27,23 @@
 #include "AUD_SuperposeReader.h"
 
 AUD_SuperposeFactory::AUD_SuperposeFactory(AUD_IFactory* factory1, AUD_IFactory* factory2) :
-		m_factory1(factory1), m_factory2(factory2) {}
+		m_factory1(factory1), m_factory2(factory2)
+{
+}
 
-AUD_IReader* AUD_SuperposeFactory::createReader()
+AUD_IReader* AUD_SuperposeFactory::createReader() const
 {
 	AUD_IReader* reader1 = m_factory1->createReader();
-	if(!reader1)
-		return 0;
 	AUD_IReader* reader2;
 	try
 	{
 		reader2 = m_factory2->createReader();
-		if(!reader2)
-		{
-			delete reader1; AUD_DELETE("reader")
-			return 0;
-		}
 	}
 	catch(AUD_Exception&)
 	{
-		delete reader1; AUD_DELETE("reader")
+		delete reader1;
 		throw;
 	}
 
-	AUD_IReader* reader = new AUD_SuperposeReader(reader1, reader2);
-	return reader;
+	return new AUD_SuperposeReader(reader1, reader2);
 }
diff --git a/intern/audaspace/FX/AUD_SuperposeFactory.h b/intern/audaspace/FX/AUD_SuperposeFactory.h
index 44e79d76887..a7fde2c182f 100644
--- a/intern/audaspace/FX/AUD_SuperposeFactory.h
+++ b/intern/audaspace/FX/AUD_SuperposeFactory.h
@@ -45,6 +45,10 @@ private:
 	 */
 	AUD_IFactory* m_factory2;
 
+	// hide copy constructor and operator=
+	AUD_SuperposeFactory(const AUD_SuperposeFactory&);
+	AUD_SuperposeFactory& operator=(const AUD_SuperposeFactory&);
+
 public:
 	/**
 	 * Creates a new superpose factory.
@@ -53,7 +57,7 @@ public:
 	 */
 	AUD_SuperposeFactory(AUD_IFactory* factory1, AUD_IFactory* factory2);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SUPERPOSEFACTORY
diff --git a/intern/audaspace/FX/AUD_SuperposeReader.cpp b/intern/audaspace/FX/AUD_SuperposeReader.cpp
index 6519f272110..c24b01b35b3 100644
--- a/intern/audaspace/FX/AUD_SuperposeReader.cpp
+++ b/intern/audaspace/FX/AUD_SuperposeReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_SuperposeReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -33,44 +32,28 @@ AUD_SuperposeReader::AUD_SuperposeReader(AUD_IReader* reader1, AUD_IReader* read
 {
 	try
 	{
-		if(!reader1)
-			AUD_THROW(AUD_ERROR_READER);
-
-		if(!reader2)
-			AUD_THROW(AUD_ERROR_READER);
-
 		AUD_Specs s1, s2;
 		s1 = reader1->getSpecs();
 		s2 = reader2->getSpecs();
-		if(memcmp(&s1, &s2, sizeof(AUD_Specs)) != 0)
+		if(memcmp(&s1, &s2, sizeof(AUD_Specs)))
 			AUD_THROW(AUD_ERROR_READER);
 	}
-
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
-		if(reader1)
-		{
-			delete reader1; AUD_DELETE("reader")
-		}
-		if(reader2)
-		{
-			delete reader2; AUD_DELETE("reader")
-		}
+		delete reader1;
+		delete reader2;
 
 		throw;
 	}
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
 AUD_SuperposeReader::~AUD_SuperposeReader()
 {
-	delete m_reader1; AUD_DELETE("reader")
-	delete m_reader2; AUD_DELETE("reader")
-	delete m_buffer; AUD_DELETE("buffer")
+	delete m_reader1;
+	delete m_reader2;
 }
 
-bool AUD_SuperposeReader::isSeekable()
+bool AUD_SuperposeReader::isSeekable() const
 {
 	return m_reader1->isSeekable() && m_reader2->isSeekable();
 }
@@ -81,50 +64,35 @@ void AUD_SuperposeReader::seek(int position)
 	m_reader2->seek(position);
 }
 
-int AUD_SuperposeReader::getLength()
+int AUD_SuperposeReader::getLength() const
 {
 	int len1 = m_reader1->getLength();
 	int len2 = m_reader2->getLength();
 	if((len1 < 0) || (len2 < 0))
 		return -1;
-	if(len1 < len2)
-		return len2;
-	return len1;
+	return AUD_MIN(len1, len2);
 }
 
-int AUD_SuperposeReader::getPosition()
+int AUD_SuperposeReader::getPosition() const
 {
 	int pos1 = m_reader1->getPosition();
 	int pos2 = m_reader2->getPosition();
 	return AUD_MAX(pos1, pos2);
 }
 
-AUD_Specs AUD_SuperposeReader::getSpecs()
+AUD_Specs AUD_SuperposeReader::getSpecs() const
 {
 	return m_reader1->getSpecs();
 }
 
-AUD_ReaderType AUD_SuperposeReader::getType()
-{
-	if(m_reader1->getType() == AUD_TYPE_BUFFER &&
-	   m_reader2->getType() == AUD_TYPE_BUFFER)
-		return AUD_TYPE_BUFFER;
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_SuperposeReader::notify(AUD_Message &message)
-{
-	return m_reader1->notify(message) | m_reader2->notify(message);
-}
-
 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();
+	if(m_buffer.getSize() < length * samplesize)
+		m_buffer.resize(length * samplesize);
+	buffer = m_buffer.getBuffer();
 
 	int len1 = length;
 	sample_t* buf;
diff --git a/intern/audaspace/FX/AUD_SuperposeReader.h b/intern/audaspace/FX/AUD_SuperposeReader.h
index 71392b1133b..eeceb9adfeb 100644
--- a/intern/audaspace/FX/AUD_SuperposeReader.h
+++ b/intern/audaspace/FX/AUD_SuperposeReader.h
@@ -27,7 +27,7 @@
 #define AUD_SUPERPOSEREADER
 
 #include "AUD_IReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This reader plays two readers with the same specs sequently.
@@ -48,15 +48,18 @@ private:
 	/**
 	 * The playback buffer for the intersecting part.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
+
+	// hide copy constructor and operator=
+	AUD_SuperposeReader(const AUD_SuperposeReader&);
+	AUD_SuperposeReader& operator=(const AUD_SuperposeReader&);
 
 public:
 	/**
 	 * Creates a new superpose reader.
 	 * \param reader1 The first reader to read from.
 	 * \param reader2 The second reader to read from.
-	 * \exception AUD_Exception Thrown if one of the reader specified is NULL
-	 *             or the specs from the readers differ.
+	 * \exception AUD_Exception Thrown if the specs from the readers differ.
 	 */
 	AUD_SuperposeReader(AUD_IReader* reader1, AUD_IReader* reader2);
 
@@ -65,13 +68,11 @@ public:
 	 */
 	virtual ~AUD_SuperposeReader();
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/FX/AUD_VolumeFactory.cpp b/intern/audaspace/FX/AUD_VolumeFactory.cpp
index fbde608aa12..9f0fd5821fd 100644
--- a/intern/audaspace/FX/AUD_VolumeFactory.cpp
+++ b/intern/audaspace/FX/AUD_VolumeFactory.cpp
@@ -28,30 +28,16 @@
 
 AUD_VolumeFactory::AUD_VolumeFactory(AUD_IFactory* factory, float volume) :
 		AUD_EffectFactory(factory),
-		m_volume(volume) {}
-
-AUD_VolumeFactory::AUD_VolumeFactory(float volume) :
-		AUD_EffectFactory(0),
-		m_volume(volume) {}
-
-float AUD_VolumeFactory::getVolume()
+		m_volume(volume)
 {
-	return m_volume;
 }
 
-void AUD_VolumeFactory::setVolume(float volume)
+float AUD_VolumeFactory::getVolume() const
 {
-	m_volume = volume;
+	return m_volume;
 }
 
-AUD_IReader* AUD_VolumeFactory::createReader()
+AUD_IReader* AUD_VolumeFactory::createReader() const
 {
-	AUD_IReader* reader = getReader();
-
-	if(reader != 0)
-	{
-		reader = new AUD_VolumeReader(reader, m_volume); AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_VolumeReader(getReader(), m_volume);
 }
diff --git a/intern/audaspace/FX/AUD_VolumeFactory.h b/intern/audaspace/FX/AUD_VolumeFactory.h
index 09f91241b47..a086aab4640 100644
--- a/intern/audaspace/FX/AUD_VolumeFactory.h
+++ b/intern/audaspace/FX/AUD_VolumeFactory.h
@@ -39,7 +39,11 @@ private:
 	/**
 	 * The volume.
 	 */
-	float m_volume;
+	const float m_volume;
+
+	// hide copy constructor and operator=
+	AUD_VolumeFactory(const AUD_VolumeFactory&);
+	AUD_VolumeFactory& operator=(const AUD_VolumeFactory&);
 
 public:
 	/**
@@ -47,26 +51,14 @@ public:
 	 * \param factory The input factory.
 	 * \param volume The desired volume.
 	 */
-	AUD_VolumeFactory(AUD_IFactory* factory = 0, float volume = 1.0f);
-
-	/**
-	 * Creates a new volume factory.
-	 * \param volume The desired volume.
-	 */
-	AUD_VolumeFactory(float volume);
+	AUD_VolumeFactory(AUD_IFactory* factory, float volume);
 
 	/**
 	 * Returns the volume.
 	 */
-	float getVolume();
-
-	/**
-	 * Sets the volume.
-	 * \param volume The new volume value. Should be between 0.0 and 1.0.
-	 */
-	void setVolume(float volume);
+	float getVolume() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_VOLUMEFACTORY
diff --git a/intern/audaspace/FX/AUD_VolumeReader.cpp b/intern/audaspace/FX/AUD_VolumeReader.cpp
index f094c1e4ea3..7401b508b28 100644
--- a/intern/audaspace/FX/AUD_VolumeReader.cpp
+++ b/intern/audaspace/FX/AUD_VolumeReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_VolumeReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -32,25 +31,6 @@ AUD_VolumeReader::AUD_VolumeReader(AUD_IReader* reader, float volume) :
 		AUD_EffectReader(reader),
 		m_volume(volume)
 {
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_VolumeReader::~AUD_VolumeReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-}
-
-bool AUD_VolumeReader::notify(AUD_Message &message)
-{
-	if(message.type == AUD_MSG_VOLUME)
-	{
-		m_volume = message.volume;
-
-		m_reader->notify(message);
-
-		return true;
-	}
-	return m_reader->notify(message);
 }
 
 void AUD_VolumeReader::read(int & length, sample_t* & buffer)
@@ -59,10 +39,10 @@ void AUD_VolumeReader::read(int & length, sample_t* & buffer)
 	AUD_Specs specs = m_reader->getSpecs();
 
 	m_reader->read(length, buf);
-	if(m_buffer->getSize() < length*AUD_SAMPLE_SIZE(specs))
-		m_buffer->resize(length*AUD_SAMPLE_SIZE(specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	for(int i = 0; i < length * specs.channels; i++)
 		buffer[i] = buf[i] * m_volume;
diff --git a/intern/audaspace/FX/AUD_VolumeReader.h b/intern/audaspace/FX/AUD_VolumeReader.h
index 489f85b10f2..0e96a27e287 100644
--- a/intern/audaspace/FX/AUD_VolumeReader.h
+++ b/intern/audaspace/FX/AUD_VolumeReader.h
@@ -27,7 +27,7 @@
 #define AUD_VOLUMEREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class reads another reader and changes it's volume.
@@ -38,28 +38,25 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The volume level.
 	 */
-	float m_volume;
+	const float m_volume;
+
+	// hide copy constructor and operator=
+	AUD_VolumeReader(const AUD_VolumeReader&);
+	AUD_VolumeReader& operator=(const AUD_VolumeReader&);
 
 public:
 	/**
 	 * Creates a new volume reader.
 	 * \param reader The reader to read from.
 	 * \param volume The size of the buffer.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_VolumeReader(AUD_IReader* reader, float volume);
 
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_VolumeReader();
-
-	virtual bool notify(AUD_Message &message);
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp b/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp
index 796764989ba..729d4acc077 100644
--- a/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp
+++ b/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp
@@ -24,8 +24,9 @@
  */
 
 #include "AUD_OpenALDevice.h"
+#include "AUD_IFactory.h"
 #include "AUD_IReader.h"
-#include "AUD_ConverterFactory.h"
+#include "AUD_ConverterReader.h"
 #include "AUD_SourceCaps.h"
 
 #include <cstring>
@@ -302,12 +303,7 @@ AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize)
 
 	// check for specific formats and channel counts to be played back
 	if(alIsExtensionPresent("AL_EXT_FLOAT32") == AL_TRUE)
-	{
 		specs.format = AUD_FORMAT_FLOAT32;
-		m_converter = NULL;
-	}
-	else
-		m_converter = new AUD_ConverterFactory(specs); AUD_NEW("factory")
 
 	m_useMC = alIsExtensionPresent("AL_EXT_MCFORMATS") == AL_TRUE;
 
@@ -317,10 +313,9 @@ AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize)
 	m_buffersize = buffersize;
 	m_playing = false;
 
-	m_playingSounds = new std::list<AUD_OpenALHandle*>(); AUD_NEW("list")
-	m_pausedSounds = new std::list<AUD_OpenALHandle*>(); AUD_NEW("list")
+	m_playingSounds = new std::list<AUD_OpenALHandle*>();
+	m_pausedSounds = new std::list<AUD_OpenALHandle*>();
 	m_bufferedFactories = new std::list<AUD_OpenALBufferedFactory*>();
-	AUD_NEW("list")
 
 	pthread_mutexattr_t attr;
 	pthread_mutexattr_init(&attr);
@@ -345,10 +340,10 @@ AUD_OpenALDevice::~AUD_OpenALDevice()
 		alDeleteSources(1, &sound->source);
 		if(!sound->isBuffered)
 		{
-			delete sound->reader; AUD_DELETE("reader")
+			delete sound->reader;
 			alDeleteBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 		}
-		delete sound; AUD_DELETE("handle")
+		delete sound;
 		m_playingSounds->erase(m_playingSounds->begin());
 	}
 
@@ -359,10 +354,10 @@ AUD_OpenALDevice::~AUD_OpenALDevice()
 		alDeleteSources(1, &sound->source);
 		if(!sound->isBuffered)
 		{
-			delete sound->reader; AUD_DELETE("reader")
+			delete sound->reader;
 			alDeleteBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 		}
-		delete sound; AUD_DELETE("handle")
+		delete sound;
 		m_pausedSounds->erase(m_pausedSounds->begin());
 	}
 
@@ -370,7 +365,7 @@ AUD_OpenALDevice::~AUD_OpenALDevice()
 	while(!m_bufferedFactories->empty())
 	{
 		alDeleteBuffers(1, &(*(m_bufferedFactories->begin()))->buffer);
-		delete *m_bufferedFactories->begin(); AUD_DELETE("bufferedfactory");
+		delete *m_bufferedFactories->begin();
 		m_bufferedFactories->erase(m_bufferedFactories->begin());
 	}
 
@@ -385,22 +380,19 @@ AUD_OpenALDevice::~AUD_OpenALDevice()
 	else
 		unlock();
 
-	delete m_playingSounds; AUD_DELETE("list")
-	delete m_pausedSounds; AUD_DELETE("list")
-	delete m_bufferedFactories; AUD_DELETE("list")
+	delete m_playingSounds;
+	delete m_pausedSounds;
+	delete m_bufferedFactories;
 
 	// quit OpenAL
 	alcMakeContextCurrent(NULL);
 	alcDestroyContext(m_context);
 	alcCloseDevice(m_device);
 
-	if(m_converter)
-		delete m_converter; AUD_DELETE("factory")
-
 	pthread_mutex_destroy(&m_mutex);
 }
 
-AUD_DeviceSpecs AUD_OpenALDevice::getSpecs()
+AUD_DeviceSpecs AUD_OpenALDevice::getSpecs() const
 {
 	return m_specs;
 }
@@ -511,7 +503,7 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 			if((*i)->factory == factory)
 			{
 				// create the handle
-				sound = new AUD_OpenALHandle; AUD_NEW("handle")
+				sound = new AUD_OpenALHandle;
 				sound->keep = keep;
 				sound->current = -1;
 				sound->isBuffered = true;
@@ -532,15 +524,15 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 						if(alGetError() != AL_NO_ERROR)
 							AUD_THROW(AUD_ERROR_OPENAL);
 					}
-					catch(AUD_Exception)
+					catch(AUD_Exception&)
 					{
 						alDeleteSources(1, &sound->source);
 						throw;
 					}
 				}
-				catch(AUD_Exception)
+				catch(AUD_Exception&)
 				{
-					delete sound; AUD_DELETE("handle")
+					delete sound;
 					alcProcessContext(m_context);
 					throw;
 				}
@@ -555,7 +547,7 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 			}
 		}
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		unlock();
 		throw;
@@ -577,14 +569,11 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 	// check format
 	bool valid = specs.channels != AUD_CHANNELS_INVALID;
 
-	if(m_converter)
-	{
-		m_converter->setReader(reader);
-		reader = m_converter->createReader();
-	}
+	if(m_specs.format != AUD_FORMAT_FLOAT32)
+		reader = new AUD_ConverterReader(reader, m_specs);
 
 	// create the handle
-	sound = new AUD_OpenALHandle; AUD_NEW("handle")
+	sound = new AUD_OpenALHandle;
 	sound->keep = keep;
 	sound->reader = reader;
 	sound->current = 0;
@@ -595,8 +584,8 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 
 	if(!valid)
 	{
-		delete sound; AUD_DELETE("handle")
-		delete reader; AUD_DELETE("reader")
+		delete sound;
+		delete reader;
 		return NULL;
 	}
 
@@ -637,22 +626,22 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 				if(alGetError() != AL_NO_ERROR)
 					AUD_THROW(AUD_ERROR_OPENAL);
 			}
-			catch(AUD_Exception)
+			catch(AUD_Exception&)
 			{
 				alDeleteSources(1, &sound->source);
 				throw;
 			}
 		}
-		catch(AUD_Exception)
+		catch(AUD_Exception&)
 		{
 			alDeleteBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 			throw;
 		}
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
-		delete sound; AUD_DELETE("handle")
-		delete reader; AUD_DELETE("reader")
+		delete sound;
+		delete reader;
 		alcProcessContext(m_context);
 		unlock();
 		throw;
@@ -737,10 +726,10 @@ bool AUD_OpenALDevice::stop(AUD_Handle* handle)
 			alDeleteSources(1, &sound->source);
 			if(!sound->isBuffered)
 			{
-				delete sound->reader; AUD_DELETE("reader")
+				delete sound->reader;
 				alDeleteBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 			}
-			delete *i; AUD_DELETE("handle")
+			delete *i;
 			m_playingSounds->erase(i);
 			result = true;
 			break;
@@ -757,10 +746,10 @@ bool AUD_OpenALDevice::stop(AUD_Handle* handle)
 				alDeleteSources(1, &sound->source);
 				if(!sound->isBuffered)
 				{
-					delete sound->reader; AUD_DELETE("reader")
+					delete sound->reader;
 					alDeleteBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 				}
-				delete *i; AUD_DELETE("handle")
+				delete *i;
 				m_pausedSounds->erase(i);
 				result = true;
 				break;
@@ -790,32 +779,6 @@ bool AUD_OpenALDevice::setKeep(AUD_Handle* handle, bool keep)
 	return result;
 }
 
-bool AUD_OpenALDevice::sendMessage(AUD_Handle* handle, AUD_Message &message)
-{
-	bool result = false;
-
-	lock();
-
-	if(handle == 0)
-	{
-		for(AUD_HandleIterator i = m_playingSounds->begin();
-			i != m_playingSounds->end(); i++)
-			if(!(*i)->isBuffered)
-				result |= (*i)->reader->notify(message);
-		for(AUD_HandleIterator i = m_pausedSounds->begin();
-			i != m_pausedSounds->end(); i++)
-			if(!(*i)->isBuffered)
-				result |= (*i)->reader->notify(message);
-	}
-	else if(isValid(handle))
-		if(!((AUD_OpenALHandle*)handle)->isBuffered)
-			result = ((AUD_OpenALHandle*)handle)->reader->notify(message);
-
-	unlock();
-
-	return result;
-}
-
 bool AUD_OpenALDevice::seek(AUD_Handle* handle, float position)
 {
 	bool result = false;
@@ -1024,26 +987,14 @@ bool AUD_OpenALDevice::setCapability(int capability, void *value)
 				AUD_DeviceSpecs specs = m_specs;
 				specs.specs = reader->getSpecs();
 
-				// determine format
-				bool valid = reader->getType() == AUD_TYPE_BUFFER;
-
-				if(valid)
-				{
-					if(m_converter)
-					{
-						m_converter->setReader(reader);
-						reader = m_converter->createReader();
-					}
-				}
+				if(m_specs.format != AUD_FORMAT_FLOAT32)
+					reader = new AUD_ConverterReader(reader, m_specs);
 
 				ALenum format;
 
-				if(valid)
-					valid = getFormat(format, specs.specs);
-
-				if(!valid)
+				if(!getFormat(format, specs.specs))
 				{
-					delete reader; AUD_DELETE("reader")
+					delete reader;
 					return false;
 				}
 
@@ -1052,7 +1003,6 @@ bool AUD_OpenALDevice::setCapability(int capability, void *value)
 				alcSuspendContext(m_context);
 
 				AUD_OpenALBufferedFactory* bf = new AUD_OpenALBufferedFactory;
-				AUD_NEW("bufferedfactory");
 				bf->factory = factory;
 
 				try
@@ -1073,16 +1023,16 @@ bool AUD_OpenALDevice::setCapability(int capability, void *value)
 						if(alGetError() != AL_NO_ERROR)
 							AUD_THROW(AUD_ERROR_OPENAL);
 					}
-					catch(AUD_Exception)
+					catch(AUD_Exception&)
 					{
 						alDeleteBuffers(1, &bf->buffer);
 						throw;
 					}
 				}
-				catch(AUD_Exception)
+				catch(AUD_Exception&)
 				{
-					delete bf; AUD_DELETE("bufferedfactory")
-					delete reader; AUD_DELETE("reader")
+					delete bf;
+					delete reader;
 					alcProcessContext(m_context);
 					unlock();
 					return false;
@@ -1116,7 +1066,6 @@ bool AUD_OpenALDevice::setCapability(int capability, void *value)
 					alDeleteBuffers(1,
 									&(*(m_bufferedFactories->begin()))->buffer);
 					delete *m_bufferedFactories->begin();
-					AUD_DELETE("bufferedfactory");
 					m_bufferedFactories->erase(m_bufferedFactories->begin());
 				}
 				unlock();
diff --git a/intern/audaspace/OpenAL/AUD_OpenALDevice.h b/intern/audaspace/OpenAL/AUD_OpenALDevice.h
index cb8c83ab810..c36f89209d3 100644
--- a/intern/audaspace/OpenAL/AUD_OpenALDevice.h
+++ b/intern/audaspace/OpenAL/AUD_OpenALDevice.h
@@ -30,7 +30,6 @@
 #include "AUD_I3DDevice.h"
 struct AUD_OpenALHandle;
 struct AUD_OpenALBufferedFactory;
-class AUD_ConverterFactory;
 
 #include <AL/al.h>
 #include <AL/alc.h>
@@ -64,11 +63,6 @@ private:
 	bool m_useMC;
 
 	/**
-	* The converter factory for readers with wrong input format.
-	*/
-	AUD_ConverterFactory* m_converter;
-
-	/**
 	 * The list of sounds that are currently playing.
 	 */
 	std::list<AUD_OpenALHandle*>* m_playingSounds;
@@ -123,6 +117,10 @@ private:
 	 */
 	bool getFormat(ALenum &format, AUD_Specs specs);
 
+	// hide copy constructor and operator=
+	AUD_OpenALDevice(const AUD_OpenALDevice&);
+	AUD_OpenALDevice& operator=(const AUD_OpenALDevice&);
+
 public:
 	/**
 	 * Opens the OpenAL audio device for playback.
@@ -142,13 +140,12 @@ public:
 
 	virtual ~AUD_OpenALDevice();
 
-	virtual AUD_DeviceSpecs getSpecs();
+	virtual AUD_DeviceSpecs getSpecs() const;
 	virtual AUD_Handle* play(AUD_IFactory* factory, bool keep = false);
 	virtual bool pause(AUD_Handle* handle);
 	virtual bool resume(AUD_Handle* handle);
 	virtual bool stop(AUD_Handle* handle);
 	virtual bool setKeep(AUD_Handle* handle, bool keep);
-	virtual bool sendMessage(AUD_Handle* handle, AUD_Message &message);
 	virtual bool seek(AUD_Handle* handle, float position);
 	virtual float getPosition(AUD_Handle* handle);
 	virtual AUD_Status getStatus(AUD_Handle* handle);
diff --git a/intern/audaspace/Python/AUD_PyAPI.cpp b/intern/audaspace/Python/AUD_PyAPI.cpp
index f1c41bf2009..30e4bf5b9fd 100644
--- a/intern/audaspace/Python/AUD_PyAPI.cpp
+++ b/intern/audaspace/Python/AUD_PyAPI.cpp
@@ -425,10 +425,10 @@ static PyTypeObject SoundType = {
 static PyObject *
 Sound_sine(PyObject* nothing, PyObject* args)
 {
-	double frequency;
+	float frequency;
 	int rate = 44100;
 
-	if(!PyArg_ParseTuple(args, "d|i", &frequency, &rate))
+	if(!PyArg_ParseTuple(args, "f|i", &frequency, &rate))
 		return NULL;
 
 	Sound *self;
@@ -1266,13 +1266,14 @@ Handle_set_loop_count(Handle *self, PyObject* args, void* nothing)
 
 	try
 	{
+		/* AUD_XXX Doesn't work atm, will come back
 		AUD_Message message;
 		message.loopcount = loops;
 		message.type = AUD_MSG_LOOP;
 		if(device->device->sendMessage(self->handle, message))
 		{
 			return 0;
-		}
+		}*/
 	}
 	catch(AUD_Exception&)
 	{
diff --git a/intern/audaspace/SDL/AUD_SDLDevice.h b/intern/audaspace/SDL/AUD_SDLDevice.h
index 4b7de1996e8..af713b27480 100644
--- a/intern/audaspace/SDL/AUD_SDLDevice.h
+++ b/intern/audaspace/SDL/AUD_SDLDevice.h
@@ -44,6 +44,10 @@ private:
 	 */
 	static void SDL_mix(void *data, Uint8* buffer, int length);
 
+	// hide copy constructor and operator=
+	AUD_SDLDevice(const AUD_SDLDevice&);
+	AUD_SDLDevice& operator=(const AUD_SDLDevice&);
+
 protected:
 	virtual void playing(bool playing);
 
diff --git a/intern/audaspace/SRC/AUD_SRCResampleFactory.cpp b/intern/audaspace/SRC/AUD_SRCResampleFactory.cpp
index caafbd14327..b421bb777e1 100644
--- a/intern/audaspace/SRC/AUD_SRCResampleFactory.cpp
+++ b/intern/audaspace/SRC/AUD_SRCResampleFactory.cpp
@@ -26,28 +26,18 @@
 #include "AUD_SRCResampleFactory.h"
 #include "AUD_SRCResampleReader.h"
 
-AUD_SRCResampleFactory::AUD_SRCResampleFactory(AUD_IReader* reader,
-											   AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(reader, specs) {}
-
 AUD_SRCResampleFactory::AUD_SRCResampleFactory(AUD_IFactory* factory,
 											   AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(factory, specs) {}
-
-AUD_SRCResampleFactory::AUD_SRCResampleFactory(AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(specs) {}
+		AUD_ResampleFactory(factory, specs)
+{
+}
 
-AUD_IReader* AUD_SRCResampleFactory::createReader()
+AUD_IReader* AUD_SRCResampleFactory::createReader() const
 {
 	AUD_IReader* reader = getReader();
 
-	if(reader != 0)
-	{
-		if(reader->getSpecs().rate != m_specs.rate)
-		{
-			reader = new AUD_SRCResampleReader(reader, m_specs.specs);
-			AUD_NEW("reader")
-		}
-	}
+	if(reader->getSpecs().rate != m_specs.rate)
+		reader = new AUD_SRCResampleReader(reader, m_specs.specs);
+
 	return reader;
 }
diff --git a/intern/audaspace/SRC/AUD_SRCResampleFactory.h b/intern/audaspace/SRC/AUD_SRCResampleFactory.h
index 4b16c70169c..4edb0e76181 100644
--- a/intern/audaspace/SRC/AUD_SRCResampleFactory.h
+++ b/intern/audaspace/SRC/AUD_SRCResampleFactory.h
@@ -34,12 +34,15 @@
  */
 class AUD_SRCResampleFactory : public AUD_ResampleFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_SRCResampleFactory(const AUD_SRCResampleFactory&);
+	AUD_SRCResampleFactory& operator=(const AUD_SRCResampleFactory&);
+
 public:
-	AUD_SRCResampleFactory(AUD_IReader* reader, AUD_DeviceSpecs specs);
 	AUD_SRCResampleFactory(AUD_IFactory* factory, AUD_DeviceSpecs specs);
-	AUD_SRCResampleFactory(AUD_DeviceSpecs specs);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SRCRESAMPLEFACTORY
diff --git a/intern/audaspace/SRC/AUD_SRCResampleReader.cpp b/intern/audaspace/SRC/AUD_SRCResampleReader.cpp
index e89857635de..553a020e76d 100644
--- a/intern/audaspace/SRC/AUD_SRCResampleReader.cpp
+++ b/intern/audaspace/SRC/AUD_SRCResampleReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_SRCResampleReader.h"
-#include "AUD_Buffer.h"
 
 #include <cmath>
 #include <cstring>
@@ -37,14 +36,13 @@ static long src_callback(void *cb_data, float **data)
 
 AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_IReader* reader,
 											 AUD_Specs specs) :
-		AUD_EffectReader(reader)
+		AUD_EffectReader(reader),
+		m_sspecs(reader->getSpecs()),
+		m_factor(double(specs.rate) / double(m_sspecs.rate)),
+		m_tspecs(specs),
+		m_position(0)
 {
-	m_sspecs = reader->getSpecs();
-
-	m_tspecs = specs;
 	m_tspecs.channels = m_sspecs.channels;
-	m_factor = (double)m_tspecs.rate / (double)m_sspecs.rate;
-	m_position = 0;
 
 	int error;
 	m_src = src_callback_new(src_callback,
@@ -56,23 +54,19 @@ AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_IReader* reader,
 	if(!m_src)
 	{
 		// XXX printf("%s\n", src_strerror(error));
-		delete m_reader; AUD_DELETE("reader")
+		delete m_reader;
 		AUD_THROW(AUD_ERROR_READER);
 	}
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
 AUD_SRCResampleReader::~AUD_SRCResampleReader()
 {
 	src_delete(m_src);
-
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
 long AUD_SRCResampleReader::doCallback(float** data)
 {
-	int length = m_buffer->getSize() / AUD_SAMPLE_SIZE(m_tspecs);
+	int length = m_buffer.getSize() / AUD_SAMPLE_SIZE(m_tspecs);
 	sample_t* buffer;
 
 	m_reader->read(length, buffer);
@@ -88,17 +82,17 @@ void AUD_SRCResampleReader::seek(int position)
 	m_position = position;
 }
 
-int AUD_SRCResampleReader::getLength()
+int AUD_SRCResampleReader::getLength() const
 {
 	return m_reader->getLength() * m_factor;
 }
 
-int AUD_SRCResampleReader::getPosition()
+int AUD_SRCResampleReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_SRCResampleReader::getSpecs()
+AUD_Specs AUD_SRCResampleReader::getSpecs() const
 {
 	return m_tspecs;
 }
@@ -107,10 +101,10 @@ 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);
+	if(m_buffer.getSize() < size)
+		m_buffer.resize(size);
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	length = src_callback_read(m_src, m_factor, length, buffer);
 
diff --git a/intern/audaspace/SRC/AUD_SRCResampleReader.h b/intern/audaspace/SRC/AUD_SRCResampleReader.h
index e09d1b66f13..5e3dafb359b 100644
--- a/intern/audaspace/SRC/AUD_SRCResampleReader.h
+++ b/intern/audaspace/SRC/AUD_SRCResampleReader.h
@@ -27,7 +27,7 @@
 #define AUD_SRCRESAMPLEREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 #include <samplerate.h>
 
@@ -38,14 +38,19 @@ class AUD_SRCResampleReader : public AUD_EffectReader
 {
 private:
 	/**
+	 * The sample specification of the source.
+	 */
+	const AUD_Specs m_sspecs;
+
+	/**
 	 * The resampling factor.
 	 */
-	double m_factor;
+	const double m_factor;
 
 	/**
 	 * The sound output buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The target specification.
@@ -53,11 +58,6 @@ private:
 	AUD_Specs m_tspecs;
 
 	/**
-	 * The sample specification of the source.
-	 */
-	AUD_Specs m_sspecs;
-
-	/**
 	 * The src state structure.
 	 */
 	SRC_STATE* m_src;
@@ -67,14 +67,17 @@ private:
 	 */
 	int m_position;
 
+	// hide copy constructor and operator=
+	AUD_SRCResampleReader(const AUD_SRCResampleReader&);
+	AUD_SRCResampleReader& operator=(const AUD_SRCResampleReader&);
+
 public:
 	/**
 	 * Creates a resampling reader.
 	 * \param reader The reader to mix.
 	 * \param specs The target specification.
 	 * \exception AUD_Exception Thrown if the source specification cannot be
-	 *            mixed to the target specification or if the reader is
-	 *            NULL.
+	 *            resampled to the target specification.
 	 */
 	AUD_SRCResampleReader(AUD_IReader* reader, AUD_Specs specs);
 
@@ -92,9 +95,9 @@ public:
 	long doCallback(float** data);
 
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.cpp b/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.cpp
index 8e71c97baec..cad64d70790 100644
--- a/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.cpp
+++ b/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.cpp
@@ -24,45 +24,29 @@
  */
 
 // needed for INT64_C
+#ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
+#endif
 
 #include "AUD_FFMPEGFactory.h"
 #include "AUD_FFMPEGReader.h"
 #include "AUD_Buffer.h"
 
-AUD_FFMPEGFactory::AUD_FFMPEGFactory(const char* filename)
+AUD_FFMPEGFactory::AUD_FFMPEGFactory(std::string filename) :
+		m_filename(filename)
 {
-	if(filename != NULL)
-	{
-		m_filename = new char[strlen(filename)+1]; AUD_NEW("string")
-		strcpy(m_filename, filename);
-	}
-	else
-		m_filename = NULL;
 }
 
-AUD_FFMPEGFactory::AUD_FFMPEGFactory(unsigned char* buffer, int size)
+AUD_FFMPEGFactory::AUD_FFMPEGFactory(const data_t* buffer, int size) :
+		m_buffer(new AUD_Buffer(size))
 {
-	m_filename = NULL;
-	m_buffer = AUD_Reference<AUD_Buffer>(new AUD_Buffer(size));
 	memcpy(m_buffer.get()->getBuffer(), buffer, size);
 }
 
-AUD_FFMPEGFactory::~AUD_FFMPEGFactory()
-{
-	if(m_filename)
-	{
-		delete[] m_filename; AUD_DELETE("string")
-	}
-}
-
-AUD_IReader* AUD_FFMPEGFactory::createReader()
+AUD_IReader* AUD_FFMPEGFactory::createReader() const
 {
-	AUD_IReader* reader;
-	if(m_filename)
-		reader = new AUD_FFMPEGReader(m_filename);
+	if(m_buffer.get())
+		return new AUD_FFMPEGReader(m_buffer);
 	else
-		reader = new AUD_FFMPEGReader(m_buffer);
-	AUD_NEW("reader")
-	return reader;
+		return new AUD_FFMPEGReader(m_filename);
 }
diff --git a/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.h b/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.h
index 22560303a73..43a6ce68ca7 100644
--- a/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.h
+++ b/intern/audaspace/ffmpeg/AUD_FFMPEGFactory.h
@@ -30,6 +30,8 @@
 #include "AUD_Reference.h"
 class AUD_Buffer;
 
+#include <string>
+
 /**
  * This factory reads a sound file via ffmpeg.
  * \warning Notice that the needed formats and codecs have to be registered
@@ -41,33 +43,32 @@ private:
 	/**
 	 * The filename of the sound source file.
 	 */
-	char* m_filename;
+	const std::string m_filename;
 
 	/**
 	 * The buffer to read from.
 	 */
 	AUD_Reference<AUD_Buffer> m_buffer;
 
+	// hide copy constructor and operator=
+	AUD_FFMPEGFactory(const AUD_FFMPEGFactory&);
+	AUD_FFMPEGFactory& operator=(const AUD_FFMPEGFactory&);
+
 public:
 	/**
 	 * Creates a new factory.
 	 * \param filename The sound file path.
 	 */
-	AUD_FFMPEGFactory(const char* filename);
+	AUD_FFMPEGFactory(std::string filename);
 
 	/**
 	 * Creates a new factory.
 	 * \param buffer The buffer to read from.
 	 * \param size The size of the buffer.
 	 */
-	AUD_FFMPEGFactory(unsigned char* buffer, int size);
-
-	/**
-	 * Destroys the factory.
-	 */
-	~AUD_FFMPEGFactory();
+	AUD_FFMPEGFactory(const data_t* buffer, int size);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_FFMPEGFACTORY
diff --git a/intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp b/intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp
index 313ea52e892..717838bc982 100644
--- a/intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp
+++ b/intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp
@@ -24,23 +24,24 @@
  */
 
 // needed for INT64_C
+#ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
+#endif
 
 #include "AUD_FFMPEGReader.h"
-#include "AUD_Buffer.h"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
 }
 
-int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer* buffer)
+int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer& buffer)
 {
 	// save packet parameters
 	uint8_t *audio_pkg_data = packet->data;
 	int audio_pkg_size = packet->size;
 
-	int buf_size = buffer->getSize();
+	int buf_size = buffer.getSize();
 	int buf_pos = 0;
 
 	int read_length, data_size;
@@ -51,21 +52,16 @@ int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer* buffer)
 		// resize buffer if needed
 		if(buf_size - buf_pos < AVCODEC_MAX_AUDIO_FRAME_SIZE)
 		{
-			buffer->resize(buf_size + AVCODEC_MAX_AUDIO_FRAME_SIZE, true);
+			buffer.resize(buf_size + AVCODEC_MAX_AUDIO_FRAME_SIZE, true);
 			buf_size += AVCODEC_MAX_AUDIO_FRAME_SIZE;
 		}
 
 		// read samples from the packet
 		data_size = buf_size - buf_pos;
-		/*read_length = avcodec_decode_audio3(m_codecCtx,
-			(int16_t*)(((data_t*)buffer->getBuffer())+buf_pos),
+		read_length = avcodec_decode_audio3(m_codecCtx,
+			(int16_t*)(((data_t*)buffer.getBuffer())+buf_pos),
 			&data_size,
-			packet);*/
-		read_length = avcodec_decode_audio2(m_codecCtx,
-			(int16_t*)(((data_t*)buffer->getBuffer())+buf_pos),
-			&data_size,
-			audio_pkg_data,
-			audio_pkg_size);
+			packet);
 
 		// read error, next packet!
 		if(read_length < 0)
@@ -93,12 +89,15 @@ void AUD_FFMPEGReader::init()
 	m_stream = -1;
 
 	for(unsigned int i = 0; i < m_formatCtx->nb_streams; i++)
+	{
 		if((m_formatCtx->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO)
 			&& (m_stream < 0))
 		{
 			m_stream=i;
 			break;
 		}
+	}
+
 	if(m_stream == -1)
 		AUD_THROW(AUD_ERROR_FFMPEG);
 
@@ -144,41 +143,39 @@ void AUD_FFMPEGReader::init()
 	}
 
 	m_specs.rate = (AUD_SampleRate) m_codecCtx->sample_rate;
-
-	// last but not least if there hasn't been any error, create the buffers
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-	m_pkgbuf = new AUD_Buffer(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1);
-	AUD_NEW("buffer")
 }
 
-AUD_FFMPEGReader::AUD_FFMPEGReader(const char* filename)
+AUD_FFMPEGReader::AUD_FFMPEGReader(std::string filename) :
+	m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
+	m_byteiocontext(NULL)
 {
-	m_byteiocontext = NULL;
-
 	// open file
-	if(av_open_input_file(&m_formatCtx, filename, NULL, 0, NULL)!=0)
+	if(av_open_input_file(&m_formatCtx, filename.c_str(), NULL, 0, NULL)!=0)
 		AUD_THROW(AUD_ERROR_FILE);
 
 	try
 	{
 		init();
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		av_close_input_file(m_formatCtx);
 		throw;
 	}
 }
 
-AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer)
+AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer) :
+		m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
+		m_membuffer(buffer)
 {
 	m_byteiocontext = (ByteIOContext*)av_mallocz(sizeof(ByteIOContext));
-	AUD_NEW("byteiocontext")
-	m_membuffer = buffer;
 
 	if(init_put_byte(m_byteiocontext, (data_t*)buffer.get()->getBuffer(),
 					 buffer.get()->getSize(), 0, NULL, NULL, NULL, NULL) != 0)
+	{
+		av_free(m_byteiocontext);
 		AUD_THROW(AUD_ERROR_FILE);
+	}
 
 	AVProbeData probe_data;
 	probe_data.filename = "";
@@ -188,16 +185,19 @@ AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer)
 
 	// open stream
 	if(av_open_input_stream(&m_formatCtx, m_byteiocontext, "", fmt, NULL)!=0)
+	{
+		av_free(m_byteiocontext);
 		AUD_THROW(AUD_ERROR_FILE);
+	}
 
 	try
 	{
 		init();
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		av_close_input_stream(m_formatCtx);
-		av_free(m_byteiocontext); AUD_DELETE("byteiocontext")
+		av_free(m_byteiocontext);
 		throw;
 	}
 }
@@ -209,16 +209,13 @@ AUD_FFMPEGReader::~AUD_FFMPEGReader()
 	if(m_byteiocontext)
 	{
 		av_close_input_stream(m_formatCtx);
-		av_free(m_byteiocontext); AUD_DELETE("byteiocontext")
+		av_free(m_byteiocontext);
 	}
 	else
 		av_close_input_file(m_formatCtx);
-
-	delete m_buffer; AUD_DELETE("buffer")
-	delete m_pkgbuf; AUD_DELETE("buffer")
 }
 
-bool AUD_FFMPEGReader::isSeekable()
+bool AUD_FFMPEGReader::isSeekable() const
 {
 	return true;
 }
@@ -260,9 +257,17 @@ void AUD_FFMPEGReader::seek(int position)
 
 						if(m_position < position)
 						{
-							sample_t* buf;
-							int length = position - m_position;
-							read(length, buf);
+							// read until we're at the right position
+							int length = AUD_DEFAULT_BUFFER_SIZE;
+							sample_t* buffer;
+							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);
+							}
 						}
 					}
 				}
@@ -276,33 +281,23 @@ void AUD_FFMPEGReader::seek(int position)
 	}
 }
 
-int AUD_FFMPEGReader::getLength()
+int AUD_FFMPEGReader::getLength() const
 {
 	// return approximated remaning size
 	return (int)((m_formatCtx->duration * m_codecCtx->sample_rate)
 				 / AV_TIME_BASE)-m_position;
 }
 
-int AUD_FFMPEGReader::getPosition()
+int AUD_FFMPEGReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_FFMPEGReader::getSpecs()
+AUD_Specs AUD_FFMPEGReader::getSpecs() const
 {
 	return m_specs.specs;
 }
 
-AUD_ReaderType AUD_FFMPEGReader::getType()
-{
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_FFMPEGReader::notify(AUD_Message &message)
-{
-	return false;
-}
-
 void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 {
 	// read packages and decode them
@@ -313,10 +308,10 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 	int sample_size = AUD_DEVICE_SAMPLE_SIZE(m_specs);
 
 	// resize output buffer if necessary
-	if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(m_specs))
-		m_buffer->resize(length * AUD_SAMPLE_SIZE(m_specs));
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs));
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	pkgbuf_pos = m_pkgbuf_left;
 	m_pkgbuf_left = 0;
 
@@ -324,7 +319,7 @@ 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*) buffer, (data_t*) m_pkgbuf.getBuffer(),
 				  data_size / AUD_FORMAT_SIZE(m_specs.format));
 		buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
 		left -= data_size/sample_size;
@@ -341,7 +336,7 @@ 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*) buffer, (data_t*) m_pkgbuf.getBuffer(),
 					  data_size / AUD_FORMAT_SIZE(m_specs.format));
 			buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
 			left -= data_size/sample_size;
@@ -352,12 +347,12 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 	if(pkgbuf_pos > data_size)
 	{
 		m_pkgbuf_left = pkgbuf_pos-data_size;
-		memmove(m_pkgbuf->getBuffer(),
-				((data_t*)m_pkgbuf->getBuffer())+data_size,
+		memmove(m_pkgbuf.getBuffer(),
+				((data_t*)m_pkgbuf.getBuffer())+data_size,
 				pkgbuf_pos-data_size);
 	}
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	if(left > 0)
 		length -= left;
diff --git a/intern/audaspace/ffmpeg/AUD_FFMPEGReader.h b/intern/audaspace/ffmpeg/AUD_FFMPEGReader.h
index f992fdf7a34..8ebf5b45cdc 100644
--- a/intern/audaspace/ffmpeg/AUD_FFMPEGReader.h
+++ b/intern/audaspace/ffmpeg/AUD_FFMPEGReader.h
@@ -29,7 +29,9 @@
 #include "AUD_ConverterFunctions.h"
 #include "AUD_IReader.h"
 #include "AUD_Reference.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
+
+#include <string>
 
 struct AVCodecContext;
 extern "C" {
@@ -55,7 +57,7 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The specification of the audio data.
@@ -65,7 +67,7 @@ private:
 	/**
 	 * The buffer for package reading.
 	 */
-	AUD_Buffer *m_pkgbuf;
+	AUD_Buffer m_pkgbuf;
 
 	/**
 	 * The count of samples still available from the last read package.
@@ -108,13 +110,17 @@ private:
 	 * \param buffer The target buffer.
 	 * \return The count of read bytes.
 	 */
-	int decode(AVPacket* packet, AUD_Buffer* buffer);
+	int decode(AVPacket* packet, AUD_Buffer& buffer);
 
 	/**
 	 * Initializes the object.
 	 */
 	void init();
 
+	// hide copy constructor and operator=
+	AUD_FFMPEGReader(const AUD_FFMPEGReader&);
+	AUD_FFMPEGReader& operator=(const AUD_FFMPEGReader&);
+
 public:
 	/**
 	 * Creates a new reader.
@@ -122,7 +128,7 @@ public:
 	 * \exception AUD_Exception Thrown if the file specified does not exist or
 	 *            cannot be read with ffmpeg.
 	 */
-	AUD_FFMPEGReader(const char* filename);
+	AUD_FFMPEGReader(std::string filename);
 
 	/**
 	 * Creates a new reader.
@@ -137,13 +143,11 @@ public:
 	 */
 	virtual ~AUD_FFMPEGReader();
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/fftw/AUD_BandPassReader.h b/intern/audaspace/fftw/AUD_BandPassReader.h
index 7a8fd3b94d5..bb63a3ec818 100644
--- a/intern/audaspace/fftw/AUD_BandPassReader.h
+++ b/intern/audaspace/fftw/AUD_BandPassReader.h
@@ -83,7 +83,6 @@ public:
 	 * \param reader The reader to read from.
 	 * \param low The lowest passed frequency.
 	 * \param high The highest passed frequency.
-	 * \exception AUD_Exception Thrown if the reader specified is NULL.
 	 */
 	AUD_BandPassReader(AUD_IReader* reader, float low, float high);
 
diff --git a/intern/audaspace/intern/AUD_Buffer.cpp b/intern/audaspace/intern/AUD_Buffer.cpp
index a8e74a023bf..11eed399ca5 100644
--- a/intern/audaspace/intern/AUD_Buffer.cpp
+++ b/intern/audaspace/intern/AUD_Buffer.cpp
@@ -34,34 +34,37 @@
 AUD_Buffer::AUD_Buffer(int size)
 {
 	m_size = size;
-	m_buffer = (data_t*) malloc(size+16); AUD_NEW("buffer")
+	m_buffer = (data_t*) malloc(size+16);
 }
 
 AUD_Buffer::~AUD_Buffer()
 {
-	free(m_buffer); AUD_DELETE("buffer")
+	free(m_buffer);
 }
 
-sample_t* AUD_Buffer::getBuffer()
+sample_t* AUD_Buffer::getBuffer() const
 {
 	return (sample_t*) AUD_ALIGN(m_buffer);
 }
 
-int AUD_Buffer::getSize()
+int AUD_Buffer::getSize() const
 {
 	return m_size;
 }
 
 void AUD_Buffer::resize(int size, bool keep)
 {
-	data_t* buffer = (data_t*) malloc(size+16); AUD_NEW("buffer")
-
-	// copy old data over if wanted
 	if(keep)
+	{
+		data_t* buffer = (data_t*) malloc(size + 16);
+
 		memcpy(AUD_ALIGN(buffer), AUD_ALIGN(m_buffer), AUD_MIN(size, m_size));
 
-	free(m_buffer); AUD_DELETE("buffer")
+		free(m_buffer);
+		m_buffer = buffer;
+	}
+	else
+		m_buffer = (data_t*) realloc(m_buffer, size + 16);
 
-	m_buffer = buffer;
 	m_size = size;
 }
diff --git a/intern/audaspace/intern/AUD_Buffer.h b/intern/audaspace/intern/AUD_Buffer.h
index f745ee6154b..b3889b35ffe 100644
--- a/intern/audaspace/intern/AUD_Buffer.h
+++ b/intern/audaspace/intern/AUD_Buffer.h
@@ -41,6 +41,10 @@ private:
 	/// The pointer to the buffer memory.
 	data_t* m_buffer;
 
+	// hide copy constructor and operator=
+	AUD_Buffer(const AUD_Buffer&);
+	AUD_Buffer& operator=(const AUD_Buffer&);
+
 public:
 	/**
 	 * Creates a new buffer.
@@ -56,12 +60,12 @@ public:
 	/**
 	 * Returns the pointer to the buffer in memory.
 	 */
-	sample_t* getBuffer();
+	sample_t* getBuffer() const;
 
 	/**
 	 * Returns the size of the buffer in bytes.
 	 */
-	int getSize();
+	int getSize() const;
 
 	/**
 	 * Resizes the buffer.
diff --git a/intern/audaspace/intern/AUD_BufferReader.cpp b/intern/audaspace/intern/AUD_BufferReader.cpp
index 0101de338bd..d3af549a868 100644
--- a/intern/audaspace/intern/AUD_BufferReader.cpp
+++ b/intern/audaspace/intern/AUD_BufferReader.cpp
@@ -28,53 +28,36 @@
 #include "AUD_Space.h"
 
 AUD_BufferReader::AUD_BufferReader(AUD_Reference<AUD_Buffer> buffer,
-								   AUD_Specs specs)
+								   AUD_Specs specs) :
+	m_position(0), m_buffer(buffer), m_specs(specs)
 {
-	m_position = 0;
-	m_buffer = buffer;
-	m_specs = specs;
 }
 
-bool AUD_BufferReader::isSeekable()
+bool AUD_BufferReader::isSeekable() const
 {
 	return true;
 }
 
 void AUD_BufferReader::seek(int position)
 {
-	if(position < 0)
-		m_position = 0;
-	else if(position > m_buffer.get()->getSize() / AUD_SAMPLE_SIZE(m_specs))
-		m_position = m_buffer.get()->getSize() / AUD_SAMPLE_SIZE(m_specs);
-	else
-		m_position = position;
+	m_position = position;
 }
 
-int AUD_BufferReader::getLength()
+int AUD_BufferReader::getLength() const
 {
-	return m_buffer.get()->getSize()/AUD_SAMPLE_SIZE(m_specs);
+	return m_buffer.get()->getSize() / AUD_SAMPLE_SIZE(m_specs);
 }
 
-int AUD_BufferReader::getPosition()
+int AUD_BufferReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_BufferReader::getSpecs()
+AUD_Specs AUD_BufferReader::getSpecs() const
 {
 	return m_specs;
 }
 
-AUD_ReaderType AUD_BufferReader::getType()
-{
-	return AUD_TYPE_BUFFER;
-}
-
-bool AUD_BufferReader::notify(AUD_Message &message)
-{
-	return false;
-}
-
 void AUD_BufferReader::read(int & length, sample_t* & buffer)
 {
 	int sample_size = AUD_SAMPLE_SIZE(m_specs);
diff --git a/intern/audaspace/intern/AUD_BufferReader.h b/intern/audaspace/intern/AUD_BufferReader.h
index f2d8ff6b57d..a8bd89060b0 100644
--- a/intern/audaspace/intern/AUD_BufferReader.h
+++ b/intern/audaspace/intern/AUD_BufferReader.h
@@ -53,6 +53,10 @@ private:
 	 */
 	AUD_Specs m_specs;
 
+	// hide copy constructor and operator=
+	AUD_BufferReader(const AUD_BufferReader&);
+	AUD_BufferReader& operator=(const AUD_BufferReader&);
+
 public:
 	/**
 	 * Creates a new buffer reader.
@@ -61,13 +65,11 @@ public:
 	 */
 	AUD_BufferReader(AUD_Reference<AUD_Buffer> buffer, AUD_Specs specs);
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_C-API.cpp b/intern/audaspace/intern/AUD_C-API.cpp
index eb0e4fba8e9..905212531d1 100644
--- a/intern/audaspace/intern/AUD_C-API.cpp
+++ b/intern/audaspace/intern/AUD_C-API.cpp
@@ -155,7 +155,7 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
 
 		return true;
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return false;
 	}
@@ -284,7 +284,7 @@ AUD_Sound* AUD_bufferSound(AUD_Sound* sound)
 	{
 		return new AUD_StreamBufferFactory(sound);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -298,7 +298,7 @@ AUD_Sound* AUD_delaySound(AUD_Sound* sound, float delay)
 	{
 		return new AUD_DelayFactory(sound, delay);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -312,7 +312,7 @@ AUD_Sound* AUD_limitSound(AUD_Sound* sound, float start, float end)
 	{
 		return new AUD_LimiterFactory(sound, start, end);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -326,7 +326,7 @@ AUD_Sound* AUD_pingpongSound(AUD_Sound* sound)
 	{
 		return new AUD_PingPongFactory(sound);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -340,7 +340,7 @@ AUD_Sound* AUD_loopSound(AUD_Sound* sound)
 	{
 		return new AUD_LoopFactory(sound);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -350,6 +350,8 @@ int AUD_setLoop(AUD_Channel* handle, int loops, float time)
 {
 	if(handle)
 	{
+		/* AUD_XXX Doesn't work atm, will come back
+
 		AUD_Message message;
 		message.type = AUD_MSG_LOOP;
 		message.loopcount = loops;
@@ -359,9 +361,9 @@ int AUD_setLoop(AUD_Channel* handle, int loops, float time)
 		{
 			return AUD_device->sendMessage(handle, message);
 		}
-		catch(AUD_Exception)
+		catch(AUD_Exception&)
 		{
-		}
+		}*/
 	}
 	return false;
 }
@@ -374,7 +376,7 @@ AUD_Sound* AUD_rectifySound(AUD_Sound* sound)
 	{
 		return new AUD_RectifyFactory(sound);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -394,7 +396,7 @@ AUD_Channel* AUD_play(AUD_Sound* sound, int keep)
 	{
 		return AUD_device->play(sound, keep);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -455,7 +457,7 @@ AUD_Channel* AUD_play3D(AUD_Sound* sound, int keep)
 		else
 			return AUD_device->play(sound, keep);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -471,7 +473,7 @@ int AUD_updateListener(AUD_3DData* data)
 		if(AUD_3ddevice)
 			return AUD_3ddevice->updateListener(*data);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 	}
 	return false;
@@ -486,7 +488,7 @@ int AUD_set3DSetting(AUD_3DSetting setting, float value)
 		if(AUD_3ddevice)
 			return AUD_3ddevice->setSetting(setting, value);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 	}
 	return false;
@@ -501,7 +503,7 @@ float AUD_get3DSetting(AUD_3DSetting setting)
 		if(AUD_3ddevice)
 			return AUD_3ddevice->getSetting(setting);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 	}
 	return 0.0f;
@@ -519,7 +521,7 @@ int AUD_update3DSource(AUD_Channel* handle, AUD_3DData* data)
 			if(AUD_3ddevice)
 				return AUD_3ddevice->updateSource(handle, *data);
 		}
-		catch(AUD_Exception)
+		catch(AUD_Exception&)
 		{
 		}
 	}
@@ -538,7 +540,7 @@ int AUD_set3DSourceSetting(AUD_Channel* handle,
 			if(AUD_3ddevice)
 				return AUD_3ddevice->setSourceSetting(handle, setting, value);
 		}
-		catch(AUD_Exception)
+		catch(AUD_Exception&)
 		{
 		}
 	}
@@ -556,7 +558,7 @@ float AUD_get3DSourceSetting(AUD_Channel* handle, AUD_3DSourceSetting setting)
 			if(AUD_3ddevice)
 				return AUD_3ddevice->getSourceSetting(handle, setting);
 		}
-		catch(AUD_Exception)
+		catch(AUD_Exception&)
 		{
 		}
 	}
@@ -576,7 +578,7 @@ int AUD_setSoundVolume(AUD_Channel* handle, float volume)
 		{
 			return AUD_device->setCapability(AUD_CAPS_SOURCE_VOLUME, &caps);
 		}
-		catch(AUD_Exception) {}
+		catch(AUD_Exception&) {}
 	}
 	return false;
 }
@@ -594,7 +596,7 @@ int AUD_setSoundPitch(AUD_Channel* handle, float pitch)
 		{
 			return AUD_device->setCapability(AUD_CAPS_SOURCE_PITCH, &caps);
 		}
-		catch(AUD_Exception) {}
+		catch(AUD_Exception&) {}
 	}
 	return false;
 }
@@ -605,7 +607,7 @@ AUD_Device* AUD_openReadDevice(AUD_DeviceSpecs specs)
 	{
 		return new AUD_ReadDevice(specs);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -622,7 +624,7 @@ AUD_Channel* AUD_playDevice(AUD_Device* device, AUD_Sound* sound, float seek)
 		device->seek(handle, seek);
 		return handle;
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return NULL;
 	}
@@ -636,7 +638,7 @@ int AUD_setDeviceVolume(AUD_Device* device, float volume)
 	{
 		return device->setCapability(AUD_CAPS_VOLUME, &volume);
 	}
-	catch(AUD_Exception) {}
+	catch(AUD_Exception&) {}
 	
 	return false;
 }
@@ -655,7 +657,7 @@ int AUD_setDeviceSoundVolume(AUD_Device* device, AUD_Channel* handle,
 		{
 			return device->setCapability(AUD_CAPS_SOURCE_VOLUME, &caps);
 		}
-		catch(AUD_Exception) {}
+		catch(AUD_Exception&) {}
 	}
 	return false;
 }
@@ -669,7 +671,7 @@ int AUD_readDevice(AUD_Device* device, data_t* buffer, int length)
 	{
 		return device->read(buffer, length);
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		return false;
 	}
@@ -683,7 +685,7 @@ void AUD_closeReadDevice(AUD_Device* device)
 	{
 		delete device;
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 	}
 }
@@ -782,23 +784,16 @@ void AUD_muteSequencer(AUD_Sound* sequencer, AUD_SequencerEntry* entry, char mut
 
 int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length)
 {
-	AUD_IReader* reader = sound->createReader();
 	AUD_DeviceSpecs specs;
 	sample_t* buf;
 
-	specs.specs = reader->getSpecs();
+	specs.rate = AUD_RATE_INVALID;
 	specs.channels = AUD_CHANNELS_MONO;
-	specs.format = AUD_FORMAT_FLOAT32;
-
-	AUD_ChannelMapperFactory mapper(reader, specs);
-
-	if(!reader || reader->getType() != AUD_TYPE_BUFFER)
-		return -1;
+	specs.format = AUD_FORMAT_INVALID;
 
-	reader = mapper.createReader();
+	AUD_ChannelMapperFactory mapper(sound, specs);
 
-	if(!reader)
-		return -1;
+	AUD_IReader* reader = mapper.createReader();
 
 	int len = reader->getLength();
 	float samplejump = (float)len / (float)length;
@@ -827,7 +822,7 @@ int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length)
 		}
 	}
 
-	delete reader; AUD_DELETE("reader")
+	delete reader;
 
 	return length;
 }
@@ -894,16 +889,3 @@ int AUD_doesPlayback()
 #endif
 	return -1;
 }
-
-#ifdef AUD_DEBUG_MEMORY
-int AUD_References(int count, const char* text)
-{
-	static int m_count = 0;
-	m_count += count;
-	if(count > 0)
-		printf("+%s\n", text);
-	if(count < 0)
-		printf("-%s\n", text);
-	return m_count;
-}
-#endif
diff --git a/intern/audaspace/intern/AUD_ChannelMapperFactory.cpp b/intern/audaspace/intern/AUD_ChannelMapperFactory.cpp
index 3420ed16649..b3d5434b1e3 100644
--- a/intern/audaspace/intern/AUD_ChannelMapperFactory.cpp
+++ b/intern/audaspace/intern/AUD_ChannelMapperFactory.cpp
@@ -28,13 +28,6 @@
 
 #include <cstring>
 
-AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(AUD_IReader* reader,
-												   AUD_DeviceSpecs specs) :
-		AUD_MixerFactory(reader, specs)
-{
-	memset(m_mapping, 0, sizeof(m_mapping));
-}
-
 AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(AUD_IFactory* factory,
 												   AUD_DeviceSpecs specs) :
 		AUD_MixerFactory(factory, specs)
@@ -42,12 +35,6 @@ AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(AUD_IFactory* factory,
 	memset(m_mapping, 0, sizeof(m_mapping));
 }
 
-AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(AUD_DeviceSpecs specs) :
-		AUD_MixerFactory(specs)
-{
-	memset(m_mapping, 0, sizeof(m_mapping));
-}
-
 AUD_ChannelMapperFactory::~AUD_ChannelMapperFactory()
 {
 	for(int i = 1; i < 10; i++)
@@ -72,12 +59,12 @@ float** AUD_ChannelMapperFactory::getMapping(int ic)
 	{
 		int channels = m_specs.channels;
 
-		m_mapping[ic] = new float*[channels+1]; AUD_NEW("mapping")
+		m_mapping[ic] = new float*[channels+1];
 		m_mapping[ic][channels] = 0;
 
 		for(int i = 0; i < channels; i++)
 		{
-			m_mapping[ic][i] = new float[ic+1]; AUD_NEW("mapping")
+			m_mapping[ic][i] = new float[ic+1];
 			for(int j = 0; j <= ic; j++)
 				m_mapping[ic][i][j] = ((i == j) || (channels == 1) ||
 									   (ic == 0)) ? 1.0f : 0.0f;
@@ -99,27 +86,21 @@ void AUD_ChannelMapperFactory::deleteMapping(int ic)
 		{
 			if(m_mapping[ic][i] != 0)
 			{
-				delete[] m_mapping[ic][i]; AUD_DELETE("mapping")
+				delete[] m_mapping[ic][i];
 			}
 			else
 				break;
 		}
-		delete[] m_mapping[ic]; AUD_DELETE("mapping")
+		delete[] m_mapping[ic];
 		m_mapping[ic] = 0;
 	}
 }
 
-AUD_IReader* AUD_ChannelMapperFactory::createReader()
+AUD_IReader* AUD_ChannelMapperFactory::createReader() const
 {
 	AUD_IReader* reader = getReader();
+	int ic = reader->getSpecs().channels;
 
-	if(reader != 0)
-	{
-		int ic = reader->getSpecs().channels;
-
-		reader = new AUD_ChannelMapperReader(reader, getMapping(ic));
-		AUD_NEW("reader")
-	}
-
-	return reader;
+	return new AUD_ChannelMapperReader(reader,
+				   const_cast<AUD_ChannelMapperFactory*>(this)->getMapping(ic));
 }
diff --git a/intern/audaspace/intern/AUD_ChannelMapperFactory.h b/intern/audaspace/intern/AUD_ChannelMapperFactory.h
index a67bfa12123..2f315874421 100644
--- a/intern/audaspace/intern/AUD_ChannelMapperFactory.h
+++ b/intern/audaspace/intern/AUD_ChannelMapperFactory.h
@@ -40,10 +40,12 @@ private:
 	 */
 	float **m_mapping[9];
 
+	// hide copy constructor and operator=
+	AUD_ChannelMapperFactory(const AUD_ChannelMapperFactory&);
+	AUD_ChannelMapperFactory& operator=(const AUD_ChannelMapperFactory&);
+
 public:
-	AUD_ChannelMapperFactory(AUD_IReader* reader, AUD_DeviceSpecs specs);
 	AUD_ChannelMapperFactory(AUD_IFactory* factory, AUD_DeviceSpecs specs);
-	AUD_ChannelMapperFactory(AUD_DeviceSpecs specs);
 
 	virtual ~AUD_ChannelMapperFactory();
 
@@ -59,7 +61,7 @@ public:
 	 */
 	void deleteMapping(int ic);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_CHANNELMAPPERFACTORY
diff --git a/intern/audaspace/intern/AUD_ChannelMapperReader.cpp b/intern/audaspace/intern/AUD_ChannelMapperReader.cpp
index d78278219e8..71b9f35b3a4 100644
--- a/intern/audaspace/intern/AUD_ChannelMapperReader.cpp
+++ b/intern/audaspace/intern/AUD_ChannelMapperReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_ChannelMapperReader.h"
-#include "AUD_Buffer.h"
 
 AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_IReader* reader,
 												 float **mapping) :
@@ -36,7 +35,7 @@ AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_IReader* reader,
 	m_rch = m_specs.channels;
 	while(mapping[++channels] != 0);
 
-	m_mapping = new float*[channels]; AUD_NEW("mapping")
+	m_mapping = new float*[channels];
 	m_specs.channels = (AUD_Channels)channels;
 
 	float sum;
@@ -44,7 +43,7 @@ AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_IReader* reader,
 
 	while(channels--)
 	{
-		m_mapping[channels] = new float[m_rch]; AUD_NEW("mapping")
+		m_mapping[channels] = new float[m_rch];
 		sum = 0.0f;
 		for(i=0; i < m_rch; i++)
 			sum += mapping[channels][i];
@@ -52,8 +51,6 @@ AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_IReader* reader,
 			m_mapping[channels][i] = sum > 0.0f ?
 									 mapping[channels][i]/sum : 0.0f;
 	}
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
 AUD_ChannelMapperReader::~AUD_ChannelMapperReader()
@@ -62,42 +59,37 @@ AUD_ChannelMapperReader::~AUD_ChannelMapperReader()
 
 	while(channels--)
 	{
-		delete[] m_mapping[channels]; AUD_DELETE("mapping")
+		delete[] m_mapping[channels];
 	}
 
-	delete[] m_mapping; AUD_DELETE("mapping")
-
-	delete m_buffer; AUD_DELETE("buffer")
+	delete[] m_mapping;
 }
 
-AUD_Specs AUD_ChannelMapperReader::getSpecs()
+AUD_Specs AUD_ChannelMapperReader::getSpecs() const
 {
 	return m_specs;
 }
 
 void AUD_ChannelMapperReader::read(int & length, sample_t* & buffer)
 {
-	m_reader->read(length, buffer);
+	sample_t* in = buffer;
 
-	int channels = m_specs.channels;
+	m_reader->read(length, in);
 
-	if(m_buffer->getSize() < length * 4 * channels)
-		m_buffer->resize(length * 4 * channels);
+	if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs))
+		m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs));
 
-	sample_t* in = buffer;
-	sample_t* out = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	sample_t sum;
 
 	for(int i = 0; i < length; i++)
 	{
-		for(int j = 0; j < channels; j++)
+		for(int j = 0; j < m_specs.channels; j++)
 		{
 			sum = 0;
 			for(int k = 0; k < m_rch; k++)
 				sum += m_mapping[j][k] * in[i * m_rch + k];
-			out[i * channels + j] = sum;
+			buffer[i * m_specs.channels + j] = sum;
 		}
 	}
-
-	buffer = m_buffer->getBuffer();
 }
diff --git a/intern/audaspace/intern/AUD_ChannelMapperReader.h b/intern/audaspace/intern/AUD_ChannelMapperReader.h
index fe79ab6edd6..398e14da55d 100644
--- a/intern/audaspace/intern/AUD_ChannelMapperReader.h
+++ b/intern/audaspace/intern/AUD_ChannelMapperReader.h
@@ -27,7 +27,7 @@
 #define AUD_CHANNELMAPPERREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class maps a sound source's channels to a specific output channel count.
@@ -39,7 +39,7 @@ private:
 	/**
 	 * The sound output buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The output specification.
@@ -56,20 +56,24 @@ private:
 	 */
 	float **m_mapping;
 
+	// hide copy constructor and operator=
+	AUD_ChannelMapperReader(const AUD_ChannelMapperReader&);
+	AUD_ChannelMapperReader& operator=(const AUD_ChannelMapperReader&);
+
 public:
 	/**
 	 * Creates a channel mapper reader.
 	 * \param reader The reader to map.
 	 * \param mapping The mapping specification as two dimensional float array.
-	 * \exception AUD_Exception Thrown if the reader is NULL.
 	 */
 	AUD_ChannelMapperReader(AUD_IReader* reader, float **mapping);
+
 	/**
 	 * Destroys the reader.
 	 */
 	~AUD_ChannelMapperReader();
 
-	virtual AUD_Specs getSpecs();
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_ConverterFactory.cpp b/intern/audaspace/intern/AUD_ConverterFactory.cpp
index 1c6d5468251..057d97fe794 100644
--- a/intern/audaspace/intern/AUD_ConverterFactory.cpp
+++ b/intern/audaspace/intern/AUD_ConverterFactory.cpp
@@ -26,29 +26,18 @@
 #include "AUD_ConverterFactory.h"
 #include "AUD_ConverterReader.h"
 
-AUD_ConverterFactory::AUD_ConverterFactory(AUD_IReader* reader,
-										   AUD_DeviceSpecs specs) :
-		AUD_MixerFactory(reader, specs) {}
-
 AUD_ConverterFactory::AUD_ConverterFactory(AUD_IFactory* factory,
 										   AUD_DeviceSpecs specs) :
-		AUD_MixerFactory(factory, specs) {}
-
-AUD_ConverterFactory::AUD_ConverterFactory(AUD_DeviceSpecs specs) :
-		AUD_MixerFactory(specs) {}
+		AUD_MixerFactory(factory, specs)
+{
+}
 
-AUD_IReader* AUD_ConverterFactory::createReader()
+AUD_IReader* AUD_ConverterFactory::createReader() const
 {
 	AUD_IReader* reader = getReader();
 
-	if(reader != 0)
-	{
-		if(m_specs.format != AUD_FORMAT_FLOAT32)
-		{
-			reader = new AUD_ConverterReader(reader, m_specs);
-			AUD_NEW("reader")
-		}
-	}
+	if(m_specs.format != AUD_FORMAT_FLOAT32)
+		reader = new AUD_ConverterReader(reader, m_specs);
 
 	return reader;
 }
diff --git a/intern/audaspace/intern/AUD_ConverterFactory.h b/intern/audaspace/intern/AUD_ConverterFactory.h
index 11ca6c9f0a8..3535616a4a6 100644
--- a/intern/audaspace/intern/AUD_ConverterFactory.h
+++ b/intern/audaspace/intern/AUD_ConverterFactory.h
@@ -34,12 +34,15 @@
  */
 class AUD_ConverterFactory : public AUD_MixerFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_ConverterFactory(const AUD_ConverterFactory&);
+	AUD_ConverterFactory& operator=(const AUD_ConverterFactory&);
+
 public:
-	AUD_ConverterFactory(AUD_IReader* reader, AUD_DeviceSpecs specs);
 	AUD_ConverterFactory(AUD_IFactory* factory, AUD_DeviceSpecs specs);
-	AUD_ConverterFactory(AUD_DeviceSpecs specs);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_CONVERTERFACTORY
diff --git a/intern/audaspace/intern/AUD_ConverterReader.cpp b/intern/audaspace/intern/AUD_ConverterReader.cpp
index 808144085bb..379a7c85851 100644
--- a/intern/audaspace/intern/AUD_ConverterReader.cpp
+++ b/intern/audaspace/intern/AUD_ConverterReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_ConverterReader.h"
-#include "AUD_Buffer.h"
 
 AUD_ConverterReader::AUD_ConverterReader(AUD_IReader* reader,
 										 AUD_DeviceSpecs specs) :
@@ -63,16 +62,9 @@ AUD_ConverterReader::AUD_ConverterReader(AUD_IReader* reader,
 	}
 
 	m_specs.format = specs.format;
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-}
-
-AUD_ConverterReader::~AUD_ConverterReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
-AUD_Specs AUD_ConverterReader::getSpecs()
+AUD_Specs AUD_ConverterReader::getSpecs() const
 {
 	return m_specs.specs;
 }
@@ -83,11 +75,11 @@ void AUD_ConverterReader::read(int & length, sample_t* & buffer)
 
 	int samplesize = AUD_SAMPLE_SIZE(m_specs);
 
-	if(m_buffer->getSize() < length*samplesize)
-		m_buffer->resize(length*samplesize);
+	if(m_buffer.getSize() < length * samplesize)
+		m_buffer.resize(length * samplesize);
 
-	m_convert((data_t*)m_buffer->getBuffer(), (data_t*)buffer,
+	m_convert((data_t*)m_buffer.getBuffer(), (data_t*)buffer,
 			  length * m_specs.channels);
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 }
diff --git a/intern/audaspace/intern/AUD_ConverterReader.h b/intern/audaspace/intern/AUD_ConverterReader.h
index ba49bbfd9ba..64a46fd63e6 100644
--- a/intern/audaspace/intern/AUD_ConverterReader.h
+++ b/intern/audaspace/intern/AUD_ConverterReader.h
@@ -28,7 +28,7 @@
 
 #include "AUD_EffectReader.h"
 #include "AUD_ConverterFunctions.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class converts a sound source from one to another format.
@@ -39,7 +39,7 @@ private:
 	/**
 	 * The sound output buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The target specification.
@@ -51,20 +51,19 @@ private:
 	 */
 	AUD_convert_f m_convert;
 
+	// hide copy constructor and operator=
+	AUD_ConverterReader(const AUD_ConverterReader&);
+	AUD_ConverterReader& operator=(const AUD_ConverterReader&);
+
 public:
 	/**
 	 * Creates a converter reader.
 	 * \param reader The reader to convert.
 	 * \param specs The target specification.
-	 * \exception AUD_Exception Thrown if the reader is NULL.
 	 */
 	AUD_ConverterReader(AUD_IReader* reader, AUD_DeviceSpecs specs);
-	/**
-	 * Destroys the reader.
-	 */
-	~AUD_ConverterReader();
 
-	virtual AUD_Specs getSpecs();
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_DefaultMixer.cpp b/intern/audaspace/intern/AUD_DefaultMixer.cpp
new file mode 100644
index 00000000000..12faa10d866
--- /dev/null
+++ b/intern/audaspace/intern/AUD_DefaultMixer.cpp
@@ -0,0 +1,63 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN LGPL LICENSE BLOCK *****
+ *
+ * Copyright 2009 Jörg Hermann Müller
+ *
+ * This file is part of AudaSpace.
+ *
+ * AudaSpace is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * AudaSpace 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * ***** END LGPL LICENSE BLOCK *****
+ */
+
+#include "AUD_DefaultMixer.h"
+#include "AUD_SRCResampleReader.h"
+#include "AUD_ChannelMapperReader.h"
+#include "AUD_ChannelMapperFactory.h"
+
+#include <cstring>
+
+AUD_DefaultMixer::AUD_DefaultMixer(AUD_DeviceSpecs specs) :
+	AUD_Mixer(specs)
+{
+}
+
+AUD_IReader* AUD_DefaultMixer::prepare(AUD_IReader* reader)
+{
+	// hacky for now, until a better channel mapper reader is available
+	AUD_ChannelMapperFactory cmf(NULL, m_specs);
+
+	AUD_Specs specs = reader->getSpecs();
+
+	// if channel count is lower in output, rechannel before resampling
+	if(specs.channels < m_specs.channels)
+	{
+		reader = new AUD_ChannelMapperReader(reader,
+											 cmf.getMapping(specs.channels));
+		specs.channels = m_specs.channels;
+	}
+
+	// resample
+	if(specs.rate != m_specs.rate)
+		reader = new AUD_SRCResampleReader(reader, m_specs.specs);
+
+	// rechannel
+	if(specs.channels != m_specs.channels)
+		reader = new AUD_ChannelMapperReader(reader,
+											 cmf.getMapping(specs.channels));
+
+	return reader;
+}
diff --git a/intern/audaspace/intern/AUD_DefaultMixer.h b/intern/audaspace/intern/AUD_DefaultMixer.h
new file mode 100644
index 00000000000..c2f69629c88
--- /dev/null
+++ b/intern/audaspace/intern/AUD_DefaultMixer.h
@@ -0,0 +1,53 @@
+/*
+ * $Id$
+ *
+ * ***** BEGIN LGPL LICENSE BLOCK *****
+ *
+ * Copyright 2009 Jörg Hermann Müller
+ *
+ * This file is part of AudaSpace.
+ *
+ * AudaSpace is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * AudaSpace 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * ***** END LGPL LICENSE BLOCK *****
+ */
+
+#ifndef AUD_DEFAULTMIXER
+#define AUD_DEFAULTMIXER
+
+#include "AUD_Mixer.h"
+
+/**
+ * This class is able to mix audiosignals of different channel count and sample
+ * rate and convert it to a specific output format.
+ * It uses a default ChannelMapperFactory and a SRCResampleFactory for
+ * the perparation.
+ */
+class AUD_DefaultMixer : public AUD_Mixer
+{
+public:
+	/**
+	 * Creates the mixer.
+	 */
+	AUD_DefaultMixer(AUD_DeviceSpecs specs);
+
+	/**
+	 * This funuction prepares a reader for playback.
+	 * \param reader The reader to prepare.
+	 * \return The reader that should be used for playback.
+	 */
+	virtual AUD_IReader* prepare(AUD_IReader* reader);
+};
+
+#endif //AUD_DEFAULTMIXER
diff --git a/intern/audaspace/intern/AUD_FileFactory.cpp b/intern/audaspace/intern/AUD_FileFactory.cpp
index 5888479a0ba..616b5ac2c18 100644
--- a/intern/audaspace/intern/AUD_FileFactory.cpp
+++ b/intern/audaspace/intern/AUD_FileFactory.cpp
@@ -30,7 +30,9 @@
 
 #ifdef WITH_FFMPEG
 // needed for INT64_C
+#ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
+#endif
 
 #include "AUD_FFMPEGReader.h"
 #endif
@@ -38,61 +40,40 @@
 #include "AUD_SndFileReader.h"
 #endif
 
-AUD_FileFactory::AUD_FileFactory(const char* filename)
+AUD_FileFactory::AUD_FileFactory(std::string filename) :
+	m_filename(filename)
 {
-	if(filename != NULL)
-	{
-		m_filename = new char[strlen(filename)+1]; AUD_NEW("string")
-		strcpy(m_filename, filename);
-	}
-	else
-		m_filename = NULL;
 }
 
-AUD_FileFactory::AUD_FileFactory(unsigned char* buffer, int size)
+AUD_FileFactory::AUD_FileFactory(const data_t* buffer, int size) :
+	m_buffer(new AUD_Buffer(size))
 {
-	m_filename = NULL;
-	m_buffer = AUD_Reference<AUD_Buffer>(new AUD_Buffer(size));
 	memcpy(m_buffer.get()->getBuffer(), buffer, size);
 }
 
-AUD_FileFactory::~AUD_FileFactory()
+AUD_IReader* AUD_FileFactory::createReader() const
 {
-	if(m_filename)
-	{
-		delete[] m_filename; AUD_DELETE("string")
-	}
-}
-
-AUD_IReader* AUD_FileFactory::createReader()
-{
-	AUD_IReader* reader = 0;
-
 #ifdef WITH_SNDFILE
 	try
 	{
-		if(m_filename)
-			reader = new AUD_SndFileReader(m_filename);
+		if(m_buffer.get())
+			return new AUD_SndFileReader(m_buffer);
 		else
-			reader = new AUD_SndFileReader(m_buffer);
-		AUD_NEW("reader")
-		return reader;
+			return new AUD_SndFileReader(m_filename);
 	}
-	catch(AUD_Exception e) {}
+	catch(AUD_Exception&) {}
 #endif
 
 #ifdef WITH_FFMPEG
 	try
 	{
-		if(m_filename)
-			reader = new AUD_FFMPEGReader(m_filename);
+		if(m_buffer.get())
+			return new AUD_FFMPEGReader(m_buffer);
 		else
-			reader = new AUD_FFMPEGReader(m_buffer);
-		AUD_NEW("reader")
-		return reader;
+			return new AUD_FFMPEGReader(m_filename);
 	}
-	catch(AUD_Exception e) {}
+	catch(AUD_Exception&) {}
 #endif
 
-	return reader;
+	AUD_THROW(AUD_ERROR_FILE)
 }
diff --git a/intern/audaspace/intern/AUD_FileFactory.h b/intern/audaspace/intern/AUD_FileFactory.h
index 6ab8f280534..9182667d72e 100644
--- a/intern/audaspace/intern/AUD_FileFactory.h
+++ b/intern/audaspace/intern/AUD_FileFactory.h
@@ -30,6 +30,8 @@
 #include "AUD_Reference.h"
 class AUD_Buffer;
 
+#include <string>
+
 /**
  * This factory tries to read a sound file via all available file readers.
  */
@@ -39,33 +41,32 @@ private:
 	/**
 	 * The filename of the sound source file.
 	 */
-	char* m_filename;
+	std::string m_filename;
 
 	/**
 	 * The buffer to read from.
 	 */
 	AUD_Reference<AUD_Buffer> m_buffer;
 
+	// hide copy constructor and operator=
+	AUD_FileFactory(const AUD_FileFactory&);
+	AUD_FileFactory& operator=(const AUD_FileFactory&);
+
 public:
 	/**
 	 * Creates a new factory.
 	 * \param filename The sound file path.
 	 */
-	AUD_FileFactory(const char* filename);
+	AUD_FileFactory(std::string filename);
 
 	/**
 	 * Creates a new factory.
 	 * \param buffer The buffer to read from.
 	 * \param size The size of the buffer.
 	 */
-	AUD_FileFactory(unsigned char* buffer, int size);
-
-	/**
-	 * Destroys the factory.
-	 */
-	~AUD_FileFactory();
+	AUD_FileFactory(const data_t* buffer, int size);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_FILEFACTORY
diff --git a/intern/audaspace/intern/AUD_IDevice.h b/intern/audaspace/intern/AUD_IDevice.h
index e924f57cefc..663d02e23be 100644
--- a/intern/audaspace/intern/AUD_IDevice.h
+++ b/intern/audaspace/intern/AUD_IDevice.h
@@ -53,7 +53,7 @@ public:
 	/**
 	 * Returns the specification of the device.
 	 */
-	virtual AUD_DeviceSpecs getSpecs()=0;
+	virtual AUD_DeviceSpecs getSpecs() const=0;
 
 	/**
 	 * Plays a sound source.
@@ -107,16 +107,6 @@ public:
 	virtual bool setKeep(AUD_Handle* handle, bool keep)=0;
 
 	/**
-	 * Sends a message to a sound or all sounds that are currently played or
-	 * paused.
-	 * \param handle The sound that should receive the message or NULL if all
-	 *        sounds should receive it.
-	 * \param message The message.
-	 * \return True if the message has been read by at least one sound.
-	 */
-	virtual bool sendMessage(AUD_Handle* handle, AUD_Message &message)=0;
-
-	/**
 	 * Seeks in a played back sound.
 	 * \param handle The handle returned by the play function.
 	 * \param position The new position from where to play back, in seconds.
diff --git a/intern/audaspace/intern/AUD_IFactory.h b/intern/audaspace/intern/AUD_IFactory.h
index f7f29c9e842..aed53cef749 100644
--- a/intern/audaspace/intern/AUD_IFactory.h
+++ b/intern/audaspace/intern/AUD_IFactory.h
@@ -49,7 +49,7 @@ public:
 	 * \exception AUD_Exception An exception may be thrown if there has been
 	 *            a more unexpected error during reader creation.
 	 */
-	virtual AUD_IReader* createReader()=0;
+	virtual AUD_IReader* createReader() const=0;
 };
 
 #endif //AUD_IFACTORY
diff --git a/intern/audaspace/intern/AUD_IReader.h b/intern/audaspace/intern/AUD_IReader.h
index 4b563100659..baba587ea03 100644
--- a/intern/audaspace/intern/AUD_IReader.h
+++ b/intern/audaspace/intern/AUD_IReader.h
@@ -46,7 +46,7 @@ public:
 	 * \return Always returns true for readers of the buffer type.
 	 * \see getType
 	 */
-	virtual bool isSeekable()=0;
+	virtual bool isSeekable() const=0;
 
 	/**
 	 * Seeks to a specific position in the source.
@@ -65,7 +65,7 @@ public:
 	 * \return The length as sample count. May be negative if unknown.
 	 * \see getType
 	 */
-	virtual int getLength()=0;
+	virtual int getLength() const=0;
 
 	/**
 	 * Returns the position of the source as a sample count value.
@@ -76,30 +76,13 @@ public:
 	 *          the buffer ones.
 	 * \see getType
 	 */
-	virtual int getPosition()=0;
+	virtual int getPosition() const=0;
 
 	/**
 	 * Returns the specification of the reader.
 	 * \return The AUD_Specs structure.
 	 */
-	virtual AUD_Specs getSpecs()=0;
-
-	/**
-	 * Returns the type of the reader. There are special conditions for the
-	 * readers of the buffer type. Those have to return correct position and
-	 * length values as well as they must be seekable.
-	 * \return AUD_TYPE_BUFFER or AUD_TYPE_STREAM.
-	 */
-	virtual AUD_ReaderType getType()=0;
-
-	/**
-	 * Sends a message to this reader and if it has subreaders it broadcasts
-	 * the message to them.
-	 * \param message The message.
-	 * \return Whether the message has been read by the reader or one of his
-	 *         subreaders.
-	 */
-	virtual bool notify(AUD_Message &message)=0;
+	virtual AUD_Specs getSpecs() const=0;
 
 	/**
 	 * Request to read the next length samples out of the source.
diff --git a/intern/audaspace/intern/AUD_LinearResampleFactory.cpp b/intern/audaspace/intern/AUD_LinearResampleFactory.cpp
index e738fc17693..91414c6a392 100644
--- a/intern/audaspace/intern/AUD_LinearResampleFactory.cpp
+++ b/intern/audaspace/intern/AUD_LinearResampleFactory.cpp
@@ -26,28 +26,18 @@
 #include "AUD_LinearResampleFactory.h"
 #include "AUD_LinearResampleReader.h"
 
-AUD_LinearResampleFactory::AUD_LinearResampleFactory(AUD_IReader* reader,
-													 AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(reader, specs) {}
-
 AUD_LinearResampleFactory::AUD_LinearResampleFactory(AUD_IFactory* factory,
 													 AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(factory, specs) {}
-
-AUD_LinearResampleFactory::AUD_LinearResampleFactory(AUD_DeviceSpecs specs) :
-		AUD_ResampleFactory(specs) {}
+		AUD_ResampleFactory(factory, specs)
+{
+}
 
-AUD_IReader* AUD_LinearResampleFactory::createReader()
+AUD_IReader* AUD_LinearResampleFactory::createReader() const
 {
 	AUD_IReader* reader = getReader();
 
-	if(reader != 0)
-	{
-		if(reader->getSpecs().rate != m_specs.rate)
-		{
-			reader = new AUD_LinearResampleReader(reader, m_specs.specs);
-			AUD_NEW("reader")
-		}
-	}
+	if(reader->getSpecs().rate != m_specs.rate)
+		reader = new AUD_LinearResampleReader(reader, m_specs.specs);
+
 	return reader;
 }
diff --git a/intern/audaspace/intern/AUD_LinearResampleFactory.h b/intern/audaspace/intern/AUD_LinearResampleFactory.h
index 81a9d623815..426641f6099 100644
--- a/intern/audaspace/intern/AUD_LinearResampleFactory.h
+++ b/intern/audaspace/intern/AUD_LinearResampleFactory.h
@@ -33,12 +33,15 @@
  */
 class AUD_LinearResampleFactory : public AUD_ResampleFactory
 {
+private:
+	// hide copy constructor and operator=
+	AUD_LinearResampleFactory(const AUD_LinearResampleFactory&);
+	AUD_LinearResampleFactory& operator=(const AUD_LinearResampleFactory&);
+
 public:
-	AUD_LinearResampleFactory(AUD_IReader* reader, AUD_DeviceSpecs specs);
 	AUD_LinearResampleFactory(AUD_IFactory* factory, AUD_DeviceSpecs specs);
-	AUD_LinearResampleFactory(AUD_DeviceSpecs specs);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_LINEARRESAMPLEFACTORY
diff --git a/intern/audaspace/intern/AUD_LinearResampleReader.cpp b/intern/audaspace/intern/AUD_LinearResampleReader.cpp
index dcd5310575d..cfe7561d336 100644
--- a/intern/audaspace/intern/AUD_LinearResampleReader.cpp
+++ b/intern/audaspace/intern/AUD_LinearResampleReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_LinearResampleReader.h"
-#include "AUD_Buffer.h"
 
 #include <cmath>
 #include <cstring>
@@ -33,25 +32,15 @@
 
 AUD_LinearResampleReader::AUD_LinearResampleReader(AUD_IReader* reader,
 												   AUD_Specs specs) :
-		AUD_EffectReader(reader)
+	AUD_EffectReader(reader),
+	m_sspecs(reader->getSpecs()),
+	m_factor(float(specs.rate) / float(m_sspecs.rate)),
+	m_tspecs(specs),
+	m_position(0),
+	m_sposition(0)
 {
-	m_sspecs = reader->getSpecs();
-
-	m_tspecs = specs;
 	m_tspecs.channels = m_sspecs.channels;
-	m_factor = (float)m_tspecs.rate / (float)m_sspecs.rate;
-
-	m_position = 0;
-	m_sposition = 0;
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-	m_cache = new AUD_Buffer(2 * AUD_SAMPLE_SIZE(specs)); AUD_NEW("buffer")
-}
-
-AUD_LinearResampleReader::~AUD_LinearResampleReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-	delete m_cache; AUD_DELETE("buffer")
+	m_cache.resize(2 * AUD_SAMPLE_SIZE(m_tspecs));
 }
 
 void AUD_LinearResampleReader::seek(int position)
@@ -61,17 +50,17 @@ void AUD_LinearResampleReader::seek(int position)
 	m_reader->seek(m_sposition);
 }
 
-int AUD_LinearResampleReader::getLength()
+int AUD_LinearResampleReader::getLength() const
 {
 	return m_reader->getLength() * m_factor;
 }
 
-int AUD_LinearResampleReader::getPosition()
+int AUD_LinearResampleReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_LinearResampleReader::getSpecs()
+AUD_Specs AUD_LinearResampleReader::getSpecs() const
 {
 	return m_tspecs;
 }
@@ -81,13 +70,13 @@ void AUD_LinearResampleReader::read(int & length, sample_t* & buffer)
 	int samplesize = AUD_SAMPLE_SIZE(m_tspecs);
 	int size = length * samplesize;
 
-	if(m_buffer->getSize() < size)
-		m_buffer->resize(size);
+	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;
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	m_reader->read(len, buf);
 
@@ -106,9 +95,9 @@ void AUD_LinearResampleReader::read(int & length, sample_t* & buffer)
 
 			if(floor(spos) < 0)
 			{
-				low = m_cache->getBuffer()[(int)(floor(spos) + 2) * CC];
+				low = m_cache.getBuffer()[(int)(floor(spos) + 2) * CC];
 				if(ceil(spos) < 0)
-					high = m_cache->getBuffer()[(int)(ceil(spos) + 2) * CC];
+					high = m_cache.getBuffer()[(int)(ceil(spos) + 2) * CC];
 				else
 					high = buf[(int)ceil(spos) * CC];
 			}
@@ -122,11 +111,11 @@ void AUD_LinearResampleReader::read(int & length, sample_t* & buffer)
 	}
 
 	if(len > 1)
-		memcpy(m_cache->getBuffer(),
+		memcpy(m_cache.getBuffer(),
 			   buf + (len - 2) * channels,
 			   2 * samplesize);
 	else if(len == 1)
-		memcpy(m_cache->getBuffer() + 1 * channels, buf, samplesize);
+		memcpy(m_cache.getBuffer() + 1 * channels, buf, samplesize);
 
 	m_sposition += len;
 	m_position += length;
diff --git a/intern/audaspace/intern/AUD_LinearResampleReader.h b/intern/audaspace/intern/AUD_LinearResampleReader.h
index c86b8b76c59..fbf56286857 100644
--- a/intern/audaspace/intern/AUD_LinearResampleReader.h
+++ b/intern/audaspace/intern/AUD_LinearResampleReader.h
@@ -27,7 +27,7 @@
 #define AUD_LINEARRESAMPLEREADER
 
 #include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This resampling reader uses libsamplerate for resampling.
@@ -36,9 +36,19 @@ class AUD_LinearResampleReader : public AUD_EffectReader
 {
 private:
 	/**
+	 * The sample specification of the source.
+	 */
+	const AUD_Specs m_sspecs;
+
+	/**
 	 * The resampling factor.
 	 */
-	float m_factor;
+	const float m_factor;
+
+	/**
+	 * The target specification.
+	 */
+	AUD_Specs m_tspecs;
 
 	/**
 	 * The current position.
@@ -53,41 +63,29 @@ private:
 	/**
 	 * The sound output buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The input caching buffer.
 	 */
-	AUD_Buffer *m_cache;
-
-	/**
-	 * The target specification.
-	 */
-	AUD_Specs m_tspecs;
+	AUD_Buffer m_cache;
 
-	/**
-	 * The sample specification of the source.
-	 */
-	AUD_Specs m_sspecs;
+	// hide copy constructor and operator=
+	AUD_LinearResampleReader(const AUD_LinearResampleReader&);
+	AUD_LinearResampleReader& operator=(const AUD_LinearResampleReader&);
 
 public:
 	/**
 	 * Creates a resampling reader.
 	 * \param reader The reader to mix.
 	 * \param specs The target specification.
-	 * \exception AUD_Exception Thrown if the reader is NULL.
 	 */
 	AUD_LinearResampleReader(AUD_IReader* reader, AUD_Specs specs);
 
-	/**
-	 * Destroys the reader.
-	 */
-	~AUD_LinearResampleReader();
-
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_Mixer.cpp b/intern/audaspace/intern/AUD_Mixer.cpp
index e77d40fdbca..419ac3af6ac 100644
--- a/intern/audaspace/intern/AUD_Mixer.cpp
+++ b/intern/audaspace/intern/AUD_Mixer.cpp
@@ -24,72 +24,13 @@
  */
 
 #include "AUD_Mixer.h"
-#include "AUD_SRCResampleFactory.h"
-#include "AUD_LinearResampleFactory.h"
-#include "AUD_ChannelMapperFactory.h"
 #include "AUD_IReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
-AUD_Mixer::AUD_Mixer()
+AUD_Mixer::AUD_Mixer(AUD_DeviceSpecs specs) :
+	m_specs(specs)
 {
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-
-	m_resampler = NULL;
-	m_mapper = NULL;
-}
-
-AUD_Mixer::~AUD_Mixer()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-
-
-	if(m_resampler)
-	{
-		delete m_resampler; AUD_DELETE("factory")
-	}
-	if(m_mapper)
-	{
-		delete m_mapper; AUD_DELETE("factory")
-	}
-}
-
-AUD_IReader* AUD_Mixer::prepare(AUD_IReader* reader)
-{
-	m_resampler->setReader(reader);
-	reader = m_resampler->createReader();
-
-	if(reader != NULL && reader->getSpecs().channels != m_specs.channels)
-	{
-		m_mapper->setReader(reader);
-		reader = m_mapper->createReader();
-	}
-
-	return reader;
-}
-
-AUD_DeviceSpecs AUD_Mixer::getSpecs()
-{
-	return m_specs;
-}
-
-void AUD_Mixer::setSpecs(AUD_DeviceSpecs specs)
-{
-	m_specs = specs;
-
-	if(m_resampler)
-	{
-		delete m_resampler; AUD_DELETE("factory")
-	}
-	if(m_mapper)
-	{
-		delete m_mapper; AUD_DELETE("factory")
-	}
-
-	m_resampler = new AUD_MIXER_RESAMPLER(specs); AUD_NEW("factory")
-	m_mapper = new AUD_ChannelMapperFactory(specs); AUD_NEW("factory")
-
 	int bigendian = 1;
 	bigendian = (((char*)&bigendian)[0]) ? 0: 1; // 1 if Big Endian
 
@@ -121,6 +62,11 @@ void AUD_Mixer::setSpecs(AUD_DeviceSpecs specs)
 	}
 }
 
+AUD_DeviceSpecs AUD_Mixer::getSpecs() const
+{
+	return m_specs;
+}
+
 void AUD_Mixer::add(sample_t* buffer, int start, int length, float volume)
 {
 	AUD_MixerBuffer buf;
@@ -137,10 +83,10 @@ void AUD_Mixer::superpose(data_t* buffer, int length, float volume)
 
 	int channels = m_specs.channels;
 
-	if(m_buffer->getSize() < length * channels * 4)
-		m_buffer->resize(length * channels * 4);
+	if(m_buffer.getSize() < length * channels * 4)
+		m_buffer.resize(length * channels * 4);
 
-	sample_t* out = m_buffer->getBuffer();
+	sample_t* out = m_buffer.getBuffer();
 	sample_t* in;
 
 	memset(out, 0, length * channels * 4);
diff --git a/intern/audaspace/intern/AUD_Mixer.h b/intern/audaspace/intern/AUD_Mixer.h
index 2e7ba743541..a7f5fb274f0 100644
--- a/intern/audaspace/intern/AUD_Mixer.h
+++ b/intern/audaspace/intern/AUD_Mixer.h
@@ -26,13 +26,8 @@
 #ifndef AUD_MIXER
 #define AUD_MIXER
 
-#define AUD_MIXER_RESAMPLER AUD_SRCResampleFactory
-
 #include "AUD_ConverterFunctions.h"
-class AUD_ConverterFactory;
-class AUD_MIXER_RESAMPLER;
-class AUD_ChannelMapperFactory;
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 class AUD_IReader;
 #include <list>
 
@@ -45,24 +40,12 @@ struct AUD_MixerBuffer
 };
 
 /**
- * This class is able to mix audiosignals of different channel count and sample
- * rate and convert it to a specific output format.
- * It uses a default ChannelMapperFactory and a SRCResampleFactory for
- * the perparation.
+ * This abstract class is able to mix audiosignals of different channel count
+ * and sample rate and convert it to a specific output format.
  */
 class AUD_Mixer
 {
-private:
-	/**
-	 * The resampling factory that resamples all readers for superposition.
-	 */
-	AUD_MIXER_RESAMPLER* m_resampler;
-
-	/**
-	 * The channel mapper factory that maps all readers for superposition.
-	 */
-	AUD_ChannelMapperFactory* m_mapper;
-
+protected:
 	/**
 	 * The list of buffers to superpose.
 	 */
@@ -71,12 +54,12 @@ private:
 	/**
 	 * The output specification.
 	 */
-	AUD_DeviceSpecs m_specs;
+	const AUD_DeviceSpecs m_specs;
 
 	/**
 	 * The temporary mixing buffer.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * Converter function.
@@ -87,31 +70,25 @@ public:
 	/**
 	 * Creates the mixer.
 	 */
-	AUD_Mixer();
+	AUD_Mixer(AUD_DeviceSpecs specs);
 
 	/**
 	 * Destroys the mixer.
 	 */
-	~AUD_Mixer();
-
-	/**
-	 * This funuction prepares a reader for playback.
-	 * \param reader The reader to prepare.
-	 * \return The reader that should be used for playback.
-	 */
-	AUD_IReader* prepare(AUD_IReader* reader);
+	virtual ~AUD_Mixer() {}
 
 	/**
 	 * Returns the target specification for superposing.
 	 * \return The target specification.
 	 */
-	AUD_DeviceSpecs getSpecs();
+	AUD_DeviceSpecs getSpecs() const;
 
 	/**
-	 * Sets the target specification for superposing.
-	 * \param specs The target specification.
+	 * This funuction prepares a reader for playback.
+	 * \param reader The reader to prepare.
+	 * \return The reader that should be used for playback.
 	 */
-	void setSpecs(AUD_DeviceSpecs specs);
+	virtual AUD_IReader* prepare(AUD_IReader* reader)=0;
 
 	/**
 	 * Adds a buffer for superposition.
@@ -120,7 +97,7 @@ public:
 	 * \param length The length of the buffer in samples.
 	 * \param volume The mixing volume. Must be a value between 0.0 and 1.0.
 	 */
-	void add(sample_t* buffer, int start, int length, float volume);
+	virtual void add(sample_t* buffer, int start, int length, float volume);
 
 	/**
 	 * Superposes all added buffers into an output buffer.
@@ -128,7 +105,7 @@ public:
 	 * \param length The length of the buffer in samples.
 	 * \param volume The mixing volume. Must be a value between 0.0 and 1.0.
 	 */
-	void superpose(data_t* buffer, int length, float volume);
+	virtual void superpose(data_t* buffer, int length, float volume);
 };
 
 #endif //AUD_MIXER
diff --git a/intern/audaspace/intern/AUD_MixerFactory.cpp b/intern/audaspace/intern/AUD_MixerFactory.cpp
index e78818301fa..4370bed6ca6 100644
--- a/intern/audaspace/intern/AUD_MixerFactory.cpp
+++ b/intern/audaspace/intern/AUD_MixerFactory.cpp
@@ -26,84 +26,23 @@
 #include "AUD_MixerFactory.h"
 #include "AUD_IReader.h"
 
-AUD_IReader* AUD_MixerFactory::getReader()
+AUD_IReader* AUD_MixerFactory::getReader() const
 {
-	AUD_IReader* reader;
-
-	// first check for an existing reader
-	if(m_reader != 0)
-	{
-		reader = m_reader;
-		m_reader = 0;
-		return reader;
-	}
-
-	// otherwise create a reader if there is a factory
-	if(m_factory != 0)
-	{
-		reader = m_factory->createReader();
-		return reader;
-	}
-
-	return 0;
-}
-
-AUD_MixerFactory::AUD_MixerFactory(AUD_IReader* reader,
-								   AUD_DeviceSpecs specs)
-{
-	m_specs = specs;
-	m_reader = reader;
-	m_factory = 0;
+	return m_factory->createReader();
 }
 
 AUD_MixerFactory::AUD_MixerFactory(AUD_IFactory* factory,
-								   AUD_DeviceSpecs specs)
+								   AUD_DeviceSpecs specs) :
+	m_specs(specs), m_factory(factory)
 {
-	m_specs = specs;
-	m_reader = 0;
-	m_factory = factory;
 }
 
-AUD_MixerFactory::AUD_MixerFactory(AUD_DeviceSpecs specs)
-{
-	m_specs = specs;
-	m_reader = 0;
-	m_factory = 0;
-}
-
-AUD_MixerFactory::~AUD_MixerFactory()
-{
-	if(m_reader != 0)
-	{
-		delete m_reader; AUD_DELETE("reader")
-	}
-}
-
-AUD_DeviceSpecs AUD_MixerFactory::getSpecs()
+AUD_DeviceSpecs AUD_MixerFactory::getSpecs() const
 {
 	return m_specs;
 }
 
-void AUD_MixerFactory::setSpecs(AUD_DeviceSpecs specs)
-{
-	m_specs = specs;
-}
-
-void AUD_MixerFactory::setReader(AUD_IReader* reader)
-{
-	if(m_reader != 0)
-	{
-		delete m_reader; AUD_DELETE("reader")
-	}
-	m_reader = reader;
-}
-
-void AUD_MixerFactory::setFactory(AUD_IFactory* factory)
-{
-	m_factory = factory;
-}
-
-AUD_IFactory* AUD_MixerFactory::getFactory()
+AUD_IFactory* AUD_MixerFactory::getFactory() const
 {
 	return m_factory;
 }
diff --git a/intern/audaspace/intern/AUD_MixerFactory.h b/intern/audaspace/intern/AUD_MixerFactory.h
index a2f4aa78d76..909eca8c148 100644
--- a/intern/audaspace/intern/AUD_MixerFactory.h
+++ b/intern/audaspace/intern/AUD_MixerFactory.h
@@ -35,9 +35,9 @@ class AUD_MixerFactory : public AUD_IFactory
 {
 protected:
 	/**
-	 * The reader that should be mixed later.
+	 * The target specification for resampling.
 	 */
-	AUD_IReader* m_reader;
+	const AUD_DeviceSpecs m_specs;
 
 	/**
 	 * If there is no reader it is created out of this factory.
@@ -45,73 +45,31 @@ protected:
 	AUD_IFactory* m_factory;
 
 	/**
-	 * The target specification for resampling.
-	 */
-	AUD_DeviceSpecs m_specs;
-
-	/**
-	 * Returns the reader created out of the factory or taken from m_reader.
+	 * Returns the reader created out of the factory.
 	 * This method can be used for the createReader function of the implementing
 	 * classes.
-	 * \return The reader to mix, or NULL if there is no reader or factory.
+	 * \return The reader to mix.
 	 */
-	AUD_IReader* getReader();
+	AUD_IReader* getReader() const;
 
 public:
 	/**
 	 * Creates a new factory.
-	 * \param reader The reader to mix.
-	 * \param specs The target specification.
-	 */
-	AUD_MixerFactory(AUD_IReader* reader, AUD_DeviceSpecs specs);
-
-	/**
-	 * Creates a new factory.
 	 * \param factory The factory to create the readers to mix out of.
 	 * \param specs The target specification.
 	 */
 	AUD_MixerFactory(AUD_IFactory* factory, AUD_DeviceSpecs specs);
 
 	/**
-	 * Creates a new factory.
-	 * \param specs The target specification.
-	 */
-	AUD_MixerFactory(AUD_DeviceSpecs specs);
-
-	/**
-	 * Destroys the resampling factory.
-	 */
-	virtual ~AUD_MixerFactory();
-
-	/**
 	 * Returns the target specification for resampling.
 	 */
-	AUD_DeviceSpecs getSpecs();
-
-	/**
-	 * Sets the target specification for resampling.
-	 * \param specs The specification.
-	 */
-	void setSpecs(AUD_DeviceSpecs specs);
-
-	/**
-	 * Sets the reader for resampling.
-	 * If there has already been a reader, it will be deleted.
-	 * \param reader The reader that should be used as source for resampling.
-	 */
-	void setReader(AUD_IReader* reader);
-
-	/**
-	 * Sets the factory for resampling.
-	 * \param factory The factory that should be used as source for resampling.
-	 */
-	void setFactory(AUD_IFactory* factory);
+	AUD_DeviceSpecs getSpecs() const;
 
 	/**
 	 * Returns the saved factory.
-	 * \return The factory or NULL if there has no factory been saved.
+	 * \return The factory.
 	 */
-	AUD_IFactory* getFactory();
+	AUD_IFactory* getFactory() const;
 };
 
 #endif //AUD_MIXERFACTORY
diff --git a/intern/audaspace/intern/AUD_NULLDevice.cpp b/intern/audaspace/intern/AUD_NULLDevice.cpp
index c9dfadd1839..9af40009335 100644
--- a/intern/audaspace/intern/AUD_NULLDevice.cpp
+++ b/intern/audaspace/intern/AUD_NULLDevice.cpp
@@ -31,14 +31,15 @@
 
 AUD_NULLDevice::AUD_NULLDevice()
 {
-	m_specs.channels = AUD_CHANNELS_INVALID;
-	m_specs.format = AUD_FORMAT_INVALID;
-	m_specs.rate = AUD_RATE_INVALID;
 }
 
-AUD_DeviceSpecs AUD_NULLDevice::getSpecs()
+AUD_DeviceSpecs AUD_NULLDevice::getSpecs() const
 {
-	return m_specs;
+	AUD_DeviceSpecs specs;
+	specs.channels = AUD_CHANNELS_INVALID;
+	specs.format = AUD_FORMAT_INVALID;
+	specs.rate = AUD_RATE_INVALID;
+	return specs;
 }
 
 AUD_Handle* AUD_NULLDevice::play(AUD_IFactory* factory, bool keep)
@@ -66,11 +67,6 @@ bool AUD_NULLDevice::setKeep(AUD_Handle* handle, bool keep)
 	return false;
 }
 
-bool AUD_NULLDevice::sendMessage(AUD_Handle* handle, AUD_Message &message)
-{
-	return false;
-}
-
 bool AUD_NULLDevice::seek(AUD_Handle* handle, float position)
 {
 	return false;
diff --git a/intern/audaspace/intern/AUD_NULLDevice.h b/intern/audaspace/intern/AUD_NULLDevice.h
index 91ddd23cf71..c3fffd7cb87 100644
--- a/intern/audaspace/intern/AUD_NULLDevice.h
+++ b/intern/audaspace/intern/AUD_NULLDevice.h
@@ -33,25 +33,18 @@
  */
 class AUD_NULLDevice : public AUD_IDevice
 {
-private:
-	/**
-	 * The specs of the device.
-	 */
-	AUD_DeviceSpecs m_specs;
-
 public:
 	/**
 	 * Creates a new NULL device.
 	 */
 	AUD_NULLDevice();
 
-	virtual AUD_DeviceSpecs getSpecs();
+	virtual AUD_DeviceSpecs getSpecs() const;
 	virtual AUD_Handle* play(AUD_IFactory* factory, bool keep = false);
 	virtual bool pause(AUD_Handle* handle);
 	virtual bool resume(AUD_Handle* handle);
 	virtual bool stop(AUD_Handle* handle);
 	virtual bool setKeep(AUD_Handle* handle, bool keep);
-	virtual bool sendMessage(AUD_Handle* handle, AUD_Message &message);
 	virtual bool seek(AUD_Handle* handle, float position);
 	virtual float getPosition(AUD_Handle* handle);
 	virtual AUD_Status getStatus(AUD_Handle* handle);
diff --git a/intern/audaspace/intern/AUD_ReadDevice.cpp b/intern/audaspace/intern/AUD_ReadDevice.cpp
index 37a7d1ae295..cde5694354e 100644
--- a/intern/audaspace/intern/AUD_ReadDevice.cpp
+++ b/intern/audaspace/intern/AUD_ReadDevice.cpp
@@ -23,21 +23,17 @@
  * ***** END LGPL LICENSE BLOCK *****
  */
 
-#include "AUD_Mixer.h"
+#include "AUD_DefaultMixer.h"
 #include "AUD_ReadDevice.h"
 #include "AUD_IReader.h"
 
 #include <cstring>
 
-AUD_ReadDevice::AUD_ReadDevice(AUD_DeviceSpecs specs)
+AUD_ReadDevice::AUD_ReadDevice(AUD_DeviceSpecs specs) :
+	m_playing(false)
 {
 	m_specs = specs;
 
-	m_mixer = new AUD_Mixer(); AUD_NEW("mixer")
-	m_mixer->setSpecs(m_specs);
-
-	m_playing = false;
-
 	create();
 }
 
diff --git a/intern/audaspace/intern/AUD_ReadDevice.h b/intern/audaspace/intern/AUD_ReadDevice.h
index 3fd90df7755..121bcb8612b 100644
--- a/intern/audaspace/intern/AUD_ReadDevice.h
+++ b/intern/audaspace/intern/AUD_ReadDevice.h
@@ -33,15 +33,19 @@
  */
 class AUD_ReadDevice : public AUD_SoftwareDevice
 {
-protected:
-	virtual void playing(bool playing);
-
 private:
 	/**
 	 * Whether the device currently.
 	 */
 	bool m_playing;
 
+	// hide copy constructor and operator=
+	AUD_ReadDevice(const AUD_ReadDevice&);
+	AUD_ReadDevice& operator=(const AUD_ReadDevice&);
+
+protected:
+	virtual void playing(bool playing);
+
 public:
 	/**
 	 * Creates a new read device.
diff --git a/intern/audaspace/intern/AUD_Reference.h b/intern/audaspace/intern/AUD_Reference.h
index 9bb9d7440b3..6b1001e2b01 100644
--- a/intern/audaspace/intern/AUD_Reference.h
+++ b/intern/audaspace/intern/AUD_Reference.h
@@ -45,12 +45,12 @@ public:
 	AUD_Reference(T* reference = 0)
 	{
 		m_reference = reference;
-		m_refcount = new int; AUD_NEW("int")
+		m_refcount = new int;
 		*m_refcount = 1;
 	}
 
 	/**
-	 * Copies a AUD_Reference object.
+	 * Copies an AUD_Reference object.
 	 * \param ref The AUD_Reference object to copy.
 	 */
 	AUD_Reference(const AUD_Reference& ref)
@@ -69,17 +69,17 @@ public:
 		(*m_refcount)--;
 		if(*m_refcount == 0)
 		{
-			if(m_reference != 0)
+			if(m_reference)
 			{
-				delete m_reference; AUD_DELETE("buffer")
+				delete m_reference;
 			}
-			delete m_refcount; AUD_DELETE("int")
+			delete m_refcount;
 		}
 	}
 
 	/**
-	 * Copies a AUD_Reference object.
-	 * \param ref The AUD_Reference object to copy.
+	 * Assigns an AUD_Reference to this object.
+	 * \param ref The AUD_Reference object to assign.
 	 */
 	AUD_Reference& operator=(const AUD_Reference& ref)
 	{
@@ -89,11 +89,11 @@ public:
 		(*m_refcount)--;
 		if(*m_refcount == 0)
 		{
-			if(m_reference != 0)
+			if(m_reference)
 			{
-				delete m_reference; AUD_DELETE("buffer")
+				delete m_reference;
 			}
-			delete m_refcount; AUD_DELETE("int")
+			delete m_refcount;
 		}
 
 		m_reference = ref.m_reference;
@@ -106,7 +106,7 @@ public:
 	/**
 	 * Returns the reference.
 	 */
-	T* get()
+	T* get() const
 	{
 		return m_reference;
 	}
diff --git a/intern/audaspace/intern/AUD_SequencerFactory.cpp b/intern/audaspace/intern/AUD_SequencerFactory.cpp
index bb5cf27fb5f..05c7fefea4a 100644
--- a/intern/audaspace/intern/AUD_SequencerFactory.cpp
+++ b/intern/audaspace/intern/AUD_SequencerFactory.cpp
@@ -28,11 +28,12 @@
 
 typedef std::list<AUD_SequencerReader*>::iterator AUD_ReaderIterator;
 
-AUD_SequencerFactory::AUD_SequencerFactory(AUD_Specs specs, void* data, AUD_volumeFunction volume)
+AUD_SequencerFactory::AUD_SequencerFactory(AUD_Specs specs, void* data,
+										   AUD_volumeFunction volume) :
+	m_specs(specs),
+	m_data(data),
+	m_volume(volume)
 {
-	m_specs = specs;
-	m_data = data;
-	m_volume = volume;
 }
 
 AUD_SequencerFactory::~AUD_SequencerFactory()
@@ -51,13 +52,23 @@ AUD_SequencerFactory::~AUD_SequencerFactory()
 	{
 		entry = m_entries.front();
 		m_entries.pop_front();
-		delete entry; AUD_DELETE("seqentry")
+		delete entry;
 	}
 }
 
+AUD_IReader* AUD_SequencerFactory::newReader()
+{
+	AUD_SequencerReader* reader = new AUD_SequencerReader(this, m_entries,
+														  m_specs, m_data,
+														  m_volume);
+	m_readers.push_front(reader);
+
+	return reader;
+}
+
 AUD_SequencerEntry* AUD_SequencerFactory::add(AUD_IFactory** sound, float begin, float end, float skip, void* data)
 {
-	AUD_SequencerEntry* entry = new AUD_SequencerEntry; AUD_NEW("seqentry")
+	AUD_SequencerEntry* entry = new AUD_SequencerEntry;
 	entry->sound = sound;
 	entry->begin = begin;
 	entry->skip = skip;
@@ -80,7 +91,7 @@ void AUD_SequencerFactory::remove(AUD_SequencerEntry* entry)
 
 	m_entries.remove(entry);
 
-	delete entry; AUD_DELETE("seqentry")
+	delete entry;
 }
 
 void AUD_SequencerFactory::move(AUD_SequencerEntry* entry, float begin, float end, float skip)
@@ -95,12 +106,9 @@ void AUD_SequencerFactory::mute(AUD_SequencerEntry* entry, bool mute)
 	entry->muted = mute;
 }
 
-AUD_IReader* AUD_SequencerFactory::createReader()
+AUD_IReader* AUD_SequencerFactory::createReader() const
 {
-	AUD_SequencerReader* reader = new AUD_SequencerReader(this, m_entries, m_specs, m_data, m_volume); AUD_NEW("reader")
-	m_readers.push_front(reader);
-
-	return reader;
+	return const_cast<AUD_SequencerFactory*>(this)->newReader();
 }
 
 void AUD_SequencerFactory::removeReader(AUD_SequencerReader* reader)
diff --git a/intern/audaspace/intern/AUD_SequencerFactory.h b/intern/audaspace/intern/AUD_SequencerFactory.h
index b564c888fc6..a2c8f48fa54 100644
--- a/intern/audaspace/intern/AUD_SequencerFactory.h
+++ b/intern/audaspace/intern/AUD_SequencerFactory.h
@@ -60,6 +60,12 @@ private:
 	void* m_data;
 	AUD_volumeFunction m_volume;
 
+	AUD_IReader* newReader();
+
+	// hide copy constructor and operator=
+	AUD_SequencerFactory(const AUD_SequencerFactory&);
+	AUD_SequencerFactory& operator=(const AUD_SequencerFactory&);
+
 public:
 	AUD_SequencerFactory(AUD_Specs specs, void* data, AUD_volumeFunction volume);
 	~AUD_SequencerFactory();
@@ -69,7 +75,7 @@ public:
 	void move(AUD_SequencerEntry* entry, float begin, float end, float skip);
 	void mute(AUD_SequencerEntry* entry, bool mute);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 
 	void removeReader(AUD_SequencerReader* reader);
 };
diff --git a/intern/audaspace/intern/AUD_SequencerReader.cpp b/intern/audaspace/intern/AUD_SequencerReader.cpp
index 8869d8d54ca..69293205498 100644
--- a/intern/audaspace/intern/AUD_SequencerReader.cpp
+++ b/intern/audaspace/intern/AUD_SequencerReader.cpp
@@ -24,20 +24,22 @@
  */
 
 #include "AUD_SequencerReader.h"
-#include "AUD_Buffer.h"
+#include "AUD_DefaultMixer.h"
 
 #include <math.h>
 
 typedef std::list<AUD_SequencerStrip*>::iterator AUD_StripIterator;
 typedef std::list<AUD_SequencerEntry*>::iterator AUD_EntryIterator;
 
-AUD_SequencerReader::AUD_SequencerReader(AUD_SequencerFactory* factory, std::list<AUD_SequencerEntry*> &entries, AUD_Specs specs, void* data, AUD_volumeFunction volume)
+AUD_SequencerReader::AUD_SequencerReader(AUD_SequencerFactory* factory,
+			std::list<AUD_SequencerEntry*> &entries, AUD_Specs specs,
+			void* data, AUD_volumeFunction volume)
 {
 	AUD_DeviceSpecs dspecs;
 	dspecs.specs = specs;
 	dspecs.format = AUD_FORMAT_FLOAT32;
 
-	m_mixer.setSpecs(dspecs);
+	m_mixer = new AUD_DefaultMixer(dspecs);
 	m_factory = factory;
 	m_data = data;
 	m_volume = volume;
@@ -46,12 +48,12 @@ AUD_SequencerReader::AUD_SequencerReader(AUD_SequencerFactory* factory, std::lis
 
 	for(AUD_EntryIterator i = entries.begin(); i != entries.end(); i++)
 	{
-		strip = new AUD_SequencerStrip;  AUD_NEW("seqstrip")
+		strip = new AUD_SequencerStrip;
 		strip->entry = *i;
 		strip->old_sound = NULL;
 
 		if(strip->old_sound)
-			strip->reader = m_mixer.prepare(strip->old_sound->createReader());
+			strip->reader = m_mixer->prepare(strip->old_sound->createReader());
 		else
 			strip->reader = NULL;
 
@@ -59,7 +61,6 @@ AUD_SequencerReader::AUD_SequencerReader(AUD_SequencerFactory* factory, std::lis
 	}
 
 	m_position = 0;
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
 AUD_SequencerReader::~AUD_SequencerReader()
@@ -75,12 +76,12 @@ AUD_SequencerReader::~AUD_SequencerReader()
 		m_strips.pop_front();
 		if(strip->reader)
 		{
-			delete strip->reader; AUD_DELETE("reader")
+			delete strip->reader;
 		}
-		delete strip; AUD_DELETE("seqstrip")
+		delete strip;
 	}
 
-	delete m_buffer; AUD_DELETE("buffer")
+	delete m_mixer;
 }
 
 void AUD_SequencerReader::destroy()
@@ -92,19 +93,19 @@ void AUD_SequencerReader::destroy()
 	{
 		strip = m_strips.front();
 		m_strips.pop_front();
-		delete strip; AUD_DELETE("seqstrip")
+		delete strip;
 	}
 }
 
 void AUD_SequencerReader::add(AUD_SequencerEntry* entry)
 {
-	AUD_SequencerStrip* strip = new AUD_SequencerStrip; AUD_NEW("seqstrip")
+	AUD_SequencerStrip* strip = new AUD_SequencerStrip;
 	strip->entry = entry;
 
 	if(*strip->entry->sound)
 	{
 		strip->old_sound = *strip->entry->sound;
-		strip->reader = m_mixer.prepare(strip->old_sound->createReader());
+		strip->reader = m_mixer->prepare(strip->old_sound->createReader());
 	}
 	else
 	{
@@ -125,16 +126,16 @@ void AUD_SequencerReader::remove(AUD_SequencerEntry* entry)
 			i++;
 			if(strip->reader)
 			{
-				delete strip->reader; AUD_DELETE("reader")
+				delete strip->reader;
 			}
 			m_strips.remove(strip);
-			delete strip; AUD_DELETE("seqstrip")
+			delete strip;
 			return;
 		}
 	}
 }
 
-bool AUD_SequencerReader::isSeekable()
+bool AUD_SequencerReader::isSeekable() const
 {
 	return true;
 }
@@ -144,44 +145,24 @@ void AUD_SequencerReader::seek(int position)
 	m_position = position;
 }
 
-int AUD_SequencerReader::getLength()
+int AUD_SequencerReader::getLength() const
 {
 	return -1;
 }
 
-int AUD_SequencerReader::getPosition()
+int AUD_SequencerReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_SequencerReader::getSpecs()
+AUD_Specs AUD_SequencerReader::getSpecs() const
 {
-	return m_mixer.getSpecs().specs;
-}
-
-AUD_ReaderType AUD_SequencerReader::getType()
-{
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_SequencerReader::notify(AUD_Message &message)
-{
-	bool result = false;
-	AUD_SequencerStrip* strip;
-
-	for(AUD_StripIterator i = m_strips.begin(); i != m_strips.end(); i++)
-	{
-		strip = *i;
-		if(strip->reader)
-			result |= (*i)->reader->notify(message);
-	}
-
-	return result;
+	return m_mixer->getSpecs().specs;
 }
 
 void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 {
-	AUD_DeviceSpecs specs = m_mixer.getSpecs();
+	AUD_DeviceSpecs specs = m_mixer->getSpecs();
 	int samplesize = AUD_SAMPLE_SIZE(specs);
 	int rate = specs.rate;
 
@@ -191,9 +172,9 @@ void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 	AUD_SequencerStrip* strip;
 	sample_t* buf;
 
-	if(m_buffer->getSize() < size)
-		m_buffer->resize(size);
-	buffer = m_buffer->getBuffer();
+	if(m_buffer.getSize() < size)
+		m_buffer.resize(size);
+	buffer = m_buffer.getBuffer();
 
 	for(AUD_StripIterator i = m_strips.begin(); i != m_strips.end(); i++)
 	{
@@ -204,12 +185,10 @@ void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 			{
 				strip->old_sound = *strip->entry->sound;
 				if(strip->reader)
-				{
-					delete strip->reader; AUD_DELETE("reader")
-				}
+					delete strip->reader;
 
 				if(strip->old_sound)
-					strip->reader = m_mixer.prepare(strip->old_sound->createReader());
+					strip->reader = m_mixer->prepare(strip->old_sound->createReader());
 				else
 					strip->reader = NULL;
 			}
@@ -236,14 +215,14 @@ void AUD_SequencerReader::read(int & length, sample_t* & buffer)
 						if(strip->reader->getPosition() != current)
 							strip->reader->seek(current);
 						strip->reader->read(len, buf);
-						m_mixer.add(buf, skip, len, m_volume(m_data, strip->entry->data, (float)m_position / (float)rate));
+						m_mixer->add(buf, skip, len, m_volume(m_data, strip->entry->data, (float)m_position / (float)rate));
 					}
 				}
 			}
 		}
 	}
 
-	m_mixer.superpose((data_t*)buffer, length, 1.0f);
+	m_mixer->superpose((data_t*)buffer, length, 1.0f);
 
 	m_position += length;
 }
diff --git a/intern/audaspace/intern/AUD_SequencerReader.h b/intern/audaspace/intern/AUD_SequencerReader.h
index a50e1642260..fd7d94c7578 100644
--- a/intern/audaspace/intern/AUD_SequencerReader.h
+++ b/intern/audaspace/intern/AUD_SequencerReader.h
@@ -28,9 +28,8 @@
 
 #include "AUD_IReader.h"
 #include "AUD_SequencerFactory.h"
-#include "AUD_Mixer.h"
-
-class AUD_Buffer;
+#include "AUD_Buffer.h"
+class AUD_Mixer;
 
 struct AUD_SequencerStrip
 {
@@ -53,12 +52,12 @@ private:
 	/**
 	 * The sound output buffer.
 	 */
-	AUD_Buffer *m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The target specification.
 	 */
-	AUD_Mixer m_mixer;
+	AUD_Mixer* m_mixer;
 
 	/**
 	 * Saves the SequencerFactory the reader belongs to.
@@ -70,14 +69,17 @@ private:
 	void* m_data;
 	AUD_volumeFunction m_volume;
 
+	// hide copy constructor and operator=
+	AUD_SequencerReader(const AUD_SequencerReader&);
+	AUD_SequencerReader& operator=(const AUD_SequencerReader&);
+
 public:
 	/**
 	 * Creates a resampling reader.
 	 * \param reader The reader to mix.
 	 * \param specs The target specification.
-	 * \exception AUD_Exception Thrown if the reader is NULL.
 	 */
-	AUD_SequencerReader(AUD_SequencerFactory* factory, std::list<AUD_SequencerEntry*> &entries, AUD_Specs specs, void* data, AUD_volumeFunction volume);
+	AUD_SequencerReader(AUD_SequencerFactory* factory, std::list<AUD_SequencerEntry*> &entries, const AUD_Specs specs, void* data, AUD_volumeFunction volume);
 
 	/**
 	 * Destroys the reader.
@@ -89,13 +91,11 @@ public:
 	void add(AUD_SequencerEntry* entry);
 	void remove(AUD_SequencerEntry* entry);
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_SinusFactory.cpp b/intern/audaspace/intern/AUD_SinusFactory.cpp
index ae878b9df60..3c8e5ccc567 100644
--- a/intern/audaspace/intern/AUD_SinusFactory.cpp
+++ b/intern/audaspace/intern/AUD_SinusFactory.cpp
@@ -27,25 +27,18 @@
 #include "AUD_SinusReader.h"
 #include "AUD_Space.h"
 
-AUD_SinusFactory::AUD_SinusFactory(double frequency, AUD_SampleRate sampleRate)
+AUD_SinusFactory::AUD_SinusFactory(float frequency, AUD_SampleRate sampleRate) :
+	m_frequency(frequency),
+	m_sampleRate(sampleRate)
 {
-	m_frequency = frequency;
-	m_sampleRate = sampleRate;
 }
 
-AUD_IReader* AUD_SinusFactory::createReader()
-{
-	AUD_IReader* reader = new AUD_SinusReader(m_frequency, m_sampleRate);
-	AUD_NEW("reader")
-	return reader;
-}
-
-double AUD_SinusFactory::getFrequency()
+float AUD_SinusFactory::getFrequency() const
 {
 	return m_frequency;
 }
 
-void AUD_SinusFactory::setFrequency(double frequency)
+AUD_IReader* AUD_SinusFactory::createReader() const
 {
-	m_frequency = frequency;
+	return new AUD_SinusReader(m_frequency, m_sampleRate);
 }
diff --git a/intern/audaspace/intern/AUD_SinusFactory.h b/intern/audaspace/intern/AUD_SinusFactory.h
index ffb36e741b9..2c5965e11f0 100644
--- a/intern/audaspace/intern/AUD_SinusFactory.h
+++ b/intern/audaspace/intern/AUD_SinusFactory.h
@@ -37,12 +37,16 @@ private:
 	/**
 	 * The frequence of the sine wave.
 	 */
-	double m_frequency;
+	const float m_frequency;
 
 	/**
 	 * The target sample rate for output.
 	 */
-	AUD_SampleRate m_sampleRate;
+	const AUD_SampleRate m_sampleRate;
+
+	// hide copy constructor and operator=
+	AUD_SinusFactory(const AUD_SinusFactory&);
+	AUD_SinusFactory& operator=(const AUD_SinusFactory&);
 
 public:
 	/**
@@ -50,21 +54,15 @@ public:
 	 * \param frequency The desired frequency.
 	 * \param sampleRate The target sample rate for playback.
 	 */
-	AUD_SinusFactory(double frequency,
+	AUD_SinusFactory(float frequency,
 					 AUD_SampleRate sampleRate = AUD_RATE_44100);
 
 	/**
 	 * Returns the frequency of the sine wave.
 	 */
-	double getFrequency();
-
-	/**
-	 * Sets the frequency.
-	 * \param frequency The new frequency.
-	 */
-	void setFrequency(double frequency);
+	float getFrequency() const;
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SINUSFACTORY
diff --git a/intern/audaspace/intern/AUD_SinusReader.cpp b/intern/audaspace/intern/AUD_SinusReader.cpp
index c52513d5d2e..e810c576a5c 100644
--- a/intern/audaspace/intern/AUD_SinusReader.cpp
+++ b/intern/audaspace/intern/AUD_SinusReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_SinusReader.h"
-#include "AUD_Buffer.h"
 
 #include <cmath>
 
@@ -32,20 +31,14 @@
 #define M_PI 3.14159265358979323846
 #endif
 
-AUD_SinusReader::AUD_SinusReader(double frequency, AUD_SampleRate sampleRate)
+AUD_SinusReader::AUD_SinusReader(float frequency, AUD_SampleRate sampleRate) :
+	m_frequency(frequency),
+	m_position(0),
+	m_sampleRate(sampleRate)
 {
-	m_frequency = frequency;
-	m_position = 0;
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-	m_sampleRate = sampleRate;
 }
 
-AUD_SinusReader::~AUD_SinusReader()
-{
-	delete m_buffer; AUD_DELETE("buffer")
-}
-
-bool AUD_SinusReader::isSeekable()
+bool AUD_SinusReader::isSeekable() const
 {
 	return true;
 }
@@ -55,17 +48,17 @@ void AUD_SinusReader::seek(int position)
 	m_position = position;
 }
 
-int AUD_SinusReader::getLength()
+int AUD_SinusReader::getLength() const
 {
 	return -1;
 }
 
-int AUD_SinusReader::getPosition()
+int AUD_SinusReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_SinusReader::getSpecs()
+AUD_Specs AUD_SinusReader::getSpecs() const
 {
 	AUD_Specs specs;
 	specs.rate = m_sampleRate;
@@ -73,27 +66,17 @@ AUD_Specs AUD_SinusReader::getSpecs()
 	return specs;
 }
 
-AUD_ReaderType AUD_SinusReader::getType()
-{
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_SinusReader::notify(AUD_Message &message)
-{
-	return false;
-}
-
 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));
+	if(m_buffer.getSize() < length * sizeof(sample_t))
+		m_buffer.resize(length * sizeof(sample_t));
 
 	// fill with sine data
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 	for(int i = 0; i < length; i++)
 	{
-		buffer[i] = sin((m_position + i) * 2.0f * M_PI * m_frequency /
+		buffer[i] = sin((m_position + i) * 2 * M_PI * m_frequency /
 						(float)m_sampleRate);
 	}
 
diff --git a/intern/audaspace/intern/AUD_SinusReader.h b/intern/audaspace/intern/AUD_SinusReader.h
index cb060dd8a43..4b88ed15db1 100644
--- a/intern/audaspace/intern/AUD_SinusReader.h
+++ b/intern/audaspace/intern/AUD_SinusReader.h
@@ -27,7 +27,7 @@
 #define AUD_SINUSREADER
 
 #include "AUD_IReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 /**
  * This class is used for sine tone playback.
@@ -43,7 +43,7 @@ private:
 	/**
 	 * The frequency of the sine wave.
 	 */
-	double m_frequency;
+	const float m_frequency;
 
 	/**
 	 * The current position in samples.
@@ -53,12 +53,16 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The sample rate for the output.
 	 */
-	AUD_SampleRate m_sampleRate;
+	const AUD_SampleRate m_sampleRate;
+
+	// hide copy constructor and operator=
+	AUD_SinusReader(const AUD_SinusReader&);
+	AUD_SinusReader& operator=(const AUD_SinusReader&);
 
 public:
 	/**
@@ -66,20 +70,13 @@ public:
 	 * \param frequency The frequency of the sine wave.
 	 * \param sampleRate The output sample rate.
 	 */
-	AUD_SinusReader(double frequency, AUD_SampleRate sampleRate);
-
-	/**
-	 * Destroys the reader.
-	 */
-	virtual ~AUD_SinusReader();
+	AUD_SinusReader(float frequency, AUD_SampleRate sampleRate);
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };
 
diff --git a/intern/audaspace/intern/AUD_SoftwareDevice.cpp b/intern/audaspace/intern/AUD_SoftwareDevice.cpp
index 5a3f25fba07..261cae23294 100644
--- a/intern/audaspace/intern/AUD_SoftwareDevice.cpp
+++ b/intern/audaspace/intern/AUD_SoftwareDevice.cpp
@@ -25,7 +25,7 @@
 
 #include "AUD_SoftwareDevice.h"
 #include "AUD_IReader.h"
-#include "AUD_Mixer.h"
+#include "AUD_DefaultMixer.h"
 #include "AUD_IFactory.h"
 #include "AUD_SourceCaps.h"
 
@@ -48,12 +48,11 @@ typedef std::list<AUD_SoftwareHandle*>::iterator AUD_HandleIterator;
 
 void AUD_SoftwareDevice::create()
 {
-	m_playingSounds = new std::list<AUD_SoftwareHandle*>(); AUD_NEW("list")
-	m_pausedSounds = new std::list<AUD_SoftwareHandle*>(); AUD_NEW("list")
+	m_playingSounds = new std::list<AUD_SoftwareHandle*>();
+	m_pausedSounds = new std::list<AUD_SoftwareHandle*>();
 	m_playback = false;
 	m_volume = 1.0f;
-	m_mixer = new AUD_Mixer(); AUD_NEW("mixer")
-	m_mixer->setSpecs(m_specs);
+	m_mixer = new AUD_DefaultMixer(m_specs);
 
 	pthread_mutexattr_t attr;
 	pthread_mutexattr_init(&attr);
@@ -69,25 +68,25 @@ void AUD_SoftwareDevice::destroy()
 	if(m_playback)
 		playing(m_playback = false);
 
-	delete m_mixer; AUD_DELETE("mixer")
+	delete m_mixer;
 
 	// delete all playing sounds
 	while(m_playingSounds->begin() != m_playingSounds->end())
 	{
-		delete (*(m_playingSounds->begin()))->reader; AUD_DELETE("reader")
-		delete *(m_playingSounds->begin()); AUD_DELETE("handle")
+		delete (*(m_playingSounds->begin()))->reader;
+		delete *(m_playingSounds->begin());
 		m_playingSounds->erase(m_playingSounds->begin());
 	}
-	delete m_playingSounds; AUD_DELETE("list")
+	delete m_playingSounds;
 
 	// delete all paused sounds
 	while(m_pausedSounds->begin() != m_pausedSounds->end())
 	{
-		delete (*(m_pausedSounds->begin()))->reader; AUD_DELETE("reader")
-		delete *(m_pausedSounds->begin()); AUD_DELETE("handle")
+		delete (*(m_pausedSounds->begin()))->reader;
+		delete *(m_pausedSounds->begin());
 		m_pausedSounds->erase(m_pausedSounds->begin());
 	}
-	delete m_pausedSounds; AUD_DELETE("list")
+	delete m_pausedSounds;
 
 	pthread_mutex_destroy(&m_mutex);
 }
@@ -154,7 +153,7 @@ bool AUD_SoftwareDevice::isValid(AUD_Handle* handle)
 	return false;
 }
 
-AUD_DeviceSpecs AUD_SoftwareDevice::getSpecs()
+AUD_DeviceSpecs AUD_SoftwareDevice::getSpecs() const
 {
 	return m_specs;
 }
@@ -174,7 +173,7 @@ AUD_Handle* AUD_SoftwareDevice::play(AUD_IFactory* factory, bool keep)
 	AUD_Specs rs = reader->getSpecs();
 
 	// play sound
-	AUD_SoftwareHandle* sound = new AUD_SoftwareHandle; AUD_NEW("handle")
+	AUD_SoftwareHandle* sound = new AUD_SoftwareHandle;
 	sound->keep = keep;
 	sound->reader = reader;
 	sound->volume = 1.0f;
@@ -252,8 +251,8 @@ bool AUD_SoftwareDevice::stop(AUD_Handle* handle)
 	{
 		if(*i == handle)
 		{
-			delete (*i)->reader; AUD_DELETE("reader")
-			delete *i; AUD_DELETE("handle")
+			delete (*i)->reader;
+			delete *i;
 			m_playingSounds->erase(i);
 			if(m_playingSounds->empty())
 				playing(m_playback = false);
@@ -268,8 +267,8 @@ bool AUD_SoftwareDevice::stop(AUD_Handle* handle)
 		{
 			if(*i == handle)
 			{
-				delete (*i)->reader; AUD_DELETE("reader")
-				delete *i; AUD_DELETE("handle")
+				delete (*i)->reader;
+				delete *i;
 				m_pausedSounds->erase(i);
 				result = true;
 				break;
@@ -299,27 +298,6 @@ bool AUD_SoftwareDevice::setKeep(AUD_Handle* handle, bool keep)
 	return result;
 }
 
-bool AUD_SoftwareDevice::sendMessage(AUD_Handle* handle, AUD_Message &message)
-{
-	lock();
-
-	bool result = false;
-
-	if(handle == 0)
-	{
-		for(AUD_HandleIterator i = m_playingSounds->begin();
-			i != m_playingSounds->end(); i++)
-			result |= (*i)->reader->notify(message);
-		for(AUD_HandleIterator i = m_pausedSounds->begin();
-			i != m_pausedSounds->end(); i++)
-			result |= (*i)->reader->notify(message);
-	}
-	else if(isValid(handle))
-		result = ((AUD_SoftwareHandle*)handle)->reader->notify(message);
-	unlock();
-	return result;
-}
-
 bool AUD_SoftwareDevice::seek(AUD_Handle* handle, float position)
 {
 	lock();
diff --git a/intern/audaspace/intern/AUD_SoftwareDevice.h b/intern/audaspace/intern/AUD_SoftwareDevice.h
index a12fddb1e00..e59f9887a0c 100644
--- a/intern/audaspace/intern/AUD_SoftwareDevice.h
+++ b/intern/audaspace/intern/AUD_SoftwareDevice.h
@@ -111,13 +111,12 @@ private:
 	bool isValid(AUD_Handle* handle);
 
 public:
-	virtual AUD_DeviceSpecs getSpecs();
+	virtual AUD_DeviceSpecs getSpecs() const;
 	virtual AUD_Handle* play(AUD_IFactory* factory, bool keep = false);
 	virtual bool pause(AUD_Handle* handle);
 	virtual bool resume(AUD_Handle* handle);
 	virtual bool stop(AUD_Handle* handle);
 	virtual bool setKeep(AUD_Handle* handle, bool keep);
-	virtual bool sendMessage(AUD_Handle* handle, AUD_Message &message);
 	virtual bool seek(AUD_Handle* handle, float position);
 	virtual float getPosition(AUD_Handle* handle);
 	virtual AUD_Status getStatus(AUD_Handle* handle);
diff --git a/intern/audaspace/intern/AUD_Space.h b/intern/audaspace/intern/AUD_Space.h
index 9e857ce73b0..d03986defe7 100644
--- a/intern/audaspace/intern/AUD_Space.h
+++ b/intern/audaspace/intern/AUD_Space.h
@@ -93,18 +93,6 @@
  */
 #define AUD_CAPS_BUFFERED_FACTORY	0x2001
 
-// Used for debugging memory leaks.
-//#define AUD_DEBUG_MEMORY
-
-#ifdef AUD_DEBUG_MEMORY
-extern int AUD_References(int count, const char* text);
-#define AUD_NEW(text) AUD_References(1, text);
-#define AUD_DELETE(text) AUD_References(-1, text);
-#else
-#define AUD_NEW(text)
-#define AUD_DELETE(text)
-#endif
-
 /**
  * The format of a sample.
  * The last 4 bit save the byte count of the format.
@@ -154,17 +142,6 @@ typedef enum
 	AUD_RATE_192000  = 192000		/// 192000 Hz.
 } AUD_SampleRate;
 
-/**
- * Type of a reader.
- * @see AUD_IReader for details.
- */
-typedef enum
-{
-	AUD_TYPE_INVALID = 0,			/// Invalid reader type.
-	AUD_TYPE_BUFFER,				/// Reader reads from a buffer.
-	AUD_TYPE_STREAM					/// Reader reads from a stream.
-} AUD_ReaderType;
-
 /// Status of a playback handle.
 typedef enum
 {
@@ -186,14 +163,6 @@ typedef enum
 	AUD_ERROR_JACK
 } AUD_Error;
 
-/// Message codes.
-typedef enum
-{
-	AUD_MSG_INVALID = 0,			/// Invalid message.
-	AUD_MSG_LOOP,					/// Loop reader message.
-	AUD_MSG_VOLUME					/// Volume reader message.
-} AUD_MessageType;
-
 /// Fading types.
 typedef enum
 {
@@ -283,28 +252,6 @@ typedef struct
 	// void* userData; - for the case it is needed someday
 } AUD_Exception;
 
-/// Message structure.
-typedef struct
-{
-	/**
-	 * The message type.
-	 */
-	AUD_MessageType type;
-
-	union
-	{
-		// loop reader
-		struct
-		{
-			int loopcount;
-			float time;
-		};
-
-		// volume reader
-		float volume;
-	};
-} AUD_Message;
-
 /// Handle structure, for inherition.
 typedef struct
 {
diff --git a/intern/audaspace/intern/AUD_StreamBufferFactory.cpp b/intern/audaspace/intern/AUD_StreamBufferFactory.cpp
index 4d2cd9e2505..4079079cb33 100644
--- a/intern/audaspace/intern/AUD_StreamBufferFactory.cpp
+++ b/intern/audaspace/intern/AUD_StreamBufferFactory.cpp
@@ -29,15 +29,12 @@
 
 #include <cstring>
 
-AUD_StreamBufferFactory::AUD_StreamBufferFactory(AUD_IFactory* factory)
+AUD_StreamBufferFactory::AUD_StreamBufferFactory(AUD_IFactory* factory) :
+	m_buffer(new AUD_Buffer())
 {
 	AUD_IReader* reader = factory->createReader();
 
-	if(reader == NULL)
-		AUD_THROW(AUD_ERROR_READER);
-
 	m_specs = reader->getSpecs();
-	m_buffer = AUD_Reference<AUD_Buffer>(new AUD_Buffer()); AUD_NEW("buffer")
 
 	int sample_size = AUD_SAMPLE_SIZE(m_specs);
 	int length;
@@ -68,13 +65,11 @@ AUD_StreamBufferFactory::AUD_StreamBufferFactory(AUD_IFactory* factory)
 		index += length;
 	}
 
-	m_buffer.get()->resize(index*sample_size, true);
-	delete reader; AUD_DELETE("reader")
+	m_buffer.get()->resize(index * sample_size, true);
+	delete reader;
 }
 
-AUD_IReader* AUD_StreamBufferFactory::createReader()
+AUD_IReader* AUD_StreamBufferFactory::createReader() const
 {
-	AUD_IReader* reader = new AUD_BufferReader(m_buffer, m_specs);
-	AUD_NEW("reader")
-	return reader;
+	return new AUD_BufferReader(m_buffer, m_specs);
 }
diff --git a/intern/audaspace/intern/AUD_StreamBufferFactory.h b/intern/audaspace/intern/AUD_StreamBufferFactory.h
index eda06f6c10c..d0cf1001e5c 100644
--- a/intern/audaspace/intern/AUD_StreamBufferFactory.h
+++ b/intern/audaspace/intern/AUD_StreamBufferFactory.h
@@ -47,6 +47,10 @@ private:
 	 */
 	AUD_Specs m_specs;
 
+	// hide copy constructor and operator=
+	AUD_StreamBufferFactory(const AUD_StreamBufferFactory&);
+	AUD_StreamBufferFactory& operator=(const AUD_StreamBufferFactory&);
+
 public:
 	/**
 	 * Creates the factory and reads the reader created by the factory supplied
@@ -56,7 +60,7 @@ public:
 	 */
 	AUD_StreamBufferFactory(AUD_IFactory* factory);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_STREAMBUFFERFACTORY
diff --git a/intern/audaspace/jack/AUD_JackDevice.cpp b/intern/audaspace/jack/AUD_JackDevice.cpp
index ae7725be81c..08a1d5920e5 100644
--- a/intern/audaspace/jack/AUD_JackDevice.cpp
+++ b/intern/audaspace/jack/AUD_JackDevice.cpp
@@ -26,7 +26,6 @@
 #include "AUD_Mixer.h"
 #include "AUD_JackDevice.h"
 #include "AUD_IReader.h"
-#include "AUD_Buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -43,8 +42,8 @@ void AUD_JackDevice::updateRingBuffers()
 	unsigned int samplesize = AUD_SAMPLE_SIZE(m_specs);
 	unsigned int i, j;
 	unsigned int channels = m_specs.channels;
-	sample_t* buffer = m_buffer->getBuffer();
-	float* deinterleave = m_deinterleavebuf->getBuffer();
+	sample_t* buffer = m_buffer.getBuffer();
+	float* deinterleave = m_deinterleavebuf.getBuffer();
 	jack_transport_state_t state;
 	jack_position_t position;
 
@@ -196,7 +195,7 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 	jack_set_sync_callback(m_client, AUD_JackDevice::jack_sync, this);
 
 	// register our output channels which are called ports in jack
-	m_ports = new jack_port_t*[m_specs.channels]; AUD_NEW("jack_port")
+	m_ports = new jack_port_t*[m_specs.channels];
 
 	try
 	{
@@ -211,22 +210,22 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 				AUD_THROW(AUD_ERROR_JACK);
 		}
 	}
-	catch(AUD_Exception)
+	catch(AUD_Exception&)
 	{
 		jack_client_close(m_client);
-		delete[] m_ports; AUD_DELETE("jack_port")
+		delete[] m_ports;
 		throw;
 	}
 
 	m_specs.rate = (AUD_SampleRate)jack_get_sample_rate(m_client);
 
 	buffersize *= sizeof(sample_t);
-	m_ringbuffers = new jack_ringbuffer_t*[specs.channels]; AUD_NEW("jack_buffers")
+	m_ringbuffers = new jack_ringbuffer_t*[specs.channels];
 	for(unsigned int i = 0; i < specs.channels; i++)
 		m_ringbuffers[i] = jack_ringbuffer_create(buffersize);
 	buffersize *= specs.channels;
-	m_buffer = new AUD_Buffer(buffersize); AUD_NEW("buffer");
-	m_deinterleavebuf = new AUD_Buffer(buffersize); AUD_NEW("buffer");
+	m_deinterleavebuf.resize(buffersize);
+	m_buffer.resize(buffersize);
 
 	create();
 
@@ -238,25 +237,19 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 	pthread_mutex_init(&m_mixingLock, NULL);
 	pthread_cond_init(&m_mixingCondition, NULL);
 
-	try
-	{
-		// activate the client
-		if(jack_activate(m_client))
-			AUD_THROW(AUD_ERROR_JACK);
-	}
-	catch(AUD_Exception)
+	// activate the client
+	if(jack_activate(m_client))
 	{
 		jack_client_close(m_client);
-		delete[] m_ports; AUD_DELETE("jack_port")
-		delete m_buffer; AUD_DELETE("buffer");
-		delete m_deinterleavebuf; AUD_DELETE("buffer");
+		delete[] m_ports;
 		for(unsigned int i = 0; i < specs.channels; i++)
 			jack_ringbuffer_free(m_ringbuffers[i]);
-		delete[] m_ringbuffers; AUD_DELETE("jack_buffers")
+		delete[] m_ringbuffers;
 		pthread_mutex_destroy(&m_mixingLock);
 		pthread_cond_destroy(&m_mixingCondition);
 		destroy();
-		throw;
+
+		AUD_THROW(AUD_ERROR_JACK);
 	}
 
 	const char** ports = jack_get_ports(m_client, NULL, NULL,
@@ -284,7 +277,7 @@ AUD_JackDevice::~AUD_JackDevice()
 		jack_client_close(m_client);
 	m_valid = false;
 
-	delete[] m_ports; AUD_DELETE("jack_port")
+	delete[] m_ports;
 
 	pthread_mutex_lock(&m_mixingLock);
 	pthread_cond_signal(&m_mixingCondition);
@@ -293,11 +286,9 @@ AUD_JackDevice::~AUD_JackDevice()
 
 	pthread_cond_destroy(&m_mixingCondition);
 	pthread_mutex_destroy(&m_mixingLock);
-	delete m_buffer; AUD_DELETE("buffer");
-	delete m_deinterleavebuf; AUD_DELETE("buffer");
 	for(unsigned int i = 0; i < m_specs.channels; i++)
 		jack_ringbuffer_free(m_ringbuffers[i]);
-	delete[] m_ringbuffers; AUD_DELETE("jack_buffers")
+	delete[] m_ringbuffers;
 
 	destroy();
 }
diff --git a/intern/audaspace/jack/AUD_JackDevice.h b/intern/audaspace/jack/AUD_JackDevice.h
index 58e34978c1f..abd32147246 100644
--- a/intern/audaspace/jack/AUD_JackDevice.h
+++ b/intern/audaspace/jack/AUD_JackDevice.h
@@ -28,7 +28,7 @@
 
 
 #include "AUD_SoftwareDevice.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
 #include <jack.h>
 #include <ringbuffer.h>
@@ -54,9 +54,12 @@ private:
 	/**
 	 * The output buffer.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
 
-	AUD_Buffer* m_deinterleavebuf;
+	/**
+	 * The deinterleaving buffer.
+	 */
+	AUD_Buffer m_deinterleavebuf;
 
 	jack_ringbuffer_t** m_ringbuffers;
 
@@ -114,13 +117,18 @@ private:
 
 	void updateRingBuffers();
 
+	// hide copy constructor and operator=
+	AUD_JackDevice(const AUD_JackDevice&);
+	AUD_JackDevice& operator=(const AUD_JackDevice&);
+
 protected:
 	virtual void playing(bool playing);
 
 public:
 	/**
 	 * Creates a Jack client for audio output.
-	 * \param specs The wanted audio specification, where only the channel count is important.
+	 * \param specs The wanted audio specification, where only the channel count
+	 *              is important.
 	 * \exception AUD_Exception Thrown if the audio device cannot be opened.
 	 */
 	AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize = AUD_DEFAULT_BUFFER_SIZE);
diff --git a/intern/audaspace/sndfile/AUD_SndFileFactory.cpp b/intern/audaspace/sndfile/AUD_SndFileFactory.cpp
index bac6dc321f4..d8ea7006073 100644
--- a/intern/audaspace/sndfile/AUD_SndFileFactory.cpp
+++ b/intern/audaspace/sndfile/AUD_SndFileFactory.cpp
@@ -29,39 +29,21 @@
 
 #include <cstring>
 
-AUD_SndFileFactory::AUD_SndFileFactory(const char* filename)
+AUD_SndFileFactory::AUD_SndFileFactory(std::string filename) :
+	m_filename(filename)
 {
-	if(filename != NULL)
-	{
-		m_filename = new char[strlen(filename)+1]; AUD_NEW("string")
-		strcpy(m_filename, filename);
-	}
-	else
-		m_filename = NULL;
 }
 
-AUD_SndFileFactory::AUD_SndFileFactory(unsigned char* buffer, int size)
+AUD_SndFileFactory::AUD_SndFileFactory(const data_t* buffer, int size) :
+	m_buffer(new AUD_Buffer(size))
 {
-	m_filename = NULL;
-	m_buffer = AUD_Reference<AUD_Buffer>(new AUD_Buffer(size));
 	memcpy(m_buffer.get()->getBuffer(), buffer, size);
 }
 
-AUD_SndFileFactory::~AUD_SndFileFactory()
-{
-	if(m_filename)
-	{
-		delete[] m_filename; AUD_DELETE("string")
-	}
-}
-
-AUD_IReader* AUD_SndFileFactory::createReader()
+AUD_IReader* AUD_SndFileFactory::createReader() const
 {
-	AUD_IReader* reader;
-	if(m_filename)
-		reader = new AUD_SndFileReader(m_filename);
+	if(m_buffer.get())
+		return new AUD_SndFileReader(m_buffer);
 	else
-		reader = new AUD_SndFileReader(m_buffer);
-	AUD_NEW("reader")
-	return reader;
+		return new AUD_SndFileReader(m_filename);
 }
diff --git a/intern/audaspace/sndfile/AUD_SndFileFactory.h b/intern/audaspace/sndfile/AUD_SndFileFactory.h
index 98187ff1590..350e48abef8 100644
--- a/intern/audaspace/sndfile/AUD_SndFileFactory.h
+++ b/intern/audaspace/sndfile/AUD_SndFileFactory.h
@@ -30,6 +30,8 @@
 #include "AUD_Reference.h"
 class AUD_Buffer;
 
+#include <string>
+
 /**
  * This factory reads a sound file via libsndfile.
  */
@@ -39,33 +41,32 @@ private:
 	/**
 	 * The filename of the sound source file.
 	 */
-	char* m_filename;
+	std::string m_filename;
 
 	/**
 	 * The buffer to read from.
 	 */
 	AUD_Reference<AUD_Buffer> m_buffer;
 
+	// hide copy constructor and operator=
+	AUD_SndFileFactory(const AUD_SndFileFactory&);
+	AUD_SndFileFactory& operator=(const AUD_SndFileFactory&);
+
 public:
 	/**
 	 * Creates a new factory.
 	 * \param filename The sound file path.
 	 */
-	AUD_SndFileFactory(const char* filename);
+	AUD_SndFileFactory(std::string filename);
 
 	/**
 	 * Creates a new factory.
 	 * \param buffer The buffer to read from.
 	 * \param size The size of the buffer.
 	 */
-	AUD_SndFileFactory(unsigned char* buffer, int size);
-
-	/**
-	 * Destroys the factory.
-	 */
-	~AUD_SndFileFactory();
+	AUD_SndFileFactory(const data_t* buffer, int size);
 
-	virtual AUD_IReader* createReader();
+	virtual AUD_IReader* createReader() const;
 };
 
 #endif //AUD_SNDFILEFACTORY
diff --git a/intern/audaspace/sndfile/AUD_SndFileReader.cpp b/intern/audaspace/sndfile/AUD_SndFileReader.cpp
index f9ed8d6388e..339139e9abb 100644
--- a/intern/audaspace/sndfile/AUD_SndFileReader.cpp
+++ b/intern/audaspace/sndfile/AUD_SndFileReader.cpp
@@ -24,7 +24,6 @@
  */
 
 #include "AUD_SndFileReader.h"
-#include "AUD_Buffer.h"
 
 #include <cstring>
 
@@ -77,12 +76,13 @@ sf_count_t AUD_SndFileReader::vio_tell(void *user_data)
 	return reader->m_memoffset;
 }
 
-AUD_SndFileReader::AUD_SndFileReader(const char* filename)
+AUD_SndFileReader::AUD_SndFileReader(std::string filename) :
+	m_position(0)
 {
 	SF_INFO sfinfo;
 
 	sfinfo.format = 0;
-	m_sndfile = sf_open(filename, SFM_READ, &sfinfo);
+	m_sndfile = sf_open(filename.c_str(), SFM_READ, &sfinfo);
 
 	if(!m_sndfile)
 		AUD_THROW(AUD_ERROR_FILE);
@@ -91,16 +91,13 @@ AUD_SndFileReader::AUD_SndFileReader(const char* filename)
 	m_specs.rate = (AUD_SampleRate) sfinfo.samplerate;
 	m_length = sfinfo.frames;
 	m_seekable = sfinfo.seekable;
-	m_position = 0;
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
-AUD_SndFileReader::AUD_SndFileReader(AUD_Reference<AUD_Buffer> buffer)
+AUD_SndFileReader::AUD_SndFileReader(AUD_Reference<AUD_Buffer> buffer) :
+	m_position(0),
+	m_membuffer(buffer),
+	m_memoffset(0)
 {
-	m_membuffer = buffer;
-	m_memoffset = 0;
-
 	m_vio.get_filelen = vio_get_filelen;
 	m_vio.read = vio_read;
 	m_vio.seek = vio_seek;
@@ -119,19 +116,14 @@ AUD_SndFileReader::AUD_SndFileReader(AUD_Reference<AUD_Buffer> buffer)
 	m_specs.rate = (AUD_SampleRate) sfinfo.samplerate;
 	m_length = sfinfo.frames;
 	m_seekable = sfinfo.seekable;
-	m_position = 0;
-
-	m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
 }
 
 AUD_SndFileReader::~AUD_SndFileReader()
 {
 	sf_close(m_sndfile);
-
-	delete m_buffer; AUD_DELETE("buffer")
 }
 
-bool AUD_SndFileReader::isSeekable()
+bool AUD_SndFileReader::isSeekable() const
 {
 	return m_seekable;
 }
@@ -145,40 +137,30 @@ void AUD_SndFileReader::seek(int position)
 	}
 }
 
-int AUD_SndFileReader::getLength()
+int AUD_SndFileReader::getLength() const
 {
 	return m_length;
 }
 
-int AUD_SndFileReader::getPosition()
+int AUD_SndFileReader::getPosition() const
 {
 	return m_position;
 }
 
-AUD_Specs AUD_SndFileReader::getSpecs()
+AUD_Specs AUD_SndFileReader::getSpecs() const
 {
 	return m_specs;
 }
 
-AUD_ReaderType AUD_SndFileReader::getType()
-{
-	return AUD_TYPE_STREAM;
-}
-
-bool AUD_SndFileReader::notify(AUD_Message &message)
-{
-	return false;
-}
-
 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);
+	if(m_buffer.getSize() < length*sample_size)
+		m_buffer.resize(length*sample_size);
 
-	buffer = m_buffer->getBuffer();
+	buffer = m_buffer.getBuffer();
 
 	length = sf_readf_float(m_sndfile, buffer, length);
 
diff --git a/intern/audaspace/sndfile/AUD_SndFileReader.h b/intern/audaspace/sndfile/AUD_SndFileReader.h
index 8886b6e9efc..a53189fdecd 100644
--- a/intern/audaspace/sndfile/AUD_SndFileReader.h
+++ b/intern/audaspace/sndfile/AUD_SndFileReader.h
@@ -28,8 +28,9 @@
 
 #include "AUD_IReader.h"
 #include "AUD_Reference.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
 
+#include <string>
 #include <sndfile.h>
 
 typedef sf_count_t (*sf_read_f)(SNDFILE *sndfile, void *ptr, sf_count_t frames);
@@ -63,7 +64,7 @@ private:
 	/**
 	 * The playback buffer.
 	 */
-	AUD_Buffer* m_buffer;
+	AUD_Buffer m_buffer;
 
 	/**
 	 * The sndfile.
@@ -91,6 +92,10 @@ private:
 	static sf_count_t vio_read(void *ptr, sf_count_t count, void *user_data);
 	static sf_count_t vio_tell(void *user_data);
 
+	// hide copy constructor and operator=
+	AUD_SndFileReader(const AUD_SndFileReader&);
+	AUD_SndFileReader& operator=(const AUD_SndFileReader&);
+
 public:
 	/**
 	 * Creates a new reader.
@@ -98,7 +103,7 @@ public:
 	 * \exception AUD_Exception Thrown if the file specified does not exist or
 	 *            cannot be read with libsndfile.
 	 */
-	AUD_SndFileReader(const char* filename);
+	AUD_SndFileReader(std::string filename);
 
 	/**
 	 * Creates a new reader.
@@ -113,13 +118,11 @@ public:
 	 */
 	virtual ~AUD_SndFileReader();
 
-	virtual bool isSeekable();
+	virtual bool isSeekable() const;
 	virtual void seek(int position);
-	virtual int getLength();
-	virtual int getPosition();
-	virtual AUD_Specs getSpecs();
-	virtual AUD_ReaderType getType();
-	virtual bool notify(AUD_Message &message);
+	virtual int getLength() const;
+	virtual int getPosition() const;
+	virtual AUD_Specs getSpecs() const;
 	virtual void read(int & length, sample_t* & buffer);
 };