From 8aa4b3dde9160d045957ec6184fc42b0310b7efd Mon Sep 17 00:00:00 2001 From: Olivier Belanger Date: Tue, 29 Nov 2022 19:23:40 -0500 Subject: [PATCH] Added get() method to *_base objects. Added int() and float() to PyoObject and *_base objects. --- ChangeLog | 5 + TODO.md | 2 + externals/externalmodule-template.c | 8 +- include/pyomodule.h | 7 + pyo/lib/_core.py | 12 +- pyo/lib/filters.py | 6 +- pyo/lib/fourier.py | 18 +- pyo/lib/midi.py | 6 +- pyo/lib/mmlmusic.py | 6 +- pyo/lib/opensndctrl.py | 10 +- pyo/lib/triggers.py | 18 +- pyo/lib/utils.py | 6 +- src/engine/dummymodule.c | 20 ++- src/engine/mixmodule.c | 10 +- src/objects/analysismodule.c | 80 ++++++--- src/objects/arithmeticmodule.c | 170 ++++++++++++------ src/objects/bandsplitmodule.c | 30 +++- src/objects/chorusmodule.c | 10 +- src/objects/compressmodule.c | 40 +++-- src/objects/convolvemodule.c | 50 ++++-- src/objects/delaymodule.c | 60 +++++-- src/objects/distomodule.c | 70 +++++--- src/objects/exprmodule.c | 10 +- src/objects/fadermodule.c | 40 +++-- src/objects/fftmodule.c | 91 +++++++--- src/objects/filtremodule.c | 230 +++++++++++++++++------- src/objects/freeverbmodule.c | 10 +- src/objects/granulatormodule.c | 60 +++++-- src/objects/harmonizermodule.c | 10 +- src/objects/hilbertmodule.c | 10 +- src/objects/hrtfmodule.c | 20 ++- src/objects/inputmodule.c | 10 +- src/objects/lfomodule.c | 10 +- src/objects/matrixprocessmodule.c | 10 +- src/objects/metromodule.c | 142 ++++++++++----- src/objects/midimodule.c | 88 ++++++--- src/objects/mmlmodule.c | 80 ++++++--- src/objects/noisemodule.c | 30 +++- src/objects/oscbankmodule.c | 10 +- src/objects/oscilmodule.c | 270 +++++++++++++++++++--------- src/objects/oscmodule.c | 22 ++- src/objects/panmodule.c | 61 +++++-- src/objects/phasevocmodule.c | 20 ++- src/objects/randommodule.c | 100 +++++++---- src/objects/recordmodule.c | 22 ++- src/objects/selectmodule.c | 22 ++- src/objects/sfplayermodule.c | 32 ++-- src/objects/sigmodule.c | 28 ++- src/objects/tablemodule.c | 20 ++- src/objects/trigmodule.c | 162 ++++++++++++----- src/objects/utilsmodule.c | 160 ++++++++++++----- src/objects/wgverbmodule.c | 22 ++- tests/pytests/test_baseObjects.py | 51 ++++++ tests/pytests/test_functions.py | 2 +- 54 files changed, 1752 insertions(+), 747 deletions(-) diff --git a/ChangeLog b/ChangeLog index a6fe8c4a..01dc9d9b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2022-11-29 belangeo + + * Added get() method to *_base objects. + * Added int() and float() to PyoObject and *_base objects. + 2022-10-21 belangeo * UI: Improved handling of system's dark mode. diff --git a/TODO.md b/TODO.md index 8e59bdfc..c1d28235 100644 --- a/TODO.md +++ b/TODO.md @@ -6,6 +6,8 @@ Roadmap 1.0.5 - python 3.10 and 3.11 wheels +- doc: Remove obsolete get_templates.py file + Roadmap 1.0.6 ------------- diff --git a/externals/externalmodule-template.c b/externals/externalmodule-template.c index 2472a32a..e3640bd3 100644 --- a/externals/externalmodule-template.c +++ b/externals/externalmodule-template.c @@ -322,6 +322,7 @@ Object dependant initializations can be added before PLAY, OUT and STOP macros. **********************************************************************/ static PyObject * Gain_getServer(Gain *self) { GET_SERVER }; static PyObject * Gain_getStream(Gain *self) { GET_STREAM }; +static PyObject * Gain_get(Gain *self) { GET_F }; static PyObject * Gain_setMul(Gain *self, PyObject *arg) { SET_MUL }; static PyObject * Gain_setAdd(Gain *self, PyObject *arg) { SET_ADD }; static PyObject * Gain_setSub(Gain *self, PyObject *arg) { SET_SUB }; @@ -339,6 +340,8 @@ static PyObject * Gain_sub(Gain *self, PyObject *arg) { SUB }; static PyObject * Gain_inplace_sub(Gain *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Gain_div(Gain *self, PyObject *arg) { DIV }; static PyObject * Gain_inplace_div(Gain *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Gain_int(Gain *self) { GET_I }; +static PyObject * Gain_float(Gain *self) { GET_F }; /********************************************************************** Setter function for attributes. Here, we need to check if the value is @@ -403,6 +406,7 @@ static PyMethodDef Gain_methods[] = { {"getServer", (PyCFunction)Gain_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Gain_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Gain_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Gain_play, METH_VARARGS | METH_KEYWORDS, "Starts dbuting without sending sound to soundcard."}, {"out", (PyCFunction)Gain_out, METH_VARARGS | METH_KEYWORDS, "Starts dbuting and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Gain_stop, METH_VARARGS | METH_KEYWORDS, "Stops dbuting."}, @@ -438,9 +442,9 @@ static PyNumberMethods Gain_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ + (unaryfunc)Gain_int, /*nb_int*/ 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Gain_float, /*nb_float*/ (binaryfunc)Gain_inplace_add, /*inplace_add*/ (binaryfunc)Gain_inplace_sub, /*inplace_subtract*/ (binaryfunc)Gain_inplace_multiply, /*inplace_multiply*/ diff --git a/include/pyomodule.h b/include/pyomodule.h index d127a873..d5fad4d5 100644 --- a/include/pyomodule.h +++ b/include/pyomodule.h @@ -1688,6 +1688,13 @@ extern PyTypeObject MMLZStreamType; Py_INCREF(self->pv_stream); \ return (PyObject *)self->pv_stream; +// *_base object's get() method. +#define GET_F \ + return PyFloat_FromDouble(self->data[self->bufsize - 1]); + +#define GET_I \ + return PyLong_FromDouble(self->data[self->bufsize - 1]); + #define SET_MUL \ if (arg == NULL) { \ Py_RETURN_NONE; \ diff --git a/pyo/lib/_core.py b/pyo/lib/_core.py index b2cc6bd8..41fdf7ad 100644 --- a/pyo/lib/_core.py +++ b/pyo/lib/_core.py @@ -1375,6 +1375,12 @@ class PyoObject(PyoObjectBase): else: return Compare(self, comp=comp, mode=mode) + def __float__(self): + return float(self._base_objs[0]) + + def __int__(self): + return int(self._base_objs[0]) + def isPlaying(self, all=False): """ Returns True if the object is currently playing, otherwise, returns False. @@ -1420,7 +1426,7 @@ class PyoObject(PyoObjectBase): def get(self, all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -1432,10 +1438,10 @@ class PyoObject(PyoObjectBase): :Args: all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's stream + If False, only the vlast alue of the first object's stream will be returned as a float. """ diff --git a/pyo/lib/filters.py b/pyo/lib/filters.py index 3c7610da..bde894ea 100644 --- a/pyo/lib/filters.py +++ b/pyo/lib/filters.py @@ -1657,7 +1657,7 @@ class Hilbert(PyoObject): def get(self, identifier="real", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -1670,8 +1670,8 @@ class Hilbert(PyoObject): Address string parameter identifying audio stream. Defaults to "real". all: boolean, optional - If True, the first value of each object's stream - will be returned as a list. Otherwise, only the value + If True, the last value of each object's stream + will be returned as a list. Otherwise, only the last value of the first object's stream will be returned as a float. Defaults to False. diff --git a/pyo/lib/fourier.py b/pyo/lib/fourier.py index 3e1b3bfd..3c23c810 100644 --- a/pyo/lib/fourier.py +++ b/pyo/lib/fourier.py @@ -144,7 +144,7 @@ class FFT(PyoObject): def get(self, identifier="real", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -157,8 +157,8 @@ class FFT(PyoObject): Address string parameter identifying audio stream. Defaults to "real". all: boolean, optional - If True, the first value of each object's stream - will be returned as a list. Otherwise, only the value + If True, the last value of each object's stream + will be returned as a list. Otherwise, only the last value of the first object's stream will be returned as a float. Defaults to False. @@ -552,7 +552,7 @@ class CarToPol(PyoObject): def get(self, identifier="mag", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -565,8 +565,8 @@ class CarToPol(PyoObject): Address string parameter identifying audio stream. Defaults to "mag". all: boolean, optional - If True, the first value of each object's stream - will be returned as a list. Otherwise, only the value + If True, the last value of each object's stream + will be returned as a list. Otherwise, only the last value of the first object's stream will be returned as a float. Defaults to False. @@ -705,7 +705,7 @@ class PolToCar(PyoObject): def get(self, identifier="real", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -718,8 +718,8 @@ class PolToCar(PyoObject): Address string parameter identifying audio stream. Defaults to "mag". all: boolean, optional - If True, the first value of each object's stream - will be returned as a list. Otherwise, only the value + If True, the last value of each object's stream + will be returned as a list. Otherwise, only the last value of the first object's stream will be returned as a float. Defaults to False. diff --git a/pyo/lib/midi.py b/pyo/lib/midi.py index 1c1bedb8..ac7fc7ed 100644 --- a/pyo/lib/midi.py +++ b/pyo/lib/midi.py @@ -649,7 +649,7 @@ class Notein(PyoObject): def get(self, identifier="pitch", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -662,10 +662,10 @@ class Notein(PyoObject): Address string parameter identifying audio stream. Defaults to "pitch". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - Otherwise, only the value of the first object's + Otherwise, only the last value of the first object's stream will be returned as a float. """ diff --git a/pyo/lib/mmlmusic.py b/pyo/lib/mmlmusic.py index 840c03ef..c6fb30ac 100644 --- a/pyo/lib/mmlmusic.py +++ b/pyo/lib/mmlmusic.py @@ -484,7 +484,7 @@ class MML(PyoObject): def get(self, identifier="amp", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -498,10 +498,10 @@ class MML(PyoObject): Address string parameter identifying audio stream. Defaults to "amp". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's + If False, only the last value of the first object's stream will be returned as a float. """ diff --git a/pyo/lib/opensndctrl.py b/pyo/lib/opensndctrl.py index 46138a86..f5694eb9 100644 --- a/pyo/lib/opensndctrl.py +++ b/pyo/lib/opensndctrl.py @@ -296,7 +296,7 @@ class OscReceive(PyoObject): def get(self, identifier=None, all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -310,8 +310,8 @@ class OscReceive(PyoObject): Defaults to None, useful when `all` is True to retreive all streams values. all: boolean, optional - If True, the first value of each object's stream - will be returned as a list. Otherwise, only the value + If True, the last value of each object's stream + will be returned as a list. Otherwise, only the last value of the first object's stream will be returned as a float. Defaults to False. @@ -810,7 +810,7 @@ class OscListReceive(PyoObject): def get(self, identifier=None, all=False): """ - Return the first list of samples of the current buffer as floats. + Return the list of last sample of the current buffers as floats. Can be used to convert audio stream to usable Python data. @@ -824,7 +824,7 @@ class OscListReceive(PyoObject): Defaults to None, useful when `all` is True to retreive all streams values. all: boolean, optional - If True, the first list of values of each object's stream + If True, the list of last values of each object's stream will be returned as a list of lists. Otherwise, only the the list of the object's identifier will be returned as a list of floats. Defaults to False. diff --git a/pyo/lib/triggers.py b/pyo/lib/triggers.py index 00075ead..6783ba1d 100644 --- a/pyo/lib/triggers.py +++ b/pyo/lib/triggers.py @@ -561,7 +561,7 @@ class Beat(PyoObject): def get(self, identifier="amp", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -574,10 +574,10 @@ class Beat(PyoObject): Address string parameter identifying audio stream. Defaults to "amp". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's + If False, only the last value of the first object's stream will be returned as a float. """ @@ -3751,7 +3751,7 @@ class Euclide(PyoObject): def get(self, identifier="amp", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -3764,10 +3764,10 @@ class Euclide(PyoObject): Address string parameter identifying audio stream. Defaults to "amp". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's + If False, only the last value of the first object's stream will be returned as a float. """ @@ -4015,7 +4015,7 @@ class TrigBurst(PyoObject): def get(self, identifier="amp", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -4028,10 +4028,10 @@ class TrigBurst(PyoObject): Address string parameter identifying audio stream. Defaults to "amp". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's + If False, only the last value of the first object's stream will be returned as a float. """ diff --git a/pyo/lib/utils.py b/pyo/lib/utils.py index a7bad1ea..a99e0e6c 100644 --- a/pyo/lib/utils.py +++ b/pyo/lib/utils.py @@ -1198,7 +1198,7 @@ class NoteinRead(PyoObject): def get(self, identifier="pitch", all=False): """ - Return the first sample of the current buffer as a float. + Return the last sample of the current buffer as a float. Can be used to convert audio stream to usable Python data. @@ -1211,10 +1211,10 @@ class NoteinRead(PyoObject): Address string parameter identifying audio stream. Defaults to "pitch". all: boolean, optional - If True, the first value of each object's stream + If True, the last value of each object's stream will be returned as a list. - If False, only the value of the first object's stream + If False, only the last value of the first object's stream will be returned as a float. """ diff --git a/src/engine/dummymodule.c b/src/engine/dummymodule.c index 8dbfe046..22e43bc3 100644 --- a/src/engine/dummymodule.c +++ b/src/engine/dummymodule.c @@ -192,6 +192,7 @@ Dummy_setInput(Dummy *self, PyObject *arg) static PyObject * Dummy_getServer(Dummy* self) { GET_SERVER }; static PyObject * Dummy_getStream(Dummy* self) { GET_STREAM }; +static PyObject * Dummy_get(Dummy *self) { GET_F }; static PyObject * Dummy_setMul(Dummy *self, PyObject *arg) { SET_MUL }; static PyObject * Dummy_setAdd(Dummy *self, PyObject *arg) { SET_ADD }; static PyObject * Dummy_setSub(Dummy *self, PyObject *arg) { SET_SUB }; @@ -209,6 +210,8 @@ static PyObject * Dummy_sub(Dummy *self, PyObject *arg) { SUB }; static PyObject * Dummy_inplace_sub(Dummy *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Dummy_div(Dummy *self, PyObject *arg) { DIV }; static PyObject * Dummy_inplace_div(Dummy *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Dummy_int(Dummy *self) { GET_I }; +static PyObject * Dummy_float(Dummy *self) { GET_F }; static PyMemberDef Dummy_members[] = { @@ -224,6 +227,7 @@ static PyMethodDef Dummy_methods[] = { {"getServer", (PyCFunction)Dummy_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Dummy_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Dummy_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Dummy_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Dummy_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Dummy_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -254,9 +258,9 @@ static PyNumberMethods Dummy_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Dummy_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Dummy_float, /*nb_float*/ (binaryfunc)Dummy_inplace_add, /*inplace_add*/ (binaryfunc)Dummy_inplace_sub, /*inplace_subtract*/ (binaryfunc)Dummy_inplace_multiply, /*inplace_multiply*/ @@ -453,6 +457,7 @@ TriggerDummy_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * TriggerDummy_getServer(TriggerDummy* self) { GET_SERVER }; static PyObject * TriggerDummy_getStream(TriggerDummy* self) { GET_STREAM }; +static PyObject * TriggerDummy_get(TriggerDummy *self) { GET_F }; static PyObject * TriggerDummy_setMul(TriggerDummy *self, PyObject *arg) { SET_MUL }; static PyObject * TriggerDummy_setAdd(TriggerDummy *self, PyObject *arg) { SET_ADD }; static PyObject * TriggerDummy_setSub(TriggerDummy *self, PyObject *arg) { SET_SUB }; @@ -469,6 +474,8 @@ static PyObject * TriggerDummy_sub(TriggerDummy *self, PyObject *arg) { SUB }; static PyObject * TriggerDummy_inplace_sub(TriggerDummy *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TriggerDummy_div(TriggerDummy *self, PyObject *arg) { DIV }; static PyObject * TriggerDummy_inplace_div(TriggerDummy *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TriggerDummy_int(TriggerDummy *self) { GET_I }; +static PyObject * TriggerDummy_float(TriggerDummy *self) { GET_F }; static PyMemberDef TriggerDummy_members[] = { @@ -483,6 +490,7 @@ static PyMethodDef TriggerDummy_methods[] = { {"getServer", (PyCFunction)TriggerDummy_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TriggerDummy_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TriggerDummy_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TriggerDummy_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)TriggerDummy_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)TriggerDummy_setMul, METH_O, "Sets oscillator mul factor."}, @@ -509,9 +517,9 @@ static PyNumberMethods TriggerDummy_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TriggerDummy_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TriggerDummy_float, /*nb_float*/ (binaryfunc)TriggerDummy_inplace_add, /*inplace_add*/ (binaryfunc)TriggerDummy_inplace_sub, /*inplace_subtract*/ (binaryfunc)TriggerDummy_inplace_multiply, /*inplace_multiply*/ diff --git a/src/engine/mixmodule.c b/src/engine/mixmodule.c index 9c39b270..4f14ed27 100644 --- a/src/engine/mixmodule.c +++ b/src/engine/mixmodule.c @@ -187,6 +187,7 @@ Mix_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Mix_getServer(Mix* self) { GET_SERVER }; static PyObject * Mix_getStream(Mix* self) { GET_STREAM }; +static PyObject * Mix_get(Mix *self) { GET_F }; static PyObject * Mix_setMul(Mix *self, PyObject *arg) { SET_MUL }; static PyObject * Mix_setAdd(Mix *self, PyObject *arg) { SET_ADD }; static PyObject * Mix_setSub(Mix *self, PyObject *arg) { SET_SUB }; @@ -204,6 +205,8 @@ static PyObject * Mix_sub(Mix *self, PyObject *arg) { SUB }; static PyObject * Mix_inplace_sub(Mix *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Mix_div(Mix *self, PyObject *arg) { DIV }; static PyObject * Mix_inplace_div(Mix *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Mix_int(Mix *self) { GET_I }; +static PyObject * Mix_float(Mix *self) { GET_F }; static PyMemberDef Mix_members[] = { @@ -219,6 +222,7 @@ static PyMethodDef Mix_methods[] = { {"getServer", (PyCFunction)Mix_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Mix_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Mix_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Mix_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Mix_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Mix_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -247,9 +251,9 @@ static PyNumberMethods Mix_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Mix_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Mix_float, /*nb_float*/ (binaryfunc)Mix_inplace_add, /*inplace_add*/ (binaryfunc)Mix_inplace_sub, /*inplace_subtract*/ (binaryfunc)Mix_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/analysismodule.c b/src/objects/analysismodule.c index e9a9678f..7567ce99 100644 --- a/src/objects/analysismodule.c +++ b/src/objects/analysismodule.c @@ -257,6 +257,7 @@ Follower_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Follower_getServer(Follower* self) { GET_SERVER }; static PyObject * Follower_getStream(Follower* self) { GET_STREAM }; +static PyObject * Follower_get(Follower *self) { GET_F }; static PyObject * Follower_setMul(Follower *self, PyObject *arg) { SET_MUL }; static PyObject * Follower_setAdd(Follower *self, PyObject *arg) { SET_ADD }; static PyObject * Follower_setSub(Follower *self, PyObject *arg) { SET_SUB }; @@ -273,6 +274,8 @@ static PyObject * Follower_sub(Follower *self, PyObject *arg) { SUB }; static PyObject * Follower_inplace_sub(Follower *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Follower_div(Follower *self, PyObject *arg) { DIV }; static PyObject * Follower_inplace_div(Follower *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Follower_int(Follower *self) { GET_I }; +static PyObject * Follower_float(Follower *self) { GET_F }; static PyObject * Follower_setFreq(Follower *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -291,6 +294,7 @@ static PyMethodDef Follower_methods[] = { {"getServer", (PyCFunction)Follower_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Follower_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Follower_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Follower_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Follower_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setFreq", (PyCFunction)Follower_setFreq, METH_O, "Sets filter cutoff frequency in cycle per second."}, @@ -319,9 +323,9 @@ static PyNumberMethods Follower_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Follower_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Follower_float, /*nb_float*/ (binaryfunc)Follower_inplace_add, /*inplace_add*/ (binaryfunc)Follower_inplace_sub, /*inplace_subtract*/ (binaryfunc)Follower_inplace_multiply, /*inplace_multiply*/ @@ -753,6 +757,7 @@ Follower2_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Follower2_getServer(Follower2* self) { GET_SERVER }; static PyObject * Follower2_getStream(Follower2* self) { GET_STREAM }; +static PyObject * Follower2_get(Follower2 *self) { GET_F }; static PyObject * Follower2_setMul(Follower2 *self, PyObject *arg) { SET_MUL }; static PyObject * Follower2_setAdd(Follower2 *self, PyObject *arg) { SET_ADD }; static PyObject * Follower2_setSub(Follower2 *self, PyObject *arg) { SET_SUB }; @@ -769,6 +774,8 @@ static PyObject * Follower2_sub(Follower2 *self, PyObject *arg) { SUB }; static PyObject * Follower2_inplace_sub(Follower2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Follower2_div(Follower2 *self, PyObject *arg) { DIV }; static PyObject * Follower2_inplace_div(Follower2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Follower2_int(Follower2 *self) { GET_I }; +static PyObject * Follower2_float(Follower2 *self) { GET_F }; static PyObject * Follower2_setRisetime(Follower2 *self, PyObject *arg) { SET_PARAM(self->risetime, self->risetime_stream, 2); } static PyObject * Follower2_setFalltime(Follower2 *self, PyObject *arg) { SET_PARAM(self->falltime, self->falltime_stream, 3); } @@ -789,6 +796,7 @@ static PyMethodDef Follower2_methods[] = { {"getServer", (PyCFunction)Follower2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Follower2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Follower2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Follower2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Follower2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setRisetime", (PyCFunction)Follower2_setRisetime, METH_O, "Sets filter risetime in second."}, @@ -818,9 +826,9 @@ static PyNumberMethods Follower2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Follower2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Follower2_float, /*nb_float*/ (binaryfunc)Follower2_inplace_add, /*inplace_add*/ (binaryfunc)Follower2_inplace_sub, /*inplace_subtract*/ (binaryfunc)Follower2_inplace_multiply, /*inplace_multiply*/ @@ -1057,6 +1065,7 @@ ZCross_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * ZCross_getServer(ZCross* self) { GET_SERVER }; static PyObject * ZCross_getStream(ZCross* self) { GET_STREAM }; +static PyObject * ZCross_get(ZCross *self) { GET_F }; static PyObject * ZCross_setMul(ZCross *self, PyObject *arg) { SET_MUL }; static PyObject * ZCross_setAdd(ZCross *self, PyObject *arg) { SET_ADD }; static PyObject * ZCross_setSub(ZCross *self, PyObject *arg) { SET_SUB }; @@ -1073,6 +1082,8 @@ static PyObject * ZCross_sub(ZCross *self, PyObject *arg) { SUB }; static PyObject * ZCross_inplace_sub(ZCross *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ZCross_div(ZCross *self, PyObject *arg) { DIV }; static PyObject * ZCross_inplace_div(ZCross *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ZCross_int(ZCross *self) { GET_I }; +static PyObject * ZCross_float(ZCross *self) { GET_F }; static PyObject * ZCross_setThresh(ZCross *self, PyObject *arg) @@ -1101,6 +1112,7 @@ static PyMethodDef ZCross_methods[] = { {"getServer", (PyCFunction)ZCross_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ZCross_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ZCross_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ZCross_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)ZCross_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setThresh", (PyCFunction)ZCross_setThresh, METH_O, "Sets the threshold factor."}, @@ -1129,9 +1141,9 @@ static PyNumberMethods ZCross_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ZCross_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ZCross_float, /*nb_float*/ (binaryfunc)ZCross_inplace_add, /*inplace_add*/ (binaryfunc)ZCross_inplace_sub, /*inplace_subtract*/ (binaryfunc)ZCross_inplace_multiply, /*inplace_multiply*/ @@ -1476,6 +1488,7 @@ Yin_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Yin_getServer(Yin* self) { GET_SERVER }; static PyObject * Yin_getStream(Yin* self) { GET_STREAM }; +static PyObject * Yin_get(Yin *self) { GET_F }; static PyObject * Yin_setMul(Yin *self, PyObject *arg) { SET_MUL }; static PyObject * Yin_setAdd(Yin *self, PyObject *arg) { SET_ADD }; static PyObject * Yin_setSub(Yin *self, PyObject *arg) { SET_SUB }; @@ -1492,6 +1505,8 @@ static PyObject * Yin_sub(Yin *self, PyObject *arg) { SUB }; static PyObject * Yin_inplace_sub(Yin *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Yin_div(Yin *self, PyObject *arg) { DIV }; static PyObject * Yin_inplace_div(Yin *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Yin_int(Yin *self) { GET_I }; +static PyObject * Yin_float(Yin *self) { GET_F }; static PyObject * Yin_setTolerance(Yin *self, PyObject *arg) @@ -1559,6 +1574,7 @@ static PyMethodDef Yin_methods[] = { {"getServer", (PyCFunction)Yin_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Yin_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Yin_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Yin_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Yin_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setTolerance", (PyCFunction)Yin_setTolerance, METH_O, "Sets the tolerance factor."}, @@ -1590,9 +1606,9 @@ static PyNumberMethods Yin_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Yin_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Yin_float, /*nb_float*/ (binaryfunc)Yin_inplace_add, /*inplace_add*/ (binaryfunc)Yin_inplace_sub, /*inplace_subtract*/ (binaryfunc)Yin_inplace_multiply, /*inplace_multiply*/ @@ -1906,6 +1922,7 @@ Centroid_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Centroid_getServer(Centroid* self) { GET_SERVER }; static PyObject * Centroid_getStream(Centroid* self) { GET_STREAM }; +static PyObject * Centroid_get(Centroid *self) { GET_F }; static PyObject * Centroid_setMul(Centroid *self, PyObject *arg) { SET_MUL }; static PyObject * Centroid_setAdd(Centroid *self, PyObject *arg) { SET_ADD }; static PyObject * Centroid_setSub(Centroid *self, PyObject *arg) { SET_SUB }; @@ -1922,6 +1939,8 @@ static PyObject * Centroid_sub(Centroid *self, PyObject *arg) { SUB }; static PyObject * Centroid_inplace_sub(Centroid *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Centroid_div(Centroid *self, PyObject *arg) { DIV }; static PyObject * Centroid_inplace_div(Centroid *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Centroid_int(Centroid *self) { GET_I }; +static PyObject * Centroid_float(Centroid *self) { GET_F }; static PyMemberDef Centroid_members[] = @@ -1938,6 +1957,7 @@ static PyMethodDef Centroid_methods[] = { {"getServer", (PyCFunction)Centroid_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Centroid_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Centroid_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Centroid_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Centroid_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)Centroid_setMul, METH_O, "Sets Centroid mul factor."}, @@ -1965,9 +1985,9 @@ static PyNumberMethods Centroid_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Centroid_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Centroid_float, /*nb_float*/ (binaryfunc)Centroid_inplace_add, /*inplace_add*/ (binaryfunc)Centroid_inplace_sub, /*inplace_subtract*/ (binaryfunc)Centroid_inplace_multiply, /*inplace_multiply*/ @@ -2292,6 +2312,7 @@ AttackDetector_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * AttackDetector_getServer(AttackDetector* self) { GET_SERVER }; static PyObject * AttackDetector_getStream(AttackDetector* self) { GET_STREAM }; +static PyObject * AttackDetector_get(AttackDetector *self) { GET_F }; static PyObject * AttackDetector_setMul(AttackDetector *self, PyObject *arg) { SET_MUL }; static PyObject * AttackDetector_setAdd(AttackDetector *self, PyObject *arg) { SET_ADD }; static PyObject * AttackDetector_setSub(AttackDetector *self, PyObject *arg) { SET_SUB }; @@ -2308,6 +2329,8 @@ static PyObject * AttackDetector_sub(AttackDetector *self, PyObject *arg) { SUB static PyObject * AttackDetector_inplace_sub(AttackDetector *self, PyObject *arg) { INPLACE_SUB }; static PyObject * AttackDetector_div(AttackDetector *self, PyObject *arg) { DIV }; static PyObject * AttackDetector_inplace_div(AttackDetector *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * AttackDetector_int(AttackDetector *self) { GET_I }; +static PyObject * AttackDetector_float(AttackDetector *self) { GET_F }; static PyObject * AttackDetector_setDeltime(AttackDetector *self, PyObject *arg) @@ -2416,6 +2439,7 @@ static PyMethodDef AttackDetector_methods[] = { {"getServer", (PyCFunction)AttackDetector_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)AttackDetector_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)AttackDetector_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)AttackDetector_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)AttackDetector_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setDeltime", (PyCFunction)AttackDetector_setDeltime, METH_O, "Sets the delay time between current and previous analysis."}, @@ -2449,9 +2473,9 @@ static PyNumberMethods AttackDetector_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)AttackDetector_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)AttackDetector_float, /*nb_float*/ (binaryfunc)AttackDetector_inplace_add, /*inplace_add*/ (binaryfunc)AttackDetector_inplace_sub, /*inplace_subtract*/ (binaryfunc)AttackDetector_inplace_multiply, /*inplace_multiply*/ @@ -3009,6 +3033,7 @@ PeakAmp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * PeakAmp_getServer(PeakAmp* self) { GET_SERVER }; static PyObject * PeakAmp_getStream(PeakAmp* self) { GET_STREAM }; +static PyObject * PeakAmp_get(PeakAmp *self) { GET_F }; static PyObject * PeakAmp_setMul(PeakAmp *self, PyObject *arg) { SET_MUL }; static PyObject * PeakAmp_setAdd(PeakAmp *self, PyObject *arg) { SET_ADD }; static PyObject * PeakAmp_setSub(PeakAmp *self, PyObject *arg) { SET_SUB }; @@ -3025,6 +3050,8 @@ static PyObject * PeakAmp_sub(PeakAmp *self, PyObject *arg) { SUB }; static PyObject * PeakAmp_inplace_sub(PeakAmp *self, PyObject *arg) { INPLACE_SUB }; static PyObject * PeakAmp_div(PeakAmp *self, PyObject *arg) { DIV }; static PyObject * PeakAmp_inplace_div(PeakAmp *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * PeakAmp_int(PeakAmp *self) { GET_I }; +static PyObject * PeakAmp_float(PeakAmp *self) { GET_F }; static PyObject * PeakAmp_getValue(PeakAmp *self) @@ -3046,6 +3073,7 @@ static PyMethodDef PeakAmp_methods[] = { {"getServer", (PyCFunction)PeakAmp_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)PeakAmp_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)PeakAmp_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)PeakAmp_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)PeakAmp_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"getValue", (PyCFunction)PeakAmp_getValue, METH_NOARGS, "Returns the current peaking value."}, @@ -3074,9 +3102,9 @@ static PyNumberMethods PeakAmp_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)PeakAmp_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)PeakAmp_float, /*nb_float*/ (binaryfunc)PeakAmp_inplace_add, /*inplace_add*/ (binaryfunc)PeakAmp_inplace_sub, /*inplace_subtract*/ (binaryfunc)PeakAmp_inplace_multiply, /*inplace_multiply*/ @@ -3297,6 +3325,7 @@ RMS_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * RMS_getServer(RMS* self) { GET_SERVER }; static PyObject * RMS_getStream(RMS* self) { GET_STREAM }; +static PyObject * RMS_get(RMS *self) { GET_F }; static PyObject * RMS_setMul(RMS *self, PyObject *arg) { SET_MUL }; static PyObject * RMS_setAdd(RMS *self, PyObject *arg) { SET_ADD }; static PyObject * RMS_setSub(RMS *self, PyObject *arg) { SET_SUB }; @@ -3313,6 +3342,8 @@ static PyObject * RMS_sub(RMS *self, PyObject *arg) { SUB }; static PyObject * RMS_inplace_sub(RMS *self, PyObject *arg) { INPLACE_SUB }; static PyObject * RMS_div(RMS *self, PyObject *arg) { DIV }; static PyObject * RMS_inplace_div(RMS *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * RMS_int(RMS *self) { GET_I }; +static PyObject * RMS_float(RMS *self) { GET_F }; static PyObject * RMS_getValue(RMS *self) @@ -3334,6 +3365,7 @@ static PyMethodDef RMS_methods[] = { {"getServer", (PyCFunction)RMS_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)RMS_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)RMS_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)RMS_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)RMS_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"getValue", (PyCFunction)RMS_getValue, METH_NOARGS, "Returns the current peaking value."}, @@ -3362,9 +3394,9 @@ static PyNumberMethods RMS_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)RMS_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)RMS_float, /*nb_float*/ (binaryfunc)RMS_inplace_add, /*inplace_add*/ (binaryfunc)RMS_inplace_sub, /*inplace_subtract*/ (binaryfunc)RMS_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/arithmeticmodule.c b/src/objects/arithmeticmodule.c index 644d5e55..958e3dee 100644 --- a/src/objects/arithmeticmodule.c +++ b/src/objects/arithmeticmodule.c @@ -197,6 +197,9 @@ static PyObject * M_Sin_sub(M_Sin *self, PyObject *arg) { SUB }; static PyObject * M_Sin_inplace_sub(M_Sin *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Sin_div(M_Sin *self, PyObject *arg) { DIV }; static PyObject * M_Sin_inplace_div(M_Sin *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Sin_int(M_Sin *self) { GET_I }; +static PyObject * M_Sin_float(M_Sin *self) { GET_F }; +static PyObject * M_Sin_get(M_Sin *self) { GET_F }; static PyMemberDef M_Sin_members[] = { @@ -212,6 +215,7 @@ static PyMethodDef M_Sin_methods[] = { {"getServer", (PyCFunction)M_Sin_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Sin_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Sin_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Sin_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Sin_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Sin_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -240,9 +244,9 @@ static PyNumberMethods M_Sin_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Sin_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Sin_float, /*nb_float*/ (binaryfunc)M_Sin_inplace_add, /*inplace_add*/ (binaryfunc)M_Sin_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Sin_inplace_multiply, /*inplace_multiply*/ @@ -473,6 +477,9 @@ static PyObject * M_Cos_sub(M_Cos *self, PyObject *arg) { SUB }; static PyObject * M_Cos_inplace_sub(M_Cos *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Cos_div(M_Cos *self, PyObject *arg) { DIV }; static PyObject * M_Cos_inplace_div(M_Cos *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Cos_int(M_Cos *self) { GET_I }; +static PyObject * M_Cos_float(M_Cos *self) { GET_F }; +static PyObject * M_Cos_get(M_Cos *self) { GET_F }; static PyMemberDef M_Cos_members[] = { @@ -488,6 +495,7 @@ static PyMethodDef M_Cos_methods[] = { {"getServer", (PyCFunction)M_Cos_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Cos_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Cos_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Cos_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Cos_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Cos_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -516,9 +524,9 @@ static PyNumberMethods M_Cos_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Cos_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Cos_float, /*nb_float*/ (binaryfunc)M_Cos_inplace_add, /*inplace_add*/ (binaryfunc)M_Cos_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Cos_inplace_multiply, /*inplace_multiply*/ @@ -749,6 +757,9 @@ static PyObject * M_Tan_sub(M_Tan *self, PyObject *arg) { SUB }; static PyObject * M_Tan_inplace_sub(M_Tan *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Tan_div(M_Tan *self, PyObject *arg) { DIV }; static PyObject * M_Tan_inplace_div(M_Tan *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Tan_int(M_Tan *self) { GET_I }; +static PyObject * M_Tan_float(M_Tan *self) { GET_F }; +static PyObject * M_Tan_get(M_Tan *self) { GET_F }; static PyMemberDef M_Tan_members[] = { @@ -764,6 +775,7 @@ static PyMethodDef M_Tan_methods[] = { {"getServer", (PyCFunction)M_Tan_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Tan_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Tan_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Tan_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Tan_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Tan_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -792,9 +804,9 @@ static PyNumberMethods M_Tan_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Tan_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Tan_float, /*nb_float*/ (binaryfunc)M_Tan_inplace_add, /*inplace_add*/ (binaryfunc)M_Tan_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Tan_inplace_multiply, /*inplace_multiply*/ @@ -1031,6 +1043,9 @@ static PyObject * M_Abs_sub(M_Abs *self, PyObject *arg) { SUB }; static PyObject * M_Abs_inplace_sub(M_Abs *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Abs_div(M_Abs *self, PyObject *arg) { DIV }; static PyObject * M_Abs_inplace_div(M_Abs *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Abs_int(M_Abs *self) { GET_I }; +static PyObject * M_Abs_float(M_Abs *self) { GET_F }; +static PyObject * M_Abs_get(M_Abs *self) { GET_F }; static PyMemberDef M_Abs_members[] = { @@ -1046,6 +1061,7 @@ static PyMethodDef M_Abs_methods[] = { {"getServer", (PyCFunction)M_Abs_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Abs_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Abs_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Abs_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Abs_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Abs_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -1074,9 +1090,9 @@ static PyNumberMethods M_Abs_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Abs_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Abs_float, /*nb_float*/ (binaryfunc)M_Abs_inplace_add, /*inplace_add*/ (binaryfunc)M_Abs_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Abs_inplace_multiply, /*inplace_multiply*/ @@ -1313,6 +1329,9 @@ static PyObject * M_Sqrt_sub(M_Sqrt *self, PyObject *arg) { SUB }; static PyObject * M_Sqrt_inplace_sub(M_Sqrt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Sqrt_div(M_Sqrt *self, PyObject *arg) { DIV }; static PyObject * M_Sqrt_inplace_div(M_Sqrt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Sqrt_int(M_Sqrt *self) { GET_I }; +static PyObject * M_Sqrt_float(M_Sqrt *self) { GET_F }; +static PyObject * M_Sqrt_get(M_Sqrt *self) { GET_F }; static PyMemberDef M_Sqrt_members[] = { @@ -1328,6 +1347,7 @@ static PyMethodDef M_Sqrt_methods[] = { {"getServer", (PyCFunction)M_Sqrt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Sqrt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Sqrt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Sqrt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Sqrt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Sqrt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -1356,9 +1376,9 @@ static PyNumberMethods M_Sqrt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Sqrt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Sqrt_float, /*nb_float*/ (binaryfunc)M_Sqrt_inplace_add, /*inplace_add*/ (binaryfunc)M_Sqrt_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Sqrt_inplace_multiply, /*inplace_multiply*/ @@ -1595,6 +1615,9 @@ static PyObject * M_Log_sub(M_Log *self, PyObject *arg) { SUB }; static PyObject * M_Log_inplace_sub(M_Log *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Log_div(M_Log *self, PyObject *arg) { DIV }; static PyObject * M_Log_inplace_div(M_Log *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Log_int(M_Log *self) { GET_I }; +static PyObject * M_Log_float(M_Log *self) { GET_F }; +static PyObject * M_Log_get(M_Log *self) { GET_F }; static PyMemberDef M_Log_members[] = { @@ -1610,6 +1633,7 @@ static PyMethodDef M_Log_methods[] = { {"getServer", (PyCFunction)M_Log_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Log_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Log_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Log_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Log_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Log_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -1638,9 +1662,9 @@ static PyNumberMethods M_Log_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Log_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Log_float, /*nb_float*/ (binaryfunc)M_Log_inplace_add, /*inplace_add*/ (binaryfunc)M_Log_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Log_inplace_multiply, /*inplace_multiply*/ @@ -1877,6 +1901,9 @@ static PyObject * M_Log10_sub(M_Log10 *self, PyObject *arg) { SUB }; static PyObject * M_Log10_inplace_sub(M_Log10 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Log10_div(M_Log10 *self, PyObject *arg) { DIV }; static PyObject * M_Log10_inplace_div(M_Log10 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Log10_int(M_Log10 *self) { GET_I }; +static PyObject * M_Log10_float(M_Log10 *self) { GET_F }; +static PyObject * M_Log10_get(M_Log10 *self) { GET_F }; static PyMemberDef M_Log10_members[] = { @@ -1892,6 +1919,7 @@ static PyMethodDef M_Log10_methods[] = { {"getServer", (PyCFunction)M_Log10_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Log10_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Log10_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Log10_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Log10_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Log10_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -1920,9 +1948,9 @@ static PyNumberMethods M_Log10_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Log10_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Log10_float, /*nb_float*/ (binaryfunc)M_Log10_inplace_add, /*inplace_add*/ (binaryfunc)M_Log10_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Log10_inplace_multiply, /*inplace_multiply*/ @@ -2159,6 +2187,9 @@ static PyObject * M_Log2_sub(M_Log2 *self, PyObject *arg) { SUB }; static PyObject * M_Log2_inplace_sub(M_Log2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Log2_div(M_Log2 *self, PyObject *arg) { DIV }; static PyObject * M_Log2_inplace_div(M_Log2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Log2_int(M_Log2 *self) { GET_I }; +static PyObject * M_Log2_float(M_Log2 *self) { GET_F }; +static PyObject * M_Log2_get(M_Log2 *self) { GET_F }; static PyMemberDef M_Log2_members[] = { @@ -2174,6 +2205,7 @@ static PyMethodDef M_Log2_methods[] = { {"getServer", (PyCFunction)M_Log2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Log2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Log2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Log2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Log2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Log2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -2202,9 +2234,9 @@ static PyNumberMethods M_Log2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Log2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Log2_float, /*nb_float*/ (binaryfunc)M_Log2_inplace_add, /*inplace_add*/ (binaryfunc)M_Log2_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Log2_inplace_multiply, /*inplace_multiply*/ @@ -2513,6 +2545,9 @@ static PyObject * M_Pow_sub(M_Pow *self, PyObject *arg) { SUB }; static PyObject * M_Pow_inplace_sub(M_Pow *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Pow_div(M_Pow *self, PyObject *arg) { DIV }; static PyObject * M_Pow_inplace_div(M_Pow *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Pow_int(M_Pow *self) { GET_I }; +static PyObject * M_Pow_float(M_Pow *self) { GET_F }; +static PyObject * M_Pow_get(M_Pow *self) { GET_F }; static PyObject * M_Pow_setBase(M_Pow *self, PyObject *arg) { SET_PARAM(self->base, self->base_stream, 2); } static PyObject * M_Pow_setExponent(M_Pow *self, PyObject *arg) { SET_PARAM(self->exponent, self->exponent_stream, 3); } @@ -2532,6 +2567,7 @@ static PyMethodDef M_Pow_methods[] = { {"getServer", (PyCFunction)M_Pow_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Pow_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Pow_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Pow_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)M_Pow_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)M_Pow_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2562,9 +2598,9 @@ static PyNumberMethods M_Pow_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Pow_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Pow_float, /*nb_float*/ (binaryfunc)M_Pow_inplace_add, /*inplace_add*/ (binaryfunc)M_Pow_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Pow_inplace_multiply, /*inplace_multiply*/ @@ -2873,6 +2909,9 @@ static PyObject * M_Atan2_sub(M_Atan2 *self, PyObject *arg) { SUB }; static PyObject * M_Atan2_inplace_sub(M_Atan2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Atan2_div(M_Atan2 *self, PyObject *arg) { DIV }; static PyObject * M_Atan2_inplace_div(M_Atan2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Atan2_int(M_Atan2 *self) { GET_I }; +static PyObject * M_Atan2_float(M_Atan2 *self) { GET_F }; +static PyObject * M_Atan2_get(M_Atan2 *self) { GET_F }; static PyObject * M_Atan2_setB(M_Atan2 *self, PyObject *arg) { SET_PARAM(self->b, self->b_stream, 2); } static PyObject * M_Atan2_setA(M_Atan2 *self, PyObject *arg) { SET_PARAM(self->a, self->a_stream, 3); } @@ -2892,6 +2931,7 @@ static PyMethodDef M_Atan2_methods[] = { {"getServer", (PyCFunction)M_Atan2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Atan2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Atan2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Atan2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)M_Atan2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)M_Atan2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2922,9 +2962,9 @@ static PyNumberMethods M_Atan2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Atan2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Atan2_float, /*nb_float*/ (binaryfunc)M_Atan2_inplace_add, /*inplace_add*/ (binaryfunc)M_Atan2_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Atan2_inplace_multiply, /*inplace_multiply*/ @@ -3155,6 +3195,9 @@ static PyObject * M_Floor_sub(M_Floor *self, PyObject *arg) { SUB }; static PyObject * M_Floor_inplace_sub(M_Floor *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Floor_div(M_Floor *self, PyObject *arg) { DIV }; static PyObject * M_Floor_inplace_div(M_Floor *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Floor_int(M_Floor *self) { GET_I }; +static PyObject * M_Floor_float(M_Floor *self) { GET_F }; +static PyObject * M_Floor_get(M_Floor *self) { GET_F }; static PyMemberDef M_Floor_members[] = { @@ -3170,6 +3213,7 @@ static PyMethodDef M_Floor_methods[] = { {"getServer", (PyCFunction)M_Floor_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Floor_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Floor_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Floor_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Floor_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Floor_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -3198,9 +3242,9 @@ static PyNumberMethods M_Floor_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Floor_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Floor_float, /*nb_float*/ (binaryfunc)M_Floor_inplace_add, /*inplace_add*/ (binaryfunc)M_Floor_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Floor_inplace_multiply, /*inplace_multiply*/ @@ -3431,6 +3475,9 @@ static PyObject * M_Ceil_sub(M_Ceil *self, PyObject *arg) { SUB }; static PyObject * M_Ceil_inplace_sub(M_Ceil *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Ceil_div(M_Ceil *self, PyObject *arg) { DIV }; static PyObject * M_Ceil_inplace_div(M_Ceil *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Ceil_int(M_Ceil *self) { GET_I }; +static PyObject * M_Ceil_float(M_Ceil *self) { GET_F }; +static PyObject * M_Ceil_get(M_Ceil *self) { GET_F }; static PyMemberDef M_Ceil_members[] = { @@ -3446,6 +3493,7 @@ static PyMethodDef M_Ceil_methods[] = { {"getServer", (PyCFunction)M_Ceil_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Ceil_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Ceil_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Ceil_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Ceil_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Ceil_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -3474,9 +3522,9 @@ static PyNumberMethods M_Ceil_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Ceil_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Ceil_float, /*nb_float*/ (binaryfunc)M_Ceil_inplace_add, /*inplace_add*/ (binaryfunc)M_Ceil_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Ceil_inplace_multiply, /*inplace_multiply*/ @@ -3707,6 +3755,9 @@ static PyObject * M_Round_sub(M_Round *self, PyObject *arg) { SUB }; static PyObject * M_Round_inplace_sub(M_Round *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Round_div(M_Round *self, PyObject *arg) { DIV }; static PyObject * M_Round_inplace_div(M_Round *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Round_int(M_Round *self) { GET_I }; +static PyObject * M_Round_float(M_Round *self) { GET_F }; +static PyObject * M_Round_get(M_Round *self) { GET_F }; static PyMemberDef M_Round_members[] = { @@ -3722,6 +3773,7 @@ static PyMethodDef M_Round_methods[] = { {"getServer", (PyCFunction)M_Round_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Round_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Round_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Round_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Round_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Round_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -3750,9 +3802,9 @@ static PyNumberMethods M_Round_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Round_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Round_float, /*nb_float*/ (binaryfunc)M_Round_inplace_add, /*inplace_add*/ (binaryfunc)M_Round_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Round_inplace_multiply, /*inplace_multiply*/ @@ -3983,6 +4035,9 @@ static PyObject * M_Tanh_sub(M_Tanh *self, PyObject *arg) { SUB }; static PyObject * M_Tanh_inplace_sub(M_Tanh *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Tanh_div(M_Tanh *self, PyObject *arg) { DIV }; static PyObject * M_Tanh_inplace_div(M_Tanh *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Tanh_int(M_Tanh *self) { GET_I }; +static PyObject * M_Tanh_float(M_Tanh *self) { GET_F }; +static PyObject * M_Tanh_get(M_Tanh *self) { GET_F }; static PyMemberDef M_Tanh_members[] = { @@ -3998,6 +4053,7 @@ static PyMethodDef M_Tanh_methods[] = { {"getServer", (PyCFunction)M_Tanh_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Tanh_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Tanh_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Tanh_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Tanh_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Tanh_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4026,9 +4082,9 @@ static PyNumberMethods M_Tanh_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Tanh_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Tanh_float, /*nb_float*/ (binaryfunc)M_Tanh_inplace_add, /*inplace_add*/ (binaryfunc)M_Tanh_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Tanh_inplace_multiply, /*inplace_multiply*/ @@ -4259,6 +4315,9 @@ static PyObject * M_Exp_sub(M_Exp *self, PyObject *arg) { SUB }; static PyObject * M_Exp_inplace_sub(M_Exp *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Exp_div(M_Exp *self, PyObject *arg) { DIV }; static PyObject * M_Exp_inplace_div(M_Exp *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Exp_int(M_Exp *self) { GET_I }; +static PyObject * M_Exp_float(M_Exp *self) { GET_F }; +static PyObject * M_Exp_get(M_Exp *self) { GET_F }; static PyMemberDef M_Exp_members[] = { @@ -4274,6 +4333,7 @@ static PyMethodDef M_Exp_methods[] = { {"getServer", (PyCFunction)M_Exp_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Exp_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Exp_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Exp_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)M_Exp_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)M_Exp_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4302,9 +4362,9 @@ static PyNumberMethods M_Exp_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Exp_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Exp_float, /*nb_float*/ (binaryfunc)M_Exp_inplace_add, /*inplace_add*/ (binaryfunc)M_Exp_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Exp_inplace_multiply, /*inplace_multiply*/ @@ -4640,6 +4700,9 @@ static PyObject * M_Div_sub(M_Div *self, PyObject *arg) { SUB }; static PyObject * M_Div_inplace_sub(M_Div *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Div_div(M_Div *self, PyObject *arg) { DIV }; static PyObject * M_Div_inplace_div(M_Div *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Div_int(M_Div *self) { GET_I }; +static PyObject * M_Div_float(M_Div *self) { GET_F }; +static PyObject * M_Div_get(M_Div *self) { GET_F }; static PyObject * M_Div_setA(M_Div *self, PyObject *arg) { SET_PARAM(self->a, self->a_stream, 2); } static PyObject * M_Div_setB(M_Div *self, PyObject *arg) { SET_PARAM(self->b, self->b_stream, 3); } @@ -4659,6 +4722,7 @@ static PyMethodDef M_Div_methods[] = { {"getServer", (PyCFunction)M_Div_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Div_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Div_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Div_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)M_Div_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)M_Div_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4689,9 +4753,9 @@ static PyNumberMethods M_Div_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Div_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Div_float, /*nb_float*/ (binaryfunc)M_Div_inplace_add, /*inplace_add*/ (binaryfunc)M_Div_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Div_inplace_multiply, /*inplace_multiply*/ @@ -5000,6 +5064,9 @@ static PyObject * M_Sub_sub(M_Sub *self, PyObject *arg) { SUB }; static PyObject * M_Sub_inplace_sub(M_Sub *self, PyObject *arg) { INPLACE_SUB }; static PyObject * M_Sub_div(M_Sub *self, PyObject *arg) { DIV }; static PyObject * M_Sub_inplace_div(M_Sub *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * M_Sub_int(M_Sub *self) { GET_I }; +static PyObject * M_Sub_float(M_Sub *self) { GET_F }; +static PyObject * M_Sub_get(M_Sub *self) { GET_F }; static PyObject * M_Sub_setA(M_Sub *self, PyObject *arg) { SET_PARAM(self->a, self->a_stream, 2); } static PyObject * M_Sub_setB(M_Sub *self, PyObject *arg) { SET_PARAM(self->b, self->b_stream, 3); } @@ -5019,6 +5086,7 @@ static PyMethodDef M_Sub_methods[] = { {"getServer", (PyCFunction)M_Sub_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)M_Sub_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)M_Sub_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)M_Sub_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)M_Sub_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)M_Sub_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5049,9 +5117,9 @@ static PyNumberMethods M_Sub_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)M_Sub_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)M_Sub_float, /*nb_float*/ (binaryfunc)M_Sub_inplace_add, /*inplace_add*/ (binaryfunc)M_Sub_inplace_sub, /*inplace_subtract*/ (binaryfunc)M_Sub_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/bandsplitmodule.c b/src/objects/bandsplitmodule.c index 3404a4f0..61957f92 100644 --- a/src/objects/bandsplitmodule.c +++ b/src/objects/bandsplitmodule.c @@ -520,6 +520,9 @@ static PyObject * BandSplit_sub(BandSplit *self, PyObject *arg) { SUB }; static PyObject * BandSplit_inplace_sub(BandSplit *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BandSplit_div(BandSplit *self, PyObject *arg) { DIV }; static PyObject * BandSplit_inplace_div(BandSplit *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BandSplit_int(BandSplit *self) { GET_I }; +static PyObject * BandSplit_float(BandSplit *self) { GET_F }; +static PyObject * BandSplit_get(BandSplit *self) { GET_F }; static PyMemberDef BandSplit_members[] = { @@ -534,6 +537,7 @@ static PyMethodDef BandSplit_methods[] = { {"getServer", (PyCFunction)BandSplit_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BandSplit_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BandSplit_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BandSplit_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BandSplit_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BandSplit_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -562,9 +566,9 @@ static PyNumberMethods BandSplit_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BandSplit_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BandSplit_float, /*nb_float*/ (binaryfunc)BandSplit_inplace_add, /*inplace_add*/ (binaryfunc)BandSplit_inplace_sub, /*inplace_subtract*/ (binaryfunc)BandSplit_inplace_multiply, /*inplace_multiply*/ @@ -1212,6 +1216,9 @@ static PyObject * FourBand_sub(FourBand *self, PyObject *arg) { SUB }; static PyObject * FourBand_inplace_sub(FourBand *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FourBand_div(FourBand *self, PyObject *arg) { DIV }; static PyObject * FourBand_inplace_div(FourBand *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FourBand_int(FourBand *self) { GET_I }; +static PyObject * FourBand_float(FourBand *self) { GET_F }; +static PyObject * FourBand_get(FourBand *self) { GET_F }; static PyMemberDef FourBand_members[] = { @@ -1226,6 +1233,7 @@ static PyMethodDef FourBand_methods[] = { {"getServer", (PyCFunction)FourBand_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FourBand_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FourBand_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FourBand_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)FourBand_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)FourBand_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1254,9 +1262,9 @@ static PyNumberMethods FourBand_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FourBand_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FourBand_float, /*nb_float*/ (binaryfunc)FourBand_inplace_add, /*inplace_add*/ (binaryfunc)FourBand_inplace_sub, /*inplace_subtract*/ (binaryfunc)FourBand_inplace_multiply, /*inplace_multiply*/ @@ -1870,6 +1878,9 @@ static PyObject * MultiBand_sub(MultiBand *self, PyObject *arg) { SUB }; static PyObject * MultiBand_inplace_sub(MultiBand *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MultiBand_div(MultiBand *self, PyObject *arg) { DIV }; static PyObject * MultiBand_inplace_div(MultiBand *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MultiBand_int(MultiBand *self) { GET_I }; +static PyObject * MultiBand_float(MultiBand *self) { GET_F }; +static PyObject * MultiBand_get(MultiBand *self) { GET_F }; static PyMemberDef MultiBand_members[] = { @@ -1884,6 +1895,7 @@ static PyMethodDef MultiBand_methods[] = { {"getServer", (PyCFunction)MultiBand_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MultiBand_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MultiBand_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MultiBand_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MultiBand_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MultiBand_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1912,9 +1924,9 @@ static PyNumberMethods MultiBand_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MultiBand_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MultiBand_float, /*nb_float*/ (binaryfunc)MultiBand_inplace_add, /*inplace_add*/ (binaryfunc)MultiBand_inplace_sub, /*inplace_subtract*/ (binaryfunc)MultiBand_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/chorusmodule.c b/src/objects/chorusmodule.c index d6685511..81ccf8c5 100644 --- a/src/objects/chorusmodule.c +++ b/src/objects/chorusmodule.c @@ -592,6 +592,9 @@ static PyObject * Chorus_sub(Chorus *self, PyObject *arg) { SUB }; static PyObject * Chorus_inplace_sub(Chorus *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Chorus_div(Chorus *self, PyObject *arg) { DIV }; static PyObject * Chorus_inplace_div(Chorus *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Chorus_int(Chorus *self) { GET_I }; +static PyObject * Chorus_float(Chorus *self) { GET_F }; +static PyObject * Chorus_get(Chorus *self) { GET_F }; static PyObject * Chorus_reset(Chorus *self) @@ -630,6 +633,7 @@ static PyMethodDef Chorus_methods[] = { {"getServer", (PyCFunction)Chorus_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Chorus_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Chorus_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Chorus_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Chorus_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Chorus_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -662,9 +666,9 @@ static PyNumberMethods Chorus_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Chorus_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Chorus_float, /*nb_float*/ (binaryfunc)Chorus_inplace_add, /*inplace_add*/ (binaryfunc)Chorus_inplace_sub, /*inplace_subtract*/ (binaryfunc)Chorus_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/compressmodule.c b/src/objects/compressmodule.c index 72772567..850bd2a3 100644 --- a/src/objects/compressmodule.c +++ b/src/objects/compressmodule.c @@ -368,6 +368,9 @@ static PyObject * Compress_sub(Compress *self, PyObject *arg) { SUB }; static PyObject * Compress_inplace_sub(Compress *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Compress_div(Compress *self, PyObject *arg) { DIV }; static PyObject * Compress_inplace_div(Compress *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Compress_int(Compress *self) { GET_I }; +static PyObject * Compress_float(Compress *self) { GET_F }; +static PyObject * Compress_get(Compress *self) { GET_F }; static PyObject * Compress_setRiseTime(Compress *self, PyObject *arg) { SET_PARAM(self->risetime, self->risetime_stream, 2); } static PyObject * Compress_setFallTime(Compress *self, PyObject *arg) { SET_PARAM(self->falltime, self->falltime_stream, 3); } @@ -432,6 +435,7 @@ static PyMethodDef Compress_methods[] = { {"getServer", (PyCFunction)Compress_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Compress_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Compress_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Compress_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Compress_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Compress_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -466,9 +470,9 @@ static PyNumberMethods Compress_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Compress_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Compress_float, /*nb_float*/ (binaryfunc)Compress_inplace_add, /*inplace_add*/ (binaryfunc)Compress_inplace_sub, /*inplace_subtract*/ (binaryfunc)Compress_inplace_multiply, /*inplace_multiply*/ @@ -1339,6 +1343,9 @@ static PyObject * Gate_sub(Gate *self, PyObject *arg) { SUB }; static PyObject * Gate_inplace_sub(Gate *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Gate_div(Gate *self, PyObject *arg) { DIV }; static PyObject * Gate_inplace_div(Gate *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Gate_int(Gate *self) { GET_I }; +static PyObject * Gate_float(Gate *self) { GET_F }; +static PyObject * Gate_get(Gate *self) { GET_F }; static PyObject * Gate_setThresh(Gate *self, PyObject *arg) { SET_PARAM(self->thresh, self->thresh_stream, 2); } static PyObject * Gate_setRiseTime(Gate *self, PyObject *arg) { SET_PARAM(self->risetime, self->risetime_stream, 3); } @@ -1381,6 +1388,7 @@ static PyMethodDef Gate_methods[] = { {"getServer", (PyCFunction)Gate_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Gate_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Gate_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Gate_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Gate_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Gate_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1413,9 +1421,9 @@ static PyNumberMethods Gate_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Gate_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Gate_float, /*nb_float*/ (binaryfunc)Gate_inplace_add, /*inplace_add*/ (binaryfunc)Gate_inplace_sub, /*inplace_subtract*/ (binaryfunc)Gate_inplace_multiply, /*inplace_multiply*/ @@ -1754,6 +1762,9 @@ static PyObject * Balance_sub(Balance *self, PyObject *arg) { SUB }; static PyObject * Balance_inplace_sub(Balance *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Balance_div(Balance *self, PyObject *arg) { DIV }; static PyObject * Balance_inplace_div(Balance *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Balance_int(Balance *self) { GET_I }; +static PyObject * Balance_float(Balance *self) { GET_F }; +static PyObject * Balance_get(Balance *self) { GET_F }; static PyObject * Balance_setFreq(Balance *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -1773,6 +1784,7 @@ static PyMethodDef Balance_methods[] = { {"getServer", (PyCFunction)Balance_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Balance_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Balance_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Balance_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Balance_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Balance_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1802,9 +1814,9 @@ static PyNumberMethods Balance_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Balance_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Balance_float, /*nb_float*/ (binaryfunc)Balance_inplace_add, /*inplace_add*/ (binaryfunc)Balance_inplace_sub, /*inplace_subtract*/ (binaryfunc)Balance_inplace_multiply, /*inplace_multiply*/ @@ -2203,6 +2215,9 @@ static PyObject * Expand_sub(Expand *self, PyObject *arg) { SUB }; static PyObject * Expand_inplace_sub(Expand *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Expand_div(Expand *self, PyObject *arg) { DIV }; static PyObject * Expand_inplace_div(Expand *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Expand_int(Expand *self) { GET_I }; +static PyObject * Expand_float(Expand *self) { GET_F }; +static PyObject * Expand_get(Expand *self) { GET_F }; static PyObject * Expand_setRiseTime(Expand *self, PyObject *arg) { SET_PARAM(self->risetime, self->risetime_stream, 2); } static PyObject * Expand_setFallTime(Expand *self, PyObject *arg) { SET_PARAM(self->falltime, self->falltime_stream, 3); } @@ -2249,6 +2264,7 @@ static PyMethodDef Expand_methods[] = { {"getServer", (PyCFunction)Expand_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Expand_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Expand_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Expand_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Expand_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Expand_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2283,9 +2299,9 @@ static PyNumberMethods Expand_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Expand_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Expand_float, /*nb_float*/ (binaryfunc)Expand_inplace_add, /*inplace_add*/ (binaryfunc)Expand_inplace_sub, /*inplace_subtract*/ (binaryfunc)Expand_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/convolvemodule.c b/src/objects/convolvemodule.c index 765720a0..f71874c2 100644 --- a/src/objects/convolvemodule.c +++ b/src/objects/convolvemodule.c @@ -238,6 +238,9 @@ static PyObject * Convolve_sub(Convolve *self, PyObject *arg) { SUB }; static PyObject * Convolve_inplace_sub(Convolve *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Convolve_div(Convolve *self, PyObject *arg) { DIV }; static PyObject * Convolve_inplace_div(Convolve *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Convolve_int(Convolve *self) { GET_I }; +static PyObject * Convolve_float(Convolve *self) { GET_F }; +static PyObject * Convolve_get(Convolve *self) { GET_F }; static PyObject * Convolve_getTable(Convolve* self) @@ -272,6 +275,7 @@ static PyMethodDef Convolve_methods[] = {"getTable", (PyCFunction)Convolve_getTable, METH_NOARGS, "Returns impulse response table object."}, {"getServer", (PyCFunction)Convolve_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Convolve_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Convolve_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Convolve_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Convolve_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Convolve_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -301,9 +305,9 @@ static PyNumberMethods Convolve_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Convolve_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Convolve_float, /*nb_float*/ (binaryfunc)Convolve_inplace_add, /*inplace_add*/ (binaryfunc)Convolve_inplace_sub, /*inplace_subtract*/ (binaryfunc)Convolve_inplace_multiply, /*inplace_multiply*/ @@ -760,6 +764,9 @@ static PyObject * IRWinSinc_sub(IRWinSinc *self, PyObject *arg) { SUB }; static PyObject * IRWinSinc_inplace_sub(IRWinSinc *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IRWinSinc_div(IRWinSinc *self, PyObject *arg) { DIV }; static PyObject * IRWinSinc_inplace_div(IRWinSinc *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IRWinSinc_int(IRWinSinc *self) { GET_I }; +static PyObject * IRWinSinc_float(IRWinSinc *self) { GET_F }; +static PyObject * IRWinSinc_get(IRWinSinc *self) { GET_F }; static PyObject * IRWinSinc_setFreq(IRWinSinc *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * IRWinSinc_setBandwidth(IRWinSinc *self, PyObject *arg) { SET_PARAM(self->bandwidth, self->bandwidth_stream, 3); } @@ -794,6 +801,7 @@ static PyMethodDef IRWinSinc_methods[] = { {"getServer", (PyCFunction)IRWinSinc_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IRWinSinc_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IRWinSinc_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IRWinSinc_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IRWinSinc_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IRWinSinc_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -825,9 +833,9 @@ static PyNumberMethods IRWinSinc_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IRWinSinc_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IRWinSinc_float, /*nb_float*/ (binaryfunc)IRWinSinc_inplace_add, /*inplace_add*/ (binaryfunc)IRWinSinc_inplace_sub, /*inplace_subtract*/ (binaryfunc)IRWinSinc_inplace_multiply, /*inplace_multiply*/ @@ -1116,6 +1124,9 @@ static PyObject * IRAverage_sub(IRAverage *self, PyObject *arg) { SUB }; static PyObject * IRAverage_inplace_sub(IRAverage *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IRAverage_div(IRAverage *self, PyObject *arg) { DIV }; static PyObject * IRAverage_inplace_div(IRAverage *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IRAverage_int(IRAverage *self) { GET_I }; +static PyObject * IRAverage_float(IRAverage *self) { GET_F }; +static PyObject * IRAverage_get(IRAverage *self) { GET_F }; static PyMemberDef IRAverage_members[] = { @@ -1131,6 +1142,7 @@ static PyMethodDef IRAverage_methods[] = { {"getServer", (PyCFunction)IRAverage_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IRAverage_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IRAverage_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IRAverage_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IRAverage_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IRAverage_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1159,9 +1171,9 @@ static PyNumberMethods IRAverage_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IRAverage_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IRAverage_float, /*nb_float*/ (binaryfunc)IRAverage_inplace_add, /*inplace_add*/ (binaryfunc)IRAverage_inplace_sub, /*inplace_subtract*/ (binaryfunc)IRAverage_inplace_multiply, /*inplace_multiply*/ @@ -1650,6 +1662,9 @@ static PyObject * IRPulse_sub(IRPulse *self, PyObject *arg) { SUB }; static PyObject * IRPulse_inplace_sub(IRPulse *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IRPulse_div(IRPulse *self, PyObject *arg) { DIV }; static PyObject * IRPulse_inplace_div(IRPulse *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IRPulse_int(IRPulse *self) { GET_I }; +static PyObject * IRPulse_float(IRPulse *self) { GET_F }; +static PyObject * IRPulse_get(IRPulse *self) { GET_F }; static PyObject * IRPulse_setFreq(IRPulse *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * IRPulse_setBandwidth(IRPulse *self, PyObject *arg) { SET_PARAM(self->bandwidth, self->bandwidth_stream, 3); } @@ -1685,6 +1700,7 @@ static PyMethodDef IRPulse_methods[] = { {"getServer", (PyCFunction)IRPulse_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IRPulse_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IRPulse_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IRPulse_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IRPulse_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IRPulse_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1716,9 +1732,9 @@ static PyNumberMethods IRPulse_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IRPulse_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IRPulse_float, /*nb_float*/ (binaryfunc)IRPulse_inplace_add, /*inplace_add*/ (binaryfunc)IRPulse_inplace_sub, /*inplace_subtract*/ (binaryfunc)IRPulse_inplace_multiply, /*inplace_multiply*/ @@ -2109,6 +2125,9 @@ static PyObject * IRFM_sub(IRFM *self, PyObject *arg) { SUB }; static PyObject * IRFM_inplace_sub(IRFM *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IRFM_div(IRFM *self, PyObject *arg) { DIV }; static PyObject * IRFM_inplace_div(IRFM *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IRFM_int(IRFM *self) { GET_I }; +static PyObject * IRFM_float(IRFM *self) { GET_F }; +static PyObject * IRFM_get(IRFM *self) { GET_F }; static PyObject * IRFM_setCarrier(IRFM *self, PyObject *arg) { SET_PARAM(self->carrier, self->carrier_stream, 2); } static PyObject * IRFM_setRatio(IRFM *self, PyObject *arg) { SET_PARAM(self->ratio, self->ratio_stream, 3); } @@ -2131,6 +2150,7 @@ static PyMethodDef IRFM_methods[] = { {"getServer", (PyCFunction)IRFM_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IRFM_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IRFM_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IRFM_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IRFM_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IRFM_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2162,9 +2182,9 @@ static PyNumberMethods IRFM_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IRFM_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IRFM_float, /*nb_float*/ (binaryfunc)IRFM_inplace_add, /*inplace_add*/ (binaryfunc)IRFM_inplace_sub, /*inplace_subtract*/ (binaryfunc)IRFM_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/delaymodule.c b/src/objects/delaymodule.c index 21b34f0d..169d0ab8 100644 --- a/src/objects/delaymodule.c +++ b/src/objects/delaymodule.c @@ -440,6 +440,9 @@ static PyObject * Delay_sub(Delay *self, PyObject *arg) { SUB }; static PyObject * Delay_inplace_sub(Delay *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Delay_div(Delay *self, PyObject *arg) { DIV }; static PyObject * Delay_inplace_div(Delay *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Delay_int(Delay *self) { GET_I }; +static PyObject * Delay_float(Delay *self) { GET_F }; +static PyObject * Delay_get(Delay *self) { GET_F }; static PyObject * Delay_setDelay(Delay *self, PyObject *arg) { SET_PARAM(self->delay, self->delay_stream, 2); } static PyObject * Delay_setFeedback(Delay *self, PyObject *arg) { SET_PARAM(self->feedback, self->feedback_stream, 3); } @@ -473,6 +476,7 @@ static PyMethodDef Delay_methods[] = { {"getServer", (PyCFunction)Delay_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Delay_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Delay_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Delay_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Delay_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Delay_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -504,9 +508,9 @@ static PyNumberMethods Delay_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Delay_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Delay_float, /*nb_float*/ (binaryfunc)Delay_inplace_add, /*inplace_add*/ (binaryfunc)Delay_inplace_sub, /*inplace_subtract*/ (binaryfunc)Delay_inplace_multiply, /*inplace_multiply*/ @@ -849,6 +853,9 @@ static PyObject * SDelay_sub(SDelay *self, PyObject *arg) { SUB }; static PyObject * SDelay_inplace_sub(SDelay *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SDelay_div(SDelay *self, PyObject *arg) { DIV }; static PyObject * SDelay_inplace_div(SDelay *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SDelay_int(SDelay *self) { GET_I }; +static PyObject * SDelay_float(SDelay *self) { GET_F }; +static PyObject * SDelay_get(SDelay *self) { GET_F }; static PyObject * SDelay_setDelay(SDelay *self, PyObject *arg) { SET_PARAM(self->delay, self->delay_stream, 2); } @@ -880,6 +887,7 @@ static PyMethodDef SDelay_methods[] = { {"getServer", (PyCFunction)SDelay_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SDelay_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SDelay_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SDelay_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SDelay_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SDelay_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -910,9 +918,9 @@ static PyNumberMethods SDelay_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SDelay_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SDelay_float, /*nb_float*/ (binaryfunc)SDelay_inplace_add, /*inplace_add*/ (binaryfunc)SDelay_inplace_sub, /*inplace_subtract*/ (binaryfunc)SDelay_inplace_multiply, /*inplace_multiply*/ @@ -1589,6 +1597,9 @@ static PyObject * Waveguide_sub(Waveguide *self, PyObject *arg) { SUB }; static PyObject * Waveguide_inplace_sub(Waveguide *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Waveguide_div(Waveguide *self, PyObject *arg) { DIV }; static PyObject * Waveguide_inplace_div(Waveguide *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Waveguide_int(Waveguide *self) { GET_I }; +static PyObject * Waveguide_float(Waveguide *self) { GET_F }; +static PyObject * Waveguide_get(Waveguide *self) { GET_F }; static PyObject * Waveguide_reset(Waveguide *self) @@ -1631,6 +1642,7 @@ static PyMethodDef Waveguide_methods[] = { {"getServer", (PyCFunction)Waveguide_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Waveguide_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Waveguide_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Waveguide_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Waveguide_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Waveguide_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1662,9 +1674,9 @@ static PyNumberMethods Waveguide_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Waveguide_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Waveguide_float, /*nb_float*/ (binaryfunc)Waveguide_inplace_add, /*inplace_add*/ (binaryfunc)Waveguide_inplace_sub, /*inplace_subtract*/ (binaryfunc)Waveguide_inplace_multiply, /*inplace_multiply*/ @@ -2734,6 +2746,9 @@ static PyObject * AllpassWG_sub(AllpassWG *self, PyObject *arg) { SUB }; static PyObject * AllpassWG_inplace_sub(AllpassWG *self, PyObject *arg) { INPLACE_SUB }; static PyObject * AllpassWG_div(AllpassWG *self, PyObject *arg) { DIV }; static PyObject * AllpassWG_inplace_div(AllpassWG *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * AllpassWG_int(AllpassWG *self) { GET_I }; +static PyObject * AllpassWG_float(AllpassWG *self) { GET_F }; +static PyObject * AllpassWG_get(AllpassWG *self) { GET_F }; static PyObject * AllpassWG_reset(AllpassWG *self) @@ -2780,6 +2795,7 @@ static PyMethodDef AllpassWG_methods[] = { {"getServer", (PyCFunction)AllpassWG_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)AllpassWG_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)AllpassWG_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)AllpassWG_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)AllpassWG_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)AllpassWG_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2812,9 +2828,9 @@ static PyNumberMethods AllpassWG_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)AllpassWG_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)AllpassWG_float, /*nb_float*/ (binaryfunc)AllpassWG_inplace_add, /*inplace_add*/ (binaryfunc)AllpassWG_inplace_sub, /*inplace_subtract*/ (binaryfunc)AllpassWG_inplace_multiply, /*inplace_multiply*/ @@ -3048,6 +3064,9 @@ static PyObject * Delay1_sub(Delay1 *self, PyObject *arg) { SUB }; static PyObject * Delay1_inplace_sub(Delay1 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Delay1_div(Delay1 *self, PyObject *arg) { DIV }; static PyObject * Delay1_inplace_div(Delay1 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Delay1_int(Delay1 *self) { GET_I }; +static PyObject * Delay1_float(Delay1 *self) { GET_F }; +static PyObject * Delay1_get(Delay1 *self) { GET_F }; static PyMemberDef Delay1_members[] = { @@ -3063,6 +3082,7 @@ static PyMethodDef Delay1_methods[] = { {"getServer", (PyCFunction)Delay1_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Delay1_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Delay1_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Delay1_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Delay1_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Delay1_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3091,9 +3111,9 @@ static PyNumberMethods Delay1_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Delay1_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Delay1_float, /*nb_float*/ (binaryfunc)Delay1_inplace_add, /*inplace_add*/ (binaryfunc)Delay1_inplace_sub, /*inplace_subtract*/ (binaryfunc)Delay1_inplace_multiply, /*inplace_multiply*/ @@ -3777,6 +3797,9 @@ static PyObject * SmoothDelay_sub(SmoothDelay *self, PyObject *arg) { SUB }; static PyObject * SmoothDelay_inplace_sub(SmoothDelay *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SmoothDelay_div(SmoothDelay *self, PyObject *arg) { DIV }; static PyObject * SmoothDelay_inplace_div(SmoothDelay *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SmoothDelay_int(SmoothDelay *self) { GET_I }; +static PyObject * SmoothDelay_float(SmoothDelay *self) { GET_F }; +static PyObject * SmoothDelay_get(SmoothDelay *self) { GET_F }; static PyObject * SmoothDelay_setDelay(SmoothDelay *self, PyObject *arg) { SET_PARAM(self->delay, self->delay_stream, 2); } static PyObject * SmoothDelay_setFeedback(SmoothDelay *self, PyObject *arg) { SET_PARAM(self->feedback, self->feedback_stream, 3); } @@ -3823,6 +3846,7 @@ static PyMethodDef SmoothDelay_methods[] = { {"getServer", (PyCFunction)SmoothDelay_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SmoothDelay_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SmoothDelay_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SmoothDelay_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SmoothDelay_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SmoothDelay_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3855,9 +3879,9 @@ static PyNumberMethods SmoothDelay_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SmoothDelay_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SmoothDelay_float, /*nb_float*/ (binaryfunc)SmoothDelay_inplace_add, /*inplace_add*/ (binaryfunc)SmoothDelay_inplace_sub, /*inplace_subtract*/ (binaryfunc)SmoothDelay_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/distomodule.c b/src/objects/distomodule.c index 9244bbb6..91b4ffac 100644 --- a/src/objects/distomodule.c +++ b/src/objects/distomodule.c @@ -338,6 +338,9 @@ static PyObject * Disto_sub(Disto *self, PyObject *arg) { SUB }; static PyObject * Disto_inplace_sub(Disto *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Disto_div(Disto *self, PyObject *arg) { DIV }; static PyObject * Disto_inplace_div(Disto *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Disto_int(Disto *self) { GET_I }; +static PyObject * Disto_float(Disto *self) { GET_F }; +static PyObject * Disto_get(Disto *self) { GET_F }; static PyObject * Disto_setDrive(Disto *self, PyObject *arg) { SET_PARAM(self->drive, self->drive_stream, 2); } static PyObject * Disto_setSlope(Disto *self, PyObject *arg) { SET_PARAM(self->slope, self->slope_stream, 3); } @@ -358,6 +361,7 @@ static PyMethodDef Disto_methods[] = { {"getServer", (PyCFunction)Disto_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Disto_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Disto_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Disto_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Disto_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Disto_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -388,9 +392,9 @@ static PyNumberMethods Disto_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Disto_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Disto_float, /*nb_float*/ (binaryfunc)Disto_inplace_add, /*inplace_add*/ (binaryfunc)Disto_inplace_sub, /*inplace_subtract*/ (binaryfunc)Disto_inplace_multiply, /*inplace_multiply*/ @@ -742,6 +746,9 @@ static PyObject * Clip_sub(Clip *self, PyObject *arg) { SUB }; static PyObject * Clip_inplace_sub(Clip *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Clip_div(Clip *self, PyObject *arg) { DIV }; static PyObject * Clip_inplace_div(Clip *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Clip_int(Clip *self) { GET_I }; +static PyObject * Clip_float(Clip *self) { GET_F }; +static PyObject * Clip_get(Clip *self) { GET_F }; static PyObject * Clip_setMin(Clip *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Clip_setMax(Clip *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -762,6 +769,7 @@ static PyMethodDef Clip_methods[] = { {"getServer", (PyCFunction)Clip_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Clip_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Clip_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Clip_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Clip_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Clip_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -792,9 +800,9 @@ static PyNumberMethods Clip_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Clip_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Clip_float, /*nb_float*/ (binaryfunc)Clip_inplace_add, /*inplace_add*/ (binaryfunc)Clip_inplace_sub, /*inplace_subtract*/ (binaryfunc)Clip_inplace_multiply, /*inplace_multiply*/ @@ -1194,6 +1202,9 @@ static PyObject * Mirror_sub(Mirror *self, PyObject *arg) { SUB }; static PyObject * Mirror_inplace_sub(Mirror *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Mirror_div(Mirror *self, PyObject *arg) { DIV }; static PyObject * Mirror_inplace_div(Mirror *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Mirror_int(Mirror *self) { GET_I }; +static PyObject * Mirror_float(Mirror *self) { GET_F }; +static PyObject * Mirror_get(Mirror *self) { GET_F }; static PyObject * Mirror_setMin(Mirror *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Mirror_setMax(Mirror *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -1214,6 +1225,7 @@ static PyMethodDef Mirror_methods[] = { {"getServer", (PyCFunction)Mirror_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Mirror_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Mirror_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Mirror_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Mirror_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Mirror_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1244,9 +1256,9 @@ static PyNumberMethods Mirror_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Mirror_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Mirror_float, /*nb_float*/ (binaryfunc)Mirror_inplace_add, /*inplace_add*/ (binaryfunc)Mirror_inplace_sub, /*inplace_subtract*/ (binaryfunc)Mirror_inplace_multiply, /*inplace_multiply*/ @@ -1682,6 +1694,9 @@ static PyObject * Wrap_sub(Wrap *self, PyObject *arg) { SUB }; static PyObject * Wrap_inplace_sub(Wrap *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Wrap_div(Wrap *self, PyObject *arg) { DIV }; static PyObject * Wrap_inplace_div(Wrap *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Wrap_int(Wrap *self) { GET_I }; +static PyObject * Wrap_float(Wrap *self) { GET_F }; +static PyObject * Wrap_get(Wrap *self) { GET_F }; static PyObject * Wrap_setMin(Wrap *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Wrap_setMax(Wrap *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -1702,6 +1717,7 @@ static PyMethodDef Wrap_methods[] = { {"getServer", (PyCFunction)Wrap_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Wrap_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Wrap_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Wrap_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Wrap_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Wrap_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1732,9 +1748,9 @@ static PyNumberMethods Wrap_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Wrap_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Wrap_float, /*nb_float*/ (binaryfunc)Wrap_inplace_add, /*inplace_add*/ (binaryfunc)Wrap_inplace_sub, /*inplace_subtract*/ (binaryfunc)Wrap_inplace_multiply, /*inplace_multiply*/ @@ -2141,6 +2157,9 @@ static PyObject * Degrade_sub(Degrade *self, PyObject *arg) { SUB }; static PyObject * Degrade_inplace_sub(Degrade *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Degrade_div(Degrade *self, PyObject *arg) { DIV }; static PyObject * Degrade_inplace_div(Degrade *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Degrade_int(Degrade *self) { GET_I }; +static PyObject * Degrade_float(Degrade *self) { GET_F }; +static PyObject * Degrade_get(Degrade *self) { GET_F }; static PyObject * Degrade_setBitdepth(Degrade *self, PyObject *arg) { SET_PARAM(self->bitdepth, self->bitdepth_stream, 2); } static PyObject * Degrade_setSrscale(Degrade *self, PyObject *arg) { SET_PARAM(self->srscale, self->srscale_stream, 3); } @@ -2161,6 +2180,7 @@ static PyMethodDef Degrade_methods[] = { {"getServer", (PyCFunction)Degrade_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Degrade_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Degrade_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Degrade_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Degrade_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Degrade_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2191,9 +2211,9 @@ static PyNumberMethods Degrade_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Degrade_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Degrade_float, /*nb_float*/ (binaryfunc)Degrade_inplace_add, /*inplace_add*/ (binaryfunc)Degrade_inplace_sub, /*inplace_subtract*/ (binaryfunc)Degrade_inplace_multiply, /*inplace_multiply*/ @@ -2460,6 +2480,9 @@ static PyObject * Min_sub(Min *self, PyObject *arg) { SUB }; static PyObject * Min_inplace_sub(Min *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Min_div(Min *self, PyObject *arg) { DIV }; static PyObject * Min_inplace_div(Min *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Min_int(Min *self) { GET_I }; +static PyObject * Min_float(Min *self) { GET_F }; +static PyObject * Min_get(Min *self) { GET_F }; static PyObject * Min_setComp(Min *self, PyObject *arg) { SET_PARAM(self->comp, self->comp_stream, 2); } @@ -2478,6 +2501,7 @@ static PyMethodDef Min_methods[] = { {"getServer", (PyCFunction)Min_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Min_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Min_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Min_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Min_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Min_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2507,9 +2531,9 @@ static PyNumberMethods Min_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Min_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Min_float, /*nb_float*/ (binaryfunc)Min_inplace_add, /*inplace_add*/ (binaryfunc)Min_inplace_sub, /*inplace_subtract*/ (binaryfunc)Min_inplace_multiply, /*inplace_multiply*/ @@ -2776,6 +2800,9 @@ static PyObject * Max_sub(Max *self, PyObject *arg) { SUB }; static PyObject * Max_inplace_sub(Max *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Max_div(Max *self, PyObject *arg) { DIV }; static PyObject * Max_inplace_div(Max *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Max_int(Max *self) { GET_I }; +static PyObject * Max_float(Max *self) { GET_F }; +static PyObject * Max_get(Max *self) { GET_F }; static PyObject * Max_setComp(Max *self, PyObject *arg) { SET_PARAM(self->comp, self->comp_stream, 2); } @@ -2794,6 +2821,7 @@ static PyMethodDef Max_methods[] = { {"getServer", (PyCFunction)Max_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Max_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Max_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Max_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Max_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Max_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2823,9 +2851,9 @@ static PyNumberMethods Max_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Max_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Max_float, /*nb_float*/ (binaryfunc)Max_inplace_add, /*inplace_add*/ (binaryfunc)Max_inplace_sub, /*inplace_subtract*/ (binaryfunc)Max_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/exprmodule.c b/src/objects/exprmodule.c index ddfbf789..371b8f05 100644 --- a/src/objects/exprmodule.c +++ b/src/objects/exprmodule.c @@ -1400,6 +1400,9 @@ static PyObject * Expr_sub(Expr *self, PyObject *arg) { SUB }; static PyObject * Expr_inplace_sub(Expr *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Expr_div(Expr *self, PyObject *arg) { DIV }; static PyObject * Expr_inplace_div(Expr *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Expr_int(Expr *self) { GET_I }; +static PyObject * Expr_float(Expr *self) { GET_F }; +static PyObject * Expr_get(Expr *self) { GET_F }; static PyMemberDef Expr_members[] = { @@ -1414,6 +1417,7 @@ static PyMethodDef Expr_methods[] = { {"getServer", (PyCFunction)Expr_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Expr_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Expr_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Expr_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Expr_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Expr_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1442,9 +1446,9 @@ static PyNumberMethods Expr_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Expr_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Expr_float, /*nb_float*/ (binaryfunc)Expr_inplace_add, /*inplace_add*/ (binaryfunc)Expr_inplace_sub, /*inplace_subtract*/ (binaryfunc)Expr_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/fadermodule.c b/src/objects/fadermodule.c index 1fdb63d0..c3ebbe40 100644 --- a/src/objects/fadermodule.c +++ b/src/objects/fadermodule.c @@ -356,6 +356,9 @@ static PyObject * Fader_sub(Fader *self, PyObject *arg) { SUB }; static PyObject * Fader_inplace_sub(Fader *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Fader_div(Fader *self, PyObject *arg) { DIV }; static PyObject * Fader_inplace_div(Fader *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Fader_int(Fader *self) { GET_I }; +static PyObject * Fader_float(Fader *self) { GET_F }; +static PyObject * Fader_get(Fader *self) { GET_F }; static PyObject * Fader_setFadein(Fader *self, PyObject *arg) @@ -404,6 +407,7 @@ static PyMethodDef Fader_methods[] = {"getServer", (PyCFunction)Fader_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Fader_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)Fader_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)Fader_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Fader_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Fader_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setMul", (PyCFunction)Fader_setMul, METH_O, "Sets Fader mul factor."}, @@ -435,9 +439,9 @@ static PyNumberMethods Fader_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Fader_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Fader_float, /*nb_float*/ (binaryfunc)Fader_inplace_add, /*inplace_add*/ (binaryfunc)Fader_inplace_sub, /*inplace_subtract*/ (binaryfunc)Fader_inplace_multiply, /*inplace_multiply*/ @@ -848,6 +852,9 @@ static PyObject * Adsr_sub(Adsr *self, PyObject *arg) { SUB }; static PyObject * Adsr_inplace_sub(Adsr *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Adsr_div(Adsr *self, PyObject *arg) { DIV }; static PyObject * Adsr_inplace_div(Adsr *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Adsr_int(Adsr *self) { GET_I }; +static PyObject * Adsr_float(Adsr *self) { GET_F }; +static PyObject * Adsr_get(Adsr *self) { GET_F }; static PyObject * Adsr_setAttack(Adsr *self, PyObject *arg) @@ -945,6 +952,7 @@ static PyMethodDef Adsr_methods[] = {"getServer", (PyCFunction)Adsr_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Adsr_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)Adsr_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)Adsr_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Adsr_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Adsr_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setMul", (PyCFunction)Adsr_setMul, METH_O, "Sets Adsr mul factor."}, @@ -978,9 +986,9 @@ static PyNumberMethods Adsr_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Adsr_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Adsr_float, /*nb_float*/ (binaryfunc)Adsr_inplace_add, /*inplace_add*/ (binaryfunc)Adsr_inplace_sub, /*inplace_subtract*/ (binaryfunc)Adsr_inplace_multiply, /*inplace_multiply*/ @@ -1318,6 +1326,9 @@ static PyObject * Linseg_sub(Linseg *self, PyObject *arg) { SUB }; static PyObject * Linseg_inplace_sub(Linseg *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Linseg_div(Linseg *self, PyObject *arg) { DIV }; static PyObject * Linseg_inplace_div(Linseg *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Linseg_int(Linseg *self) { GET_I }; +static PyObject * Linseg_float(Linseg *self) { GET_F }; +static PyObject * Linseg_get(Linseg *self) { GET_F }; static PyObject * Linseg_setList(Linseg *self, PyObject *value) @@ -1381,6 +1392,7 @@ static PyMethodDef Linseg_methods[] = { {"getServer", (PyCFunction)Linseg_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Linseg_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Linseg_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Linseg_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Linseg_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"clear", (PyCFunction)Linseg_clear_data, METH_NOARGS, "Resets the data buffer to 0."}, @@ -1412,9 +1424,9 @@ static PyNumberMethods Linseg_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Linseg_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Linseg_float, /*nb_float*/ (binaryfunc)Linseg_inplace_add, /*inplace_add*/ (binaryfunc)Linseg_inplace_sub, /*inplace_subtract*/ (binaryfunc)Linseg_inplace_multiply, /*inplace_multiply*/ @@ -1780,6 +1792,9 @@ static PyObject * Expseg_sub(Expseg *self, PyObject *arg) { SUB }; static PyObject * Expseg_inplace_sub(Expseg *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Expseg_div(Expseg *self, PyObject *arg) { DIV }; static PyObject * Expseg_inplace_div(Expseg *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Expseg_int(Expseg *self) { GET_I }; +static PyObject * Expseg_float(Expseg *self) { GET_F }; +static PyObject * Expseg_get(Expseg *self) { GET_F }; static PyObject * Expseg_setList(Expseg *self, PyObject *value) @@ -1865,6 +1880,7 @@ static PyMethodDef Expseg_methods[] = { {"getServer", (PyCFunction)Expseg_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Expseg_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Expseg_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Expseg_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Expseg_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"pause", (PyCFunction)Expseg_pause, METH_NOARGS, "Toggles between play and stop without reset."}, @@ -1898,9 +1914,9 @@ static PyNumberMethods Expseg_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Expseg_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Expseg_float, /*nb_float*/ (binaryfunc)Expseg_inplace_add, /*inplace_add*/ (binaryfunc)Expseg_inplace_sub, /*inplace_subtract*/ (binaryfunc)Expseg_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/fftmodule.c b/src/objects/fftmodule.c index e7f0ffcc..2b14e5d9 100644 --- a/src/objects/fftmodule.c +++ b/src/objects/fftmodule.c @@ -513,6 +513,9 @@ static PyObject * FFT_sub(FFT *self, PyObject *arg) { SUB }; static PyObject * FFT_inplace_sub(FFT *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FFT_div(FFT *self, PyObject *arg) { DIV }; static PyObject * FFT_inplace_div(FFT *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FFT_int(FFT *self) { GET_I }; +static PyObject * FFT_float(FFT *self) { GET_F }; +static PyObject * FFT_get(FFT *self) { GET_F }; static PyMemberDef FFT_members[] = { @@ -527,6 +530,7 @@ static PyMethodDef FFT_methods[] = { {"getServer", (PyCFunction)FFT_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FFT_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FFT_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FFT_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)FFT_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)FFT_setMul, METH_O, "Sets FFT mul factor."}, @@ -554,9 +558,9 @@ static PyNumberMethods FFT_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FFT_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FFT_float, /*nb_float*/ (binaryfunc)FFT_inplace_add, /*inplace_add*/ (binaryfunc)FFT_inplace_sub, /*inplace_subtract*/ (binaryfunc)FFT_inplace_multiply, /*inplace_multiply*/ @@ -903,6 +907,9 @@ static PyObject * IFFT_sub(IFFT *self, PyObject *arg) { SUB }; static PyObject * IFFT_inplace_sub(IFFT *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IFFT_div(IFFT *self, PyObject *arg) { DIV }; static PyObject * IFFT_inplace_div(IFFT *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IFFT_int(IFFT *self) { GET_I }; +static PyObject * IFFT_float(IFFT *self) { GET_F }; +static PyObject * IFFT_get(IFFT *self) { GET_F }; static PyObject * IFFT_setSize(IFFT *self, PyObject *args, PyObject *kwds) @@ -955,6 +962,7 @@ static PyMethodDef IFFT_methods[] = { {"getServer", (PyCFunction)IFFT_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IFFT_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IFFT_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IFFT_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IFFT_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IFFT_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -985,9 +993,9 @@ static PyNumberMethods IFFT_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IFFT_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IFFT_float, /*nb_float*/ (binaryfunc)IFFT_inplace_add, /*inplace_add*/ (binaryfunc)IFFT_inplace_sub, /*inplace_subtract*/ (binaryfunc)IFFT_inplace_multiply, /*inplace_multiply*/ @@ -1236,6 +1244,9 @@ static PyObject * CarToPol_sub(CarToPol *self, PyObject *arg) { SUB }; static PyObject * CarToPol_inplace_sub(CarToPol *self, PyObject *arg) { INPLACE_SUB }; static PyObject * CarToPol_div(CarToPol *self, PyObject *arg) { DIV }; static PyObject * CarToPol_inplace_div(CarToPol *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * CarToPol_int(CarToPol *self) { GET_I }; +static PyObject * CarToPol_float(CarToPol *self) { GET_F }; +static PyObject * CarToPol_get(CarToPol *self) { GET_F }; static PyMemberDef CarToPol_members[] = { @@ -1252,6 +1263,7 @@ static PyMethodDef CarToPol_methods[] = { {"getServer", (PyCFunction)CarToPol_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)CarToPol_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)CarToPol_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)CarToPol_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)CarToPol_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)CarToPol_setMul, METH_O, "Sets CarToPol mul factor."}, @@ -1279,9 +1291,9 @@ static PyNumberMethods CarToPol_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)CarToPol_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)CarToPol_float, /*nb_float*/ (binaryfunc)CarToPol_inplace_add, /*inplace_add*/ (binaryfunc)CarToPol_inplace_sub, /*inplace_subtract*/ (binaryfunc)CarToPol_inplace_multiply, /*inplace_multiply*/ @@ -1530,6 +1542,9 @@ static PyObject * PolToCar_sub(PolToCar *self, PyObject *arg) { SUB }; static PyObject * PolToCar_inplace_sub(PolToCar *self, PyObject *arg) { INPLACE_SUB }; static PyObject * PolToCar_div(PolToCar *self, PyObject *arg) { DIV }; static PyObject * PolToCar_inplace_div(PolToCar *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * PolToCar_int(PolToCar *self) { GET_I }; +static PyObject * PolToCar_float(PolToCar *self) { GET_F }; +static PyObject * PolToCar_get(PolToCar *self) { GET_F }; static PyMemberDef PolToCar_members[] = { @@ -1546,6 +1561,7 @@ static PyMethodDef PolToCar_methods[] = { {"getServer", (PyCFunction)PolToCar_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)PolToCar_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)PolToCar_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)PolToCar_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)PolToCar_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)PolToCar_setMul, METH_O, "Sets PolToCar mul factor."}, @@ -1573,9 +1589,9 @@ static PyNumberMethods PolToCar_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)PolToCar_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)PolToCar_float, /*nb_float*/ (binaryfunc)PolToCar_inplace_add, /*inplace_add*/ (binaryfunc)PolToCar_inplace_sub, /*inplace_subtract*/ (binaryfunc)PolToCar_inplace_multiply, /*inplace_multiply*/ @@ -2098,6 +2114,9 @@ static PyObject * FrameDelta_sub(FrameDelta *self, PyObject *arg) { SUB }; static PyObject * FrameDelta_inplace_sub(FrameDelta *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FrameDelta_div(FrameDelta *self, PyObject *arg) { DIV }; static PyObject * FrameDelta_inplace_div(FrameDelta *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FrameDelta_int(FrameDelta *self) { GET_I }; +static PyObject * FrameDelta_float(FrameDelta *self) { GET_F }; +static PyObject * FrameDelta_get(FrameDelta *self) { GET_F }; static PyMemberDef FrameDelta_members[] = { @@ -2112,6 +2131,7 @@ static PyMethodDef FrameDelta_methods[] = { {"getServer", (PyCFunction)FrameDelta_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FrameDelta_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FrameDelta_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FrameDelta_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)FrameDelta_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)FrameDelta_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2140,9 +2160,9 @@ static PyNumberMethods FrameDelta_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FrameDelta_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FrameDelta_float, /*nb_float*/ (binaryfunc)FrameDelta_inplace_add, /*inplace_add*/ (binaryfunc)FrameDelta_inplace_sub, /*inplace_subtract*/ (binaryfunc)FrameDelta_inplace_multiply, /*inplace_multiply*/ @@ -2654,6 +2674,9 @@ static PyObject * FrameAccum_sub(FrameAccum *self, PyObject *arg) { SUB }; static PyObject * FrameAccum_inplace_sub(FrameAccum *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FrameAccum_div(FrameAccum *self, PyObject *arg) { DIV }; static PyObject * FrameAccum_inplace_div(FrameAccum *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FrameAccum_int(FrameAccum *self) { GET_I }; +static PyObject * FrameAccum_float(FrameAccum *self) { GET_F }; +static PyObject * FrameAccum_get(FrameAccum *self) { GET_F }; static PyMemberDef FrameAccum_members[] = { @@ -2668,6 +2691,7 @@ static PyMethodDef FrameAccum_methods[] = { {"getServer", (PyCFunction)FrameAccum_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FrameAccum_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FrameAccum_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FrameAccum_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)FrameAccum_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)FrameAccum_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2696,9 +2720,9 @@ static PyNumberMethods FrameAccum_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FrameAccum_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FrameAccum_float, /*nb_float*/ (binaryfunc)FrameAccum_inplace_add, /*inplace_add*/ (binaryfunc)FrameAccum_inplace_sub, /*inplace_subtract*/ (binaryfunc)FrameAccum_inplace_multiply, /*inplace_multiply*/ @@ -3302,6 +3326,9 @@ static PyObject * Vectral_sub(Vectral *self, PyObject *arg) { SUB }; static PyObject * Vectral_inplace_sub(Vectral *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Vectral_div(Vectral *self, PyObject *arg) { DIV }; static PyObject * Vectral_inplace_div(Vectral *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Vectral_int(Vectral *self) { GET_I }; +static PyObject * Vectral_float(Vectral *self) { GET_F }; +static PyObject * Vectral_get(Vectral *self) { GET_F }; static PyMemberDef Vectral_members[] = { @@ -3316,6 +3343,7 @@ static PyMethodDef Vectral_methods[] = { {"getServer", (PyCFunction)Vectral_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Vectral_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Vectral_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Vectral_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Vectral_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Vectral_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3344,9 +3372,9 @@ static PyNumberMethods Vectral_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Vectral_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Vectral_float, /*nb_float*/ (binaryfunc)Vectral_inplace_add, /*inplace_add*/ (binaryfunc)Vectral_inplace_sub, /*inplace_subtract*/ (binaryfunc)Vectral_inplace_multiply, /*inplace_multiply*/ @@ -3953,7 +3981,9 @@ static PyObject * CvlVerb_sub(CvlVerb *self, PyObject *arg) { SUB }; static PyObject * CvlVerb_inplace_sub(CvlVerb *self, PyObject *arg) { INPLACE_SUB }; static PyObject * CvlVerb_div(CvlVerb *self, PyObject *arg) { DIV }; static PyObject * CvlVerb_inplace_div(CvlVerb *self, PyObject *arg) { INPLACE_DIV }; - +static PyObject * CvlVerb_int(CvlVerb *self) { GET_I }; +static PyObject * CvlVerb_float(CvlVerb *self) { GET_F }; +static PyObject * CvlVerb_get(CvlVerb *self) { GET_F }; static PyMemberDef CvlVerb_members[] = { @@ -3970,6 +4000,7 @@ static PyMethodDef CvlVerb_methods[] = { {"getServer", (PyCFunction)CvlVerb_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)CvlVerb_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)CvlVerb_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"out", (PyCFunction)CvlVerb_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"play", (PyCFunction)CvlVerb_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)CvlVerb_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3999,9 +4030,9 @@ static PyNumberMethods CvlVerb_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)CvlVerb_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)CvlVerb_float, /*nb_float*/ (binaryfunc)CvlVerb_inplace_add, /*inplace_add*/ (binaryfunc)CvlVerb_inplace_sub, /*inplace_subtract*/ (binaryfunc)CvlVerb_inplace_multiply, /*inplace_multiply*/ @@ -4864,6 +4895,9 @@ static PyObject * IFFTMatrix_sub(IFFTMatrix *self, PyObject *arg) { SUB }; static PyObject * IFFTMatrix_inplace_sub(IFFTMatrix *self, PyObject *arg) { INPLACE_SUB }; static PyObject * IFFTMatrix_div(IFFTMatrix *self, PyObject *arg) { DIV }; static PyObject * IFFTMatrix_inplace_div(IFFTMatrix *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * IFFTMatrix_int(IFFTMatrix *self) { GET_I }; +static PyObject * IFFTMatrix_float(IFFTMatrix *self) { GET_F }; +static PyObject * IFFTMatrix_get(IFFTMatrix *self) { GET_F }; static PyObject * IFFTMatrix_setIndex(IFFTMatrix *self, PyObject *arg) { @@ -4960,6 +4994,7 @@ static PyMethodDef IFFTMatrix_methods[] = { {"getServer", (PyCFunction)IFFTMatrix_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)IFFTMatrix_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)IFFTMatrix_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)IFFTMatrix_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)IFFTMatrix_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)IFFTMatrix_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4992,9 +5027,9 @@ static PyNumberMethods IFFTMatrix_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)IFFTMatrix_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)IFFTMatrix_float, /*nb_float*/ (binaryfunc)IFFTMatrix_inplace_add, /*inplace_add*/ (binaryfunc)IFFTMatrix_inplace_sub, /*inplace_subtract*/ (binaryfunc)IFFTMatrix_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/filtremodule.c b/src/objects/filtremodule.c index 274e82ff..72e64722 100644 --- a/src/objects/filtremodule.c +++ b/src/objects/filtremodule.c @@ -447,6 +447,9 @@ static PyObject * Biquad_sub(Biquad *self, PyObject *arg) { SUB }; static PyObject * Biquad_inplace_sub(Biquad *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Biquad_div(Biquad *self, PyObject *arg) { DIV }; static PyObject * Biquad_inplace_div(Biquad *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Biquad_int(Biquad *self) { GET_I }; +static PyObject * Biquad_float(Biquad *self) { GET_F }; +static PyObject * Biquad_get(Biquad *self) { GET_F }; static PyObject * Biquad_setFreq(Biquad *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Biquad_setQ(Biquad *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -482,6 +485,7 @@ static PyMethodDef Biquad_methods[] = { {"getServer", (PyCFunction)Biquad_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Biquad_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Biquad_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Biquad_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Biquad_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Biquad_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -513,9 +517,9 @@ static PyNumberMethods Biquad_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Biquad_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Biquad_float, /*nb_float*/ (binaryfunc)Biquad_inplace_add, /*inplace_add*/ (binaryfunc)Biquad_inplace_sub, /*inplace_subtract*/ (binaryfunc)Biquad_inplace_multiply, /*inplace_multiply*/ @@ -1062,6 +1066,9 @@ static PyObject * Biquadx_sub(Biquadx *self, PyObject *arg) { SUB }; static PyObject * Biquadx_inplace_sub(Biquadx *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Biquadx_div(Biquadx *self, PyObject *arg) { DIV }; static PyObject * Biquadx_inplace_div(Biquadx *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Biquadx_int(Biquadx *self) { GET_I }; +static PyObject * Biquadx_float(Biquadx *self) { GET_F }; +static PyObject * Biquadx_get(Biquadx *self) { GET_F }; static PyObject * Biquadx_setFreq(Biquadx *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Biquadx_setQ(Biquadx *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -1111,6 +1118,7 @@ static PyMethodDef Biquadx_methods[] = { {"getServer", (PyCFunction)Biquadx_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Biquadx_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Biquadx_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Biquadx_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Biquadx_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Biquadx_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1143,9 +1151,9 @@ static PyNumberMethods Biquadx_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Biquadx_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Biquadx_float, /*nb_float*/ (binaryfunc)Biquadx_inplace_add, /*inplace_add*/ (binaryfunc)Biquadx_inplace_sub, /*inplace_subtract*/ (binaryfunc)Biquadx_inplace_multiply, /*inplace_multiply*/ @@ -1424,6 +1432,9 @@ static PyObject * Biquada_sub(Biquada *self, PyObject *arg) { SUB }; static PyObject * Biquada_inplace_sub(Biquada *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Biquada_div(Biquada *self, PyObject *arg) { DIV }; static PyObject * Biquada_inplace_div(Biquada *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Biquada_int(Biquada *self) { GET_I }; +static PyObject * Biquada_float(Biquada *self) { GET_F }; +static PyObject * Biquada_get(Biquada *self) { GET_F }; static PyObject * Biquada_setB0(Biquada *self, PyObject *arg) @@ -1511,6 +1522,7 @@ static PyMethodDef Biquada_methods[] = { {"getServer", (PyCFunction)Biquada_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Biquada_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Biquada_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Biquada_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Biquada_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Biquada_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1545,9 +1557,9 @@ static PyNumberMethods Biquada_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Biquada_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Biquada_float, /*nb_float*/ (binaryfunc)Biquada_inplace_add, /*inplace_add*/ (binaryfunc)Biquada_inplace_sub, /*inplace_subtract*/ (binaryfunc)Biquada_inplace_multiply, /*inplace_multiply*/ @@ -2152,6 +2164,9 @@ static PyObject * EQ_sub(EQ *self, PyObject *arg) { SUB }; static PyObject * EQ_inplace_sub(EQ *self, PyObject *arg) { INPLACE_SUB }; static PyObject * EQ_div(EQ *self, PyObject *arg) { DIV }; static PyObject * EQ_inplace_div(EQ *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * EQ_int(EQ *self) { GET_I }; +static PyObject * EQ_float(EQ *self) { GET_F }; +static PyObject * EQ_get(EQ *self) { GET_F }; static PyObject * EQ_setFreq(EQ *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * EQ_setQ(EQ *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -2189,6 +2204,7 @@ static PyMethodDef EQ_methods[] = { {"getServer", (PyCFunction)EQ_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)EQ_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)EQ_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)EQ_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)EQ_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)EQ_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2221,9 +2237,9 @@ static PyNumberMethods EQ_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)EQ_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)EQ_float, /*nb_float*/ (binaryfunc)EQ_inplace_add, /*inplace_add*/ (binaryfunc)EQ_inplace_sub, /*inplace_subtract*/ (binaryfunc)EQ_inplace_multiply, /*inplace_multiply*/ @@ -2623,6 +2639,9 @@ static PyObject * Port_sub(Port *self, PyObject *arg) { SUB }; static PyObject * Port_inplace_sub(Port *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Port_div(Port *self, PyObject *arg) { DIV }; static PyObject * Port_inplace_div(Port *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Port_int(Port *self) { GET_I }; +static PyObject * Port_float(Port *self) { GET_F }; +static PyObject * Port_get(Port *self) { GET_F }; static PyObject * Port_setRiseTime(Port *self, PyObject *arg) { SET_PARAM(self->risetime, self->risetime_stream, 2); } static PyObject * Port_setFallTime(Port *self, PyObject *arg) { SET_PARAM(self->falltime, self->falltime_stream, 3); } @@ -2643,6 +2662,7 @@ static PyMethodDef Port_methods[] = { {"getServer", (PyCFunction)Port_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Port_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Port_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Port_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Port_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Port_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2673,9 +2693,9 @@ static PyNumberMethods Port_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Port_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Port_float, /*nb_float*/ (binaryfunc)Port_inplace_add, /*inplace_add*/ (binaryfunc)Port_inplace_sub, /*inplace_subtract*/ (binaryfunc)Port_inplace_multiply, /*inplace_multiply*/ @@ -2979,6 +2999,9 @@ static PyObject * Tone_sub(Tone *self, PyObject *arg) { SUB }; static PyObject * Tone_inplace_sub(Tone *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Tone_div(Tone *self, PyObject *arg) { DIV }; static PyObject * Tone_inplace_div(Tone *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Tone_int(Tone *self) { GET_I }; +static PyObject * Tone_float(Tone *self) { GET_F }; +static PyObject * Tone_get(Tone *self) { GET_F }; static PyObject * Tone_setFreq(Tone *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -2997,6 +3020,7 @@ static PyMethodDef Tone_methods[] = { {"getServer", (PyCFunction)Tone_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Tone_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Tone_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Tone_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Tone_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Tone_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3026,9 +3050,9 @@ static PyNumberMethods Tone_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Tone_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Tone_float, /*nb_float*/ (binaryfunc)Tone_inplace_add, /*inplace_add*/ (binaryfunc)Tone_inplace_sub, /*inplace_subtract*/ (binaryfunc)Tone_inplace_multiply, /*inplace_multiply*/ @@ -3334,6 +3358,9 @@ static PyObject * Atone_sub(Atone *self, PyObject *arg) { SUB }; static PyObject * Atone_inplace_sub(Atone *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Atone_div(Atone *self, PyObject *arg) { DIV }; static PyObject * Atone_inplace_div(Atone *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Atone_int(Atone *self) { GET_I }; +static PyObject * Atone_float(Atone *self) { GET_F }; +static PyObject * Atone_get(Atone *self) { GET_F }; static PyObject * Atone_setFreq(Atone *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -3352,6 +3379,7 @@ static PyMethodDef Atone_methods[] = { {"getServer", (PyCFunction)Atone_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Atone_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Atone_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Atone_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Atone_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Atone_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3381,9 +3409,9 @@ static PyNumberMethods Atone_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Atone_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Atone_float, /*nb_float*/ (binaryfunc)Atone_inplace_add, /*inplace_add*/ (binaryfunc)Atone_inplace_sub, /*inplace_subtract*/ (binaryfunc)Atone_inplace_multiply, /*inplace_multiply*/ @@ -3618,6 +3646,9 @@ static PyObject * DCBlock_sub(DCBlock *self, PyObject *arg) { SUB }; static PyObject * DCBlock_inplace_sub(DCBlock *self, PyObject *arg) { INPLACE_SUB }; static PyObject * DCBlock_div(DCBlock *self, PyObject *arg) { DIV }; static PyObject * DCBlock_inplace_div(DCBlock *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * DCBlock_int(DCBlock *self) { GET_I }; +static PyObject * DCBlock_float(DCBlock *self) { GET_F }; +static PyObject * DCBlock_get(DCBlock *self) { GET_F }; static PyMemberDef DCBlock_members[] = { @@ -3633,6 +3664,7 @@ static PyMethodDef DCBlock_methods[] = { {"getServer", (PyCFunction)DCBlock_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)DCBlock_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)DCBlock_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)DCBlock_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)DCBlock_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)DCBlock_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3661,9 +3693,9 @@ static PyNumberMethods DCBlock_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)DCBlock_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)DCBlock_float, /*nb_float*/ (binaryfunc)DCBlock_inplace_add, /*inplace_add*/ (binaryfunc)DCBlock_inplace_sub, /*inplace_subtract*/ (binaryfunc)DCBlock_inplace_multiply, /*inplace_multiply*/ @@ -4132,6 +4164,9 @@ static PyObject * Allpass_sub(Allpass *self, PyObject *arg) { SUB }; static PyObject * Allpass_inplace_sub(Allpass *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Allpass_div(Allpass *self, PyObject *arg) { DIV }; static PyObject * Allpass_inplace_div(Allpass *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Allpass_int(Allpass *self) { GET_I }; +static PyObject * Allpass_float(Allpass *self) { GET_F }; +static PyObject * Allpass_get(Allpass *self) { GET_F }; static PyObject * Allpass_setDelay(Allpass *self, PyObject *arg) { SET_PARAM(self->delay, self->delay_stream, 2); } static PyObject * Allpass_setFeedback(Allpass *self, PyObject *arg) { SET_PARAM(self->feedback, self->feedback_stream, 3); } @@ -4152,6 +4187,7 @@ static PyMethodDef Allpass_methods[] = { {"getServer", (PyCFunction)Allpass_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Allpass_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Allpass_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Allpass_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Allpass_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Allpass_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4182,9 +4218,9 @@ static PyNumberMethods Allpass_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Allpass_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Allpass_float, /*nb_float*/ (binaryfunc)Allpass_inplace_add, /*inplace_add*/ (binaryfunc)Allpass_inplace_sub, /*inplace_subtract*/ (binaryfunc)Allpass_inplace_multiply, /*inplace_multiply*/ @@ -4574,6 +4610,9 @@ static PyObject * Allpass2_sub(Allpass2 *self, PyObject *arg) { SUB }; static PyObject * Allpass2_inplace_sub(Allpass2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Allpass2_div(Allpass2 *self, PyObject *arg) { DIV }; static PyObject * Allpass2_inplace_div(Allpass2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Allpass2_int(Allpass2 *self) { GET_I }; +static PyObject * Allpass2_float(Allpass2 *self) { GET_F }; +static PyObject * Allpass2_get(Allpass2 *self) { GET_F }; static PyObject * Allpass2_setFreq(Allpass2 *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Allpass2_setBw(Allpass2 *self, PyObject *arg) { SET_PARAM(self->bw, self->bw_stream, 3); } @@ -4594,6 +4633,7 @@ static PyMethodDef Allpass2_methods[] = { {"getServer", (PyCFunction)Allpass2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Allpass2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Allpass2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Allpass2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Allpass2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Allpass2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4624,9 +4664,9 @@ static PyNumberMethods Allpass2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Allpass2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Allpass2_float, /*nb_float*/ (binaryfunc)Allpass2_inplace_add, /*inplace_add*/ (binaryfunc)Allpass2_inplace_sub, /*inplace_subtract*/ (binaryfunc)Allpass2_inplace_multiply, /*inplace_multiply*/ @@ -5410,6 +5450,9 @@ static PyObject * Phaser_sub(Phaser *self, PyObject *arg) { SUB }; static PyObject * Phaser_inplace_sub(Phaser *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Phaser_div(Phaser *self, PyObject *arg) { DIV }; static PyObject * Phaser_inplace_div(Phaser *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Phaser_int(Phaser *self) { GET_I }; +static PyObject * Phaser_float(Phaser *self) { GET_F }; +static PyObject * Phaser_get(Phaser *self) { GET_F }; static PyObject * Phaser_setFreq(Phaser *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Phaser_setSpread(Phaser *self, PyObject *arg) { SET_PARAM(self->spread, self->spread_stream, 3); } @@ -5434,6 +5477,7 @@ static PyMethodDef Phaser_methods[] = { {"getServer", (PyCFunction)Phaser_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Phaser_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Phaser_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Phaser_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Phaser_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Phaser_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5466,9 +5510,9 @@ static PyNumberMethods Phaser_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Phaser_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Phaser_float, /*nb_float*/ (binaryfunc)Phaser_inplace_add, /*inplace_add*/ (binaryfunc)Phaser_inplace_sub, /*inplace_subtract*/ (binaryfunc)Phaser_inplace_multiply, /*inplace_multiply*/ @@ -6674,6 +6718,9 @@ static PyObject * Vocoder_sub(Vocoder *self, PyObject *arg) { SUB }; static PyObject * Vocoder_inplace_sub(Vocoder *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Vocoder_div(Vocoder *self, PyObject *arg) { DIV }; static PyObject * Vocoder_inplace_div(Vocoder *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Vocoder_int(Vocoder *self) { GET_I }; +static PyObject * Vocoder_float(Vocoder *self) { GET_F }; +static PyObject * Vocoder_get(Vocoder *self) { GET_F }; static PyObject * Vocoder_setFreq(Vocoder *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Vocoder_setSpread(Vocoder *self, PyObject *arg) { SET_PARAM(self->spread, self->spread_stream, 3); } @@ -6713,6 +6760,7 @@ static PyMethodDef Vocoder_methods[] = { {"getServer", (PyCFunction)Vocoder_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Vocoder_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Vocoder_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Vocoder_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Vocoder_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Vocoder_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6746,9 +6794,9 @@ static PyNumberMethods Vocoder_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Vocoder_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Vocoder_float, /*nb_float*/ (binaryfunc)Vocoder_inplace_add, /*inplace_add*/ (binaryfunc)Vocoder_inplace_sub, /*inplace_subtract*/ (binaryfunc)Vocoder_inplace_multiply, /*inplace_multiply*/ @@ -7476,6 +7524,9 @@ static PyObject * SVF_sub(SVF *self, PyObject *arg) { SUB }; static PyObject * SVF_inplace_sub(SVF *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SVF_div(SVF *self, PyObject *arg) { DIV }; static PyObject * SVF_inplace_div(SVF *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SVF_int(SVF *self) { GET_I }; +static PyObject * SVF_float(SVF *self) { GET_F }; +static PyObject * SVF_get(SVF *self) { GET_F }; static PyObject * SVF_setFreq(SVF *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * SVF_setQ(SVF *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -7498,6 +7549,7 @@ static PyMethodDef SVF_methods[] = { {"getServer", (PyCFunction)SVF_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SVF_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SVF_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SVF_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SVF_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SVF_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -7529,9 +7581,9 @@ static PyNumberMethods SVF_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SVF_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SVF_float, /*nb_float*/ (binaryfunc)SVF_inplace_add, /*inplace_add*/ (binaryfunc)SVF_inplace_sub, /*inplace_subtract*/ (binaryfunc)SVF_inplace_multiply, /*inplace_multiply*/ @@ -8277,6 +8329,9 @@ static PyObject * SVF2_sub(SVF2 *self, PyObject *arg) { SUB }; static PyObject * SVF2_inplace_sub(SVF2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SVF2_div(SVF2 *self, PyObject *arg) { DIV }; static PyObject * SVF2_inplace_div(SVF2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SVF2_int(SVF2 *self) { GET_I }; +static PyObject * SVF2_float(SVF2 *self) { GET_F }; +static PyObject * SVF2_get(SVF2 *self) { GET_F }; static PyObject * SVF2_setFreq(SVF2 *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * SVF2_setQ(SVF2 *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -8323,6 +8378,7 @@ static PyMethodDef SVF2_methods[] = { {"getServer", (PyCFunction)SVF2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SVF2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SVF2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SVF2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SVF2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SVF2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -8356,9 +8412,9 @@ static PyNumberMethods SVF2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SVF2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SVF2_float, /*nb_float*/ (binaryfunc)SVF2_inplace_add, /*inplace_add*/ (binaryfunc)SVF2_inplace_sub, /*inplace_subtract*/ (binaryfunc)SVF2_inplace_multiply, /*inplace_multiply*/ @@ -8655,6 +8711,9 @@ static PyObject * Average_sub(Average *self, PyObject *arg) { SUB }; static PyObject * Average_inplace_sub(Average *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Average_div(Average *self, PyObject *arg) { DIV }; static PyObject * Average_inplace_div(Average *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Average_int(Average *self) { GET_I }; +static PyObject * Average_float(Average *self) { GET_F }; +static PyObject * Average_get(Average *self) { GET_F }; static PyObject * Average_setSize(Average *self, PyObject *arg) @@ -8696,6 +8755,7 @@ static PyMethodDef Average_methods[] = { {"getServer", (PyCFunction)Average_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Average_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Average_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Average_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Average_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Average_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -8725,9 +8785,9 @@ static PyNumberMethods Average_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Average_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Average_float, /*nb_float*/ (binaryfunc)Average_inplace_add, /*inplace_add*/ (binaryfunc)Average_inplace_sub, /*inplace_subtract*/ (binaryfunc)Average_inplace_multiply, /*inplace_multiply*/ @@ -9134,6 +9194,9 @@ static PyObject * Reson_sub(Reson *self, PyObject *arg) { SUB }; static PyObject * Reson_inplace_sub(Reson *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Reson_div(Reson *self, PyObject *arg) { DIV }; static PyObject * Reson_inplace_div(Reson *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Reson_int(Reson *self) { GET_I }; +static PyObject * Reson_float(Reson *self) { GET_F }; +static PyObject * Reson_get(Reson *self) { GET_F }; static PyObject * Reson_setFreq(Reson *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Reson_setQ(Reson *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -9154,6 +9217,7 @@ static PyMethodDef Reson_methods[] = { {"getServer", (PyCFunction)Reson_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Reson_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Reson_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Reson_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Reson_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Reson_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -9184,9 +9248,9 @@ static PyNumberMethods Reson_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Reson_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Reson_float, /*nb_float*/ (binaryfunc)Reson_inplace_add, /*inplace_add*/ (binaryfunc)Reson_inplace_sub, /*inplace_subtract*/ (binaryfunc)Reson_inplace_multiply, /*inplace_multiply*/ @@ -9648,6 +9712,9 @@ static PyObject * Resonx_sub(Resonx *self, PyObject *arg) { SUB }; static PyObject * Resonx_inplace_sub(Resonx *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Resonx_div(Resonx *self, PyObject *arg) { DIV }; static PyObject * Resonx_inplace_div(Resonx *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Resonx_int(Resonx *self) { GET_I }; +static PyObject * Resonx_float(Resonx *self) { GET_F }; +static PyObject * Resonx_get(Resonx *self) { GET_F }; static PyObject * Resonx_setFreq(Resonx *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Resonx_setQ(Resonx *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -9682,6 +9749,7 @@ static PyMethodDef Resonx_methods[] = { {"getServer", (PyCFunction)Resonx_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Resonx_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Resonx_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Resonx_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Resonx_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Resonx_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -9713,9 +9781,9 @@ static PyNumberMethods Resonx_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Resonx_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Resonx_float, /*nb_float*/ (binaryfunc)Resonx_inplace_add, /*inplace_add*/ (binaryfunc)Resonx_inplace_sub, /*inplace_subtract*/ (binaryfunc)Resonx_inplace_multiply, /*inplace_multiply*/ @@ -10047,6 +10115,9 @@ static PyObject * ButLP_sub(ButLP *self, PyObject *arg) { SUB }; static PyObject * ButLP_inplace_sub(ButLP *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ButLP_div(ButLP *self, PyObject *arg) { DIV }; static PyObject * ButLP_inplace_div(ButLP *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ButLP_int(ButLP *self) { GET_I }; +static PyObject * ButLP_float(ButLP *self) { GET_F }; +static PyObject * ButLP_get(ButLP *self) { GET_F }; static PyObject * ButLP_setFreq(ButLP *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -10065,6 +10136,7 @@ static PyMethodDef ButLP_methods[] = { {"getServer", (PyCFunction)ButLP_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ButLP_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ButLP_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ButLP_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ButLP_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ButLP_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -10094,9 +10166,9 @@ static PyNumberMethods ButLP_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ButLP_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ButLP_float, /*nb_float*/ (binaryfunc)ButLP_inplace_add, /*inplace_add*/ (binaryfunc)ButLP_inplace_sub, /*inplace_subtract*/ (binaryfunc)ButLP_inplace_multiply, /*inplace_multiply*/ @@ -10428,6 +10500,9 @@ static PyObject * ButHP_sub(ButHP *self, PyObject *arg) { SUB }; static PyObject * ButHP_inplace_sub(ButHP *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ButHP_div(ButHP *self, PyObject *arg) { DIV }; static PyObject * ButHP_inplace_div(ButHP *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ButHP_int(ButHP *self) { GET_I }; +static PyObject * ButHP_float(ButHP *self) { GET_F }; +static PyObject * ButHP_get(ButHP *self) { GET_F }; static PyObject * ButHP_setFreq(ButHP *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -10446,6 +10521,7 @@ static PyMethodDef ButHP_methods[] = { {"getServer", (PyCFunction)ButHP_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ButHP_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ButHP_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ButHP_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ButHP_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ButHP_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -10475,9 +10551,9 @@ static PyNumberMethods ButHP_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ButHP_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ButHP_float, /*nb_float*/ (binaryfunc)ButHP_inplace_add, /*inplace_add*/ (binaryfunc)ButHP_inplace_sub, /*inplace_subtract*/ (binaryfunc)ButHP_inplace_multiply, /*inplace_multiply*/ @@ -10891,6 +10967,9 @@ static PyObject * ButBP_sub(ButBP *self, PyObject *arg) { SUB }; static PyObject * ButBP_inplace_sub(ButBP *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ButBP_div(ButBP *self, PyObject *arg) { DIV }; static PyObject * ButBP_inplace_div(ButBP *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ButBP_int(ButBP *self) { GET_I }; +static PyObject * ButBP_float(ButBP *self) { GET_F }; +static PyObject * ButBP_get(ButBP *self) { GET_F }; static PyObject * ButBP_setFreq(ButBP *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * ButBP_setQ(ButBP *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -10911,6 +10990,7 @@ static PyMethodDef ButBP_methods[] = { {"getServer", (PyCFunction)ButBP_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ButBP_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ButBP_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ButBP_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ButBP_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ButBP_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -10941,9 +11021,9 @@ static PyNumberMethods ButBP_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ButBP_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ButBP_float, /*nb_float*/ (binaryfunc)ButBP_inplace_add, /*inplace_add*/ (binaryfunc)ButBP_inplace_sub, /*inplace_subtract*/ (binaryfunc)ButBP_inplace_multiply, /*inplace_multiply*/ @@ -11357,6 +11437,9 @@ static PyObject * ButBR_sub(ButBR *self, PyObject *arg) { SUB }; static PyObject * ButBR_inplace_sub(ButBR *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ButBR_div(ButBR *self, PyObject *arg) { DIV }; static PyObject * ButBR_inplace_div(ButBR *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ButBR_int(ButBR *self) { GET_I }; +static PyObject * ButBR_float(ButBR *self) { GET_F }; +static PyObject * ButBR_get(ButBR *self) { GET_F }; static PyObject * ButBR_setFreq(ButBR *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * ButBR_setQ(ButBR *self, PyObject *arg) { SET_PARAM(self->q, self->q_stream, 3); } @@ -11377,6 +11460,7 @@ static PyMethodDef ButBR_methods[] = { {"getServer", (PyCFunction)ButBR_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ButBR_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ButBR_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ButBR_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ButBR_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ButBR_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -11407,9 +11491,9 @@ static PyNumberMethods ButBR_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ButBR_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ButBR_float, /*nb_float*/ (binaryfunc)ButBR_inplace_add, /*inplace_add*/ (binaryfunc)ButBR_inplace_sub, /*inplace_subtract*/ (binaryfunc)ButBR_inplace_multiply, /*inplace_multiply*/ @@ -11832,6 +11916,9 @@ static PyObject * ComplexRes_sub(ComplexRes *self, PyObject *arg) { SUB }; static PyObject * ComplexRes_inplace_sub(ComplexRes *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ComplexRes_div(ComplexRes *self, PyObject *arg) { DIV }; static PyObject * ComplexRes_inplace_div(ComplexRes *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ComplexRes_int(ComplexRes *self) { GET_I }; +static PyObject * ComplexRes_float(ComplexRes *self) { GET_F }; +static PyObject * ComplexRes_get(ComplexRes *self) { GET_F }; static PyObject * ComplexRes_setFreq(ComplexRes *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * ComplexRes_setDecay(ComplexRes *self, PyObject *arg) { SET_PARAM(self->decay, self->decay_stream, 3); } @@ -11852,6 +11939,7 @@ static PyMethodDef ComplexRes_methods[] = { {"getServer", (PyCFunction)ComplexRes_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ComplexRes_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ComplexRes_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ComplexRes_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ComplexRes_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ComplexRes_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -11882,9 +11970,9 @@ static PyNumberMethods ComplexRes_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ComplexRes_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ComplexRes_float, /*nb_float*/ (binaryfunc)ComplexRes_inplace_add, /*inplace_add*/ (binaryfunc)ComplexRes_inplace_sub, /*inplace_subtract*/ (binaryfunc)ComplexRes_inplace_multiply, /*inplace_multiply*/ @@ -12324,6 +12412,9 @@ static PyObject * MoogLP_sub(MoogLP *self, PyObject *arg) { SUB }; static PyObject * MoogLP_inplace_sub(MoogLP *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MoogLP_div(MoogLP *self, PyObject *arg) { DIV }; static PyObject * MoogLP_inplace_div(MoogLP *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MoogLP_int(MoogLP *self) { GET_I }; +static PyObject * MoogLP_float(MoogLP *self) { GET_F }; +static PyObject * MoogLP_get(MoogLP *self) { GET_F }; static PyObject * MoogLP_setFreq(MoogLP *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * MoogLP_setRes(MoogLP *self, PyObject *arg) { SET_PARAM(self->res, self->res_stream, 3); } @@ -12344,6 +12435,7 @@ static PyMethodDef MoogLP_methods[] = { {"getServer", (PyCFunction)MoogLP_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MoogLP_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MoogLP_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MoogLP_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MoogLP_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MoogLP_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -12374,9 +12466,9 @@ static PyNumberMethods MoogLP_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MoogLP_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MoogLP_float, /*nb_float*/ (binaryfunc)MoogLP_inplace_add, /*inplace_add*/ (binaryfunc)MoogLP_inplace_sub, /*inplace_subtract*/ (binaryfunc)MoogLP_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/freeverbmodule.c b/src/objects/freeverbmodule.c index c1db6ff0..95703d7f 100644 --- a/src/objects/freeverbmodule.c +++ b/src/objects/freeverbmodule.c @@ -818,6 +818,9 @@ static PyObject * Freeverb_sub(Freeverb *self, PyObject *arg) { SUB }; static PyObject * Freeverb_inplace_sub(Freeverb *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Freeverb_div(Freeverb *self, PyObject *arg) { DIV }; static PyObject * Freeverb_inplace_div(Freeverb *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Freeverb_int(Freeverb *self) { GET_I }; +static PyObject * Freeverb_float(Freeverb *self) { GET_F }; +static PyObject * Freeverb_get(Freeverb *self) { GET_F }; static PyObject * Freeverb_setSize(Freeverb *self, PyObject *arg) { SET_PARAM(self->size, self->size_stream, 2); } static PyObject * Freeverb_setDamp(Freeverb *self, PyObject *arg) { SET_PARAM(self->damp, self->damp_stream, 3); } @@ -869,6 +872,7 @@ static PyMethodDef Freeverb_methods[] = { {"getServer", (PyCFunction)Freeverb_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Freeverb_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Freeverb_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Freeverb_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Freeverb_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Freeverb_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -901,9 +905,9 @@ static PyNumberMethods Freeverb_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Freeverb_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Freeverb_float, /*nb_float*/ (binaryfunc)Freeverb_inplace_add, /*inplace_add*/ (binaryfunc)Freeverb_inplace_sub, /*inplace_subtract*/ (binaryfunc)Freeverb_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/granulatormodule.c b/src/objects/granulatormodule.c index becb470c..be9c8f47 100644 --- a/src/objects/granulatormodule.c +++ b/src/objects/granulatormodule.c @@ -900,6 +900,9 @@ static PyObject * Granulator_sub(Granulator *self, PyObject *arg) { SUB }; static PyObject * Granulator_inplace_sub(Granulator *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Granulator_div(Granulator *self, PyObject *arg) { DIV }; static PyObject * Granulator_inplace_div(Granulator *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Granulator_int(Granulator *self) { GET_I }; +static PyObject * Granulator_float(Granulator *self) { GET_F }; +static PyObject * Granulator_get(Granulator *self) { GET_F }; static PyObject * Granulator_setPitch(Granulator *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 2); } static PyObject * Granulator_setPos(Granulator *self, PyObject *arg) { SET_PARAM(self->pos, self->pos_stream, 3); } @@ -1004,6 +1007,7 @@ static PyMethodDef Granulator_methods[] = {"setEnv", (PyCFunction)Granulator_setEnv, METH_O, "Sets envelope table."}, {"getServer", (PyCFunction)Granulator_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Granulator_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Granulator_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Granulator_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Granulator_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Granulator_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1037,9 +1041,9 @@ static PyNumberMethods Granulator_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Granulator_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Granulator_float, /*nb_float*/ (binaryfunc)Granulator_inplace_add, /*inplace_add*/ (binaryfunc)Granulator_inplace_sub, /*inplace_subtract*/ (binaryfunc)Granulator_inplace_multiply, /*inplace_multiply*/ @@ -2184,6 +2188,9 @@ static PyObject * Looper_sub(Looper *self, PyObject *arg) { SUB }; static PyObject * Looper_inplace_sub(Looper *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Looper_div(Looper *self, PyObject *arg) { DIV }; static PyObject * Looper_inplace_div(Looper *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Looper_int(Looper *self) { GET_I }; +static PyObject * Looper_float(Looper *self) { GET_F }; +static PyObject * Looper_get(Looper *self) { GET_F }; static PyObject * Looper_setPitch(Looper *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 2); } static PyObject * Looper_setStart(Looper *self, PyObject *arg) { SET_PARAM(self->start, self->start_stream, 3); } @@ -2343,6 +2350,7 @@ static PyMethodDef Looper_methods[] = {"getServer", (PyCFunction)Looper_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Looper_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)Looper_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)Looper_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Looper_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Looper_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Looper_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2384,9 +2392,9 @@ static PyNumberMethods Looper_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Looper_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Looper_float, /*nb_float*/ (binaryfunc)Looper_inplace_add, /*inplace_add*/ (binaryfunc)Looper_inplace_sub, /*inplace_subtract*/ (binaryfunc)Looper_inplace_multiply, /*inplace_multiply*/ @@ -2598,6 +2606,9 @@ static PyObject * LooperTimeStream_sub(LooperTimeStream *self, PyObject *arg) { static PyObject * LooperTimeStream_inplace_sub(LooperTimeStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * LooperTimeStream_div(LooperTimeStream *self, PyObject *arg) { DIV }; static PyObject * LooperTimeStream_inplace_div(LooperTimeStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * LooperTimeStream_int(LooperTimeStream *self) { GET_I }; +static PyObject * LooperTimeStream_float(LooperTimeStream *self) { GET_F }; +static PyObject * LooperTimeStream_get(LooperTimeStream *self) { GET_F }; static PyMemberDef LooperTimeStream_members[] = { @@ -2612,6 +2623,7 @@ static PyMethodDef LooperTimeStream_methods[] = { {"getServer", (PyCFunction)LooperTimeStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)LooperTimeStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)LooperTimeStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)LooperTimeStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)LooperTimeStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)LooperTimeStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2640,9 +2652,9 @@ static PyNumberMethods LooperTimeStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)LooperTimeStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)LooperTimeStream_float, /*nb_float*/ (binaryfunc)LooperTimeStream_inplace_add, /*inplace_add*/ (binaryfunc)LooperTimeStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)LooperTimeStream_inplace_multiply, /*inplace_multiply*/ @@ -3198,6 +3210,9 @@ static PyObject * Granule_sub(Granule *self, PyObject *arg) { SUB }; static PyObject * Granule_inplace_sub(Granule *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Granule_div(Granule *self, PyObject *arg) { DIV }; static PyObject * Granule_inplace_div(Granule *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Granule_int(Granule *self) { GET_I }; +static PyObject * Granule_float(Granule *self) { GET_F }; +static PyObject * Granule_get(Granule *self) { GET_F }; static PyObject * Granule_setDens(Granule *self, PyObject *arg) { SET_PARAM(self->dens, self->dens_stream, 2); } static PyObject * Granule_setPitch(Granule *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 3); } @@ -3279,6 +3294,7 @@ static PyMethodDef Granule_methods[] = {"setEnv", (PyCFunction)Granule_setEnv, METH_O, "Sets envelope table."}, {"getServer", (PyCFunction)Granule_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Granule_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Granule_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Granule_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Granule_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Granule_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3312,9 +3328,9 @@ static PyNumberMethods Granule_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Granule_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Granule_float, /*nb_float*/ (binaryfunc)Granule_inplace_add, /*inplace_add*/ (binaryfunc)Granule_inplace_sub, /*inplace_subtract*/ (binaryfunc)Granule_inplace_multiply, /*inplace_multiply*/ @@ -4500,6 +4516,9 @@ static PyObject * Particle_sub(Particle *self, PyObject *arg) { SUB }; static PyObject * Particle_inplace_sub(Particle *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Particle_div(Particle *self, PyObject *arg) { DIV }; static PyObject * Particle_inplace_div(Particle *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Particle_int(Particle *self) { GET_I }; +static PyObject * Particle_float(Particle *self) { GET_F }; +static PyObject * Particle_get(Particle *self) { GET_F }; static PyMemberDef Particle_members[] = { @@ -4514,6 +4533,7 @@ static PyMethodDef Particle_methods[] = { {"getServer", (PyCFunction)Particle_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Particle_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Particle_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Particle_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Particle_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Particle_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4542,9 +4562,9 @@ static PyNumberMethods Particle_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Particle_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Particle_float, /*nb_float*/ (binaryfunc)Particle_inplace_add, /*inplace_add*/ (binaryfunc)Particle_inplace_sub, /*inplace_subtract*/ (binaryfunc)Particle_inplace_multiply, /*inplace_multiply*/ @@ -6149,6 +6169,9 @@ static PyObject * Particle2_sub(Particle2 *self, PyObject *arg) { SUB }; static PyObject * Particle2_inplace_sub(Particle2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Particle2_div(Particle2 *self, PyObject *arg) { DIV }; static PyObject * Particle2_inplace_div(Particle2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Particle2_int(Particle2 *self) { GET_I }; +static PyObject * Particle2_float(Particle2 *self) { GET_F }; +static PyObject * Particle2_get(Particle2 *self) { GET_F }; static PyMemberDef Particle2_members[] = { @@ -6163,6 +6186,7 @@ static PyMethodDef Particle2_methods[] = { {"getServer", (PyCFunction)Particle2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Particle2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Particle2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Particle2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Particle2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Particle2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6191,9 +6215,9 @@ static PyNumberMethods Particle2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Particle2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Particle2_float, /*nb_float*/ (binaryfunc)Particle2_inplace_add, /*inplace_add*/ (binaryfunc)Particle2_inplace_sub, /*inplace_subtract*/ (binaryfunc)Particle2_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/harmonizermodule.c b/src/objects/harmonizermodule.c index f135068e..f107f021 100644 --- a/src/objects/harmonizermodule.c +++ b/src/objects/harmonizermodule.c @@ -592,6 +592,9 @@ static PyObject * Harmonizer_sub(Harmonizer *self, PyObject *arg) { SUB }; static PyObject * Harmonizer_inplace_sub(Harmonizer *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Harmonizer_div(Harmonizer *self, PyObject *arg) { DIV }; static PyObject * Harmonizer_inplace_div(Harmonizer *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Harmonizer_int(Harmonizer *self) { GET_I }; +static PyObject * Harmonizer_float(Harmonizer *self) { GET_F }; +static PyObject * Harmonizer_get(Harmonizer *self) { GET_F }; static PyObject * Harmonizer_setTranspo(Harmonizer *self, PyObject *arg) {SET_PARAM(self->transpo, self->transpo_stream, 2); } static PyObject * Harmonizer_setFeedback(Harmonizer *self, PyObject *arg) { SET_PARAM(self->feedback, self->feedback_stream, 3); } @@ -645,6 +648,7 @@ static PyMethodDef Harmonizer_methods[] = { {"getServer", (PyCFunction)Harmonizer_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Harmonizer_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Harmonizer_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Harmonizer_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Harmonizer_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Harmonizer_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -677,9 +681,9 @@ static PyNumberMethods Harmonizer_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Harmonizer_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Harmonizer_float, /*nb_float*/ (binaryfunc)Harmonizer_inplace_add, /*inplace_add*/ (binaryfunc)Harmonizer_inplace_sub, /*inplace_subtract*/ (binaryfunc)Harmonizer_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/hilbertmodule.c b/src/objects/hilbertmodule.c index 4d3be757..af0201fb 100644 --- a/src/objects/hilbertmodule.c +++ b/src/objects/hilbertmodule.c @@ -407,6 +407,9 @@ static PyObject * Hilbert_sub(Hilbert *self, PyObject *arg) { SUB }; static PyObject * Hilbert_inplace_sub(Hilbert *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Hilbert_div(Hilbert *self, PyObject *arg) { DIV }; static PyObject * Hilbert_inplace_div(Hilbert *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Hilbert_int(Hilbert *self) { GET_I }; +static PyObject * Hilbert_float(Hilbert *self) { GET_F }; +static PyObject * Hilbert_get(Hilbert *self) { GET_F }; static PyMemberDef Hilbert_members[] = { @@ -421,6 +424,7 @@ static PyMethodDef Hilbert_methods[] = { {"getServer", (PyCFunction)Hilbert_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Hilbert_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Hilbert_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Hilbert_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Hilbert_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Hilbert_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -449,9 +453,9 @@ static PyNumberMethods Hilbert_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Hilbert_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Hilbert_float, /*nb_float*/ (binaryfunc)Hilbert_inplace_add, /*inplace_add*/ (binaryfunc)Hilbert_inplace_sub, /*inplace_subtract*/ (binaryfunc)Hilbert_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/hrtfmodule.c b/src/objects/hrtfmodule.c index 5096046c..56fbd75a 100644 --- a/src/objects/hrtfmodule.c +++ b/src/objects/hrtfmodule.c @@ -980,6 +980,9 @@ static PyObject * HRTF_sub(HRTF *self, PyObject *arg) { SUB }; static PyObject * HRTF_inplace_sub(HRTF *self, PyObject *arg) { INPLACE_SUB }; static PyObject * HRTF_div(HRTF *self, PyObject *arg) { DIV }; static PyObject * HRTF_inplace_div(HRTF *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * HRTF_int(HRTF *self) { GET_I }; +static PyObject * HRTF_float(HRTF *self) { GET_F }; +static PyObject * HRTF_get(HRTF *self) { GET_F }; static PyMemberDef HRTF_members[] = { @@ -994,6 +997,7 @@ static PyMethodDef HRTF_methods[] = { {"getServer", (PyCFunction)HRTF_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)HRTF_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)HRTF_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)HRTF_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)HRTF_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)HRTF_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1022,9 +1026,9 @@ static PyNumberMethods HRTF_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)HRTF_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)HRTF_float, /*nb_float*/ (binaryfunc)HRTF_inplace_add, /*inplace_add*/ (binaryfunc)HRTF_inplace_sub, /*inplace_subtract*/ (binaryfunc)HRTF_inplace_multiply, /*inplace_multiply*/ @@ -1690,6 +1694,9 @@ static PyObject * Binaural_sub(Binaural *self, PyObject *arg) { SUB }; static PyObject * Binaural_inplace_sub(Binaural *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Binaural_div(Binaural *self, PyObject *arg) { DIV }; static PyObject * Binaural_inplace_div(Binaural *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Binaural_int(Binaural *self) { GET_I }; +static PyObject * Binaural_float(Binaural *self) { GET_F }; +static PyObject * Binaural_get(Binaural *self) { GET_F }; static PyMemberDef Binaural_members[] = { @@ -1704,6 +1711,7 @@ static PyMethodDef Binaural_methods[] = { {"getServer", (PyCFunction)Binaural_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Binaural_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Binaural_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Binaural_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Binaural_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Binaural_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1732,9 +1740,9 @@ static PyNumberMethods Binaural_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Binaural_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Binaural_float, /*nb_float*/ (binaryfunc)Binaural_inplace_add, /*inplace_add*/ (binaryfunc)Binaural_inplace_sub, /*inplace_subtract*/ (binaryfunc)Binaural_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/inputmodule.c b/src/objects/inputmodule.c index a81d7b69..ff0ceec7 100644 --- a/src/objects/inputmodule.c +++ b/src/objects/inputmodule.c @@ -184,6 +184,9 @@ static PyObject * Input_sub(Input *self, PyObject *arg) { SUB }; static PyObject * Input_inplace_sub(Input *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Input_div(Input *self, PyObject *arg) { DIV }; static PyObject * Input_inplace_div(Input *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Input_int(Input *self) { GET_I }; +static PyObject * Input_float(Input *self) { GET_F }; +static PyObject * Input_get(Input *self) { GET_F }; static PyMemberDef Input_members[] = { @@ -198,6 +201,7 @@ static PyMethodDef Input_methods[] = { {"getServer", (PyCFunction)Input_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Input_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Input_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Input_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Input_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Input_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -226,9 +230,9 @@ static PyNumberMethods Input_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Input_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Input_float, /*nb_float*/ (binaryfunc)Input_inplace_add, /*inplace_add*/ (binaryfunc)Input_inplace_sub, /*inplace_subtract*/ (binaryfunc)Input_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/lfomodule.c b/src/objects/lfomodule.c index ca426c88..704fc539 100644 --- a/src/objects/lfomodule.c +++ b/src/objects/lfomodule.c @@ -1422,6 +1422,9 @@ static PyObject * LFO_sub(LFO *self, PyObject *arg) { SUB }; static PyObject * LFO_inplace_sub(LFO *self, PyObject *arg) { INPLACE_SUB }; static PyObject * LFO_div(LFO *self, PyObject *arg) { DIV }; static PyObject * LFO_inplace_div(LFO *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * LFO_int(LFO *self) { GET_I }; +static PyObject * LFO_float(LFO *self) { GET_F }; +static PyObject * LFO_get(LFO *self) { GET_F }; static PyObject * LFO_setFreq(LFO *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * LFO_setSharp(LFO *self, PyObject *arg) { SET_PARAM(self->sharp, self->sharp_stream, 3); } @@ -1470,6 +1473,7 @@ static PyMethodDef LFO_methods[] = { {"getServer", (PyCFunction)LFO_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)LFO_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)LFO_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)LFO_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)LFO_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)LFO_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1502,9 +1506,9 @@ static PyNumberMethods LFO_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)LFO_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)LFO_float, /*nb_float*/ (binaryfunc)LFO_inplace_add, /*inplace_add*/ (binaryfunc)LFO_inplace_sub, /*inplace_subtract*/ (binaryfunc)LFO_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/matrixprocessmodule.c b/src/objects/matrixprocessmodule.c index 9dbeec67..9de9edc5 100644 --- a/src/objects/matrixprocessmodule.c +++ b/src/objects/matrixprocessmodule.c @@ -223,6 +223,9 @@ static PyObject * MatrixPointer_sub(MatrixPointer *self, PyObject *arg) { SUB }; static PyObject * MatrixPointer_inplace_sub(MatrixPointer *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MatrixPointer_div(MatrixPointer *self, PyObject *arg) { DIV }; static PyObject * MatrixPointer_inplace_div(MatrixPointer *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MatrixPointer_int(MatrixPointer *self) { GET_I }; +static PyObject * MatrixPointer_float(MatrixPointer *self) { GET_F }; +static PyObject * MatrixPointer_get(MatrixPointer *self) { GET_F }; static PyObject * MatrixPointer_getMatrix(MatrixPointer* self) @@ -309,6 +312,7 @@ static PyMethodDef MatrixPointer_methods[] = {"getMatrix", (PyCFunction)MatrixPointer_getMatrix, METH_NOARGS, "Returns waveform matrix object."}, {"getServer", (PyCFunction)MatrixPointer_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MatrixPointer_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MatrixPointer_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MatrixPointer_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MatrixPointer_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MatrixPointer_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -340,9 +344,9 @@ static PyNumberMethods MatrixPointer_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MatrixPointer_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MatrixPointer_float, /*nb_float*/ (binaryfunc)MatrixPointer_inplace_add, /*inplace_add*/ (binaryfunc)MatrixPointer_inplace_sub, /*inplace_subtract*/ (binaryfunc)MatrixPointer_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/metromodule.c b/src/objects/metromodule.c index a5a391cd..62a99f11 100644 --- a/src/objects/metromodule.c +++ b/src/objects/metromodule.c @@ -262,6 +262,9 @@ static PyObject * Metro_sub(Metro *self, PyObject *arg) { SUB }; static PyObject * Metro_inplace_sub(Metro *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Metro_div(Metro *self, PyObject *arg) { DIV }; static PyObject * Metro_inplace_div(Metro *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Metro_int(Metro *self) { GET_I }; +static PyObject * Metro_float(Metro *self) { GET_F }; +static PyObject * Metro_get(Metro *self) { GET_F }; static PyObject * Metro_setTime(Metro *self, PyObject *arg) { SET_PARAM(self->time, self->time_stream, 2); } @@ -279,6 +282,7 @@ static PyMethodDef Metro_methods[] = { {"getServer", (PyCFunction)Metro_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Metro_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Metro_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Metro_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Metro_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setTime", (PyCFunction)Metro_setTime, METH_O, "Sets time factor."}, @@ -307,9 +311,9 @@ static PyNumberMethods Metro_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Metro_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Metro_float, /*nb_float*/ (binaryfunc)Metro_inplace_add, /*inplace_add*/ (binaryfunc)Metro_inplace_sub, /*inplace_subtract*/ (binaryfunc)Metro_inplace_multiply, /*inplace_multiply*/ @@ -1023,6 +1027,9 @@ static PyObject * Seq_sub(Seq *self, PyObject *arg) { SUB }; static PyObject * Seq_inplace_sub(Seq *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Seq_div(Seq *self, PyObject *arg) { DIV }; static PyObject * Seq_inplace_div(Seq *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Seq_int(Seq *self) { GET_I }; +static PyObject * Seq_float(Seq *self) { GET_F }; +static PyObject * Seq_get(Seq *self) { GET_F }; static PyMemberDef Seq_members[] = { @@ -1037,6 +1044,7 @@ static PyMethodDef Seq_methods[] = { {"getServer", (PyCFunction)Seq_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Seq_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Seq_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Seq_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Seq_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Seq_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1065,9 +1073,9 @@ static PyNumberMethods Seq_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Seq_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Seq_float, /*nb_float*/ (binaryfunc)Seq_inplace_add, /*inplace_add*/ (binaryfunc)Seq_inplace_sub, /*inplace_subtract*/ (binaryfunc)Seq_inplace_multiply, /*inplace_multiply*/ @@ -1532,6 +1540,9 @@ static PyObject * Cloud_sub(Cloud *self, PyObject *arg) { SUB }; static PyObject * Cloud_inplace_sub(Cloud *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Cloud_div(Cloud *self, PyObject *arg) { DIV }; static PyObject * Cloud_inplace_div(Cloud *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Cloud_int(Cloud *self) { GET_I }; +static PyObject * Cloud_float(Cloud *self) { GET_F }; +static PyObject * Cloud_get(Cloud *self) { GET_F }; static PyMemberDef Cloud_members[] = { @@ -1546,6 +1557,7 @@ static PyMethodDef Cloud_methods[] = { {"getServer", (PyCFunction)Cloud_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Cloud_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Cloud_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Cloud_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Cloud_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Cloud_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1574,9 +1586,9 @@ static PyNumberMethods Cloud_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Cloud_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Cloud_float, /*nb_float*/ (binaryfunc)Cloud_inplace_add, /*inplace_add*/ (binaryfunc)Cloud_inplace_sub, /*inplace_subtract*/ (binaryfunc)Cloud_inplace_multiply, /*inplace_multiply*/ @@ -1789,6 +1801,9 @@ static PyObject * Trig_sub(Trig *self, PyObject *arg) { SUB }; static PyObject * Trig_inplace_sub(Trig *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Trig_div(Trig *self, PyObject *arg) { DIV }; static PyObject * Trig_inplace_div(Trig *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Trig_int(Trig *self) { GET_I }; +static PyObject * Trig_float(Trig *self) { GET_F }; +static PyObject * Trig_get(Trig *self) { GET_F }; static PyMemberDef Trig_members[] = { @@ -1803,6 +1818,7 @@ static PyMethodDef Trig_methods[] = { {"getServer", (PyCFunction)Trig_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Trig_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Trig_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Trig_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Trig_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)Trig_setMul, METH_O, "Sets oscillator mul factor."}, @@ -1830,9 +1846,9 @@ static PyNumberMethods Trig_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Trig_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Trig_float, /*nb_float*/ (binaryfunc)Trig_inplace_add, /*inplace_add*/ (binaryfunc)Trig_inplace_sub, /*inplace_subtract*/ (binaryfunc)Trig_inplace_multiply, /*inplace_multiply*/ @@ -2995,6 +3011,9 @@ static PyObject * Beat_sub(Beat *self, PyObject *arg) { SUB }; static PyObject * Beat_inplace_sub(Beat *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Beat_div(Beat *self, PyObject *arg) { DIV }; static PyObject * Beat_inplace_div(Beat *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Beat_int(Beat *self) { GET_I }; +static PyObject * Beat_float(Beat *self) { GET_F }; +static PyObject * Beat_get(Beat *self) { GET_F }; static PyMemberDef Beat_members[] = { @@ -3009,6 +3028,7 @@ static PyMethodDef Beat_methods[] = { {"getServer", (PyCFunction)Beat_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Beat_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Beat_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Beat_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Beat_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Beat_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3037,9 +3057,9 @@ static PyNumberMethods Beat_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Beat_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Beat_float, /*nb_float*/ (binaryfunc)Beat_inplace_add, /*inplace_add*/ (binaryfunc)Beat_inplace_sub, /*inplace_subtract*/ (binaryfunc)Beat_inplace_multiply, /*inplace_multiply*/ @@ -3257,6 +3277,9 @@ static PyObject * BeatTapStream_sub(BeatTapStream *self, PyObject *arg) { SUB }; static PyObject * BeatTapStream_inplace_sub(BeatTapStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BeatTapStream_div(BeatTapStream *self, PyObject *arg) { DIV }; static PyObject * BeatTapStream_inplace_div(BeatTapStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BeatTapStream_int(BeatTapStream *self) { GET_I }; +static PyObject * BeatTapStream_float(BeatTapStream *self) { GET_F }; +static PyObject * BeatTapStream_get(BeatTapStream *self) { GET_F }; static PyMemberDef BeatTapStream_members[] = { @@ -3271,6 +3294,7 @@ static PyMethodDef BeatTapStream_methods[] = { {"getServer", (PyCFunction)BeatTapStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BeatTapStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BeatTapStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BeatTapStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BeatTapStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BeatTapStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3299,9 +3323,9 @@ static PyNumberMethods BeatTapStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BeatTapStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BeatTapStream_float, /*nb_float*/ (binaryfunc)BeatTapStream_inplace_add, /*inplace_add*/ (binaryfunc)BeatTapStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)BeatTapStream_inplace_multiply, /*inplace_multiply*/ @@ -3519,6 +3543,9 @@ static PyObject * BeatAmpStream_sub(BeatAmpStream *self, PyObject *arg) { SUB }; static PyObject * BeatAmpStream_inplace_sub(BeatAmpStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BeatAmpStream_div(BeatAmpStream *self, PyObject *arg) { DIV }; static PyObject * BeatAmpStream_inplace_div(BeatAmpStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BeatAmpStream_int(BeatAmpStream *self) { GET_I }; +static PyObject * BeatAmpStream_float(BeatAmpStream *self) { GET_F }; +static PyObject * BeatAmpStream_get(BeatAmpStream *self) { GET_F }; static PyMemberDef BeatAmpStream_members[] = { @@ -3533,6 +3560,7 @@ static PyMethodDef BeatAmpStream_methods[] = { {"getServer", (PyCFunction)BeatAmpStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BeatAmpStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BeatAmpStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BeatAmpStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BeatAmpStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BeatAmpStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3561,9 +3589,9 @@ static PyNumberMethods BeatAmpStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BeatAmpStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BeatAmpStream_float, /*nb_float*/ (binaryfunc)BeatAmpStream_inplace_add, /*inplace_add*/ (binaryfunc)BeatAmpStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)BeatAmpStream_inplace_multiply, /*inplace_multiply*/ @@ -3781,6 +3809,9 @@ static PyObject * BeatDurStream_sub(BeatDurStream *self, PyObject *arg) { SUB }; static PyObject * BeatDurStream_inplace_sub(BeatDurStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BeatDurStream_div(BeatDurStream *self, PyObject *arg) { DIV }; static PyObject * BeatDurStream_inplace_div(BeatDurStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BeatDurStream_int(BeatDurStream *self) { GET_I }; +static PyObject * BeatDurStream_float(BeatDurStream *self) { GET_F }; +static PyObject * BeatDurStream_get(BeatDurStream *self) { GET_F }; static PyMemberDef BeatDurStream_members[] = { @@ -3795,6 +3826,7 @@ static PyMethodDef BeatDurStream_methods[] = { {"getServer", (PyCFunction)BeatDurStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BeatDurStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BeatDurStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BeatDurStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BeatDurStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BeatDurStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3823,9 +3855,9 @@ static PyNumberMethods BeatDurStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BeatDurStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BeatDurStream_float, /*nb_float*/ (binaryfunc)BeatDurStream_inplace_add, /*inplace_add*/ (binaryfunc)BeatDurStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)BeatDurStream_inplace_multiply, /*inplace_multiply*/ @@ -4043,6 +4075,9 @@ static PyObject * BeatEndStream_sub(BeatEndStream *self, PyObject *arg) { SUB }; static PyObject * BeatEndStream_inplace_sub(BeatEndStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BeatEndStream_div(BeatEndStream *self, PyObject *arg) { DIV }; static PyObject * BeatEndStream_inplace_div(BeatEndStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BeatEndStream_int(BeatEndStream *self) { GET_I }; +static PyObject * BeatEndStream_float(BeatEndStream *self) { GET_F }; +static PyObject * BeatEndStream_get(BeatEndStream *self) { GET_F }; static PyMemberDef BeatEndStream_members[] = { @@ -4057,6 +4092,7 @@ static PyMethodDef BeatEndStream_methods[] = { {"getServer", (PyCFunction)BeatEndStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BeatEndStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BeatEndStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BeatEndStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BeatEndStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BeatEndStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4085,9 +4121,9 @@ static PyNumberMethods BeatEndStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BeatEndStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BeatEndStream_float, /*nb_float*/ (binaryfunc)BeatEndStream_inplace_add, /*inplace_add*/ (binaryfunc)BeatEndStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)BeatEndStream_inplace_multiply, /*inplace_multiply*/ @@ -4654,6 +4690,9 @@ static PyObject * TrigBurst_sub(TrigBurst *self, PyObject *arg) { SUB }; static PyObject * TrigBurst_inplace_sub(TrigBurst *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigBurst_div(TrigBurst *self, PyObject *arg) { DIV }; static PyObject * TrigBurst_inplace_div(TrigBurst *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigBurst_int(TrigBurst *self) { GET_I }; +static PyObject * TrigBurst_float(TrigBurst *self) { GET_F }; +static PyObject * TrigBurst_get(TrigBurst *self) { GET_F }; static PyMemberDef TrigBurst_members[] = { @@ -4668,6 +4707,7 @@ static PyMethodDef TrigBurst_methods[] = { {"getServer", (PyCFunction)TrigBurst_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigBurst_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigBurst_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigBurst_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigBurst_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigBurst_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4696,9 +4736,9 @@ static PyNumberMethods TrigBurst_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigBurst_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigBurst_float, /*nb_float*/ (binaryfunc)TrigBurst_inplace_add, /*inplace_add*/ (binaryfunc)TrigBurst_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigBurst_inplace_multiply, /*inplace_multiply*/ @@ -4916,6 +4956,9 @@ static PyObject * TrigBurstTapStream_sub(TrigBurstTapStream *self, PyObject *arg static PyObject * TrigBurstTapStream_inplace_sub(TrigBurstTapStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigBurstTapStream_div(TrigBurstTapStream *self, PyObject *arg) { DIV }; static PyObject * TrigBurstTapStream_inplace_div(TrigBurstTapStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigBurstTapStream_int(TrigBurstTapStream *self) { GET_I }; +static PyObject * TrigBurstTapStream_float(TrigBurstTapStream *self) { GET_F }; +static PyObject * TrigBurstTapStream_get(TrigBurstTapStream *self) { GET_F }; static PyMemberDef TrigBurstTapStream_members[] = { @@ -4930,6 +4973,7 @@ static PyMethodDef TrigBurstTapStream_methods[] = { {"getServer", (PyCFunction)TrigBurstTapStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigBurstTapStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigBurstTapStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigBurstTapStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigBurstTapStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigBurstTapStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4958,9 +5002,9 @@ static PyNumberMethods TrigBurstTapStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigBurstTapStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigBurstTapStream_float, /*nb_float*/ (binaryfunc)TrigBurstTapStream_inplace_add, /*inplace_add*/ (binaryfunc)TrigBurstTapStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigBurstTapStream_inplace_multiply, /*inplace_multiply*/ @@ -5178,6 +5222,9 @@ static PyObject * TrigBurstAmpStream_sub(TrigBurstAmpStream *self, PyObject *arg static PyObject * TrigBurstAmpStream_inplace_sub(TrigBurstAmpStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigBurstAmpStream_div(TrigBurstAmpStream *self, PyObject *arg) { DIV }; static PyObject * TrigBurstAmpStream_inplace_div(TrigBurstAmpStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigBurstAmpStream_int(TrigBurstAmpStream *self) { GET_I }; +static PyObject * TrigBurstAmpStream_float(TrigBurstAmpStream *self) { GET_F }; +static PyObject * TrigBurstAmpStream_get(TrigBurstAmpStream *self) { GET_F }; static PyMemberDef TrigBurstAmpStream_members[] = { @@ -5192,6 +5239,7 @@ static PyMethodDef TrigBurstAmpStream_methods[] = { {"getServer", (PyCFunction)TrigBurstAmpStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigBurstAmpStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigBurstAmpStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigBurstAmpStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigBurstAmpStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigBurstAmpStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5220,9 +5268,9 @@ static PyNumberMethods TrigBurstAmpStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigBurstAmpStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigBurstAmpStream_float, /*nb_float*/ (binaryfunc)TrigBurstAmpStream_inplace_add, /*inplace_add*/ (binaryfunc)TrigBurstAmpStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigBurstAmpStream_inplace_multiply, /*inplace_multiply*/ @@ -5440,6 +5488,9 @@ static PyObject * TrigBurstDurStream_sub(TrigBurstDurStream *self, PyObject *arg static PyObject * TrigBurstDurStream_inplace_sub(TrigBurstDurStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigBurstDurStream_div(TrigBurstDurStream *self, PyObject *arg) { DIV }; static PyObject * TrigBurstDurStream_inplace_div(TrigBurstDurStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigBurstDurStream_int(TrigBurstDurStream *self) { GET_I }; +static PyObject * TrigBurstDurStream_float(TrigBurstDurStream *self) { GET_F }; +static PyObject * TrigBurstDurStream_get(TrigBurstDurStream *self) { GET_F }; static PyMemberDef TrigBurstDurStream_members[] = { @@ -5454,6 +5505,7 @@ static PyMethodDef TrigBurstDurStream_methods[] = { {"getServer", (PyCFunction)TrigBurstDurStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigBurstDurStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigBurstDurStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigBurstDurStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigBurstDurStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigBurstDurStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5482,9 +5534,9 @@ static PyNumberMethods TrigBurstDurStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigBurstDurStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigBurstDurStream_float, /*nb_float*/ (binaryfunc)TrigBurstDurStream_inplace_add, /*inplace_add*/ (binaryfunc)TrigBurstDurStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigBurstDurStream_inplace_multiply, /*inplace_multiply*/ @@ -5702,6 +5754,9 @@ static PyObject * TrigBurstEndStream_sub(TrigBurstEndStream *self, PyObject *arg static PyObject * TrigBurstEndStream_inplace_sub(TrigBurstEndStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigBurstEndStream_div(TrigBurstEndStream *self, PyObject *arg) { DIV }; static PyObject * TrigBurstEndStream_inplace_div(TrigBurstEndStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigBurstEndStream_int(TrigBurstEndStream *self) { GET_I }; +static PyObject * TrigBurstEndStream_float(TrigBurstEndStream *self) { GET_F }; +static PyObject * TrigBurstEndStream_get(TrigBurstEndStream *self) { GET_F }; static PyMemberDef TrigBurstEndStream_members[] = { @@ -5716,6 +5771,7 @@ static PyMethodDef TrigBurstEndStream_methods[] = { {"getServer", (PyCFunction)TrigBurstEndStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigBurstEndStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigBurstEndStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigBurstEndStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigBurstEndStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigBurstEndStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5744,9 +5800,9 @@ static PyNumberMethods TrigBurstEndStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigBurstEndStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigBurstEndStream_float, /*nb_float*/ (binaryfunc)TrigBurstEndStream_inplace_add, /*inplace_add*/ (binaryfunc)TrigBurstEndStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigBurstEndStream_inplace_multiply, /*inplace_multiply*/ @@ -5804,4 +5860,4 @@ PyTypeObject TrigBurstEndStreamType = 0, /* tp_init */ 0, /* tp_alloc */ TrigBurstEndStream_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/midimodule.c b/src/objects/midimodule.c index 44bf6d6b..3079999d 100644 --- a/src/objects/midimodule.c +++ b/src/objects/midimodule.c @@ -690,6 +690,9 @@ static PyObject * Midictl_sub(Midictl *self, PyObject *arg) { SUB }; static PyObject * Midictl_inplace_sub(Midictl *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Midictl_div(Midictl *self, PyObject *arg) { DIV }; static PyObject * Midictl_inplace_div(Midictl *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Midictl_int(Midictl *self) { GET_I }; +static PyObject * Midictl_float(Midictl *self) { GET_F }; +static PyObject * Midictl_get(Midictl *self) { GET_F }; static PyObject * Midictl_setValue(Midictl *self, PyObject *arg) @@ -779,6 +782,7 @@ static PyMethodDef Midictl_methods[] = { {"getServer", (PyCFunction)Midictl_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Midictl_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Midictl_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Midictl_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Midictl_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValue", (PyCFunction)Midictl_setValue, METH_O, "Resets audio stream to value in argument."}, @@ -811,9 +815,9 @@ static PyNumberMethods Midictl_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Midictl_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Midictl_float, /*nb_float*/ (binaryfunc)Midictl_inplace_add, /*inplace_add*/ (binaryfunc)Midictl_inplace_sub, /*inplace_subtract*/ (binaryfunc)Midictl_inplace_multiply, /*inplace_multiply*/ @@ -1108,6 +1112,9 @@ static PyObject * Bendin_sub(Bendin *self, PyObject *arg) { SUB }; static PyObject * Bendin_inplace_sub(Bendin *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Bendin_div(Bendin *self, PyObject *arg) { DIV }; static PyObject * Bendin_inplace_div(Bendin *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Bendin_int(Bendin *self) { GET_I }; +static PyObject * Bendin_float(Bendin *self) { GET_F }; +static PyObject * Bendin_get(Bendin *self) { GET_F }; static PyObject * Bendin_setBrange(Bendin *self, PyObject *arg) @@ -1178,6 +1185,7 @@ static PyMethodDef Bendin_methods[] = { {"getServer", (PyCFunction)Bendin_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Bendin_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Bendin_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Bendin_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Bendin_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setBrange", (PyCFunction)Bendin_setBrange, METH_O, "Sets the bending bipolar range."}, @@ -1208,9 +1216,9 @@ static PyNumberMethods Bendin_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Bendin_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Bendin_float, /*nb_float*/ (binaryfunc)Bendin_inplace_add, /*inplace_add*/ (binaryfunc)Bendin_inplace_sub, /*inplace_subtract*/ (binaryfunc)Bendin_inplace_multiply, /*inplace_multiply*/ @@ -1493,6 +1501,9 @@ static PyObject * Touchin_sub(Touchin *self, PyObject *arg) { SUB }; static PyObject * Touchin_inplace_sub(Touchin *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Touchin_div(Touchin *self, PyObject *arg) { DIV }; static PyObject * Touchin_inplace_div(Touchin *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Touchin_int(Touchin *self) { GET_I }; +static PyObject * Touchin_float(Touchin *self) { GET_F }; +static PyObject * Touchin_get(Touchin *self) { GET_F }; static PyObject * Touchin_setMinScale(Touchin *self, PyObject *arg) @@ -1551,6 +1562,7 @@ static PyMethodDef Touchin_methods[] = { {"getServer", (PyCFunction)Touchin_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Touchin_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Touchin_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Touchin_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Touchin_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMinScale", (PyCFunction)Touchin_setMinScale, METH_O, "Sets the minimum value of scaling."}, @@ -1581,9 +1593,9 @@ static PyNumberMethods Touchin_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Touchin_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Touchin_float, /*nb_float*/ (binaryfunc)Touchin_inplace_add, /*inplace_add*/ (binaryfunc)Touchin_inplace_sub, /*inplace_subtract*/ (binaryfunc)Touchin_inplace_multiply, /*inplace_multiply*/ @@ -1840,6 +1852,9 @@ static PyObject * Programin_sub(Programin *self, PyObject *arg) { SUB }; static PyObject * Programin_inplace_sub(Programin *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Programin_div(Programin *self, PyObject *arg) { DIV }; static PyObject * Programin_inplace_div(Programin *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Programin_int(Programin *self) { GET_I }; +static PyObject * Programin_float(Programin *self) { GET_F }; +static PyObject * Programin_get(Programin *self) { GET_F }; static PyObject * Programin_setChannel(Programin *self, PyObject *arg) @@ -1872,6 +1887,7 @@ static PyMethodDef Programin_methods[] = { {"getServer", (PyCFunction)Programin_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Programin_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Programin_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Programin_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Programin_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setChannel", (PyCFunction)Programin_setChannel, METH_O, "Sets the midi channel."}, @@ -1900,9 +1916,9 @@ static PyNumberMethods Programin_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Programin_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Programin_float, /*nb_float*/ (binaryfunc)Programin_inplace_add, /*inplace_add*/ (binaryfunc)Programin_inplace_sub, /*inplace_subtract*/ (binaryfunc)Programin_inplace_multiply, /*inplace_multiply*/ @@ -2652,6 +2668,7 @@ Notein_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * Notein_getServer(Notein* self) { GET_SERVER }; static PyObject * Notein_getStream(Notein* self) { GET_STREAM }; +static PyObject * Notein_get(Notein *self) { GET_F }; static PyObject * Notein_setMul(Notein *self, PyObject *arg) { SET_MUL }; static PyObject * Notein_setAdd(Notein *self, PyObject *arg) { SET_ADD }; static PyObject * Notein_setSub(Notein *self, PyObject *arg) { SET_SUB }; @@ -2668,6 +2685,8 @@ static PyObject * Notein_sub(Notein *self, PyObject *arg) { SUB }; static PyObject * Notein_inplace_sub(Notein *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Notein_div(Notein *self, PyObject *arg) { DIV }; static PyObject * Notein_inplace_div(Notein *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Notein_int(Notein *self) { GET_I }; +static PyObject * Notein_float(Notein *self) { GET_F }; static PyMemberDef Notein_members[] = { @@ -2684,6 +2703,7 @@ static PyMethodDef Notein_methods[] = {"_getStream", (PyCFunction)Notein_getStream, METH_NOARGS, "Returns stream object."}, {"play", (PyCFunction)Notein_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Notein_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, + {"get", (PyCFunction)Notein_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"setMul", (PyCFunction)Notein_setMul, METH_O, "Sets Notein mul factor."}, {"setAdd", (PyCFunction)Notein_setAdd, METH_O, "Sets Notein add factor."}, {"setSub", (PyCFunction)Notein_setSub, METH_O, "Sets inverse add factor."}, @@ -2709,9 +2729,9 @@ static PyNumberMethods Notein_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ + (unaryfunc)Notein_int, /*nb_int*/ 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Notein_float, /*nb_float*/ (binaryfunc)Notein_inplace_add, /*inplace_add*/ (binaryfunc)Notein_inplace_sub, /*inplace_subtract*/ (binaryfunc)Notein_inplace_multiply, /*inplace_multiply*/ @@ -2937,6 +2957,9 @@ static PyObject * NoteinTrig_sub(NoteinTrig *self, PyObject *arg) { SUB }; static PyObject * NoteinTrig_inplace_sub(NoteinTrig *self, PyObject *arg) { INPLACE_SUB }; static PyObject * NoteinTrig_div(NoteinTrig *self, PyObject *arg) { DIV }; static PyObject * NoteinTrig_inplace_div(NoteinTrig *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * NoteinTrig_int(NoteinTrig *self) { GET_I }; +static PyObject * NoteinTrig_float(NoteinTrig *self) { GET_F }; +static PyObject * NoteinTrig_get(NoteinTrig *self) { GET_F }; static PyMemberDef NoteinTrig_members[] = { @@ -2951,6 +2974,7 @@ static PyMethodDef NoteinTrig_methods[] = { {"getServer", (PyCFunction)NoteinTrig_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)NoteinTrig_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)NoteinTrig_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)NoteinTrig_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)NoteinTrig_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)NoteinTrig_setMul, METH_O, "Sets NoteinTrig mul factor."}, @@ -2978,9 +3002,9 @@ static PyNumberMethods NoteinTrig_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)NoteinTrig_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)NoteinTrig_float, /*nb_float*/ (binaryfunc)NoteinTrig_inplace_add, /*inplace_add*/ (binaryfunc)NoteinTrig_inplace_sub, /*inplace_subtract*/ (binaryfunc)NoteinTrig_inplace_multiply, /*inplace_multiply*/ @@ -3319,6 +3343,9 @@ static PyObject * MidiAdsr_sub(MidiAdsr *self, PyObject *arg) { SUB }; static PyObject * MidiAdsr_inplace_sub(MidiAdsr *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MidiAdsr_div(MidiAdsr *self, PyObject *arg) { DIV }; static PyObject * MidiAdsr_inplace_div(MidiAdsr *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MidiAdsr_int(MidiAdsr *self) { GET_I }; +static PyObject * MidiAdsr_float(MidiAdsr *self) { GET_F }; +static PyObject * MidiAdsr_get(MidiAdsr *self) { GET_F }; static PyObject * MidiAdsr_setAttack(MidiAdsr *self, PyObject *arg) @@ -3414,6 +3441,7 @@ static PyMethodDef MidiAdsr_methods[] = { {"getServer", (PyCFunction)MidiAdsr_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MidiAdsr_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MidiAdsr_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MidiAdsr_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)MidiAdsr_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setMul", (PyCFunction)MidiAdsr_setMul, METH_O, "Sets MidiAdsr mul factor."}, @@ -3446,9 +3474,9 @@ static PyNumberMethods MidiAdsr_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MidiAdsr_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MidiAdsr_float, /*nb_float*/ (binaryfunc)MidiAdsr_inplace_add, /*inplace_add*/ (binaryfunc)MidiAdsr_inplace_sub, /*inplace_subtract*/ (binaryfunc)MidiAdsr_inplace_multiply, /*inplace_multiply*/ @@ -3793,6 +3821,9 @@ static PyObject * MidiDelAdsr_sub(MidiDelAdsr *self, PyObject *arg) { SUB }; static PyObject * MidiDelAdsr_inplace_sub(MidiDelAdsr *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MidiDelAdsr_div(MidiDelAdsr *self, PyObject *arg) { DIV }; static PyObject * MidiDelAdsr_inplace_div(MidiDelAdsr *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MidiDelAdsr_int(MidiDelAdsr *self) { GET_I }; +static PyObject * MidiDelAdsr_float(MidiDelAdsr *self) { GET_F }; +static PyObject * MidiDelAdsr_get(MidiDelAdsr *self) { GET_F }; static PyObject * MidiDelAdsr_setDelay(MidiDelAdsr *self, PyObject *arg) @@ -3902,6 +3933,7 @@ static PyMethodDef MidiDelAdsr_methods[] = { {"getServer", (PyCFunction)MidiDelAdsr_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MidiDelAdsr_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MidiDelAdsr_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MidiDelAdsr_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)MidiDelAdsr_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setMul", (PyCFunction)MidiDelAdsr_setMul, METH_O, "Sets MidiDelAdsr mul factor."}, @@ -3935,9 +3967,9 @@ static PyNumberMethods MidiDelAdsr_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MidiDelAdsr_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MidiDelAdsr_float, /*nb_float*/ (binaryfunc)MidiDelAdsr_inplace_add, /*inplace_add*/ (binaryfunc)MidiDelAdsr_inplace_sub, /*inplace_subtract*/ (binaryfunc)MidiDelAdsr_inplace_multiply, /*inplace_multiply*/ @@ -4507,6 +4539,9 @@ static PyObject * MidiLinseg_sub(MidiLinseg *self, PyObject *arg) { SUB }; static PyObject * MidiLinseg_inplace_sub(MidiLinseg *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MidiLinseg_div(MidiLinseg *self, PyObject *arg) { DIV }; static PyObject * MidiLinseg_inplace_div(MidiLinseg *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MidiLinseg_int(MidiLinseg *self) { GET_I }; +static PyObject * MidiLinseg_float(MidiLinseg *self) { GET_F }; +static PyObject * MidiLinseg_get(MidiLinseg *self) { GET_F }; static PyObject * MidiLinseg_setList(MidiLinseg *self, PyObject *value) @@ -4559,6 +4594,7 @@ static PyMethodDef MidiLinseg_methods[] = {"getServer", (PyCFunction)MidiLinseg_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MidiLinseg_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)MidiLinseg_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)MidiLinseg_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MidiLinseg_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)MidiLinseg_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setList", (PyCFunction)MidiLinseg_setList, METH_O, "Sets target points list."}, @@ -4588,9 +4624,9 @@ static PyNumberMethods MidiLinseg_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MidiLinseg_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MidiLinseg_float, /*nb_float*/ (binaryfunc)MidiLinseg_inplace_add, /*inplace_add*/ (binaryfunc)MidiLinseg_inplace_sub, /*inplace_subtract*/ (binaryfunc)MidiLinseg_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/mmlmodule.c b/src/objects/mmlmodule.c index 778ad621..b85d3a05 100644 --- a/src/objects/mmlmodule.c +++ b/src/objects/mmlmodule.c @@ -1143,6 +1143,9 @@ static PyObject * MML_sub(MML *self, PyObject *arg) { SUB }; static PyObject * MML_inplace_sub(MML *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MML_div(MML *self, PyObject *arg) { DIV }; static PyObject * MML_inplace_div(MML *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MML_int(MML *self) { GET_I }; +static PyObject * MML_float(MML *self) { GET_F }; +static PyObject * MML_get(MML *self) { GET_F }; static PyMemberDef MML_members[] = { @@ -1157,6 +1160,7 @@ static PyMethodDef MML_methods[] = { {"getServer", (PyCFunction)MML_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MML_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MML_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MML_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MML_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MML_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1185,9 +1189,9 @@ static PyNumberMethods MML_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MML_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MML_float, /*nb_float*/ (binaryfunc)MML_inplace_add, /*inplace_add*/ (binaryfunc)MML_inplace_sub, /*inplace_subtract*/ (binaryfunc)MML_inplace_multiply, /*inplace_multiply*/ @@ -1405,6 +1409,9 @@ static PyObject * MMLFreqStream_sub(MMLFreqStream *self, PyObject *arg) { SUB }; static PyObject * MMLFreqStream_inplace_sub(MMLFreqStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLFreqStream_div(MMLFreqStream *self, PyObject *arg) { DIV }; static PyObject * MMLFreqStream_inplace_div(MMLFreqStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLFreqStream_int(MMLFreqStream *self) { GET_I }; +static PyObject * MMLFreqStream_float(MMLFreqStream *self) { GET_F }; +static PyObject * MMLFreqStream_get(MMLFreqStream *self) { GET_F }; static PyMemberDef MMLFreqStream_members[] = { @@ -1419,6 +1426,7 @@ static PyMethodDef MMLFreqStream_methods[] = { {"getServer", (PyCFunction)MMLFreqStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLFreqStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLFreqStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLFreqStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLFreqStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLFreqStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1447,9 +1455,9 @@ static PyNumberMethods MMLFreqStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLFreqStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLFreqStream_float, /*nb_float*/ (binaryfunc)MMLFreqStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLFreqStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLFreqStream_inplace_multiply, /*inplace_multiply*/ @@ -1667,6 +1675,9 @@ static PyObject * MMLAmpStream_sub(MMLAmpStream *self, PyObject *arg) { SUB }; static PyObject * MMLAmpStream_inplace_sub(MMLAmpStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLAmpStream_div(MMLAmpStream *self, PyObject *arg) { DIV }; static PyObject * MMLAmpStream_inplace_div(MMLAmpStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLAmpStream_int(MMLAmpStream *self) { GET_I }; +static PyObject * MMLAmpStream_float(MMLAmpStream *self) { GET_F }; +static PyObject * MMLAmpStream_get(MMLAmpStream *self) { GET_F }; static PyMemberDef MMLAmpStream_members[] = { @@ -1681,6 +1692,7 @@ static PyMethodDef MMLAmpStream_methods[] = { {"getServer", (PyCFunction)MMLAmpStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLAmpStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLAmpStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLAmpStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLAmpStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLAmpStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1709,9 +1721,9 @@ static PyNumberMethods MMLAmpStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLAmpStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLAmpStream_float, /*nb_float*/ (binaryfunc)MMLAmpStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLAmpStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLAmpStream_inplace_multiply, /*inplace_multiply*/ @@ -1929,6 +1941,9 @@ static PyObject * MMLDurStream_sub(MMLDurStream *self, PyObject *arg) { SUB }; static PyObject * MMLDurStream_inplace_sub(MMLDurStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLDurStream_div(MMLDurStream *self, PyObject *arg) { DIV }; static PyObject * MMLDurStream_inplace_div(MMLDurStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLDurStream_int(MMLDurStream *self) { GET_I }; +static PyObject * MMLDurStream_float(MMLDurStream *self) { GET_F }; +static PyObject * MMLDurStream_get(MMLDurStream *self) { GET_F }; static PyMemberDef MMLDurStream_members[] = { @@ -1943,6 +1958,7 @@ static PyMethodDef MMLDurStream_methods[] = { {"getServer", (PyCFunction)MMLDurStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLDurStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLDurStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLDurStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLDurStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLDurStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1971,9 +1987,9 @@ static PyNumberMethods MMLDurStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLDurStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLDurStream_float, /*nb_float*/ (binaryfunc)MMLDurStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLDurStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLDurStream_inplace_multiply, /*inplace_multiply*/ @@ -2191,6 +2207,9 @@ static PyObject * MMLEndStream_sub(MMLEndStream *self, PyObject *arg) { SUB }; static PyObject * MMLEndStream_inplace_sub(MMLEndStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLEndStream_div(MMLEndStream *self, PyObject *arg) { DIV }; static PyObject * MMLEndStream_inplace_div(MMLEndStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLEndStream_int(MMLEndStream *self) { GET_I }; +static PyObject * MMLEndStream_float(MMLEndStream *self) { GET_F }; +static PyObject * MMLEndStream_get(MMLEndStream *self) { GET_F }; static PyMemberDef MMLEndStream_members[] = { @@ -2205,6 +2224,7 @@ static PyMethodDef MMLEndStream_methods[] = { {"getServer", (PyCFunction)MMLEndStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLEndStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLEndStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLEndStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLEndStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLEndStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2233,9 +2253,9 @@ static PyNumberMethods MMLEndStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLEndStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLEndStream_float, /*nb_float*/ (binaryfunc)MMLEndStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLEndStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLEndStream_inplace_multiply, /*inplace_multiply*/ @@ -2453,6 +2473,9 @@ static PyObject * MMLXStream_sub(MMLXStream *self, PyObject *arg) { SUB }; static PyObject * MMLXStream_inplace_sub(MMLXStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLXStream_div(MMLXStream *self, PyObject *arg) { DIV }; static PyObject * MMLXStream_inplace_div(MMLXStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLXStream_int(MMLXStream *self) { GET_I }; +static PyObject * MMLXStream_float(MMLXStream *self) { GET_F }; +static PyObject * MMLXStream_get(MMLXStream *self) { GET_F }; static PyMemberDef MMLXStream_members[] = { @@ -2467,6 +2490,7 @@ static PyMethodDef MMLXStream_methods[] = { {"getServer", (PyCFunction)MMLXStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLXStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLXStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLXStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLXStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLXStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2495,9 +2519,9 @@ static PyNumberMethods MMLXStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLXStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLXStream_float, /*nb_float*/ (binaryfunc)MMLXStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLXStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLXStream_inplace_multiply, /*inplace_multiply*/ @@ -2715,6 +2739,9 @@ static PyObject * MMLYStream_sub(MMLYStream *self, PyObject *arg) { SUB }; static PyObject * MMLYStream_inplace_sub(MMLYStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLYStream_div(MMLYStream *self, PyObject *arg) { DIV }; static PyObject * MMLYStream_inplace_div(MMLYStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLYStream_int(MMLYStream *self) { GET_I }; +static PyObject * MMLYStream_float(MMLYStream *self) { GET_F }; +static PyObject * MMLYStream_get(MMLYStream *self) { GET_F }; static PyMemberDef MMLYStream_members[] = { @@ -2729,6 +2756,7 @@ static PyMethodDef MMLYStream_methods[] = { {"getServer", (PyCFunction)MMLYStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLYStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLYStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLYStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLYStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLYStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2757,9 +2785,9 @@ static PyNumberMethods MMLYStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLYStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLYStream_float, /*nb_float*/ (binaryfunc)MMLYStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLYStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLYStream_inplace_multiply, /*inplace_multiply*/ @@ -2977,6 +3005,9 @@ static PyObject * MMLZStream_sub(MMLZStream *self, PyObject *arg) { SUB }; static PyObject * MMLZStream_inplace_sub(MMLZStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MMLZStream_div(MMLZStream *self, PyObject *arg) { DIV }; static PyObject * MMLZStream_inplace_div(MMLZStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MMLZStream_int(MMLZStream *self) { GET_I }; +static PyObject * MMLZStream_float(MMLZStream *self) { GET_F }; +static PyObject * MMLZStream_get(MMLZStream *self) { GET_F }; static PyMemberDef MMLZStream_members[] = { @@ -2991,6 +3022,7 @@ static PyMethodDef MMLZStream_methods[] = { {"getServer", (PyCFunction)MMLZStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MMLZStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MMLZStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MMLZStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MMLZStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MMLZStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3019,9 +3051,9 @@ static PyNumberMethods MMLZStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MMLZStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MMLZStream_float, /*nb_float*/ (binaryfunc)MMLZStream_inplace_add, /*inplace_add*/ (binaryfunc)MMLZStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)MMLZStream_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/noisemodule.c b/src/objects/noisemodule.c index 9c8ae7cf..b91b0885 100644 --- a/src/objects/noisemodule.c +++ b/src/objects/noisemodule.c @@ -214,6 +214,9 @@ static PyObject * Noise_sub(Noise *self, PyObject *arg) { SUB }; static PyObject * Noise_inplace_sub(Noise *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Noise_div(Noise *self, PyObject *arg) { DIV }; static PyObject * Noise_inplace_div(Noise *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Noise_int(Noise *self) { GET_I }; +static PyObject * Noise_float(Noise *self) { GET_F }; +static PyObject * Noise_get(Noise *self) { GET_F }; static PyObject * Noise_setType(Noise *self, PyObject *arg) @@ -243,6 +246,7 @@ static PyMethodDef Noise_methods[] = { {"getServer", (PyCFunction)Noise_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Noise_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Noise_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Noise_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Noise_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Noise_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -272,9 +276,9 @@ static PyNumberMethods Noise_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Noise_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Noise_float, /*nb_float*/ (binaryfunc)Noise_inplace_add, /*inplace_add*/ (binaryfunc)Noise_inplace_sub, /*inplace_subtract*/ (binaryfunc)Noise_inplace_multiply, /*inplace_multiply*/ @@ -513,6 +517,9 @@ static PyObject * PinkNoise_sub(PinkNoise *self, PyObject *arg) { SUB }; static PyObject * PinkNoise_inplace_sub(PinkNoise *self, PyObject *arg) { INPLACE_SUB }; static PyObject * PinkNoise_div(PinkNoise *self, PyObject *arg) { DIV }; static PyObject * PinkNoise_inplace_div(PinkNoise *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * PinkNoise_int(PinkNoise *self) { GET_I }; +static PyObject * PinkNoise_float(PinkNoise *self) { GET_F }; +static PyObject * PinkNoise_get(PinkNoise *self) { GET_F }; static PyMemberDef PinkNoise_members[] = { @@ -527,6 +534,7 @@ static PyMethodDef PinkNoise_methods[] = { {"getServer", (PyCFunction)PinkNoise_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)PinkNoise_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)PinkNoise_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)PinkNoise_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)PinkNoise_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)PinkNoise_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -555,9 +563,9 @@ static PyNumberMethods PinkNoise_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)PinkNoise_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)PinkNoise_float, /*nb_float*/ (binaryfunc)PinkNoise_inplace_add, /*inplace_add*/ (binaryfunc)PinkNoise_inplace_sub, /*inplace_subtract*/ (binaryfunc)PinkNoise_inplace_multiply, /*inplace_multiply*/ @@ -788,6 +796,9 @@ static PyObject * BrownNoise_sub(BrownNoise *self, PyObject *arg) { SUB }; static PyObject * BrownNoise_inplace_sub(BrownNoise *self, PyObject *arg) { INPLACE_SUB }; static PyObject * BrownNoise_div(BrownNoise *self, PyObject *arg) { DIV }; static PyObject * BrownNoise_inplace_div(BrownNoise *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * BrownNoise_int(BrownNoise *self) { GET_I }; +static PyObject * BrownNoise_float(BrownNoise *self) { GET_F }; +static PyObject * BrownNoise_get(BrownNoise *self) { GET_F }; static PyMemberDef BrownNoise_members[] = { @@ -802,6 +813,7 @@ static PyMethodDef BrownNoise_methods[] = { {"getServer", (PyCFunction)BrownNoise_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)BrownNoise_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)BrownNoise_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)BrownNoise_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)BrownNoise_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)BrownNoise_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -830,9 +842,9 @@ static PyNumberMethods BrownNoise_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)BrownNoise_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)BrownNoise_float, /*nb_float*/ (binaryfunc)BrownNoise_inplace_add, /*inplace_add*/ (binaryfunc)BrownNoise_inplace_sub, /*inplace_subtract*/ (binaryfunc)BrownNoise_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/oscbankmodule.c b/src/objects/oscbankmodule.c index 21001384..211b881a 100644 --- a/src/objects/oscbankmodule.c +++ b/src/objects/oscbankmodule.c @@ -608,6 +608,9 @@ static PyObject * OscBank_sub(OscBank *self, PyObject *arg) { SUB }; static PyObject * OscBank_inplace_sub(OscBank *self, PyObject *arg) { INPLACE_SUB }; static PyObject * OscBank_div(OscBank *self, PyObject *arg) { DIV }; static PyObject * OscBank_inplace_div(OscBank *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * OscBank_int(OscBank *self) { GET_I }; +static PyObject * OscBank_float(OscBank *self) { GET_F }; +static PyObject * OscBank_get(OscBank *self) { GET_F }; static PyObject * OscBank_getTable(OscBank *self) @@ -666,6 +669,7 @@ static PyMethodDef OscBank_methods[] = {"getTable", (PyCFunction)OscBank_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)OscBank_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)OscBank_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)OscBank_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)OscBank_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)OscBank_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)OscBank_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -703,9 +707,9 @@ static PyNumberMethods OscBank_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)OscBank_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)OscBank_float, /*nb_float*/ (binaryfunc)OscBank_inplace_add, /*inplace_add*/ (binaryfunc)OscBank_inplace_sub, /*inplace_subtract*/ (binaryfunc)OscBank_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/oscilmodule.c b/src/objects/oscilmodule.c index 625c2831..307e3e74 100644 --- a/src/objects/oscilmodule.c +++ b/src/objects/oscilmodule.c @@ -361,6 +361,9 @@ static PyObject * Sine_sub(Sine *self, PyObject *arg) { SUB }; static PyObject * Sine_inplace_sub(Sine *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Sine_div(Sine *self, PyObject *arg) { DIV }; static PyObject * Sine_inplace_div(Sine *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Sine_int(Sine *self) { GET_I }; +static PyObject * Sine_float(Sine *self) { GET_F }; +static PyObject * Sine_get(Sine *self) { GET_F }; static PyObject * Sine_setFreq(Sine *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2) } static PyObject * Sine_setPhase(Sine *self, PyObject *arg) { SET_PARAM(self->phase, self->phase_stream, 3) } @@ -387,6 +390,7 @@ static PyMethodDef Sine_methods[] = { {"getServer", (PyCFunction)Sine_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Sine_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Sine_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Sine_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Sine_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Sine_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -418,9 +422,9 @@ static PyNumberMethods Sine_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Sine_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Sine_float, /*nb_float*/ (binaryfunc)Sine_inplace_add, /*inplace_add*/ (binaryfunc)Sine_inplace_sub, /*inplace_subtract*/ (binaryfunc)Sine_inplace_multiply, /*inplace_multiply*/ @@ -889,6 +893,9 @@ static PyObject * FastSine_sub(FastSine *self, PyObject *arg) { SUB }; static PyObject * FastSine_inplace_sub(FastSine *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FastSine_div(FastSine *self, PyObject *arg) { DIV }; static PyObject * FastSine_inplace_div(FastSine *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FastSine_int(FastSine *self) { GET_I }; +static PyObject * FastSine_float(FastSine *self) { GET_F }; +static PyObject * FastSine_get(FastSine *self) { GET_F }; static PyObject * FastSine_setFreq(FastSine *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } @@ -932,6 +939,7 @@ static PyMethodDef FastSine_methods[] = { {"getServer", (PyCFunction)FastSine_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FastSine_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FastSine_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FastSine_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)FastSine_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)FastSine_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -963,9 +971,9 @@ static PyNumberMethods FastSine_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FastSine_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FastSine_float, /*nb_float*/ (binaryfunc)FastSine_inplace_add, /*inplace_add*/ (binaryfunc)FastSine_inplace_sub, /*inplace_subtract*/ (binaryfunc)FastSine_inplace_multiply, /*inplace_multiply*/ @@ -1307,6 +1315,9 @@ static PyObject * SineLoop_sub(SineLoop *self, PyObject *arg) { SUB }; static PyObject * SineLoop_inplace_sub(SineLoop *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SineLoop_div(SineLoop *self, PyObject *arg) { DIV }; static PyObject * SineLoop_inplace_div(SineLoop *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SineLoop_int(SineLoop *self) { GET_I }; +static PyObject * SineLoop_float(SineLoop *self) { GET_F }; +static PyObject * SineLoop_get(SineLoop *self) { GET_F }; static PyObject * SineLoop_setFreq(SineLoop *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * SineLoop_setFeedback(SineLoop *self, PyObject *arg) { SET_PARAM(self->feedback, self->feedback_stream, 3); } @@ -1326,6 +1337,7 @@ static PyMethodDef SineLoop_methods[] = { {"getServer", (PyCFunction)SineLoop_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SineLoop_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SineLoop_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SineLoop_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SineLoop_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SineLoop_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1356,9 +1368,9 @@ static PyNumberMethods SineLoop_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SineLoop_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SineLoop_float, /*nb_float*/ (binaryfunc)SineLoop_inplace_add, /*inplace_add*/ (binaryfunc)SineLoop_inplace_sub, /*inplace_subtract*/ (binaryfunc)SineLoop_inplace_multiply, /*inplace_multiply*/ @@ -1767,6 +1779,9 @@ static PyObject * Osc_sub(Osc *self, PyObject *arg) { SUB }; static PyObject * Osc_inplace_sub(Osc *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Osc_div(Osc *self, PyObject *arg) { DIV }; static PyObject * Osc_inplace_div(Osc *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Osc_int(Osc *self) { GET_I }; +static PyObject * Osc_float(Osc *self) { GET_F }; +static PyObject * Osc_get(Osc *self) { GET_F }; static PyObject * Osc_getTable(Osc* self) @@ -1828,6 +1843,7 @@ static PyMethodDef Osc_methods[] = {"getTable", (PyCFunction)Osc_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)Osc_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Osc_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Osc_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Osc_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Osc_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Osc_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1861,9 +1877,9 @@ static PyNumberMethods Osc_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Osc_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Osc_float, /*nb_float*/ (binaryfunc)Osc_inplace_add, /*inplace_add*/ (binaryfunc)Osc_inplace_sub, /*inplace_subtract*/ (binaryfunc)Osc_inplace_multiply, /*inplace_multiply*/ @@ -2250,6 +2266,9 @@ static PyObject * OscLoop_sub(OscLoop *self, PyObject *arg) { SUB }; static PyObject * OscLoop_inplace_sub(OscLoop *self, PyObject *arg) { INPLACE_SUB }; static PyObject * OscLoop_div(OscLoop *self, PyObject *arg) { DIV }; static PyObject * OscLoop_inplace_div(OscLoop *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * OscLoop_int(OscLoop *self) { GET_I }; +static PyObject * OscLoop_float(OscLoop *self) { GET_F }; +static PyObject * OscLoop_get(OscLoop *self) { GET_F }; static PyObject * OscLoop_getTable(OscLoop* self) @@ -2289,6 +2308,7 @@ static PyMethodDef OscLoop_methods[] = {"getTable", (PyCFunction)OscLoop_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)OscLoop_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)OscLoop_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)OscLoop_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)OscLoop_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)OscLoop_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)OscLoop_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2320,9 +2340,9 @@ static PyNumberMethods OscLoop_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)OscLoop_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)OscLoop_float, /*nb_float*/ (binaryfunc)OscLoop_inplace_add, /*inplace_add*/ (binaryfunc)OscLoop_inplace_sub, /*inplace_subtract*/ (binaryfunc)OscLoop_inplace_multiply, /*inplace_multiply*/ @@ -2754,6 +2774,9 @@ static PyObject * OscTrig_sub(OscTrig *self, PyObject *arg) { SUB }; static PyObject * OscTrig_inplace_sub(OscTrig *self, PyObject *arg) { INPLACE_SUB }; static PyObject * OscTrig_div(OscTrig *self, PyObject *arg) { DIV }; static PyObject * OscTrig_inplace_div(OscTrig *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * OscTrig_int(OscTrig *self) { GET_I }; +static PyObject * OscTrig_float(OscTrig *self) { GET_F }; +static PyObject * OscTrig_get(OscTrig *self) { GET_F }; static PyObject * OscTrig_getTable(OscTrig* self) @@ -2838,6 +2861,7 @@ static PyMethodDef OscTrig_methods[] = {"getTable", (PyCFunction)OscTrig_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)OscTrig_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)OscTrig_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)OscTrig_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)OscTrig_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)OscTrig_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)OscTrig_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2872,9 +2896,9 @@ static PyNumberMethods OscTrig_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)OscTrig_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)OscTrig_float, /*nb_float*/ (binaryfunc)OscTrig_inplace_add, /*inplace_add*/ (binaryfunc)OscTrig_inplace_sub, /*inplace_subtract*/ (binaryfunc)OscTrig_inplace_multiply, /*inplace_multiply*/ @@ -3254,6 +3278,9 @@ static PyObject * Phasor_sub(Phasor *self, PyObject *arg) { SUB }; static PyObject * Phasor_inplace_sub(Phasor *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Phasor_div(Phasor *self, PyObject *arg) { DIV }; static PyObject * Phasor_inplace_div(Phasor *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Phasor_int(Phasor *self) { GET_I }; +static PyObject * Phasor_float(Phasor *self) { GET_F }; +static PyObject * Phasor_get(Phasor *self) { GET_F }; static PyObject * Phasor_setFreq(Phasor *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Phasor_setPhase(Phasor *self, PyObject *arg) { SET_PARAM(self->phase, self->phase_stream, 3); } @@ -3280,6 +3307,7 @@ static PyMethodDef Phasor_methods[] = { {"getServer", (PyCFunction)Phasor_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Phasor_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Phasor_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Phasor_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Phasor_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Phasor_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3311,9 +3339,9 @@ static PyNumberMethods Phasor_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Phasor_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Phasor_float, /*nb_float*/ (binaryfunc)Phasor_inplace_add, /*inplace_add*/ (binaryfunc)Phasor_inplace_sub, /*inplace_subtract*/ (binaryfunc)Phasor_inplace_multiply, /*inplace_multiply*/ @@ -3567,6 +3595,9 @@ static PyObject * Pointer_sub(Pointer *self, PyObject *arg) { SUB }; static PyObject * Pointer_inplace_sub(Pointer *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Pointer_div(Pointer *self, PyObject *arg) { DIV }; static PyObject * Pointer_inplace_div(Pointer *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Pointer_int(Pointer *self) { GET_I }; +static PyObject * Pointer_float(Pointer *self) { GET_F }; +static PyObject * Pointer_get(Pointer *self) { GET_F }; static PyObject * Pointer_getTable(Pointer* self) @@ -3624,6 +3655,7 @@ static PyMethodDef Pointer_methods[] = {"getTable", (PyCFunction)Pointer_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)Pointer_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Pointer_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Pointer_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Pointer_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Pointer_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Pointer_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3654,9 +3686,9 @@ static PyNumberMethods Pointer_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Pointer_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Pointer_float, /*nb_float*/ (binaryfunc)Pointer_inplace_add, /*inplace_add*/ (binaryfunc)Pointer_inplace_sub, /*inplace_subtract*/ (binaryfunc)Pointer_inplace_multiply, /*inplace_multiply*/ @@ -3950,6 +3982,9 @@ static PyObject * Pointer2_sub(Pointer2 *self, PyObject *arg) { SUB }; static PyObject * Pointer2_inplace_sub(Pointer2 *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Pointer2_div(Pointer2 *self, PyObject *arg) { DIV }; static PyObject * Pointer2_inplace_div(Pointer2 *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Pointer2_int(Pointer2 *self) { GET_I }; +static PyObject * Pointer2_float(Pointer2 *self) { GET_F }; +static PyObject * Pointer2_get(Pointer2 *self) { GET_F }; static PyObject * Pointer2_getTable(Pointer2* self) @@ -4035,6 +4070,7 @@ static PyMethodDef Pointer2_methods[] = {"getTable", (PyCFunction)Pointer2_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)Pointer2_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Pointer2_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Pointer2_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Pointer2_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Pointer2_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Pointer2_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4067,9 +4103,9 @@ static PyNumberMethods Pointer2_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Pointer2_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Pointer2_float, /*nb_float*/ (binaryfunc)Pointer2_inplace_add, /*inplace_add*/ (binaryfunc)Pointer2_inplace_sub, /*inplace_subtract*/ (binaryfunc)Pointer2_inplace_multiply, /*inplace_multiply*/ @@ -4325,6 +4361,9 @@ static PyObject * TableIndex_sub(TableIndex *self, PyObject *arg) { SUB }; static PyObject * TableIndex_inplace_sub(TableIndex *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TableIndex_div(TableIndex *self, PyObject *arg) { DIV }; static PyObject * TableIndex_inplace_div(TableIndex *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TableIndex_int(TableIndex *self) { GET_I }; +static PyObject * TableIndex_float(TableIndex *self) { GET_F }; +static PyObject * TableIndex_get(TableIndex *self) { GET_F }; static PyObject * TableIndex_getTable(TableIndex* self) @@ -4382,6 +4421,7 @@ static PyMethodDef TableIndex_methods[] = {"getTable", (PyCFunction)TableIndex_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)TableIndex_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TableIndex_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TableIndex_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TableIndex_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TableIndex_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TableIndex_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4412,9 +4452,9 @@ static PyNumberMethods TableIndex_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TableIndex_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TableIndex_float, /*nb_float*/ (binaryfunc)TableIndex_inplace_add, /*inplace_add*/ (binaryfunc)TableIndex_inplace_sub, /*inplace_subtract*/ (binaryfunc)TableIndex_inplace_multiply, /*inplace_multiply*/ @@ -4678,6 +4718,9 @@ static PyObject * Lookup_sub(Lookup *self, PyObject *arg) { SUB }; static PyObject * Lookup_inplace_sub(Lookup *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Lookup_div(Lookup *self, PyObject *arg) { DIV }; static PyObject * Lookup_inplace_div(Lookup *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Lookup_int(Lookup *self) { GET_I }; +static PyObject * Lookup_float(Lookup *self) { GET_F }; +static PyObject * Lookup_get(Lookup *self) { GET_F }; static PyObject * Lookup_getTable(Lookup* self) @@ -4735,6 +4778,7 @@ static PyMethodDef Lookup_methods[] = {"getTable", (PyCFunction)Lookup_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)Lookup_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Lookup_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Lookup_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Lookup_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Lookup_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Lookup_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4765,9 +4809,9 @@ static PyNumberMethods Lookup_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Lookup_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Lookup_float, /*nb_float*/ (binaryfunc)Lookup_inplace_add, /*inplace_add*/ (binaryfunc)Lookup_inplace_sub, /*inplace_subtract*/ (binaryfunc)Lookup_inplace_multiply, /*inplace_multiply*/ @@ -5496,6 +5540,9 @@ static PyObject * Pulsar_sub(Pulsar *self, PyObject *arg) { SUB }; static PyObject * Pulsar_inplace_sub(Pulsar *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Pulsar_div(Pulsar *self, PyObject *arg) { DIV }; static PyObject * Pulsar_inplace_div(Pulsar *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Pulsar_int(Pulsar *self) { GET_I }; +static PyObject * Pulsar_float(Pulsar *self) { GET_F }; +static PyObject * Pulsar_get(Pulsar *self) { GET_F }; static PyObject * Pulsar_getTable(Pulsar* self) @@ -5571,6 +5618,7 @@ static PyMethodDef Pulsar_methods[] = {"getEnv", (PyCFunction)Pulsar_getEnv, METH_NOARGS, "Returns object envelope."}, {"getServer", (PyCFunction)Pulsar_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Pulsar_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Pulsar_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Pulsar_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Pulsar_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Pulsar_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5605,9 +5653,9 @@ static PyNumberMethods Pulsar_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Pulsar_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Pulsar_float, /*nb_float*/ (binaryfunc)Pulsar_inplace_add, /*inplace_add*/ (binaryfunc)Pulsar_inplace_sub, /*inplace_subtract*/ (binaryfunc)Pulsar_inplace_multiply, /*inplace_multiply*/ @@ -6064,6 +6112,9 @@ static PyObject * TableRead_sub(TableRead *self, PyObject *arg) { SUB }; static PyObject * TableRead_inplace_sub(TableRead *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TableRead_div(TableRead *self, PyObject *arg) { DIV }; static PyObject * TableRead_inplace_div(TableRead *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TableRead_int(TableRead *self) { GET_I }; +static PyObject * TableRead_float(TableRead *self) { GET_F }; +static PyObject * TableRead_get(TableRead *self) { GET_F }; static PyObject * TableRead_getTable(TableRead* self) @@ -6145,6 +6196,7 @@ static PyMethodDef TableRead_methods[] = {"getServer", (PyCFunction)TableRead_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TableRead_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)TableRead_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)TableRead_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TableRead_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TableRead_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TableRead_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6179,9 +6231,9 @@ static PyNumberMethods TableRead_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TableRead_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TableRead_float, /*nb_float*/ (binaryfunc)TableRead_inplace_add, /*inplace_add*/ (binaryfunc)TableRead_inplace_sub, /*inplace_subtract*/ (binaryfunc)TableRead_inplace_multiply, /*inplace_multiply*/ @@ -6717,6 +6769,9 @@ static PyObject * Fm_sub(Fm *self, PyObject *arg) { SUB }; static PyObject * Fm_inplace_sub(Fm *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Fm_div(Fm *self, PyObject *arg) { DIV }; static PyObject * Fm_inplace_div(Fm *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Fm_int(Fm *self) { GET_I }; +static PyObject * Fm_float(Fm *self) { GET_F }; +static PyObject * Fm_get(Fm *self) { GET_F }; static PyObject * Fm_setCarrier(Fm *self, PyObject *arg) { SET_PARAM(self->car, self->car_stream, 2); } static PyObject * Fm_setRatio(Fm *self, PyObject *arg) { SET_PARAM(self->ratio, self->ratio_stream, 3); } @@ -6738,6 +6793,7 @@ static PyMethodDef Fm_methods[] = { {"getServer", (PyCFunction)Fm_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Fm_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Fm_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Fm_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Fm_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Fm_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6769,9 +6825,9 @@ static PyNumberMethods Fm_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Fm_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Fm_float, /*nb_float*/ (binaryfunc)Fm_inplace_add, /*inplace_add*/ (binaryfunc)Fm_inplace_sub, /*inplace_subtract*/ (binaryfunc)Fm_inplace_multiply, /*inplace_multiply*/ @@ -7145,6 +7201,9 @@ static PyObject * CrossFm_sub(CrossFm *self, PyObject *arg) { SUB }; static PyObject * CrossFm_inplace_sub(CrossFm *self, PyObject *arg) { INPLACE_SUB }; static PyObject * CrossFm_div(CrossFm *self, PyObject *arg) { DIV }; static PyObject * CrossFm_inplace_div(CrossFm *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * CrossFm_int(CrossFm *self) { GET_I }; +static PyObject * CrossFm_float(CrossFm *self) { GET_F }; +static PyObject * CrossFm_get(CrossFm *self) { GET_F }; static PyObject * CrossFm_setCarrier(CrossFm *self, PyObject *arg) { SET_PARAM(self->car, self->car_stream, 2); } static PyObject * CrossFm_setRatio(CrossFm *self, PyObject *arg) { SET_PARAM(self->ratio, self->ratio_stream, 3); } @@ -7168,6 +7227,7 @@ static PyMethodDef CrossFm_methods[] = { {"getServer", (PyCFunction)CrossFm_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)CrossFm_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)CrossFm_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)CrossFm_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)CrossFm_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)CrossFm_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -7200,9 +7260,9 @@ static PyNumberMethods CrossFm_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)CrossFm_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)CrossFm_float, /*nb_float*/ (binaryfunc)CrossFm_inplace_add, /*inplace_add*/ (binaryfunc)CrossFm_inplace_sub, /*inplace_subtract*/ (binaryfunc)CrossFm_inplace_multiply, /*inplace_multiply*/ @@ -7592,6 +7652,9 @@ static PyObject * Blit_sub(Blit *self, PyObject *arg) { SUB }; static PyObject * Blit_inplace_sub(Blit *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Blit_div(Blit *self, PyObject *arg) { DIV }; static PyObject * Blit_inplace_div(Blit *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Blit_int(Blit *self) { GET_I }; +static PyObject * Blit_float(Blit *self) { GET_F }; +static PyObject * Blit_get(Blit *self) { GET_F }; static PyObject * Blit_setFreq(Blit *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * Blit_setHarms(Blit *self, PyObject *arg) { SET_PARAM(self->harms, self->harms_stream, 3); } @@ -7611,6 +7674,7 @@ static PyMethodDef Blit_methods[] = { {"getServer", (PyCFunction)Blit_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Blit_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Blit_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Blit_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundfreqd."}, {"out", (PyCFunction)Blit_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundfreqd channel speficied by argument."}, {"stop", (PyCFunction)Blit_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -7641,9 +7705,9 @@ static PyNumberMethods Blit_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Blit_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Blit_float, /*nb_float*/ (binaryfunc)Blit_inplace_add, /*inplace_add*/ (binaryfunc)Blit_inplace_sub, /*inplace_subtract*/ (binaryfunc)Blit_inplace_multiply, /*inplace_multiply*/ @@ -8085,6 +8149,9 @@ static PyObject * Rossler_sub(Rossler *self, PyObject *arg) { SUB }; static PyObject * Rossler_inplace_sub(Rossler *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Rossler_div(Rossler *self, PyObject *arg) { DIV }; static PyObject * Rossler_inplace_div(Rossler *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Rossler_int(Rossler *self) { GET_I }; +static PyObject * Rossler_float(Rossler *self) { GET_F }; +static PyObject * Rossler_get(Rossler *self) { GET_F }; static PyObject * Rossler_setPitch(Rossler *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 2); } static PyObject * Rossler_setChaos(Rossler *self, PyObject *arg) { SET_PARAM(self->chaos, self->chaos_stream, 3); } @@ -8110,6 +8177,7 @@ static PyMethodDef Rossler_methods[] = { {"getServer", (PyCFunction)Rossler_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Rossler_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Rossler_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Rossler_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Rossler_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Rossler_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -8140,9 +8208,9 @@ static PyNumberMethods Rossler_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Rossler_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Rossler_float, /*nb_float*/ (binaryfunc)Rossler_inplace_add, /*inplace_add*/ (binaryfunc)Rossler_inplace_sub, /*inplace_subtract*/ (binaryfunc)Rossler_inplace_multiply, /*inplace_multiply*/ @@ -8364,6 +8432,9 @@ static PyObject * RosslerAlt_sub(RosslerAlt *self, PyObject *arg) { SUB }; static PyObject * RosslerAlt_inplace_sub(RosslerAlt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * RosslerAlt_div(RosslerAlt *self, PyObject *arg) { DIV }; static PyObject * RosslerAlt_inplace_div(RosslerAlt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * RosslerAlt_int(RosslerAlt *self) { GET_I }; +static PyObject * RosslerAlt_float(RosslerAlt *self) { GET_F }; +static PyObject * RosslerAlt_get(RosslerAlt *self) { GET_F }; static PyMemberDef RosslerAlt_members[] = { @@ -8378,6 +8449,7 @@ static PyMethodDef RosslerAlt_methods[] = { {"getServer", (PyCFunction)RosslerAlt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)RosslerAlt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)RosslerAlt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)RosslerAlt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)RosslerAlt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)RosslerAlt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -8405,9 +8477,9 @@ static PyNumberMethods RosslerAlt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)RosslerAlt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)RosslerAlt_float, /*nb_float*/ (binaryfunc)RosslerAlt_inplace_add, /*inplace_add*/ (binaryfunc)RosslerAlt_inplace_sub, /*inplace_subtract*/ (binaryfunc)RosslerAlt_inplace_multiply, /*inplace_multiply*/ @@ -8849,6 +8921,9 @@ static PyObject * Lorenz_sub(Lorenz *self, PyObject *arg) { SUB }; static PyObject * Lorenz_inplace_sub(Lorenz *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Lorenz_div(Lorenz *self, PyObject *arg) { DIV }; static PyObject * Lorenz_inplace_div(Lorenz *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Lorenz_int(Lorenz *self) { GET_I }; +static PyObject * Lorenz_float(Lorenz *self) { GET_F }; +static PyObject * Lorenz_get(Lorenz *self) { GET_F }; static PyObject * Lorenz_setPitch(Lorenz *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 2); } static PyObject * Lorenz_setChaos(Lorenz *self, PyObject *arg) { SET_PARAM(self->chaos, self->chaos_stream, 3); } @@ -8874,6 +8949,7 @@ static PyMethodDef Lorenz_methods[] = { {"getServer", (PyCFunction)Lorenz_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Lorenz_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Lorenz_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Lorenz_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Lorenz_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Lorenz_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -8904,9 +8980,9 @@ static PyNumberMethods Lorenz_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Lorenz_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Lorenz_float, /*nb_float*/ (binaryfunc)Lorenz_inplace_add, /*inplace_add*/ (binaryfunc)Lorenz_inplace_sub, /*inplace_subtract*/ (binaryfunc)Lorenz_inplace_multiply, /*inplace_multiply*/ @@ -9128,6 +9204,9 @@ static PyObject * LorenzAlt_sub(LorenzAlt *self, PyObject *arg) { SUB }; static PyObject * LorenzAlt_inplace_sub(LorenzAlt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * LorenzAlt_div(LorenzAlt *self, PyObject *arg) { DIV }; static PyObject * LorenzAlt_inplace_div(LorenzAlt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * LorenzAlt_int(LorenzAlt *self) { GET_I }; +static PyObject * LorenzAlt_float(LorenzAlt *self) { GET_F }; +static PyObject * LorenzAlt_get(LorenzAlt *self) { GET_F }; static PyMemberDef LorenzAlt_members[] = { @@ -9142,6 +9221,7 @@ static PyMethodDef LorenzAlt_methods[] = { {"getServer", (PyCFunction)LorenzAlt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)LorenzAlt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)LorenzAlt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)LorenzAlt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)LorenzAlt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)LorenzAlt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -9169,9 +9249,9 @@ static PyNumberMethods LorenzAlt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)LorenzAlt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)LorenzAlt_float, /*nb_float*/ (binaryfunc)LorenzAlt_inplace_add, /*inplace_add*/ (binaryfunc)LorenzAlt_inplace_sub, /*inplace_subtract*/ (binaryfunc)LorenzAlt_inplace_multiply, /*inplace_multiply*/ @@ -9621,6 +9701,9 @@ static PyObject * ChenLee_sub(ChenLee *self, PyObject *arg) { SUB }; static PyObject * ChenLee_inplace_sub(ChenLee *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ChenLee_div(ChenLee *self, PyObject *arg) { DIV }; static PyObject * ChenLee_inplace_div(ChenLee *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ChenLee_int(ChenLee *self) { GET_I }; +static PyObject * ChenLee_float(ChenLee *self) { GET_F }; +static PyObject * ChenLee_get(ChenLee *self) { GET_F }; static PyObject * ChenLee_setPitch(ChenLee *self, PyObject *arg) { SET_PARAM(self->pitch, self->pitch_stream, 2); } static PyObject * ChenLee_setChaos(ChenLee *self, PyObject *arg) { SET_PARAM(self->chaos, self->chaos_stream, 3); } @@ -9646,6 +9729,7 @@ static PyMethodDef ChenLee_methods[] = { {"getServer", (PyCFunction)ChenLee_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ChenLee_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ChenLee_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ChenLee_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ChenLee_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ChenLee_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -9676,9 +9760,9 @@ static PyNumberMethods ChenLee_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ChenLee_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ChenLee_float, /*nb_float*/ (binaryfunc)ChenLee_inplace_add, /*inplace_add*/ (binaryfunc)ChenLee_inplace_sub, /*inplace_subtract*/ (binaryfunc)ChenLee_inplace_multiply, /*inplace_multiply*/ @@ -9900,6 +9984,9 @@ static PyObject * ChenLeeAlt_sub(ChenLeeAlt *self, PyObject *arg) { SUB }; static PyObject * ChenLeeAlt_inplace_sub(ChenLeeAlt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ChenLeeAlt_div(ChenLeeAlt *self, PyObject *arg) { DIV }; static PyObject * ChenLeeAlt_inplace_div(ChenLeeAlt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ChenLeeAlt_int(ChenLeeAlt *self) { GET_I }; +static PyObject * ChenLeeAlt_float(ChenLeeAlt *self) { GET_F }; +static PyObject * ChenLeeAlt_get(ChenLeeAlt *self) { GET_F }; static PyMemberDef ChenLeeAlt_members[] = { @@ -9914,6 +10001,7 @@ static PyMethodDef ChenLeeAlt_methods[] = { {"getServer", (PyCFunction)ChenLeeAlt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ChenLeeAlt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)ChenLeeAlt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ChenLeeAlt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)ChenLeeAlt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)ChenLeeAlt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -9941,9 +10029,9 @@ static PyNumberMethods ChenLeeAlt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ChenLeeAlt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ChenLeeAlt_float, /*nb_float*/ (binaryfunc)ChenLeeAlt_inplace_add, /*inplace_add*/ (binaryfunc)ChenLeeAlt_inplace_sub, /*inplace_subtract*/ (binaryfunc)ChenLeeAlt_inplace_multiply, /*inplace_multiply*/ @@ -10593,6 +10681,9 @@ static PyObject * SumOsc_sub(SumOsc *self, PyObject *arg) { SUB }; static PyObject * SumOsc_inplace_sub(SumOsc *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SumOsc_div(SumOsc *self, PyObject *arg) { DIV }; static PyObject * SumOsc_inplace_div(SumOsc *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SumOsc_int(SumOsc *self) { GET_I }; +static PyObject * SumOsc_float(SumOsc *self) { GET_F }; +static PyObject * SumOsc_get(SumOsc *self) { GET_F }; static PyObject * SumOsc_setFreq(SumOsc *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * SumOsc_setRatio(SumOsc *self, PyObject *arg) { SET_PARAM(self->ratio, self->ratio_stream, 3); } @@ -10614,6 +10705,7 @@ static PyMethodDef SumOsc_methods[] = { {"getServer", (PyCFunction)SumOsc_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SumOsc_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SumOsc_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SumOsc_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundfreqd."}, {"out", (PyCFunction)SumOsc_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundfreqd channel speficied by argument."}, {"stop", (PyCFunction)SumOsc_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -10645,9 +10737,9 @@ static PyNumberMethods SumOsc_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SumOsc_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SumOsc_float, /*nb_float*/ (binaryfunc)SumOsc_inplace_add, /*inplace_add*/ (binaryfunc)SumOsc_inplace_sub, /*inplace_subtract*/ (binaryfunc)SumOsc_inplace_multiply, /*inplace_multiply*/ @@ -11444,6 +11536,9 @@ static PyObject * SuperSaw_sub(SuperSaw *self, PyObject *arg) { SUB }; static PyObject * SuperSaw_inplace_sub(SuperSaw *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SuperSaw_div(SuperSaw *self, PyObject *arg) { DIV }; static PyObject * SuperSaw_inplace_div(SuperSaw *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SuperSaw_int(SuperSaw *self) { GET_I }; +static PyObject * SuperSaw_float(SuperSaw *self) { GET_F }; +static PyObject * SuperSaw_get(SuperSaw *self) { GET_F }; static PyObject * SuperSaw_setFreq(SuperSaw *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * SuperSaw_setDetune(SuperSaw *self, PyObject *arg) { SET_PARAM(self->detune, self->detune_stream, 3); } @@ -11465,6 +11560,7 @@ static PyMethodDef SuperSaw_methods[] = { {"getServer", (PyCFunction)SuperSaw_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SuperSaw_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SuperSaw_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SuperSaw_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SuperSaw_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SuperSaw_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -11496,9 +11592,9 @@ static PyNumberMethods SuperSaw_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SuperSaw_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SuperSaw_float, /*nb_float*/ (binaryfunc)SuperSaw_inplace_add, /*inplace_add*/ (binaryfunc)SuperSaw_inplace_sub, /*inplace_subtract*/ (binaryfunc)SuperSaw_inplace_multiply, /*inplace_multiply*/ @@ -11895,6 +11991,9 @@ static PyObject * RCOsc_sub(RCOsc *self, PyObject *arg) { SUB }; static PyObject * RCOsc_inplace_sub(RCOsc *self, PyObject *arg) { INPLACE_SUB }; static PyObject * RCOsc_div(RCOsc *self, PyObject *arg) { DIV }; static PyObject * RCOsc_inplace_div(RCOsc *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * RCOsc_int(RCOsc *self) { GET_I }; +static PyObject * RCOsc_float(RCOsc *self) { GET_F }; +static PyObject * RCOsc_get(RCOsc *self) { GET_F }; static PyObject * RCOsc_setFreq(RCOsc *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 2); } static PyObject * RCOsc_setSharp(RCOsc *self, PyObject *arg) { SET_PARAM(self->sharp, self->sharp_stream, 3); } @@ -11921,6 +12020,7 @@ static PyMethodDef RCOsc_methods[] = { {"getServer", (PyCFunction)RCOsc_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)RCOsc_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)RCOsc_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)RCOsc_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)RCOsc_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)RCOsc_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -11952,9 +12052,9 @@ static PyNumberMethods RCOsc_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)RCOsc_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)RCOsc_float, /*nb_float*/ (binaryfunc)RCOsc_inplace_add, /*inplace_add*/ (binaryfunc)RCOsc_inplace_sub, /*inplace_subtract*/ (binaryfunc)RCOsc_inplace_multiply, /*inplace_multiply*/ @@ -12235,6 +12335,9 @@ static PyObject * TableScale_sub(TableScale *self, PyObject *arg) { SUB }; static PyObject * TableScale_inplace_sub(TableScale *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TableScale_div(TableScale *self, PyObject *arg) { DIV }; static PyObject * TableScale_inplace_div(TableScale *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TableScale_int(TableScale *self) { GET_I }; +static PyObject * TableScale_float(TableScale *self) { GET_F }; +static PyObject * TableScale_get(TableScale *self) { GET_F }; static PyObject * TableScale_getTable(TableScale* self) @@ -12289,6 +12392,7 @@ static PyMethodDef TableScale_methods[] = {"getOuttable", (PyCFunction)TableScale_getOuttable, METH_NOARGS, "Returns output table object."}, {"getServer", (PyCFunction)TableScale_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TableScale_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TableScale_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TableScale_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TableScale_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TableScale_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -12319,9 +12423,9 @@ static PyNumberMethods TableScale_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TableScale_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TableScale_float, /*nb_float*/ (binaryfunc)TableScale_inplace_add, /*inplace_add*/ (binaryfunc)TableScale_inplace_sub, /*inplace_subtract*/ (binaryfunc)TableScale_inplace_multiply, /*inplace_multiply*/ @@ -12748,6 +12852,9 @@ static PyObject * TableScan_sub(TableScan *self, PyObject *arg) { SUB }; static PyObject * TableScan_inplace_sub(TableScan *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TableScan_div(TableScan *self, PyObject *arg) { DIV }; static PyObject * TableScan_inplace_div(TableScan *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TableScan_int(TableScan *self) { GET_I }; +static PyObject * TableScan_float(TableScan *self) { GET_F }; +static PyObject * TableScan_get(TableScan *self) { GET_F }; static PyObject * TableScan_getTable(TableScan* self) @@ -12789,6 +12896,7 @@ static PyMethodDef TableScan_methods[] = {"getTable", (PyCFunction)TableScan_getTable, METH_NOARGS, "Returns waveform table object."}, {"getServer", (PyCFunction)TableScan_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TableScan_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TableScan_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TableScan_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TableScan_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TableScan_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -12819,9 +12927,9 @@ static PyNumberMethods TableScan_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TableScan_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TableScan_float, /*nb_float*/ (binaryfunc)TableScan_inplace_add, /*inplace_add*/ (binaryfunc)TableScan_inplace_sub, /*inplace_subtract*/ (binaryfunc)TableScan_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/oscmodule.c b/src/objects/oscmodule.c index f1805289..e077a2ae 100644 --- a/src/objects/oscmodule.c +++ b/src/objects/oscmodule.c @@ -472,6 +472,9 @@ static PyObject * OscReceive_sub(OscReceive *self, PyObject *arg) { SUB }; static PyObject * OscReceive_inplace_sub(OscReceive *self, PyObject *arg) { INPLACE_SUB }; static PyObject * OscReceive_div(OscReceive *self, PyObject *arg) { DIV }; static PyObject * OscReceive_inplace_div(OscReceive *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * OscReceive_int(OscReceive *self) { GET_I }; +static PyObject * OscReceive_float(OscReceive *self) { GET_F }; +static PyObject * OscReceive_get(OscReceive *self) { GET_F }; static PyMemberDef OscReceive_members[] = { @@ -486,6 +489,7 @@ static PyMethodDef OscReceive_methods[] = { {"getServer", (PyCFunction)OscReceive_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)OscReceive_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)OscReceive_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)OscReceive_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)OscReceive_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setInterpolation", (PyCFunction)OscReceive_setInterpolation, METH_O, "Sets interpolation on or off."}, @@ -514,9 +518,9 @@ static PyNumberMethods OscReceive_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)OscReceive_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)OscReceive_float, /*nb_float*/ (binaryfunc)OscReceive_inplace_add, /*inplace_add*/ (binaryfunc)OscReceive_inplace_sub, /*inplace_subtract*/ (binaryfunc)OscReceive_inplace_multiply, /*inplace_multiply*/ @@ -1843,6 +1847,9 @@ static PyObject * OscListReceive_sub(OscListReceive *self, PyObject *arg) { SUB static PyObject * OscListReceive_inplace_sub(OscListReceive *self, PyObject *arg) { INPLACE_SUB }; static PyObject * OscListReceive_div(OscListReceive *self, PyObject *arg) { DIV }; static PyObject * OscListReceive_inplace_div(OscListReceive *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * OscListReceive_int(OscListReceive *self) { GET_I }; +static PyObject * OscListReceive_float(OscListReceive *self) { GET_F }; +static PyObject * OscListReceive_get(OscListReceive *self) { GET_F }; static PyMemberDef OscListReceive_members[] = { @@ -1857,6 +1864,7 @@ static PyMethodDef OscListReceive_methods[] = { {"getServer", (PyCFunction)OscListReceive_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)OscListReceive_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)OscListReceive_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)OscListReceive_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)OscListReceive_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setInterpolation", (PyCFunction)OscListReceive_setInterpolation, METH_O, "Sets interpolation on or off."}, @@ -1885,9 +1893,9 @@ static PyNumberMethods OscListReceive_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)OscListReceive_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)OscListReceive_float, /*nb_float*/ (binaryfunc)OscListReceive_inplace_add, /*inplace_add*/ (binaryfunc)OscListReceive_inplace_sub, /*inplace_subtract*/ (binaryfunc)OscListReceive_inplace_multiply, /*inplace_multiply*/ @@ -1945,4 +1953,4 @@ PyTypeObject OscListReceiveType = 0, /* tp_init */ 0, /* tp_alloc */ OscListReceive_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/panmodule.c b/src/objects/panmodule.c index fc2b2e53..9b47d8bc 100644 --- a/src/objects/panmodule.c +++ b/src/objects/panmodule.c @@ -581,6 +581,9 @@ static PyObject * Pan_sub(Pan *self, PyObject *arg) { SUB }; static PyObject * Pan_inplace_sub(Pan *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Pan_div(Pan *self, PyObject *arg) { DIV }; static PyObject * Pan_inplace_div(Pan *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Pan_int(Pan *self) { GET_I }; +static PyObject * Pan_float(Pan *self) { GET_F }; +static PyObject * Pan_get(Pan *self) { GET_F }; static PyMemberDef Pan_members[] = { @@ -595,6 +598,7 @@ static PyMethodDef Pan_methods[] = { {"getServer", (PyCFunction)Pan_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Pan_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Pan_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Pan_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Pan_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Pan_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -623,9 +627,9 @@ static PyNumberMethods Pan_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Pan_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Pan_float, /*nb_float*/ (binaryfunc)Pan_inplace_add, /*inplace_add*/ (binaryfunc)Pan_inplace_sub, /*inplace_subtract*/ (binaryfunc)Pan_inplace_multiply, /*inplace_multiply*/ @@ -1209,6 +1213,9 @@ static PyObject * SPan_sub(SPan *self, PyObject *arg) { SUB }; static PyObject * SPan_inplace_sub(SPan *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SPan_div(SPan *self, PyObject *arg) { DIV }; static PyObject * SPan_inplace_div(SPan *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SPan_int(SPan *self) { GET_I }; +static PyObject * SPan_float(SPan *self) { GET_F }; +static PyObject * SPan_get(SPan *self) { GET_F }; static PyMemberDef SPan_members[] = { @@ -1223,6 +1230,7 @@ static PyMethodDef SPan_methods[] = { {"getServer", (PyCFunction)SPan_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SPan_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SPan_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SPan_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SPan_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SPan_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1251,9 +1259,9 @@ static PyNumberMethods SPan_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SPan_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SPan_float, /*nb_float*/ (binaryfunc)SPan_inplace_add, /*inplace_add*/ (binaryfunc)SPan_inplace_sub, /*inplace_subtract*/ (binaryfunc)SPan_inplace_multiply, /*inplace_multiply*/ @@ -1757,6 +1765,9 @@ static PyObject * Switch_sub(Switch *self, PyObject *arg) { SUB }; static PyObject * Switch_inplace_sub(Switch *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Switch_div(Switch *self, PyObject *arg) { DIV }; static PyObject * Switch_inplace_div(Switch *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Switch_int(Switch *self) { GET_I }; +static PyObject * Switch_float(Switch *self) { GET_F }; +static PyObject * Switch_get(Switch *self) { GET_F }; static PyMemberDef Switch_members[] = { @@ -1771,6 +1782,7 @@ static PyMethodDef Switch_methods[] = { {"getServer", (PyCFunction)Switch_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Switch_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Switch_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Switch_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Switch_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Switch_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1799,9 +1811,9 @@ static PyNumberMethods Switch_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Switch_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Switch_float, /*nb_float*/ (binaryfunc)Switch_inplace_add, /*inplace_add*/ (binaryfunc)Switch_inplace_sub, /*inplace_subtract*/ (binaryfunc)Switch_inplace_multiply, /*inplace_multiply*/ @@ -2073,6 +2085,9 @@ static PyObject * VoiceManager_sub(VoiceManager *self, PyObject *arg) { SUB }; static PyObject * VoiceManager_inplace_sub(VoiceManager *self, PyObject *arg) { INPLACE_SUB }; static PyObject * VoiceManager_div(VoiceManager *self, PyObject *arg) { DIV }; static PyObject * VoiceManager_inplace_div(VoiceManager *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * VoiceManager_int(VoiceManager *self) { GET_I }; +static PyObject * VoiceManager_float(VoiceManager *self) { GET_F }; +static PyObject * VoiceManager_get(VoiceManager *self) { GET_F }; static PyObject * VoiceManager_setTriggers(VoiceManager *self, PyObject *arg) @@ -2115,6 +2130,7 @@ static PyMethodDef VoiceManager_methods[] = { {"getServer", (PyCFunction)VoiceManager_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)VoiceManager_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)VoiceManager_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)VoiceManager_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)VoiceManager_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setTriggers", (PyCFunction)VoiceManager_setTriggers, METH_O, "Sets list of trigger streams."}, @@ -2143,9 +2159,9 @@ static PyNumberMethods VoiceManager_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)VoiceManager_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)VoiceManager_float, /*nb_float*/ (binaryfunc)VoiceManager_inplace_add, /*inplace_add*/ (binaryfunc)VoiceManager_inplace_sub, /*inplace_subtract*/ (binaryfunc)VoiceManager_inplace_multiply, /*inplace_multiply*/ @@ -2752,6 +2768,9 @@ static PyObject * MixerVoice_sub(MixerVoice *self, PyObject *arg) { SUB }; static PyObject * MixerVoice_inplace_sub(MixerVoice *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MixerVoice_div(MixerVoice *self, PyObject *arg) { DIV }; static PyObject * MixerVoice_inplace_div(MixerVoice *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MixerVoice_int(MixerVoice *self) { GET_I }; +static PyObject * MixerVoice_float(MixerVoice *self) { GET_F }; +static PyObject * MixerVoice_get(MixerVoice *self) { GET_F }; static PyMemberDef MixerVoice_members[] = { @@ -2766,6 +2785,7 @@ static PyMethodDef MixerVoice_methods[] = { {"getServer", (PyCFunction)MixerVoice_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MixerVoice_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MixerVoice_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MixerVoice_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)MixerVoice_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)MixerVoice_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2794,9 +2814,9 @@ static PyNumberMethods MixerVoice_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MixerVoice_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MixerVoice_float, /*nb_float*/ (binaryfunc)MixerVoice_inplace_add, /*inplace_add*/ (binaryfunc)MixerVoice_inplace_sub, /*inplace_subtract*/ (binaryfunc)MixerVoice_inplace_multiply, /*inplace_multiply*/ @@ -3205,6 +3225,9 @@ static PyObject * Selector_sub(Selector *self, PyObject *arg) { SUB }; static PyObject * Selector_inplace_sub(Selector *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Selector_div(Selector *self, PyObject *arg) { DIV }; static PyObject * Selector_inplace_div(Selector *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Selector_int(Selector *self) { GET_I }; +static PyObject * Selector_float(Selector *self) { GET_F }; +static PyObject * Selector_get(Selector *self) { GET_F }; static PyObject * Selector_setInputs(Selector *self, PyObject *arg) @@ -3255,6 +3278,7 @@ static PyMethodDef Selector_methods[] = { {"getServer", (PyCFunction)Selector_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Selector_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Selector_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Selector_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Selector_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Selector_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3286,9 +3310,9 @@ static PyNumberMethods Selector_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Selector_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Selector_float, /*nb_float*/ (binaryfunc)Selector_inplace_add, /*inplace_add*/ (binaryfunc)Selector_inplace_sub, /*inplace_subtract*/ (binaryfunc)Selector_inplace_multiply, /*inplace_multiply*/ @@ -3347,4 +3371,3 @@ PyTypeObject SelectorType = 0, /* tp_alloc */ Selector_new, /* tp_new */ }; - diff --git a/src/objects/phasevocmodule.c b/src/objects/phasevocmodule.c index bfd88910..30431d3b 100644 --- a/src/objects/phasevocmodule.c +++ b/src/objects/phasevocmodule.c @@ -879,6 +879,9 @@ static PyObject * PVSynth_sub(PVSynth *self, PyObject *arg) { SUB }; static PyObject * PVSynth_inplace_sub(PVSynth *self, PyObject *arg) { INPLACE_SUB }; static PyObject * PVSynth_div(PVSynth *self, PyObject *arg) { DIV }; static PyObject * PVSynth_inplace_div(PVSynth *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * PVSynth_int(PVSynth *self) { GET_I }; +static PyObject * PVSynth_float(PVSynth *self) { GET_F }; +static PyObject * PVSynth_get(PVSynth *self) { GET_F }; static PyMemberDef PVSynth_members[] = { @@ -894,6 +897,7 @@ static PyMethodDef PVSynth_methods[] = { {"getServer", (PyCFunction)PVSynth_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)PVSynth_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)PVSynth_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)PVSynth_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)PVSynth_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)PVSynth_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -924,9 +928,9 @@ static PyNumberMethods PVSynth_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)PVSynth_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)PVSynth_float, /*nb_float*/ (binaryfunc)PVSynth_inplace_add, /*inplace_add*/ (binaryfunc)PVSynth_inplace_sub, /*inplace_subtract*/ (binaryfunc)PVSynth_inplace_multiply, /*inplace_multiply*/ @@ -1448,6 +1452,9 @@ static PyObject * PVAddSynth_sub(PVAddSynth *self, PyObject *arg) { SUB }; static PyObject * PVAddSynth_inplace_sub(PVAddSynth *self, PyObject *arg) { INPLACE_SUB }; static PyObject * PVAddSynth_div(PVAddSynth *self, PyObject *arg) { DIV }; static PyObject * PVAddSynth_inplace_div(PVAddSynth *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * PVAddSynth_int(PVAddSynth *self) { GET_I }; +static PyObject * PVAddSynth_float(PVAddSynth *self) { GET_F }; +static PyObject * PVAddSynth_get(PVAddSynth *self) { GET_F }; static PyMemberDef PVAddSynth_members[] = { @@ -1464,6 +1471,7 @@ static PyMethodDef PVAddSynth_methods[] = { {"getServer", (PyCFunction)PVAddSynth_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)PVAddSynth_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)PVAddSynth_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)PVAddSynth_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)PVAddSynth_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)PVAddSynth_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1497,9 +1505,9 @@ static PyNumberMethods PVAddSynth_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)PVAddSynth_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)PVAddSynth_float, /*nb_float*/ (binaryfunc)PVAddSynth_inplace_add, /*inplace_add*/ (binaryfunc)PVAddSynth_inplace_sub, /*inplace_subtract*/ (binaryfunc)PVAddSynth_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/randommodule.c b/src/objects/randommodule.c index cf9e21e5..b8302b8d 100644 --- a/src/objects/randommodule.c +++ b/src/objects/randommodule.c @@ -496,6 +496,9 @@ static PyObject * Randi_sub(Randi *self, PyObject *arg) { SUB }; static PyObject * Randi_inplace_sub(Randi *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Randi_div(Randi *self, PyObject *arg) { DIV }; static PyObject * Randi_inplace_div(Randi *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Randi_int(Randi *self) { GET_I }; +static PyObject * Randi_float(Randi *self) { GET_F }; +static PyObject * Randi_get(Randi *self) { GET_F }; static PyObject * Randi_setMin(Randi *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Randi_setMax(Randi *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -517,6 +520,7 @@ static PyMethodDef Randi_methods[] = { {"getServer", (PyCFunction)Randi_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Randi_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Randi_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Randi_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Randi_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Randi_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -548,9 +552,9 @@ static PyNumberMethods Randi_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Randi_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Randi_float, /*nb_float*/ (binaryfunc)Randi_inplace_add, /*inplace_add*/ (binaryfunc)Randi_inplace_sub, /*inplace_subtract*/ (binaryfunc)Randi_inplace_multiply, /*inplace_multiply*/ @@ -1065,6 +1069,9 @@ static PyObject * Randh_sub(Randh *self, PyObject *arg) { SUB }; static PyObject * Randh_inplace_sub(Randh *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Randh_div(Randh *self, PyObject *arg) { DIV }; static PyObject * Randh_inplace_div(Randh *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Randh_int(Randh *self) { GET_I }; +static PyObject * Randh_float(Randh *self) { GET_F }; +static PyObject * Randh_get(Randh *self) { GET_F }; static PyObject * Randh_setMin(Randh *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Randh_setMax(Randh *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -1086,6 +1093,7 @@ static PyMethodDef Randh_methods[] = { {"getServer", (PyCFunction)Randh_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Randh_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Randh_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Randh_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Randh_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Randh_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1117,9 +1125,9 @@ static PyNumberMethods Randh_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Randh_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Randh_float, /*nb_float*/ (binaryfunc)Randh_inplace_add, /*inplace_add*/ (binaryfunc)Randh_inplace_sub, /*inplace_subtract*/ (binaryfunc)Randh_inplace_multiply, /*inplace_multiply*/ @@ -1415,6 +1423,9 @@ static PyObject * Choice_sub(Choice *self, PyObject *arg) { SUB }; static PyObject * Choice_inplace_sub(Choice *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Choice_div(Choice *self, PyObject *arg) { DIV }; static PyObject * Choice_inplace_div(Choice *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Choice_int(Choice *self) { GET_I }; +static PyObject * Choice_float(Choice *self) { GET_F }; +static PyObject * Choice_get(Choice *self) { GET_F }; static PyObject * Choice_setChoice(Choice *self, PyObject *arg) @@ -1456,6 +1467,7 @@ static PyMethodDef Choice_methods[] = { {"getServer", (PyCFunction)Choice_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Choice_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Choice_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Choice_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Choice_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Choice_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1486,9 +1498,9 @@ static PyNumberMethods Choice_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Choice_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Choice_float, /*nb_float*/ (binaryfunc)Choice_inplace_add, /*inplace_add*/ (binaryfunc)Choice_inplace_sub, /*inplace_subtract*/ (binaryfunc)Choice_inplace_multiply, /*inplace_multiply*/ @@ -1847,6 +1859,9 @@ static PyObject * RandInt_sub(RandInt *self, PyObject *arg) { SUB }; static PyObject * RandInt_inplace_sub(RandInt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * RandInt_div(RandInt *self, PyObject *arg) { DIV }; static PyObject * RandInt_inplace_div(RandInt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * RandInt_int(RandInt *self) { GET_I }; +static PyObject * RandInt_float(RandInt *self) { GET_F }; +static PyObject * RandInt_get(RandInt *self) { GET_F }; static PyObject * RandInt_setMax(RandInt *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 2); } static PyObject * RandInt_setFreq(RandInt *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 3); } @@ -1866,6 +1881,7 @@ static PyMethodDef RandInt_methods[] = { {"getServer", (PyCFunction)RandInt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)RandInt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)RandInt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)RandInt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)RandInt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)RandInt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1896,9 +1912,9 @@ static PyNumberMethods RandInt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)RandInt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)RandInt_float, /*nb_float*/ (binaryfunc)RandInt_inplace_add, /*inplace_add*/ (binaryfunc)RandInt_inplace_sub, /*inplace_subtract*/ (binaryfunc)RandInt_inplace_multiply, /*inplace_multiply*/ @@ -2314,6 +2330,9 @@ static PyObject * RandDur_sub(RandDur *self, PyObject *arg) { SUB }; static PyObject * RandDur_inplace_sub(RandDur *self, PyObject *arg) { INPLACE_SUB }; static PyObject * RandDur_div(RandDur *self, PyObject *arg) { DIV }; static PyObject * RandDur_inplace_div(RandDur *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * RandDur_int(RandDur *self) { GET_I }; +static PyObject * RandDur_float(RandDur *self) { GET_F }; +static PyObject * RandDur_get(RandDur *self) { GET_F }; static PyObject * RandDur_setMin(RandDur *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * RandDur_setMax(RandDur *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -2333,6 +2352,7 @@ static PyMethodDef RandDur_methods[] = { {"getServer", (PyCFunction)RandDur_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)RandDur_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)RandDur_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)RandDur_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)RandDur_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)RandDur_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2363,9 +2383,9 @@ static PyNumberMethods RandDur_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)RandDur_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)RandDur_float, /*nb_float*/ (binaryfunc)RandDur_inplace_add, /*inplace_add*/ (binaryfunc)RandDur_inplace_sub, /*inplace_subtract*/ (binaryfunc)RandDur_inplace_multiply, /*inplace_multiply*/ @@ -3222,6 +3242,9 @@ static PyObject * Xnoise_sub(Xnoise *self, PyObject *arg) { SUB }; static PyObject * Xnoise_inplace_sub(Xnoise *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Xnoise_div(Xnoise *self, PyObject *arg) { DIV }; static PyObject * Xnoise_inplace_div(Xnoise *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Xnoise_int(Xnoise *self) { GET_I }; +static PyObject * Xnoise_float(Xnoise *self) { GET_F }; +static PyObject * Xnoise_get(Xnoise *self) { GET_F }; static PyObject * Xnoise_setType(Xnoise *self, PyObject *arg) @@ -3257,6 +3280,7 @@ static PyMethodDef Xnoise_methods[] = { {"getServer", (PyCFunction)Xnoise_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Xnoise_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Xnoise_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Xnoise_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Xnoise_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Xnoise_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3289,9 +3313,9 @@ static PyNumberMethods Xnoise_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Xnoise_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Xnoise_float, /*nb_float*/ (binaryfunc)Xnoise_inplace_add, /*inplace_add*/ (binaryfunc)Xnoise_inplace_sub, /*inplace_subtract*/ (binaryfunc)Xnoise_inplace_multiply, /*inplace_multiply*/ @@ -4194,6 +4218,9 @@ static PyObject * XnoiseMidi_sub(XnoiseMidi *self, PyObject *arg) { SUB }; static PyObject * XnoiseMidi_inplace_sub(XnoiseMidi *self, PyObject *arg) { INPLACE_SUB }; static PyObject * XnoiseMidi_div(XnoiseMidi *self, PyObject *arg) { DIV }; static PyObject * XnoiseMidi_inplace_div(XnoiseMidi *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * XnoiseMidi_int(XnoiseMidi *self) { GET_I }; +static PyObject * XnoiseMidi_float(XnoiseMidi *self) { GET_F }; +static PyObject * XnoiseMidi_get(XnoiseMidi *self) { GET_F }; static PyObject * XnoiseMidi_setType(XnoiseMidi *self, PyObject *arg) @@ -4269,6 +4296,7 @@ static PyMethodDef XnoiseMidi_methods[] = { {"getServer", (PyCFunction)XnoiseMidi_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)XnoiseMidi_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)XnoiseMidi_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)XnoiseMidi_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)XnoiseMidi_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)XnoiseMidi_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4303,9 +4331,9 @@ static PyNumberMethods XnoiseMidi_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)XnoiseMidi_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)XnoiseMidi_float, /*nb_float*/ (binaryfunc)XnoiseMidi_inplace_add, /*inplace_add*/ (binaryfunc)XnoiseMidi_inplace_sub, /*inplace_subtract*/ (binaryfunc)XnoiseMidi_inplace_multiply, /*inplace_multiply*/ @@ -4992,6 +5020,9 @@ static PyObject * XnoiseDur_sub(XnoiseDur *self, PyObject *arg) { SUB }; static PyObject * XnoiseDur_inplace_sub(XnoiseDur *self, PyObject *arg) { INPLACE_SUB }; static PyObject * XnoiseDur_div(XnoiseDur *self, PyObject *arg) { DIV }; static PyObject * XnoiseDur_inplace_div(XnoiseDur *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * XnoiseDur_int(XnoiseDur *self) { GET_I }; +static PyObject * XnoiseDur_float(XnoiseDur *self) { GET_F }; +static PyObject * XnoiseDur_get(XnoiseDur *self) { GET_F }; static PyObject * XnoiseDur_setType(XnoiseDur *self, PyObject *arg) @@ -5029,6 +5060,7 @@ static PyMethodDef XnoiseDur_methods[] = { {"getServer", (PyCFunction)XnoiseDur_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)XnoiseDur_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)XnoiseDur_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)XnoiseDur_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)XnoiseDur_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)XnoiseDur_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5062,9 +5094,9 @@ static PyNumberMethods XnoiseDur_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)XnoiseDur_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)XnoiseDur_float, /*nb_float*/ (binaryfunc)XnoiseDur_inplace_add, /*inplace_add*/ (binaryfunc)XnoiseDur_inplace_sub, /*inplace_subtract*/ (binaryfunc)XnoiseDur_inplace_multiply, /*inplace_multiply*/ @@ -5430,6 +5462,9 @@ static PyObject * Urn_sub(Urn *self, PyObject *arg) { SUB }; static PyObject * Urn_inplace_sub(Urn *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Urn_div(Urn *self, PyObject *arg) { DIV }; static PyObject * Urn_inplace_div(Urn *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Urn_int(Urn *self) { GET_I }; +static PyObject * Urn_float(Urn *self) { GET_F }; +static PyObject * Urn_get(Urn *self) { GET_F }; static PyObject * Urn_setMax(Urn *self, PyObject *arg) @@ -5460,6 +5495,7 @@ static PyMethodDef Urn_methods[] = {"getServer", (PyCFunction)Urn_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Urn_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)Urn_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)Urn_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Urn_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Urn_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Urn_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5490,9 +5526,9 @@ static PyNumberMethods Urn_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Urn_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Urn_float, /*nb_float*/ (binaryfunc)Urn_inplace_add, /*inplace_add*/ (binaryfunc)Urn_inplace_sub, /*inplace_subtract*/ (binaryfunc)Urn_inplace_multiply, /*inplace_multiply*/ @@ -5877,6 +5913,9 @@ static PyObject * LogiMap_sub(LogiMap *self, PyObject *arg) { SUB }; static PyObject * LogiMap_inplace_sub(LogiMap *self, PyObject *arg) { INPLACE_SUB }; static PyObject * LogiMap_div(LogiMap *self, PyObject *arg) { DIV }; static PyObject * LogiMap_inplace_div(LogiMap *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * LogiMap_int(LogiMap *self) { GET_I }; +static PyObject * LogiMap_float(LogiMap *self) { GET_F }; +static PyObject * LogiMap_get(LogiMap *self) { GET_F }; static PyObject * LogiMap_setChaos(LogiMap *self, PyObject *arg) { SET_PARAM(self->chaos, self->chaos_stream, 2); } static PyObject * LogiMap_setFreq(LogiMap *self, PyObject *arg) { SET_PARAM(self->freq, self->freq_stream, 3); } @@ -5896,6 +5935,7 @@ static PyMethodDef LogiMap_methods[] = { {"getServer", (PyCFunction)LogiMap_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)LogiMap_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)LogiMap_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)LogiMap_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)LogiMap_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)LogiMap_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -5926,9 +5966,9 @@ static PyNumberMethods LogiMap_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)LogiMap_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)LogiMap_float, /*nb_float*/ (binaryfunc)LogiMap_inplace_add, /*inplace_add*/ (binaryfunc)LogiMap_inplace_sub, /*inplace_subtract*/ (binaryfunc)LogiMap_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/recordmodule.c b/src/objects/recordmodule.c index 8fea5f53..7e653645 100644 --- a/src/objects/recordmodule.c +++ b/src/objects/recordmodule.c @@ -850,6 +850,9 @@ static PyObject * ControlRead_sub(ControlRead *self, PyObject *arg) { SUB }; static PyObject * ControlRead_inplace_sub(ControlRead *self, PyObject *arg) { INPLACE_SUB }; static PyObject * ControlRead_div(ControlRead *self, PyObject *arg) { DIV }; static PyObject * ControlRead_inplace_div(ControlRead *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * ControlRead_int(ControlRead *self) { GET_I }; +static PyObject * ControlRead_float(ControlRead *self) { GET_F }; +static PyObject * ControlRead_get(ControlRead *self) { GET_F }; static PyObject * ControlRead_setValues(ControlRead *self, PyObject *arg) @@ -920,6 +923,7 @@ static PyMethodDef ControlRead_methods[] = {"getServer", (PyCFunction)ControlRead_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)ControlRead_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)ControlRead_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)ControlRead_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)ControlRead_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)ControlRead_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValues", (PyCFunction)ControlRead_setValues, METH_O, "Fill buffer with values in input."}, @@ -951,9 +955,9 @@ static PyNumberMethods ControlRead_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)ControlRead_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)ControlRead_float, /*nb_float*/ (binaryfunc)ControlRead_inplace_add, /*inplace_add*/ (binaryfunc)ControlRead_inplace_sub, /*inplace_subtract*/ (binaryfunc)ControlRead_inplace_multiply, /*inplace_multiply*/ @@ -1480,6 +1484,9 @@ static PyObject * NoteinRead_sub(NoteinRead *self, PyObject *arg) { SUB }; static PyObject * NoteinRead_inplace_sub(NoteinRead *self, PyObject *arg) { INPLACE_SUB }; static PyObject * NoteinRead_div(NoteinRead *self, PyObject *arg) { DIV }; static PyObject * NoteinRead_inplace_div(NoteinRead *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * NoteinRead_int(NoteinRead *self) { GET_I }; +static PyObject * NoteinRead_float(NoteinRead *self) { GET_F }; +static PyObject * NoteinRead_get(NoteinRead *self) { GET_F }; static PyObject * NoteinRead_setValues(NoteinRead *self, PyObject *arg) @@ -1542,6 +1549,7 @@ static PyMethodDef NoteinRead_methods[] = {"getServer", (PyCFunction)NoteinRead_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)NoteinRead_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)NoteinRead_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)NoteinRead_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)NoteinRead_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)NoteinRead_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValues", (PyCFunction)NoteinRead_setValues, METH_O, "Fill buffer with values in input."}, @@ -1572,9 +1580,9 @@ static PyNumberMethods NoteinRead_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)NoteinRead_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)NoteinRead_float, /*nb_float*/ (binaryfunc)NoteinRead_inplace_add, /*inplace_add*/ (binaryfunc)NoteinRead_inplace_sub, /*inplace_subtract*/ (binaryfunc)NoteinRead_inplace_multiply, /*inplace_multiply*/ @@ -1632,4 +1640,4 @@ PyTypeObject NoteinReadType = 0, /* tp_init */ 0, /* tp_alloc */ NoteinRead_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/selectmodule.c b/src/objects/selectmodule.c index 420da0c6..7e94d7fc 100644 --- a/src/objects/selectmodule.c +++ b/src/objects/selectmodule.c @@ -208,6 +208,9 @@ static PyObject * Select_sub(Select *self, PyObject *arg) { SUB }; static PyObject * Select_inplace_sub(Select *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Select_div(Select *self, PyObject *arg) { DIV }; static PyObject * Select_inplace_div(Select *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Select_int(Select *self) { GET_I }; +static PyObject * Select_float(Select *self) { GET_F }; +static PyObject * Select_get(Select *self) { GET_F }; static PyObject * Select_setValue(Select *self, PyObject *arg) @@ -235,6 +238,7 @@ static PyMethodDef Select_methods[] = { {"getServer", (PyCFunction)Select_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Select_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Select_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Select_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Select_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValue", (PyCFunction)Select_setValue, METH_O, "Sets value to select."}, @@ -263,9 +267,9 @@ static PyNumberMethods Select_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Select_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Select_float, /*nb_float*/ (binaryfunc)Select_inplace_add, /*inplace_add*/ (binaryfunc)Select_inplace_sub, /*inplace_subtract*/ (binaryfunc)Select_inplace_multiply, /*inplace_multiply*/ @@ -506,6 +510,9 @@ static PyObject * Change_sub(Change *self, PyObject *arg) { SUB }; static PyObject * Change_inplace_sub(Change *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Change_div(Change *self, PyObject *arg) { DIV }; static PyObject * Change_inplace_div(Change *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Change_int(Change *self) { GET_I }; +static PyObject * Change_float(Change *self) { GET_F }; +static PyObject * Change_get(Change *self) { GET_F }; static PyMemberDef Change_members[] = { @@ -520,6 +527,7 @@ static PyMethodDef Change_methods[] = { {"getServer", (PyCFunction)Change_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Change_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Change_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Change_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Change_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)Change_setMul, METH_O, "Sets mul factor."}, @@ -547,9 +555,9 @@ static PyNumberMethods Change_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Change_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Change_float, /*nb_float*/ (binaryfunc)Change_inplace_add, /*inplace_add*/ (binaryfunc)Change_inplace_sub, /*inplace_subtract*/ (binaryfunc)Change_inplace_multiply, /*inplace_multiply*/ @@ -607,4 +615,4 @@ PyTypeObject ChangeType = 0, /* tp_init */ 0, /* tp_alloc */ Change_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/sfplayermodule.c b/src/objects/sfplayermodule.c index f5475dc2..f0104c7d 100644 --- a/src/objects/sfplayermodule.c +++ b/src/objects/sfplayermodule.c @@ -744,6 +744,9 @@ static PyObject * SfPlay_sub(SfPlay *self, PyObject *arg) { SUB }; static PyObject * SfPlay_inplace_sub(SfPlay *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SfPlay_div(SfPlay *self, PyObject *arg) { DIV }; static PyObject * SfPlay_inplace_div(SfPlay *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SfPlay_int(SfPlay *self) { GET_I }; +static PyObject * SfPlay_float(SfPlay *self) { GET_F }; +static PyObject * SfPlay_get(SfPlay *self) { GET_F }; static PyMemberDef SfPlay_members[] = { @@ -758,6 +761,7 @@ static PyMethodDef SfPlay_methods[] = { {"getServer", (PyCFunction)SfPlay_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SfPlay_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SfPlay_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SfPlay_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SfPlay_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SfPlay_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -786,9 +790,9 @@ static PyNumberMethods SfPlay_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SfPlay_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SfPlay_float, /*nb_float*/ (binaryfunc)SfPlay_inplace_add, /*inplace_add*/ (binaryfunc)SfPlay_inplace_sub, /*inplace_subtract*/ (binaryfunc)SfPlay_inplace_multiply, /*inplace_multiply*/ @@ -1734,6 +1738,9 @@ static PyObject * SfMarkerShuffle_sub(SfMarkerShuffle *self, PyObject *arg) { SU static PyObject * SfMarkerShuffle_inplace_sub(SfMarkerShuffle *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SfMarkerShuffle_div(SfMarkerShuffle *self, PyObject *arg) { DIV }; static PyObject * SfMarkerShuffle_inplace_div(SfMarkerShuffle *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SfMarkerShuffle_int(SfMarkerShuffle *self) { GET_I }; +static PyObject * SfMarkerShuffle_float(SfMarkerShuffle *self) { GET_F }; +static PyObject * SfMarkerShuffle_get(SfMarkerShuffle *self) { GET_F }; static PyMemberDef SfMarkerShuffle_members[] = { @@ -1748,6 +1755,7 @@ static PyMethodDef SfMarkerShuffle_methods[] = { {"getServer", (PyCFunction)SfMarkerShuffle_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SfMarkerShuffle_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SfMarkerShuffle_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SfMarkerShuffle_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SfMarkerShuffle_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SfMarkerShuffle_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1776,9 +1784,9 @@ static PyNumberMethods SfMarkerShuffle_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SfMarkerShuffle_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SfMarkerShuffle_float, /*nb_float*/ (binaryfunc)SfMarkerShuffle_inplace_add, /*inplace_add*/ (binaryfunc)SfMarkerShuffle_inplace_sub, /*inplace_subtract*/ (binaryfunc)SfMarkerShuffle_inplace_multiply, /*inplace_multiply*/ @@ -2530,6 +2538,9 @@ static PyObject * SfMarkerLoop_sub(SfMarkerLoop *self, PyObject *arg) { SUB }; static PyObject * SfMarkerLoop_inplace_sub(SfMarkerLoop *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SfMarkerLoop_div(SfMarkerLoop *self, PyObject *arg) { DIV }; static PyObject * SfMarkerLoop_inplace_div(SfMarkerLoop *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SfMarkerLoop_int(SfMarkerLoop *self) { GET_I }; +static PyObject * SfMarkerLoop_float(SfMarkerLoop *self) { GET_F }; +static PyObject * SfMarkerLoop_get(SfMarkerLoop *self) { GET_F }; static PyMemberDef SfMarkerLoop_members[] = { @@ -2544,6 +2555,7 @@ static PyMethodDef SfMarkerLoop_methods[] = { {"getServer", (PyCFunction)SfMarkerLoop_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SfMarkerLoop_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SfMarkerLoop_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SfMarkerLoop_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SfMarkerLoop_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SfMarkerLoop_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2572,9 +2584,9 @@ static PyNumberMethods SfMarkerLoop_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SfMarkerLoop_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SfMarkerLoop_float, /*nb_float*/ (binaryfunc)SfMarkerLoop_inplace_add, /*inplace_add*/ (binaryfunc)SfMarkerLoop_inplace_sub, /*inplace_subtract*/ (binaryfunc)SfMarkerLoop_inplace_multiply, /*inplace_multiply*/ @@ -2632,4 +2644,4 @@ PyTypeObject SfMarkerLoopType = 0, /* tp_init */ 0, /* tp_alloc */ SfMarkerLoop_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/sigmodule.c b/src/objects/sigmodule.c index cc54fd71..e0fedfb8 100644 --- a/src/objects/sigmodule.c +++ b/src/objects/sigmodule.c @@ -191,6 +191,7 @@ static PyObject * Sig_setValue(Sig *self, PyObject *arg) { SET_PARAM(self->value static PyObject * Sig_getServer(Sig* self) { GET_SERVER }; static PyObject * Sig_getStream(Sig* self) { GET_STREAM }; +static PyObject * Sig_get(Sig *self) { GET_F }; static PyObject * Sig_setMul(Sig *self, PyObject *arg) { SET_MUL }; static PyObject * Sig_setAdd(Sig *self, PyObject *arg) { SET_ADD }; static PyObject * Sig_setSub(Sig *self, PyObject *arg) { SET_SUB }; @@ -208,6 +209,8 @@ static PyObject * Sig_sub(Sig *self, PyObject *arg) { SUB }; static PyObject * Sig_inplace_sub(Sig *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Sig_div(Sig *self, PyObject *arg) { DIV }; static PyObject * Sig_inplace_div(Sig *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Sig_int(Sig *self) { GET_I }; +static PyObject * Sig_float(Sig *self) { GET_F }; static PyMemberDef Sig_members[] = { @@ -223,6 +226,7 @@ static PyMethodDef Sig_methods[] = { {"getServer", (PyCFunction)Sig_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Sig_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Sig_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Sig_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Sig_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Sig_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -252,9 +256,9 @@ static PyNumberMethods Sig_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ + (unaryfunc)Sig_int, /*nb_int*/ 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Sig_float, /*nb_float*/ (binaryfunc)Sig_inplace_add, /*inplace_add*/ (binaryfunc)Sig_inplace_sub, /*inplace_subtract*/ (binaryfunc)Sig_inplace_multiply, /*inplace_multiply*/ @@ -602,6 +606,9 @@ static PyObject * SigTo_sub(SigTo *self, PyObject *arg) { SUB }; static PyObject * SigTo_inplace_sub(SigTo *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SigTo_div(SigTo *self, PyObject *arg) { DIV }; static PyObject * SigTo_inplace_div(SigTo *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SigTo_int(SigTo *self) { GET_I }; +static PyObject * SigTo_float(SigTo *self) { GET_F }; +static PyObject * SigTo_get(SigTo *self) { GET_F }; static PyMemberDef SigTo_members[] = { @@ -618,6 +625,7 @@ static PyMethodDef SigTo_methods[] = { {"getServer", (PyCFunction)SigTo_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SigTo_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SigTo_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SigTo_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)SigTo_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValue", (PyCFunction)SigTo_setValue, METH_O, "Sets SigTo value."}, @@ -647,9 +655,9 @@ static PyNumberMethods SigTo_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SigTo_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SigTo_float, /*nb_float*/ (binaryfunc)SigTo_inplace_add, /*inplace_add*/ (binaryfunc)SigTo_inplace_sub, /*inplace_subtract*/ (binaryfunc)SigTo_inplace_multiply, /*inplace_multiply*/ @@ -1027,6 +1035,9 @@ static PyObject * VarPort_sub(VarPort *self, PyObject *arg) { SUB }; static PyObject * VarPort_inplace_sub(VarPort *self, PyObject *arg) { INPLACE_SUB }; static PyObject * VarPort_div(VarPort *self, PyObject *arg) { DIV }; static PyObject * VarPort_inplace_div(VarPort *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * VarPort_int(VarPort *self) { GET_I }; +static PyObject * VarPort_float(VarPort *self) { GET_F }; +static PyObject * VarPort_get(VarPort *self) { GET_F }; static PyMemberDef VarPort_members[] = { @@ -1041,6 +1052,7 @@ static PyMethodDef VarPort_methods[] = { {"getServer", (PyCFunction)VarPort_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)VarPort_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)VarPort_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)VarPort_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)VarPort_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setValue", (PyCFunction)VarPort_setValue, METH_O, "Sets VarPort value."}, @@ -1071,9 +1083,9 @@ static PyNumberMethods VarPort_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)VarPort_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)VarPort_float, /*nb_float*/ (binaryfunc)VarPort_inplace_add, /*inplace_add*/ (binaryfunc)VarPort_inplace_sub, /*inplace_subtract*/ (binaryfunc)VarPort_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/tablemodule.c b/src/objects/tablemodule.c index 48038270..d27191cd 100644 --- a/src/objects/tablemodule.c +++ b/src/objects/tablemodule.c @@ -6585,6 +6585,9 @@ static PyObject * TableRecTimeStream_sub(TableRecTimeStream *self, PyObject *arg static PyObject * TableRecTimeStream_inplace_sub(TableRecTimeStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TableRecTimeStream_div(TableRecTimeStream *self, PyObject *arg) { DIV }; static PyObject * TableRecTimeStream_inplace_div(TableRecTimeStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TableRecTimeStream_int(TableRecTimeStream *self) { GET_I }; +static PyObject * TableRecTimeStream_float(TableRecTimeStream *self) { GET_F }; +static PyObject * TableRecTimeStream_get(TableRecTimeStream *self) { GET_F }; static PyMemberDef TableRecTimeStream_members[] = { @@ -6599,6 +6602,7 @@ static PyMethodDef TableRecTimeStream_methods[] = { {"getServer", (PyCFunction)TableRecTimeStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TableRecTimeStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TableRecTimeStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TableRecTimeStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TableRecTimeStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TableRecTimeStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6627,9 +6631,9 @@ static PyNumberMethods TableRecTimeStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TableRecTimeStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TableRecTimeStream_float, /*nb_float*/ (binaryfunc)TableRecTimeStream_inplace_add, /*inplace_add*/ (binaryfunc)TableRecTimeStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TableRecTimeStream_inplace_multiply, /*inplace_multiply*/ @@ -7414,6 +7418,9 @@ static PyObject * TrigTableRecTimeStream_sub(TrigTableRecTimeStream *self, PyObj static PyObject * TrigTableRecTimeStream_inplace_sub(TrigTableRecTimeStream *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigTableRecTimeStream_div(TrigTableRecTimeStream *self, PyObject *arg) { DIV }; static PyObject * TrigTableRecTimeStream_inplace_div(TrigTableRecTimeStream *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigTableRecTimeStream_int(TrigTableRecTimeStream *self) { GET_I }; +static PyObject * TrigTableRecTimeStream_float(TrigTableRecTimeStream *self) { GET_F }; +static PyObject * TrigTableRecTimeStream_get(TrigTableRecTimeStream *self) { GET_F }; static PyMemberDef TrigTableRecTimeStream_members[] = { @@ -7428,6 +7435,7 @@ static PyMethodDef TrigTableRecTimeStream_methods[] = { {"getServer", (PyCFunction)TrigTableRecTimeStream_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigTableRecTimeStream_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigTableRecTimeStream_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigTableRecTimeStream_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigTableRecTimeStream_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigTableRecTimeStream_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -7456,9 +7464,9 @@ static PyNumberMethods TrigTableRecTimeStream_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigTableRecTimeStream_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigTableRecTimeStream_float, /*nb_float*/ (binaryfunc)TrigTableRecTimeStream_inplace_add, /*inplace_add*/ (binaryfunc)TrigTableRecTimeStream_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigTableRecTimeStream_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/trigmodule.c b/src/objects/trigmodule.c index c9c55007..bffc7aaa 100644 --- a/src/objects/trigmodule.c +++ b/src/objects/trigmodule.c @@ -248,6 +248,9 @@ static PyObject * TrigRandInt_sub(TrigRandInt *self, PyObject *arg) { SUB }; static PyObject * TrigRandInt_inplace_sub(TrigRandInt *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigRandInt_div(TrigRandInt *self, PyObject *arg) { DIV }; static PyObject * TrigRandInt_inplace_div(TrigRandInt *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigRandInt_int(TrigRandInt *self) { GET_I }; +static PyObject * TrigRandInt_float(TrigRandInt *self) { GET_F }; +static PyObject * TrigRandInt_get(TrigRandInt *self) { GET_F }; static PyObject * TrigRandInt_setMax(TrigRandInt *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 2); } @@ -266,6 +269,7 @@ static PyMethodDef TrigRandInt_methods[] = { {"getServer", (PyCFunction)TrigRandInt_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigRandInt_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigRandInt_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigRandInt_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigRandInt_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigRandInt_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -295,9 +299,9 @@ static PyNumberMethods TrigRandInt_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigRandInt_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigRandInt_float, /*nb_float*/ (binaryfunc)TrigRandInt_inplace_add, /*inplace_add*/ (binaryfunc)TrigRandInt_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigRandInt_inplace_multiply, /*inplace_multiply*/ @@ -720,6 +724,9 @@ static PyObject * TrigRand_sub(TrigRand *self, PyObject *arg) { SUB }; static PyObject * TrigRand_inplace_sub(TrigRand *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigRand_div(TrigRand *self, PyObject *arg) { DIV }; static PyObject * TrigRand_inplace_div(TrigRand *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigRand_int(TrigRand *self) { GET_I }; +static PyObject * TrigRand_float(TrigRand *self) { GET_F }; +static PyObject * TrigRand_get(TrigRand *self) { GET_F }; static PyObject * TrigRand_setMin(TrigRand *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * TrigRand_setMax(TrigRand *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -754,6 +761,7 @@ static PyMethodDef TrigRand_methods[] = { {"getServer", (PyCFunction)TrigRand_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigRand_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigRand_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigRand_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigRand_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigRand_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -785,9 +793,9 @@ static PyNumberMethods TrigRand_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigRand_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigRand_float, /*nb_float*/ (binaryfunc)TrigRand_inplace_add, /*inplace_add*/ (binaryfunc)TrigRand_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigRand_inplace_multiply, /*inplace_multiply*/ @@ -1064,6 +1072,9 @@ static PyObject * TrigChoice_sub(TrigChoice *self, PyObject *arg) { SUB }; static PyObject * TrigChoice_inplace_sub(TrigChoice *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigChoice_div(TrigChoice *self, PyObject *arg) { DIV }; static PyObject * TrigChoice_inplace_div(TrigChoice *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigChoice_int(TrigChoice *self) { GET_I }; +static PyObject * TrigChoice_float(TrigChoice *self) { GET_F }; +static PyObject * TrigChoice_get(TrigChoice *self) { GET_F }; static PyObject * TrigChoice_setChoice(TrigChoice *self, PyObject *arg) @@ -1117,6 +1128,7 @@ static PyMethodDef TrigChoice_methods[] = { {"getServer", (PyCFunction)TrigChoice_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigChoice_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigChoice_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigChoice_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigChoice_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigChoice_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1147,9 +1159,9 @@ static PyNumberMethods TrigChoice_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigChoice_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigChoice_float, /*nb_float*/ (binaryfunc)TrigChoice_inplace_add, /*inplace_add*/ (binaryfunc)TrigChoice_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigChoice_inplace_multiply, /*inplace_multiply*/ @@ -1755,6 +1767,9 @@ static PyObject * TrigEnv_sub(TrigEnv *self, PyObject *arg) { SUB }; static PyObject * TrigEnv_inplace_sub(TrigEnv *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigEnv_div(TrigEnv *self, PyObject *arg) { DIV }; static PyObject * TrigEnv_inplace_div(TrigEnv *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigEnv_int(TrigEnv *self) { GET_I }; +static PyObject * TrigEnv_float(TrigEnv *self) { GET_F }; +static PyObject * TrigEnv_get(TrigEnv *self) { GET_F }; static PyObject * TrigEnv_getTable(TrigEnv* self) @@ -1809,6 +1824,7 @@ static PyMethodDef TrigEnv_methods[] = {"getServer", (PyCFunction)TrigEnv_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigEnv_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)TrigEnv_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)TrigEnv_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigEnv_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigEnv_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigEnv_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1840,9 +1856,9 @@ static PyNumberMethods TrigEnv_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigEnv_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigEnv_float, /*nb_float*/ (binaryfunc)TrigEnv_inplace_add, /*inplace_add*/ (binaryfunc)TrigEnv_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigEnv_inplace_multiply, /*inplace_multiply*/ @@ -2172,6 +2188,9 @@ static PyObject * TrigLinseg_sub(TrigLinseg *self, PyObject *arg) { SUB }; static PyObject * TrigLinseg_inplace_sub(TrigLinseg *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigLinseg_div(TrigLinseg *self, PyObject *arg) { DIV }; static PyObject * TrigLinseg_inplace_div(TrigLinseg *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigLinseg_int(TrigLinseg *self) { GET_I }; +static PyObject * TrigLinseg_float(TrigLinseg *self) { GET_F }; +static PyObject * TrigLinseg_get(TrigLinseg *self) { GET_F }; static PyObject * TrigLinseg_setList(TrigLinseg *self, PyObject *value) @@ -2213,6 +2232,7 @@ static PyMethodDef TrigLinseg_methods[] = {"getServer", (PyCFunction)TrigLinseg_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigLinseg_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)TrigLinseg_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)TrigLinseg_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigLinseg_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)TrigLinseg_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setList", (PyCFunction)TrigLinseg_setList, METH_O, "Sets target points list."}, @@ -2241,9 +2261,9 @@ static PyNumberMethods TrigLinseg_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigLinseg_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigLinseg_float, /*nb_float*/ (binaryfunc)TrigLinseg_inplace_add, /*inplace_add*/ (binaryfunc)TrigLinseg_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigLinseg_inplace_multiply, /*inplace_multiply*/ @@ -2604,6 +2624,9 @@ static PyObject * TrigExpseg_sub(TrigExpseg *self, PyObject *arg) { SUB }; static PyObject * TrigExpseg_inplace_sub(TrigExpseg *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigExpseg_div(TrigExpseg *self, PyObject *arg) { DIV }; static PyObject * TrigExpseg_inplace_div(TrigExpseg *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigExpseg_int(TrigExpseg *self) { GET_I }; +static PyObject * TrigExpseg_float(TrigExpseg *self) { GET_F }; +static PyObject * TrigExpseg_get(TrigExpseg *self) { GET_F }; static PyObject * TrigExpseg_setList(TrigExpseg *self, PyObject *value) @@ -2666,6 +2689,7 @@ static PyMethodDef TrigExpseg_methods[] = {"getServer", (PyCFunction)TrigExpseg_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigExpseg_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)TrigExpseg_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)TrigExpseg_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigExpseg_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)TrigExpseg_stop, METH_VARARGS | METH_KEYWORDS, "Starts fadeout and stops computing."}, {"setList", (PyCFunction)TrigExpseg_setList, METH_O, "Sets target points list."}, @@ -2696,9 +2720,9 @@ static PyNumberMethods TrigExpseg_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigExpseg_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigExpseg_float, /*nb_float*/ (binaryfunc)TrigExpseg_inplace_add, /*inplace_add*/ (binaryfunc)TrigExpseg_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigExpseg_inplace_multiply, /*inplace_multiply*/ @@ -3394,6 +3418,9 @@ static PyObject * TrigXnoise_sub(TrigXnoise *self, PyObject *arg) { SUB }; static PyObject * TrigXnoise_inplace_sub(TrigXnoise *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigXnoise_div(TrigXnoise *self, PyObject *arg) { DIV }; static PyObject * TrigXnoise_inplace_div(TrigXnoise *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigXnoise_int(TrigXnoise *self) { GET_I }; +static PyObject * TrigXnoise_float(TrigXnoise *self) { GET_F }; +static PyObject * TrigXnoise_get(TrigXnoise *self) { GET_F }; static PyObject * TrigXnoise_setType(TrigXnoise *self, PyObject *arg) @@ -3428,6 +3455,7 @@ static PyMethodDef TrigXnoise_methods[] = { {"getServer", (PyCFunction)TrigXnoise_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigXnoise_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigXnoise_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigXnoise_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigXnoise_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigXnoise_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3459,9 +3487,9 @@ static PyNumberMethods TrigXnoise_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigXnoise_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigXnoise_float, /*nb_float*/ (binaryfunc)TrigXnoise_inplace_add, /*inplace_add*/ (binaryfunc)TrigXnoise_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigXnoise_inplace_multiply, /*inplace_multiply*/ @@ -4202,6 +4230,9 @@ static PyObject * TrigXnoiseMidi_sub(TrigXnoiseMidi *self, PyObject *arg) { SUB static PyObject * TrigXnoiseMidi_inplace_sub(TrigXnoiseMidi *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigXnoiseMidi_div(TrigXnoiseMidi *self, PyObject *arg) { DIV }; static PyObject * TrigXnoiseMidi_inplace_div(TrigXnoiseMidi *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigXnoiseMidi_int(TrigXnoiseMidi *self) { GET_I }; +static PyObject * TrigXnoiseMidi_float(TrigXnoiseMidi *self) { GET_F }; +static PyObject * TrigXnoiseMidi_get(TrigXnoiseMidi *self) { GET_F }; static PyObject * TrigXnoiseMidi_setType(TrigXnoiseMidi *self, PyObject *arg) @@ -4276,6 +4307,7 @@ static PyMethodDef TrigXnoiseMidi_methods[] = { {"getServer", (PyCFunction)TrigXnoiseMidi_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigXnoiseMidi_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigXnoiseMidi_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigXnoiseMidi_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigXnoiseMidi_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigXnoiseMidi_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -4309,9 +4341,9 @@ static PyNumberMethods TrigXnoiseMidi_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigXnoiseMidi_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigXnoiseMidi_float, /*nb_float*/ (binaryfunc)TrigXnoiseMidi_inplace_add, /*inplace_add*/ (binaryfunc)TrigXnoiseMidi_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigXnoiseMidi_inplace_multiply, /*inplace_multiply*/ @@ -4592,6 +4624,9 @@ static PyObject * Counter_sub(Counter *self, PyObject *arg) { SUB }; static PyObject * Counter_inplace_sub(Counter *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Counter_div(Counter *self, PyObject *arg) { DIV }; static PyObject * Counter_inplace_div(Counter *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Counter_int(Counter *self) { GET_I }; +static PyObject * Counter_float(Counter *self) { GET_F }; +static PyObject * Counter_get(Counter *self) { GET_F }; static PyObject * Counter_setMin(Counter *self, PyObject *arg) @@ -4670,6 +4705,7 @@ static PyMethodDef Counter_methods[] = { {"getServer", (PyCFunction)Counter_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Counter_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Counter_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Counter_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Counter_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMin", (PyCFunction)Counter_setMin, METH_O, "Sets minimum value."}, @@ -4701,9 +4737,9 @@ static PyNumberMethods Counter_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Counter_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Counter_float, /*nb_float*/ (binaryfunc)Counter_inplace_add, /*inplace_add*/ (binaryfunc)Counter_inplace_sub, /*inplace_subtract*/ (binaryfunc)Counter_inplace_multiply, /*inplace_multiply*/ @@ -5068,6 +5104,9 @@ static PyObject * Thresh_sub(Thresh *self, PyObject *arg) { SUB }; static PyObject * Thresh_inplace_sub(Thresh *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Thresh_div(Thresh *self, PyObject *arg) { DIV }; static PyObject * Thresh_inplace_div(Thresh *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Thresh_int(Thresh *self) { GET_I }; +static PyObject * Thresh_float(Thresh *self) { GET_F }; +static PyObject * Thresh_get(Thresh *self) { GET_F }; static PyObject * Thresh_setThreshold(Thresh *self, PyObject *arg) { SET_PARAM(self->threshold, self->threshold_stream, 2); } @@ -5099,6 +5138,7 @@ static PyMethodDef Thresh_methods[] = { {"getServer", (PyCFunction)Thresh_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Thresh_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Thresh_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Thresh_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Thresh_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setThreshold", (PyCFunction)Thresh_setThreshold, METH_O, "Sets threshold value."}, @@ -5128,9 +5168,9 @@ static PyNumberMethods Thresh_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Thresh_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Thresh_float, /*nb_float*/ (binaryfunc)Thresh_inplace_add, /*inplace_add*/ (binaryfunc)Thresh_inplace_sub, /*inplace_subtract*/ (binaryfunc)Thresh_inplace_multiply, /*inplace_multiply*/ @@ -5416,6 +5456,9 @@ static PyObject * Percent_sub(Percent *self, PyObject *arg) { SUB }; static PyObject * Percent_inplace_sub(Percent *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Percent_div(Percent *self, PyObject *arg) { DIV }; static PyObject * Percent_inplace_div(Percent *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Percent_int(Percent *self) { GET_I }; +static PyObject * Percent_float(Percent *self) { GET_F }; +static PyObject * Percent_get(Percent *self) { GET_F }; static PyObject * Percent_setPercent(Percent *self, PyObject *arg) { SET_PARAM(self->percent, self->percent_stream, 2); } @@ -5434,6 +5477,7 @@ static PyMethodDef Percent_methods[] = { {"getServer", (PyCFunction)Percent_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Percent_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Percent_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Percent_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Percent_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setPercent", (PyCFunction)Percent_setPercent, METH_O, "Sets percentange value."}, @@ -5462,9 +5506,9 @@ static PyNumberMethods Percent_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Percent_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Percent_float, /*nb_float*/ (binaryfunc)Percent_inplace_add, /*inplace_add*/ (binaryfunc)Percent_inplace_sub, /*inplace_subtract*/ (binaryfunc)Percent_inplace_multiply, /*inplace_multiply*/ @@ -5727,6 +5771,9 @@ static PyObject * Timer_sub(Timer *self, PyObject *arg) { SUB }; static PyObject * Timer_inplace_sub(Timer *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Timer_div(Timer *self, PyObject *arg) { DIV }; static PyObject * Timer_inplace_div(Timer *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Timer_int(Timer *self) { GET_I }; +static PyObject * Timer_float(Timer *self) { GET_F }; +static PyObject * Timer_get(Timer *self) { GET_F }; static PyMemberDef Timer_members[] = { @@ -5743,6 +5790,7 @@ static PyMethodDef Timer_methods[] = { {"getServer", (PyCFunction)Timer_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Timer_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Timer_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Timer_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Timer_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)Timer_setMul, METH_O, "Sets mul factor."}, @@ -5770,9 +5818,9 @@ static PyNumberMethods Timer_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Timer_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Timer_float, /*nb_float*/ (binaryfunc)Timer_inplace_add, /*inplace_add*/ (binaryfunc)Timer_inplace_sub, /*inplace_subtract*/ (binaryfunc)Timer_inplace_multiply, /*inplace_multiply*/ @@ -6084,6 +6132,9 @@ static PyObject * Iter_sub(Iter *self, PyObject *arg) { SUB }; static PyObject * Iter_inplace_sub(Iter *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Iter_div(Iter *self, PyObject *arg) { DIV }; static PyObject * Iter_inplace_div(Iter *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Iter_int(Iter *self) { GET_I }; +static PyObject * Iter_float(Iter *self) { GET_F }; +static PyObject * Iter_get(Iter *self) { GET_F }; static PyObject * Iter_setChoice(Iter *self, PyObject *arg) @@ -6136,6 +6187,7 @@ static PyMethodDef Iter_methods[] = {"getServer", (PyCFunction)Iter_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Iter_getStream, METH_NOARGS, "Returns stream object."}, {"_getTriggerStream", (PyCFunction)Iter_getTriggerStream, METH_NOARGS, "Returns trigger stream object."}, + {"get", (PyCFunction)Iter_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Iter_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Iter_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Iter_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -6166,9 +6218,9 @@ static PyNumberMethods Iter_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Iter_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Iter_float, /*nb_float*/ (binaryfunc)Iter_inplace_add, /*inplace_add*/ (binaryfunc)Iter_inplace_sub, /*inplace_subtract*/ (binaryfunc)Iter_inplace_multiply, /*inplace_multiply*/ @@ -6421,6 +6473,9 @@ static PyObject * Count_sub(Count *self, PyObject *arg) { SUB }; static PyObject * Count_inplace_sub(Count *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Count_div(Count *self, PyObject *arg) { DIV }; static PyObject * Count_inplace_div(Count *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Count_int(Count *self) { GET_I }; +static PyObject * Count_float(Count *self) { GET_F }; +static PyObject * Count_get(Count *self) { GET_F }; static PyObject * Count_setMin(Count *self, PyObject *arg) @@ -6456,6 +6511,7 @@ static PyMethodDef Count_methods[] = { {"getServer", (PyCFunction)Count_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Count_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Count_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Count_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Count_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMin", (PyCFunction)Count_setMin, METH_O, "Sets the minimum value."}, @@ -6485,9 +6541,9 @@ static PyNumberMethods Count_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Count_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Count_float, /*nb_float*/ (binaryfunc)Count_inplace_add, /*inplace_add*/ (binaryfunc)Count_inplace_sub, /*inplace_subtract*/ (binaryfunc)Count_inplace_multiply, /*inplace_multiply*/ @@ -6738,6 +6794,9 @@ static PyObject * NextTrig_sub(NextTrig *self, PyObject *arg) { SUB }; static PyObject * NextTrig_inplace_sub(NextTrig *self, PyObject *arg) { INPLACE_SUB }; static PyObject * NextTrig_div(NextTrig *self, PyObject *arg) { DIV }; static PyObject * NextTrig_inplace_div(NextTrig *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * NextTrig_int(NextTrig *self) { GET_I }; +static PyObject * NextTrig_float(NextTrig *self) { GET_F }; +static PyObject * NextTrig_get(NextTrig *self) { GET_F }; static PyMemberDef NextTrig_members[] = { @@ -6754,6 +6813,7 @@ static PyMethodDef NextTrig_methods[] = { {"getServer", (PyCFunction)NextTrig_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)NextTrig_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)NextTrig_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)NextTrig_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)NextTrig_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setMul", (PyCFunction)NextTrig_setMul, METH_O, "Sets mul factor."}, @@ -6781,9 +6841,9 @@ static PyNumberMethods NextTrig_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)NextTrig_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)NextTrig_float, /*nb_float*/ (binaryfunc)NextTrig_inplace_add, /*inplace_add*/ (binaryfunc)NextTrig_inplace_sub, /*inplace_subtract*/ (binaryfunc)NextTrig_inplace_multiply, /*inplace_multiply*/ @@ -7054,6 +7114,9 @@ static PyObject * TrigVal_sub(TrigVal *self, PyObject *arg) { SUB }; static PyObject * TrigVal_inplace_sub(TrigVal *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrigVal_div(TrigVal *self, PyObject *arg) { DIV }; static PyObject * TrigVal_inplace_div(TrigVal *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrigVal_int(TrigVal *self) { GET_I }; +static PyObject * TrigVal_float(TrigVal *self) { GET_F }; +static PyObject * TrigVal_get(TrigVal *self) { GET_F }; static PyObject * TrigVal_setValue(TrigVal *self, PyObject *arg) { SET_PARAM(self->value, self->value_stream, 2); } @@ -7072,6 +7135,7 @@ static PyMethodDef TrigVal_methods[] = { {"getServer", (PyCFunction)TrigVal_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrigVal_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrigVal_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrigVal_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrigVal_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrigVal_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -7101,9 +7165,9 @@ static PyNumberMethods TrigVal_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrigVal_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrigVal_float, /*nb_float*/ (binaryfunc)TrigVal_inplace_add, /*inplace_add*/ (binaryfunc)TrigVal_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrigVal_inplace_multiply, /*inplace_multiply*/ @@ -7161,4 +7225,4 @@ PyTypeObject TrigValType = 0, /* tp_init */ 0, /* tp_alloc */ TrigVal_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/src/objects/utilsmodule.c b/src/objects/utilsmodule.c index 13dd5369..8707e8d1 100644 --- a/src/objects/utilsmodule.c +++ b/src/objects/utilsmodule.c @@ -508,6 +508,9 @@ static PyObject * Snap_sub(Snap *self, PyObject *arg) { SUB }; static PyObject * Snap_inplace_sub(Snap *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Snap_div(Snap *self, PyObject *arg) { DIV }; static PyObject * Snap_inplace_div(Snap *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Snap_int(Snap *self) { GET_I }; +static PyObject * Snap_float(Snap *self) { GET_F }; +static PyObject * Snap_get(Snap *self) { GET_F }; static PyObject * Snap_setChoice(Snap *self, PyObject *arg) @@ -579,6 +582,7 @@ static PyMethodDef Snap_methods[] = { {"getServer", (PyCFunction)Snap_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Snap_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Snap_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Snap_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Snap_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Snap_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -609,9 +613,9 @@ static PyNumberMethods Snap_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Snap_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Snap_float, /*nb_float*/ (binaryfunc)Snap_inplace_add, /*inplace_add*/ (binaryfunc)Snap_inplace_sub, /*inplace_subtract*/ (binaryfunc)Snap_inplace_multiply, /*inplace_multiply*/ @@ -902,6 +906,9 @@ static PyObject * Interp_sub(Interp *self, PyObject *arg) { SUB }; static PyObject * Interp_inplace_sub(Interp *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Interp_div(Interp *self, PyObject *arg) { DIV }; static PyObject * Interp_inplace_div(Interp *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Interp_int(Interp *self) { GET_I }; +static PyObject * Interp_float(Interp *self) { GET_F }; +static PyObject * Interp_get(Interp *self) { GET_F }; static PyObject * Interp_setInterp(Interp *self, PyObject *arg) { SET_PARAM(self->interp, self->interp_stream, 2); } @@ -921,6 +928,7 @@ static PyMethodDef Interp_methods[] = { {"getServer", (PyCFunction)Interp_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Interp_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Interp_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Interp_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Interp_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Interp_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -950,9 +958,9 @@ static PyNumberMethods Interp_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Interp_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Interp_float, /*nb_float*/ (binaryfunc)Interp_inplace_add, /*inplace_add*/ (binaryfunc)Interp_inplace_sub, /*inplace_subtract*/ (binaryfunc)Interp_inplace_multiply, /*inplace_multiply*/ @@ -1263,6 +1271,9 @@ static PyObject * SampHold_sub(SampHold *self, PyObject *arg) { SUB }; static PyObject * SampHold_inplace_sub(SampHold *self, PyObject *arg) { INPLACE_SUB }; static PyObject * SampHold_div(SampHold *self, PyObject *arg) { DIV }; static PyObject * SampHold_inplace_div(SampHold *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * SampHold_int(SampHold *self) { GET_I }; +static PyObject * SampHold_float(SampHold *self) { GET_F }; +static PyObject * SampHold_get(SampHold *self) { GET_F }; static PyObject * SampHold_setValue(SampHold *self, PyObject *arg) { SET_PARAM(self->value, self->value_stream, 2); } @@ -1282,6 +1293,7 @@ static PyMethodDef SampHold_methods[] = { {"getServer", (PyCFunction)SampHold_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)SampHold_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)SampHold_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)SampHold_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)SampHold_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)SampHold_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1311,9 +1323,9 @@ static PyNumberMethods SampHold_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)SampHold_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)SampHold_float, /*nb_float*/ (binaryfunc)SampHold_inplace_add, /*inplace_add*/ (binaryfunc)SampHold_inplace_sub, /*inplace_subtract*/ (binaryfunc)SampHold_inplace_multiply, /*inplace_multiply*/ @@ -1630,6 +1642,9 @@ static PyObject * TrackHold_sub(TrackHold *self, PyObject *arg) { SUB }; static PyObject * TrackHold_inplace_sub(TrackHold *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TrackHold_div(TrackHold *self, PyObject *arg) { DIV }; static PyObject * TrackHold_inplace_div(TrackHold *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TrackHold_int(TrackHold *self) { GET_I }; +static PyObject * TrackHold_float(TrackHold *self) { GET_F }; +static PyObject * TrackHold_get(TrackHold *self) { GET_F }; static PyObject * TrackHold_setValue(TrackHold *self, PyObject *arg) { SET_PARAM(self->value, self->value_stream, 2); } @@ -1649,6 +1664,7 @@ static PyMethodDef TrackHold_methods[] = { {"getServer", (PyCFunction)TrackHold_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TrackHold_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TrackHold_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TrackHold_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)TrackHold_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)TrackHold_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -1678,9 +1694,9 @@ static PyNumberMethods TrackHold_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TrackHold_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TrackHold_float, /*nb_float*/ (binaryfunc)TrackHold_inplace_add, /*inplace_add*/ (binaryfunc)TrackHold_inplace_sub, /*inplace_subtract*/ (binaryfunc)TrackHold_inplace_multiply, /*inplace_multiply*/ @@ -1995,6 +2011,9 @@ static PyObject * Compare_sub(Compare *self, PyObject *arg) { SUB }; static PyObject * Compare_inplace_sub(Compare *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Compare_div(Compare *self, PyObject *arg) { DIV }; static PyObject * Compare_inplace_div(Compare *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Compare_int(Compare *self) { GET_I }; +static PyObject * Compare_float(Compare *self) { GET_F }; +static PyObject * Compare_get(Compare *self) { GET_F }; static PyObject * Compare_setComp(Compare *self, PyObject *arg) { SET_PARAM(self->comp, self->comp_stream, 2); } @@ -2042,6 +2061,7 @@ static PyMethodDef Compare_methods[] = { {"getServer", (PyCFunction)Compare_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Compare_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Compare_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Compare_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Compare_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"setComp", (PyCFunction)Compare_setComp, METH_O, "Sets the comparison object."}, @@ -2071,9 +2091,9 @@ static PyNumberMethods Compare_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Compare_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Compare_float, /*nb_float*/ (binaryfunc)Compare_inplace_add, /*inplace_add*/ (binaryfunc)Compare_inplace_sub, /*inplace_subtract*/ (binaryfunc)Compare_inplace_multiply, /*inplace_multiply*/ @@ -2413,6 +2433,9 @@ static PyObject * Between_sub(Between *self, PyObject *arg) { SUB }; static PyObject * Between_inplace_sub(Between *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Between_div(Between *self, PyObject *arg) { DIV }; static PyObject * Between_inplace_div(Between *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Between_int(Between *self) { GET_I }; +static PyObject * Between_float(Between *self) { GET_F }; +static PyObject * Between_get(Between *self) { GET_F }; static PyObject * Between_setMin(Between *self, PyObject *arg) { SET_PARAM(self->min, self->min_stream, 2); } static PyObject * Between_setMax(Between *self, PyObject *arg) { SET_PARAM(self->max, self->max_stream, 3); } @@ -2433,6 +2456,7 @@ static PyMethodDef Between_methods[] = { {"getServer", (PyCFunction)Between_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Between_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Between_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Between_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Between_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Between_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2463,9 +2487,9 @@ static PyNumberMethods Between_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Between_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Between_float, /*nb_float*/ (binaryfunc)Between_inplace_add, /*inplace_add*/ (binaryfunc)Between_inplace_sub, /*inplace_subtract*/ (binaryfunc)Between_inplace_multiply, /*inplace_multiply*/ @@ -2705,6 +2729,9 @@ static PyObject * Denorm_sub(Denorm *self, PyObject *arg) { SUB }; static PyObject * Denorm_inplace_sub(Denorm *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Denorm_div(Denorm *self, PyObject *arg) { DIV }; static PyObject * Denorm_inplace_div(Denorm *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Denorm_int(Denorm *self) { GET_I }; +static PyObject * Denorm_float(Denorm *self) { GET_F }; +static PyObject * Denorm_get(Denorm *self) { GET_F }; static PyMemberDef Denorm_members[] = { @@ -2720,6 +2747,7 @@ static PyMethodDef Denorm_methods[] = { {"getServer", (PyCFunction)Denorm_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Denorm_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Denorm_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Denorm_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Denorm_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Denorm_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2748,9 +2776,9 @@ static PyNumberMethods Denorm_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Denorm_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Denorm_float, /*nb_float*/ (binaryfunc)Denorm_inplace_add, /*inplace_add*/ (binaryfunc)Denorm_inplace_sub, /*inplace_subtract*/ (binaryfunc)Denorm_inplace_multiply, /*inplace_multiply*/ @@ -2999,6 +3027,9 @@ static PyObject * DBToA_sub(DBToA *self, PyObject *arg) { SUB }; static PyObject * DBToA_inplace_sub(DBToA *self, PyObject *arg) { INPLACE_SUB }; static PyObject * DBToA_div(DBToA *self, PyObject *arg) { DIV }; static PyObject * DBToA_inplace_div(DBToA *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * DBToA_int(DBToA *self) { GET_I }; +static PyObject * DBToA_float(DBToA *self) { GET_F }; +static PyObject * DBToA_get(DBToA *self) { GET_F }; static PyMemberDef DBToA_members[] = { @@ -3014,6 +3045,7 @@ static PyMethodDef DBToA_methods[] = { {"getServer", (PyCFunction)DBToA_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)DBToA_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)DBToA_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)DBToA_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)DBToA_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)DBToA_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -3042,9 +3074,9 @@ static PyNumberMethods DBToA_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)DBToA_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)DBToA_float, /*nb_float*/ (binaryfunc)DBToA_inplace_add, /*inplace_add*/ (binaryfunc)DBToA_inplace_sub, /*inplace_subtract*/ (binaryfunc)DBToA_inplace_multiply, /*inplace_multiply*/ @@ -3293,6 +3325,9 @@ static PyObject * AToDB_sub(AToDB *self, PyObject *arg) { SUB }; static PyObject * AToDB_inplace_sub(AToDB *self, PyObject *arg) { INPLACE_SUB }; static PyObject * AToDB_div(AToDB *self, PyObject *arg) { DIV }; static PyObject * AToDB_inplace_div(AToDB *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * AToDB_int(AToDB *self) { GET_I }; +static PyObject * AToDB_float(AToDB *self) { GET_F }; +static PyObject * AToDB_get(AToDB *self) { GET_F }; static PyMemberDef AToDB_members[] = { @@ -3308,6 +3343,7 @@ static PyMethodDef AToDB_methods[] = { {"getServer", (PyCFunction)AToDB_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)AToDB_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)AToDB_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)AToDB_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)AToDB_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)AToDB_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -3336,9 +3372,9 @@ static PyNumberMethods AToDB_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)AToDB_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)AToDB_float, /*nb_float*/ (binaryfunc)AToDB_inplace_add, /*inplace_add*/ (binaryfunc)AToDB_inplace_sub, /*inplace_subtract*/ (binaryfunc)AToDB_inplace_multiply, /*inplace_multiply*/ @@ -3769,6 +3805,9 @@ static PyObject * Scale_sub(Scale *self, PyObject *arg) { SUB }; static PyObject * Scale_inplace_sub(Scale *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Scale_div(Scale *self, PyObject *arg) { DIV }; static PyObject * Scale_inplace_div(Scale *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Scale_int(Scale *self) { GET_I }; +static PyObject * Scale_float(Scale *self) { GET_F }; +static PyObject * Scale_get(Scale *self) { GET_F }; static PyObject * Scale_setInMin(Scale *self, PyObject *arg) { SET_PARAM(self->inmin, self->inmin_stream, 2); } static PyObject * Scale_setInMax(Scale *self, PyObject *arg) { SET_PARAM(self->inmax, self->inmax_stream, 3); } @@ -3790,6 +3829,7 @@ static PyMethodDef Scale_methods[] = { {"getServer", (PyCFunction)Scale_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Scale_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Scale_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Scale_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)Scale_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)Scale_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -3823,9 +3863,9 @@ static PyNumberMethods Scale_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Scale_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Scale_float, /*nb_float*/ (binaryfunc)Scale_inplace_add, /*inplace_add*/ (binaryfunc)Scale_inplace_sub, /*inplace_subtract*/ (binaryfunc)Scale_inplace_multiply, /*inplace_multiply*/ @@ -4069,6 +4109,9 @@ static PyObject * CentsToTranspo_sub(CentsToTranspo *self, PyObject *arg) { SUB static PyObject * CentsToTranspo_inplace_sub(CentsToTranspo *self, PyObject *arg) { INPLACE_SUB }; static PyObject * CentsToTranspo_div(CentsToTranspo *self, PyObject *arg) { DIV }; static PyObject * CentsToTranspo_inplace_div(CentsToTranspo *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * CentsToTranspo_int(CentsToTranspo *self) { GET_I }; +static PyObject * CentsToTranspo_float(CentsToTranspo *self) { GET_F }; +static PyObject * CentsToTranspo_get(CentsToTranspo *self) { GET_F }; static PyMemberDef CentsToTranspo_members[] = { @@ -4084,6 +4127,7 @@ static PyMethodDef CentsToTranspo_methods[] = { {"getServer", (PyCFunction)CentsToTranspo_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)CentsToTranspo_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)CentsToTranspo_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)CentsToTranspo_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)CentsToTranspo_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)CentsToTranspo_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4112,9 +4156,9 @@ static PyNumberMethods CentsToTranspo_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)CentsToTranspo_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)CentsToTranspo_float, /*nb_float*/ (binaryfunc)CentsToTranspo_inplace_add, /*inplace_add*/ (binaryfunc)CentsToTranspo_inplace_sub, /*inplace_subtract*/ (binaryfunc)CentsToTranspo_inplace_multiply, /*inplace_multiply*/ @@ -4358,6 +4402,9 @@ static PyObject * TranspoToCents_sub(TranspoToCents *self, PyObject *arg) { SUB static PyObject * TranspoToCents_inplace_sub(TranspoToCents *self, PyObject *arg) { INPLACE_SUB }; static PyObject * TranspoToCents_div(TranspoToCents *self, PyObject *arg) { DIV }; static PyObject * TranspoToCents_inplace_div(TranspoToCents *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * TranspoToCents_int(TranspoToCents *self) { GET_I }; +static PyObject * TranspoToCents_float(TranspoToCents *self) { GET_F }; +static PyObject * TranspoToCents_get(TranspoToCents *self) { GET_F }; static PyMemberDef TranspoToCents_members[] = { @@ -4373,6 +4420,7 @@ static PyMethodDef TranspoToCents_methods[] = { {"getServer", (PyCFunction)TranspoToCents_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)TranspoToCents_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)TranspoToCents_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)TranspoToCents_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)TranspoToCents_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)TranspoToCents_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4401,9 +4449,9 @@ static PyNumberMethods TranspoToCents_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)TranspoToCents_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)TranspoToCents_float, /*nb_float*/ (binaryfunc)TranspoToCents_inplace_add, /*inplace_add*/ (binaryfunc)TranspoToCents_inplace_sub, /*inplace_subtract*/ (binaryfunc)TranspoToCents_inplace_multiply, /*inplace_multiply*/ @@ -4647,6 +4695,9 @@ static PyObject * MToF_sub(MToF *self, PyObject *arg) { SUB }; static PyObject * MToF_inplace_sub(MToF *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MToF_div(MToF *self, PyObject *arg) { DIV }; static PyObject * MToF_inplace_div(MToF *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MToF_int(MToF *self) { GET_I }; +static PyObject * MToF_float(MToF *self) { GET_F }; +static PyObject * MToF_get(MToF *self) { GET_F }; static PyMemberDef MToF_members[] = { @@ -4662,6 +4713,7 @@ static PyMethodDef MToF_methods[] = { {"getServer", (PyCFunction)MToF_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MToF_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MToF_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MToF_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)MToF_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)MToF_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4690,9 +4742,9 @@ static PyNumberMethods MToF_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MToF_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MToF_float, /*nb_float*/ (binaryfunc)MToF_inplace_add, /*inplace_add*/ (binaryfunc)MToF_inplace_sub, /*inplace_subtract*/ (binaryfunc)MToF_inplace_multiply, /*inplace_multiply*/ @@ -4939,6 +4991,9 @@ static PyObject * FToM_sub(FToM *self, PyObject *arg) { SUB }; static PyObject * FToM_inplace_sub(FToM *self, PyObject *arg) { INPLACE_SUB }; static PyObject * FToM_div(FToM *self, PyObject *arg) { DIV }; static PyObject * FToM_inplace_div(FToM *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * FToM_int(FToM *self) { GET_I }; +static PyObject * FToM_float(FToM *self) { GET_F }; +static PyObject * FToM_get(FToM *self) { GET_F }; static PyMemberDef FToM_members[] = { @@ -4954,6 +5009,7 @@ static PyMethodDef FToM_methods[] = { {"getServer", (PyCFunction)FToM_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)FToM_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)FToM_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)FToM_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)FToM_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)FToM_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -4982,9 +5038,9 @@ static PyNumberMethods FToM_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)FToM_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)FToM_float, /*nb_float*/ (binaryfunc)FToM_inplace_add, /*inplace_add*/ (binaryfunc)FToM_inplace_sub, /*inplace_subtract*/ (binaryfunc)FToM_inplace_multiply, /*inplace_multiply*/ @@ -5243,6 +5299,9 @@ static PyObject * MToT_sub(MToT *self, PyObject *arg) { SUB }; static PyObject * MToT_inplace_sub(MToT *self, PyObject *arg) { INPLACE_SUB }; static PyObject * MToT_div(MToT *self, PyObject *arg) { DIV }; static PyObject * MToT_inplace_div(MToT *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * MToT_int(MToT *self) { GET_I }; +static PyObject * MToT_float(MToT *self) { GET_F }; +static PyObject * MToT_get(MToT *self) { GET_F }; static PyMemberDef MToT_members[] = { @@ -5258,6 +5317,7 @@ static PyMethodDef MToT_methods[] = { {"getServer", (PyCFunction)MToT_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)MToT_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)MToT_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)MToT_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)MToT_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)MToT_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -5287,9 +5347,9 @@ static PyNumberMethods MToT_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)MToT_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)MToT_float, /*nb_float*/ (binaryfunc)MToT_inplace_add, /*inplace_add*/ (binaryfunc)MToT_inplace_sub, /*inplace_subtract*/ (binaryfunc)MToT_inplace_multiply, /*inplace_multiply*/ @@ -5792,6 +5852,9 @@ static PyObject * Resample_sub(Resample *self, PyObject *arg) { SUB }; static PyObject * Resample_inplace_sub(Resample *self, PyObject *arg) { INPLACE_SUB }; static PyObject * Resample_div(Resample *self, PyObject *arg) { DIV }; static PyObject * Resample_inplace_div(Resample *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * Resample_int(Resample *self) { GET_I }; +static PyObject * Resample_float(Resample *self) { GET_F }; +static PyObject * Resample_get(Resample *self) { GET_F }; static PyMemberDef Resample_members[] = { @@ -5807,6 +5870,7 @@ static PyMethodDef Resample_methods[] = { {"getServer", (PyCFunction)Resample_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)Resample_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)Resample_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)Resample_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"stop", (PyCFunction)Resample_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, {"out", (PyCFunction)Resample_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, @@ -5836,9 +5900,9 @@ static PyNumberMethods Resample_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)Resample_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)Resample_float, /*nb_float*/ (binaryfunc)Resample_inplace_add, /*inplace_add*/ (binaryfunc)Resample_inplace_sub, /*inplace_subtract*/ (binaryfunc)Resample_inplace_multiply, /*inplace_multiply*/ diff --git a/src/objects/wgverbmodule.c b/src/objects/wgverbmodule.c index 3be760bd..9cb3d2ab 100644 --- a/src/objects/wgverbmodule.c +++ b/src/objects/wgverbmodule.c @@ -663,6 +663,9 @@ static PyObject * WGVerb_sub(WGVerb *self, PyObject *arg) { SUB }; static PyObject * WGVerb_inplace_sub(WGVerb *self, PyObject *arg) { INPLACE_SUB }; static PyObject * WGVerb_div(WGVerb *self, PyObject *arg) { DIV }; static PyObject * WGVerb_inplace_div(WGVerb *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * WGVerb_int(WGVerb *self) { GET_I }; +static PyObject * WGVerb_float(WGVerb *self) { GET_F }; +static PyObject * WGVerb_get(WGVerb *self) { GET_F }; static PyObject * WGVerb_reset(WGVerb *self) @@ -706,6 +709,7 @@ static PyMethodDef WGVerb_methods[] = { {"getServer", (PyCFunction)WGVerb_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)WGVerb_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)WGVerb_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)WGVerb_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)WGVerb_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)WGVerb_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -738,9 +742,9 @@ static PyNumberMethods WGVerb_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)WGVerb_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)WGVerb_float, /*nb_float*/ (binaryfunc)WGVerb_inplace_add, /*inplace_add*/ (binaryfunc)WGVerb_inplace_sub, /*inplace_subtract*/ (binaryfunc)WGVerb_inplace_multiply, /*inplace_multiply*/ @@ -2113,6 +2117,9 @@ static PyObject * STRev_sub(STRev *self, PyObject *arg) { SUB }; static PyObject * STRev_inplace_sub(STRev *self, PyObject *arg) { INPLACE_SUB }; static PyObject * STRev_div(STRev *self, PyObject *arg) { DIV }; static PyObject * STRev_inplace_div(STRev *self, PyObject *arg) { INPLACE_DIV }; +static PyObject * STRev_int(STRev *self) { GET_I }; +static PyObject * STRev_float(STRev *self) { GET_F }; +static PyObject * STRev_get(STRev *self) { GET_F }; static PyMemberDef STRev_members[] = { @@ -2127,6 +2134,7 @@ static PyMethodDef STRev_methods[] = { {"getServer", (PyCFunction)STRev_getServer, METH_NOARGS, "Returns server object."}, {"_getStream", (PyCFunction)STRev_getStream, METH_NOARGS, "Returns stream object."}, + {"get", (PyCFunction)STRev_get, METH_NOARGS, "Returns the last floating-point value of the stream's buffer data."}, {"play", (PyCFunction)STRev_play, METH_VARARGS | METH_KEYWORDS, "Starts computing without sending sound to soundcard."}, {"out", (PyCFunction)STRev_out, METH_VARARGS | METH_KEYWORDS, "Starts computing and sends sound to soundcard channel speficied by argument."}, {"stop", (PyCFunction)STRev_stop, METH_VARARGS | METH_KEYWORDS, "Stops computing."}, @@ -2155,9 +2163,9 @@ static PyNumberMethods STRev_as_number = 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ - 0, /*nb_int*/ - 0, /*nb_long*/ - 0, /*nb_float*/ + (unaryfunc)STRev_int, /*nb_int*/ + 0, /*nb_long*/ + (unaryfunc)STRev_float, /*nb_float*/ (binaryfunc)STRev_inplace_add, /*inplace_add*/ (binaryfunc)STRev_inplace_sub, /*inplace_subtract*/ (binaryfunc)STRev_inplace_multiply, /*inplace_multiply*/ @@ -2215,4 +2223,4 @@ PyTypeObject STRevType = 0, /* tp_init */ 0, /* tp_alloc */ STRev_new, /* tp_new */ -}; \ No newline at end of file +}; diff --git a/tests/pytests/test_baseObjects.py b/tests/pytests/test_baseObjects.py index fd901716..6fd9823a 100644 --- a/tests/pytests/test_baseObjects.py +++ b/tests/pytests/test_baseObjects.py @@ -349,6 +349,57 @@ class TestPyoObject: assert a.get() == 25 assert a.get(all=True) == [25, 50] + def test_get_from_base(self, audio_server): + a = Sig([100, 200]) + assert a[0].get() == 100 + assert a[1].get() == 200 + + a.value = [25, 50] + + with StartAndAdvanceOneBuf(audio_server): + assert a[0].get() == 25 + assert a[1].get() == 50 + + def test_convert_as_float(self, audio_server): + a = Sig(100.5) + assert float(a) == 100.5 + + a.value = 25.5 + + with StartAndAdvanceOneBuf(audio_server): + assert float(a) == 25.5 + + def test_convert_as_int(self, audio_server): + a = Sig(100.5) + assert int(a) == 100 + + a.value = 25.5 + + with StartAndAdvanceOneBuf(audio_server): + assert int(a) == 25 + + def test_convert_base_as_float(self, audio_server): + a = Sig([100.5, 200.5]) + assert float(a[0]) == 100.5 + assert float(a[1]) == 200.5 + + a.value = [25.5, 50.5] + + with StartAndAdvanceOneBuf(audio_server): + assert float(a[0]) == 25.5 + assert float(a[1]) == 50.5 + + def test_convert_base_as_int(self, audio_server): + a = Sig([100.5, 200.5]) + assert int(a[0]) == 100 + assert int(a[1]) == 200 + + a.value = [25.5, 50.5] + + with StartAndAdvanceOneBuf(audio_server): + assert int(a[0]) == 25 + assert int(a[1]) == 50 + def test_play(self, audio_server): a = Sine() assert a.isPlaying() == True diff --git a/tests/pytests/test_functions.py b/tests/pytests/test_functions.py index 01e4b6ba..e2b2059c 100644 --- a/tests/pytests/test_functions.py +++ b/tests/pytests/test_functions.py @@ -11,7 +11,7 @@ class TestInitFunctions: assert "PyoObject" in kwds assert "SineLoop" in kwds assert "Particle" in kwds - assert len(kwds) == 369 + assert len(kwds) == 368 def test_getPyoExamples(self): examples = getPyoExamples(fullpath=True) -- 2.30.2