From 42088654d66f38bca725eb3c69ad84883d185cd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Stenac?= <zorglub@videolan.org> Date: Wed, 2 Nov 2005 18:32:39 +0000 Subject: [PATCH] Merge fixes to the python binding from my branch --- bindings/python/setup.py | 3 +- bindings/python/vlcglue.c | 2291 +++++++++++++++++++------------------ bindings/python/vlcglue.h | 123 ++ src/audio_output/output.c | 2 +- src/control/core.c | 6 +- src/control/init.c | 10 +- 6 files changed, 1304 insertions(+), 1131 deletions(-) create mode 100644 bindings/python/vlcglue.h diff --git a/bindings/python/setup.py b/bindings/python/setup.py index 66bdf3107f..9904c72064 100644 --- a/bindings/python/setup.py +++ b/bindings/python/setup.py @@ -34,7 +34,8 @@ def get_ldflags(): # To compile in a local vlc tree vlclocal = Extension('vlc', - sources = ['vlcglue.c', '../../src/control/init.c'], + sources = ['vlcglue.c', + '../../src/control/init.c'], include_dirs = ['../../include', '../../', '/usr/win32/include' ], extra_objects = [ '../../lib/libvlc.a' ], extra_compile_args = get_cflags(), diff --git a/bindings/python/vlcglue.c b/bindings/python/vlcglue.c index 9f5a912f06..3d7cffefe4 100644 --- a/bindings/python/vlcglue.c +++ b/bindings/python/vlcglue.c @@ -1,108 +1,702 @@ -#include <Python.h> -#include "structmember.h" - -/* Undefine the following define to disable low-level vlc Object support */ -#define VLCOBJECT_SUPPORT 1 - -#define __VLC__ - -#include <stdio.h> - -#include <vlc/control.h> - -#define SELF ((MediaControl*)self) - -#define MC_TRY exception=mediacontrol_exception_init(exception) -#define MC_EXCEPT \ - if (exception->code) { \ - PyObject *py_exc = MediaControl_InternalException; \ - switch (exception->code) { \ - case mediacontrol_InternalException: \ - py_exc = MediaControl_InternalException; \ - break; \ - case mediacontrol_PlaylistException: \ - py_exc = MediaControl_PlaylistException; \ - break; \ - case mediacontrol_InvalidPosition: \ - py_exc = MediaControl_InvalidPosition; \ - break; \ - case mediacontrol_PositionKeyNotSupported: \ - py_exc = MediaControl_PositionKeyNotSupported; \ - break; \ - case mediacontrol_PositionOriginNotSupported: \ - py_exc = MediaControl_PositionOriginNotSupported; \ - break; \ - } \ - PyErr_SetString(py_exc, exception->message); \ - mediacontrol_exception_free(exception); \ - return NULL; \ - } else { mediacontrol_exception_free(exception); } +/***************************************************************************** + * vlcglue.c: VLC Module + ***************************************************************************** + * Copyright (C) 1998-2004 the VideoLAN team + * $Id: vlc.c 12667 2005-09-25 10:19:26Z zorglub $ + * + * Authors: Olivier Aubert <oaubert at bat710.univ-lyon1.fr> + * Cl�ment Stenac <zorglub@videolan.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + *****************************************************************************/ +#include "vlcglue.h" + +/************************************************************************** + * VLC Module + **************************************************************************/ + +#ifndef vlcMODINIT_FUNC /* declarations for DLL import/export */ +#define vlcMODINIT_FUNC void +#endif + +static PyMethodDef vlc_methods[] = { + {NULL} /* Sentinel */ +}; /* Module globals */ -static PyObject *MediaControl_InternalException = NULL; -static PyObject *MediaControl_PositionKeyNotSupported = NULL; -static PyObject *MediaControl_PositionOriginNotSupported = NULL; -static PyObject *MediaControl_InvalidPosition = NULL; -static PyObject *MediaControl_PlaylistException = NULL; +PyObject* MediaControl_InternalException = NULL; +PyObject* MediaControl_PositionKeyNotSupported = NULL; +PyObject *MediaControl_PositionOriginNotSupported = NULL; +PyObject* MediaControl_InvalidPosition = NULL; +PyObject *MediaControl_PlaylistException = NULL; +vlcMODINIT_FUNC initvlc(void) +{ + PyObject* m; + PyPosition_Type.tp_new = PyType_GenericNew; + PyPosition_Type.tp_alloc = PyType_GenericAlloc; + + if (PyType_Ready(&PyPosition_Type) < 0) + return; + if (PyType_Ready(&MediaControl_Type) < 0) + return; #ifdef VLCOBJECT_SUPPORT + if (PyType_Ready(&vlcObject_Type) < 0) + return; +#endif + + /* PyEval_InitThreads(); */ + + /* Have a look at +http://base.bel-epa.com/pyapache/Python/MySQL-python/MySQL-python-0.3.0/_mysqlmodule.c */ + + m = Py_InitModule3( "vlc", vlc_methods, + "VLC media player embedding module."); + + /* Exceptions */ + MediaControl_InternalException = + PyErr_NewException("vlc.InternalException", NULL, NULL); + PyModule_AddObject(m, "InternalException", MediaControl_InternalException); -/* vlcObject (low level access) */ -#define VLCSELF ((vlcObject*)self) -typedef struct { - PyObject_HEAD - vlc_object_t* p_object; -} vlcObject; + MediaControl_PositionKeyNotSupported = + PyErr_NewException("vlc.PositionKeyNotSupported", NULL, NULL); + PyModule_AddObject(m, "PositionKeyNotSupported", + MediaControl_PositionKeyNotSupported); -staticforward PyTypeObject vlcObject_Type; + MediaControl_PositionOriginNotSupported= + PyErr_NewException("vlc.InvalidPosition", NULL, NULL); + PyModule_AddObject(m, "PositionOriginNotSupported", + MediaControl_PositionOriginNotSupported); + MediaControl_InvalidPosition = + PyErr_NewException("vlc.InvalidPosition", NULL, NULL); + PyModule_AddObject(m, "InvalidPosition", MediaControl_InvalidPosition); + + MediaControl_PlaylistException = + PyErr_NewException("vlc.PlaylistException", NULL, NULL); + PyModule_AddObject(m, "PlaylistException", MediaControl_PlaylistException); + + /* Types */ + Py_INCREF(&PyPosition_Type); + PyModule_AddObject(m, "Position", (PyObject *)&PyPosition_Type); + Py_INCREF(&MediaControl_Type); + PyModule_AddObject(m, "MediaControl", (PyObject *)&MediaControl_Type); +#ifdef VLCOBJECT_SUPPORT + Py_INCREF(&vlcObject_Type); + PyModule_AddObject(m, "Object", (PyObject *)&vlcObject_Type); #endif -/* MediaControl object */ -typedef struct { - PyObject_HEAD - mediacontrol_Instance* mc; -} MediaControl; + /* Constants */ + PyModule_AddIntConstant(m, "AbsolutePosition", + mediacontrol_AbsolutePosition); + PyModule_AddIntConstant(m, "RelativePosition", + mediacontrol_RelativePosition); + PyModule_AddIntConstant(m, "ModuloPosition", + mediacontrol_ModuloPosition); + + PyModule_AddIntConstant(m, "ByteCount", mediacontrol_ByteCount); + PyModule_AddIntConstant(m, "SampleCount", mediacontrol_SampleCount); + PyModule_AddIntConstant(m, "MediaTime", mediacontrol_MediaTime); + PyModule_AddIntConstant(m, "PlayingStatus", mediacontrol_PlayingStatus); + PyModule_AddIntConstant(m, "PauseStatus", mediacontrol_PauseStatus); + PyModule_AddIntConstant(m, "ForwardStatus", mediacontrol_ForwardStatus); + PyModule_AddIntConstant(m, "BackwardStatus", mediacontrol_BackwardStatus); + PyModule_AddIntConstant(m, "InitStatus", mediacontrol_InitStatus); + PyModule_AddIntConstant(m, "EndStatus", mediacontrol_EndStatus); + PyModule_AddIntConstant(m, "UndefinedStatus", mediacontrol_UndefinedStatus); +} + + +/* Make libpostproc happy... */ +void * fast_memcpy(void * to, const void * from, size_t len) +{ + return memcpy(to, from, len); +} + -staticforward PyTypeObject MediaControl_Type; +/***************************************************************************** + * VLCObject implementation + *****************************************************************************/ -/* Position object */ -typedef struct { - PyObject_HEAD - int origin; - int key; - long long value; -} PyPosition; +#ifdef VLCOBJECT_SUPPORT -static int -PyPosition_init(PyPosition *self, PyObject *args, PyObject *kwds) +static PyObject *vlcObject_new( + PyTypeObject *type, PyObject *args, PyObject *kwds) { - self->origin = mediacontrol_AbsolutePosition; - self->key = mediacontrol_MediaTime; - self->value = 0; + vlcObject *self; + vlc_object_t *p_object; + int i_id; + + self = PyObject_New(vlcObject, &vlcObject_Type); + + if ( !PyArg_ParseTuple(args, "i", &i_id) ) + return NULL; - return 0; + /* Maybe we were already initialized */ + p_object = (vlc_object_t*)vlc_current_object(i_id); + + if (! p_object) + { + /* Try to initialize */ + i_id = VLC_Create(); + p_object = (vlc_object_t*)vlc_current_object(i_id); + } + + if (! p_object) + { + PyErr_SetString(PyExc_StandardError, "Unable to get object."); + return NULL; + } + + self->p_object = p_object; + self->b_released = 0; + + Py_INCREF( self ); /* Ah bon ? */ + return (PyObject *)self; } -static PyMethodDef PyPosition_methods[] = { - {NULL} /* Sentinel */ -}; +static PyObject * vlcObject_release( PyObject *self ) +{ + if( VLCSELF->b_released == 0 ) + { + vlc_object_release( VLCSELF->p_object ); + VLCSELF->b_released = 1; + } + Py_INCREF( Py_None); + return Py_None; +} + +static void vlcObject_dealloc(PyObject *self) +{ + vlcObject_release( self ); + PyMem_DEL(self); +} + +static PyObject * vlcObject_find_object(PyObject *self, PyObject *args) +{ + vlcObject *retval; + vlc_object_t *p_obj; + char *psz_name; + int i_object_type; + + if ( !PyArg_ParseTuple(args, "s", &psz_name) ) + return NULL; -static PyMemberDef PyPosition_members[] = { - {"origin", T_INT, offsetof(PyPosition, origin), 0, "Position origin"}, - {"key", T_INT, offsetof(PyPosition, key), 0, "Position key"}, - {"value", T_ULONG, offsetof(PyPosition, value), 0, "Position value"}, - {NULL} /* Sentinel */ + /* psz_name is in + (aout, decoder, input, httpd, intf, playlist, root, vlc, vout) + */ + switch (psz_name[0]) + { + case 'a': + i_object_type = VLC_OBJECT_AOUT; + break; + case 'd': + i_object_type = VLC_OBJECT_DECODER; + break; + case 'h': + i_object_type = VLC_OBJECT_HTTPD; + break; + case 'i': + if (strlen(psz_name) < 3) + i_object_type = VLC_OBJECT_INTF; + else if (psz_name[2] == 't') + i_object_type = VLC_OBJECT_INTF; + else + i_object_type = VLC_OBJECT_INPUT; + break; + case 'p': + i_object_type = VLC_OBJECT_PLAYLIST; + break; + case 'r': + i_object_type = VLC_OBJECT_ROOT; + break; + case 'v': + if (strlen(psz_name) < 3) + i_object_type = VLC_OBJECT_VLC; + else if (psz_name[1] == 'l') + i_object_type = VLC_OBJECT_VLC; + else + i_object_type = VLC_OBJECT_VOUT; + break; + default: + /* FIXME: raise an exception */ + return Py_None; + } + + p_obj = vlc_object_find( VLCSELF->p_object, i_object_type, FIND_ANYWHERE ); + + if (! p_obj) + { + Py_INCREF(Py_None); + return Py_None; + } + + retval = PyObject_New(vlcObject, &vlcObject_Type); + + retval->p_object = p_obj; + + return (PyObject *)retval; +} + +static PyObject * vlcObject_info(PyObject *self, PyObject *args) +{ + PyObject *retval; + vlc_object_t *p_obj; + + p_obj = VLCSELF->p_object; + + /* Return information about the object as a dict. */ + retval = PyDict_New(); + + PyDict_SetItemString(retval, "object-id", + Py_BuildValue("l", p_obj->i_object_id)); + PyDict_SetItemString(retval, "object-type", + Py_BuildValue("s", p_obj->psz_object_type)); + PyDict_SetItemString(retval, "object-name", + Py_BuildValue("s", p_obj->psz_object_name)); + PyDict_SetItemString(retval, "thread", + PyBool_FromLong(p_obj->b_thread)); + PyDict_SetItemString(retval, "thread-id", + PyLong_FromLongLong(p_obj->thread_id)); + PyDict_SetItemString(retval, "refcount", + PyInt_FromLong(p_obj->i_refcount)); + + return retval; +} + +static PyObject * vlcObject_find_id(PyObject *self, PyObject *args) +{ + vlcObject *retval; + vlc_object_t* p_object; + int i_id; + + if ( !PyArg_ParseTuple(args, "i", &i_id) ) + { + PyErr_SetString(PyExc_StandardError, "Error: no id was given.\n"); + return Py_None; + } + + p_object = (vlc_object_t*)vlc_current_object(i_id); + + if (! p_object) + { + Py_INCREF(Py_None); + return Py_None; + } + + retval = PyObject_NEW(vlcObject, &vlcObject_Type); + + retval->p_object = p_object; + + return (PyObject *)retval; +} + +/* Do a var_Get call on the object. Parameter: the variable name. */ +/* FIXME: We should make them attributes */ +static PyObject * vlcObject_var_get(PyObject *self, PyObject *args) +{ + PyObject *retval; + vlc_value_t value; + char *psz_name; + int i_type; + + if ( !PyArg_ParseTuple(args, "s", &psz_name) ) + { + PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + if( var_Get( VLCSELF->p_object, psz_name, &value ) != VLC_SUCCESS ) + { + PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + i_type = var_Type (VLCSELF->p_object, psz_name); + + switch (i_type) + { + case VLC_VAR_VOID : + retval = PyString_FromString("A void variable"); + break; + case VLC_VAR_BOOL : + retval = PyBool_FromLong(value.b_bool); + break; + case VLC_VAR_INTEGER : + retval = PyInt_FromLong((long)value.i_int); + break; + case VLC_VAR_HOTKEY : + retval = PyString_FromFormat("A hotkey variable (%d)", value.i_int); + break; + case VLC_VAR_FILE : + case VLC_VAR_STRING : + case VLC_VAR_DIRECTORY : + case VLC_VAR_VARIABLE : + retval = PyString_FromString(value.psz_string); + break; + case VLC_VAR_MODULE : + retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type); + ((vlcObject*)retval)->p_object = value.p_object; + break; + case VLC_VAR_FLOAT : + retval = PyFloat_FromDouble((double)value.f_float); + break; + case VLC_VAR_TIME : + retval = PyLong_FromLongLong(value.i_time); + break; + case VLC_VAR_ADDRESS : + retval = PyString_FromString("A VLC address (not handled yet)"); + break; + case VLC_VAR_LIST : + retval = PyString_FromString("A VLC list (not handled yet)"); + break; + case VLC_VAR_MUTEX : + retval = PyString_FromString("A mutex"); + break; + default: + retval = Py_None; + } + + Py_INCREF(retval); + return retval; +} + +static PyObject * vlcObject_var_type(PyObject *self, + PyObject *args) +{ + char *psz_name; + PyObject *retval; + int i_type; + + if ( !PyArg_ParseTuple(args, "s", &psz_name)) + { + PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + i_type = var_Type(VLCSELF->p_object, psz_name); + + switch (i_type) + { + case VLC_VAR_VOID : + retval = PyString_FromString("Void"); + break; + case VLC_VAR_BOOL : + retval = PyString_FromString("Boolean"); + break; + case VLC_VAR_INTEGER : + retval = PyString_FromString("Integer"); + break; + case VLC_VAR_HOTKEY : + retval = PyString_FromString("Hotkey"); + break; + case VLC_VAR_FILE : + retval = PyString_FromString("File"); + break; + case VLC_VAR_STRING : + retval = PyString_FromString("String"); + break; + case VLC_VAR_DIRECTORY : + retval = PyString_FromString("Directory"); + break; + case VLC_VAR_VARIABLE : + retval = PyString_FromString("Variable"); + break; + case VLC_VAR_MODULE : + retval = PyString_FromString("Module"); + break; + case VLC_VAR_FLOAT : + retval = PyString_FromString("Float"); + break; + case VLC_VAR_TIME : + retval = PyString_FromString("Time"); + break; + case VLC_VAR_ADDRESS : + retval = PyString_FromString("Address"); + break; + case VLC_VAR_LIST : + retval = PyString_FromString("List"); + break; + case VLC_VAR_MUTEX : + retval = PyString_FromString("Mutex"); + break; + default: + retval = PyString_FromString("Unknown"); + } + return retval; +} + +/* Do a var_Set call on the object. Parameter: the variable name. */ +/* FIXME: We should make them attributes */ +static PyObject * vlcObject_var_set(PyObject *self, + PyObject *args) +{ + vlc_value_t value; + char *psz_name; + PyObject *py_value; + int i_type; + vlc_object_t *p_obj; + + if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) ) + { + PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + p_obj = VLCSELF->p_object; + i_type = var_Type(p_obj, psz_name); + + switch (i_type) + { + case VLC_VAR_VOID : + break; + case VLC_VAR_BOOL : + value.b_bool = PyInt_AsLong(py_value); + break; + case VLC_VAR_INTEGER : + case VLC_VAR_HOTKEY : + value.i_int = PyInt_AsLong(py_value); + break; + case VLC_VAR_FILE : + case VLC_VAR_STRING : + case VLC_VAR_DIRECTORY : + case VLC_VAR_VARIABLE : + value.psz_string = strdup(PyString_AsString(py_value)); + break; + case VLC_VAR_MODULE : + /* FIXME: we should check the PyObject type and get its p_object */ + value.p_object = ((vlcObject*)p_obj)->p_object; + break; + case VLC_VAR_FLOAT : + value.f_float = PyFloat_AsDouble(py_value); + break; + case VLC_VAR_TIME : + value.i_time = PyLong_AsLongLong(py_value); + break; + case VLC_VAR_ADDRESS : + value.p_address = (char*)PyLong_AsVoidPtr(py_value); + break; + case VLC_VAR_LIST : + /* FIXME */ + value.p_list = NULL; + break; + case VLC_VAR_MUTEX : + break; + } + + var_Set(p_obj, psz_name, value); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * vlcObject_var_list(PyObject *self, + PyObject *args) +{ + PyObject *retval; + int i_size; + int i_index; + + i_size = VLCSELF->p_object->i_vars; + retval = PyTuple_New(i_size); + + for (i_index = 0 ; i_index < i_size ; i_index++) + { + PyTuple_SetItem(retval, i_index, + Py_BuildValue("s", VLCSELF->p_object->p_vars[i_index].psz_name)); + } + + /* Py_INCREF(retval); */ + return retval; +} + +/* Do a config_Get call on the object. Parameter: the variable name. */ +static PyObject * vlcObject_config_get(PyObject *self, + PyObject *args) +{ + PyObject *retval; + vlc_value_t value; + char *psz_name; + module_config_t *p_config; + + if ( !PyArg_ParseTuple(args, "s", &psz_name) ) + { + PyErr_SetString(PyExc_StandardError, "Error: no config variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + p_config = config_FindConfig( VLCSELF->p_object, psz_name ); + + if( !p_config ) + { + PyErr_SetString(PyExc_StandardError, "Error: config variable does not exist.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + switch (p_config->i_type) + { + case CONFIG_ITEM_BOOL : + retval = PyBool_FromLong(p_config->i_value); + break; + case CONFIG_ITEM_INTEGER : + retval = PyInt_FromLong((long)p_config->i_value); + break; + case CONFIG_ITEM_KEY : + retval = PyString_FromFormat("A hotkey variable (%d)", p_config->i_value); + break; + case CONFIG_ITEM_FILE : + case CONFIG_ITEM_STRING : + case CONFIG_ITEM_DIRECTORY : + case CONFIG_ITEM_MODULE : + vlc_mutex_lock( p_config->p_lock ); + if( p_config->psz_value ) + retval = PyString_FromString( p_config->psz_value ); + else + retval = PyString_FromString( "" ); + vlc_mutex_unlock( p_config->p_lock ); + break; + retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type); + ((vlcObject*)retval)->p_object = value.p_object; + break; + case CONFIG_ITEM_FLOAT : + retval = PyFloat_FromDouble((double)p_config->f_value); + break; + default: + retval = Py_None; + Py_INCREF(retval); + } + + return retval; +} + +/* Do a var_Set call on the object. Parameter: the variable name. */ +/* FIXME: We should make them attributes */ +static PyObject * vlcObject_config_set(PyObject *self, + PyObject *args) +{ + char *psz_name; + PyObject *py_value; + vlc_object_t *p_obj; + module_config_t *p_config; + + + if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) ) + { + PyErr_SetString(PyExc_StandardError, + "Error: no variable name was given.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + p_obj = VLCSELF->p_object; + p_config = config_FindConfig( p_obj, psz_name ); + /* sanity checks */ + if( !p_config ) + { + PyErr_SetString(PyExc_StandardError, + "Error: option does not exist.\n"); + Py_INCREF(Py_None); + return Py_None; + } + + switch (p_config->i_type) + { + case CONFIG_ITEM_BOOL : + case CONFIG_ITEM_INTEGER : + case CONFIG_ITEM_KEY : + config_PutInt(p_obj, psz_name, PyInt_AsLong(py_value)); + break; + case CONFIG_ITEM_FILE : + case CONFIG_ITEM_STRING : + case CONFIG_ITEM_DIRECTORY : + case CONFIG_ITEM_MODULE : + config_PutPsz(p_obj, psz_name, PyString_AsString(py_value)); + break; + case CONFIG_ITEM_FLOAT : + config_PutFloat(p_obj, psz_name, PyFloat_AsDouble(py_value)); + break; + } + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * vlcObject_children(PyObject *self, + PyObject *args) +{ + PyObject *retval; + int i_size; + int i_index; + + i_size = VLCSELF->p_object->i_children; + retval = PyTuple_New(i_size); + + for (i_index = 0 ; i_index < i_size ; i_index++) + { + PyTuple_SetItem(retval, i_index, + Py_BuildValue("i", + VLCSELF->p_object->pp_children[i_index]->i_object_id)); + } + + /* Py_INCREF(retval); */ + return retval; +} + + +/* Method table */ +static PyMethodDef vlcObject_methods[] = +{ + { "get", vlcObject_var_get, METH_VARARGS, + "get(str) -> value Get a variable value."}, + { "set", vlcObject_var_set, METH_VARARGS, + "set(str, value) Set a variable value" }, + { "config_get", vlcObject_config_get, METH_VARARGS, + "get(str) -> value Get an option value." }, + { "config_set", vlcObject_config_set, METH_VARARGS, + "set(str, value) Set an option value" }, + { "type", vlcObject_var_type, METH_VARARGS, + "type(str) -> str Get a variable type" }, + { "list", vlcObject_var_list, METH_VARARGS, + "list() List the available variables" }, + { "children", vlcObject_children, METH_VARARGS, + "children() List the children ids" }, + { "find_object", vlcObject_find_object, METH_VARARGS, + "find_object(str) -> Object Find the object of a given type.\n\nAvailable types are : aout, decoder, input, httpd, intf, playlist, root, vlc, vout"}, + { "find_id", vlcObject_find_id, METH_VARARGS, + "find_id(int) -> Object Find an object by id" }, + { "info", vlcObject_info, METH_VARARGS, + "info() -> dict Return information about the object" }, + { "release", vlcObject_release, METH_VARARGS, + "release() -> Release the VLC Object" }, + { NULL, NULL, 0, NULL }, }; -static PyTypeObject PyPosition_Type = { +static PyTypeObject vlcObject_Type = +{ PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ - "vlc.Position", /*tp_name*/ - sizeof(PyPosition_Type), /*tp_basicsize*/ + "vlc.Object", /*tp_name*/ + sizeof(vlcObject_Type), /*tp_basicsize*/ 0, /*tp_itemsize*/ - 0, /*tp_dealloc*/ + (destructor)vlcObject_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ @@ -118,547 +712,503 @@ static PyTypeObject PyPosition_Type = { 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - "Represent a Position with origin, key and value", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - PyPosition_methods, /* tp_methods */ - PyPosition_members, /* tp_members */ + "Explore VLC objects.", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + vlcObject_methods, /* tp_methods */ + 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)PyPosition_init, /* tp_init */ + 0, /* tp_init */ 0, /* tp_alloc */ - 0, /* tp_new */ + vlcObject_new, /* tp_new */ }; -static mediacontrol_PositionKey positionKey_py_to_c( PyObject * py_key ) -{ - mediacontrol_PositionKey key_position = mediacontrol_MediaTime; - int key; - - if(!PyArg_Parse(py_key, "i", &key)) - { - PyErr_SetString (MediaControl_InternalException, "Invalid key value"); - return key_position; - } - - switch (key) - { - case 0: key = mediacontrol_ByteCount; break; - case 1: key = mediacontrol_SampleCount; break; - case 2: key = mediacontrol_MediaTime; break; - } - - return key_position; -} - -static mediacontrol_PositionOrigin positionOrigin_py_to_c( PyObject * py_origin ) -{ - mediacontrol_PositionOrigin origin_position = mediacontrol_AbsolutePosition; - int origin; - - if(!PyArg_Parse(py_origin,"i", &origin)) - { - PyErr_SetString (MediaControl_InternalException, "Invalid origin value"); - return origin_position; - } - - switch (origin) - { - case 0: origin_position = mediacontrol_AbsolutePosition; break; - case 1: origin_position = mediacontrol_RelativePosition; break; - case 2: origin_position = mediacontrol_ModuloPosition; break; - } - - return origin_position; -} - -/* Methods for transforming the Position Python object to Position structure*/ -static mediacontrol_Position* position_py_to_c( PyObject * py_position ) -{ - mediacontrol_Position * a_position = NULL; - PyPosition *pos = (PyPosition*)py_position; - - a_position = (mediacontrol_Position*)malloc(sizeof(mediacontrol_Position)); - if (! a_position) - { - PyErr_SetString(PyExc_MemoryError, "Out of memory"); - return NULL; - } - - if (PyObject_IsInstance(py_position, (PyObject*)&PyPosition_Type)) - { - a_position->origin = pos->origin; - a_position->key = pos->key; - a_position->value = pos->value; - } - else - { - /* Feature: if we give an integer, it will be considered as - a relative position in mediatime */ - a_position->origin = mediacontrol_RelativePosition; - a_position->key = mediacontrol_MediaTime; - a_position->value = PyLong_AsLongLong(py_position); - } - return a_position; -} - -static PyPosition* position_c_to_py(mediacontrol_Position *position) -{ - PyPosition* py_retval; +#endif - py_retval = PyObject_New(PyPosition, &PyPosition_Type); - py_retval->origin = position->origin; - py_retval->key = position->key; - py_retval->value = position->value; - return py_retval; -} +/***************************************************************************** + * VLC MediaControl object implementation + *****************************************************************************/ -/* constructor : create the new type, thread and init */ static PyObject *MediaControl_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - MediaControl *self; - mediacontrol_Exception *exception = NULL; - PyObject* py_list = NULL; - char** ppsz_args = NULL; + MediaControl *self; + mediacontrol_Exception *exception = NULL; + PyObject* py_list = NULL; + char** ppsz_args = NULL; - self = PyObject_New(MediaControl, &MediaControl_Type); + self = PyObject_New(MediaControl, &MediaControl_Type); - if (PyArg_ParseTuple(args, "O", &py_list)) + if (PyArg_ParseTuple(args, "O", &py_list)) { - int i_size; - int i_index; - - Py_INCREF(py_list); - if (! PySequence_Check(py_list)) - { - PyErr_SetString(PyExc_TypeError, "Parameter must be a sequence."); - return NULL; - } - i_size = PySequence_Size(py_list); - ppsz_args = malloc(i_size + 1); - if (! ppsz_args) - { - PyErr_SetString(PyExc_MemoryError, "Out of memory"); - return NULL; - } - - for (i_index = 0; i_index < i_size; i_index++) - { - ppsz_args[i_index]=strdup(PyString_AsString(PyObject_Str(PySequence_GetItem(py_list, - i_index)))); - } - ppsz_args[i_size] = NULL; - Py_DECREF(py_list); + int i_size; + int i_index; + + Py_INCREF(py_list); + if (! PySequence_Check(py_list)) + { + PyErr_SetString(PyExc_TypeError, "Parameter must be a sequence."); + return NULL; + } + i_size = PySequence_Size(py_list); + ppsz_args = malloc(i_size + 1); + if (! ppsz_args) + { + PyErr_SetString(PyExc_MemoryError, "Out of memory"); + return NULL; + } + + for ( i_index = 0; i_index < i_size; i_index++ ) + { + ppsz_args[i_index] = + strdup( PyString_AsString( PyObject_Str( + PySequence_GetItem(py_list, + i_index ) ) ) ); + } + ppsz_args[i_size] = NULL; + Py_DECREF(py_list); } - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - self->mc = mediacontrol_new(ppsz_args, exception); - MC_EXCEPT; - Py_END_ALLOW_THREADS - - Py_INCREF(self); - return (PyObject *)self; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + self->mc = mediacontrol_new( ppsz_args, exception ); + MC_EXCEPT; + Py_END_ALLOW_THREADS + + Py_INCREF(self); + return (PyObject *)self; } -static void -MediaControl_dealloc(PyObject *self) +static void MediaControl_dealloc(PyObject *self) { - PyMem_DEL(self); + PyMem_DEL(self); } -/* Returns the current position in the stream. The returned value can +/** + * Returns the current position in the stream. The returned value can be relative or absolute (according to PositionOrigin) and the unit - is set by PositionKey */ -static PyObject * MediaControl_get_media_position(PyObject *self, PyObject *args) + is set by PositionKey + */ +static PyObject * MediaControl_get_media_position( + PyObject *self, PyObject *args) { - mediacontrol_Position* pos; - mediacontrol_Exception* exception = NULL; - PyObject *py_origin; - PyObject *py_key; - PyObject *py_retval; - mediacontrol_PositionOrigin origin; - mediacontrol_PositionKey key; - - if( !PyArg_ParseTuple(args, "OO", &py_origin, &py_key)) - return NULL; - - origin = positionOrigin_py_to_c(py_origin); - key = positionKey_py_to_c(py_key); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - pos = mediacontrol_get_media_position(SELF->mc, origin, key, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - py_retval = (PyObject*)position_c_to_py(pos); - free(pos); - return py_retval; + mediacontrol_Position* pos; + mediacontrol_Exception* exception = NULL; + PyObject *py_origin; + PyObject *py_key; + PyObject *py_retval; + mediacontrol_PositionOrigin origin; + mediacontrol_PositionKey key; + + if( !PyArg_ParseTuple( args, "OO", &py_origin, &py_key ) ) + return NULL; + + origin = positionOrigin_py_to_c(py_origin); + key = positionKey_py_to_c(py_key); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + pos = mediacontrol_get_media_position(SELF->mc, origin, key, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + py_retval = (PyObject*)position_c_to_py(pos); + free( pos ); + return py_retval; } -/* Sets the media position */ -static PyObject *MediaControl_set_media_position(PyObject *self, PyObject *args) +/** Sets the media position */ +static PyObject *MediaControl_set_media_position( + PyObject *self, PyObject *args ) { - mediacontrol_Exception* exception = NULL; - mediacontrol_Position *a_position; - PyObject *py_pos; + mediacontrol_Exception* exception = NULL; + mediacontrol_Position *a_position; + PyObject *py_pos; - if( !PyArg_ParseTuple(args, "O", &py_pos) ) - return NULL; + if( !PyArg_ParseTuple( args, "O", &py_pos ) ) + return NULL; - a_position = position_py_to_c(py_pos); - if (!a_position) + a_position = position_py_to_c(py_pos); + if (!a_position ) { - PyErr_SetString(PyExc_MemoryError, "Out of memory"); - return NULL; + PyErr_SetString(PyExc_MemoryError, "Out of memory"); + return NULL; } - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_set_media_position(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_set_media_position( SELF->mc, a_position, exception ); + free( a_position ); + Py_END_ALLOW_THREADS + MC_EXCEPT; - Py_INCREF(Py_None); - return Py_None; + Py_INCREF(Py_None); + return Py_None; } static PyObject *MediaControl_start(PyObject *self, PyObject *args) { - mediacontrol_Position *a_position; - mediacontrol_Exception *exception = NULL; - PyObject *py_pos; - - if( !PyArg_ParseTuple(args, "O", &py_pos)) - return NULL; - - a_position = position_py_to_c(py_pos); - if (!a_position) - return NULL; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_start(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Position *a_position; + mediacontrol_Exception *exception = NULL; + PyObject *py_pos; + + if( !PyArg_ParseTuple(args, "O", &py_pos ) ) + return NULL; + + a_position = position_py_to_c(py_pos); + if ( !a_position ) + return NULL; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_start(SELF->mc, a_position, exception); + free(a_position); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } static PyObject *MediaControl_pause(PyObject *self, PyObject *args) { - mediacontrol_Position *a_position; - mediacontrol_Exception *exception = NULL; - PyObject *py_pos; - - if( !PyArg_ParseTuple(args, "O", &py_pos)) - return NULL; - - a_position = position_py_to_c(py_pos); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_pause(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Position *a_position; + mediacontrol_Exception *exception = NULL; + PyObject *py_pos; + + if( !PyArg_ParseTuple(args, "O", &py_pos ) ) + return NULL; + + a_position = position_py_to_c(py_pos); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_pause(SELF->mc, a_position, exception); + free(a_position); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF( Py_None ); + return Py_None; } static PyObject * MediaControl_resume(PyObject *self, PyObject *args) { - mediacontrol_Position *a_position; - mediacontrol_Exception *exception = NULL; - PyObject *py_pos; - - if( !PyArg_ParseTuple(args, "O", &py_pos)) - return NULL; - - a_position = position_py_to_c(py_pos); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_start(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Position *a_position; + mediacontrol_Exception *exception = NULL; + PyObject *py_pos; + + if( !PyArg_ParseTuple(args, "O", &py_pos ) ) + return NULL; + + a_position = position_py_to_c(py_pos); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_start(SELF->mc, a_position, exception); + free(a_position); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } static PyObject *MediaControl_stop(PyObject *self, PyObject *args) { - mediacontrol_Position *a_position; - mediacontrol_Exception *exception = NULL; - PyObject *py_pos; - - if( !PyArg_ParseTuple(args, "O", &py_pos)) - return NULL; - - a_position = position_py_to_c(py_pos); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_stop(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Position *a_position; + mediacontrol_Exception *exception = NULL; + PyObject *py_pos; + + if( !PyArg_ParseTuple(args, "O", &py_pos ) ) + return NULL; + + a_position = position_py_to_c(py_pos); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_stop(SELF->mc, a_position, exception); + free(a_position); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } static PyObject *MediaControl_exit(PyObject *self, PyObject *args) { - mediacontrol_exit(SELF->mc); - Py_INCREF(Py_None); - return Py_None; + mediacontrol_exit(SELF->mc); + Py_INCREF(Py_None); + return Py_None; } static PyObject *MediaControl_playlist_add_item(PyObject *self, PyObject *args) { - char *psz_file; - mediacontrol_Exception *exception = NULL; - - if ( !PyArg_ParseTuple(args, "s", &psz_file) ) - return NULL; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_playlist_add_item(SELF->mc, psz_file, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + char *psz_file; + mediacontrol_Exception *exception = NULL; + + if ( !PyArg_ParseTuple(args, "s", &psz_file) ) + return NULL; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_playlist_add_item(SELF->mc, psz_file, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } -static PyObject * MediaControl_playlist_clear(PyObject *self, - PyObject *args) +static PyObject * MediaControl_playlist_clear( PyObject *self, + PyObject *args) { - mediacontrol_Exception *exception = NULL; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_playlist_clear(SELF->mc, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Exception *exception = NULL; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_playlist_clear(SELF->mc, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } -static PyObject * MediaControl_playlist_get_list(PyObject *self, - PyObject *args) +static PyObject * MediaControl_playlist_get_list( PyObject *self, + PyObject *args ) { - PyObject *py_retval; - mediacontrol_Exception *exception = NULL; - mediacontrol_PlaylistSeq* pl; - int i_index; - int i_playlist_size; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - pl = mediacontrol_playlist_get_list(SELF->mc, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - i_playlist_size = pl->size; - - py_retval = PyTuple_New(i_playlist_size); - - for (i_index = 0 ; i_index < i_playlist_size ; i_index++) + PyObject *py_retval; + mediacontrol_Exception *exception = NULL; + mediacontrol_PlaylistSeq* pl; + int i_index; + int i_playlist_size; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + pl = mediacontrol_playlist_get_list(SELF->mc, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + i_playlist_size = pl->size; + + py_retval = PyList_New( i_playlist_size ); + + for (i_index = 0 ; i_index < i_playlist_size ; i_index++) { - PyTuple_SetItem(py_retval, i_index, Py_BuildValue("s", pl->data[i_index])); + PyList_SetItem( py_retval, i_index, + Py_BuildValue("s", pl->data[i_index] ) ); } - mediacontrol_PlaylistSeq__free(pl); + mediacontrol_PlaylistSeq__free(pl); - return py_retval; + return py_retval; } static PyObject * MediaControl_snapshot(PyObject *self, PyObject *args) { - mediacontrol_RGBPicture *retval = NULL; - mediacontrol_Exception* exception = NULL; - mediacontrol_Position *a_position = NULL; - PyObject *py_pos = NULL; - PyObject *py_obj = NULL; - - if( !PyArg_ParseTuple(args, "O", &py_pos)) - return NULL; - - a_position = position_py_to_c(py_pos); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - retval = mediacontrol_snapshot(SELF->mc, a_position, exception); - free(a_position); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - if( !retval ) { - Py_INCREF( Py_None ); - return Py_None; - } - - /* FIXME: create a real RGBPicture object */ - py_obj = PyDict_New(); - - PyDict_SetItemString(py_obj, "width", Py_BuildValue("i", retval->width)); - PyDict_SetItemString(py_obj, "height", Py_BuildValue("i", retval->height)); - PyDict_SetItemString(py_obj, "type", Py_BuildValue("i", retval->type)); - PyDict_SetItemString(py_obj, "data", Py_BuildValue("s#", retval->data, retval->size)); - - /* Py_INCREF(py_obj); */ - return py_obj; + mediacontrol_RGBPicture *retval = NULL; + mediacontrol_Exception* exception = NULL; + mediacontrol_Position *a_position = NULL; + PyObject *py_pos = NULL; + PyObject *py_obj = NULL; + + if( !PyArg_ParseTuple(args, "O", &py_pos)) + return NULL; + + a_position = position_py_to_c(py_pos); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + retval = mediacontrol_snapshot(SELF->mc, a_position, exception); + free( a_position ); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + if( !retval ) + { + Py_INCREF( Py_None ); + return Py_None; + } + + /* FIXME: create a real RGBPicture object */ + py_obj = PyDict_New(); + + PyDict_SetItemString(py_obj, "width", + Py_BuildValue("i", retval->width) ); + PyDict_SetItemString(py_obj, "height", + Py_BuildValue("i", retval->height) ); + PyDict_SetItemString(py_obj, "type", + Py_BuildValue("i", retval->type) ); + PyDict_SetItemString(py_obj, "data", + Py_BuildValue("s#", retval->data, retval->size) ); + + /* Py_INCREF(py_obj); */ + return py_obj; } static PyObject* MediaControl_display_text(PyObject *self, PyObject *args) -{ - mediacontrol_Exception* exception = NULL; - PyObject *py_begin, *py_end; - char* message; - mediacontrol_Position * begin; - mediacontrol_Position * end; - - if( !PyArg_ParseTuple(args, "sOO", &message, &py_begin, &py_end)) - return NULL; - - begin = position_py_to_c(py_begin); - end = position_py_to_c(py_end); - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_display_text(SELF->mc, message, begin, end, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - free(begin); - free(end); - - Py_INCREF(Py_None); - return Py_None; +{ + mediacontrol_Exception* exception = NULL; + PyObject *py_begin, *py_end; + char* message; + mediacontrol_Position * begin; + mediacontrol_Position * end; + + if( !PyArg_ParseTuple(args, "sOO", &message, &py_begin, &py_end)) + return NULL; + + begin = position_py_to_c(py_begin); + end = position_py_to_c(py_end); + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_display_text(SELF->mc, message, begin, end, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + free(begin); + free(end); + + Py_INCREF(Py_None); + return Py_None; } -static PyObject* MediaControl_get_stream_information(PyObject *self, PyObject *args) +static PyObject* MediaControl_get_stream_information( + PyObject *self, PyObject *args) { - mediacontrol_StreamInformation *retval = NULL; - mediacontrol_Exception* exception = NULL; - PyObject *py_obj; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - retval = mediacontrol_get_stream_information(SELF->mc, mediacontrol_MediaTime, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - py_obj = PyDict_New(); - - /* FIXME: create a real StreamInformation object */ - PyDict_SetItemString(py_obj, "status", Py_BuildValue("i", retval->streamstatus)); - PyDict_SetItemString(py_obj, "url", Py_BuildValue("s", retval->url)); - PyDict_SetItemString(py_obj, "position", Py_BuildValue("L", retval->position)); - PyDict_SetItemString(py_obj, "length", Py_BuildValue("L", retval->length)); - - free(retval->url); - free(retval); - - /* Py_INCREF(py_obj); */ - return py_obj; + mediacontrol_StreamInformation *retval = NULL; + mediacontrol_Exception* exception = NULL; + PyObject *py_obj; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + retval = mediacontrol_get_stream_information( + SELF->mc, mediacontrol_MediaTime, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + py_obj = PyDict_New(); + + /* FIXME: create a real StreamInformation object */ + PyDict_SetItemString(py_obj, "status", + Py_BuildValue("i", retval->streamstatus)); + PyDict_SetItemString(py_obj, "url", + Py_BuildValue("s", retval->url)); + PyDict_SetItemString(py_obj, "position", + Py_BuildValue("L", retval->position)); + PyDict_SetItemString(py_obj, "length", + Py_BuildValue("L", retval->length)); + + free(retval->url); + free(retval); + + /* Py_INCREF(py_obj); */ + return py_obj; } static PyObject* MediaControl_sound_set_volume(PyObject *self, PyObject *args) { - mediacontrol_Exception* exception = NULL; - unsigned short volume; - - if (!PyArg_ParseTuple(args, "H", &volume)) - return NULL; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_sound_set_volume(SELF->mc, volume, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; + mediacontrol_Exception* exception = NULL; + unsigned short volume; + + if (!PyArg_ParseTuple(args, "H", &volume)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_sound_set_volume(SELF->mc, volume, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; } static PyObject* MediaControl_sound_get_volume(PyObject *self, PyObject *args) { - mediacontrol_Exception* exception = NULL; - PyObject *py_retval; - unsigned short volume; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - volume=mediacontrol_sound_get_volume(SELF->mc, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - py_retval = Py_BuildValue("H", volume); - return py_retval; + mediacontrol_Exception* exception = NULL; + PyObject *py_retval; + unsigned short volume; + + Py_BEGIN_ALLOW_THREADS + MC_TRY; + volume=mediacontrol_sound_get_volume(SELF->mc, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + py_retval = Py_BuildValue("H", volume); + return py_retval; } static PyObject* MediaControl_set_visual(PyObject *self, PyObject *args) { - mediacontrol_Exception* exception = NULL; - WINDOWHANDLE visual; - - if (!PyArg_ParseTuple(args, "i", &visual)) - return NULL; - - Py_BEGIN_ALLOW_THREADS - MC_TRY; - mediacontrol_set_visual(SELF->mc, visual, exception); - Py_END_ALLOW_THREADS - MC_EXCEPT; - - Py_INCREF(Py_None); - return Py_None; -} + mediacontrol_Exception* exception = NULL; + WINDOWHANDLE visual; + if (!PyArg_ParseTuple(args, "i", &visual)) + return NULL; -/* Method table */ -static PyMethodDef MediaControl_methods[] = { - {"get_media_position", MediaControl_get_media_position, METH_VARARGS, "get_media_position(origin, key) -> Position Get current media position."}, - {"set_media_position", MediaControl_set_media_position, METH_VARARGS, "set_media_position(Position) Set media position"}, - {"start", MediaControl_start, METH_VARARGS, "start(Position) Start the player."}, - {"pause", MediaControl_pause, METH_VARARGS, "pause(Position) Pause the player."}, - {"resume", MediaControl_resume, METH_VARARGS, "resume(Position) Resume the player"}, - {"stop", MediaControl_stop, METH_VARARGS, "stop(Position) Stop the player"}, - {"exit", MediaControl_exit, METH_VARARGS, "exit() Exit the player"}, - {"playlist_add_item", MediaControl_playlist_add_item, METH_VARARGS, "playlist_add_item(str) Add an item to the playlist"}, - {"playlist_get_list", MediaControl_playlist_get_list, METH_VARARGS, "playlist_get_list() -> list Get the contents of the playlist"}, - {"playlist_clear", MediaControl_playlist_clear, METH_VARARGS, "clear() Clear the playlist."}, - {"snapshot", MediaControl_snapshot, METH_VARARGS, "snapshot(Position) -> dict Take a snapshot"}, - {"display_text", MediaControl_display_text, METH_VARARGS, "display_text(str, Position, Position) Display a text on the video"}, - {"get_stream_information", MediaControl_get_stream_information, METH_VARARGS, "get_stream_information() -> dict Get information about the stream"}, - {"sound_get_volume", MediaControl_sound_get_volume, METH_VARARGS, "sound_get_volume() -> int Get the volume"}, - {"sound_set_volume", MediaControl_sound_set_volume, METH_VARARGS, "sound_set_volume(int) Set the volume"}, - {"set_visual", MediaControl_set_visual, METH_VARARGS, "set_visual(int) Set the embedding window visual ID"}, - {NULL, NULL, 0, NULL}, + Py_BEGIN_ALLOW_THREADS + MC_TRY; + mediacontrol_set_visual(SELF->mc, visual, exception); + Py_END_ALLOW_THREADS + MC_EXCEPT; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyMethodDef MediaControl_methods[] = +{ + {"get_media_position", MediaControl_get_media_position, METH_VARARGS, + "get_media_position(origin, key) -> Position Get current media position." }, + { "set_media_position", MediaControl_set_media_position, METH_VARARGS, + "set_media_position(Position) Set media position" }, + { "start", MediaControl_start, METH_VARARGS, + "start(Position) Start the player." }, + { "pause", MediaControl_pause, METH_VARARGS, + "pause(Position) Pause the player." }, + { "resume", MediaControl_resume, METH_VARARGS, + "resume(Position) Resume the player" }, + { "stop", MediaControl_stop, METH_VARARGS, + "stop(Position) Stop the player" }, + { "exit", MediaControl_exit, METH_VARARGS, + "exit() Exit the player" }, + { "playlist_add_item", MediaControl_playlist_add_item, METH_VARARGS, + "playlist_add_item(str) Add an item to the playlist" }, + { "playlist_get_list", MediaControl_playlist_get_list, METH_VARARGS, + "playlist_get_list() -> list Get the contents of the playlist" }, + { "playlist_clear", MediaControl_playlist_clear, METH_VARARGS, + "clear() Clear the playlist." }, + { "snapshot", MediaControl_snapshot, METH_VARARGS, + "snapshot(Position) -> dict Take a snapshot" }, + { "display_text", MediaControl_display_text, METH_VARARGS, + "display_text(str, Position, Position) Display a text on the video" }, + { "get_stream_information", MediaControl_get_stream_information, + METH_VARARGS, + "get_stream_information() -> dict Get information about the stream"}, + { "sound_get_volume", MediaControl_sound_get_volume, METH_VARARGS, + "sound_get_volume() -> int Get the volume" }, + { "sound_set_volume", MediaControl_sound_set_volume, METH_VARARGS, + "sound_set_volume(int) Set the volume" }, + { "set_visual", MediaControl_set_visual, METH_VARARGS, + "set_visual(int) Set the embedding window visual ID" }, + { NULL, NULL, 0, NULL }, }; -static PyTypeObject MediaControl_Type = { +static PyTypeObject MediaControl_Type = +{ PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "vlc.MediaControl", /*tp_name*/ @@ -681,12 +1231,12 @@ static PyTypeObject MediaControl_Type = { 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ "Control of a VLC instance.", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ MediaControl_methods, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ @@ -700,542 +1250,125 @@ static PyTypeObject MediaControl_Type = { MediaControl_new, /* tp_new */ }; -#ifdef VLCOBJECT_SUPPORT - -/***** vlcObject definitions *****/ -/* constructor : create the new type, thread and init */ -static PyObject *vlcObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) -{ - vlcObject *self; - vlc_object_t *p_object; - int i_id; - - self = PyObject_New(vlcObject, &vlcObject_Type); +/*********************************************************************** + * Position + ***********************************************************************/ - if ( !PyArg_ParseTuple(args, "i", &i_id) ) - return NULL; - /* Maybe we were already initialized */ - p_object = (vlc_object_t*)vlc_current_object(i_id); - - if (! p_object) - { - /* Try to initialize */ - i_id = VLC_Create(); - p_object = (vlc_object_t*)vlc_current_object(i_id); - } - - if (! p_object) - { - PyErr_SetString(PyExc_StandardError, "Unable to get object."); - return NULL; - } - - self->p_object = p_object; - - Py_INCREF(self); /* Ah bon ? */ - return (PyObject *)self; -} - -static void -vlcObject_dealloc(PyObject *self) +static int PyPosition_init( PyPosition *self, PyObject *args, PyObject *kwds ) { - vlc_object_release(VLCSELF->p_object); - PyMem_DEL(self); + self->origin = mediacontrol_AbsolutePosition; + self->key = mediacontrol_MediaTime; + self->value = 0; + return 0; } -static PyObject * vlcObject_find_object(PyObject *self, - PyObject *args) +mediacontrol_PositionKey positionKey_py_to_c( PyObject * py_key ) { - vlcObject *retval; - vlc_object_t *p_obj; - char *psz_name; - int i_object_type; - - if ( !PyArg_ParseTuple(args, "s", &psz_name) ) - return NULL; - - /* psz_name is in - (aout, decoder, input, httpd, intf, playlist, root, vlc, vout) - */ - switch (psz_name[0]) - { - case 'a': - i_object_type = VLC_OBJECT_AOUT; - break; - case 'd': - i_object_type = VLC_OBJECT_DECODER; - break; - case 'h': - i_object_type = VLC_OBJECT_HTTPD; - break; - case 'i': - if (strlen(psz_name) < 3) - i_object_type = VLC_OBJECT_INTF; - else if (psz_name[2] == 't') - i_object_type = VLC_OBJECT_INTF; - else - i_object_type = VLC_OBJECT_INPUT; - break; - case 'p': - i_object_type = VLC_OBJECT_PLAYLIST; - break; - case 'r': - i_object_type = VLC_OBJECT_ROOT; - break; - case 'v': - if (strlen(psz_name) < 3) - i_object_type = VLC_OBJECT_VLC; - else if (psz_name[1] == 'l') - i_object_type = VLC_OBJECT_VLC; - else - i_object_type = VLC_OBJECT_VOUT; - break; - default: - /* FIXME: raise an exception */ - return Py_None; - } - - p_obj = vlc_object_find( VLCSELF->p_object, i_object_type, FIND_ANYWHERE ); - - if (! p_obj) - { - Py_INCREF(Py_None); - return Py_None; - } - - retval = PyObject_New(vlcObject, &vlcObject_Type); - - retval->p_object = p_obj; - - return (PyObject *)retval; -} - -static PyObject * vlcObject_info(PyObject *self, - PyObject *args) -{ - PyObject *retval; - vlc_object_t *p_obj; - - p_obj = VLCSELF->p_object; - - /* Return information about the object as a dict. */ - retval = PyDict_New(); - - PyDict_SetItemString(retval, "object-id", Py_BuildValue("l", p_obj->i_object_id)); - PyDict_SetItemString(retval, "object-type", Py_BuildValue("s", p_obj->psz_object_type)); - PyDict_SetItemString(retval, "object-name", Py_BuildValue("s", p_obj->psz_object_name)); - PyDict_SetItemString(retval, "thread", PyBool_FromLong(p_obj->b_thread)); - PyDict_SetItemString(retval, "thread-id", PyLong_FromLongLong(p_obj->thread_id)); - PyDict_SetItemString(retval, "refcount", PyInt_FromLong(p_obj->i_refcount)); - - return retval; -} - -static PyObject * vlcObject_find_id(PyObject *self, - PyObject *args) -{ - vlcObject *retval; - vlc_object_t* p_object; - int i_id; + mediacontrol_PositionKey key_position = mediacontrol_MediaTime; + int key; - if ( !PyArg_ParseTuple(args, "i", &i_id) ) + if( !PyArg_Parse( py_key, "i", &key ) ) { - PyErr_SetString(PyExc_StandardError, "Error: no id was given.\n"); - return Py_None; + PyErr_SetString (MediaControl_InternalException, "Invalid key value"); + return key_position; } - p_object = (vlc_object_t*)vlc_current_object(i_id); - - if (! p_object) + switch (key) { - Py_INCREF(Py_None); - return Py_None; + case 0: key = mediacontrol_ByteCount; break; + case 1: key = mediacontrol_SampleCount; break; + case 2: key = mediacontrol_MediaTime; break; } - - retval = PyObject_NEW(vlcObject, &vlcObject_Type); - - retval->p_object = p_object; - - return (PyObject *)retval; + return key_position; } -/* Do a var_Get call on the object. Parameter: the variable name. */ -/* FIXME: We should make them attributes */ -static PyObject * vlcObject_var_get(PyObject *self, - PyObject *args) +mediacontrol_PositionOrigin positionOrigin_py_to_c( PyObject * py_origin ) { - PyObject *retval; - vlc_value_t value; - char *psz_name; - int i_type; - - if ( !PyArg_ParseTuple(args, "s", &psz_name) ) - { - PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; - } + mediacontrol_PositionOrigin origin_position = + mediacontrol_AbsolutePosition; + int origin; - if( var_Get( VLCSELF->p_object, psz_name, &value ) != VLC_SUCCESS ) + if(!PyArg_Parse(py_origin,"i", &origin)) { - PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; + PyErr_SetString( MediaControl_InternalException, + "Invalid origin value"); + return origin_position; } - - i_type = var_Type (VLCSELF->p_object, psz_name); - switch (i_type) + switch (origin) { - case VLC_VAR_VOID : - retval = PyString_FromString("A void variable"); - break; - case VLC_VAR_BOOL : - retval = PyBool_FromLong(value.b_bool); - break; - case VLC_VAR_INTEGER : - retval = PyInt_FromLong((long)value.i_int); - break; - case VLC_VAR_HOTKEY : - retval = PyString_FromFormat("A hotkey variable (%d)", value.i_int); - break; - case VLC_VAR_FILE : - case VLC_VAR_STRING : - case VLC_VAR_DIRECTORY : - case VLC_VAR_VARIABLE : - retval = PyString_FromString(value.psz_string); - break; - case VLC_VAR_MODULE : - retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type); - ((vlcObject*)retval)->p_object = value.p_object; - break; - case VLC_VAR_FLOAT : - retval = PyFloat_FromDouble((double)value.f_float); - break; - case VLC_VAR_TIME : - retval = PyLong_FromLongLong(value.i_time); - break; - case VLC_VAR_ADDRESS : - retval = PyString_FromString("A VLC address (not handled yet)"); - break; - case VLC_VAR_LIST : - retval = PyString_FromString("A VLC list (not handled yet)"); - break; - case VLC_VAR_MUTEX : - retval = PyString_FromString("A mutex"); - break; - default: - retval = Py_None; + case 0: origin_position = mediacontrol_AbsolutePosition; break; + case 1: origin_position = mediacontrol_RelativePosition; break; + case 2: origin_position = mediacontrol_ModuloPosition; break; } - Py_INCREF(retval); - return retval; + return origin_position; } -static PyObject * vlcObject_var_type(PyObject *self, - PyObject *args) +/* Methods for transforming the Position Python object to Position structure*/ +mediacontrol_Position* position_py_to_c( PyObject * py_position ) { - char *psz_name; - PyObject *retval; - int i_type; - - if ( !PyArg_ParseTuple(args, "s", &psz_name)) - { - PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; - } + mediacontrol_Position * a_position = NULL; + PyPosition *pos = (PyPosition*)py_position; - i_type = var_Type(VLCSELF->p_object, psz_name); - - switch (i_type) + a_position = (mediacontrol_Position*)malloc(sizeof(mediacontrol_Position)); + if (! a_position) { - case VLC_VAR_VOID : - retval = PyString_FromString("Void"); - break; - case VLC_VAR_BOOL : - retval = PyString_FromString("Boolean"); - break; - case VLC_VAR_INTEGER : - retval = PyString_FromString("Integer"); - break; - case VLC_VAR_HOTKEY : - retval = PyString_FromString("Hotkey"); - break; - case VLC_VAR_FILE : - retval = PyString_FromString("File"); - break; - case VLC_VAR_STRING : - retval = PyString_FromString("String"); - break; - case VLC_VAR_DIRECTORY : - retval = PyString_FromString("Directory"); - break; - case VLC_VAR_VARIABLE : - retval = PyString_FromString("Variable"); - break; - case VLC_VAR_MODULE : - retval = PyString_FromString("Module"); - break; - case VLC_VAR_FLOAT : - retval = PyString_FromString("Float"); - break; - case VLC_VAR_TIME : - retval = PyString_FromString("Time"); - break; - case VLC_VAR_ADDRESS : - retval = PyString_FromString("Address"); - break; - case VLC_VAR_LIST : - retval = PyString_FromString("List"); - break; - case VLC_VAR_MUTEX : - retval = PyString_FromString("Mutex"); - break; - default: - retval = PyString_FromString("Unknown"); + PyErr_SetString(PyExc_MemoryError, "Out of memory"); + return NULL; } - return retval; -} -/* Do a var_Set call on the object. Parameter: the variable name. */ -/* FIXME: We should make them attributes */ -static PyObject * vlcObject_var_set(PyObject *self, - PyObject *args) -{ - vlc_value_t value; - char *psz_name; - PyObject *py_value; - int i_type; - vlc_object_t *p_obj; - - if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) ) + if (PyObject_IsInstance(py_position, (PyObject*)&PyPosition_Type)) { - PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; + a_position->origin = pos->origin; + a_position->key = pos->key; + a_position->value = pos->value; } - - p_obj = VLCSELF->p_object; - i_type = var_Type(p_obj, psz_name); - - switch (i_type) + else { - case VLC_VAR_VOID : - break; - case VLC_VAR_BOOL : - value.b_bool = PyInt_AsLong(py_value); - break; - case VLC_VAR_INTEGER : - case VLC_VAR_HOTKEY : - value.i_int = PyInt_AsLong(py_value); - break; - case VLC_VAR_FILE : - case VLC_VAR_STRING : - case VLC_VAR_DIRECTORY : - case VLC_VAR_VARIABLE : - value.psz_string = strdup(PyString_AsString(py_value)); - break; - case VLC_VAR_MODULE : - /* FIXME: we should check the PyObject type and get its p_object */ - value.p_object = ((vlcObject*)p_obj)->p_object; - break; - case VLC_VAR_FLOAT : - value.f_float = PyFloat_AsDouble(py_value); - break; - case VLC_VAR_TIME : - value.i_time = PyLong_AsLongLong(py_value); - break; - case VLC_VAR_ADDRESS : - value.p_address = (char*)PyLong_AsVoidPtr(py_value); - break; - case VLC_VAR_LIST : - /* FIXME */ - value.p_list = NULL; - break; - case VLC_VAR_MUTEX : - break; + /* Feature: if we give an integer, it will be considered as + a relative position in mediatime */ + a_position->origin = mediacontrol_RelativePosition; + a_position->key = mediacontrol_MediaTime; + a_position->value = PyLong_AsLongLong(py_position); } - - var_Set(p_obj, psz_name, value); - - Py_INCREF(Py_None); - return Py_None; -} - -static PyObject * vlcObject_var_list(PyObject *self, - PyObject *args) -{ - PyObject *retval; - int i_size; - int i_index; - - i_size = VLCSELF->p_object->i_vars; - retval = PyTuple_New(i_size); - - for (i_index = 0 ; i_index < i_size ; i_index++) - { - PyTuple_SetItem(retval, i_index, - Py_BuildValue("s", VLCSELF->p_object->p_vars[i_index].psz_name)); - } - - /* Py_INCREF(retval); */ - return retval; + return a_position; } -/* Do a config_Get call on the object. Parameter: the variable name. */ -static PyObject * vlcObject_config_get(PyObject *self, - PyObject *args) +PyPosition* position_c_to_py(mediacontrol_Position *position) { - PyObject *retval; - vlc_value_t value; - char *psz_name; - module_config_t *p_config; - - if ( !PyArg_ParseTuple(args, "s", &psz_name) ) - { - PyErr_SetString(PyExc_StandardError, "Error: no config variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; - } - - p_config = config_FindConfig( VLCSELF->p_object, psz_name ); + PyPosition* py_retval; - if( !p_config ) - { - PyErr_SetString(PyExc_StandardError, "Error: config variable does not exist.\n"); - Py_INCREF(Py_None); - return Py_None; - } - - switch (p_config->i_type) - { - case CONFIG_ITEM_BOOL : - retval = PyBool_FromLong(p_config->i_value); - break; - case CONFIG_ITEM_INTEGER : - retval = PyInt_FromLong((long)p_config->i_value); - break; - case CONFIG_ITEM_KEY : - retval = PyString_FromFormat("A hotkey variable (%d)", p_config->i_value); - break; - case CONFIG_ITEM_FILE : - case CONFIG_ITEM_STRING : - case CONFIG_ITEM_DIRECTORY : - case CONFIG_ITEM_MODULE : - vlc_mutex_lock( p_config->p_lock ); - if( p_config->psz_value ) - retval = PyString_FromString( p_config->psz_value ); - else - retval = PyString_FromString( "" ); - vlc_mutex_unlock( p_config->p_lock ); - break; - retval = (PyObject*)PyObject_New(vlcObject, &vlcObject_Type); - ((vlcObject*)retval)->p_object = value.p_object; - break; - case CONFIG_ITEM_FLOAT : - retval = PyFloat_FromDouble((double)p_config->f_value); - break; - default: - retval = Py_None; - Py_INCREF(retval); - } + py_retval = PyObject_New(PyPosition, &PyPosition_Type); + py_retval->origin = position->origin; + py_retval->key = position->key; + py_retval->value = position->value; - return retval; + return py_retval; } -/* Do a var_Set call on the object. Parameter: the variable name. */ -/* FIXME: We should make them attributes */ -static PyObject * vlcObject_config_set(PyObject *self, - PyObject *args) +static PyMethodDef PyPosition_methods[] = { - char *psz_name; - PyObject *py_value; - vlc_object_t *p_obj; - module_config_t *p_config; - - - if ( !PyArg_ParseTuple(args, "sO", &psz_name, &py_value) ) - { - PyErr_SetString(PyExc_StandardError, "Error: no variable name was given.\n"); - Py_INCREF(Py_None); - return Py_None; - } - - p_obj = VLCSELF->p_object; - p_config = config_FindConfig( p_obj, psz_name ); - /* sanity checks */ - if( !p_config ) - { - PyErr_SetString(PyExc_StandardError, "Error: option does not exist.\n"); - Py_INCREF(Py_None); - return Py_None; - } - - switch (p_config->i_type) - { - case CONFIG_ITEM_BOOL : - case CONFIG_ITEM_INTEGER : - case CONFIG_ITEM_KEY : - config_PutInt(p_obj, psz_name, PyInt_AsLong(py_value)); - break; - case CONFIG_ITEM_FILE : - case CONFIG_ITEM_STRING : - case CONFIG_ITEM_DIRECTORY : - case CONFIG_ITEM_MODULE : - config_PutPsz(p_obj, psz_name, PyString_AsString(py_value)); - break; - case CONFIG_ITEM_FLOAT : - config_PutFloat(p_obj, psz_name, PyFloat_AsDouble(py_value)); - break; - } - Py_INCREF(Py_None); - return Py_None; -} + { NULL } /* Sentinel */ +}; -static PyObject * vlcObject_children(PyObject *self, - PyObject *args) +static PyMemberDef PyPosition_members[] = { - PyObject *retval; - int i_size; - int i_index; - - i_size = VLCSELF->p_object->i_children; - retval = PyTuple_New(i_size); - - for (i_index = 0 ; i_index < i_size ; i_index++) - { - PyTuple_SetItem(retval, i_index, - Py_BuildValue("i", VLCSELF->p_object->pp_children[i_index]->i_object_id)); - } - - /* Py_INCREF(retval); */ - return retval; -} - -/* Method table */ -static PyMethodDef vlcObject_methods[] = { - {"get", vlcObject_var_get, METH_VARARGS, "get(str) -> value Get a variable value."}, - {"set", vlcObject_var_set, METH_VARARGS, "set(str, value) Set a variable value"}, - {"config_get", vlcObject_config_get, METH_VARARGS, "get(str) -> value Get an option value."}, - {"config_set", vlcObject_config_set, METH_VARARGS, "set(str, value) Set an option value"}, - {"type", vlcObject_var_type, METH_VARARGS, "type(str) -> str Get a variable type"}, - {"list", vlcObject_var_list, METH_VARARGS, "list() List the available variables"}, - {"children", vlcObject_children, METH_VARARGS, "children() List the children ids"}, - {"find_object", vlcObject_find_object, METH_VARARGS, "find_object(str) -> Object Find the object of a given type.\n\nAvailable types are : aout, decoder, input, httpd, intf, playlist, root, vlc, vout"}, - {"find_id", vlcObject_find_id, METH_VARARGS, "find_id(int) -> Object Find an object by id"}, - {"info", vlcObject_info, METH_VARARGS, "info() -> dict Return information about the object"}, - {NULL, NULL, 0, NULL}, + { "origin", T_INT, offsetof(PyPosition, origin), 0, "Position origin" }, + { "key", T_INT, offsetof(PyPosition, key), 0, "Position key" }, + { "value", T_ULONG, offsetof(PyPosition, value), 0, "Position value" }, + { NULL } /* Sentinel */ }; -static PyTypeObject vlcObject_Type = { +static PyTypeObject PyPosition_Type = +{ PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ - "vlc.Object", /*tp_name*/ - sizeof(vlcObject_Type), /*tp_basicsize*/ + "vlc.Position", /*tp_name*/ + sizeof(PyPosition_Type), /*tp_basicsize*/ 0, /*tp_itemsize*/ - (destructor)vlcObject_dealloc, /*tp_dealloc*/ + 0, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ @@ -1251,112 +1384,22 @@ static PyTypeObject vlcObject_Type = { 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ - "Explore VLC objects.", /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - vlcObject_methods, /* tp_methods */ - 0, /* tp_members */ + "Represent a Position with origin, key and value", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PyPosition_methods, /* tp_methods */ + PyPosition_members, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - 0, /* tp_init */ + (initproc)PyPosition_init, /* tp_init */ 0, /* tp_alloc */ - vlcObject_new, /* tp_new */ -}; - -/***** End of vlcObject definitions *****/ -#endif - -/* Module functions */ - -static PyMethodDef vlc_methods[] = { - {NULL} /* Sentinel */ + 0, /* tp_new */ }; - - -#ifndef vlcMODINIT_FUNC /* declarations for DLL import/export */ -#define vlcMODINIT_FUNC void -#endif -vlcMODINIT_FUNC -initvlc(void) -{ - PyObject* m; - - PyPosition_Type.tp_new = PyType_GenericNew; - PyPosition_Type.tp_alloc = PyType_GenericAlloc; - - if (PyType_Ready(&PyPosition_Type) < 0) - return; - if (PyType_Ready(&MediaControl_Type) < 0) - return; -#ifdef VLCOBJECT_SUPPORT - if (PyType_Ready(&vlcObject_Type) < 0) - return; -#endif - - /* PyEval_InitThreads(); */ - - /* Have a look at - http://base.bel-epa.com/pyapache/Python/MySQL-python/MySQL-python-0.3.0/_mysqlmodule.c */ - - m = Py_InitModule3("vlc", vlc_methods, "VideoLan Client embedding module."); - - /* Exceptions */ - MediaControl_InternalException = PyErr_NewException("vlc.InternalException", NULL, NULL); - PyModule_AddObject(m, "InternalException", MediaControl_InternalException); - - MediaControl_PositionKeyNotSupported = PyErr_NewException("vlc.PositionKeyNotSupported", - NULL, NULL); - PyModule_AddObject(m, "PositionKeyNotSupported", MediaControl_PositionKeyNotSupported); - - MediaControl_PositionOriginNotSupported=PyErr_NewException("vlc.InvalidPosition", NULL, NULL); - PyModule_AddObject(m, "PositionOriginNotSupported", MediaControl_PositionOriginNotSupported); - - MediaControl_InvalidPosition = PyErr_NewException("vlc.InvalidPosition", NULL, NULL); - PyModule_AddObject(m, "InvalidPosition", MediaControl_InvalidPosition); - - MediaControl_PlaylistException = PyErr_NewException("vlc.PlaylistException", NULL, NULL); - PyModule_AddObject(m, "PlaylistException", MediaControl_PlaylistException); - - /* Types */ - Py_INCREF(&PyPosition_Type); - PyModule_AddObject(m, "Position", (PyObject *)&PyPosition_Type); - Py_INCREF(&MediaControl_Type); - PyModule_AddObject(m, "MediaControl", (PyObject *)&MediaControl_Type); -#ifdef VLCOBJECT_SUPPORT - Py_INCREF(&vlcObject_Type); - PyModule_AddObject(m, "Object", (PyObject *)&vlcObject_Type); -#endif - - /* Constants */ - PyModule_AddIntConstant(m, "AbsolutePosition", mediacontrol_AbsolutePosition); - PyModule_AddIntConstant(m, "RelativePosition", mediacontrol_RelativePosition); - PyModule_AddIntConstant(m, "ModuloPosition", mediacontrol_ModuloPosition); - - PyModule_AddIntConstant(m, "ByteCount", mediacontrol_ByteCount); - PyModule_AddIntConstant(m, "SampleCount", mediacontrol_SampleCount); - PyModule_AddIntConstant(m, "MediaTime", mediacontrol_MediaTime); - - PyModule_AddIntConstant(m, "PlayingStatus", mediacontrol_PlayingStatus); - PyModule_AddIntConstant(m, "PauseStatus", mediacontrol_PauseStatus); - PyModule_AddIntConstant(m, "ForwardStatus", mediacontrol_ForwardStatus); - PyModule_AddIntConstant(m, "BackwardStatus", mediacontrol_BackwardStatus); - PyModule_AddIntConstant(m, "InitStatus", mediacontrol_InitStatus); - PyModule_AddIntConstant(m, "EndStatus", mediacontrol_EndStatus); - PyModule_AddIntConstant(m, "UndefinedStatus", mediacontrol_UndefinedStatus); - - -} - -/* Make libpostproc happy... */ -void * fast_memcpy(void * to, const void * from, size_t len) -{ - return memcpy(to, from, len); -} diff --git a/bindings/python/vlcglue.h b/bindings/python/vlcglue.h new file mode 100644 index 0000000000..db60aca4e3 --- /dev/null +++ b/bindings/python/vlcglue.h @@ -0,0 +1,123 @@ +/***************************************************************************** + * vlcglue.h: Main header for the Python binding + ***************************************************************************** + * Copyright (C) 1998-2004 the VideoLAN team + * $Id: vlc.c 12667 2005-09-25 10:19:26Z zorglub $ + * + * Authors: Olivier Aubert <oaubert at bat710.univ-lyon1.fr> + * Cl�ment Stenac <zorglub@videolan.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + *****************************************************************************/ + +#include <Python.h> +#include "structmember.h" + +/* Undefine the following define to disable low-level vlc Object support */ +#define VLCOBJECT_SUPPORT 0 + +#define __VLC__ + +#include <stdio.h> +#include <vlc/control.h> + +#define SELF ((MediaControl*)self) + +/********************************************************************** + * Exceptions handling + **********************************************************************/ + +#define MC_TRY exception=mediacontrol_exception_init(exception) + +#define MC_EXCEPT \ + if (exception->code) { \ + PyObject *py_exc = MediaControl_InternalException; \ + switch (exception->code) { \ + case mediacontrol_InternalException: \ + py_exc = MediaControl_InternalException; \ + break; \ + case mediacontrol_PlaylistException: \ + py_exc = MediaControl_PlaylistException; \ + break; \ + case mediacontrol_InvalidPosition: \ + py_exc = MediaControl_InvalidPosition; \ + break; \ + case mediacontrol_PositionKeyNotSupported: \ + py_exc = MediaControl_PositionKeyNotSupported; \ + break; \ + case mediacontrol_PositionOriginNotSupported: \ + py_exc = MediaControl_PositionOriginNotSupported; \ + break; \ + } \ + PyErr_SetString(py_exc, exception->message); \ + mediacontrol_exception_free(exception); \ + return NULL; \ + } else { mediacontrol_exception_free(exception); } + +PyObject *MediaControl_InternalException; +PyObject *MediaControl_PositionKeyNotSupported; +PyObject *MediaControl_PositionOriginNotSupported; +PyObject *MediaControl_InvalidPosition; +PyObject *MediaControl_PlaylistException; + +/********************************************************************** + * VLC Object + **********************************************************************/ +#ifdef VLCOBJECT_SUPPORT + +#define VLCSELF ((vlcObject*)self) + +/********************************************************************** + * VLCObject Object + **********************************************************************/ +typedef struct +{ + PyObject_HEAD + vlc_object_t* p_object; + int b_released; +} vlcObject; + +staticforward PyTypeObject vlcObject_Type; + +#endif + +/********************************************************************** + * MediaControl Object + **********************************************************************/ +typedef struct +{ + PyObject_HEAD + mediacontrol_Instance* mc; +}MediaControl; + +staticforward PyTypeObject MediaControl_Type; + +/********************************************************************** + * Position Object + **********************************************************************/ +typedef struct +{ + PyObject_HEAD + int origin; + int key; + long long value; +} PyPosition; + +staticforward PyTypeObject PyPosition_Type; + +mediacontrol_PositionKey positionKey_py_to_c( PyObject * py_key ); +mediacontrol_PositionOrigin positionOrigin_py_to_c( PyObject * py_origin ); +mediacontrol_Position* position_py_to_c( PyObject * py_position ); +PyPosition* position_c_to_py(mediacontrol_Position *position); diff --git a/src/audio_output/output.c b/src/audio_output/output.c index 5cee853dc2..5df0c88a7b 100644 --- a/src/audio_output/output.c +++ b/src/audio_output/output.c @@ -186,7 +186,7 @@ int aout_OutputNew( aout_instance_t * p_aout, p_aout->mixer.mixer.i_format = p_format->i_format; } - aout_FormatPrint( p_aout, "mixer", &p_aout->output.output ); + aout_FormatPrint( p_aout, "mixer", &p_aout->mixer.mixer ); /* Create filters. */ p_aout->output.i_nb_filters = 0; diff --git a/src/control/core.c b/src/control/core.c index 7185554c72..e763f436d5 100644 --- a/src/control/core.c +++ b/src/control/core.c @@ -74,7 +74,8 @@ mediacontrol_Instance* mediacontrol_new_from_object( vlc_object_t* p_object, retval->vlc_object_id = p_vlc->i_object_id; /* We can keep references on these, which should not change. Is it true ? */ - retval->p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); + retval->p_playlist = vlc_object_find( p_vlc, + VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); retval->p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_ANYWHERE ); if( ! retval->p_playlist || ! retval->p_intf ) @@ -272,7 +273,8 @@ mediacontrol_playlist_add_item( mediacontrol_Instance *self, return; } - playlist_Add( self->p_playlist, psz_file, psz_file , PLAYLIST_REPLACE, 0 ); + playlist_Add( self->p_playlist, psz_file, psz_file , PLAYLIST_INSERT, + PLAYLIST_END ); } void diff --git a/src/control/init.c b/src/control/init.c index 5ea73bc975..f0836a82d6 100644 --- a/src/control/init.c +++ b/src/control/init.c @@ -62,7 +62,8 @@ mediacontrol_Instance* mediacontrol_new( char** args, mediacontrol_Exception *ex retval->vlc_object_id = p_vlc_id; /* We can keep references on these, which should not change. Is it true ? */ - retval->p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); + retval->p_playlist = vlc_object_find( p_vlc, + VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); retval->p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_ANYWHERE ); if( ! retval->p_playlist || ! retval->p_intf ) @@ -71,16 +72,19 @@ mediacontrol_Instance* mediacontrol_new( char** args, mediacontrol_Exception *ex exception->message = strdup( "No available interface" ); return NULL; } + + return retval; }; void mediacontrol_exit( mediacontrol_Instance *self ) { - /* + vlc_object_release( (vlc_object_t* )self->p_playlist ); vlc_object_release( (vlc_object_t* )self->p_intf ); - */ + vlc_object_release( (vlc_object_t*)self->p_vlc ); + VLC_CleanUp( self->vlc_object_id ); VLC_Destroy( self->vlc_object_id ); } -- 2.25.4