Audaspace:

* Added an error string for audaspace exceptions.
* Fixed PyAPI exceptions.
* Minor bugfixes.
* Added a name parameter to the Jack device, so that one can define an own name via Python.

intern/audaspace/FX/AUD_DoubleReader.cpp

@@ -27,6 +27,9 @@
 
 #include <cstring>
 
+static const char* specs_error = "AUD_DoubleReader: Both readers have to have "
+								 "the same specs.";
+
 AUD_DoubleReader::AUD_DoubleReader(AUD_IReader* reader1,
 								   AUD_IReader* reader2) :
 		m_reader1(reader1), m_reader2(reader2), m_finished1(false)
@@ -38,7 +41,7 @@ AUD_DoubleReader::AUD_DoubleReader(AUD_IReader* reader1,
 	{
 		delete reader1;
 		delete reader2;
-		AUD_THROW(AUD_ERROR_READER);
+		AUD_THROW(AUD_ERROR_SPECS, specs_error);
 	}
 }
 

intern/audaspace/FX/AUD_ReverseReader.cpp

@@ -27,13 +27,16 @@
 
 #include <cstring>
 
+static const char* props_error = "AUD_ReverseReader: The reader has to be "
+								 "seekable and a finite length.";
+
 AUD_ReverseReader::AUD_ReverseReader(AUD_IReader* reader) :
 		AUD_EffectReader(reader),
 		m_length(reader->getLength()),
 		m_position(0)
 {
 	if(m_length < 0 || !reader->isSeekable())
-		AUD_THROW(AUD_ERROR_READER);
+		AUD_THROW(AUD_ERROR_PROPS, props_error);
 }
 
 void AUD_ReverseReader::seek(int position)

intern/audaspace/FX/AUD_SuperposeReader.cpp

@@ -27,6 +27,9 @@
 
 #include <cstring>
 
+static const char* specs_error = "AUD_SuperposeReader: Both readers have to "
+								 "have the same specs.";
+
 AUD_SuperposeReader::AUD_SuperposeReader(AUD_IReader* reader1, AUD_IReader* reader2) :
 	m_reader1(reader1), m_reader2(reader2)
 {
@@ -36,7 +39,7 @@ AUD_SuperposeReader::AUD_SuperposeReader(AUD_IReader* reader1, AUD_IReader* read
 		s1 = reader1->getSpecs();
 		s2 = reader2->getSpecs();
 		if(memcmp(&s1, &s2, sizeof(AUD_Specs)))
-			AUD_THROW(AUD_ERROR_READER);
+			AUD_THROW(AUD_ERROR_SPECS, specs_error);
 	}
 	catch(AUD_Exception&)
 	{

intern/audaspace/OpenAL/AUD_OpenALDevice.cpp

@@ -289,6 +289,8 @@ bool AUD_OpenALDevice::isValid(AUD_Handle* handle)
 	return false;
 }
 
+static const char* open_error = "AUD_OpenALDevice: Device couldn't be opened.";
+
 AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize)
 {
 	// cannot determine how many channels or which format OpenAL uses, but
@@ -313,7 +315,7 @@ AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize)
 	m_device = alcOpenDevice(NULL);
 
 	if(!m_device)
-		AUD_THROW(AUD_ERROR_OPENAL);
+		AUD_THROW(AUD_ERROR_OPENAL, open_error);
 
 	// at least try to set the frequency
 	ALCint attribs[] = { ALC_FREQUENCY, specs.rate, 0 };
@@ -513,6 +515,15 @@ bool AUD_OpenALDevice::getFormat(ALenum &format, AUD_Specs specs)
 	return valid;
 }
 
+static const char* genbuffer_error = "AUD_OpenALDevice: Buffer couldn't be "
+									 "generated.";
+static const char* gensource_error = "AUD_OpenALDevice: Source couldn't be "
+									 "generated.";
+static const char* queue_error = "AUD_OpenALDevice: Buffer couldn't be "
+								 "queued to the source.";
+static const char* bufferdata_error = "AUD_OpenALDevice: Buffer couldn't be "
+									  "filled with data.";
+
 AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 {
 	lock();
@@ -542,13 +553,13 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 				{
 					alGenSources(1, &sound->source);
 					if(alGetError() != AL_NO_ERROR)
-						AUD_THROW(AUD_ERROR_OPENAL);
+						AUD_THROW(AUD_ERROR_OPENAL, gensource_error);
 
 					try
 					{
 						alSourcei(sound->source, AL_BUFFER, (*i)->buffer);
 						if(alGetError() != AL_NO_ERROR)
-							AUD_THROW(AUD_ERROR_OPENAL);
+							AUD_THROW(AUD_ERROR_OPENAL, queue_error);
 					}
 					catch(AUD_Exception&)
 					{
@@ -586,9 +597,6 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 
 	AUD_IReader* reader = factory->createReader();
 
-	if(reader == NULL)
-		AUD_THROW(AUD_ERROR_READER);
-
 	AUD_DeviceSpecs specs = m_specs;
 	specs.specs = reader->getSpecs();
 
@@ -624,7 +632,7 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 	{
 		alGenBuffers(AUD_OPENAL_CYCLE_BUFFERS, sound->buffers);
 		if(alGetError() != AL_NO_ERROR)
-			AUD_THROW(AUD_ERROR_OPENAL);
+			AUD_THROW(AUD_ERROR_OPENAL, genbuffer_error);
 
 		try
 		{
@@ -639,19 +647,19 @@ AUD_Handle* AUD_OpenALDevice::play(AUD_IFactory* factory, bool keep)
 							 length * AUD_DEVICE_SAMPLE_SIZE(specs),
 							 specs.rate);
 				if(alGetError() != AL_NO_ERROR)
-					AUD_THROW(AUD_ERROR_OPENAL);
+					AUD_THROW(AUD_ERROR_OPENAL, bufferdata_error);
 			}
 
 			alGenSources(1, &sound->source);
 			if(alGetError() != AL_NO_ERROR)
-				AUD_THROW(AUD_ERROR_OPENAL);
+				AUD_THROW(AUD_ERROR_OPENAL, gensource_error);
 
 			try
 			{
 				alSourceQueueBuffers(sound->source, AUD_OPENAL_CYCLE_BUFFERS,
 									 sound->buffers);
 				if(alGetError() != AL_NO_ERROR)
-					AUD_THROW(AUD_ERROR_OPENAL);
+					AUD_THROW(AUD_ERROR_OPENAL, queue_error);
 			}
 			catch(AUD_Exception&)
 			{

intern/audaspace/SDL/AUD_SDLDevice.cpp

@@ -33,6 +33,10 @@ void AUD_SDLDevice::SDL_mix(void *data, Uint8* buffer, int length)
 	device->mix((data_t*)buffer,length/AUD_DEVICE_SAMPLE_SIZE(device->m_specs));
 }
 
+static const char* open_error = "AUD_SDLDevice: Device couldn't be opened.";
+static const char* format_error = "AUD_SDLDevice: Obtained unsupported sample "
+								  "format.";
+
 AUD_SDLDevice::AUD_SDLDevice(AUD_DeviceSpecs specs, int buffersize)
 {
 	if(specs.channels == AUD_CHANNELS_INVALID)
@@ -57,7 +61,7 @@ AUD_SDLDevice::AUD_SDLDevice(AUD_DeviceSpecs specs, int buffersize)
 	format.userdata = this;
 
 	if(SDL_OpenAudio(&format, &obtained) != 0)
-		AUD_THROW(AUD_ERROR_SDL);
+		AUD_THROW(AUD_ERROR_SDL, open_error);
 
 	m_specs.rate = (AUD_SampleRate)obtained.freq;
 	m_specs.channels = (AUD_Channels)obtained.channels;
@@ -66,7 +70,10 @@ AUD_SDLDevice::AUD_SDLDevice(AUD_DeviceSpecs specs, int buffersize)
 	else if(obtained.format == AUDIO_S16LSB || obtained.format == AUDIO_S16MSB)
 		m_specs.format = AUD_FORMAT_S16;
 	else
-		AUD_THROW(AUD_ERROR_SDL);
+	{
+		SDL_CloseAudio();
+		AUD_THROW(AUD_ERROR_SDL, format_error);
+	}
 
 	create();
 }

intern/audaspace/SRC/AUD_SRCResampleReader.cpp

@@ -34,6 +34,9 @@ static long src_callback(void *cb_data, float **data)
 	return ((AUD_SRCResampleReader*)cb_data)->doCallback(data);
 }
 
+static const char* state_error = "AUD_SRCResampleReader: SRC State couldn't be "
+								 "created.";
+
 AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_IReader* reader,
 											 AUD_Specs specs) :
 		AUD_EffectReader(reader),
@@ -54,8 +57,7 @@ AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_IReader* reader,
 	if(!m_src)
 	{
 		// XXX printf("%s\n", src_strerror(error));
-		delete m_reader;
+		AUD_THROW(AUD_ERROR_SRC, state_error);
-		AUD_THROW(AUD_ERROR_READER);
 	}
 }
 

intern/audaspace/ffmpeg/AUD_FFMPEGReader.cpp

@@ -77,13 +77,24 @@ int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer& buffer)
 	return buf_pos;
 }
 
+static const char* streaminfo_error = "AUD_FFMPEGReader: Stream info couldn't "
+									  "be found.";
+static const char* noaudio_error = "AUD_FFMPEGReader: File doesn't include an "
+								   "audio stream.";
+static const char* nodecoder_error = "AUD_FFMPEGReader: No decoder found for "
+									 "the audio stream.";
+static const char* codecopen_error = "AUD_FFMPEGReader: Codec couldn't be "
+									 "opened.";
+static const char* format_error = "AUD_FFMPEGReader: Unsupported sample "
+								  "format.";
+
 void AUD_FFMPEGReader::init()
 {
 	m_position = 0;
 	m_pkgbuf_left = 0;
 
 	if(av_find_stream_info(m_formatCtx)<0)
-		AUD_THROW(AUD_ERROR_FFMPEG);
+		AUD_THROW(AUD_ERROR_FFMPEG, streaminfo_error);
 
 	// find audio stream and codec
 	m_stream = -1;
@@ -99,17 +110,17 @@ void AUD_FFMPEGReader::init()
 	}
 
 	if(m_stream == -1)
-		AUD_THROW(AUD_ERROR_FFMPEG);
+		AUD_THROW(AUD_ERROR_FFMPEG, noaudio_error);
 
 	m_codecCtx = m_formatCtx->streams[m_stream]->codec;
 
 	// get a decoder and open it
 	AVCodec *aCodec = avcodec_find_decoder(m_codecCtx->codec_id);
 	if(!aCodec)
-		AUD_THROW(AUD_ERROR_FFMPEG);
+		AUD_THROW(AUD_ERROR_FFMPEG, nodecoder_error);
 
 	if(avcodec_open(m_codecCtx, aCodec)<0)
-		AUD_THROW(AUD_ERROR_FFMPEG);
+		AUD_THROW(AUD_ERROR_FFMPEG, codecopen_error);
 
 	// XXX this prints file information to stdout:
 	//dump_format(m_formatCtx, 0, NULL, 0);
@@ -139,19 +150,22 @@ void AUD_FFMPEGReader::init()
 		m_specs.format = AUD_FORMAT_FLOAT64;
 		break;
 	default:
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FFMPEG, format_error);
 	}
 
 	m_specs.rate = (AUD_SampleRate) m_codecCtx->sample_rate;
 }
 
+static const char* fileopen_error = "AUD_FFMPEGReader: File couldn't be "
+									"opened.";
+
 AUD_FFMPEGReader::AUD_FFMPEGReader(std::string filename) :
 	m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
 	m_byteiocontext(NULL)
 {
 	// open file
 	if(av_open_input_file(&m_formatCtx, filename.c_str(), NULL, 0, NULL)!=0)
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FILE, fileopen_error);
 
 	try
 	{
@@ -164,6 +178,9 @@ 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) :
 		m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
 		m_membuffer(buffer)
@@ -174,7 +191,7 @@ AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer) :
 					 buffer.get()->getSize(), 0, NULL, NULL, NULL, NULL) != 0)
 	{
 		av_free(m_byteiocontext);
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FILE, fileopen_error);
 	}
 
 	AVProbeData probe_data;
@@ -187,7 +204,7 @@ AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer) :
 	if(av_open_input_stream(&m_formatCtx, m_byteiocontext, "", fmt, NULL)!=0)
 	{
 		av_free(m_byteiocontext);
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FILE, streamopen_error);
 	}
 
 	try

intern/audaspace/intern/AUD_C-API.cpp

@@ -131,7 +131,7 @@ int AUD_init(AUD_DeviceType device, AUD_DeviceSpecs specs, int buffersize)
 #endif
 #ifdef WITH_JACK
 		case AUD_JACK_DEVICE:
-			dev = new AUD_JackDevice(specs, buffersize);
+			dev = new AUD_JackDevice("Blender", specs, buffersize);
 			break;
 #endif
 		default:

intern/audaspace/intern/AUD_FileFactory.cpp

@@ -51,6 +51,8 @@ AUD_FileFactory::AUD_FileFactory(const data_t* buffer, int size) :
 	memcpy(m_buffer.get()->getBuffer(), buffer, size);
 }
 
+static const char* read_error = "AUD_FileFactory: File couldn't be read.";
+
 AUD_IReader* AUD_FileFactory::createReader() const
 {
 #ifdef WITH_SNDFILE
@@ -75,5 +77,5 @@ AUD_IReader* AUD_FileFactory::createReader() const
 	catch(AUD_Exception&) {}
 #endif
 
-	AUD_THROW(AUD_ERROR_FILE);
+	AUD_THROW(AUD_ERROR_FILE, read_error);
 }

intern/audaspace/intern/AUD_SoftwareDevice.cpp

@@ -211,9 +211,6 @@ AUD_Handle* AUD_SoftwareDevice::play(AUD_IFactory* factory, bool keep)
 {
 	AUD_IReader* reader = factory->createReader();
 
-	if(reader == NULL)
-		AUD_THROW(AUD_ERROR_READER);
-
 	// prepare the reader
 	reader = m_mixer->prepare(reader);
 	if(reader == NULL)

intern/audaspace/intern/AUD_Space.h

@@ -33,7 +33,7 @@
 /// The size of a sample in the specified format in bytes.
 #define AUD_SAMPLE_SIZE(specs) (specs.channels * sizeof(sample_t))
 /// Throws a AUD_Exception with the provided error code.
-#define AUD_THROW(exception) { AUD_Exception e; e.error = exception; throw e; }
+#define AUD_THROW(exception, errorstr) { AUD_Exception e; e.error = exception; e.str = errorstr; throw e; }
 
 /// Returns the smaller of the two values.
 #define AUD_MIN(a, b) (((a) < (b)) ? (a) : (b))
@@ -108,13 +108,14 @@ typedef enum
 typedef enum
 {
 	AUD_NO_ERROR = 0,
-	AUD_ERROR_READER,
+	AUD_ERROR_SPECS,
-	AUD_ERROR_FACTORY,
+	AUD_ERROR_PROPS,
 	AUD_ERROR_FILE,
+	AUD_ERROR_SRC,
 	AUD_ERROR_FFMPEG,
-	AUD_ERROR_SDL,
 	AUD_ERROR_OPENAL,
-	AUD_ERROR_JACK
+	AUD_ERROR_SDL,
+	AUD_ERROR_JACK,
 } AUD_Error;
 
 /// Fading types.
@@ -181,6 +182,11 @@ typedef struct
 	 */
 	AUD_Error error;
 
+	/**
+	 * Error string.
+	 */
+	const char* str;
+
 	// void* userData; - for the case it is needed someday
 } AUD_Exception;
 

intern/audaspace/jack/AUD_JackDevice.cpp

@@ -172,7 +172,13 @@ void AUD_JackDevice::jack_shutdown(void *data)
 	device->m_valid = false;
 }
 
-AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
+static const char* clientopen_error = "AUD_JackDevice: Couldn't connect to "
+									  "jack server.";
+static const char* port_error = "AUD_JackDevice: Couldn't create output port.";
+static const char* activate_error = "AUD_JackDevice: Couldn't activate the "
+									"client.";
+
+AUD_JackDevice::AUD_JackDevice(std::string name, AUD_DeviceSpecs specs, int buffersize)
 {
 	if(specs.channels == AUD_CHANNELS_INVALID)
 		specs.channels = AUD_CHANNELS_STEREO;
@@ -185,9 +191,9 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 	jack_status_t status;
 
 	// open client
-	m_client = jack_client_open("Blender", options, &status);
+	m_client = jack_client_open(name.c_str(), options, &status);
 	if(m_client == NULL)
-		AUD_THROW(AUD_ERROR_JACK);
+		AUD_THROW(AUD_ERROR_JACK, clientopen_error);
 
 	// set callbacks
 	jack_set_process_callback(m_client, AUD_JackDevice::jack_mix, this);
@@ -207,7 +213,7 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 											JACK_DEFAULT_AUDIO_TYPE,
 											JackPortIsOutput, 0);
 			if(m_ports[i] == NULL)
-				AUD_THROW(AUD_ERROR_JACK);
+				AUD_THROW(AUD_ERROR_JACK, port_error);
 		}
 	}
 	catch(AUD_Exception&)
@@ -249,7 +255,7 @@ AUD_JackDevice::AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize)
 		pthread_cond_destroy(&m_mixingCondition);
 		destroy();
 
-		AUD_THROW(AUD_ERROR_JACK);
+		AUD_THROW(AUD_ERROR_JACK, activate_error);
 	}
 
 	const char** ports = jack_get_ports(m_client, NULL, NULL,

intern/audaspace/jack/AUD_JackDevice.h

@@ -30,6 +30,8 @@
 #include "AUD_SoftwareDevice.h"
 #include "AUD_Buffer.h"
 
+#include <string>
+
 #include <jack.h>
 #include <ringbuffer.h>
 
@@ -127,11 +129,13 @@ protected:
 public:
 	/**
 	 * Creates a Jack client for audio output.
+	 * \param name The client name.
 	 * \param specs The wanted audio specification, where only the channel count
 	 *              is important.
+	 * \param buffersize The size of the internal buffer.
 	 * \exception AUD_Exception Thrown if the audio device cannot be opened.
 	 */
-	AUD_JackDevice(AUD_DeviceSpecs specs, int buffersize = AUD_DEFAULT_BUFFER_SIZE);
+	AUD_JackDevice(std::string name, AUD_DeviceSpecs specs, int buffersize = AUD_DEFAULT_BUFFER_SIZE);
 
 	/**
 	 * Closes the Jack client.

intern/audaspace/sndfile/AUD_SndFileReader.cpp

@@ -76,6 +76,9 @@ sf_count_t AUD_SndFileReader::vio_tell(void *user_data)
 	return reader->m_memoffset;
 }
 
+static const char* fileopen_error = "AUD_SndFileReader: File couldn't be "
+									"read.";
+
 AUD_SndFileReader::AUD_SndFileReader(std::string filename) :
 	m_position(0)
 {
@@ -85,7 +88,7 @@ AUD_SndFileReader::AUD_SndFileReader(std::string filename) :
 	m_sndfile = sf_open(filename.c_str(), SFM_READ, &sfinfo);
 
 	if(!m_sndfile)
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FILE, fileopen_error);
 
 	m_specs.channels = (AUD_Channels) sfinfo.channels;
 	m_specs.rate = (AUD_SampleRate) sfinfo.samplerate;
@@ -110,7 +113,7 @@ AUD_SndFileReader::AUD_SndFileReader(AUD_Reference<AUD_Buffer> buffer) :
 	m_sndfile = sf_open_virtual(&m_vio, SFM_READ, &sfinfo, this);
 
 	if(!m_sndfile)
-		AUD_THROW(AUD_ERROR_FILE);
+		AUD_THROW(AUD_ERROR_FILE, fileopen_error);
 
 	m_specs.channels = (AUD_Channels) sfinfo.channels;
 	m_specs.rate = (AUD_SampleRate) sfinfo.samplerate;