Changeset 915


Ignore:
Timestamp:
Jan 29, 2007 12:09:33 PM (13 years ago)
Author:
fahris
Message:

update py_pjsua.c 290107

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjsip-apps/src/py_pjsua/py_pjsua.c

    r914 r915  
    3434static void cb_reconfigure_logging(int level, const char *data, pj_size_t len) 
    3535{ 
     36         
    3637    if (PyCallable_Check(obj_reconfigure_logging)) 
    3738    { 
     
    5051static void cb_logging_init(int level, const char *data, pj_size_t len) 
    5152{ 
     53         
    5254    if (PyCallable_Check(obj_logging_init)) 
    5355    { 
     
    183185static void cb_on_call_state(pjsua_call_id call_id, pjsip_event *e) 
    184186{ 
     187 
     188        printf("on_call_state called\n"); 
    185189    if (PyCallable_Check(obj_callback->on_call_state)) 
    186     { 
    187         pjsip_event_Object * obj = 
    188             (pjsip_event_Object *)PyType_GenericNew(&pjsip_event_Type,  
     190    {    
     191        pjsip_event_Object * obj; 
     192                 
     193            obj = 
     194                (pjsip_event_Object *)PyType_GenericNew(&pjsip_event_Type,  
    189195                                                    NULL, NULL); 
    190         obj->event = e; 
    191  
     196                 
     197            obj->event = e; 
     198                 
    192199        PyObject_CallFunctionObjArgs( 
    193200            obj_callback->on_call_state,Py_BuildValue("i",call_id),obj,NULL 
    194201        ); 
     202                 
    195203    } 
    196204} 
     
    204212                                pjsip_rx_data *rdata) 
    205213{ 
     214        printf("on_incoming_call called\n"); 
    206215    if (PyCallable_Check(obj_callback->on_incoming_call)) 
    207216    { 
     
    228237static void cb_on_call_media_state(pjsua_call_id call_id) 
    229238{ 
     239        printf("on_call_media_state called\n"); 
    230240    if (PyCallable_Check(obj_callback->on_call_media_state)) 
    231241    { 
     
    245255    PyObject * ret; 
    246256    int cd; 
     257        printf("on_call_transfer_request called\n"); 
    247258    if (PyCallable_Check(obj_callback->on_call_transfer_request)) 
    248259    { 
     
    280291    PyObject * ret; 
    281292    int cnt; 
     293        printf("on_call_transfer_status called\n"); 
    282294    if (PyCallable_Check(obj_callback->on_call_transfer_status)) 
    283295    { 
     
    315327    PyObject * txt; 
    316328    int cd; 
     329        printf("on_call_replace_request called\n"); 
    317330    if (PyCallable_Check(obj_callback->on_call_replace_request)) 
    318331    { 
     
    351364                                pjsua_call_id new_call_id) 
    352365{ 
     366        printf("on_call_replaced\n"); 
    353367    if (PyCallable_Check(obj_callback->on_call_replaced)) 
    354368    { 
     
    369383static void cb_on_reg_state(pjsua_acc_id acc_id) 
    370384{ 
     385        printf("on_reg_state\n"); 
    371386    if (PyCallable_Check(obj_callback->on_reg_state)) 
    372387    { 
     
    382397static void cb_on_buddy_state(pjsua_buddy_id buddy_id) 
    383398{ 
     399        printf("on_buddy_state called\n"); 
    384400    if (PyCallable_Check(obj_callback->on_buddy_state)) 
    385401    { 
     
    396412                        const pj_str_t *mime_type, const pj_str_t *body) 
    397413{ 
     414        printf("on_pager called\n"); 
    398415    if (PyCallable_Check(obj_callback->on_pager)) 
    399416    { 
     
    419436                                const pj_str_t *reason) 
    420437{ 
     438         
    421439    PyObject * obj = PyType_GenericNew(user_data, NULL, NULL); 
     440        printf("on_pager_status called\n"); 
    422441    if (PyCallable_Check(obj_callback->on_pager)) 
    423442    { 
     
    441460                            pj_bool_t is_typing) 
    442461{ 
     462        printf("on_typing called\n"); 
    443463    if (PyCallable_Check(obj_callback->on_typing)) 
    444464    { 
     
    595615    }, 
    596616    { 
    597         "on_call_media__state", T_OBJECT_EX, 
     617        "on_call_media_state", T_OBJECT_EX, 
    598618        offsetof(callback_Object, on_call_media_state), 0, 
    599619        "Notify application when media state in the call has changed. Normal " 
     
    12971317            if (PyTuple_Check(tuple)) { 
    12981318                hname.ptr = PyString_AsString(PyTuple_GetItem(tuple,0)); 
    1299                 hname.slen = strlen(PyString_AsString(PyTuple_GetItem(tuple,0))); 
     1319                hname.slen = strlen(PyString_AsString 
     1320                                        (PyTuple_GetItem(tuple,0))); 
    13001321                hvalue.ptr = PyString_AsString(PyTuple_GetItem(tuple,1)); 
    1301                 hvalue.slen = strlen(PyString_AsString(PyTuple_GetItem(tuple,1))); 
     1322                hvalue.slen = strlen(PyString_AsString 
     1323                                        (PyTuple_GetItem(tuple,1))); 
    13021324            } else { 
    13031325                hname.ptr = ""; 
     
    17691791    } 
    17701792    pjsua_media_config_default(&cfg); 
    1771     obj = (media_config_Object *)PyType_GenericNew(&media_config_Type, NULL, NULL); 
     1793    obj = (media_config_Object *)PyType_GenericNew 
     1794                (&media_config_Type, NULL, NULL); 
    17721795    obj->clock_rate = cfg.clock_rate; 
    17731796    obj->ec_options = cfg.ec_options; 
     
    18101833    ); 
    18111834 
    1812     translate_hdr_rev((pjsip_generic_string_hdr *)&msg.hdr_list, obj->hdr_list); 
     1835    translate_hdr_rev((pjsip_generic_string_hdr *)&msg.hdr_list,obj->hdr_list); 
    18131836     
    18141837    return (PyObject *)obj; 
     
    18211844static PyObject *py_pjsua_reconfigure_logging(PyObject *pSelf, PyObject *pArgs) 
    18221845{ 
     1846        PyObject * logObj; 
    18231847    logging_config_Object *log; 
    18241848    pjsua_logging_config cfg; 
    18251849    pj_status_t status; 
    18261850 
    1827     if (!PyArg_ParseTuple(pArgs, "O", &log)) 
    1828     { 
    1829         return NULL; 
    1830     } 
    1831     cfg.msg_logging = log->msg_logging; 
    1832     cfg.level = log->level; 
    1833     cfg.console_level = log->console_level; 
    1834     cfg.decor = log->decor; 
    1835     cfg.log_filename.ptr = PyString_AsString(log->log_filename); 
    1836     cfg.log_filename.slen = strlen(cfg.log_filename.ptr); 
    1837     Py_XDECREF(obj_reconfigure_logging); 
    1838     obj_reconfigure_logging = log->cb; 
    1839     Py_INCREF(obj_reconfigure_logging); 
    1840     cfg.cb = &cb_reconfigure_logging; 
    1841     status = pjsua_reconfigure_logging(&cfg); 
     1851    if (!PyArg_ParseTuple(pArgs, "O", &logObj)) 
     1852    { 
     1853        return NULL; 
     1854    } 
     1855    if (logObj != Py_None) { 
     1856        log = (logging_config_Object *)logObj; 
     1857        cfg.msg_logging = log->msg_logging; 
     1858        cfg.level = log->level; 
     1859        cfg.console_level = log->console_level; 
     1860        cfg.decor = log->decor; 
     1861        cfg.log_filename.ptr = PyString_AsString(log->log_filename); 
     1862        cfg.log_filename.slen = strlen(cfg.log_filename.ptr); 
     1863        Py_XDECREF(obj_reconfigure_logging); 
     1864        obj_reconfigure_logging = log->cb; 
     1865        Py_INCREF(obj_reconfigure_logging); 
     1866        cfg.cb = &cb_reconfigure_logging; 
     1867        status = pjsua_reconfigure_logging(&cfg); 
     1868    } else { 
     1869        status = pjsua_reconfigure_logging(NULL); 
     1870        } 
    18421871    return Py_BuildValue("i",status); 
    18431872} 
     
    19742003{ 
    19752004    pj_status_t status; 
     2005    PyObject * ua_cfgObj; 
    19762006    config_Object * ua_cfg; 
     2007    PyObject * log_cfgObj; 
    19772008    logging_config_Object * log_cfg; 
     2009    PyObject * media_cfgObj; 
    19782010    media_config_Object * media_cfg; 
    19792011    pjsua_config cfg_ua; 
     2012    pjsua_config * p_cfg_ua; 
    19802013    pjsua_logging_config cfg_log; 
     2014    pjsua_logging_config * p_cfg_log; 
    19812015    pjsua_media_config cfg_media; 
     2016    pjsua_media_config * p_cfg_media; 
    19822017    unsigned i; 
    19832018 
    1984     if (!PyArg_ParseTuple(pArgs, "OOO", &ua_cfg, &log_cfg, &media_cfg)) 
    1985     { 
    1986         return NULL; 
    1987     } 
    1988  
     2019    if (!PyArg_ParseTuple(pArgs, "OOO", &ua_cfgObj, &log_cfgObj,&media_cfgObj)) 
     2020    { 
     2021        return NULL; 
     2022    } 
     2023 
     2024     
    19892025    pjsua_config_default(&cfg_ua); 
    19902026    pjsua_logging_config_default(&cfg_log); 
    19912027    pjsua_media_config_default(&cfg_media); 
    1992     cfg_ua.cred_count = ua_cfg->cred_count; 
    1993     for (i = 0; i < 4; i++) 
    1994     { 
    1995         cfg_ua.cred_info[i] = ua_cfg->cred_info[i]; 
    1996     } 
    1997     cfg_ua.max_calls = ua_cfg->max_calls; 
    1998     for (i = 0; i < PJSUA_ACC_MAX_PROXIES; i++) 
    1999     { 
    2000         cfg_ua.outbound_proxy[i] = ua_cfg->outbound_proxy[i]; 
    2001     } 
    2002  
    2003     cfg_ua.outbound_proxy_cnt = ua_cfg->outbound_proxy_cnt; 
    2004     cfg_ua.thread_cnt = ua_cfg->thread_cnt; 
    2005     cfg_ua.user_agent.ptr = PyString_AsString(ua_cfg->user_agent); 
    2006     cfg_ua.user_agent.slen = strlen(cfg_ua.user_agent.ptr); 
    2007  
    2008     obj_callback = ua_cfg->cb; 
    2009     cfg_ua.cb.on_call_state = &cb_on_call_state; 
    2010     cfg_ua.cb.on_incoming_call = &cb_on_incoming_call; 
    2011     cfg_ua.cb.on_call_media_state = &cb_on_call_media_state; 
    2012     cfg_ua.cb.on_call_transfer_request = &cb_on_call_transfer_request; 
    2013     cfg_ua.cb.on_call_transfer_status = &cb_on_call_transfer_status; 
    2014     cfg_ua.cb.on_call_replace_request = &cb_on_call_replace_request; 
    2015     cfg_ua.cb.on_call_replaced = &cb_on_call_replaced; 
    2016     cfg_ua.cb.on_reg_state = &cb_on_reg_state; 
    2017     cfg_ua.cb.on_buddy_state = &cb_on_buddy_state; 
    2018     cfg_ua.cb.on_pager = &cb_on_pager; 
    2019     cfg_ua.cb.on_pager_status = &cb_on_pager_status; 
    2020     cfg_ua.cb.on_typing = &cb_on_typing; 
    2021  
    2022     cfg_log.msg_logging = log_cfg->msg_logging; 
    2023     cfg_log.level = log_cfg->level; 
    2024     cfg_log.console_level = log_cfg->console_level; 
    2025     cfg_log.decor = log_cfg->decor; 
    2026     cfg_log.log_filename.ptr = PyString_AsString(log_cfg->log_filename); 
    2027     cfg_log.log_filename.slen = strlen(cfg_log.log_filename.ptr); 
    2028     Py_XDECREF(obj_logging_init); 
    2029     obj_logging_init = log_cfg->cb; 
    2030     Py_INCREF(obj_logging_init); 
    2031     cfg_log.cb = &cb_logging_init; 
    2032  
    2033  
    2034     cfg_media.clock_rate = media_cfg->clock_rate; 
    2035     cfg_media.ec_options = media_cfg->ec_options; 
    2036     cfg_media.ec_tail_len = media_cfg->ec_tail_len; 
    2037     cfg_media.has_ioqueue = media_cfg->has_ioqueue; 
    2038     cfg_media.ilbc_mode = media_cfg->ilbc_mode; 
    2039     cfg_media.max_media_ports = media_cfg->max_media_ports; 
    2040     cfg_media.no_vad = media_cfg->no_vad; 
    2041     cfg_media.ptime = media_cfg->ptime; 
    2042     cfg_media.quality = media_cfg->quality; 
    2043     cfg_media.rx_drop_pct = media_cfg->rx_drop_pct; 
    2044     cfg_media.thread_cnt = media_cfg->thread_cnt; 
    2045     cfg_media.tx_drop_pct = media_cfg->tx_drop_pct; 
    2046  
    2047     status = pjsua_init(&cfg_ua, &cfg_log, &cfg_media); 
     2028 
     2029    if (ua_cfgObj != Py_None) { 
     2030                ua_cfg = (config_Object *)ua_cfgObj; 
     2031        cfg_ua.cred_count = ua_cfg->cred_count; 
     2032        for (i = 0; i < 4; i++) 
     2033                { 
     2034            cfg_ua.cred_info[i] = ua_cfg->cred_info[i]; 
     2035                } 
     2036        cfg_ua.max_calls = ua_cfg->max_calls; 
     2037        for (i = 0; i < PJSUA_ACC_MAX_PROXIES; i++) 
     2038                { 
     2039            cfg_ua.outbound_proxy[i] = ua_cfg->outbound_proxy[i]; 
     2040                } 
     2041 
     2042        cfg_ua.outbound_proxy_cnt = ua_cfg->outbound_proxy_cnt; 
     2043        cfg_ua.thread_cnt = ua_cfg->thread_cnt; 
     2044        cfg_ua.user_agent.ptr = PyString_AsString(ua_cfg->user_agent); 
     2045        cfg_ua.user_agent.slen = strlen(cfg_ua.user_agent.ptr); 
     2046 
     2047        obj_callback = ua_cfg->cb; 
     2048        cfg_ua.cb.on_call_state = &cb_on_call_state; 
     2049        cfg_ua.cb.on_incoming_call = &cb_on_incoming_call; 
     2050        cfg_ua.cb.on_call_media_state = &cb_on_call_media_state; 
     2051        cfg_ua.cb.on_call_transfer_request = &cb_on_call_transfer_request; 
     2052        cfg_ua.cb.on_call_transfer_status = &cb_on_call_transfer_status; 
     2053        cfg_ua.cb.on_call_replace_request = &cb_on_call_replace_request; 
     2054        cfg_ua.cb.on_call_replaced = &cb_on_call_replaced; 
     2055        cfg_ua.cb.on_reg_state = &cb_on_reg_state; 
     2056        cfg_ua.cb.on_buddy_state = &cb_on_buddy_state; 
     2057        cfg_ua.cb.on_pager = &cb_on_pager; 
     2058        cfg_ua.cb.on_pager_status = &cb_on_pager_status; 
     2059        cfg_ua.cb.on_typing = &cb_on_typing; 
     2060        p_cfg_ua = &cfg_ua; 
     2061    } else { 
     2062        p_cfg_ua = NULL; 
     2063        } 
     2064    if (log_cfgObj != Py_None) { 
     2065        log_cfg = (logging_config_Object *)log_cfgObj; 
     2066        cfg_log.msg_logging = log_cfg->msg_logging; 
     2067        cfg_log.level = log_cfg->level; 
     2068        cfg_log.console_level = log_cfg->console_level; 
     2069        cfg_log.decor = log_cfg->decor; 
     2070        cfg_log.log_filename.ptr = PyString_AsString(log_cfg->log_filename); 
     2071        cfg_log.log_filename.slen = strlen(cfg_log.log_filename.ptr); 
     2072        Py_XDECREF(obj_logging_init); 
     2073        obj_logging_init = log_cfg->cb; 
     2074        Py_INCREF(obj_logging_init); 
     2075        cfg_log.cb = &cb_logging_init; 
     2076        p_cfg_log = &cfg_log; 
     2077    } else { 
     2078        p_cfg_log = NULL; 
     2079        } 
     2080    if (media_cfgObj != Py_None) { 
     2081        media_cfg = (media_config_Object *)media_cfgObj; 
     2082        cfg_media.clock_rate = media_cfg->clock_rate; 
     2083        cfg_media.ec_options = media_cfg->ec_options; 
     2084        cfg_media.ec_tail_len = media_cfg->ec_tail_len; 
     2085        cfg_media.has_ioqueue = media_cfg->has_ioqueue; 
     2086        cfg_media.ilbc_mode = media_cfg->ilbc_mode; 
     2087        cfg_media.max_media_ports = media_cfg->max_media_ports; 
     2088        cfg_media.no_vad = media_cfg->no_vad; 
     2089        cfg_media.ptime = media_cfg->ptime; 
     2090        cfg_media.quality = media_cfg->quality; 
     2091        cfg_media.rx_drop_pct = media_cfg->rx_drop_pct; 
     2092        cfg_media.thread_cnt = media_cfg->thread_cnt; 
     2093        cfg_media.tx_drop_pct = media_cfg->tx_drop_pct; 
     2094            p_cfg_media = &cfg_media; 
     2095        } else { 
     2096        p_cfg_media = NULL; 
     2097        } 
     2098    status = pjsua_init(p_cfg_ua, p_cfg_log, p_cfg_media); 
    20482099    return Py_BuildValue("i",status); 
    20492100} 
     
    30583109(PyObject *pSelf, PyObject *pArgs) 
    30593110{ 
     3111        PyObject * tmpObj; 
    30603112    stun_config_Object *obj; 
    30613113    pjsua_stun_config *cfg; 
    30623114 
    3063     if (!PyArg_ParseTuple(pArgs, "O", &obj)) 
    3064     { 
    3065         return NULL; 
    3066     } 
    3067     cfg = (pjsua_stun_config *)malloc(sizeof(pjsua_stun_config)); 
    3068     cfg->stun_port1 = obj->stun_port1; 
    3069     cfg->stun_port2 = obj->stun_port2; 
    3070     cfg->stun_srv1.ptr = PyString_AsString(obj->stun_srv1); 
    3071     cfg->stun_srv1.slen = strlen(PyString_AsString(obj->stun_srv1)); 
    3072     cfg->stun_srv2.ptr = PyString_AsString(obj->stun_srv2); 
    3073     cfg->stun_srv2.slen = strlen(PyString_AsString(obj->stun_srv2)); 
     3115    if (!PyArg_ParseTuple(pArgs, "O", &tmpObj)) 
     3116    { 
     3117        return NULL; 
     3118    } 
     3119        if (tmpObj != Py_None) 
     3120        { 
     3121                obj = (stun_config_Object *) tmpObj; 
     3122        cfg = (pjsua_stun_config *)malloc(sizeof(pjsua_stun_config)); 
     3123        cfg->stun_port1 = obj->stun_port1; 
     3124        cfg->stun_port2 = obj->stun_port2; 
     3125        cfg->stun_srv1.ptr = PyString_AsString(obj->stun_srv1); 
     3126        cfg->stun_srv1.slen = strlen(PyString_AsString(obj->stun_srv1)); 
     3127        cfg->stun_srv2.ptr = PyString_AsString(obj->stun_srv2); 
     3128        cfg->stun_srv2.slen = strlen(PyString_AsString(obj->stun_srv2)); 
     3129        } else { 
     3130                cfg = NULL; 
     3131        } 
    30743132    pjsua_normalize_stun_config(cfg); 
    30753133    obj->stun_port1 = cfg->stun_port1; 
     
    30953153    int type; 
    30963154     
     3155        PyObject * tmpObj; 
    30973156    transport_config_Object *obj; 
    30983157    pjsua_transport_config cfg; 
    30993158    pjsua_transport_id id; 
    3100     if (!PyArg_ParseTuple(pArgs, "iO", &type, &obj)) 
    3101     { 
    3102         return NULL; 
    3103     } 
    3104     cfg.public_addr.ptr = PyString_AsString(obj->public_addr); 
    3105     cfg.public_addr.slen = strlen(PyString_AsString(obj->public_addr)); 
    3106     cfg.bound_addr.ptr = PyString_AsString(obj->bound_addr); 
    3107     cfg.bound_addr.slen = strlen(PyString_AsString(obj->bound_addr)); 
    3108     cfg.port = obj->port; 
    3109     cfg.use_stun = obj->use_stun; 
    3110     cfg.stun_config.stun_port1 = obj->stun_config->stun_port1; 
    3111     cfg.stun_config.stun_port2 = obj->stun_config->stun_port2; 
    3112     cfg.stun_config.stun_srv1.ptr =  
    3113         PyString_AsString(obj->stun_config->stun_srv1); 
    3114     cfg.stun_config.stun_srv1.slen =  
    3115         strlen(PyString_AsString(obj->stun_config->stun_srv1)); 
    3116     cfg.stun_config.stun_srv2.ptr =  
    3117         PyString_AsString(obj->stun_config->stun_srv2); 
    3118     cfg.stun_config.stun_srv2.slen =  
    3119         strlen(PyString_AsString(obj->stun_config->stun_srv2)); 
    3120     status = pjsua_transport_create(type, &cfg, &id); 
     3159    if (!PyArg_ParseTuple(pArgs, "iO", &type, &tmpObj)) 
     3160    { 
     3161        return NULL; 
     3162    } 
     3163        if (tmpObj != Py_None) 
     3164        { 
     3165        obj = (transport_config_Object *)tmpObj; 
     3166        cfg.public_addr.ptr = PyString_AsString(obj->public_addr); 
     3167        cfg.public_addr.slen = strlen(PyString_AsString(obj->public_addr)); 
     3168        cfg.bound_addr.ptr = PyString_AsString(obj->bound_addr); 
     3169        cfg.bound_addr.slen = strlen(PyString_AsString(obj->bound_addr)); 
     3170        cfg.port = obj->port; 
     3171        cfg.use_stun = obj->use_stun; 
     3172        cfg.stun_config.stun_port1 = obj->stun_config->stun_port1; 
     3173        cfg.stun_config.stun_port2 = obj->stun_config->stun_port2; 
     3174        cfg.stun_config.stun_srv1.ptr =  
     3175            PyString_AsString(obj->stun_config->stun_srv1); 
     3176        cfg.stun_config.stun_srv1.slen =  
     3177            strlen(PyString_AsString(obj->stun_config->stun_srv1)); 
     3178        cfg.stun_config.stun_srv2.ptr =  
     3179            PyString_AsString(obj->stun_config->stun_srv2); 
     3180        cfg.stun_config.stun_srv2.slen =  
     3181            strlen(PyString_AsString(obj->stun_config->stun_srv2)); 
     3182        status = pjsua_transport_create(type, &cfg, &id); 
     3183        } else { 
     3184        status = pjsua_transport_create(type, NULL, &id); 
     3185        } 
    31213186     
    31223187     
     
    31313196{ 
    31323197    pj_status_t status;      
     3198        PyObject * tmpObj; 
    31333199    pjsip_transport_Object *obj;         
    31343200    pjsua_transport_id id; 
    3135     if (!PyArg_ParseTuple(pArgs, "O", &obj)) 
    3136     { 
    3137         return NULL; 
    3138     } 
    3139          
    3140      
    3141     status = pjsua_transport_register(obj->tp, &id); 
     3201    if (!PyArg_ParseTuple(pArgs, "O", &tmpObj)) 
     3202    { 
     3203        return NULL; 
     3204    } 
     3205    if (tmpObj != Py_None) 
     3206        { 
     3207        obj = (pjsip_transport_Object *)tmpObj; 
     3208        status = pjsua_transport_register(obj->tp, &id); 
     3209    } else { 
     3210        status = pjsua_transport_register(NULL, &id); 
     3211    } 
    31423212     
    31433213    return Py_BuildValue("ii",status, id); 
     
    31543224     
    31553225    pjsua_transport_id id[PJSIP_MAX_TRANSPORTS]; 
    3156     int c, i; 
     3226    unsigned c, i; 
    31573227    if (!PyArg_ParseTuple(pArgs, "")) 
    31583228    { 
     
    31723242        } 
    31733243    } 
    3174      
    31753244     
    31763245    return Py_BuildValue("O",list); 
     
    38793948{     
    38803949    int is_default; 
     3950        PyObject * acObj; 
    38813951    acc_config_Object * ac; 
    38823952    pjsua_acc_config cfg; 
     
    38863956    int i; 
    38873957 
    3888     if (!PyArg_ParseTuple(pArgs, "Oi", &ac, &is_default)) 
    3889     { 
    3890         return NULL; 
    3891     } 
    3892     cfg.cred_count = ac->cred_count; 
    3893     for (i = 0; i < 8; i++)  
    3894     { 
    3895         /*cfg.cred_info[i] = ac->cred_info[i];*/ 
    3896         pjsip_cred_info_Object * ci = (pjsip_cred_info_Object *)PyList_GetItem((PyObject *)ac->cred_info,i); 
    3897         cfg.cred_info[i].data.ptr = PyString_AsString(ci->data); 
    3898         cfg.cred_info[i].data.slen = strlen(PyString_AsString(ci->data)); 
    3899         cfg.cred_info[i].realm.ptr = PyString_AsString(ci->realm); 
    3900         cfg.cred_info[i].realm.slen = strlen(PyString_AsString(ci->realm)); 
    3901         cfg.cred_info[i].scheme.ptr = PyString_AsString(ci->scheme); 
    3902         cfg.cred_info[i].scheme.slen = strlen(PyString_AsString(ci->scheme)); 
    3903         cfg.cred_info[i].username.ptr = PyString_AsString(ci->username); 
    3904         cfg.cred_info[i].username.slen = strlen(PyString_AsString(ci->username)); 
    3905         cfg.cred_info[i].data_type = ci->data_type; 
    3906     } 
    3907     cfg.force_contact.ptr = PyString_AsString(ac->force_contact); 
    3908     cfg.force_contact.slen = strlen(PyString_AsString(ac->force_contact)); 
    3909     cfg.id.ptr = PyString_AsString(ac->id); 
    3910     cfg.id.slen = strlen(PyString_AsString(ac->id)); 
    3911     cfg.priority = ac->priority; 
    3912     for (i = 0; i < 8; i++) { 
    3913         /*cfg.proxy[i] = ac->proxy[i];*/ 
    3914         cfg.proxy[i].ptr = PyString_AsString(PyList_GetItem((PyObject *)ac->proxy,i)); 
    3915     } 
    3916     cfg.proxy_cnt = ac->proxy_cnt; 
    3917     cfg.publish_enabled = ac->publish_enabled; 
    3918     cfg.reg_timeout = ac->reg_timeout; 
    3919     cfg.reg_uri.ptr = PyString_AsString(ac->reg_uri); 
    3920     cfg.reg_uri.slen = strlen(PyString_AsString(ac->reg_uri)); 
    3921      
    3922     status = pjsua_acc_add(&cfg, is_default, &p_acc_id); 
     3958    if (!PyArg_ParseTuple(pArgs, "Oi", &acObj, &is_default)) 
     3959    { 
     3960        return NULL; 
     3961    } 
     3962    if (acObj != Py_None) 
     3963        { 
     3964        ac = (acc_config_Object *)acObj; 
     3965        cfg.cred_count = ac->cred_count; 
     3966        for (i = 0; i < 8; i++)  
     3967                { 
     3968            /*cfg.cred_info[i] = ac->cred_info[i];*/ 
     3969                pjsip_cred_info_Object * ci = (pjsip_cred_info_Object *) 
     3970                                PyList_GetItem((PyObject *)ac->cred_info,i); 
     3971                cfg.cred_info[i].data.ptr = PyString_AsString(ci->data); 
     3972                cfg.cred_info[i].data.slen = strlen(PyString_AsString(ci->data)); 
     3973                cfg.cred_info[i].realm.ptr = PyString_AsString(ci->realm); 
     3974                cfg.cred_info[i].realm.slen = strlen(PyString_AsString(ci->realm)); 
     3975                cfg.cred_info[i].scheme.ptr = PyString_AsString(ci->scheme); 
     3976                cfg.cred_info[i].scheme.slen = strlen 
     3977                                (PyString_AsString(ci->scheme)); 
     3978                cfg.cred_info[i].username.ptr = PyString_AsString(ci->username); 
     3979                cfg.cred_info[i].username.slen = strlen 
     3980                                (PyString_AsString(ci->username)); 
     3981                cfg.cred_info[i].data_type = ci->data_type; 
     3982                } 
     3983        cfg.force_contact.ptr = PyString_AsString(ac->force_contact); 
     3984        cfg.force_contact.slen = strlen(PyString_AsString(ac->force_contact)); 
     3985        cfg.id.ptr = PyString_AsString(ac->id); 
     3986        cfg.id.slen = strlen(PyString_AsString(ac->id)); 
     3987        cfg.priority = ac->priority; 
     3988        for (i = 0; i < 8; i++) { 
     3989            /*cfg.proxy[i] = ac->proxy[i];*/ 
     3990                cfg.proxy[i].ptr = PyString_AsString 
     3991                                (PyList_GetItem((PyObject *)ac->proxy,i)); 
     3992                } 
     3993        cfg.proxy_cnt = ac->proxy_cnt; 
     3994        cfg.publish_enabled = ac->publish_enabled; 
     3995        cfg.reg_timeout = ac->reg_timeout; 
     3996        cfg.reg_uri.ptr = PyString_AsString(ac->reg_uri); 
     3997        cfg.reg_uri.slen = strlen(PyString_AsString(ac->reg_uri)); 
     3998     
     3999        status = pjsua_acc_add(&cfg, is_default, &p_acc_id); 
     4000    } else { 
     4001        status = pjsua_acc_add(NULL, is_default, &p_acc_id); 
     4002        } 
    39234003     
    39244004    return Py_BuildValue("ii", status, p_acc_id); 
     
    39394019         
    39404020 
    3941     if (!PyArg_ParseTuple(pArgs, "iiO", &tid, &is_default)) 
     4021    if (!PyArg_ParseTuple(pArgs, "ii", &tid, &is_default)) 
    39424022    { 
    39434023        return NULL; 
     
    39754055(PyObject *pSelf, PyObject *pArgs) 
    39764056{        
     4057        PyObject * acObj; 
    39774058    acc_config_Object * ac; 
    39784059    pjsua_acc_config cfg;        
     
    39814062    int i; 
    39824063 
    3983     if (!PyArg_ParseTuple(pArgs, "iO", &acc_id, &ac)) 
    3984     { 
    3985         return NULL; 
    3986     } 
    3987     cfg.cred_count = ac->cred_count; 
    3988     for (i = 0; i < 8; i++)  
    3989     { 
    3990         /*cfg.cred_info[i] = ac->cred_info[i];*/ 
    3991         pjsip_cred_info_Object * ci = (pjsip_cred_info_Object *)PyList_GetItem((PyObject *)ac->cred_info,i); 
    3992         cfg.cred_info[i].data.ptr = PyString_AsString(ci->data); 
    3993         cfg.cred_info[i].data.slen = strlen(PyString_AsString(ci->data)); 
    3994         cfg.cred_info[i].realm.ptr = PyString_AsString(ci->realm); 
    3995         cfg.cred_info[i].realm.slen = strlen(PyString_AsString(ci->realm)); 
    3996         cfg.cred_info[i].scheme.ptr = PyString_AsString(ci->scheme); 
    3997         cfg.cred_info[i].scheme.slen = strlen(PyString_AsString(ci->scheme)); 
    3998         cfg.cred_info[i].username.ptr = PyString_AsString(ci->username); 
    3999         cfg.cred_info[i].username.slen = strlen(PyString_AsString(ci->username)); 
    4000     } 
    4001     cfg.force_contact.ptr = PyString_AsString(ac->force_contact); 
    4002     cfg.force_contact.slen = strlen(PyString_AsString(ac->force_contact)); 
    4003     cfg.id.ptr = PyString_AsString(ac->id); 
    4004     cfg.id.slen = strlen(PyString_AsString(ac->id)); 
    4005     cfg.priority = ac->priority; 
    4006     for (i = 0; i < 8; i++) { 
    4007         /*cfg.proxy[i] = ac->proxy[i];*/ 
    4008         cfg.proxy[i].ptr = PyString_AsString(PyList_GetItem((PyObject *)ac->proxy,i)); 
    4009     } 
    4010     cfg.proxy_cnt = ac->proxy_cnt; 
    4011     cfg.publish_enabled = ac->publish_enabled; 
    4012     cfg.reg_timeout = ac->reg_timeout; 
    4013     cfg.reg_uri.ptr = PyString_AsString(ac->reg_uri); 
    4014     cfg.reg_uri.slen = strlen(PyString_AsString(ac->reg_uri));   
    4015     status = pjsua_acc_modify(acc_id, &cfg);     
     4064    if (!PyArg_ParseTuple(pArgs, "iO", &acc_id, &acObj)) 
     4065    { 
     4066        return NULL; 
     4067    } 
     4068    if (acObj != Py_None) 
     4069        { 
     4070                ac = (acc_config_Object *)acObj; 
     4071        cfg.cred_count = ac->cred_count; 
     4072        for (i = 0; i < 8; i++)  
     4073                { 
     4074            /*cfg.cred_info[i] = ac->cred_info[i];*/ 
     4075            pjsip_cred_info_Object * ci = (pjsip_cred_info_Object *) 
     4076                                PyList_GetItem((PyObject *)ac->cred_info,i); 
     4077            cfg.cred_info[i].data.ptr = PyString_AsString(ci->data); 
     4078            cfg.cred_info[i].data.slen = strlen(PyString_AsString(ci->data)); 
     4079            cfg.cred_info[i].realm.ptr = PyString_AsString(ci->realm); 
     4080            cfg.cred_info[i].realm.slen = strlen(PyString_AsString(ci->realm)); 
     4081            cfg.cred_info[i].scheme.ptr = PyString_AsString(ci->scheme); 
     4082            cfg.cred_info[i].scheme.slen = strlen 
     4083                                (PyString_AsString(ci->scheme)); 
     4084            cfg.cred_info[i].username.ptr = PyString_AsString(ci->username); 
     4085            cfg.cred_info[i].username.slen = strlen 
     4086                                (PyString_AsString(ci->username)); 
     4087                } 
     4088        cfg.force_contact.ptr = PyString_AsString(ac->force_contact); 
     4089        cfg.force_contact.slen = strlen(PyString_AsString(ac->force_contact)); 
     4090        cfg.id.ptr = PyString_AsString(ac->id); 
     4091        cfg.id.slen = strlen(PyString_AsString(ac->id)); 
     4092        cfg.priority = ac->priority; 
     4093        for (i = 0; i < 8; i++) { 
     4094            /*cfg.proxy[i] = ac->proxy[i];*/ 
     4095                cfg.proxy[i].ptr = PyString_AsString 
     4096                                (PyList_GetItem((PyObject *)ac->proxy,i)); 
     4097                } 
     4098        cfg.proxy_cnt = ac->proxy_cnt; 
     4099        cfg.publish_enabled = ac->publish_enabled; 
     4100        cfg.reg_timeout = ac->reg_timeout; 
     4101        cfg.reg_uri.ptr = PyString_AsString(ac->reg_uri); 
     4102        cfg.reg_uri.slen = strlen(PyString_AsString(ac->reg_uri));       
     4103        status = pjsua_acc_modify(acc_id, &cfg); 
     4104        } else { 
     4105                status = pjsua_acc_modify(acc_id, NULL); 
     4106        } 
    40164107    return Py_BuildValue("i", status); 
    40174108} 
     
    41114202     
    41124203    pjsua_acc_id id[PJSUA_MAX_ACC]; 
    4113     int c, i; 
     4204    unsigned c, i; 
    41144205    if (!PyArg_ParseTuple(pArgs, "")) 
    41154206    { 
     
    41284219    } 
    41294220     
    4130      
    41314221    return Py_BuildValue("O",list); 
    41324222} 
     
    41424232     
    41434233    pjsua_acc_info info[PJSUA_MAX_ACC]; 
    4144     int c, i; 
     4234    unsigned c, i; 
    41454235    if (!PyArg_ParseTuple(pArgs, "")) 
    41464236    { 
     
    41764266    } 
    41774267     
    4178      
    41794268    return Py_BuildValue("O",list); 
    41804269} 
     
    42104299{        
    42114300    int acc_id;  
     4301        PyObject * tmpObj; 
    42124302    pjsip_rx_data_Object * obj; 
    42134303    pjsip_rx_data * rdata; 
    42144304 
    4215     if (!PyArg_ParseTuple(pArgs, "O", &obj)) 
    4216     { 
    4217         return NULL; 
    4218     } 
    4219          
    4220     rdata = obj->rdata; 
    4221     acc_id = pjsua_acc_find_for_incoming(rdata); 
    4222          
     4305    if (!PyArg_ParseTuple(pArgs, "O", &tmpObj)) 
     4306    { 
     4307        return NULL; 
     4308    } 
     4309    if (tmpObj != Py_None) 
     4310        { 
     4311        obj = (pjsip_rx_data_Object *)tmpObj; 
     4312        rdata = obj->rdata; 
     4313        acc_id = pjsua_acc_find_for_incoming(rdata); 
     4314        } else { 
     4315        acc_id = pjsua_acc_find_for_incoming(NULL); 
     4316        } 
    42234317    return Py_BuildValue("i", acc_id); 
    42244318} 
     
    42324326{        
    42334327    int status; 
    4234     int acc_id;  
     4328    int acc_id; 
     4329        PyObject * pObj; 
    42354330    pj_pool_Object * p; 
    42364331    pj_pool_t * pool; 
     
    42404335    pj_str_t uri; 
    42414336 
    4242     if (!PyArg_ParseTuple(pArgs, "OiO", &p, &acc_id, &stru)) 
    4243     { 
    4244         return NULL; 
    4245     } 
    4246          
    4247     pool = p->pool;     
    4248     uri.ptr = PyString_AsString(stru); 
    4249     uri.slen = strlen(PyString_AsString(stru)); 
    4250     status = pjsua_acc_create_uac_contact(pool, &contact, acc_id, &uri); 
     4337    if (!PyArg_ParseTuple(pArgs, "OiO", &pObj, &acc_id, &stru)) 
     4338    { 
     4339        return NULL; 
     4340    } 
     4341    if (pObj != Py_None) 
     4342        { 
     4343        p = (pj_pool_Object *)pObj; 
     4344        pool = p->pool;     
     4345        uri.ptr = PyString_AsString(stru); 
     4346        uri.slen = strlen(PyString_AsString(stru)); 
     4347        status = pjsua_acc_create_uac_contact(pool, &contact, acc_id, &uri); 
     4348        } else { 
     4349        status = pjsua_acc_create_uac_contact(NULL, &contact, acc_id, &uri); 
     4350        } 
    42514351    strc = PyString_FromStringAndSize(contact.ptr, contact.slen); 
    42524352         
     
    42634363    int status; 
    42644364    int acc_id;  
     4365        PyObject * pObj; 
    42654366    pj_pool_Object * p; 
    42664367    pj_pool_t * pool; 
    42674368    PyObject * strc; 
    42684369    pj_str_t contact; 
     4370        PyObject * rObj; 
    42694371    pjsip_rx_data_Object * objr; 
    42704372    pjsip_rx_data * rdata; 
    42714373 
    4272     if (!PyArg_ParseTuple(pArgs, "OiO", &p, &acc_id, &objr)) 
    4273     { 
    4274         return NULL; 
    4275     } 
    4276          
    4277     pool = p->pool; 
    4278      
    4279     rdata = objr->rdata; 
     4374    if (!PyArg_ParseTuple(pArgs, "OiO", &pObj, &acc_id, &rObj)) 
     4375    { 
     4376        return NULL; 
     4377    } 
     4378    if (pObj != Py_None) 
     4379        { 
     4380        p = (pj_pool_Object *)pObj; 
     4381        pool = p->pool; 
     4382    } else { 
     4383                pool = NULL; 
     4384        } 
     4385    if (rObj != Py_None) 
     4386        { 
     4387                objr = (pjsip_rx_data_Object *)rObj; 
     4388        rdata = objr->rdata; 
     4389        } else { 
     4390        rdata = NULL; 
     4391        } 
    42804392    status = pjsua_acc_create_uas_contact(pool, &contact, acc_id, rdata); 
    42814393    strc = PyString_FromStringAndSize(contact.ptr, contact.slen); 
     
    46844796     
    46854797    pjsua_buddy_id id[PJSUA_MAX_BUDDIES]; 
    4686     int c, i; 
     4798    unsigned c, i; 
    46874799    if (!PyArg_ParseTuple(pArgs, "")) 
    46884800    { 
    46894801        return NULL; 
    46904802    }    
    4691      
    46924803    c = PJ_ARRAY_SIZE(id); 
    46934804    status = pjsua_enum_buddies(id, &c); 
    4694      
    46954805    list = PyList_New(c); 
    46964806    for (i = 0; i < c; i++) { 
     
    47004810        } 
    47014811    } 
    4702      
    47034812     
    47044813    return Py_BuildValue("O",list); 
     
    47604869static PyObject *py_pjsua_buddy_add 
    47614870(PyObject *pSelf, PyObject *pArgs) 
    4762 {         
     4871{    
     4872    PyObject * bcObj; 
    47634873    buddy_config_Object * bc; 
     4874         
    47644875    pjsua_buddy_config cfg; 
    47654876     
     
    47674878    int status; 
    47684879 
    4769     if (!PyArg_ParseTuple(pArgs, "O", &bc)) 
    4770     { 
    4771         return NULL; 
    4772     } 
    4773     cfg.subscribe = bc->subscribe; 
    4774     cfg.uri.ptr = PyString_AsString(bc->uri); 
    4775     cfg.uri.slen = strlen(PyString_AsString(bc->uri));     
    4776      
    4777     status = pjsua_buddy_add(&cfg, &p_buddy_id); 
    4778      
     4880    if (!PyArg_ParseTuple(pArgs, "O", &bcObj)) 
     4881    { 
     4882        return NULL; 
     4883    } 
     4884    if (bcObj != Py_None) 
     4885        { 
     4886                bc = (buddy_config_Object *)bcObj; 
     4887 
     4888        cfg.subscribe = bc->subscribe; 
     4889        cfg.uri.ptr = PyString_AsString(bc->uri); 
     4890        cfg.uri.slen = strlen(PyString_AsString(bc->uri));     
     4891     
     4892        status = pjsua_buddy_add(&cfg, &p_buddy_id); 
     4893        } else { 
     4894        status = pjsua_buddy_add(NULL, &p_buddy_id); 
     4895    } 
    47794896    return Py_BuildValue("ii", status, p_buddy_id); 
    47804897} 
     
    48524969    PyObject * sc; 
    48534970    pjsua_msg_data msg_data; 
     4971    PyObject * omdObj; 
    48544972    msg_data_Object * omd; 
    48554973    int user_data; 
    48564974    pj_pool_t *pool; 
    48574975 
    4858     if (!PyArg_ParseTuple(pArgs, "iOOOOi", &acc_id, &st, &smt, &sc, &omd, &user_data)) 
     4976    if (!PyArg_ParseTuple(pArgs, "iOOOOi", &acc_id,  
     4977                &st, &smt, &sc, &omdObj, &user_data)) 
    48594978    { 
    48604979        return NULL; 
     
    48674986    content.ptr = PyString_AsString(sc); 
    48684987    content.slen = strlen(PyString_AsString(sc)); 
    4869     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    4870     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    4871     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    4872     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    4873     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    4874  
    4875     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    4876     status = pjsua_im_send(acc_id, &to, &mime_type, &content, &msg_data, &user_data);    
    4877     pj_pool_release(pool); 
     4988    if (omdObj != Py_None) 
     4989        { 
     4990                 
     4991        omd = (msg_data_Object *)omdObj; 
     4992        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     4993        msg_data.content_type.slen = strlen 
     4994                        (PyString_AsString(omd->content_type)); 
     4995        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     4996        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     4997        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     4998 
     4999        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     5000        status = pjsua_im_send(acc_id, &to, &mime_type,  
     5001                        &content, &msg_data, &user_data);        
     5002        pj_pool_release(pool); 
     5003        } else { 
     5004                 
     5005        status = pjsua_im_send(acc_id, &to, NULL,  
     5006                        &content, NULL, NULL);   
     5007        } 
     5008         
    48785009    return Py_BuildValue("i",status); 
    48795010} 
     
    48915022    int is_typing; 
    48925023    pjsua_msg_data msg_data; 
     5024        PyObject * omdObj; 
    48935025    msg_data_Object * omd; 
    48945026    pj_pool_t * pool; 
    48955027 
    4896     if (!PyArg_ParseTuple(pArgs, "iOiO", &acc_id, &st, &is_typing, &omd)) 
     5028    if (!PyArg_ParseTuple(pArgs, "iOiO", &acc_id, &st, &is_typing, &omdObj)) 
    48975029    { 
    48985030        return NULL; 
     
    49015033    to.ptr = PyString_AsString(st); 
    49025034    to.slen = strlen(PyString_AsString(st));     
    4903     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    4904     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    4905     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    4906     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    4907     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    4908  
    4909     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    4910     status = pjsua_im_typing(acc_id, &to, is_typing, &msg_data);         
    4911     pj_pool_release(pool); 
     5035    if (omdObj != Py_None) 
     5036        { 
     5037        omd = (msg_data_Object *)omdObj; 
     5038        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     5039        msg_data.content_type.slen = strlen 
     5040                        (PyString_AsString(omd->content_type)); 
     5041        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     5042        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     5043        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     5044 
     5045        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     5046        status = pjsua_im_typing(acc_id, &to, is_typing, &msg_data);     
     5047        pj_pool_release(pool); 
     5048        } else { 
     5049        status = pjsua_im_typing(acc_id, &to, is_typing, NULL); 
     5050        } 
    49125051    return Py_BuildValue("i",status); 
    49135052} 
     
    58095948     
    58105949    pjsua_conf_port_id id[PJSUA_MAX_CONF_PORTS]; 
    5811     int c, i; 
     5950    unsigned c, i; 
    58125951    if (!PyArg_ParseTuple(pArgs, "")) 
    58135952    { 
     
    58255964        } 
    58265965    } 
    5827      
    58285966     
    58295967    return Py_BuildValue("O",list); 
     
    58736011{        
    58746012    int p_id; 
     6013        PyObject * oportObj; 
    58756014    pjmedia_port_Object * oport; 
     6015        pjmedia_port * port; 
     6016        PyObject * opoolObj; 
    58766017    pj_pool_Object * opool; 
     6018        pj_pool_t * pool; 
    58776019     
    58786020    int status;  
    58796021     
    58806022 
    5881     if (!PyArg_ParseTuple(pArgs, "OO", &opool, &oport)) 
    5882     { 
    5883         return NULL; 
    5884     } 
    5885          
    5886      
    5887  
    5888     status = pjsua_conf_add_port(opool->pool, oport->port, &p_id); 
     6023    if (!PyArg_ParseTuple(pArgs, "OO", &opoolObj, &oportObj)) 
     6024    { 
     6025        return NULL; 
     6026    } 
     6027    if (opoolObj != Py_None) 
     6028        { 
     6029        opool = (pj_pool_Object *)opoolObj; 
     6030                pool = opool->pool; 
     6031        } else { 
     6032                opool = NULL; 
     6033                pool = NULL; 
     6034    } 
     6035    if (oportObj != Py_None) 
     6036        { 
     6037        oport = (pjmedia_port_Object *)oportObj; 
     6038                port = oport->port; 
     6039        } else { 
     6040        oport = NULL; 
     6041                port = NULL; 
     6042    } 
     6043 
     6044    status = pjsua_conf_add_port(pool, port, &p_id); 
    58896045     
    58906046     
     
    60626218     
    60636219 
    6064     if (!PyArg_ParseTuple(pArgs, "OiOii", &filename, &enc_type, &enc_param, &max_size, &options)) 
     6220    if (!PyArg_ParseTuple(pArgs, "OiOii", &filename,  
     6221                &enc_type, &enc_param, &max_size, &options)) 
    60656222    { 
    60666223        return NULL; 
     
    60706227        strparam.ptr = PyString_AsString(enc_param); 
    60716228        strparam.slen = strlen(PyString_AsString(enc_param)); 
    6072     status = pjsua_recorder_create(&str, enc_type, NULL, max_size, options, &p_id); 
     6229    status = pjsua_recorder_create 
     6230                (&str, enc_type, NULL, max_size, options, &p_id); 
    60736231     
    60746232    return Py_BuildValue("ii", status, p_id); 
     
    61266284     
    61276285    pjmedia_snd_dev_info info[64]; 
    6128     int c, i; 
     6286    unsigned c, i; 
    61296287    if (!PyArg_ParseTuple(pArgs, "")) 
    61306288    { 
     
    61616319    } 
    61626320     
    6163      
    61646321    return Py_BuildValue("O",list); 
    61656322} 
     
    62786435     
    62796436    int status;  
    6280     int p_tail_ms; 
     6437    unsigned p_tail_ms; 
    62816438 
    62826439    if (!PyArg_ParseTuple(pArgs, "")) 
     
    63016458     
    63026459    pjsua_codec_info info[PJMEDIA_CODEC_MGR_MAX_CODECS]; 
    6303     int c, i; 
     6460    unsigned c, i; 
    63046461    if (!PyArg_ParseTuple(pArgs, "")) 
    63056462    { 
     
    63306487    } 
    63316488     
    6332      
     6489 
    63336490    return Py_BuildValue("O",list); 
    63346491} 
     
    64096566    pj_str_t str; 
    64106567    pjmedia_codec_param param; 
     6568        PyObject * tmpObj; 
    64116569    pjmedia_codec_param_Object *obj; 
    64126570     
    64136571     
    6414     if (!PyArg_ParseTuple(pArgs, "OO", &id, &obj)) 
     6572    if (!PyArg_ParseTuple(pArgs, "OO", &id, &tmpObj)) 
    64156573    { 
    64166574        return NULL; 
    64176575    }    
     6576 
    64186577    str.ptr = PyString_AsString(id); 
    64196578    str.slen = strlen(PyString_AsString(id)); 
    6420     param.info.avg_bps = obj->info->avg_bps; 
    6421     param.info.channel_cnt = obj->info->channel_cnt; 
    6422     param.info.clock_rate = obj->info->clock_rate; 
    6423     param.info.frm_ptime = obj->info->frm_ptime; 
    6424     param.info.pcm_bits_per_sample = obj->info->pcm_bits_per_sample; 
    6425     param.info.pt = obj->info->pt; 
    6426     param.setting.cng = obj->setting->cng; 
    6427     param.setting.dec_fmtp_mode = obj->setting->dec_fmtp_mode; 
    6428     param.setting.enc_fmtp_mode = obj->setting->enc_fmtp_mode; 
    6429     param.setting.frm_per_pkt = obj->setting->frm_per_pkt; 
    6430     param.setting.penh = obj->setting->penh; 
    6431     param.setting.plc = obj->setting->plc; 
    6432     param.setting.reserved = obj->setting->reserved; 
    6433     param.setting.vad = obj->setting->vad; 
    6434     status = pjsua_codec_set_param(&str, &param); 
    6435      
     6579    if (tmpObj != Py_None) 
     6580        { 
     6581        obj = (pjmedia_codec_param_Object *)tmpObj; 
     6582        param.info.avg_bps = obj->info->avg_bps; 
     6583        param.info.channel_cnt = obj->info->channel_cnt; 
     6584        param.info.clock_rate = obj->info->clock_rate; 
     6585        param.info.frm_ptime = obj->info->frm_ptime; 
     6586        param.info.pcm_bits_per_sample = obj->info->pcm_bits_per_sample; 
     6587        param.info.pt = obj->info->pt; 
     6588        param.setting.cng = obj->setting->cng; 
     6589        param.setting.dec_fmtp_mode = obj->setting->dec_fmtp_mode; 
     6590        param.setting.enc_fmtp_mode = obj->setting->enc_fmtp_mode; 
     6591        param.setting.frm_per_pkt = obj->setting->frm_per_pkt; 
     6592        param.setting.penh = obj->setting->penh; 
     6593        param.setting.plc = obj->setting->plc; 
     6594        param.setting.reserved = obj->setting->reserved; 
     6595        param.setting.vad = obj->setting->vad; 
     6596        status = pjsua_codec_set_param(&str, &param); 
     6597    } else { 
     6598        status = pjsua_codec_set_param(&str, NULL); 
     6599        } 
    64366600    return Py_BuildValue("i", status); 
    64376601} 
     
    68407004        "connect_duration", T_OBJECT_EX, 
    68417005        offsetof(call_info_Object, connect_duration), 0, 
    6842         "Up-to-date call connected duration (zero when call is not established)" 
     7006        "Up-to-date call connected duration(zero when call is not established)" 
    68437007    }, 
    68447008    { 
     
    69507114     
    69517115    pjsua_transport_id id[PJSUA_MAX_CALLS]; 
    6952     int c, i; 
     7116    unsigned c, i; 
    69537117    if (!PyArg_ParseTuple(pArgs, "")) 
    69547118    { 
     
    69687132        } 
    69697133    } 
    6970      
    69717134     
    69727135    return Py_BuildValue("O",list); 
     
    69857148    unsigned options; 
    69867149    pjsua_msg_data msg_data; 
     7150        PyObject * omdObj; 
    69877151    msg_data_Object * omd; 
    69887152    int user_data; 
     
    69907154    pj_pool_t * pool; 
    69917155 
    6992     if (!PyArg_ParseTuple(pArgs, "iOIiO", &acc_id, &sd, &options, &user_data, &omd)) 
     7156    if (!PyArg_ParseTuple 
     7157                (pArgs, "iOIiO", &acc_id, &sd, &options, &user_data, &omdObj)) 
    69937158    { 
    69947159        return NULL; 
     
    69977162    dst_uri.ptr = PyString_AsString(sd); 
    69987163    dst_uri.slen = strlen(PyString_AsString(sd)); 
    6999      
    7000     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7001     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7002     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7003     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7004     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7005     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7006     status = pjsua_call_make_call(acc_id, &dst_uri, options, &user_data, &msg_data, &call_id);   
    7007     pj_pool_release(pool); 
     7164    if (omdObj != Py_None) { 
     7165                omd = (msg_data_Object *)omdObj; 
     7166        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7167        msg_data.content_type.slen = strlen 
     7168                        (PyString_AsString(omd->content_type)); 
     7169        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7170        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7171        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7172        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7173        status = pjsua_call_make_call(acc_id, &dst_uri,  
     7174                        options, &user_data, &msg_data, &call_id);       
     7175        pj_pool_release(pool); 
     7176        } else { 
     7177        status = pjsua_call_make_call(acc_id, &dst_uri,  
     7178                        options, &user_data, NULL, &call_id);    
     7179        } 
    70087180    return Py_BuildValue("ii",status, call_id); 
    70097181} 
     
    71927364    unsigned code; 
    71937365    pjsua_msg_data msg_data; 
     7366        PyObject * omdObj; 
    71947367    msg_data_Object * omd;     
    71957368    pj_pool_t * pool; 
    71967369 
    7197     if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omd)) 
     7370    if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omdObj)) 
    71987371    { 
    71997372        return NULL; 
     
    72027375    reason.ptr = PyString_AsString(sr); 
    72037376    reason.slen = strlen(PyString_AsString(sr)); 
    7204      
    7205     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7206     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7207     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7208     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7209     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7210     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7211     status = pjsua_call_answer(call_id, code, &reason, &msg_data);       
    7212      
    7213     pj_pool_release(pool); 
     7377    if (omdObj != Py_None) { 
     7378        omd = (msg_data_Object *)omdObj; 
     7379        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7380        msg_data.content_type.slen = strlen 
     7381                        (PyString_AsString(omd->content_type)); 
     7382        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7383        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7384        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7385        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7386         
     7387        status = pjsua_call_answer(call_id, code, &reason, &msg_data);   
     7388     
     7389        pj_pool_release(pool); 
     7390    } else { 
     7391         
     7392        status = pjsua_call_answer(call_id, code, &reason, NULL);        
     7393        } 
    72147394    return Py_BuildValue("i",status); 
    72157395} 
     
    72277407    unsigned code; 
    72287408    pjsua_msg_data msg_data; 
     7409        PyObject * omdObj; 
    72297410    msg_data_Object * omd;     
    72307411    pj_pool_t * pool; 
    72317412 
    7232     if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omd)) 
     7413    if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omdObj)) 
    72337414    { 
    72347415        return NULL; 
     
    72377418    reason.ptr = PyString_AsString(sr); 
    72387419    reason.slen = strlen(PyString_AsString(sr)); 
    7239      
    7240     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7241     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7242     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7243     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7244     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7245     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7246     status = pjsua_call_hangup(call_id, code, &reason, &msg_data);       
    7247     pj_pool_release(pool); 
     7420    if (omdObj != Py_None) { 
     7421        omd = (msg_data_Object *)omdObj; 
     7422        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7423        msg_data.content_type.slen = strlen 
     7424                        (PyString_AsString(omd->content_type)); 
     7425        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7426        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7427        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7428        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7429        status = pjsua_call_hangup(call_id, code, &reason, &msg_data);   
     7430        pj_pool_release(pool); 
     7431        } else { 
     7432        status = pjsua_call_hangup(call_id, code, &reason, NULL);        
     7433        } 
    72487434    return Py_BuildValue("i",status); 
    72497435} 
     
    72587444    int call_id;     
    72597445    pjsua_msg_data msg_data; 
     7446        PyObject * omdObj; 
    72607447    msg_data_Object * omd;     
    72617448    pj_pool_t * pool; 
    72627449 
    7263     if (!PyArg_ParseTuple(pArgs, "iO", &call_id, &omd)) 
    7264     { 
    7265         return NULL; 
    7266     } 
    7267          
    7268     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7269     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7270     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7271     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7272     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7273     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7274     status = pjsua_call_set_hold(call_id, &msg_data);    
    7275     pj_pool_release(pool); 
     7450    if (!PyArg_ParseTuple(pArgs, "iO", &call_id, &omdObj)) 
     7451    { 
     7452        return NULL; 
     7453    } 
     7454 
     7455    if (omdObj != Py_None) { 
     7456        omd = (msg_data_Object *)omdObj; 
     7457        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7458        msg_data.content_type.slen = strlen 
     7459                        (PyString_AsString(omd->content_type)); 
     7460        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7461        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7462        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7463        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7464        status = pjsua_call_set_hold(call_id, &msg_data);        
     7465        pj_pool_release(pool); 
     7466        } else { 
     7467        status = pjsua_call_set_hold(call_id, NULL);     
     7468        } 
    72767469    return Py_BuildValue("i",status); 
    72777470} 
     
    72877480    int unhold; 
    72887481    pjsua_msg_data msg_data; 
     7482    PyObject * omdObj; 
    72897483    msg_data_Object * omd;     
    72907484    pj_pool_t * pool; 
    72917485 
    7292     if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &unhold, &omd)) 
    7293     { 
    7294         return NULL; 
    7295     } 
    7296          
    7297     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7298     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7299     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7300     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7301     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7302     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7303     status = pjsua_call_reinvite(call_id, unhold, &msg_data);    
    7304     pj_pool_release(pool); 
     7486    if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &unhold, &omdObj)) 
     7487    { 
     7488        return NULL; 
     7489    } 
     7490 
     7491    if (omdObj != Py_None) 
     7492        { 
     7493        omd = (msg_data_Object *)omdObj; 
     7494        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7495        msg_data.content_type.slen = strlen 
     7496                        (PyString_AsString(omd->content_type)); 
     7497        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7498        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7499        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7500        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7501        status = pjsua_call_reinvite(call_id, unhold, &msg_data);        
     7502        pj_pool_release(pool); 
     7503    } else { 
     7504        status = pjsua_call_reinvite(call_id, unhold, NULL); 
     7505    } 
    73057506    return Py_BuildValue("i",status); 
    73067507} 
     
    73177518    PyObject * sd; 
    73187519    pjsua_msg_data msg_data; 
     7520    PyObject * omdObj; 
    73197521    msg_data_Object * omd;     
    73207522    pj_pool_t * pool; 
    73217523 
    7322     if (!PyArg_ParseTuple(pArgs, "iOO", &call_id, &sd, &omd)) 
     7524    if (!PyArg_ParseTuple(pArgs, "iOO", &call_id, &sd, &omdObj)) 
    73237525    { 
    73247526        return NULL; 
     
    73287530    dest.slen = strlen(PyString_AsString(sd)); 
    73297531     
    7330     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7331     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7332     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7333     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7334     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7335     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7336     status = pjsua_call_xfer(call_id, &dest, &msg_data);         
    7337     pj_pool_release(pool); 
     7532    if (omdObj != Py_None) 
     7533        { 
     7534        omd = (msg_data_Object *)omdObj; 
     7535        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7536        msg_data.content_type.slen = strlen 
     7537                        (PyString_AsString(omd->content_type)); 
     7538        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7539        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7540        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7541        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7542        status = pjsua_call_xfer(call_id, &dest, &msg_data);     
     7543        pj_pool_release(pool); 
     7544        } else { 
     7545        status = pjsua_call_xfer(call_id, &dest, NULL);  
     7546        } 
    73387547    return Py_BuildValue("i",status); 
    73397548} 
     
    73507559    unsigned options;     
    73517560    pjsua_msg_data msg_data; 
     7561    PyObject * omdObj; 
    73527562    msg_data_Object * omd;     
    73537563    pj_pool_t * pool; 
    73547564 
    7355     if (!PyArg_ParseTuple(pArgs, "iiIO", &call_id, &dest_call_id, &options, &omd)) 
     7565    if (!PyArg_ParseTuple 
     7566                (pArgs, "iiIO", &call_id, &dest_call_id, &options, &omdObj)) 
    73567567    { 
    73577568        return NULL; 
    73587569    } 
    73597570         
    7360      
    7361     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7362     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7363     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7364     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7365     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7366     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7367     status = pjsua_call_xfer_replaces(call_id, dest_call_id, options, &msg_data);        
    7368     pj_pool_release(pool); 
     7571    if (omdObj != Py_None) 
     7572        { 
     7573        omd = (msg_data_Object *)omdObj;     
     7574        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7575        msg_data.content_type.slen = strlen 
     7576                        (PyString_AsString(omd->content_type)); 
     7577        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7578        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7579        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7580        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7581        status = pjsua_call_xfer_replaces 
     7582                        (call_id, dest_call_id, options, &msg_data);     
     7583        pj_pool_release(pool); 
     7584        } else { 
     7585        status = pjsua_call_xfer_replaces(call_id, dest_call_id,options, NULL);  
     7586        } 
    73697587    return Py_BuildValue("i",status); 
    73707588} 
     
    74047622    PyObject * sc; 
    74057623    pjsua_msg_data msg_data; 
     7624    PyObject * omdObj; 
    74067625    msg_data_Object * omd;     
    74077626    int user_data; 
    74087627    pj_pool_t * pool; 
    74097628 
    7410     if (!PyArg_ParseTuple(pArgs, "iOOOi", &call_id, &sm, &sc, &omd, &user_data)) 
     7629    if (!PyArg_ParseTuple 
     7630                (pArgs, "iOOOi", &call_id, &sm, &sc, &omdObj, &user_data)) 
    74117631    { 
    74127632        return NULL; 
     
    74187638    content.slen = strlen(PyString_AsString(sc)); 
    74197639     
    7420     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7421     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7422     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7423     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7424     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7425     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7426     status = pjsua_call_send_im(call_id, &mime_type, &content, &msg_data, &user_data);   
    7427     pj_pool_release(pool); 
     7640    if (omdObj != Py_None) 
     7641        { 
     7642        omd = (msg_data_Object *)omdObj; 
     7643        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7644        msg_data.content_type.slen = strlen 
     7645                        (PyString_AsString(omd->content_type)); 
     7646        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7647        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7648        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7649        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7650        status = pjsua_call_send_im 
     7651                        (call_id, &mime_type, &content, &msg_data, &user_data);  
     7652        pj_pool_release(pool); 
     7653        } else { 
     7654        status = pjsua_call_send_im 
     7655                        (call_id, &mime_type, &content, NULL, &user_data);       
     7656        } 
    74287657    return Py_BuildValue("i",status); 
    74297658} 
     
    74397668    int is_typing; 
    74407669    pjsua_msg_data msg_data; 
     7670    PyObject * omdObj; 
    74417671    msg_data_Object * omd;     
    74427672    pj_pool_t * pool; 
    74437673 
    7444     if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &is_typing, &omd)) 
     7674    if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &is_typing, &omdObj)) 
    74457675    { 
    74467676        return NULL; 
    74477677    } 
    74487678         
    7449     msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
    7450     msg_data.content_type.slen = strlen(PyString_AsString(omd->content_type)); 
    7451     msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
    7452     msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
    7453     pool = pjsua_pool_create("pjsua", 4000, 4000); 
    7454     translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
    7455     status = pjsua_call_send_typing_ind(call_id, is_typing, &msg_data);  
    7456     pj_pool_release(pool); 
     7679    if (omdObj != Py_None) 
     7680        { 
     7681        omd = (msg_data_Object *)omdObj; 
     7682        msg_data.content_type.ptr = PyString_AsString(omd->content_type); 
     7683        msg_data.content_type.slen = strlen 
     7684                        (PyString_AsString(omd->content_type)); 
     7685        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body); 
     7686        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body)); 
     7687        pool = pjsua_pool_create("pjsua", 4000, 4000); 
     7688        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list); 
     7689        status = pjsua_call_send_typing_ind(call_id, is_typing, &msg_data);      
     7690        pj_pool_release(pool); 
     7691        } else { 
     7692        status = pjsua_call_send_typing_ind(call_id, is_typing, NULL);   
     7693        } 
    74577694    return Py_BuildValue("i",status); 
    74587695} 
     
    75857822/* END OF LIB CALL */ 
    75867823 
    7587 /* For testing purpose only */ 
    7588  
    7589 struct call_data 
    7590 { 
    7591     pj_timer_entry          timer; 
    7592 }; 
    7593  
    7594 /* 
    7595  * call_data_Object 
    7596  */ 
    7597 typedef struct 
    7598 { 
    7599     PyObject_HEAD 
    7600     /* Type-specific fields go here. */ 
    7601     struct call_data * data; 
    7602 } call_data_Object; 
    7603  
    7604  
    7605 /* 
    7606  * call_data_Type 
    7607  */ 
    7608 static PyTypeObject call_data_Type = 
    7609 { 
    7610     PyObject_HEAD_INIT(NULL) 
    7611     0,                              /*ob_size*/ 
    7612     "py_pjsua.Call_Data",       /*tp_name*/ 
    7613     sizeof(call_data_Object),   /*tp_basicsize*/ 
    7614     0,                              /*tp_itemsize*/ 
    7615     0,                              /*tp_dealloc*/ 
    7616     0,                              /*tp_print*/ 
    7617     0,                              /*tp_getattr*/ 
    7618     0,                              /*tp_setattr*/ 
    7619     0,                              /*tp_compare*/ 
    7620     0,                              /*tp_repr*/ 
    7621     0,                              /*tp_as_number*/ 
    7622     0,                              /*tp_as_sequence*/ 
    7623     0,                              /*tp_as_mapping*/ 
    7624     0,                              /*tp_hash */ 
    7625     0,                              /*tp_call*/ 
    7626     0,                              /*tp_str*/ 
    7627     0,                              /*tp_getattro*/ 
    7628     0,                              /*tp_setattro*/ 
    7629     0,                              /*tp_as_buffer*/ 
    7630     Py_TPFLAGS_DEFAULT,             /*tp_flags*/ 
    7631     "call_data objects",        /*tp_doc*/ 
    7632 }; 
    7633  
    7634 static void call_timeout_callback(pj_timer_heap_t *timer_heap, 
    7635                                   struct pj_timer_entry *entry, unsigned duration) 
    7636 { 
    7637     pjsua_call_id call_id = entry->id; 
    7638     pjsua_msg_data msg_data; 
    7639     pjsip_generic_string_hdr warn; 
    7640     pj_str_t hname = pj_str("Warning"); 
    7641     pj_str_t hvalue = pj_str("399 pjsua \"Call duration exceeded\""); 
    7642  
    7643     PJ_UNUSED_ARG(timer_heap); 
    7644  
    7645     if (call_id == PJSUA_INVALID_ID) { 
    7646         PJ_LOG(1,(THIS_FILE, "Invalid call ID in timer callback")); 
    7647         return; 
    7648     } 
    7649      
    7650     /* Add warning header */ 
    7651     pjsua_msg_data_init(&msg_data); 
    7652     pjsip_generic_string_hdr_init2(&warn, &hname, &hvalue); 
    7653     pj_list_push_back(&msg_data.hdr_list, &warn); 
    7654  
    7655     /* Call duration has been exceeded; disconnect the call */ 
    7656     PJ_LOG(3,(THIS_FILE, "Duration (%d seconds) has been exceeded " 
    7657                          "for call %d, disconnecting the call", 
    7658                          duration, call_id)); 
    7659     entry->id = PJSUA_INVALID_ID; 
    7660     pjsua_call_hangup(call_id, 200, NULL, &msg_data); 
    7661 } 
    7662  
    7663 /*static PyObject *py_pjsua_call_timeout_callback 
    7664 (PyObject *pSelf, PyObject *pArgs) 
    7665 {        
    7666  
    7667     if (!PyArg_ParseTuple(pArgs, "")) 
    7668     { 
    7669         return NULL; 
    7670     }    
    7671      
    7672     call_timeout_callback(); 
    7673      
    7674     Py_INCREF(Py_None); 
    7675     return Py_None; 
    7676 }*/ 
    7677  
    7678 static void on_call_state_1() { 
    7679 /*      if app_config.call_data[call_id].timer.id != PJSUA_INVALID_ID) { 
    7680             struct call_data *cd = &app_config.call_data[call_id]; 
    7681             pjsip_endpoint *endpt = pjsua_get_pjsip_endpt(); 
    7682  
    7683             cd->timer.id = PJSUA_INVALID_ID; 
    7684             pjsip_endpt_cancel_timer(endpt, &cd->timer); 
    7685         } 
    7686  
    7687         PJ_LOG(3,(THIS_FILE, "Call %d is DISCONNECTED [reason=%d (%s)]",  
    7688                   call_id, 
    7689                   call_info.last_status, 
    7690                   call_info.last_status_text.ptr));*/ 
    7691 } 
    7692  
    7693 /* END OF Testing section */ 
    7694  
    76957824/* 
    76967825 * Map of function names to functions 
Note: See TracChangeset for help on using the changeset viewer.