Changeset 8490 for branches/jingle

Show
Ignore:
Timestamp:
08/12/07 02:16:54 (16 months ago)
Author:
liori
Message:

Jingle: better farsight wrappers

Location:
branches/jingle/src/common
Files:
3 modified

Legend:

Unmodified
Added
Removed

  • branches/jingle/src/common/farsight/farsight.defs

    r8485 r8490  
    122122    '("int" "id") 
    123123    '("const-char*" "encoding_name") 
    124     '("FarsightMediaType" "media_type") 
     124    '("int" "media_type") 
    125125    '("guint" "clock_rate") 
    126126  ) 
    … …  
    206206  (of-object "FarsightStream") 
    207207  (c-name "farsight_stream_get_media_type") 
    208   (return-type "FarsightMediaType") 
     208  (return-type "int") 
    209209) 
    210210 
    … …  
    363363  (of-object "FarsightStream") 
    364364  (c-name "farsight_stream_get_state") 
    365   (return-type "FarsightStreamState") 
     365  (return-type "int") 
    366366) 
    367367 
    … …  
    369369  (of-object "FarsightStream") 
    370370  (c-name "farsight_stream_get_direction") 
    371   (return-type "FarsightStreamDirection") 
     371  (return-type "int") 
    372372) 
    373373 
    … …  
    375375  (of-object "FarsightStream") 
    376376  (c-name "farsight_stream_get_current_direction") 
    377   (return-type "FarsightStreamDirection") 
    378 ) 
    379  
    380 (define-method get_media_type 
    381   (of-object "FarsightStream") 
    382   (c-name "farsight_stream_get_media_type") 
    383   (return-type "FarsightMediaType") 
     377  (return-type "int") 
    384378) 
    385379 
    … …  
    425419  (return-type "none") 
    426420  (parameters 
    427     '("FarsightStreamError" "err") 
     421    '("int" "err") 
    428422    '("const-gchar*" "mesg") 
    429423  ) 
    … …  
    469463  (return-type "none") 
    470464  (parameters 
    471     '("FarsightStreamState" "state") 
    472     '("FarsightStreamDirection" "direction") 
     465    '("int" "state") 
     466    '("int" "direction") 
    473467  ) 
    474468) 

  • branches/jingle/src/common/farsight/farsight.override

    r8489 r8490  
    77#include <farsight/farsight-transport.h> 
    88 
    9 #define GetString(name) PyString_AsString(PyMapping_GetItemString(item, name)) 
    10 #define GetLong(name)   PyInt_AsLong(PyMapping_GetItemString(item, name)) 
    11 #define GetFloat(name)  PyFloat_AsDouble(PyMapping_GetItemString(item, name)) 
     9/* functions to put data into dict */ 
     10inline static void insert_long_into_dict(PyObject* dict, char* key, long value) { 
     11        PyObject* item=PyInt_FromLong(value); 
     12        PyDict_SetItemString(dict, key, item); 
     13        Py_DECREF(item); 
     14} 
     15 
     16inline static void insert_str_into_dict(PyObject* dict, char* key, const char* value) { 
     17        if (!value) return; 
     18        PyObject* item=PyString_FromString(value); 
     19        PyDict_SetItemString(dict, key, item); 
     20        Py_DECREF(item); 
     21} 
     22 
     23inline static void insert_double_into_dict(PyObject* dict, char* key, double value) { 
     24        PyObject* item=PyFloat_FromDouble(value); 
     25        PyDict_SetItemString(dict, key, item); 
     26        Py_DECREF(item); 
     27} 
     28 
     29static PyObject* farsight_transport_info_to_dict(FarsightTransportInfo* fti) { 
     30        PyObject* dict = PyDict_New(); 
     31 
     32        insert_str_into_dict    (dict, "candidate_id",  fti->candidate_id); 
     33        insert_long_into_dict   (dict, "component",     fti->component); 
     34        insert_str_into_dict    (dict, "ip",            fti->ip); 
     35        insert_long_into_dict   (dict, "port",          fti->port); 
     36        insert_long_into_dict   (dict, "proto",         fti->proto); 
     37        insert_str_into_dict    (dict, "proto_subtype", fti->proto_subtype); 
     38        insert_str_into_dict    (dict, "proto_profile", fti->proto_profile); 
     39        insert_double_into_dict (dict, "preference",    fti->preference); 
     40        insert_long_into_dict   (dict, "type",          fti->type); 
     41        insert_str_into_dict    (dict, "username",      fti->username); 
     42        insert_str_into_dict    (dict, "password",      fti->password); 
     43 
     44        return dict; 
     45} 
    1246 
    1347static PyObject* farsight_codec_to_dict(FarsightCodec* fc) { 
    1448        PyObject* dict = PyDict_New(); 
    15         PyObject* item; 
    16  
    17         PyDict_SetItemString(dict, "id",                item=PyInt_FromLong(fc->id)); 
    18         Py_DECREF(item); 
    19  
    20         PyDict_SetItemString(dict, "encoding_name",     item=PyString_FromString(fc->encoding_name)); 
    21         Py_DECREF(item); 
    22  
    23         PyDict_SetItemString(dict, "media_type",        item=PyInt_FromLong(fc->media_type)); 
    24         Py_DECREF(item); 
    25  
    26         PyDict_SetItemString(dict, "clock_rate",        item=PyInt_FromLong(fc->clock_rate)); 
    27         Py_DECREF(item); 
    28  
    29         PyDict_SetItemString(dict, "channels",          item=PyInt_FromLong(fc->channels)); 
    30         Py_DECREF(item); 
     49 
     50        /* these two are required */ 
     51        insert_long_into_dict(dict, "id", fc->id); 
     52        insert_str_into_dict(dict, "encoding_name", fc->encoding_name); 
     53 
     54        /* next are optional */ 
     55        if (fc->media_type)     insert_long_into_dict(dict, "media_type", fc->media_type); 
     56        if (fc->clock_rate)     insert_long_into_dict(dict, "clock_rate", fc->clock_rate); 
     57        if (fc->channels)       insert_long_into_dict(dict, "channels", fc->channels); 
     58 
     59        if (fc->optional_params) { 
     60                PyObject* params = PyDict_New(); 
     61                GList* list; 
     62 
     63                for(list=fc->optional_params; list; list=g_list_next(list)) { 
     64                        FarsightCodecParameter *fcp=list->data; 
     65                        insert_str_into_dict(params, fcp->name, fcp->value); 
     66                } 
     67 
     68                PyDict_SetItemString(dict, "params", params); 
     69                Py_DECREF(params); 
     70        } 
    3171 
    3272        return dict; 
    3373} 
     74 
     75/* functions to get data from dict */ 
     76/* next three functions might raise an error */ 
     77inline static long get_long_from_dict(PyObject* dict, char* key) { 
     78        PyObject* pyint=PyMapping_GetItemString(dict, key); 
     79        return(pyint?PyInt_AsLong(pyint):0); 
     80} 
     81 
     82inline static char* get_str_from_dict(PyObject* dict, char* key) { 
     83        PyObject* str=PyMapping_GetItemString(dict, key); 
     84        return(str?PyString_AsString(str):NULL); 
     85} 
     86 
     87inline static double get_double_from_dict(PyObject* dict, char* key) { 
     88        PyObject* pyfloat=PyMapping_GetItemString(dict, key); 
     89        return(pyfloat?PyFloat_AsDouble(pyfloat):0.0); 
     90} 
     91 
     92/* may raise an exception */ 
     93static void dict_to_farsight_transport_info(PyObject* dict, FarsightTransportInfo* fti) { 
     94        if (!dict) return; 
     95 
     96        /* required */ 
     97        fti->candidate_id       = get_str_from_dict(dict, "candidate_id"); 
     98        fti->component          = get_long_from_dict(dict, "component"); 
     99        fti->ip                 = get_str_from_dict(dict, "ip"); 
     100        fti->port               = get_long_from_dict(dict, "port"); 
     101        fti->proto              = get_long_from_dict(dict, "proto"); 
     102        fti->proto_subtype      = get_str_from_dict(dict, "proto_subtype"); 
     103        fti->proto_profile      = get_str_from_dict(dict, "proto_profile"); 
     104        fti->preference         = get_double_from_dict(dict, "preference"); 
     105        fti->type               = get_long_from_dict(dict, "type"); 
     106 
     107        if (PyError_Occurred()) return; 
     108 
     109        /* optional */ 
     110        fti->username           = get_str_from_dict(dict, "username"); 
     111        fti->password           = get_str_from_dict(dict, "password"); 
     112 
     113        PyError_Clear(); 
     114} 
     115 
     116/* GArray must be freed if not NULL; 
     117   may raise an exception */ 
     118static void dict_to_farsight_codec(PyObject* dict, FarsightCodec* fc, GArray** fcp) { 
     119        GArray* array=*fcp; 
     120 
     121        if (!dict) return; 
     122 
     123        /* required data */ 
     124        fc->id                  = get_long_from_dict(dict, "id"); 
     125        fc->encoding_name       = get_str_from_dict(dict, "encoding_name"); 
     126 
     127        if (PyError_Occured()) return; 
     128 
     129        /* optional data */ 
     130        fc->media_type          = get_long_from_dict(dict, "media_type"); 
     131        fc->clock_rate          = get_long_from_dict(dict, "clock_rate"); 
     132        fc->channels            = get_long_from_dict(dict, "channels"); 
     133 
     134        if (PyMapping_HasKeyString(dict, "params")) { 
     135                PyObject* params = PyMapping_GetItemString(dict, "params"); 
     136                if (PyDict_Check(params)) { 
     137                        PyObject *key, *value; 
     138                        int pos=0; 
     139                        GList* list=NULL; 
     140                        int i=0; 
     141 
     142                        if (!array) 
     143                                array = g_array_new(FALSE, FALSE, sizeof(FarsightCodecParameter)); 
     144 
     145                        while (PyDict_Next(params, &pos, &key, &value)) { 
     146                                if (PyString_Check(key) && PyString_Check(value)) { 
     147                                        FarsightCodecParameter fcp; 
     148                                        fcp.name = PyString_AsString(key); 
     149                                        fcp.value= PyString_AsString(value); 
     150                                        g_array_append_val(array, fcp); 
     151                                        list=g_list_prepend(list, 
     152                                                &g_array_index(array, FarsightCodecParameter, i++)); 
     153                                } else { 
     154                                        /* this is not a string? not good... */ 
     155                                        puts("keys and values must be strings here!"); 
     156                                } 
     157                        } 
     158 
     159                        fc->optional_params = list; 
     160                } else { 
     161                        /* this is not a dictionary? fail miserably... */ 
     162                        puts("params must be a dictionary!"); 
     163                } 
     164        } 
     165 
     166        PyErr_Clear(); 
     167 
     168        *fcp = array; 
     169} 
     170 
    34171%% 
    35172modulename farsight 
    … …  
    92229        static char* kwlist[] = {"candidate_id", NULL}; 
    93230        char* candidate_id; 
    94         GList* list; 
     231        GList* list, *tmp; 
    95232        FarsightTransportInfo* data; 
    96233        PyObject* ret; 
    … …  
    101238 
    102239        list = farsight_stream_get_native_candidate(FARSIGHT_STREAM(self->obj), candidate_id); 
    103         data = list->data; 
    104  
    105         ret = PyDict_New(); 
    106  
    107         PyDict_SetItemString(ret, "candidate_id",       item=PyString_FromString(data->candidate_id)); 
    108         Py_DECREF(item); 
    109  
    110         PyDict_SetItemString(ret, "component",          item=PyInt_FromLong(data->component)); 
    111         Py_DECREF(item); 
    112  
    113         PyDict_SetItemString(ret, "ip",                 item=PyString_FromString(data->ip)); 
    114         Py_DECREF(item); 
    115  
    116         PyDict_SetItemString(ret, "port",               item=PyInt_FromLong(data->port)); 
    117         Py_DECREF(item); 
    118  
    119         PyDict_SetItemString(ret, "proto",              item=PyInt_FromLong(data->proto)); 
    120         Py_DECREF(item); 
    121  
    122         PyDict_SetItemString(ret, "proto_subtype",      item=PyString_FromString(data->proto_subtype)); 
    123         Py_DECREF(item); 
    124  
    125         PyDict_SetItemString(ret, "proto_profile",      item=PyString_FromString(data->proto_profile)); 
    126         Py_DECREF(item); 
    127  
    128         PyDict_SetItemString(ret, "preference",         item=PyFloat_FromDouble(data->preference)); 
    129         Py_DECREF(item); 
    130  
    131         PyDict_SetItemString(ret, "type",               item=PyInt_FromLong(data->type)); 
    132         Py_DECREF(item); 
    133  
    134         PyDict_SetItemString(ret, "username",           item=PyString_FromString(data->username)); 
    135         Py_DECREF(item); 
    136  
    137         PyDict_SetItemString(ret, "password",           item=PyString_FromString(data->password)); 
    138         Py_DECREF(item); 
     240 
     241        ret = PyList_New(0); 
     242        for(tmp=list;list;list=g_list_next(list)) { 
     243                FarsightTransportInfo *fti = tmp->data; 
     244                PyObject *item = farsight_transport_info_to_dict(fti); 
     245 
     246                PyList_Append(ret, item); 
     247                Py_DECREF(item); 
     248        } 
    139249 
    140250        g_list_free(list); 
    … …  
    151261        list=farsight_stream_get_native_candidate_list(FARSIGHT_STREAM(self->obj)); 
    152262 
    153         ret=PyList_New(0); 
    154         for (tmp=list; tmp!=NULL; tmp=g_list_next(tmp)) { 
    155                 FarsightCodec *codec = tmp->data; 
    156                 PyObject *item = pygobject_new((GObject *) codec); 
     263        ret = PyList_New(0); 
     264        for(tmp=list;list;list=g_list_next(list)) { 
     265                FarsightTransportInfo *fti = tmp->data; 
     266                PyObject *item = farsight_transport_info_to_dict(fti); 
    157267 
    158268                PyList_Append(ret, item); 
    159269                Py_DECREF(item); 
    160270        } 
    161         // g_list_free(list); (a const list, we don't free it?) 
     271 
    162272        return ret; 
    163273} 
    … …  
    218328                FarsightTransportInfo fti; 
    219329 
    220                 PyObject* item = PySequence_GetItem(list, listsize-i-1); 
    221  
    222                 fti.candidate_id=GetString("candidate_id"); 
    223                 fti.component=GetLong("component"); 
    224                 fti.ip=GetString("ip"); 
    225                 fti.port=GetLong("port"); 
    226                 fti.proto=GetLong("proto"); 
    227                 fti.proto_subtype=GetString("proto_subtype"); 
    228                 fti.proto_profile=GetString("proto_profile"); 
    229                 fti.preference=GetFloat("preference"); 
    230                 fti.type=GetLong("type"); 
    231                 fti.username=""; 
    232                 fti.password=""; 
     330                dict_to_farsight_transport_info(PySequence_GetItem(list, listsize-i-1), &fti); 
    233331 
    234332                g_array_append_val(candidate_array, fti); 
    … …  
    238336        } 
    239337 
    240         farsight_stream_set_remote_candidate_list(FARSIGHT_STREAM(self->obj), candidate_list); 
     338        if(!PyError_Occurred()) { 
     339                farsight_stream_set_remote_candidate_list(FARSIGHT_STREAM(self->obj), candidate_list); 
     340        } 
    241341 
    242342        g_array_free(candidate_array, FALSE); 
    243343        g_list_free(candidate_list); 
    244344 
    245         Py_INCREF(Py_None); 
    246         return Py_None; 
     345        if(!PyError_Occurred()) { 
     346                Py_INCREF(Py_None); 
     347                return Py_None; 
     348        } else { 
     349                return NULL; 
     350        } 
    247351} 
    248352%% 
    … …  
    255359        PyObject* list, * item; 
    256360        GArray* codecs_array; 
     361        GArray* fcp_array=NULL; 
    257362        GList* codecs_list=NULL; 
    258363        int i, listsize; 
    … …  
    267372        for(i=0;i<listsize;i++) { 
    268373                FarsightCodec fc; 
    269                 PyObject* item = PySequence_GetItem(list, listsize-i-1); 
    270  
    271                 fc.id = GetLong("id"); 
    272                 fc.encoding_name = GetString("encoding_name"); 
    273                 fc.media_type = GetLong("media_type"); 
    274                 fc.clock_rate = GetLong("clock_rate"); 
    275                 fc.channels = GetLong("channels"); 
    276                 fc.optional_params = NULL; 
     374 
     375                dict_to_farsight_codec(PySequence_GetItem(list, listsize-i-1), &fc, &fcp_array); 
    277376 
    278377                g_array_append_val(codecs_array, fc); 
    … …  
    281380        } 
    282381 
    283         farsight_stream_set_remote_codecs(FARSIGHT_STREAM(self->obj), codecs_list); 
    284  
     382        if (!PyError_Occurred()) { 
     383                farsight_stream_set_remote_codecs(FARSIGHT_STREAM(self->obj), codecs_list); 
     384        } 
     385 
     386        g_array_free(fcp_array, FALSE); 
    285387        g_array_free(codecs_array, FALSE); 
    286388        g_list_free(codecs_list); 
    287389 
    288         Py_INCREF(Py_None); 
    289         return Py_None; 
    290 } 
     390        if (!PyError_Occurred()) { 
     391                Py_INCREF(Py_None); 
     392                return Py_None; 
     393        } else { 
     394                return NULL; 
     395        } 
     396} 

  • branches/jingle/src/common/jingle.py

    r8489 r8490  
    409409        def on_p2pstream_native_candidates_prepared(self, *whatever): pass 
    410410        def on_p2pstream_state_changed(self, *whatever): pass 
    411         def on_p2pstream_new_native_candidate(self, *whatever): pass 
     411        def on_p2pstream_new_native_candidate(self, p2pstream, candidate_id): 
     412                candidate = p2pstream.get_native_candidate(candidate_id) 
     413 
     414 
    412415        def getCodecs(self): 
    413416                codecs=self.p2pstream.get_local_codecs()