Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Audaspace:

Browse Source 
Replacing AUD_Reference with boost::shared_ptr.
This commit is contained in:
Joerg Mueller
2012-11-05 14:24:35 +00:00
parent 0f9559fe71
commit 5a8d5f77af
137 changed files with 1091 additions and 1040 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
intern/audaspace/CMakeLists.txt
View File

@@ -28,6 +28,7 @@ set(INC
set(INC_SYS
${PTHREADS_INCLUDE_DIRS}
${BOOST_INCLUDE_DIR}
)
set(SRC
@@ -120,6 +121,8 @@ set(SRC
intern/AUD_ResampleFactory.h
intern/AUD_ResampleReader.cpp
intern/AUD_ResampleReader.h
intern/AUD_Sequencer.cpp
intern/AUD_Sequencer.h
intern/AUD_SequencerEntry.cpp
intern/AUD_SequencerEntry.h
intern/AUD_SequencerFactory.cpp
@@ -150,6 +153,7 @@ set(SRC
FX/AUD_DelayReader.h
FX/AUD_DoubleFactory.h
FX/AUD_DoubleReader.h
FX/AUD_IDynamicIIRFilterCalculator.h
FX/AUD_DynamicIIRFilterFactory.h
FX/AUD_DynamicIIRFilterReader.h
FX/AUD_EffectFactory.h

8
intern/audaspace/FX/AUD_AccumulatorFactory.cpp
View File

@@ -50,15 +50,15 @@ sample_t AUD_AccumulatorFactory::accumulatorFilter(AUD_CallbackIIRFilterReader*
return out;
}
AUD_AccumulatorFactory::AUD_AccumulatorFactory(AUD_Reference<AUD_IFactory> factory,
AUD_AccumulatorFactory::AUD_AccumulatorFactory(boost::shared_ptr<AUD_IFactory> factory,
bool additive) :
AUD_EffectFactory(factory),
m_additive(additive)
{
}
AUD_Reference<AUD_IReader> AUD_AccumulatorFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_AccumulatorFactory::createReader()
{
return new AUD_CallbackIIRFilterReader(getReader(), 2, 2,
m_additive ? accumulatorFilterAdditive : accumulatorFilter);
return boost::shared_ptr<AUD_IReader>(new AUD_CallbackIIRFilterReader(getReader(), 2, 2,
m_additive ? accumulatorFilterAdditive : accumulatorFilter));
}

4
intern/audaspace/FX/AUD_AccumulatorFactory.h
View File

@@ -58,9 +58,9 @@ public:
* \param factory The input factory.
* \param additive Whether the accumulator is additive.
*/
AUD_AccumulatorFactory(AUD_Reference<AUD_IFactory> factory, bool additive = false);
AUD_AccumulatorFactory(boost::shared_ptr<AUD_IFactory> factory, bool additive = false);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
static sample_t accumulatorFilterAdditive(AUD_CallbackIIRFilterReader* reader, void* useless);
static sample_t accumulatorFilter(AUD_CallbackIIRFilterReader* reader, void* useless);

2
intern/audaspace/FX/AUD_BaseIIRFilterReader.cpp
View File

@@ -33,7 +33,7 @@
#define CC m_specs.channels + m_channel
AUD_BaseIIRFilterReader::AUD_BaseIIRFilterReader(AUD_Reference<AUD_IReader> reader, int in,
AUD_BaseIIRFilterReader::AUD_BaseIIRFilterReader(boost::shared_ptr<AUD_IReader> reader, int in,
int out) :
AUD_EffectReader(reader),
m_specs(reader->getSpecs()),

2
intern/audaspace/FX/AUD_BaseIIRFilterReader.h
View File

@@ -90,7 +90,7 @@ protected:
* \param in The count of past input samples needed.
* \param out The count of past output samples needed.
*/
AUD_BaseIIRFilterReader(AUD_Reference<AUD_IReader> reader, int in, int out);
AUD_BaseIIRFilterReader(boost::shared_ptr<AUD_IReader> reader, int in, int out);
void setLengths(int in, int out);

2
intern/audaspace/FX/AUD_ButterworthFactory.cpp
View File

@@ -39,7 +39,7 @@
#define BWPB41 0.76536686473
#define BWPB42 1.84775906502
AUD_ButterworthFactory::AUD_ButterworthFactory(AUD_Reference<AUD_IFactory> factory,
AUD_ButterworthFactory::AUD_ButterworthFactory(boost::shared_ptr<AUD_IFactory> factory,
float frequency) :
AUD_DynamicIIRFilterFactory(factory),
m_frequency(frequency)

2
intern/audaspace/FX/AUD_ButterworthFactory.h
View File

@@ -53,7 +53,7 @@ public:
* \param factory The input factory.
* \param frequency The cutoff frequency.
*/
AUD_ButterworthFactory(AUD_Reference<AUD_IFactory> factory, float frequency);
AUD_ButterworthFactory(boost::shared_ptr<AUD_IFactory> factory, float frequency);
virtual void recalculateCoefficients(AUD_SampleRate rate,
std::vector<float>& b,

2
intern/audaspace/FX/AUD_CallbackIIRFilterReader.cpp
View File

@@ -29,7 +29,7 @@
#include "AUD_CallbackIIRFilterReader.h"
AUD_CallbackIIRFilterReader::AUD_CallbackIIRFilterReader(AUD_Reference<AUD_IReader> reader,
AUD_CallbackIIRFilterReader::AUD_CallbackIIRFilterReader(boost::shared_ptr<AUD_IReader> reader,
int in, int out,
doFilterIIR doFilter,
endFilterIIR endFilter,

2
intern/audaspace/FX/AUD_CallbackIIRFilterReader.h
View File

@@ -74,7 +74,7 @@ public:
* \param endFilter The finishing callback.
* \param data Data pointer for the callbacks.
*/
AUD_CallbackIIRFilterReader(AUD_Reference<AUD_IReader> reader, int in, int out,
AUD_CallbackIIRFilterReader(boost::shared_ptr<AUD_IReader> reader, int in, int out,
doFilterIIR doFilter,
endFilterIIR endFilter = 0,
void* data = 0);

6
intern/audaspace/FX/AUD_DelayFactory.cpp
View File

@@ -31,7 +31,7 @@
#include "AUD_DelayReader.h"
#include "AUD_Space.h"
AUD_DelayFactory::AUD_DelayFactory(AUD_Reference<AUD_IFactory> factory, float delay) :
AUD_DelayFactory::AUD_DelayFactory(boost::shared_ptr<AUD_IFactory> factory, float delay) :
AUD_EffectFactory(factory),
m_delay(delay)
{
@@ -42,7 +42,7 @@ float AUD_DelayFactory::getDelay() const
return m_delay;
}
AUD_Reference<AUD_IReader> AUD_DelayFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_DelayFactory::createReader()
{
return new AUD_DelayReader(getReader(), m_delay);
return boost::shared_ptr<AUD_IReader>(new AUD_DelayReader(getReader(), m_delay));
}

4
intern/audaspace/FX/AUD_DelayFactory.h
View File

@@ -53,14 +53,14 @@ public:
* \param factory The input factory.
* \param delay The desired delay in seconds.
*/
AUD_DelayFactory(AUD_Reference<AUD_IFactory> factory, float delay = 0);
AUD_DelayFactory(boost::shared_ptr<AUD_IFactory> factory, float delay = 0);
/**
* Returns the delay in seconds.
*/
float getDelay() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_DELAYFACTORY_H__

2
intern/audaspace/FX/AUD_DelayReader.cpp
View File

@@ -31,7 +31,7 @@
#include <cstring>
AUD_DelayReader::AUD_DelayReader(AUD_Reference<AUD_IReader> reader, float delay) :
AUD_DelayReader::AUD_DelayReader(boost::shared_ptr<AUD_IReader> reader, float delay) :
AUD_EffectReader(reader),
m_delay(int((AUD_SampleRate)delay * reader->getSpecs().rate)),
m_remdelay(int((AUD_SampleRate)delay * reader->getSpecs().rate))

2
intern/audaspace/FX/AUD_DelayReader.h
View File

@@ -59,7 +59,7 @@ public:
* \param reader The reader to read from.
* \param delay The delay in seconds.
*/
AUD_DelayReader(AUD_Reference<AUD_IReader> reader, float delay);
AUD_DelayReader(boost::shared_ptr<AUD_IReader> reader, float delay);
virtual void seek(int position);
virtual int getLength() const;

10
intern/audaspace/FX/AUD_DoubleFactory.cpp
View File

@@ -30,15 +30,15 @@
#include "AUD_DoubleFactory.h"
#include "AUD_DoubleReader.h"
AUD_DoubleFactory::AUD_DoubleFactory(AUD_Reference<AUD_IFactory> factory1, AUD_Reference<AUD_IFactory> factory2) :
AUD_DoubleFactory::AUD_DoubleFactory(boost::shared_ptr<AUD_IFactory> factory1, boost::shared_ptr<AUD_IFactory> factory2) :
m_factory1(factory1), m_factory2(factory2)
{
}
AUD_Reference<AUD_IReader> AUD_DoubleFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_DoubleFactory::createReader()
{
AUD_Reference<AUD_IReader> reader1 = m_factory1->createReader();
AUD_Reference<AUD_IReader> reader2 = m_factory2->createReader();
boost::shared_ptr<AUD_IReader> reader1 = m_factory1->createReader();
boost::shared_ptr<AUD_IReader> reader2 = m_factory2->createReader();
return new AUD_DoubleReader(reader1, reader2);
return boost::shared_ptr<AUD_IReader>(new AUD_DoubleReader(reader1, reader2));
}

8
intern/audaspace/FX/AUD_DoubleFactory.h
View File

@@ -41,12 +41,12 @@ private:
/**
* First played factory.
*/
AUD_Reference<AUD_IFactory> m_factory1;
boost::shared_ptr<AUD_IFactory> m_factory1;
/**
* Second played factory.
*/
AUD_Reference<AUD_IFactory> m_factory2;
boost::shared_ptr<AUD_IFactory> m_factory2;
// hide copy constructor and operator=
AUD_DoubleFactory(const AUD_DoubleFactory&);
@@ -58,9 +58,9 @@ public:
* \param factory1 The first input factory.
* \param factory2 The second input factory.
*/
AUD_DoubleFactory(AUD_Reference<AUD_IFactory> factory1, AUD_Reference<AUD_IFactory> factory2);
AUD_DoubleFactory(boost::shared_ptr<AUD_IFactory> factory1, boost::shared_ptr<AUD_IFactory> factory2);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_DOUBLEFACTORY_H__

4
intern/audaspace/FX/AUD_DoubleReader.cpp
View File

@@ -31,8 +31,8 @@
#include <cstring>
AUD_DoubleReader::AUD_DoubleReader(AUD_Reference<AUD_IReader> reader1,
AUD_Reference<AUD_IReader> reader2) :
AUD_DoubleReader::AUD_DoubleReader(boost::shared_ptr<AUD_IReader> reader1,
boost::shared_ptr<AUD_IReader> reader2) :
m_reader1(reader1), m_reader2(reader2), m_finished1(false)
{
AUD_Specs s1, s2;

9
intern/audaspace/FX/AUD_DoubleReader.h
View File

@@ -32,7 +32,8 @@
#include "AUD_IReader.h"
#include "AUD_Buffer.h"
#include "AUD_Reference.h"
#include <boost/shared_ptr.hpp>
/**
* This reader plays two readers sequently.
@@ -43,12 +44,12 @@ private:
/**
* The first reader.
*/
AUD_Reference<AUD_IReader> m_reader1;
boost::shared_ptr<AUD_IReader> m_reader1;
/**
* The second reader.
*/
AUD_Reference<AUD_IReader> m_reader2;
boost::shared_ptr<AUD_IReader> m_reader2;
/**
* Whether we've reached the end of the first reader.
@@ -65,7 +66,7 @@ public:
* \param reader1 The first reader to read from.
* \param reader2 The second reader to read from.
*/
AUD_DoubleReader(AUD_Reference<AUD_IReader> reader1, AUD_Reference<AUD_IReader> reader2);
AUD_DoubleReader(boost::shared_ptr<AUD_IReader> reader1, boost::shared_ptr<AUD_IReader> reader2);
/**
* Destroys the reader.

8
intern/audaspace/FX/AUD_DynamicIIRFilterFactory.cpp
View File

@@ -29,12 +29,14 @@
#include "AUD_DynamicIIRFilterFactory.h"
#include "AUD_DynamicIIRFilterReader.h"
AUD_DynamicIIRFilterFactory::AUD_DynamicIIRFilterFactory(AUD_Reference<AUD_IFactory> factory) :
AUD_DynamicIIRFilterFactory::AUD_DynamicIIRFilterFactory(boost::shared_ptr<AUD_IFactory> factory) :
AUD_EffectFactory(factory)
{
}
AUD_Reference<AUD_IReader> AUD_DynamicIIRFilterFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_DynamicIIRFilterFactory::createReader()
{
return new AUD_DynamicIIRFilterReader(getReader(), this);
return boost::shared_ptr<AUD_IReader>(new AUD_DynamicIIRFilterReader(getReader(), m_calculator));
}

18
intern/audaspace/FX/AUD_DynamicIIRFilterFactory.h
View File

@@ -30,6 +30,7 @@
#define __AUD_DYNAMICIIRFILTERFACTORY_H__
#include "AUD_EffectFactory.h"
#include "AUD_IDynamicIIRFilterCalculator.h"
#include <vector>
/**
@@ -40,24 +41,17 @@
*/
class AUD_DynamicIIRFilterFactory : public AUD_EffectFactory
{
protected:
boost::shared_ptr<AUD_IDynamicIIRFilterCalculator> m_calculator;
public:
/**
* Creates a new Dynmic IIR filter factory.
* \param factory The input factory.
*/
AUD_DynamicIIRFilterFactory(AUD_Reference<AUD_IFactory> factory);
AUD_DynamicIIRFilterFactory(boost::shared_ptr<AUD_IFactory> factory);
virtual AUD_Reference<AUD_IReader> createReader();
/**
* Recalculates the filter coefficients.
* \param rate The sample rate of the audio data.
* \param[out] b The input filter coefficients.
* \param[out] a The output filter coefficients.
*/
virtual void recalculateCoefficients(AUD_SampleRate rate,
std::vector<float>& b,
std::vector<float>& a)=0;
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif // __AUD_DYNAMICIIRFILTERFACTORY_H__

8
intern/audaspace/FX/AUD_DynamicIIRFilterReader.cpp
View File

@@ -28,10 +28,10 @@
#include "AUD_DynamicIIRFilterReader.h"
AUD_DynamicIIRFilterReader::AUD_DynamicIIRFilterReader(AUD_Reference<AUD_IReader> reader,
AUD_Reference<AUD_DynamicIIRFilterFactory> factory) :
AUD_DynamicIIRFilterReader::AUD_DynamicIIRFilterReader(boost::shared_ptr<AUD_IReader> reader,
boost::shared_ptr<AUD_IDynamicIIRFilterCalculator> calculator) :
AUD_IIRFilterReader(reader, std::vector<float>(), std::vector<float>()),
m_factory(factory)
m_calculator(calculator)
{
sampleRateChanged(reader->getSpecs().rate);
}
@@ -39,6 +39,6 @@ AUD_DynamicIIRFilterReader::AUD_DynamicIIRFilterReader(AUD_Reference<AUD_IReader
void AUD_DynamicIIRFilterReader::sampleRateChanged(AUD_SampleRate rate)
{
std::vector<float> a, b;
m_factory->recalculateCoefficients(rate, b, a);
m_calculator->recalculateCoefficients(rate, b, a);
setCoefficients(b, a);
}

8
intern/audaspace/FX/AUD_DynamicIIRFilterReader.h
View File

@@ -30,7 +30,7 @@
#define __AUD_DYNAMICIIRFILTERREADER_H__
#include "AUD_IIRFilterReader.h"
#include "AUD_DynamicIIRFilterFactory.h"
#include "AUD_IDynamicIIRFilterCalculator.h"
/**
* This class is for dynamic infinite impulse response filters with simple
@@ -42,11 +42,11 @@ private:
/**
* The factory for dynamically recalculating filter coefficients.
*/
AUD_Reference<AUD_DynamicIIRFilterFactory> m_factory;
boost::shared_ptr<AUD_IDynamicIIRFilterCalculator> m_calculator;
public:
AUD_DynamicIIRFilterReader(AUD_Reference<AUD_IReader> reader,
AUD_Reference<AUD_DynamicIIRFilterFactory> factory);
AUD_DynamicIIRFilterReader(boost::shared_ptr<AUD_IReader> reader,
boost::shared_ptr<AUD_IDynamicIIRFilterCalculator> calculator);
virtual void sampleRateChanged(AUD_SampleRate rate);
};

4
intern/audaspace/FX/AUD_EffectFactory.cpp
View File

@@ -30,7 +30,7 @@
#include "AUD_EffectFactory.h"
#include "AUD_IReader.h"
AUD_EffectFactory::AUD_EffectFactory(AUD_Reference<AUD_IFactory> factory)
AUD_EffectFactory::AUD_EffectFactory(boost::shared_ptr<AUD_IFactory> factory)
{
m_factory = factory;
}
@@ -39,7 +39,7 @@ AUD_EffectFactory::~AUD_EffectFactory()
{
}
AUD_Reference<AUD_IFactory> AUD_EffectFactory::getFactory() const
boost::shared_ptr<AUD_IFactory> AUD_EffectFactory::getFactory() const
{
return m_factory;
}

8
intern/audaspace/FX/AUD_EffectFactory.h
View File

@@ -47,7 +47,7 @@ protected:
/**
* If there is no reader it is created out of this factory.
*/
AUD_Reference<AUD_IFactory> m_factory;
boost::shared_ptr<AUD_IFactory> m_factory;
/**
* Returns the reader created out of the factory.
@@ -55,7 +55,7 @@ protected:
* classes.
* \return The reader created out of the factory.
*/
inline AUD_Reference<AUD_IReader> getReader() const
inline boost::shared_ptr<AUD_IReader> getReader() const
{
return m_factory->createReader();
}
@@ -65,7 +65,7 @@ public:
* Creates a new factory.
* \param factory The input factory.
*/
AUD_EffectFactory(AUD_Reference<AUD_IFactory> factory);
AUD_EffectFactory(boost::shared_ptr<AUD_IFactory> factory);
/**
* Destroys the factory.
@@ -76,7 +76,7 @@ public:
* Returns the saved factory.
* \return The factory or NULL if there has no factory been saved.
*/
AUD_Reference<AUD_IFactory> getFactory() const;
boost::shared_ptr<AUD_IFactory> getFactory() const;
};
#endif //__AUD_EFFECTFACTORY_H__

2
intern/audaspace/FX/AUD_EffectReader.cpp
View File

@@ -29,7 +29,7 @@
#include "AUD_EffectReader.h"
AUD_EffectReader::AUD_EffectReader(AUD_Reference<AUD_IReader> reader)
AUD_EffectReader::AUD_EffectReader(boost::shared_ptr<AUD_IReader> reader)
{
m_reader = reader;
}

7
intern/audaspace/FX/AUD_EffectReader.h
View File

@@ -31,7 +31,8 @@
#define __AUD_EFFECTREADER_H__
#include "AUD_IReader.h"
#include "AUD_Reference.h"
#include <boost/shared_ptr.hpp>
/**
* This reader is a base class for all effect readers that take one other reader
@@ -48,14 +49,14 @@ protected:
/**
* The reader to read from.
*/
AUD_Reference<AUD_IReader> m_reader;
boost::shared_ptr<AUD_IReader> m_reader;
public:
/**
* Creates a new effect reader.
* \param reader The reader to read from.
*/
AUD_EffectReader(AUD_Reference<AUD_IReader> reader);
AUD_EffectReader(boost::shared_ptr<AUD_IReader> reader);
/**
* Destroys the reader.

10
intern/audaspace/FX/AUD_EnvelopeFactory.cpp
View File

@@ -54,7 +54,7 @@ void AUD_EnvelopeFactory::endEnvelopeFilter(EnvelopeParameters* param)
delete param;
}
AUD_EnvelopeFactory::AUD_EnvelopeFactory(AUD_Reference<AUD_IFactory> factory, float attack,
AUD_EnvelopeFactory::AUD_EnvelopeFactory(boost::shared_ptr<AUD_IFactory> factory, float attack,
float release, float threshold,
float arthreshold) :
AUD_EffectFactory(factory),
@@ -65,9 +65,9 @@ AUD_EnvelopeFactory::AUD_EnvelopeFactory(AUD_Reference<AUD_IFactory> factory, fl
{
}
AUD_Reference<AUD_IReader> AUD_EnvelopeFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_EnvelopeFactory::createReader()
{
AUD_Reference<AUD_IReader> reader = getReader();
boost::shared_ptr<AUD_IReader> reader = getReader();
EnvelopeParameters* param = new EnvelopeParameters();
param->arthreshold = m_arthreshold;
@@ -75,8 +75,8 @@ AUD_Reference<AUD_IReader> AUD_EnvelopeFactory::createReader()
param->release = pow(m_arthreshold, 1.0f/(static_cast<float>(reader->getSpecs().rate) * m_release));
param->threshold = m_threshold;
return new AUD_CallbackIIRFilterReader(reader, 1, 2,
return boost::shared_ptr<AUD_IReader>(new AUD_CallbackIIRFilterReader(reader, 1, 2,
(doFilterIIR) envelopeFilter,
(endFilterIIR) endEnvelopeFilter,
param);
param));
}

4
intern/audaspace/FX/AUD_EnvelopeFactory.h
View File

@@ -73,10 +73,10 @@ public:
* \param threshold The threshold value.
* \param arthreshold The attack/release threshold value.
*/
AUD_EnvelopeFactory(AUD_Reference<AUD_IFactory> factory, float attack, float release,
AUD_EnvelopeFactory(boost::shared_ptr<AUD_IFactory> factory, float attack, float release,
float threshold, float arthreshold);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
static sample_t envelopeFilter(AUD_CallbackIIRFilterReader* reader, EnvelopeParameters* param);
static void endEnvelopeFilter(EnvelopeParameters* param);

6
intern/audaspace/FX/AUD_FaderFactory.cpp
View File

@@ -30,7 +30,7 @@
#include "AUD_FaderFactory.h"
#include "AUD_FaderReader.h"
AUD_FaderFactory::AUD_FaderFactory(AUD_Reference<AUD_IFactory> factory, AUD_FadeType type,
AUD_FaderFactory::AUD_FaderFactory(boost::shared_ptr<AUD_IFactory> factory, AUD_FadeType type,
float start, float length) :
AUD_EffectFactory(factory),
m_type(type),
@@ -54,7 +54,7 @@ float AUD_FaderFactory::getLength() const
return m_length;
}
AUD_Reference<AUD_IReader> AUD_FaderFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_FaderFactory::createReader()
{
return new AUD_FaderReader(getReader(), m_type, m_start, m_length);
return boost::shared_ptr<AUD_IReader>(new AUD_FaderReader(getReader(), m_type, m_start, m_length));
}

4
intern/audaspace/FX/AUD_FaderFactory.h
View File

@@ -67,7 +67,7 @@ public:
* \param start The time where fading should start in seconds.
* \param length How long fading should last in seconds.
*/
AUD_FaderFactory(AUD_Reference<AUD_IFactory> factory,
AUD_FaderFactory(boost::shared_ptr<AUD_IFactory> factory,
AUD_FadeType type = AUD_FADE_IN,
float start = 0.0f, float length = 1.0f);
@@ -86,7 +86,7 @@ public:
*/
float getLength() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_FADERFACTORY_H__

2
intern/audaspace/FX/AUD_FaderReader.cpp
View File

@@ -31,7 +31,7 @@
#include <cstring>
AUD_FaderReader::AUD_FaderReader(AUD_Reference<AUD_IReader> reader, AUD_FadeType type,
AUD_FaderReader::AUD_FaderReader(boost::shared_ptr<AUD_IReader> reader, AUD_FadeType type,
float start,float length) :
AUD_EffectReader(reader),
m_type(type),

2
intern/audaspace/FX/AUD_FaderReader.h
View File

@@ -67,7 +67,7 @@ public:
* \param start The time where fading should start in seconds.
* \param length How long fading should last in seconds.
*/
AUD_FaderReader(AUD_Reference<AUD_IReader> reader, AUD_FadeType type,
AUD_FaderReader(boost::shared_ptr<AUD_IReader> reader, AUD_FadeType type,
float start,float length);
virtual void read(int& length, bool& eos, sample_t* buffer);

2
intern/audaspace/FX/AUD_HighpassFactory.cpp
View File

@@ -36,7 +36,7 @@
#define M_PI 3.14159265358979323846
#endif
AUD_HighpassFactory::AUD_HighpassFactory(AUD_Reference<AUD_IFactory> factory, float frequency,
AUD_HighpassFactory::AUD_HighpassFactory(boost::shared_ptr<AUD_IFactory> factory, float frequency,
float Q) :
AUD_DynamicIIRFilterFactory(factory),
m_frequency(frequency),

2
intern/audaspace/FX/AUD_HighpassFactory.h
View File

@@ -59,7 +59,7 @@ public:
* \param frequency The cutoff frequency.
* \param Q The Q factor.
*/
AUD_HighpassFactory(AUD_Reference<AUD_IFactory> factory, float frequency, float Q = 1.0f);
AUD_HighpassFactory(boost::shared_ptr<AUD_IFactory> factory, float frequency, float Q = 1.0f);
virtual void recalculateCoefficients(AUD_SampleRate rate, std::vector<float> &b, std::vector<float> &a);
};

44
intern/audaspace/intern/AUD_ReferenceHandler.cpp → intern/audaspace/FX/AUD_IDynamicIIRFilterCalculator.h
View File

@@ -22,31 +22,31 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file audaspace/intern/AUD_ReferenceHandler.cpp
* \ingroup audaspaceintern
/** \file audaspace/FX/AUD_IDynamicIIRFilterCalculator.h
* \ingroup audfx
*/
#include "AUD_Reference.h"
#ifndef AUD_IDYNAMICIIRFILTERCALCULATOR_H
#define AUD_IDYNAMICIIRFILTERCALCULATOR_H
std::map<void*, unsigned int> AUD_ReferenceHandler::m_references;
pthread_mutex_t AUD_ReferenceHandler::m_mutex;
bool AUD_ReferenceHandler::m_mutex_initialised = false;
#include <vector>
pthread_mutex_t *AUD_ReferenceHandler::getMutex()
/**
* This interface calculates dynamic filter coefficients which depend on the
* sampling rate for AUD_DynamicIIRFilterReaders.
*/
class AUD_IDynamicIIRFilterCalculator
{
if(!m_mutex_initialised)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&m_mutex, &attr);
pthread_mutexattr_destroy(&attr);
m_mutex_initialised = true;
}
return &m_mutex;
}
public:
/**
* Recalculates the filter coefficients.
* \param rate The sample rate of the audio data.
* \param[out] b The input filter coefficients.
* \param[out] a The output filter coefficients.
*/
virtual void recalculateCoefficients(AUD_SampleRate rate,
std::vector<float>& b,
std::vector<float>& a)=0;
};
#endif // AUD_IDYNAMICIIRFILTERCALCULATOR_H

6
intern/audaspace/FX/AUD_IIRFilterFactory.cpp
View File

@@ -30,14 +30,14 @@
#include "AUD_IIRFilterFactory.h"
#include "AUD_IIRFilterReader.h"
AUD_IIRFilterFactory::AUD_IIRFilterFactory(AUD_Reference<AUD_IFactory> factory,
AUD_IIRFilterFactory::AUD_IIRFilterFactory(boost::shared_ptr<AUD_IFactory> factory,
std::vector<float> b,
std::vector<float> a) :
AUD_EffectFactory(factory), m_a(a), m_b(b)
{
}
AUD_Reference<AUD_IReader> AUD_IIRFilterFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_IIRFilterFactory::createReader()
{
return new AUD_IIRFilterReader(getReader(), m_b, m_a);
return boost::shared_ptr<AUD_IReader>(new AUD_IIRFilterReader(getReader(), m_b, m_a));
}

5
intern/audaspace/FX/AUD_IIRFilterFactory.h
View File

@@ -31,6 +31,7 @@
#define __AUD_IIRFILTERFACTORY_H__
#include "AUD_EffectFactory.h"
#include "AUD_IDynamicIIRFilterCalculator.h"
#include <vector>
@@ -61,10 +62,10 @@ public:
* \param b The input filter coefficients.
* \param a The output filter coefficients.
*/
AUD_IIRFilterFactory(AUD_Reference<AUD_IFactory> factory, std::vector<float> b,
AUD_IIRFilterFactory(boost::shared_ptr<AUD_IFactory> factory, std::vector<float> b,
std::vector<float> a);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_IIRFILTERFACTORY_H__

2
intern/audaspace/FX/AUD_IIRFilterReader.cpp
View File

@@ -29,7 +29,7 @@
#include "AUD_IIRFilterReader.h"
AUD_IIRFilterReader::AUD_IIRFilterReader(AUD_Reference<AUD_IReader> reader,
AUD_IIRFilterReader::AUD_IIRFilterReader(boost::shared_ptr<AUD_IReader> reader,
const std::vector<float>& b,
const std::vector<float>& a) :
AUD_BaseIIRFilterReader(reader, b.size(), a.size()), m_a(a), m_b(b)

2
intern/audaspace/FX/AUD_IIRFilterReader.h
View File

@@ -61,7 +61,7 @@ public:
* \param b The input filter coefficients.
* \param a The output filter coefficients.
*/
AUD_IIRFilterReader(AUD_Reference<AUD_IReader> reader, const std::vector<float>& b,
AUD_IIRFilterReader(boost::shared_ptr<AUD_IReader> reader, const std::vector<float>& b,
const std::vector<float>& a);
virtual sample_t filter();

6
intern/audaspace/FX/AUD_LimiterFactory.cpp
View File

@@ -31,7 +31,7 @@
#include "AUD_LimiterReader.h"
#include "AUD_Space.h"
AUD_LimiterFactory::AUD_LimiterFactory(AUD_Reference<AUD_IFactory> factory,
AUD_LimiterFactory::AUD_LimiterFactory(boost::shared_ptr<AUD_IFactory> factory,
float start, float end) :
AUD_EffectFactory(factory),
m_start(start),
@@ -49,7 +49,7 @@ float AUD_LimiterFactory::getEnd() const
return m_end;
}
AUD_Reference<AUD_IReader> AUD_LimiterFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_LimiterFactory::createReader()
{
return new AUD_LimiterReader(getReader(), m_start, m_end);
return boost::shared_ptr<AUD_IReader>(new AUD_LimiterReader(getReader(), m_start, m_end));
}

4
intern/audaspace/FX/AUD_LimiterFactory.h
View File

@@ -60,7 +60,7 @@ public:
* \param end The desired end time, a negative value signals that it should
* play to the end.
*/
AUD_LimiterFactory(AUD_Reference<AUD_IFactory> factory,
AUD_LimiterFactory(boost::shared_ptr<AUD_IFactory> factory,
float start = 0, float end = -1);
/**
@@ -73,7 +73,7 @@ public:
*/
float getEnd() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_LIMITERFACTORY_H__

2
intern/audaspace/FX/AUD_LimiterReader.cpp
View File

@@ -30,7 +30,7 @@
#include "AUD_LimiterReader.h"
#include "AUD_Buffer.h"
AUD_LimiterReader::AUD_LimiterReader(AUD_Reference<AUD_IReader> reader,
AUD_LimiterReader::AUD_LimiterReader(boost::shared_ptr<AUD_IReader> reader,
float start, float end) :
AUD_EffectReader(reader),
m_start(start),

2
intern/audaspace/FX/AUD_LimiterReader.h
View File

@@ -60,7 +60,7 @@ public:
* \param end The desired end time (sample exklusive), a negative value
* signals that it should play to the end.
*/
AUD_LimiterReader(AUD_Reference<AUD_IReader> reader, float start = 0, float end = -1);
AUD_LimiterReader(boost::shared_ptr<AUD_IReader> reader, float start = 0, float end = -1);
virtual void seek(int position);
virtual int getLength() const;

6
intern/audaspace/FX/AUD_LoopFactory.cpp
View File

@@ -30,7 +30,7 @@
#include "AUD_LoopFactory.h"
#include "AUD_LoopReader.h"
AUD_LoopFactory::AUD_LoopFactory(AUD_Reference<AUD_IFactory> factory, int loop) :
AUD_LoopFactory::AUD_LoopFactory(boost::shared_ptr<AUD_IFactory> factory, int loop) :
AUD_EffectFactory(factory),
m_loop(loop)
{
@@ -41,7 +41,7 @@ int AUD_LoopFactory::getLoop() const
return m_loop;
}
AUD_Reference<AUD_IReader> AUD_LoopFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_LoopFactory::createReader()
{
return new AUD_LoopReader(getReader(), m_loop);
return boost::shared_ptr<AUD_IReader>(new AUD_LoopReader(getReader(), m_loop));
}

4
intern/audaspace/FX/AUD_LoopFactory.h
View File

@@ -55,14 +55,14 @@ public:
* \param loop The desired loop count, negative values result in endless
* looping.
*/
AUD_LoopFactory(AUD_Reference<AUD_IFactory> factory, int loop = -1);
AUD_LoopFactory(boost::shared_ptr<AUD_IFactory> factory, int loop = -1);
/**
* Returns the loop count.
*/
int getLoop() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_LOOPFACTORY_H__

2
intern/audaspace/FX/AUD_LoopReader.cpp
View File

@@ -32,7 +32,7 @@
#include <cstring>
AUD_LoopReader::AUD_LoopReader(AUD_Reference<AUD_IReader> reader, int loop) :
AUD_LoopReader::AUD_LoopReader(boost::shared_ptr<AUD_IReader> reader, int loop) :
AUD_EffectReader(reader), m_count(loop), m_left(loop)
{
}

2
intern/audaspace/FX/AUD_LoopReader.h
View File

@@ -61,7 +61,7 @@ public:
* \param loop The desired loop count, negative values result in endless
* looping.
*/
AUD_LoopReader(AUD_Reference<AUD_IReader> reader, int loop);
AUD_LoopReader(boost::shared_ptr<AUD_IReader> reader, int loop);
virtual void seek(int position);
virtual int getLength() const;

2
intern/audaspace/FX/AUD_LowpassFactory.cpp
View File

@@ -36,7 +36,7 @@
#define M_PI 3.14159265358979323846
#endif
AUD_LowpassFactory::AUD_LowpassFactory(AUD_Reference<AUD_IFactory> factory, float frequency,
AUD_LowpassFactory::AUD_LowpassFactory(boost::shared_ptr<AUD_IFactory> factory, float frequency,
float Q) :
AUD_DynamicIIRFilterFactory(factory),
m_frequency(frequency),

2
intern/audaspace/FX/AUD_LowpassFactory.h
View File

@@ -59,7 +59,7 @@ public:
* \param frequency The cutoff frequency.
* \param Q The Q factor.
*/
AUD_LowpassFactory(AUD_Reference<AUD_IFactory> factory, float frequency, float Q = 1.0f);
AUD_LowpassFactory(boost::shared_ptr<AUD_IFactory> factory, float frequency, float Q = 1.0f);
virtual void recalculateCoefficients(AUD_SampleRate rate, std::vector<float> &b, std::vector<float> &a);
};

10
intern/audaspace/FX/AUD_PingPongFactory.cpp
View File

@@ -31,16 +31,16 @@
#include "AUD_DoubleReader.h"
#include "AUD_ReverseFactory.h"
AUD_PingPongFactory::AUD_PingPongFactory(AUD_Reference<AUD_IFactory> factory) :
AUD_PingPongFactory::AUD_PingPongFactory(boost::shared_ptr<AUD_IFactory> factory) :
AUD_EffectFactory(factory)
{
}
AUD_Reference<AUD_IReader> AUD_PingPongFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_PingPongFactory::createReader()
{
AUD_Reference<AUD_IReader> reader = getReader();
boost::shared_ptr<AUD_IReader> reader = getReader();
AUD_ReverseFactory factory(m_factory);
AUD_Reference<AUD_IReader> reader2 = factory.createReader();
boost::shared_ptr<AUD_IReader> reader2 = factory.createReader();
return new AUD_DoubleReader(reader, reader2);
return boost::shared_ptr<AUD_IReader>(new AUD_DoubleReader(reader, reader2));
}

4
intern/audaspace/FX/AUD_PingPongFactory.h
View File

@@ -48,9 +48,9 @@ public:
* Creates a new ping pong factory.
* \param factory The input factory.
*/
AUD_PingPongFactory(AUD_Reference<AUD_IFactory> factory);
AUD_PingPongFactory(boost::shared_ptr<AUD_IFactory> factory);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_PINGPONGFACTORY_H__

6
intern/audaspace/FX/AUD_PitchFactory.cpp
View File

@@ -31,13 +31,13 @@
#include "AUD_PitchReader.h"
#include "AUD_Space.h"
AUD_PitchFactory::AUD_PitchFactory(AUD_Reference<AUD_IFactory> factory, float pitch) :
AUD_PitchFactory::AUD_PitchFactory(boost::shared_ptr<AUD_IFactory> factory, float pitch) :
AUD_EffectFactory(factory),
m_pitch(pitch)
{
}
AUD_Reference<AUD_IReader> AUD_PitchFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_PitchFactory::createReader()
{
return new AUD_PitchReader(getReader(), m_pitch);
return boost::shared_ptr<AUD_IReader>(new AUD_PitchReader(getReader(), m_pitch));
}

4
intern/audaspace/FX/AUD_PitchFactory.h
View File

@@ -53,9 +53,9 @@ public:
* \param factory The input factory.
* \param pitch The desired pitch.
*/
AUD_PitchFactory(AUD_Reference<AUD_IFactory> factory, float pitch);
AUD_PitchFactory(boost::shared_ptr<AUD_IFactory> factory, float pitch);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_PITCHFACTORY_H__

2
intern/audaspace/FX/AUD_PitchReader.cpp
View File

@@ -29,7 +29,7 @@
#include "AUD_PitchReader.h"
AUD_PitchReader::AUD_PitchReader(AUD_Reference<AUD_IReader> reader, float pitch) :
AUD_PitchReader::AUD_PitchReader(boost::shared_ptr<AUD_IReader> reader, float pitch) :
AUD_EffectReader(reader), m_pitch(pitch)
{
}

2
intern/audaspace/FX/AUD_PitchReader.h
View File

@@ -53,7 +53,7 @@ public:
* \param reader The reader to read from.
* \param pitch The pitch value.
*/
AUD_PitchReader(AUD_Reference<AUD_IReader> reader, float pitch);
AUD_PitchReader(boost::shared_ptr<AUD_IReader> reader, float pitch);
virtual AUD_Specs getSpecs() const;

6
intern/audaspace/FX/AUD_RectifyFactory.cpp
View File

@@ -37,12 +37,12 @@ sample_t AUD_RectifyFactory::rectifyFilter(AUD_CallbackIIRFilterReader* reader,
return fabs(reader->x(0));
}
AUD_RectifyFactory::AUD_RectifyFactory(AUD_Reference<AUD_IFactory> factory) :
AUD_RectifyFactory::AUD_RectifyFactory(boost::shared_ptr<AUD_IFactory> factory) :
AUD_EffectFactory(factory)
{
}
AUD_Reference<AUD_IReader> AUD_RectifyFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_RectifyFactory::createReader()
{
return new AUD_CallbackIIRFilterReader(getReader(), 1, 1, rectifyFilter);
return boost::shared_ptr<AUD_IReader>(new AUD_CallbackIIRFilterReader(getReader(), 1, 1, rectifyFilter));
}

4
intern/audaspace/FX/AUD_RectifyFactory.h
View File

@@ -48,9 +48,9 @@ public:
* Creates a new rectify factory.
* \param factory The input factory.
*/
AUD_RectifyFactory(AUD_Reference<AUD_IFactory> factory);
AUD_RectifyFactory(boost::shared_ptr<AUD_IFactory> factory);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
static sample_t rectifyFilter(AUD_CallbackIIRFilterReader* reader, void* useless);
};

6
intern/audaspace/FX/AUD_ReverseFactory.cpp
View File

@@ -31,12 +31,12 @@
#include "AUD_ReverseReader.h"
#include "AUD_Space.h"
AUD_ReverseFactory::AUD_ReverseFactory(AUD_Reference<AUD_IFactory> factory) :
AUD_ReverseFactory::AUD_ReverseFactory(boost::shared_ptr<AUD_IFactory> factory) :
AUD_EffectFactory(factory)
{
}
AUD_Reference<AUD_IReader> AUD_ReverseFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_ReverseFactory::createReader()
{
return new AUD_ReverseReader(getReader());
return boost::shared_ptr<AUD_IReader>(new AUD_ReverseReader(getReader()));
}

4
intern/audaspace/FX/AUD_ReverseFactory.h
View File

@@ -48,9 +48,9 @@ public:
* Creates a new reverse factory.
* \param factory The input factory.
*/
AUD_ReverseFactory(AUD_Reference<AUD_IFactory> factory);
AUD_ReverseFactory(boost::shared_ptr<AUD_IFactory> factory);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_REVERSEFACTORY_H__

2
intern/audaspace/FX/AUD_ReverseReader.cpp
View File

@@ -34,7 +34,7 @@
static const char* props_error = "AUD_ReverseReader: The reader has to be "
"seekable and a finite length.";
AUD_ReverseReader::AUD_ReverseReader(AUD_Reference<AUD_IReader> reader) :
AUD_ReverseReader::AUD_ReverseReader(boost::shared_ptr<AUD_IReader> reader) :
AUD_EffectReader(reader),
m_length(reader->getLength()),
m_position(0)

2
intern/audaspace/FX/AUD_ReverseReader.h
View File

@@ -61,7 +61,7 @@ public:
* \exception AUD_Exception Thrown if the reader specified has an
* undeterminable/infinite length or is not seekable.
*/
AUD_ReverseReader(AUD_Reference<AUD_IReader> reader);
AUD_ReverseReader(boost::shared_ptr<AUD_IReader> reader);
virtual void seek(int position);
virtual int getLength() const;

8
intern/audaspace/FX/AUD_SquareFactory.cpp
View File

@@ -46,7 +46,7 @@ void AUD_SquareFactory::endSquareFilter(float* threshold)
delete threshold;
}
AUD_SquareFactory::AUD_SquareFactory(AUD_Reference<AUD_IFactory> factory, float threshold) :
AUD_SquareFactory::AUD_SquareFactory(boost::shared_ptr<AUD_IFactory> factory, float threshold) :
AUD_EffectFactory(factory),
m_threshold(threshold)
{
@@ -57,10 +57,10 @@ float AUD_SquareFactory::getThreshold() const
return m_threshold;
}
AUD_Reference<AUD_IReader> AUD_SquareFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_SquareFactory::createReader()
{
return new AUD_CallbackIIRFilterReader(getReader(), 1, 1,
return boost::shared_ptr<AUD_IReader>(new AUD_CallbackIIRFilterReader(getReader(), 1, 1,
(doFilterIIR) squareFilter,
(endFilterIIR) endSquareFilter,
new float(m_threshold));
new float(m_threshold)));
}

4
intern/audaspace/FX/AUD_SquareFactory.h
View File

@@ -54,14 +54,14 @@ public:
* \param factory The input factory.
* \param threshold The threshold.
*/
AUD_SquareFactory(AUD_Reference<AUD_IFactory> factory, float threshold = 0.0f);
AUD_SquareFactory(boost::shared_ptr<AUD_IFactory> factory, float threshold = 0.0f);
/**
* Returns the threshold.
*/
float getThreshold() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
static sample_t squareFilter(AUD_CallbackIIRFilterReader* reader, float* threshold);
static void endSquareFilter(float* threshold);

6
intern/audaspace/FX/AUD_SumFactory.cpp
View File

@@ -30,16 +30,16 @@
#include "AUD_SumFactory.h"
#include "AUD_IIRFilterReader.h"
AUD_SumFactory::AUD_SumFactory(AUD_Reference<AUD_IFactory> factory) :
AUD_SumFactory::AUD_SumFactory(boost::shared_ptr<AUD_IFactory> factory) :
AUD_EffectFactory(factory)
{
}
AUD_Reference<AUD_IReader> AUD_SumFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_SumFactory::createReader()
{
std::vector<float> a, b;
a.push_back(1);
a.push_back(-1);
b.push_back(1);
return new AUD_IIRFilterReader(getReader(), b, a);
return boost::shared_ptr<AUD_IReader>(new AUD_IIRFilterReader(getReader(), b, a));
}

4
intern/audaspace/FX/AUD_SumFactory.h
View File

@@ -47,9 +47,9 @@ public:
* Creates a new sum factory.
* \param factory The input factory.
*/
AUD_SumFactory(AUD_Reference<AUD_IFactory> factory);
AUD_SumFactory(boost::shared_ptr<AUD_IFactory> factory);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_SUMFACTORY_H__

10
intern/audaspace/FX/AUD_SuperposeFactory.cpp
View File

@@ -30,15 +30,15 @@
#include "AUD_SuperposeFactory.h"
#include "AUD_SuperposeReader.h"
AUD_SuperposeFactory::AUD_SuperposeFactory(AUD_Reference<AUD_IFactory> factory1, AUD_Reference<AUD_IFactory> factory2) :
AUD_SuperposeFactory::AUD_SuperposeFactory(boost::shared_ptr<AUD_IFactory> factory1, boost::shared_ptr<AUD_IFactory> factory2) :
m_factory1(factory1), m_factory2(factory2)
{
}
AUD_Reference<AUD_IReader> AUD_SuperposeFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_SuperposeFactory::createReader()
{
AUD_Reference<AUD_IReader> reader1 = m_factory1->createReader();
AUD_Reference<AUD_IReader> reader2 = m_factory2->createReader();
boost::shared_ptr<AUD_IReader> reader1 = m_factory1->createReader();
boost::shared_ptr<AUD_IReader> reader2 = m_factory2->createReader();
return new AUD_SuperposeReader(reader1, reader2);
return boost::shared_ptr<AUD_IReader>(new AUD_SuperposeReader(reader1, reader2));
}

8
intern/audaspace/FX/AUD_SuperposeFactory.h
View File

@@ -43,12 +43,12 @@ private:
/**
* First played factory.
*/
AUD_Reference<AUD_IFactory> m_factory1;
boost::shared_ptr<AUD_IFactory> m_factory1;
/**
* Second played factory.
*/
AUD_Reference<AUD_IFactory> m_factory2;
boost::shared_ptr<AUD_IFactory> m_factory2;
// hide copy constructor and operator=
AUD_SuperposeFactory(const AUD_SuperposeFactory&);
@@ -60,9 +60,9 @@ public:
* \param factory1 The first input factory.
* \param factory2 The second input factory.
*/
AUD_SuperposeFactory(AUD_Reference<AUD_IFactory> factory1, AUD_Reference<AUD_IFactory> factory2);
AUD_SuperposeFactory(boost::shared_ptr<AUD_IFactory> factory1, boost::shared_ptr<AUD_IFactory> factory2);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_SUPERPOSEFACTORY_H__

2
intern/audaspace/FX/AUD_SuperposeReader.cpp
View File

@@ -34,7 +34,7 @@
static const char* specs_error = "AUD_SuperposeReader: Both readers have to "
"have the same specs.";
AUD_SuperposeReader::AUD_SuperposeReader(AUD_Reference<AUD_IReader> reader1, AUD_Reference<AUD_IReader> reader2) :
AUD_SuperposeReader::AUD_SuperposeReader(boost::shared_ptr<AUD_IReader> reader1, boost::shared_ptr<AUD_IReader> reader2) :
m_reader1(reader1), m_reader2(reader2)
{
}

9
intern/audaspace/FX/AUD_SuperposeReader.h
View File

@@ -32,7 +32,8 @@
#include "AUD_IReader.h"
#include "AUD_Buffer.h"
#include "AUD_Reference.h"
#include <boost/shared_ptr.hpp>
/**
* This reader plays two readers with the same specs in parallel.
@@ -43,12 +44,12 @@ private:
/**
* The first reader.
*/
AUD_Reference<AUD_IReader> m_reader1;
boost::shared_ptr<AUD_IReader> m_reader1;
/**
* The second reader.
*/
AUD_Reference<AUD_IReader> m_reader2;
boost::shared_ptr<AUD_IReader> m_reader2;
/**
* Buffer used for mixing.
@@ -66,7 +67,7 @@ public:
* \param reader2 The second reader to read from.
* \exception AUD_Exception Thrown if the specs from the readers differ.
*/
AUD_SuperposeReader(AUD_Reference<AUD_IReader> reader1, AUD_Reference<AUD_IReader> reader2);
AUD_SuperposeReader(boost::shared_ptr<AUD_IReader> reader1, boost::shared_ptr<AUD_IReader> reader2);
/**
* Destroys the reader.

6
intern/audaspace/FX/AUD_VolumeFactory.cpp
View File

@@ -30,7 +30,7 @@
#include "AUD_VolumeFactory.h"
#include "AUD_IIRFilterReader.h"
AUD_VolumeFactory::AUD_VolumeFactory(AUD_Reference<AUD_IFactory> factory, float volume) :
AUD_VolumeFactory::AUD_VolumeFactory(boost::shared_ptr<AUD_IFactory> factory, float volume) :
AUD_EffectFactory(factory),
m_volume(volume)
{
@@ -41,10 +41,10 @@ float AUD_VolumeFactory::getVolume() const
return m_volume;
}
AUD_Reference<AUD_IReader> AUD_VolumeFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_VolumeFactory::createReader()
{
std::vector<float> a, b;
a.push_back(1);
b.push_back(m_volume);
return new AUD_IIRFilterReader(getReader(), b, a);
return boost::shared_ptr<AUD_IReader>(new AUD_IIRFilterReader(getReader(), b, a));
}

4
intern/audaspace/FX/AUD_VolumeFactory.h
View File

@@ -55,7 +55,7 @@ public:
* \param factory The input factory.
* \param volume The desired volume.
*/
AUD_VolumeFactory(AUD_Reference<AUD_IFactory> factory, float volume);
AUD_VolumeFactory(boost::shared_ptr<AUD_IFactory> factory, float volume);
/**
* Returns the volume.
@@ -63,7 +63,7 @@ public:
*/
float getVolume() const;
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_VOLUMEFACTORY_H__

63
intern/audaspace/OpenAL/AUD_OpenALDevice.cpp
View File

@@ -67,7 +67,7 @@ static const char* queue_error = "AUD_OpenALDevice: Buffer couldn't be "
static const char* bufferdata_error = "AUD_OpenALDevice: Buffer couldn't be "
"filled with data.";
AUD_OpenALDevice::AUD_OpenALHandle::AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, AUD_Reference<AUD_IReader> reader, bool keep) :
AUD_OpenALDevice::AUD_OpenALHandle::AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, boost::shared_ptr<AUD_IReader> reader, bool keep) :
m_isBuffered(false), m_reader(reader), m_keep(keep), m_format(format), m_current(0),
m_eos(false), m_loopcount(0), m_stop(NULL), m_stop_data(NULL), m_status(AUD_STATUS_PLAYING),
m_device(device)
@@ -130,14 +130,22 @@ bool AUD_OpenALDevice::AUD_OpenALHandle::pause()
if(m_status == AUD_STATUS_PLAYING)
{
m_device->m_playingSounds.remove(this);
m_device->m_pausedSounds.push_back(this);
for(AUD_HandleIterator it = m_device->m_playingSounds.begin(); it != m_device->m_playingSounds.end(); it++)
{
if(it->get() == this)
{
boost::shared_ptr<AUD_OpenALHandle> This = *it;
alSourcePause(m_source);
m_device->m_playingSounds.erase(it);
m_device->m_pausedSounds.push_back(This);
m_status = AUD_STATUS_PAUSED;
alSourcePause(m_source);
return true;
m_status = AUD_STATUS_PAUSED;
return true;
}
}
}
}
@@ -152,12 +160,21 @@ bool AUD_OpenALDevice::AUD_OpenALHandle::resume()
if(m_status == AUD_STATUS_PAUSED)
{
m_device->m_pausedSounds.remove(this);
m_device->m_playingSounds.push_back(this);
for(AUD_HandleIterator it = m_device->m_pausedSounds.begin(); it != m_device->m_pausedSounds.end(); it++)
{
if(it->get() == this)
{
boost::shared_ptr<AUD_OpenALHandle> This = *it;
m_device->start();
m_status = AUD_STATUS_PLAYING;
return true;
m_device->m_pausedSounds.erase(it);
m_device->m_playingSounds.push_back(This);
m_device->start();
m_status = AUD_STATUS_PLAYING;
return true;
}
}
}
}
@@ -184,7 +201,7 @@ bool AUD_OpenALDevice::AUD_OpenALHandle::stop()
{
if(it->get() == this)
{
AUD_Reference<AUD_OpenALHandle> This = *it;
boost::shared_ptr<AUD_OpenALHandle> This = *it;
m_device->m_playingSounds.erase(it);
@@ -838,15 +855,15 @@ void AUD_OpenALDevice::start(bool join)
void AUD_OpenALDevice::updateStreams()
{
AUD_Reference<AUD_OpenALHandle> sound;
boost::shared_ptr<AUD_OpenALHandle> sound;
int length;
ALint info;
AUD_DeviceSpecs specs = m_specs;
ALCenum cerr;
std::list<AUD_Reference<AUD_OpenALHandle> > stopSounds;
std::list<AUD_Reference<AUD_OpenALHandle> > pauseSounds;
std::list<boost::shared_ptr<AUD_OpenALHandle> > stopSounds;
std::list<boost::shared_ptr<AUD_OpenALHandle> > pauseSounds;
AUD_HandleIterator it;
while(1)
@@ -1204,32 +1221,32 @@ bool AUD_OpenALDevice::getFormat(ALenum &format, AUD_Specs specs)
return valid;
}
AUD_Reference<AUD_IHandle> AUD_OpenALDevice::play(AUD_Reference<AUD_IReader> reader, bool keep)
boost::shared_ptr<AUD_IHandle> AUD_OpenALDevice::play(boost::shared_ptr<AUD_IReader> reader, bool keep)
{
AUD_Specs specs = reader->getSpecs();
// check format
if(specs.channels == AUD_CHANNELS_INVALID)
return AUD_Reference<AUD_IHandle>();
return boost::shared_ptr<AUD_IHandle>();
if(m_specs.format != AUD_FORMAT_FLOAT32)
reader = new AUD_ConverterReader(reader, m_specs);
reader = boost::shared_ptr<AUD_IReader>(new AUD_ConverterReader(reader, m_specs));
ALenum format;
if(!getFormat(format, specs))
return AUD_Reference<AUD_IHandle>();
return boost::shared_ptr<AUD_IHandle>();
AUD_MutexLock lock(*this);
alcSuspendContext(m_context);
AUD_Reference<AUD_OpenALDevice::AUD_OpenALHandle> sound;
boost::shared_ptr<AUD_OpenALDevice::AUD_OpenALHandle> sound;
try
{
// create the handle
sound = new AUD_OpenALDevice::AUD_OpenALHandle(this, format, reader, keep);
sound = boost::shared_ptr<AUD_OpenALDevice::AUD_OpenALHandle>(new AUD_OpenALDevice::AUD_OpenALHandle(this, format, reader, keep));
}
catch(AUD_Exception&)
{
@@ -1244,10 +1261,10 @@ AUD_Reference<AUD_IHandle> AUD_OpenALDevice::play(AUD_Reference<AUD_IReader> rea
start();
return AUD_Reference<AUD_IHandle>(sound);
return boost::shared_ptr<AUD_IHandle>(sound);
}
AUD_Reference<AUD_IHandle> AUD_OpenALDevice::play(AUD_Reference<AUD_IFactory> factory, bool keep)
boost::shared_ptr<AUD_IHandle> AUD_OpenALDevice::play(boost::shared_ptr<AUD_IFactory> factory, bool keep)
{
/* AUD_XXX disabled
AUD_OpenALHandle* sound = NULL;

14
intern/audaspace/OpenAL/AUD_OpenALDevice.h
View File

@@ -58,7 +58,7 @@ private:
bool m_isBuffered;
/// The reader source.
AUD_Reference<AUD_IReader> m_reader;
boost::shared_ptr<AUD_IReader> m_reader;
/// Whether to keep the source if end of it is reached.
bool m_keep;
@@ -105,7 +105,7 @@ private:
* \param reader The reader this handle plays.
* \param keep Whether to keep the handle alive when the reader ends.
*/
AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, AUD_Reference<AUD_IReader> reader, bool keep);
AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, boost::shared_ptr<AUD_IReader> reader, bool keep);
virtual ~AUD_OpenALHandle() {}
virtual bool pause();
@@ -150,7 +150,7 @@ private:
virtual bool setConeVolumeOuter(float volume);
};
typedef std::list<AUD_Reference<AUD_OpenALHandle> >::iterator AUD_HandleIterator;
typedef std::list<boost::shared_ptr<AUD_OpenALHandle> >::iterator AUD_HandleIterator;
/**
* The OpenAL device handle.
@@ -175,12 +175,12 @@ private:
/**
* The list of sounds that are currently playing.
*/
std::list<AUD_Reference<AUD_OpenALHandle> > m_playingSounds;
std::list<boost::shared_ptr<AUD_OpenALHandle> > m_playingSounds;
/**
* The list of sounds that are currently paused.
*/
std::list<AUD_Reference<AUD_OpenALHandle> > m_pausedSounds;
std::list<boost::shared_ptr<AUD_OpenALHandle> > m_pausedSounds;
/**
* The list of buffered factories.
@@ -255,8 +255,8 @@ public:
virtual ~AUD_OpenALDevice();
virtual AUD_DeviceSpecs getSpecs() const;
virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IReader> reader, bool keep = false);
virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IFactory> factory, bool keep = false);
virtual boost::shared_ptr<AUD_IHandle> play(boost::shared_ptr<AUD_IReader> reader, bool keep = false);
virtual boost::shared_ptr<AUD_IHandle> play(boost::shared_ptr<AUD_IFactory> factory, bool keep = false);
virtual void stopAll();
virtual void lock();
virtual void unlock();

170
intern/audaspace/Python/AUD_PyAPI.cpp
View File

@@ -90,7 +90,7 @@ static void
Factory_dealloc(Factory* self)
{
if(self->factory)
delete reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory);
delete reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory);
Py_XDECREF(self->child_list);
Py_TYPE(self)->tp_free((PyObject *)self);
}
@@ -114,7 +114,7 @@ Factory_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
try
{
self->factory = new AUD_Reference<AUD_IFactory>(new AUD_FileFactory(filename));
self->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_FileFactory(filename));
}
catch(AUD_Exception& e)
{
@@ -154,7 +154,7 @@ Factory_sine(PyTypeObject* type, PyObject *args)
{
try
{
self->factory = new AUD_Reference<AUD_IFactory>(new AUD_SinusFactory(frequency, (AUD_SampleRate)rate));
self->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_SinusFactory(frequency, (AUD_SampleRate)rate));
}
catch(AUD_Exception& e)
{
@@ -193,7 +193,7 @@ Factory_file(PyTypeObject* type, PyObject *args)
{
try
{
self->factory = new AUD_Reference<AUD_IFactory>(new AUD_FileFactory(filename));
self->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_FileFactory(filename));
}
catch(AUD_Exception& e)
{
@@ -236,7 +236,7 @@ Factory_lowpass(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_LowpassFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), frequency, Q));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_LowpassFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), frequency, Q));
}
catch(AUD_Exception& e)
{
@@ -277,7 +277,7 @@ Factory_delay(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_DelayFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), delay));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_DelayFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), delay));
}
catch(AUD_Exception& e)
{
@@ -321,7 +321,7 @@ Factory_join(Factory* self, PyObject *object)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_DoubleFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), *reinterpret_cast<AUD_Reference<AUD_IFactory>*>(child->factory)));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_DoubleFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), *reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(child->factory)));
}
catch(AUD_Exception& e)
{
@@ -364,7 +364,7 @@ Factory_highpass(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_HighpassFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), frequency, Q));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_HighpassFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), frequency, Q));
}
catch(AUD_Exception& e)
{
@@ -405,7 +405,7 @@ Factory_limit(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_LimiterFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), start, end));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_LimiterFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), start, end));
}
catch(AUD_Exception& e)
{
@@ -449,7 +449,7 @@ Factory_pitch(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_PitchFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), factor));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_PitchFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), factor));
}
catch(AUD_Exception& e)
{
@@ -491,7 +491,7 @@ Factory_volume(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_VolumeFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), volume));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_VolumeFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), volume));
}
catch(AUD_Exception& e)
{
@@ -534,7 +534,7 @@ Factory_fadein(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_FaderFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), AUD_FADE_IN, start, length));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_FaderFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), AUD_FADE_IN, start, length));
}
catch(AUD_Exception& e)
{
@@ -578,7 +578,7 @@ Factory_fadeout(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_FaderFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), AUD_FADE_OUT, start, length));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_FaderFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), AUD_FADE_OUT, start, length));
}
catch(AUD_Exception& e)
{
@@ -620,7 +620,7 @@ Factory_loop(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_LoopFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), loop));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_LoopFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), loop));
}
catch(AUD_Exception& e)
{
@@ -663,7 +663,7 @@ Factory_mix(Factory* self, PyObject *object)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_SuperposeFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), *reinterpret_cast<AUD_Reference<AUD_IFactory>*>(child->factory)));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_SuperposeFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), *reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(child->factory)));
}
catch(AUD_Exception& e)
{
@@ -696,7 +696,7 @@ Factory_pingpong(Factory* self)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_PingPongFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory)));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_PingPongFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory)));
}
catch(AUD_Exception& e)
{
@@ -735,7 +735,7 @@ Factory_reverse(Factory* self)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_ReverseFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory)));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_ReverseFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory)));
}
catch(AUD_Exception& e)
{
@@ -770,7 +770,7 @@ Factory_buffer(Factory* self)
{
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_StreamBufferFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory)));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_StreamBufferFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory)));
}
catch(AUD_Exception& e)
{
@@ -812,7 +812,7 @@ Factory_square(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_SquareFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), threshold));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_SquareFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), threshold));
}
catch(AUD_Exception& e)
{
@@ -915,7 +915,7 @@ Factory_filter(Factory* self, PyObject *args)
try
{
parent->factory = new AUD_Reference<AUD_IFactory>(new AUD_IIRFilterFactory(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(self->factory), b, a));
parent->factory = new boost::shared_ptr<AUD_IFactory>(new AUD_IIRFilterFactory(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(self->factory), b, a));
}
catch(AUD_Exception& e)
{
@@ -1039,7 +1039,7 @@ static void
Handle_dealloc(Handle* self)
{
if(self->handle)
delete reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle);
delete reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle);
Py_TYPE(self)->tp_free((PyObject *)self);
}
@@ -1054,7 +1054,7 @@ Handle_pause(Handle *self)
{
try
{
return PyBool_FromLong((long)(*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->pause());
return PyBool_FromLong((long)(*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->pause());
}
catch(AUD_Exception& e)
{
@@ -1074,7 +1074,7 @@ Handle_resume(Handle *self)
{
try
{
return PyBool_FromLong((long)(*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->resume());
return PyBool_FromLong((long)(*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->resume());
}
catch(AUD_Exception& e)
{
@@ -1095,7 +1095,7 @@ Handle_stop(Handle *self)
{
try
{
return PyBool_FromLong((long)(*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->stop());
return PyBool_FromLong((long)(*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->stop());
}
catch(AUD_Exception& e)
{
@@ -1125,7 +1125,7 @@ Handle_get_position(Handle *self, void* nothing)
{
try
{
return Py_BuildValue("f", (*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getPosition());
return Py_BuildValue("f", (*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getPosition());
}
catch(AUD_Exception& e)
{
@@ -1144,7 +1144,7 @@ Handle_set_position(Handle *self, PyObject *args, void* nothing)
try
{
if((*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->seek(position))
if((*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->seek(position))
return 0;
PyErr_SetString(AUDError, "Couldn't seek the sound!");
}
@@ -1170,7 +1170,7 @@ Handle_get_keep(Handle *self, void* nothing)
{
try
{
return PyBool_FromLong((long)(*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getKeep());
return PyBool_FromLong((long)(*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getKeep());
}
catch(AUD_Exception& e)
{
@@ -1192,7 +1192,7 @@ Handle_set_keep(Handle *self, PyObject *args, void* nothing)
try
{
if((*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->setKeep(keep))
if((*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->setKeep(keep))
return 0;
PyErr_SetString(AUDError, "Couldn't set keep of the sound!");
}
@@ -1212,7 +1212,7 @@ Handle_get_status(Handle *self, void* nothing)
{
try
{
return PyBool_FromLong((long)(*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getStatus());
return PyBool_FromLong((long)(*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getStatus());
}
catch(AUD_Exception& e)
{
@@ -1229,7 +1229,7 @@ Handle_get_volume(Handle *self, void* nothing)
{
try
{
return Py_BuildValue("f", (*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getVolume());
return Py_BuildValue("f", (*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getVolume());
}
catch(AUD_Exception& e)
{
@@ -1248,7 +1248,7 @@ Handle_set_volume(Handle *self, PyObject *args, void* nothing)
try
{
if((*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->setVolume(volume))
if((*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->setVolume(volume))
return 0;
PyErr_SetString(AUDError, "Couldn't set the sound volume!");
}
@@ -1268,7 +1268,7 @@ Handle_get_pitch(Handle *self, void* nothing)
{
try
{
return Py_BuildValue("f", (*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getPitch());
return Py_BuildValue("f", (*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getPitch());
}
catch(AUD_Exception& e)
{
@@ -1287,7 +1287,7 @@ Handle_set_pitch(Handle *self, PyObject *args, void* nothing)
try
{
if((*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->setPitch(pitch))
if((*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->setPitch(pitch))
return 0;
PyErr_SetString(AUDError, "Couldn't set the sound pitch!");
}
@@ -1307,7 +1307,7 @@ Handle_get_loop_count(Handle *self, void* nothing)
{
try
{
return Py_BuildValue("i", (*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->getLoopCount());
return Py_BuildValue("i", (*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->getLoopCount());
}
catch(AUD_Exception& e)
{
@@ -1326,7 +1326,7 @@ Handle_set_loop_count(Handle *self, PyObject *args, void* nothing)
try
{
if((*reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle))->setLoopCount(loops))
if((*reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle))->setLoopCount(loops))
return 0;
PyErr_SetString(AUDError, "Couldn't set the loop count!");
}
@@ -1346,7 +1346,7 @@ Handle_get_location(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Vector3 v = handle->getSourceLocation();
@@ -1375,7 +1375,7 @@ Handle_set_location(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Vector3 location(x, y, z);
@@ -1402,7 +1402,7 @@ Handle_get_velocity(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Vector3 v = handle->getSourceVelocity();
@@ -1431,7 +1431,7 @@ Handle_set_velocity(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Vector3 velocity(x, y, z);
@@ -1458,7 +1458,7 @@ Handle_get_orientation(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Quaternion o = handle->getSourceOrientation();
@@ -1487,7 +1487,7 @@ Handle_set_orientation(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
AUD_Quaternion orientation(w, x, y, z);
@@ -1514,7 +1514,7 @@ Handle_get_relative(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return PyBool_FromLong((long)handle->isRelative());
@@ -1545,7 +1545,7 @@ Handle_set_relative(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setRelative(relative))
@@ -1572,7 +1572,7 @@ Handle_get_volume_minimum(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getVolumeMinimum());
@@ -1600,7 +1600,7 @@ Handle_set_volume_minimum(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setVolumeMinimum(volume))
@@ -1627,7 +1627,7 @@ Handle_get_volume_maximum(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getVolumeMaximum());
@@ -1655,7 +1655,7 @@ Handle_set_volume_maximum(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setVolumeMaximum(volume))
@@ -1683,7 +1683,7 @@ Handle_get_distance_reference(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getDistanceReference());
@@ -1711,7 +1711,7 @@ Handle_set_distance_reference(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setDistanceReference(distance))
@@ -1739,7 +1739,7 @@ Handle_get_distance_maximum(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getDistanceMaximum());
@@ -1767,7 +1767,7 @@ Handle_set_distance_maximum(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setDistanceMaximum(distance))
@@ -1795,7 +1795,7 @@ Handle_get_attenuation(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getAttenuation());
@@ -1823,7 +1823,7 @@ Handle_set_attenuation(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setAttenuation(factor))
@@ -1856,7 +1856,7 @@ Handle_get_cone_angle_inner(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getConeAngleInner());
@@ -1884,7 +1884,7 @@ Handle_set_cone_angle_inner(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setConeAngleInner(angle))
@@ -1911,7 +1911,7 @@ Handle_get_cone_angle_outer(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getConeAngleOuter());
@@ -1939,7 +1939,7 @@ Handle_set_cone_angle_outer(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setConeAngleOuter(angle))
@@ -1966,7 +1966,7 @@ Handle_get_cone_volume_outer(Handle *self, void* nothing)
{
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
return Py_BuildValue("f", handle->getConeVolumeOuter());
@@ -1994,7 +1994,7 @@ Handle_set_cone_volume_outer(Handle *self, PyObject *args, void* nothing)
try
{
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<AUD_Reference<AUD_IHandle>*>(self->handle)->get());
AUD_I3DHandle* handle = dynamic_cast<AUD_I3DHandle*>(reinterpret_cast<boost::shared_ptr<AUD_IHandle>*>(self->handle)->get());
if(handle)
{
if(handle->setConeVolumeOuter(volume))
@@ -2104,7 +2104,7 @@ static void
Device_dealloc(Device* self)
{
if(self->device)
delete reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device);
delete reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device);
Py_TYPE(self)->tp_free((PyObject *)self);
}
@@ -2147,21 +2147,21 @@ Device_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
case AUD_DEVICE_NULL:
(void)specs; /* quiet warning when others disabled */
self->device = new AUD_Reference<AUD_IDevice>(new AUD_NULLDevice());
self->device = new boost::shared_ptr<AUD_IDevice>(new AUD_NULLDevice());
break;
case AUD_DEVICE_OPENAL:
#ifdef WITH_OPENAL
self->device = new AUD_Reference<AUD_IDevice>(new AUD_OpenALDevice(specs, buffersize));
self->device = new boost::shared_ptr<AUD_IDevice>(new AUD_OpenALDevice(specs, buffersize));
#endif
break;
case AUD_DEVICE_SDL:
#ifdef WITH_SDL
self->device = new AUD_Reference<AUD_IDevice>(new AUD_SDLDevice(specs, buffersize));
self->device = new boost::shared_ptr<AUD_IDevice>(new AUD_SDLDevice(specs, buffersize));
#endif
break;
case AUD_DEVICE_JACK:
#ifdef WITH_JACK
self->device = new AUD_Reference<AUD_IDevice>(new AUD_JackDevice(name, specs, buffersize));
self->device = new boost::shared_ptr<AUD_IDevice>(new AUD_JackDevice(name, specs, buffersize));
#endif
break;
case AUD_DEVICE_READ:
@@ -2236,7 +2236,7 @@ Device_play(Device *self, PyObject *args, PyObject *kwds)
{
try
{
handle->handle = new AUD_Reference<AUD_IHandle>((*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->play(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(sound->factory), keep));
handle->handle = new boost::shared_ptr<AUD_IHandle>((*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->play(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(sound->factory), keep));
}
catch(AUD_Exception& e)
{
@@ -2258,7 +2258,7 @@ Device_stopAll(Device *self)
{
try
{
(*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->stopAll();
(*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->stopAll();
Py_RETURN_NONE;
}
catch(AUD_Exception& e)
@@ -2284,7 +2284,7 @@ Device_lock(Device *self)
{
try
{
(*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->lock();
(*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->lock();
Py_RETURN_NONE;
}
catch(AUD_Exception& e)
@@ -2304,7 +2304,7 @@ Device_unlock(Device *self)
{
try
{
(*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->unlock();
(*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->unlock();
Py_RETURN_NONE;
}
catch(AUD_Exception& e)
@@ -2338,7 +2338,7 @@ Device_get_rate(Device *self, void* nothing)
{
try
{
AUD_DeviceSpecs specs = (*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->getSpecs();
AUD_DeviceSpecs specs = (*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("d", specs.rate);
}
catch(AUD_Exception& e)
@@ -2356,7 +2356,7 @@ Device_get_format(Device *self, void* nothing)
{
try
{
AUD_DeviceSpecs specs = (*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->getSpecs();
AUD_DeviceSpecs specs = (*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("i", specs.format);
}
catch(AUD_Exception& e)
@@ -2374,7 +2374,7 @@ Device_get_channels(Device *self, void* nothing)
{
try
{
AUD_DeviceSpecs specs = (*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->getSpecs();
AUD_DeviceSpecs specs = (*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("i", specs.channels);
}
catch(AUD_Exception& e)
@@ -2392,7 +2392,7 @@ Device_get_volume(Device *self, void* nothing)
{
try
{
return Py_BuildValue("f", (*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->getVolume());
return Py_BuildValue("f", (*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->getVolume());
}
catch(AUD_Exception& e)
{
@@ -2411,7 +2411,7 @@ Device_set_volume(Device *self, PyObject *args, void* nothing)
try
{
(*reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device))->setVolume(volume);
(*reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device))->setVolume(volume);
return 0;
}
catch(AUD_Exception& e)
@@ -2429,7 +2429,7 @@ Device_get_listener_location(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Vector3 v = device->getListenerLocation();
@@ -2458,7 +2458,7 @@ Device_set_listener_location(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Vector3 location(x, y, z);
@@ -2484,7 +2484,7 @@ Device_get_listener_velocity(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Vector3 v = device->getListenerVelocity();
@@ -2513,7 +2513,7 @@ Device_set_listener_velocity(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Vector3 velocity(x, y, z);
@@ -2539,7 +2539,7 @@ Device_get_listener_orientation(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Quaternion o = device->getListenerOrientation();
@@ -2568,7 +2568,7 @@ Device_set_listener_orientation(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
AUD_Quaternion orientation(w, x, y, z);
@@ -2595,7 +2595,7 @@ Device_get_speed_of_sound(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("f", device->getSpeedOfSound());
@@ -2623,7 +2623,7 @@ Device_set_speed_of_sound(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
device->setSpeedOfSound(speed);
@@ -2651,7 +2651,7 @@ Device_get_doppler_factor(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("f", device->getDopplerFactor());
@@ -2679,7 +2679,7 @@ Device_set_doppler_factor(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
device->setDopplerFactor(factor);
@@ -2705,7 +2705,7 @@ Device_get_distance_model(Device *self, void* nothing)
{
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("i", int(device->getDistanceModel()));
@@ -2733,7 +2733,7 @@ Device_set_distance_model(Device *self, PyObject *args, void* nothing)
try
{
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<AUD_Reference<AUD_IDevice>*>(self->device)->get());
AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(reinterpret_cast<boost::shared_ptr<AUD_IDevice>*>(self->device)->get());
if(device)
{
device->setDistanceModel(AUD_DistanceModel(model));

2
intern/audaspace/SConscript
View File

@@ -3,7 +3,7 @@
Import ('env')
sources = env.Glob('intern/*.cpp') + env.Glob('FX/*.cpp')
incs = '. intern FX ' + env['BF_PTHREADS_INC']
incs = '. intern FX ' + env['BF_PTHREADS_INC'] + ' ' + env['BF_BOOST_INC']
defs = []
if env['WITH_BF_FFMPEG']:

8
intern/audaspace/ffmpeg/AUD_FFMPEGFactory.cpp
View File

@@ -46,10 +46,10 @@ AUD_FFMPEGFactory::AUD_FFMPEGFactory(const data_t* buffer, int size) :
memcpy(m_buffer->getBuffer(), buffer, size);
}
AUD_Reference<AUD_IReader> AUD_FFMPEGFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_FFMPEGFactory::createReader()
{
if(m_buffer.isNull())
return new AUD_FFMPEGReader(m_filename);
if(m_buffer.get())
return boost::shared_ptr<AUD_IReader>(new AUD_FFMPEGReader(m_buffer));
else
return new AUD_FFMPEGReader(m_buffer);
return boost::shared_ptr<AUD_IReader>(new AUD_FFMPEGReader(m_filename));
}

6
intern/audaspace/ffmpeg/AUD_FFMPEGFactory.h
View File

@@ -31,10 +31,10 @@
#define __AUD_FFMPEGFACTORY_H__
#include "AUD_IFactory.h"
#include "AUD_Reference.h"
#include "AUD_Buffer.h"
#include <string>
#include <boost/shared_ptr.hpp>
/**
* This factory reads a sound file via ffmpeg.
@@ -52,7 +52,7 @@ private:
/**
* The buffer to read from.
*/
AUD_Reference<AUD_Buffer> m_buffer;
boost::shared_ptr<AUD_Buffer> m_buffer;
// hide copy constructor and operator=
AUD_FFMPEGFactory(const AUD_FFMPEGFactory&);
@@ -72,7 +72,7 @@ public:
*/
AUD_FFMPEGFactory(const data_t* buffer, int size);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_FFMPEGFACTORY_H__

2
intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp
View File

@@ -197,7 +197,7 @@ AUD_FFMPEGReader::AUD_FFMPEGReader(std::string filename) :
static const char* streamopen_error = "AUD_FFMPEGReader: Stream couldn't be "
"opened.";
AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer) :
AUD_FFMPEGReader::AUD_FFMPEGReader(boost::shared_ptr<AUD_Buffer> buffer) :
m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
m_membuffer(buffer),
m_membufferpos(0)

6
intern/audaspace/ffmpeg/AUD_FFMPEGReader.h
View File

@@ -32,10 +32,10 @@
#include "AUD_ConverterFunctions.h"
#include "AUD_IReader.h"
#include "AUD_Reference.h"
#include "AUD_Buffer.h"
#include <string>
#include <boost/shared_ptr.hpp>
struct AVCodecContext;
extern "C" {
@@ -99,7 +99,7 @@ private:
/**
* The memory file to read from.
*/
AUD_Reference<AUD_Buffer> m_membuffer;
boost::shared_ptr<AUD_Buffer> m_membuffer;
/**
* The buffer to read with.
@@ -143,7 +143,7 @@ public:
* \exception AUD_Exception Thrown if the buffer specified cannot be read
* with ffmpeg.
*/
AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer);
AUD_FFMPEGReader(boost::shared_ptr<AUD_Buffer> buffer);
/**
* Destroys the reader and closes the file.

2
intern/audaspace/intern/AUD_BufferReader.cpp
View File

@@ -33,7 +33,7 @@
#include <cstring>
AUD_BufferReader::AUD_BufferReader(AUD_Reference<AUD_Buffer> buffer,
AUD_BufferReader::AUD_BufferReader(boost::shared_ptr<AUD_Buffer> buffer,
AUD_Specs specs) :
m_position(0), m_buffer(buffer), m_specs(specs)
{

7
intern/audaspace/intern/AUD_BufferReader.h
View File

@@ -31,9 +31,10 @@
#define __AUD_BUFFERREADER_H__
#include "AUD_IReader.h"
#include "AUD_Reference.h"
class AUD_Buffer;
#include <boost/shared_ptr.hpp>
/**
* This class represents a simple reader from a buffer that exists in memory.
* \warning Notice that the buffer used for creating the reader must exist as
@@ -50,7 +51,7 @@ private:
/**
* The buffer that is read.
*/
AUD_Reference<AUD_Buffer> m_buffer;
boost::shared_ptr<AUD_Buffer> m_buffer;
/**
* The specification of the sample data in the buffer.
@@ -67,7 +68,7 @@ public:
* \param buffer The buffer to read from.
* \param specs The specification of the sample data in the buffer.
*/
AUD_BufferReader(AUD_Reference<AUD_Buffer> buffer, AUD_Specs specs);
AUD_BufferReader(boost::shared_ptr<AUD_Buffer> buffer, AUD_Specs specs);
virtual bool isSeekable() const;
virtual void seek(int position);

140
intern/audaspace/intern/AUD_C-API.cpp
View File

@@ -91,10 +91,10 @@ extern "C" {
#include <cassert>
typedef AUD_Reference<AUD_IFactory> AUD_Sound;
typedef AUD_Reference<AUD_ReadDevice> AUD_Device;
typedef AUD_Reference<AUD_IHandle> AUD_Handle;
typedef AUD_Reference<AUD_SequencerEntry> AUD_SEntry;
typedef boost::shared_ptr<AUD_IFactory> AUD_Sound;
typedef boost::shared_ptr<AUD_ReadDevice> AUD_Device;
typedef boost::shared_ptr<AUD_IHandle> AUD_Handle;
typedef boost::shared_ptr<AUD_SequencerEntry> AUD_SEntry;
#define AUD_CAPI_IMPLEMENTATION
#include "AUD_C-API.h"
@@ -103,7 +103,7 @@ typedef AUD_Reference<AUD_SequencerEntry> AUD_SEntry;
# define NULL (void *)0
#endif
static AUD_Reference<AUD_IDevice> AUD_device;
static boost::shared_ptr<AUD_IDevice> AUD_device;
static AUD_I3DDevice *AUD_3ddevice;
void AUD_initOnce()
@@ -115,25 +115,25 @@ void AUD_initOnce()
int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
{
AUD_Reference<AUD_IDevice> dev;
boost::shared_ptr<AUD_IDevice> dev;
if (!AUD_device.isNull()) {
if (AUD_device.get()) {
AUD_exit();
}
try {
switch(device) {
case AUD_NULL_DEVICE:
dev = new AUD_NULLDevice();
dev = boost::shared_ptr<AUD_IDevice>(new AUD_NULLDevice());
break;
#ifdef WITH_SDL
case AUD_SDL_DEVICE:
dev = new AUD_SDLDevice(specs, buffersize);
dev = boost::shared_ptr<AUD_IDevice>(new AUD_SDLDevice(specs, buffersize));
break;
#endif
#ifdef WITH_OPENAL
case AUD_OPENAL_DEVICE:
dev = new AUD_OpenALDevice(specs, buffersize);
dev = boost::shared_ptr<AUD_IDevice>(new AUD_OpenALDevice(specs, buffersize));
break;
#endif
#ifdef WITH_JACK
@@ -147,7 +147,7 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
else
{
#endif
dev = new AUD_JackDevice("Blender", specs, buffersize);
dev = boost::shared_ptr<AUD_IDevice>(new AUD_JackDevice("Blender", specs, buffersize));
break;
#ifdef __APPLE__
}
@@ -170,17 +170,17 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
void AUD_exit()
{
AUD_device = AUD_Reference<AUD_IDevice>();
AUD_device = boost::shared_ptr<AUD_IDevice>();
AUD_3ddevice = NULL;
}
#ifdef WITH_PYTHON
static PyObject *AUD_getCDevice(PyObject *self)
{
if (!AUD_device.isNull()) {
if (AUD_device.get()) {
Device *device = (Device *)Device_empty();
if (device != NULL) {
device->device = new AUD_Reference<AUD_IDevice>(AUD_device);
device->device = new boost::shared_ptr<AUD_IDevice>(AUD_device);
return (PyObject *)device;
}
}
@@ -206,12 +206,12 @@ static PyObject *AUD_getSoundFromPointer(PyObject *self, PyObject *args)
if (PyArg_Parse(args, "l:_sound_from_pointer", &lptr)) {
if (lptr) {
AUD_Reference<AUD_IFactory>* factory = (AUD_Reference<AUD_IFactory>*) sound_get_factory((void *) lptr);
boost::shared_ptr<AUD_IFactory>* factory = (boost::shared_ptr<AUD_IFactory>*) sound_get_factory((void *) lptr);
if (factory) {
Factory *obj = (Factory *)Factory_empty();
if (obj) {
obj->factory = new AUD_Reference<AUD_IFactory>(*factory);
obj->factory = new boost::shared_ptr<AUD_IFactory>(*factory);
return (PyObject *) obj;
}
}
@@ -246,7 +246,7 @@ void *AUD_getPythonFactory(AUD_Sound *sound)
if (sound) {
Factory *obj = (Factory *) Factory_empty();
if (obj) {
obj->factory = new AUD_Reference<AUD_IFactory>(*sound);
obj->factory = new boost::shared_ptr<AUD_IFactory>(*sound);
return (PyObject *) obj;
}
}
@@ -261,7 +261,7 @@ AUD_Sound *AUD_getPythonSound(void *sound)
if (!factory)
return NULL;
return new AUD_Reference<AUD_IFactory>(*reinterpret_cast<AUD_Reference<AUD_IFactory>*>(factory->factory));
return new boost::shared_ptr<AUD_IFactory>(*reinterpret_cast<boost::shared_ptr<AUD_IFactory>*>(factory->factory));
}
#endif
@@ -286,9 +286,9 @@ AUD_SoundInfo AUD_getInfo(AUD_Sound *sound)
info.length = 0.0f;
try {
AUD_Reference<AUD_IReader> reader = (*sound)->createReader();
boost::shared_ptr<AUD_IReader> reader = (*sound)->createReader();
if (!reader.isNull()) {
if (reader.get()) {
info.specs = reader->getSpecs();
info.length = reader->getLength() / (float) info.specs.rate;
}
@@ -432,7 +432,7 @@ AUD_Handle *AUD_play(AUD_Sound *sound, int keep)
assert(sound);
try {
AUD_Handle handle = AUD_device->play(*sound, keep);
if (!handle.isNull()) {
if (handle.get()) {
return new AUD_Handle(handle);
}
}
@@ -552,9 +552,9 @@ int AUD_setDistanceModel(AUD_DistanceModel model)
int AUD_setSourceLocation(AUD_Handle *handle, const float location[3])
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
AUD_Vector3 v(location[0], location[1], location[2]);
return h->setSourceLocation(v);
}
@@ -565,9 +565,9 @@ int AUD_setSourceLocation(AUD_Handle *handle, const float location[3])
int AUD_setSourceVelocity(AUD_Handle *handle, const float velocity[3])
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
AUD_Vector3 v(velocity[0], velocity[1], velocity[2]);
return h->setSourceVelocity(v);
}
@@ -578,9 +578,9 @@ int AUD_setSourceVelocity(AUD_Handle *handle, const float velocity[3])
int AUD_setSourceOrientation(AUD_Handle *handle, const float orientation[4])
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
AUD_Quaternion q(orientation[3], orientation[0], orientation[1], orientation[2]);
return h->setSourceOrientation(q);
}
@@ -591,9 +591,9 @@ int AUD_setSourceOrientation(AUD_Handle *handle, const float orientation[4])
int AUD_setRelative(AUD_Handle *handle, int relative)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setRelative(relative);
}
@@ -603,9 +603,9 @@ int AUD_setRelative(AUD_Handle *handle, int relative)
int AUD_setVolumeMaximum(AUD_Handle *handle, float volume)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setVolumeMaximum(volume);
}
@@ -615,9 +615,9 @@ int AUD_setVolumeMaximum(AUD_Handle *handle, float volume)
int AUD_setVolumeMinimum(AUD_Handle *handle, float volume)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setVolumeMinimum(volume);
}
@@ -627,9 +627,9 @@ int AUD_setVolumeMinimum(AUD_Handle *handle, float volume)
int AUD_setDistanceMaximum(AUD_Handle *handle, float distance)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setDistanceMaximum(distance);
}
@@ -639,9 +639,9 @@ int AUD_setDistanceMaximum(AUD_Handle *handle, float distance)
int AUD_setDistanceReference(AUD_Handle *handle, float distance)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setDistanceReference(distance);
}
@@ -651,9 +651,9 @@ int AUD_setDistanceReference(AUD_Handle *handle, float distance)
int AUD_setAttenuation(AUD_Handle *handle, float factor)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setAttenuation(factor);
}
@@ -663,9 +663,9 @@ int AUD_setAttenuation(AUD_Handle *handle, float factor)
int AUD_setConeAngleOuter(AUD_Handle *handle, float angle)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setConeAngleOuter(angle);
}
@@ -675,9 +675,9 @@ int AUD_setConeAngleOuter(AUD_Handle *handle, float angle)
int AUD_setConeAngleInner(AUD_Handle *handle, float angle)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setConeAngleInner(angle);
}
@@ -687,9 +687,9 @@ int AUD_setConeAngleInner(AUD_Handle *handle, float angle)
int AUD_setConeVolumeOuter(AUD_Handle *handle, float volume)
{
assert(handle);
AUD_Reference<AUD_I3DHandle> h(*handle);
boost::shared_ptr<AUD_I3DHandle> h = boost::dynamic_pointer_cast<AUD_I3DHandle>(*handle);
if (!h.isNull()) {
if (h.get()) {
return h->setConeVolumeOuter(volume);
}
@@ -734,7 +734,7 @@ AUD_Handle *AUD_playDevice(AUD_Device *device, AUD_Sound *sound, float seek)
try {
AUD_Handle handle = (*device)->play(*sound);
if (!handle.isNull()) {
if (handle.get()) {
handle->seek(seek);
return new AUD_Handle(handle);
}
@@ -793,38 +793,38 @@ float *AUD_readSoundBuffer(const char *filename, float low, float high,
AUD_DeviceSpecs specs;
specs.channels = AUD_CHANNELS_MONO;
specs.rate = (AUD_SampleRate)samplerate;
AUD_Reference<AUD_IFactory> sound;
boost::shared_ptr<AUD_IFactory> sound;
AUD_Reference<AUD_IFactory> file = new AUD_FileFactory(filename);
boost::shared_ptr<AUD_IFactory> file = boost::shared_ptr<AUD_IFactory>(new AUD_FileFactory(filename));
int position = 0;
try {
AUD_Reference<AUD_IReader> reader = file->createReader();
boost::shared_ptr<AUD_IReader> reader = file->createReader();
AUD_SampleRate rate = reader->getSpecs().rate;
sound = new AUD_ChannelMapperFactory(file, specs);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_ChannelMapperFactory(file, specs));
if (high < rate)
sound = new AUD_LowpassFactory(sound, high);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_LowpassFactory(sound, high));
if (low > 0)
sound = new AUD_HighpassFactory(sound, low);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_HighpassFactory(sound, low));
sound = new AUD_EnvelopeFactory(sound, attack, release, threshold, 0.1f);
sound = new AUD_LinearResampleFactory(sound, specs);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_EnvelopeFactory(sound, attack, release, threshold, 0.1f));
sound = boost::shared_ptr<AUD_IFactory>(new AUD_LinearResampleFactory(sound, specs));
if (square)
sound = new AUD_SquareFactory(sound, sthreshold);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_SquareFactory(sound, sthreshold));
if (accumulate)
sound = new AUD_AccumulatorFactory(sound, additive);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_AccumulatorFactory(sound, additive));
else if (additive)
sound = new AUD_SumFactory(sound);
sound = boost::shared_ptr<AUD_IFactory>(new AUD_SumFactory(sound));
reader = sound->createReader();
if (reader.isNull())
if (!reader.get())
return NULL;
int len;
@@ -856,14 +856,14 @@ static void pauseSound(AUD_Handle *handle)
AUD_Handle *AUD_pauseAfter(AUD_Handle *handle, float seconds)
{
AUD_Reference<AUD_IFactory> silence = new AUD_SilenceFactory;
AUD_Reference<AUD_IFactory> limiter = new AUD_LimiterFactory(silence, 0, seconds);
boost::shared_ptr<AUD_IFactory> silence = boost::shared_ptr<AUD_IFactory>(new AUD_SilenceFactory);
boost::shared_ptr<AUD_IFactory> limiter = boost::shared_ptr<AUD_IFactory>(new AUD_LimiterFactory(silence, 0, seconds));
AUD_MutexLock lock(*AUD_device);
try {
AUD_Handle handle2 = AUD_device->play(limiter);
if (!handle2.isNull()) {
if (handle2.get()) {
handle2->setStopCallback((stopCallback)pauseSound, handle);
return new AUD_Handle(handle2);
}
@@ -881,7 +881,7 @@ AUD_Sound *AUD_createSequencer(float fps, int muted)
AUD_Specs specs;
specs.channels = AUD_CHANNELS_STEREO;
specs.rate = AUD_RATE_44100;
AUD_Sound *sequencer = new AUD_Sound(AUD_Reference<AUD_SequencerFactory>(new AUD_SequencerFactory(specs, fps, muted)));
AUD_Sound *sequencer = new AUD_Sound(boost::shared_ptr<AUD_SequencerFactory>(new AUD_SequencerFactory(specs, fps, muted)));
return sequencer;
}
@@ -1070,7 +1070,7 @@ int AUD_readSound(AUD_Sound *sound, sample_t *buffer, int length, int samples_pe
specs.channels = AUD_CHANNELS_MONO;
specs.format = AUD_FORMAT_INVALID;
AUD_Reference<AUD_IReader> reader = AUD_ChannelMapperFactory(*sound, specs).createReader();
boost::shared_ptr<AUD_IReader> reader = AUD_ChannelMapperFactory(*sound, specs).createReader();
specs.specs = reader->getSpecs();
int len;
@@ -1124,7 +1124,7 @@ int AUD_readSound(AUD_Sound *sound, sample_t *buffer, int length, int samples_pe
AUD_Sound *AUD_copy(AUD_Sound *sound)
{
return new AUD_Reference<AUD_IFactory>(*sound);
return new boost::shared_ptr<AUD_IFactory>(*sound);
}
void AUD_freeHandle(AUD_Handle *handle)
@@ -1176,9 +1176,9 @@ const char *AUD_mixdown(AUD_Sound *sound, unsigned int start, unsigned int lengt
AUD_SequencerFactory *f = dynamic_cast<AUD_SequencerFactory *>(sound->get());
f->setSpecs(specs.specs);
AUD_Reference<AUD_IReader> reader = f->createQualityReader();
boost::shared_ptr<AUD_IReader> reader = f->createQualityReader();
reader->seek(start);
AUD_Reference<AUD_IWriter> writer = AUD_FileWriter::createWriter(filename, specs, format, codec, bitrate);
boost::shared_ptr<AUD_IWriter> writer = AUD_FileWriter::createWriter(filename, specs, format, codec, bitrate);
AUD_FileWriter::writeReader(reader, writer, length, buffersize);
return NULL;
@@ -1196,7 +1196,7 @@ const char *AUD_mixdown_per_channel(AUD_Sound *sound, unsigned int start, unsign
f->setSpecs(specs.specs);
std::vector<AUD_Reference<AUD_IWriter> > writers;
std::vector<boost::shared_ptr<AUD_IWriter> > writers;
int channels = specs.channels;
specs.channels = AUD_CHANNELS_MONO;
@@ -1220,7 +1220,7 @@ const char *AUD_mixdown_per_channel(AUD_Sound *sound, unsigned int start, unsign
writers.push_back(AUD_FileWriter::createWriter(stream.str(), specs, format, codec, bitrate));
}
AUD_Reference<AUD_IReader> reader = f->createQualityReader();
boost::shared_ptr<AUD_IReader> reader = f->createQualityReader();
reader->seek(start);
AUD_FileWriter::writeReader(reader, writers, length, buffersize);
@@ -1242,7 +1242,7 @@ AUD_Device *AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound *sequencer, f
dynamic_cast<AUD_SequencerFactory *>(sequencer->get())->setSpecs(specs.specs);
AUD_Handle handle = device->play(*sequencer);
if (!handle.isNull()) {
if (handle.get()) {
handle->seek(start);
}
@@ -1254,7 +1254,7 @@ AUD_Device *AUD_openMixdownDevice(AUD_DeviceSpecs specs, AUD_Sound *sequencer, f
}
}
AUD_Reference<AUD_IDevice> AUD_getDevice()
boost::shared_ptr<AUD_IDevice> AUD_getDevice()
{
return AUD_device;
}

4
intern/audaspace/intern/AUD_C-API.h
View File

@@ -755,7 +755,7 @@ extern AUD_Sound *AUD_getPythonSound(void *sound);
#ifdef __cplusplus
}
#include "AUD_Reference.h"
#include <boost/shared_ptr.hpp>
class AUD_IDevice;
class AUD_I3DDevice;
@@ -763,7 +763,7 @@ class AUD_I3DDevice;
* Returns the current playback device.
* \return The playback device.
*/
AUD_Reference<AUD_IDevice> AUD_getDevice();
boost::shared_ptr<AUD_IDevice> AUD_getDevice();
/**
* Returns the current playback 3D device.

8
intern/audaspace/intern/AUD_ChannelMapperFactory.cpp
View File

@@ -32,14 +32,14 @@
#include <cstring>
AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(AUD_Reference<AUD_IFactory> factory,
AUD_ChannelMapperFactory::AUD_ChannelMapperFactory(boost::shared_ptr<AUD_IFactory> factory,
AUD_DeviceSpecs specs) :
AUD_MixerFactory(factory, specs)
{
}
AUD_Reference<AUD_IReader> AUD_ChannelMapperFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_ChannelMapperFactory::createReader()
{
AUD_Reference<AUD_IReader> reader = getReader();
return new AUD_ChannelMapperReader(reader, m_specs.channels);
boost::shared_ptr<AUD_IReader> reader = getReader();
return boost::shared_ptr<AUD_IReader>(new AUD_ChannelMapperReader(reader, m_specs.channels));
}

4
intern/audaspace/intern/AUD_ChannelMapperFactory.h
View File

@@ -49,9 +49,9 @@ public:
* \param factory The input factory.
* \param specs The target specifications.
*/
AUD_ChannelMapperFactory(AUD_Reference<AUD_IFactory> factory, AUD_DeviceSpecs specs);
AUD_ChannelMapperFactory(boost::shared_ptr<AUD_IFactory> factory, AUD_DeviceSpecs specs);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_CHANNELMAPPERFACTORY_H__

2
intern/audaspace/intern/AUD_ChannelMapperReader.cpp
View File

@@ -38,7 +38,7 @@
#include "AUD_ChannelMapperReader.h"
AUD_ChannelMapperReader::AUD_ChannelMapperReader(AUD_Reference<AUD_IReader> reader,
AUD_ChannelMapperReader::AUD_ChannelMapperReader(boost::shared_ptr<AUD_IReader> reader,
AUD_Channels channels) :
AUD_EffectReader(reader), m_target_channels(channels),
m_source_channels(AUD_CHANNELS_INVALID), m_mapping(0), m_map_size(0), m_mono_angle(0)

2
intern/audaspace/intern/AUD_ChannelMapperReader.h
View File

@@ -110,7 +110,7 @@ public:
* \param reader The reader to map.
* \param mapping The mapping specification as two dimensional float array.
*/
AUD_ChannelMapperReader(AUD_Reference<AUD_IReader> reader, AUD_Channels channels);
AUD_ChannelMapperReader(boost::shared_ptr<AUD_IReader> reader, AUD_Channels channels);
/**
* Destroys the reader.

8
intern/audaspace/intern/AUD_ConverterFactory.cpp
View File

@@ -30,18 +30,18 @@
#include "AUD_ConverterFactory.h"
#include "AUD_ConverterReader.h"
AUD_ConverterFactory::AUD_ConverterFactory(AUD_Reference<AUD_IFactory> factory,
AUD_ConverterFactory::AUD_ConverterFactory(boost::shared_ptr<AUD_IFactory> factory,
AUD_DeviceSpecs specs) :
AUD_MixerFactory(factory, specs)
{
}
AUD_Reference<AUD_IReader> AUD_ConverterFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_ConverterFactory::createReader()
{
AUD_Reference<AUD_IReader> reader = getReader();
boost::shared_ptr<AUD_IReader> reader = getReader();
if(m_specs.format != AUD_FORMAT_FLOAT32)
reader = new AUD_ConverterReader(reader, m_specs);
reader = boost::shared_ptr<AUD_IReader>(new AUD_ConverterReader(reader, m_specs));
return reader;
}

4
intern/audaspace/intern/AUD_ConverterFactory.h
View File

@@ -49,9 +49,9 @@ public:
* \param factory The input factory.
* \param specs The target specifications.
*/
AUD_ConverterFactory(AUD_Reference<AUD_IFactory> factory, AUD_DeviceSpecs specs);
AUD_ConverterFactory(boost::shared_ptr<AUD_IFactory> factory, AUD_DeviceSpecs specs);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_CONVERTERFACTORY_H__

2
intern/audaspace/intern/AUD_ConverterReader.cpp
View File

@@ -29,7 +29,7 @@
#include "AUD_ConverterReader.h"
AUD_ConverterReader::AUD_ConverterReader(AUD_Reference<AUD_IReader> reader,
AUD_ConverterReader::AUD_ConverterReader(boost::shared_ptr<AUD_IReader> reader,
AUD_DeviceSpecs specs) :
AUD_EffectReader(reader),
m_format(specs.format)

2
intern/audaspace/intern/AUD_ConverterReader.h
View File

@@ -65,7 +65,7 @@ public:
* \param reader The reader to convert.
* \param specs The target specification.
*/
AUD_ConverterReader(AUD_Reference<AUD_IReader> reader, AUD_DeviceSpecs specs);
AUD_ConverterReader(boost::shared_ptr<AUD_IReader> reader, AUD_DeviceSpecs specs);
virtual void read(int& length, bool& eos, sample_t* buffer);
};

14
intern/audaspace/intern/AUD_FileFactory.cpp
View File

@@ -56,15 +56,15 @@ AUD_FileFactory::AUD_FileFactory(const data_t* buffer, int size) :
static const char* read_error = "AUD_FileFactory: File couldn't be read.";
AUD_Reference<AUD_IReader> AUD_FileFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_FileFactory::createReader()
{
#ifdef WITH_SNDFILE
try
{
if(m_buffer.isNull())
return new AUD_SndFileReader(m_filename);
if(m_buffer.get())
return boost::shared_ptr<AUD_IReader>(new AUD_SndFileReader(m_buffer));
else
return new AUD_SndFileReader(m_buffer);
return boost::shared_ptr<AUD_IReader>(new AUD_SndFileReader(m_filename));
}
catch(AUD_Exception&) {}
#endif
@@ -72,10 +72,10 @@ AUD_Reference<AUD_IReader> AUD_FileFactory::createReader()
#ifdef WITH_FFMPEG
try
{
if(m_buffer.isNull())
return new AUD_FFMPEGReader(m_filename);
if(m_buffer.get())
return boost::shared_ptr<AUD_IReader>(new AUD_FFMPEGReader(m_buffer));
else
return new AUD_FFMPEGReader(m_buffer);
return boost::shared_ptr<AUD_IReader>(new AUD_FFMPEGReader(m_filename));
}
catch(AUD_Exception&) {}
#endif

6
intern/audaspace/intern/AUD_FileFactory.h
View File

@@ -31,10 +31,10 @@
#define __AUD_FILEFACTORY_H__
#include "AUD_IFactory.h"
#include "AUD_Reference.h"
#include "AUD_Buffer.h"
#include <string>
#include <boost/shared_ptr.hpp>
/**
* This factory tries to read a sound file via all available file readers.
@@ -50,7 +50,7 @@ private:
/**
* The buffer to read from.
*/
AUD_Reference<AUD_Buffer> m_buffer;
boost::shared_ptr<AUD_Buffer> m_buffer;
// hide copy constructor and operator=
AUD_FileFactory(const AUD_FileFactory&);
@@ -70,7 +70,7 @@ public:
*/
AUD_FileFactory(const data_t* buffer, int size);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_FILEFACTORY_H__

10
intern/audaspace/intern/AUD_FileWriter.cpp
View File

@@ -43,13 +43,13 @@
static const char* write_error = "AUD_FileWriter: File couldn't be written.";
AUD_Reference<AUD_IWriter> AUD_FileWriter::createWriter(std::string filename,AUD_DeviceSpecs specs,
boost::shared_ptr<AUD_IWriter> AUD_FileWriter::createWriter(std::string filename,AUD_DeviceSpecs specs,
AUD_Container format, AUD_Codec codec, unsigned int bitrate)
{
#ifdef WITH_SNDFILE
try
{
return new AUD_SndFileWriter(filename, specs, format, codec, bitrate);
return boost::shared_ptr<AUD_IWriter>(new AUD_SndFileWriter(filename, specs, format, codec, bitrate));
}
catch(AUD_Exception&) {}
#endif
@@ -57,7 +57,7 @@ AUD_Reference<AUD_IWriter> AUD_FileWriter::createWriter(std::string filename,AUD
#ifdef WITH_FFMPEG
try
{
return new AUD_FFMPEGWriter(filename, specs, format, codec, bitrate);
return boost::shared_ptr<AUD_IWriter>(new AUD_FFMPEGWriter(filename, specs, format, codec, bitrate));
}
catch(AUD_Exception&) {}
#endif
@@ -65,7 +65,7 @@ AUD_Reference<AUD_IWriter> AUD_FileWriter::createWriter(std::string filename,AUD
AUD_THROW(AUD_ERROR_SPECS, write_error);
}
void AUD_FileWriter::writeReader(AUD_Reference<AUD_IReader> reader, AUD_Reference<AUD_IWriter> writer, unsigned int length, unsigned int buffersize)
void AUD_FileWriter::writeReader(boost::shared_ptr<AUD_IReader> reader, boost::shared_ptr<AUD_IWriter> writer, unsigned int length, unsigned int buffersize)
{
AUD_Buffer buffer(buffersize * AUD_SAMPLE_SIZE(writer->getSpecs()));
sample_t* buf = buffer.getBuffer();
@@ -94,7 +94,7 @@ void AUD_FileWriter::writeReader(AUD_Reference<AUD_IReader> reader, AUD_Referenc
}
}
void AUD_FileWriter::writeReader(AUD_Reference<AUD_IReader> reader, std::vector<AUD_Reference<AUD_IWriter> >& writers, unsigned int length, unsigned int buffersize)
void AUD_FileWriter::writeReader(boost::shared_ptr<AUD_IReader> reader, std::vector<boost::shared_ptr<AUD_IWriter> >& writers, unsigned int length, unsigned int buffersize)
{
AUD_Buffer buffer(buffersize * AUD_SAMPLE_SIZE(reader->getSpecs()));
AUD_Buffer buffer2(buffersize * sizeof(sample_t));

9
intern/audaspace/intern/AUD_FileWriter.h
View File

@@ -32,8 +32,7 @@
#include <string>
#include <vector>
#include "AUD_Reference.h"
#include <boost/shared_ptr.hpp>
#include "AUD_IWriter.h"
#include "AUD_IReader.h"
@@ -59,7 +58,7 @@ public:
* \param bitrate The bitrate for encoding.
* \return The writer to write data to.
*/
static AUD_Reference<AUD_IWriter> createWriter(std::string filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate);
static boost::shared_ptr<AUD_IWriter> createWriter(std::string filename, AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate);
/**
* Writes a reader to a writer.
@@ -68,7 +67,7 @@ public:
* \param length How many samples should be transfered.
* \param buffersize How many samples should be transfered at once.
*/
static void writeReader(AUD_Reference<AUD_IReader> reader, AUD_Reference<AUD_IWriter> writer, unsigned int length, unsigned int buffersize);
static void writeReader(boost::shared_ptr<AUD_IReader> reader, boost::shared_ptr<AUD_IWriter> writer, unsigned int length, unsigned int buffersize);
/**
* Writes a reader to several writers.
@@ -77,7 +76,7 @@ public:
* \param length How many samples should be transfered.
* \param buffersize How many samples should be transfered at once.
*/
static void writeReader(AUD_Reference<AUD_IReader> reader, std::vector<AUD_Reference<AUD_IWriter> >& writers, unsigned int length, unsigned int buffersize);
static void writeReader(boost::shared_ptr<AUD_IReader> reader, std::vector<boost::shared_ptr<AUD_IWriter> >& writers, unsigned int length, unsigned int buffersize);
};
#endif //__AUD_FILEWRITER_H__

7
intern/audaspace/intern/AUD_IDevice.h
View File

@@ -31,12 +31,13 @@
#define __AUD_IDEVICE_H__
#include "AUD_Space.h"
#include "AUD_Reference.h"
#include "AUD_IFactory.h"
#include "AUD_IReader.h"
#include "AUD_IHandle.h"
#include "AUD_ILockable.h"
#include <boost/shared_ptr.hpp>
/**
* This class represents an output device for sound sources.
* Output devices may be several backends such as plattform independand like
@@ -68,7 +69,7 @@ public:
* \exception AUD_Exception Thrown if there's an unexpected (from the
* device side) error during creation of the reader.
*/
virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IReader> reader, bool keep = false)=0;
virtual boost::shared_ptr<AUD_IHandle> play(boost::shared_ptr<AUD_IReader> reader, bool keep = false)=0;
/**
* Plays a sound source.
@@ -80,7 +81,7 @@ public:
* \exception AUD_Exception Thrown if there's an unexpected (from the
* device side) error during creation of the reader.
*/
virtual AUD_Reference<AUD_IHandle> play(AUD_Reference<AUD_IFactory> factory, bool keep = false)=0;
virtual boost::shared_ptr<AUD_IHandle> play(boost::shared_ptr<AUD_IFactory> factory, bool keep = false)=0;
/**
* Stops all playing sounds.

5
intern/audaspace/intern/AUD_IFactory.h
View File

@@ -31,9 +31,10 @@
#define __AUD_IFACTORY_H__
#include "AUD_Space.h"
#include "AUD_Reference.h"
#include "AUD_IReader.h"
#include <boost/shared_ptr.hpp>
/**
* This class represents a type of sound source and saves the necessary values
* for it. It is able to create a reader that is actually usable for playback
@@ -54,7 +55,7 @@ public:
* \exception AUD_Exception An exception may be thrown if there has been
* a more unexpected error during reader creation.
*/
virtual AUD_Reference<AUD_IReader> createReader()=0;
virtual boost::shared_ptr<AUD_IReader> createReader()=0;
};
#endif //__AUD_IFACTORY_H__

6
intern/audaspace/intern/AUD_JOSResampleFactory.cpp
View File

@@ -30,13 +30,13 @@
#include "AUD_JOSResampleFactory.h"
#include "AUD_JOSResampleReader.h"
AUD_JOSResampleFactory::AUD_JOSResampleFactory(AUD_Reference<AUD_IFactory> factory,
AUD_JOSResampleFactory::AUD_JOSResampleFactory(boost::shared_ptr<AUD_IFactory> factory,
AUD_DeviceSpecs specs) :
AUD_MixerFactory(factory, specs)
{
}
AUD_Reference<AUD_IReader> AUD_JOSResampleFactory::createReader()
boost::shared_ptr<AUD_IReader> AUD_JOSResampleFactory::createReader()
{
return new AUD_JOSResampleReader(getReader(), m_specs.specs);
return boost::shared_ptr<AUD_IReader>(new AUD_JOSResampleReader(getReader(), m_specs.specs));
}

4
intern/audaspace/intern/AUD_JOSResampleFactory.h
View File

@@ -48,9 +48,9 @@ public:
* \param factory The input factory.
* \param specs The target specifications.
*/
AUD_JOSResampleFactory(AUD_Reference<AUD_IFactory> factory, AUD_DeviceSpecs specs);
AUD_JOSResampleFactory(boost::shared_ptr<AUD_IFactory> factory, AUD_DeviceSpecs specs);
virtual AUD_Reference<AUD_IReader> createReader();
virtual boost::shared_ptr<AUD_IReader> createReader();
};
#endif //__AUD_JOSRESAMPLEFACTORY_H__

2
intern/audaspace/intern/AUD_JOSResampleReader.cpp
View File

@@ -68,7 +68,7 @@ static inline int lrint(double d)
#define fp_rest(x) (x & ((1 << SHIFT_BITS) - 1))
#define fp_rest_to_double(x) fp_to_double(fp_rest(x))
AUD_JOSResampleReader::AUD_JOSResampleReader(AUD_Reference<AUD_IReader> reader, AUD_Specs specs) :
AUD_JOSResampleReader::AUD_JOSResampleReader(boost::shared_ptr<AUD_IReader> reader, AUD_Specs specs) :
AUD_ResampleReader(reader, specs.rate),
m_channels(AUD_CHANNELS_INVALID),
m_n(0),

2
intern/audaspace/intern/AUD_JOSResampleReader.h
View File

@@ -123,7 +123,7 @@ public:
* \param reader The reader to mix.
* \param specs The target specification.
*/
AUD_JOSResampleReader(AUD_Reference<AUD_IReader> reader, AUD_Specs specs);
AUD_JOSResampleReader(boost::shared_ptr<AUD_IReader> reader, AUD_Specs specs);
virtual void seek(int position);
virtual int getLength() const;

Some files were not shown because too many files have changed in this diff Show More