Changeset 1266


Ignore:
Timestamp:
May 11, 2007 3:14:34 PM (12 years ago)
Author:
bennylp
Message:

HUGE changeset to make the rest of the libraries compile with C++ mode

Location:
pjproject/trunk
Files:
76 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib-util/src/pjlib-util-test/encryption.c

    r1016 r1266  
    385385 
    386386/* CRC32 test data, generated from crc32 test on a Linux box */ 
    387 struct 
     387struct crc32_test_t 
    388388{ 
    389389    char            *input; 
     
    552552        return PJ_ENOMEM; 
    553553 
    554     input = pj_pool_alloc(pool, input_len); 
     554    input = (pj_uint8_t*)pj_pool_alloc(pool, input_len); 
    555555    pj_memset(input, '\xaa', input_len); 
    556556     
  • pjproject/trunk/pjlib/src/pj/except.c

    r974 r1266  
    4242    struct pj_exception_state_t *handler; 
    4343 
    44     handler = pj_thread_local_get(thread_local_id); 
     44    handler = (struct pj_exception_state_t*)  
     45              pj_thread_local_get(thread_local_id); 
    4546    if (handler == NULL) { 
    4647        PJ_LOG(1,("except.c", "!!!FATAL: unhandled exception %s!\n",  
     
    7980        pj_atexit(&exception_cleanup); 
    8081    } 
    81     parent_handler = pj_thread_local_get(thread_local_id); 
     82    parent_handler = (struct pj_exception_state_t *) 
     83                      pj_thread_local_get(thread_local_id); 
    8284    rec->prev = parent_handler; 
    8385    pj_thread_local_set(thread_local_id, rec); 
     
    8890    struct pj_exception_state_t *handler; 
    8991 
    90     handler = pj_thread_local_get(thread_local_id); 
     92    handler = (struct pj_exception_state_t *) 
     93              pj_thread_local_get(thread_local_id); 
    9194    pj_assert(handler != NULL); 
    9295    pj_thread_local_set(thread_local_id, handler->prev); 
  • pjproject/trunk/pjlib/src/pj/ioqueue_common_abs.c

    r1159 r1266  
    302302        } else { 
    303303            pj_assert(!"Invalid operation type!"); 
    304             write_op->op = 0; 
     304            write_op->op = PJ_IOQUEUE_OP_NONE; 
    305305            send_rc = PJ_EBUG; 
    306306        } 
     
    319319        { 
    320320 
    321             write_op->op = 0; 
     321            write_op->op = PJ_IOQUEUE_OP_NONE; 
    322322 
    323323            if (h->fd_type != PJ_SOCK_DGRAM) { 
     
    376376        accept_op = h->accept_list.next; 
    377377        pj_list_erase(accept_op); 
    378         accept_op->op = 0; 
     378        accept_op->op = PJ_IOQUEUE_OP_NONE; 
    379379 
    380380        /* Clear bit in fdset if there is no more pending accept */ 
     
    418418 
    419419        if ((read_op->op == PJ_IOQUEUE_OP_RECV_FROM)) { 
    420             read_op->op = 0; 
     420            read_op->op = PJ_IOQUEUE_OP_NONE; 
    421421            rc = pj_sock_recvfrom(h->fd, read_op->buf, &bytes_read,  
    422422                                  read_op->flags, 
     
    424424                                  read_op->rmt_addrlen); 
    425425        } else if ((read_op->op == PJ_IOQUEUE_OP_RECV)) { 
    426             read_op->op = 0; 
     426            read_op->op = PJ_IOQUEUE_OP_NONE; 
    427427            rc = pj_sock_recv(h->fd, read_op->buf, &bytes_read,  
    428428                              read_op->flags); 
    429429        } else { 
    430430            pj_assert(read_op->op == PJ_IOQUEUE_OP_READ); 
    431             read_op->op = 0; 
     431            read_op->op = PJ_IOQUEUE_OP_NONE; 
    432432            /* 
    433433             * User has specified pj_ioqueue_read(). 
     
    562562 
    563563    read_op = (struct read_operation*)op_key; 
    564     read_op->op = 0; 
     564    read_op->op = PJ_IOQUEUE_OP_NONE; 
    565565 
    566566    /* Check if key is closing. */ 
     
    631631 
    632632    read_op = (struct read_operation*)op_key; 
    633     read_op->op = 0; 
     633    read_op->op = PJ_IOQUEUE_OP_NONE; 
    634634 
    635635    /* Try to see if there's data immediately available.  
     
    769769 
    770770    write_op->op = PJ_IOQUEUE_OP_SEND; 
    771     write_op->buf = (void*)data; 
     771    write_op->buf = (char*)data; 
    772772    write_op->size = *length; 
    773773    write_op->written = 0; 
     
    849849     * Check that address storage can hold the address parameter. 
    850850     */ 
    851     PJ_ASSERT_RETURN(addrlen <= sizeof(pj_sockaddr_in), PJ_EBUG); 
     851    PJ_ASSERT_RETURN(addrlen <= (int)sizeof(pj_sockaddr_in), PJ_EBUG); 
    852852 
    853853    /* 
     
    884884 
    885885    write_op->op = PJ_IOQUEUE_OP_SEND_TO; 
    886     write_op->buf = (void*)data; 
     886    write_op->buf = (char*)data; 
    887887    write_op->size = *length; 
    888888    write_op->written = 0; 
     
    921921 
    922922    accept_op = (struct accept_operation*)op_key; 
    923     accept_op->op = 0; 
     923    accept_op->op = PJ_IOQUEUE_OP_NONE; 
    924924 
    925925    /* Fast track: 
     
    10531053        if (op_rec == (void*)op_key) { 
    10541054            pj_list_erase(op_rec); 
    1055             op_rec->op = 0; 
     1055            op_rec->op = PJ_IOQUEUE_OP_NONE; 
    10561056            pj_mutex_unlock(key->mutex); 
    10571057 
     
    10671067        if (op_rec == (void*)op_key) { 
    10681068            pj_list_erase(op_rec); 
    1069             op_rec->op = 0; 
     1069            op_rec->op = PJ_IOQUEUE_OP_NONE; 
    10701070            pj_mutex_unlock(key->mutex); 
    10711071 
     
    10811081        if (op_rec == (void*)op_key) { 
    10821082            pj_list_erase(op_rec); 
    1083             op_rec->op = 0; 
     1083            op_rec->op = PJ_IOQUEUE_OP_NONE; 
    10841084            pj_mutex_unlock(key->mutex); 
    10851085 
  • pjproject/trunk/pjlib/src/pj/ioqueue_select.c

    r1159 r1266  
    194194 
    195195    /* Create and init common ioqueue stuffs */ 
    196     ioqueue = pj_pool_alloc(pool, sizeof(pj_ioqueue_t)); 
     196    ioqueue = PJ_POOL_ALLOC_T(pool, pj_ioqueue_t); 
    197197    ioqueue_init(ioqueue); 
    198198 
     
    231231        pj_ioqueue_key_t *key; 
    232232 
    233         key = pj_pool_alloc(pool, sizeof(pj_ioqueue_key_t)); 
     233        key = PJ_POOL_ALLOC_T(pool, pj_ioqueue_key_t); 
    234234        key->ref_count = 0; 
    235235        rc = pj_mutex_create_recursive(pool, NULL, &key->mutex); 
  • pjproject/trunk/pjlib/src/pj/log.c

    r1042 r1266  
    147147    } 
    148148    len = len + print_len; 
    149     if (len > 0 && len < sizeof(log_buffer)-2) { 
     149    if (len > 0 && len < (int)sizeof(log_buffer)-2) { 
    150150        if (log_decor & PJ_LOG_HAS_CR) { 
    151151            log_buffer[len++] = '\r'; 
  • pjproject/trunk/pjlib/src/pj/os_core_unix.c

    r1076 r1266  
    2222 *   the RTEMS port. 
    2323 */ 
    24 #define _GNU_SOURCE 
     24#ifndef _GNU_SOURCE 
     25#   define _GNU_SOURCE 
     26#endif 
    2527#include <pj/os.h> 
    2628#include <pj/assert.h> 
     
    340342static void *thread_main(void *param) 
    341343{ 
    342     pj_thread_t *rec = param; 
     344    pj_thread_t *rec = (pj_thread_t*)param; 
    343345    void *result; 
    344346    pj_status_t rc; 
     
    507509{ 
    508510#if PJ_HAS_THREADS 
    509     pj_thread_t *rec = pj_thread_local_get(thread_tls_id); 
     511    pj_thread_t *rec = (pj_thread_t*)pj_thread_local_get(thread_tls_id); 
    510512     
    511513    if (rec == NULL) { 
     
    664666{ 
    665667    pj_status_t rc; 
    666     pj_atomic_t *atomic_var = pj_pool_calloc(pool, 1, sizeof(pj_atomic_t)); 
     668    pj_atomic_t *atomic_var; 
     669 
     670    atomic_var = PJ_POOL_ZALLOC_T(pool, pj_atomic_t); 
     671 
    667672    PJ_ASSERT_RETURN(atomic_var, PJ_ENOMEM); 
    668673     
     
    908913 
    909914/////////////////////////////////////////////////////////////////////////////// 
     915#if defined(PJ_LINUX) && PJ_LINUX!=0 
     916PJ_BEGIN_DECL 
     917PJ_DECL(int) pthread_mutexattr_settype(pthread_mutexattr_t*,int); 
     918PJ_END_DECL 
     919#endif 
     920 
    910921static pj_status_t init_mutex(pj_mutex_t *mutex, const char *name, int type) 
    911922{ 
     
    922933    if (type == PJ_MUTEX_SIMPLE) { 
    923934#if defined(PJ_LINUX) && PJ_LINUX!=0 
    924         extern int pthread_mutexattr_settype(pthread_mutexattr_t*,int); 
    925935        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP); 
    926936#elif defined(PJ_RTEMS) && PJ_RTEMS!=0 
     
    931941    } else { 
    932942#if defined(PJ_LINUX) && PJ_LINUX!=0 
    933         extern int pthread_mutexattr_settype(pthread_mutexattr_t*,int); 
    934943        rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP); 
    935944#elif defined(PJ_RTEMS) && PJ_RTEMS!=0 
     
    9921001    PJ_ASSERT_RETURN(pool && ptr_mutex, PJ_EINVAL); 
    9931002 
    994     mutex = pj_pool_alloc(pool, sizeof(*mutex)); 
     1003    mutex = PJ_POOL_ALLOC_T(pool, pj_mutex_t); 
    9951004    PJ_ASSERT_RETURN(mutex, PJ_ENOMEM); 
    9961005 
     
    12291238    PJ_UNUSED_ARG(name); 
    12301239     
    1231     rwm = pj_pool_alloc(pool, sizeof(pj_rwmutex_t)); 
     1240    rwm = PJ_POOL_ALLOC_T(pool, pj_rwmutex_t); 
    12321241    PJ_ASSERT_RETURN(rwm, PJ_ENOMEM); 
    12331242 
     
    13301339    PJ_ASSERT_RETURN(pool != NULL && ptr_sem != NULL, PJ_EINVAL); 
    13311340 
    1332     sem = pj_pool_alloc(pool, sizeof(*sem)); 
     1341    sem = PJ_POOL_ALLOC_T(pool, pj_sem_t); 
    13331342    PJ_ASSERT_RETURN(sem, PJ_ENOMEM); 
    13341343 
  • pjproject/trunk/pjlib/src/pj/os_error_unix.c

    r974 r1266  
    4141} 
    4242 
     43PJ_BEGIN_DECL 
     44 
     45    PJ_DECL(int) platform_strerror(pj_os_err_type code,  
     46                                   char *buf, pj_size_t bufsize ); 
     47PJ_END_DECL 
     48 
    4349/*  
    4450 * platform_strerror() 
  • pjproject/trunk/pjlib/src/pj/sock_bsd.c

    r974 r1266  
    386386    PJ_CHECK_STACK(); 
    387387 
    388     PJ_ASSERT_RETURN(addr && len >= sizeof(struct sockaddr_in), PJ_EINVAL); 
     388    PJ_ASSERT_RETURN(addr && len >= (int)sizeof(struct sockaddr_in), PJ_EINVAL); 
    389389 
    390390    if (bind(sock, (struct sockaddr*)addr, len) != 0) 
  • pjproject/trunk/pjlib/src/pjlib-test/file.c

    r974 r1266  
    126126 
    127127    size = 0; 
    128     while (size < sizeof(readbuf)) { 
     128    while (size < (pj_ssize_t)sizeof(readbuf)) { 
    129129        pj_ssize_t read; 
    130130        read = 1; 
  • pjproject/trunk/pjlib/src/pjlib-test/ioq_perf.c

    r1236 r1266  
    506506 
    507507    best_bandwidth = 0; 
    508     for (i=0; i<sizeof(test_param)/sizeof(test_param[0]); ++i) { 
     508    for (i=0; i<(int)(sizeof(test_param)/sizeof(test_param[0])); ++i) { 
    509509        pj_size_t bandwidth; 
    510510 
  • pjproject/trunk/pjlib/src/pjlib-test/sock.c

    r1238 r1266  
    142142    PJ_LOG(3,("test", "...simple_sock_test()")); 
    143143 
    144     for (i=0; i<sizeof(types)/sizeof(types[0]); ++i) { 
     144    for (i=0; i<(int)(sizeof(types)/sizeof(types[0])); ++i) { 
    145145         
    146146        rc = pj_sock_socket(PJ_AF_INET, types[i], 0, &sock); 
  • pjproject/trunk/pjlib/src/pjlib-test/string.c

    r1235 r1266  
    9797#define STRTEST(res,S1,S2,code) \ 
    9898            do { \ 
    99                 s1.ptr=S1; s1.slen=S1?len:0; \ 
    100                 s2.ptr=S2; s2.slen=S2?len:0; \ 
     99                s1.ptr=S1; s1.slen=(S1)?len:0; \ 
     100                s2.ptr=S2; s2.slen=(S2)?len:0; \ 
    101101                pj_get_timestamp(&t1); \ 
    102102                if (C(pj_stricmp(&s1,&s2),res)) return code; \ 
     
    124124    pj_thread_sleep(0); 
    125125 
     126#define SNULL 0 
     127 
    126128    /* Compare empty strings. */ 
    127129    len=0; 
    128130    STRTEST( 0, "","",-500); 
    129     STRTEST( 0, NULL,"",-502); 
    130     STRTEST( 0, "",NULL,-504); 
    131     STRTEST( 0, NULL,NULL,-506); 
     131    STRTEST( 0, SNULL,"",-502); 
     132    STRTEST( 0, "",SNULL,-504); 
     133    STRTEST( 0, SNULL,SNULL,-506); 
    132134    STRTEST( 0, "hello","world",-508); 
    133135 
     
    140142    STRTEST( 0, "a",buf+1,-512); 
    141143    STRTEST( -1, "O", "P", -514); 
    142     STRTEST(-1, NULL, "a", -516); 
    143     STRTEST(1, "a", NULL, -518); 
     144    STRTEST(-1, SNULL, "a", -516); 
     145    STRTEST(1, "a", SNULL, -518); 
    144146 
    145147    /* equal, length=2  
     
    267269    len=0; 
    268270    STR_TEST(0, "", "", -400); 
    269     STR_TEST(0, NULL, "", -405); 
    270     STR_TEST(0, "", NULL, -410); 
    271     STR_TEST(0, NULL, NULL, -415); 
     271    STR_TEST(0, SNULL, "", -405); 
     272    STR_TEST(0, "", SNULL, -410); 
     273    STR_TEST(0, SNULL, SNULL, -415); 
    272274    STR_TEST(0, "hello", "", -420); 
    273     STR_TEST(0, "hello", NULL, -425); 
     275    STR_TEST(0, "hello", SNULL, -425); 
    274276 
    275277    /* Test with length != 0 */ 
     
    278280    STR_TEST(1, "12", "1", -435); 
    279281    STR_TEST(-1, "1", "12", -440); 
    280     STR_TEST(-1, NULL, "12", -445); 
    281     STR_TEST(1, "12", NULL, -450); 
     282    STR_TEST(-1, SNULL, "12", -445); 
     283    STR_TEST(1, "12", SNULL, -450); 
    282284 
    283285    return 0; 
     
    296298    int i; 
    297299 
    298     pool = pj_pool_create(mem, NULL, 4096, 0, NULL); 
     300    pool = pj_pool_create(mem, SNULL, 4096, 0, SNULL); 
    299301    if (!pool) return -5; 
    300302     
     
    368370    s5 = pj_str("123456"); 
    369371 
    370     pj_strtoul2(&s5, NULL, 10); /* Crash test */ 
     372    pj_strtoul2(&s5, SNULL, 10);        /* Crash test */ 
    371373 
    372374    if (pj_strtoul2(&s5, &s4, 10) != 123456UL) 
     
    382384    if (s4.slen != 4) 
    383385        return -294; 
    384     if (s4.ptr == NULL || *s4.ptr != 'A') 
     386    if (s4.ptr == SNULL || *s4.ptr != 'A') 
    385387        return -295; 
    386388    if (pj_strtoul2(&s5, &s4, 16) != 0x123ABCDUL) 
  • pjproject/trunk/pjmedia/src/pjmedia-codec/gsm.c

    r1177 r1266  
    123123struct gsm_data 
    124124{ 
    125     void                *encoder; 
    126     void                *decoder; 
     125    gsm_state           *encoder; 
     126    gsm_state           *decoder; 
    127127    pj_bool_t            plc_enabled; 
    128128#if !PLC_DISABLED 
     
    324324        pj_list_erase(codec); 
    325325    } else { 
    326         codec = pj_pool_zalloc(gsm_codec_factory.pool,  
    327                                sizeof(pjmedia_codec)); 
     326        codec = PJ_POOL_ZALLOC_T(gsm_codec_factory.pool, pjmedia_codec); 
    328327        PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM); 
    329328        codec->op = &gsm_op; 
    330329        codec->factory = factory; 
    331330 
    332         gsm_data = pj_pool_zalloc(gsm_codec_factory.pool,  
    333                                   sizeof(struct gsm_data)); 
     331        gsm_data = PJ_POOL_ZALLOC_T(gsm_codec_factory.pool, struct gsm_data); 
    334332        codec->codec_data = gsm_data; 
    335333 
     
    372370    PJ_ASSERT_RETURN(factory == &gsm_codec_factory.base, PJ_EINVAL); 
    373371 
    374     gsm_data = codec->codec_data; 
     372    gsm_data = (struct gsm_data*) codec->codec_data; 
    375373 
    376374    /* Close codec, if it's not closed. */ 
     
    418416                                   pjmedia_codec_param *attr ) 
    419417{ 
    420     struct gsm_data *gsm_data = codec->codec_data; 
     418    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data; 
    421419 
    422420    pj_assert(gsm_data != NULL); 
     
    442440static pj_status_t gsm_codec_close( pjmedia_codec *codec ) 
    443441{ 
    444     struct gsm_data *gsm_data = codec->codec_data; 
     442    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data; 
    445443 
    446444    pj_assert(gsm_data != NULL); 
     
    465463                                     const pjmedia_codec_param *attr ) 
    466464{ 
    467     struct gsm_data *gsm_data = codec->codec_data; 
     465    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data; 
    468466 
    469467    pj_assert(gsm_data != NULL); 
     
    517515                                     struct pjmedia_frame *output) 
    518516{ 
    519     struct gsm_data *gsm_data = codec->codec_data; 
     517    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data; 
    520518 
    521519    pj_assert(gsm_data != NULL); 
     
    536534 
    537535        is_silence = pjmedia_silence_det_detect(gsm_data->vad,  
    538                                                 input->buf, 
     536                                                (const pj_int16_t*) input->buf, 
    539537                                                (input->size >> 1), 
    540538                                                NULL); 
     
    571569                                     struct pjmedia_frame *output) 
    572570{ 
    573     struct gsm_data *gsm_data = codec->codec_data; 
     571    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data; 
    574572 
    575573    pj_assert(gsm_data != NULL); 
  • pjproject/trunk/pjmedia/src/pjmedia-codec/ilbc.c

    r1169 r1266  
    320320    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); 
    321321 
    322     codec = pj_pool_zalloc(pool, sizeof(struct ilbc_codec)); 
     322    codec = PJ_POOL_ZALLOC_T(pool, struct ilbc_codec); 
    323323    codec->base.op = &ilbc_op; 
    324324    codec->base.factory = factory; 
     
    531531 
    532532        is_silence = pjmedia_silence_det_detect(ilbc_codec->vad,  
    533                                                 input->buf, 
     533                                                (const pj_int16_t*)input->buf, 
    534534                                                (input->size >> 1), 
    535535                                                NULL); 
     
    586586 
    587587    /* Decode to temporary buffer */ 
    588     iLBC_decode(ilbc_codec->dec_block, input->buf, 
     588    iLBC_decode(ilbc_codec->dec_block, (unsigned char*) input->buf, 
    589589                &ilbc_codec->dec, 1); 
    590590 
  • pjproject/trunk/pjmedia/src/pjmedia-codec/l16.c

    r974 r1266  
    429429    if (pj_list_empty(&l16_factory.codec_list)) { 
    430430 
    431         codec = pj_pool_alloc(l16_factory.pool, sizeof(pjmedia_codec)); 
     431        codec = PJ_POOL_ALLOC_T(l16_factory.pool, pjmedia_codec); 
    432432        codec->codec_data = pj_pool_alloc(l16_factory.pool,  
    433433                                          sizeof(struct l16_data)); 
     
    442442    /* Init private data */ 
    443443    ptime = GET_PTIME(id->clock_rate); 
    444     data = codec->codec_data; 
     444    data = (struct l16_data*) codec->codec_data; 
    445445    data->frame_size = ptime * id->clock_rate * id->channel_cnt * 2 / 1000; 
    446446 
  • pjproject/trunk/pjmedia/src/pjmedia-codec/speex_codec.c

    r974 r1266  
    482482        pj_list_erase(codec); 
    483483    } else { 
    484         codec = pj_pool_zalloc(spx_factory.pool,  
    485                                sizeof(pjmedia_codec)); 
     484        codec = PJ_POOL_ZALLOC_T(spx_factory.pool, pjmedia_codec); 
    486485        PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM); 
    487486        codec->op = &spx_op; 
     
    737736 
    738737    /* Encode the frame */ 
    739     tx = speex_encode_int(spx->enc, input->buf, &spx->enc_bits); 
     738    tx = speex_encode_int(spx->enc, (spx_int16_t*)input->buf,  
     739                          &spx->enc_bits); 
    740740 
    741741    /* Check if we need not to transmit the frame (DTX) */ 
     
    754754    /* Copy the bits to an array of char that can be written */ 
    755755    output->size = speex_bits_write(&spx->enc_bits,  
    756                                     output->buf, output_buf_len); 
     756                                    (char*)output->buf, output_buf_len); 
    757757    output->type = PJMEDIA_FRAME_TYPE_AUDIO; 
    758758    output->timestamp = input->timestamp; 
     
    782782 
    783783    /* Copy the data into the bit-stream struct */ 
    784     speex_bits_read_from(&spx->dec_bits, input->buf, input->size); 
     784    speex_bits_read_from(&spx->dec_bits, (char*)input->buf, input->size); 
    785785 
    786786    /* Decode the data */ 
    787     speex_decode_int(spx->dec, &spx->dec_bits, output->buf); 
     787    speex_decode_int(spx->dec, &spx->dec_bits, (spx_int16_t*)output->buf); 
    788788 
    789789    output->type = PJMEDIA_FRAME_TYPE_AUDIO; 
    790790    output->size = speex_bits_nbytes(&spx->dec_bits); 
    791     pj_assert(output->size <= (int)output_buf_len); 
     791    pj_assert(output->size <= (unsigned)output_buf_len); 
    792792    output->timestamp.u64 = input->timestamp.u64; 
    793793 
     
    815815 
    816816    /* Recover packet loss */ 
    817     speex_decode_int(spx->dec, NULL, output->buf); 
     817    speex_decode_int(spx->dec, NULL, (spx_int16_t*) output->buf); 
    818818 
    819819    output->size = count * 2; 
  • pjproject/trunk/pjmedia/src/pjmedia/clock_thread.c

    r974 r1266  
    6767                     PJ_EINVAL); 
    6868 
    69     clock = pj_pool_alloc(pool, sizeof(pjmedia_clock)); 
     69    clock = PJ_POOL_ALLOC_T(pool, pjmedia_clock); 
    7070 
    7171     
     
    198198{ 
    199199    pj_timestamp now; 
    200     pjmedia_clock *clock = arg; 
     200    pjmedia_clock *clock = (pjmedia_clock*) arg; 
    201201 
    202202    /* Get the first tick */ 
  • pjproject/trunk/pjmedia/src/pjmedia/conference.c

    r1171 r1266  
    240240 
    241241    /* Create port. */ 
    242     conf_port = pj_pool_zalloc(pool, sizeof(struct conf_port)); 
     242    conf_port = PJ_POOL_ZALLOC_T(pool, struct conf_port); 
    243243    PJ_ASSERT_RETURN(conf_port, PJ_ENOMEM); 
    244244 
     
    255255 
    256256    /* Create transmit flag array */ 
    257     conf_port->listener_slots = pj_pool_zalloc(pool,  
     257    conf_port->listener_slots = (SLOT_TYPE*) 
     258                                pj_pool_zalloc(pool,  
    258259                                          conf->max_ports * sizeof(SLOT_TYPE)); 
    259260    PJ_ASSERT_RETURN(conf_port->listener_slots, PJ_ENOMEM); 
     
    336337                                           conf->clock_rate); 
    337338        conf_port->rx_buf_count = 0; 
    338         conf_port->rx_buf = pj_pool_alloc(pool, conf_port->rx_buf_cap * 
     339        conf_port->rx_buf = (pj_int16_t*) 
     340                            pj_pool_alloc(pool, conf_port->rx_buf_cap * 
    339341                                                sizeof(conf_port->rx_buf[0])); 
    340342        PJ_ASSERT_RETURN(conf_port->rx_buf, PJ_ENOMEM); 
     
    343345        conf_port->tx_buf_cap = conf_port->rx_buf_cap; 
    344346        conf_port->tx_buf_count = 0; 
    345         conf_port->tx_buf = pj_pool_alloc(pool, conf_port->tx_buf_cap * 
     347        conf_port->tx_buf = (pj_int16_t*) 
     348                            pj_pool_alloc(pool, conf_port->tx_buf_cap * 
    346349                                                sizeof(conf_port->tx_buf[0])); 
    347350        PJ_ASSERT_RETURN(conf_port->tx_buf, PJ_ENOMEM); 
     
    350353 
    351354    /* Create mix buffer. */ 
    352     conf_port->mix_buf = pj_pool_zalloc(pool, conf->samples_per_frame * 
     355    conf_port->mix_buf = (pj_uint32_t*) 
     356                         pj_pool_zalloc(pool, conf->samples_per_frame * 
    353357                                              sizeof(conf_port->mix_buf[0])); 
    354358    PJ_ASSERT_RETURN(conf_port->mix_buf, PJ_ENOMEM); 
     
    381385    /* Passive port has rx buffers. */ 
    382386    for (i=0; i<RX_BUF_COUNT; ++i) { 
    383         conf_port->snd_buf[i] = pj_pool_zalloc(pool, conf->samples_per_frame * 
     387        conf_port->snd_buf[i] = (pj_int16_t*) 
     388                                pj_pool_zalloc(pool, conf->samples_per_frame * 
    384389                                              sizeof(conf_port->snd_buf[0][0])); 
    385390        if (conf_port->snd_buf[i] == NULL) { 
     
    487492 
    488493    /* Create and init conf structure. */ 
    489     conf = pj_pool_zalloc(pool, sizeof(pjmedia_conf)); 
     494    conf = PJ_POOL_ZALLOC_T(pool, pjmedia_conf); 
    490495    PJ_ASSERT_RETURN(conf, PJ_ENOMEM); 
    491496 
    492     conf->ports = pj_pool_zalloc(pool, max_ports*sizeof(void*)); 
     497    conf->ports = (struct conf_port**)  
     498                  pj_pool_zalloc(pool, max_ports*sizeof(void*)); 
    493499    PJ_ASSERT_RETURN(conf->ports, PJ_ENOMEM); 
    494500 
     
    502508     
    503509    /* Create and initialize the master port interface. */ 
    504     conf->master_port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); 
     510    conf->master_port = PJ_POOL_ZALLOC_T(pool, pjmedia_port); 
    505511    PJ_ASSERT_RETURN(conf->master_port, PJ_ENOMEM); 
    506512     
     
    523529 
    524530    /* Create temporary buffer. */ 
    525     conf->uns_buf = pj_pool_zalloc(pool, samples_per_frame * 
     531    conf->uns_buf = (pj_uint16_t*) 
     532                    pj_pool_zalloc(pool, samples_per_frame * 
    526533                                         sizeof(conf->uns_buf[0])); 
    527534 
     
    598605static pj_status_t destroy_port(pjmedia_port *this_port) 
    599606{ 
    600     pjmedia_conf *conf = this_port->port_data.pdata; 
     607    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata; 
    601608    return pjmedia_conf_destroy(conf); 
    602609} 
     
    626633                                                const pj_str_t *name) 
    627634{ 
    628     int len; 
     635    unsigned len; 
    629636 
    630637    /* Sanity check. */ 
     
    764771        name = &tmp; 
    765772 
    766         tmp.ptr = pj_pool_alloc(pool, 32); 
     773        tmp.ptr = (char*) pj_pool_alloc(pool, 32); 
    767774        tmp.slen = pj_ansi_snprintf(tmp.ptr, 32, "ConfPort#%d", index); 
    768775    } 
    769776 
    770777    /* Create and initialize the media port structure. */ 
    771     port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); 
     778    port = PJ_POOL_ZALLOC_T(pool, pjmedia_port); 
    772779    PJ_ASSERT_RETURN(port, PJ_ENOMEM); 
    773780     
     
    16011608                             pjmedia_frame *frame) 
    16021609{ 
    1603     pjmedia_conf *conf = this_port->port_data.pdata; 
     1610    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata; 
    16041611    pjmedia_frame_type speaker_frame_type = PJMEDIA_FRAME_TYPE_NONE; 
    16051612    unsigned ci, cj, i, j; 
     
    16771684 
    16781685            snd_buf = conf_port->snd_buf[conf_port->snd_read_pos]; 
    1679             pjmedia_copy_samples(frame->buf, snd_buf, conf->samples_per_frame); 
     1686            pjmedia_copy_samples((pj_int16_t*)frame->buf, snd_buf,  
     1687                                 conf->samples_per_frame); 
    16801688            conf_port->snd_read_pos = (conf_port->snd_read_pos+1) % RX_BUF_COUNT; 
    16811689 
     
    16851693            pjmedia_frame_type frame_type; 
    16861694 
    1687             status = read_port(conf, conf_port, frame->buf,  
     1695            status = read_port(conf, conf_port, (pj_int16_t*)frame->buf,  
    16881696                               conf->samples_per_frame, &frame_type); 
    16891697             
     
    17111719         */ 
    17121720        if (conf_port->rx_adj_level != NORMAL_LEVEL) { 
    1713             pj_int16_t *input = frame->buf; 
     1721            pj_int16_t *input = (pj_int16_t*) frame->buf; 
    17141722            pj_int32_t adj = conf_port->rx_adj_level; 
    17151723 
     
    17391747 
    17401748        } else { 
    1741             level = pjmedia_calc_avg_signal(frame->buf,  
     1749            level = pjmedia_calc_avg_signal((pj_int16_t*) frame->buf,  
    17421750                                            conf->samples_per_frame); 
    17431751        } 
     
    18001808            if (listener->transmitter_cnt == 1) { 
    18011809                pjmedia_copy_samples((pj_int16_t*)mix_buf,  
    1802                                      frame->buf, conf->samples_per_frame); 
     1810                                     (const pj_int16_t*)frame->buf,  
     1811                                     conf->samples_per_frame); 
    18031812                listener->src_level = level; 
    18041813            } else { 
     
    18571866                           conf->samples_per_frame)); 
    18581867 
    1859         pjmedia_copy_samples( frame->buf, (pj_int16_t*)conf->ports[0]->mix_buf,  
     1868        pjmedia_copy_samples( (pj_int16_t*)frame->buf,  
     1869                              (const pj_int16_t*)conf->ports[0]->mix_buf,  
    18601870                              conf->samples_per_frame); 
    18611871    } else { 
    1862         pjmedia_zero_samples( frame->buf, conf->samples_per_frame );  
     1872        pjmedia_zero_samples((pj_int16_t*)frame->buf, conf->samples_per_frame);  
    18631873    } 
    18641874 
     
    18981908                             const pjmedia_frame *frame) 
    18991909{ 
    1900     pjmedia_conf *conf = this_port->port_data.pdata; 
     1910    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata; 
    19011911    struct conf_port *port = conf->ports[this_port->port_data.ldata]; 
    1902     const pj_int16_t *input = frame->buf; 
     1912    const pj_int16_t *input = (const pj_int16_t*) frame->buf; 
    19031913    pj_int16_t *target_snd_buf; 
    19041914 
  • pjproject/trunk/pjmedia/src/pjmedia/echo_common.c

    r974 r1266  
    146146#endif 
    147147 
    148     ec = pj_pool_zalloc(pool, sizeof(struct pjmedia_echo_state)); 
     148    ec = PJ_POOL_ZALLOC_T(pool, struct pjmedia_echo_state); 
    149149 
    150150    if (options & PJMEDIA_ECHO_SIMPLE) { 
  • pjproject/trunk/pjmedia/src/pjmedia/echo_port.c

    r974 r1266  
    6060 
    6161    /* Create the port and the AEC itself */ 
    62     ec = pj_pool_zalloc(pool, sizeof(struct ec)); 
     62    ec = PJ_POOL_ZALLOC_T(pool, struct ec); 
    6363     
    6464    pjmedia_port_info_init(&ec->base.info, &AEC, SIGNATURE, 
     
    101101                     PJ_EINVAL); 
    102102 
    103     pjmedia_echo_capture(ec->ec, frame->buf, 0); 
     103    pjmedia_echo_capture(ec->ec, (pj_int16_t*)frame->buf, 0); 
    104104 
    105105    return pjmedia_port_put_frame(ec->dn_port, frame); 
     
    117117    status = pjmedia_port_get_frame(ec->dn_port, frame); 
    118118    if (status!=PJ_SUCCESS || frame->type!=PJMEDIA_FRAME_TYPE_AUDIO) { 
    119         pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame); 
     119        pjmedia_zero_samples((pj_int16_t*)frame->buf,  
     120                             this_port->info.samples_per_frame); 
    120121    } 
    121122 
    122     pjmedia_echo_playback(ec->ec, frame->buf); 
     123    pjmedia_echo_playback(ec->ec, (pj_int16_t*)frame->buf); 
    123124 
    124125    return status; 
  • pjproject/trunk/pjmedia/src/pjmedia/echo_speex.c

    r974 r1266  
    7878    unsigned i; 
    7979 
    80     fq = pj_pool_zalloc(pool, sizeof(pjmedia_frame_queue)); 
     80    fq = PJ_POOL_ZALLOC_T(pool, pjmedia_frame_queue); 
    8181 
    8282    pj_ansi_snprintf(fq->obj_name, sizeof(fq->obj_name), name, fq); 
     
    9494        struct fq_frame *f; 
    9595 
    96         f = pj_pool_zalloc(pool, sizeof(struct fq_frame)); 
     96        f = PJ_POOL_ZALLOC_T(pool, struct fq_frame); 
    9797        f->buf = pj_pool_alloc(pool, frame_size); 
    9898 
     
    295295    *p_echo = NULL; 
    296296 
    297     echo = pj_pool_zalloc(pool, sizeof(speex_ec)); 
     297    echo = PJ_POOL_ZALLOC_T(pool, speex_ec); 
    298298    PJ_ASSERT_RETURN(echo != NULL, PJ_ENOMEM); 
    299299 
     
    356356 
    357357    /* Create temporary frame for echo cancellation */ 
    358     echo->tmp_frame = pj_pool_zalloc(pool, 2 * samples_per_frame); 
     358    echo->tmp_frame = (pj_int16_t*) pj_pool_zalloc(pool, 2 * samples_per_frame); 
    359359    PJ_ASSERT_RETURN(echo->tmp_frame != NULL, PJ_ENOMEM); 
    360360 
    361361    /* Create temporary frame to receive residue */ 
    362     echo->residue = pj_pool_zalloc(pool, sizeof(spx_int32_t) *  
     362    echo->residue = (spx_int32_t*) 
     363                    pj_pool_zalloc(pool, sizeof(spx_int32_t) *  
    363364                                            (samples_per_frame+1)); 
    364365    PJ_ASSERT_RETURN(echo->residue != NULL, PJ_ENOMEM); 
     
    392393PJ_DEF(pj_status_t) speex_aec_destroy(void *state ) 
    393394{ 
    394     speex_ec *echo = state; 
     395    speex_ec *echo = (speex_ec*) state; 
    395396 
    396397    PJ_ASSERT_RETURN(echo && echo->state, PJ_EINVAL); 
     
    424425                                       pj_int16_t *play_frm ) 
    425426{ 
    426     speex_ec *echo = state; 
     427    speex_ec *echo = (speex_ec*) state; 
    427428 
    428429    /* Sanity checks */ 
     
    482483                                       unsigned options ) 
    483484{ 
    484     speex_ec *echo = state; 
     485    speex_ec *echo = (speex_ec*) state; 
    485486    pj_status_t status = PJ_SUCCESS; 
    486487 
     
    552553                                           void *reserved ) 
    553554{ 
    554     speex_ec *echo = state; 
     555    speex_ec *echo = (speex_ec*) state; 
    555556 
    556557    /* Sanity checks */ 
  • pjproject/trunk/pjmedia/src/pjmedia/echo_suppress.c

    r974 r1266  
    8686    PJ_UNUSED_ARG(latency_ms); 
    8787 
    88     ec = pj_pool_zalloc(pool, sizeof(struct echo_supp)); 
     88    ec = PJ_POOL_ZALLOC_T(pool, struct echo_supp); 
    8989    ec->samples_per_frame = samples_per_frame; 
    9090    ec->tail_ms = tail_ms; 
     
    120120                                        pj_int16_t *play_frm ) 
    121121{ 
    122     echo_supp *ec = state; 
     122    echo_supp *ec = (echo_supp*) state; 
    123123    pj_bool_t silence; 
    124124    pj_bool_t last_suppressing = ec->suppressing; 
     
    150150                                       unsigned options ) 
    151151{ 
    152     echo_supp *ec = state; 
     152    echo_supp *ec = (echo_supp*) state; 
    153153    pj_time_val now; 
    154154    unsigned delay_ms; 
     
    186186                                           void *reserved ) 
    187187{ 
    188     echo_supp *ec = state; 
     188    echo_supp *ec = (echo_supp*) state; 
    189189    pj_bool_t silence; 
    190190 
  • pjproject/trunk/pjmedia/src/pjmedia/endpoint.c

    r1103 r1266  
    127127        return PJ_ENOMEM; 
    128128 
    129     endpt = pj_pool_zalloc(pool, sizeof(struct pjmedia_endpt)); 
     129    endpt = PJ_POOL_ZALLOC_T(pool, struct pjmedia_endpt); 
    130130    endpt->pool = pool; 
    131131    endpt->pf = pf; 
     
    247247static int PJ_THREAD_FUNC worker_proc(void *arg) 
    248248{ 
    249     pjmedia_endpt *endpt = arg; 
     249    pjmedia_endpt *endpt = (pjmedia_endpt*) arg; 
    250250 
    251251    while (!endpt->quit_flag) { 
     
    294294 
    295295    /* Create and initialize basic SDP session */ 
    296     sdp = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_session)); 
     296    sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session); 
    297297 
    298298    pj_gettimeofday(&tv); 
     
    308308     * SDP connection line in the session level. 
    309309     */ 
    310     sdp->conn = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_conn)); 
     310    sdp->conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn); 
    311311    sdp->conn->net_type = STR_IN; 
    312312    sdp->conn->addr_type = STR_IP4; 
     
    322322 
    323323    sdp->media_count = 1; 
    324     m = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_media)); 
     324    m = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media); 
    325325    sdp->media[0] = m; 
    326326 
     
    338338#if defined(PJMEDIA_HAS_RTCP_IN_SDP) && PJMEDIA_HAS_RTCP_IN_SDP!=0 
    339339    if (sock_info->rtcp_addr_name.sin_family != 0) { 
    340         attr = pj_pool_alloc(pool, sizeof(pjmedia_sdp_attr)); 
     340        attr = PJ_POOL_ALLOC_T(pool, pjmedia_sdp_attr); 
    341341        attr->name = pj_str("rtcp"); 
    342         attr->value.ptr = pj_pool_alloc(pool, 80); 
     342        attr->value.ptr = (char*) pj_pool_alloc(pool, 80); 
    343343        attr->value.slen =  
    344344            pj_ansi_snprintf(attr->value.ptr, 80, 
     
    368368        fmt = &m->desc.fmt[m->desc.fmt_count++]; 
    369369 
    370         fmt->ptr = pj_pool_alloc(pool, 8); 
     370        fmt->ptr = (char*) pj_pool_alloc(pool, 8); 
    371371        fmt->slen = pj_utoa(codec_info->pt, fmt->ptr); 
    372372 
     
    400400        if (codec_param.setting.dec_fmtp_mode != 0) { 
    401401            const pj_str_t fmtp = { "fmtp", 4 }; 
    402             attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr)); 
     402            attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr); 
    403403 
    404404            attr->name = fmtp; 
    405             attr->value.ptr = pj_pool_alloc(pool, 32); 
     405            attr->value.ptr = (char*) pj_pool_alloc(pool, 32); 
    406406            attr->value.slen =  
    407407                pj_ansi_snprintf( attr->value.ptr, 32, 
     
    414414 
    415415    /* Add sendrecv attribute. */ 
    416     attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr)); 
     416    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr); 
    417417    attr->name = STR_SENDRECV; 
    418418    m->attr[m->attr_count++] = attr; 
     
    428428 
    429429    /* Add rtpmap. */ 
    430     attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr)); 
     430    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr); 
    431431    attr->name = pj_str("rtpmap"); 
    432432    attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR  
     
    435435 
    436436    /* Add fmtp */ 
    437     attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr)); 
     437    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr); 
    438438    attr->name = pj_str("fmtp"); 
    439439    attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR " 0-15"); 
  • pjproject/trunk/pjmedia/src/pjmedia/g711.c

    r1242 r1266  
    320320        struct g711_private *codec_priv; 
    321321 
    322         codec = pj_pool_alloc(g711_factory.pool, sizeof(pjmedia_codec)); 
    323         codec_priv = pj_pool_zalloc(g711_factory.pool,  
    324                                     sizeof(struct g711_private)); 
     322        codec = PJ_POOL_ALLOC_T(g711_factory.pool, pjmedia_codec); 
     323        codec_priv = PJ_POOL_ZALLOC_T(g711_factory.pool, struct g711_private); 
    325324        if (!codec || !codec_priv) { 
    326325            pj_mutex_unlock(g711_factory.mutex); 
     
    372371                                      pjmedia_codec *codec ) 
    373372{ 
    374     struct g711_private *priv = codec->codec_data; 
     373    struct g711_private *priv = (struct g711_private*) codec->codec_data; 
    375374    int i = 0; 
    376375 
     
    421420                             pjmedia_codec_param *attr ) 
    422421{ 
    423     struct g711_private *priv = codec->codec_data; 
     422    struct g711_private *priv = (struct g711_private*) codec->codec_data; 
    424423    priv->pt = attr->info.pt; 
    425424#if !PLC_DISABLED 
     
    440439                                const pjmedia_codec_param *attr ) 
    441440{ 
    442     struct g711_private *priv = codec->codec_data; 
     441    struct g711_private *priv = (struct g711_private*) codec->codec_data; 
    443442 
    444443    if (attr->info.pt != priv->pt) 
     
    488487{ 
    489488    pj_int16_t *samples = (pj_int16_t*) input->buf; 
    490     struct g711_private *priv = codec->codec_data; 
     489    struct g711_private *priv = (struct g711_private*) codec->codec_data; 
    491490 
    492491    /* Check output buffer length */ 
     
    502501                                             &input->timestamp); 
    503502 
    504         is_silence = pjmedia_silence_det_detect(priv->vad, input->buf,  
     503        is_silence = pjmedia_silence_det_detect(priv->vad,  
     504                                                (const pj_int16_t*) input->buf,  
    505505                                                (input->size >> 1), NULL); 
    506506        if (is_silence &&  
     
    521521    if (priv->pt == PJMEDIA_RTP_PT_PCMA) { 
    522522        unsigned i, n; 
    523         pj_uint8_t *dst = output->buf; 
     523        pj_uint8_t *dst = (pj_uint8_t*) output->buf; 
    524524 
    525525        n = (input->size >> 1); 
     
    529529    } else if (priv->pt == PJMEDIA_RTP_PT_PCMU) { 
    530530        unsigned i, n; 
    531         pj_uint8_t *dst = output->buf; 
     531        pj_uint8_t *dst = (pj_uint8_t*) output->buf; 
    532532 
    533533        n = (input->size >> 1); 
     
    551551                                struct pjmedia_frame *output) 
    552552{ 
    553     struct g711_private *priv = codec->codec_data; 
     553    struct g711_private *priv = (struct g711_private*) codec->codec_data; 
    554554 
    555555    /* Check output buffer length */ 
     
    564564    if (priv->pt == PJMEDIA_RTP_PT_PCMA) { 
    565565        unsigned i; 
    566         pj_uint8_t *src = input->buf; 
    567         pj_uint16_t *dst = output->buf; 
     566        pj_uint8_t *src = (pj_uint8_t*) input->buf; 
     567        pj_uint16_t *dst = (pj_uint16_t*) output->buf; 
    568568 
    569569        for (i=0; i!=input->size; ++i) { 
     
    572572    } else if (priv->pt == PJMEDIA_RTP_PT_PCMU) { 
    573573        unsigned i; 
    574         pj_uint8_t *src = input->buf; 
    575         pj_uint16_t *dst = output->buf; 
     574        pj_uint8_t *src = (pj_uint8_t*) input->buf; 
     575        pj_uint16_t *dst = (pj_uint16_t*) output->buf; 
    576576 
    577577        for (i=0; i!=input->size; ++i) { 
  • pjproject/trunk/pjmedia/src/pjmedia/jbuf.c

    r974 r1266  
    3131 
    3232 
    33 struct jb_framelist 
     33typedef struct jb_framelist_t 
    3434{ 
    3535    char        *flist_buffer; 
     
    4141    unsigned     flist_tail; 
    4242    unsigned     flist_origin; 
    43 }; 
    44  
    45  
    46 typedef struct jb_framelist jb_framelist; 
     43} jb_framelist_t; 
     44 
    4745 
    4846struct pjmedia_jbuf 
    4947{ 
    5048    pj_str_t        name;                 // jitter buffer name 
    51     jb_framelist    jb_framelist; 
     49    jb_framelist_t  jb_framelist; 
    5250    pj_size_t       jb_frame_size;        // frame size  
    5351    unsigned        jb_frame_ptime;       // frame duration. 
     
    9391 
    9492static pj_status_t jb_framelist_init( pj_pool_t *pool, 
    95                                       jb_framelist *framelist, 
     93                                      jb_framelist_t *framelist, 
    9694                                      unsigned frame_size, 
    9795                                      unsigned max_count)  
     
    9997    PJ_ASSERT_RETURN(pool && framelist, PJ_EINVAL); 
    10098 
    101     pj_bzero(framelist, sizeof(jb_framelist)); 
     99    pj_bzero(framelist, sizeof(jb_framelist_t)); 
    102100 
    103101    framelist->flist_frame_size = frame_size; 
    104102    framelist->flist_max_count = max_count; 
    105     framelist->flist_buffer = pj_pool_zalloc(pool, 
     103    framelist->flist_buffer = (char*)  
     104                              pj_pool_zalloc(pool, 
    106105                                             framelist->flist_frame_size *  
    107106                                             framelist->flist_max_count); 
    108107 
    109     framelist->flist_frame_type =  
     108    framelist->flist_frame_type = (int*) 
    110109        pj_pool_zalloc(pool, sizeof(framelist->flist_frame_type[0]) *  
    111110                                framelist->flist_max_count); 
     
    117116} 
    118117 
    119 static pj_status_t jb_framelist_destroy(jb_framelist *framelist)  
     118static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist)  
    120119{ 
    121120    PJ_UNUSED_ARG(framelist); 
     
    124123 
    125124 
    126 static unsigned jb_framelist_size(jb_framelist *framelist)  
     125static unsigned jb_framelist_size(jb_framelist_t *framelist)  
    127126{ 
    128127    if (framelist->flist_tail == framelist->flist_head) { 
     
    135134 
    136135 
    137 static pj_bool_t jb_framelist_get(jb_framelist *framelist, 
     136static pj_bool_t jb_framelist_get(jb_framelist_t *framelist, 
    138137                                  void *frame, 
    139138                                  pjmedia_jb_frame_type *p_type)  
     
    168167 
    169168 
    170 static void jb_framelist_remove_head( jb_framelist *framelist, 
     169static void jb_framelist_remove_head( jb_framelist_t *framelist, 
    171170                                      unsigned count)  
    172171{ 
     
    215214 
    216215 
    217 static pj_bool_t jb_framelist_put_at(jb_framelist *framelist, 
     216static pj_bool_t jb_framelist_put_at(jb_framelist_t *framelist, 
    218217                                     unsigned index, 
    219218                                     const void *frame, 
     
    283282    pj_status_t status; 
    284283 
    285     jb = pj_pool_zalloc(pool, sizeof(pjmedia_jbuf)); 
     284    jb = PJ_POOL_ZALLOC_T(pool, pjmedia_jbuf); 
    286285 
    287286    status = jb_framelist_init(pool, &jb->jb_framelist, frame_size, max_count); 
  • pjproject/trunk/pjmedia/src/pjmedia/master_port.c

    r974 r1266  
    8585 
    8686    /* Create the master port instance */ 
    87     m = pj_pool_zalloc(pool, sizeof(pjmedia_master_port)); 
     87    m = PJ_POOL_ZALLOC_T(pool, pjmedia_master_port); 
    8888    m->options = options; 
    8989    m->u_port = u_port; 
     
    145145static void clock_callback(const pj_timestamp *ts, void *user_data) 
    146146{ 
    147     pjmedia_master_port *m = user_data; 
     147    pjmedia_master_port *m = (pjmedia_master_port*) user_data; 
    148148    pjmedia_frame frame; 
    149149    pj_status_t status; 
  • pjproject/trunk/pjmedia/src/pjmedia/mem_capture.c

    r974 r1266  
    7474 
    7575 
    76     rec = pj_pool_zalloc(pool, sizeof(struct mem_rec)); 
     76    rec = PJ_POOL_ZALLOC_T(pool, struct mem_rec); 
    7777    PJ_ASSERT_RETURN(rec != NULL, PJ_ENOMEM); 
    7878 
  • pjproject/trunk/pjmedia/src/pjmedia/mem_player.c

    r974 r1266  
    7676 
    7777 
    78     port = pj_pool_zalloc(pool, sizeof(struct mem_player)); 
     78    port = PJ_POOL_ZALLOC_T(pool, struct mem_player); 
    7979    PJ_ASSERT_RETURN(port != NULL, PJ_ENOMEM); 
    8080 
  • pjproject/trunk/pjmedia/src/pjmedia/null_port.c

    r974 r1266  
    4545    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL); 
    4646 
    47     port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); 
     47    port = PJ_POOL_ZALLOC_T(pool, pjmedia_port); 
    4848    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); 
    4949 
     
    8484    frame->size = this_port->info.samples_per_frame * 2; 
    8585    frame->timestamp.u32.lo += this_port->info.samples_per_frame; 
    86     pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame); 
     86    pjmedia_zero_samples((pj_int16_t*)frame->buf,  
     87                         this_port->info.samples_per_frame); 
    8788 
    8889    return PJ_SUCCESS; 
  • pjproject/trunk/pjmedia/src/pjmedia/pasound.c

    r1247 r1266  
    8585                              void *userData ) 
    8686{ 
    87     pjmedia_snd_stream *stream = userData; 
     87    pjmedia_snd_stream *stream = (pjmedia_snd_stream*) userData; 
    8888    pj_status_t status; 
    8989 
     
    131131                             void *userData ) 
    132132{ 
    133     pjmedia_snd_stream *stream = userData; 
     133    pjmedia_snd_stream *stream = (pjmedia_snd_stream*) userData; 
    134134    pj_status_t status; 
    135135    unsigned size = frameCount * stream->bytes_per_sample * 
     
    389389        return PJ_ENOMEM; 
    390390 
    391     stream = pj_pool_zalloc(pool, sizeof(*stream)); 
     391    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream); 
    392392    stream->pool = pool; 
    393393    pj_strdup2_with_null(pool, &stream->name, paDevInfo->name); 
     
    485485        return PJ_ENOMEM; 
    486486 
    487     stream = pj_pool_calloc(pool, 1, sizeof(*stream)); 
     487    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream); 
    488488    stream->pool = pool; 
    489489    pj_strdup2_with_null(pool, &stream->name, paDevInfo->name); 
     
    605605        return PJ_ENOMEM; 
    606606 
    607     stream = pj_pool_zalloc(pool, sizeof(*stream)); 
     607    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream); 
    608608    stream->pool = pool; 
    609609    pj_strdup2_with_null(pool, &stream->name, paRecDevInfo->name); 
  • pjproject/trunk/pjmedia/src/pjmedia/plc_common.c

    r974 r1266  
    8787    PJ_UNUSED_ARG(options); 
    8888 
    89     plc = pj_pool_zalloc(pool, sizeof(pjmedia_plc)); 
     89    plc = PJ_POOL_ZALLOC_T(pool, pjmedia_plc); 
    9090 
    9191    if (0) 
     
    151151    PJ_UNUSED_ARG(clock_rate); 
    152152 
    153     o = pj_pool_alloc(pool, sizeof(struct replay_plc)); 
     153    o = PJ_POOL_ALLOC_T(pool, struct replay_plc); 
    154154    o->size = samples_per_frame * 2; 
    155155    o->replay_cnt = 0; 
    156     o->frame = pj_pool_zalloc(pool, o->size); 
     156    o->frame = (pj_int16_t*) pj_pool_zalloc(pool, o->size); 
    157157 
    158158    return o; 
     
    161161static void plc_replay_save(void *plc, pj_int16_t *frame) 
    162162{ 
    163     struct replay_plc *o = plc; 
     163    struct replay_plc *o = (struct replay_plc*) plc; 
    164164 
    165165    pj_memcpy(o->frame, frame, o->size); 
     
    169169static void plc_replay_generate(void *plc, pj_int16_t *frame) 
    170170{ 
    171     struct replay_plc *o = plc; 
     171    struct replay_plc *o = (struct replay_plc*) plc; 
    172172    unsigned i, count; 
    173173    pj_int16_t *samp; 
  • pjproject/trunk/pjmedia/src/pjmedia/resample_port.c

    r1171 r1266  
    7070     
    7171    /* Create and initialize port. */ 
    72     rport = pj_pool_zalloc(pool, sizeof(struct resample_port)); 
     72    rport = PJ_POOL_ZALLOC_T(pool, struct resample_port); 
    7373    PJ_ASSERT_RETURN(rport != NULL, PJ_ENOMEM); 
    7474 
     
    8585     * both functions may run simultaneously. 
    8686     */ 
    87     rport->get_buf = pj_pool_alloc(pool, dn_port->info.bytes_per_frame); 
     87    rport->get_buf = (pj_int16_t*) 
     88                     pj_pool_alloc(pool, dn_port->info.bytes_per_frame); 
    8889    PJ_ASSERT_RETURN(rport->get_buf != NULL, PJ_ENOMEM); 
    8990 
    90     rport->put_buf = pj_pool_alloc(pool, dn_port->info.bytes_per_frame); 
     91    rport->put_buf = (pj_int16_t*) 
     92                     pj_pool_alloc(pool, dn_port->info.bytes_per_frame); 
    9193    PJ_ASSERT_RETURN(rport->put_buf != NULL, PJ_ENOMEM); 
    9294 
     
    140142 
    141143    if (frame->type == PJMEDIA_FRAME_TYPE_AUDIO) { 
    142         pjmedia_resample_run( rport->resample_put, frame->buf,  
     144        pjmedia_resample_run( rport->resample_put,  
     145                              (const pj_int16_t*) frame->buf,  
    143146                              rport->put_buf); 
    144147 
     
    189192    } 
    190193 
    191     pjmedia_resample_run( rport->resample_get, tmp_frame.buf, frame->buf); 
     194    pjmedia_resample_run( rport->resample_get,  
     195                          (const pj_int16_t*) tmp_frame.buf,  
     196                          (pj_int16_t*) frame->buf); 
    192197 
    193198    frame->size = rport->base.info.bytes_per_frame; 
  • pjproject/trunk/pjmedia/src/pjmedia/resample_resample.c

    r1242 r1266  
    5959                     rate_out && samples_per_frame, PJ_EINVAL); 
    6060 
    61     resample = pj_pool_alloc(pool, sizeof(pjmedia_resample)); 
     61    resample = PJ_POOL_ALLOC_T(pool, pjmedia_resample); 
    6262    PJ_ASSERT_RETURN(resample, PJ_ENOMEM); 
    6363 
     
    8989 
    9090        size = (samples_per_frame + 2*resample->xoff) * sizeof(pj_int16_t); 
    91         resample->buffer = pj_pool_alloc(pool, size); 
     91        resample->buffer = (pj_int16_t*) pj_pool_alloc(pool, size); 
    9292        PJ_ASSERT_RETURN(resample->buffer, PJ_ENOMEM); 
    9393 
  • pjproject/trunk/pjmedia/src/pjmedia/rtcp.c

    r974 r1266  
    141141 
    142142    /* Name */ 
    143     sess->name = name ? name : THIS_FILE, 
     143    sess->name = name ? name : (char*)THIS_FILE, 
    144144 
    145145    /* Set clock rate */ 
     
    333333                                   pj_size_t size) 
    334334{ 
    335     const pjmedia_rtcp_common *common = pkt; 
     335    pjmedia_rtcp_common *common = (pjmedia_rtcp_common*) pkt; 
    336336    const pjmedia_rtcp_rr *rr = NULL; 
    337337    const pjmedia_rtcp_sr *sr = NULL; 
  • pjproject/trunk/pjmedia/src/pjmedia/sdp.c

    r1240 r1266  
    461461                           rtpmap->param.ptr); 
    462462 
    463     if (len < 1 || len > sizeof(tempbuf)) 
     463    if (len < 1 || len > (int)sizeof(tempbuf)) 
    464464        return PJMEDIA_SDP_ERTPMAPTOOLONG; 
    465465 
  • pjproject/trunk/pjmedia/src/pjmedia/sdp_neg.c

    r1240 r1266  
    5757PJ_DEF(const char*) pjmedia_sdp_neg_state_str(pjmedia_sdp_neg_state state) 
    5858{ 
    59     if (state >=0 && state < PJ_ARRAY_SIZE(state_str)) 
     59    if (state >=0 && state < (pjmedia_sdp_neg_state)PJ_ARRAY_SIZE(state_str)) 
    6060        return state_str[state]; 
    6161 
  • pjproject/trunk/pjmedia/src/pjmedia/session.c

    r1109 r1266  
    422422   
    423423    /* Now that we have codec info, get the codec param. */ 
    424     si->param = pj_pool_alloc(pool, sizeof(*si->param)); 
     424    si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param); 
    425425    status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt, si->param); 
    426426    if (status != PJ_SUCCESS) 
     
    533533    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); 
    534534 
    535     session = pj_pool_zalloc(pool, sizeof(pjmedia_session)); 
     535    session = PJ_POOL_ZALLOC_T(pool, pjmedia_session); 
    536536    session->pool = pool; 
    537537    session->endpt = endpt; 
  • pjproject/trunk/pjmedia/src/pjmedia/silencedet.c

    r974 r1266  
    6969    PJ_ASSERT_RETURN(pool && p_sd, PJ_EINVAL); 
    7070 
    71     sd = pj_pool_zalloc(pool, sizeof(struct pjmedia_silence_det)); 
     71    sd = PJ_POOL_ZALLOC_T(pool, pjmedia_silence_det); 
    7272 
    7373    pj_ansi_strncpy(sd->objname, THIS_FILE, PJ_MAX_OBJ_NAME); 
  • pjproject/trunk/pjmedia/src/pjmedia/sound_port.c

    r1202 r1266  
    7474                           /* out */  unsigned size) 
    7575{ 
    76     pjmedia_snd_port *snd_port = user_data; 
     76    pjmedia_snd_port *snd_port = (pjmedia_snd_port*) user_data; 
    7777    pjmedia_port *port; 
    7878    pjmedia_frame frame; 
     
    112112 
    113113    if (snd_port->plc) 
    114         pjmedia_plc_save(snd_port->plc, output); 
     114        pjmedia_plc_save(snd_port->plc, (pj_int16_t*) output); 
    115115 
    116116    if (snd_port->ec_state) { 
     
    121121        } 
    122122        snd_port->ec_suspend_count = 0; 
    123         pjmedia_echo_playback(snd_port->ec_state, output); 
     123        pjmedia_echo_playback(snd_port->ec_state, (pj_int16_t*)output); 
    124124    } 
    125125 
     
    137137        if (snd_port->ec_state) { 
    138138            /* To maintain correct delay in EC */ 
    139             pjmedia_echo_playback(snd_port->ec_state, output); 
     139            pjmedia_echo_playback(snd_port->ec_state, (pj_int16_t*)output); 
    140140        } 
    141141    } 
     
    144144    if (snd_port->plc) { 
    145145 
    146         pjmedia_plc_generate(snd_port->plc, output); 
     146        pjmedia_plc_generate(snd_port->plc, (pj_int16_t*) output); 
    147147#ifdef SIMULATE_LOST_PCT 
    148148        PJ_LOG(4,(THIS_FILE, "Lost frame generated")); 
     
    166166                          /* in*/    unsigned size) 
    167167{ 
    168     pjmedia_snd_port *snd_port = user_data; 
     168    pjmedia_snd_port *snd_port = (pjmedia_snd_port*) user_data; 
    169169    pjmedia_port *port; 
    170170    pjmedia_frame frame; 
     
    182182    /* Cancel echo */ 
    183183    if (snd_port->ec_state && !snd_port->ec_suspended) { 
    184         pjmedia_echo_capture(snd_port->ec_state, input, 0); 
     184        pjmedia_echo_capture(snd_port->ec_state, (pj_int16_t*) input, 0); 
    185185    } 
    186186 
     
    327327    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL); 
    328328 
    329     snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port)); 
     329    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port); 
    330330    PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM); 
    331331 
     
    366366    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL); 
    367367 
    368     snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port)); 
     368    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port); 
    369369    PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM); 
    370370 
     
    403403    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL); 
    404404 
    405     snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port)); 
     405    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port); 
    406406    PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM); 
    407407 
  • pjproject/trunk/pjmedia/src/pjmedia/splitcomb.c

    r974 r1266  
    5959        pjmedia_port *port; 
    6060        pj_bool_t     reversed; 
    61     } *port_desc; 
     61    } port_desc[64]; 
    6262 
    6363    /* Temporary buffers needed to extract mono frame from 
     
    144144 
    145145    /* Create the splitter/combiner structure */ 
    146     sc = pj_pool_zalloc(pool, sizeof(struct splitcomb)); 
     146    sc = PJ_POOL_ZALLOC_T(pool, struct splitcomb); 
    147147    PJ_ASSERT_RETURN(sc != NULL, PJ_ENOMEM); 
    148148 
    149149    /* Create temporary buffers */ 
    150     sc->get_buf = pj_pool_alloc(pool, samples_per_frame *  
     150    sc->get_buf = (TMP_SAMP_TYPE*) 
     151                  pj_pool_alloc(pool, samples_per_frame *  
    151152                                      sizeof(TMP_SAMP_TYPE) / 
    152153                                      channel_count); 
    153154    PJ_ASSERT_RETURN(sc->get_buf, PJ_ENOMEM); 
    154155 
    155     sc->put_buf = pj_pool_alloc(pool, samples_per_frame *  
     156    sc->put_buf = (TMP_SAMP_TYPE*) 
     157                  pj_pool_alloc(pool, samples_per_frame *  
    156158                                      sizeof(TMP_SAMP_TYPE) / 
    157159                                      channel_count); 
     
    171173 
    172174    /* Init ports array */ 
     175    /* 
    173176    sc->port_desc = pj_pool_zalloc(pool, channel_count*sizeof(*sc->port_desc)); 
     177    */ 
     178    pj_bzero(sc->port_desc, sizeof(sc->port_desc)); 
    174179 
    175180    /* Done for now */ 
     
    238243 
    239244    /* Create the port */ 
    240     rport = pj_pool_zalloc(pool, sizeof(struct reverse_port)); 
     245    rport = PJ_POOL_ZALLOC_T(pool, struct reverse_port); 
    241246    rport->parent = sc; 
    242247    rport->ch_num = ch_num; 
     
    262267    /* Create put buffers */ 
    263268    for (i=0; i<rport->buf_cnt; ++i) { 
    264         rport->dnstream_buf[i] = pj_pool_zalloc(pool, port->info.bytes_per_frame); 
     269        rport->dnstream_buf[i]=(pj_int16_t*) 
     270                               pj_pool_zalloc(pool, port->info.bytes_per_frame); 
    265271        PJ_ASSERT_RETURN(rport->dnstream_buf[i], PJ_ENOMEM); 
    266272    } 
     
    269275    /* Create get buffers */ 
    270276    for (i=0; i<rport->buf_cnt; ++i) { 
    271         rport->upstream_buf[i] = pj_pool_zalloc(pool,  
     277        rport->upstream_buf[i] = (pj_int16_t*) 
     278                                 pj_pool_zalloc(pool,  
    272279                                                port->info.bytes_per_frame); 
    273280        PJ_ASSERT_RETURN(rport->upstream_buf[i], PJ_ENOMEM); 
     
    367374 
    368375            /* Extract the mono frame */ 
    369             extract_mono_frame(frame->buf, sc->put_buf, ch,  
     376            extract_mono_frame((const pj_int16_t*)frame->buf, sc->put_buf, ch,  
    370377                               this_port->info.channel_count,  
    371378                               frame->size * 8 /  
     
    405412 
    406413            /* Extract mono-frame and put it in downstream buffer */ 
    407             extract_mono_frame(frame->buf,  
     414            extract_mono_frame((const pj_int16_t*)frame->buf,  
    408415                               rport->dnstream_buf[rport->dn_write_pos], 
    409416                               ch, this_port->info.channel_count,  
     
    434441 
    435442    /* Clear output frame */ 
    436     pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame); 
     443    pjmedia_zero_samples((pj_int16_t*)frame->buf,  
     444                         this_port->info.samples_per_frame); 
    437445 
    438446    /* Read frame from each port */ 
     
    460468 
    461469            /* Combine the mono frame into multichannel frame */ 
    462             store_mono_frame(mono_frame.buf, frame->buf, ch, 
     470            store_mono_frame((const pj_int16_t*)mono_frame.buf,  
     471                             (pj_int16_t*)frame->buf, ch, 
    463472                             this_port->info.channel_count, 
    464473                             mono_frame.size * 8 / 
     
    495504 
    496505            /* Combine the mono frame into multichannel frame */ 
    497             store_mono_frame(rport->upstream_buf[rport->up_read_pos],  
    498                              frame->buf, ch, 
     506            store_mono_frame((const pj_int16_t*)rport->upstream_buf[rport->up_read_pos],  
     507                             (pj_int16_t*)frame->buf, ch, 
    499508                             this_port->info.channel_count, 
    500509                             port->info.samples_per_frame); 
     
    580589 
    581590    pjmedia_copy_samples(rport->upstream_buf[rport->up_write_pos], 
    582                          frame->buf, count); 
     591                         (const pj_int16_t*) frame->buf, count); 
    583592    rport->up_write_pos = (rport->up_write_pos+1) % rport->buf_cnt; 
    584593 
     
    622631 
    623632    /* Get the samples from the circular buffer */ 
    624     pjmedia_copy_samples(frame->buf,  
     633    pjmedia_copy_samples((pj_int16_t*)frame->buf,  
    625634                         rport->dnstream_buf[rport->dn_read_pos], 
    626635                         count); 
  • pjproject/trunk/pjmedia/src/pjmedia/stream.c

    r1048 r1266  
    167167static pj_status_t get_frame( pjmedia_port *port, pjmedia_frame *frame) 
    168168{ 
    169     pjmedia_stream *stream = port->port_data.pdata; 
     169    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    170170    pjmedia_channel *channel = stream->dec; 
    171171    unsigned samples_count, samples_per_frame, samples_required; 
     
    192192                        stream->codec_param.info.channel_cnt /  
    193193                        1000; 
    194     p_out_samp = frame->buf; 
     194    p_out_samp = (pj_int16_t*) frame->buf; 
    195195 
    196196    for (samples_count=0; samples_count < samples_required;  
     
    383383    pj_assert(sizeof(pjmedia_rtp_dtmf_event) == 4); 
    384384 
    385     event = frame_out->buf; 
     385    event = (pjmedia_rtp_dtmf_event*) frame_out->buf; 
    386386    cur_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts); 
    387387    duration = cur_ts - digit->start_ts; 
     
    515515                                  const pjmedia_frame *frame ) 
    516516{ 
    517     pjmedia_stream *stream = port->port_data.pdata; 
     517    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    518518    pjmedia_channel *channel = stream->enc; 
    519519    pj_status_t status = 0; 
     
    666666    /* Set RTP marker bit if currently not streaming */ 
    667667    if (stream->is_streaming == PJ_FALSE) { 
    668         pjmedia_rtp_hdr *rtp = channel->out_pkt; 
     668        pjmedia_rtp_hdr *rtp = (pjmedia_rtp_hdr*) channel->out_pkt; 
    669669 
    670670        rtp->m = 1; 
     
    698698                              const pjmedia_frame *frame ) 
    699699{ 
    700     pjmedia_stream *stream = port->port_data.pdata; 
     700    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    701701    pjmedia_frame tmp_zero_frame; 
    702702    unsigned samples_per_frame; 
     
    831831                                  const void *payload, unsigned payloadlen) 
    832832{ 
    833     const pjmedia_rtp_dtmf_event *event = payload; 
     833    pjmedia_rtp_dtmf_event *event = (pjmedia_rtp_dtmf_event*) payload; 
    834834 
    835835    /* Check compiler packing. */ 
     
    903903 
    904904{ 
    905     pjmedia_stream *stream = data; 
     905    pjmedia_stream *stream = (pjmedia_stream*) data; 
    906906    pjmedia_channel *channel = stream->dec; 
    907907    const pjmedia_rtp_hdr *hdr; 
     
    919919 
    920920    /* Ignore keep-alive packets */ 
    921     if (bytes_read < sizeof(pjmedia_rtp_hdr)) 
     921    if (bytes_read < (pj_ssize_t) sizeof(pjmedia_rtp_hdr)) 
    922922        return; 
    923923 
     
    10531053                        pj_ssize_t bytes_read) 
    10541054{ 
    1055     pjmedia_stream *stream = data; 
     1055    pjmedia_stream *stream = (pjmedia_stream*) data; 
    10561056 
    10571057    /* Check for errors */ 
     
    10811081    /* Allocate memory for channel descriptor */ 
    10821082 
    1083     channel = pj_pool_zalloc(pool, sizeof(pjmedia_channel)); 
     1083    channel = PJ_POOL_ZALLOC_T(pool, pjmedia_channel); 
    10841084    PJ_ASSERT_RETURN(channel != NULL, PJ_ENOMEM); 
    10851085 
     
    11471147    /* Allocate the media stream: */ 
    11481148 
    1149     stream = pj_pool_zalloc(pool, sizeof(pjmedia_stream)); 
     1149    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_stream); 
    11501150    PJ_ASSERT_RETURN(stream != NULL, PJ_ENOMEM); 
    11511151 
    11521152    /* Init stream/port name */ 
    1153     name.ptr = pj_pool_alloc(pool, M); 
     1153    name.ptr = (char*) pj_pool_alloc(pool, M); 
    11541154    name.slen = pj_ansi_snprintf(name.ptr, M, "strm%p", stream); 
    11551155 
     
    12631263        /* Allocate buffer */ 
    12641264        stream->enc_buf_size = stream->port.info.clock_rate * ptime / 1000; 
    1265         stream->enc_buf = pj_pool_alloc(pool, stream->enc_buf_size * 2); 
     1265        stream->enc_buf = (pj_int16_t*) 
     1266                          pj_pool_alloc(pool, stream->enc_buf_size * 2); 
    12661267 
    12671268    } else { 
     
    15361537     
    15371538    if (stream->tx_dtmf_count+digit_char->slen >= 
    1538         PJ_ARRAY_SIZE(stream->tx_dtmf_buf)) 
     1539        (long)PJ_ARRAY_SIZE(stream->tx_dtmf_buf)) 
    15391540    { 
    15401541        status = PJ_ETOOMANY; 
  • pjproject/trunk/pjmedia/src/pjmedia/tonegen.c

    r1009 r1266  
    306306 
    307307    /* Create and initialize port */ 
    308     tonegen = pj_pool_zalloc(pool, sizeof(struct tonegen)); 
     308    tonegen = PJ_POOL_ZALLOC_T(pool, struct tonegen); 
    309309    if (name == NULL || name->slen == 0) name = &STR_TONE_GEN; 
    310310    status = pjmedia_port_info_init(&tonegen->base.info, name,  
     
    422422    } 
    423423     
    424     dst = frame->buf; 
     424    dst = (short*) frame->buf; 
    425425    end = dst + port->info.samples_per_frame; 
    426426 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_ice.c

    r1162 r1266  
    250250    unsigned i, cand_cnt; 
    251251 
    252     buffer = pj_pool_alloc(pool, MAXLEN); 
     252    buffer = (char*) pj_pool_alloc(pool, MAXLEN); 
    253253 
    254254    /* Create ice-ufrag attribute */ 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_udp.c

    r1248 r1266  
    235235        return PJ_ENOMEM; 
    236236 
    237     tp = pj_pool_zalloc(pool, sizeof(struct transport_udp)); 
     237    tp = PJ_POOL_ZALLOC_T(pool, struct transport_udp); 
    238238    tp->pool = pool; 
    239239    tp->options = options; 
     
    379379    PJ_UNUSED_ARG(op_key); 
    380380 
    381     udp = pj_ioqueue_get_user_data(key); 
     381    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key); 
    382382 
    383383    do { 
     
    480480    PJ_UNUSED_ARG(op_key); 
    481481 
    482     udp = pj_ioqueue_get_user_data(key); 
     482    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key); 
    483483 
    484484    do { 
     
    568568 
    569569    /* Copy remote RTP address, if one is specified. */ 
    570     rtcp_addr = rem_rtcp; 
     570    rtcp_addr = (const pj_sockaddr_in*) rem_rtcp; 
    571571    if (rtcp_addr && rtcp_addr->sin_addr.s_addr != 0) { 
    572572        pj_memcpy(&udp->rem_rtcp_addr, rem_rtcp, sizeof(pj_sockaddr_in)); 
  • pjproject/trunk/pjmedia/src/pjmedia/wav_player.c

    r974 r1266  
    8080    struct file_port *port; 
    8181 
    82     port = pj_pool_zalloc(pool, sizeof(struct file_port)); 
     82    port = PJ_POOL_ZALLOC_T(pool, struct file_port); 
    8383    if (!port) 
    8484        return NULL; 
     
    350350 
    351351    /* Create buffer. */ 
    352     fport->buf = pj_pool_alloc(pool, fport->bufsize); 
     352    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize); 
    353353    if (!fport->buf) { 
    354354        pj_file_close(fport->fd); 
  • pjproject/trunk/pjmedia/src/pjmedia/wav_playlist.c

    r919 r1266  
    8585    struct playlist_port *port; 
    8686 
    87     port = pj_pool_zalloc(pool, sizeof(struct playlist_port)); 
     87    port = PJ_POOL_ZALLOC_T(pool, struct playlist_port); 
    8888    if (!port) 
    8989        return NULL; 
     
    276276 
    277277    /* Create file descriptor list */ 
    278     fport->fd_list = pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count); 
     278    fport->fd_list = (pj_oshandle_t*) 
     279                     pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count); 
    279280    if (!fport->fd_list) { 
    280281        return PJ_ENOMEM; 
     
    282283 
    283284    /* Create file size list */ 
    284     fport->fsize_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); 
     285    fport->fsize_list = (pj_off_t*) 
     286                        pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); 
    285287    if (!fport->fsize_list) { 
    286288        return PJ_ENOMEM; 
     
    288290 
    289291    /* Create start of WAVE data list */ 
    290     fport->start_data_list = pj_pool_alloc(pool, sizeof(unsigned)*file_count); 
     292    fport->start_data_list = (unsigned*) 
     293                             pj_pool_alloc(pool, sizeof(unsigned)*file_count); 
    291294    if (!fport->start_data_list) { 
    292295        return PJ_ENOMEM; 
     
    294297 
    295298    /* Create file position list */ 
    296     fport->fpos_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); 
     299    fport->fpos_list = (pj_off_t*) 
     300                       pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); 
    297301    if (!fport->fpos_list) { 
    298302        return PJ_ENOMEM; 
     
    306310 
    307311    /* Create buffer. */ 
    308     fport->buf = pj_pool_alloc(pool, fport->bufsize); 
     312    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize); 
    309313    if (!fport->buf) { 
    310314        return PJ_ENOMEM; 
  • pjproject/trunk/pjmedia/src/pjmedia/wav_writer.c

    r974 r1266  
    8484 
    8585    /* Create file port instance. */ 
    86     fport = pj_pool_zalloc(pool, sizeof(struct file_port)); 
     86    fport = PJ_POOL_ZALLOC_T(pool, struct file_port); 
    8787    PJ_ASSERT_RETURN(fport != NULL, PJ_ENOMEM); 
    8888 
     
    150150 
    151151    /* Allocate buffer and set initial write position */ 
    152     fport->buf = pj_pool_alloc(pool, fport->bufsize); 
     152    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize); 
    153153    if (fport->buf == NULL) { 
    154154        pj_file_close(fport->fd); 
  • pjproject/trunk/pjnath/src/pjnath/stun_msg.c

    r1265 r1266  
    1818 */ 
    1919#include <pjnath/stun_msg.h> 
     20#include <pjnath/stun_auth.h> 
    2021#include <pjnath/errno.h> 
    2122#include <pjlib-util/crc32.h> 
  • pjproject/trunk/pjnath/src/pjstun-client/client_main.c

    r1210 r1266  
    2828#define REQ_TRANSPORT   -1                  /* 0: udp, 1: tcp, -1: disable */ 
    2929#define REQ_PORT_PROPS  -1                  /* -1 to disable */ 
    30 #define REQ_IP          NULL                /* IP address string */ 
     30#define REQ_IP          0                   /* IP address string */ 
    3131 
    3232//#define OPTIONS               PJ_STUN_NO_AUTHENTICATE 
     
    355355        } 
    356356 
    357         if (REQ_IP != NULL) { 
     357        if (REQ_IP) { 
    358358            pj_sockaddr_in addr; 
    359359            pj_str_t tmp; 
  • pjproject/trunk/pjnath/src/pjstun-srv-test/server.c

    r1091 r1266  
    8888 
    8989    srv->si.thread_cnt = thread_cnt; 
    90     srv->threads = pj_pool_calloc(pool, thread_cnt, sizeof(pj_thread_t*)); 
     90    srv->threads = (pj_thread_t**) 
     91                   pj_pool_calloc(pool, thread_cnt, sizeof(pj_thread_t*)); 
    9192    for (i=0; i<thread_cnt; ++i) { 
    9293        status = pj_thread_create(pool, "worker%p", &worker_thread, 
  • pjproject/trunk/pjnath/src/pjstun-srv-test/turn_usage.c

    r1091 r1266  
    286286 
    287287    if (client) { 
    288         status = pj_stun_msg_check(pkt, pkt_size, flags); 
     288        status = pj_stun_msg_check((const pj_uint8_t*)pkt, pkt_size, flags); 
    289289 
    290290        if (status == PJ_SUCCESS) { 
     
    13551355    PJ_UNUSED_ARG(op_key); 
    13561356 
    1357     client = pj_ioqueue_get_user_data(key); 
     1357    client = (struct turn_client*) pj_ioqueue_get_user_data(key); 
    13581358     
    13591359    /* Lock client */ 
  • pjproject/trunk/pjnath/src/pjstun-srv-test/usage.c

    r1054 r1266  
    100100 
    101101    usage->worker_cnt = si->thread_cnt; 
    102     usage->worker = pj_pool_calloc(pool, si->thread_cnt,  
    103                                    sizeof(struct worker)); 
     102    usage->worker = (struct worker*) pj_pool_calloc(pool, si->thread_cnt,  
     103                                                    sizeof(struct worker)); 
    104104    for (i=0; i<si->thread_cnt; ++i) { 
    105105        pj_ioqueue_op_key_init(&usage->worker[i].read_key,  
     
    109109 
    110110    usage->send_count = usage->worker_cnt * 2; 
    111     usage->send_key = pj_pool_calloc(pool, usage->send_count,  
     111    usage->send_key = (pj_ioqueue_op_key_t*) 
     112                      pj_pool_calloc(pool, usage->send_count,  
    112113                                     sizeof(pj_ioqueue_op_key_t)); 
    113114    for (i=0; i<usage->send_count; ++i) { 
     
    241242{ 
    242243    enum { MAX_LOOP = 10 }; 
    243     pj_stun_usage *usage = pj_ioqueue_get_user_data(key); 
     244    pj_stun_usage *usage = (pj_stun_usage*) pj_ioqueue_get_user_data(key); 
    244245    struct worker *worker = (struct worker*) op_key; 
    245246    unsigned count; 
  • pjproject/trunk/pjsip/build/Makefile

    r1202 r1266  
    9090                    tsx_uas_test.o txdata_test.o uri_test.o 
    9191export TEST_CFLAGS += $(_CFLAGS) 
    92 export TEST_LDFLAGS += $(PJ_LDFLAGS) $(PJ_LDLIBS) 
     92export TEST_LDFLAGS += $(PJ_LDFLAGS) $(PJ_LDLIBS) $(LDFLAGS) 
    9393export TEST_EXE := ../bin/pjsip-test-$(TARGET_NAME)$(HOST_EXE) 
    9494 
  • pjproject/trunk/pjsip/src/pjsip-simple/presence.c

    r1241 r1266  
    5858 * Presence message body type. 
    5959 */ 
    60 typedef enum content_type 
     60typedef enum content_type_e 
    6161{ 
    6262    CONTENT_TYPE_NONE, 
    6363    CONTENT_TYPE_PIDF, 
    6464    CONTENT_TYPE_XPIDF, 
    65 } content_type; 
     65} content_type_e; 
    6666 
    6767/* 
     
    7272    pjsip_evsub         *sub;           /**< Event subscribtion record.     */ 
    7373    pjsip_dialog        *dlg;           /**< The dialog.                    */ 
    74     content_type         content_type;  /**< Content-Type.                  */ 
     74    content_type_e       content_type;  /**< Content-Type.                  */ 
    7575    pjsip_pres_status    status;        /**< Presence status.               */ 
    7676    pjsip_pres_status    tmp_status;    /**< Temp, before NOTIFY is answred.*/ 
     
    227227    pjsip_expires_hdr *expires_hdr; 
    228228    unsigned expires; 
    229     content_type content_type = CONTENT_TYPE_NONE; 
     229    content_type_e content_type = CONTENT_TYPE_NONE; 
    230230    pjsip_evsub *sub; 
    231231    pjsip_pres *pres; 
  • pjproject/trunk/pjsip/src/pjsip-ua/sip_inv.c

    r1242 r1266  
    230230        return PJ_FALSE; 
    231231 
    232     inv = dlg->mod_data[mod_inv.mod.id]; 
     232    inv = (pjsip_inv_session*) dlg->mod_data[mod_inv.mod.id]; 
    233233 
    234234    /* Report to dialog that we handle INVITE, CANCEL, BYE, ACK.  
     
    412412PJ_DEF(pjsip_inv_session*) pjsip_dlg_get_inv_session(pjsip_dialog *dlg) 
    413413{ 
    414     return dlg->mod_data[mod_inv.mod.id]; 
     414    return (pjsip_inv_session*) dlg->mod_data[mod_inv.mod.id]; 
    415415} 
    416416 
     
    453453 
    454454    /* Create the session */ 
    455     inv = pj_pool_zalloc(dlg->pool, sizeof(pjsip_inv_session)); 
     455    inv = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_inv_session); 
    456456    pj_assert(inv != NULL); 
    457457 
     
    578578 
    579579        /* Parse and validate SDP */ 
    580         status = pjmedia_sdp_parse(rdata->tp_info.pool, body->data, body->len, 
    581                                    &sdp); 
     580        status = pjmedia_sdp_parse(rdata->tp_info.pool,  
     581                                   (char*)body->data, body->len, &sdp); 
    582582        if (status == PJ_SUCCESS) 
    583583            status = pjmedia_sdp_validate(sdp); 
     
    651651     * implicitly by sending this INVITE. 
    652652     */ 
    653     allow = pjsip_msg_find_hdr(msg, PJSIP_H_ALLOW, NULL); 
     653    allow = (pjsip_allow_hdr*) pjsip_msg_find_hdr(msg, PJSIP_H_ALLOW, NULL); 
    654654    if (allow) { 
    655655        unsigned i; 
     
    669669 
    670670    /* Check Supported header */ 
    671     sup_hdr = pjsip_msg_find_hdr(msg, PJSIP_H_SUPPORTED, NULL); 
     671    sup_hdr = (pjsip_supported_hdr*) 
     672              pjsip_msg_find_hdr(msg, PJSIP_H_SUPPORTED, NULL); 
    672673    if (sup_hdr) { 
    673674        unsigned i; 
     
    684685 
    685686    /* Check Require header */ 
    686     req_hdr = pjsip_msg_find_hdr(msg, PJSIP_H_REQUIRE, NULL); 
     687    req_hdr = (pjsip_require_hdr*) 
     688              pjsip_msg_find_hdr(msg, PJSIP_H_REQUIRE, NULL); 
    687689    if (req_hdr) { 
    688690        unsigned i; 
     
    743745                pj_assert(h); 
    744746                if (h) { 
    745                     sup_hdr = pjsip_hdr_clone(rdata->tp_info.pool, h); 
     747                    sup_hdr = (pjsip_supported_hdr*) 
     748                              pjsip_hdr_clone(rdata->tp_info.pool, h); 
    746749                    pj_list_push_back(&res_hdr_list, sup_hdr); 
    747750                } 
     
    783786            pj_assert(h); 
    784787            if (h) { 
    785                 sup_hdr = pjsip_hdr_clone(rdata->tp_info.pool, h); 
     788                sup_hdr = (pjsip_supported_hdr*) 
     789                          pjsip_hdr_clone(rdata->tp_info.pool, h); 
    786790                pj_list_push_back(&res_hdr_list, sup_hdr); 
    787791            } 
     
    815819            pjsip_hdr *cloned; 
    816820 
    817             cloned = pjsip_hdr_clone(tdata->pool, h); 
     821            cloned = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, h); 
    818822            PJ_ASSERT_RETURN(cloned, PJ_ENOMEM); 
    819823 
     
    875879 
    876880    /* Create the session */ 
    877     inv = pj_pool_zalloc(dlg->pool, sizeof(pjsip_inv_session)); 
     881    inv = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_inv_session); 
    878882    pj_assert(inv != NULL); 
    879883 
     
    894898 
    895899        /* Parse and validate SDP */ 
    896         status = pjmedia_sdp_parse(inv->pool, body->data, body->len, 
     900        status = pjmedia_sdp_parse(inv->pool, (char*)body->data, body->len, 
    897901                                   &rem_sdp); 
    898902        if (status == PJ_SUCCESS) 
     
    936940 
    937941    /* Attach our data to the transaction. */ 
    938     tsx_inv_data = pj_pool_zalloc(inv->invite_tsx->pool,  
    939                                   sizeof(struct tsx_inv_data)); 
     942    tsx_inv_data = PJ_POOL_ZALLOC_T(inv->invite_tsx->pool, struct tsx_inv_data); 
    940943    tsx_inv_data->inv = inv; 
    941944    inv->invite_tsx->mod_data[mod_inv.mod.id] = tsx_inv_data; 
     
    9981001{ 
    9991002    PJ_UNUSED_ARG(len); 
    1000     return pjmedia_sdp_session_clone(pool, data); 
     1003    return pjmedia_sdp_session_clone(pool, (const pjmedia_sdp_session*)data); 
    10011004} 
    10021005 
    10031006static int print_sdp(pjsip_msg_body *body, char *buf, pj_size_t len) 
    10041007{ 
    1005     return pjmedia_sdp_print(body->data, buf, len); 
     1008    return pjmedia_sdp_print((const pjmedia_sdp_session*)body->data, buf, len); 
    10061009} 
    10071010 
     
    10151018    pjsip_msg_body *body; 
    10161019 
    1017     body = pj_pool_zalloc(pool, sizeof(pjsip_msg_body)); 
     1020    body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body); 
    10181021    PJ_ASSERT_RETURN(body != NULL, PJ_ENOMEM); 
    10191022 
     
    10831086 
    10841087        while (hdr != &inv->dlg->inv_hdr) { 
    1085             pjsip_msg_add_hdr(tdata->msg, 
     1088            pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    10861089                              pjsip_hdr_shallow_clone(tdata->pool, hdr)); 
    10871090            hdr = hdr->next; 
     
    11181121    hdr = pjsip_endpt_get_capability(inv->dlg->endpt, PJSIP_H_ALLOW, NULL); 
    11191122    if (hdr) { 
    1120         pjsip_msg_add_hdr(tdata->msg, 
     1123        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    11211124                          pjsip_hdr_shallow_clone(tdata->pool, hdr)); 
    11221125    } 
     
    11251128    hdr = pjsip_endpt_get_capability(inv->dlg->endpt, PJSIP_H_SUPPORTED, NULL); 
    11261129    if (hdr) { 
    1127         pjsip_msg_add_hdr(tdata->msg, 
     1130        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    11281131                          pjsip_hdr_shallow_clone(tdata->pool, hdr)); 
    11291132    } 
     
    11781181 
    11791182    /* Get/attach invite session's transaction data */ 
    1180     tsx_inv_data = tsx->mod_data[mod_inv.mod.id]; 
     1183    tsx_inv_data = (struct tsx_inv_data*) tsx->mod_data[mod_inv.mod.id]; 
    11811184    if (tsx_inv_data == NULL) { 
    1182         tsx_inv_data = pj_pool_zalloc(tsx->pool, sizeof(struct tsx_inv_data)); 
     1185        tsx_inv_data = PJ_POOL_ZALLOC_T(tsx->pool, struct tsx_inv_data); 
    11831186        tsx_inv_data->inv = inv; 
    11841187        tsx->mod_data[mod_inv.mod.id] = tsx_inv_data; 
     
    12081211    /* Parse the SDP body. */ 
    12091212 
    1210     status = pjmedia_sdp_parse(rdata->tp_info.pool, msg->body->data, 
     1213    status = pjmedia_sdp_parse(rdata->tp_info.pool,  
     1214                               (char*)msg->body->data, 
    12111215                               msg->body->len, &sdp); 
    12121216    if (status != PJ_SUCCESS) { 
     
    15881592 
    15891593        pj_strdup_with_null(inv->dlg->pool, &tmp, new_contact); 
    1590         contact_hdr = pjsip_parse_hdr(inv->dlg->pool, &STR_CONTACT,  
     1594        contact_hdr = (pjsip_contact_hdr*) 
     1595                      pjsip_parse_hdr(inv->dlg->pool, &STR_CONTACT,  
    15911596                                      tmp.ptr, tmp.slen, NULL); 
    15921597        if (!contact_hdr) { 
     
    16851690        pjsip_dlg_inc_lock(inv->dlg); 
    16861691 
    1687         tsx_inv_data = pj_pool_zalloc(inv->pool, sizeof(struct tsx_inv_data)); 
     1692        tsx_inv_data = PJ_POOL_ZALLOC_T(inv->pool, struct tsx_inv_data); 
    16881693        tsx_inv_data->inv = inv; 
    16891694 
     
    17011706         * request. 
    17021707         */ 
    1703         PJ_ASSERT_RETURN((cseq=pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL))!=NULL 
     1708        PJ_ASSERT_RETURN((cseq=(pjsip_cseq_hdr*)pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL))!=NULL 
    17041709                          && (cseq->cseq == inv->invite_tsx->cseq), 
    17051710                         PJ_EINVALIDOP); 
     
    24162421                                                    NULL); 
    24172422                if (accept) { 
    2418                     pjsip_msg_add_hdr(tdata->msg, 
     2423                    pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) 
    24192424                                      pjsip_hdr_clone(tdata->pool, accept)); 
    24202425                } 
  • pjproject/trunk/pjsip/src/pjsip-ua/sip_reg.c

    r974 r1266  
    104104    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); 
    105105 
    106     regc = pj_pool_zalloc(pool, sizeof(struct pjsip_regc)); 
     106    regc = PJ_POOL_ZALLOC_T(pool, pjsip_regc); 
    107107 
    108108    regc->pool = pool; 
     
    110110    regc->token = token; 
    111111    regc->cb = cb; 
    112     regc->contact_buf = pj_pool_alloc(pool, PJSIP_REGC_CONTACT_BUF_SIZE); 
     112    regc->contact_buf = (char*)pj_pool_alloc(pool, PJSIP_REGC_CONTACT_BUF_SIZE); 
    113113    regc->expires = PJSIP_REGC_EXPIRATION_NOT_SPECIFIED; 
    114114 
     
    387387        const pjsip_route_hdr *route; 
    388388 
    389         route_pos = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     389        route_pos = (pjsip_hdr*) 
     390                    pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    390391        if (!route_pos) 
    391392            route_pos = &tdata->msg->hdr; 
     
    393394        route = regc->route_set.next; 
    394395        while (route != &regc->route_set) { 
    395             pjsip_hdr *new_hdr = pjsip_hdr_shallow_clone(tdata->pool, route); 
     396            pjsip_hdr *new_hdr = (pjsip_hdr*) 
     397                                 pjsip_hdr_shallow_clone(tdata->pool, route); 
    396398            pj_list_insert_after(route_pos, new_hdr); 
    397399            route_pos = new_hdr; 
     
    406408        hdr = regc->hdr_list.next; 
    407409        while (hdr != &regc->hdr_list) { 
    408             pjsip_hdr *new_hdr = pjsip_hdr_shallow_clone(tdata->pool, hdr); 
     410            pjsip_hdr *new_hdr = (pjsip_hdr*) 
     411                                 pjsip_hdr_shallow_clone(tdata->pool, hdr); 
    409412            pjsip_msg_add_hdr(tdata->msg, new_hdr); 
    410413            hdr = hdr->next; 
     
    433436    /* Add Contact header. */ 
    434437    msg = tdata->msg; 
    435     pjsip_msg_add_hdr(msg, pjsip_hdr_shallow_clone(tdata->pool,  
     438    pjsip_msg_add_hdr(msg, (pjsip_hdr*) 
     439                           pjsip_hdr_shallow_clone(tdata->pool,  
    436440                                                   regc->contact_hdr)); 
    437441    if (regc->expires_hdr) 
    438         pjsip_msg_add_hdr(msg, pjsip_hdr_shallow_clone(tdata->pool, 
     442        pjsip_msg_add_hdr(msg, (pjsip_hdr*) 
     443                               pjsip_hdr_shallow_clone(tdata->pool, 
    439444                                                       regc->expires_hdr)); 
    440445 
     
    471476 
    472477    msg = tdata->msg; 
    473     pjsip_msg_add_hdr(msg, pjsip_hdr_shallow_clone(tdata->pool,  
     478    pjsip_msg_add_hdr(msg, (pjsip_hdr*) 
     479                           pjsip_hdr_shallow_clone(tdata->pool,  
    474480                                                   regc->contact_hdr)); 
    475481    pjsip_msg_add_hdr( msg, (pjsip_hdr*)regc->unreg_expires_hdr); 
     
    554560                                   struct pj_timer_entry *entry) 
    555561{ 
    556     pjsip_regc *regc = entry->user_data; 
     562    pjsip_regc *regc = (pjsip_regc*) entry->user_data; 
    557563    pjsip_tx_data *tdata; 
    558564    pj_status_t status; 
     
    588594{ 
    589595    pj_status_t status; 
    590     pjsip_regc *regc = token; 
     596    pjsip_regc *regc = (pjsip_regc*) token; 
    591597    pjsip_transaction *tsx = event->body.tsx_state.tsx; 
    592598     
     
    654660            rdata = event->body.tsx_state.src.rdata; 
    655661            msg = rdata->msg_info.msg; 
    656             hdr = pjsip_msg_find_hdr( msg, PJSIP_H_CONTACT, NULL); 
     662            hdr = (pjsip_contact_hdr*) 
     663                  pjsip_msg_find_hdr( msg, PJSIP_H_CONTACT, NULL); 
    657664            while (hdr) { 
    658665                contact[contact_cnt++] = hdr; 
     
    660667                if (hdr == (void*)&msg->hdr) 
    661668                    break; 
    662                 hdr = pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, hdr); 
     669                hdr = (pjsip_contact_hdr*) 
     670                      pjsip_msg_find_hdr(msg, PJSIP_H_CONTACT, hdr); 
    663671            } 
    664672 
    665             expires = pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
     673            expires = (pjsip_expires_hdr*) 
     674                      pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL); 
    666675 
    667676            if (expires) 
     
    741750    /* Increment CSeq */ 
    742751    cseq = ++regc->cseq_hdr->cseq; 
    743     cseq_hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL); 
     752    cseq_hdr = (pjsip_cseq_hdr*) 
     753               pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL); 
    744754    cseq_hdr->cseq = cseq; 
    745755 
  • pjproject/trunk/pjsip/src/pjsip-ua/sip_replaces.c

    r974 r1266  
    5353PJ_DEF(pjsip_replaces_hdr*) pjsip_replaces_hdr_create(pj_pool_t *pool) 
    5454{ 
    55     pjsip_replaces_hdr *hdr = pj_pool_zalloc(pool, sizeof(*hdr)); 
     55    pjsip_replaces_hdr *hdr = PJ_POOL_ZALLOC_T(pool, pjsip_replaces_hdr); 
    5656    hdr->type = PJSIP_H_OTHER; 
    5757    hdr->name.ptr = "Replaces"; 
     
    109109                            const pjsip_replaces_hdr *rhs ) 
    110110{ 
    111     pjsip_replaces_hdr *hdr = pj_pool_alloc(pool, sizeof(*hdr)); 
     111    pjsip_replaces_hdr *hdr = PJ_POOL_ALLOC_T(pool, pjsip_replaces_hdr); 
    112112    pj_memcpy(hdr, rhs, sizeof(*hdr)); 
    113113    pjsip_param_shallow_clone(pool, &hdr->other_param, &rhs->other_param); 
     
    145145            hdr->early_only = PJ_TRUE; 
    146146        } else { 
    147             pjsip_param *param = pj_pool_alloc(ctx->pool, sizeof(pjsip_param)); 
     147            pjsip_param *param = PJ_POOL_ALLOC_T(ctx->pool, pjsip_param); 
    148148            param->name = pname; 
    149149            param->value = pvalue; 
     
    319319                pjsip_hdr *cloned; 
    320320 
    321                 cloned = pjsip_hdr_clone(tdata->pool, h); 
     321                cloned = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, h); 
    322322                PJ_ASSERT_RETURN(cloned, PJ_ENOMEM); 
    323323 
  • pjproject/trunk/pjsip/src/pjsip-ua/sip_xfer.c

    r1242 r1266  
    180180 
    181181    /* Create xfer session */ 
    182     xfer = pj_pool_zalloc(dlg->pool, sizeof(pjsip_xfer)); 
     182    xfer = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_xfer); 
    183183    xfer->dlg = dlg; 
    184184    xfer->sub = sub; 
     
    249249 
    250250    /* Create server xfer subscription */ 
    251     xfer = pj_pool_zalloc(dlg->pool, sizeof(pjsip_xfer)); 
     251    xfer = PJ_POOL_ZALLOC_T(dlg->pool, pjsip_xfer); 
    252252    xfer->dlg = dlg; 
    253253    xfer->sub = sub; 
     
    287287 
    288288    /* Get the xfer object. */ 
    289     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     289    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    290290    PJ_ASSERT_RETURN(xfer != NULL, PJSIP_ENOREFERSESSION); 
    291291 
     
    374374 
    375375    /* Get the xfer object. */ 
    376     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     376    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    377377    PJ_ASSERT_RETURN(xfer != NULL, PJSIP_ENOREFERSESSION); 
    378378 
     
    399399 
    400400    /* Create sipfrag content. */ 
    401     body = pj_pool_alloc(tdata->pool, 128); 
     401    body = (char*) pj_pool_alloc(tdata->pool, 128); 
    402402    bodylen = pj_ansi_snprintf(body, 128, "SIP/2.0 %u %.*s", 
    403403                               xfer_st_code, 
     
    410410 
    411411    /* Create SIP message body. */ 
    412     msg_body = pj_pool_zalloc(tdata->pool, sizeof(pjsip_msg_body)); 
     412    msg_body = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_msg_body); 
    413413    msg_body->content_type.type = STR_MESSAGE; 
    414414    msg_body->content_type.subtype = STR_SIPFRAG; 
     
    448448 
    449449    /* Get the xfer object. */ 
    450     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     450    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    451451    PJ_ASSERT_RETURN(xfer != NULL, PJSIP_ENOREFERSESSION); 
    452452 
     
    481481    pjsip_xfer *xfer; 
    482482 
    483     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     483    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    484484    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    485485 
     
    497497    pjsip_xfer *xfer; 
    498498 
    499     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     499    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    500500    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    501501 
     
    516516    pjsip_xfer *xfer; 
    517517 
    518     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     518    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    519519    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    520520 
     
    557557    pjsip_xfer *xfer; 
    558558 
    559     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     559    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    560560    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    561561 
     
    572572    pjsip_xfer *xfer; 
    573573 
    574     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     574    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    575575    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    576576 
     
    595595    pjsip_xfer *xfer; 
    596596 
    597     xfer = pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
     597    xfer = (pjsip_xfer*) pjsip_evsub_get_mod_data(sub, mod_xfer.id); 
    598598    PJ_ASSERT_ON_FAIL(xfer!=NULL, {return;}); 
    599599 
  • pjproject/trunk/pjsip/src/pjsip/sip_endpoint.c

    r1240 r1266  
    168168    pj_status_t status = PJ_SUCCESS; 
    169169    pjsip_module *m; 
    170     int i; 
     170    unsigned i; 
    171171 
    172172    pj_rwmutex_lock_write(endpt->mod_mutex); 
     
    248248 
    249249    /* Make sure the module exists in the array. */ 
    250     PJ_ASSERT_ON_FAIL(  mod->id>=0 && mod->id<PJ_ARRAY_SIZE(endpt->modules) && 
     250    PJ_ASSERT_ON_FAIL(  mod->id>=0 &&  
     251                        mod->id<(int)PJ_ARRAY_SIZE(endpt->modules) && 
    251252                        endpt->modules[mod->id] == mod, 
    252253                        {status = PJ_ENOTFOUND; goto on_return;}); 
     
    10801081 
    10811082    len = pj_ansi_strlen(format); 
    1082     if (len < sizeof(newformat)-30) { 
     1083    if (len < (int)sizeof(newformat)-30) { 
    10831084        pj_str_t errstr; 
    10841085 
  • pjproject/trunk/pjsip/src/pjsip/sip_msg.c

    r1240 r1266  
    9898static int init_status_phrase() 
    9999{ 
    100     int i; 
     100    unsigned i; 
    101101    pj_str_t default_reason_phrase = { "Default status message", 22}; 
    102102 
     
    195195                                  pj_str_t *str) 
    196196{ 
    197     int i; 
     197    unsigned i; 
    198198    for (i=0; i<PJ_ARRAY_SIZE(method_names); ++i) { 
    199199        if (pj_memcmp(str->ptr, method_names[i]->ptr, str->slen)==0 ||  
     
    516516    } 
    517517 
    518     return (code>=100 && code<(sizeof(status_phrase)/sizeof(status_phrase[0]))) ?  
     518    return (code>=100 &&  
     519            code<(int)(sizeof(status_phrase)/sizeof(status_phrase[0]))) ?  
    519520        &status_phrase[code] : &status_phrase[0]; 
    520521} 
  • pjproject/trunk/pjsip/src/pjsip/sip_transport.c

    r1248 r1266  
    9898 * Transport names. 
    9999 */ 
    100 struct 
     100struct transport_names_t 
    101101{ 
    102102    pjsip_transport_type_e type; 
     
    217217 
    218218    /* Check that argument is valid. */ 
    219     PJ_ASSERT_RETURN(type < PJ_ARRAY_SIZE(transport_names), 0); 
     219    PJ_ASSERT_RETURN((unsigned)type < PJ_ARRAY_SIZE(transport_names), 0); 
    220220 
    221221    /* Return transport flag. */ 
     
    236236 
    237237    /* Check that argument is valid. */ 
    238     PJ_ASSERT_RETURN(type < PJ_ARRAY_SIZE(transport_names), 5060); 
     238    PJ_ASSERT_RETURN((unsigned)type < PJ_ARRAY_SIZE(transport_names), 5060); 
    239239 
    240240    /* Return the port. */ 
     
    254254 
    255255    /* Check that argument is valid. */ 
    256     PJ_ASSERT_RETURN(type < PJ_ARRAY_SIZE(transport_names), "Unknown"); 
     256    PJ_ASSERT_RETURN((unsigned)type<PJ_ARRAY_SIZE(transport_names), "Unknown"); 
    257257 
    258258    /* Return the port. */ 
     
    415415    } 
    416416 
    417     if (len < 1 || len >= sizeof(info_buf)) { 
     417    if (len < 1 || len >= (int)sizeof(info_buf)) { 
    418418        return (char*)obj_name; 
    419419    } 
  • pjproject/trunk/pjsip/src/pjsip/sip_transport_tls_ossl.c

    r1088 r1266  
    260260{ 
    261261    enum { M = 48 }; 
    262     host_port->host.ptr = pj_pool_alloc(pool, M); 
     262    host_port->host.ptr = (char*)pj_pool_alloc(pool, M); 
    263263    host_port->host.slen = pj_ansi_snprintf( host_port->host.ptr, M, "%s",  
    264264                                            pj_inet_ntoa(addr->sin_addr)); 
     
    270270static int password_cb(char *buf, int num, int rwflag, void *user_data) 
    271271{ 
    272     struct tls_listener *lis = user_data; 
     272    struct tls_listener *lis = (struct tls_listener*) user_data; 
    273273 
    274274    PJ_UNUSED_ARG(rwflag); 
     
    905905 
    906906 
    907     listener = pj_pool_zalloc(pool, sizeof(struct tls_listener)); 
     907    listener = PJ_POOL_ZALLOC_T(pool, struct tls_listener); 
    908908    listener->factory.pool = pool; 
    909909    listener->factory.type = PJSIP_TRANSPORT_TLS; 
     
    10371037        } 
    10381038 
    1039         listener->accept_op[i] = pj_pool_zalloc(pool,  
    1040                                                 sizeof(struct pending_accept)); 
     1039        listener->accept_op[i] = PJ_POOL_ZALLOC_T(pool, struct pending_accept); 
    10411040        pj_ioqueue_op_key_init(&listener->accept_op[i]->op_key,  
    10421041                                sizeof(listener->accept_op[i]->op_key)); 
     
    11921191     * Create and initialize basic transport structure. 
    11931192     */ 
    1194     tls = pj_pool_zalloc(pool, sizeof(*tls)); 
     1193    tls = PJ_POOL_ZALLOC_T(pool, struct tls_transport); 
    11951194    tls->sock = sock; 
    11961195    tls->is_server = is_server; 
     
    12181217    tls->base.flag = pjsip_transport_get_flag_from_type(PJSIP_TRANSPORT_TLS); 
    12191218 
    1220     tls->base.info = pj_pool_alloc(pool, 64); 
     1219    tls->base.info = (char*) pj_pool_alloc(pool, 64); 
    12211220    pj_ansi_snprintf(tls->base.info, 64, "TLS to %s:%d", 
    12221221                     pj_inet_ntoa(remote->sin_addr),  
     
    16361635    int err_cnt = 0; 
    16371636 
    1638     listener = pj_ioqueue_get_user_data(key); 
     1637    listener = (struct tls_listener*) pj_ioqueue_get_user_data(key); 
    16391638    accept_op = (struct pending_accept*) op_key; 
    16401639 
     
    16951694            pool = pjsip_endpt_create_pool(listener->endpt, "tlss%p",  
    16961695                                           POOL_TP_INIT, POOL_TP_INC); 
    1697             new_op = pj_pool_zalloc(pool, sizeof(struct pending_accept)); 
     1696            new_op = PJ_POOL_ZALLOC_T(pool, struct pending_accept); 
    16981697            new_op->pool = pool; 
    16991698            new_op->listener = listener; 
     
    17571756                              pj_ssize_t bytes_sent) 
    17581757{ 
    1759     struct tls_transport *tls = pj_ioqueue_get_user_data(key); 
     1758    struct tls_transport *tls; 
    17601759    pjsip_tx_data_op_key *tdata_op_key = (pjsip_tx_data_op_key*)op_key; 
    17611760 
     1761    tls = (struct tls_transport*) pj_ioqueue_get_user_data(key); 
    17621762    tdata_op_key->tdata = NULL; 
    17631763 
     
    17901790    struct delayed_tdata *delayed_tdata; 
    17911791 
    1792     delayed_tdata = pj_pool_alloc(tdata->pool,  
    1793                                   sizeof(*delayed_tdata)); 
     1792    delayed_tdata = PJ_POOL_ALLOC_T(tdata->pool, struct delayed_tdata); 
    17941793    delayed_tdata->tdata_op_key = &tdata->op_key; 
    17951794    pj_list_push_back(&tls->delayed_list, delayed_tdata); 
     
    20982097    int addrlen; 
    20992098 
    2100     tls = pj_ioqueue_get_user_data(key); 
     2099    tls = (struct tls_transport*) pj_ioqueue_get_user_data(key); 
    21012100 
    21022101    /* Check connect() status */ 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_acc.c

    r1242 r1266  
    3838PJ_DEF(pj_bool_t) pjsua_acc_is_valid(pjsua_acc_id acc_id) 
    3939{ 
    40     return acc_id>=0 && acc_id<PJ_ARRAY_SIZE(pjsua_var.acc) && 
     40    return acc_id>=0 && acc_id<(int)PJ_ARRAY_SIZE(pjsua_var.acc) && 
    4141           pjsua_var.acc[acc_id].valid; 
    4242} 
     
    186186        pj_strdup_with_null(pjsua_var.pool, &tmp,  
    187187                            &pjsua_var.ua_cfg.outbound_proxy[i]); 
    188         r = pjsip_parse_hdr(pjsua_var.pool, &hname, tmp.ptr, tmp.slen, NULL); 
     188        r = (pjsip_route_hdr*) 
     189            pjsip_parse_hdr(pjsua_var.pool, &hname, tmp.ptr, tmp.slen, NULL); 
    189190        if (r == NULL) { 
    190191            pjsua_perror(THIS_FILE, "Invalid outbound proxy URI", 
     
    201202 
    202203        pj_strdup_with_null(pjsua_var.pool, &tmp, &acc_cfg->proxy[i]); 
    203         r = pjsip_parse_hdr(pjsua_var.pool, &hname, tmp.ptr, tmp.slen, NULL); 
     204        r = (pjsip_route_hdr*) 
     205            pjsip_parse_hdr(pjsua_var.pool, &hname, tmp.ptr, tmp.slen, NULL); 
    204206        if (r == NULL) { 
    205207            pjsua_perror(THIS_FILE, "Invalid URI in account route set", 
     
    323325 
    324326    /* ID must be valid */ 
    325     PJ_ASSERT_RETURN(tid>=0 && tid<PJ_ARRAY_SIZE(pjsua_var.tpdata), PJ_EINVAL); 
     327    PJ_ASSERT_RETURN(tid>=0 && tid<(int)PJ_ARRAY_SIZE(pjsua_var.tpdata),  
     328                     PJ_EINVAL); 
    326329 
    327330    /* Transport must be valid */ 
     
    434437{ 
    435438 
    436     pjsua_acc *acc = param->token; 
     439    pjsua_acc *acc = (pjsua_acc*) param->token; 
    437440 
    438441    PJSUA_LOCK(); 
     
    817820    } 
    818821 
    819     sip_uri = pjsip_uri_get_uri(uri); 
     822    sip_uri = (pjsip_sip_uri*) pjsip_uri_get_uri(uri); 
    820823 
    821824    /* Find matching domain AND port */ 
     
    955958    r = acc->route_set.next; 
    956959    while (r != &acc->route_set) { 
    957         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_clone(tdata->pool, r)); 
     960        pjsip_msg_add_hdr(tdata->msg,  
     961                          (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, r)); 
    958962        r = r->next; 
    959963    } 
     
    10371041 
    10381042    /* Create the contact header */ 
    1039     contact->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
     1043    contact->ptr = (char*)pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
    10401044    contact->slen = pj_ansi_snprintf(contact->ptr, PJSIP_MAX_URL_SIZE, 
    10411045                                     "%.*s%s<%s:%.*s%s%.*s:%d;transport=%s>", 
     
    10981102 
    10991103        /* Otherwise URI is Contact URI */ 
    1100         h_contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, 
     1104        h_contact = (pjsip_contact_hdr*) 
     1105                    pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, 
    11011106                                       NULL); 
    11021107        if (h_contact) 
    1103             uri = pjsip_uri_get_uri(h_contact->uri); 
     1108            uri = (pjsip_uri*) pjsip_uri_get_uri(h_contact->uri); 
    11041109         
    11051110 
     
    11081113         */ 
    11091114        if (uri == NULL) 
    1110             uri = pjsip_uri_get_uri(rdata->msg_info.from->uri); 
     1115            uri = (pjsip_uri*) pjsip_uri_get_uri(rdata->msg_info.from->uri); 
    11111116 
    11121117 
     
    11431148 
    11441149    /* Create the contact header */ 
    1145     contact->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
     1150    contact->ptr = (char*) pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
    11461151    contact->slen = pj_ansi_snprintf(contact->ptr, PJSIP_MAX_URL_SIZE, 
    11471152                                     "%.*s%s<%s:%.*s%s%.*s:%d;transport=%s>", 
     
    11701175    acc = &pjsua_var.acc[acc_id]; 
    11711176 
    1172     PJ_ASSERT_RETURN(tp_id >= 0 && tp_id < PJ_ARRAY_SIZE(pjsua_var.tpdata), 
     1177    PJ_ASSERT_RETURN(tp_id >= 0 && tp_id < (int)PJ_ARRAY_SIZE(pjsua_var.tpdata), 
    11731178                     PJ_EINVAL); 
    11741179     
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_call.c

    r1264 r1266  
    204204    pjsua_acc *acc; 
    205205    pjsua_call *call; 
    206     unsigned call_id; 
     206    int call_id = -1; 
    207207    pj_str_t contact; 
    208208    pjsip_tx_data *tdata; 
     
    211211 
    212212    /* Check that account is valid */ 
    213     PJ_ASSERT_RETURN(acc_id>=0 || acc_id<PJ_ARRAY_SIZE(pjsua_var.acc),  
     213    PJ_ASSERT_RETURN(acc_id>=0 || acc_id<(int)PJ_ARRAY_SIZE(pjsua_var.acc),  
    214214                     PJ_EINVAL); 
    215215 
     
    231231 
    232232    /* Find free call slot. */ 
    233     for (call_id=0; call_id<pjsua_var.ua_cfg.max_calls; ++call_id) { 
     233    for (call_id=0; call_id<(int)pjsua_var.ua_cfg.max_calls; ++call_id) { 
    234234        if (pjsua_var.calls[call_id].inv == NULL) 
    235235            break; 
    236236    } 
    237237 
    238     if (call_id == pjsua_var.ua_cfg.max_calls) { 
     238    if (call_id == (int)pjsua_var.ua_cfg.max_calls) { 
    239239        pjsua_perror(THIS_FILE, "Error making file", PJ_ETOOMANY); 
    240240        PJSUA_UNLOCK(); 
     
    508508 
    509509        /* Get the replaced call instance */ 
    510         replaced_call = replaced_dlg->mod_data[pjsua_var.mod.id]; 
     510        replaced_call = (pjsua_call*) replaced_dlg->mod_data[pjsua_var.mod.id]; 
    511511 
    512512        /* Notify application */ 
     
    691691 
    692692        /* Get the replaced call instance */ 
    693         replaced_call = replaced_dlg->mod_data[pjsua_var.mod.id]; 
     693        replaced_call = (pjsua_call*) replaced_dlg->mod_data[pjsua_var.mod.id]; 
    694694 
    695695        /* Notify application */ 
     
    13781378                      dest_dlg->remote.info->tag.slen + 
    13791379                      dest_dlg->local.info->tag.slen + 32  
    1380                       < sizeof(str_dest_buf), PJSIP_EURITOOLONG); 
     1380                      < (long)sizeof(str_dest_buf), PJSIP_EURITOOLONG); 
    13811381 
    13821382    /* Print URI */ 
     
    13841384    str_dest.slen = 1; 
    13851385 
    1386     uri = pjsip_uri_get_uri(dest_dlg->remote.info->uri); 
     1386    uri = (pjsip_uri*) pjsip_uri_get_uri(dest_dlg->remote.info->uri); 
    13871387    len = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, uri,  
    13881388                          str_dest_buf+1, sizeof(str_dest_buf)-1); 
     
    15101510 
    15111511    /* Create IM data and attach to the request. */ 
    1512     im_data = pj_pool_zalloc(tdata->pool, sizeof(*im_data)); 
     1512    im_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsua_im_data); 
    15131513    im_data->acc_id = call->acc_id; 
    15141514    im_data->call_id = call_id; 
     
    19351935    PJSUA_LOCK(); 
    19361936 
    1937     call = inv->dlg->mod_data[pjsua_var.mod.id]; 
     1937    call = (pjsua_call*) inv->dlg->mod_data[pjsua_var.mod.id]; 
    19381938 
    19391939    if (!call) { 
     
    21052105    PJSUA_LOCK(); 
    21062106 
    2107     call = inv->dlg->mod_data[pjsua_var.mod.id]; 
     2107    call = (pjsua_call*) inv->dlg->mod_data[pjsua_var.mod.id]; 
    21082108 
    21092109    if (status != PJ_SUCCESS) { 
     
    22322232    PJSUA_LOCK(); 
    22332233 
    2234     call = inv->dlg->mod_data[pjsua_var.mod.id]; 
     2234    call = (pjsua_call*) inv->dlg->mod_data[pjsua_var.mod.id]; 
    22352235 
    22362236    /* 
     
    23152315        pjsua_call *call; 
    23162316 
    2317         call = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     2317        call = (pjsua_call*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    23182318 
    23192319        /* Must be receipt of response message */ 
     
    23782378        pj_status_t status; 
    23792379 
    2380         call = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     2380        call = (pjsua_call*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    23812381 
    23822382        /* When subscription is terminated, clear the xfer_sub member of  
     
    24222422 
    24232423            /* Try to parse the content */ 
    2424             status = pjsip_parse_status_line(body->data, body->len,  
     2424            status = pjsip_parse_status_line((char*)body->data, body->len,  
    24252425                                             &status_line); 
    24262426            if (status != PJ_SUCCESS) { 
     
    24672467        pjsua_call *call; 
    24682468 
    2469         call = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     2469        call = (pjsua_call*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    24702470        if (!call) 
    24712471            return; 
     
    25022502    pjsip_evsub *sub; 
    25032503 
    2504     existing_call = inv->dlg->mod_data[pjsua_var.mod.id]; 
     2504    existing_call = (pjsua_call*) inv->dlg->mod_data[pjsua_var.mod.id]; 
    25052505 
    25062506    /* Find the Refer-To header */ 
     
    25292529     * request. 
    25302530     */ 
    2531     ref_by_hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_ref_by,  
     2531    ref_by_hdr = (pjsip_hdr*) 
     2532                 pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_ref_by,  
    25322533                                            NULL); 
    25332534 
     
    26562657     */ 
    26572658    if (ref_by_hdr != NULL) { 
    2658         pjsip_hdr *dup = pjsip_hdr_clone(rdata->tp_info.pool, ref_by_hdr); 
     2659        pjsip_hdr *dup = (pjsip_hdr*) 
     2660                         pjsip_hdr_clone(rdata->tp_info.pool, ref_by_hdr); 
    26592661        pj_list_push_back(&msg_data.hdr_list, dup); 
    26602662    } 
     
    27112713                                            pjsip_event *e) 
    27122714{ 
    2713     pjsua_call *call = inv->dlg->mod_data[pjsua_var.mod.id]; 
     2715    pjsua_call *call = (pjsua_call*) inv->dlg->mod_data[pjsua_var.mod.id]; 
    27142716 
    27152717    PJSUA_LOCK(); 
     
    27732775            pjsua_im_data *im_data; 
    27742776 
    2775             im_data = tsx->mod_data[pjsua_var.mod.id]; 
     2777            im_data = (pjsua_im_data*) tsx->mod_data[pjsua_var.mod.id]; 
    27762778            /* im_data can be NULL if this is typing indication */ 
    27772779 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_core.c

    r1248 r1266  
    165165    cap_hdr = pjsip_endpt_get_capability(pjsua_var.endpt, PJSIP_H_ALLOW, NULL); 
    166166    if (cap_hdr) { 
    167         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_clone(tdata->pool, cap_hdr)); 
     167        pjsip_msg_add_hdr(tdata->msg,  
     168                          (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, cap_hdr)); 
    168169    } 
    169170 
     
    171172    cap_hdr = pjsip_endpt_get_capability(pjsua_var.endpt, PJSIP_H_ACCEPT, NULL); 
    172173    if (cap_hdr) { 
    173         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_clone(tdata->pool, cap_hdr)); 
     174        pjsip_msg_add_hdr(tdata->msg,  
     175                          (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, cap_hdr)); 
    174176    } 
    175177 
     
    177179    cap_hdr = pjsip_endpt_get_capability(pjsua_var.endpt, PJSIP_H_SUPPORTED, NULL); 
    178180    if (cap_hdr) { 
    179         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_clone(tdata->pool, cap_hdr)); 
     181        pjsip_msg_add_hdr(tdata->msg,  
     182                          (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, cap_hdr)); 
    180183    } 
    181184 
     
    183186    cap_hdr = pjsip_evsub_get_allow_events_hdr(NULL); 
    184187    if (cap_hdr) { 
    185         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_clone(tdata->pool, cap_hdr)); 
     188        pjsip_msg_add_hdr(tdata->msg,  
     189                          (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, cap_hdr)); 
    186190    } 
    187191 
     
    14561460 
    14571461    /* Make sure id is in range. */ 
    1458     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.tpdata), PJ_EINVAL); 
     1462    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.tpdata),  
     1463                     PJ_EINVAL); 
    14591464 
    14601465    /* Make sure that transport exists */ 
     
    15241529{ 
    15251530    /* Make sure id is in range. */ 
    1526     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.tpdata), PJ_EINVAL); 
     1531    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.tpdata),  
     1532                     PJ_EINVAL); 
    15271533 
    15281534    /* Make sure that transport exists */ 
     
    15471553 
    15481554    /* Make sure id is in range. */ 
    1549     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.tpdata), PJ_EINVAL); 
     1555    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.tpdata),  
     1556                     PJ_EINVAL); 
    15501557 
    15511558    /* Make sure that transport exists */ 
     
    16401647        pjsip_hdr *new_hdr; 
    16411648 
    1642         new_hdr = pjsip_hdr_clone(tdata->pool, hdr); 
     1649        new_hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr); 
    16431650        pjsip_msg_add_hdr(tdata->msg, new_hdr); 
    16441651 
     
    16721679        pjsip_route_hdr *new_r; 
    16731680 
    1674         new_r = pjsip_hdr_clone(tdata->pool, r); 
     1681        new_r = (pjsip_route_hdr*) pjsip_hdr_clone(tdata->pool, r); 
    16751682        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)new_r); 
    16761683 
     
    17191726        return; 
    17201727 
    1721     pj_assert(tp_id >= 0 && tp_id < PJ_ARRAY_SIZE(pjsua_var.tpdata)); 
     1728    pj_assert(tp_id >= 0 && tp_id < (int)PJ_ARRAY_SIZE(pjsua_var.tpdata)); 
    17221729    tpdata = &pjsua_var.tpdata[tp_id]; 
    17231730 
     
    17491756    if (!pool) return -1; 
    17501757 
    1751     url = pj_pool_alloc(pool, len+1); 
     1758    url = (char*) pj_pool_alloc(pool, len+1); 
    17521759    pj_ansi_strcpy(url, c_url); 
    17531760 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_im.c

    r1242 r1266  
    113113     * "text/plain". 
    114114     */ 
    115     ctype = pjsip_msg_find_hdr(msg, PJSIP_H_CONTENT_TYPE, NULL); 
     115    ctype = (pjsip_ctype_hdr*) 
     116            pjsip_msg_find_hdr(msg, PJSIP_H_CONTENT_TYPE, NULL); 
    116117    if (msg->body == NULL || ctype == NULL ||  
    117118        !acceptable_message(&ctype->media))  
     
    143144 
    144145    /* Build remote contact */ 
    145     contact_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, 
     146    contact_hdr = (pjsip_contact_hdr*) 
     147                  pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, 
    146148                                     NULL); 
    147149    if (contact_hdr) { 
    148         contact.ptr = pj_pool_alloc(rdata->tp_info.pool,  
    149                                     PJSIP_MAX_URL_SIZE); 
     150        contact.ptr = (char*) pj_pool_alloc(rdata->tp_info.pool,  
     151                                            PJSIP_MAX_URL_SIZE); 
    150152        contact.slen = pjsip_uri_print(PJSIP_URI_IN_CONTACT_HDR, 
    151153                                       contact_hdr->uri, contact.ptr, 
     
    163165         
    164166        /* Save text body */ 
    165         text_body.ptr = rdata->msg_info.msg->body->data; 
     167        text_body.ptr = (char*) rdata->msg_info.msg->body->data; 
    166168        text_body.slen = rdata->msg_info.msg->body->len; 
    167169 
     
    176178        pj_bool_t is_typing; 
    177179 
    178         status = pjsip_iscomposing_parse( rdata->tp_info.pool, body->data, 
    179                                           body->len, &is_typing, NULL, NULL, 
    180                                           NULL ); 
     180        status = pjsip_iscomposing_parse(rdata->tp_info.pool, (char*)body->data, 
     181                                         body->len, &is_typing, NULL, NULL, 
     182                                         NULL ); 
    181183        if (status != PJ_SUCCESS) { 
    182184            pjsua_perror(THIS_FILE, "Invalid MESSAGE body", status); 
     
    241243     * not available, then use From header. 
    242244     */ 
    243     from.ptr = pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE); 
    244     contact_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, 
     245    from.ptr = (char*) pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE); 
     246    contact_hdr = (pjsip_contact_hdr*) 
     247                  pjsip_msg_find_hdr(rdata->msg_info.msg, 
    245248                                     PJSIP_H_CONTACT, NULL); 
    246249    if (contact_hdr) { 
     
    258261 
    259262    /* Build the To text. */ 
    260     to.ptr = pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE); 
     263    to.ptr = (char*) pj_pool_alloc(rdata->tp_info.pool, PJSIP_MAX_URL_SIZE); 
    261264    to.slen = pjsip_uri_print( PJSIP_URI_IN_FROMTO_HDR,  
    262265                               rdata->msg_info.to->uri, 
     
    276279static void im_callback(void *token, pjsip_event *e) 
    277280{ 
    278     pjsua_im_data *im_data = token; 
     281    pjsua_im_data *im_data = (pjsua_im_data*) token; 
    279282 
    280283    if (e->type == PJSIP_EVENT_TSX_STATE) { 
     
    353356static void typing_callback(void *token, pjsip_event *e) 
    354357{ 
    355     pjsua_im_data *im_data = token; 
     358    pjsua_im_data *im_data = (pjsua_im_data*) token; 
    356359 
    357360    if (e->type == PJSIP_EVENT_TSX_STATE) { 
     
    464467     * application on the callback 
    465468     */ 
    466     im_data = pj_pool_zalloc(tdata->pool, sizeof(*im_data)); 
     469    im_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsua_im_data); 
    467470    im_data->acc_id = acc_id; 
    468471    im_data->call_id = PJSUA_INVALID_ID; 
     
    571574 
    572575    /* Create data to reauthenticate */ 
    573     im_data = pj_pool_zalloc(tdata->pool, sizeof(*im_data)); 
     576    im_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsua_im_data); 
    574577    im_data->acc_id = acc_id; 
    575578 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_media.c

    r1262 r1266  
    12381238PJ_DEF(pjsua_conf_port_id) pjsua_player_get_conf_port(pjsua_player_id id) 
    12391239{ 
    1240     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
     1240    PJ_ASSERT_RETURN(id>=0&&id<(int)PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
    12411241    PJ_ASSERT_RETURN(pjsua_var.player[id].port != NULL, PJ_EINVAL); 
    12421242 
     
    12501250                                           pjmedia_port **p_port) 
    12511251{ 
    1252     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
     1252    PJ_ASSERT_RETURN(id>=0&&id<(int)PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
    12531253    PJ_ASSERT_RETURN(pjsua_var.player[id].port != NULL, PJ_EINVAL); 
    12541254    PJ_ASSERT_RETURN(p_port != NULL, PJ_EINVAL); 
     
    12651265                                          pj_uint32_t samples) 
    12661266{ 
    1267     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
     1267    PJ_ASSERT_RETURN(id>=0&&id<(int)PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
    12681268    PJ_ASSERT_RETURN(pjsua_var.player[id].port != NULL, PJ_EINVAL); 
    12691269    PJ_ASSERT_RETURN(pjsua_var.player[id].type == 0, PJ_EINVAL); 
     
    12791279PJ_DEF(pj_status_t) pjsua_player_destroy(pjsua_player_id id) 
    12801280{ 
    1281     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
     1281    PJ_ASSERT_RETURN(id>=0&&id<(int)PJ_ARRAY_SIZE(pjsua_var.player), PJ_EINVAL); 
    12821282    PJ_ASSERT_RETURN(pjsua_var.player[id].port != NULL, PJ_EINVAL); 
    12831283 
     
    14151415PJ_DEF(pjsua_conf_port_id) pjsua_recorder_get_conf_port(pjsua_recorder_id id) 
    14161416{ 
    1417     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.recorder), PJ_EINVAL); 
     1417    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.recorder),  
     1418                     PJ_EINVAL); 
    14181419    PJ_ASSERT_RETURN(pjsua_var.recorder[id].port != NULL, PJ_EINVAL); 
    14191420 
     
    14271428                                             pjmedia_port **p_port) 
    14281429{ 
    1429     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.recorder), PJ_EINVAL); 
     1430    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.recorder),  
     1431                     PJ_EINVAL); 
    14301432    PJ_ASSERT_RETURN(pjsua_var.recorder[id].port != NULL, PJ_EINVAL); 
    14311433    PJ_ASSERT_RETURN(p_port != NULL, PJ_EINVAL); 
     
    14401442PJ_DEF(pj_status_t) pjsua_recorder_destroy(pjsua_recorder_id id) 
    14411443{ 
    1442     PJ_ASSERT_RETURN(id>=0 && id<PJ_ARRAY_SIZE(pjsua_var.recorder), PJ_EINVAL); 
     1444    PJ_ASSERT_RETURN(id>=0 && id<(int)PJ_ARRAY_SIZE(pjsua_var.recorder),  
     1445                     PJ_EINVAL); 
    14431446    PJ_ASSERT_RETURN(pjsua_var.recorder[id].port != NULL, PJ_EINVAL); 
    14441447 
  • pjproject/trunk/pjsip/src/pjsua-lib/pjsua_pres.c

    r1087 r1266  
    3838PJ_DEF(pj_bool_t) pjsua_buddy_is_valid(pjsua_buddy_id buddy_id) 
    3939{ 
    40     return buddy_id>=0 && buddy_id<PJ_ARRAY_SIZE(pjsua_var.buddy) && 
     40    return buddy_id>=0 && buddy_id<(int)PJ_ARRAY_SIZE(pjsua_var.buddy) && 
    4141           pjsua_var.buddy[buddy_id].uri.slen != 0; 
    4242} 
     
    153153 
    154154    /* Find empty slot */ 
    155     for (index=0; index<PJ_ARRAY_SIZE(pjsua_var.buddy); ++index) { 
     155    for (index=0; index<(int)PJ_ARRAY_SIZE(pjsua_var.buddy); ++index) { 
    156156        if (pjsua_var.buddy[index].uri.slen == 0) 
    157157            break; 
     
    424424    PJSUA_LOCK(); 
    425425 
    426     uapres = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     426    uapres = (pjsua_srv_pres*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    427427    if (uapres) { 
    428428        PJ_LOG(3,(THIS_FILE, "Server subscription to %s is %s", 
     
    517517 
    518518    /* Attach our data to the subscription: */ 
    519     uapres = pj_pool_alloc(dlg->pool, sizeof(pjsua_srv_pres)); 
     519    uapres = PJ_POOL_ALLOC_T(dlg->pool, pjsua_srv_pres); 
    520520    uapres->sub = sub; 
    521     uapres->remote = pj_pool_alloc(dlg->pool, PJSIP_MAX_URL_SIZE); 
     521    uapres->remote = (char*) pj_pool_alloc(dlg->pool, PJSIP_MAX_URL_SIZE); 
    522522    status = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, dlg->remote.info->uri, 
    523523                             uapres->remote, PJSIP_MAX_URL_SIZE); 
     
    586586static void publish_cb(struct pjsip_publishc_cbparam *param) 
    587587{ 
    588     pjsua_acc *acc = param->token; 
     588    pjsua_acc *acc = (pjsua_acc*) param->token; 
    589589 
    590590    if (param->code/100 != 2 || param->status != PJ_SUCCESS) { 
     
    856856    PJSUA_LOCK(); 
    857857 
    858     buddy = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     858    buddy = (pjsua_buddy*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    859859    if (buddy) { 
    860860        PJ_LOG(3,(THIS_FILE,  
     
    889889    PJSUA_LOCK(); 
    890890 
    891     buddy = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     891    buddy = (pjsua_buddy*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    892892    if (!buddy) { 
    893893        PJSUA_UNLOCK(); 
     
    915915 
    916916    /* Find contact header. */ 
    917     contact_hdr = pjsip_msg_find_hdr(event->body.rx_msg.rdata->msg_info.msg, 
     917    contact_hdr = (pjsip_contact_hdr*) 
     918                  pjsip_msg_find_hdr(event->body.rx_msg.rdata->msg_info.msg, 
    918919                                     PJSIP_H_CONTACT, NULL); 
    919920    if (!contact_hdr) { 
     
    922923    } 
    923924 
    924     buddy->contact.ptr = pj_pool_alloc(pjsua_var.pool, PJSIP_MAX_URL_SIZE); 
     925    buddy->contact.ptr = (char*) 
     926                         pj_pool_alloc(pjsua_var.pool, PJSIP_MAX_URL_SIZE); 
    925927    buddy->contact.slen = pjsip_uri_print( PJSIP_URI_IN_CONTACT_HDR, 
    926928                                           contact_hdr->uri, 
     
    946948    PJSUA_LOCK(); 
    947949 
    948     buddy = pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
     950    buddy = (pjsua_buddy*) pjsip_evsub_get_mod_data(sub, pjsua_var.mod.id); 
    949951    if (buddy) { 
    950952        /* Update our info. */ 
  • pjproject/trunk/pjsip/src/test-pjsip/dns_test.c

    r1035 r1266  
    3636               const struct pjsip_server_addresses *addr) 
    3737{ 
    38     struct result *result = token; 
     38    struct result *result = (struct result*) token; 
    3939 
    4040    result->status = status; 
  • pjproject/trunk/pjsip/src/test-pjsip/msg_test.c

    r1236 r1266  
    187187 
    188188    /* Create buffer for comparison. */ 
    189     str1.ptr = pj_pool_alloc(pool, BUFLEN); 
    190     str2.ptr = pj_pool_alloc(pool, BUFLEN); 
     189    str1.ptr = (char*)pj_pool_alloc(pool, BUFLEN); 
     190    str2.ptr = (char*)pj_pool_alloc(pool, BUFLEN); 
    191191 
    192192    /* Compare message type. */ 
     
    661661 
    662662    // Body 
    663     body = pj_pool_zalloc(pool, sizeof(*body)); 
     663    body = PJ_POOL_ZALLOC_T(pool, pjsip_msg_body); 
    664664    msg->body = body; 
    665665    body->content_type.type = pj_str("application"); 
    666666    body->content_type.subtype = pj_str("sdp"); 
    667     body->data =  
     667    body->data = (void*) 
    668668        "v=0\r\n" 
    669669        "o=alice 53655765 2353687637 IN IP4 pc33.atlanta.com\r\n" 
     
    673673        "m=audio 3456 RTP/AVP 0 1 3 99\r\n" 
    674674        "a=rtpmap:0 PCMU/8000\r\n"; 
    675     body->len = pj_native_strlen(body->data); 
     675    body->len = pj_native_strlen((const char*) body->data); 
    676676    body->print_body = &pjsip_print_text_body; 
    677677 
     
    716716 
    717717    for (loop=0; loop<LOOP; ++loop) { 
    718         for (i=0; i<PJ_ARRAY_SIZE(test_array); ++i) { 
     718        for (i=0; i<(int)PJ_ARRAY_SIZE(test_array); ++i) { 
    719719            pool = pjsip_endpt_create_pool(endpt, NULL, POOL_SIZE, POOL_SIZE); 
    720720            status = test_entry( pool, &test_array[i] ); 
     
    14541454        hname = pj_str(test->hname); 
    14551455        len = strlen(test->hcontent); 
    1456         parsed_hdr1 = pjsip_parse_hdr(pool, &hname, test->hcontent, len, &parsed_len); 
     1456        parsed_hdr1 = (pjsip_hdr*) pjsip_parse_hdr(pool, &hname,  
     1457                                                   test->hcontent, len,  
     1458                                                   &parsed_len); 
    14571459        if (parsed_hdr1 == NULL) { 
    14581460            if (test->flags & HDR_FLAG_PARSE_FAIL) { 
     
    14761478            hname = pj_str(test->hshort_name); 
    14771479            len = strlen(test->hcontent); 
    1478             parsed_hdr2 = pjsip_parse_hdr(pool, &hname, test->hcontent, len, &parsed_len); 
     1480            parsed_hdr2 = (pjsip_hdr*) pjsip_parse_hdr(pool, &hname, test->hcontent, len, &parsed_len); 
    14791481            if (parsed_hdr2 == NULL) { 
    14801482                PJ_LOG(3,(THIS_FILE, "    error parsing header %s: %s", test->hshort_name, test->hcontent)); 
     
    14901492 
    14911493        /* Print the original header */ 
    1492         input = pj_pool_alloc(pool, 1024); 
     1494        input = (char*) pj_pool_alloc(pool, 1024); 
    14931495        len = pj_ansi_snprintf(input, 1024, "%s: %s", test->hname, test->hcontent); 
    14941496        if (len < 1 || len >= 1024) 
     
    14961498 
    14971499        /* Print the parsed header*/ 
    1498         output = pj_pool_alloc(pool, 1024); 
     1500        output = (char*) pj_pool_alloc(pool, 1024); 
    14991501        len = pjsip_hdr_print_on(parsed_hdr1, output, 1024); 
    15001502        if (len < 1 || len >= 1024) { 
  • pjproject/trunk/pjsip/src/test-pjsip/transport_test.c

    r974 r1266  
    561561 
    562562        /* Generate Call-ID for each thread. */ 
    563         rt_test_data[i].call_id.ptr = pj_pool_alloc(pool, rt_call_id.slen+1); 
     563        rt_test_data[i].call_id.ptr = (char*) pj_pool_alloc(pool, rt_call_id.slen+1); 
    564564        pj_strcpy(&rt_test_data[i].call_id, &rt_call_id); 
    565565        buf[0] = '0' + i; 
  • pjproject/trunk/pjsip/src/test-pjsip/tsx_bench.c

    r974 r1266  
    5454 
    5555    /* Create transaction array */ 
    56     tsx = pj_pool_zalloc(request->pool, working_set * sizeof(pj_pool_t*)); 
     56    tsx = (pjsip_transaction**) pj_pool_zalloc(request->pool, working_set * sizeof(pj_pool_t*)); 
    5757 
    5858    pj_bzero(&mod_tsx_user, sizeof(mod_tsx_user)); 
     
    131131    rdata.tp_info.pool = request->pool; 
    132132    rdata.msg_info.msg = request->msg; 
    133     rdata.msg_info.from = pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
    134     rdata.msg_info.to = pjsip_msg_find_hdr(request->msg, PJSIP_H_TO, NULL); 
    135     rdata.msg_info.cseq = pjsip_msg_find_hdr(request->msg, PJSIP_H_CSEQ, NULL); 
    136     rdata.msg_info.cid = pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
     133    rdata.msg_info.from = (pjsip_from_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
     134    rdata.msg_info.to = (pjsip_to_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_TO, NULL); 
     135    rdata.msg_info.cseq = (pjsip_cseq_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_CSEQ, NULL); 
     136    rdata.msg_info.cid = (pjsip_cid_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
    137137    rdata.msg_info.via = via; 
    138138     
     
    148148 
    149149    /* Create transaction array */ 
    150     tsx = pj_pool_zalloc(request->pool, working_set * sizeof(pj_pool_t*)); 
     150    tsx = (pjsip_transaction**) pj_pool_zalloc(request->pool, working_set * sizeof(pj_pool_t*)); 
    151151 
    152152    pj_bzero(&mod_tsx_user, sizeof(mod_tsx_user)); 
  • pjproject/trunk/pjsip/src/test-pjsip/tsx_uac_test.c

    r974 r1266  
    365365                PJ_LOG(3,(THIS_FILE,  
    366366                          "    error: prev state is %s instead of %s", 
    367                           pjsip_tsx_state_str(e->body.tsx_state.prev_state), 
     367                          pjsip_tsx_state_str((pjsip_tsx_state_e)e->body.tsx_state.prev_state), 
    368368                          pjsip_tsx_state_str(PJSIP_TSX_STATE_PROCEEDING))); 
    369369                test_complete = -739; 
     
    548548                                    struct pj_timer_entry *entry) 
    549549{ 
    550     struct response *r = entry->user_data; 
     550    struct response *r = (struct response*) entry->user_data; 
    551551    pjsip_transport *tp = r->res_addr.transport; 
    552552 
     
    760760 
    761761        /* Schedule sending final response in couple of of secs. */ 
    762         r = pj_pool_alloc(tdata->pool, sizeof(*r)); 
     762        r = PJ_POOL_ALLOC_T(tdata->pool, struct response); 
    763763        r->res_addr = res_addr; 
    764764        r->tdata = tdata; 
     
    881881 
    882882            /* Schedule sending final response in couple of of secs. */ 
    883             r = pj_pool_alloc(tdata->pool, sizeof(*r)); 
     883            r = PJ_POOL_ALLOC_T(tdata->pool, struct response); 
    884884            r->res_addr = res_addr; 
    885885            r->tdata = tdata; 
     
    969969 
    970970    /* Set the branch param for test 1. */ 
    971     via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     971    via = (pjsip_via_hdr*) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    972972    via->branch_param = pj_str(branch_param); 
    973973 
     
    10981098    enabled = msg_logger_set_enabled(0); 
    10991099 
    1100     for (i=0; i<PJ_ARRAY_SIZE(sub_test); ++i) { 
     1100    for (i=0; i<(int)PJ_ARRAY_SIZE(sub_test); ++i) { 
    11011101 
    11021102        PJ_LOG(3,(THIS_FILE,  
     
    12321232 
    12331233 
    1234     for (i=0; i<PJ_ARRAY_SIZE(delay); ++i) { 
     1234    for (i=0; i<(int)PJ_ARRAY_SIZE(delay); ++i) { 
    12351235 
    12361236        PJ_LOG(3,(THIS_FILE,  
     
    13031303 
    13041304    /* Do the test. */ 
    1305     for (i=0; i<PJ_ARRAY_SIZE(delay); ++i) { 
     1305    for (i=0; i<(int)PJ_ARRAY_SIZE(delay); ++i) { 
    13061306         
    13071307        if (test_param->type == PJSIP_TRANSPORT_LOOP_DGRAM) { 
     
    13441344 
    13451345    /* Get transport flag */ 
    1346     tp_flag = pjsip_transport_get_flag_from_type(test_param->type); 
     1346    tp_flag = pjsip_transport_get_flag_from_type((pjsip_transport_type_e)test_param->type); 
    13471347 
    13481348    pj_ansi_sprintf(TARGET_URI, "sip:bob@127.0.0.1:%d;transport=%s",  
  • pjproject/trunk/pjsip/src/test-pjsip/tsx_uas_test.c

    r974 r1266  
    209209{ 
    210210    pjsip_transaction *tsx; 
    211     struct response *r = entry->user_data; 
     211    struct response *r = (struct response*) entry->user_data; 
    212212    pj_status_t status; 
    213213 
     
    277277    } 
    278278 
    279     r = pj_pool_alloc(tdata->pool, sizeof(*r)); 
     279    r = PJ_POOL_ALLOC_T(tdata->pool, struct response); 
    280280    pj_strdup(tdata->pool, &r->tsx_key, tsx_key); 
    281281    r->tdata = tdata; 
     
    285285    pj_time_val_normalize(&delay); 
    286286 
    287     t = pj_pool_zalloc(tdata->pool, sizeof(*t)); 
     287    t = PJ_POOL_ZALLOC_T(tdata->pool, pj_timer_entry); 
    288288    t->user_data = r; 
    289289    t->cb = &send_response_timer; 
     
    10971097                uri->transport_param = pj_str("loop-dgram"); 
    10981098 
    1099                 via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     1099                via = (pjsip_via_hdr*) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    11001100                via->branch_param = pj_str(TEST9_BRANCH_ID); 
    11011101 
     
    11981198 
    11991199    /* Set the branch param for test 1. */ 
    1200     via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     1200    via = (pjsip_via_hdr*) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    12011201    via->branch_param = pj_str(branch_param); 
    12021202 
     
    14721472    int i, status; 
    14731473 
    1474     for (i=0; i<PJ_ARRAY_SIZE(tests); ++i) { 
     1474    for (i=0; i<(int)PJ_ARRAY_SIZE(tests); ++i) { 
    14751475        pj_time_val fail_time, end_test, now; 
    14761476 
     
    15331533 
    15341534    test_param = param; 
    1535     tp_flag = pjsip_transport_get_flag_from_type(param->type); 
     1535    tp_flag = pjsip_transport_get_flag_from_type((pjsip_transport_type_e)param->type); 
    15361536 
    15371537    pj_ansi_sprintf(TARGET_URI, "sip:bob@127.0.0.1:%d;transport=%s",  
  • pjproject/trunk/pjsip/src/test-pjsip/txdata_test.c

    r974 r1266  
    445445 
    446446    /* Fill up the Via header to prevent syntax error on parsing */ 
    447     via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
     447    via = (pjsip_via_hdr*) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL); 
    448448    via->transport = pj_str("TCP"); 
    449449    via->sent_by.host = pj_str("127.0.0.1"); 
     
    708708    via->branch_param = pj_str("012345678901234567890123456789"); 
    709709    via->recvd_param = pj_str("192.168.0.7"); 
    710     pjsip_msg_insert_first_hdr(request->msg, pjsip_hdr_clone(request->pool, via)); 
    711     pjsip_msg_insert_first_hdr(request->msg, pjsip_hdr_clone(request->pool, via)); 
     710    pjsip_msg_insert_first_hdr(request->msg, (pjsip_hdr*) pjsip_hdr_clone(request->pool, via)); 
     711    pjsip_msg_insert_first_hdr(request->msg, (pjsip_hdr*) pjsip_hdr_clone(request->pool, via)); 
    712712    pjsip_msg_insert_first_hdr(request->msg, (pjsip_hdr*)via); 
    713713     
     
    717717    rdata.tp_info.pool = request->pool; 
    718718    rdata.msg_info.msg = request->msg; 
    719     rdata.msg_info.from = pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
    720     rdata.msg_info.to = pjsip_msg_find_hdr(request->msg, PJSIP_H_TO, NULL); 
    721     rdata.msg_info.cseq = pjsip_msg_find_hdr(request->msg, PJSIP_H_CSEQ, NULL); 
    722     rdata.msg_info.cid = pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
     719    rdata.msg_info.from = (pjsip_from_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
     720    rdata.msg_info.to = (pjsip_to_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_TO, NULL); 
     721    rdata.msg_info.cseq = (pjsip_cseq_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_CSEQ, NULL); 
     722    rdata.msg_info.cid = (pjsip_cid_hdr*) pjsip_msg_find_hdr(request->msg, PJSIP_H_FROM, NULL); 
    723723    rdata.msg_info.via = via; 
    724724 
  • pjproject/trunk/pjsip/src/test-pjsip/uri_test.c

    r1231 r1266  
    383383        do { \ 
    384384            pjsip_param *param; \ 
    385             param=pj_pool_alloc(pool, sizeof(pjsip_param)); \ 
     385            param=PJ_POOL_ALLOC_T(pool, pjsip_param); \ 
    386386            param->name = pj_str(pname); \ 
    387387            param->value = pj_str(pvalue); \ 
     
    663663    uri->number = pj_str("911"); 
    664664     
    665     p = pj_pool_alloc(pool, sizeof(*p)); 
     665    p = PJ_POOL_ALLOC_T(pool, pjsip_param); 
    666666    p->name = p->value = pj_str("p1"); 
    667667    pj_list_insert_before(&uri->other_param, p); 
     
    726726 
    727727    /* Print both URI. */ 
    728     s1.ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
    729     s2.ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
     728    s1.ptr = (char*) pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
     729    s2.ptr = (char*) pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE); 
    730730 
    731731    pj_get_timestamp(&t1); 
Note: See TracChangeset for help on using the changeset viewer.