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);
}
/**
* 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:
/**
*/
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
*/
#include "AUD_AccumulatorReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
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)
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)
{
{
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];
#define AUD_ACCUMULATORREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class represents an accumulator.
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);
};
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);
}
/**
* 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:
/**
*/
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
*/
#include "AUD_ButterworthReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
#include <cmath>
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);
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++)
#define AUD_BUTTERWORTHREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class represents a butterworth filter.
/**
* 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.
*/
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.
* \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);
};
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);
}
/**
* 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:
/**
* \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
*/
#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;
}
}
-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;
}
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);
#define AUD_DELAYREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class reads another reader and changes it's delay.
/**
* 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);
};
#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);
}
*/
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.
*/
AUD_DoubleFactory(AUD_IFactory* factory1, AUD_IFactory* factory2);
- virtual AUD_IReader* createReader();
+ virtual AUD_IReader* createReader() const;
};
#endif //AUD_DOUBLEFACTORY
*/
#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();
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;
}
}
#define AUD_DOUBLEREADER
#include "AUD_IReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This reader plays two readers with the same specs sequently.
/**
* 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);
*/
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);
};
#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;
}
*/
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.
* 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:
/**
/**
* 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
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();
}
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);
*/
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.
/**
* 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);
*/
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);
};
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);
}
/**
* 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:
/**
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
*/
#include "AUD_EnvelopeReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
#include <cmath>
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;
#define AUD_ENVELOPEREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class represents an envelope follower.
{
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:
/**
* \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);
};
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);
}
/**
* 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:
/**
* \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
*/
#include "AUD_FaderReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
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)
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++)
}
buffer = buf;
+ m_empty = false;
}
}
#define AUD_FADERREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class fades another reader.
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:
/**
* \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);
};
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);
}
/**
* 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:
/**
*/
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
*/
#include "AUD_HighpassReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
#include <cmath>
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;
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++)
#define AUD_HIGHPASSREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
#define AUD_HIGHPASS_ORDER 3
/**
* 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.
*/
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);
};
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);
}
/**
* 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:
/**
* \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
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);
}
}
}
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)
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)
{
/**
* 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:
/**
* \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);
};
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);
}
/**
* 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:
/**
* \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
#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)
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;
#define AUD_LOOPREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class reads another reader and loops it.
/**
* 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:
/**
* \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);
};
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);
}
/**
* 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:
/**
*/
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
*/
#include "AUD_LowpassReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
#include <cmath>
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;
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++)
#define AUD_LOWPASSREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
#define AUD_LOWPASS_ORDER 3
/**
* 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.
*/
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);
};
#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);
}
*/
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
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);
}
/**
* 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:
/**
* \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
#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));
/**
* 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
#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());
}
*/
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
*/
#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)
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]);
#define AUD_RECTIFYREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class reads another reader and rectifies it.
/**
* 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);
};
#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());
}
*/
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
*/
#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)
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;
}
{
// first correct the length
if(m_position + length > m_length)
- length = m_length-m_position;
+ length = m_length - m_position;
if(length <= 0)
{
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;
m_position += length;
- buffer = m_buffer->getBuffer();
+ buffer = m_buffer.getBuffer();
}
#define AUD_REVERSEREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class reads another reader from back to front.
{
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);
};
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);
}
/**
* 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:
/**
* \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
*/
#include "AUD_SquareReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
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)
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++)
{
#define AUD_SQUAREREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class changes another signal into a square signal.
/**
* 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);
};
#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());
}
*/
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
*/
#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++)
#define AUD_SUMREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class represents an summer.
/**
* 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);
};
#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);
}
*/
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.
*/
AUD_SuperposeFactory(AUD_IFactory* factory1, AUD_IFactory* factory2);
- virtual AUD_IReader* createReader();
+ virtual AUD_IReader* createReader() const;
};
#endif //AUD_SUPERPOSEFACTORY
*/
#include "AUD_SuperposeReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
{
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();
}
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;
#define AUD_SUPERPOSEREADER
#include "AUD_IReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This reader plays two readers with the same specs sequently.
/**
* 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);
*/
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);
};
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);
}
/**
* 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:
/**
* \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
*/
#include "AUD_VolumeReader.h"
-#include "AUD_Buffer.h"
#include <cstring>
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)
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;
#define AUD_VOLUMEREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This class reads another reader and changes it's volume.
/**
* 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);
};
*/
#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>
// 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;
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);
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());
}
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());
}
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());
}
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;
}
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;
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;
}
}
}
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
unlock();
throw;
// 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;
if(!valid)
{
- delete sound; AUD_DELETE("handle")
- delete reader; AUD_DELETE("reader")
+ delete sound;
+ delete reader;
return NULL;
}
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;
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;
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;
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;
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;
}
alcSuspendContext(m_context);
AUD_OpenALBufferedFactory* bf = new AUD_OpenALBufferedFactory;
- AUD_NEW("bufferedfactory");
bf->factory = factory;
try
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;
alDeleteBuffers(1,
&(*(m_bufferedFactories->begin()))->buffer);
delete *m_bufferedFactories->begin();
- AUD_DELETE("bufferedfactory");
m_bufferedFactories->erase(m_bufferedFactories->begin());
}
unlock();
#include "AUD_I3DDevice.h"
struct AUD_OpenALHandle;
struct AUD_OpenALBufferedFactory;
-class AUD_ConverterFactory;
#include <AL/al.h>
#include <AL/alc.h>
*/
bool m_useMC;
- /**
- * The converter factory for readers with wrong input format.
- */
- AUD_ConverterFactory* m_converter;
-
/**
* The list of sounds that are currently playing.
*/
*/
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.
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);
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;
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&)
{
*/
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);
#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;
}
*/
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
*/
#include "AUD_SRCResampleReader.h"
-#include "AUD_Buffer.h"
#include <cmath>
#include <cstring>
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,
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);
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;
}
{
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);
#define AUD_SRCRESAMPLEREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
#include <samplerate.h>
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.
*/
AUD_Specs m_tspecs;
- /**
- * The sample specification of the source.
- */
- AUD_Specs m_sspecs;
-
/**
* The src state structure.
*/
*/
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);
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);
};
*/
// 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);
}
#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
/**
* 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
*/
// 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;
// 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)
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);
}
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 = "";
// 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;
}
}
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;
}
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);
+ }
}
}
}
}
}
-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
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;
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;
// 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;
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;
#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" {
/**
* The playback buffer.
*/
- AUD_Buffer *m_buffer;
+ AUD_Buffer m_buffer;
/**
* The specification of the audio data.
/**
* The buffer for package reading.
*/
- AUD_Buffer *m_pkgbuf;
+ AUD_Buffer m_pkgbuf;
/**
* The count of samples still available from the last read package.
* \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.
* \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.
*/
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);
};
* \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);
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;
}
/// 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.
/**
* 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.
#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);
*/
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.
*/
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);
};
return true;
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return false;
}
{
return new AUD_StreamBufferFactory(sound);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return new AUD_DelayFactory(sound, delay);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return new AUD_LimiterFactory(sound, start, end);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return new AUD_PingPongFactory(sound);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return new AUD_LoopFactory(sound);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
if(handle)
{
+ /* AUD_XXX Doesn't work atm, will come back
+
AUD_Message message;
message.type = AUD_MSG_LOOP;
message.loopcount = loops;
{
return AUD_device->sendMessage(handle, message);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
- }
+ }*/
}
return false;
}
{
return new AUD_RectifyFactory(sound);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return AUD_device->play(sound, keep);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
else
return AUD_device->play(sound, keep);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
if(AUD_3ddevice)
return AUD_3ddevice->updateListener(*data);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
return false;
if(AUD_3ddevice)
return AUD_3ddevice->setSetting(setting, value);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
return false;
if(AUD_3ddevice)
return AUD_3ddevice->getSetting(setting);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
return 0.0f;
if(AUD_3ddevice)
return AUD_3ddevice->updateSource(handle, *data);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
}
if(AUD_3ddevice)
return AUD_3ddevice->setSourceSetting(handle, setting, value);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
}
if(AUD_3ddevice)
return AUD_3ddevice->getSourceSetting(handle, setting);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
}
{
return AUD_device->setCapability(AUD_CAPS_SOURCE_VOLUME, &caps);
}
- catch(AUD_Exception) {}
+ catch(AUD_Exception&) {}
}
return false;
}
{
return AUD_device->setCapability(AUD_CAPS_SOURCE_PITCH, &caps);
}
- catch(AUD_Exception) {}
+ catch(AUD_Exception&) {}
}
return false;
}
{
return new AUD_ReadDevice(specs);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
device->seek(handle, seek);
return handle;
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return NULL;
}
{
return device->setCapability(AUD_CAPS_VOLUME, &volume);
}
- catch(AUD_Exception) {}
+ catch(AUD_Exception&) {}
return false;
}
{
return device->setCapability(AUD_CAPS_SOURCE_VOLUME, &caps);
}
- catch(AUD_Exception) {}
+ catch(AUD_Exception&) {}
}
return false;
}
{
return device->read(buffer, length);
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
return false;
}
{
delete device;
}
- catch(AUD_Exception)
+ catch(AUD_Exception&)
{
}
}
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;
}
}
- delete reader; AUD_DELETE("reader")
+ delete reader;
return length;
}
#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
#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)
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++)
{
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;
{
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));
}
*/
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();
*/
void deleteMapping(int ic);
- virtual AUD_IReader* createReader();
+ virtual AUD_IReader* createReader() const;
};
#endif //AUD_CHANNELMAPPERFACTORY
*/
#include "AUD_ChannelMapperReader.h"
-#include "AUD_Buffer.h"
AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_IReader* reader,
float **mapping) :
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;
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];
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()
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();
}
#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.
/**
* The sound output buffer.
*/
- AUD_Buffer *m_buffer;
+ AUD_Buffer m_buffer;
/**
* The output specification.
*/
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);
};
#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;
}
*/
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
*/
#include "AUD_ConverterReader.h"
-#include "AUD_Buffer.h"
AUD_ConverterReader::AUD_ConverterReader(AUD_IReader* reader,
AUD_DeviceSpecs specs) :
}
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;
}
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();
}
#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.
/**
* The sound output buffer.
*/
- AUD_Buffer *m_buffer;
+ AUD_Buffer m_buffer;
/**
* The target specification.
*/
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);
};
--- /dev/null
+/*
+ * $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;
+}
--- /dev/null
+/*
+ * $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
#ifdef WITH_FFMPEG
// needed for INT64_C
+#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
+#endif
#include "AUD_FFMPEGReader.h"
#endif
#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)
}
#include "AUD_Reference.h"
class AUD_Buffer;
+#include <string>
+
/**
* This factory tries to read a sound file via all available file readers.
*/
/**
* 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
/**
* Returns the specification of the device.
*/
- virtual AUD_DeviceSpecs getSpecs()=0;
+ virtual AUD_DeviceSpecs getSpecs() const=0;
/**
* Plays a sound source.
*/
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.
* \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
* \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.
* \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.
* 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.
#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;
}
*/
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
*/
#include "AUD_LinearResampleReader.h"
-#include "AUD_Buffer.h"
#include <cmath>
#include <cstring>
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)
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;
}
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);
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];
}
}
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;
#define AUD_LINEARRESAMPLEREADER
#include "AUD_EffectReader.h"
-class AUD_Buffer;
+#include "AUD_Buffer.h"
/**
* This resampling reader uses libsamplerate for resampling.
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.
/**
* 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);
};
*/
#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
}
}
+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;
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);
#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>
};
/**
- * 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.
*/
/**
* 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.
/**
* 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.
*/<
projects / blender-staging.git / commitdiff