Changeset 4728


Ignore:
Timestamp:
Feb 4, 2014 10:13:56 AM (7 years ago)
Author:
bennylp
Message:

Misc (re #1630): Fixing warnings about variable set but not used with recent gcc

Location:
pjproject/trunk
Files:
26 edited

Legend:

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

    r4537 r4728  
    4646    pj_thread_t        *input_thread; 
    4747    pj_bool_t           thread_quit; 
    48     pj_sem_t           *thread_sem;    
    49     pj_cli_console_cfg  cfg;     
     48    pj_sem_t           *thread_sem; 
     49    pj_cli_console_cfg  cfg; 
    5050 
    5151    struct async_input_t 
    52     {         
     52    { 
    5353        char       *buf; 
    54         unsigned    maxlen;      
     54        unsigned    maxlen; 
    5555        pj_sem_t   *sem; 
    5656    } input; 
     
    127127    if (!pool) 
    128128        return PJ_ENOMEM; 
    129          
     129 
    130130    sess = PJ_POOL_ZALLOC_T(pool, pj_cli_sess); 
    131131    fe = PJ_POOL_ZALLOC_T(pool, struct cli_console_fe); 
     
    136136    } 
    137137    sess->fe = &fe->base; 
    138     sess->log_level = param->log_level;     
     138    sess->log_level = param->log_level; 
    139139    sess->op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_sess_op); 
    140140    fe->base.op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_front_end_op); 
     
    155155 
    156156    pj_cli_register_front_end(cli, &fe->base); 
    157     if (param->prompt_str.slen == 0) {   
     157    if (param->prompt_str.slen == 0) { 
    158158        pj_str_t prompt_sign = pj_str(">>> "); 
    159159        fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool, prompt_sign.slen+1); 
    160         pj_strcpy(&fe->cfg.prompt_str, &prompt_sign);    
     160        pj_strcpy(&fe->cfg.prompt_str, &prompt_sign); 
    161161    } else { 
    162         fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool,  
     162        fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool, 
    163163                                               param->prompt_str.slen+1); 
    164164        pj_strcpy(&fe->cfg.prompt_str, &param->prompt_str); 
    165     }     
    166     fe->cfg.prompt_str.ptr[fe->cfg.prompt_str.slen] = 0;  
     165    } 
     166    fe->cfg.prompt_str.ptr[fe->cfg.prompt_str.slen] = 0; 
    167167 
    168168    if (param->quit_command.slen) 
     
    184184    send_data.ptr = data_str; 
    185185    send_data.slen = 0; 
    186      
     186 
    187187    pj_strcat(&send_data, &fe->cfg.prompt_str); 
    188188    send_data.ptr[send_data.slen] = 0; 
     
    191191} 
    192192 
    193 static void send_err_arg(pj_cli_sess *sess,  
    194                          const pj_cli_exec_info *info,  
     193static void send_err_arg(pj_cli_sess *sess, 
     194                         const pj_cli_exec_info *info, 
    195195                         const pj_str_t *msg, 
    196196                         pj_bool_t with_return) 
     
    219219 
    220220    send_data.ptr[send_data.slen] = 0; 
    221     printf("%s", send_data.ptr);     
    222 } 
    223  
    224 static void send_inv_arg(pj_cli_sess *sess,  
     221    printf("%s", send_data.ptr); 
     222} 
     223 
     224static void send_inv_arg(pj_cli_sess *sess, 
    225225                         const pj_cli_exec_info *info, 
    226226                         pj_bool_t with_return) 
     
    230230} 
    231231 
    232 static void send_too_many_arg(pj_cli_sess *sess,  
     232static void send_too_many_arg(pj_cli_sess *sess, 
    233233                              const pj_cli_exec_info *info, 
    234234                              pj_bool_t with_return) 
     
    238238} 
    239239 
    240 static void send_hint_arg(pj_str_t *send_data,  
     240static void send_hint_arg(pj_str_t *send_data, 
    241241                          const pj_str_t *desc, 
    242242                          pj_ssize_t cmd_len, 
     
    257257} 
    258258 
    259 static void send_ambi_arg(pj_cli_sess *sess,  
     259static void send_ambi_arg(pj_cli_sess *sess, 
    260260                          const pj_cli_exec_info *info, 
    261261                          pj_bool_t with_return) 
     
    270270    pj_ssize_t max_length = 0; 
    271271    pj_ssize_t cmd_length = 0; 
    272     const pj_str_t *cmd_desc = 0; 
    273272    static const pj_str_t sc_type = {"sc", 2}; 
    274273    static const pj_str_t choice_type = {"choice", 6}; 
    275274    send_data.ptr = data; 
    276275    send_data.slen = 0; 
    277      
     276 
    278277    if (with_return) 
    279278        pj_strcat2(&send_data, "\r\n"); 
     
    284283        pj_strcat2(&send_data, " "); 
    285284    } 
    286     pj_strcat2(&send_data, "^");         
     285    pj_strcat2(&send_data, "^"); 
    287286    /* Get the max length of the command name */ 
    288287    for (i=0;i<info->hint_cnt;++i) { 
    289         if ((&hint[i].type) && (hint[i].type.slen > 0)) {            
    290             if (pj_stricmp(&hint[i].type, &sc_type) == 0) {              
     288        if ((&hint[i].type) && (hint[i].type.slen > 0)) { 
     289            if (pj_stricmp(&hint[i].type, &sc_type) == 0) { 
    291290                if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) { 
    292291                    cmd_length += (hint[i].name.slen + 3); 
    293292                } else { 
    294293                    cmd_length = hint[i].name.slen; 
    295                 }                
     294                } 
    296295            } else { 
    297296                cmd_length = hint[i].name.slen; 
    298297            } 
    299         } else {                     
     298        } else { 
    300299            cmd_length = hint[i].name.slen; 
    301300        } 
     
    308307    cmd_length = 0; 
    309308    for (i=0;i<info->hint_cnt;++i) { 
    310         if ((&hint[i].type) && (hint[i].type.slen > 0)) {            
     309        if ((&hint[i].type) && (hint[i].type.slen > 0)) { 
    311310            if (pj_stricmp(&hint[i].type, &sc_type) == 0) { 
    312311                parse_state = OP_SHORTCUT; 
     
    316315                parse_state = OP_TYPE; 
    317316            } 
    318         } else {                     
     317        } else { 
    319318            parse_state = OP_NORMAL; 
    320319        } 
     
    324323            cmd_length = hint[i].name.slen; 
    325324        } 
    326      
     325 
    327326        switch (parse_state) { 
    328327        case OP_CHOICE: 
    329328            pj_strcat2(&send_data, "["); 
    330329            pj_strcat(&send_data, &hint[i].name); 
    331             pj_strcat2(&send_data, "]");         
     330            pj_strcat2(&send_data, "]"); 
    332331            break; 
    333332        case OP_TYPE: 
    334333            pj_strcat2(&send_data, "<"); 
    335334            pj_strcat(&send_data, &hint[i].type); 
    336             pj_strcat2(&send_data, ">");         
     335            pj_strcat2(&send_data, ">"); 
    337336            break; 
    338337        case OP_SHORTCUT: 
    339338            /* Format : "Command | sc |  description" */ 
    340             {            
     339            { 
    341340                cmd_length += hint[i].name.slen; 
    342341                if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) { 
    343342                    pj_strcat2(&send_data, " | "); 
    344                     cmd_length += 3;                 
     343                    cmd_length += 3; 
    345344                } else { 
    346345                    pj_strcat2(&send_data, "\r\n  "); 
    347346                } 
    348                 pj_strcat(&send_data, &hint[i].name);    
     347                pj_strcat(&send_data, &hint[i].name); 
    349348            } 
    350349            break; 
    351350        default: 
    352351            pj_strcat(&send_data, &hint[i].name); 
    353             cmd_desc = &hint[i].desc; 
    354352            break; 
    355353        } 
    356          
    357         if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) ||  
     354 
     355        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) || 
    358356            ((i+1) >= info->hint_cnt) || 
    359             (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen)))  
     357            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen))) 
    360358        { 
    361359            /* Add description info */ 
     
    364362            cmd_length = 0; 
    365363        } 
    366     }   
     364    } 
    367365    pj_strcat2(&send_data, "\r\n"); 
    368366    pj_strcat(&send_data, &fe->cfg.prompt_str); 
    369367    send_data.ptr[send_data.slen] = 0; 
    370     printf("%s", send_data.ptr);     
     368    printf("%s", send_data.ptr); 
    371369} 
    372370 
     
    375373    pj_status_t status; 
    376374    pj_bool_t retval = PJ_TRUE; 
    377      
     375 
    378376    pj_pool_t *pool; 
    379377    pj_cli_cmd_val *cmd_val; 
     
    388386 
    389387    cmd_val = PJ_POOL_ZALLOC_T(pool, pj_cli_cmd_val); 
    390      
    391     status = pj_cli_sess_parse(sess, recv_buf, cmd_val,  
     388 
     389    status = pj_cli_sess_parse(sess, recv_buf, cmd_val, 
    392390                               pool, &info); 
    393391 
    394392    switch (status) { 
    395393    case PJ_CLI_EINVARG: 
    396         send_inv_arg(sess, &info, PJ_TRUE);              
     394        send_inv_arg(sess, &info, PJ_TRUE); 
    397395        break; 
    398396    case PJ_CLI_ETOOMANYARGS: 
     
    403401        send_ambi_arg(sess, &info, PJ_TRUE); 
    404402        break; 
    405     case PJ_SUCCESS:     
    406         if (info.hint_cnt > 0) {         
    407             /* Compelete command */          
    408             send_ambi_arg(sess, &info, PJ_TRUE);                         
     403    case PJ_SUCCESS: 
     404        if (info.hint_cnt > 0) { 
     405            /* Compelete command */ 
     406            send_ambi_arg(sess, &info, PJ_TRUE); 
    409407        } else { 
    410408            retval = PJ_FALSE; 
    411         }        
    412         break; 
    413     } 
    414  
    415     pj_pool_release(pool);       
    416     return retval;  
     409        } 
     410        break; 
     411    } 
     412 
     413    pj_pool_release(pool); 
     414    return retval; 
    417415} 
    418416 
     
    421419    pj_status_t status; 
    422420    pj_bool_t retval = PJ_TRUE; 
    423      
    424     pj_pool_t *pool;     
     421 
     422    pj_pool_t *pool; 
    425423    pj_cli_exec_info info; 
    426424    pj_cli_t *cli = sess->fe->cli; 
    427425    struct cli_console_fe *fe = (struct cli_console_fe *)sess->fe; 
    428426    char *recv_buf = fe->input.buf; 
    429          
     427 
    430428    printf("\r\n"); 
    431429 
    432430    pool = pj_pool_create(pj_cli_get_param(cli)->pf, "handle_exec", 
    433431                          PJ_CLI_CONSOLE_POOL_SIZE, PJ_CLI_CONSOLE_POOL_INC, 
    434                           NULL);     
    435      
    436     status = pj_cli_sess_exec(sess, recv_buf,  
     432                          NULL); 
     433 
     434    status = pj_cli_sess_exec(sess, recv_buf, 
    437435                              pool, &info); 
    438436 
    439437    switch (status) { 
    440438    case PJ_CLI_EINVARG: 
    441         send_inv_arg(sess, &info, PJ_FALSE);     
     439        send_inv_arg(sess, &info, PJ_FALSE); 
    442440        break; 
    443441    case PJ_CLI_ETOOMANYARGS: 
     
    452450        break; 
    453451    case PJ_SUCCESS: 
    454         send_prompt_str(sess);   
    455         break; 
    456     }     
    457  
    458     pj_pool_release(pool);       
    459     return retval;  
     452        send_prompt_str(sess); 
     453        break; 
     454    } 
     455 
     456    pj_pool_release(pool); 
     457    return retval; 
    460458} 
    461459 
    462460static int readline_thread(void * p) 
    463 {     
     461{ 
    464462    struct cli_console_fe * fe = (struct cli_console_fe *)p; 
    465463 
     
    473471 
    474472        if (fgets(recv_buf, fe->input.maxlen, stdin) == NULL) { 
    475             /*  
     473            /* 
    476474             * Be friendly to users who redirect commands into 
    477475             * program, when file ends, resume with kbd. 
     
    488486                puts("Cannot switch back to console from file redirection"); 
    489487                if (fe->cfg.quit_command.slen) { 
    490                     pj_memcpy(recv_buf, fe->cfg.quit_command.ptr,  
     488                    pj_memcpy(recv_buf, fe->cfg.quit_command.ptr, 
    491489                              fe->input.maxlen); 
    492490                } 
    493                 recv_buf[fe->cfg.quit_command.slen] = '\0';              
     491                recv_buf[fe->cfg.quit_command.slen] = '\0'; 
    494492            } else { 
    495493                puts("Switched back to console from file redirection"); 
     
    506504            break; 
    507505        } 
    508         input_len = pj_ansi_strlen(fe->input.buf);       
     506        input_len = pj_ansi_strlen(fe->input.buf); 
    509507        if ((input_len > 1) && (fe->input.buf[input_len-2] == '?')) { 
    510508            fe->input.buf[input_len-1] = 0; 
     
    516514        } 
    517515 
    518         pj_sem_post(fe->input.sem);         
     516        pj_sem_post(fe->input.sem); 
    519517        pj_sem_wait(fe->thread_sem); 
    520     }     
     518    } 
    521519 
    522520    return 0; 
    523521} 
    524522 
    525 PJ_DEF(pj_status_t) pj_cli_console_process(pj_cli_sess *sess,  
     523PJ_DEF(pj_status_t) pj_cli_console_process(pj_cli_sess *sess, 
    526524                                           char *buf, 
    527525                                           unsigned maxlen) 
  • pjproject/trunk/pjlib-util/src/pjlib-util/cli_telnet.c

    r4537 r4728  
    3737    (defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0) 
    3838 
    39 #define EADDRINUSE WSAEADDRINUSE  
     39#define EADDRINUSE WSAEADDRINUSE 
    4040 
    4141#endif 
     
    6767 * This specify the state for the telnet option negotiation. 
    6868 */ 
    69 enum cli_telnet_option_states  
    70 {     
     69enum cli_telnet_option_states 
     70{ 
    7171    OPT_DISABLE,                /* Option disable */ 
    7272    OPT_ENABLE,                 /* Option enable */ 
    7373    OPT_EXPECT_DISABLE,         /* Already send disable req, expecting resp */ 
    7474    OPT_EXPECT_ENABLE,          /* Already send enable req, expecting resp */ 
    75     OPT_EXPECT_DISABLE_REV,     /* Already send disable req, expecting resp,  
     75    OPT_EXPECT_DISABLE_REV,     /* Already send disable req, expecting resp, 
    7676                                 * need to send enable req */ 
    7777    OPT_EXPECT_ENABLE_REV       /* Already send enable req, expecting resp, 
     
    199199}; 
    200200 
    201 enum terminal_cmd  
     201enum terminal_cmd 
    202202{ 
    203203    TC_ESC              = 27, 
     
    207207    TC_LEFT             = 68, 
    208208    TC_END              = 70, 
    209     TC_HOME             = 72,     
     209    TC_HOME             = 72, 
    210210    TC_CTRL_C           = 3, 
    211211    TC_CR               = 13, 
     
    229229 
    230230/** 
    231  * This structure contains the command line shown to the user.  
    232  * The telnet also needs to maintain and manage command cursor position.  
     231 * This structure contains the command line shown to the user. 
     232 * The telnet also needs to maintain and manage command cursor position. 
    233233 * Due to that reason, the insert/delete character process from buffer will 
    234234 * consider its current cursor position. 
     
    252252 
    253253/** 
    254  * This structure contains the command history executed by user.  
     254 * This structure contains the command history executed by user. 
    255255 * Besides storing the command history, it is necessary to be able 
    256256 * to browse it. 
     
    291291    pj_thread_t            *worker_thread; 
    292292    pj_bool_t               is_quitting; 
    293     pj_mutex_t             *mutex;     
     293    pj_mutex_t             *mutex; 
    294294} cli_telnet_fe; 
    295295 
     
    305305 
    306306/** 
    307  * Return the number of characters between the current cursor position  
     307 * Return the number of characters between the current cursor position 
    308308 * to the end of line. 
    309309 */ 
     
    314314 
    315315/** 
    316  * Insert character to the receive buffer.  
    317  */ 
    318 static pj_bool_t recv_buf_insert(telnet_recv_buf *recv_buf,  
    319                                  unsigned char *data)  
    320 {     
     316 * Insert character to the receive buffer. 
     317 */ 
     318static pj_bool_t recv_buf_insert(telnet_recv_buf *recv_buf, 
     319                                 unsigned char *data) 
     320{ 
    321321    if (recv_buf->len+1 >= PJ_CLI_MAX_CMDBUF) { 
    322322        return PJ_FALSE; 
    323     } else {     
     323    } else { 
    324324        if (*data == '\t' || *data == '?' || *data == '\r') { 
    325325            /* Always insert to the end of line */ 
     
    328328            /* Insert based on the current cursor pos */ 
    329329            unsigned cur_pos = recv_buf->cur_pos; 
    330             unsigned rlen = recv_buf_right_len(recv_buf);            
    331             if (rlen > 0) {                  
     330            unsigned rlen = recv_buf_right_len(recv_buf); 
     331            if (rlen > 0) { 
    332332                /* Shift right characters */ 
    333                 pj_memmove(&recv_buf->rbuf[cur_pos+1],  
    334                            &recv_buf->rbuf[cur_pos],  
     333                pj_memmove(&recv_buf->rbuf[cur_pos+1], 
     334                           &recv_buf->rbuf[cur_pos], 
    335335                           rlen+1); 
    336             }  
     336            } 
    337337            recv_buf->rbuf[cur_pos] = *data; 
    338338        } 
     
    356356            unsigned cur_pos = recv_buf->cur_pos; 
    357357            /* Shift left characters */ 
    358             pj_memmove(&recv_buf->rbuf[cur_pos-1], &recv_buf->rbuf[cur_pos],  
     358            pj_memmove(&recv_buf->rbuf[cur_pos-1], &recv_buf->rbuf[cur_pos], 
    359359                       rlen); 
    360360        } 
     
    362362        --recv_buf->len; 
    363363        recv_buf->rbuf[recv_buf->len] = 0; 
    364     }     
     364    } 
    365365    return PJ_TRUE; 
    366366} 
     
    373373 
    374374/** 
    375  * Insert the command to history. If the entered command is not on the list,  
    376  * a new entry will be created. All entered command will be moved to  
    377  * the first entry of the history.  
    378  */ 
    379 static pj_status_t insert_history(cli_telnet_sess *sess,                                  
     375 * Insert the command to history. If the entered command is not on the list, 
     376 * a new entry will be created. All entered command will be moved to 
     377 * the first entry of the history. 
     378 */ 
     379static pj_status_t insert_history(cli_telnet_sess *sess, 
    380380                                  char *cmd_val) 
    381381{ 
     
    393393    in_history = pj_list_search(sess->history, (void*)&cmd, compare_str); 
    394394    if (!in_history) { 
    395         if (pj_list_size(sess->history) < PJ_CLI_MAX_CMD_HISTORY) {          
     395        if (pj_list_size(sess->history) < PJ_CLI_MAX_CMD_HISTORY) { 
    396396            char *data_history; 
    397397            in_history = PJ_POOL_ZALLOC_T(sess->pool, cmd_history); 
    398398            pj_list_init(in_history); 
    399             data_history = (char *)pj_pool_calloc(sess->pool,  
     399            data_history = (char *)pj_pool_calloc(sess->pool, 
    400400                           sizeof(char), PJ_CLI_MAX_CMDBUF); 
    401401            in_history->command.ptr = data_history; 
     
    404404            /* Get the oldest history */ 
    405405            in_history = sess->history->prev; 
    406         }            
     406        } 
    407407    } else { 
    408408        pj_list_insert_nodes_after(in_history->prev, in_history->next); 
     
    416416 
    417417/** 
    418  * Get the next or previous history of the shown/active history.  
     418 * Get the next or previous history of the shown/active history. 
    419419 */ 
    420420static pj_str_t* get_prev_history(cli_telnet_sess *sess, pj_bool_t is_forward) 
     
    434434        return NULL; 
    435435    } else { 
    436         if (is_forward) {            
    437             node = (node->next==root)?node->next->next:node->next;           
     436        if (is_forward) { 
     437            node = (node->next==root)?node->next->next:node->next; 
    438438        } else { 
    439             node = (node->prev==root)?node->prev->prev:node->prev;           
     439            node = (node->prev==root)?node->prev->prev:node->prev; 
    440440        } 
    441441        retval = &node->command; 
     
    451451 * referenced - (RFC-854). 
    452452 */ 
    453 static pj_bool_t send_telnet_cmd(cli_telnet_sess *sess,  
    454                                  cli_telnet_command cmd,  
     453static pj_bool_t send_telnet_cmd(cli_telnet_sess *sess, 
     454                                 cli_telnet_command cmd, 
    455455                                 unsigned char option) 
    456 {        
     456{ 
    457457    unsigned char buf[3]; 
    458458    PJ_ASSERT_RETURN(sess, PJ_FALSE); 
     
    470470 * For local option: send WILL. 
    471471 * For remote option: send DO. 
    472  * This method also handle the state transition of the ENABLE  
     472 * This method also handle the state transition of the ENABLE 
    473473 * negotiation process. 
    474474 */ 
    475 static pj_bool_t send_enable_option(cli_telnet_sess *sess,  
    476                                     pj_bool_t is_local,  
     475static pj_bool_t send_enable_option(cli_telnet_sess *sess, 
     476                                    pj_bool_t is_local, 
    477477                                    unsigned char option) 
    478478{ 
     
    500500            *state = OPT_EXPECT_ENABLE; 
    501501            break; 
    502         case OPT_EXPECT_DISABLE_REV:         
     502        case OPT_EXPECT_DISABLE_REV: 
    503503            *state = OPT_DISABLE; 
    504504            break; 
     
    509509} 
    510510 
    511 static pj_bool_t send_cmd_do(cli_telnet_sess *sess,  
     511static pj_bool_t send_cmd_do(cli_telnet_sess *sess, 
    512512                             unsigned char option) 
    513513{ 
     
    515515} 
    516516 
    517 static pj_bool_t send_cmd_will(cli_telnet_sess *sess,  
     517static pj_bool_t send_cmd_will(cli_telnet_sess *sess, 
    518518                               unsigned char option) 
    519519{ 
     
    523523/** 
    524524 * This method will handle receiving telnet's ENABLE option negotiation. 
    525  * This method also handle the state transition of the ENABLE  
    526  * negotiation process.  
    527  */ 
    528 static pj_bool_t receive_enable_option(cli_telnet_sess *sess,  
    529                                        pj_bool_t is_local,  
     525 * This method also handle the state transition of the ENABLE 
     526 * negotiation process. 
     527 */ 
     528static pj_bool_t receive_enable_option(cli_telnet_sess *sess, 
     529                                       pj_bool_t is_local, 
    530530                                       unsigned char option) 
    531531{ 
     
    550550            } 
    551551            break; 
    552         case OPT_EXPECT_ENABLE:      
     552        case OPT_EXPECT_ENABLE: 
    553553            *state = OPT_ENABLE; 
    554554            break; 
    555         case OPT_EXPECT_DISABLE:             
     555        case OPT_EXPECT_DISABLE: 
    556556            *state = OPT_DISABLE; 
    557557            break; 
    558558        case OPT_EXPECT_ENABLE_REV: 
    559559            *state = OPT_EXPECT_DISABLE; 
    560             send_telnet_cmd(sess, is_local?WONT:DONT, option);       
     560            send_telnet_cmd(sess, is_local?WONT:DONT, option); 
    561561            break; 
    562562        case OPT_EXPECT_DISABLE_REV: 
     
    566566            return PJ_FALSE; 
    567567    } 
    568     return PJ_TRUE;         
     568    return PJ_TRUE; 
    569569} 
    570570 
    571571/** 
    572572 * This method will handle receiving telnet's DISABLE option negotiation. 
    573  * This method also handle the state transition of the DISABLE  
    574  * negotiation process.  
    575  */ 
    576 static pj_bool_t receive_disable_option(cli_telnet_sess *sess,  
    577                                         pj_bool_t is_local,  
     573 * This method also handle the state transition of the DISABLE 
     574 * negotiation process. 
     575 */ 
     576static pj_bool_t receive_disable_option(cli_telnet_sess *sess, 
     577                                        pj_bool_t is_local, 
    578578                                        unsigned char option) 
    579579{ 
     
    585585    sess_opt = &sess->telnet_option[option]; 
    586586    state = is_local?(&sess_opt->local_state):(&sess_opt->peer_state); 
    587      
     587 
    588588    switch (*state) { 
    589589        case OPT_ENABLE: 
     
    595595            /* Ignore if already enabled */ 
    596596            break; 
    597         case OPT_EXPECT_ENABLE:      
     597        case OPT_EXPECT_ENABLE: 
    598598        case OPT_EXPECT_DISABLE: 
    599599            *state = OPT_DISABLE; 
     
    601601        case OPT_EXPECT_ENABLE_REV: 
    602602            *state = OPT_DISABLE; 
    603             send_telnet_cmd(sess, is_local?WONT:DONT, option);       
     603            send_telnet_cmd(sess, is_local?WONT:DONT, option); 
    604604            break; 
    605605        case OPT_EXPECT_DISABLE_REV: 
     
    610610            return PJ_FALSE; 
    611611    } 
    612     return PJ_TRUE;        
     612    return PJ_TRUE; 
    613613} 
    614614 
     
    633633} 
    634634 
    635 static void set_local_option(cli_telnet_sess *sess,  
    636                              unsigned char option,  
    637                              pj_bool_t enable)  
     635static void set_local_option(cli_telnet_sess *sess, 
     636                             unsigned char option, 
     637                             pj_bool_t enable) 
    638638{ 
    639639    sess->telnet_option[option].local_is_enable = enable; 
    640640} 
    641641 
    642 static void set_peer_option(cli_telnet_sess *sess,  
    643                             unsigned char option,  
    644                             pj_bool_t enable)  
     642static void set_peer_option(cli_telnet_sess *sess, 
     643                            unsigned char option, 
     644                            pj_bool_t enable) 
    645645{ 
    646646    sess->telnet_option[option].peer_is_enable = enable; 
    647647} 
    648648 
    649 static pj_bool_t is_local_option_state_ena(cli_telnet_sess *sess,  
     649static pj_bool_t is_local_option_state_ena(cli_telnet_sess *sess, 
    650650                                           unsigned char option) 
    651 {     
     651{ 
    652652    return (sess->telnet_option[option].local_state == OPT_ENABLE); 
    653653} 
    654654 
    655 static void send_return_key(cli_telnet_sess *sess)  
    656 {     
     655static void send_return_key(cli_telnet_sess *sess) 
     656{ 
    657657    telnet_sess_send2(sess, (unsigned char*)"\r\n", 2); 
    658658} 
     
    671671    send_data.ptr = data_str; 
    672672    send_data.slen = 0; 
    673      
     673 
    674674    pj_strcat(&send_data, &fe->cfg.prompt_str); 
    675675 
     
    681681 * the error position of the source command. 
    682682 */ 
    683 static void send_err_arg(cli_telnet_sess *sess,  
    684                          const pj_cli_exec_info *info,  
     683static void send_err_arg(cli_telnet_sess *sess, 
     684                         const pj_cli_exec_info *info, 
    685685                         const pj_str_t *msg, 
    686686                         pj_bool_t with_return, 
     
    715715} 
    716716 
    717 static void send_inv_arg(cli_telnet_sess *sess,  
     717static void send_inv_arg(cli_telnet_sess *sess, 
    718718                         const pj_cli_exec_info *info, 
    719719                         pj_bool_t with_return, 
     
    724724} 
    725725 
    726 static void send_too_many_arg(cli_telnet_sess *sess,  
     726static void send_too_many_arg(cli_telnet_sess *sess, 
    727727                              const pj_cli_exec_info *info, 
    728728                              pj_bool_t with_return, 
     
    733733} 
    734734 
    735 static void send_hint_arg(cli_telnet_sess *sess,  
    736                           pj_str_t *send_data,  
     735static void send_hint_arg(cli_telnet_sess *sess, 
     736                          pj_str_t *send_data, 
    737737                          const pj_str_t *desc, 
    738738                          pj_ssize_t cmd_len, 
     
    756756 * is ambiguous. It will show the matching command as the hint information. 
    757757 */ 
    758 static void send_ambi_arg(cli_telnet_sess *sess,  
     758static void send_ambi_arg(cli_telnet_sess *sess, 
    759759                          const pj_cli_exec_info *info, 
    760760                          pj_bool_t with_return, 
     
    770770    pj_ssize_t max_length = 0; 
    771771    pj_ssize_t cmd_length = 0; 
    772     const pj_str_t *cmd_desc = 0; 
    773772    static const pj_str_t sc_type = {"sc", 2}; 
    774773    static const pj_str_t choice_type = {"choice", 6}; 
    775774    send_data.ptr = data; 
    776775    send_data.slen = 0; 
    777      
     776 
    778777    if (with_return) 
    779778        pj_strcat2(&send_data, "\r\n"); 
     
    787786    /* Get the max length of the command name */ 
    788787    for (i=0;i<info->hint_cnt;++i) { 
    789         if ((&hint[i].type) && (hint[i].type.slen > 0)) {            
    790             if (pj_stricmp(&hint[i].type, &sc_type) == 0) {              
     788        if ((&hint[i].type) && (hint[i].type.slen > 0)) { 
     789            if (pj_stricmp(&hint[i].type, &sc_type) == 0) { 
    791790                if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) { 
    792791                    cmd_length += (hint[i].name.slen + 3); 
    793792                } else { 
    794793                    cmd_length = hint[i].name.slen; 
    795                 }                
     794                } 
    796795            } else { 
    797796                cmd_length = hint[i].name.slen; 
    798797            } 
    799         } else {                     
     798        } else { 
    800799            cmd_length = hint[i].name.slen; 
    801800        } 
     
    805804        } 
    806805    } 
    807      
     806 
    808807    cmd_length = 0; 
    809808    /* Build hint information */ 
    810     for (i=0;i<info->hint_cnt;++i) {                     
    811         if ((&hint[i].type) && (hint[i].type.slen > 0)) {            
     809    for (i=0;i<info->hint_cnt;++i) { 
     810        if ((&hint[i].type) && (hint[i].type.slen > 0)) { 
    812811            if (pj_stricmp(&hint[i].type, &sc_type) == 0) { 
    813812                parse_state = OP_SHORTCUT; 
     
    817816                parse_state = OP_TYPE; 
    818817            } 
    819         } else {                     
     818        } else { 
    820819            parse_state = OP_NORMAL; 
    821820        } 
    822          
     821 
    823822        if (parse_state != OP_SHORTCUT) { 
    824823            pj_strcat2(&send_data, "\r\n  "); 
    825824            cmd_length = hint[i].name.slen; 
    826         }            
    827          
     825        } 
     826 
    828827        switch (parse_state) { 
    829828        case OP_CHOICE: 
    830             /* Format : "[Choice Value]  description" */             
     829            /* Format : "[Choice Value]  description" */ 
    831830            pj_strcat2(&send_data, "["); 
    832831            pj_strcat(&send_data, &hint[i].name); 
    833             pj_strcat2(&send_data, "]");         
     832            pj_strcat2(&send_data, "]"); 
    834833            break; 
    835834        case OP_TYPE: 
     
    837836            pj_strcat2(&send_data, "<"); 
    838837            pj_strcat(&send_data, &hint[i].name); 
    839             pj_strcat2(&send_data, ">");         
     838            pj_strcat2(&send_data, ">"); 
    840839            break; 
    841840        case OP_SHORTCUT: 
    842841            /* Format : "Command | sc |  description" */ 
    843             {            
     842            { 
    844843                cmd_length += hint[i].name.slen; 
    845844                if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) { 
    846845                    pj_strcat2(&send_data, " | "); 
    847                     cmd_length += 3;                 
     846                    cmd_length += 3; 
    848847                } else { 
    849848                    pj_strcat2(&send_data, "\r\n  "); 
    850849                } 
    851                 pj_strcat(&send_data, &hint[i].name);    
     850                pj_strcat(&send_data, &hint[i].name); 
    852851            } 
    853852            break; 
     
    855854            /* Command */ 
    856855            pj_strcat(&send_data, &hint[i].name); 
    857             cmd_desc = &hint[i].desc;        
    858             break; 
    859         } 
    860          
    861         if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) ||  
     856            break; 
     857        } 
     858 
     859        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) || 
    862860            ((i+1) >= info->hint_cnt) || 
    863             (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen)))  
     861            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen))) 
    864862        { 
    865863            /* Add description info */ 
    866             send_hint_arg(sess, &send_data,  
    867                           &hint[i].desc, cmd_length,  
     864            send_hint_arg(sess, &send_data, 
     865                          &hint[i].desc, cmd_length, 
    868866                          max_length); 
    869867 
    870868            cmd_length = 0; 
    871         }        
    872     }   
    873     pj_strcat2(&send_data, "\r\n");        
     869        } 
     870    } 
     871    pj_strcat2(&send_data, "\r\n"); 
    874872    pj_strcat(&send_data, &fe->cfg.prompt_str); 
    875873    if (with_last_cmd) 
    876874        pj_strcat2(&send_data, (char *)sess->rcmd->rbuf); 
    877875 
    878     telnet_sess_send(sess, &send_data);     
     876    telnet_sess_send(sess, &send_data); 
    879877} 
    880878 
     
    882880 * This method is to send command completion of the entered command. 
    883881 */ 
    884 static void send_comp_arg(cli_telnet_sess *sess,  
     882static void send_comp_arg(cli_telnet_sess *sess, 
    885883                          pj_cli_exec_info *info) 
    886884{ 
     
    893891    send_data.slen = 0; 
    894892 
    895     pj_strcat(&send_data, &info->hint[0].name);         
     893    pj_strcat(&send_data, &info->hint[0].name); 
    896894 
    897895    telnet_sess_send(sess, &send_data); 
     
    902900 */ 
    903901static pj_bool_t handle_alfa_num(cli_telnet_sess *sess, unsigned char *data) 
    904 {         
     902{ 
    905903    if (is_local_option_state_ena(sess, TERM_ECHO)) { 
    906904        if (recv_buf_right_len(sess->rcmd) > 0) { 
    907             /* Cursor is not at EOL, insert character */             
     905            /* Cursor is not at EOL, insert character */ 
    908906            unsigned char echo[5] = {0x1b, 0x5b, 0x31, 0x40, 0x00}; 
    909907            echo[4] = *data; 
     
    914912        } 
    915913        return PJ_TRUE; 
    916     }  
     914    } 
    917915    return PJ_FALSE; 
    918916} 
     
    926924    if (recv_buf_backspace(sess->rcmd)) { 
    927925        if (rlen) { 
    928             /*  
    929              * Cursor is not at the end of line, move the characters  
     926            /* 
     927             * Cursor is not at the end of line, move the characters 
    930928             * after the cursor to left 
    931929             */ 
     
    934932            telnet_sess_send2(sess, echo, 5); 
    935933        } else { 
    936             const static unsigned char echo[3] = {0x08, 0x20, 0x08};         
     934            const static unsigned char echo[3] = {0x08, 0x20, 0x08}; 
    937935            telnet_sess_send2(sess, echo, 3); 
    938936        } 
     
    942940} 
    943941 
    944 /*  
    945  * Syntax error handler for parser.  
     942/* 
     943 * Syntax error handler for parser. 
    946944 */ 
    947945static void on_syntax_error(pj_scanner *scanner) 
     
    958956    pj_scanner scanner; 
    959957    PJ_USE_EXCEPTION; 
    960     pj_scan_init(&scanner, cmd->ptr, cmd->slen, PJ_SCAN_AUTOSKIP_WS,  
     958    pj_scan_init(&scanner, cmd->ptr, cmd->slen, PJ_SCAN_AUTOSKIP_WS, 
    961959                 &on_syntax_error); 
    962960    PJ_TRY { 
     
    966964    } 
    967965    PJ_CATCH_ANY { 
    968         pj_scan_fini(&scanner);  
     966        pj_scan_fini(&scanner); 
    969967        return PJ_GET_EXCEPTION(); 
    970968    } 
     
    981979    pj_bool_t retval = PJ_TRUE; 
    982980    unsigned len; 
    983      
     981 
    984982    pj_pool_t *pool; 
    985983    pj_cli_cmd_val *cmd_val; 
     
    990988 
    991989    cmd_val = PJ_POOL_ZALLOC_T(pool, pj_cli_cmd_val); 
    992      
    993     status = pj_cli_sess_parse(&sess->base, (char *)&sess->rcmd->rbuf, cmd_val,  
    994                                pool, &info);     
     990 
     991    status = pj_cli_sess_parse(&sess->base, (char *)&sess->rcmd->rbuf, cmd_val, 
     992                               pool, &info); 
    995993 
    996994    len = (unsigned)pj_ansi_strlen((char *)sess->rcmd->rbuf); 
     
    998996    switch (status) { 
    999997    case PJ_CLI_EINVARG: 
    1000         send_inv_arg(sess, &info, PJ_TRUE, PJ_TRUE);             
     998        send_inv_arg(sess, &info, PJ_TRUE, PJ_TRUE); 
    1001999        break; 
    10021000    case PJ_CLI_ETOOMANYARGS: 
     
    10151013            telnet_sess_send2(sess, data_sent, rlen); 
    10161014        } 
    1017         if (info.hint_cnt > 0) {         
     1015        if (info.hint_cnt > 0) { 
    10181016            /* Complete command */ 
    10191017            pj_str_t cmd = pj_str((char *)sess->rcmd->rbuf); 
     
    10261024                if (hint_info->slen >= last_token.slen) { 
    10271025                    hint_info->slen -= last_token.slen; 
    1028                     pj_memmove(hint_info->ptr,  
    1029                                &hint_info->ptr[last_token.slen],  
    1030                                hint_info->slen);                     
    1031                 }  
     1026                    pj_memmove(hint_info->ptr, 
     1027                               &hint_info->ptr[last_token.slen], 
     1028                               hint_info->slen); 
     1029                } 
    10321030                send_comp_arg(sess, &info); 
    10331031 
    1034                 pj_memcpy(&sess->rcmd->rbuf[len], info.hint[0].name.ptr,  
     1032                pj_memcpy(&sess->rcmd->rbuf[len], info.hint[0].name.ptr, 
    10351033                          info.hint[0].name.slen); 
    10361034 
    10371035                len += (unsigned)info.hint[0].name.slen; 
    1038                 sess->rcmd->rbuf[len] = 0;                   
     1036                sess->rcmd->rbuf[len] = 0; 
    10391037            } 
    10401038        } else { 
     
    10461044    sess->rcmd->cur_pos = sess->rcmd->len; 
    10471045 
    1048     pj_pool_release(pool);       
    1049     return retval;  
     1046    pj_pool_release(pool); 
     1047    return retval; 
    10501048} 
    10511049 
     
    10571055    pj_status_t status; 
    10581056    pj_bool_t retval = PJ_TRUE; 
    1059      
    1060     pj_pool_t *pool;     
    1061     pj_cli_exec_info info;     
    1062      
     1057 
     1058    pj_pool_t *pool; 
     1059    pj_cli_exec_info info; 
     1060 
    10631061    send_return_key(sess); 
    10641062    insert_history(sess, (char *)&sess->rcmd->rbuf); 
     
    10661064    pool = pj_pool_create(sess->pool->factory, "handle_return", 
    10671065                          PJ_CLI_TELNET_POOL_SIZE, PJ_CLI_TELNET_POOL_INC, 
    1068                           NULL);     
    1069      
    1070     status = pj_cli_sess_exec(&sess->base, (char *)&sess->rcmd->rbuf,  
     1066                          NULL); 
     1067 
     1068    status = pj_cli_sess_exec(&sess->base, (char *)&sess->rcmd->rbuf, 
    10711069                              pool, &info); 
    10721070 
    10731071    switch (status) { 
    10741072    case PJ_CLI_EINVARG: 
    1075         send_inv_arg(sess, &info, PJ_FALSE, PJ_FALSE);   
     1073        send_inv_arg(sess, &info, PJ_FALSE, PJ_FALSE); 
    10761074        break; 
    10771075    case PJ_CLI_ETOOMANYARGS: 
     
    10881086        send_prompt_str(sess); 
    10891087        break; 
    1090     }     
     1088    } 
    10911089    if (retval) { 
    10921090        sess->rcmd->rbuf[0] = 0; 
     
    10951093    } 
    10961094 
    1097     pj_pool_release(pool);       
    1098     return retval;  
     1095    pj_pool_release(pool); 
     1096    return retval; 
    10991097} 
    11001098 
     
    11061104    if (recv_buf_right_len(sess->rcmd)) { 
    11071105        unsigned char *data = &sess->rcmd->rbuf[sess->rcmd->cur_pos++]; 
    1108         telnet_sess_send2(sess, data, 1);                
     1106        telnet_sess_send2(sess, data, 1); 
    11091107        return PJ_TRUE; 
    11101108    } 
     
    11161114 */ 
    11171115static pj_bool_t handle_left_key(cli_telnet_sess *sess) 
    1118 {     
     1116{ 
    11191117    static const unsigned char move_cursor_left = 0x08; 
    11201118    if (sess->rcmd->cur_pos) { 
     
    11511149            send_data.slen = sess->rcmd->cur_pos; 
    11521150        } 
    1153          
     1151 
    11541152        if (sess->rcmd->len > (unsigned)history->slen) { 
    11551153            /* Clear the command currently shown*/ 
     
    11591157 
    11601158            /* Move cursor position to the beginning of line */ 
    1161             pj_memset(&send_data.ptr[send_data.slen], MOVE_CURSOR_LEFT,  
     1159            pj_memset(&send_data.ptr[send_data.slen], MOVE_CURSOR_LEFT, 
    11621160                      buf_len); 
    11631161            send_data.slen += buf_len; 
    1164         }  
     1162        } 
    11651163        /* Send data */ 
    11661164        pj_strcat(&send_data, history); 
     
    11751173} 
    11761174 
    1177 static pj_status_t process_vt100_cmd(cli_telnet_sess *sess,  
     1175static pj_status_t process_vt100_cmd(cli_telnet_sess *sess, 
    11781176                                     unsigned char *cmd) 
    1179 {     
     1177{ 
    11801178    pj_status_t status = PJ_TRUE; 
    11811179    switch (*cmd) { 
     
    12251223} 
    12261224 
    1227 /*  
    1228  * Send a message to a telnet session  
     1225/* 
     1226 * Send a message to a telnet session 
    12291227 */ 
    12301228static pj_status_t telnet_sess_send(cli_telnet_sess *sess, 
     
    12411239 
    12421240    if (sess->buf_len == 0) 
    1243         status = pj_activesock_send(sess->asock, &sess->op_key,  
     1241        status = pj_activesock_send(sess->asock, &sess->op_key, 
    12441242                                    str->ptr, &sz, 0); 
    1245     /* If we cannot send now, append it at the end of the buffer  
     1243    /* If we cannot send now, append it at the end of the buffer 
    12461244     * to be sent later. 
    12471245     */ 
    1248     if (sess->buf_len > 0 ||  
     1246    if (sess->buf_len > 0 || 
    12491247        (status != PJ_SUCCESS && status != PJ_EPENDING)) 
    12501248    { 
     
    12731271} 
    12741272 
    1275 /*  
    1276  * Send a message to a telnet session with formatted text  
     1273/* 
     1274 * Send a message to a telnet session with formatted text 
    12771275 * (add single linefeed character with carriage return) 
    12781276 */ 
     
    12881286    PJ_USE_EXCEPTION; 
    12891287 
    1290     pj_scan_init(&scanner, str->ptr, str->slen,  
     1288    pj_scan_init(&scanner, str->ptr, str->slen, 
    12911289                 PJ_SCAN_AUTOSKIP_WS, &on_syntax_error); 
    1292      
     1290 
    12931291    str_begin = scanner.begin; 
    12941292 
    12951293    PJ_TRY { 
    1296         while (!pj_scan_is_eof(&scanner)) {                  
    1297             pj_scan_get_until_ch(&scanner, '\n', &out_str);          
     1294        while (!pj_scan_is_eof(&scanner)) { 
     1295            pj_scan_get_until_ch(&scanner, '\n', &out_str); 
    12981296            str_len = (int)(scanner.curptr - str_begin); 
    1299             if (*scanner.curptr == '\n') {               
    1300                 if ((str_len > 1) && (out_str.ptr[str_len-2] == '\r'))  
    1301                 {                            
     1297            if (*scanner.curptr == '\n') { 
     1298                if ((str_len > 1) && (out_str.ptr[str_len-2] == '\r')) 
     1299                { 
    13021300                    continue; 
    1303                 } else {                     
     1301                } else { 
    13041302                    int str_pos = (int)(str_begin - scanner.begin); 
    13051303 
     
    13141312                        pj_scan_advance_n(&scanner, 1, PJ_TRUE); 
    13151313                        str_begin = scanner.curptr; 
    1316                     }                
     1314                    } 
    13171315                } 
    13181316            } else { 
     
    13551353    pj_mutex_unlock(tsess->smutex); 
    13561354    pj_activesock_close(tsess->asock); 
    1357     pj_mutex_destroy(tsess->smutex);     
     1355    pj_mutex_destroy(tsess->smutex); 
    13581356    pj_pool_release(tsess->pool); 
    13591357} 
     
    13631361{ 
    13641362    cli_telnet_fe *tfe = (cli_telnet_fe *)fe; 
    1365     pj_cli_sess *sess;     
     1363    pj_cli_sess *sess; 
    13661364 
    13671365    pj_mutex_lock(tfe->mutex); 
     
    13711369        cli_telnet_sess *tsess = (cli_telnet_sess *)sess; 
    13721370 
    1373         sess = sess->next;         
     1371        sess = sess->next; 
    13741372        if (tsess->base.log_level > level) { 
    13751373            pj_str_t s; 
     
    13791377        } 
    13801378    } 
    1381      
     1379 
    13821380    pj_mutex_unlock(tfe->mutex); 
    13831381} 
     
    14361434                            pj_activesock_get_user_data(asock); 
    14371435 
    1438     PJ_UNUSED_ARG(op_key);     
     1436    PJ_UNUSED_ARG(op_key); 
    14391437 
    14401438    if (sent <= 0) { 
     
    14711469                            pj_activesock_get_user_data(asock); 
    14721470    cli_telnet_fe *tfe = (cli_telnet_fe *)sess->base.fe; 
    1473     unsigned char *cdata = (unsigned char*)data;     
     1471    unsigned char *cdata = (unsigned char*)data; 
    14741472    pj_status_t is_valid = PJ_TRUE; 
    14751473 
     
    14831481        TRACE_((THIS_FILE, "Error on data read %d", status)); 
    14841482        return PJ_FALSE; 
    1485     }     
     1483    } 
    14861484 
    14871485    pj_mutex_lock(sess->smutex); 
     
    14901488        case ST_CR: 
    14911489            sess->parse_state = ST_NORMAL; 
    1492             if (*cdata == 0 || *cdata == '\n')                           
     1490            if (*cdata == 0 || *cdata == '\n') 
    14931491                pj_mutex_unlock(sess->smutex); 
    14941492                is_valid = handle_return(sess); 
    1495                 if (!is_valid)               
     1493                if (!is_valid) 
    14961494                    return PJ_FALSE; 
    1497                 pj_mutex_lock(sess->smutex);     
     1495                pj_mutex_lock(sess->smutex); 
    14981496                break; 
    14991497        case ST_NORMAL: 
     
    15021500            } else if (*cdata == 127) { 
    15031501                is_valid = handle_backspace(sess, cdata); 
    1504             } else if (*cdata == 27) {               
     1502            } else if (*cdata == 27) { 
    15051503                sess->parse_state = ST_ESC; 
    1506             } else {  
     1504            } else { 
    15071505                if (recv_buf_insert(sess->rcmd, cdata)) { 
    15081506                    if (*cdata == '\r') { 
     
    15191517            break; 
    15201518        case ST_ESC: 
    1521             if (*cdata == 91) {          
     1519            if (*cdata == 91) { 
    15221520                sess->parse_state = ST_VT100; 
    15231521            } else { 
     
    15981596    if (status != PJ_SUCCESS && status != PJ_EPENDING) { 
    15991597        TRACE_((THIS_FILE, "Error on data accept %d", status)); 
    1600         if (status == PJ_ESOCKETSTOP)  
    1601             telnet_restart(fe);      
    1602          
     1598        if (status == PJ_ESOCKETSTOP) 
     1599            telnet_restart(fe); 
     1600 
    16031601        return PJ_FALSE; 
    1604     }     
     1602    } 
    16051603 
    16061604    /* An incoming connection is accepted, create a new session */ 
     
    16091607                          NULL); 
    16101608    if (!pool) { 
    1611         TRACE_((THIS_FILE,  
     1609        TRACE_((THIS_FILE, 
    16121610                "Not enough memory to create a new telnet session")); 
    16131611        return PJ_TRUE; 
     
    16321630    if (sstatus != PJ_SUCCESS) 
    16331631        goto on_exit; 
    1634      
     1632 
    16351633    sstatus = pj_activesock_create(pool, newsock, pj_SOCK_STREAM(), 
    16361634                                   NULL, fe->cfg.ioqueue, 
     
    16571655    send_cmd_do(sess, SUPPRESS_GA); 
    16581656    send_cmd_will(sess, TERM_ECHO); 
    1659     send_cmd_will(sess, STATUS);    
     1657    send_cmd_will(sess, STATUS); 
    16601658    send_cmd_will(sess, SUPPRESS_GA); 
    16611659 
     
    16821680    else 
    16831681        pj_sock_close(newsock); 
    1684      
     1682 
    16851683    if (sess->smutex) 
    16861684        pj_mutex_destroy(sess->smutex); 
     
    16971695    cli_telnet_fe *fe; 
    16981696    pj_pool_t *pool; 
    1699     pj_status_t status;    
     1697    pj_status_t status; 
    17001698 
    17011699    PJ_ASSERT_RETURN(cli, PJ_EINVAL); 
     
    17071705    if (!fe) 
    17081706        return PJ_ENOMEM; 
    1709          
     1707 
    17101708    fe->base.op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_front_end_op); 
    17111709 
     
    17141712    else 
    17151713        pj_memcpy(&fe->cfg, param, sizeof(*param)); 
    1716          
     1714 
    17171715    pj_list_init(&fe->sess_head); 
    17181716    fe->base.cli = cli; 
     
    17221720    fe->pool = pool; 
    17231721 
    1724     if (!fe->cfg.ioqueue) {      
     1722    if (!fe->cfg.ioqueue) { 
    17251723        /* Create own ioqueue if application doesn't supply one */ 
    17261724        status = pj_ioqueue_create(pool, 8, &fe->cfg.ioqueue); 
     
    17621760    pj_activesock_cb asock_cb; 
    17631761    pj_sockaddr_in addr; 
    1764     pj_status_t status;    
     1762    pj_status_t status; 
    17651763    int val; 
    17661764    int restart_retry; 
     
    17941792        PJ_LOG(4,(THIS_FILE, "Address is still in use, retrying..")); 
    17951793        pj_thread_sleep(msec); 
    1796     }     
    1797      
    1798     if (status == PJ_SUCCESS) {  
    1799         int addr_len = sizeof(addr);     
     1794    } 
     1795 
     1796    if (status == PJ_SUCCESS) { 
     1797        int addr_len = sizeof(addr); 
    18001798 
    18011799        status = pj_sock_getsockname(sock, &addr, &addr_len); 
    18021800        if (status != PJ_SUCCESS) 
    18031801            goto on_exit; 
    1804              
    1805         fe->cfg.port = pj_sockaddr_in_get_port(&addr);   
     1802 
     1803        fe->cfg.port = pj_sockaddr_in_get_port(&addr); 
    18061804 
    18071805        if (fe->cfg.prompt_str.slen == 0) { 
    18081806            pj_str_t prompt_sign = {"> ", 2}; 
    1809             char *prompt_data = pj_pool_alloc(fe->pool,  
     1807            char *prompt_data = pj_pool_alloc(fe->pool, 
    18101808                                              pj_gethostname()->slen+2); 
    18111809            fe->cfg.prompt_str.ptr = prompt_data; 
     
    18131811            pj_strcpy(&fe->cfg.prompt_str, pj_gethostname()); 
    18141812            pj_strcat(&fe->cfg.prompt_str, &prompt_sign); 
    1815         }        
     1813        } 
    18161814    } else { 
    18171815        PJ_LOG(3, (THIS_FILE, "Failed binding the socket")); 
     
    18691867{ 
    18701868    pj_status_t status; 
    1871     pj_cli_sess *sess;       
     1869    pj_cli_sess *sess; 
    18721870 
    18731871    fe->is_quitting = PJ_TRUE; 
    1874     if (fe->worker_thread) {     
     1872    if (fe->worker_thread) { 
    18751873        pj_thread_join(fe->worker_thread); 
    18761874    } 
     
    19111909} 
    19121910 
    1913 PJ_DEF(pj_status_t) pj_cli_telnet_get_info(pj_cli_front_end *fe,  
     1911PJ_DEF(pj_status_t) pj_cli_telnet_get_info(pj_cli_front_end *fe, 
    19141912                                           pj_cli_telnet_info *info) 
    19151913{ 
    19161914    pj_sockaddr hostip; 
    19171915    pj_status_t status; 
    1918     cli_telnet_fe *tfe = (cli_telnet_fe*) fe;  
    1919  
    1920     PJ_ASSERT_RETURN(fe && (fe->type == PJ_CLI_TELNET_FRONT_END) && info,  
     1916    cli_telnet_fe *tfe = (cli_telnet_fe*) fe; 
     1917 
     1918    PJ_ASSERT_RETURN(fe && (fe->type == PJ_CLI_TELNET_FRONT_END) && info, 
    19211919                     PJ_EINVAL); 
    19221920 
  • pjproject/trunk/pjlib/src/pj/os_core_unix.c

    r4359 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020/* 
     
    165165    pj_log_init(); 
    166166 
    167     /* Initialize exception ID for the pool.  
     167    /* Initialize exception ID for the pool. 
    168168     * Must do so after critical section is configured. 
    169169     */ 
     
    171171    if (rc != PJ_SUCCESS) 
    172172        return rc; 
    173      
     173 
    174174    /* Init random seed. */ 
    175175    /* Or probably not. Let application in charge of this */ 
     
    188188        } 
    189189    } 
    190 #endif    
     190#endif 
    191191 
    192192    /* Flag PJLIB as initialized */ 
     
    383383 * Get native thread handle 
    384384 */ 
    385 PJ_DEF(void*) pj_thread_get_os_handle(pj_thread_t *thread)  
     385PJ_DEF(void*) pj_thread_get_os_handle(pj_thread_t *thread) 
    386386{ 
    387387    PJ_ASSERT_RETURN(thread, NULL); 
     
    441441 
    442442    if(cstr_thread_name && pj_strlen(&thread_name) < sizeof(thread->obj_name)-1) 
    443         pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name),  
     443        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name), 
    444444                         cstr_thread_name, thread->thread); 
    445445    else 
    446         pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name),  
     446        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name), 
    447447                         "thr%p", (void*)thread->thread); 
    448      
     448 
    449449    rc = pj_thread_local_set(thread_tls_id, thread); 
    450450    if (rc != PJ_SUCCESS) { 
     
    458458    thread->stk_max_usage = 0; 
    459459#else 
    460     stack_ptr = '\0'; 
     460    PJ_UNUSED_ARG(stack_ptr); 
    461461#endif 
    462462 
     
    533533 * pj_thread_create(...) 
    534534 */ 
    535 PJ_DEF(pj_status_t) pj_thread_create( pj_pool_t *pool,  
     535PJ_DEF(pj_status_t) pj_thread_create( pj_pool_t *pool, 
    536536                                      const char *thread_name, 
    537                                       pj_thread_proc *proc,  
     537                                      pj_thread_proc *proc, 
    538538                                      void *arg, 
    539                                       pj_size_t stack_size,  
     539                                      pj_size_t stack_size, 
    540540                                      unsigned flags, 
    541541                                      pj_thread_t **ptr_thread) 
     
    555555    rec = (struct pj_thread_t*) pj_pool_zalloc(pool, sizeof(pj_thread_t)); 
    556556    PJ_ASSERT_RETURN(rec, PJ_ENOMEM); 
    557      
     557 
    558558    /* Set name. */ 
    559     if (!thread_name)  
     559    if (!thread_name) 
    560560        thread_name = "thr%p"; 
    561      
     561 
    562562    if (strchr(thread_name, '%')) { 
    563563        pj_ansi_snprintf(rec->obj_name, PJ_MAX_OBJ_NAME, thread_name, rec); 
     
    587587        pj_assert(rec->suspended_mutex == NULL); 
    588588    } 
    589      
     589 
    590590 
    591591    /* Init thread attributes */ 
     
    668668#if PJ_HAS_THREADS 
    669669    pj_thread_t *rec = (pj_thread_t*)pj_thread_local_get(thread_tls_id); 
    670      
     670 
    671671    if (rec == NULL) { 
    672672        pj_assert(!"Calling pjlib from unknown/external thread. You must " 
     
    706706        return PJ_SUCCESS; 
    707707    else { 
    708         /* Calling pthread_join() on a thread that no longer exists and  
    709          * getting back ESRCH isn't an error (in this context).  
     708        /* Calling pthread_join() on a thread that no longer exists and 
     709         * getting back ESRCH isn't an error (in this context). 
    710710         * Thanks Phil Torre <ptorre@zetron.com>. 
    711711         */ 
     
    762762    /* MacOS X (reported on 10.5) seems to always set errno to ETIMEDOUT. 
    763763     * It does so because usleep() is declared to return int, and we're 
    764      * supposed to check for errno only when usleep() returns non-zero.  
     764     * supposed to check for errno only when usleep() returns non-zero. 
    765765     * Unfortunately, usleep() is declared to return void in other platforms 
    766      * so it's not possible to always check for the return value (unless  
     766     * so it's not possible to always check for the return value (unless 
    767767     * we add a detection routine in autoconf). 
    768768     * 
     
    832832 * pj_atomic_create() 
    833833 */ 
    834 PJ_DEF(pj_status_t) pj_atomic_create( pj_pool_t *pool,  
     834PJ_DEF(pj_status_t) pj_atomic_create( pj_pool_t *pool, 
    835835                                      pj_atomic_value_t initial, 
    836836                                      pj_atomic_t **ptr_atomic) 
     
    842842 
    843843    PJ_ASSERT_RETURN(atomic_var, PJ_ENOMEM); 
    844      
     844 
    845845#if PJ_HAS_THREADS 
    846846    rc = pj_mutex_create(pool, "atm%p", PJ_MUTEX_SIMPLE, &atomic_var->mutex); 
     
    880880#if PJ_HAS_THREADS 
    881881    pj_mutex_unlock( atomic_var->mutex); 
    882 #endif  
     882#endif 
    883883} 
    884884 
     
    889889{ 
    890890    pj_atomic_value_t oldval; 
    891      
     891 
    892892    PJ_CHECK_STACK(); 
    893893 
     
    959959/* 
    960960 * pj_atomic_add_and_get() 
    961  */  
    962 PJ_DEF(pj_atomic_value_t) pj_atomic_add_and_get( pj_atomic_t *atomic_var,  
     961 */ 
     962PJ_DEF(pj_atomic_value_t) pj_atomic_add_and_get( pj_atomic_t *atomic_var, 
    963963                                                 pj_atomic_value_t value ) 
    964964{ 
     
    968968    pj_mutex_lock(atomic_var->mutex); 
    969969#endif 
    970      
     970 
    971971    atomic_var->value += value; 
    972972    new_value = atomic_var->value; 
     
    981981/* 
    982982 * pj_atomic_add() 
    983  */  
    984 PJ_DEF(void) pj_atomic_add( pj_atomic_t *atomic_var,  
     983 */ 
     984PJ_DEF(void) pj_atomic_add( pj_atomic_t *atomic_var, 
    985985                            pj_atomic_value_t value ) 
    986986{ 
     
    10121012            break; 
    10131013    } 
    1014     if (i == MAX_THREADS)  
     1014    if (i == MAX_THREADS) 
    10151015        return PJ_ETOOMANY; 
    1016      
     1016 
    10171017    tls_flag[i] = 1; 
    10181018    tls[i] = NULL; 
     
    11191119       defined(PJ_PTHREAD_MUTEXATTR_T_HAS_RECURSIVE) 
    11201120        // Phil Torre <ptorre@zetron.com>: 
    1121         // The RTEMS implementation of POSIX mutexes doesn't include  
     1121        // The RTEMS implementation of POSIX mutexes doesn't include 
    11221122        // pthread_mutexattr_settype(), so what follows is a hack 
    11231123        // until I get RTEMS patched to support the set/get functions. 
     
    11321132#endif 
    11331133    } 
    1134      
     1134 
    11351135    if (rc != 0) { 
    11361136        return PJ_RETURN_OS_ERROR(rc); 
     
    11411141        return PJ_RETURN_OS_ERROR(rc); 
    11421142    } 
    1143      
     1143 
    11441144    rc = pthread_mutexattr_destroy(&attr); 
    11451145    if (rc != 0) { 
     
    11761176 * pj_mutex_create() 
    11771177 */ 
    1178 PJ_DEF(pj_status_t) pj_mutex_create(pj_pool_t *pool,  
    1179                                     const char *name,  
     1178PJ_DEF(pj_status_t) pj_mutex_create(pj_pool_t *pool, 
     1179                                    const char *name, 
    11801180                                    int type, 
    11811181                                    pj_mutex_t **ptr_mutex) 
     
    11921192    if ((rc=init_mutex(mutex, name, type)) != PJ_SUCCESS) 
    11931193        return rc; 
    1194      
     1194 
    11951195    *ptr_mutex = mutex; 
    11961196    return PJ_SUCCESS; 
     
    12041204 * pj_mutex_create_simple() 
    12051205 */ 
    1206 PJ_DEF(pj_status_t) pj_mutex_create_simple( pj_pool_t *pool,  
     1206PJ_DEF(pj_status_t) pj_mutex_create_simple( pj_pool_t *pool, 
    12071207                                            const char *name, 
    12081208                                            pj_mutex_t **mutex ) 
     
    12331233 
    12341234#if PJ_DEBUG 
    1235     PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting (mutex owner=%s)",  
     1235    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting (mutex owner=%s)", 
    12361236                                pj_thread_this()->obj_name, 
    12371237                                mutex->owner_name)); 
    12381238#else 
    1239     PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting",  
     1239    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting", 
    12401240                                pj_thread_this()->obj_name)); 
    12411241#endif 
     
    12511251    } 
    12521252 
    1253     PJ_LOG(6,(mutex->obj_name,  
    1254               (status==0 ?  
    1255                 "Mutex acquired by thread %s (level=%d)" :  
     1253    PJ_LOG(6,(mutex->obj_name, 
     1254              (status==0 ? 
     1255                "Mutex acquired by thread %s (level=%d)" : 
    12561256                "Mutex acquisition FAILED by %s (level=%d)"), 
    12571257              pj_thread_this()->obj_name, 
    12581258              mutex->nesting_level)); 
    12591259#else 
    1260     PJ_LOG(6,(mutex->obj_name,  
     1260    PJ_LOG(6,(mutex->obj_name, 
    12611261              (status==0 ? "Mutex acquired by thread %s" : "FAILED by %s"), 
    12621262              pj_thread_this()->obj_name)); 
     
    12911291    } 
    12921292 
    1293     PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s (level=%d)",  
    1294                                 pj_thread_this()->obj_name,  
     1293    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s (level=%d)", 
     1294                                pj_thread_this()->obj_name, 
    12951295                                mutex->nesting_level)); 
    12961296#else 
    1297     PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s",  
     1297    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s", 
    12981298                                pj_thread_this()->obj_name)); 
    12991299#endif 
     
    13221322    PJ_ASSERT_RETURN(mutex, PJ_EINVAL); 
    13231323 
    1324     PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is trying",  
     1324    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is trying", 
    13251325                                pj_thread_this()->obj_name)); 
    13261326 
     
    13331333        ++mutex->nesting_level; 
    13341334 
    1335         PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s (level=%d)",  
     1335        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s (level=%d)", 
    13361336                                   pj_thread_this()->obj_name, 
    13371337                                   mutex->nesting_level)); 
    13381338#else 
    1339         PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s",  
     1339        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s", 
    13401340                                  pj_thread_this()->obj_name)); 
    13411341#endif 
    13421342    } else { 
    1343         PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s's trylock() failed",  
     1343        PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s's trylock() failed", 
    13441344                                    pj_thread_this()->obj_name)); 
    13451345    } 
    1346      
     1346 
    13471347    if (status==0) 
    13481348        return PJ_SUCCESS; 
     
    14261426 
    14271427    PJ_UNUSED_ARG(name); 
    1428      
     1428 
    14291429    rwm = PJ_POOL_ALLOC_T(pool, pj_rwmutex_t); 
    14301430    PJ_ASSERT_RETURN(rwm, PJ_ENOMEM); 
     
    15161516 * pj_sem_create() 
    15171517 */ 
    1518 PJ_DEF(pj_status_t) pj_sem_create( pj_pool_t *pool,  
     1518PJ_DEF(pj_status_t) pj_sem_create( pj_pool_t *pool, 
    15191519                                   const char *name, 
    1520                                    unsigned initial,  
     1520                                   unsigned initial, 
    15211521                                   unsigned max, 
    15221522                                   pj_sem_t **ptr_sem) 
     
    15371537        pj_str_t nam; 
    15381538 
    1539         /* We should use SEM_NAME_LEN, but this doesn't seem to be  
     1539        /* We should use SEM_NAME_LEN, but this doesn't seem to be 
    15401540         * declared anywhere? The value here is just from trial and error 
    15411541         * to get the longest name supported. 
     
    15541554 
    15551555        /* Create semaphore */ 
    1556         sem->sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IRUSR|S_IWUSR,  
     1556        sem->sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IRUSR|S_IWUSR, 
    15571557                            initial); 
    15581558        if (sem->sem == SEM_FAILED) 
     
    15641564#else 
    15651565    sem->sem = PJ_POOL_ALLOC_T(pool, sem_t); 
    1566     if (sem_init( sem->sem, 0, initial) != 0)  
     1566    if (sem_init( sem->sem, 0, initial) != 0) 
    15671567        return PJ_RETURN_OS_ERROR(pj_get_native_os_error()); 
    15681568#endif 
    1569      
     1569 
    15701570    /* Set name. */ 
    15711571    if (!name) { 
     
    16001600    PJ_ASSERT_RETURN(sem, PJ_EINVAL); 
    16011601 
    1602     PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s is waiting",  
     1602    PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s is waiting", 
    16031603                              pj_thread_this()->obj_name)); 
    16041604 
    16051605    result = sem_wait( sem->sem ); 
    1606      
     1606 
    16071607    if (result == 0) { 
    1608         PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s",  
     1608        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s", 
    16091609                                  pj_thread_this()->obj_name)); 
    16101610    } else { 
    1611         PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s FAILED to acquire",  
     1611        PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s FAILED to acquire", 
    16121612                                  pj_thread_this()->obj_name)); 
    16131613    } 
     
    16351635 
    16361636    result = sem_trywait( sem->sem ); 
    1637      
     1637 
    16381638    if (result == 0) { 
    1639         PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s",  
     1639        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s", 
    16401640                                  pj_thread_this()->obj_name)); 
    1641     }  
     1641    } 
    16421642    if (result == 0) 
    16431643        return PJ_SUCCESS; 
  • pjproject/trunk/pjlib/src/pjlib-test/test.c

    r4712 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include "test.h" 
     
    3939const char *param_echo_server = ECHO_SERVER_ADDRESS; 
    4040int param_echo_port = ECHO_SERVER_START_PORT; 
    41 int param_log_decor = PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_TIME |  
     41int param_log_decor = PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_TIME | 
    4242                      PJ_LOG_HAS_MICRO_SEC; 
    4343 
     
    6464        return rc; 
    6565    } 
    66      
     66 
    6767    //pj_dump_config(); 
    6868    pj_caching_pool_init( &caching_pool, NULL, 0 ); 
     
    9999    DO_TEST( string_test() ); 
    100100#endif 
    101      
     101 
    102102#if INCLUDE_FIFOBUF_TEST 
    103103    DO_TEST( fifobuf_test() ); 
     
    185185        param_echo_sock_type = pj_SOCK_DGRAM(); 
    186186 
    187     echo_client( param_echo_sock_type,  
    188                  param_echo_server,  
     187    echo_client( param_echo_sock_type, 
     188                 param_echo_server, 
    189189                 param_echo_port); 
    190190#endif 
     
    197197 
    198198    PJ_LOG(3,("test", "")); 
    199   
     199 
    200200    pj_thread_get_stack_info(pj_thread_this(), &filename, &line); 
    201     PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u",  
     201    PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u", 
    202202                      pj_thread_get_stack_max_usage(pj_thread_this()), 
    203203                      filename, line)); 
     
    206206    else 
    207207        PJ_LOG(3,("test", "Test completed with error(s)")); 
    208      
     208 
    209209    pj_shutdown(); 
    210      
     210 
    211211    return 0; 
    212212} 
     
    217217{ 
    218218    PJ_USE_EXCEPTION; 
    219  
    220     pj_AF_INET(); 
    221219 
    222220    PJ_TRY { 
     
    225223    PJ_CATCH_ANY { 
    226224        int id = PJ_GET_EXCEPTION(); 
    227         PJ_LOG(3,("test", "FATAL: unhandled exception id %d (%s)",  
     225        PJ_LOG(3,("test", "FATAL: unhandled exception id %d (%s)", 
    228226                  id, pj_exception_id_name(id))); 
    229227    } 
  • pjproject/trunk/pjlib/src/pjlib-test/thread.c

    r3553 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include "test.h" 
     
    3131 *  - whether thread timeslicing works, and threads have equal 
    3232 *    time-slice proportion. 
    33  *  
     33 * 
    3434 * APIs tested: 
    3535 *  - pj_thread_create() 
     
    7878 
    7979    id = *pcounter; 
     80    PJ_UNUSED_ARG(id); /* Warning about unused var if TRACE__ is disabled */ 
    8081    TRACE__((THIS_FILE, "     thread %d running..", id)); 
    8182 
     
    121122    pj_status_t rc; 
    122123    pj_uint32_t counter = 0; 
    123   
     124 
    124125    PJ_LOG(3,(THIS_FILE, "..%s", title)); 
    125      
     126 
    126127    pool = pj_pool_create(mem, NULL, 4000, 4000, NULL); 
    127128    if (!pool) 
     
    153154            return -1015; 
    154155        } 
    155          
     156 
    156157        rc = pj_thread_resume(thread); 
    157158        if (rc != PJ_SUCCESS) { 
     
    160161        } 
    161162    } 
    162      
     163 
    163164    PJ_LOG(3,(THIS_FILE, "..waiting for thread to quit..")); 
    164165 
     
    174175        return -1025; 
    175176    } 
    176      
     177 
    177178    PJ_LOG(3,(THIS_FILE, "...%s success", title)); 
    178179    return PJ_SUCCESS; 
     
    203204    for (i=0; i<NUM_THREADS; ++i) { 
    204205        counter[i] = i; 
    205         rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc,  
    206                               &counter[i],  
    207                               PJ_THREAD_DEFAULT_STACK_SIZE,  
    208                               PJ_THREAD_SUSPENDED,  
     206        rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc, 
     207                              &counter[i], 
     208                              PJ_THREAD_DEFAULT_STACK_SIZE, 
     209                              PJ_THREAD_SUSPENDED, 
    209210                              &thread[i]); 
    210211        if (rc!=PJ_SUCCESS) { 
     
    224225    for (i=0; i<NUM_THREADS; ++i) { 
    225226        if (counter[i] > i) { 
    226             PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!",  
     227            PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!", 
    227228                      i)); 
    228229            return -30; 
     
    240241    } 
    241242 
    242     /* Main thread sleeps for some time to allow threads to run.  
     243    /* Main thread sleeps for some time to allow threads to run. 
    243244     * The longer we sleep, the more accurate the calculation will be, 
    244245     * but it'll make user waits for longer for the test to finish. 
     
    253254    /* Wait until all threads quit, then destroy. */ 
    254255    for (i=0; i<NUM_THREADS; ++i) { 
    255         TRACE__((THIS_FILE, "    Main thread joining thread %d [%p]..",  
     256        TRACE__((THIS_FILE, "    Main thread joining thread %d [%p]..", 
    256257                            i, thread[i])); 
    257258        rc = pj_thread_join(thread[i]); 
     
    292293    diff = (highest-lowest)*100 / ((highest+lowest)/2); 
    293294    if ( diff >= 50) { 
    294         PJ_LOG(3,(THIS_FILE,  
     295        PJ_LOG(3,(THIS_FILE, 
    295296                  "...ERROR: thread didn't have equal timeslice!")); 
    296         PJ_LOG(3,(THIS_FILE,  
     297        PJ_LOG(3,(THIS_FILE, 
    297298                  ".....lowest counter=%u, highest counter=%u, diff=%u%%", 
    298299                  lowest, highest, diff)); 
    299300        return -80; 
    300301    } else { 
    301         PJ_LOG(3,(THIS_FILE,  
     302        PJ_LOG(3,(THIS_FILE, 
    302303                  "...info: timeslice diff between lowest & highest=%u%%", 
    303304                  diff)); 
     
    315316    if (rc != PJ_SUCCESS) 
    316317        return rc; 
    317      
     318 
    318319    rc = simple_thread("suspended thread test", PJ_THREAD_SUSPENDED); 
    319320    if (rc != PJ_SUCCESS) 
    320321        return rc; 
    321      
     322 
    322323    rc = timeslice_test(); 
    323324    if (rc != PJ_SUCCESS) 
     
    329330#else 
    330331/* To prevent warning about "translation unit is empty" 
    331  * when this test is disabled.  
     332 * when this test is disabled. 
    332333 */ 
    333334int dummy_thread_test; 
  • pjproject/trunk/pjmedia/src/pjmedia-audiodev/bb10_dev.c

    r4707 r4728  
    501501                if (status.status == SND_PCM_STATUS_READY || 
    502502                    status.status == SND_PCM_STATUS_UNDERRUN || 
    503                     status.status == SND_PCM_STATUS_ERROR )  
     503                    status.status == SND_PCM_STATUS_ERROR ) 
    504504                { 
    505505                    if (snd_pcm_plugin_prepare (stream->pb_pcm, 
     
    778778    TRACE_((THIS_FILE, "bb10_open_playback: pb_frames = %d clock = %d", 
    779779                       stream->pb_frames, param->clock_rate)); 
    780      
     780 
    781781    return PJ_SUCCESS; 
    782782} 
     
    864864 
    865865    frame_size = setup.buf.block.frag_size; 
     866    PJ_UNUSED_ARG(frame_size); /* Warning about unused var */ 
    866867 
    867868    /* Set clock rate */ 
     
    962963 
    963964 
    964 /*  
     965/* 
    965966 * API: get running parameter 
    966967 * based on ALSA template 
     
    981982/* 
    982983 * API: get capability 
    983  * based on ALSA template  
     984 * based on ALSA template 
    984985*/ 
    985986static pj_status_t bb10_stream_get_cap(pjmedia_aud_stream *s, 
     
    10431044            ret = bb10_initialize_playback_ctrl(stream,true); 
    10441045        } else { 
    1045             ret = bb10_initialize_playback_ctrl(stream,false);           
     1046            ret = bb10_initialize_playback_ctrl(stream,false); 
    10461047        } 
    10471048        return ret; 
  • pjproject/trunk/pjmedia/src/pjmedia/echo_suppress.c

    r4713 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include <pjmedia/types.h> 
     
    7878#if 0 
    7979#   define TRACE_(expr) PJ_LOG(5,expr) 
     80 
     81static const char *state_names[] = 
     82{ 
     83    "Null", 
     84    "local talking", 
     85    "remote silent", 
     86    "doubletalk", 
     87    "remote talking" 
     88}; 
     89 
    8090#else 
    8191#   define TRACE_(expr) 
     
    126136} talk_state_t; 
    127137 
    128 static const char *state_names[] =  
    129 { 
    130     "Null", 
    131     "local talking", 
    132     "remote silent", 
    133     "doubletalk", 
    134     "remote talking" 
    135 }; 
    136  
    137138 
    138139/* Description: 
    139140 
    140141   The echo suppressor tries to find the position of echoed signal by looking 
    141    at the correlation between signal played to the speaker (played signal)  
     142   at the correlation between signal played to the speaker (played signal) 
    142143   and the signal captured from the microphone (recorded signal). 
    143144 
    144    To do this, it first divides the frames (from mic and speaker) into  
     145   To do this, it first divides the frames (from mic and speaker) into 
    145146   segments, calculate the audio level of the segment, and save the level 
    146147   information in the playback and record history (play_hist and rec_hist 
     
    151152 
    152153   The record history size is as large as the template size (tmpl_cnt), since 
    153    we will use the record history as the template to find the best matching  
     154   we will use the record history as the template to find the best matching 
    154155   position in the playback history. 
    155156 
     
    188189      similar) the signal is. The correlation value is done over the template 
    189190      duration. 
    190     - the gain scaling factor, that is the ratio between mic signal and  
     191    - the gain scaling factor, that is the ratio between mic signal and 
    191192      speaker signal. The ES calculates both the minimum and average ratios. 
    192193 
     
    210211   Processing: 
    211212 
    212    Once learning is done, the ES will change the level of the mic signal  
     213   Once learning is done, the ES will change the level of the mic signal 
    213214   depending on the state of the conversation and according to the ratio that 
    214215   has been found in the learning phase above. 
     
    264265 
    265266/* 
    266  * Create.  
     267 * Create. 
    267268 */ 
    268269PJ_DEF(pj_status_t) echo_supp_create( pj_pool_t *pool, 
     
    293294    ec->play_hist_cnt = (pj_uint16_t)(ec->tail_cnt+ec->templ_cnt); 
    294295 
    295     ec->max_calc = (pj_uint16_t)(MAX_CALC_DURATION_SEC * clock_rate /  
     296    ec->max_calc = (pj_uint16_t)(MAX_CALC_DURATION_SEC * clock_rate / 
    296297                                 ec->samples_per_segment); 
    297298 
    298     ec->rec_hist = (pj_uint16_t*)  
     299    ec->rec_hist = (pj_uint16_t*) 
    299300                    pj_pool_alloc(pool, ec->templ_cnt * 
    300301                                        sizeof(ec->rec_hist[0])); 
    301302 
    302303    /* Note: play history has twice number of elements */ 
    303     ec->play_hist = (pj_uint16_t*)  
     304    ec->play_hist = (pj_uint16_t*) 
    304305                     pj_pool_alloc(pool, ec->play_hist_cnt * 
    305306                                         sizeof(ec->play_hist[0])); 
    306307 
    307308    ec->corr_sum = (float*) 
    308                    pj_pool_alloc(pool, ec->tail_cnt *  
     309                   pj_pool_alloc(pool, ec->tail_cnt * 
    309310                                       sizeof(ec->corr_sum[0])); 
    310311    ec->tmp_corr = (float*) 
    311                    pj_pool_alloc(pool, ec->tail_cnt *  
     312                   pj_pool_alloc(pool, ec->tail_cnt * 
    312313                                       sizeof(ec->tmp_corr[0])); 
    313314    ec->min_factor = (float*) 
    314                      pj_pool_alloc(pool, ec->tail_cnt *  
     315                     pj_pool_alloc(pool, ec->tail_cnt * 
    315316                                         sizeof(ec->min_factor[0])); 
    316317    ec->avg_factor = (float*) 
    317                      pj_pool_alloc(pool, ec->tail_cnt *  
     318                     pj_pool_alloc(pool, ec->tail_cnt * 
    318319                                         sizeof(ec->avg_factor[0])); 
    319320    ec->tmp_factor = (float*) 
    320                      pj_pool_alloc(pool, ec->tail_cnt *  
     321                     pj_pool_alloc(pool, ec->tail_cnt * 
    321322                                         sizeof(ec->tmp_factor[0])); 
    322323    echo_supp_reset(ec); 
     
    328329 
    329330/* 
    330  * Destroy.  
     331 * Destroy. 
    331332 */ 
    332333PJ_DEF(pj_status_t) echo_supp_destroy(void *state) 
     
    394395 
    395396/* Set state */ 
    396 static void echo_supp_set_state(echo_supp *ec, talk_state_t state,  
     397static void echo_supp_set_state(echo_supp *ec, talk_state_t state, 
    397398                                unsigned level) 
    398399{ 
     
    400401 
    401402    if (state != ec->talk_state) { 
    402         TRACE_((THIS_FILE, "[%03d.%03d] %s --> %s, level=%u",  
    403                            (ec->update_cnt * SEGMENT_PTIME / 1000),  
     403        TRACE_((THIS_FILE, "[%03d.%03d] %s --> %s, level=%u", 
     404                           (ec->update_cnt * SEGMENT_PTIME / 1000), 
    404405                           ((ec->update_cnt * SEGMENT_PTIME) % 1000), 
    405406                           state_names[ec->talk_state], 
     
    470471    } else { 
    471472        /* Update from previous calculation */ 
    472         ec->sum_rec_level = ec->sum_rec_level - old_rec_frm_level +  
     473        ec->sum_rec_level = ec->sum_rec_level - old_rec_frm_level + 
    473474                            ec->rec_hist[ec->templ_cnt-1]; 
    474         ec->rec_corr = ec->rec_corr - ((float)ec->rec_hist[0] /  
     475        ec->rec_corr = ec->rec_corr - ((float)ec->rec_hist[0] / 
    475476                                              old_rec_frm_level) + 
    476477                       ((float)ec->rec_hist[ec->templ_cnt-1] / 
     
    483484     * to detect echo. 
    484485     */ 
    485     /*  
    486      * First phase: do full calculation for the first position  
     486    /* 
     487     * First phase: do full calculation for the first position 
    487488     */ 
    488489    if (ec->sum_play_level0 == 0) { 
     
    501502    } else { 
    502503        /* Update from previous calculation */ 
    503         ec->sum_play_level0 = ec->sum_play_level0 - old_play_frm_level +  
     504        ec->sum_play_level0 = ec->sum_play_level0 - old_play_frm_level + 
    504505                              ec->play_hist[ec->templ_cnt-1]; 
    505         ec->play_corr0 = ec->play_corr0 - ((float)ec->play_hist[0] /  
     506        ec->play_corr0 = ec->play_corr0 - ((float)ec->play_hist[0] / 
    506507                                                  old_play_frm_level) + 
    507508                         ((float)ec->play_hist[ec->templ_cnt-1] / 
     
    585586        if (ec->tmp_factor[i] < ec->min_factor[i]) 
    586587            ec->min_factor[i] = ec->tmp_factor[i]; 
    587         ec->avg_factor[i] = ((ec->avg_factor[i] * ec->tail_cnt) +  
     588        ec->avg_factor[i] = ((ec->avg_factor[i] * ec->tail_cnt) + 
    588589                                    ec->tmp_factor[i]) / 
    589590                            (ec->tail_cnt + 1); 
     
    610611        iavg = (int)(ec->avg_factor[ec->tail_index] * 1000); 
    611612 
    612         PJ_LOG(4,(THIS_FILE,  
     613        PJ_LOG(4,(THIS_FILE, 
    613614                  "Echo suppressor updated at t=%03d.%03ds, echo tail=%d msec" 
    614615                  ", factor min/avg=%d.%03d/%d.%03d", 
     
    634635        iavg = (int)(ec->avg_factor[ec->tail_index] * 1000); 
    635636 
    636         PJ_LOG(4,(THIS_FILE,  
     637        PJ_LOG(4,(THIS_FILE, 
    637638                  "Echo suppressor learning done at t=%03d.%03ds, tail=%d ms" 
    638639                  ", factor min/avg=%d.%03d/%d.%03d", 
     
    647648 
    648649/* Amplify frame */ 
    649 static void amplify_frame(pj_int16_t *frm, unsigned length,  
     650static void amplify_frame(pj_int16_t *frm, unsigned length, 
    650651                          pj_ufloat_t factor) 
    651652{ 
     
    657658} 
    658659 
    659 /*  
     660/* 
    660661 * Perform echo cancellation. 
    661662 */ 
     
    710711         * if remote user is currently talking 
    711712         */ 
    712         for (i=ec->play_hist_cnt -lookup_cnt -tail_cnt;  
    713              i<ec->play_hist_cnt-tail_cnt; ++i)  
     713        for (i=ec->play_hist_cnt -lookup_cnt -tail_cnt; 
     714             i<ec->play_hist_cnt-tail_cnt; ++i) 
    714715        { 
    715716            if (ec->play_hist[i] > play_level) 
     
    733734            } else { 
    734735                /* Speaker is active, but we've picked up large signal in 
    735                  * the microphone. Assume that this is an echo, so bring  
     736                 * the microphone. Assume that this is an echo, so bring 
    736737                 * the level down to minimum too. 
    737738                 */ 
     
    763764 
    764765        /* Amplify frame */ 
    765         amplify_frame(rec_frm, ec->samples_per_frame,  
     766        amplify_frame(rec_frm, ec->samples_per_frame, 
    766767                      pj_ufloat_from_float(factor)); 
    767768        ec->last_factor = factor; 
     
    775776 
    776777            /* Accumulate average echo residue to see the ES effectiveness */ 
    777             ec->residue = ((ec->residue * ec->running_cnt) + level) /  
     778            ec->residue = ((ec->residue * ec->running_cnt) + level) / 
    778779                          (ec->running_cnt + 1); 
    779780 
  • pjproject/trunk/pjmedia/src/pjmedia/jbuf.c

    r4537 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020/* 
     
    3636#define INVALID_OFFSET          -9999 
    3737 
    38 /* Maximum burst length, whenever an operation is bursting longer than  
     38/* Maximum burst length, whenever an operation is bursting longer than 
    3939 * this value, JB will assume that the opposite operation was idle. 
    4040 */ 
     
    4747 
    4848 
    49 /* Minimal difference between JB size and 2*burst-level to perform  
    50  * JB shrinking in static discard algorithm.  
     49/* Minimal difference between JB size and 2*burst-level to perform 
     50 * JB shrinking in static discard algorithm. 
    5151 */ 
    5252#define STA_DISC_SAFE_SHRINKING_DIFF    1 
     
    6868    pj_uint32_t     *bit_info;          /**< frame bit info array           */ 
    6969    pj_uint32_t     *ts;                /**< timestamp array                */ 
    70      
     70 
    7171    /* States */ 
    7272    unsigned         head;              /**< index of head, pointed frame 
    7373                                             will be returned by next GET   */ 
    74     unsigned         size;              /**< current size of framelist,  
     74    unsigned         size;              /**< current size of framelist, 
    7575                                             including discarded frames.    */ 
    76     unsigned         discarded_num;     /**< current number of discarded  
     76    unsigned         discarded_num;     /**< current number of discarded 
    7777                                             frames.                        */ 
    7878    int              origin;            /**< original index of flist_head   */ 
     
    9292    pj_size_t       jb_frame_size;      /**< frame size                     */ 
    9393    unsigned        jb_frame_ptime;     /**< frame duration.                */ 
    94     pj_size_t       jb_max_count;       /**< capacity of jitter buffer,  
     94    pj_size_t       jb_max_count;       /**< capacity of jitter buffer, 
    9595                                             in frames                      */ 
    9696    int             jb_init_prefetch;   /**< Initial prefetch               */ 
     
    9898    int             jb_max_prefetch;    /**< Maximum allowable prefetch     */ 
    9999    int             jb_max_burst;       /**< maximum possible burst, whenever 
    100                                              burst exceeds this value, it  
    101                                              won't be included in level  
     100                                             burst exceeds this value, it 
     101                                             won't be included in level 
    102102                                             calculation                    */ 
    103103    int             jb_min_shrink_gap;  /**< How often can we shrink        */ 
     
    108108 
    109109    /* States */ 
    110     int             jb_level;           /**< delay between source &  
    111                                              destination (calculated according  
    112                                              of the number of burst get/put  
     110    int             jb_level;           /**< delay between source & 
     111                                             destination (calculated according 
     112                                             of the number of burst get/put 
    113113                                             operations)                    */ 
    114     int             jb_max_hist_level;  /**< max level during the last level  
     114    int             jb_max_hist_level;  /**< max level during the last level 
    115115                                             calculations                   */ 
    116     int             jb_stable_hist;     /**< num of times the delay has been  
     116    int             jb_stable_hist;     /**< num of times the delay has been 
    117117                                             lower then the prefetch num    */ 
    118     int             jb_last_op;         /**< last operation executed  
     118    int             jb_last_op;         /**< last operation executed 
    119119                                             (put/get)                      */ 
    120120    int             jb_eff_level;       /**< effective burst level          */ 
    121     int             jb_prefetch;        /**< no. of frame to insert before  
    122                                              removing some (at the beginning  
    123                                              of the framelist->content  
     121    int             jb_prefetch;        /**< no. of frame to insert before 
     122                                             removing some (at the beginning 
     123                                             of the framelist->content 
    124124                                             operation), the value may be 
    125125                                             continuously updated based on 
    126126                                             current frame burst level.     */ 
    127127    pj_bool_t       jb_prefetching;     /**< flag if jbuf is prefetching.   */ 
    128     int             jb_status;          /**< status is 'init' until the first  
     128    int             jb_status;          /**< status is 'init' until the first 
    129129                                             'put' operation                */ 
    130     int             jb_init_cycle_cnt;  /**< status is 'init' until the first  
     130    int             jb_init_cycle_cnt;  /**< status is 'init' until the first 
    131131                                             'put' operation                */ 
    132132 
     
    137137 
    138138    /* Statistics */ 
    139     pj_math_stat    jb_delay;           /**< Delay statistics of jitter buffer  
     139    pj_math_stat    jb_delay;           /**< Delay statistics of jitter buffer 
    140140                                             (in ms)                        */ 
    141141    pj_math_stat    jb_burst;           /**< Burst statistics (in frames)   */ 
     
    165165 
    166166 
    167 /* Enabling this would log the jitter buffer state about once per  
     167/* Enabling this would log the jitter buffer state about once per 
    168168 * second. 
    169169 */ 
     
    181181                                      jb_framelist_t *framelist, 
    182182                                      unsigned frame_size, 
    183                                       unsigned max_count)  
     183                                      unsigned max_count) 
    184184{ 
    185185    PJ_ASSERT_RETURN(pool && framelist, PJ_EINVAL); 
     
    189189    framelist->frame_size   = frame_size; 
    190190    framelist->max_count    = max_count; 
    191     framelist->content      = (char*)  
     191    framelist->content      = (char*) 
    192192                              pj_pool_alloc(pool, 
    193                                             framelist->frame_size*  
     193                                            framelist->frame_size* 
    194194                                            framelist->max_count); 
    195195    framelist->frame_type   = (int*) 
    196                               pj_pool_alloc(pool,  
     196                              pj_pool_alloc(pool, 
    197197                                            sizeof(framelist->frame_type[0])* 
    198198                                            framelist->max_count); 
    199199    framelist->content_len  = (pj_size_t*) 
    200                               pj_pool_alloc(pool,  
     200                              pj_pool_alloc(pool, 
    201201                                            sizeof(framelist->content_len[0])* 
    202202                                            framelist->max_count); 
    203203    framelist->bit_info     = (pj_uint32_t*) 
    204                               pj_pool_alloc(pool,  
     204                              pj_pool_alloc(pool, 
    205205                                            sizeof(framelist->bit_info[0])* 
    206206                                            framelist->max_count); 
    207207    framelist->ts           = (pj_uint32_t*) 
    208                               pj_pool_alloc(pool,  
     208                              pj_pool_alloc(pool, 
    209209                                            sizeof(framelist->ts[0])* 
    210210                                            framelist->max_count); 
     
    214214} 
    215215 
    216 static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist)  
     216static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist) 
    217217{ 
    218218    PJ_UNUSED_ARG(framelist); 
     
    220220} 
    221221 
    222 static pj_status_t jb_framelist_reset(jb_framelist_t *framelist)  
     222static pj_status_t jb_framelist_reset(jb_framelist_t *framelist) 
    223223{ 
    224224    framelist->head = 0; 
     
    228228 
    229229 
    230     //pj_bzero(framelist->content,  
    231     //       framelist->frame_size *  
     230    //pj_bzero(framelist->content, 
     231    //       framelist->frame_size * 
    232232    //       framelist->max_count); 
    233233 
    234234    pj_memset(framelist->frame_type, 
    235235              PJMEDIA_JB_MISSING_FRAME, 
    236               sizeof(framelist->frame_type[0]) *  
     236              sizeof(framelist->frame_type[0]) * 
    237237              framelist->max_count); 
    238238 
    239     pj_bzero(framelist->content_len,  
    240              sizeof(framelist->content_len[0]) *  
     239    pj_bzero(framelist->content_len, 
     240             sizeof(framelist->content_len[0]) * 
    241241             framelist->max_count); 
    242242 
    243243    //pj_bzero(framelist->bit_info, 
    244     //       sizeof(framelist->bit_info[0]) *  
     244    //       sizeof(framelist->bit_info[0]) * 
    245245    //       framelist->max_count); 
    246246 
     
    249249 
    250250 
    251 static unsigned jb_framelist_size(const jb_framelist_t *framelist)  
     251static unsigned jb_framelist_size(const jb_framelist_t *framelist) 
    252252{ 
    253253    return framelist->size; 
     
    255255 
    256256 
    257 static unsigned jb_framelist_eff_size(const jb_framelist_t *framelist)  
     257static unsigned jb_framelist_eff_size(const jb_framelist_t *framelist) 
    258258{ 
    259259    return (framelist->size - framelist->discarded_num); 
    260260} 
    261261 
    262 static int jb_framelist_origin(const jb_framelist_t *framelist)  
     262static int jb_framelist_origin(const jb_framelist_t *framelist) 
    263263{ 
    264264    return framelist->origin; 
     
    271271                                  pj_uint32_t *bit_info, 
    272272                                  pj_uint32_t *ts, 
    273                                   int *seq)  
     273                                  int *seq) 
    274274{ 
    275275    if (framelist->size) { 
     
    296296                    *bit_info = 0; 
    297297            } else { 
    298                 pj_memcpy(frame,  
    299                           framelist->content +  
     298                pj_memcpy(frame, 
     299                          framelist->content + 
    300300                          framelist->head * framelist->frame_size, 
    301301                          framelist->frame_size); 
    302                 *p_type = (pjmedia_jb_frame_type)  
     302                *p_type = (pjmedia_jb_frame_type) 
    303303                          framelist->frame_type[framelist->head]; 
    304304                if (size) 
     
    312312                *seq = framelist->origin; 
    313313 
    314             //pj_bzero(framelist->content +  
     314            //pj_bzero(framelist->content + 
    315315            //   framelist->head * framelist->frame_size, 
    316316            //   framelist->frame_size); 
     
    323323            framelist->head = (framelist->head + 1) % framelist->max_count; 
    324324            framelist->size--; 
    325          
     325 
    326326            return PJ_TRUE; 
    327327        } 
     
    342342                                   pj_uint32_t *bit_info, 
    343343                                   pj_uint32_t *ts, 
    344                                    int *seq)  
     344                                   int *seq) 
    345345{ 
    346346    unsigned pos, idx; 
     
    367367        *frame = framelist->content + pos*framelist->frame_size; 
    368368    if (type) 
    369         *type = (pjmedia_jb_frame_type)  
     369        *type = (pjmedia_jb_frame_type) 
    370370                framelist->frame_type[pos]; 
    371371    if (size) 
     
    384384/* Remove oldest frames as many as param 'count' */ 
    385385static unsigned jb_framelist_remove_head(jb_framelist_t *framelist, 
    386                                          unsigned count)  
    387 { 
    388     if (count > framelist->size)  
     386                                         unsigned count) 
     387{ 
     388    if (count > framelist->size) 
    389389        count = framelist->size; 
    390390 
     
    410410        } 
    411411 
    412         //pj_bzero(framelist->content +  
     412        //pj_bzero(framelist->content + 
    413413        //          framelist->head * framelist->frame_size, 
    414414        //          step1*framelist->frame_size); 
     
    440440        framelist->size -= count; 
    441441    } 
    442      
     442 
    443443    return count; 
    444444} 
     
    549549 
    550550 
    551 PJ_DEF(pj_status_t) pjmedia_jbuf_create(pj_pool_t *pool,  
     551PJ_DEF(pj_status_t) pjmedia_jbuf_create(pj_pool_t *pool, 
    552552                                        const pj_str_t *name, 
    553                                         unsigned frame_size,  
     553                                        unsigned frame_size, 
    554554                                        unsigned ptime, 
    555555                                        unsigned max_count, 
     
    597597    PJ_ASSERT_RETURN(prefetch <= jb->jb_max_count, PJ_EINVAL); 
    598598 
    599     jb->jb_min_prefetch = jb->jb_max_prefetch =  
     599    jb->jb_min_prefetch = jb->jb_max_prefetch = 
    600600        jb->jb_prefetch = jb->jb_init_prefetch = prefetch; 
    601601 
     
    676676               "  burst (min/max/avg/dev)=%d/%d/%d/%d frames\n" 
    677677               "  lost=%d discard=%d empty=%d", 
    678                jb_framelist_size(&jb->jb_framelist),  
    679                jb_framelist_eff_size(&jb->jb_framelist),  
     678               jb_framelist_size(&jb->jb_framelist), 
     679               jb_framelist_eff_size(&jb->jb_framelist), 
    680680               jb->jb_prefetch, jb->jb_eff_level, 
    681                jb->jb_delay.min, jb->jb_delay.max, jb->jb_delay.mean,  
     681               jb->jb_delay.min, jb->jb_delay.max, jb->jb_delay.mean, 
    682682               pj_math_stat_get_stddev(&jb->jb_delay), 
    683                jb->jb_burst.min, jb->jb_burst.max, jb->jb_burst.mean,  
     683               jb->jb_burst.min, jb->jb_burst.max, jb->jb_burst.mean, 
    684684               pj_math_stat_get_stddev(&jb->jb_burst), 
    685685               jb->jb_lost, jb->jb_discard, jb->jb_empty)); 
     
    705705 
    706706        enum { STABLE_HISTORY_LIMIT = 20 }; 
    707          
     707 
    708708        jb->jb_stable_hist++; 
    709          
    710         /* Only update the effective level (and prefetch) if 'stable'  
     709 
     710        /* Only update the effective level (and prefetch) if 'stable' 
    711711         * condition is reached (not just short time impulse) 
    712712         */ 
    713713        if (jb->jb_stable_hist > STABLE_HISTORY_LIMIT) { 
    714          
     714 
    715715            diff = (jb->jb_eff_level - jb->jb_max_hist_level) / 3; 
    716716 
     
    724724            if (jb->jb_init_prefetch) { 
    725725                jb->jb_prefetch = jb->jb_eff_level; 
    726                 if (jb->jb_prefetch < jb->jb_min_prefetch)  
     726                if (jb->jb_prefetch < jb->jb_min_prefetch) 
    727727                    jb->jb_prefetch = jb->jb_min_prefetch; 
    728728                if (jb->jb_prefetch > jb->jb_max_prefetch) 
     
    736736            TRACE__((jb->jb_name.ptr,"jb updated(1), lvl=%d pre=%d, size=%d", 
    737737                     jb->jb_eff_level, jb->jb_prefetch, cur_size)); 
     738            PJ_UNUSED_ARG(cur_size); /* Warning about unused var */ 
    738739        } 
    739740    } 
     
    759760        //jb->jb_max_hist_level = 0; 
    760761 
    761         TRACE__((jb->jb_name.ptr,"jb updated(2), lvl=%d pre=%d, size=%d",  
     762        TRACE__((jb->jb_name.ptr,"jb updated(2), lvl=%d pre=%d, size=%d", 
    762763                 jb->jb_eff_level, jb->jb_prefetch, cur_size)); 
    763764    } 
     
    778779     * 
    779780     * Moreover, normally drift level is quite low, so JB shouldn't need 
    780      * to shrink aggresively, it will shrink maximum one frame per  
    781      * PJMEDIA_JBUF_DISC_MIN_GAP ms. Theoritically, JB may handle drift level  
     781     * to shrink aggresively, it will shrink maximum one frame per 
     782     * PJMEDIA_JBUF_DISC_MIN_GAP ms. Theoritically, JB may handle drift level 
    782783     * as much as = FRAME_PTIME/PJMEDIA_JBUF_DISC_MIN_GAP * 100% 
    783784     * 
    784      * Whenever there is drift, where PUT > GET, this method will keep  
     785     * Whenever there is drift, where PUT > GET, this method will keep 
    785786     * the latency (JB size) as much as twice of burst level. 
    786787     */ 
     
    797798        int seq_origin; 
    798799 
    799         /* Check and adjust jb_discard_ref, in case there was  
    800          * seq restart  
     800        /* Check and adjust jb_discard_ref, in case there was 
     801         * seq restart 
    801802         */ 
    802803        seq_origin = jb_framelist_origin(&jb->jb_framelist); 
     
    814815            jb->jb_discard += diff; 
    815816 
    816             TRACE__((jb->jb_name.ptr,  
     817            TRACE__((jb->jb_name.ptr, 
    817818                     "JB shrinking %d frame(s), cur size=%d", diff, 
    818819                     jb_framelist_eff_size(&jb->jb_framelist))); 
     
    846847        T = PJMEDIA_JBUF_PRO_DISC_T2; 
    847848    else 
    848         T = PJMEDIA_JBUF_PRO_DISC_T1 +  
     849        T = PJMEDIA_JBUF_PRO_DISC_T1 + 
    849850            (PJMEDIA_JBUF_PRO_DISC_T2 - PJMEDIA_JBUF_PRO_DISC_T1) * 
    850851            (burst_level - PJMEDIA_JBUF_PRO_DISC_MIN_BURST) / 
     
    874875    if (last_seq >= (jb->jb_discard_ref + (int)jb->jb_discard_dist)) { 
    875876        int discard_seq; 
    876          
     877 
    877878        discard_seq = jb->jb_discard_ref + jb->jb_discard_dist; 
    878879        if (discard_seq < jb_framelist_origin(&jb->jb_framelist)) 
     
    881882        jb_framelist_discard(&jb->jb_framelist, discard_seq); 
    882883 
    883         TRACE__((jb->jb_name.ptr,  
     884        TRACE__((jb->jb_name.ptr, 
    884885                "Discard #%d: ref=#%d dist=%d orig=%d size=%d/%d " 
    885886                "burst=%d/%d", 
     
    897898    } 
    898899} 
    899      
     900 
    900901 
    901902PJ_INLINE(void) jbuf_update(pjmedia_jbuf *jb, int oper) 
     
    905906 
    906907        if (jb->jb_status == JB_STATUS_INITIALIZING) { 
    907             /* Switch status 'initializing' -> 'processing' after some OP  
    908              * switch cycles and current OP is GET (burst level is calculated  
     908            /* Switch status 'initializing' -> 'processing' after some OP 
     909             * switch cycles and current OP is GET (burst level is calculated 
    909910             * based on PUT burst), so burst calculation is guaranted to be 
    910911             * performed right after the status switching. 
     
    922923        } 
    923924 
    924         /* Perform jitter calculation based on PUT burst-level only, since  
     925        /* Perform jitter calculation based on PUT burst-level only, since 
    925926         * GET burst-level may not be accurate, e.g: when VAD is active. 
    926927         * Note that when burst-level is too big, i.e: exceeds jb_max_burst, 
    927          * the GET op may be idle, in this case, we better skip the jitter  
     928         * the GET op may be idle, in this case, we better skip the jitter 
    928929         * calculation. 
    929930         */ 
     
    940941} 
    941942 
    942 PJ_DEF(void) pjmedia_jbuf_put_frame( pjmedia_jbuf *jb,  
    943                                      const void *frame,  
    944                                      pj_size_t frame_size,  
     943PJ_DEF(void) pjmedia_jbuf_put_frame( pjmedia_jbuf *jb, 
     944                                     const void *frame, 
     945                                     pj_size_t frame_size, 
    945946                                     int frame_seq) 
    946947{ 
     
    948949} 
    949950 
    950 PJ_DEF(void) pjmedia_jbuf_put_frame2(pjmedia_jbuf *jb,  
    951                                      const void *frame,  
    952                                      pj_size_t frame_size,  
     951PJ_DEF(void) pjmedia_jbuf_put_frame2(pjmedia_jbuf *jb, 
     952                                     const void *frame, 
     953                                     pj_size_t frame_size, 
    953954                                     pj_uint32_t bit_info, 
    954955                                     int frame_seq, 
    955956                                     pj_bool_t *discarded) 
    956957{ 
    957     pjmedia_jbuf_put_frame3(jb, frame, frame_size, bit_info, frame_seq, 0,  
     958    pjmedia_jbuf_put_frame3(jb, frame, frame_size, bit_info, frame_seq, 0, 
    958959                            discarded); 
    959960} 
    960961 
    961 PJ_DEF(void) pjmedia_jbuf_put_frame3(pjmedia_jbuf *jb,  
    962                                      const void *frame,  
    963                                      pj_size_t frame_size,  
     962PJ_DEF(void) pjmedia_jbuf_put_frame3(pjmedia_jbuf *jb, 
     963                                     const void *frame, 
     964                                     pj_size_t frame_size, 
    964965                                     pj_uint32_t bit_info, 
    965966                                     int frame_seq, 
     
    978979                                 (unsigned)min_frame_size, bit_info, ts, 
    979980                                 PJMEDIA_JB_NORMAL_FRAME); 
    980      
     981 
    981982    /* Jitter buffer is full, remove some older frames */ 
    982983    while (status == PJ_ETOOMANY) { 
     
    10101011    if (status == PJ_SUCCESS) { 
    10111012        if (jb->jb_prefetching) { 
    1012             TRACE__((jb->jb_name.ptr, "PUT prefetch_cnt=%d/%d",  
     1013            TRACE__((jb->jb_name.ptr, "PUT prefetch_cnt=%d/%d", 
    10131014                     new_size, jb->jb_prefetch)); 
    10141015            if (new_size >= jb->jb_prefetch) 
     
    10241025 * Get frame from jitter buffer. 
    10251026 */ 
    1026 PJ_DEF(void) pjmedia_jbuf_get_frame( pjmedia_jbuf *jb,  
    1027                                      void *frame,  
     1027PJ_DEF(void) pjmedia_jbuf_get_frame( pjmedia_jbuf *jb, 
     1028                                     void *frame, 
    10281029                                     char *p_frame_type) 
    10291030{ 
     
    10351036 * Get frame from jitter buffer. 
    10361037 */ 
    1037 PJ_DEF(void) pjmedia_jbuf_get_frame2(pjmedia_jbuf *jb,  
    1038                                      void *frame,  
     1038PJ_DEF(void) pjmedia_jbuf_get_frame2(pjmedia_jbuf *jb, 
     1039                                     void *frame, 
    10391040                                     pj_size_t *size, 
    10401041                                     char *p_frame_type, 
     
    10481049 * Get frame from jitter buffer. 
    10491050 */ 
    1050 PJ_DEF(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb,  
    1051                                      void *frame,  
     1051PJ_DEF(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb, 
     1052                                     void *frame, 
    10521053                                     pj_size_t *size, 
    10531054                                     char *p_frame_type, 
     
    10781079 
    10791080        /* Try to retrieve a frame from frame list */ 
    1080         res = jb_framelist_get(&jb->jb_framelist, frame, size, &ftype,  
     1081        res = jb_framelist_get(&jb->jb_framelist, frame, size, &ftype, 
    10811082                               bit_info, ts, seq); 
    10821083        if (res) { 
     
    10971098                /* We've just retrieved one frame, so add one to cur_size */ 
    10981099                cur_size = jb_framelist_eff_size(&jb->jb_framelist) + 1; 
    1099                 pj_math_stat_update(&jb->jb_delay,  
     1100                pj_math_stat_update(&jb->jb_delay, 
    11001101                                    cur_size*jb->jb_frame_ptime); 
    11011102            } 
     
    11291130    state->min_prefetch = jb->jb_min_prefetch; 
    11301131    state->max_prefetch = jb->jb_max_prefetch; 
    1131      
     1132 
    11321133    state->burst = jb->jb_eff_level; 
    11331134    state->prefetch = jb->jb_prefetch; 
    11341135    state->size = jb_framelist_eff_size(&jb->jb_framelist); 
    1135      
     1136 
    11361137    state->avg_delay = jb->jb_delay.mean; 
    11371138    state->min_delay = jb->jb_delay.min; 
    11381139    state->max_delay = jb->jb_delay.max; 
    11391140    state->dev_delay = pj_math_stat_get_stddev(&jb->jb_delay); 
    1140      
     1141 
    11411142    state->avg_burst = jb->jb_burst.mean; 
    11421143    state->empty = jb->jb_empty; 
     
    11501151PJ_DEF(void) pjmedia_jbuf_peek_frame( pjmedia_jbuf *jb, 
    11511152                                      unsigned offset, 
    1152                                       const void **frame,  
    1153                                       pj_size_t *size,  
     1153                                      const void **frame, 
     1154                                      pj_size_t *size, 
    11541155                                      char *p_frm_type, 
    11551156                                      pj_uint32_t *bit_info, 
     
    11711172 
    11721173 
    1173 PJ_DEF(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb,  
     1174PJ_DEF(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb, 
    11741175                                           unsigned frame_cnt) 
    11751176{ 
  • pjproject/trunk/pjmedia/src/pjmedia/stream.c

    r4613 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include <pjmedia/stream.h> 
     
    185185     */ 
    186186    pj_bool_t                has_g722_mpeg_bug; 
    187                                             /**< Flag to specify whether  
    188                                                  normalization process  
     187                                            /**< Flag to specify whether 
     188                                                 normalization process 
    189189                                                 is needed                  */ 
    190190    unsigned                 rtp_tx_ts_len_per_pkt; 
    191191                                            /**< Normalized ts length per packet 
    192                                                  transmitted according to  
     192                                                 transmitted according to 
    193193                                                 'erroneous' definition     */ 
    194194    unsigned                 rtp_rx_ts_len_per_frame; 
    195195                                            /**< Normalized ts length per frame 
    196                                                  received according to  
     196                                                 received according to 
    197197                                                 'erroneous' definition     */ 
    198198    unsigned                 rtp_rx_last_cnt;/**< Nb of frames in last pkt  */ 
     
    203203 
    204204#if defined(PJMEDIA_HAS_RTCP_XR) && (PJMEDIA_HAS_RTCP_XR != 0) 
    205     pj_uint32_t              rtcp_xr_last_tx;  /**< RTCP XR tx time  
     205    pj_uint32_t              rtcp_xr_last_tx;  /**< RTCP XR tx time 
    206206                                                    in timestamp.           */ 
    207207    pj_uint32_t              rtcp_xr_interval; /**< Interval, in timestamp. */ 
    208     pj_sockaddr              rtcp_xr_dest;     /**< Additional remote RTCP XR  
    209                                                     dest. If sin_family is  
     208    pj_sockaddr              rtcp_xr_dest;     /**< Additional remote RTCP XR 
     209                                                    dest. If sin_family is 
    210210                                                    zero, it will be ignored*/ 
    211211    unsigned                 rtcp_xr_dest_len; /**< Length of RTCP XR dest 
     
    231231 
    232232/* RFC 2833 digit */ 
    233 static const char digitmap[16] = { '0', '1', '2', '3',  
    234                                    '4', '5', '6', '7',  
     233static const char digitmap[16] = { '0', '1', '2', '3', 
     234                                   '4', '5', '6', '7', 
    235235                                   '8', '9', '*', '#', 
    236236                                   'A', 'B', 'C', 'D'}; 
     
    285285} 
    286286 
    287 PJ_INLINE(int) trace_jb_print_state(pjmedia_stream *stream,  
     287PJ_INLINE(int) trace_jb_print_state(pjmedia_stream *stream, 
    288288                                    char **buf, pj_ssize_t len) 
    289289{ 
     
    460460 
    461461#else 
    462      
     462 
    463463    PJ_UNUSED_ARG(stream); 
    464464 
     
    498498    samples_per_frame = stream->codec_param.info.frm_ptime * 
    499499                        stream->codec_param.info.clock_rate * 
    500                         stream->codec_param.info.channel_cnt /  
     500                        stream->codec_param.info.channel_cnt / 
    501501                        1000; 
    502502    p_out_samp = (pj_int16_t*) frame->buf; 
    503503 
    504     for (samples_count=0; samples_count < samples_required;  
    505          samples_count += samples_per_frame)  
     504    for (samples_count=0; samples_count < samples_required; 
     505         samples_count += samples_per_frame) 
    506506    { 
    507507        char frame_type; 
     
    518518 
    519519        if (frame_type == PJMEDIA_JB_MISSING_FRAME) { 
    520              
     520 
    521521            /* Activate PLC */ 
    522             if (stream->codec->op->recover &&  
     522            if (stream->codec->op->recover && 
    523523                stream->codec_param.setting.plc && 
    524                 stream->plc_cnt < stream->max_plc_cnt)  
     524                stream->plc_cnt < stream->max_plc_cnt) 
    525525            { 
    526526                pjmedia_frame frame_out; 
     
    561561            /* Jitter buffer is empty. If this is the first "empty" state, 
    562562             * activate PLC to smoothen the fade-out, otherwise zero 
    563              * the frame.  
     563             * the frame. 
    564564             */ 
    565565            //Using this "if" will only invoke PLC for the first packet 
     
    568568            if (1) { 
    569569                /* Activate PLC to smoothen the missing frame */ 
    570                 if (stream->codec->op->recover &&  
     570                if (stream->codec->op->recover && 
    571571                    stream->codec_param.setting.plc && 
    572                     stream->plc_cnt < stream->max_plc_cnt)  
     572                    stream->plc_cnt < stream->max_plc_cnt) 
    573573                { 
    574574                    pjmedia_frame frame_out; 
     
    590590 
    591591                    with_plc = ", plc invoked"; 
    592                 }  
     592                } 
    593593            } 
    594594 
     
    604604                /* Report changing frame type event */ 
    605605                pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    606                 PJ_LOG(5,(stream->port.info.name.ptr,  
    607                           "Jitter buffer empty (prefetch=%d)%s",  
     606                PJ_LOG(5,(stream->port.info.name.ptr, 
     607                          "Jitter buffer empty (prefetch=%d)%s", 
    608608                          jb_state.prefetch, with_plc)); 
    609609 
     
    623623 
    624624            /* Always activate PLC when it's available.. */ 
    625             if (stream->codec->op->recover &&  
     625            if (stream->codec->op->recover && 
    626626                stream->codec_param.setting.plc && 
    627                 stream->plc_cnt < stream->max_plc_cnt)  
     627                stream->plc_cnt < stream->max_plc_cnt) 
    628628            { 
    629629                pjmedia_frame frame_out; 
     
    645645 
    646646                with_plc = ", plc invoked"; 
    647             }  
     647            } 
    648648 
    649649            if (samples_count < samples_required) { 
     
    658658                /* Report changing frame type event */ 
    659659                pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    660                 PJ_LOG(5,(stream->port.info.name.ptr,  
    661                           "Jitter buffer is bufferring (prefetch=%d)%s",  
     660                PJ_LOG(5,(stream->port.info.name.ptr, 
     661                          "Jitter buffer is bufferring (prefetch=%d)%s", 
    662662                          jb_state.prefetch, with_plc)); 
    663663 
     
    684684            frame_out.size = frame->size - samples_count*BYTES_PER_SAMPLE; 
    685685            status = pjmedia_codec_decode( stream->codec, &frame_in, 
    686                                            (unsigned)frame_out.size,  
     686                                           (unsigned)frame_out.size, 
    687687                                           &frame_out); 
    688688            if (status != 0) { 
    689                 LOGERR_((port->info.name.ptr, "codec decode() error",  
     689                LOGERR_((port->info.name.ptr, "codec decode() error", 
    690690                         status)); 
    691691 
    692                 pjmedia_zero_samples(p_out_samp + samples_count,  
     692                pjmedia_zero_samples(p_out_samp + samples_count, 
    693693                                     samples_per_frame); 
    694694            } 
     
    696696            if (stream->jb_last_frm != frame_type) { 
    697697                /* Report changing frame type event */ 
    698                 PJ_LOG(5,(stream->port.info.name.ptr,  
     698                PJ_LOG(5,(stream->port.info.name.ptr, 
    699699                          "Jitter buffer starts returning normal frames " 
    700700                          "(after %d empty/lost)", 
     
    753753    samples_per_frame = stream->codec_param.info.frm_ptime * 
    754754                        stream->codec_param.info.clock_rate * 
    755                         stream->codec_param.info.channel_cnt /  
     755                        stream->codec_param.info.channel_cnt / 
    756756                        1000; 
    757757 
     
    774774        trace_jb_get(stream, frame_type, frame_size); 
    775775#endif 
    776          
     776 
    777777        /* Unlock jitter buffer mutex. */ 
    778778        pj_mutex_unlock( stream->jb_mutex ); 
     
    791791                                           0, frame); 
    792792            if (status != PJ_SUCCESS) { 
    793                 LOGERR_((port->info.name.ptr, "codec decode() error",  
     793                LOGERR_((port->info.name.ptr, "codec decode() error", 
    794794                         status)); 
    795795                pjmedia_frame_ext_append_subframe(f, NULL, 0, 
     
    799799            if (stream->jb_last_frm != frame_type) { 
    800800                /* Report changing frame type event */ 
    801                 PJ_LOG(5,(stream->port.info.name.ptr,  
     801                PJ_LOG(5,(stream->port.info.name.ptr, 
    802802                          "Jitter buffer starts returning normal frames " 
    803803                          "(after %d empty/lost)", 
     
    817817                status = pjmedia_codec_recover(stream->codec, 0, frame); 
    818818            } 
    819              
     819 
    820820            /* No PLC or PLC failed */ 
    821821            if (!stream->codec->op->recover || status != PJ_SUCCESS) { 
     
    840840                    /* Report changing frame type event */ 
    841841                    pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    842                     PJ_LOG(5,(stream->port.info.name.ptr,  
    843                               "Jitter buffer empty (prefetch=%d)",  
     842                    PJ_LOG(5,(stream->port.info.name.ptr, 
     843                              "Jitter buffer empty (prefetch=%d)", 
    844844                              jb_state.prefetch)); 
    845845 
     
    859859                    /* Report changing frame type event */ 
    860860                    pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    861                     PJ_LOG(5,(stream->port.info.name.ptr,  
     861                    PJ_LOG(5,(stream->port.info.name.ptr, 
    862862                              "Jitter buffer is bufferring (prefetch=%d)", 
    863863                              jb_state.prefetch)); 
     
    879879 * Transmit DTMF 
    880880 */ 
    881 static void create_dtmf_payload(pjmedia_stream *stream,  
     881static void create_dtmf_payload(pjmedia_stream *stream, 
    882882                                struct pjmedia_frame *frame_out, 
    883883                                int forced_last, int *first, int *last) 
     
    885885    pjmedia_rtp_dtmf_event *event; 
    886886    struct dtmf *digit = &stream->tx_dtmf_buf[0]; 
    887     pj_uint32_t cur_ts; 
    888887 
    889888    pj_assert(sizeof(pjmedia_rtp_dtmf_event) == 4); 
     
    892891 
    893892    event = (pjmedia_rtp_dtmf_event*) frame_out->buf; 
    894     cur_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts); 
    895893 
    896894    if (digit->duration == 0) { 
    897         PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c",  
     895        PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c", 
    898896                  digitmap[digit->event])); 
    899897        *first = 1; 
     
    988986        /* Update RTCP XR with current JB states */ 
    989987        pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    990              
     988 
    991989        i = jb_state.avg_delay; 
    992         status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     990        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    993991                                             PJMEDIA_RTCP_XR_INFO_JB_NOM, i); 
    994992        pj_assert(status == PJ_SUCCESS); 
    995993 
    996994        i = jb_state.max_delay; 
    997         status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     995        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    998996                                             PJMEDIA_RTCP_XR_INFO_JB_MAX, i); 
    999997        pj_assert(status == PJ_SUCCESS); 
     
    10081006            /* Send the RTCP XR to third-party destination if specified */ 
    10091007            if (stream->rtcp_xr_dest_len) { 
    1010                 pjmedia_transport_send_rtcp2(stream->transport,  
     1008                pjmedia_transport_send_rtcp2(stream->transport, 
    10111009                                             &stream->rtcp_xr_dest, 
    1012                                              stream->rtcp_xr_dest_len,  
     1010                                             stream->rtcp_xr_dest_len, 
    10131011                                             xr_pkt, xr_len); 
    10141012            } 
     
    10501048static void check_tx_rtcp(pjmedia_stream *stream, pj_uint32_t timestamp) 
    10511049{ 
    1052     /* Note that timestamp may represent local or remote timestamp,  
     1050    /* Note that timestamp may represent local or remote timestamp, 
    10531051     * depending on whether this function is called from put_frame() 
    10541052     * or get_frame(). 
     
    10561054 
    10571055    if (stream->rtcp_last_tx == 0) { 
    1058          
     1056 
    10591057        stream->rtcp_last_tx = timestamp; 
    10601058 
     
    10671065            if (stream->rtcp_xr_last_tx == 0) { 
    10681066                stream->rtcp_xr_last_tx = timestamp; 
    1069             } else if (timestamp - stream->rtcp_xr_last_tx >=  
     1067            } else if (timestamp - stream->rtcp_xr_last_tx >= 
    10701068                       stream->rtcp_xr_interval) 
    10711069            { 
     
    11311129 
    11321130    /* How many samples are needed */ 
    1133     count = stream->codec_param.info.enc_ptime *  
     1131    count = stream->codec_param.info.enc_ptime * 
    11341132            PJMEDIA_PIA_SRATE(&stream->port.info) / 1000; 
    11351133 
     
    11541152 * put_frame_imp() 
    11551153 */ 
    1156 static pj_status_t put_frame_imp( pjmedia_port *port,  
     1154static pj_status_t put_frame_imp( pjmedia_port *port, 
    11571155                                  pjmedia_frame *frame ) 
    11581156{ 
     
    11751173        pj_uint32_t dtx_duration; 
    11761174 
    1177         dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent,  
     1175        dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent, 
    11781176                                           &frame->timestamp); 
    11791177        if (dtx_duration > 
     
    11941192    /* Number of samples in the frame */ 
    11951193    if (frame->type == PJMEDIA_FRAME_TYPE_AUDIO) 
    1196         ts_len = ((unsigned)frame->size >> 1) /  
     1194        ts_len = ((unsigned)frame->size >> 1) / 
    11971195                 stream->codec_param.info.channel_cnt; 
    11981196    else if (frame->type == PJMEDIA_FRAME_TYPE_EXTENDED) 
     
    12061204 
    12071205#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG!=0) 
    1208     /* Handle special case for audio codec with RTP timestamp inconsistence  
     1206    /* Handle special case for audio codec with RTP timestamp inconsistence 
    12091207     * e.g: G722, MPEG audio. 
    12101208     */ 
     
    12251223 
    12261224 
    1227     /* If we have DTMF digits in the queue, transmit the digits.  
     1225    /* If we have DTMF digits in the queue, transmit the digits. 
    12281226     * Otherwise encode the PCM buffer. 
    12291227     */ 
     
    12351233        /* Encapsulate into RTP packet. Note that: 
    12361234         *  - RTP marker should be set on the beginning of a new event 
    1237          *  - RTP timestamp is constant for the same packet.  
     1235         *  - RTP timestamp is constant for the same packet. 
    12381236         */ 
    1239         status = pjmedia_rtp_encode_rtp( &channel->rtp,  
    1240                                          stream->tx_event_pt, first,  
     1237        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
     1238                                         stream->tx_event_pt, first, 
    12411239                                         (int)frame_out.size, 
    1242                                          (first ? rtp_ts_len : 0),  
    1243                                          (const void**)&rtphdr,  
     1240                                         (first ? rtp_ts_len : 0), 
     1241                                         (const void**)&rtphdr, 
    12441242                                         &rtphdrlen); 
    12451243 
    12461244        if (last) { 
    1247             /* This is the last packet for the event.  
     1245            /* This is the last packet for the event. 
    12481246             * Increment the RTP timestamp of the RTP session, for next 
    12491247             * RTP packets. 
     
    12721270               stream->codec_param.info.channel_cnt * 
    12731271               stream->codec_param.info.clock_rate/1000 < 
    1274                   PJ_ARRAY_SIZE(zero_frame))  
     1272                  PJ_ARRAY_SIZE(zero_frame)) 
    12751273    { 
    12761274        pjmedia_frame silence_frame; 
     
    12831281        silence_frame.type = PJMEDIA_FRAME_TYPE_AUDIO; 
    12841282        silence_frame.timestamp.u32.lo = pj_ntohl(stream->enc->rtp.out_hdr.ts); 
    1285          
     1283 
    12861284        /* Encode! */ 
    12871285        status = pjmedia_codec_encode( stream->codec, &silence_frame, 
    1288                                        channel->out_pkt_size -  
     1286                                       channel->out_pkt_size - 
    12891287                                       sizeof(pjmedia_rtp_hdr), 
    12901288                                       &frame_out); 
    12911289        if (status != PJ_SUCCESS) { 
    1292             LOGERR_((stream->port.info.name.ptr,  
     1290            LOGERR_((stream->port.info.name.ptr, 
    12931291                    "Codec encode() error", status)); 
    12941292            return status; 
     
    12961294 
    12971295        /* Encapsulate. */ 
    1298         status = pjmedia_rtp_encode_rtp( &channel->rtp,  
    1299                                          channel->pt, 0,  
    1300                                          (int)frame_out.size, rtp_ts_len,  
    1301                                          (const void**)&rtphdr,  
     1296        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
     1297                                         channel->pt, 0, 
     1298                                         (int)frame_out.size, rtp_ts_len, 
     1299                                         (const void**)&rtphdr, 
    13021300                                         &rtphdrlen); 
    13031301 
     
    13091307    { 
    13101308        /* Encode! */ 
    1311         status = pjmedia_codec_encode( stream->codec, frame,  
    1312                                        channel->out_pkt_size -  
     1309        status = pjmedia_codec_encode( stream->codec, frame, 
     1310                                       channel->out_pkt_size - 
    13131311                                       sizeof(pjmedia_rtp_hdr), 
    13141312                                       &frame_out); 
    13151313        if (status != PJ_SUCCESS) { 
    1316             LOGERR_((stream->port.info.name.ptr,  
     1314            LOGERR_((stream->port.info.name.ptr, 
    13171315                    "Codec encode() error", status)); 
    13181316            return status; 
     
    13201318 
    13211319        /* Encapsulate. */ 
    1322         status = pjmedia_rtp_encode_rtp( &channel->rtp,  
    1323                                          channel->pt, 0,  
    1324                                          (int)frame_out.size, rtp_ts_len,  
    1325                                          (const void**)&rtphdr,  
     1320        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
     1321                                         channel->pt, 0, 
     1322                                         (int)frame_out.size, rtp_ts_len, 
     1323                                         (const void**)&rtphdr, 
    13261324                                         &rtphdrlen); 
    13271325 
     
    13291327 
    13301328        /* Just update RTP session's timestamp. */ 
    1331         status = pjmedia_rtp_encode_rtp( &channel->rtp,  
    1332                                          0, 0,  
    1333                                          0, rtp_ts_len,  
    1334                                          (const void**)&rtphdr,  
     1329        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
     1330                                         0, 0, 
     1331                                         0, rtp_ts_len, 
     1332                                         (const void**)&rtphdr, 
    13351333                                         &rtphdrlen); 
    13361334 
     
    13381336 
    13391337    if (status != PJ_SUCCESS) { 
    1340         LOGERR_((stream->port.info.name.ptr,  
     1338        LOGERR_((stream->port.info.name.ptr, 
    13411339                "RTP encode_rtp() error", status)); 
    13421340        return status; 
    13431341    } 
    13441342 
    1345     /* Check if now is the time to transmit RTCP SR/RR report.  
     1343    /* Check if now is the time to transmit RTCP SR/RR report. 
    13461344     * We only do this when stream direction is not "decoding only", because 
    13471345     * when it is, check_tx_rtcp() will be handled by get_frame(). 
     
    14141412 * RTP packet, and transmit to peer. 
    14151413 */ 
    1416 static pj_status_t put_frame( pjmedia_port *port,  
     1414static pj_status_t put_frame( pjmedia_port *port, 
    14171415                              pjmedia_frame *frame ) 
    14181416{ 
     
    14621460     */ 
    14631461    if (stream->vad_enabled != stream->codec_param.setting.vad && 
    1464         (stream->tx_duration - stream->ts_vad_disabled) >  
     1462        (stream->tx_duration - stream->ts_vad_disabled) > 
    14651463           PJMEDIA_PIA_SRATE(&stream->port.info) * 
    14661464          PJMEDIA_STREAM_VAD_SUSPEND_MSEC / 1000) 
     
    14791477        pj_status_t status = PJ_SUCCESS; 
    14801478 
    1481         /* Copy original frame to temporary frame since we need  
     1479        /* Copy original frame to temporary frame since we need 
    14821480         * to modify it. 
    14831481         */ 
     
    15461544 * Handle incoming DTMF digits. 
    15471545 */ 
    1548 static void handle_incoming_dtmf( pjmedia_stream *stream,  
     1546static void handle_incoming_dtmf( pjmedia_stream *stream, 
    15491547                                  const void *payload, unsigned payloadlen) 
    15501548{ 
     
    15721570    /* Ignore unknown event. */ 
    15731571    if (event->event > 15) { 
    1574         PJ_LOG(5,(stream->port.info.name.ptr,  
     1572        PJ_LOG(5,(stream->port.info.name.ptr, 
    15751573                  "Ignored RTP pkt with bad DTMF event %d", 
    15761574                  event->event)); 
     
    15911589    if (stream->dtmf_cb) { 
    15921590 
    1593         stream->dtmf_cb(stream, stream->dtmf_cb_user_data,  
     1591        stream->dtmf_cb(stream, stream->dtmf_cb_user_data, 
    15941592                        digitmap[event->event]); 
    15951593 
     
    16011599        if (stream->rx_dtmf_count >= PJ_ARRAY_SIZE(stream->rx_dtmf_buf)) { 
    16021600            /* DTMF digits overflow.  Discard the oldest digit. */ 
    1603             pj_array_erase(stream->rx_dtmf_buf,  
     1601            pj_array_erase(stream->rx_dtmf_buf, 
    16041602                           sizeof(stream->rx_dtmf_buf[0]), 
    16051603                           stream->rx_dtmf_count, 0); 
     
    16141612/* 
    16151613 * This callback is called by stream transport on receipt of packets 
    1616  * in the RTP socket.  
    1617  */ 
    1618 static void on_rx_rtp( void *data,  
     1614 * in the RTP socket. 
     1615 */ 
     1616static void on_rx_rtp( void *data, 
    16191617                       void *pkt, 
    16201618                       pj_ssize_t bytes_read) 
     
    16321630    /* Check for errors */ 
    16331631    if (bytes_read < 0) { 
    1634         LOGERR_((stream->port.info.name.ptr, "RTP recv() error",  
     1632        LOGERR_((stream->port.info.name.ptr, "RTP recv() error", 
    16351633                (pj_status_t)-bytes_read)); 
    16361634        return; 
     
    16601658                                hdr->pt != stream->rx_event_pt); 
    16611659    if (seq_st.status.value) { 
    1662         TRC_  ((stream->port.info.name.ptr,  
     1660        TRC_  ((stream->port.info.name.ptr, 
    16631661                "RTP status: badpt=%d, badssrc=%d, dup=%d, " 
    1664                 "outorder=%d, probation=%d, restart=%d",  
     1662                "outorder=%d, probation=%d, restart=%d", 
    16651663                seq_st.status.flag.badpt, 
    16661664                seq_st.status.flag.badssrc, 
     
    17371735                                     payloadlen, &ts, &count, frames); 
    17381736        if (status != PJ_SUCCESS) { 
    1739             LOGERR_((stream->port.info.name.ptr,  
    1740                      "Codec parse() error",  
     1737            LOGERR_((stream->port.info.name.ptr, 
     1738                     "Codec parse() error", 
    17411739                     status)); 
    17421740            count = 0; 
     
    17461744        /* This code is used to learn the samples per frame value that is put 
    17471745         * by remote endpoint, for codecs with inconsistent clock rate such 
    1748          * as G.722 or MPEG audio. We need to learn the samples per frame  
     1746         * as G.722 or MPEG audio. We need to learn the samples per frame 
    17491747         * value as it is used as divider when inserting frames into the 
    17501748         * jitter buffer. 
     
    17521750        if (stream->has_g722_mpeg_bug) { 
    17531751            if (stream->rtp_rx_check_cnt) { 
    1754                 /* Make sure the detection performed only on two consecutive  
     1752                /* Make sure the detection performed only on two consecutive 
    17551753                 * packets with valid RTP sequence and no wrapped timestamp. 
    17561754                 */ 
    1757                 if (seq_st.diff == 1 && stream->rtp_rx_last_ts &&  
    1758                     ts.u64 > stream->rtp_rx_last_ts &&  
     1755                if (seq_st.diff == 1 && stream->rtp_rx_last_ts && 
     1756                    ts.u64 > stream->rtp_rx_last_ts && 
    17591757                    stream->rtp_rx_last_cnt > 0) 
    17601758                { 
     
    17681766 
    17691767                    /* Get remote frame timestamp span */ 
    1770                     peer_frm_ts_diff =  
    1771                         ((pj_uint32_t)ts.u64-stream->rtp_rx_last_ts) /  
     1768                    peer_frm_ts_diff = 
     1769                        ((pj_uint32_t)ts.u64-stream->rtp_rx_last_ts) / 
    17721770                        stream->rtp_rx_last_cnt; 
    17731771 
     
    17781776                     */ 
    17791777                    if (stream->codec_param.info.pt == PJMEDIA_RTP_PT_G722 && 
    1780                         (peer_frm_ts_diff == frm_ts_span ||  
     1778                        (peer_frm_ts_diff == frm_ts_span || 
    17811779                         peer_frm_ts_diff == (frm_ts_span>>1))) 
    17821780                    { 
     
    17901788                        if (--stream->rtp_rx_check_cnt == 0) { 
    17911789                            PJ_LOG(4, (THIS_FILE, "G722 codec used, remote" 
    1792                                        " samples per frame detected = %d",  
     1790                                       " samples per frame detected = %d", 
    17931791                                       stream->rtp_rx_ts_len_per_frame)); 
    1794                              
     1792 
    17951793                            /* Reset jitter buffer once detection done */ 
    17961794                            pjmedia_jbuf_reset(stream->jb); 
     
    18111809 
    18121810        } else { 
    1813             ts_span = stream->codec_param.info.frm_ptime *  
     1811            ts_span = stream->codec_param.info.frm_ptime * 
    18141812                      stream->codec_param.info.clock_rate / 
    18151813                      1000; 
    18161814        } 
    18171815#else 
    1818         ts_span = stream->codec_param.info.frm_ptime *  
     1816        ts_span = stream->codec_param.info.frm_ptime * 
    18191817                  stream->codec_param.info.clock_rate / 
    18201818                  1000; 
     
    18421840 
    18431841    /* Check if now is the time to transmit RTCP SR/RR report. 
    1844      * We only do this when stream direction is "decoding only",  
     1842     * We only do this when stream direction is "decoding only", 
    18451843     * because otherwise check_tx_rtcp() will be handled by put_frame() 
    18461844     */ 
     
    18501848 
    18511849    if (status != 0) { 
    1852         LOGERR_((stream->port.info.name.ptr, "Jitter buffer put() error",  
     1850        LOGERR_((stream->port.info.name.ptr, "Jitter buffer put() error", 
    18531851                status)); 
    18541852        pkt_discarded = PJ_TRUE; 
     
    18801878/* 
    18811879 * This callback is called by stream transport on receipt of packets 
    1882  * in the RTCP socket.  
     1880 * in the RTCP socket. 
    18831881 */ 
    18841882static void on_rx_rtcp( void *data, 
    1885                         void *pkt,  
     1883                        void *pkt, 
    18861884                        pj_ssize_t bytes_read) 
    18871885{ 
     
    18901888    /* Check for errors */ 
    18911889    if (bytes_read < 0) { 
    1892         LOGERR_((stream->port.info.name.ptr, "RTCP recv() error",  
     1890        LOGERR_((stream->port.info.name.ptr, "RTCP recv() error", 
    18931891                (pj_status_t)-bytes_read)); 
    18941892        return; 
     
    19111909    pjmedia_channel *channel; 
    19121910    pj_status_t status; 
    1913      
     1911 
    19141912    /* Allocate memory for channel descriptor */ 
    19151913 
     
    19241922    channel->pt = pt; 
    19251923 
    1926      
     1924 
    19271925    /* Allocate buffer for outgoing packet. */ 
    19281926 
    19291927    if (param->type == PJMEDIA_TYPE_AUDIO) { 
    1930         channel->out_pkt_size = sizeof(pjmedia_rtp_hdr) +  
    1931                                 stream->codec_param.info.max_bps *  
    1932                                 PJMEDIA_MAX_FRAME_DURATION_MS /  
     1928        channel->out_pkt_size = sizeof(pjmedia_rtp_hdr) + 
     1929                                stream->codec_param.info.max_bps * 
     1930                                PJMEDIA_MAX_FRAME_DURATION_MS / 
    19331931                                8 / 1000; 
    19341932        if (channel->out_pkt_size > PJMEDIA_MAX_MTU - 
     
    20782076        stream->codec_param = *info->param; 
    20792077    else { 
    2080         status = pjmedia_codec_mgr_get_default_param(stream->codec_mgr,  
    2081                                                      &info->fmt,  
     2078        status = pjmedia_codec_mgr_get_default_param(stream->codec_mgr, 
     2079                                                     &info->fmt, 
    20822080                                                     &stream->codec_param); 
    20832081        if (status != PJ_SUCCESS) 
     
    21372135    /* If encoder and decoder's ptime are asymmetric, then we need to 
    21382136     * create buffer on the encoder side. This could happen for example 
    2139      * with iLBC  
     2137     * with iLBC 
    21402138     */ 
    21412139    if (stream->codec_param.info.enc_ptime!=0 && 
     
    21852183        stream->frame_size = stream->codec_param.info.max_rx_frame_size; 
    21862184    } else { 
    2187         stream->frame_size = stream->codec_param.info.max_bps *  
     2185        stream->frame_size = stream->codec_param.info.max_bps * 
    21882186                             stream->codec_param.info.frm_ptime / 8 / 1000; 
    21892187        if ((stream->codec_param.info.max_bps * 
     
    22182216    /* Init jitter buffer parameters: */ 
    22192217    if (info->jb_max >= stream->codec_param.info.frm_ptime) 
    2220         jb_max = (info->jb_max + stream->codec_param.info.frm_ptime - 1) /  
     2218        jb_max = (info->jb_max + stream->codec_param.info.frm_ptime - 1) / 
    22212219                 stream->codec_param.info.frm_ptime; 
    22222220    else 
     
    22432241    /* Create jitter buffer */ 
    22442242    status = pjmedia_jbuf_create(pool, &stream->port.info.name, 
    2245                                  stream->frame_size,  
     2243                                 stream->frame_size, 
    22462244                                 stream->codec_param.info.frm_ptime, 
    22472245                                 jb_max, &stream->jb); 
     
    22552253    /* Create decoder channel: */ 
    22562254 
    2257     status = create_channel( pool, stream, PJMEDIA_DIR_DECODING,  
     2255    status = create_channel( pool, stream, PJMEDIA_DIR_DECODING, 
    22582256                             info->rx_pt, info, &stream->dec); 
    22592257    if (status != PJ_SUCCESS) 
     
    22632261    /* Create encoder channel: */ 
    22642262 
    2265     status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING,  
     2263    status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING, 
    22662264                             info->tx_pt, info, &stream->enc); 
    22672265    if (status != PJ_SUCCESS) 
     
    23162314 
    23172315    /* Only attach transport when stream is ready. */ 
    2318     status = pjmedia_transport_attach(tp, stream, &info->rem_addr,  
    2319                                       &info->rem_rtcp,  
    2320                                       pj_sockaddr_get_len(&info->rem_addr),  
     2316    status = pjmedia_transport_attach(tp, stream, &info->rem_addr, 
     2317                                      &info->rem_rtcp, 
     2318                                      pj_sockaddr_get_len(&info->rem_addr), 
    23212319                                      &on_rx_rtp, &on_rx_rtcp); 
    23222320    if (status != PJ_SUCCESS) 
     
    23362334            stream->rtcp_xr_interval = info->rtcp_xr_interval; 
    23372335        else 
    2338             stream->rtcp_xr_interval = (PJMEDIA_RTCP_INTERVAL +  
    2339                                        (pj_rand() % 8000)) *  
     2336            stream->rtcp_xr_interval = (PJMEDIA_RTCP_INTERVAL + 
     2337                                       (pj_rand() % 8000)) * 
    23402338                                       info->fmt.clock_rate / 1000; 
    23412339 
     
    23492347        /* jitter buffer adaptive info */ 
    23502348        i = PJMEDIA_RTCP_XR_JB_ADAPTIVE; 
    2351         pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     2349        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    23522350                                    PJMEDIA_RTCP_XR_INFO_CONF_JBA, 
    23532351                                    i); 
     
    23552353        /* Jitter buffer aggressiveness info (estimated) */ 
    23562354        i = 7; 
    2357         pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     2355        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    23582356                                    PJMEDIA_RTCP_XR_INFO_CONF_JBR, 
    23592357                                    i); 
     
    23612359        /* Jitter buffer absolute maximum delay */ 
    23622360        i = jb_max * stream->codec_param.info.frm_ptime; 
    2363         pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     2361        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    23642362                                    PJMEDIA_RTCP_XR_INFO_JB_ABS_MAX, 
    23652363                                    i); 
     
    23742372            i = PJMEDIA_RTCP_XR_PLC_DIS; 
    23752373#endif 
    2376         pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,  
     2374        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
    23772375                                    PJMEDIA_RTCP_XR_INFO_CONF_PLC, 
    23782376                                    i); 
     
    23962394        pj_ssize_t len; 
    23972395 
    2398         pj_ansi_snprintf(trace_name, sizeof(trace_name),  
     2396        pj_ansi_snprintf(trace_name, sizeof(trace_name), 
    23992397                         TRACE_JB_PATH_PREFIX "%s.csv", 
    24002398                         stream->port.info.name.ptr); 
     
    24022400        if (status != PJ_SUCCESS) { 
    24032401            stream->trace_jb_fd = TRACE_JB_INVALID_FD; 
    2404             PJ_LOG(3,(THIS_FILE, "Failed creating RTP trace file '%s'",  
     2402            PJ_LOG(3,(THIS_FILE, "Failed creating RTP trace file '%s'", 
    24052403                      trace_name)); 
    24062404        } else { 
     
    24902488    } 
    24912489 
    2492     /* Detach from transport  
     2490    /* Detach from transport 
    24932491     * MUST NOT hold stream mutex while detaching from transport, as 
    24942492     * it may cause deadlock. See ticket #460 for the details. 
     
    25132511 
    25142512    /* Free mutex */ 
    2515      
     2513 
    25162514    if (stream->jb_mutex) { 
    25172515        pj_mutex_destroy(stream->jb_mutex); 
     
    27242722        return PJMEDIA_RTP_EREMNORFC2833; 
    27252723    } 
    2726      
     2724 
    27272725    pj_mutex_lock(stream->jb_mutex); 
    2728      
     2726 
    27292727    if (stream->tx_dtmf_count+digit_char->slen >= 
    27302728        (long)PJ_ARRAY_SIZE(stream->tx_dtmf_buf)) 
     
    27352733 
    27362734        /* convert ASCII digits into payload type first, to make sure 
    2737          * that all digits are valid.  
     2735         * that all digits are valid. 
    27382736         */ 
    27392737        for (i=0; i<digit_char->slen; ++i) { 
     
    27442742            { 
    27452743                pt = dig - '0'; 
    2746             }  
     2744            } 
    27472745            else if (dig >= 'a' && dig <= 'd') 
    27482746            { 
     
    28302828 */ 
    28312829PJ_DEF(pj_status_t) pjmedia_stream_set_dtmf_callback(pjmedia_stream *stream, 
    2832                                  void (*cb)(pjmedia_stream*,  
    2833                                             void *user_data,  
    2834                                             int digit),  
     2830                                 void (*cb)(pjmedia_stream*, 
     2831                                            void *user_data, 
     2832                                            int digit), 
    28352833                                 void *user_data) 
    28362834{ 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_srtp.c

    r4723 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
    1919 */ 
    2020 
     
    4646#define MAX_KEY_LEN                 128 
    4747 
    48 /* Initial value of probation counter. When probation counter > 0,  
     48/* Initial value of probation counter. When probation counter > 0, 
    4949 * it means SRTP is in probation state, and it may restart when 
    5050 * srtp_unprotect() returns err_status_replay_* 
     
    7777 
    7878    /* cipher AES_CM, auth HMAC_SHA1, auth tag len = 10 octets */ 
    79     {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10,  
     79    {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10, 
    8080        sec_serv_conf_and_auth}, 
    8181 
     
    8484        sec_serv_conf_and_auth}, 
    8585 
    86     /*  
     86    /* 
    8787     * F8_128_HMAC_SHA1_8 not supported by libsrtp? 
    8888     * {"F8_128_HMAC_SHA1_8", NULL_CIPHER, 0, NULL_AUTH, 0, 0, 0, sec_serv_none} 
     
    125125                                   void *pkt, 
    126126                                   pj_ssize_t size); 
    127          
     127 
    128128    /* Transport information */ 
    129129    pjmedia_transport   *member_tp; /**< Underlying transport.       */ 
     
    131131    /* SRTP usage policy of peer. This field is updated when media is starting. 
    132132     * This is useful when SRTP is in optional mode and peer is using mandatory 
    133      * mode, so when local is about to reinvite/update, it should offer  
     133     * mode, so when local is about to reinvite/update, it should offer 
    134134     * RTP/SAVP instead of offering RTP/AVP. 
    135135     */ 
    136136    pjmedia_srtp_use     peer_use; 
    137137 
    138     /* When probation counter > 0, it means SRTP is in probation state,  
     138    /* When probation counter > 0, it means SRTP is in probation state, 
    139139     * and it may restart when srtp_unprotect() returns err_status_replay_* 
    140140     */ 
     
    206206 
    207207 
    208 static pjmedia_transport_op transport_srtp_op =  
     208static pjmedia_transport_op transport_srtp_op = 
    209209{ 
    210210    &transport_get_info, 
     
    239239        "couldn't deallocate properly",     /* err_status_dealloc_fail  = 4  */ 
    240240        "couldn't initialize",              /* err_status_init_fail     = 5  */ 
    241         "can't process as much data as requested",  
     241        "can't process as much data as requested", 
    242242                                            /* err_status_terminus      = 6  */ 
    243243        "authentication failure",           /* err_status_auth_fail     = 7  */ 
    244244        "cipher failure",                   /* err_status_cipher_fail   = 8  */ 
    245245        "replay check failed (bad index)",  /* err_status_replay_fail   = 9  */ 
    246         "replay check failed (index too old)",  
     246        "replay check failed (index too old)", 
    247247                                            /* err_status_replay_old    = 10 */ 
    248248        "algorithm failed test routine",    /* err_status_algo_fail     = 11 */ 
    249249        "unsupported operation",            /* err_status_no_such_op    = 12 */ 
    250250        "no appropriate context found",     /* err_status_no_ctx        = 13 */ 
    251         "unable to perform desired validation",  
     251        "unable to perform desired validation", 
    252252                                            /* err_status_cant_check    = 14 */ 
    253253        "can't use key any more",           /* err_status_key_expired   = 15 */ 
     
    286286 
    287287        err = srtp_init(); 
    288         if (err != err_status_ok) {  
    289             PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s",  
     288        if (err != err_status_ok) { 
     289            PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s", 
    290290                       get_libsrtp_errstr(err))); 
    291291            return PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
     
    294294        if (pjmedia_endpt_atexit(endpt, pjmedia_srtp_deinit_lib) != PJ_SUCCESS) 
    295295        { 
    296             /* There will be memory leak when it fails to schedule libsrtp  
     296            /* There will be memory leak when it fails to schedule libsrtp 
    297297             * deinitialization, however the memory leak could be harmless, 
    298              * since in modern OS's memory used by an application is released  
     298             * since in modern OS's memory used by an application is released 
    299299             * when the application terminates. 
    300300             */ 
     
    307307    PJ_UNUSED_ARG(endpt); 
    308308#endif 
    309      
     309 
    310310    return PJ_SUCCESS; 
    311311} 
     
    338338#endif 
    339339    if (err != err_status_ok) { 
    340         PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s",  
     340        PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s", 
    341341                   get_libsrtp_errstr(err))); 
    342342    } 
     
    350350    int i; 
    351351    int cs_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]); 
    352      
     352 
    353353    /* treat unspecified crypto_name as crypto 'NULL' */ 
    354354    if (crypto_name->slen == 0) 
     
    421421 
    422422    /* Check crypto availability */ 
    423     if (opt && opt->crypto_count == 0 &&  
     423    if (opt && opt->crypto_count == 0 && 
    424424        opt->use == PJMEDIA_SRTP_MANDATORY) 
    425425        return PJMEDIA_SRTP_ESDPREQCRYPTO; 
     
    435435 
    436436            /* check key length */ 
    437             if (opt->crypto[i].key.slen &&  
    438                 opt->crypto[i].key.slen <  
     437            if (opt->crypto[i].key.slen && 
     438                opt->crypto[i].key.slen < 
    439439                (pj_ssize_t)crypto_suites[cs_idx].cipher_key_len) 
    440440                return PJMEDIA_SRTP_EINKEYLEN; 
     
    506506 */ 
    507507PJ_DEF(pj_status_t) pjmedia_transport_srtp_start( 
    508                            pjmedia_transport *tp,  
     508                           pjmedia_transport *tp, 
    509509                           const pjmedia_srtp_crypto *tx, 
    510510                           const pjmedia_srtp_crypto *rx) 
     
    518518    int              cr_rx_idx = 0; 
    519519    int              au_rx_idx = 0; 
    520     int              crypto_suites_cnt; 
    521520    pj_status_t      status = PJ_SUCCESS; 
    522521 
     
    528527        pjmedia_transport_srtp_stop(tp); 
    529528    } 
    530  
    531     crypto_suites_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]); 
    532529 
    533530    /* Get encryption and authentication method */ 
     
    545542 
    546543    /* Check whether the crypto-suite requested is supported */ 
    547     if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 ||  
     544    if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 || 
    548545        au_rx_idx == -1) 
    549546    { 
     
    648645        else 
    649646            b64[b64_len] = '\0'; 
    650          
     647 
    651648        PJ_LOG(5, (srtp->pool->obj_name, "TX: %s key=%s", 
    652649                   srtp->tx_policy.name.ptr, b64)); 
     
    700697    err = srtp_dealloc(p_srtp->srtp_rx_ctx); 
    701698    if (err != err_status_ok) { 
    702         PJ_LOG(4, (p_srtp->pool->obj_name,  
     699        PJ_LOG(4, (p_srtp->pool->obj_name, 
    703700                   "Failed to dealloc RX SRTP context: %s", 
    704701                   get_libsrtp_errstr(err))); 
     
    706703    err = srtp_dealloc(p_srtp->srtp_tx_ctx); 
    707704    if (err != err_status_ok) { 
    708         PJ_LOG(4, (p_srtp->pool->obj_name,  
     705        PJ_LOG(4, (p_srtp->pool->obj_name, 
    709706                   "Failed to dealloc TX SRTP context: %s", 
    710707                   get_libsrtp_errstr(err))); 
     
    753750    info->spc_info[spc_info_idx].type = PJMEDIA_TRANSPORT_TYPE_SRTP; 
    754751    info->spc_info[spc_info_idx].cbsize = sizeof(srtp_info); 
    755     pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info,  
     752    pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info, 
    756753              sizeof(srtp_info)); 
    757754 
     
    782779 
    783780    /* Attach itself to transport */ 
    784     status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr,  
     781    status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr, 
    785782                                      rem_rtcp, addr_len, &srtp_rtp_cb, 
    786783                                      &srtp_rtcp_cb); 
     
    842839 
    843840    if (err == err_status_ok) { 
    844         status = pjmedia_transport_send_rtp(srtp->member_tp,  
     841        status = pjmedia_transport_send_rtp(srtp->member_tp, 
    845842                                            srtp->rtp_tx_buffer, len); 
    846843    } else { 
    847844        status = PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
    848845    } 
    849      
     846 
    850847    return status; 
    851848} 
     
    870867 
    871868    if (srtp->bypass_srtp) { 
    872         return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len,  
     869        return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len, 
    873870                                            pkt, size); 
    874871    } 
     
    903900{ 
    904901    transport_srtp *srtp = (transport_srtp *) tp; 
    905      
     902 
    906903    PJ_ASSERT_RETURN(tp, PJ_EINVAL); 
    907904 
     
    965962    } 
    966963    err = srtp_unprotect(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    967     if (srtp->probation_cnt > 0 &&  
    968         (err == err_status_replay_old || err == err_status_replay_fail))  
     964    if (srtp->probation_cnt > 0 && 
     965        (err == err_status_replay_old || err == err_status_replay_fail)) 
    969966    { 
    970967        /* Handle such condition that stream is updated (RTP seq is reinited 
    971          * & SRTP is restarted), but some old packets are still coming  
     968         * & SRTP is restarted), but some old packets are still coming 
    972969         * so SRTP is learning wrong RTP seq. While the newly inited RTP seq 
    973          * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect()  
     970         * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect() 
    974971         * will return err_status_replay_*. Restarting SRTP can resolve this. 
    975972         */ 
     
    982979                                              &tx, &rx); 
    983980        if (status != PJ_SUCCESS) { 
    984             PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s",  
     981            PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s", 
    985982                      get_libsrtp_errstr(err))); 
    986983        } else if (!srtp->bypass_srtp) { 
     
    990987 
    991988    if (err != err_status_ok) { 
    992         PJ_LOG(5,(srtp->pool->obj_name,  
    993                   "Failed to unprotect SRTP, pkt size=%d, err=%s",  
     989        PJ_LOG(5,(srtp->pool->obj_name, 
     990                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
    994991                  size, get_libsrtp_errstr(err))); 
    995992    } else { 
     
    10361033    err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len); 
    10371034    if (err != err_status_ok) { 
    1038         PJ_LOG(5,(srtp->pool->obj_name,  
     1035        PJ_LOG(5,(srtp->pool->obj_name, 
    10391036                  "Failed to unprotect SRTCP, pkt size=%d, err=%s", 
    10401037                  size, get_libsrtp_errstr(err))); 
     
    10561053 */ 
    10571054static pj_status_t generate_crypto_attr_value(pj_pool_t *pool, 
    1058                                               char *buffer, int *buffer_len,  
     1055                                              char *buffer, int *buffer_len, 
    10591056                                              pjmedia_srtp_crypto *crypto, 
    10601057                                              int tag) 
     
    10881085            key_ok = PJ_TRUE; 
    10891086 
    1090             err = crypto_get_random((unsigned char*)key,  
     1087            err = crypto_get_random((unsigned char*)key, 
    10911088                                     crypto_suites[cs_idx].cipher_key_len); 
    10921089            if (err != err_status_ok) { 
     
    11001097        } while (!key_ok); 
    11011098        crypto->key.ptr = (char*) 
    1102                           pj_pool_zalloc(pool,  
     1099                          pj_pool_zalloc(pool, 
    11031100                                         crypto_suites[cs_idx].cipher_key_len); 
    11041101        pj_memcpy(crypto->key.ptr, key, crypto_suites[cs_idx].cipher_key_len); 
     
    11181115 
    11191116    b64_key[b64_key_len] = '\0'; 
    1120      
     1117 
    11211118    PJ_ASSERT_RETURN(*buffer_len >= (crypto->name.slen + \ 
    11221119                     b64_key_len + 16), PJ_ETOOSMALL); 
     
    11241121    /* Print the crypto attribute value. */ 
    11251122    print_len = pj_ansi_snprintf(buffer, *buffer_len, "%d %s inline:%s", 
    1126                                    tag,  
     1123                                   tag, 
    11271124                                   crypto_suites[cs_idx].name, 
    11281125                                   b64_key); 
     
    12061203    crypto->key.ptr = (char*) pj_pool_zalloc(pool, MAX_KEY_LEN); 
    12071204    itmp = MAX_KEY_LEN; 
    1208     status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr,  
     1205    status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr, 
    12091206                              &itmp); 
    12101207    if (status != PJ_SUCCESS) { 
     
    12271224 
    12281225    PJ_ASSERT_RETURN(tp, PJ_EINVAL); 
    1229      
     1226 
    12301227    pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg)); 
    12311228    pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg)); 
     
    12751272 
    12761273PROPAGATE_MEDIA_CREATE: 
    1277     return pjmedia_transport_media_create(srtp->member_tp, sdp_pool,  
     1274    return pjmedia_transport_media_create(srtp->member_tp, sdp_pool, 
    12781275                                          member_tp_option, sdp_remote, 
    12791276                                          media_index); 
     
    12971294 
    12981295    PJ_ASSERT_RETURN(tp && sdp_pool && sdp_local, PJ_EINVAL); 
    1299      
     1296 
    13001297    pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg)); 
    13011298    pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg)); 
     
    13071304 
    13081305    /* Bypass if media transport is not RTP/AVP or RTP/SAVP */ 
    1309     if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 &&  
     1306    if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 && 
    13101307        pj_stricmp(&m_loc->desc.transport, &ID_RTP_SAVP) != 0) 
    13111308        goto BYPASS_SRTP; 
     
    13181315     */ 
    13191316    /* 
    1320     if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) ||  
     1317    if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) || 
    13211318        (m_rem && pjmedia_sdp_media_find_attr(m_rem, &ID_INACTIVE, NULL))) 
    13221319        goto BYPASS_SRTP; 
    13231320    */ 
    13241321 
    1325     /* Check remote media transport & set local media transport  
     1322    /* Check remote media transport & set local media transport 
    13261323     * based on SRTP usage option. 
    13271324     */ 
     
    13331330                goto BYPASS_SRTP; 
    13341331            case PJMEDIA_SRTP_OPTIONAL: 
    1335                 m_loc->desc.transport =  
     1332                m_loc->desc.transport = 
    13361333                                (srtp->peer_use == PJMEDIA_SRTP_MANDATORY)? 
    13371334                                ID_RTP_SAVP : ID_RTP_AVP; 
     
    13561353                if (buffer_len) { 
    13571354                    pj_strset(&attr_value, buffer, buffer_len); 
    1358                     attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr,  
     1355                    attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr, 
    13591356                                                   &attr_value); 
    13601357                    m_loc->attr[m_loc->attr_count++] = attr; 
     
    14011398                has_crypto_attr = PJ_TRUE; 
    14021399 
    1403                 status = parse_attr_crypto(srtp->pool, m_rem->attr[i],  
     1400                status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
    14041401                                           &tmp_rx_crypto, &tags[cr_attr_count]); 
    14051402                if (status != PJ_SUCCESS) 
    14061403                    return status; 
    1407           
     1404 
    14081405                /* Check duplicated tag */ 
    14091406                for (j=0; j<cr_attr_count; ++j) { 
     
    14171414                    /* lets see if the crypto-suite offered is supported */ 
    14181415                    for (j=0; j<srtp->setting.crypto_count; ++j) 
    1419                         if (pj_stricmp(&tmp_rx_crypto.name,  
     1416                        if (pj_stricmp(&tmp_rx_crypto.name, 
    14201417                                       &srtp->setting.crypto[j].name) == 0) 
    14211418                        { 
     
    14341431                            //          hex_test_key, 
    14351432                            //          strlen(hex_test_key)); 
    1436                             //pj_strset(test_key, raw_test_key,  
     1433                            //pj_strset(test_key, raw_test_key, 
    14371434                            //    crypto_suites[cs_idx].cipher_key_len); 
    14381435                            /* EO Force to use test key */ 
    14391436 
    1440                             if (tmp_rx_crypto.key.slen !=  
     1437                            if (tmp_rx_crypto.key.slen != 
    14411438                                (int)crypto_suites[cs_idx].cipher_key_len) 
    14421439                                return PJMEDIA_SRTP_EINKEYLEN; 
     
    14591456                case PJMEDIA_SRTP_OPTIONAL: 
    14601457                    /* bypass SRTP when no crypto-attr and remote uses RTP/AVP */ 
    1461                     if (!has_crypto_attr &&  
     1458                    if (!has_crypto_attr && 
    14621459                        pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0) 
    14631460                        goto BYPASS_SRTP; 
    14641461                    /* bypass SRTP when nothing match and remote uses RTP/AVP */ 
    1465                     else if (matched_idx == -1 &&  
     1462                    else if (matched_idx == -1 && 
    14661463                        pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0) 
    14671464                        goto BYPASS_SRTP; 
     
    14851482            } 
    14861483 
    1487             /* we have to generate crypto answer,  
     1484            /* we have to generate crypto answer, 
    14881485             * with srtp->tx_policy_neg matched the offer 
    14891486             * and rem_tag contains matched offer tag. 
     
    14971494 
    14981495            srtp->tx_policy_neg = srtp->setting.crypto[matched_idx]; 
    1499              
     1496 
    15001497            /* If buffer_len==0, just skip the crypto attribute. */ 
    15011498            if (buffer_len) { 
    15021499                pj_strset(&attr_value, buffer, buffer_len); 
    1503                 attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr,  
     1500                attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr, 
    15041501                                               &attr_value); 
    15051502                m_loc->attr[m_loc->attr_count++] = attr; 
     
    15081505            /* At this point, we get valid rx_policy_neg & tx_policy_neg. */ 
    15091506        } 
    1510              
     1507 
    15111508    } 
    15121509    goto PROPAGATE_MEDIA_CREATE; 
     
    15191516 
    15201517PROPAGATE_MEDIA_CREATE: 
    1521     return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool,  
     1518    return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool, 
    15221519                                        sdp_local, sdp_remote, media_index); 
    15231520} 
     
    15481545    /* For answerer side, this function will just have to start SRTP */ 
    15491546 
    1550     /* Check remote media transport & set local media transport  
     1547    /* Check remote media transport & set local media transport 
    15511548     * based on SRTP usage option. 
    15521549     */ 
     
    15611558            // Regardless the answer's transport type (RTP/AVP or RTP/SAVP), 
    15621559            // the answer must be processed through in optional mode. 
    1563             // Please note that at this point transport type is ensured to be  
     1560            // Please note that at this point transport type is ensured to be 
    15641561            // RTP/AVP or RTP/SAVP, see transport_media_create() 
    15651562            //if (pj_stricmp(&m_rem->desc.transport, &m_loc->desc.transport)) { 
     
    15741571        } 
    15751572    } 
    1576      
     1573 
    15771574    if (srtp->offerer_side) { 
    15781575        /* find supported crypto-suite, get the tag, and assign policy_local */ 
     
    15931590            has_crypto_attr = PJ_TRUE; 
    15941591 
    1595             status = parse_attr_crypto(srtp->pool, m_rem->attr[i],  
     1592            status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
    15961593                                       &tmp_tx_crypto, &rem_tag); 
    15971594            if (status != PJ_SUCCESS) 
     
    16061603 
    16071604            /* match the crypto name */ 
    1608             if (pj_stricmp(&tmp_tx_crypto.name,  
     1605            if (pj_stricmp(&tmp_tx_crypto.name, 
    16091606                &srtp->setting.crypto[rem_tag-1].name) != 0) 
    16101607            { 
     
    16341631 
    16351632    /* Make sure we have the SRTP policies */ 
    1636     if (srtp_crypto_empty(&srtp->tx_policy_neg) ||  
     1633    if (srtp_crypto_empty(&srtp->tx_policy_neg) || 
    16371634        srtp_crypto_empty(&srtp->rx_policy_neg)) 
    16381635    { 
     
    16711668 
    16721669PROPAGATE_MEDIA_START: 
    1673     return pjmedia_transport_media_start(srtp->member_tp, pool,  
     1670    return pjmedia_transport_media_start(srtp->member_tp, pool, 
    16741671                                         sdp_local, sdp_remote, 
    16751672                                         media_index); 
     
    16851682    status = pjmedia_transport_media_stop(srtp->member_tp); 
    16861683    if (status != PJ_SUCCESS) 
    1687         PJ_LOG(4, (srtp->pool->obj_name,  
     1684        PJ_LOG(4, (srtp->pool->obj_name, 
    16881685                   "SRTP failed stop underlying media transport.")); 
    16891686 
     
    17201717    else 
    17211718        err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, pkt, pkt_len); 
    1722      
     1719 
    17231720    if (err != err_status_ok) { 
    1724         PJ_LOG(5,(srtp->pool->obj_name,  
    1725                   "Failed to unprotect SRTP, pkt size=%d, err=%s",  
     1721        PJ_LOG(5,(srtp->pool->obj_name, 
     1722                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
    17261723                  *pkt_len, get_libsrtp_errstr(err))); 
    17271724    } 
  • pjproject/trunk/pjmedia/src/test/jbuf_test.c

    r3841 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include <stdio.h> 
     
    4848} test_cond_t; 
    4949 
    50 static pj_bool_t parse_test_headers(char *line, test_param_t *param,  
     50static pj_bool_t parse_test_headers(char *line, test_param_t *param, 
    5151                               test_cond_t *cond) 
    5252{ 
     
    5757        char mode_st[16]; 
    5858 
    59         sscanf(p+1, "%s %u %u %u", mode_st, &param->init_prefetch,  
     59        sscanf(p+1, "%s %u %u %u", mode_st, &param->init_prefetch, 
    6060               &param->min_prefetch, &param->max_prefetch); 
    6161        param->adaptive = (pj_ansi_stricmp(mode_st, "adaptive") == 0); 
     
    103103} 
    104104 
    105 static pj_bool_t process_test_data(char data, pjmedia_jbuf *jb,  
     105static pj_bool_t process_test_data(char data, pjmedia_jbuf *jb, 
    106106                                   pj_uint16_t *seq, pj_uint16_t *last_seq) 
    107107{ 
     
    156156 
    157157        pjmedia_jbuf_get_state(jb, &state); 
    158         printf("seq=%d\t%c\tsize=%d\tprefetch=%d\n",  
     158        printf("seq=%d\t%c\tsize=%d\tprefetch=%d\n", 
    159159               *last_seq, toupper(data), state.size, state.prefetch); 
    160160    } 
     161#else 
     162    PJ_UNUSED_ARG(print_state); /* Warning about variable set but unused */ 
    161163#endif 
    162164 
     
    171173    int rc = 0; 
    172174    const char* input_filename = "Jbtest.dat"; 
    173     const char* input_search_path[] = {  
     175    const char* input_search_path[] = { 
    174176        "../build", 
    175177        "pjmedia/build", 
     
    192194        } 
    193195    } 
    194      
     196 
    195197    /* Failed to open test data file. */ 
    196198    if (input == NULL) { 
     
    245247 
    246248        if (param.adaptive) { 
    247             pjmedia_jbuf_set_adaptive(jb,  
    248                                       param.init_prefetch,  
     249            pjmedia_jbuf_set_adaptive(jb, 
     250                                      param.init_prefetch, 
    249251                                      param.min_prefetch, 
    250252                                      param.max_prefetch); 
     
    255257#ifdef REPORT 
    256258        pjmedia_jbuf_get_state(jb, &state); 
    257         printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n",  
    258                state.size, state.prefetch, state.min_prefetch,  
     259        printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n", 
     260               state.size, state.prefetch, state.min_prefetch, 
    259261               state.max_prefetch); 
    260262#endif 
     
    264266        while (1) { 
    265267            char c; 
    266              
     268 
    267269            /* Get next line of test data */ 
    268270            if (!p || *p == 0) { 
     
    302304        printf("  size=%d prefetch=%d\n", state.size, state.prefetch); 
    303305        printf("  delay (min/max/avg/dev)=%d/%d/%d/%d ms\n", 
    304                state.min_delay, state.max_delay, state.avg_delay,  
     306               state.min_delay, state.max_delay, state.avg_delay, 
    305307               state.dev_delay); 
    306         printf("  lost=%d discard=%d empty=%d burst(avg)=%d\n",  
     308        printf("  lost=%d discard=%d empty=%d burst(avg)=%d\n", 
    307309               state.lost, state.discard, state.empty, state.avg_burst); 
    308310 
    309311        /* Evaluate test session */ 
    310312        if (cond.burst >= 0 && (int)state.avg_burst > cond.burst) { 
    311             printf("! 'Burst' should be %d, it is %d\n",  
     313            printf("! 'Burst' should be %d, it is %d\n", 
    312314                   cond.burst, state.avg_burst); 
    313315            rc |= 1; 
    314316        } 
    315317        if (cond.delay >= 0 && (int)state.avg_delay/JB_PTIME > cond.delay) { 
    316             printf("! 'Delay' should be %d, it is %d\n",  
     318            printf("! 'Delay' should be %d, it is %d\n", 
    317319                   cond.delay, state.avg_delay/JB_PTIME); 
    318320            rc |= 2; 
    319321        } 
    320322        if (cond.delay_min >= 0 && (int)state.min_delay/JB_PTIME > cond.delay_min) { 
    321             printf("! 'Minimum delay' should be %d, it is %d\n",  
     323            printf("! 'Minimum delay' should be %d, it is %d\n", 
    322324                   cond.delay_min, state.min_delay/JB_PTIME); 
    323325            rc |= 32; 
     
    329331        } 
    330332        if (cond.empty >= 0 && (int)state.empty > cond.empty) { 
    331             printf("! 'Empty' should be %d, it is %d\n",  
     333            printf("! 'Empty' should be %d, it is %d\n", 
    332334                   cond.empty, state.empty); 
    333335            rc |= 8; 
    334336        } 
    335337        if (cond.lost >= 0 && (int)state.lost > cond.lost) { 
    336             printf("! 'Lost' should be %d, it is %d\n",  
     338            printf("! 'Lost' should be %d, it is %d\n", 
    337339                   cond.lost, state.lost); 
    338340            rc |= 16; 
  • pjproject/trunk/pjnath/src/pjnath-test/ice_test.c

    r4412 r4728  
    11/* $Id$ */ 
    2 /*  
     2/* 
    33 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com) 
    44 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org> 
     
    1616 * You should have received a copy of the GNU General Public License 
    1717 * along with this program; if not, write to the Free Software 
    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  
     18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1919 */ 
    2020#include "test.h" 
     
    113113 
    114114static void ice_on_rx_data(pj_ice_strans *ice_st, 
    115                            unsigned comp_id,  
     115                           unsigned comp_id, 
    116116                           void *pkt, pj_size_t size, 
    117117                           const pj_sockaddr_t *src_addr, 
    118118                           unsigned src_addr_len); 
    119 static void ice_on_ice_complete(pj_ice_strans *ice_st,  
     119static void ice_on_ice_complete(pj_ice_strans *ice_st, 
    120120                                pj_ice_strans_op op, 
    121121                                pj_status_t status); 
     
    202202    return PJ_SUCCESS; 
    203203} 
    204                               
     204 
    205205/* Create test session */ 
    206206static int create_sess(pj_stun_config *stun_cfg, 
     
    239239        return -10; 
    240240    } 
    241     sess->server->turn_respond_allocate =  
     241    sess->server->turn_respond_allocate = 
    242242        sess->server->turn_respond_refresh = PJ_TRUE; 
    243243 
     
    319319 
    320320static void ice_on_rx_data(pj_ice_strans *ice_st, 
    321                            unsigned comp_id,  
     321                           unsigned comp_id, 
    322322                           void *pkt, pj_size_t size, 
    323323                           const pj_sockaddr_t *src_addr, 
     
    336336 
    337337 
    338 static void ice_on_ice_complete(pj_ice_strans *ice_st,  
     338static void ice_on_ice_complete(pj_ice_strans *ice_st, 
    339339                                pj_ice_strans_op op, 
    340340                                pj_status_t status) 
     
    437437    for (; i<max_cnt; ++i) { 
    438438        if (ept1->cfg.comp_cnt>i && 
    439             pj_ice_strans_get_valid_pair(ept1->ice, i+1) != NULL)  
     439            pj_ice_strans_get_valid_pair(ept1->ice, i+1) != NULL) 
    440440        { 
    441441            PJ_LOG(3,(THIS_FILE, INDENT "err: ice1 shouldn't have valid pair " 
     
    444444        } 
    445445        if (ept2->cfg.comp_cnt>i && 
    446             pj_ice_strans_get_valid_pair(ept2->ice, i+1) != NULL)  
     446            pj_ice_strans_get_valid_pair(ept2->ice, i+1) != NULL) 
    447447        { 
    448448            PJ_LOG(3,(THIS_FILE, INDENT "err: ice2 shouldn't have valid pair " 
     
    464464                                    pj_gettimeofday(&t); \ 
    465465                                    if (expr) { \ 
    466                                         rc = PJ_SUCCESS; \ 
     466                &