Page MenuHome
Differential D2716 Diff 9122 extern/audaspace/bindings/python/PyDevice.cpp

Changeset View

Standalone View

View Options

extern/audaspace/bindings/python/PyDevice.cpp

  • This file was added.
/*******************************************************************************
* Copyright 2009-2016 Jörg Müller
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
#include "PyDevice.h"
#include "PySound.h"
#include "PyHandle.h"
#include "Exception.h"
#include "devices/IDevice.h"
#include "devices/I3DDevice.h"
#include "devices/DeviceManager.h"
#include "devices/IDeviceFactory.h"
#include <structmember.h>
using namespace aud;
extern PyObject* AUDError;
static const char* device_not_3d_error = "Device is not a 3D device!";
// ====================================================================
static void
Device_dealloc(Device* self)
{
if(self->device)
delete reinterpret_cast<std::shared_ptr<IDevice>*>(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", nullptr};
const char* device = nullptr;
double rate = RATE_48000;
int channels = CHANNELS_STEREO;
int format = FORMAT_FLOAT32;
int buffersize = AUD_DEFAULT_BUFFER_SIZE;
const char* name = "";
if(!PyArg_ParseTupleAndKeywords(args, kwds, "|sdiiis:Device", const_cast<char**>(kwlist),
&device, &rate, &channels, &format, &buffersize, &name))
return nullptr;
if(buffersize < 128)
{
PyErr_SetString(PyExc_ValueError, "buffer_size must be at least 128!");
return nullptr;
}
self = (Device*)type->tp_alloc(type, 0);
if(self != nullptr)
{
DeviceSpecs specs;
specs.channels = (Channels)channels;
specs.format = (SampleFormat)format;
specs.rate = (SampleRate)rate;
self->device = nullptr;
try
{
if(!device)
{
auto dev = DeviceManager::getDevice();
if(!dev)
{
DeviceManager::openDefaultDevice();
dev = DeviceManager::getDevice();
}
self->device = new std::shared_ptr<IDevice>(dev);
}
else
{
std::shared_ptr<IDeviceFactory> factory;
if(!*device)
factory = DeviceManager::getDefaultDeviceFactory();
else
factory = DeviceManager::getDeviceFactory(device);
if(factory)
{
factory->setName(name);
factory->setSpecs(specs);
factory->setBufferSize(buffersize);
self->device = new std::shared_ptr<IDevice>(factory->openDevice());
}
}
}
catch(Exception& e)
{
Py_DECREF(self);
PyErr_SetString(AUDError, e.what());
return nullptr;
}
if(!self->device)
{
Py_DECREF(self);
PyErr_SetString(AUDError, "Unsupported device type!");
return nullptr;
}
}
return (PyObject *)self;
}
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
{
(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->lock();
Py_RETURN_NONE;
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
PyDoc_STRVAR(M_aud_Device_play_doc,
"play(sound, keep=False)\n\n"
"Plays a sound.\n\n"
":arg sound: The sound to play.\n"
":type sound: :class:`Sound`\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 = nullptr;
bool keep = false;
static const char* kwlist[] = {"sound", "keep", nullptr};
if(!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:play", const_cast<char**>(kwlist), &object, &keepo))
return nullptr;
Sound* sound = checkSound(object);
if(!sound)
return nullptr;
if(keepo != nullptr)
{
if(!PyBool_Check(keepo))
{
PyErr_SetString(PyExc_TypeError, "keep is not a boolean!");
return nullptr;
}
keep = keepo == Py_True;
}
Handle* handle;
handle = (Handle*)Handle_empty();
if(handle != nullptr)
{
try
{
handle->handle = new std::shared_ptr<IHandle>((*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->play(*reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound), keep));
}
catch(Exception& e)
{
Py_DECREF(handle);
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
return (PyObject *)handle;
}
PyDoc_STRVAR(M_aud_Device_stopAll_doc,
"stopAll()\n\n"
"Stops all playing and paused sounds.");
static PyObject *
Device_stopAll(Device* self)
{
try
{
(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->stopAll();
Py_RETURN_NONE;
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->unlock();
Py_RETURN_NONE;
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
static PyMethodDef Device_methods[] = {
{"lock", (PyCFunction)Device_lock, METH_NOARGS,
M_aud_Device_lock_doc
},
{"play", (PyCFunction)Device_play, METH_VARARGS | METH_KEYWORDS,
M_aud_Device_play_doc
},
{"stopAll", (PyCFunction)Device_stopAll, METH_NOARGS,
M_aud_Device_stopAll_doc
},
{"unlock", (PyCFunction)Device_unlock, METH_NOARGS,
M_aud_Device_unlock_doc
},
{nullptr} /* Sentinel */
};
PyDoc_STRVAR(M_aud_Device_channels_doc,
"The channel count of the device.");
static PyObject *
Device_get_channels(Device* self, void* nothing)
{
try
{
DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("i", specs.channels);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("i", int(device->getDistanceModel()));
}
else
{
PyErr_SetString(AUDError, device_not_3d_error);
return nullptr;
}
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
device->setDistanceModel(DistanceModel(model));
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("f", device->getDopplerFactor());
}
else
{
PyErr_SetString(AUDError, device_not_3d_error);
return nullptr;
}
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
device->setDopplerFactor(factor);
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
PyDoc_STRVAR(M_aud_Device_format_doc,
"The native sample format of the device.");
static PyObject *
Device_get_format(Device* self, void* nothing)
{
try
{
DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("i", specs.format);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
Vector3 v = device->getListenerLocation();
return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
}
else
{
PyErr_SetString(AUDError, device_not_3d_error);
}
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return nullptr;
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
Vector3 location(x, y, z);
device->setListenerLocation(location);
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
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(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return nullptr;
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
Quaternion orientation(w, x, y, z);
device->setListenerOrientation(orientation);
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
Vector3 v = device->getListenerVelocity();
return Py_BuildValue("(fff)", v.x(), v.y(), v.z());
}
else
{
PyErr_SetString(AUDError, device_not_3d_error);
}
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return nullptr;
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
Vector3 velocity(x, y, z);
device->setListenerVelocity(velocity);
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
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
{
DeviceSpecs specs = (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getSpecs();
return Py_BuildValue("d", specs.rate);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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.3 m/s.");
static PyObject *
Device_get_speed_of_sound(Device* self, void* nothing)
{
try
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
return Py_BuildValue("f", device->getSpeedOfSound());
}
else
{
PyErr_SetString(AUDError, device_not_3d_error);
return nullptr;
}
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
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
{
I3DDevice* device = dynamic_cast<I3DDevice*>(reinterpret_cast<std::shared_ptr<IDevice>*>(self->device)->get());
if(device)
{
device->setSpeedOfSound(speed);
return 0;
}
else
PyErr_SetString(AUDError, device_not_3d_error);
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
}
return -1;
}
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", (*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->getVolume());
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return nullptr;
}
}
static int
Device_set_volume(Device* self, PyObject* args, void* nothing)
{
float volume;
if(!PyArg_Parse(args, "f:volume", &volume))
return -1;
try
{
(*reinterpret_cast<std::shared_ptr<IDevice>*>(self->device))->setVolume(volume);
return 0;
}
catch(Exception& e)
{
PyErr_SetString(AUDError, e.what());
return -1;
}
}
static PyGetSetDef Device_properties[] = {
{(char*)"channels", (getter)Device_get_channels, nullptr,
M_aud_Device_channels_doc, nullptr },
{(char*)"distance_model", (getter)Device_get_distance_model, (setter)Device_set_distance_model,
M_aud_Device_distance_model_doc, nullptr },
{(char*)"doppler_factor", (getter)Device_get_doppler_factor, (setter)Device_set_doppler_factor,
M_aud_Device_doppler_factor_doc, nullptr },
{(char*)"format", (getter)Device_get_format, nullptr,
M_aud_Device_format_doc, nullptr },
{(char*)"listener_location", (getter)Device_get_listener_location, (setter)Device_set_listener_location,
M_aud_Device_listener_location_doc, nullptr },
{(char*)"listener_orientation", (getter)Device_get_listener_orientation, (setter)Device_set_listener_orientation,
M_aud_Device_listener_orientation_doc, nullptr },
{(char*)"listener_velocity", (getter)Device_get_listener_velocity, (setter)Device_set_listener_velocity,
M_aud_Device_listener_velocity_doc, nullptr },
{(char*)"rate", (getter)Device_get_rate, nullptr,
M_aud_Device_rate_doc, nullptr },
{(char*)"speed_of_sound", (getter)Device_get_speed_of_sound, (setter)Device_set_speed_of_sound,
M_aud_Device_speed_of_sound_doc, nullptr },
{(char*)"volume", (getter)Device_get_volume, (setter)Device_set_volume,
M_aud_Device_volume_doc, nullptr },
{nullptr} /* 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(nullptr, 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 */
};
AUD_API PyObject* Device_empty()
{
return DeviceType.tp_alloc(&DeviceType, 0);
}
AUD_API Device* checkDevice(PyObject* device)
{
if(!PyObject_TypeCheck(device, &DeviceType))
{
PyErr_SetString(PyExc_TypeError, "Object is not of type Device!");
return nullptr;
}
return (Device*)device;
}
bool initializeDevice()
{
return PyType_Ready(&DeviceType) >= 0;
}
void addDeviceToModule(PyObject* module)
{
Py_INCREF(&DeviceType);
PyModule_AddObject(module, "Device", (PyObject *)&DeviceType);
}