~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/pjsip-apps/src/py_pjsua/py_pjsua.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* $Id: py_pjsua.c 3553 2011-05-05 06:14:19Z nanang $ */
 
2
/* 
 
3
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 
4
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 
19
 */
 
20
#include "py_pjsua.h"
 
21
 
 
22
#define THIS_FILE    "main.c"
 
23
#define POOL_SIZE    4000
 
24
#define SND_DEV_NUM  64
 
25
#define SND_NAME_LEN  64
 
26
 
 
27
/* LIB BASE */
 
28
 
 
29
static PyObject* obj_log_cb;
 
30
static long thread_id;
 
31
 
 
32
#define ENTER_PYTHON()      PyGILState_STATE state = PyGILState_Ensure()
 
33
#define LEAVE_PYTHON()      PyGILState_Release(state)
 
34
 
 
35
/*
 
36
 * cb_log_cb
 
37
 * declares method for reconfiguring logging process for callback struct
 
38
 */
 
39
static void cb_log_cb(int level, const char *data, int len)
 
40
{
 
41
        
 
42
    /* Ignore if this callback is called from alien thread context,
 
43
     * or otherwise it will crash Python.
 
44
     */
 
45
    if (pj_thread_local_get(thread_id) == 0)
 
46
        return;
 
47
 
 
48
    if (PyCallable_Check(obj_log_cb))
 
49
    {
 
50
        ENTER_PYTHON();
 
51
 
 
52
        PyObject_CallFunctionObjArgs(
 
53
            obj_log_cb, Py_BuildValue("i",level),
 
54
            PyString_FromString(data), Py_BuildValue("i",len), NULL
 
55
        );
 
56
 
 
57
        LEAVE_PYTHON();
 
58
    }
 
59
}
 
60
 
 
61
 
 
62
 
 
63
/*
 
64
 * The global callback object.
 
65
 */
 
66
static PyObj_pjsua_callback * g_obj_callback;
 
67
 
 
68
 
 
69
/*
 
70
 * cb_on_call_state
 
71
 * declares method on_call_state for callback struct
 
72
 */
 
73
static void cb_on_call_state(pjsua_call_id call_id, pjsip_event *e)
 
74
{
 
75
    if (PyCallable_Check(g_obj_callback->on_call_state))
 
76
    {   
 
77
        PyObj_pjsip_event * obj;
 
78
 
 
79
        ENTER_PYTHON();
 
80
 
 
81
        obj = (PyObj_pjsip_event *)PyType_GenericNew(&PyTyp_pjsip_event,
 
82
                                                      NULL, NULL);
 
83
                
 
84
        obj->event = e;
 
85
                
 
86
        PyObject_CallFunctionObjArgs(
 
87
            g_obj_callback->on_call_state,
 
88
            Py_BuildValue("i",call_id),
 
89
            obj,
 
90
            NULL
 
91
        );
 
92
 
 
93
        LEAVE_PYTHON();
 
94
    }
 
95
}
 
96
 
 
97
 
 
98
/*
 
99
 * cb_on_incoming_call
 
100
 * declares method on_incoming_call for callback struct
 
101
 */
 
102
static void cb_on_incoming_call(pjsua_acc_id acc_id, pjsua_call_id call_id,
 
103
                                pjsip_rx_data *rdata)
 
104
{
 
105
    if (PyCallable_Check(g_obj_callback->on_incoming_call))
 
106
    {
 
107
        PyObj_pjsip_rx_data * obj;
 
108
 
 
109
        ENTER_PYTHON();
 
110
 
 
111
        obj = (PyObj_pjsip_rx_data *)PyType_GenericNew(&PyTyp_pjsip_rx_data, 
 
112
                                                        NULL, NULL);
 
113
        obj->rdata = rdata;
 
114
 
 
115
        PyObject_CallFunctionObjArgs(
 
116
                g_obj_callback->on_incoming_call,
 
117
                Py_BuildValue("i",acc_id),
 
118
                Py_BuildValue("i",call_id),
 
119
                obj,
 
120
                NULL
 
121
        );
 
122
 
 
123
        LEAVE_PYTHON();
 
124
    }
 
125
}
 
126
 
 
127
 
 
128
/*
 
129
 * cb_on_call_media_state
 
130
 * declares method on_call_media_state for callback struct
 
131
 */
 
132
static void cb_on_call_media_state(pjsua_call_id call_id)
 
133
{
 
134
    if (PyCallable_Check(g_obj_callback->on_call_media_state))
 
135
    {
 
136
        ENTER_PYTHON();
 
137
 
 
138
        PyObject_CallFunction(
 
139
            g_obj_callback->on_call_media_state,
 
140
            "i",
 
141
            call_id,
 
142
            NULL
 
143
        );
 
144
 
 
145
        LEAVE_PYTHON();
 
146
    }
 
147
}
 
148
 
 
149
 
 
150
/*
 
151
 * cb_on_dtmf_digit()
 
152
 * Callback from PJSUA-LIB on receiving DTMF digit
 
153
 */
 
154
static void cb_on_dtmf_digit(pjsua_call_id call_id, int digit)
 
155
{
 
156
    if (PyCallable_Check(g_obj_callback->on_dtmf_digit))
 
157
    {
 
158
        char digit_str[10];
 
159
 
 
160
        ENTER_PYTHON();
 
161
 
 
162
        pj_ansi_snprintf(digit_str, sizeof(digit_str), "%c", digit);
 
163
 
 
164
        PyObject_CallFunctionObjArgs(
 
165
            g_obj_callback->on_dtmf_digit,
 
166
            Py_BuildValue("i",call_id),
 
167
            PyString_FromString(digit_str),
 
168
            NULL
 
169
        );
 
170
 
 
171
        LEAVE_PYTHON();
 
172
    }
 
173
}
 
174
 
 
175
 
 
176
/*
 
177
 * Notify application on call being transfered.
 
178
 * !modified @061206
 
179
 */
 
180
static void cb_on_call_transfer_request(pjsua_call_id call_id,
 
181
                                        const pj_str_t *dst,
 
182
                                        pjsip_status_code *code)
 
183
{
 
184
    if (PyCallable_Check(g_obj_callback->on_call_transfer_request))
 
185
    {
 
186
        PyObject * ret;
 
187
        int cd;
 
188
 
 
189
        ENTER_PYTHON();
 
190
 
 
191
        ret = PyObject_CallFunctionObjArgs(
 
192
            g_obj_callback->on_call_transfer_request,
 
193
            Py_BuildValue("i",call_id),
 
194
            PyString_FromStringAndSize(dst->ptr, dst->slen),
 
195
            Py_BuildValue("i",*code),
 
196
            NULL
 
197
        );
 
198
        if (ret != NULL) {
 
199
            if (ret != Py_None) {
 
200
                if (PyArg_Parse(ret,"i",&cd)) {
 
201
                    *code = cd;
 
202
                }
 
203
            }
 
204
        }
 
205
 
 
206
        LEAVE_PYTHON();
 
207
    }
 
208
}
 
209
 
 
210
 
 
211
/*
 
212
 * Notify application of the status of previously sent call
 
213
 * transfer request. Application can monitor the status of the
 
214
 * call transfer request, for example to decide whether to 
 
215
 * terminate existing call.
 
216
 * !modified @061206
 
217
 */
 
218
static void cb_on_call_transfer_status( pjsua_call_id call_id,
 
219
                                        int status_code,
 
220
                                        const pj_str_t *status_text,
 
221
                                        pj_bool_t final,
 
222
                                        pj_bool_t *p_cont)
 
223
{
 
224
    if (PyCallable_Check(g_obj_callback->on_call_transfer_status))
 
225
    {
 
226
        PyObject * ret;
 
227
        int cnt;
 
228
 
 
229
        ENTER_PYTHON();
 
230
 
 
231
        ret = PyObject_CallFunctionObjArgs(
 
232
            g_obj_callback->on_call_transfer_status,
 
233
            Py_BuildValue("i",call_id),
 
234
            Py_BuildValue("i",status_code),
 
235
            PyString_FromStringAndSize(status_text->ptr, status_text->slen),
 
236
            Py_BuildValue("i",final),
 
237
            Py_BuildValue("i",*p_cont),
 
238
            NULL
 
239
        );
 
240
        if (ret != NULL) {
 
241
            if (ret != Py_None) {
 
242
                if (PyArg_Parse(ret,"i",&cnt)) {
 
243
                    *p_cont = cnt;
 
244
                }
 
245
            }
 
246
        }
 
247
 
 
248
        LEAVE_PYTHON();
 
249
    }
 
250
}
 
251
 
 
252
 
 
253
/*
 
254
 * Notify application about incoming INVITE with Replaces header.
 
255
 * Application may reject the request by setting non-2xx code.
 
256
 * !modified @061206
 
257
 */
 
258
static void cb_on_call_replace_request( pjsua_call_id call_id,
 
259
                                        pjsip_rx_data *rdata,
 
260
                                        int *st_code,
 
261
                                        pj_str_t *st_text)
 
262
{
 
263
    if (PyCallable_Check(g_obj_callback->on_call_replace_request))
 
264
    {
 
265
        PyObject * ret;
 
266
        PyObject * txt;
 
267
        int cd;
 
268
        PyObj_pjsip_rx_data * obj;
 
269
 
 
270
        ENTER_PYTHON();
 
271
 
 
272
        obj = (PyObj_pjsip_rx_data *)PyType_GenericNew(&PyTyp_pjsip_rx_data,
 
273
                                                        NULL, NULL);
 
274
        obj->rdata = rdata;
 
275
 
 
276
        ret = PyObject_CallFunctionObjArgs(
 
277
            g_obj_callback->on_call_replace_request,
 
278
            Py_BuildValue("i",call_id),
 
279
            obj,
 
280
            Py_BuildValue("i",*st_code),
 
281
            PyString_FromStringAndSize(st_text->ptr, st_text->slen),
 
282
            NULL
 
283
        );
 
284
        if (ret != NULL) {
 
285
            if (ret != Py_None) {
 
286
                if (PyArg_ParseTuple(ret,"iO",&cd, &txt)) {
 
287
                    *st_code = cd;
 
288
                    st_text->ptr = PyString_AsString(txt);
 
289
                    st_text->slen = strlen(PyString_AsString(txt));
 
290
                }
 
291
            }
 
292
        }
 
293
 
 
294
        LEAVE_PYTHON();
 
295
    }
 
296
}
 
297
 
 
298
 
 
299
/*
 
300
 * Notify application that an existing call has been replaced with
 
301
 * a new call. This happens when PJSUA-API receives incoming INVITE
 
302
 * request with Replaces header.
 
303
 */
 
304
static void cb_on_call_replaced(pjsua_call_id old_call_id,
 
305
                                pjsua_call_id new_call_id)
 
306
{
 
307
    if (PyCallable_Check(g_obj_callback->on_call_replaced))
 
308
    {
 
309
        ENTER_PYTHON();
 
310
 
 
311
        PyObject_CallFunctionObjArgs(
 
312
            g_obj_callback->on_call_replaced,
 
313
            Py_BuildValue("i",old_call_id),
 
314
            Py_BuildValue("i",new_call_id),
 
315
            NULL
 
316
        );
 
317
 
 
318
        LEAVE_PYTHON();
 
319
    }
 
320
}
 
321
 
 
322
 
 
323
/*
 
324
 * cb_on_reg_state
 
325
 * declares method on_reg_state for callback struct
 
326
 */
 
327
static void cb_on_reg_state(pjsua_acc_id acc_id)
 
328
{
 
329
    if (PyCallable_Check(g_obj_callback->on_reg_state))
 
330
    {
 
331
        ENTER_PYTHON();
 
332
 
 
333
        PyObject_CallFunction(
 
334
            g_obj_callback->on_reg_state,
 
335
            "i",
 
336
            acc_id,
 
337
            NULL
 
338
        );
 
339
 
 
340
        LEAVE_PYTHON();
 
341
    }
 
342
}
 
343
 
 
344
 
 
345
/*
 
346
 * cb_on_buddy_state
 
347
 * declares method on_buddy state for callback struct
 
348
 */
 
349
static void cb_on_buddy_state(pjsua_buddy_id buddy_id)
 
350
{
 
351
    if (PyCallable_Check(g_obj_callback->on_buddy_state))
 
352
    {
 
353
        ENTER_PYTHON();
 
354
 
 
355
        PyObject_CallFunction(
 
356
            g_obj_callback->on_buddy_state,
 
357
            "i",
 
358
            buddy_id,
 
359
            NULL
 
360
        );
 
361
 
 
362
        LEAVE_PYTHON();
 
363
    }
 
364
}
 
365
 
 
366
/*
 
367
 * cb_on_pager
 
368
 * declares method on_pager for callback struct
 
369
 */
 
370
static void cb_on_pager(pjsua_call_id call_id, const pj_str_t *from,
 
371
                        const pj_str_t *to, const pj_str_t *contact,
 
372
                        const pj_str_t *mime_type, const pj_str_t *body)
 
373
{
 
374
    if (PyCallable_Check(g_obj_callback->on_pager))
 
375
    {
 
376
        ENTER_PYTHON();
 
377
 
 
378
        PyObject_CallFunctionObjArgs(
 
379
            g_obj_callback->on_pager,Py_BuildValue("i",call_id),
 
380
            PyString_FromStringAndSize(from->ptr, from->slen),
 
381
            PyString_FromStringAndSize(to->ptr, to->slen),
 
382
            PyString_FromStringAndSize(contact->ptr, contact->slen),
 
383
            PyString_FromStringAndSize(mime_type->ptr, mime_type->slen),
 
384
            PyString_FromStringAndSize(body->ptr, body->slen), 
 
385
            NULL
 
386
        );
 
387
 
 
388
        LEAVE_PYTHON();
 
389
    }
 
390
}
 
391
 
 
392
 
 
393
/*
 
394
 * cb_on_pager_status
 
395
 * declares method on_pager_status for callback struct
 
396
 */
 
397
static void cb_on_pager_status(pjsua_call_id call_id, const pj_str_t *to,
 
398
                                const pj_str_t *body, void *user_data,
 
399
                                pjsip_status_code status,
 
400
                                const pj_str_t *reason)
 
401
{
 
402
    if (PyCallable_Check(g_obj_callback->on_pager))
 
403
    {
 
404
        PyObject * obj_user_data;
 
405
 
 
406
        ENTER_PYTHON();
 
407
 
 
408
        obj_user_data = Py_BuildValue("i", user_data);
 
409
 
 
410
        PyObject_CallFunctionObjArgs(
 
411
            g_obj_callback->on_pager_status,
 
412
            Py_BuildValue("i",call_id),
 
413
            PyString_FromStringAndSize(to->ptr, to->slen),
 
414
            PyString_FromStringAndSize(body->ptr, body->slen), 
 
415
            obj_user_data,
 
416
            Py_BuildValue("i",status),
 
417
            PyString_FromStringAndSize(reason->ptr,reason->slen),
 
418
            NULL
 
419
        );
 
420
 
 
421
        LEAVE_PYTHON();
 
422
    }
 
423
}
 
424
 
 
425
 
 
426
/*
 
427
 * cb_on_typing
 
428
 * declares method on_typing for callback struct
 
429
 */
 
430
static void cb_on_typing(pjsua_call_id call_id, const pj_str_t *from,
 
431
                            const pj_str_t *to, const pj_str_t *contact,
 
432
                            pj_bool_t is_typing)
 
433
{
 
434
    if (PyCallable_Check(g_obj_callback->on_typing))
 
435
    {
 
436
        ENTER_PYTHON();
 
437
 
 
438
        PyObject_CallFunctionObjArgs(
 
439
            g_obj_callback->on_typing,Py_BuildValue("i",call_id),
 
440
            PyString_FromStringAndSize(from->ptr, from->slen),
 
441
            PyString_FromStringAndSize(to->ptr, to->slen),
 
442
            PyString_FromStringAndSize(contact->ptr, contact->slen),
 
443
            Py_BuildValue("i",is_typing),
 
444
            NULL
 
445
        );
 
446
 
 
447
        LEAVE_PYTHON();
 
448
    }
 
449
}
 
450
 
 
451
 
 
452
 
 
453
/* 
 
454
 * translate_hdr
 
455
 * internal function 
 
456
 * translate from hdr_list to pjsip_generic_string_hdr
 
457
 */
 
458
void translate_hdr(pj_pool_t *pool, pjsip_hdr *hdr, PyObject *py_hdr_list)
 
459
{
 
460
    pj_list_init(hdr);
 
461
 
 
462
    if (PyList_Check(py_hdr_list)) {
 
463
        int i;
 
464
 
 
465
        for (i = 0; i < PyList_Size(py_hdr_list); i++) 
 
466
        { 
 
467
            pj_str_t hname, hvalue;
 
468
            pjsip_generic_string_hdr * new_hdr;
 
469
            PyObject * tuple = PyList_GetItem(py_hdr_list, i);
 
470
 
 
471
            if (PyTuple_Check(tuple)) 
 
472
            {
 
473
                hname.ptr = PyString_AsString(PyTuple_GetItem(tuple,0));
 
474
                hname.slen = strlen(PyString_AsString
 
475
                                        (PyTuple_GetItem(tuple,0)));
 
476
                hvalue.ptr = PyString_AsString(PyTuple_GetItem(tuple,1));
 
477
                hvalue.slen = strlen(PyString_AsString
 
478
                                        (PyTuple_GetItem(tuple,1)));
 
479
            } else {
 
480
                hname.ptr = "";
 
481
                hname.slen = 0;
 
482
                hvalue.ptr = "";
 
483
                hvalue.slen = 0;
 
484
            }  
 
485
            new_hdr = pjsip_generic_string_hdr_create(pool, &hname, &hvalue);
 
486
            pj_list_push_back((pj_list_type *)hdr, (pj_list_type *)new_hdr);
 
487
        }     
 
488
    }
 
489
}
 
490
 
 
491
/* 
 
492
 * translate_hdr_rev
 
493
 * internal function
 
494
 * translate from pjsip_generic_string_hdr to hdr_list
 
495
 */
 
496
 
 
497
void translate_hdr_rev(pjsip_generic_string_hdr *hdr, PyObject *py_hdr_list)
 
498
{
 
499
    int i;
 
500
    int len;
 
501
    pjsip_generic_string_hdr * p_hdr;
 
502
 
 
503
    len = pj_list_size(hdr);
 
504
    
 
505
    if (len > 0) 
 
506
    {
 
507
        p_hdr = hdr;
 
508
        Py_XDECREF(py_hdr_list);
 
509
        py_hdr_list = PyList_New(len);
 
510
 
 
511
        for (i = 0; i < len && p_hdr != NULL; i++) 
 
512
        {
 
513
            PyObject * tuple;
 
514
            PyObject * str;
 
515
 
 
516
            tuple = PyTuple_New(2);
 
517
            
 
518
            str = PyString_FromStringAndSize(p_hdr->name.ptr, p_hdr->name.slen);
 
519
            PyTuple_SetItem(tuple, 0, str);
 
520
            str = PyString_FromStringAndSize
 
521
                (hdr->hvalue.ptr, p_hdr->hvalue.slen);
 
522
            PyTuple_SetItem(tuple, 1, str);
 
523
            PyList_SetItem(py_hdr_list, i, tuple);
 
524
            p_hdr = p_hdr->next;
 
525
        }
 
526
    }
 
527
    
 
528
    
 
529
}
 
530
 
 
531
/*
 
532
 * py_pjsua_thread_register
 
533
 * !added @ 061206
 
534
 */
 
535
static PyObject *py_pjsua_thread_register(PyObject *pSelf, PyObject *pArgs)
 
536
{
 
537
        
 
538
    pj_status_t status; 
 
539
    const char *name;
 
540
    PyObject *py_desc;
 
541
    pj_thread_t *thread;
 
542
    void *thread_desc;
 
543
#if 0
 
544
    int size;
 
545
    int i;
 
546
    int *td;
 
547
#endif
 
548
 
 
549
    PJ_UNUSED_ARG(pSelf);
 
550
 
 
551
    if (!PyArg_ParseTuple(pArgs, "sO", &name, &py_desc))
 
552
    {
 
553
         return NULL;
 
554
    }
 
555
#if 0
 
556
    size = PyList_Size(py_desc);
 
557
    td = (int *)malloc(size * sizeof(int));
 
558
    for (i = 0; i < size; i++) 
 
559
    {
 
560
        if (!PyArg_Parse(PyList_GetItem(py_desc,i),"i", td[i])) 
 
561
        {
 
562
            return NULL;
 
563
        }
 
564
    }
 
565
    thread_desc = td;
 
566
#else
 
567
    thread_desc = malloc(sizeof(pj_thread_desc));
 
568
#endif
 
569
    status = pj_thread_register(name, thread_desc, &thread);
 
570
 
 
571
    if (status == PJ_SUCCESS)
 
572
        status = pj_thread_local_set(thread_id, (void*)1);
 
573
    return Py_BuildValue("i",status);
 
574
}
 
575
 
 
576
/*
 
577
 * py_pjsua_logging_config_default
 
578
 * !modified @ 051206
 
579
 */
 
580
static PyObject *py_pjsua_logging_config_default(PyObject *pSelf,
 
581
                                                    PyObject *pArgs)
 
582
{
 
583
    PyObj_pjsua_logging_config *obj;    
 
584
    pjsua_logging_config cfg;
 
585
 
 
586
    PJ_UNUSED_ARG(pSelf);
 
587
 
 
588
    if (!PyArg_ParseTuple(pArgs, ""))
 
589
    {
 
590
        return NULL;
 
591
    }
 
592
    
 
593
    pjsua_logging_config_default(&cfg);
 
594
    obj = (PyObj_pjsua_logging_config *) PyObj_pjsua_logging_config_new
 
595
                (&PyTyp_pjsua_logging_config,NULL,NULL);
 
596
    PyObj_pjsua_logging_config_import(obj, &cfg);
 
597
    
 
598
    return (PyObject *)obj;
 
599
}
 
600
 
 
601
 
 
602
/*
 
603
 * py_pjsua_config_default
 
604
 * !modified @ 051206
 
605
 */
 
606
static PyObject *py_pjsua_config_default(PyObject *pSelf, PyObject *pArgs)
 
607
{
 
608
    PyObj_pjsua_config *obj;
 
609
    pjsua_config cfg;
 
610
 
 
611
    PJ_UNUSED_ARG(pSelf);
 
612
 
 
613
    if (!PyArg_ParseTuple(pArgs, ""))
 
614
    {
 
615
        return NULL;
 
616
    }
 
617
    pjsua_config_default(&cfg);
 
618
    obj = (PyObj_pjsua_config *) PyObj_pjsua_config_new(&PyTyp_pjsua_config, NULL, NULL);
 
619
    PyObj_pjsua_config_import(obj, &cfg);
 
620
 
 
621
    return (PyObject *)obj;
 
622
}
 
623
 
 
624
 
 
625
/*
 
626
 * py_pjsua_media_config_default
 
627
 * !modified @ 051206
 
628
 */
 
629
static PyObject * py_pjsua_media_config_default(PyObject *pSelf,
 
630
                                                PyObject *pArgs)
 
631
{
 
632
    PyObj_pjsua_media_config *obj;
 
633
    pjsua_media_config cfg;
 
634
 
 
635
    PJ_UNUSED_ARG(pSelf);
 
636
 
 
637
    if (!PyArg_ParseTuple(pArgs, ""))
 
638
    {
 
639
        return NULL;
 
640
    }
 
641
    pjsua_media_config_default(&cfg);
 
642
    obj = (PyObj_pjsua_media_config *)
 
643
          PyType_GenericNew(&PyTyp_pjsua_media_config, NULL, NULL);
 
644
    PyObj_pjsua_media_config_import(obj, &cfg);
 
645
    return (PyObject *)obj;
 
646
}
 
647
 
 
648
 
 
649
/*
 
650
 * py_pjsua_msg_data_init
 
651
 * !modified @ 051206
 
652
 */
 
653
static PyObject *py_pjsua_msg_data_init(PyObject *pSelf, PyObject *pArgs)
 
654
{
 
655
    PyObj_pjsua_msg_data *obj;
 
656
    pjsua_msg_data msg;
 
657
    
 
658
    PJ_UNUSED_ARG(pSelf);
 
659
 
 
660
    if (!PyArg_ParseTuple(pArgs, ""))
 
661
    {
 
662
        return NULL;
 
663
    }
 
664
    pjsua_msg_data_init(&msg);
 
665
    obj = (PyObj_pjsua_msg_data *)PyObj_pjsua_msg_data_new(&PyTyp_pjsua_msg_data, NULL, NULL);
 
666
    Py_XDECREF(obj->content_type);
 
667
    obj->content_type = PyString_FromStringAndSize(
 
668
        msg.content_type.ptr, msg.content_type.slen
 
669
    );
 
670
    Py_XDECREF(obj->msg_body);
 
671
    obj->msg_body = PyString_FromStringAndSize(
 
672
        msg.msg_body.ptr, msg.msg_body.slen
 
673
    );
 
674
 
 
675
    translate_hdr_rev((pjsip_generic_string_hdr *)&msg.hdr_list,obj->hdr_list);
 
676
    
 
677
    return (PyObject *)obj;
 
678
}
 
679
 
 
680
 
 
681
/*
 
682
 * py_pjsua_reconfigure_logging
 
683
 */
 
684
static PyObject *py_pjsua_reconfigure_logging(PyObject *pSelf, PyObject *pArgs)
 
685
{
 
686
    PyObject * logObj;
 
687
    PyObj_pjsua_logging_config *log;
 
688
    pjsua_logging_config cfg;
 
689
    pj_status_t status;
 
690
 
 
691
    PJ_UNUSED_ARG(pSelf);
 
692
 
 
693
    if (!PyArg_ParseTuple(pArgs, "O", &logObj))
 
694
    {
 
695
        return NULL;
 
696
    }
 
697
    if (logObj != Py_None) 
 
698
    {
 
699
        log = (PyObj_pjsua_logging_config *)logObj;
 
700
        cfg.msg_logging = log->msg_logging;
 
701
        cfg.level = log->level;
 
702
        cfg.console_level = log->console_level;
 
703
        cfg.decor = log->decor;
 
704
        cfg.log_filename.ptr = PyString_AsString(log->log_filename);
 
705
        cfg.log_filename.slen = strlen(cfg.log_filename.ptr);
 
706
        Py_XDECREF(obj_log_cb);
 
707
        obj_log_cb = log->cb;
 
708
        Py_INCREF(obj_log_cb);
 
709
        cfg.cb = &cb_log_cb;
 
710
        status = pjsua_reconfigure_logging(&cfg);
 
711
    } else {
 
712
        status = pjsua_reconfigure_logging(NULL);
 
713
    }
 
714
    return Py_BuildValue("i",status);
 
715
}
 
716
 
 
717
 
 
718
/*
 
719
 * py_pjsua_pool_create
 
720
 */
 
721
static PyObject *py_pjsua_pool_create(PyObject *pSelf, PyObject *pArgs)
 
722
{
 
723
    pj_size_t init_size;
 
724
    pj_size_t increment;
 
725
    const char * name;
 
726
    pj_pool_t *p;
 
727
    PyObj_pj_pool *pool;
 
728
 
 
729
    PJ_UNUSED_ARG(pSelf);
 
730
 
 
731
    if (!PyArg_ParseTuple(pArgs, "sII", &name, &init_size, &increment))
 
732
    {
 
733
        return NULL;
 
734
    }
 
735
    
 
736
    p = pjsua_pool_create(name, init_size, increment);
 
737
    pool = (PyObj_pj_pool *)PyType_GenericNew(&PyTyp_pj_pool_t, NULL, NULL);
 
738
    pool->pool = p;
 
739
    return (PyObject *)pool;
 
740
 
 
741
}
 
742
 
 
743
 
 
744
/*
 
745
 * py_pjsua_get_pjsip_endpt
 
746
 */
 
747
static PyObject *py_pjsua_get_pjsip_endpt(PyObject *pSelf, PyObject *pArgs)
 
748
{
 
749
    PyObj_pjsip_endpoint *endpt;
 
750
    pjsip_endpoint *e;
 
751
 
 
752
    PJ_UNUSED_ARG(pSelf);
 
753
 
 
754
    if (!PyArg_ParseTuple(pArgs, ""))
 
755
    {
 
756
        return NULL;
 
757
    }
 
758
    e = pjsua_get_pjsip_endpt();
 
759
    endpt = (PyObj_pjsip_endpoint *)PyType_GenericNew(
 
760
        &PyTyp_pjsip_endpoint, NULL, NULL
 
761
    );
 
762
    endpt->endpt = e;
 
763
    return (PyObject *)endpt;
 
764
}
 
765
 
 
766
 
 
767
/*
 
768
 * py_pjsua_get_pjmedia_endpt
 
769
 */
 
770
static PyObject *py_pjsua_get_pjmedia_endpt(PyObject *pSelf, PyObject *pArgs)
 
771
{
 
772
    PyObj_pjmedia_endpt *endpt;
 
773
    pjmedia_endpt *e;
 
774
 
 
775
    PJ_UNUSED_ARG(pSelf);
 
776
 
 
777
    if (!PyArg_ParseTuple(pArgs, ""))
 
778
    {
 
779
        return NULL;
 
780
    }
 
781
    e = pjsua_get_pjmedia_endpt();
 
782
    endpt = (PyObj_pjmedia_endpt *)PyType_GenericNew(
 
783
        &PyTyp_pjmedia_endpt, NULL, NULL
 
784
    );
 
785
    endpt->endpt = e;
 
786
    return (PyObject *)endpt;
 
787
}
 
788
 
 
789
 
 
790
/*
 
791
 * py_pjsua_get_pool_factory
 
792
 */
 
793
static PyObject *py_pjsua_get_pool_factory(PyObject *pSelf, PyObject *pArgs)
 
794
{
 
795
    PyObj_pj_pool_factory *pool;
 
796
    pj_pool_factory *p;
 
797
 
 
798
    PJ_UNUSED_ARG(pSelf);
 
799
 
 
800
    if (!PyArg_ParseTuple(pArgs, ""))
 
801
    {
 
802
        return NULL;
 
803
    }
 
804
    p = pjsua_get_pool_factory();
 
805
    pool = (PyObj_pj_pool_factory *)PyType_GenericNew(
 
806
        &PyTyp_pj_pool_factory, NULL, NULL
 
807
    );
 
808
    pool->pool_fact = p;
 
809
    return (PyObject *)pool;
 
810
}
 
811
 
 
812
 
 
813
/*
 
814
 * py_pjsua_perror
 
815
 */
 
816
static PyObject *py_pjsua_perror(PyObject *pSelf, PyObject *pArgs)
 
817
{
 
818
    const char *sender;
 
819
    const char *title;
 
820
    pj_status_t status;
 
821
 
 
822
    PJ_UNUSED_ARG(pSelf);
 
823
 
 
824
    if (!PyArg_ParseTuple(pArgs, "ssi", &sender, &title, &status))
 
825
    {
 
826
        return NULL;
 
827
    }
 
828
        
 
829
    pjsua_perror(sender, title, status);
 
830
    Py_INCREF(Py_None);
 
831
    return Py_None;
 
832
}
 
833
 
 
834
 
 
835
/*
 
836
 * py_pjsua_create
 
837
 */
 
838
static PyObject *py_pjsua_create(PyObject *pSelf, PyObject *pArgs)
 
839
{
 
840
    pj_status_t status;
 
841
 
 
842
    PJ_UNUSED_ARG(pSelf);
 
843
 
 
844
    if (!PyArg_ParseTuple(pArgs, ""))
 
845
    {
 
846
        return NULL;
 
847
    }
 
848
    status = pjsua_create();
 
849
    
 
850
    if (status == PJ_SUCCESS) 
 
851
    {
 
852
        status = pj_thread_local_alloc(&thread_id);
 
853
        if (status == PJ_SUCCESS)
 
854
            status = pj_thread_local_set(thread_id, (void*)1);
 
855
    }
 
856
 
 
857
    return Py_BuildValue("i",status);
 
858
}
 
859
 
 
860
 
 
861
/*
 
862
 * py_pjsua_init
 
863
 */
 
864
static PyObject *py_pjsua_init(PyObject *pSelf, PyObject *pArgs)
 
865
{
 
866
    pj_status_t status;
 
867
    PyObject *o_ua_cfg, *o_log_cfg, *o_media_cfg;
 
868
    pjsua_config cfg_ua, *p_cfg_ua;
 
869
    pjsua_logging_config cfg_log, *p_cfg_log;
 
870
    pjsua_media_config cfg_media, *p_cfg_media;
 
871
 
 
872
    PJ_UNUSED_ARG(pSelf);
 
873
 
 
874
    if (!PyArg_ParseTuple(pArgs, "OOO", &o_ua_cfg, &o_log_cfg, &o_media_cfg))
 
875
    {
 
876
        return NULL;
 
877
    }
 
878
    
 
879
    pjsua_config_default(&cfg_ua);
 
880
    pjsua_logging_config_default(&cfg_log);
 
881
    pjsua_media_config_default(&cfg_media);
 
882
 
 
883
    if (o_ua_cfg != Py_None) 
 
884
    {
 
885
        PyObj_pjsua_config *obj_ua_cfg = (PyObj_pjsua_config*)o_ua_cfg;
 
886
 
 
887
        PyObj_pjsua_config_export(&cfg_ua, obj_ua_cfg);
 
888
 
 
889
        g_obj_callback = obj_ua_cfg->cb;
 
890
        Py_INCREF(g_obj_callback);
 
891
 
 
892
        cfg_ua.cb.on_call_state = &cb_on_call_state;
 
893
        cfg_ua.cb.on_incoming_call = &cb_on_incoming_call;
 
894
        cfg_ua.cb.on_call_media_state = &cb_on_call_media_state;
 
895
        cfg_ua.cb.on_dtmf_digit = &cb_on_dtmf_digit;
 
896
        cfg_ua.cb.on_call_transfer_request = &cb_on_call_transfer_request;
 
897
        cfg_ua.cb.on_call_transfer_status = &cb_on_call_transfer_status;
 
898
        cfg_ua.cb.on_call_replace_request = &cb_on_call_replace_request;
 
899
        cfg_ua.cb.on_call_replaced = &cb_on_call_replaced;
 
900
        cfg_ua.cb.on_reg_state = &cb_on_reg_state;
 
901
        cfg_ua.cb.on_buddy_state = &cb_on_buddy_state;
 
902
        cfg_ua.cb.on_pager = &cb_on_pager;
 
903
        cfg_ua.cb.on_pager_status = &cb_on_pager_status;
 
904
        cfg_ua.cb.on_typing = &cb_on_typing;
 
905
 
 
906
        p_cfg_ua = &cfg_ua;
 
907
 
 
908
    } else {
 
909
        p_cfg_ua = NULL;
 
910
    }
 
911
 
 
912
    if (o_log_cfg != Py_None) 
 
913
    {
 
914
        PyObj_pjsua_logging_config * obj_log;
 
915
 
 
916
        obj_log = (PyObj_pjsua_logging_config *)o_log_cfg;
 
917
        
 
918
        PyObj_pjsua_logging_config_export(&cfg_log, obj_log);
 
919
 
 
920
        Py_XDECREF(obj_log_cb);
 
921
        obj_log_cb = obj_log->cb;
 
922
        Py_INCREF(obj_log_cb);
 
923
 
 
924
        cfg_log.cb = &cb_log_cb;
 
925
        p_cfg_log = &cfg_log;
 
926
 
 
927
    } else {
 
928
        p_cfg_log = NULL;
 
929
    }
 
930
 
 
931
    if (o_media_cfg != Py_None) 
 
932
    {
 
933
        PyObj_pjsua_media_config_export(&cfg_media, 
 
934
                                        (PyObj_pjsua_media_config*)o_media_cfg);
 
935
        p_cfg_media = &cfg_media;
 
936
 
 
937
    } else {
 
938
        p_cfg_media = NULL;
 
939
    }
 
940
 
 
941
    status = pjsua_init(p_cfg_ua, p_cfg_log, p_cfg_media);
 
942
    return Py_BuildValue("i",status);
 
943
}
 
944
 
 
945
 
 
946
/*
 
947
 * py_pjsua_start
 
948
 */
 
949
static PyObject *py_pjsua_start(PyObject *pSelf, PyObject *pArgs)
 
950
{
 
951
    pj_status_t status;
 
952
 
 
953
    PJ_UNUSED_ARG(pSelf);
 
954
 
 
955
    if (!PyArg_ParseTuple(pArgs, ""))
 
956
    {
 
957
        return NULL;
 
958
    }
 
959
    status = pjsua_start();
 
960
    
 
961
    return Py_BuildValue("i",status);
 
962
}
 
963
 
 
964
 
 
965
/*
 
966
 * py_pjsua_destroy
 
967
 */
 
968
static PyObject *py_pjsua_destroy(PyObject *pSelf, PyObject *pArgs)
 
969
{
 
970
    pj_status_t status;
 
971
 
 
972
    PJ_UNUSED_ARG(pSelf);
 
973
 
 
974
    if (!PyArg_ParseTuple(pArgs, ""))
 
975
    {
 
976
        return NULL;
 
977
    }
 
978
    status = pjsua_destroy();
 
979
    
 
980
    return Py_BuildValue("i",status);
 
981
}
 
982
 
 
983
 
 
984
/*
 
985
 * py_pjsua_handle_events
 
986
 */
 
987
static PyObject *py_pjsua_handle_events(PyObject *pSelf, PyObject *pArgs)
 
988
{
 
989
    int ret;
 
990
    unsigned msec;
 
991
 
 
992
    PJ_UNUSED_ARG(pSelf);
 
993
 
 
994
    if (!PyArg_ParseTuple(pArgs, "i", &msec))
 
995
    {
 
996
        return NULL;
 
997
    }
 
998
 
 
999
    /* Since handle_events() will block, we must wrap it with ALLOW_THREADS
 
1000
     * construct, or otherwise many Python blocking functions (such as
 
1001
     * time.sleep(), readline(), etc.) may hang/block indefinitely.
 
1002
     * See http://www.python.org/doc/current/api/threads.html for more info.
 
1003
     */
 
1004
    Py_BEGIN_ALLOW_THREADS
 
1005
    ret = pjsua_handle_events(msec);
 
1006
    Py_END_ALLOW_THREADS
 
1007
    
 
1008
    return Py_BuildValue("i",ret);
 
1009
}
 
1010
 
 
1011
 
 
1012
/*
 
1013
 * py_pjsua_verify_sip_url
 
1014
 */
 
1015
static PyObject *py_pjsua_verify_sip_url(PyObject *pSelf, PyObject *pArgs)
 
1016
{
 
1017
    pj_status_t status;
 
1018
    const char *url;
 
1019
 
 
1020
    PJ_UNUSED_ARG(pSelf);
 
1021
 
 
1022
    if (!PyArg_ParseTuple(pArgs, "s", &url))
 
1023
    {
 
1024
        return NULL;
 
1025
    }
 
1026
    status = pjsua_verify_sip_url(url);
 
1027
    
 
1028
    return Py_BuildValue("i",status);
 
1029
}
 
1030
 
 
1031
 
 
1032
/*
 
1033
 * function doc
 
1034
 */
 
1035
 
 
1036
static char pjsua_thread_register_doc[] =
 
1037
    "int py_pjsua.thread_register(string name, int[] desc)";
 
1038
static char pjsua_perror_doc[] =
 
1039
    "void py_pjsua.perror (string sender, string title, int status) "
 
1040
    "Display error message for the specified error code. Parameters: "
 
1041
    "sender: The log sender field;  "
 
1042
    "title: Message title for the error; "
 
1043
    "status: Status code.";
 
1044
 
 
1045
static char pjsua_create_doc[] =
 
1046
    "int py_pjsua.create (void) "
 
1047
    "Instantiate pjsua application. Application "
 
1048
    "must call this function before calling any other functions, to make sure "
 
1049
    "that the underlying libraries are properly initialized. Once this "
 
1050
    "function has returned success, application must call pjsua_destroy() "
 
1051
    "before quitting.";
 
1052
 
 
1053
static char pjsua_init_doc[] =
 
1054
    "int py_pjsua.init (py_pjsua.Config obj_ua_cfg, "
 
1055
        "py_pjsua.Logging_Config log_cfg, py_pjsua.Media_Config media_cfg) "
 
1056
    "Initialize pjsua with the specified settings. All the settings are "
 
1057
    "optional, and the default values will be used when the config is not "
 
1058
    "specified. Parameters: "
 
1059
    "obj_ua_cfg : User agent configuration;  "
 
1060
    "log_cfg : Optional logging configuration; "
 
1061
    "media_cfg : Optional media configuration.";
 
1062
 
 
1063
static char pjsua_start_doc[] =
 
1064
    "int py_pjsua.start (void) "
 
1065
    "Application is recommended to call this function after all "
 
1066
    "initialization is done, so that the library can do additional checking "
 
1067
    "set up additional";
 
1068
 
 
1069
static char pjsua_destroy_doc[] =
 
1070
    "int py_pjsua.destroy (void) "
 
1071
    "Destroy pjsua This function must be called once PJSUA is created. To "
 
1072
    "make it easier for application, application may call this function "
 
1073
    "several times with no danger.";
 
1074
 
 
1075
static char pjsua_handle_events_doc[] =
 
1076
    "int py_pjsua.handle_events (int msec_timeout) "
 
1077
    "Poll pjsua for events, and if necessary block the caller thread for the "
 
1078
    "specified maximum interval (in miliseconds) Parameters: "
 
1079
    "msec_timeout: Maximum time to wait, in miliseconds. "
 
1080
    "Returns: The number of events that have been handled during the poll. "
 
1081
    "Negative value indicates error, and application can retrieve the error "
 
1082
    "as (err = -return_value).";
 
1083
 
 
1084
static char pjsua_verify_sip_url_doc[] =
 
1085
    "int py_pjsua.verify_sip_url (string c_url) "
 
1086
    "Verify that valid SIP url is given Parameters: "
 
1087
    "c_url: The URL, as NULL terminated string.";
 
1088
 
 
1089
static char pjsua_pool_create_doc[] =
 
1090
    "py_pjsua.Pj_Pool py_pjsua.pool_create (string name, int init_size, "
 
1091
                                            "int increment) "
 
1092
    "Create memory pool Parameters: "
 
1093
    "name: Optional pool name; "
 
1094
    "init_size: Initial size of the pool;  "
 
1095
    "increment: Increment size.";
 
1096
 
 
1097
static char pjsua_get_pjsip_endpt_doc[] =
 
1098
    "py_pjsua.Pjsip_Endpoint py_pjsua.get_pjsip_endpt (void) "
 
1099
    "Internal function to get SIP endpoint instance of pjsua, which is needed "
 
1100
    "for example to register module, create transports, etc. Probably is only "
 
1101
    "valid after pjsua_init() is called.";
 
1102
 
 
1103
static char pjsua_get_pjmedia_endpt_doc[] =
 
1104
    "py_pjsua.Pjmedia_Endpt py_pjsua.get_pjmedia_endpt (void) "
 
1105
    "Internal function to get media endpoint instance. Only valid after "
 
1106
    "pjsua_init() is called.";
 
1107
 
 
1108
static char pjsua_get_pool_factory_doc[] =
 
1109
    "py_pjsua.Pj_Pool_Factory py_pjsua.get_pool_factory (void) "
 
1110
    "Internal function to get PJSUA pool factory. Only valid after "
 
1111
    "pjsua_init() is called.";
 
1112
 
 
1113
static char pjsua_reconfigure_logging_doc[] =
 
1114
    "int py_pjsua.reconfigure_logging (py_pjsua.Logging_Config c) "
 
1115
    "Application can call this function at any time (after pjsua_create(), of "
 
1116
    "course) to change logging settings. Parameters: "
 
1117
    "c: Logging configuration.";
 
1118
 
 
1119
static char pjsua_logging_config_default_doc[] =
 
1120
    "py_pjsua.Logging_Config py_pjsua.logging_config_default  ()  "
 
1121
    "Use this function to initialize logging config.";
 
1122
 
 
1123
static char pjsua_config_default_doc[] =
 
1124
    "py_pjsua.Config py_pjsua.config_default (). Use this function to "
 
1125
    "initialize pjsua config. ";
 
1126
 
 
1127
static char pjsua_media_config_default_doc[] =
 
1128
    "py_pjsua.Media_Config py_pjsua.media_config_default (). "
 
1129
    "Use this function to initialize media config.";
 
1130
 
 
1131
static char pjsua_msg_data_init_doc[] =
 
1132
    "py_pjsua.Msg_Data void py_pjsua.msg_data_init () "
 
1133
    "Initialize message data ";
 
1134
        
 
1135
 
 
1136
/* END OF LIB BASE */
 
1137
 
 
1138
/* LIB TRANSPORT */
 
1139
 
 
1140
/*
 
1141
 * py_pjsua_transport_config_default
 
1142
 * !modified @ 051206
 
1143
 */
 
1144
static PyObject *py_pjsua_transport_config_default(PyObject *pSelf, 
 
1145
                                                   PyObject *pArgs)
 
1146
{
 
1147
    PyObj_pjsua_transport_config *obj;
 
1148
    pjsua_transport_config cfg;
 
1149
 
 
1150
    PJ_UNUSED_ARG(pSelf);
 
1151
 
 
1152
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1153
        return NULL;
 
1154
    }
 
1155
 
 
1156
    pjsua_transport_config_default(&cfg);
 
1157
    obj = (PyObj_pjsua_transport_config*)
 
1158
          PyObj_pjsua_transport_config_new(&PyTyp_pjsua_transport_config,
 
1159
                                           NULL, NULL);
 
1160
    PyObj_pjsua_transport_config_import(obj, &cfg);
 
1161
 
 
1162
    return (PyObject *)obj;
 
1163
}
 
1164
 
 
1165
/*
 
1166
 * py_pjsua_transport_create
 
1167
 * !modified @ 051206
 
1168
 */
 
1169
static PyObject *py_pjsua_transport_create(PyObject *pSelf, PyObject *pArgs)
 
1170
{
 
1171
    pj_status_t status;
 
1172
    int type;
 
1173
    PyObject * tmpObj;
 
1174
    pjsua_transport_config cfg;
 
1175
    pjsua_transport_id id;
 
1176
 
 
1177
    PJ_UNUSED_ARG(pSelf);
 
1178
 
 
1179
    if (!PyArg_ParseTuple(pArgs, "iO", &type, &tmpObj)) {
 
1180
        return NULL;
 
1181
    }
 
1182
 
 
1183
    if (tmpObj != Py_None) {
 
1184
        PyObj_pjsua_transport_config *obj;
 
1185
        obj = (PyObj_pjsua_transport_config*)tmpObj;
 
1186
        PyObj_pjsua_transport_config_export(&cfg, obj);
 
1187
        status = pjsua_transport_create(type, &cfg, &id);
 
1188
    } else {
 
1189
        status = pjsua_transport_create(type, NULL, &id);
 
1190
    }
 
1191
    
 
1192
    
 
1193
    return Py_BuildValue("ii", status, id);
 
1194
}
 
1195
 
 
1196
/*
 
1197
 * py_pjsua_enum_transports
 
1198
 * !modified @ 261206
 
1199
 */
 
1200
static PyObject *py_pjsua_enum_transports(PyObject *pSelf, PyObject *pArgs)
 
1201
{
 
1202
    pj_status_t status;
 
1203
    PyObject *list;
 
1204
    
 
1205
    pjsua_transport_id id[PJSIP_MAX_TRANSPORTS];
 
1206
    unsigned c, i;
 
1207
 
 
1208
    PJ_UNUSED_ARG(pSelf);
 
1209
 
 
1210
    if (!PyArg_ParseTuple(pArgs, ""))
 
1211
    {
 
1212
        return NULL;
 
1213
    }   
 
1214
    
 
1215
    c = PJ_ARRAY_SIZE(id);
 
1216
    status = pjsua_enum_transports(id, &c);
 
1217
    
 
1218
    list = PyList_New(c);
 
1219
    for (i = 0; i < c; i++) 
 
1220
    {     
 
1221
        int ret = PyList_SetItem(list, i, Py_BuildValue("i", id[i]));
 
1222
        if (ret == -1) 
 
1223
        {
 
1224
            return NULL;
 
1225
        }
 
1226
    }
 
1227
    
 
1228
    return Py_BuildValue("O",list);
 
1229
}
 
1230
 
 
1231
/*
 
1232
 * py_pjsua_transport_get_info
 
1233
 * !modified @ 051206
 
1234
 */
 
1235
static PyObject *py_pjsua_transport_get_info(PyObject *pSelf, PyObject *pArgs)
 
1236
{
 
1237
    pj_status_t status;
 
1238
    int id;
 
1239
    pjsua_transport_info info;
 
1240
    
 
1241
    PJ_UNUSED_ARG(pSelf);
 
1242
 
 
1243
    if (!PyArg_ParseTuple(pArgs, "i", &id)) {
 
1244
        return NULL;
 
1245
    }   
 
1246
    
 
1247
    status = pjsua_transport_get_info(id, &info);       
 
1248
    if (status == PJ_SUCCESS) {
 
1249
        PyObj_pjsua_transport_info *obj;
 
1250
        obj = (PyObj_pjsua_transport_info *) 
 
1251
              PyObj_pjsua_transport_info_new(&PyTyp_pjsua_transport_info, 
 
1252
                                             NULL, NULL);
 
1253
        PyObj_pjsua_transport_info_import(obj, &info);
 
1254
        return Py_BuildValue("O", obj);
 
1255
    } else {
 
1256
        Py_INCREF(Py_None);
 
1257
        return Py_None;
 
1258
    }
 
1259
}
 
1260
 
 
1261
/*
 
1262
 * py_pjsua_transport_set_enable
 
1263
 */
 
1264
static PyObject *py_pjsua_transport_set_enable
 
1265
(PyObject *pSelf, PyObject *pArgs)
 
1266
{
 
1267
    pj_status_t status;
 
1268
    int id;
 
1269
    int enabled;
 
1270
 
 
1271
    PJ_UNUSED_ARG(pSelf);
 
1272
 
 
1273
    if (!PyArg_ParseTuple(pArgs, "ii", &id, &enabled))
 
1274
    {
 
1275
        return NULL;
 
1276
    }   
 
1277
    status = pjsua_transport_set_enable(id, enabled);   
 
1278
    
 
1279
    return Py_BuildValue("i",status);
 
1280
}
 
1281
 
 
1282
/*
 
1283
 * py_pjsua_transport_close
 
1284
 */
 
1285
static PyObject *py_pjsua_transport_close(PyObject *pSelf, PyObject *pArgs)
 
1286
{
 
1287
    pj_status_t status;
 
1288
    int id;
 
1289
    int force;
 
1290
 
 
1291
    PJ_UNUSED_ARG(pSelf);
 
1292
 
 
1293
    if (!PyArg_ParseTuple(pArgs, "ii", &id, &force))
 
1294
    {
 
1295
        return NULL;
 
1296
    }   
 
1297
    status = pjsua_transport_close(id, force);  
 
1298
    
 
1299
    return Py_BuildValue("i",status);
 
1300
}
 
1301
 
 
1302
static char pjsua_transport_config_default_doc[] =
 
1303
    "py_pjsua.Transport_Config py_pjsua.transport_config_default () "
 
1304
    "Call this function to initialize UDP config with default values.";
 
1305
static char pjsua_transport_create_doc[] =
 
1306
    "int, int py_pjsua.transport_create (int type, "
 
1307
    "py_pjsua.Transport_Config cfg) "
 
1308
    "Create SIP transport.";
 
1309
static char pjsua_enum_transports_doc[] =
 
1310
    "int[] py_pjsua.enum_transports () "
 
1311
    "Enumerate all transports currently created in the system.";
 
1312
static char pjsua_transport_get_info_doc[] =
 
1313
    "void py_pjsua.transport_get_info "
 
1314
    "(py_pjsua.Transport_ID id, py_pjsua.Transport_Info info) "
 
1315
    "Get information about transports.";
 
1316
static char pjsua_transport_set_enable_doc[] =
 
1317
    "void py_pjsua.transport_set_enable "
 
1318
    "(py_pjsua.Transport_ID id, int enabled) "
 
1319
    "Disable a transport or re-enable it. "
 
1320
    "By default transport is always enabled after it is created. "
 
1321
    "Disabling a transport does not necessarily close the socket, "
 
1322
    "it will only discard incoming messages and prevent the transport "
 
1323
    "from being used to send outgoing messages.";
 
1324
static char pjsua_transport_close_doc[] =
 
1325
    "void py_pjsua.transport_close (py_pjsua.Transport_ID id, int force) "
 
1326
    "Close the transport. If transport is forcefully closed, "
 
1327
    "it will be immediately closed, and any pending transactions "
 
1328
    "that are using the transport may not terminate properly. "
 
1329
    "Otherwise, the system will wait until all transactions are closed "
 
1330
    "while preventing new users from using the transport, and will close "
 
1331
    "the transport when it is safe to do so.";
 
1332
 
 
1333
/* END OF LIB TRANSPORT */
 
1334
 
 
1335
/* LIB ACCOUNT */
 
1336
 
 
1337
 
 
1338
/*
 
1339
 * py_pjsua_acc_config_default
 
1340
 * !modified @ 051206
 
1341
 */
 
1342
static PyObject *py_pjsua_acc_config_default(PyObject *pSelf, PyObject *pArgs)
 
1343
{
 
1344
    PyObj_pjsua_acc_config *obj;
 
1345
    pjsua_acc_config cfg;
 
1346
 
 
1347
    PJ_UNUSED_ARG(pSelf);
 
1348
 
 
1349
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1350
        return NULL;
 
1351
    }
 
1352
 
 
1353
    pjsua_acc_config_default(&cfg);
 
1354
    obj = (PyObj_pjsua_acc_config *)
 
1355
          PyObj_pjsua_acc_config_new(&PyTyp_pjsua_acc_config, 
 
1356
                                     NULL, NULL);
 
1357
    PyObj_pjsua_acc_config_import(obj, &cfg);
 
1358
    return (PyObject *)obj;
 
1359
}
 
1360
 
 
1361
/*
 
1362
 * py_pjsua_acc_get_count
 
1363
 */
 
1364
static PyObject *py_pjsua_acc_get_count(PyObject *pSelf, PyObject *pArgs)
 
1365
{
 
1366
    int count;
 
1367
 
 
1368
    PJ_UNUSED_ARG(pSelf);
 
1369
 
 
1370
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1371
        return NULL;
 
1372
    }
 
1373
 
 
1374
    count = pjsua_acc_get_count();
 
1375
    return Py_BuildValue("i",count);
 
1376
}
 
1377
 
 
1378
/*
 
1379
 * py_pjsua_acc_is_valid
 
1380
 */
 
1381
static PyObject *py_pjsua_acc_is_valid(PyObject *pSelf, PyObject *pArgs)
 
1382
{    
 
1383
    int id;
 
1384
    int is_valid;
 
1385
 
 
1386
    PJ_UNUSED_ARG(pSelf);
 
1387
 
 
1388
    if (!PyArg_ParseTuple(pArgs, "i", &id)) {
 
1389
        return NULL;
 
1390
    }
 
1391
 
 
1392
    is_valid = pjsua_acc_is_valid(id);  
 
1393
    return Py_BuildValue("i", is_valid);
 
1394
}
 
1395
 
 
1396
/*
 
1397
 * py_pjsua_acc_set_default
 
1398
 */
 
1399
static PyObject *py_pjsua_acc_set_default(PyObject *pSelf, PyObject *pArgs)
 
1400
{    
 
1401
    int id;
 
1402
    int status;
 
1403
 
 
1404
    PJ_UNUSED_ARG(pSelf);
 
1405
 
 
1406
    if (!PyArg_ParseTuple(pArgs, "i", &id)) {
 
1407
        return NULL;
 
1408
    }
 
1409
    status = pjsua_acc_set_default(id);
 
1410
        
 
1411
    return Py_BuildValue("i", status);
 
1412
}
 
1413
 
 
1414
/*
 
1415
 * py_pjsua_acc_get_default
 
1416
 */
 
1417
static PyObject *py_pjsua_acc_get_default(PyObject *pSelf, PyObject *pArgs)
 
1418
{    
 
1419
    int id;
 
1420
        
 
1421
    PJ_UNUSED_ARG(pSelf);
 
1422
 
 
1423
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1424
        return NULL;
 
1425
    }
 
1426
 
 
1427
    id = pjsua_acc_get_default();
 
1428
        
 
1429
    return Py_BuildValue("i", id);
 
1430
}
 
1431
 
 
1432
/*
 
1433
 * py_pjsua_acc_add
 
1434
 * !modified @ 051206
 
1435
 */
 
1436
static PyObject *py_pjsua_acc_add(PyObject *pSelf, PyObject *pArgs)
 
1437
{    
 
1438
    int is_default;
 
1439
    PyObject * acObj;
 
1440
    PyObj_pjsua_acc_config * ac;
 
1441
    int acc_id;
 
1442
    int status;
 
1443
 
 
1444
    PJ_UNUSED_ARG(pSelf);
 
1445
 
 
1446
    if (!PyArg_ParseTuple(pArgs, "Oi", &acObj, &is_default)) {
 
1447
        return NULL;
 
1448
    }
 
1449
    
 
1450
    if (acObj != Py_None) {
 
1451
        pjsua_acc_config cfg;
 
1452
 
 
1453
        pjsua_acc_config_default(&cfg);
 
1454
        ac = (PyObj_pjsua_acc_config *)acObj;
 
1455
        PyObj_pjsua_acc_config_export(&cfg, ac);
 
1456
        status = pjsua_acc_add(&cfg, is_default, &acc_id);
 
1457
    } else {
 
1458
        status = PJ_EINVAL;
 
1459
        acc_id = PJSUA_INVALID_ID;
 
1460
    }
 
1461
    
 
1462
    return Py_BuildValue("ii", status, acc_id);
 
1463
}
 
1464
 
 
1465
/*
 
1466
 * py_pjsua_acc_add_local
 
1467
 * !modified @ 051206
 
1468
 */
 
1469
static PyObject *py_pjsua_acc_add_local(PyObject *pSelf, PyObject *pArgs)
 
1470
{    
 
1471
    int is_default;
 
1472
    int tid;
 
1473
    int p_acc_id;
 
1474
    int status;
 
1475
        
 
1476
    PJ_UNUSED_ARG(pSelf);
 
1477
 
 
1478
    if (!PyArg_ParseTuple(pArgs, "ii", &tid, &is_default)) {
 
1479
        return NULL;
 
1480
    }
 
1481
        
 
1482
    
 
1483
    status = pjsua_acc_add_local(tid, is_default, &p_acc_id);
 
1484
    
 
1485
    return Py_BuildValue("ii", status, p_acc_id);
 
1486
}
 
1487
 
 
1488
/*
 
1489
 * py_pjsua_acc_del
 
1490
 */
 
1491
static PyObject *py_pjsua_acc_del(PyObject *pSelf, PyObject *pArgs)
 
1492
{    
 
1493
    int acc_id;
 
1494
    int status;
 
1495
 
 
1496
    PJ_UNUSED_ARG(pSelf);
 
1497
 
 
1498
    if (!PyArg_ParseTuple(pArgs, "i", &acc_id))
 
1499
    {
 
1500
        return NULL;
 
1501
    }
 
1502
        
 
1503
        
 
1504
    status = pjsua_acc_del(acc_id);     
 
1505
    return Py_BuildValue("i", status);
 
1506
}
 
1507
 
 
1508
/*
 
1509
 * py_pjsua_acc_modify
 
1510
 */
 
1511
static PyObject *py_pjsua_acc_modify(PyObject *pSelf, PyObject *pArgs)
 
1512
{       
 
1513
    PyObject * acObj;
 
1514
    PyObj_pjsua_acc_config * ac;
 
1515
    int acc_id;
 
1516
    int status;
 
1517
 
 
1518
    PJ_UNUSED_ARG(pSelf);
 
1519
 
 
1520
    if (!PyArg_ParseTuple(pArgs, "iO", &acc_id, &acObj)) {
 
1521
        return NULL;
 
1522
    }
 
1523
 
 
1524
    if (acObj != Py_None) {
 
1525
        pjsua_acc_config cfg;   
 
1526
 
 
1527
        pjsua_acc_config_default(&cfg);
 
1528
        ac = (PyObj_pjsua_acc_config *)acObj;
 
1529
        PyObj_pjsua_acc_config_export(&cfg, ac);
 
1530
 
 
1531
        status = pjsua_acc_modify(acc_id, &cfg);
 
1532
    } else {
 
1533
        status = PJ_EINVAL;
 
1534
    }
 
1535
    return Py_BuildValue("i", status);
 
1536
}
 
1537
 
 
1538
/*
 
1539
 * py_pjsua_acc_set_online_status
 
1540
 */
 
1541
static PyObject *py_pjsua_acc_set_online_status(PyObject *pSelf, 
 
1542
                                                PyObject *pArgs)
 
1543
{    
 
1544
    int is_online;      
 
1545
    int acc_id;
 
1546
    int status; 
 
1547
 
 
1548
    PJ_UNUSED_ARG(pSelf);
 
1549
 
 
1550
    if (!PyArg_ParseTuple(pArgs, "ii", &acc_id, &is_online)) {
 
1551
        return NULL;
 
1552
    }
 
1553
        
 
1554
    status = pjsua_acc_set_online_status(acc_id, is_online);
 
1555
        
 
1556
    return Py_BuildValue("i", status);
 
1557
}
 
1558
 
 
1559
/*
 
1560
 * py_pjsua_acc_set_online_status2
 
1561
 */
 
1562
static PyObject *py_pjsua_acc_set_online_status2(PyObject *pSelf, 
 
1563
                                                 PyObject *pArgs)
 
1564
{    
 
1565
    int is_online;      
 
1566
    int acc_id;
 
1567
    int activity_id;
 
1568
    const char *activity_text;
 
1569
    pjrpid_element rpid;
 
1570
    pj_status_t status; 
 
1571
 
 
1572
    PJ_UNUSED_ARG(pSelf);
 
1573
 
 
1574
    if (!PyArg_ParseTuple(pArgs, "iiis", &acc_id, &is_online,
 
1575
                          &activity_id, &activity_text)) {
 
1576
        return NULL;
 
1577
    }
 
1578
 
 
1579
    pj_bzero(&rpid, sizeof(rpid));
 
1580
    rpid.activity = activity_id;
 
1581
    rpid.note = pj_str((char*)activity_text);
 
1582
 
 
1583
    status = pjsua_acc_set_online_status2(acc_id, is_online, &rpid);
 
1584
 
 
1585
    return Py_BuildValue("i", status);
 
1586
}
 
1587
 
 
1588
/*
 
1589
 * py_pjsua_acc_set_registration
 
1590
 */
 
1591
static PyObject *py_pjsua_acc_set_registration(PyObject *pSelf, 
 
1592
                                               PyObject *pArgs)
 
1593
{    
 
1594
    int renew;  
 
1595
    int acc_id;
 
1596
    int status; 
 
1597
 
 
1598
    PJ_UNUSED_ARG(pSelf);
 
1599
 
 
1600
    if (!PyArg_ParseTuple(pArgs, "ii", &acc_id, &renew)) {
 
1601
        return NULL;
 
1602
    }
 
1603
        
 
1604
    status = pjsua_acc_set_registration(acc_id, renew);
 
1605
        
 
1606
    return Py_BuildValue("i", status);
 
1607
}
 
1608
 
 
1609
/*
 
1610
 * py_pjsua_acc_get_info
 
1611
 * !modified @ 051206
 
1612
 */
 
1613
static PyObject *py_pjsua_acc_get_info(PyObject *pSelf, PyObject *pArgs)
 
1614
{       
 
1615
    int acc_id;
 
1616
    PyObj_pjsua_acc_info * obj;
 
1617
    pjsua_acc_info info;
 
1618
    int status; 
 
1619
 
 
1620
    PJ_UNUSED_ARG(pSelf);
 
1621
 
 
1622
    if (!PyArg_ParseTuple(pArgs, "i", &acc_id)) {
 
1623
        return NULL;
 
1624
    }
 
1625
    
 
1626
    status = pjsua_acc_get_info(acc_id, &info);
 
1627
    if (status == PJ_SUCCESS) {
 
1628
        obj = (PyObj_pjsua_acc_info *)
 
1629
            PyObj_pjsua_acc_info_new(&PyTyp_pjsua_acc_info,NULL, NULL);
 
1630
        PyObj_pjsua_acc_info_import(obj, &info);
 
1631
        return Py_BuildValue("O", obj);
 
1632
    } else {
 
1633
        Py_INCREF(Py_None);
 
1634
        return Py_None;
 
1635
    }
 
1636
}
 
1637
 
 
1638
/*
 
1639
 * py_pjsua_enum_accs
 
1640
 * !modified @ 241206
 
1641
 */
 
1642
static PyObject *py_pjsua_enum_accs(PyObject *pSelf, PyObject *pArgs)
 
1643
{
 
1644
    pj_status_t status;
 
1645
    PyObject *list;
 
1646
    
 
1647
    pjsua_acc_id id[PJSUA_MAX_ACC];
 
1648
    unsigned c, i;
 
1649
 
 
1650
    PJ_UNUSED_ARG(pSelf);
 
1651
 
 
1652
    if (!PyArg_ParseTuple(pArgs, ""))
 
1653
    {
 
1654
        return NULL;
 
1655
    }   
 
1656
    c = PJ_ARRAY_SIZE(id);
 
1657
    
 
1658
    status = pjsua_enum_accs(id, &c);
 
1659
    
 
1660
    list = PyList_New(c);
 
1661
    for (i = 0; i < c; i++) 
 
1662
    {
 
1663
        int ret = PyList_SetItem(list, i, Py_BuildValue("i", id[i]));
 
1664
        if (ret == -1) 
 
1665
        {
 
1666
            return NULL;
 
1667
        }
 
1668
    }
 
1669
    
 
1670
    return Py_BuildValue("O",list);
 
1671
}
 
1672
 
 
1673
/*
 
1674
 * py_pjsua_acc_enum_info
 
1675
 * !modified @ 241206
 
1676
 */
 
1677
static PyObject *py_pjsua_acc_enum_info(PyObject *pSelf, PyObject *pArgs)
 
1678
{
 
1679
    pj_status_t status;
 
1680
    PyObject *list;
 
1681
    pjsua_acc_info info[PJSUA_MAX_ACC];
 
1682
    unsigned c, i;
 
1683
 
 
1684
    PJ_UNUSED_ARG(pSelf);
 
1685
 
 
1686
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1687
        return NULL;
 
1688
    }   
 
1689
    
 
1690
    c = PJ_ARRAY_SIZE(info);
 
1691
    status = pjsua_acc_enum_info(info, &c);
 
1692
    
 
1693
    list = PyList_New(c);
 
1694
    for (i = 0; i < c; i++) {
 
1695
        PyObj_pjsua_acc_info *obj;
 
1696
        obj = (PyObj_pjsua_acc_info *)
 
1697
              PyObj_pjsua_acc_info_new(&PyTyp_pjsua_acc_info, NULL, NULL);
 
1698
 
 
1699
        PyObj_pjsua_acc_info_import(obj, &info[i]);
 
1700
 
 
1701
        PyList_SetItem(list, i, (PyObject *)obj);
 
1702
    }
 
1703
    
 
1704
    return Py_BuildValue("O",list);
 
1705
}
 
1706
 
 
1707
/*
 
1708
 * py_pjsua_acc_find_for_outgoing
 
1709
 */
 
1710
static PyObject *py_pjsua_acc_find_for_outgoing(PyObject *pSelf, 
 
1711
                                                PyObject *pArgs)
 
1712
{       
 
1713
    int acc_id; 
 
1714
    PyObject * url;
 
1715
    pj_str_t str;
 
1716
 
 
1717
    PJ_UNUSED_ARG(pSelf);
 
1718
 
 
1719
    if (!PyArg_ParseTuple(pArgs, "O", &url))
 
1720
    {
 
1721
        return NULL;
 
1722
    }
 
1723
    str.ptr = PyString_AsString(url);
 
1724
    str.slen = strlen(PyString_AsString(url));
 
1725
        
 
1726
    acc_id = pjsua_acc_find_for_outgoing(&str);
 
1727
        
 
1728
    return Py_BuildValue("i", acc_id);
 
1729
}
 
1730
 
 
1731
/*
 
1732
 * py_pjsua_acc_find_for_incoming
 
1733
 */
 
1734
static PyObject *py_pjsua_acc_find_for_incoming(PyObject *pSelf, 
 
1735
                                                PyObject *pArgs)
 
1736
{       
 
1737
    int acc_id; 
 
1738
    PyObject * tmpObj;
 
1739
    PyObj_pjsip_rx_data * obj;
 
1740
    pjsip_rx_data * rdata;
 
1741
 
 
1742
    PJ_UNUSED_ARG(pSelf);
 
1743
 
 
1744
    if (!PyArg_ParseTuple(pArgs, "O", &tmpObj))
 
1745
    {
 
1746
        return NULL;
 
1747
    }
 
1748
    if (tmpObj != Py_None)
 
1749
    {
 
1750
        obj = (PyObj_pjsip_rx_data *)tmpObj;
 
1751
        rdata = obj->rdata;
 
1752
        acc_id = pjsua_acc_find_for_incoming(rdata);
 
1753
    } else {
 
1754
        acc_id = pjsua_acc_find_for_incoming(NULL);
 
1755
    }
 
1756
    return Py_BuildValue("i", acc_id);
 
1757
}
 
1758
 
 
1759
/*
 
1760
 * py_pjsua_acc_create_uac_contact
 
1761
 * !modified @ 061206
 
1762
 */
 
1763
static PyObject *py_pjsua_acc_create_uac_contact(PyObject *pSelf, 
 
1764
                                                 PyObject *pArgs)
 
1765
{       
 
1766
    int status;
 
1767
    int acc_id;
 
1768
    PyObject * pObj;
 
1769
    PyObj_pj_pool * p;
 
1770
    pj_pool_t * pool;
 
1771
    PyObject * strc;
 
1772
    pj_str_t contact;
 
1773
    PyObject * stru;
 
1774
    pj_str_t uri;
 
1775
 
 
1776
    PJ_UNUSED_ARG(pSelf);
 
1777
 
 
1778
    if (!PyArg_ParseTuple(pArgs, "OiO", &pObj, &acc_id, &stru))
 
1779
    {
 
1780
        return NULL;
 
1781
    }
 
1782
    if (pObj != Py_None)
 
1783
    {
 
1784
        p = (PyObj_pj_pool *)pObj;
 
1785
        pool = p->pool;    
 
1786
        uri.ptr = PyString_AsString(stru);
 
1787
        uri.slen = strlen(PyString_AsString(stru));
 
1788
        status = pjsua_acc_create_uac_contact(pool, &contact, acc_id, &uri);
 
1789
    } else {
 
1790
        status = pjsua_acc_create_uac_contact(NULL, &contact, acc_id, &uri);
 
1791
    }
 
1792
    strc = PyString_FromStringAndSize(contact.ptr, contact.slen);
 
1793
        
 
1794
    return Py_BuildValue("O", strc);
 
1795
}
 
1796
 
 
1797
/*
 
1798
 * py_pjsua_acc_create_uas_contact
 
1799
 * !modified @ 061206
 
1800
 */
 
1801
static PyObject *py_pjsua_acc_create_uas_contact(PyObject *pSelf, 
 
1802
                                                 PyObject *pArgs)
 
1803
{       
 
1804
    int status;
 
1805
    int acc_id; 
 
1806
    PyObject * pObj;
 
1807
    PyObj_pj_pool * p;
 
1808
    pj_pool_t * pool;
 
1809
    PyObject * strc;
 
1810
    pj_str_t contact;
 
1811
    PyObject * rObj;
 
1812
    PyObj_pjsip_rx_data * objr;
 
1813
    pjsip_rx_data * rdata;
 
1814
 
 
1815
    PJ_UNUSED_ARG(pSelf);
 
1816
 
 
1817
    if (!PyArg_ParseTuple(pArgs, "OiO", &pObj, &acc_id, &rObj))
 
1818
    {
 
1819
        return NULL;
 
1820
    }
 
1821
    if (pObj != Py_None)
 
1822
    {
 
1823
        p = (PyObj_pj_pool *)pObj;
 
1824
        pool = p->pool;
 
1825
    } else {
 
1826
                pool = NULL;
 
1827
    }
 
1828
    if (rObj != Py_None)
 
1829
    {
 
1830
        objr = (PyObj_pjsip_rx_data *)rObj;
 
1831
        rdata = objr->rdata;
 
1832
    } else {
 
1833
        rdata = NULL;
 
1834
    }
 
1835
    status = pjsua_acc_create_uas_contact(pool, &contact, acc_id, rdata);
 
1836
    strc = PyString_FromStringAndSize(contact.ptr, contact.slen);
 
1837
        
 
1838
    return Py_BuildValue("O", strc);
 
1839
}
 
1840
 
 
1841
static char pjsua_acc_config_default_doc[] =
 
1842
    "py_pjsua.Acc_Config py_pjsua.acc_config_default () "
 
1843
    "Call this function to initialize account config with default values.";
 
1844
static char pjsua_acc_get_count_doc[] =
 
1845
    "int py_pjsua.acc_get_count () "
 
1846
    "Get number of current accounts.";
 
1847
static char pjsua_acc_is_valid_doc[] =
 
1848
    "int py_pjsua.acc_is_valid (int acc_id)  "
 
1849
    "Check if the specified account ID is valid.";
 
1850
static char pjsua_acc_set_default_doc[] =
 
1851
    "int py_pjsua.acc_set_default (int acc_id) "
 
1852
    "Set default account to be used when incoming "
 
1853
    "and outgoing requests doesn't match any accounts.";
 
1854
static char pjsua_acc_get_default_doc[] =
 
1855
    "int py_pjsua.acc_get_default () "
 
1856
    "Get default account.";
 
1857
static char pjsua_acc_add_doc[] =
 
1858
    "int, int py_pjsua.acc_add (py_pjsua.Acc_Config cfg, "
 
1859
    "int is_default) "
 
1860
    "Add a new account to pjsua. PJSUA must have been initialized "
 
1861
    "(with pjsua_init()) before calling this function.";
 
1862
static char pjsua_acc_add_local_doc[] =
 
1863
    "int,int py_pjsua.acc_add_local (int tid, "
 
1864
    "int is_default) "
 
1865
    "Add a local account. A local account is used to identify "
 
1866
    "local endpoint instead of a specific user, and for this reason, "
 
1867
    "a transport ID is needed to obtain the local address information.";
 
1868
static char pjsua_acc_del_doc[] =
 
1869
    "int py_pjsua.acc_del (int acc_id) "
 
1870
    "Delete account.";
 
1871
static char pjsua_acc_modify_doc[] =
 
1872
    "int py_pjsua.acc_modify (int acc_id, py_pjsua.Acc_Config cfg) "
 
1873
    "Modify account information.";
 
1874
static char pjsua_acc_set_online_status_doc[] =
 
1875
    "int py_pjsua.acc_set_online_status2(int acc_id, int is_online) "
 
1876
    "Modify account's presence status to be advertised "
 
1877
    "to remote/presence subscribers.";
 
1878
static char pjsua_acc_set_online_status2_doc[] =
 
1879
    "int py_pjsua.acc_set_online_status (int acc_id, int is_online, "
 
1880
                                         "int activity_id, string activity_text) "
 
1881
    "Modify account's presence status to be advertised "
 
1882
    "to remote/presence subscribers.";
 
1883
static char pjsua_acc_set_registration_doc[] =
 
1884
    "int py_pjsua.acc_set_registration (int acc_id, int renew) "
 
1885
    "Update registration or perform unregistration.";
 
1886
static char pjsua_acc_get_info_doc[] =
 
1887
    "py_pjsua.Acc_Info py_pjsua.acc_get_info (int acc_id) "
 
1888
    "Get account information.";
 
1889
static char pjsua_enum_accs_doc[] =
 
1890
    "int[] py_pjsua.enum_accs () "
 
1891
    "Enum accounts all account ids.";
 
1892
static char pjsua_acc_enum_info_doc[] =
 
1893
    "py_pjsua.Acc_Info[] py_pjsua.acc_enum_info () "
 
1894
    "Enum accounts info.";
 
1895
static char pjsua_acc_find_for_outgoing_doc[] =
 
1896
    "int py_pjsua.acc_find_for_outgoing (string url) "
 
1897
    "This is an internal function to find the most appropriate account "
 
1898
    "to used to reach to the specified URL.";
 
1899
static char pjsua_acc_find_for_incoming_doc[] =
 
1900
    "int py_pjsua.acc_find_for_incoming (PyObj_pjsip_rx_data rdata) "
 
1901
    "This is an internal function to find the most appropriate account "
 
1902
    "to be used to handle incoming calls.";
 
1903
static char pjsua_acc_create_uac_contact_doc[] =
 
1904
    "string py_pjsua.acc_create_uac_contact (PyObj_pj_pool pool, "
 
1905
    "int acc_id, string uri) "
 
1906
    "Create a suitable URI to be put as Contact based on the specified "
 
1907
    "target URI for the specified account.";
 
1908
static char pjsua_acc_create_uas_contact_doc[] =
 
1909
    "string py_pjsua.acc_create_uas_contact (PyObj_pj_pool pool, "
 
1910
    "int acc_id, PyObj_pjsip_rx_data rdata) "
 
1911
    "Create a suitable URI to be put as Contact based on the information "
 
1912
    "in the incoming request.";
 
1913
 
 
1914
/* END OF LIB ACCOUNT */
 
1915
 
 
1916
/* LIB BUDDY */
 
1917
 
 
1918
 
 
1919
 
 
1920
/*
 
1921
 * py_pjsua_buddy_config_default
 
1922
 */
 
1923
static PyObject *py_pjsua_buddy_config_default(PyObject *pSelf, 
 
1924
                                               PyObject *pArgs)
 
1925
{    
 
1926
    PyObj_pjsua_buddy_config *obj;      
 
1927
    pjsua_buddy_config cfg;
 
1928
 
 
1929
    PJ_UNUSED_ARG(pSelf);
 
1930
 
 
1931
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1932
        return NULL;
 
1933
    }
 
1934
    
 
1935
    pjsua_buddy_config_default(&cfg);
 
1936
    obj = (PyObj_pjsua_buddy_config *) 
 
1937
          PyObj_pjsua_buddy_config_new(&PyTyp_pjsua_buddy_config, NULL, NULL);
 
1938
    PyObj_pjsua_buddy_config_import(obj, &cfg);
 
1939
    
 
1940
    return (PyObject *)obj;
 
1941
}
 
1942
 
 
1943
/*
 
1944
 * py_pjsua_get_buddy_count
 
1945
 */
 
1946
static PyObject *py_pjsua_get_buddy_count(PyObject *pSelf, PyObject *pArgs)
 
1947
{    
 
1948
    int ret;
 
1949
 
 
1950
    PJ_UNUSED_ARG(pSelf);
 
1951
 
 
1952
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1953
        return NULL;
 
1954
    }
 
1955
    ret = pjsua_get_buddy_count();
 
1956
        
 
1957
    return Py_BuildValue("i", ret);
 
1958
}
 
1959
 
 
1960
/*
 
1961
 * py_pjsua_buddy_is_valid
 
1962
 */
 
1963
static PyObject *py_pjsua_buddy_is_valid(PyObject *pSelf, PyObject *pArgs)
 
1964
{    
 
1965
    int id;
 
1966
    int is_valid;
 
1967
 
 
1968
    PJ_UNUSED_ARG(pSelf);
 
1969
 
 
1970
    if (!PyArg_ParseTuple(pArgs, "i", &id)) {
 
1971
        return NULL;
 
1972
    }
 
1973
    is_valid = pjsua_buddy_is_valid(id);
 
1974
        
 
1975
    return Py_BuildValue("i", is_valid);
 
1976
}
 
1977
 
 
1978
/*
 
1979
 * py_pjsua_enum_buddies
 
1980
 * !modified @ 241206
 
1981
 */
 
1982
static PyObject *py_pjsua_enum_buddies(PyObject *pSelf, PyObject *pArgs)
 
1983
{
 
1984
    pj_status_t status;
 
1985
    PyObject *list;
 
1986
    
 
1987
    pjsua_buddy_id id[PJSUA_MAX_BUDDIES];
 
1988
    unsigned c, i;
 
1989
 
 
1990
    PJ_UNUSED_ARG(pSelf);
 
1991
 
 
1992
    if (!PyArg_ParseTuple(pArgs, "")) {
 
1993
        return NULL;
 
1994
    }   
 
1995
    c = PJ_ARRAY_SIZE(id);
 
1996
    status = pjsua_enum_buddies(id, &c);
 
1997
    list = PyList_New(c);
 
1998
    for (i = 0; i < c; i++) {
 
1999
        PyList_SetItem(list, i, Py_BuildValue("i", id[i]));
 
2000
    }
 
2001
    
 
2002
    return Py_BuildValue("O",list);
 
2003
}
 
2004
 
 
2005
/*
 
2006
 * py_pjsua_buddy_get_info
 
2007
 * !modified @ 071206
 
2008
 */
 
2009
static PyObject *py_pjsua_buddy_get_info(PyObject *pSelf, PyObject *pArgs)
 
2010
{       
 
2011
    int buddy_id;
 
2012
    PyObj_pjsua_buddy_info * obj;
 
2013
    pjsua_buddy_info info;
 
2014
    int status; 
 
2015
 
 
2016
    PJ_UNUSED_ARG(pSelf);
 
2017
 
 
2018
    if (!PyArg_ParseTuple(pArgs, "i", &buddy_id)) {
 
2019
        return NULL;
 
2020
    }
 
2021
 
 
2022
    status = pjsua_buddy_get_info(buddy_id, &info);
 
2023
    if (status == PJ_SUCCESS) {
 
2024
        obj = (PyObj_pjsua_buddy_info *)
 
2025
              PyObj_pjsua_buddy_config_new(&PyTyp_pjsua_buddy_info,NULL,NULL);
 
2026
        PyObj_pjsua_buddy_info_import(obj, &info);      
 
2027
        return Py_BuildValue("O", obj);
 
2028
    } else {
 
2029
        Py_INCREF(Py_None);
 
2030
        return Py_None;
 
2031
    }
 
2032
}
 
2033
 
 
2034
/*
 
2035
 * py_pjsua_buddy_add
 
2036
 * !modified @ 061206
 
2037
 */
 
2038
static PyObject *py_pjsua_buddy_add(PyObject *pSelf, PyObject *pArgs)
 
2039
{   
 
2040
    PyObject * bcObj;
 
2041
    int buddy_id;
 
2042
    int status;
 
2043
 
 
2044
    PJ_UNUSED_ARG(pSelf);
 
2045
 
 
2046
    if (!PyArg_ParseTuple(pArgs, "O", &bcObj)) {
 
2047
        return NULL;
 
2048
    }
 
2049
 
 
2050
    if (bcObj != Py_None) {
 
2051
        pjsua_buddy_config cfg;
 
2052
        PyObj_pjsua_buddy_config * bc;
 
2053
 
 
2054
        bc = (PyObj_pjsua_buddy_config *)bcObj;
 
2055
 
 
2056
        pjsua_buddy_config_default(&cfg);
 
2057
        PyObj_pjsua_buddy_config_export(&cfg, bc);  
 
2058
    
 
2059
        status = pjsua_buddy_add(&cfg, &buddy_id);
 
2060
    } else {
 
2061
        status = PJ_EINVAL;
 
2062
        buddy_id = PJSUA_INVALID_ID;
 
2063
    }
 
2064
    return Py_BuildValue("ii", status, buddy_id);
 
2065
}
 
2066
 
 
2067
/*
 
2068
 * py_pjsua_buddy_del
 
2069
 */
 
2070
static PyObject *py_pjsua_buddy_del(PyObject *pSelf, PyObject *pArgs)
 
2071
{    
 
2072
    int buddy_id;
 
2073
    int status;
 
2074
 
 
2075
    PJ_UNUSED_ARG(pSelf);
 
2076
 
 
2077
    if (!PyArg_ParseTuple(pArgs, "i", &buddy_id)) {
 
2078
        return NULL;
 
2079
    }
 
2080
        
 
2081
        
 
2082
    status = pjsua_buddy_del(buddy_id); 
 
2083
    return Py_BuildValue("i", status);
 
2084
}
 
2085
 
 
2086
/*
 
2087
 * py_pjsua_buddy_subscribe_pres
 
2088
 */
 
2089
static PyObject *py_pjsua_buddy_subscribe_pres(PyObject *pSelf, PyObject *pArgs)
 
2090
{    
 
2091
    int buddy_id;
 
2092
    int status;
 
2093
    int subscribe;
 
2094
 
 
2095
    PJ_UNUSED_ARG(pSelf);
 
2096
 
 
2097
    if (!PyArg_ParseTuple(pArgs, "ii", &buddy_id, &subscribe)) {
 
2098
        return NULL;
 
2099
    }
 
2100
        
 
2101
        
 
2102
    status = pjsua_buddy_subscribe_pres(buddy_id, subscribe);   
 
2103
    return Py_BuildValue("i", status);
 
2104
}
 
2105
 
 
2106
/*
 
2107
 * py_pjsua_pres_dump
 
2108
 */
 
2109
static PyObject *py_pjsua_pres_dump(PyObject *pSelf, PyObject *pArgs)
 
2110
{    
 
2111
    int verbose;
 
2112
 
 
2113
    PJ_UNUSED_ARG(pSelf);
 
2114
 
 
2115
    if (!PyArg_ParseTuple(pArgs, "i", &verbose)) {
 
2116
        return NULL;
 
2117
    }
 
2118
        
 
2119
        
 
2120
    pjsua_pres_dump(verbose);   
 
2121
    Py_INCREF(Py_None);
 
2122
    return Py_None;
 
2123
}
 
2124
 
 
2125
/*
 
2126
 * py_pjsua_im_send
 
2127
 * !modified @ 071206
 
2128
 */
 
2129
static PyObject *py_pjsua_im_send(PyObject *pSelf, PyObject *pArgs)
 
2130
{    
 
2131
    int status;
 
2132
    int acc_id;
 
2133
    pj_str_t * mime_type, tmp_mime_type;
 
2134
    pj_str_t to, content;
 
2135
    PyObject * st;
 
2136
    PyObject * smt;
 
2137
    PyObject * sc;
 
2138
    pjsua_msg_data msg_data;
 
2139
    PyObject * omdObj;
 
2140
    PyObj_pjsua_msg_data * omd;
 
2141
    
 
2142
    int user_data;
 
2143
    pj_pool_t *pool;
 
2144
 
 
2145
    PJ_UNUSED_ARG(pSelf);
 
2146
 
 
2147
    if (!PyArg_ParseTuple(pArgs, "iOOOOi", &acc_id, 
 
2148
                &st, &smt, &sc, &omdObj, &user_data))
 
2149
    {
 
2150
        return NULL;
 
2151
    }
 
2152
    if (smt != Py_None) {
 
2153
        mime_type = &tmp_mime_type;
 
2154
        tmp_mime_type = PyString_to_pj_str(smt);
 
2155
    } else {
 
2156
        mime_type = NULL;
 
2157
    }
 
2158
    to = PyString_to_pj_str(st);
 
2159
        content = PyString_to_pj_str(sc);
 
2160
 
 
2161
    if (omdObj != Py_None) {
 
2162
                
 
2163
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
2164
        msg_data.content_type = PyString_to_pj_str(omd->content_type);
 
2165
        msg_data.msg_body = PyString_to_pj_str(omd->msg_body);
 
2166
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
2167
 
 
2168
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
2169
        status = pjsua_im_send(acc_id, &to, mime_type, 
 
2170
                        &content, &msg_data, (void *)user_data);        
 
2171
        pj_pool_release(pool);
 
2172
    } else {
 
2173
                
 
2174
        status = pjsua_im_send(acc_id, &to, mime_type, 
 
2175
                        &content, NULL, NULL);  
 
2176
    }
 
2177
    
 
2178
    return Py_BuildValue("i",status);
 
2179
}
 
2180
 
 
2181
/*
 
2182
 * py_pjsua_im_typing
 
2183
 */
 
2184
static PyObject *py_pjsua_im_typing(PyObject *pSelf, PyObject *pArgs)
 
2185
{    
 
2186
    int status;
 
2187
    int acc_id;
 
2188
    pj_str_t to;
 
2189
    PyObject * st;
 
2190
    int is_typing;
 
2191
    pjsua_msg_data msg_data;
 
2192
    PyObject * omdObj;
 
2193
    PyObj_pjsua_msg_data * omd;
 
2194
    pj_pool_t * pool;
 
2195
 
 
2196
    PJ_UNUSED_ARG(pSelf);
 
2197
 
 
2198
    if (!PyArg_ParseTuple(pArgs, "iOiO", &acc_id, &st, &is_typing, &omdObj)) {
 
2199
        return NULL;
 
2200
    }
 
2201
        
 
2202
    to = PyString_to_pj_str(st);
 
2203
 
 
2204
    if (omdObj != Py_None) {
 
2205
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
2206
        msg_data.content_type = PyString_to_pj_str(omd->content_type);
 
2207
        msg_data.msg_body = PyString_to_pj_str(omd->msg_body);
 
2208
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
2209
 
 
2210
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
2211
        status = pjsua_im_typing(acc_id, &to, is_typing, &msg_data);    
 
2212
        pj_pool_release(pool);
 
2213
    } else {
 
2214
        status = pjsua_im_typing(acc_id, &to, is_typing, NULL);
 
2215
    }
 
2216
    return Py_BuildValue("i",status);
 
2217
}
 
2218
 
 
2219
static char pjsua_buddy_config_default_doc[] =
 
2220
    "py_pjsua.Buddy_Config py_pjsua.buddy_config_default () "
 
2221
    "Set default values to the buddy config.";
 
2222
static char pjsua_get_buddy_count_doc[] =
 
2223
    "int py_pjsua.get_buddy_count () "
 
2224
    "Get total number of buddies.";
 
2225
static char pjsua_buddy_is_valid_doc[] =
 
2226
    "int py_pjsua.buddy_is_valid (int buddy_id) "
 
2227
    "Check if buddy ID is valid.";
 
2228
static char pjsua_enum_buddies_doc[] =
 
2229
    "int[] py_pjsua.enum_buddies () "
 
2230
    "Enum buddy IDs.";
 
2231
static char pjsua_buddy_get_info_doc[] =
 
2232
    "py_pjsua.Buddy_Info py_pjsua.buddy_get_info (int buddy_id) "
 
2233
    "Get detailed buddy info.";
 
2234
static char pjsua_buddy_add_doc[] =
 
2235
    "int,int py_pjsua.buddy_add (py_pjsua.Buddy_Config cfg) "
 
2236
    "Add new buddy.";
 
2237
static char pjsua_buddy_del_doc[] =
 
2238
    "int py_pjsua.buddy_del (int buddy_id) "
 
2239
    "Delete buddy.";
 
2240
static char pjsua_buddy_subscribe_pres_doc[] =
 
2241
    "int py_pjsua.buddy_subscribe_pres (int buddy_id, int subscribe) "
 
2242
    "Enable/disable buddy's presence monitoring.";
 
2243
static char pjsua_pres_dump_doc[] =
 
2244
    "void py_pjsua.pres_dump (int verbose) "
 
2245
    "Dump presence subscriptions to log file.";
 
2246
static char pjsua_im_send_doc[] =
 
2247
    "int py_pjsua.im_send (int acc_id, string to, string mime_type, "
 
2248
    "string content, py_pjsua.Msg_Data msg_data, int user_data) "
 
2249
    "Send instant messaging outside dialog, using the specified account "
 
2250
    "for route set and authentication.";
 
2251
static char pjsua_im_typing_doc[] =
 
2252
    "int py_pjsua.im_typing (int acc_id, string to, int is_typing, "
 
2253
    "py_pjsua.Msg_Data msg_data) "
 
2254
    "Send typing indication outside dialog.";
 
2255
 
 
2256
/* END OF LIB BUDDY */
 
2257
 
 
2258
/* LIB MEDIA */
 
2259
 
 
2260
 
 
2261
 
 
2262
/*
 
2263
 * PyObj_pjsua_codec_info
 
2264
 * Codec Info
 
2265
 * !modified @ 071206
 
2266
 */
 
2267
typedef struct
 
2268
{
 
2269
    PyObject_HEAD
 
2270
    /* Type-specific fields go here. */ 
 
2271
    
 
2272
    PyObject * codec_id;
 
2273
    pj_uint8_t priority;    
 
2274
    char buf_[32];
 
2275
} PyObj_pjsua_codec_info;
 
2276
 
 
2277
 
 
2278
/*
 
2279
 * codec_info_dealloc
 
2280
 * deletes a codec_info from memory
 
2281
 * !modified @ 071206
 
2282
 */
 
2283
static void codec_info_dealloc(PyObj_pjsua_codec_info* self)
 
2284
{
 
2285
    Py_XDECREF(self->codec_id);    
 
2286
    
 
2287
    self->ob_type->tp_free((PyObject*)self);
 
2288
}
 
2289
 
 
2290
 
 
2291
/*
 
2292
 * codec_info_new
 
2293
 * constructor for codec_info object
 
2294
 * !modified @ 071206
 
2295
 */
 
2296
static PyObject * codec_info_new(PyTypeObject *type, PyObject *args,
 
2297
                                    PyObject *kwds)
 
2298
{
 
2299
    PyObj_pjsua_codec_info *self;
 
2300
 
 
2301
    PJ_UNUSED_ARG(args);
 
2302
    PJ_UNUSED_ARG(kwds);
 
2303
 
 
2304
    self = (PyObj_pjsua_codec_info *)type->tp_alloc(type, 0);
 
2305
    if (self != NULL)
 
2306
    {
 
2307
        self->codec_id = PyString_FromString("");
 
2308
        if (self->codec_id == NULL)
 
2309
        {
 
2310
            Py_DECREF(self);
 
2311
            return NULL;
 
2312
        }        
 
2313
        
 
2314
 
 
2315
    }
 
2316
    return (PyObject *)self;
 
2317
}
 
2318
 
 
2319
/*
 
2320
 * codec_info_members
 
2321
 * !modified @ 071206
 
2322
 */
 
2323
static PyMemberDef codec_info_members[] =
 
2324
{    
 
2325
    {
 
2326
        "codec_id", T_OBJECT_EX,
 
2327
        offsetof(PyObj_pjsua_codec_info, codec_id), 0,
 
2328
        "Codec unique identification."        
 
2329
    },
 
2330
    
 
2331
    {
 
2332
        "priority", T_INT, 
 
2333
        offsetof(PyObj_pjsua_codec_info, priority), 0,
 
2334
        "Codec priority (integer 0-255)."
 
2335
    },
 
2336
    
 
2337
    
 
2338
    
 
2339
    {NULL}  /* Sentinel */
 
2340
};
 
2341
 
 
2342
 
 
2343
 
 
2344
 
 
2345
/*
 
2346
 * PyTyp_pjsua_codec_info
 
2347
 */
 
2348
static PyTypeObject PyTyp_pjsua_codec_info =
 
2349
{
 
2350
    PyObject_HEAD_INIT(NULL)
 
2351
    0,                              /*ob_size*/
 
2352
    "py_pjsua.Codec_Info",      /*tp_name*/
 
2353
    sizeof(PyObj_pjsua_codec_info),  /*tp_basicsize*/
 
2354
    0,                              /*tp_itemsize*/
 
2355
    (destructor)codec_info_dealloc,/*tp_dealloc*/
 
2356
    0,                              /*tp_print*/
 
2357
    0,                              /*tp_getattr*/
 
2358
    0,                              /*tp_setattr*/
 
2359
    0,                              /*tp_compare*/
 
2360
    0,                              /*tp_repr*/
 
2361
    0,                              /*tp_as_number*/
 
2362
    0,                              /*tp_as_sequence*/
 
2363
    0,                              /*tp_as_mapping*/
 
2364
    0,                              /*tp_hash */
 
2365
    0,                              /*tp_call*/
 
2366
    0,                              /*tp_str*/
 
2367
    0,                              /*tp_getattro*/
 
2368
    0,                              /*tp_setattro*/
 
2369
    0,                              /*tp_as_buffer*/
 
2370
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
2371
    "Codec Info objects",       /* tp_doc */
 
2372
    0,                              /* tp_traverse */
 
2373
    0,                              /* tp_clear */
 
2374
    0,                              /* tp_richcompare */
 
2375
    0,                              /* tp_weaklistoffset */
 
2376
    0,                              /* tp_iter */
 
2377
    0,                              /* tp_iternext */
 
2378
    0,                              /* tp_methods */
 
2379
    codec_info_members,         /* tp_members */
 
2380
    0,                              /* tp_getset */
 
2381
    0,                              /* tp_base */
 
2382
    0,                              /* tp_dict */
 
2383
    0,                              /* tp_descr_get */
 
2384
    0,                              /* tp_descr_set */
 
2385
    0,                              /* tp_dictoffset */
 
2386
    0,                              /* tp_init */
 
2387
    0,                              /* tp_alloc */
 
2388
    codec_info_new,             /* tp_new */
 
2389
 
 
2390
};
 
2391
 
 
2392
/*
 
2393
 * PyObj_pjsua_conf_port_info
 
2394
 * Conf Port Info
 
2395
 */
 
2396
typedef struct
 
2397
{
 
2398
    PyObject_HEAD
 
2399
    /* Type-specific fields go here. */ 
 
2400
    
 
2401
    int  slot_id;
 
2402
    PyObject *  name;
 
2403
    unsigned  clock_rate;
 
2404
    unsigned  channel_count;
 
2405
    unsigned  samples_per_frame;
 
2406
    unsigned  bits_per_sample;
 
2407
    PyListObject * listeners;
 
2408
 
 
2409
} PyObj_pjsua_conf_port_info;
 
2410
 
 
2411
 
 
2412
/*
 
2413
 * conf_port_info_dealloc
 
2414
 * deletes a conf_port_info from memory
 
2415
 */
 
2416
static void conf_port_info_dealloc(PyObj_pjsua_conf_port_info* self)
 
2417
{
 
2418
    Py_XDECREF(self->name);    
 
2419
    Py_XDECREF(self->listeners);
 
2420
    self->ob_type->tp_free((PyObject*)self);
 
2421
}
 
2422
 
 
2423
 
 
2424
/*
 
2425
 * conf_port_info_new
 
2426
 * constructor for conf_port_info object
 
2427
 */
 
2428
static PyObject * conf_port_info_new(PyTypeObject *type, PyObject *args,
 
2429
                                    PyObject *kwds)
 
2430
{
 
2431
    PyObj_pjsua_conf_port_info *self;
 
2432
 
 
2433
    PJ_UNUSED_ARG(args);
 
2434
    PJ_UNUSED_ARG(kwds);
 
2435
 
 
2436
    self = (PyObj_pjsua_conf_port_info *)type->tp_alloc(type, 0);
 
2437
    if (self != NULL)
 
2438
    {
 
2439
        self->name = PyString_FromString("");
 
2440
        if (self->name == NULL)
 
2441
        {
 
2442
            Py_DECREF(self);
 
2443
            return NULL;
 
2444
        }        
 
2445
        
 
2446
        self->listeners = (PyListObject *)PyList_New(0);
 
2447
        if (self->listeners == NULL)
 
2448
        {
 
2449
            Py_DECREF(self);
 
2450
            return NULL;
 
2451
        }
 
2452
    }
 
2453
    return (PyObject *)self;
 
2454
}
 
2455
 
 
2456
/*
 
2457
 * conf_port_info_members
 
2458
 */
 
2459
static PyMemberDef conf_port_info_members[] =
 
2460
{   
 
2461
    {
 
2462
        "slot_id", T_INT, 
 
2463
        offsetof(PyObj_pjsua_conf_port_info, slot_id), 0,
 
2464
        "Conference port number."
 
2465
    },
 
2466
    {
 
2467
        "name", T_OBJECT_EX,
 
2468
        offsetof(PyObj_pjsua_conf_port_info, name), 0,
 
2469
        "Port name"        
 
2470
    },
 
2471
    {
 
2472
        "clock_rate", T_INT, 
 
2473
        offsetof(PyObj_pjsua_conf_port_info, clock_rate), 0,
 
2474
        "Clock rate"
 
2475
    },
 
2476
    {
 
2477
        "channel_count", T_INT, 
 
2478
        offsetof(PyObj_pjsua_conf_port_info, channel_count), 0,
 
2479
        "Number of channels."
 
2480
    },
 
2481
    {
 
2482
        "samples_per_frame", T_INT, 
 
2483
        offsetof(PyObj_pjsua_conf_port_info, samples_per_frame), 0,
 
2484
        "Samples per frame "
 
2485
    },
 
2486
    {
 
2487
        "bits_per_sample", T_INT, 
 
2488
        offsetof(PyObj_pjsua_conf_port_info, bits_per_sample), 0,
 
2489
        "Bits per sample"
 
2490
    },
 
2491
    {
 
2492
        "listeners", T_OBJECT_EX,
 
2493
        offsetof(PyObj_pjsua_conf_port_info, listeners), 0,
 
2494
        "Array of listeners (in other words, ports where this port "
 
2495
        "is transmitting to"
 
2496
    },
 
2497
    
 
2498
    {NULL}  /* Sentinel */
 
2499
};
 
2500
 
 
2501
 
 
2502
 
 
2503
 
 
2504
/*
 
2505
 * PyTyp_pjsua_conf_port_info
 
2506
 */
 
2507
static PyTypeObject PyTyp_pjsua_conf_port_info =
 
2508
{
 
2509
    PyObject_HEAD_INIT(NULL)
 
2510
    0,                              /*ob_size*/
 
2511
    "py_pjsua.Conf_Port_Info",      /*tp_name*/
 
2512
    sizeof(PyObj_pjsua_conf_port_info),  /*tp_basicsize*/
 
2513
    0,                              /*tp_itemsize*/
 
2514
    (destructor)conf_port_info_dealloc,/*tp_dealloc*/
 
2515
    0,                              /*tp_print*/
 
2516
    0,                              /*tp_getattr*/
 
2517
    0,                              /*tp_setattr*/
 
2518
    0,                              /*tp_compare*/
 
2519
    0,                              /*tp_repr*/
 
2520
    0,                              /*tp_as_number*/
 
2521
    0,                              /*tp_as_sequence*/
 
2522
    0,                              /*tp_as_mapping*/
 
2523
    0,                              /*tp_hash */
 
2524
    0,                              /*tp_call*/
 
2525
    0,                              /*tp_str*/
 
2526
    0,                              /*tp_getattro*/
 
2527
    0,                              /*tp_setattro*/
 
2528
    0,                              /*tp_as_buffer*/
 
2529
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
2530
    "Conf Port Info objects",       /* tp_doc */
 
2531
    0,                              /* tp_traverse */
 
2532
    0,                              /* tp_clear */
 
2533
    0,                              /* tp_richcompare */
 
2534
    0,                              /* tp_weaklistoffset */
 
2535
    0,                              /* tp_iter */
 
2536
    0,                              /* tp_iternext */
 
2537
    0,                              /* tp_methods */
 
2538
    conf_port_info_members,         /* tp_members */
 
2539
    0,                              /* tp_getset */
 
2540
    0,                              /* tp_base */
 
2541
    0,                              /* tp_dict */
 
2542
    0,                              /* tp_descr_get */
 
2543
    0,                              /* tp_descr_set */
 
2544
    0,                              /* tp_dictoffset */
 
2545
    0,                              /* tp_init */
 
2546
    0,                              /* tp_alloc */
 
2547
    conf_port_info_new,             /* tp_new */
 
2548
 
 
2549
};
 
2550
 
 
2551
/*
 
2552
 * PyObj_pjmedia_port
 
2553
 */
 
2554
typedef struct
 
2555
{
 
2556
    PyObject_HEAD
 
2557
    /* Type-specific fields go here. */
 
2558
    pjmedia_port * port;
 
2559
} PyObj_pjmedia_port;
 
2560
 
 
2561
 
 
2562
/*
 
2563
 * PyTyp_pjmedia_port
 
2564
 */
 
2565
static PyTypeObject PyTyp_pjmedia_port =
 
2566
{
 
2567
    PyObject_HEAD_INIT(NULL)
 
2568
    0,                         /*ob_size*/
 
2569
    "py_pjsua.PJMedia_Port",        /*tp_name*/
 
2570
    sizeof(PyObj_pjmedia_port),    /*tp_basicsize*/
 
2571
    0,                         /*tp_itemsize*/
 
2572
    0,                         /*tp_dealloc*/
 
2573
    0,                         /*tp_print*/
 
2574
    0,                         /*tp_getattr*/
 
2575
    0,                         /*tp_setattr*/
 
2576
    0,                         /*tp_compare*/
 
2577
    0,                         /*tp_repr*/
 
2578
    0,                         /*tp_as_number*/
 
2579
    0,                         /*tp_as_sequence*/
 
2580
    0,                         /*tp_as_mapping*/
 
2581
    0,                         /*tp_hash */
 
2582
    0,                         /*tp_call*/
 
2583
    0,                         /*tp_str*/
 
2584
    0,                         /*tp_getattro*/
 
2585
    0,                         /*tp_setattro*/
 
2586
    0,                         /*tp_as_buffer*/
 
2587
    Py_TPFLAGS_DEFAULT,        /*tp_flags*/
 
2588
    "pjmedia_port objects",       /* tp_doc */
 
2589
 
 
2590
};
 
2591
 
 
2592
/*
 
2593
 * PyObj_pjmedia_snd_dev_info
 
2594
 * PJMedia Snd Dev Info
 
2595
 */
 
2596
typedef struct
 
2597
{
 
2598
    PyObject_HEAD
 
2599
    /* Type-specific fields go here. */ 
 
2600
    
 
2601
    
 
2602
    unsigned  input_count;
 
2603
    unsigned  output_count;
 
2604
    unsigned  default_samples_per_sec;    
 
2605
    PyObject * name;
 
2606
 
 
2607
} PyObj_pjmedia_snd_dev_info;
 
2608
 
 
2609
 
 
2610
/*
 
2611
 * pjmedia_snd_dev_info_dealloc
 
2612
 * deletes a pjmedia_snd_dev_info from memory
 
2613
 */
 
2614
static void pjmedia_snd_dev_info_dealloc(PyObj_pjmedia_snd_dev_info* self)
 
2615
{
 
2616
    Py_XDECREF(self->name);        
 
2617
    self->ob_type->tp_free((PyObject*)self);
 
2618
}
 
2619
 
 
2620
 
 
2621
/*
 
2622
 * pjmedia_snd_dev_info_new
 
2623
 * constructor for pjmedia_snd_dev_info object
 
2624
 */
 
2625
static PyObject * pjmedia_snd_dev_info_new(PyTypeObject *type, PyObject *args,
 
2626
                                    PyObject *kwds)
 
2627
{
 
2628
    PyObj_pjmedia_snd_dev_info *self;
 
2629
 
 
2630
    PJ_UNUSED_ARG(args);
 
2631
    PJ_UNUSED_ARG(kwds);
 
2632
 
 
2633
    self = (PyObj_pjmedia_snd_dev_info *)type->tp_alloc(type, 0);
 
2634
    if (self != NULL)
 
2635
    {
 
2636
        self->name = PyString_FromString("");
 
2637
        if (self->name == NULL)
 
2638
        {
 
2639
            Py_DECREF(self);
 
2640
            return NULL;
 
2641
        }        
 
2642
        
 
2643
    }
 
2644
    return (PyObject *)self;
 
2645
}
 
2646
 
 
2647
/*
 
2648
 * pjmedia_snd_dev_info_members
 
2649
 */
 
2650
static PyMemberDef pjmedia_snd_dev_info_members[] =
 
2651
{   
 
2652
    
 
2653
    {
 
2654
        "name", T_OBJECT_EX,
 
2655
        offsetof(PyObj_pjmedia_snd_dev_info, name), 0,
 
2656
        "Device name"        
 
2657
    },
 
2658
    {
 
2659
        "input_count", T_INT, 
 
2660
        offsetof(PyObj_pjmedia_snd_dev_info, input_count), 0,
 
2661
        "Max number of input channels"
 
2662
    },
 
2663
    {
 
2664
        "output_count", T_INT, 
 
2665
        offsetof(PyObj_pjmedia_snd_dev_info, output_count), 0,
 
2666
        "Max number of output channels"
 
2667
    },
 
2668
    {
 
2669
        "default_samples_per_sec", T_INT, 
 
2670
        offsetof(PyObj_pjmedia_snd_dev_info, default_samples_per_sec), 0,
 
2671
        "Default sampling rate."
 
2672
    },
 
2673
    
 
2674
    
 
2675
    {NULL}  /* Sentinel */
 
2676
};
 
2677
 
 
2678
 
 
2679
 
 
2680
 
 
2681
/*
 
2682
 * PyTyp_pjmedia_snd_dev_info
 
2683
 */
 
2684
static PyTypeObject PyTyp_pjmedia_snd_dev_info =
 
2685
{
 
2686
    PyObject_HEAD_INIT(NULL)
 
2687
    0,                              /*ob_size*/
 
2688
    "py_pjsua.PJMedia_Snd_Dev_Info",      /*tp_name*/
 
2689
    sizeof(PyObj_pjmedia_snd_dev_info),  /*tp_basicsize*/
 
2690
    0,                              /*tp_itemsize*/
 
2691
    (destructor)pjmedia_snd_dev_info_dealloc,/*tp_dealloc*/
 
2692
    0,                              /*tp_print*/
 
2693
    0,                              /*tp_getattr*/
 
2694
    0,                              /*tp_setattr*/
 
2695
    0,                              /*tp_compare*/
 
2696
    0,                              /*tp_repr*/
 
2697
    0,                              /*tp_as_number*/
 
2698
    0,                              /*tp_as_sequence*/
 
2699
    0,                              /*tp_as_mapping*/
 
2700
    0,                              /*tp_hash */
 
2701
    0,                              /*tp_call*/
 
2702
    0,                              /*tp_str*/
 
2703
    0,                              /*tp_getattro*/
 
2704
    0,                              /*tp_setattro*/
 
2705
    0,                              /*tp_as_buffer*/
 
2706
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
2707
    "PJMedia Snd Dev Info objects",       /* tp_doc */
 
2708
    0,                              /* tp_traverse */
 
2709
    0,                              /* tp_clear */
 
2710
    0,                              /* tp_richcompare */
 
2711
    0,                              /* tp_weaklistoffset */
 
2712
    0,                              /* tp_iter */
 
2713
    0,                              /* tp_iternext */
 
2714
    0,                              /* tp_methods */
 
2715
    pjmedia_snd_dev_info_members,         /* tp_members */
 
2716
    0,                              /* tp_getset */
 
2717
    0,                              /* tp_base */
 
2718
    0,                              /* tp_dict */
 
2719
    0,                              /* tp_descr_get */
 
2720
    0,                              /* tp_descr_set */
 
2721
    0,                              /* tp_dictoffset */
 
2722
    0,                              /* tp_init */
 
2723
    0,                              /* tp_alloc */
 
2724
    pjmedia_snd_dev_info_new,             /* tp_new */
 
2725
 
 
2726
};
 
2727
 
 
2728
/*
 
2729
 * PyObj_pjmedia_codec_param_info
 
2730
 * PJMedia Codec Param Info
 
2731
 */
 
2732
typedef struct
 
2733
{
 
2734
    PyObject_HEAD
 
2735
    /* Type-specific fields go here. */ 
 
2736
    
 
2737
    unsigned  clock_rate;
 
2738
    unsigned  channel_cnt;
 
2739
    pj_uint32_t avg_bps;
 
2740
    pj_uint16_t frm_ptime;
 
2741
    pj_uint8_t  pcm_bits_per_sample;
 
2742
    pj_uint8_t  pt;     
 
2743
 
 
2744
} PyObj_pjmedia_codec_param_info;
 
2745
 
 
2746
 
 
2747
 
 
2748
/*
 
2749
 * pjmedia_codec_param_info_members
 
2750
 */
 
2751
static PyMemberDef pjmedia_codec_param_info_members[] =
 
2752
{   
 
2753
    
 
2754
    {
 
2755
        "clock_rate", T_INT, 
 
2756
        offsetof(PyObj_pjmedia_codec_param_info, clock_rate), 0,
 
2757
        "Sampling rate in Hz"
 
2758
    },
 
2759
    {
 
2760
        "channel_cnt", T_INT, 
 
2761
        offsetof(PyObj_pjmedia_codec_param_info, channel_cnt), 0,
 
2762
        "Channel count"
 
2763
    },
 
2764
    {
 
2765
        "avg_bps", T_INT, 
 
2766
        offsetof(PyObj_pjmedia_codec_param_info, avg_bps), 0,
 
2767
        "Average bandwidth in bits/sec"
 
2768
    },
 
2769
    {
 
2770
        "frm_ptime", T_INT, 
 
2771
        offsetof(PyObj_pjmedia_codec_param_info, frm_ptime), 0,
 
2772
        "Base frame ptime in msec."
 
2773
    },
 
2774
    {
 
2775
        "pcm_bits_per_sample", T_INT, 
 
2776
        offsetof(PyObj_pjmedia_codec_param_info, pcm_bits_per_sample), 0,
 
2777
        "Bits/sample in the PCM side"
 
2778
    },
 
2779
    {
 
2780
        "pt", T_INT, 
 
2781
        offsetof(PyObj_pjmedia_codec_param_info, pt), 0,
 
2782
        "Payload type"
 
2783
    },
 
2784
    
 
2785
    {NULL}  /* Sentinel */
 
2786
};
 
2787
 
 
2788
 
 
2789
 
 
2790
 
 
2791
/*
 
2792
 * PyTyp_pjmedia_codec_param_info
 
2793
 */
 
2794
static PyTypeObject PyTyp_pjmedia_codec_param_info =
 
2795
{
 
2796
    PyObject_HEAD_INIT(NULL)
 
2797
    0,                              /*ob_size*/
 
2798
    "py_pjsua.PJMedia_Codec_Param_Info",      /*tp_name*/
 
2799
    sizeof(PyObj_pjmedia_codec_param_info),  /*tp_basicsize*/
 
2800
    0,                              /*tp_itemsize*/
 
2801
    0,/*tp_dealloc*/
 
2802
    0,                              /*tp_print*/
 
2803
    0,                              /*tp_getattr*/
 
2804
    0,                              /*tp_setattr*/
 
2805
    0,                              /*tp_compare*/
 
2806
    0,                              /*tp_repr*/
 
2807
    0,                              /*tp_as_number*/
 
2808
    0,                              /*tp_as_sequence*/
 
2809
    0,                              /*tp_as_mapping*/
 
2810
    0,                              /*tp_hash */
 
2811
    0,                              /*tp_call*/
 
2812
    0,                              /*tp_str*/
 
2813
    0,                              /*tp_getattro*/
 
2814
    0,                              /*tp_setattro*/
 
2815
    0,                              /*tp_as_buffer*/
 
2816
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
2817
    "PJMedia Codec Param Info objects",       /* tp_doc */
 
2818
    0,                              /* tp_traverse */
 
2819
    0,                              /* tp_clear */
 
2820
    0,                              /* tp_richcompare */
 
2821
    0,                              /* tp_weaklistoffset */
 
2822
    0,                              /* tp_iter */
 
2823
    0,                              /* tp_iternext */
 
2824
    0,                              /* tp_methods */
 
2825
    pjmedia_codec_param_info_members,         /* tp_members */
 
2826
    
 
2827
 
 
2828
};
 
2829
 
 
2830
/*
 
2831
 * PyObj_pjmedia_codec_param_setting
 
2832
 * PJMedia Codec Param Setting
 
2833
 */
 
2834
typedef struct
 
2835
{
 
2836
    PyObject_HEAD
 
2837
    /* Type-specific fields go here. */ 
 
2838
    pj_uint8_t  frm_per_pkt; 
 
2839
    unsigned    vad;
 
2840
    unsigned    cng;
 
2841
    unsigned    penh;
 
2842
    unsigned    plc;
 
2843
    unsigned    reserved;
 
2844
    pj_uint8_t  enc_fmtp_mode;
 
2845
    pj_uint8_t  dec_fmtp_mode; 
 
2846
 
 
2847
} PyObj_pjmedia_codec_param_setting;
 
2848
 
 
2849
 
 
2850
 
 
2851
/*
 
2852
 * pjmedia_codec_param_setting_members
 
2853
 */
 
2854
static PyMemberDef pjmedia_codec_param_setting_members[] =
 
2855
{   
 
2856
    
 
2857
    {
 
2858
        "frm_per_pkt", T_INT, 
 
2859
        offsetof(PyObj_pjmedia_codec_param_setting, frm_per_pkt), 0,
 
2860
        "Number of frames per packet"
 
2861
    },
 
2862
    {
 
2863
        "vad", T_INT, 
 
2864
        offsetof(PyObj_pjmedia_codec_param_setting, vad), 0,
 
2865
        "Voice Activity Detector"
 
2866
    },
 
2867
    {
 
2868
        "penh", T_INT, 
 
2869
        offsetof(PyObj_pjmedia_codec_param_setting, penh), 0,
 
2870
        "Perceptual Enhancement"
 
2871
    },
 
2872
    {
 
2873
        "plc", T_INT, 
 
2874
        offsetof(PyObj_pjmedia_codec_param_setting, plc), 0,
 
2875
        "Packet loss concealment"
 
2876
    },
 
2877
    {
 
2878
        "reserved", T_INT, 
 
2879
        offsetof(PyObj_pjmedia_codec_param_setting, reserved), 0,
 
2880
        "Reserved, must be zero"
 
2881
    },
 
2882
    {
 
2883
        "cng", T_INT, 
 
2884
        offsetof(PyObj_pjmedia_codec_param_setting, cng), 0,
 
2885
        "Comfort Noise Generator"
 
2886
    },
 
2887
    {
 
2888
        "enc_fmtp_mode", T_INT, 
 
2889
        offsetof(PyObj_pjmedia_codec_param_setting, enc_fmtp_mode), 0,
 
2890
        "Mode param in fmtp (def:0)"
 
2891
    },
 
2892
    {
 
2893
        "dec_fmtp_mode", T_INT, 
 
2894
        offsetof(PyObj_pjmedia_codec_param_setting, dec_fmtp_mode), 0,
 
2895
        "Mode param in fmtp (def:0)"
 
2896
    },
 
2897
    
 
2898
    {NULL}  /* Sentinel */
 
2899
};
 
2900
 
 
2901
 
 
2902
 
 
2903
 
 
2904
/*
 
2905
 * PyTyp_pjmedia_codec_param_setting
 
2906
 */
 
2907
static PyTypeObject PyTyp_pjmedia_codec_param_setting =
 
2908
{
 
2909
    PyObject_HEAD_INIT(NULL)
 
2910
    0,                              /*ob_size*/
 
2911
    "py_pjsua.PJMedia_Codec_Param_Setting",      /*tp_name*/
 
2912
    sizeof(PyObj_pjmedia_codec_param_setting),  /*tp_basicsize*/
 
2913
    0,                              /*tp_itemsize*/
 
2914
    0,/*tp_dealloc*/
 
2915
    0,                              /*tp_print*/
 
2916
    0,                              /*tp_getattr*/
 
2917
    0,                              /*tp_setattr*/
 
2918
    0,                              /*tp_compare*/
 
2919
    0,                              /*tp_repr*/
 
2920
    0,                              /*tp_as_number*/
 
2921
    0,                              /*tp_as_sequence*/
 
2922
    0,                              /*tp_as_mapping*/
 
2923
    0,                              /*tp_hash */
 
2924
    0,                              /*tp_call*/
 
2925
    0,                              /*tp_str*/
 
2926
    0,                              /*tp_getattro*/
 
2927
    0,                              /*tp_setattro*/
 
2928
    0,                              /*tp_as_buffer*/
 
2929
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
2930
    "PJMedia Codec Param Setting objects",       /* tp_doc */
 
2931
    0,                              /* tp_traverse */
 
2932
    0,                              /* tp_clear */
 
2933
    0,                              /* tp_richcompare */
 
2934
    0,                              /* tp_weaklistoffset */
 
2935
    0,                              /* tp_iter */
 
2936
    0,                              /* tp_iternext */
 
2937
    0,                              /* tp_methods */
 
2938
    pjmedia_codec_param_setting_members,         /* tp_members */
 
2939
    
 
2940
 
 
2941
};
 
2942
 
 
2943
/*
 
2944
 * PyObj_pjmedia_codec_param
 
2945
 * PJMedia Codec Param
 
2946
 */
 
2947
typedef struct
 
2948
{
 
2949
    PyObject_HEAD
 
2950
    /* Type-specific fields go here. */ 
 
2951
    
 
2952
    PyObj_pjmedia_codec_param_info * info;
 
2953
    PyObj_pjmedia_codec_param_setting * setting;
 
2954
 
 
2955
} PyObj_pjmedia_codec_param;
 
2956
 
 
2957
 
 
2958
/*
 
2959
 * pjmedia_codec_param_dealloc
 
2960
 * deletes a pjmedia_codec_param from memory
 
2961
 */
 
2962
static void pjmedia_codec_param_dealloc(PyObj_pjmedia_codec_param* self)
 
2963
{
 
2964
    Py_XDECREF(self->info);        
 
2965
    Py_XDECREF(self->setting);        
 
2966
    self->ob_type->tp_free((PyObject*)self);
 
2967
}
 
2968
 
 
2969
 
 
2970
/*
 
2971
 * pjmedia_codec_param_new
 
2972
 * constructor for pjmedia_codec_param object
 
2973
 */
 
2974
static PyObject * pjmedia_codec_param_new(PyTypeObject *type, PyObject *args,
 
2975
                                    PyObject *kwds)
 
2976
{
 
2977
    PyObj_pjmedia_codec_param *self;
 
2978
 
 
2979
    PJ_UNUSED_ARG(args);
 
2980
    PJ_UNUSED_ARG(kwds);
 
2981
 
 
2982
    self = (PyObj_pjmedia_codec_param *)type->tp_alloc(type, 0);
 
2983
    if (self != NULL)
 
2984
    {
 
2985
        self->info = (PyObj_pjmedia_codec_param_info *)
 
2986
            PyType_GenericNew(&PyTyp_pjmedia_codec_param_info, NULL, NULL);
 
2987
        if (self->info == NULL)
 
2988
        {
 
2989
            Py_DECREF(self);
 
2990
            return NULL;
 
2991
        }        
 
2992
        self->setting = (PyObj_pjmedia_codec_param_setting *)
 
2993
            PyType_GenericNew(&PyTyp_pjmedia_codec_param_setting, NULL, NULL);
 
2994
        if (self->setting == NULL)
 
2995
        {
 
2996
            Py_DECREF(self);
 
2997
            return NULL;
 
2998
        }        
 
2999
    }
 
3000
    return (PyObject *)self;
 
3001
}
 
3002
 
 
3003
/*
 
3004
 * pjmedia_codec_param_members
 
3005
 */
 
3006
static PyMemberDef pjmedia_codec_param_members[] =
 
3007
{   
 
3008
    
 
3009
    {
 
3010
        "info", T_OBJECT_EX,
 
3011
        offsetof(PyObj_pjmedia_codec_param, info), 0,
 
3012
        "The 'info' part of codec param describes the capability of the codec,"
 
3013
        " and the value should NOT be changed by application."        
 
3014
    },
 
3015
    {
 
3016
        "setting", T_OBJECT_EX,
 
3017
        offsetof(PyObj_pjmedia_codec_param, setting), 0, 
 
3018
        "The 'setting' part of codec param describes various settings to be "
 
3019
        "applied to the codec. When the codec param is retrieved from the "
 
3020
        "codec or codec factory, the values of these will be filled by "
 
3021
        "the capability of the codec. Any features that are supported by "
 
3022
        "the codec (e.g. vad or plc) will be turned on, so that application "
 
3023
        "can query which capabilities are supported by the codec. "
 
3024
        "Application may change the settings here before instantiating "
 
3025
        "the codec/stream."        
 
3026
    },
 
3027
    
 
3028
    {NULL}  /* Sentinel */
 
3029
};
 
3030
 
 
3031
 
 
3032
 
 
3033
 
 
3034
/*
 
3035
 * PyTyp_pjmedia_codec_param
 
3036
 */
 
3037
static PyTypeObject PyTyp_pjmedia_codec_param =
 
3038
{
 
3039
    PyObject_HEAD_INIT(NULL)
 
3040
    0,                              /*ob_size*/
 
3041
    "py_pjsua.PJMedia_Codec_Param",      /*tp_name*/
 
3042
    sizeof(PyObj_pjmedia_codec_param),  /*tp_basicsize*/
 
3043
    0,                              /*tp_itemsize*/
 
3044
    (destructor)pjmedia_codec_param_dealloc,/*tp_dealloc*/
 
3045
    0,                              /*tp_print*/
 
3046
    0,                              /*tp_getattr*/
 
3047
    0,                              /*tp_setattr*/
 
3048
    0,                              /*tp_compare*/
 
3049
    0,                              /*tp_repr*/
 
3050
    0,                              /*tp_as_number*/
 
3051
    0,                              /*tp_as_sequence*/
 
3052
    0,                              /*tp_as_mapping*/
 
3053
    0,                              /*tp_hash */
 
3054
    0,                              /*tp_call*/
 
3055
    0,                              /*tp_str*/
 
3056
    0,                              /*tp_getattro*/
 
3057
    0,                              /*tp_setattro*/
 
3058
    0,                              /*tp_as_buffer*/
 
3059
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
3060
    "PJMedia Codec Param objects",       /* tp_doc */
 
3061
    0,                              /* tp_traverse */
 
3062
    0,                              /* tp_clear */
 
3063
    0,                              /* tp_richcompare */
 
3064
    0,                              /* tp_weaklistoffset */
 
3065
    0,                              /* tp_iter */
 
3066
    0,                              /* tp_iternext */
 
3067
    0,                              /* tp_methods */
 
3068
    pjmedia_codec_param_members,         /* tp_members */
 
3069
    0,                              /* tp_getset */
 
3070
    0,                              /* tp_base */
 
3071
    0,                              /* tp_dict */
 
3072
    0,                              /* tp_descr_get */
 
3073
    0,                              /* tp_descr_set */
 
3074
    0,                              /* tp_dictoffset */
 
3075
    0,                              /* tp_init */
 
3076
    0,                              /* tp_alloc */
 
3077
    pjmedia_codec_param_new,             /* tp_new */
 
3078
 
 
3079
};
 
3080
 
 
3081
/*
 
3082
 * py_pjsua_conf_get_max_ports
 
3083
 */
 
3084
static PyObject *py_pjsua_conf_get_max_ports
 
3085
(PyObject *pSelf, PyObject *pArgs)
 
3086
{    
 
3087
    int ret;
 
3088
    
 
3089
    PJ_UNUSED_ARG(pSelf);
 
3090
 
 
3091
    if (!PyArg_ParseTuple(pArgs, ""))
 
3092
    {
 
3093
        return NULL;
 
3094
    }
 
3095
    ret = pjsua_conf_get_max_ports();
 
3096
        
 
3097
    return Py_BuildValue("i", ret);
 
3098
}
 
3099
 
 
3100
/*
 
3101
 * py_pjsua_conf_get_active_ports
 
3102
 */
 
3103
static PyObject *py_pjsua_conf_get_active_ports
 
3104
(PyObject *pSelf, PyObject *pArgs)
 
3105
{    
 
3106
    int ret;
 
3107
 
 
3108
    PJ_UNUSED_ARG(pSelf);
 
3109
 
 
3110
    if (!PyArg_ParseTuple(pArgs, ""))
 
3111
    {
 
3112
        return NULL;
 
3113
    }
 
3114
    ret = pjsua_conf_get_active_ports();
 
3115
        
 
3116
    return Py_BuildValue("i", ret);
 
3117
}
 
3118
 
 
3119
/*
 
3120
 * py_pjsua_enum_conf_ports
 
3121
 * !modified @ 241206
 
3122
 */
 
3123
static PyObject *py_pjsua_enum_conf_ports(PyObject *pSelf, PyObject *pArgs)
 
3124
{
 
3125
    pj_status_t status;
 
3126
    PyObject *list;
 
3127
    
 
3128
    pjsua_conf_port_id id[PJSUA_MAX_CONF_PORTS];
 
3129
    unsigned c, i;
 
3130
 
 
3131
    PJ_UNUSED_ARG(pSelf);
 
3132
 
 
3133
    if (!PyArg_ParseTuple(pArgs, ""))
 
3134
    {
 
3135
        return NULL;
 
3136
    }   
 
3137
    
 
3138
    c = PJ_ARRAY_SIZE(id);
 
3139
    status = pjsua_enum_conf_ports(id, &c);
 
3140
    
 
3141
    list = PyList_New(c);
 
3142
    for (i = 0; i < c; i++) 
 
3143
    {
 
3144
        int ret = PyList_SetItem(list, i, Py_BuildValue("i", id[i]));
 
3145
        if (ret == -1) 
 
3146
        {
 
3147
            return NULL;
 
3148
        }
 
3149
    }
 
3150
    
 
3151
    return Py_BuildValue("O",list);
 
3152
}
 
3153
 
 
3154
/*
 
3155
 * py_pjsua_conf_get_port_info
 
3156
 */
 
3157
static PyObject *py_pjsua_conf_get_port_info
 
3158
(PyObject *pSelf, PyObject *pArgs)
 
3159
{       
 
3160
    int id;
 
3161
    PyObj_pjsua_conf_port_info * obj;
 
3162
    pjsua_conf_port_info info;
 
3163
    int status; 
 
3164
    unsigned i;
 
3165
 
 
3166
    PJ_UNUSED_ARG(pSelf);
 
3167
 
 
3168
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3169
    {
 
3170
        return NULL;
 
3171
    }
 
3172
        
 
3173
    
 
3174
    status = pjsua_conf_get_port_info(id, &info);
 
3175
    obj = (PyObj_pjsua_conf_port_info *)conf_port_info_new
 
3176
            (&PyTyp_pjsua_conf_port_info,NULL,NULL);
 
3177
    obj->bits_per_sample = info.bits_per_sample;
 
3178
    obj->channel_count = info.bits_per_sample;
 
3179
    obj->clock_rate = info.clock_rate;
 
3180
    obj->name = PyString_FromStringAndSize(info.name.ptr, info.name.slen);
 
3181
    obj->samples_per_frame = info.samples_per_frame;
 
3182
    obj->slot_id = info.slot_id;
 
3183
    
 
3184
    obj->listeners = (PyListObject *)PyList_New(info.listener_cnt);
 
3185
    for (i = 0; i < info.listener_cnt; i++) {
 
3186
        PyObject * item = Py_BuildValue("i",info.listeners[i]);
 
3187
        PyList_SetItem((PyObject *)obj->listeners, i, item);
 
3188
    }
 
3189
    return Py_BuildValue("O", obj);
 
3190
}
 
3191
 
 
3192
/*
 
3193
 * py_pjsua_conf_add_port
 
3194
 */
 
3195
static PyObject *py_pjsua_conf_add_port
 
3196
(PyObject *pSelf, PyObject *pArgs)
 
3197
{       
 
3198
    int p_id;
 
3199
    PyObject * oportObj;
 
3200
    PyObj_pjmedia_port * oport;
 
3201
    pjmedia_port * port;
 
3202
    PyObject * opoolObj;
 
3203
    PyObj_pj_pool * opool;
 
3204
    pj_pool_t * pool;
 
3205
    
 
3206
    int status; 
 
3207
    
 
3208
    PJ_UNUSED_ARG(pSelf);
 
3209
 
 
3210
    if (!PyArg_ParseTuple(pArgs, "OO", &opoolObj, &oportObj))
 
3211
    {
 
3212
        return NULL;
 
3213
    }
 
3214
    if (opoolObj != Py_None)
 
3215
    {
 
3216
        opool = (PyObj_pj_pool *)opoolObj;
 
3217
                pool = opool->pool;
 
3218
    } else {
 
3219
       opool = NULL;
 
3220
       pool = NULL;
 
3221
    }
 
3222
    if (oportObj != Py_None)
 
3223
    {
 
3224
        oport = (PyObj_pjmedia_port *)oportObj;
 
3225
                port = oport->port;
 
3226
    } else {
 
3227
        oport = NULL;
 
3228
        port = NULL;
 
3229
    }
 
3230
 
 
3231
    status = pjsua_conf_add_port(pool, port, &p_id);
 
3232
    
 
3233
    
 
3234
    return Py_BuildValue("ii", status, p_id);
 
3235
}
 
3236
 
 
3237
/*
 
3238
 * py_pjsua_conf_remove_port
 
3239
 */
 
3240
static PyObject *py_pjsua_conf_remove_port
 
3241
(PyObject *pSelf, PyObject *pArgs)
 
3242
{       
 
3243
    int id;
 
3244
    int status; 
 
3245
    
 
3246
    PJ_UNUSED_ARG(pSelf);
 
3247
 
 
3248
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3249
    {
 
3250
        return NULL;
 
3251
    }   
 
3252
    
 
3253
    status = pjsua_conf_remove_port(id);
 
3254
    
 
3255
    
 
3256
    return Py_BuildValue("i", status);
 
3257
}
 
3258
 
 
3259
/*
 
3260
 * py_pjsua_conf_connect
 
3261
 */
 
3262
static PyObject *py_pjsua_conf_connect
 
3263
(PyObject *pSelf, PyObject *pArgs)
 
3264
{       
 
3265
    int source, sink;
 
3266
    int status; 
 
3267
    
 
3268
    PJ_UNUSED_ARG(pSelf);
 
3269
 
 
3270
    if (!PyArg_ParseTuple(pArgs, "ii", &source, &sink))
 
3271
    {
 
3272
        return NULL;
 
3273
    }   
 
3274
    
 
3275
    status = pjsua_conf_connect(source, sink);
 
3276
    
 
3277
    
 
3278
    return Py_BuildValue("i", status);
 
3279
}
 
3280
 
 
3281
/*
 
3282
 * py_pjsua_conf_disconnect
 
3283
 */
 
3284
static PyObject *py_pjsua_conf_disconnect
 
3285
(PyObject *pSelf, PyObject *pArgs)
 
3286
{       
 
3287
    int source, sink;
 
3288
    int status; 
 
3289
    
 
3290
    PJ_UNUSED_ARG(pSelf);
 
3291
 
 
3292
    if (!PyArg_ParseTuple(pArgs, "ii", &source, &sink))
 
3293
    {
 
3294
        return NULL;
 
3295
    }   
 
3296
    
 
3297
    status = pjsua_conf_disconnect(source, sink);
 
3298
    
 
3299
    
 
3300
    return Py_BuildValue("i", status);
 
3301
}
 
3302
 
 
3303
/*
 
3304
 * py_pjsua_player_create
 
3305
 */
 
3306
static PyObject *py_pjsua_player_create
 
3307
(PyObject *pSelf, PyObject *pArgs)
 
3308
{       
 
3309
    int id;
 
3310
    int options;
 
3311
    PyObject * filename;
 
3312
    pj_str_t str;
 
3313
    int status; 
 
3314
    
 
3315
    PJ_UNUSED_ARG(pSelf);
 
3316
 
 
3317
    if (!PyArg_ParseTuple(pArgs, "Oi", &filename, &options))
 
3318
    {
 
3319
        return NULL;
 
3320
    }   
 
3321
    str.ptr = PyString_AsString(filename);
 
3322
    str.slen = strlen(PyString_AsString(filename));
 
3323
    status = pjsua_player_create(&str, options, &id);
 
3324
    
 
3325
    return Py_BuildValue("ii", status, id);
 
3326
}
 
3327
 
 
3328
/*
 
3329
 * py_pjsua_player_get_conf_port
 
3330
 */
 
3331
static PyObject *py_pjsua_player_get_conf_port
 
3332
(PyObject *pSelf, PyObject *pArgs)
 
3333
{       
 
3334
    
 
3335
    int id, port_id;    
 
3336
    
 
3337
    PJ_UNUSED_ARG(pSelf);
 
3338
 
 
3339
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3340
    {
 
3341
        return NULL;
 
3342
    }   
 
3343
    
 
3344
    port_id = pjsua_player_get_conf_port(id);
 
3345
    
 
3346
    
 
3347
    return Py_BuildValue("i", port_id);
 
3348
}
 
3349
 
 
3350
/*
 
3351
 * py_pjsua_player_set_pos
 
3352
 */
 
3353
static PyObject *py_pjsua_player_set_pos
 
3354
(PyObject *pSelf, PyObject *pArgs)
 
3355
{       
 
3356
    int id;
 
3357
    pj_uint32_t samples;
 
3358
    int status; 
 
3359
    
 
3360
    PJ_UNUSED_ARG(pSelf);
 
3361
 
 
3362
    if (!PyArg_ParseTuple(pArgs, "iI", &id, &samples))
 
3363
    {
 
3364
        return NULL;
 
3365
    }   
 
3366
    
 
3367
    status = pjsua_player_set_pos(id, samples);
 
3368
    
 
3369
    
 
3370
    return Py_BuildValue("i", status);
 
3371
}
 
3372
 
 
3373
/*
 
3374
 * py_pjsua_player_destroy
 
3375
 */
 
3376
static PyObject *py_pjsua_player_destroy
 
3377
(PyObject *pSelf, PyObject *pArgs)
 
3378
{       
 
3379
    int id;
 
3380
    int status; 
 
3381
    
 
3382
    PJ_UNUSED_ARG(pSelf);
 
3383
 
 
3384
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3385
    {
 
3386
        return NULL;
 
3387
    }   
 
3388
    
 
3389
    status = pjsua_player_destroy(id);
 
3390
    
 
3391
    
 
3392
    return Py_BuildValue("i", status);
 
3393
}
 
3394
 
 
3395
/*
 
3396
 * py_pjsua_recorder_create
 
3397
 * !modified @ 261206
 
3398
 */
 
3399
static PyObject *py_pjsua_recorder_create
 
3400
(PyObject *pSelf, PyObject *pArgs)
 
3401
{       
 
3402
    int p_id;
 
3403
    int options;
 
3404
    int max_size;
 
3405
    PyObject * filename;
 
3406
    pj_str_t str;
 
3407
    PyObject * enc_param;
 
3408
    pj_str_t strparam;
 
3409
    int enc_type;
 
3410
    
 
3411
    int status; 
 
3412
    
 
3413
    PJ_UNUSED_ARG(pSelf);
 
3414
 
 
3415
    if (!PyArg_ParseTuple(pArgs, "OiOii", &filename, 
 
3416
                &enc_type, &enc_param, &max_size, &options))
 
3417
    {
 
3418
        return NULL;
 
3419
    }   
 
3420
    str.ptr = PyString_AsString(filename);
 
3421
    str.slen = strlen(PyString_AsString(filename));
 
3422
    if (enc_param != Py_None)
 
3423
    {
 
3424
        strparam.ptr = PyString_AsString(enc_param);
 
3425
        strparam.slen = strlen(PyString_AsString(enc_param));
 
3426
        status = pjsua_recorder_create
 
3427
                (&str, enc_type, NULL, max_size, options, &p_id);
 
3428
    } else {
 
3429
        status = pjsua_recorder_create
 
3430
                (&str, enc_type, NULL, max_size, options, &p_id);
 
3431
    }
 
3432
    return Py_BuildValue("ii", status, p_id);
 
3433
}
 
3434
 
 
3435
/*
 
3436
 * py_pjsua_recorder_get_conf_port
 
3437
 */
 
3438
static PyObject *py_pjsua_recorder_get_conf_port
 
3439
(PyObject *pSelf, PyObject *pArgs)
 
3440
{       
 
3441
    
 
3442
    int id, port_id;    
 
3443
    
 
3444
    PJ_UNUSED_ARG(pSelf);
 
3445
 
 
3446
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3447
    {
 
3448
        return NULL;
 
3449
    }   
 
3450
    
 
3451
    port_id = pjsua_recorder_get_conf_port(id);
 
3452
    
 
3453
    
 
3454
    return Py_BuildValue("i", port_id);
 
3455
}
 
3456
 
 
3457
/*
 
3458
 * py_pjsua_recorder_destroy
 
3459
 */
 
3460
static PyObject *py_pjsua_recorder_destroy
 
3461
(PyObject *pSelf, PyObject *pArgs)
 
3462
{       
 
3463
    int id;
 
3464
    int status; 
 
3465
    
 
3466
    PJ_UNUSED_ARG(pSelf);
 
3467
 
 
3468
    if (!PyArg_ParseTuple(pArgs, "i", &id))
 
3469
    {
 
3470
        return NULL;
 
3471
    }   
 
3472
    
 
3473
    status = pjsua_recorder_destroy(id);
 
3474
    
 
3475
    
 
3476
    return Py_BuildValue("i", status);
 
3477
}
 
3478
 
 
3479
/*
 
3480
 * py_pjsua_enum_snd_devs
 
3481
 */
 
3482
static PyObject *py_pjsua_enum_snd_devs(PyObject *pSelf, PyObject *pArgs)
 
3483
{
 
3484
    pj_status_t status;
 
3485
    PyObject *list;
 
3486
    
 
3487
    pjmedia_snd_dev_info info[SND_DEV_NUM];
 
3488
    unsigned c, i;
 
3489
 
 
3490
    PJ_UNUSED_ARG(pSelf);
 
3491
 
 
3492
    if (!PyArg_ParseTuple(pArgs, ""))
 
3493
    {
 
3494
        return NULL;
 
3495
    }   
 
3496
    
 
3497
    c = PJ_ARRAY_SIZE(info);
 
3498
    status = pjsua_enum_snd_devs(info, &c);
 
3499
    
 
3500
    list = PyList_New(c);
 
3501
    for (i = 0; i < c; i++) 
 
3502
    {
 
3503
        int ret;
 
3504
        int j;
 
3505
        char * str;
 
3506
        
 
3507
        PyObj_pjmedia_snd_dev_info * obj;
 
3508
        obj = (PyObj_pjmedia_snd_dev_info *)pjmedia_snd_dev_info_new
 
3509
            (&PyTyp_pjmedia_snd_dev_info, NULL, NULL);
 
3510
        obj->default_samples_per_sec = info[i].default_samples_per_sec;
 
3511
        obj->input_count = info[i].input_count;
 
3512
        obj->output_count = info[i].output_count;
 
3513
        str = (char *)malloc(SND_NAME_LEN * sizeof(char));
 
3514
        memset(str, 0, SND_NAME_LEN);
 
3515
        for (j = 0; j < SND_NAME_LEN; j++)
 
3516
        {
 
3517
            str[j] = info[i].name[j];
 
3518
        }
 
3519
        obj->name = PyString_FromStringAndSize(str, SND_NAME_LEN);
 
3520
        free(str);
 
3521
        ret = PyList_SetItem(list, i, (PyObject *)obj);
 
3522
        if (ret == -1) 
 
3523
        {
 
3524
            return NULL;
 
3525
        }
 
3526
    }
 
3527
    
 
3528
    return Py_BuildValue("O",list);
 
3529
}
 
3530
 
 
3531
/*
 
3532
 * py_pjsua_get_snd_dev
 
3533
 */
 
3534
static PyObject *py_pjsua_get_snd_dev
 
3535
(PyObject *pSelf, PyObject *pArgs)
 
3536
{       
 
3537
    int capture_dev, playback_dev;
 
3538
    int status; 
 
3539
    
 
3540
    PJ_UNUSED_ARG(pSelf);
 
3541
 
 
3542
    if (!PyArg_ParseTuple(pArgs, ""))
 
3543
    {
 
3544
        return NULL;
 
3545
    }   
 
3546
    
 
3547
    status = pjsua_get_snd_dev(&capture_dev, &playback_dev);
 
3548
    
 
3549
    
 
3550
    return Py_BuildValue("ii", capture_dev, playback_dev);
 
3551
}
 
3552
 
 
3553
/*
 
3554
 * py_pjsua_set_snd_dev
 
3555
 */
 
3556
static PyObject *py_pjsua_set_snd_dev
 
3557
(PyObject *pSelf, PyObject *pArgs)
 
3558
{       
 
3559
    int capture_dev, playback_dev;
 
3560
    int status; 
 
3561
    
 
3562
    PJ_UNUSED_ARG(pSelf);
 
3563
 
 
3564
    if (!PyArg_ParseTuple(pArgs, "ii", &capture_dev, &playback_dev))
 
3565
    {
 
3566
        return NULL;
 
3567
    }   
 
3568
    
 
3569
    status = pjsua_set_snd_dev(capture_dev, playback_dev);
 
3570
    
 
3571
    
 
3572
    return Py_BuildValue("i", status);
 
3573
}
 
3574
 
 
3575
/*
 
3576
 * py_pjsua_set_null_snd_dev
 
3577
 */
 
3578
static PyObject *py_pjsua_set_null_snd_dev
 
3579
(PyObject *pSelf, PyObject *pArgs)
 
3580
{       
 
3581
    
 
3582
    int status; 
 
3583
    
 
3584
    PJ_UNUSED_ARG(pSelf);
 
3585
 
 
3586
    if (!PyArg_ParseTuple(pArgs, ""))
 
3587
    {
 
3588
        return NULL;
 
3589
    }   
 
3590
    
 
3591
    status = pjsua_set_null_snd_dev();
 
3592
    
 
3593
    
 
3594
    return Py_BuildValue("i", status);
 
3595
}
 
3596
 
 
3597
/*
 
3598
 * py_pjsua_set_no_snd_dev
 
3599
 */
 
3600
static PyObject *py_pjsua_set_no_snd_dev
 
3601
(PyObject *pSelf, PyObject *pArgs)
 
3602
{       
 
3603
    
 
3604
    PyObj_pjmedia_port * obj;   
 
3605
    
 
3606
    PJ_UNUSED_ARG(pSelf);
 
3607
 
 
3608
    if (!PyArg_ParseTuple(pArgs, ""))
 
3609
    {
 
3610
        return NULL;
 
3611
    }   
 
3612
     
 
3613
    obj = (PyObj_pjmedia_port *)PyType_GenericNew
 
3614
        (&PyTyp_pjmedia_port, NULL, NULL);
 
3615
    obj->port = pjsua_set_no_snd_dev();
 
3616
    return Py_BuildValue("O", obj);
 
3617
}
 
3618
 
 
3619
/*
 
3620
 * py_pjsua_set_ec
 
3621
 */
 
3622
static PyObject *py_pjsua_set_ec
 
3623
(PyObject *pSelf, PyObject *pArgs)
 
3624
{       
 
3625
    int options;
 
3626
    int tail_ms;
 
3627
    int status; 
 
3628
    
 
3629
    PJ_UNUSED_ARG(pSelf);
 
3630
 
 
3631
    if (!PyArg_ParseTuple(pArgs, "ii", &tail_ms, &options))
 
3632
    {
 
3633
        return NULL;
 
3634
    }   
 
3635
    
 
3636
    status = pjsua_set_ec(tail_ms, options);
 
3637
    
 
3638
    
 
3639
    return Py_BuildValue("i", status);
 
3640
}
 
3641
 
 
3642
/*
 
3643
 * py_pjsua_get_ec_tail
 
3644
 */
 
3645
static PyObject *py_pjsua_get_ec_tail
 
3646
(PyObject *pSelf, PyObject *pArgs)
 
3647
{       
 
3648
    
 
3649
    int status; 
 
3650
    unsigned p_tail_ms;
 
3651
 
 
3652
    PJ_UNUSED_ARG(pSelf);
 
3653
 
 
3654
    if (!PyArg_ParseTuple(pArgs, ""))
 
3655
    {
 
3656
        return NULL;
 
3657
    }   
 
3658
    
 
3659
    status = pjsua_get_ec_tail(&p_tail_ms);
 
3660
    
 
3661
    
 
3662
    return Py_BuildValue("i", p_tail_ms);
 
3663
}
 
3664
 
 
3665
/*
 
3666
 * py_pjsua_enum_codecs
 
3667
 * !modified @ 261206
 
3668
 */
 
3669
static PyObject *py_pjsua_enum_codecs(PyObject *pSelf, PyObject *pArgs)
 
3670
{
 
3671
    pj_status_t status;
 
3672
    PyObject *list;
 
3673
    
 
3674
    pjsua_codec_info info[PJMEDIA_CODEC_MGR_MAX_CODECS];
 
3675
    unsigned c, i;
 
3676
 
 
3677
    PJ_UNUSED_ARG(pSelf);
 
3678
 
 
3679
    if (!PyArg_ParseTuple(pArgs, ""))
 
3680
    {
 
3681
        return NULL;
 
3682
    }   
 
3683
    
 
3684
    c = PJ_ARRAY_SIZE(info);
 
3685
    status = pjsua_enum_codecs(info, &c);
 
3686
    
 
3687
    list = PyList_New(c);
 
3688
    for (i = 0; i < c; i++) 
 
3689
    {
 
3690
        int ret;
 
3691
        int j;
 
3692
        PyObj_pjsua_codec_info * obj;
 
3693
        obj = (PyObj_pjsua_codec_info *)codec_info_new
 
3694
            (&PyTyp_pjsua_codec_info, NULL, NULL);
 
3695
        obj->codec_id = PyString_FromStringAndSize
 
3696
            (info[i].codec_id.ptr, info[i].codec_id.slen);
 
3697
        obj->priority = info[i].priority;
 
3698
        for (j = 0; j < 32; j++)
 
3699
        {           
 
3700
             obj->buf_[j] = info[i].buf_[j];
 
3701
        }       
 
3702
        ret = PyList_SetItem(list, i, (PyObject *)obj);
 
3703
        if (ret == -1) {
 
3704
            return NULL;
 
3705
        }       
 
3706
    }
 
3707
    
 
3708
 
 
3709
    return Py_BuildValue("O",list);
 
3710
}
 
3711
 
 
3712
/*
 
3713
 * py_pjsua_codec_set_priority
 
3714
 */
 
3715
static PyObject *py_pjsua_codec_set_priority
 
3716
(PyObject *pSelf, PyObject *pArgs)
 
3717
{       
 
3718
    
 
3719
    int status; 
 
3720
    PyObject * id;
 
3721
    pj_str_t str;
 
3722
    pj_uint8_t priority;
 
3723
    
 
3724
    PJ_UNUSED_ARG(pSelf);
 
3725
 
 
3726
    if (!PyArg_ParseTuple(pArgs, "OB", &id, &priority))
 
3727
    {
 
3728
        return NULL;
 
3729
    }   
 
3730
    str.ptr = PyString_AsString(id);
 
3731
    str.slen = strlen(PyString_AsString(id));
 
3732
    status = pjsua_codec_set_priority(&str, priority);
 
3733
    
 
3734
    
 
3735
    return Py_BuildValue("i", status);
 
3736
}
 
3737
 
 
3738
/*
 
3739
 * py_pjsua_codec_get_param
 
3740
 */
 
3741
static PyObject *py_pjsua_codec_get_param
 
3742
(PyObject *pSelf, PyObject *pArgs)
 
3743
{       
 
3744
    
 
3745
    int status; 
 
3746
    PyObject * id;
 
3747
    pj_str_t str;
 
3748
    pjmedia_codec_param param;
 
3749
    PyObj_pjmedia_codec_param *obj;
 
3750
    
 
3751
    PJ_UNUSED_ARG(pSelf);
 
3752
 
 
3753
    if (!PyArg_ParseTuple(pArgs, "O", &id))
 
3754
    {
 
3755
        return NULL;
 
3756
    }   
 
3757
    str.ptr = PyString_AsString(id);
 
3758
    str.slen = strlen(PyString_AsString(id));
 
3759
    status = pjsua_codec_get_param(&str, &param);
 
3760
    obj = (PyObj_pjmedia_codec_param *)pjmedia_codec_param_new
 
3761
        (&PyTyp_pjmedia_codec_param, NULL, NULL);
 
3762
    obj->info->avg_bps = param.info.avg_bps;
 
3763
    obj->info->channel_cnt = param.info.channel_cnt;
 
3764
    obj->info->clock_rate = param.info.clock_rate;
 
3765
    obj->info->frm_ptime = param.info.frm_ptime;
 
3766
    obj->info->pcm_bits_per_sample = param.info.pcm_bits_per_sample;
 
3767
    obj->info->pt = param.info.pt;
 
3768
    obj->setting->cng = param.setting.cng;
 
3769
    //deprecated:
 
3770
    //obj->setting->dec_fmtp_mode = param.setting.dec_fmtp_mode;
 
3771
    //obj->setting->enc_fmtp_mode = param.setting.enc_fmtp_mode;
 
3772
    obj->setting->frm_per_pkt = param.setting.frm_per_pkt;
 
3773
    obj->setting->penh = param.setting.penh;
 
3774
    obj->setting->plc = param.setting.plc;
 
3775
    obj->setting->reserved = param.setting.reserved;
 
3776
    obj->setting->vad = param.setting.vad;
 
3777
 
 
3778
    return Py_BuildValue("O", obj);
 
3779
}
 
3780
/*
 
3781
 * py_pjsua_codec_set_param
 
3782
 */
 
3783
static PyObject *py_pjsua_codec_set_param
 
3784
(PyObject *pSelf, PyObject *pArgs)
 
3785
{       
 
3786
    
 
3787
    int status; 
 
3788
    PyObject * id;
 
3789
    pj_str_t str;
 
3790
    pjmedia_codec_param param;
 
3791
    PyObject * tmpObj;
 
3792
    PyObj_pjmedia_codec_param *obj;
 
3793
    
 
3794
    PJ_UNUSED_ARG(pSelf);
 
3795
 
 
3796
    if (!PyArg_ParseTuple(pArgs, "OO", &id, &tmpObj))
 
3797
    {
 
3798
        return NULL;
 
3799
    }   
 
3800
 
 
3801
    str.ptr = PyString_AsString(id);
 
3802
    str.slen = strlen(PyString_AsString(id));
 
3803
    if (tmpObj != Py_None)
 
3804
    {
 
3805
        obj = (PyObj_pjmedia_codec_param *)tmpObj;
 
3806
        param.info.avg_bps = obj->info->avg_bps;
 
3807
        param.info.channel_cnt = obj->info->channel_cnt;
 
3808
        param.info.clock_rate = obj->info->clock_rate;
 
3809
        param.info.frm_ptime = obj->info->frm_ptime;
 
3810
        param.info.pcm_bits_per_sample = obj->info->pcm_bits_per_sample;
 
3811
        param.info.pt = obj->info->pt;
 
3812
        param.setting.cng = obj->setting->cng;
 
3813
        //Deprecated:
 
3814
        //param.setting.dec_fmtp_mode = obj->setting->dec_fmtp_mode;
 
3815
        //param.setting.enc_fmtp_mode = obj->setting->enc_fmtp_mode;
 
3816
        param.setting.frm_per_pkt = obj->setting->frm_per_pkt;
 
3817
        param.setting.penh = obj->setting->penh;
 
3818
        param.setting.plc = obj->setting->plc;
 
3819
        param.setting.reserved = obj->setting->reserved;
 
3820
        param.setting.vad = obj->setting->vad;
 
3821
        status = pjsua_codec_set_param(&str, &param);
 
3822
    } else {
 
3823
        status = pjsua_codec_set_param(&str, NULL);
 
3824
    }
 
3825
    return Py_BuildValue("i", status);
 
3826
}
 
3827
 
 
3828
static char pjsua_conf_get_max_ports_doc[] =
 
3829
    "int py_pjsua.conf_get_max_ports () "
 
3830
    "Get maxinum number of conference ports.";
 
3831
static char pjsua_conf_get_active_ports_doc[] =
 
3832
    "int py_pjsua.conf_get_active_ports () "
 
3833
    "Get current number of active ports in the bridge.";
 
3834
static char pjsua_enum_conf_ports_doc[] =
 
3835
    "int[] py_pjsua.enum_conf_ports () "
 
3836
    "Enumerate all conference ports.";
 
3837
static char pjsua_conf_get_port_info_doc[] =
 
3838
    "py_pjsua.Conf_Port_Info py_pjsua.conf_get_port_info (int id) "
 
3839
    "Get information about the specified conference port";
 
3840
static char pjsua_conf_add_port_doc[] =
 
3841
    "int, int py_pjsua.conf_add_port "
 
3842
    "(py_pjsua.Pj_Pool pool, py_pjsua.PJMedia_Port port) "
 
3843
    "Add arbitrary media port to PJSUA's conference bridge. "
 
3844
    "Application can use this function to add the media port "
 
3845
    "that it creates. For media ports that are created by PJSUA-LIB "
 
3846
    "(such as calls, file player, or file recorder), PJSUA-LIB will "
 
3847
    "automatically add the port to the bridge.";
 
3848
static char pjsua_conf_remove_port_doc[] =
 
3849
    "int py_pjsua.conf_remove_port (int id) "
 
3850
    "Remove arbitrary slot from the conference bridge. "
 
3851
    "Application should only call this function "
 
3852
    "if it registered the port manually.";
 
3853
static char pjsua_conf_connect_doc[] =
 
3854
    "int py_pjsua.conf_connect (int source, int sink) "
 
3855
    "Establish unidirectional media flow from souce to sink. "
 
3856
    "One source may transmit to multiple destinations/sink. "
 
3857
    "And if multiple sources are transmitting to the same sink, "
 
3858
    "the media will be mixed together. Source and sink may refer "
 
3859
    "to the same ID, effectively looping the media. "
 
3860
    "If bidirectional media flow is desired, application "
 
3861
    "needs to call this function twice, with the second "
 
3862
    "one having the arguments reversed.";
 
3863
static char pjsua_conf_disconnect_doc[] =
 
3864
    "int py_pjsua.conf_disconnect (int source, int sink) "
 
3865
    "Disconnect media flow from the source to destination port.";
 
3866
static char pjsua_player_create_doc[] =
 
3867
    "int, int py_pjsua.player_create (string filename, int options) "
 
3868
    "Create a file player, and automatically connect "
 
3869
    "this player to the conference bridge.";
 
3870
static char pjsua_player_get_conf_port_doc[] =
 
3871
    "int py_pjsua.player_get_conf_port (int) "
 
3872
    "Get conference port ID associated with player.";
 
3873
static char pjsua_player_set_pos_doc[] =
 
3874
    "int py_pjsua.player_set_pos (int id, int samples) "
 
3875
    "Set playback position.";
 
3876
static char pjsua_player_destroy_doc[] =
 
3877
    "int py_pjsua.player_destroy (int id) "
 
3878
    "Close the file, remove the player from the bridge, "
 
3879
    "and free resources associated with the file player.";
 
3880
static char pjsua_recorder_create_doc[] =
 
3881
    "int, int py_pjsua.recorder_create (string filename, "
 
3882
    "int enc_type, int enc_param, int max_size, int options) "
 
3883
    "Create a file recorder, and automatically connect this recorder "
 
3884
    "to the conference bridge. The recorder currently supports recording "
 
3885
    "WAV file, and on Windows, MP3 file. The type of the recorder to use "
 
3886
    "is determined by the extension of the file (e.g. '.wav' or '.mp3').";
 
3887
static char pjsua_recorder_get_conf_port_doc[] =
 
3888
    "int py_pjsua.recorder_get_conf_port (int id) "
 
3889
    "Get conference port associated with recorder.";
 
3890
static char pjsua_recorder_destroy_doc[] =
 
3891
    "int py_pjsua.recorder_destroy (int id) "
 
3892
    "Destroy recorder (this will complete recording).";
 
3893
static char pjsua_enum_snd_devs_doc[] =
 
3894
    "py_pjsua.PJMedia_Snd_Dev_Info[] py_pjsua.enum_snd_devs (int count) "
 
3895
    "Enum sound devices.";
 
3896
static char pjsua_get_snd_dev_doc[] =
 
3897
    "int, int py_pjsua.get_snd_dev () "
 
3898
    "Get currently active sound devices. "
 
3899
    "If sound devices has not been created "
 
3900
    "(for example when pjsua_start() is not called), "
 
3901
    "it is possible that the function returns "
 
3902
    "PJ_SUCCESS with -1 as device IDs.";
 
3903
static char pjsua_set_snd_dev_doc[] =
 
3904
    "int py_pjsua.set_snd_dev (int capture_dev, int playback_dev) "
 
3905
    "Select or change sound device. Application may call this function "
 
3906
    "at any time to replace current sound device.";
 
3907
static char pjsua_set_null_snd_dev_doc[] =
 
3908
    "int py_pjsua.set_null_snd_dev () "
 
3909
    "Set pjsua to use null sound device. The null sound device only "
 
3910
    "provides the timing needed by the conference bridge, and will not "
 
3911
    "interract with any hardware.";
 
3912
static char pjsua_set_no_snd_dev_doc[] =
 
3913
    "py_pjsua.PJMedia_Port py_pjsua.set_no_snd_dev () "
 
3914
    "Disconnect the main conference bridge from any sound devices, "
 
3915
    "and let application connect the bridge to it's "
 
3916
    "own sound device/master port.";
 
3917
static char pjsua_set_ec_doc[] =
 
3918
    "int py_pjsua.set_ec (int tail_ms, int options) "
 
3919
    "Configure the echo canceller tail length of the sound port.";
 
3920
static char pjsua_get_ec_tail_doc[] =
 
3921
    "int py_pjsua.get_ec_tail () "
 
3922
    "Get current echo canceller tail length.";
 
3923
static char pjsua_enum_codecs_doc[] =
 
3924
    "py_pjsua.Codec_Info[] py_pjsua.enum_codecs () "
 
3925
    "Enum all supported codecs in the system.";
 
3926
static char pjsua_codec_set_priority_doc[] =
 
3927
    "int py_pjsua.codec_set_priority (string id, int priority) "
 
3928
    "Change codec priority.";
 
3929
static char pjsua_codec_get_param_doc[] =
 
3930
    "py_pjsua.PJMedia_Codec_Param py_pjsua.codec_get_param (string id) "
 
3931
    "Get codec parameters";
 
3932
static char pjsua_codec_set_param_doc[] =
 
3933
    "int py_pjsua.codec_set_param (string id, "
 
3934
    "py_pjsua.PJMedia_Codec_Param param) "
 
3935
    "Set codec parameters.";
 
3936
 
 
3937
/* END OF LIB MEDIA */
 
3938
 
 
3939
/* LIB CALL */
 
3940
 
 
3941
/*
 
3942
 * PyObj_pj_time_val
 
3943
 * PJ Time Val
 
3944
 */
 
3945
typedef struct
 
3946
{
 
3947
    PyObject_HEAD
 
3948
    /* Type-specific fields go here. */ 
 
3949
    long sec;
 
3950
    long msec;
 
3951
 
 
3952
} PyObj_pj_time_val;
 
3953
 
 
3954
 
 
3955
 
 
3956
/*
 
3957
 * pj_time_val_members
 
3958
 */
 
3959
static PyMemberDef pj_time_val_members[] =
 
3960
{   
 
3961
    
 
3962
    {
 
3963
        "sec", T_INT, 
 
3964
        offsetof(PyObj_pj_time_val, sec), 0,
 
3965
        "The seconds part of the time"
 
3966
    },
 
3967
    {
 
3968
        "msec", T_INT, 
 
3969
        offsetof(PyObj_pj_time_val, sec), 0,
 
3970
        "The milliseconds fraction of the time"
 
3971
    },
 
3972
    
 
3973
    
 
3974
    {NULL}  /* Sentinel */
 
3975
};
 
3976
 
 
3977
 
 
3978
 
 
3979
 
 
3980
/*
 
3981
 * PyTyp_pj_time_val
 
3982
 */
 
3983
static PyTypeObject PyTyp_pj_time_val =
 
3984
{
 
3985
    PyObject_HEAD_INIT(NULL)
 
3986
    0,                              /*ob_size*/
 
3987
    "py_pjsua.PJ_Time_Val",      /*tp_name*/
 
3988
    sizeof(PyObj_pj_time_val),  /*tp_basicsize*/
 
3989
    0,                              /*tp_itemsize*/
 
3990
    0,/*tp_dealloc*/
 
3991
    0,                              /*tp_print*/
 
3992
    0,                              /*tp_getattr*/
 
3993
    0,                              /*tp_setattr*/
 
3994
    0,                              /*tp_compare*/
 
3995
    0,                              /*tp_repr*/
 
3996
    0,                              /*tp_as_number*/
 
3997
    0,                              /*tp_as_sequence*/
 
3998
    0,                              /*tp_as_mapping*/
 
3999
    0,                              /*tp_hash */
 
4000
    0,                              /*tp_call*/
 
4001
    0,                              /*tp_str*/
 
4002
    0,                              /*tp_getattro*/
 
4003
    0,                              /*tp_setattro*/
 
4004
    0,                              /*tp_as_buffer*/
 
4005
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
4006
    "PJ Time Val objects",       /* tp_doc */
 
4007
    0,                              /* tp_traverse */
 
4008
    0,                              /* tp_clear */
 
4009
    0,                              /* tp_richcompare */
 
4010
    0,                              /* tp_weaklistoffset */
 
4011
    0,                              /* tp_iter */
 
4012
    0,                              /* tp_iternext */
 
4013
    0,                              /* tp_methods */
 
4014
    pj_time_val_members,         /* tp_members */
 
4015
    
 
4016
 
 
4017
};
 
4018
 
 
4019
/*
 
4020
 * PyObj_pjsua_call_info
 
4021
 * Call Info
 
4022
 */
 
4023
typedef struct
 
4024
{
 
4025
    PyObject_HEAD
 
4026
    /* Type-specific fields go here. */ 
 
4027
    
 
4028
    int id;
 
4029
    int role;
 
4030
    int acc_id;
 
4031
    PyObject * local_info;
 
4032
    PyObject * local_contact;
 
4033
    PyObject * remote_info;
 
4034
    PyObject * remote_contact;
 
4035
    PyObject * call_id;
 
4036
    int state;
 
4037
    PyObject * state_text;
 
4038
    int last_status;
 
4039
    PyObject * last_status_text;
 
4040
    int media_status;
 
4041
    int media_dir;
 
4042
    int conf_slot;
 
4043
    PyObj_pj_time_val * connect_duration;
 
4044
    PyObj_pj_time_val * total_duration;
 
4045
    struct {
 
4046
        char local_info[128];
 
4047
        char local_contact[128];
 
4048
        char remote_info[128];
 
4049
        char remote_contact[128];
 
4050
        char call_id[128];
 
4051
        char last_status_text[128];
 
4052
    } buf_;
 
4053
 
 
4054
} PyObj_pjsua_call_info;
 
4055
 
 
4056
 
 
4057
/*
 
4058
 * call_info_dealloc
 
4059
 * deletes a call_info from memory
 
4060
 */
 
4061
static void call_info_dealloc(PyObj_pjsua_call_info* self)
 
4062
{
 
4063
    Py_XDECREF(self->local_info);
 
4064
    Py_XDECREF(self->local_contact);
 
4065
    Py_XDECREF(self->remote_info);
 
4066
    Py_XDECREF(self->remote_contact);
 
4067
    Py_XDECREF(self->call_id);
 
4068
    Py_XDECREF(self->state_text);
 
4069
    Py_XDECREF(self->last_status_text);
 
4070
    Py_XDECREF(self->connect_duration);
 
4071
    Py_XDECREF(self->total_duration);
 
4072
    self->ob_type->tp_free((PyObject*)self);
 
4073
}
 
4074
 
 
4075
 
 
4076
/*
 
4077
 * call_info_new
 
4078
 * constructor for call_info object
 
4079
 */
 
4080
static PyObject * call_info_new(PyTypeObject *type, PyObject *args,
 
4081
                                    PyObject *kwds)
 
4082
{
 
4083
    PyObj_pjsua_call_info *self;
 
4084
 
 
4085
    PJ_UNUSED_ARG(args);
 
4086
    PJ_UNUSED_ARG(kwds);
 
4087
 
 
4088
    self = (PyObj_pjsua_call_info *)type->tp_alloc(type, 0);
 
4089
    if (self != NULL)
 
4090
    {
 
4091
        self->local_info = PyString_FromString("");
 
4092
        if (self->local_info == NULL)
 
4093
        {
 
4094
            Py_DECREF(self);
 
4095
            return NULL;
 
4096
        }       
 
4097
        self->local_contact = PyString_FromString("");
 
4098
        if (self->local_contact == NULL)
 
4099
        {
 
4100
            Py_DECREF(self);
 
4101
            return NULL;
 
4102
        }
 
4103
        self->remote_info = PyString_FromString("");
 
4104
        if (self->remote_info == NULL)
 
4105
        {
 
4106
            Py_DECREF(self);
 
4107
            return NULL;
 
4108
        }
 
4109
        self->remote_contact = PyString_FromString("");
 
4110
        if (self->remote_contact == NULL)
 
4111
        {
 
4112
            Py_DECREF(self);
 
4113
            return NULL;
 
4114
        }
 
4115
        self->call_id = PyString_FromString("");
 
4116
        if (self->call_id == NULL)
 
4117
        {
 
4118
            Py_DECREF(self);
 
4119
            return NULL;
 
4120
        }
 
4121
        self->state_text = PyString_FromString("");
 
4122
        if (self->state_text == NULL)
 
4123
        {
 
4124
            Py_DECREF(self);
 
4125
            return NULL;
 
4126
        }
 
4127
        self->last_status_text = PyString_FromString("");
 
4128
        if (self->last_status_text == NULL)
 
4129
        {
 
4130
            Py_DECREF(self);
 
4131
            return NULL;
 
4132
        }
 
4133
        self->connect_duration = (PyObj_pj_time_val *)PyType_GenericNew
 
4134
            (&PyTyp_pj_time_val,NULL,NULL);
 
4135
        if (self->connect_duration == NULL)
 
4136
        {
 
4137
            Py_DECREF(self);
 
4138
            return NULL;
 
4139
        }
 
4140
        self->total_duration = (PyObj_pj_time_val *)PyType_GenericNew
 
4141
            (&PyTyp_pj_time_val,NULL,NULL);
 
4142
        if (self->total_duration == NULL)
 
4143
        {
 
4144
            Py_DECREF(self);
 
4145
            return NULL;
 
4146
        }
 
4147
    }
 
4148
    return (PyObject *)self;
 
4149
}
 
4150
 
 
4151
/*
 
4152
 * call_info_members
 
4153
 */
 
4154
static PyMemberDef call_info_members[] =
 
4155
{   
 
4156
    {
 
4157
        "id", T_INT, 
 
4158
        offsetof(PyObj_pjsua_call_info, id), 0,
 
4159
        "Call identification"
 
4160
    },
 
4161
    {
 
4162
        "role", T_INT, 
 
4163
        offsetof(PyObj_pjsua_call_info, role), 0,
 
4164
        "Initial call role (UAC == caller)"
 
4165
    },
 
4166
    {
 
4167
        "acc_id", T_INT, 
 
4168
        offsetof(PyObj_pjsua_call_info, acc_id), 0,
 
4169
        "The account ID where this call belongs."
 
4170
    },
 
4171
    {
 
4172
        "local_info", T_OBJECT_EX,
 
4173
        offsetof(PyObj_pjsua_call_info, local_info), 0,
 
4174
        "Local URI"        
 
4175
    },
 
4176
    {
 
4177
        "local_contact", T_OBJECT_EX,
 
4178
        offsetof(PyObj_pjsua_call_info, local_contact), 0,
 
4179
        "Local Contact"        
 
4180
    },
 
4181
    {
 
4182
        "remote_info", T_OBJECT_EX,
 
4183
        offsetof(PyObj_pjsua_call_info, remote_info), 0,
 
4184
        "Remote URI"        
 
4185
    },
 
4186
    {
 
4187
        "remote_contact", T_OBJECT_EX,
 
4188
        offsetof(PyObj_pjsua_call_info, remote_contact), 0,
 
4189
        "Remote Contact"        
 
4190
    },
 
4191
    {
 
4192
        "call_id", T_OBJECT_EX,
 
4193
        offsetof(PyObj_pjsua_call_info, call_id), 0,
 
4194
        "Dialog Call-ID string"        
 
4195
    },
 
4196
    {
 
4197
        "state", T_INT, 
 
4198
        offsetof(PyObj_pjsua_call_info, state), 0,
 
4199
        "Call state"
 
4200
    },
 
4201
    {
 
4202
        "state_text", T_OBJECT_EX,
 
4203
        offsetof(PyObj_pjsua_call_info, state_text), 0,
 
4204
        "Text describing the state "        
 
4205
    },
 
4206
    {
 
4207
        "last_status", T_INT, 
 
4208
        offsetof(PyObj_pjsua_call_info, last_status), 0,
 
4209
        "Last status code heard, which can be used as cause code"
 
4210
    },
 
4211
    {
 
4212
        "last_status_text", T_OBJECT_EX,
 
4213
        offsetof(PyObj_pjsua_call_info, last_status_text), 0,
 
4214
        "The reason phrase describing the status."        
 
4215
    },
 
4216
    {
 
4217
        "media_status", T_INT, 
 
4218
        offsetof(PyObj_pjsua_call_info, media_status), 0,
 
4219
        "Call media status."
 
4220
    },
 
4221
    {
 
4222
        "media_dir", T_INT, 
 
4223
        offsetof(PyObj_pjsua_call_info, media_dir), 0,
 
4224
        "Media direction"
 
4225
    },
 
4226
    {
 
4227
        "conf_slot", T_INT, 
 
4228
        offsetof(PyObj_pjsua_call_info, conf_slot), 0,
 
4229
        "The conference port number for the call"
 
4230
    },
 
4231
    {
 
4232
        "connect_duration", T_OBJECT_EX,
 
4233
        offsetof(PyObj_pjsua_call_info, connect_duration), 0,
 
4234
        "Up-to-date call connected duration(zero when call is not established)"
 
4235
    },
 
4236
    {
 
4237
        "total_duration", T_OBJECT_EX,
 
4238
        offsetof(PyObj_pjsua_call_info, total_duration), 0,
 
4239
        "Total call duration, including set-up time"        
 
4240
    },
 
4241
    
 
4242
    {NULL}  /* Sentinel */
 
4243
};
 
4244
 
 
4245
 
 
4246
 
 
4247
 
 
4248
/*
 
4249
 * PyTyp_pjsua_call_info
 
4250
 */
 
4251
static PyTypeObject PyTyp_pjsua_call_info =
 
4252
{
 
4253
    PyObject_HEAD_INIT(NULL)
 
4254
    0,                              /*ob_size*/
 
4255
    "py_pjsua.Call_Info",      /*tp_name*/
 
4256
    sizeof(PyObj_pjsua_call_info),  /*tp_basicsize*/
 
4257
    0,                              /*tp_itemsize*/
 
4258
    (destructor)call_info_dealloc,/*tp_dealloc*/
 
4259
    0,                              /*tp_print*/
 
4260
    0,                              /*tp_getattr*/
 
4261
    0,                              /*tp_setattr*/
 
4262
    0,                              /*tp_compare*/
 
4263
    0,                              /*tp_repr*/
 
4264
    0,                              /*tp_as_number*/
 
4265
    0,                              /*tp_as_sequence*/
 
4266
    0,                              /*tp_as_mapping*/
 
4267
    0,                              /*tp_hash */
 
4268
    0,                              /*tp_call*/
 
4269
    0,                              /*tp_str*/
 
4270
    0,                              /*tp_getattro*/
 
4271
    0,                              /*tp_setattro*/
 
4272
    0,                              /*tp_as_buffer*/
 
4273
    Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 
4274
    "Call Info objects",       /* tp_doc */
 
4275
    0,                              /* tp_traverse */
 
4276
    0,                              /* tp_clear */
 
4277
    0,                              /* tp_richcompare */
 
4278
    0,                              /* tp_weaklistoffset */
 
4279
    0,                              /* tp_iter */
 
4280
    0,                              /* tp_iternext */
 
4281
    0,                              /* tp_methods */
 
4282
    call_info_members,         /* tp_members */
 
4283
    0,                              /* tp_getset */
 
4284
    0,                              /* tp_base */
 
4285
    0,                              /* tp_dict */
 
4286
    0,                              /* tp_descr_get */
 
4287
    0,                              /* tp_descr_set */
 
4288
    0,                              /* tp_dictoffset */
 
4289
    0,                              /* tp_init */
 
4290
    0,                              /* tp_alloc */
 
4291
    call_info_new,             /* tp_new */
 
4292
 
 
4293
};
 
4294
 
 
4295
/*
 
4296
 * py_pjsua_call_get_max_count
 
4297
 */
 
4298
static PyObject *py_pjsua_call_get_max_count
 
4299
(PyObject *pSelf, PyObject *pArgs)
 
4300
{       
 
4301
    int count;
 
4302
 
 
4303
    PJ_UNUSED_ARG(pSelf);
 
4304
 
 
4305
    if (!PyArg_ParseTuple(pArgs, ""))
 
4306
    {
 
4307
        return NULL;
 
4308
    }   
 
4309
    
 
4310
    count = pjsua_call_get_max_count();
 
4311
    
 
4312
    
 
4313
    return Py_BuildValue("i", count);
 
4314
}
 
4315
 
 
4316
/*
 
4317
 * py_pjsua_call_get_count
 
4318
 */
 
4319
static PyObject *py_pjsua_call_get_count
 
4320
(PyObject *pSelf, PyObject *pArgs)
 
4321
{       
 
4322
    
 
4323
    int count;  
 
4324
    
 
4325
    PJ_UNUSED_ARG(pSelf);
 
4326
 
 
4327
    if (!PyArg_ParseTuple(pArgs, ""))
 
4328
    {
 
4329
        return NULL;
 
4330
    }   
 
4331
    
 
4332
    count = pjsua_call_get_count();
 
4333
    
 
4334
    
 
4335
    return Py_BuildValue("i", count);
 
4336
}
 
4337
 
 
4338
/*
 
4339
 * py_pjsua_enum_calls
 
4340
 */
 
4341
static PyObject *py_pjsua_enum_calls(PyObject *pSelf, PyObject *pArgs)
 
4342
{
 
4343
    pj_status_t status;
 
4344
    PyObject *list;
 
4345
    
 
4346
    pjsua_transport_id id[PJSUA_MAX_CALLS];
 
4347
    unsigned c, i;
 
4348
 
 
4349
    PJ_UNUSED_ARG(pSelf);
 
4350
 
 
4351
    if (!PyArg_ParseTuple(pArgs, ""))
 
4352
    {
 
4353
        return NULL;
 
4354
    }   
 
4355
    
 
4356
    c = PJ_ARRAY_SIZE(id);
 
4357
    status = pjsua_enum_calls(id, &c);
 
4358
    
 
4359
    list = PyList_New(c);
 
4360
    for (i = 0; i < c; i++) 
 
4361
    {     
 
4362
        int ret = PyList_SetItem(list, i, Py_BuildValue("i", id[i]));
 
4363
        if (ret == -1) 
 
4364
        {
 
4365
            return NULL;
 
4366
        }
 
4367
    }
 
4368
    
 
4369
    return Py_BuildValue("O",list);
 
4370
}
 
4371
 
 
4372
/*
 
4373
 * py_pjsua_call_make_call
 
4374
 */
 
4375
static PyObject *py_pjsua_call_make_call
 
4376
(PyObject *pSelf, PyObject *pArgs)
 
4377
{    
 
4378
    int status;
 
4379
    int acc_id;
 
4380
    pj_str_t dst_uri;
 
4381
    PyObject * sd;
 
4382
    unsigned options;
 
4383
    pjsua_msg_data msg_data;
 
4384
    PyObject * omdObj;
 
4385
    PyObj_pjsua_msg_data * omd;
 
4386
    int user_data;
 
4387
    int call_id;
 
4388
    pj_pool_t * pool;
 
4389
 
 
4390
    PJ_UNUSED_ARG(pSelf);
 
4391
 
 
4392
    if (!PyArg_ParseTuple
 
4393
                (pArgs, "iOIiO", &acc_id, &sd, &options, &user_data, &omdObj))
 
4394
    {
 
4395
        return NULL;
 
4396
    }
 
4397
        
 
4398
    dst_uri.ptr = PyString_AsString(sd);
 
4399
    dst_uri.slen = strlen(PyString_AsString(sd));
 
4400
    if (omdObj != Py_None) 
 
4401
    {
 
4402
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4403
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4404
        msg_data.content_type.slen = strlen
 
4405
                        (PyString_AsString(omd->content_type));
 
4406
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4407
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4408
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4409
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4410
        status = pjsua_call_make_call(acc_id, &dst_uri, 
 
4411
                        options, (void*)user_data, &msg_data, &call_id);        
 
4412
        pj_pool_release(pool);
 
4413
    } else {
 
4414
                
 
4415
        status = pjsua_call_make_call(acc_id, &dst_uri, 
 
4416
                        options, (void*)user_data, NULL, &call_id);     
 
4417
    }
 
4418
        
 
4419
    return Py_BuildValue("ii",status, call_id);
 
4420
        
 
4421
}
 
4422
 
 
4423
/*
 
4424
 * py_pjsua_call_is_active
 
4425
 */
 
4426
static PyObject *py_pjsua_call_is_active
 
4427
(PyObject *pSelf, PyObject *pArgs)
 
4428
{       
 
4429
    int call_id;
 
4430
    int isActive;       
 
4431
    
 
4432
    PJ_UNUSED_ARG(pSelf);
 
4433
 
 
4434
    if (!PyArg_ParseTuple(pArgs, "i", &call_id))
 
4435
    {
 
4436
        return NULL;
 
4437
    }   
 
4438
    
 
4439
    isActive = pjsua_call_is_active(call_id);
 
4440
    
 
4441
    
 
4442
    return Py_BuildValue("i", isActive);
 
4443
}
 
4444
 
 
4445
/*
 
4446
 * py_pjsua_call_has_media
 
4447
 */
 
4448
static PyObject *py_pjsua_call_has_media
 
4449
(PyObject *pSelf, PyObject *pArgs)
 
4450
{       
 
4451
    int call_id;
 
4452
    int hasMedia;       
 
4453
    
 
4454
    PJ_UNUSED_ARG(pSelf);
 
4455
 
 
4456
    if (!PyArg_ParseTuple(pArgs, "i", &call_id))
 
4457
    {
 
4458
        return NULL;
 
4459
    }   
 
4460
    
 
4461
    hasMedia = pjsua_call_has_media(call_id);
 
4462
    
 
4463
    
 
4464
    return Py_BuildValue("i", hasMedia);
 
4465
}
 
4466
 
 
4467
/*
 
4468
 * py_pjsua_call_get_conf_port
 
4469
 */
 
4470
static PyObject *py_pjsua_call_get_conf_port
 
4471
(PyObject *pSelf, PyObject *pArgs)
 
4472
{       
 
4473
    int call_id;
 
4474
    int port_id;        
 
4475
    
 
4476
    PJ_UNUSED_ARG(pSelf);
 
4477
 
 
4478
    if (!PyArg_ParseTuple(pArgs, "i", &call_id))
 
4479
    {
 
4480
        return NULL;
 
4481
    }   
 
4482
    
 
4483
    port_id = pjsua_call_get_conf_port(call_id);
 
4484
    
 
4485
    
 
4486
    return Py_BuildValue("i", port_id);
 
4487
}
 
4488
 
 
4489
/*
 
4490
 * py_pjsua_call_get_info
 
4491
 */
 
4492
static PyObject *py_pjsua_call_get_info
 
4493
(PyObject *pSelf, PyObject *pArgs)
 
4494
{       
 
4495
    int call_id;
 
4496
    int status;
 
4497
    PyObj_pjsua_call_info * oi;
 
4498
    pjsua_call_info info;
 
4499
    
 
4500
    PJ_UNUSED_ARG(pSelf);
 
4501
 
 
4502
    if (!PyArg_ParseTuple(pArgs, "i", &call_id))
 
4503
    {
 
4504
        return NULL;
 
4505
    }   
 
4506
    
 
4507
    
 
4508
    status = pjsua_call_get_info(call_id, &info);
 
4509
    if (status == PJ_SUCCESS) 
 
4510
    {
 
4511
        oi = (PyObj_pjsua_call_info *)call_info_new(&PyTyp_pjsua_call_info, NULL, NULL);
 
4512
        oi->acc_id = info.acc_id;
 
4513
        pj_ansi_snprintf(oi->buf_.call_id, sizeof(oi->buf_.call_id),
 
4514
            "%.*s", (int)info.call_id.slen, info.call_id.ptr);
 
4515
        pj_ansi_snprintf(oi->buf_.last_status_text, 
 
4516
            sizeof(oi->buf_.last_status_text),
 
4517
            "%.*s", (int)info.last_status_text.slen, info.last_status_text.ptr);
 
4518
        pj_ansi_snprintf(oi->buf_.local_contact, sizeof(oi->buf_.local_contact),
 
4519
            "%.*s", (int)info.local_contact.slen, info.local_contact.ptr);
 
4520
        pj_ansi_snprintf(oi->buf_.local_info, sizeof(oi->buf_.local_info),
 
4521
            "%.*s", (int)info.local_info.slen, info.local_info.ptr);
 
4522
        pj_ansi_snprintf(oi->buf_.remote_contact,
 
4523
            sizeof(oi->buf_.remote_contact),
 
4524
            "%.*s", (int)info.remote_contact.slen, info.remote_contact.ptr);
 
4525
        pj_ansi_snprintf(oi->buf_.remote_info, sizeof(oi->buf_.remote_info),
 
4526
            "%.*s", (int)info.remote_info.slen, info.remote_info.ptr);
 
4527
 
 
4528
        oi->call_id = PyString_FromStringAndSize(info.call_id.ptr, 
 
4529
            info.call_id.slen);
 
4530
        oi->conf_slot = info.conf_slot;
 
4531
        oi->connect_duration->sec = info.connect_duration.sec;
 
4532
        oi->connect_duration->msec = info.connect_duration.msec;
 
4533
        oi->total_duration->sec = info.total_duration.sec;
 
4534
        oi->total_duration->msec = info.total_duration.msec;
 
4535
        oi->id = info.id;
 
4536
        oi->last_status = info.last_status;
 
4537
        oi->last_status_text = PyString_FromStringAndSize(
 
4538
            info.last_status_text.ptr, info.last_status_text.slen);
 
4539
        oi->local_contact = PyString_FromStringAndSize(
 
4540
            info.local_contact.ptr, info.local_contact.slen);
 
4541
        oi->local_info = PyString_FromStringAndSize(
 
4542
            info.local_info.ptr, info.local_info.slen);
 
4543
        oi->remote_contact = PyString_FromStringAndSize(
 
4544
            info.remote_contact.ptr, info.remote_contact.slen);
 
4545
        oi->remote_info = PyString_FromStringAndSize(
 
4546
            info.remote_info.ptr, info.remote_info.slen);
 
4547
        oi->media_dir = info.media_dir;
 
4548
        oi->media_status = info.media_status;
 
4549
        oi->role = info.role;
 
4550
        oi->state = info.state;
 
4551
        oi->state_text = PyString_FromStringAndSize(
 
4552
            info.state_text.ptr, info.state_text.slen);
 
4553
 
 
4554
        return Py_BuildValue("O", oi);
 
4555
    } else {
 
4556
        Py_INCREF(Py_None);
 
4557
        return Py_None;
 
4558
    }
 
4559
}
 
4560
 
 
4561
/*
 
4562
 * py_pjsua_call_set_user_data
 
4563
 */
 
4564
static PyObject *py_pjsua_call_set_user_data
 
4565
(PyObject *pSelf, PyObject *pArgs)
 
4566
{       
 
4567
    int call_id;
 
4568
    int user_data;      
 
4569
    int status;
 
4570
 
 
4571
    PJ_UNUSED_ARG(pSelf);
 
4572
 
 
4573
    if (!PyArg_ParseTuple(pArgs, "ii", &call_id, &user_data))
 
4574
    {
 
4575
        return NULL;
 
4576
    }   
 
4577
    
 
4578
    status = pjsua_call_set_user_data(call_id, (void*)user_data);
 
4579
    
 
4580
    
 
4581
    return Py_BuildValue("i", status);
 
4582
}
 
4583
 
 
4584
/*
 
4585
 * py_pjsua_call_get_user_data
 
4586
 */
 
4587
static PyObject *py_pjsua_call_get_user_data
 
4588
(PyObject *pSelf, PyObject *pArgs)
 
4589
{       
 
4590
    int call_id;
 
4591
    void * user_data;   
 
4592
    
 
4593
    PJ_UNUSED_ARG(pSelf);
 
4594
 
 
4595
    if (!PyArg_ParseTuple(pArgs, "i", &call_id))
 
4596
    {
 
4597
        return NULL;
 
4598
    }   
 
4599
    
 
4600
    user_data = pjsua_call_get_user_data(call_id);
 
4601
    
 
4602
    
 
4603
    return Py_BuildValue("i", (int)user_data);
 
4604
}
 
4605
 
 
4606
/*
 
4607
 * py_pjsua_call_answer
 
4608
 */
 
4609
static PyObject *py_pjsua_call_answer
 
4610
(PyObject *pSelf, PyObject *pArgs)
 
4611
{    
 
4612
    int status;
 
4613
    int call_id;
 
4614
    pj_str_t * reason, tmp_reason;
 
4615
    PyObject * sr;
 
4616
    unsigned code;
 
4617
    pjsua_msg_data msg_data;
 
4618
    PyObject * omdObj;
 
4619
    PyObj_pjsua_msg_data * omd;    
 
4620
    pj_pool_t * pool;
 
4621
 
 
4622
    PJ_UNUSED_ARG(pSelf);
 
4623
 
 
4624
    if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omdObj))
 
4625
    {
 
4626
        return NULL;
 
4627
    }
 
4628
    if (sr == Py_None) 
 
4629
    {
 
4630
        reason = NULL;
 
4631
    } else {
 
4632
        reason = &tmp_reason;
 
4633
        tmp_reason.ptr = PyString_AsString(sr);
 
4634
        tmp_reason.slen = strlen(PyString_AsString(sr));
 
4635
    }
 
4636
    if (omdObj != Py_None) 
 
4637
    {
 
4638
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4639
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4640
        msg_data.content_type.slen = strlen
 
4641
                        (PyString_AsString(omd->content_type));
 
4642
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4643
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4644
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4645
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4646
        
 
4647
        status = pjsua_call_answer(call_id, code, reason, &msg_data);   
 
4648
    
 
4649
        pj_pool_release(pool);
 
4650
    } else {
 
4651
        
 
4652
        status = pjsua_call_answer(call_id, code, reason, NULL);
 
4653
        
 
4654
    }
 
4655
    
 
4656
    return Py_BuildValue("i",status);
 
4657
}
 
4658
 
 
4659
/*
 
4660
 * py_pjsua_call_hangup
 
4661
 */
 
4662
static PyObject *py_pjsua_call_hangup
 
4663
(PyObject *pSelf, PyObject *pArgs)
 
4664
{    
 
4665
    int status;
 
4666
    int call_id;
 
4667
    pj_str_t * reason, tmp_reason;
 
4668
    PyObject * sr;
 
4669
    unsigned code;
 
4670
    pjsua_msg_data msg_data;
 
4671
    PyObject * omdObj;
 
4672
    PyObj_pjsua_msg_data * omd;    
 
4673
    pj_pool_t * pool = NULL;
 
4674
 
 
4675
    PJ_UNUSED_ARG(pSelf);
 
4676
 
 
4677
    if (!PyArg_ParseTuple(pArgs, "iIOO", &call_id, &code, &sr, &omdObj))
 
4678
    {
 
4679
        return NULL;
 
4680
    }
 
4681
    if (sr == Py_None)
 
4682
    {
 
4683
        reason = NULL;
 
4684
    } else {
 
4685
        reason = &tmp_reason;
 
4686
        tmp_reason.ptr = PyString_AsString(sr);
 
4687
        tmp_reason.slen = strlen(PyString_AsString(sr));
 
4688
    }
 
4689
    if (omdObj != Py_None) 
 
4690
    {
 
4691
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4692
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4693
        msg_data.content_type.slen = strlen
 
4694
                        (PyString_AsString(omd->content_type));
 
4695
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4696
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4697
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4698
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4699
        status = pjsua_call_hangup(call_id, code, reason, &msg_data);   
 
4700
        pj_pool_release(pool);
 
4701
    } else {
 
4702
        status = pjsua_call_hangup(call_id, code, reason, NULL);        
 
4703
    }
 
4704
    
 
4705
    return Py_BuildValue("i",status);
 
4706
}
 
4707
 
 
4708
/*
 
4709
 * py_pjsua_call_set_hold
 
4710
 */
 
4711
static PyObject *py_pjsua_call_set_hold
 
4712
(PyObject *pSelf, PyObject *pArgs)
 
4713
{    
 
4714
    int status;
 
4715
    int call_id;    
 
4716
    pjsua_msg_data msg_data;
 
4717
    PyObject * omdObj;
 
4718
    PyObj_pjsua_msg_data * omd;    
 
4719
    pj_pool_t * pool;
 
4720
 
 
4721
    PJ_UNUSED_ARG(pSelf);
 
4722
 
 
4723
    if (!PyArg_ParseTuple(pArgs, "iO", &call_id, &omdObj))
 
4724
    {
 
4725
        return NULL;
 
4726
    }
 
4727
 
 
4728
    if (omdObj != Py_None) 
 
4729
    {
 
4730
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4731
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4732
        msg_data.content_type.slen = strlen
 
4733
                        (PyString_AsString(omd->content_type));
 
4734
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4735
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4736
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4737
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4738
        status = pjsua_call_set_hold(call_id, &msg_data);       
 
4739
        pj_pool_release(pool);
 
4740
    } else {
 
4741
        status = pjsua_call_set_hold(call_id, NULL);    
 
4742
    }
 
4743
    return Py_BuildValue("i",status);
 
4744
}
 
4745
 
 
4746
/*
 
4747
 * py_pjsua_call_reinvite
 
4748
 */
 
4749
static PyObject *py_pjsua_call_reinvite
 
4750
(PyObject *pSelf, PyObject *pArgs)
 
4751
{    
 
4752
    int status;
 
4753
    int call_id;    
 
4754
    int unhold;
 
4755
    pjsua_msg_data msg_data;
 
4756
    PyObject * omdObj;
 
4757
    PyObj_pjsua_msg_data * omd;    
 
4758
    pj_pool_t * pool;
 
4759
 
 
4760
    PJ_UNUSED_ARG(pSelf);
 
4761
 
 
4762
    if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &unhold, &omdObj))
 
4763
    {
 
4764
        return NULL;
 
4765
    }
 
4766
 
 
4767
    if (omdObj != Py_None)
 
4768
    {
 
4769
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4770
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4771
        msg_data.content_type.slen = strlen
 
4772
                        (PyString_AsString(omd->content_type));
 
4773
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4774
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4775
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4776
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4777
        status = pjsua_call_reinvite(call_id, unhold, &msg_data);       
 
4778
        pj_pool_release(pool);
 
4779
    } else {
 
4780
        status = pjsua_call_reinvite(call_id, unhold, NULL);
 
4781
    }
 
4782
    return Py_BuildValue("i",status);
 
4783
}
 
4784
 
 
4785
/*
 
4786
 * py_pjsua_call_xfer
 
4787
 */
 
4788
static PyObject *py_pjsua_call_xfer
 
4789
(PyObject *pSelf, PyObject *pArgs)
 
4790
{    
 
4791
    int status;
 
4792
    int call_id;
 
4793
    pj_str_t dest;
 
4794
    PyObject * sd;
 
4795
    pjsua_msg_data msg_data;
 
4796
    PyObject * omdObj;
 
4797
    PyObj_pjsua_msg_data * omd;    
 
4798
    pj_pool_t * pool;
 
4799
 
 
4800
    PJ_UNUSED_ARG(pSelf);
 
4801
 
 
4802
    if (!PyArg_ParseTuple(pArgs, "iOO", &call_id, &sd, &omdObj))
 
4803
    {
 
4804
        return NULL;
 
4805
    }
 
4806
        
 
4807
    dest.ptr = PyString_AsString(sd);
 
4808
    dest.slen = strlen(PyString_AsString(sd));
 
4809
    
 
4810
    if (omdObj != Py_None)
 
4811
    {
 
4812
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4813
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4814
        msg_data.content_type.slen = strlen
 
4815
                        (PyString_AsString(omd->content_type));
 
4816
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4817
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4818
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4819
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4820
        status = pjsua_call_xfer(call_id, &dest, &msg_data);    
 
4821
        pj_pool_release(pool);
 
4822
    } else {
 
4823
        status = pjsua_call_xfer(call_id, &dest, NULL); 
 
4824
    }
 
4825
    return Py_BuildValue("i",status);
 
4826
}
 
4827
 
 
4828
/*
 
4829
 * py_pjsua_call_xfer_replaces
 
4830
 */
 
4831
static PyObject *py_pjsua_call_xfer_replaces
 
4832
(PyObject *pSelf, PyObject *pArgs)
 
4833
{    
 
4834
    int status;
 
4835
    int call_id;
 
4836
    int dest_call_id;
 
4837
    unsigned options;    
 
4838
    pjsua_msg_data msg_data;
 
4839
    PyObject * omdObj;
 
4840
    PyObj_pjsua_msg_data * omd;    
 
4841
    pj_pool_t * pool;
 
4842
 
 
4843
    PJ_UNUSED_ARG(pSelf);
 
4844
 
 
4845
    if (!PyArg_ParseTuple
 
4846
                (pArgs, "iiIO", &call_id, &dest_call_id, &options, &omdObj))
 
4847
    {
 
4848
        return NULL;
 
4849
    }
 
4850
        
 
4851
    if (omdObj != Py_None)
 
4852
    {
 
4853
        omd = (PyObj_pjsua_msg_data *)omdObj;    
 
4854
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4855
        msg_data.content_type.slen = strlen
 
4856
                        (PyString_AsString(omd->content_type));
 
4857
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4858
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4859
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4860
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4861
        status = pjsua_call_xfer_replaces
 
4862
                        (call_id, dest_call_id, options, &msg_data);    
 
4863
        pj_pool_release(pool);
 
4864
    } else {
 
4865
        status = pjsua_call_xfer_replaces(call_id, dest_call_id,options, NULL); 
 
4866
    }
 
4867
    return Py_BuildValue("i",status);
 
4868
}
 
4869
 
 
4870
/*
 
4871
 * py_pjsua_call_dial_dtmf
 
4872
 */
 
4873
static PyObject *py_pjsua_call_dial_dtmf
 
4874
(PyObject *pSelf, PyObject *pArgs)
 
4875
{       
 
4876
    int call_id;
 
4877
    PyObject * sd;
 
4878
    pj_str_t digits;
 
4879
    int status;
 
4880
 
 
4881
    PJ_UNUSED_ARG(pSelf);
 
4882
 
 
4883
    if (!PyArg_ParseTuple(pArgs, "iO", &call_id, &sd))
 
4884
    {
 
4885
        return NULL;
 
4886
    }   
 
4887
    digits.ptr = PyString_AsString(sd);
 
4888
    digits.slen = strlen(PyString_AsString(sd));
 
4889
    status = pjsua_call_dial_dtmf(call_id, &digits);
 
4890
    
 
4891
    return Py_BuildValue("i", status);
 
4892
}
 
4893
 
 
4894
/*
 
4895
 * py_pjsua_call_send_im
 
4896
 */
 
4897
static PyObject *py_pjsua_call_send_im
 
4898
(PyObject *pSelf, PyObject *pArgs)
 
4899
{    
 
4900
    int status;
 
4901
    int call_id;
 
4902
    pj_str_t content;
 
4903
    pj_str_t * mime_type, tmp_mime_type;
 
4904
    PyObject * sm;
 
4905
    PyObject * sc;
 
4906
    pjsua_msg_data msg_data;
 
4907
    PyObject * omdObj;
 
4908
    PyObj_pjsua_msg_data * omd;    
 
4909
    int user_data;
 
4910
    pj_pool_t * pool;
 
4911
 
 
4912
    PJ_UNUSED_ARG(pSelf);
 
4913
 
 
4914
    if (!PyArg_ParseTuple
 
4915
                (pArgs, "iOOOi", &call_id, &sm, &sc, &omdObj, &user_data))
 
4916
    {
 
4917
        return NULL;
 
4918
    }
 
4919
    if (sm == Py_None)
 
4920
    {
 
4921
        mime_type = NULL;
 
4922
    } else {
 
4923
        mime_type = &tmp_mime_type;
 
4924
        tmp_mime_type.ptr = PyString_AsString(sm);
 
4925
        tmp_mime_type.slen = strlen(PyString_AsString(sm));
 
4926
    }
 
4927
    content.ptr = PyString_AsString(sc);
 
4928
    content.slen = strlen(PyString_AsString(sc));
 
4929
    
 
4930
    if (omdObj != Py_None)
 
4931
    {
 
4932
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4933
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4934
        msg_data.content_type.slen = strlen
 
4935
                        (PyString_AsString(omd->content_type));
 
4936
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4937
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4938
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4939
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4940
        status = pjsua_call_send_im
 
4941
                (call_id, mime_type, &content, &msg_data, (void *)user_data);   
 
4942
        pj_pool_release(pool);
 
4943
    } else {
 
4944
        status = pjsua_call_send_im
 
4945
                        (call_id, mime_type, &content, NULL, (void *)user_data);        
 
4946
    }
 
4947
    
 
4948
    return Py_BuildValue("i",status);
 
4949
}
 
4950
 
 
4951
/*
 
4952
 * py_pjsua_call_send_typing_ind
 
4953
 */
 
4954
static PyObject *py_pjsua_call_send_typing_ind
 
4955
(PyObject *pSelf, PyObject *pArgs)
 
4956
{    
 
4957
    int status;
 
4958
    int call_id;    
 
4959
    int is_typing;
 
4960
    pjsua_msg_data msg_data;
 
4961
    PyObject * omdObj;
 
4962
    PyObj_pjsua_msg_data * omd;    
 
4963
    pj_pool_t * pool;
 
4964
 
 
4965
    PJ_UNUSED_ARG(pSelf);
 
4966
 
 
4967
    if (!PyArg_ParseTuple(pArgs, "iiO", &call_id, &is_typing, &omdObj))
 
4968
    {
 
4969
        return NULL;
 
4970
    }
 
4971
        
 
4972
    if (omdObj != Py_None)
 
4973
    {
 
4974
        omd = (PyObj_pjsua_msg_data *)omdObj;
 
4975
        msg_data.content_type.ptr = PyString_AsString(omd->content_type);
 
4976
        msg_data.content_type.slen = strlen
 
4977
                        (PyString_AsString(omd->content_type));
 
4978
        msg_data.msg_body.ptr = PyString_AsString(omd->msg_body);
 
4979
        msg_data.msg_body.slen = strlen(PyString_AsString(omd->msg_body));
 
4980
        pool = pjsua_pool_create("pjsua", POOL_SIZE, POOL_SIZE);
 
4981
        translate_hdr(pool, &msg_data.hdr_list, omd->hdr_list);
 
4982
        status = pjsua_call_send_typing_ind(call_id, is_typing, &msg_data);     
 
4983
        pj_pool_release(pool);
 
4984
    } else {
 
4985
        status = pjsua_call_send_typing_ind(call_id, is_typing, NULL);  
 
4986
    }
 
4987
    return Py_BuildValue("i",status);
 
4988
}
 
4989
 
 
4990
/*
 
4991
 * py_pjsua_call_hangup_all
 
4992
 */
 
4993
static PyObject *py_pjsua_call_hangup_all
 
4994
(PyObject *pSelf, PyObject *pArgs)
 
4995
{       
 
4996
 
 
4997
    PJ_UNUSED_ARG(pSelf);
 
4998
 
 
4999
    if (!PyArg_ParseTuple(pArgs, ""))
 
5000
    {
 
5001
        return NULL;
 
5002
    }   
 
5003
    
 
5004
    pjsua_call_hangup_all();
 
5005
    
 
5006
    Py_INCREF(Py_None);
 
5007
    return Py_None;
 
5008
}
 
5009
 
 
5010
/*
 
5011
 * py_pjsua_call_dump
 
5012
 */
 
5013
static PyObject *py_pjsua_call_dump
 
5014
(PyObject *pSelf, PyObject *pArgs)
 
5015
{       
 
5016
    int call_id;
 
5017
    int with_media;
 
5018
    PyObject * sb;
 
5019
    PyObject * si;
 
5020
    char * buffer;
 
5021
    char * indent;
 
5022
    unsigned maxlen;    
 
5023
    int status;
 
5024
 
 
5025
    PJ_UNUSED_ARG(pSelf);
 
5026
 
 
5027
    if (!PyArg_ParseTuple(pArgs, "iiIO", &call_id, &with_media, &maxlen, &si))
 
5028
    {
 
5029
        return NULL;
 
5030
    }   
 
5031
    buffer = (char *) malloc (maxlen * sizeof(char));
 
5032
    indent = PyString_AsString(si);
 
5033
    
 
5034
    status = pjsua_call_dump(call_id, with_media, buffer, maxlen, indent);
 
5035
    sb = PyString_FromStringAndSize(buffer, maxlen);
 
5036
    free(buffer);
 
5037
    return Py_BuildValue("O", sb);
 
5038
}
 
5039
 
 
5040
 
 
5041
/*
 
5042
 * py_pjsua_dump
 
5043
 * Dump application states.
 
5044
 */
 
5045
static PyObject *py_pjsua_dump(PyObject *pSelf, PyObject *pArgs)
 
5046
{
 
5047
    unsigned old_decor;
 
5048
    char buf[1024];
 
5049
    int detail;
 
5050
 
 
5051
    PJ_UNUSED_ARG(pSelf);
 
5052
 
 
5053
    if (!PyArg_ParseTuple(pArgs, "i", &detail))
 
5054
    {
 
5055
        return NULL;
 
5056
    }   
 
5057
 
 
5058
    PJ_LOG(3,(THIS_FILE, "Start dumping application states:"));
 
5059
 
 
5060
    old_decor = pj_log_get_decor();
 
5061
    pj_log_set_decor(old_decor & (PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_CR));
 
5062
 
 
5063
    if (detail)
 
5064
        pj_dump_config();
 
5065
 
 
5066
    pjsip_endpt_dump(pjsua_get_pjsip_endpt(), detail);
 
5067
    pjmedia_endpt_dump(pjsua_get_pjmedia_endpt());
 
5068
    pjsip_tsx_layer_dump(detail);
 
5069
    pjsip_ua_dump(detail);
 
5070
 
 
5071
 
 
5072
    /* Dump all invite sessions: */
 
5073
    PJ_LOG(3,(THIS_FILE, "Dumping invite sessions:"));
 
5074
 
 
5075
    if (pjsua_call_get_count() == 0) {
 
5076
 
 
5077
        PJ_LOG(3,(THIS_FILE, "  - no sessions -"));
 
5078
 
 
5079
    } else {
 
5080
        unsigned i, max;
 
5081
 
 
5082
        max = pjsua_call_get_max_count();
 
5083
        for (i=0; i<max; ++i) {
 
5084
            if (pjsua_call_is_active(i)) {
 
5085
                pjsua_call_dump(i, detail, buf, sizeof(buf), "  ");
 
5086
                PJ_LOG(3,(THIS_FILE, "%s", buf));
 
5087
            }
 
5088
        }
 
5089
    }
 
5090
 
 
5091
    /* Dump presence status */
 
5092
    pjsua_pres_dump(detail);
 
5093
 
 
5094
    pj_log_set_decor(old_decor);
 
5095
    PJ_LOG(3,(THIS_FILE, "Dump complete"));
 
5096
 
 
5097
    Py_INCREF(Py_None);
 
5098
    return Py_None;
 
5099
}
 
5100
 
 
5101
 
 
5102
static char pjsua_call_get_max_count_doc[] =
 
5103
    "int py_pjsua.call_get_max_count () "
 
5104
    "Get maximum number of calls configured in pjsua.";
 
5105
static char pjsua_call_get_count_doc[] =
 
5106
    "int py_pjsua.call_get_count () "
 
5107
    "Get number of currently active calls.";
 
5108
static char pjsua_enum_calls_doc[] =
 
5109
    "int[] py_pjsua.enum_calls () "
 
5110
    "Get maximum number of calls configured in pjsua.";
 
5111
static char pjsua_call_make_call_doc[] =
 
5112
    "int,int py_pjsua.call_make_call (int acc_id, string dst_uri, int options,"
 
5113
    "int user_data, py_pjsua.Msg_Data msg_data) "
 
5114
    "Make outgoing call to the specified URI using the specified account.";
 
5115
static char pjsua_call_is_active_doc[] =
 
5116
    "int py_pjsua.call_is_active (int call_id) "
 
5117
    "Check if the specified call has active INVITE session and the INVITE "
 
5118
    "session has not been disconnected.";
 
5119
static char pjsua_call_has_media_doc[] =
 
5120
    "int py_pjsua.call_has_media (int call_id) "
 
5121
    "Check if call has an active media session.";
 
5122
static char pjsua_call_get_conf_port_doc[] =
 
5123
    "int py_pjsua.call_get_conf_port (int call_id) "
 
5124
    "Get the conference port identification associated with the call.";
 
5125
static char pjsua_call_get_info_doc[] =
 
5126
    "py_pjsua.Call_Info py_pjsua.call_get_info (int call_id) "
 
5127
    "Obtain detail information about the specified call.";
 
5128
static char pjsua_call_set_user_data_doc[] =
 
5129
    "int py_pjsua.call_set_user_data (int call_id, int user_data) "
 
5130
    "Attach application specific data to the call.";
 
5131
static char pjsua_call_get_user_data_doc[] =
 
5132
    "int py_pjsua.call_get_user_data (int call_id) "
 
5133
    "Get user data attached to the call.";
 
5134
static char pjsua_call_answer_doc[] =
 
5135
    "int py_pjsua.call_answer (int call_id, int code, string reason, "
 
5136
    "py_pjsua.Msg_Data msg_data) "
 
5137
    "Send response to incoming INVITE request.";
 
5138
static char pjsua_call_hangup_doc[] =
 
5139
    "int py_pjsua.call_hangup (int call_id, int code, string reason, "
 
5140
    "py_pjsua.Msg_Data msg_data) "
 
5141
    "Hangup call by using method that is appropriate according "
 
5142
    "to the call state.";
 
5143
static char pjsua_call_set_hold_doc[] =
 
5144
    "int py_pjsua.call_set_hold (int call_id, py_pjsua.Msg_Data msg_data) "
 
5145
    "Put the specified call on hold.";
 
5146
static char pjsua_call_reinvite_doc[] =
 
5147
    "int py_pjsua.call_reinvite (int call_id, int unhold, "
 
5148
    "py_pjsua.Msg_Data msg_data) "
 
5149
    "Send re-INVITE (to release hold).";
 
5150
static char pjsua_call_xfer_doc[] =
 
5151
    "int py_pjsua.call_xfer (int call_id, string dest, "
 
5152
    "py_pjsua.Msg_Data msg_data) "
 
5153
    "Initiate call transfer to the specified address. "
 
5154
    "This function will send REFER request to instruct remote call party "
 
5155
    "to initiate a new INVITE session to the specified destination/target.";
 
5156
static char pjsua_call_xfer_replaces_doc[] =
 
5157
    "int py_pjsua.call_xfer_replaces (int call_id, int dest_call_id, "
 
5158
    "int options, py_pjsua.Msg_Data msg_data) "
 
5159
    "Initiate attended call transfer. This function will send REFER request "
 
5160
    "to instruct remote call party to initiate new INVITE session to the URL "
 
5161
    "of dest_call_id. The party at dest_call_id then should 'replace' the call"
 
5162
    "with us with the new call from the REFER recipient.";
 
5163
static char pjsua_call_dial_dtmf_doc[] =
 
5164
    "int py_pjsua.call_dial_dtmf (int call_id, string digits) "
 
5165
    "Send DTMF digits to remote using RFC 2833 payload formats.";
 
5166
static char pjsua_call_send_im_doc[] =
 
5167
    "int py_pjsua.call_send_im (int call_id, string mime_type, string content,"
 
5168
    "py_pjsua.Msg_Data msg_data, int user_data) "
 
5169
    "Send instant messaging inside INVITE session.";
 
5170
static char pjsua_call_send_typing_ind_doc[] =
 
5171
    "int py_pjsua.call_send_typing_ind (int call_id, int is_typing, "
 
5172
    "py_pjsua.Msg_Data msg_data) "
 
5173
    "Send IM typing indication inside INVITE session.";
 
5174
static char pjsua_call_hangup_all_doc[] =
 
5175
    "void py_pjsua.call_hangup_all () "
 
5176
    "Terminate all calls.";
 
5177
static char pjsua_call_dump_doc[] =
 
5178
    "int py_pjsua.call_dump (int call_id, int with_media, int maxlen, "
 
5179
    "string indent) "
 
5180
    "Dump call and media statistics to string.";
 
5181
 
 
5182
/* END OF LIB CALL */
 
5183
 
 
5184
/*
 
5185
 * Map of function names to functions
 
5186
 */
 
5187
static PyMethodDef py_pjsua_methods[] =
 
5188
{
 
5189
    {
 
5190
        "thread_register", py_pjsua_thread_register, METH_VARARGS, 
 
5191
         pjsua_thread_register_doc
 
5192
    },
 
5193
    {
 
5194
        "perror", py_pjsua_perror, METH_VARARGS, pjsua_perror_doc
 
5195
    },
 
5196
    {
 
5197
        "create", py_pjsua_create, METH_VARARGS, pjsua_create_doc
 
5198
    },
 
5199
    {
 
5200
        "init", py_pjsua_init, METH_VARARGS, pjsua_init_doc
 
5201
    },
 
5202
    {
 
5203
        "start", py_pjsua_start, METH_VARARGS, pjsua_start_doc
 
5204
    },
 
5205
    {
 
5206
        "destroy", py_pjsua_destroy, METH_VARARGS, pjsua_destroy_doc
 
5207
    },
 
5208
    {
 
5209
        "handle_events", py_pjsua_handle_events, METH_VARARGS,
 
5210
        pjsua_handle_events_doc
 
5211
    },
 
5212
    {
 
5213
        "verify_sip_url", py_pjsua_verify_sip_url, METH_VARARGS,
 
5214
        pjsua_verify_sip_url_doc
 
5215
    },
 
5216
    {
 
5217
        "pool_create", py_pjsua_pool_create, METH_VARARGS,
 
5218
        pjsua_pool_create_doc
 
5219
    },
 
5220
    {
 
5221
        "get_pjsip_endpt", py_pjsua_get_pjsip_endpt, METH_VARARGS,
 
5222
        pjsua_get_pjsip_endpt_doc
 
5223
    },
 
5224
    {
 
5225
        "get_pjmedia_endpt", py_pjsua_get_pjmedia_endpt, METH_VARARGS,
 
5226
        pjsua_get_pjmedia_endpt_doc
 
5227
    },
 
5228
    {
 
5229
        "get_pool_factory", py_pjsua_get_pool_factory, METH_VARARGS,
 
5230
        pjsua_get_pool_factory_doc
 
5231
    },
 
5232
    {
 
5233
        "reconfigure_logging", py_pjsua_reconfigure_logging, METH_VARARGS,
 
5234
        pjsua_reconfigure_logging_doc
 
5235
    },
 
5236
    {
 
5237
        "logging_config_default", py_pjsua_logging_config_default,
 
5238
        METH_VARARGS, pjsua_logging_config_default_doc
 
5239
    },
 
5240
    {
 
5241
        "config_default", py_pjsua_config_default, METH_VARARGS,
 
5242
        pjsua_config_default_doc
 
5243
    },
 
5244
    {
 
5245
        "media_config_default", py_pjsua_media_config_default, METH_VARARGS,
 
5246
        pjsua_media_config_default_doc
 
5247
    },
 
5248
    
 
5249
    
 
5250
    {
 
5251
        "msg_data_init", py_pjsua_msg_data_init, METH_VARARGS,
 
5252
        pjsua_msg_data_init_doc
 
5253
    },
 
5254
    {
 
5255
        "transport_config_default", py_pjsua_transport_config_default, 
 
5256
        METH_VARARGS,pjsua_transport_config_default_doc
 
5257
    },
 
5258
    {
 
5259
        "transport_create", py_pjsua_transport_create, METH_VARARGS,
 
5260
        pjsua_transport_create_doc
 
5261
    },
 
5262
    {
 
5263
        "transport_enum_transports", py_pjsua_enum_transports, METH_VARARGS,
 
5264
        pjsua_enum_transports_doc
 
5265
    },
 
5266
    {
 
5267
        "transport_get_info", py_pjsua_transport_get_info, METH_VARARGS,
 
5268
        pjsua_transport_get_info_doc
 
5269
    },
 
5270
    {
 
5271
        "transport_set_enable", py_pjsua_transport_set_enable, METH_VARARGS,
 
5272
        pjsua_transport_set_enable_doc
 
5273
    },
 
5274
    {
 
5275
       "transport_close", py_pjsua_transport_close, METH_VARARGS,
 
5276
        pjsua_transport_close_doc
 
5277
    },
 
5278
    {
 
5279
        "acc_config_default", py_pjsua_acc_config_default, METH_VARARGS,
 
5280
        pjsua_acc_config_default_doc
 
5281
    },
 
5282
    {
 
5283
        "acc_get_count", py_pjsua_acc_get_count, METH_VARARGS,
 
5284
        pjsua_acc_get_count_doc
 
5285
    },
 
5286
    {
 
5287
        "acc_is_valid", py_pjsua_acc_is_valid, METH_VARARGS,
 
5288
        pjsua_acc_is_valid_doc
 
5289
    },
 
5290
    {
 
5291
        "acc_set_default", py_pjsua_acc_set_default, METH_VARARGS,
 
5292
        pjsua_acc_set_default_doc
 
5293
    },
 
5294
    {
 
5295
        "acc_get_default", py_pjsua_acc_get_default, METH_VARARGS,
 
5296
        pjsua_acc_get_default_doc
 
5297
    },
 
5298
    {
 
5299
        "acc_add", py_pjsua_acc_add, METH_VARARGS,
 
5300
        pjsua_acc_add_doc
 
5301
    },
 
5302
    {
 
5303
        "acc_add_local", py_pjsua_acc_add_local, METH_VARARGS,
 
5304
        pjsua_acc_add_local_doc
 
5305
    },
 
5306
    {
 
5307
        "acc_del", py_pjsua_acc_del, METH_VARARGS,
 
5308
        pjsua_acc_del_doc
 
5309
    },
 
5310
    {
 
5311
        "acc_modify", py_pjsua_acc_modify, METH_VARARGS,
 
5312
        pjsua_acc_modify_doc
 
5313
    },
 
5314
    {
 
5315
        "acc_set_online_status", py_pjsua_acc_set_online_status, METH_VARARGS,
 
5316
        pjsua_acc_set_online_status_doc
 
5317
    },
 
5318
    {
 
5319
        "acc_set_online_status2", py_pjsua_acc_set_online_status2, METH_VARARGS,
 
5320
        pjsua_acc_set_online_status2_doc
 
5321
    },
 
5322
    {
 
5323
        "acc_set_registration", py_pjsua_acc_set_registration, METH_VARARGS,
 
5324
        pjsua_acc_set_registration_doc
 
5325
    },
 
5326
    {
 
5327
        "acc_get_info", py_pjsua_acc_get_info, METH_VARARGS,
 
5328
        pjsua_acc_get_info_doc
 
5329
    },
 
5330
    {
 
5331
        "enum_accs", py_pjsua_enum_accs, METH_VARARGS,
 
5332
        pjsua_enum_accs_doc
 
5333
    },
 
5334
    {
 
5335
        "acc_enum_info", py_pjsua_acc_enum_info, METH_VARARGS,
 
5336
        pjsua_acc_enum_info_doc
 
5337
    },
 
5338
    {
 
5339
        "acc_find_for_outgoing", py_pjsua_acc_find_for_outgoing, METH_VARARGS,
 
5340
        pjsua_acc_find_for_outgoing_doc
 
5341
    },
 
5342
    {
 
5343
        "acc_find_for_incoming", py_pjsua_acc_find_for_incoming, METH_VARARGS,
 
5344
        pjsua_acc_find_for_incoming_doc
 
5345
    },
 
5346
    {
 
5347
        "acc_create_uac_contact", py_pjsua_acc_create_uac_contact, METH_VARARGS,
 
5348
        pjsua_acc_create_uac_contact_doc
 
5349
    },
 
5350
    {
 
5351
        "acc_create_uas_contact", py_pjsua_acc_create_uas_contact, METH_VARARGS,
 
5352
        pjsua_acc_create_uas_contact_doc
 
5353
    },
 
5354
    {
 
5355
        "buddy_config_default", py_pjsua_buddy_config_default, METH_VARARGS,
 
5356
        pjsua_buddy_config_default_doc
 
5357
    },
 
5358
    {
 
5359
        "get_buddy_count", py_pjsua_get_buddy_count, METH_VARARGS,
 
5360
        pjsua_get_buddy_count_doc
 
5361
    },
 
5362
    {
 
5363
        "buddy_is_valid", py_pjsua_buddy_is_valid, METH_VARARGS,
 
5364
        pjsua_buddy_is_valid_doc
 
5365
    },
 
5366
    {
 
5367
        "enum_buddies", py_pjsua_enum_buddies, METH_VARARGS,
 
5368
        pjsua_enum_buddies_doc
 
5369
    },    
 
5370
    {
 
5371
        "buddy_get_info", py_pjsua_buddy_get_info, METH_VARARGS,
 
5372
        pjsua_buddy_get_info_doc
 
5373
    },
 
5374
    {
 
5375
        "buddy_add", py_pjsua_buddy_add, METH_VARARGS,
 
5376
        pjsua_buddy_add_doc
 
5377
    },
 
5378
    {
 
5379
        "buddy_del", py_pjsua_buddy_del, METH_VARARGS,
 
5380
        pjsua_buddy_del_doc
 
5381
    },
 
5382
    {
 
5383
        "buddy_subscribe_pres", py_pjsua_buddy_subscribe_pres, METH_VARARGS,
 
5384
        pjsua_buddy_subscribe_pres_doc
 
5385
    },
 
5386
    {
 
5387
        "pres_dump", py_pjsua_pres_dump, METH_VARARGS,
 
5388
        pjsua_pres_dump_doc
 
5389
    },
 
5390
    {
 
5391
        "im_send", py_pjsua_im_send, METH_VARARGS,
 
5392
        pjsua_im_send_doc
 
5393
    },
 
5394
    {
 
5395
        "im_typing", py_pjsua_im_typing, METH_VARARGS,
 
5396
        pjsua_im_typing_doc
 
5397
    },
 
5398
        {
 
5399
        "conf_get_max_ports", py_pjsua_conf_get_max_ports, METH_VARARGS,
 
5400
        pjsua_conf_get_max_ports_doc
 
5401
    },
 
5402
    {
 
5403
        "conf_get_active_ports", py_pjsua_conf_get_active_ports, METH_VARARGS,
 
5404
        pjsua_conf_get_active_ports_doc
 
5405
    },
 
5406
    {
 
5407
        "enum_conf_ports", py_pjsua_enum_conf_ports, METH_VARARGS,
 
5408
        pjsua_enum_conf_ports_doc
 
5409
    },
 
5410
    {
 
5411
        "conf_get_port_info", py_pjsua_conf_get_port_info, METH_VARARGS,
 
5412
        pjsua_conf_get_port_info_doc
 
5413
    },
 
5414
    {
 
5415
        "conf_add_port", py_pjsua_conf_add_port, METH_VARARGS,
 
5416
        pjsua_conf_add_port_doc
 
5417
    },
 
5418
    {
 
5419
        "conf_remove_port", py_pjsua_conf_remove_port, METH_VARARGS,
 
5420
        pjsua_conf_remove_port_doc
 
5421
    },
 
5422
    {
 
5423
        "conf_connect", py_pjsua_conf_connect, METH_VARARGS,
 
5424
        pjsua_conf_connect_doc
 
5425
    },
 
5426
    {
 
5427
        "conf_disconnect", py_pjsua_conf_disconnect, METH_VARARGS,
 
5428
        pjsua_conf_disconnect_doc
 
5429
    },
 
5430
    {
 
5431
        "player_create", py_pjsua_player_create, METH_VARARGS,
 
5432
        pjsua_player_create_doc
 
5433
    },
 
5434
    {
 
5435
        "player_get_conf_port", py_pjsua_player_get_conf_port, METH_VARARGS,
 
5436
        pjsua_player_get_conf_port_doc
 
5437
    },
 
5438
    {
 
5439
        "player_set_pos", py_pjsua_player_set_pos, METH_VARARGS,
 
5440
        pjsua_player_set_pos_doc
 
5441
    },
 
5442
    {
 
5443
        "player_destroy", py_pjsua_player_destroy, METH_VARARGS,
 
5444
        pjsua_player_destroy_doc
 
5445
    },
 
5446
    {
 
5447
        "recorder_create", py_pjsua_recorder_create, METH_VARARGS,
 
5448
        pjsua_recorder_create_doc
 
5449
    },
 
5450
    {
 
5451
        "recorder_get_conf_port", py_pjsua_recorder_get_conf_port, METH_VARARGS,
 
5452
        pjsua_recorder_get_conf_port_doc
 
5453
    },
 
5454
    {
 
5455
        "recorder_destroy", py_pjsua_recorder_destroy, METH_VARARGS,
 
5456
        pjsua_recorder_destroy_doc
 
5457
    },
 
5458
    {
 
5459
        "enum_snd_devs", py_pjsua_enum_snd_devs, METH_VARARGS,
 
5460
        pjsua_enum_snd_devs_doc
 
5461
    },
 
5462
    {
 
5463
        "get_snd_dev", py_pjsua_get_snd_dev, METH_VARARGS,
 
5464
        pjsua_get_snd_dev_doc
 
5465
    },
 
5466
    {
 
5467
        "set_snd_dev", py_pjsua_set_snd_dev, METH_VARARGS,
 
5468
        pjsua_set_snd_dev_doc
 
5469
    },
 
5470
    {
 
5471
        "set_null_snd_dev", py_pjsua_set_null_snd_dev, METH_VARARGS,
 
5472
        pjsua_set_null_snd_dev_doc
 
5473
    },
 
5474
    {
 
5475
        "set_no_snd_dev", py_pjsua_set_no_snd_dev, METH_VARARGS,
 
5476
        pjsua_set_no_snd_dev_doc
 
5477
    },
 
5478
    {
 
5479
        "set_ec", py_pjsua_set_ec, METH_VARARGS,
 
5480
        pjsua_set_ec_doc
 
5481
    },
 
5482
    {
 
5483
        "get_ec_tail", py_pjsua_get_ec_tail, METH_VARARGS,
 
5484
        pjsua_get_ec_tail_doc
 
5485
    },
 
5486
    {
 
5487
        "enum_codecs", py_pjsua_enum_codecs, METH_VARARGS,
 
5488
        pjsua_enum_codecs_doc
 
5489
    },
 
5490
    {
 
5491
        "codec_set_priority", py_pjsua_codec_set_priority, METH_VARARGS,
 
5492
        pjsua_codec_set_priority_doc
 
5493
    },
 
5494
    {
 
5495
        "codec_get_param", py_pjsua_codec_get_param, METH_VARARGS,
 
5496
        pjsua_codec_get_param_doc
 
5497
    },
 
5498
    {
 
5499
        "codec_set_param", py_pjsua_codec_set_param, METH_VARARGS,
 
5500
        pjsua_codec_set_param_doc
 
5501
    },
 
5502
    {
 
5503
        "call_get_max_count", py_pjsua_call_get_max_count, METH_VARARGS,
 
5504
        pjsua_call_get_max_count_doc
 
5505
    },
 
5506
    {
 
5507
        "call_get_count", py_pjsua_call_get_count, METH_VARARGS,
 
5508
        pjsua_call_get_count_doc
 
5509
    },
 
5510
    {
 
5511
        "enum_calls", py_pjsua_enum_calls, METH_VARARGS,
 
5512
        pjsua_enum_calls_doc
 
5513
    },
 
5514
    {
 
5515
        "call_make_call", py_pjsua_call_make_call, METH_VARARGS,
 
5516
        pjsua_call_make_call_doc
 
5517
    },
 
5518
    {
 
5519
        "call_is_active", py_pjsua_call_is_active, METH_VARARGS,
 
5520
        pjsua_call_is_active_doc
 
5521
    },
 
5522
    {
 
5523
        "call_has_media", py_pjsua_call_has_media, METH_VARARGS,
 
5524
        pjsua_call_has_media_doc
 
5525
    },
 
5526
    {
 
5527
        "call_get_conf_port", py_pjsua_call_get_conf_port, METH_VARARGS,
 
5528
        pjsua_call_get_conf_port_doc
 
5529
    },
 
5530
    {
 
5531
        "call_get_info", py_pjsua_call_get_info, METH_VARARGS,
 
5532
        pjsua_call_get_info_doc
 
5533
    },
 
5534
    {
 
5535
        "call_set_user_data", py_pjsua_call_set_user_data, METH_VARARGS,
 
5536
        pjsua_call_set_user_data_doc
 
5537
    },
 
5538
    {
 
5539
        "call_get_user_data", py_pjsua_call_get_user_data, METH_VARARGS,
 
5540
        pjsua_call_get_user_data_doc
 
5541
    },
 
5542
    {
 
5543
        "call_answer", py_pjsua_call_answer, METH_VARARGS,
 
5544
        pjsua_call_answer_doc
 
5545
    },
 
5546
    {
 
5547
        "call_hangup", py_pjsua_call_hangup, METH_VARARGS,
 
5548
        pjsua_call_hangup_doc
 
5549
    },
 
5550
    {
 
5551
        "call_set_hold", py_pjsua_call_set_hold, METH_VARARGS,
 
5552
        pjsua_call_set_hold_doc
 
5553
    },
 
5554
    {
 
5555
        "call_reinvite", py_pjsua_call_reinvite, METH_VARARGS,
 
5556
        pjsua_call_reinvite_doc
 
5557
    },
 
5558
    {
 
5559
        "call_xfer", py_pjsua_call_xfer, METH_VARARGS,
 
5560
        pjsua_call_xfer_doc
 
5561
    },
 
5562
    {
 
5563
        "call_xfer_replaces", py_pjsua_call_xfer_replaces, METH_VARARGS,
 
5564
        pjsua_call_xfer_replaces_doc
 
5565
    },
 
5566
    {
 
5567
        "call_dial_dtmf", py_pjsua_call_dial_dtmf, METH_VARARGS,
 
5568
        pjsua_call_dial_dtmf_doc
 
5569
    },
 
5570
    {
 
5571
        "call_send_im", py_pjsua_call_send_im, METH_VARARGS,
 
5572
        pjsua_call_send_im_doc
 
5573
    },
 
5574
    {
 
5575
        "call_send_typing_ind", py_pjsua_call_send_typing_ind, METH_VARARGS,
 
5576
        pjsua_call_send_typing_ind_doc
 
5577
    },
 
5578
    {
 
5579
        "call_hangup_all", py_pjsua_call_hangup_all, METH_VARARGS,
 
5580
        pjsua_call_hangup_all_doc
 
5581
    },
 
5582
    {
 
5583
        "call_dump", py_pjsua_call_dump, METH_VARARGS,
 
5584
        pjsua_call_dump_doc
 
5585
    },
 
5586
    {
 
5587
        "dump", py_pjsua_dump, METH_VARARGS, "Dump application state"
 
5588
    },
 
5589
 
 
5590
    
 
5591
    {NULL, NULL} /* end of function list */
 
5592
};
 
5593
 
 
5594
 
 
5595
 
 
5596
/*
 
5597
 * Mapping C structs from and to Python objects & initializing object
 
5598
 */
 
5599
DL_EXPORT(void)
 
5600
initpy_pjsua(void)
 
5601
{
 
5602
    PyObject* m = NULL;
 
5603
#define ADD_CONSTANT(mod,name)  PyModule_AddIntConstant(mod,#name,name)
 
5604
 
 
5605
    
 
5606
    PyEval_InitThreads();
 
5607
 
 
5608
    if (PyType_Ready(&PyTyp_pjsua_callback) < 0)
 
5609
        return;
 
5610
    if (PyType_Ready(&PyTyp_pjsua_config) < 0)
 
5611
        return;
 
5612
    if (PyType_Ready(&PyTyp_pjsua_logging_config) < 0)
 
5613
        return;
 
5614
    if (PyType_Ready(&PyTyp_pjsua_msg_data) < 0)
 
5615
        return;
 
5616
    PyTyp_pjsua_media_config.tp_new = PyType_GenericNew;
 
5617
    if (PyType_Ready(&PyTyp_pjsua_media_config) < 0)
 
5618
        return;
 
5619
    PyTyp_pjsip_event.tp_new = PyType_GenericNew;
 
5620
    if (PyType_Ready(&PyTyp_pjsip_event) < 0)
 
5621
        return;
 
5622
    PyTyp_pjsip_rx_data.tp_new = PyType_GenericNew;
 
5623
    if (PyType_Ready(&PyTyp_pjsip_rx_data) < 0)
 
5624
        return;
 
5625
    PyTyp_pj_pool_t.tp_new = PyType_GenericNew;
 
5626
    if (PyType_Ready(&PyTyp_pj_pool_t) < 0)
 
5627
        return;
 
5628
    PyTyp_pjsip_endpoint.tp_new = PyType_GenericNew;
 
5629
    if (PyType_Ready(&PyTyp_pjsip_endpoint) < 0)
 
5630
        return;
 
5631
    PyTyp_pjmedia_endpt.tp_new = PyType_GenericNew;
 
5632
    if (PyType_Ready(&PyTyp_pjmedia_endpt) < 0)
 
5633
        return;
 
5634
    PyTyp_pj_pool_factory.tp_new = PyType_GenericNew;
 
5635
    if (PyType_Ready(&PyTyp_pj_pool_factory) < 0)
 
5636
        return;
 
5637
    PyTyp_pjsip_cred_info.tp_new = PyType_GenericNew;
 
5638
    if (PyType_Ready(&PyTyp_pjsip_cred_info) < 0)
 
5639
        return;
 
5640
 
 
5641
    /* LIB TRANSPORT */
 
5642
 
 
5643
    if (PyType_Ready(&PyTyp_pjsua_transport_config) < 0)
 
5644
        return;
 
5645
    
 
5646
    if (PyType_Ready(&PyTyp_pjsua_transport_info) < 0)
 
5647
        return;
 
5648
    
 
5649
    /* END OF LIB TRANSPORT */
 
5650
 
 
5651
    /* LIB ACCOUNT */
 
5652
 
 
5653
    
 
5654
    if (PyType_Ready(&PyTyp_pjsua_acc_config) < 0)
 
5655
        return;
 
5656
    if (PyType_Ready(&PyTyp_pjsua_acc_info) < 0)
 
5657
        return;
 
5658
 
 
5659
    /* END OF LIB ACCOUNT */
 
5660
 
 
5661
    /* LIB BUDDY */
 
5662
 
 
5663
    if (PyType_Ready(&PyTyp_pjsua_buddy_config) < 0)
 
5664
        return;
 
5665
    if (PyType_Ready(&PyTyp_pjsua_buddy_info) < 0)
 
5666
        return;
 
5667
 
 
5668
    /* END OF LIB BUDDY */
 
5669
 
 
5670
    /* LIB MEDIA */
 
5671
  
 
5672
    if (PyType_Ready(&PyTyp_pjsua_codec_info) < 0)
 
5673
        return;
 
5674
 
 
5675
    if (PyType_Ready(&PyTyp_pjsua_conf_port_info) < 0)
 
5676
        return;
 
5677
 
 
5678
    PyTyp_pjmedia_port.tp_new = PyType_GenericNew;
 
5679
    if (PyType_Ready(&PyTyp_pjmedia_port) < 0)
 
5680
        return;
 
5681
 
 
5682
    if (PyType_Ready(&PyTyp_pjmedia_snd_dev_info) < 0)
 
5683
        return;
 
5684
 
 
5685
    PyTyp_pjmedia_codec_param_info.tp_new = PyType_GenericNew;
 
5686
    if (PyType_Ready(&PyTyp_pjmedia_codec_param_info) < 0)
 
5687
        return;
 
5688
    PyTyp_pjmedia_codec_param_setting.tp_new = PyType_GenericNew;
 
5689
    if (PyType_Ready(&PyTyp_pjmedia_codec_param_setting) < 0)
 
5690
        return;
 
5691
 
 
5692
    if (PyType_Ready(&PyTyp_pjmedia_codec_param) < 0)
 
5693
        return;
 
5694
 
 
5695
    /* END OF LIB MEDIA */
 
5696
 
 
5697
    /* LIB CALL */
 
5698
 
 
5699
    PyTyp_pj_time_val.tp_new = PyType_GenericNew;
 
5700
    if (PyType_Ready(&PyTyp_pj_time_val) < 0)
 
5701
        return;
 
5702
 
 
5703
    if (PyType_Ready(&PyTyp_pjsua_call_info) < 0)
 
5704
        return;
 
5705
 
 
5706
    /* END OF LIB CALL */
 
5707
 
 
5708
    m = Py_InitModule3(
 
5709
        "py_pjsua", py_pjsua_methods,"PJSUA-lib module for python"
 
5710
    );
 
5711
 
 
5712
    Py_INCREF(&PyTyp_pjsua_callback);
 
5713
    PyModule_AddObject(m, "Callback", (PyObject *)&PyTyp_pjsua_callback);
 
5714
 
 
5715
    Py_INCREF(&PyTyp_pjsua_config);
 
5716
    PyModule_AddObject(m, "Config", (PyObject *)&PyTyp_pjsua_config);
 
5717
 
 
5718
    Py_INCREF(&PyTyp_pjsua_media_config);
 
5719
    PyModule_AddObject(m, "Media_Config", (PyObject *)&PyTyp_pjsua_media_config);
 
5720
 
 
5721
    Py_INCREF(&PyTyp_pjsua_logging_config);
 
5722
    PyModule_AddObject(m, "Logging_Config", (PyObject *)&PyTyp_pjsua_logging_config);
 
5723
 
 
5724
    Py_INCREF(&PyTyp_pjsua_msg_data);
 
5725
    PyModule_AddObject(m, "Msg_Data", (PyObject *)&PyTyp_pjsua_msg_data);
 
5726
 
 
5727
    Py_INCREF(&PyTyp_pjsip_event);
 
5728
    PyModule_AddObject(m, "Pjsip_Event", (PyObject *)&PyTyp_pjsip_event);
 
5729
 
 
5730
    Py_INCREF(&PyTyp_pjsip_rx_data);
 
5731
    PyModule_AddObject(m, "Pjsip_Rx_Data", (PyObject *)&PyTyp_pjsip_rx_data);
 
5732
 
 
5733
    Py_INCREF(&PyTyp_pj_pool_t);
 
5734
    PyModule_AddObject(m, "Pj_Pool", (PyObject *)&PyTyp_pj_pool_t);
 
5735
 
 
5736
    Py_INCREF(&PyTyp_pjsip_endpoint);
 
5737
    PyModule_AddObject(m, "Pjsip_Endpoint", (PyObject *)&PyTyp_pjsip_endpoint);
 
5738
 
 
5739
    Py_INCREF(&PyTyp_pjmedia_endpt);
 
5740
    PyModule_AddObject(m, "Pjmedia_Endpt", (PyObject *)&PyTyp_pjmedia_endpt);
 
5741
 
 
5742
    Py_INCREF(&PyTyp_pj_pool_factory);
 
5743
    PyModule_AddObject(
 
5744
        m, "Pj_Pool_Factory", (PyObject *)&PyTyp_pj_pool_factory
 
5745
    );
 
5746
 
 
5747
    Py_INCREF(&PyTyp_pjsip_cred_info);
 
5748
    PyModule_AddObject(m, "Pjsip_Cred_Info",
 
5749
        (PyObject *)&PyTyp_pjsip_cred_info
 
5750
    );
 
5751
 
 
5752
    /* LIB TRANSPORT */
 
5753
 
 
5754
    Py_INCREF(&PyTyp_pjsua_transport_config);
 
5755
    PyModule_AddObject
 
5756
        (m, "Transport_Config", (PyObject *)&PyTyp_pjsua_transport_config);
 
5757
    
 
5758
    Py_INCREF(&PyTyp_pjsua_transport_info);
 
5759
    PyModule_AddObject(m, "Transport_Info", (PyObject *)&PyTyp_pjsua_transport_info);
 
5760
    
 
5761
 
 
5762
    /* END OF LIB TRANSPORT */
 
5763
 
 
5764
    /* LIB ACCOUNT */
 
5765
 
 
5766
    
 
5767
    Py_INCREF(&PyTyp_pjsua_acc_config);
 
5768
    PyModule_AddObject(m, "Acc_Config", (PyObject *)&PyTyp_pjsua_acc_config);
 
5769
    Py_INCREF(&PyTyp_pjsua_acc_info);
 
5770
    PyModule_AddObject(m, "Acc_Info", (PyObject *)&PyTyp_pjsua_acc_info);
 
5771
 
 
5772
    /* END OF LIB ACCOUNT */
 
5773
 
 
5774
    /* LIB BUDDY */
 
5775
    
 
5776
    Py_INCREF(&PyTyp_pjsua_buddy_config);
 
5777
    PyModule_AddObject(m, "Buddy_Config", (PyObject *)&PyTyp_pjsua_buddy_config);
 
5778
    Py_INCREF(&PyTyp_pjsua_buddy_info);
 
5779
    PyModule_AddObject(m, "Buddy_Info", (PyObject *)&PyTyp_pjsua_buddy_info);
 
5780
 
 
5781
    /* END OF LIB BUDDY */
 
5782
 
 
5783
    /* LIB MEDIA */
 
5784
 
 
5785
    Py_INCREF(&PyTyp_pjsua_codec_info);
 
5786
    PyModule_AddObject(m, "Codec_Info", (PyObject *)&PyTyp_pjsua_codec_info);
 
5787
    Py_INCREF(&PyTyp_pjsua_conf_port_info);
 
5788
    PyModule_AddObject(m, "Conf_Port_Info", (PyObject *)&PyTyp_pjsua_conf_port_info);
 
5789
    Py_INCREF(&PyTyp_pjmedia_port);
 
5790
    PyModule_AddObject(m, "PJMedia_Port", (PyObject *)&PyTyp_pjmedia_port);
 
5791
    Py_INCREF(&PyTyp_pjmedia_snd_dev_info);
 
5792
    PyModule_AddObject(m, "PJMedia_Snd_Dev_Info", 
 
5793
        (PyObject *)&PyTyp_pjmedia_snd_dev_info);
 
5794
    Py_INCREF(&PyTyp_pjmedia_codec_param_info);
 
5795
    PyModule_AddObject(m, "PJMedia_Codec_Param_Info", 
 
5796
        (PyObject *)&PyTyp_pjmedia_codec_param_info);
 
5797
    Py_INCREF(&PyTyp_pjmedia_codec_param_setting);
 
5798
    PyModule_AddObject(m, "PJMedia_Codec_Param_Setting", 
 
5799
        (PyObject *)&PyTyp_pjmedia_codec_param_setting);
 
5800
    Py_INCREF(&PyTyp_pjmedia_codec_param);
 
5801
    PyModule_AddObject(m, "PJMedia_Codec_Param", 
 
5802
        (PyObject *)&PyTyp_pjmedia_codec_param);
 
5803
 
 
5804
    /* END OF LIB MEDIA */
 
5805
 
 
5806
    /* LIB CALL */
 
5807
 
 
5808
    Py_INCREF(&PyTyp_pj_time_val);
 
5809
    PyModule_AddObject(m, "PJ_Time_Val", (PyObject *)&PyTyp_pj_time_val);
 
5810
 
 
5811
    Py_INCREF(&PyTyp_pjsua_call_info);
 
5812
    PyModule_AddObject(m, "Call_Info", (PyObject *)&PyTyp_pjsua_call_info);
 
5813
 
 
5814
    /* END OF LIB CALL */
 
5815
 
 
5816
 
 
5817
    /*
 
5818
     * Add various constants.
 
5819
     */
 
5820
 
 
5821
    /* Call states */
 
5822
    ADD_CONSTANT(m, PJSIP_INV_STATE_NULL);
 
5823
    ADD_CONSTANT(m, PJSIP_INV_STATE_CALLING);
 
5824
    ADD_CONSTANT(m, PJSIP_INV_STATE_INCOMING);
 
5825
    ADD_CONSTANT(m, PJSIP_INV_STATE_EARLY);
 
5826
    ADD_CONSTANT(m, PJSIP_INV_STATE_CONNECTING);
 
5827
    ADD_CONSTANT(m, PJSIP_INV_STATE_CONFIRMED);
 
5828
    ADD_CONSTANT(m, PJSIP_INV_STATE_DISCONNECTED);
 
5829
 
 
5830
    /* Call media status (enum pjsua_call_media_status) */
 
5831
    ADD_CONSTANT(m, PJSUA_CALL_MEDIA_NONE);
 
5832
    ADD_CONSTANT(m, PJSUA_CALL_MEDIA_ACTIVE);
 
5833
    ADD_CONSTANT(m, PJSUA_CALL_MEDIA_LOCAL_HOLD);
 
5834
    ADD_CONSTANT(m, PJSUA_CALL_MEDIA_REMOTE_HOLD);
 
5835
 
 
5836
    /* Buddy status */
 
5837
    ADD_CONSTANT(m, PJSUA_BUDDY_STATUS_UNKNOWN);
 
5838
    ADD_CONSTANT(m, PJSUA_BUDDY_STATUS_ONLINE);
 
5839
    ADD_CONSTANT(m, PJSUA_BUDDY_STATUS_OFFLINE);
 
5840
 
 
5841
    /* PJSIP transport types (enum pjsip_transport_type_e) */
 
5842
    ADD_CONSTANT(m, PJSIP_TRANSPORT_UNSPECIFIED);
 
5843
    ADD_CONSTANT(m, PJSIP_TRANSPORT_UDP);
 
5844
    ADD_CONSTANT(m, PJSIP_TRANSPORT_TCP);
 
5845
    ADD_CONSTANT(m, PJSIP_TRANSPORT_TLS);
 
5846
    ADD_CONSTANT(m, PJSIP_TRANSPORT_SCTP);
 
5847
    ADD_CONSTANT(m, PJSIP_TRANSPORT_LOOP);
 
5848
    ADD_CONSTANT(m, PJSIP_TRANSPORT_LOOP_DGRAM);
 
5849
 
 
5850
 
 
5851
    /* Invalid IDs */
 
5852
    ADD_CONSTANT(m, PJSUA_INVALID_ID);
 
5853
 
 
5854
 
 
5855
    /* Various compile time constants */
 
5856
    ADD_CONSTANT(m, PJSUA_ACC_MAX_PROXIES);
 
5857
    ADD_CONSTANT(m, PJSUA_MAX_ACC);
 
5858
    ADD_CONSTANT(m, PJSUA_REG_INTERVAL);
 
5859
    ADD_CONSTANT(m, PJSUA_PUBLISH_EXPIRATION);
 
5860
    ADD_CONSTANT(m, PJSUA_DEFAULT_ACC_PRIORITY);
 
5861
    ADD_CONSTANT(m, PJSUA_MAX_BUDDIES);
 
5862
    ADD_CONSTANT(m, PJSUA_MAX_CONF_PORTS);
 
5863
    ADD_CONSTANT(m, PJSUA_DEFAULT_CLOCK_RATE);
 
5864
    ADD_CONSTANT(m, PJSUA_DEFAULT_CODEC_QUALITY);
 
5865
    ADD_CONSTANT(m, PJSUA_DEFAULT_ILBC_MODE);
 
5866
    ADD_CONSTANT(m, PJSUA_DEFAULT_EC_TAIL_LEN);
 
5867
    ADD_CONSTANT(m, PJSUA_MAX_CALLS);
 
5868
    ADD_CONSTANT(m, PJSUA_XFER_NO_REQUIRE_REPLACES);
 
5869
 
 
5870
 
 
5871
#undef ADD_CONSTANT
 
5872
}