Differential D2716 Diff 9122 extern/audaspace/bindings/python/PySequenceEntry.cpp

Changeset View

Standalone View

extern/audaspace/bindings/python/PySequenceEntry.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 "PySequenceEntry.h"

				#include "PySound.h"

				#include "Exception.h"
				#include "sequence/AnimateableProperty.h"
				#include "sequence/SequenceEntry.h"

				#include <structmember.h>
				#include <vector>

				using aud::Exception;
				using aud::AnimateableProperty;
				using aud::AnimateablePropertyType;
				using aud::ISound;

				extern PyObject* AUDError;

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

				static void
				SequenceEntry_dealloc(SequenceEntry* self)
				{
				if(self->entry)
				delete reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				Py_TYPE(self)->tp_free((PyObject *)self);
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_move_doc,
				"move()\n\n"
				"Moves the entry.\n\n"
				":arg begin: The new start time.\n"
				":type begin: float\n"
				":arg end: The new end time or a negative value if unknown.\n"
				":type end: float\n"
				":arg skip: How many seconds to skip at the beginning.\n"
				":type skip: float\n");

				static PyObject *
				SequenceEntry_move(SequenceEntry* self, PyObject* args)
				{
				float begin, end, skip;

				if(!PyArg_ParseTuple(args, "fff:move", &begin, &end, &skip))
				return nullptr;

				try
				{
				(reinterpret_cast<std::shared_ptr<aud::SequenceEntry>>(self->entry))->move(begin, end, skip);
				Py_RETURN_NONE;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_setAnimationData_doc,
				"setAnimationData()\n\n"
				"Writes animation data to a sequenced entry.\n\n"
				":arg type: The type of animation data.\n"
				":type type: int\n"
				":arg frame: The frame this data is for.\n"
				":type frame: int\n"
				":arg data: The data to write.\n"
				":type data: sequence of float\n"
				":arg animated: Whether the attribute is animated.\n"
				":type animated: bool");

				static PyObject *
				SequenceEntry_setAnimationData(SequenceEntry* self, PyObject* args)
				{
				int type, frame;
				PyObject* py_data;
				Py_ssize_t py_data_len;
				PyObject* animatedo;
				bool animated;

				if(!PyArg_ParseTuple(args, "iiOO:setAnimationData", &type, &frame, &py_data, &animatedo))
				return nullptr;

				if(!PySequence_Check(py_data))
				{
				PyErr_SetString(PyExc_TypeError, "Parameter is not a sequence!");
				return nullptr;
				}

				py_data_len= PySequence_Size(py_data);

				std::vector<float> data;
				data.resize(py_data_len);

				PyObject* py_value;
				float value;

				for(Py_ssize_t i = 0; i < py_data_len; i++)
				{
				py_value = PySequence_GetItem(py_data, i);
				value= (float)PyFloat_AsDouble(py_value);
				Py_DECREF(py_value);

				if(value == -1.0f && PyErr_Occurred()) {
				return nullptr;
				}

				data.push_back(value);
				}

				if(!PyBool_Check(animatedo))
				{
				PyErr_SetString(PyExc_TypeError, "animated is not a boolean!");
				return nullptr;
				}

				animated = animatedo == Py_True;

				try
				{
				AnimateableProperty* prop = (reinterpret_cast<std::shared_ptr<aud::SequenceEntry>>(self->entry))->getAnimProperty(static_cast<AnimateablePropertyType>(type));

				if(prop->getCount() != py_data_len)
				{
				PyErr_SetString(PyExc_ValueError, "the amount of floats doesn't fit the animated property");
				return nullptr;
				}

				if(animated)
				{
				if(frame >= 0)
				prop->write(&data[0], frame, 1);
				}
				else
				{
				prop->write(&data[0]);
				}
				Py_RETURN_NONE;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static PyMethodDef SequenceEntry_methods[] = {
				{"move", (PyCFunction)SequenceEntry_move, METH_VARARGS,
				M_aud_SequenceEntry_move_doc
				},
				{"setAnimationData", (PyCFunction)SequenceEntry_setAnimationData, METH_VARARGS,
				M_aud_SequenceEntry_setAnimationData_doc
				},
				{nullptr} /* Sentinel */
				};

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

				static PyObject *
				SequenceEntry_get_attenuation(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getAttenuation());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_attenuation(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float factor;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setAttenuation(factor);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_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 *
				SequenceEntry_get_cone_angle_inner(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getConeAngleInner());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_cone_angle_inner(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float angle;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setConeAngleInner(angle);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

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

				static PyObject *
				SequenceEntry_get_cone_angle_outer(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getConeAngleOuter());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_cone_angle_outer(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float angle;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setConeAngleOuter(angle);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

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

				static PyObject *
				SequenceEntry_get_cone_volume_outer(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getConeVolumeOuter());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_cone_volume_outer(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float volume;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setConeVolumeOuter(volume);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_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 *
				SequenceEntry_get_distance_maximum(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getDistanceMaximum());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_distance_maximum(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float distance;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setDistanceMaximum(distance);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_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 *
				SequenceEntry_get_distance_reference(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getDistanceReference());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_distance_reference(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float distance;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setDistanceReference(distance);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_muted_doc,
				"Whether the entry is muted.\n");

				static PyObject *
				SequenceEntry_get_muted(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return PyBool_FromLong((long)(*entry)->isMuted());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

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

				bool muted = args == Py_True;

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->mute(muted);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

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

				static PyObject *
				SequenceEntry_get_relative(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return PyBool_FromLong((long)(*entry)->isRelative());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return nullptr;
				}

				static int
				SequenceEntry_set_relative(SequenceEntry* 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);

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setRelative(relative);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				PyDoc_STRVAR(M_aud_SequenceEntry_sound_doc,
				"The sound the entry is representing and will be played in the sequence.");

				static PyObject *
				SequenceEntry_get_sound(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				Sound* object = (Sound*) Sound_empty();
				if(object)
				{
				object->sound = new std::shared_ptr<ISound>((*entry)->getSound());
				return (PyObject *) object;
				}
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return nullptr;
				}

				static int
				SequenceEntry_set_sound(SequenceEntry* self, PyObject* args, void* nothing)
				{
				Sound* sound = checkSound(args);

				if(!sound)
				return -1;

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(entry)->setSound(reinterpret_cast<std::shared_ptr<ISound>*>(sound->sound));
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

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

				static PyObject *
				SequenceEntry_get_volume_maximum(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getVolumeMaximum());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_volume_maximum(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float volume;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setVolumeMaximum(volume);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

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

				static PyObject *
				SequenceEntry_get_volume_minimum(SequenceEntry* self, void* nothing)
				{
				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				return Py_BuildValue("f", (*entry)->getVolumeMinimum());
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				return nullptr;
				}
				}

				static int
				SequenceEntry_set_volume_minimum(SequenceEntry* self, PyObject* args, void* nothing)
				{
				float volume;

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

				try
				{
				std::shared_ptr<aud::SequenceEntry>* entry = reinterpret_cast<std::shared_ptr<aud::SequenceEntry>*>(self->entry);
				(*entry)->setVolumeMinimum(volume);
				return 0;
				}
				catch(Exception& e)
				{
				PyErr_SetString(AUDError, e.what());
				}

				return -1;
				}

				static PyGetSetDef SequenceEntry_properties[] = {
				{(char*)"attenuation", (getter)SequenceEntry_get_attenuation, (setter)SequenceEntry_set_attenuation,
				M_aud_SequenceEntry_attenuation_doc, nullptr },
				{(char*)"cone_angle_inner", (getter)SequenceEntry_get_cone_angle_inner, (setter)SequenceEntry_set_cone_angle_inner,
				M_aud_SequenceEntry_cone_angle_inner_doc, nullptr },
				{(char*)"cone_angle_outer", (getter)SequenceEntry_get_cone_angle_outer, (setter)SequenceEntry_set_cone_angle_outer,
				M_aud_SequenceEntry_cone_angle_outer_doc, nullptr },
				{(char*)"cone_volume_outer", (getter)SequenceEntry_get_cone_volume_outer, (setter)SequenceEntry_set_cone_volume_outer,
				M_aud_SequenceEntry_cone_volume_outer_doc, nullptr },
				{(char*)"distance_maximum", (getter)SequenceEntry_get_distance_maximum, (setter)SequenceEntry_set_distance_maximum,
				M_aud_SequenceEntry_distance_maximum_doc, nullptr },
				{(char*)"distance_reference", (getter)SequenceEntry_get_distance_reference, (setter)SequenceEntry_set_distance_reference,
				M_aud_SequenceEntry_distance_reference_doc, nullptr },
				{(char*)"muted", (getter)SequenceEntry_get_muted, (setter)SequenceEntry_set_muted,
				M_aud_SequenceEntry_muted_doc, nullptr },
				{(char*)"relative", (getter)SequenceEntry_get_relative, (setter)SequenceEntry_set_relative,
				M_aud_SequenceEntry_relative_doc, nullptr },
				{(char*)"sound", (getter)SequenceEntry_get_sound, (setter)SequenceEntry_set_sound,
				M_aud_SequenceEntry_sound_doc, nullptr },
				{(char*)"volume_maximum", (getter)SequenceEntry_get_volume_maximum, (setter)SequenceEntry_set_volume_maximum,
				M_aud_SequenceEntry_volume_maximum_doc, nullptr },
				{(char*)"volume_minimum", (getter)SequenceEntry_get_volume_minimum, (setter)SequenceEntry_set_volume_minimum,
				M_aud_SequenceEntry_volume_minimum_doc, nullptr },
				{nullptr} /* Sentinel */
				};

				PyDoc_STRVAR(M_aud_SequenceEntry_doc,
				"SequenceEntry objects represent an entry of a sequenced sound.");

				static PyTypeObject SequenceEntryType = {
				PyVarObject_HEAD_INIT(nullptr, 0)
				"aud.SequenceEntry", /* tp_name */
				sizeof(SequenceEntry), /* tp_basicsize */
				0, /* tp_itemsize */
				(destructor)SequenceEntry_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_SequenceEntry_doc, /* tp_doc */
				0, /* tp_traverse */
				0, /* tp_clear */
				0, /* tp_richcompare */
				0, /* tp_weaklistoffset */
				0, /* tp_iter */
				0, /* tp_iternext */
				SequenceEntry_methods, /* tp_methods */
				0, /* tp_members */
				SequenceEntry_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 */
				};

				AUD_API PyObject* SequenceEntry_empty()
				{
				return SequenceEntryType.tp_alloc(&SequenceEntryType, 0);
				}


				AUD_API SequenceEntry* checkSequenceEntry(PyObject* entry)
				{
				if(!PyObject_TypeCheck(entry, &SequenceEntryType))
				{
				PyErr_SetString(PyExc_TypeError, "Object is not of type SequenceEntry!");
				return nullptr;
				}

				return (SequenceEntry*)entry;
				}


				bool initializeSequenceEntry()
				{
				return PyType_Ready(&SequenceEntryType) >= 0;
				}


				void addSequenceEntryToModule(PyObject* module)
				{
				Py_INCREF(&SequenceEntryType);
				PyModule_AddObject(module, "SequenceEntry", (PyObject *)&SequenceEntryType);
				}