{
if (self->scale)
scale_destroy(self->scale);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static int
};
static PyTypeObject ScaleType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT(NULL, 0)
"jack_mixer_c.Scale", /*tp_name*/
sizeof(ScaleObject), /*tp_basicsize*/
0, /*tp_itemsize*/
Channel_dealloc(ChannelObject *self)
{
Py_XDECREF(self->midi_change_callback);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static int
return -1;
}
channel_volume_write(self->channel, PyFloat_AsDouble(value));
+ channel_set_midi_cc_volume_picked_up(self->channel, false);
return 0;
}
Channel_set_balance(ChannelObject *self, PyObject *value, void *closure)
{
channel_balance_write(self->channel, PyFloat_AsDouble(value));
+ channel_set_midi_cc_balance_picked_up(self->channel, false);
return 0;
}
{
PyObject *result;
- if (channel_is_out_muted(self->channel)) {
+ if (channel_is_out_muted(self->channel)) {
result = Py_True;
} else {
result = Py_False;
return result;
}
+static PyObject*
+Channel_get_kmeter(ChannelObject *self, void *closure)
+{
+ PyObject *result;
+ double peak_left, peak_right, rms_left, rms_right;
+
+ if (channel_is_stereo(self->channel)) {
+ result = PyTuple_New(4);
+ channel_stereo_kmeter_read(self->channel, &peak_left, &peak_right, &rms_left, &rms_right);
+ PyTuple_SetItem(result, 0, PyFloat_FromDouble(peak_left));
+ PyTuple_SetItem(result, 1, PyFloat_FromDouble(peak_right));
+ PyTuple_SetItem(result, 2, PyFloat_FromDouble(rms_left));
+ PyTuple_SetItem(result, 3, PyFloat_FromDouble(rms_right));
+ } else {
+ result = PyTuple_New(2);
+ channel_mono_kmeter_read(self->channel, &peak_left, &rms_left);
+ PyTuple_SetItem(result, 0, PyFloat_FromDouble(peak_left));
+ PyTuple_SetItem(result, 1, PyFloat_FromDouble(rms_left));
+ }
+ return result;
+}
+
static PyObject*
Channel_get_abspeak(ChannelObject *self, void *closure)
{
static PyObject*
Channel_get_name(ChannelObject *self, void *closure)
{
- return PyString_FromString(channel_get_name(self->channel));
+ return PyUnicode_FromString(channel_get_name(self->channel));
}
static int
Channel_set_name(ChannelObject *self, PyObject *value, void *closure)
{
- channel_rename(self->channel, PyString_AsString(value));
+ channel_rename(self->channel, PyUnicode_AsUTF8(value));
return 0;
}
static PyObject*
Channel_get_balance_midi_cc(ChannelObject *self, void *closure)
{
- return PyInt_FromLong(channel_get_balance_midi_cc(self->channel));
+ return PyLong_FromLong(channel_get_balance_midi_cc(self->channel));
}
static int
int new_cc;
unsigned int result;
- new_cc = PyInt_AsLong(value);
+ new_cc = PyLong_AsLong(value);
result = channel_set_balance_midi_cc(self->channel, new_cc);
if (result == 0) {
return 0;
static PyObject*
Channel_get_volume_midi_cc(ChannelObject *self, void *closure)
{
- return PyInt_FromLong(channel_get_volume_midi_cc(self->channel));
+ return PyLong_FromLong(channel_get_volume_midi_cc(self->channel));
}
static int
int new_cc;
unsigned int result;
- new_cc = PyInt_AsLong(value);
+ new_cc = PyLong_AsLong(value);
result = channel_set_volume_midi_cc(self->channel, new_cc);
if (result == 0) {
return 0;
static PyObject*
Channel_get_mute_midi_cc(ChannelObject *self, void *closure)
{
- return PyInt_FromLong(channel_get_mute_midi_cc(self->channel));
+ return PyLong_FromLong(channel_get_mute_midi_cc(self->channel));
}
static int
int new_cc;
unsigned int result;
- new_cc = PyInt_AsLong(value);
+ new_cc = PyLong_AsLong(value);
result = channel_set_mute_midi_cc(self->channel, new_cc);
if (result == 0) {
return 0;
static PyObject*
Channel_get_solo_midi_cc(ChannelObject *self, void *closure)
{
- return PyInt_FromLong(channel_get_solo_midi_cc(self->channel));
+ return PyLong_FromLong(channel_get_solo_midi_cc(self->channel));
}
static int
int new_cc;
unsigned int result;
- new_cc = PyInt_AsLong(value);
+ new_cc = PyLong_AsLong(value);
result = channel_set_solo_midi_cc(self->channel, new_cc);
if (result == 0) {
return 0;
{"meter",
(getter)Channel_get_meter, NULL,
"meter", NULL},
+ {"kmeter",
+ (getter)Channel_get_kmeter, NULL,
+ "kmeter", NULL},
{"abspeak",
(getter)Channel_get_abspeak, (setter)Channel_set_abspeak,
"balance", NULL},
}
static PyObject*
-Channel_autoset_midi_cc(ChannelObject *self, PyObject *args)
+Channel_autoset_volume_midi_cc(ChannelObject *self, PyObject *args)
{
if (! PyArg_ParseTuple(args, "")) return NULL;
- channel_autoset_midi_cc(self->channel);
+ channel_autoset_volume_midi_cc(self->channel);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject*
+Channel_autoset_balance_midi_cc(ChannelObject *self, PyObject *args)
+{
+ if (! PyArg_ParseTuple(args, "")) return NULL;
+ channel_autoset_balance_midi_cc(self->channel);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject*
+Channel_autoset_mute_midi_cc(ChannelObject *self, PyObject *args)
+{
+ if (! PyArg_ParseTuple(args, "")) return NULL;
+ channel_autoset_mute_midi_cc(self->channel);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject*
+Channel_autoset_solo_midi_cc(ChannelObject *self, PyObject *args)
+{
+ if (! PyArg_ParseTuple(args, "")) return NULL;
+ channel_autoset_solo_midi_cc(self->channel);
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef channel_methods[] = {
{"remove", (PyCFunction)Channel_remove, METH_VARARGS, "Remove"},
- {"autoset_midi_cc", (PyCFunction)Channel_autoset_midi_cc, METH_VARARGS, "Autoset MIDI CC"},
+ {"autoset_volume_midi_cc",
+ (PyCFunction)Channel_autoset_volume_midi_cc, METH_VARARGS, "Autoset Volume MIDI CC"},
+ {"autoset_balance_midi_cc",
+ (PyCFunction)Channel_autoset_balance_midi_cc, METH_VARARGS, "Autoset Balance MIDI CC"},
+ {"autoset_mute_midi_cc",
+ (PyCFunction)Channel_autoset_mute_midi_cc, METH_VARARGS, "Autoset Mute MIDI CC"},
+ {"autoset_solo_midi_cc",
+ (PyCFunction)Channel_autoset_solo_midi_cc, METH_VARARGS, "Autoset Solo MIDI CC"},
{NULL}
};
static PyTypeObject ChannelType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT(NULL, 0)
"jack_mixer_c.Channel", /*tp_name*/
sizeof(ChannelObject), /*tp_basicsize*/
0, /*tp_itemsize*/
return result;
}
+static PyObject*
+OutputChannel_set_in_prefader(OutputChannelObject *self, PyObject *args)
+{
+ PyObject *channel;
+ unsigned char prefader;
+
+ if (! PyArg_ParseTuple(args, "Ob", &channel, &prefader)) return NULL;
+
+ output_channel_set_in_prefader(self->output_channel,
+ ((ChannelObject*)channel)->channel,
+ prefader);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyObject*
+OutputChannel_is_in_prefader(OutputChannelObject *self, PyObject *args)
+{
+ PyObject *channel;
+ PyObject *result;
+
+ if (! PyArg_ParseTuple(args, "O", &channel)) return NULL;
+
+ if (output_channel_is_in_prefader(self->output_channel,
+ ((ChannelObject*)channel)->channel)) {
+ result = Py_True;
+ } else {
+ result = Py_False;
+ }
+
+ Py_INCREF(result);
+ return result;
+}
+
static PyMethodDef output_channel_methods[] = {
{"remove", (PyCFunction)OutputChannel_remove, METH_VARARGS, "Remove"},
{"set_solo", (PyCFunction)OutputChannel_set_solo, METH_VARARGS, "Set a channel as solo"},
{"set_muted", (PyCFunction)OutputChannel_set_muted, METH_VARARGS, "Set a channel as muted"},
{"is_solo", (PyCFunction)OutputChannel_is_solo, METH_VARARGS, "Is a channel set as solo"},
{"is_muted", (PyCFunction)OutputChannel_is_muted, METH_VARARGS, "Is a channel set as muted"},
+ {"set_in_prefader", (PyCFunction)OutputChannel_set_in_prefader, METH_VARARGS, "Set a channel as prefader"},
+ {"is_in_prefader", (PyCFunction)OutputChannel_is_in_prefader, METH_VARARGS, "Is a channel set as prefader"},
{NULL}
};
static PyTypeObject OutputChannelType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT(NULL, 0)
"jack_mixer_c.OutputChannel", /*tp_name*/
sizeof(OutputChannelObject), /*tp_basicsize*/
0, /*tp_itemsize*/
{
if (self->mixer)
destroy(self->mixer);
- self->ob_type->tp_free((PyObject*)self);
+ Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject*
static PyObject*
Mixer_get_channels_count(MixerObject *self, void *closure)
{
- return PyInt_FromLong(get_channels_count(self->mixer));
+ return PyLong_FromLong(get_channels_count(self->mixer));
}
static PyObject*
Mixer_get_client_name(MixerObject *self, void *closure)
{
- return PyString_FromString(get_client_name(self->mixer));
+ return PyUnicode_FromString(get_client_name(self->mixer));
}
static PyObject*
Mixer_get_last_midi_channel(MixerObject *self, void *closure)
{
- return PyInt_FromLong(get_last_midi_channel(self->mixer));
+ return PyLong_FromLong(get_last_midi_channel(self->mixer));
}
static int
int new_channel;
unsigned int result;
- new_channel = PyInt_AsLong(value);
+ new_channel = PyLong_AsLong(value);
result = set_last_midi_channel(self->mixer, new_channel);
if (result == 0) {
return 0;
return -1;
}
+static PyObject*
+Mixer_get_midi_behavior_mode(MixerObject *self, void *closure)
+{
+ return PyLong_FromLong(get_midi_behavior_mode(self->mixer));
+}
+
+static int
+Mixer_set_midi_behavior_mode(MixerObject *self, PyObject *value, void *closure)
+{
+ int mode;
+ unsigned int result;
+
+ mode = PyLong_AsLong(value);
+ result = set_midi_behavior_mode(self->mixer, mode);
+ if (result == 0) {
+ return 0;
+ }
+ return -1;
+}
+
+
+
static PyGetSetDef Mixer_getseters[] = {
{"channels_count", (getter)Mixer_get_channels_count, NULL,
"channels count", NULL},
{"last_midi_channel", (getter)Mixer_get_last_midi_channel, (setter)Mixer_set_last_midi_channel,
"last midi channel", NULL},
+ {"midi_behavior_mode", (getter)Mixer_get_midi_behavior_mode, (setter)Mixer_set_midi_behavior_mode,
+ "midi behavior mode", NULL},
{NULL}
};
};
static PyTypeObject MixerType = {
- PyObject_HEAD_INIT(NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT(NULL, 0)
"jack_mixer_c.Mixer", /*tp_name*/
sizeof(MixerObject), /*tp_basicsize*/
0, /*tp_itemsize*/
static PyMethodDef jack_mixer_methods[] = {
- {NULL} /* Sentinel */
+ {NULL, NULL, 0, NULL} /* Sentinel */
};
+static struct PyModuleDef moduledef = {
+ PyModuleDef_HEAD_INIT,
+ "jack_mixer_c", /* m_name */
+ "Jack Mixer C Helper Module", /* m_doc */
+ -1, /* m_size */
+ jack_mixer_methods, /* m_methods */
+ NULL, /* m_reload */
+ NULL, /* m_traverse */
+ NULL, /* m_clear */
+ NULL, /* m_free */
+};
-PyMODINIT_FUNC initjack_mixer_c(void)
+PyMODINIT_FUNC PyInit_jack_mixer_c(void)
{
PyObject *m;
if (PyType_Ready(&MixerType) < 0)
- return;
+ return NULL;
if (PyType_Ready(&ChannelType) < 0)
- return;
+ return NULL;
if (PyType_Ready(&OutputChannelType) < 0)
- return;
+ return NULL;
if (PyType_Ready(&ScaleType) < 0)
- return;
-
- m = Py_InitModule3("jack_mixer_c", jack_mixer_methods, "Jack Mixer C Helper Module");
-
+ return NULL;
+
+ m = PyModule_Create(&moduledef);
+ //m = Py_InitModule3("jack_mixer_c", jack_mixer_methods, "module doc");
+
Py_INCREF(&MixerType);
PyModule_AddObject(m, "Mixer", (PyObject*)&MixerType);
Py_INCREF(&ChannelType);
PyModule_AddObject(m, "OutputChannel", (PyObject*)&OutputChannelType);
Py_INCREF(&ScaleType);
PyModule_AddObject(m, "Scale", (PyObject*)&ScaleType);
+
+ return m;
}
projects / jack_mixer.git / blobdiff