diff options
Diffstat (limited to 'extern/audaspace/bindings/python/PySequenceEntry.cpp')
| -rw-r--r-- | extern/audaspace/bindings/python/PySequenceEntry.cpp | 740 |
1 files changed, 0 insertions, 740 deletions
diff --git a/extern/audaspace/bindings/python/PySequenceEntry.cpp b/extern/audaspace/bindings/python/PySequenceEntry.cpp deleted file mode 100644 index e6a034ed880..00000000000 --- a/extern/audaspace/bindings/python/PySequenceEntry.cpp +++ /dev/null @@ -1,740 +0,0 @@ -/******************************************************************************* - * 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); -} |