/*
 * $Id$
 *
 * ***** BEGIN LGPL LICENSE BLOCK *****
 *
 * Copyright 2009 Jörg Hermann Müller
 *
 * This file is part of AudaSpace.
 *
 * AudaSpace is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * AudaSpace is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
 *
 * ***** END LGPL LICENSE BLOCK *****
 */

#include "AUD_PyAPI.h"
#include "structmember.h"

#include "AUD_I3DDevice.h"
#include "AUD_NULLDevice.h"
#include "AUD_DelayFactory.h"
#include "AUD_DoubleFactory.h"
#include "AUD_FaderFactory.h"
#include "AUD_HighpassFactory.h"
#include "AUD_LimiterFactory.h"
#include "AUD_LoopFactory.h"
#include "AUD_LowpassFactory.h"
#include "AUD_PingPongFactory.h"
#include "AUD_PitchFactory.h"
#include "AUD_ReverseFactory.h"
#include "AUD_SinusFactory.h"
#include "AUD_FileFactory.h"
#include "AUD_SquareFactory.h"
#include "AUD_StreamBufferFactory.h"
#include "AUD_SuperposeFactory.h"
#include "AUD_VolumeFactory.h"
#include "AUD_IIRFilterFactory.h"

#ifdef WITH_SDL
#include "AUD_SDLDevice.h"
#endif

#ifdef WITH_OPENAL
#include "AUD_OpenALDevice.h"
#endif

#ifdef WITH_JACK
#include "AUD_JackDevice.h"
#endif

// ====================================================================

typedef enum
{
	AUD_DEVICE_NULL = 0,
	AUD_DEVICE_OPENAL,
	AUD_DEVICE_SDL,
	AUD_DEVICE_JACK,
	AUD_DEVICE_READ,
} AUD_DeviceTypes;

// ====================================================================

#define PY_MODULE_ADD_CONSTANT(module, name) PyModule_AddIntConstant(module, #name, name)

// ====================================================================

static PyObject* AUDError;

static const char* device_not_3d_error = "Device is not a 3D device!";

// ====================================================================

static void
Factory_dealloc(Factory* self)
{
	if(self->factory)
		delete self->factory;
	Py_XDECREF(self->child_list);
	Py_TYPE(self)->tp_free((PyObject*)self);
}

static PyObject *
Factory_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
	Factory *self;

	self = (Factory*)type->tp_alloc(type, 0);
	if(self != NULL)
	{
		static const char *kwlist[] = {"filename", NULL};
		const char* filename = NULL;

		if(!PyArg_ParseTupleAndKeywords(args, kwds, "s:Factory", const_cast<char**>(kwlist), &filename))
		{
			Py_DECREF(self);
			return NULL;
		}

		try
		{
			self->factory = new AUD_FileFactory(filename);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(self);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)self;
}

PyDoc_STRVAR(M_aud_Factory_sine_doc,
			 "sine(frequency, rate=44100)\n\n"
			 "Creates a sine factory which plays a sine wave.\n\n"
			 ":arg frequency: The frequency of the sine wave in Hz.\n"
			 ":type frequency: float\n"
			 ":arg rate: The sampling rate in Hz. It's recommended to set this "
			 "value to the playback device's samling rate to avoid resamping.\n"
			 ":type rate: int\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_sine(PyTypeObject* type, PyObject* args)
{
	float frequency;
	int rate = 44100;

	if(!PyArg_ParseTuple(args, "f|i:sine", &frequency, &rate))
		return NULL;

	Factory *self;

	self = (Factory*)type->tp_alloc(type, 0);
	if(self != NULL)
	{
		try
		{
			self->factory = new AUD_SinusFactory(frequency, (AUD_SampleRate)rate);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(self);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)self;
}

PyDoc_STRVAR(M_aud_Factory_file_doc,
			 "file(filename)\n\n"
			 "Creates a factory object of a sound file.\n\n"
			 ":arg filename: Path of the file.\n"
			 ":type filename: string\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. warning:: If the file doesn't exist or can't be read you will "
			 "not get an exception immediately, but when you try to start "
			 "playback of that factory.");

static PyObject *
Factory_file(PyTypeObject* type, PyObject* args)
{
	const char* filename = NULL;

	if(!PyArg_ParseTuple(args, "s:file", &filename))
		return NULL;

	Factory *self;

	self = (Factory*)type->tp_alloc(type, 0);
	if(self != NULL)
	{
		try
		{
			self->factory = new AUD_FileFactory(filename);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(self);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)self;
}

PyDoc_STRVAR(M_aud_Factory_lowpass_doc,
			 "lowpass(frequency, Q=0.5)\n\n"
			 "Creates a second order lowpass filter based on the transfer "
			 "function H(s) = 1 / (s^2 + s/Q + 1)\n\n"
			 ":arg frequency: The cut off trequency of the lowpass.\n"
			 ":type frequency: float\n"
			 ":arg Q: Q factor of the lowpass.\n"
			 ":type Q: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_lowpass(Factory* self, PyObject* args)
{
	float frequency;
	float Q = 0.5;

	if(!PyArg_ParseTuple(args, "f|f:lowpass", &frequency, &Q))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_LowpassFactory(self->factory, frequency, Q);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_delay_doc,
			 "delay(time)\n\n"
			 "Delays by playing adding silence in front of the other factory's "
			 "data.\n\n"
			 ":arg time: How many seconds of silence should be added before "
			 "the factory.\n"
			 ":type time: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_delay(Factory* self, PyObject* args)
{
	float delay;

	if(!PyArg_ParseTuple(args, "f:delay", &delay))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_DelayFactory(self->factory, delay);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_join_doc,
			 "join(factory)\n\n"
			 "Plays two factories in sequence.\n\n"
			 ":arg factory: The factory to play second.\n"
			 ":type factory: :class:`Factory`\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: The two factories have to have the same specifications "
			 "(channels and samplerate).");

static PyObject *
Factory_join(Factory* self, PyObject* object)
{
	PyTypeObject* type = ((PyObject*)self)->ob_type;

	if(!PyObject_TypeCheck(object, type))
	{
		PyErr_SetString(PyExc_TypeError, "Object has to be of type Factory!");
		return NULL;
	}

	Factory *parent;
	Factory *child = (Factory*)object;

	parent = (Factory*)type->tp_alloc(type, 0);
	if(parent != NULL)
	{
		parent->child_list = Py_BuildValue("(OO)", self, object);

		try
		{
			parent->factory = new AUD_DoubleFactory(self->factory, child->factory);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_highpass_doc,
			 "highpass(frequency, Q=0.5)\n\n"
			 "Creates a second order highpass filter based on the transfer "
			 "function H(s) = s^2 / (s^2 + s/Q + 1)\n\n"
			 ":arg frequency: The cut off trequency of the highpass.\n"
			 ":type frequency: float\n"
			 ":arg Q: Q factor of the lowpass.\n"
			 ":type Q: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_highpass(Factory* self, PyObject* args)
{
	float frequency;
	float Q = 0.5;

	if(!PyArg_ParseTuple(args, "f|f:highpass", &frequency, &Q))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_HighpassFactory(self->factory, frequency, Q);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_limit_doc,
			 "limit(start, end)\n\n"
			 "Limits a factory within a specific start and end time.\n\n"
			 ":arg start: Start time in seconds.\n"
			 ":type start: float\n"
			 ":arg end: End time in seconds.\n"
			 ":type end: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_limit(Factory* self, PyObject* args)
{
	float start, end;

	if(!PyArg_ParseTuple(args, "ff:limit", &start, &end))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_LimiterFactory(self->factory, start, end);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_pitch_doc,
			 "pitch(factor)\n\n"
			 "Changes the pitch of a factory with a specific factor.\n\n"
			 ":arg factor: The factor to change the pitch with.\n"
			 ":type factor: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: This is done by changing the sample rate of the "
			 "underlying factory, which has to be an integer, so the factor "
			 "value rounded and the factor may not be 100 % accurate.\n\n"
			 ".. note:: This is a filter function, you might consider using "
			 ":attr:`Handle.pitch` instead.");

static PyObject *
Factory_pitch(Factory* self, PyObject* args)
{
	float factor;

	if(!PyArg_ParseTuple(args, "f:pitch", &factor))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_PitchFactory(self->factory, factor);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_volume_doc,
			 "volume(volume)\n\n"
			 "Changes the volume of a factory.\n\n"
			 ":arg volume: The new volume..\n"
			 ":type volume: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: Should be in the range [0, 1] to avoid clipping.\n\n"
			 ".. note:: This is a filter function, you might consider using "
			 ":attr:`Handle.volume` instead.");

static PyObject *
Factory_volume(Factory* self, PyObject* args)
{
	float volume;

	if(!PyArg_ParseTuple(args, "f:volume", &volume))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_VolumeFactory(self->factory, volume);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_fadein_doc,
			 "fadein(start, length)\n\n"
			 "Fades a factory in by raising the volume linearly in the given "
			 "time interval.\n\n"
			 ":arg start: Time in seconds when the fading should start.\n"
			 ":type start: float\n"
			 ":arg length: Time in seconds how long the fading should last.\n"
			 ":type length: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: Before the fade starts it plays silence.");

static PyObject *
Factory_fadein(Factory* self, PyObject* args)
{
	float start, length;

	if(!PyArg_ParseTuple(args, "ff:fadein", &start, &length))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_FaderFactory(self->factory, AUD_FADE_IN, start, length);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_fadeout_doc,
			 "fadeout(start, length)\n\n"
			 "Fades a factory in by lowering the volume linearly in the given "
			 "time interval.\n\n"
			 ":arg start: Time in seconds when the fading should start.\n"
			 ":type start: float\n"
			 ":arg length: Time in seconds how long the fading should last.\n"
			 ":type length: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: After the fade this factory plays silence, so that "
			 "the length of the factory is not altered.");

static PyObject *
Factory_fadeout(Factory* self, PyObject* args)
{
	float start, length;

	if(!PyArg_ParseTuple(args, "ff:fadeout", &start, &length))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_FaderFactory(self->factory, AUD_FADE_OUT, start, length);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_loop_doc,
			 "loop(count)\n\n"
			 "Loops a factory.\n\n"
			 ":arg count: How often the factory should be looped. "
			 "Negative values mean endlessly.\n"
			 ":type count: integer\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: This is a filter function, you might consider using "
			 ":attr:`Handle.loop_count` instead.");

static PyObject *
Factory_loop(Factory* self, PyObject* args)
{
	int loop;

	if(!PyArg_ParseTuple(args, "i:loop", &loop))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_LoopFactory(self->factory, loop);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_mix_doc,
			 "mix(factory)\n\n"
			 "Mixes two factories.\n\n"
			 ":arg factory: The factory to mix over the other.\n"
			 ":type factory: :class:`Factory`\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: The two factories have to have the same specifications "
			 "(channels and samplerate).");

static PyObject *
Factory_mix(Factory* self, PyObject* object)
{
	PyTypeObject* type = ((PyObject*)self)->ob_type;

	if(!PyObject_TypeCheck(object, type))
	{
		PyErr_SetString(PyExc_TypeError, "Object is not of type Factory!");
		return NULL;
	}

	Factory *parent = (Factory*)type->tp_alloc(type, 0);
	Factory *child = (Factory*)object;

	if(parent != NULL)
	{
		parent->child_list = Py_BuildValue("(OO)", self, object);

		try
		{
			parent->factory = new AUD_SuperposeFactory(self->factory, child->factory);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_pingpong_doc,
			 "pingpong()\n\n"
			 "Plays a factory forward and then backward.\n"
			 "This is like joining a factory with its reverse.\n\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_pingpong(Factory* self)
{
	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_PingPongFactory(self->factory);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_reverse_doc,
			 "reverse()\n\n"
			 "Plays a factory reversed.\n\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: The factory has to have a finite length and has to be "
			 "seekable. It's recommended to use this only with factories	 with "
			 "fast and accurate seeking, which is not true for encoded audio "
			 "files, such ones should be buffered using :meth:`buffer` before "
			 "being played reversed.\n\n"
			 ".. warning:: If seeking is not accurate in the underlying factory "
			 "you'll likely hear skips/jumps/cracks.");

static PyObject *
Factory_reverse(Factory* self)
{
	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_ReverseFactory(self->factory);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_buffer_doc,
			 "buffer()\n\n"
			 "Buffers a factory into RAM.\n"
			 "This saves CPU usage needed for decoding and file access if the "
			 "underlying factory reads from a file on the harddisk, but it "
			 "consumes a lot of memory.\n\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`\n\n"
			 ".. note:: Only known-length factories can be buffered.\n\n"
			 ".. warning:: Raw PCM data needs a lot of space, only buffer "
			 "short factories.");

static PyObject *
Factory_buffer(Factory* self)
{
	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		try
		{
			parent->factory = new AUD_StreamBufferFactory(self->factory);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_square_doc,
			 "square(threshold = 0)\n\n"
			 "Makes a square wave out of an audio wave by setting all samples "
			 "with a amplitude >= threshold to 1, all <= -threshold to -1 and "
			 "all between to 0.\n\n"
			 ":arg threshold: Threshold value over which an amplitude counts "
			 "non-zero.\n"
			 ":type threshold: float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_square(Factory* self, PyObject* args)
{
	float threshold = 0;

	if(!PyArg_ParseTuple(args, "|f:square", &threshold))
		return NULL;

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_SquareFactory(self->factory, threshold);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

PyDoc_STRVAR(M_aud_Factory_filter_doc,
			 "filter(b, a = (1))\n\n"
			 "Filters a factory with the supplied IIR filter coefficients.\n"
			 "Without the second parameter you'll get a FIR filter.\n"
			 "If the first value of the a sequence is 0 it will be set to 1 "
			 "automatically.\n"
			 "If the first value of the a sequence is neither 0 nor 1, all "
			 "filter coefficients will be scaled by this value so that it is 1 "
			 "in the end, you don't have to scale yourself.\n\n"
			 ":arg b: The nominator filter coefficients.\n"
			 ":type b: sequence of float\n"
			 ":arg a: The denominator filter coefficients.\n"
			 ":type a: sequence of float\n"
			 ":return: The created :class:`Factory` object.\n"
			 ":rtype: :class:`Factory`");

static PyObject *
Factory_filter(Factory* self, PyObject* args)
{
	PyObject* py_b;
	PyObject* py_a = NULL;

	if(!PyArg_ParseTuple(args, "O|O:filter", &py_b, &py_a))
		return NULL;

	if(!PySequence_Check(py_b) || (py_a != NULL && !PySequence_Check(py_a)))
	{
		PyErr_SetString(PyExc_TypeError, "Parameter is not a sequence!");
		return NULL;
	}

	if(!PySequence_Size(py_b) || (py_a != NULL && !PySequence_Size(py_a)))
	{
		PyErr_SetString(PyExc_ValueError, "The sequence has to contain at least one value!");
		return NULL;
	}

	std::vector<float> a, b;
	PyObject* py_value;
	float value;
	int result;

	for(int i = 0; i < PySequence_Size(py_b); i++)
	{
		py_value = PySequence_GetItem(py_b, i);
		result = PyArg_Parse(py_value, "f:filter", &value);
		Py_DECREF(py_value);

		if(!result)
			return NULL;

		b.push_back(value);
	}

	if(py_a)
	{
		for(int i = 0; i < PySequence_Size(py_a); i++)
		{
			py_value = PySequence_GetItem(py_a, i);
			result = PyArg_Parse(py_value, "f:filter", &value);
			Py_DECREF(py_value);

			if(!result)
				return NULL;

			a.push_back(value);
		}

		if(a[0] == 0)
			a[0] = 1;
	}
	else
		a.push_back(1);

	PyTypeObject* type = ((PyObject*)self)->ob_type;
	Factory *parent = (Factory*)type->tp_alloc(type, 0);

	if(parent != NULL)
	{
		Py_INCREF(self);
		parent->child_list = (PyObject*)self;

		try
		{
			parent->factory = new AUD_IIRFilterFactory(self->factory, b, a);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(parent);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)parent;
}

static PyMethodDef Factory_methods[] = {
	{"sine", (PyCFunction)Factory_sine, METH_VARARGS | METH_CLASS,
	 M_aud_Factory_sine_doc
	},
	{"file", (PyCFunction)Factory_file, METH_VARARGS | METH_CLASS,
	 M_aud_Factory_file_doc
	},
	{"lowpass", (PyCFunction)Factory_lowpass, METH_VARARGS,
	 M_aud_Factory_lowpass_doc
	},
	{"delay", (PyCFunction)Factory_delay, METH_VARARGS,
	 M_aud_Factory_delay_doc
	},
	{"join", (PyCFunction)Factory_join, METH_O,
	 M_aud_Factory_join_doc
	},
	{"highpass", (PyCFunction)Factory_highpass, METH_VARARGS,
	 M_aud_Factory_highpass_doc
	},
	{"limit", (PyCFunction)Factory_limit, METH_VARARGS,
	 M_aud_Factory_limit_doc
	},
	{"pitch", (PyCFunction)Factory_pitch, METH_VARARGS,
	 M_aud_Factory_pitch_doc
	},
	{"volume", (PyCFunction)Factory_volume, METH_VARARGS,
	 M_aud_Factory_volume_doc
	},
	{"fadein", (PyCFunction)Factory_fadein, METH_VARARGS,
	 M_aud_Factory_fadein_doc
	},
	{"fadeout", (PyCFunction)Factory_fadeout, METH_VARARGS,
	 M_aud_Factory_fadeout_doc
	},
	{"loop", (PyCFunction)Factory_loop, METH_VARARGS,
	 M_aud_Factory_loop_doc
	},
	{"mix", (PyCFunction)Factory_mix, METH_O,
	 M_aud_Factory_mix_doc
	},
	{"pingpong", (PyCFunction)Factory_pingpong, METH_NOARGS,
	 M_aud_Factory_pingpong_doc
	},
	{"reverse", (PyCFunction)Factory_reverse, METH_NOARGS,
	 M_aud_Factory_reverse_doc
	},
	{"buffer", (PyCFunction)Factory_buffer, METH_NOARGS,
	 M_aud_Factory_buffer_doc
	},
	{"square", (PyCFunction)Factory_square, METH_VARARGS,
	 M_aud_Factory_square_doc
	},
	{"filter", (PyCFunction)Factory_filter, METH_VARARGS,
	 M_aud_Factory_filter_doc
	},
	{NULL}  /* Sentinel */
};

PyDoc_STRVAR(M_aud_Factory_doc,
			 "Factory objects are immutable and represent a sound that can be "
			 "played simultaneously multiple times. They are called factories "
			 "because they create reader objects internally that are used for "
			 "playback.");

static PyTypeObject FactoryType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	"aud.Factory",               /* tp_name */
	sizeof(Factory),             /* tp_basicsize */
	0,                         /* tp_itemsize */
	(destructor)Factory_dealloc, /* tp_dealloc */
	0,                         /* tp_print */
	0,                         /* tp_getattr */
	0,                         /* tp_setattr */
	0,                         /* tp_reserved */
	0,                         /* tp_repr */
	0,                         /* tp_as_number */
	0,                         /* tp_as_sequence */
	0,                         /* tp_as_mapping */
	0,                         /* tp_hash  */
	0,                         /* tp_call */
	0,                         /* tp_str */
	0,                         /* tp_getattro */
	0,                         /* tp_setattro */
	0,                         /* tp_as_buffer */
	Py_TPFLAGS_DEFAULT,        /* tp_flags */
	M_aud_Factory_doc,           /* tp_doc */
	0,		                   /* tp_traverse */
	0,		                   /* tp_clear */
	0,		                   /* tp_richcompare */
	0,		                   /* tp_weaklistoffset */
	0,		                   /* tp_iter */
	0,		                   /* tp_iternext */
	Factory_methods,             /* tp_methods */
	0,                         /* tp_members */
	0,                         /* tp_getset */
	0,                         /* tp_base */
	0,                         /* tp_dict */
	0,                         /* tp_descr_get */
	0,                         /* tp_descr_set */
	0,                         /* tp_dictoffset */
	0,                         /* tp_init */
	0,                         /* tp_alloc */
	Factory_new,                 /* tp_new */
};

// ========== Handle ==================================================

static void
Handle_dealloc(Handle* self)
{
	Py_XDECREF(self->device);
	Py_TYPE(self)->tp_free((PyObject*)self);
}

PyDoc_STRVAR(M_aud_Handle_pause_doc,
			 "pause()\n\n"
			 "Pauses playback.\n\n"
			 ":return: Whether the action succeeded.\n"
			 ":rtype: bool");

static PyObject *
Handle_pause(Handle *self)
{
	Device* device = (Device*)self->device;

	try
	{
		return PyBool_FromLong((long)device->device->pause(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Handle_resume_doc,
			 "resume()\n\n"
			 "Resumes playback.\n\n"
			 ":return: Whether the action succeeded.\n"
			 ":rtype: bool");

static PyObject *
Handle_resume(Handle *self)
{
	Device* device = (Device*)self->device;

	try
	{
		return PyBool_FromLong((long)device->device->resume(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Handle_stop_doc,
			 "stop()\n\n"
			 "Stops playback.\n\n"
			 ":return: Whether the action succeeded.\n"
			 ":rtype: bool\n\n"
			 ".. note:: This makes the handle invalid.");

static PyObject *
Handle_stop(Handle *self)
{
	Device* device = (Device*)self->device;

	try
	{
		return PyBool_FromLong((long)device->device->stop(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static PyMethodDef Handle_methods[] = {
	{"pause", (PyCFunction)Handle_pause, METH_NOARGS,
	 M_aud_Handle_pause_doc
	},
	{"resume", (PyCFunction)Handle_resume, METH_NOARGS,
	 M_aud_Handle_resume_doc
	},
	{"stop", (PyCFunction)Handle_stop, METH_NOARGS,
	 M_aud_Handle_stop_doc
	},
	{NULL}  /* Sentinel */
};

PyDoc_STRVAR(M_aud_Handle_position_doc,
			 "The playback position of the sound in seconds.");

static PyObject *
Handle_get_position(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return Py_BuildValue("f", device->device->getPosition(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_position(Handle *self, PyObject* args, void* nothing)
{
	float position;

	if(!PyArg_Parse(args, "f:position", &position))
		return -1;

	Device* device = (Device*)self->device;

	try
	{
		if(device->device->seek(self->handle, position))
			return 0;
		PyErr_SetString(AUDError, "Couldn't seek the sound!");
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_keep_doc,
			 "Whether the sound should be kept paused in the device when its "
			 "end is reached.\n"
			 "This can be used to seek the sound to some position and start "
			 "playback again.\n\n"
			 ".. warning:: If this is set to true and you forget stopping this "
			 "equals a memory leak as the handle exists until the device is "
			 "destroyed.");

static PyObject *
Handle_get_keep(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return PyBool_FromLong((long)device->device->getKeep(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_keep(Handle *self, PyObject* args, void* nothing)
{
	if(!PyBool_Check(args))
	{
		PyErr_SetString(PyExc_TypeError, "keep is not a boolean!");
		return -1;
	}

	bool keep = args == Py_True;
	Device* device = (Device*)self->device;

	try
	{
		if(device->device->setKeep(self->handle, keep))
			return 0;
		PyErr_SetString(AUDError, "Couldn't set keep of the sound!");
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_status_doc,
			 "Whether the sound is playing, paused or stopped (=invalid).");

static PyObject *
Handle_get_status(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return PyBool_FromLong((long)device->device->getStatus(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Handle_volume_doc,
			 "The volume of the sound.");

static PyObject *
Handle_get_volume(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return Py_BuildValue("f", device->device->getVolume(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_volume(Handle *self, PyObject* args, void* nothing)
{
	float volume;

	if(!PyArg_Parse(args, "f:volume", &volume))
		return -1;

	Device* device = (Device*)self->device;

	try
	{
		if(device->device->setVolume(self->handle, volume))
			return 0;
		PyErr_SetString(AUDError, "Couldn't set the sound volume!");
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_pitch_doc,
			 "The pitch of the sound.");

static PyObject *
Handle_get_pitch(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return Py_BuildValue("f", device->device->getPitch(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_pitch(Handle *self, PyObject* args, void* nothing)
{
	float pitch;

	if(!PyArg_Parse(args, "f:pitch", &pitch))
		return -1;

	Device* device = (Device*)self->device;

	try
	{
		if(device->device->setPitch(self->handle, pitch))
			return 0;
		PyErr_SetString(AUDError, "Couldn't set the sound pitch!");
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_loop_count_doc,
			 "The (remaining) loop count of the sound. A negative value indicates infinity.");

static PyObject *
Handle_get_loop_count(Handle *self, void* nothing)
{
	Device* device = (Device*)self->device;

	try
	{
		return Py_BuildValue("i", device->device->getLoopCount(self->handle));
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_loop_count(Handle *self, PyObject* args, void* nothing)
{
	int loops;

	if(!PyArg_Parse(args, "i:loop_count", &loops))
		return -1;

	Device* device = (Device*)self->device;

	try
	{
		if(device->device->setLoopCount(self->handle, loops))
			return 0;
		PyErr_SetString(AUDError, "Couldn't set the loop count!");
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_location_doc,
			 "The source's location in 3D space, a 3D tuple of floats.");

static PyObject *
Handle_get_location(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Vector3 v = device->getSourceLocation(self->handle);
			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Handle_set_location(Handle *self, PyObject* args, void* nothing)
{
	float x, y, z;

	if(!PyArg_Parse(args, "(fff):location", &x, &y, &z))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Vector3 location(x, y, z);
			if(device->setSourceLocation(self->handle, location))
				return 0;
			PyErr_SetString(AUDError, "Location couldn't be set!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_velocity_doc,
			 "The source's velocity in 3D space, a 3D tuple of floats.");

static PyObject *
Handle_get_velocity(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Vector3 v = device->getSourceVelocity(self->handle);
			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Handle_set_velocity(Handle *self, PyObject* args, void* nothing)
{
	float x, y, z;

	if(!PyArg_Parse(args, "(fff):velocity", &x, &y, &z))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Vector3 velocity(x, y, z);
			if(device->setSourceVelocity(self->handle, velocity))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the velocity!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_orientation_doc,
			 "The source's orientation in 3D space as quaternion, a 4 float tuple.");

static PyObject *
Handle_get_orientation(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Quaternion o = device->getSourceOrientation(self->handle);
			return Py_BuildValue("(ffff)", o.w(), o.x(), o.y(), o.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Handle_set_orientation(Handle *self, PyObject* args, void* nothing)
{
	float w, x, y, z;

	if(!PyArg_Parse(args, "(ffff):orientation", &w, &x, &y, &z))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			AUD_Quaternion orientation(w, x, y, z);
			if(device->setSourceOrientation(self->handle, orientation))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the orientation!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_relative_doc,
			 "Whether the source's location, velocity and orientation is relative or absolute to the listener.");

static PyObject *
Handle_get_relative(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return PyBool_FromLong((long)device->isRelative(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Handle_set_relative(Handle *self, PyObject* args, void* nothing)
{
	if(!PyBool_Check(args))
	{
		PyErr_SetString(PyExc_TypeError, "Value is not a boolean!");
		return -1;
	}

	bool relative = (args == Py_True);
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setRelative(self->handle, relative))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the relativeness!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_volume_minimum_doc,
			 "The minimum volume of the source.\n\n"
			 ".. seealso:: :attr:`Device.distance_model`");

static PyObject *
Handle_get_volume_minimum(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getVolumeMinimum(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_volume_minimum(Handle *self, PyObject* args, void* nothing)
{
	float volume;

	if(!PyArg_Parse(args, "f:volume_minimum", &volume))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setVolumeMinimum(self->handle, volume))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the minimum volume!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_volume_maximum_doc,
			 "The maximum volume of the source.\n\n"
			 ".. seealso:: :attr:`Device.distance_model`");

static PyObject *
Handle_get_volume_maximum(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getVolumeMaximum(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_volume_maximum(Handle *self, PyObject* args, void* nothing)
{
	float volume;

	if(!PyArg_Parse(args, "f:volume_maximum", &volume))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setVolumeMaximum(self->handle, volume))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the maximum volume!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_distance_reference_doc,
			 "The reference distance of the source.\n"
			 "At this distance the volume will be exactly :attr:`volume`.\n\n"
			 ".. seealso:: :attr:`Device.distance_model`");

static PyObject *
Handle_get_distance_reference(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getDistanceReference(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_distance_reference(Handle *self, PyObject* args, void* nothing)
{
	float distance;

	if(!PyArg_Parse(args, "f:distance_reference", &distance))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setDistanceReference(self->handle, distance))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the reference distance!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_distance_maximum_doc,
			 "The maximum distance of the source.\n"
			 "If the listener is further away the source volume will be 0.\n\n"
			 ".. seealso:: :attr:`Device.distance_model`");

static PyObject *
Handle_get_distance_maximum(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getDistanceMaximum(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_distance_maximum(Handle *self, PyObject* args, void* nothing)
{
	float distance;

	if(!PyArg_Parse(args, "f:distance_maximum", &distance))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setDistanceMaximum(self->handle, distance))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the maximum distance!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_attenuation_doc,
			 "This factor is used for distance based attenuation of the "
			 "source.\n\n"
			 ".. seealso:: :attr:`Device.distance_model`");

static PyObject *
Handle_get_attenuation(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getAttenuation(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_attenuation(Handle *self, PyObject* args, void* nothing)
{
	float factor;

	if(!PyArg_Parse(args, "f:attenuation", &factor))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setAttenuation(self->handle, factor))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the attenuation!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_cone_angle_inner_doc,
			 "The opening angle of the inner cone of the source. If the cone "
			 "values of a source are set there are two (audible) cones with "
			 "the apex at the :attr:`location` of the source and with infinite "
			 "height, heading in the direction of the source's "
			 ":attr:`orientation`.\n"
			 "In the inner cone the volume is normal. Outside the outer cone "
			 "the volume will be :attr:`cone_volume_outer` and in the area "
			 "between the volume will be interpolated linearly.");

static PyObject *
Handle_get_cone_angle_inner(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getConeAngleInner(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_cone_angle_inner(Handle *self, PyObject* args, void* nothing)
{
	float angle;

	if(!PyArg_Parse(args, "f:cone_angle_inner", &angle))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setConeAngleInner(self->handle, angle))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the cone inner angle!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_cone_angle_outer_doc,
			 "The opening angle of the outer cone of the source.\n\n"
			 ".. seealso:: :attr:`cone_angle_inner`");

static PyObject *
Handle_get_cone_angle_outer(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getConeAngleOuter(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_cone_angle_outer(Handle *self, PyObject* args, void* nothing)
{
	float angle;

	if(!PyArg_Parse(args, "f:cone_angle_outer", &angle))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setConeAngleOuter(self->handle, angle))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the cone outer angle!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Handle_cone_volume_outer_doc,
			 "The volume outside the outer cone of the source.\n\n"
			 ".. seealso:: :attr:`cone_angle_inner`");

static PyObject *
Handle_get_cone_volume_outer(Handle *self, void* nothing)
{
	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			return Py_BuildValue("f", device->getConeVolumeOuter(self->handle));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Handle_set_cone_volume_outer(Handle *self, PyObject* args, void* nothing)
{
	float volume;

	if(!PyArg_Parse(args, "f:cone_volume_outer", &volume))
		return -1;

	Device* dev = (Device*)self->device;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device);
		if(device)
		{
			if(device->setConeVolumeOuter(self->handle, volume))
				return 0;
			PyErr_SetString(AUDError, "Couldn't set the cone outer volume!");
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

static PyGetSetDef Handle_properties[] = {
	{(char*)"position", (getter)Handle_get_position, (setter)Handle_set_position,
	 M_aud_Handle_position_doc, NULL },
	{(char*)"keep", (getter)Handle_get_keep, (setter)Handle_set_keep,
	 M_aud_Handle_keep_doc, NULL },
	{(char*)"status", (getter)Handle_get_status, NULL,
	 M_aud_Handle_status_doc, NULL },
	{(char*)"volume", (getter)Handle_get_volume, (setter)Handle_set_volume,
	 M_aud_Handle_volume_doc, NULL },
	{(char*)"pitch", (getter)Handle_get_pitch, (setter)Handle_set_pitch,
	 M_aud_Handle_pitch_doc, NULL },
	{(char*)"loop_count", (getter)Handle_get_loop_count, (setter)Handle_set_loop_count,
	 M_aud_Handle_loop_count_doc, NULL },
	{(char*)"location", (getter)Handle_get_location, (setter)Handle_set_location,
	 M_aud_Handle_location_doc, NULL },
	{(char*)"velocity", (getter)Handle_get_velocity, (setter)Handle_set_velocity,
	 M_aud_Handle_velocity_doc, NULL },
	{(char*)"orientation", (getter)Handle_get_orientation, (setter)Handle_set_orientation,
	 M_aud_Handle_orientation_doc, NULL },
	{(char*)"relative", (getter)Handle_get_relative, (setter)Handle_set_relative,
	 M_aud_Handle_relative_doc, NULL },
	{(char*)"volume_minimum", (getter)Handle_get_volume_minimum, (setter)Handle_set_volume_minimum,
	 M_aud_Handle_volume_minimum_doc, NULL },
	{(char*)"volume_maximum", (getter)Handle_get_volume_maximum, (setter)Handle_set_volume_maximum,
	 M_aud_Handle_volume_maximum_doc, NULL },
	{(char*)"distance_reference", (getter)Handle_get_distance_reference, (setter)Handle_set_distance_reference,
	 M_aud_Handle_distance_reference_doc, NULL },
	{(char*)"distance_maximum", (getter)Handle_get_distance_maximum, (setter)Handle_set_distance_maximum,
	 M_aud_Handle_distance_maximum_doc, NULL },
	{(char*)"attenuation", (getter)Handle_get_attenuation, (setter)Handle_set_attenuation,
	 M_aud_Handle_attenuation_doc, NULL },
	{(char*)"cone_angle_inner", (getter)Handle_get_cone_angle_inner, (setter)Handle_set_cone_angle_inner,
	 M_aud_Handle_cone_angle_inner_doc, NULL },
	{(char*)"cone_angle_outer", (getter)Handle_get_cone_angle_outer, (setter)Handle_set_cone_angle_outer,
	 M_aud_Handle_cone_angle_outer_doc, NULL },
	{(char*)"cone_volume_outer", (getter)Handle_get_cone_volume_outer, (setter)Handle_set_cone_volume_outer,
	 M_aud_Handle_cone_volume_outer_doc, NULL },
	{NULL}  /* Sentinel */
};

PyDoc_STRVAR(M_aud_Handle_doc,
			 "Handle objects are playback handles that can be used to control "
			 "playback of a sound. If a sound is played back multiple times "
			 "then there are as many handles.");

static PyTypeObject HandleType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	"aud.Handle",              /* tp_name */
	sizeof(Handle),            /* tp_basicsize */
	0,                         /* tp_itemsize */
	(destructor)Handle_dealloc,/* tp_dealloc */
	0,                         /* tp_print */
	0,                         /* tp_getattr */
	0,                         /* tp_setattr */
	0,                         /* tp_reserved */
	0,                         /* tp_repr */
	0,                         /* tp_as_number */
	0,                         /* tp_as_sequence */
	0,                         /* tp_as_mapping */
	0,                         /* tp_hash  */
	0,                         /* tp_call */
	0,                         /* tp_str */
	0,                         /* tp_getattro */
	0,                         /* tp_setattro */
	0,                         /* tp_as_buffer */
	Py_TPFLAGS_DEFAULT,        /* tp_flags */
	M_aud_Handle_doc,          /* tp_doc */
	0,		                   /* tp_traverse */
	0,		                   /* tp_clear */
	0,		                   /* tp_richcompare */
	0,		                   /* tp_weaklistoffset */
	0,		                   /* tp_iter */
	0,		                   /* tp_iternext */
	Handle_methods,            /* tp_methods */
	0,                         /* tp_members */
	Handle_properties,         /* tp_getset */
	0,                         /* tp_base */
	0,                         /* tp_dict */
	0,                         /* tp_descr_get */
	0,                         /* tp_descr_set */
	0,                         /* tp_dictoffset */
	0,                         /* tp_init */
	0,                         /* tp_alloc */
	0,                         /* tp_new */
};

// ========== Device ==================================================

static void
Device_dealloc(Device* self)
{
	if(self->device)
		delete self->device;
	Py_TYPE(self)->tp_free((PyObject*)self);
}

static PyObject *
Device_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
	Device *self;

	static const char *kwlist[] = {"type", "rate", "channels", "format", "buffer_size", "name", NULL};
	int device;
	int rate = AUD_RATE_44100;
	int channels = AUD_CHANNELS_STEREO;
	int format = AUD_FORMAT_FLOAT32;
	int buffersize = AUD_DEFAULT_BUFFER_SIZE;
	const char* name = "Audaspace";

	if(!PyArg_ParseTupleAndKeywords(args, kwds, "i|iiiis:Device", const_cast<char**>(kwlist),
									&device, &rate, &channels, &format, &buffersize, &name))
		return NULL;

	if(buffersize < 128)
	{
		PyErr_SetString(PyExc_ValueError, "buffer_size must be greater than 127!");
		return NULL;
	}

	self = (Device*)type->tp_alloc(type, 0);
	if(self != NULL)
	{
		AUD_DeviceSpecs specs;
		specs.channels = (AUD_Channels)channels;
		specs.format = (AUD_SampleFormat)format;
		specs.rate = (AUD_SampleRate)rate;

		self->device = NULL;

		try
		{
			switch(device)
			{
			case AUD_DEVICE_NULL:
				self->device = new AUD_NULLDevice();
				break;
			case AUD_DEVICE_OPENAL:
#ifdef WITH_OPENAL
				self->device = new AUD_OpenALDevice(specs, buffersize);
#endif
				break;
			case AUD_DEVICE_SDL:
#ifdef WITH_SDL
				self->device = new AUD_SDLDevice(specs, buffersize);
#endif
				break;
			case AUD_DEVICE_JACK:
#ifdef WITH_JACK
				self->device = new AUD_JackDevice(name, specs, buffersize);
#endif
				break;
			case AUD_DEVICE_READ:
				break;
			}

		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(self);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}

		if(!self->device)
		{
			Py_DECREF(self);
			PyErr_SetString(AUDError, "Unsupported device type!");
			return NULL;
		}
	}

	return (PyObject *)self;
}

PyDoc_STRVAR(M_aud_Device_play_doc,
			 "play(factory, keep=False)\n\n"
			 "Plays a factory.\n\n"
			 ":arg factory: The factory to play.\n"
			 ":type factory: :class:`Factory`\n"
			 ":arg keep: See :attr:`Handle.keep`.\n"
			 ":type keep: bool\n"
			 ":return: The playback handle with which playback can be "
			 "controlled with.\n"
			 ":rtype: :class:`Handle`");

static PyObject *
Device_play(Device *self, PyObject *args, PyObject *kwds)
{
	PyObject* object;
	PyObject* keepo = NULL;

	bool keep = false;

	static const char *kwlist[] = {"factory", "keep", NULL};

	if(!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:play", const_cast<char**>(kwlist), &object, &keepo))
		return NULL;

	if(!PyObject_TypeCheck(object, &FactoryType))
	{
		PyErr_SetString(PyExc_TypeError, "Object is not of type Factory!");
		return NULL;
	}

	if(keepo != NULL)
	{
		if(!PyBool_Check(keepo))
		{
			PyErr_SetString(PyExc_TypeError, "keep is not a boolean!");
			return NULL;
		}

		keep = keepo == Py_True;
	}

	Factory* sound = (Factory*)object;
	Handle *handle;

	handle = (Handle*)HandleType.tp_alloc(&HandleType, 0);
	if(handle != NULL)
	{
		handle->device = (PyObject*)self;
		Py_INCREF(self);

		try
		{
			handle->handle = self->device->play(sound->factory, keep);
		}
		catch(AUD_Exception& e)
		{
			Py_DECREF(handle);
			PyErr_SetString(AUDError, e.str);
			return NULL;
		}
	}

	return (PyObject *)handle;
}

PyDoc_STRVAR(M_aud_Device_lock_doc,
			 "lock()\n\n"
			 "Locks the device so that it's guaranteed, that no samples are "
			 "read from the streams until :meth:`unlock` is called.\n"
			 "This is useful if you want to do start/stop/pause/resume some "
			 "sounds at the same time.\n\n"
			 ".. note:: The device has to be unlocked as often as locked to be "
			 "able to continue playback.\n\n"
			 ".. warning:: Make sure the time between locking and unlocking is "
			 "as short as possible to avoid clicks.");

static PyObject *
Device_lock(Device *self)
{
	try
	{
		self->device->lock();
		Py_RETURN_NONE;
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Device_unlock_doc,
			 "unlock()\n\n"
			 "Unlocks the device after a lock call, see :meth:`lock` for "
			 "details.");

static PyObject *
Device_unlock(Device *self)
{
	try
	{
		self->device->unlock();
		Py_RETURN_NONE;
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static PyMethodDef Device_methods[] = {
	{"play", (PyCFunction)Device_play, METH_VARARGS | METH_KEYWORDS,
	 M_aud_Device_play_doc
	},
	{"lock", (PyCFunction)Device_lock, METH_NOARGS,
	 M_aud_Device_lock_doc
	},
	{"unlock", (PyCFunction)Device_unlock, METH_NOARGS,
	 M_aud_Device_unlock_doc
	},
	{NULL}  /* Sentinel */
};

PyDoc_STRVAR(M_aud_Device_rate_doc,
			 "The sampling rate of the device in Hz.");

static PyObject *
Device_get_rate(Device *self, void* nothing)
{
	try
	{
		AUD_DeviceSpecs specs = self->device->getSpecs();
		return Py_BuildValue("i", specs.rate);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Device_format_doc,
			 "The native sample format of the device.");

static PyObject *
Device_get_format(Device *self, void* nothing)
{
	try
	{
		AUD_DeviceSpecs specs = self->device->getSpecs();
		return Py_BuildValue("i", specs.format);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Device_channels_doc,
			 "The channel count of the device.");

static PyObject *
Device_get_channels(Device *self, void* nothing)
{
	try
	{
		AUD_DeviceSpecs specs = self->device->getSpecs();
		return Py_BuildValue("i", specs.channels);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

PyDoc_STRVAR(M_aud_Device_volume_doc,
			 "The overall volume of the device.");

static PyObject *
Device_get_volume(Device *self, void* nothing)
{
	try
	{
		return Py_BuildValue("f", self->device->getVolume());
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Device_set_volume(Device *self, PyObject* args, void* nothing)
{
	float volume;

	if(!PyArg_Parse(args, "f:volume", &volume))
		return -1;

	try
	{
		self->device->setVolume(volume);
		return 0;
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return -1;
	}
}

PyDoc_STRVAR(M_aud_Device_listener_location_doc,
			 "The listeners's location in 3D space, a 3D tuple of floats.");

static PyObject *
Device_get_listener_location(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Vector3 v = device->getListenerLocation();
			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Device_set_listener_location(Device *self, PyObject* args, void* nothing)
{
	float x, y, z;

	if(!PyArg_Parse(args, "(fff):listener_location", &x, &y, &z))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Vector3 location(x, y, z);
			device->setListenerLocation(location);
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Device_listener_velocity_doc,
			 "The listener's velocity in 3D space, a 3D tuple of floats.");

static PyObject *
Device_get_listener_velocity(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Vector3 v = device->getListenerVelocity();
			return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Device_set_listener_velocity(Device *self, PyObject* args, void* nothing)
{
	float x, y, z;

	if(!PyArg_Parse(args, "(fff):listener_velocity", &x, &y, &z))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Vector3 velocity(x, y, z);
			device->setListenerVelocity(velocity);
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Device_listener_orientation_doc,
			 "The listener's orientation in 3D space as quaternion, a 4 float tuple.");

static PyObject *
Device_get_listener_orientation(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Quaternion o = device->getListenerOrientation();
			return Py_BuildValue("(ffff)", o.w(), o.x(), o.y(), o.z());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return NULL;
}

static int
Device_set_listener_orientation(Device *self, PyObject* args, void* nothing)
{
	float w, x, y, z;

	if(!PyArg_Parse(args, "(ffff):listener_orientation", &w, &x, &y, &z))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			AUD_Quaternion orientation(w, x, y, z);
			device->setListenerOrientation(orientation);
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Device_speed_of_sound_doc,
			 "The speed of sound of the device.\n"
			 "The speed of sound in air is typically 343 m/s.");

static PyObject *
Device_get_speed_of_sound(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			return Py_BuildValue("f", device->getSpeedOfSound());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Device_set_speed_of_sound(Device *self, PyObject* args, void* nothing)
{
	float speed;

	if(!PyArg_Parse(args, "f:speed_of_sound", &speed))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			device->setSpeedOfSound(speed);
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Device_doppler_factor_doc,
			 "The doppler factor of the device.\n"
			 "This factor is a scaling factor for the velocity vectors in "
			 "doppler calculation. So a value bigger than 1 will exaggerate "
			 "the effect as it raises the velocity.");

static PyObject *
Device_get_doppler_factor(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			return Py_BuildValue("f", device->getDopplerFactor());
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Device_set_doppler_factor(Device *self, PyObject* args, void* nothing)
{
	float factor;

	if(!PyArg_Parse(args, "f:doppler_factor", &factor))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			device->setDopplerFactor(factor);
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

PyDoc_STRVAR(M_aud_Device_distance_model_doc,
			 "The distance model of the device.\n\n"
			 ".. seealso:: http://connect.creativelabs.com/openal/Documentation/OpenAL%201.1%20Specification.htm#_Toc199835864");

static PyObject *
Device_get_distance_model(Device *self, void* nothing)
{
	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			return Py_BuildValue("i", int(device->getDistanceModel()));
		}
		else
		{
			PyErr_SetString(AUDError, device_not_3d_error);
			return NULL;
		}
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
		return NULL;
	}
}

static int
Device_set_distance_model(Device *self, PyObject* args, void* nothing)
{
	int model;

	if(!PyArg_Parse(args, "i:distance_model", &model))
		return -1;

	try
	{
		AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device);
		if(device)
		{
			device->setDistanceModel(AUD_DistanceModel(model));
			return 0;
		}
		else
			PyErr_SetString(AUDError, device_not_3d_error);
	}
	catch(AUD_Exception& e)
	{
		PyErr_SetString(AUDError, e.str);
	}

	return -1;
}

static PyGetSetDef Device_properties[] = {
	{(char*)"rate", (getter)Device_get_rate, NULL,
	 M_aud_Device_rate_doc, NULL },
	{(char*)"format", (getter)Device_get_format, NULL,
	 M_aud_Device_format_doc, NULL },
	{(char*)"channels", (getter)Device_get_channels, NULL,
	 M_aud_Device_channels_doc, NULL },
	{(char*)"volume", (getter)Device_get_volume, (setter)Device_set_volume,
	 M_aud_Device_volume_doc, NULL },
	{(char*)"listener_location", (getter)Device_get_listener_location, (setter)Device_set_listener_location,
	 M_aud_Device_listener_location_doc, NULL },
	{(char*)"listener_velocity", (getter)Device_get_listener_velocity, (setter)Device_set_listener_velocity,
	 M_aud_Device_listener_velocity_doc, NULL },
	{(char*)"listener_orientation", (getter)Device_get_listener_orientation, (setter)Device_set_listener_orientation,
	 M_aud_Device_listener_orientation_doc, NULL },
	{(char*)"speed_of_sound", (getter)Device_get_speed_of_sound, (setter)Device_set_speed_of_sound,
	 M_aud_Device_speed_of_sound_doc, NULL },
	{(char*)"doppler_factor", (getter)Device_get_doppler_factor, (setter)Device_set_doppler_factor,
	 M_aud_Device_doppler_factor_doc, NULL },
	{(char*)"distance_model", (getter)Device_get_distance_model, (setter)Device_set_distance_model,
	 M_aud_Device_distance_model_doc, NULL },
	{NULL}  /* Sentinel */
};

PyDoc_STRVAR(M_aud_Device_doc,
			 "Device objects represent an audio output backend like OpenAL or "
			 "SDL, but might also represent a file output or RAM buffer "
			 "output.");

static PyTypeObject DeviceType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	"aud.Device",              /* tp_name */
	sizeof(Device),            /* tp_basicsize */
	0,                         /* tp_itemsize */
	(destructor)Device_dealloc,/* tp_dealloc */
	0,                         /* tp_print */
	0,                         /* tp_getattr */
	0,                         /* tp_setattr */
	0,                         /* tp_reserved */
	0,                         /* tp_repr */
	0,                         /* tp_as_number */
	0,                         /* tp_as_sequence */
	0,                         /* tp_as_mapping */
	0,                         /* tp_hash  */
	0,                         /* tp_call */
	0,                         /* tp_str */
	0,                         /* tp_getattro */
	0,                         /* tp_setattro */
	0,                         /* tp_as_buffer */
	Py_TPFLAGS_DEFAULT,        /* tp_flags */
	M_aud_Device_doc,          /* tp_doc */
	0,		                   /* tp_traverse */
	0,		                   /* tp_clear */
	0,		                   /* tp_richcompare */
	0,		                   /* tp_weaklistoffset */
	0,		                   /* tp_iter */
	0,		                   /* tp_iternext */
	Device_methods,            /* tp_methods */
	0,                         /* tp_members */
	Device_properties,         /* tp_getset */
	0,                         /* tp_base */
	0,                         /* tp_dict */
	0,                         /* tp_descr_get */
	0,                         /* tp_descr_set */
	0,                         /* tp_dictoffset */
	0,                         /* tp_init */
	0,                         /* tp_alloc */
	Device_new,                /* tp_new */
};

PyObject *
Device_empty()
{
	return DeviceType.tp_alloc(&DeviceType, 0);
}

// ====================================================================

PyDoc_STRVAR(M_aud_doc,
			 "This module provides access to the audaspace audio library.");

static struct PyModuleDef audmodule = {
	PyModuleDef_HEAD_INIT,
	"aud",     /* name of module */
	M_aud_doc, /* module documentation */
	-1,        /* size of per-interpreter state of the module,
				  or -1 if the module keeps state in global variables. */
   NULL, NULL, NULL, NULL, NULL
};

PyMODINIT_FUNC
PyInit_aud(void)
{
	PyObject* m;

	if(PyType_Ready(&FactoryType) < 0)
		return NULL;

	if(PyType_Ready(&DeviceType) < 0)
		return NULL;

	if(PyType_Ready(&HandleType) < 0)
		return NULL;

	m = PyModule_Create(&audmodule);
	if(m == NULL)
		return NULL;

	Py_INCREF(&FactoryType);
	PyModule_AddObject(m, "Factory", (PyObject*)&FactoryType);

	Py_INCREF(&DeviceType);
	PyModule_AddObject(m, "Device", (PyObject*)&DeviceType);

	Py_INCREF(&HandleType);
	PyModule_AddObject(m, "Handle", (PyObject*)&HandleType);

	AUDError = PyErr_NewException("aud.error", NULL, NULL);
	Py_INCREF(AUDError);
	PyModule_AddObject(m, "error", AUDError);

	// device constants
	PY_MODULE_ADD_CONSTANT(m, AUD_DEVICE_NULL);
	PY_MODULE_ADD_CONSTANT(m, AUD_DEVICE_OPENAL);
	PY_MODULE_ADD_CONSTANT(m, AUD_DEVICE_SDL);
	PY_MODULE_ADD_CONSTANT(m, AUD_DEVICE_JACK);
	//PY_MODULE_ADD_CONSTANT(m, AUD_DEVICE_READ);
	// format constants
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_FLOAT32);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_FLOAT64);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_INVALID);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_S16);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_S24);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_S32);
	PY_MODULE_ADD_CONSTANT(m, AUD_FORMAT_U8);
	// status constants
	PY_MODULE_ADD_CONSTANT(m, AUD_STATUS_INVALID);
	PY_MODULE_ADD_CONSTANT(m, AUD_STATUS_PAUSED);
	PY_MODULE_ADD_CONSTANT(m, AUD_STATUS_PLAYING);
	// distance model constants
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_EXPONENT);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_EXPONENT_CLAMPED);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_INVERSE);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_INVERSE_CLAMPED);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_LINEAR);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_LINEAR_CLAMPED);
	PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_INVALID);

	return m;
}