/// Rewires this node to the specified sourcenode. I don't think this is ever used (properly).
void AudioDataOutputXT::rewireTo(SourceNodeXT *source)
{
debug() << Q_FUNC_INFO << "rewiring to " << source;
if (!source->audioOutputPort()) { // I can't get no satisfaction
debug() << Q_FUNC_INFO << " no audioport in source";
return;
}
// Make sure the source is sane
source->assert();
// Get the audio input port in our post plugin
xine_post_in_t *target = (xine_post_in_t*)xine_post_input(
&((post_plugin_t*)m_plugin)->xine_post,
const_cast<char*>("audio in"));
if (!xine_post_wire(source->audioOutputPort(), target)) {
qWarning() << Q_FUNC_INFO << ": Failed to rewire!";
return;
}
m_postOutput = source->audioOutputPort();
m_xtSink->rewireTo(source);
// Make sure things went okay
source->assert();
SinkNodeXT::assert();
}
void VolumeFaderEffectXT::createInstance()
{
xine_audio_port_t *audioPort = fakeAudioPort();
Q_ASSERT(0 == m_plugin);
debug() << Q_FUNC_INFO << audioPort << " fadeTime = " << m_parameters.fadeTime;
m_plugin = xine_post_init(m_xine, "KVolumeFader", 1, &audioPort, 0);
xine_post_in_t *paraInput = xine_post_input(m_plugin, "parameters");
Q_ASSERT(paraInput);
Q_ASSERT(paraInput->type == XINE_POST_DATA_PARAMETERS);
Q_ASSERT(paraInput->data);
m_pluginApi = reinterpret_cast<xine_post_api_t *>(paraInput->data);
m_pluginApi->set_parameters(m_plugin, &m_parameters);
}
PyObject *
Xine_Post_PyObject_post_input(Xine_Post_PyObject *self, PyObject *args, PyObject *kwargs)
{
char *name;
xine_post_in_t *input;
if (!PyArg_ParseTuple(args, "s", &name))
return NULL;
input = xine_post_input(self->post, name);
if (!input) {
PyErr_Format(xine_error, "Failed to get post input: %s", name);
return NULL;
}
return (PyObject *)pyxine_new_post_in_pyobject(self->xine, self->post, input, 1);
}
// Owner is a Xine object
Xine_Post_PyObject *
pyxine_new_post_pyobject(Xine_PyObject *xine, xine_post_t *post, char *id, int do_dispose)
{
int i;
const char *const *list;
Xine_Post_PyObject *o = (Xine_Post_PyObject *)xine_object_to_pyobject_find(post);
if (o) {
Py_INCREF(o);
return o;
}
o = (Xine_Post_PyObject *)Xine_Post_PyObject__new(&Xine_Post_PyObject_Type, NULL, NULL);
if (!o)
return NULL;
//printf("Alloc Post: py=%p xine=%p\n", o, post);
o->do_dispose = do_dispose;
o->post = post;
o->xine = xine;
o->name = Py_BuildValue("z", id);
Py_INCREF(o->xine);
xine_object_to_pyobject_register(post, (PyObject *)o);
list = xine_post_list_outputs(post);
for (i = 0; list[i]; i++) {
xine_post_out_t *out = xine_post_output(post, list[i]);
PyObject *pyout = (PyObject *)pyxine_new_post_out_pyobject(xine, post, out, 1);
PyList_Append(o->outputs, pyout);
Py_DECREF(pyout);
}
list = xine_post_list_inputs(post);
for (i = 0; list[i]; i++) {
xine_post_in_t *in = xine_post_input(post, list[i]);
PyObject *pyin = (PyObject *)pyxine_new_post_in_pyobject(xine, post, in, 1);
PyList_Append(o->inputs, pyin);
Py_DECREF(pyin);
}
return o;
}
PyObject *
Xine_Post_PyObject_get_help(Xine_Post_PyObject *self, PyObject *args, PyObject *kwargs)
{
xine_post_in_t *input_api;
xine_post_api_t *api;
char *help;
input_api = (xine_post_in_t *)xine_post_input(self->post, "parameters");
if (!input_api) {
Py_INCREF(Py_None);
return Py_None;
}
api = (xine_post_api_t *)input_api->data;
help = api->get_help();
if (!help)
help = "";
return PyString_FromString(help);
}
PyObject *
Xine_Post_PyObject_set_parameters(Xine_Post_PyObject *self, PyObject *args, PyObject *kwargs)
{
xine_post_in_t *input_api;
xine_post_api_t *api;
xine_post_api_descr_t *desc;
xine_post_api_parameter_t *parm;
char *data;
PyObject *dict;
if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
return NULL;
input_api = (xine_post_in_t *)xine_post_input(self->post, "parameters");
if (!input_api) {
Py_INCREF(Py_None);
return Py_None;
}
api = (xine_post_api_t *)input_api->data;
desc = api->get_param_descr();
parm = desc->parameter;
data = (void *)malloc(desc->struct_size);
api->get_parameters(self->post, (void *)data);
while (parm->type != POST_PARAM_TYPE_LAST) {
PyObject *value = PyDict_GetItemString(dict, parm->name);
if (!value) {
parm++;
continue;
}
switch(parm->type) {
case POST_PARAM_TYPE_INT:
*(int *)(data + parm->offset) = PyLong_AsLong(value);
break;
case POST_PARAM_TYPE_DOUBLE:
*(double *)(data + parm->offset) = PyFloat_AsDouble(value);
break;
case POST_PARAM_TYPE_CHAR:
strncpy((char *)(data + parm->offset), PyString_AsString(value), parm->size);
break;
case POST_PARAM_TYPE_STRING:
{
char *tmp;
tmp = (void *)calloc(1, PySequence_Size(value) + 1);
strcpy(tmp, PyString_AsString(value));
*(char **)(data + parm->offset) = tmp;
break;
}
case POST_PARAM_TYPE_STRINGLIST:
{
int i;
char **strings, *tmp;
strings = (char **)malloc(PyList_Size(value) + 1);
for (i = 0; i < PyList_Size(value); i++) {
PyObject *o = PyList_GetItem(value, i);
tmp = (void *)calloc(1, PySequence_Size(o) + 1);
strcpy(tmp, PyString_AsString(o));
strings[i] = tmp;
Py_DECREF(o);
}
strings[i] = NULL;
*(char **)(data + parm->offset) = (char *)strings;
break;
}
case POST_PARAM_TYPE_BOOL:
*(int *)(data + parm->offset) = PyLong_AsLong(value);
break;
}
parm++;
}
Py_BEGIN_ALLOW_THREADS
api->set_parameters(self->post, (void *)data);
Py_END_ALLOW_THREADS
free(data);
if (PyErr_Occurred())
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
PyObject *
Xine_Post_PyObject_get_parameters(Xine_Post_PyObject *self, PyObject *args, PyObject *kwargs)
{
xine_post_in_t *input_api;
xine_post_api_t *api;
xine_post_api_descr_t *desc;
xine_post_api_parameter_t *parm;
char *data;
PyObject *dict= PyDict_New();
input_api = (xine_post_in_t *)xine_post_input(self->post, "parameters");
if (!input_api) {
Py_INCREF(Py_None);
return Py_None;
}
api = (xine_post_api_t *)input_api->data;
desc = api->get_param_descr();
parm = desc->parameter;
data = (void *)malloc(desc->struct_size);
api->get_parameters(self->post, (void *)data);
while (parm->type != POST_PARAM_TYPE_LAST) {
PyObject *value = NULL;
switch(parm->type) {
case POST_PARAM_TYPE_INT:
value = PyInt_FromLong(*(int *)(data + parm->offset));
break;
case POST_PARAM_TYPE_DOUBLE:
value = PyFloat_FromDouble(*(double *)(data + parm->offset));
break;
case POST_PARAM_TYPE_CHAR:
value = PyString_FromString((char *)(data + parm->offset));
break;
case POST_PARAM_TYPE_STRING:
value = PyString_FromString(*(char **)(data + parm->offset));
break;
case POST_PARAM_TYPE_STRINGLIST:
{
int i;
char **strings = (char **)(data + parm->offset);
PyObject *str;
value = PyList_New(0);
for (i = 0; strings[i]; i++) {
str = PyString_FromString(strings[i]);
PyList_Append(value, str);
Py_DECREF(str);
}
break;
}
case POST_PARAM_TYPE_BOOL:
value = PyBool_FromLong(*(int *)(data + parm->offset));
break;
}
if (PyErr_Occurred())
break;
if (value)
PyDict_SetItemString_STEAL(dict, parm->name, value);
parm++;
}
free(data);
if (PyErr_Occurred())
return NULL;
return dict;
}
PyObject *
Xine_Post_PyObject_get_parameters_desc(Xine_Post_PyObject *self, PyObject *args, PyObject *kwargs)
{
xine_post_in_t *input_api;
xine_post_api_t *api;
xine_post_api_descr_t *desc;
xine_post_api_parameter_t *parm;
PyObject *param_dict = PyDict_New();
input_api = (xine_post_in_t *)xine_post_input(self->post, "parameters");
if (!input_api) {
Py_INCREF(Py_None);
return Py_None;
}
api = (xine_post_api_t *)input_api->data;
desc = api->get_param_descr();
parm = desc->parameter;
while (parm->type != POST_PARAM_TYPE_LAST) {
PyObject *dict = PyDict_New();
PyObject *type = Py_None;
PyObject *enums = PyList_New(0);
switch(parm->type) {
case POST_PARAM_TYPE_INT:
type = (PyObject *)&PyInt_Type;
break;
case POST_PARAM_TYPE_DOUBLE:
type = (PyObject *)&PyFloat_Type;
break;
case POST_PARAM_TYPE_CHAR:
case POST_PARAM_TYPE_STRING:
type = (PyObject *)&PyString_Type;
break;
case POST_PARAM_TYPE_STRINGLIST:
type = (PyObject *)&PyList_Type;
break;
case POST_PARAM_TYPE_BOOL:
type = (PyObject *)&PyBool_Type;
break;
}
PyDict_SetItemString(dict, "type", type);
PyDict_SetItemString_STEAL(dict, "name", PyString_FromString(parm->name));
PyDict_SetItemString_STEAL(dict, "description", PyString_FromString(parm->description));
PyDict_SetItemString_STEAL(dict, "readonly", PyBool_FromLong(parm->readonly));
if (parm->enum_values) {
int i;
for (i = 0; parm->enum_values[i]; i++) {
PyObject *str = PyString_FromString(parm->enum_values[i]);
PyList_Append(enums, str);
Py_DECREF(str);
}
}
PyDict_SetItemString_STEAL(dict, "enums", enums);
PyDict_SetItemString_STEAL(param_dict, parm->name, dict);
parm++;
}
return param_dict;
}
