Changeset 4728 for pjproject

Timestamp:

Feb 4, 2014 10:13:56 AM (11 years ago)

Author:

bennylp

Message:

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

Location:

pjproject/trunk

Files:

• pjlib-util/src/pjlib-util/cli_console.c (modified) (25 diffs)
• pjlib-util/src/pjlib-util/cli_telnet.c (modified) (95 diffs)
• pjlib/src/pj/os_core_unix.c (modified) (40 diffs)
• pjlib/src/pjlib-test/test.c (modified) (10 diffs)
• pjlib/src/pjlib-test/thread.c (modified) (15 diffs)
• pjmedia/src/pjmedia-audiodev/bb10_dev.c (modified) (6 diffs)
• pjmedia/src/pjmedia/echo_suppress.c (modified) (24 diffs)
• pjmedia/src/pjmedia/jbuf.c (modified) (54 diffs)
• pjmedia/src/pjmedia/stream.c (modified) (91 diffs)
• pjmedia/src/pjmedia/transport_srtp.c (modified) (62 diffs)
• pjmedia/src/test/jbuf_test.c (modified) (13 diffs)
• pjnath/src/pjnath-test/ice_test.c (modified) (37 diffs)
• pjnath/src/pjnath-test/test.c (modified) (7 diffs)
• pjnath/src/pjnath/ice_strans.c (modified) (59 diffs)
• pjnath/src/pjturn-srv/allocation.c (modified) (56 diffs)
• pjnath/src/pjturn-srv/server.c (modified) (30 diffs)
• pjsip-apps/src/pjsystest/systest.c (modified) (37 diffs)
• pjsip/src/pjsip/sip_auth_client.c (modified) (31 diffs)
• pjsip/src/pjsip/sip_dialog.c (modified) (69 diffs)
• pjsip/src/pjsua-lib/pjsua_call.c (modified) (154 diffs)
• pjsip/src/test/tsx_uas_test.c (modified) (54 diffs)
• pjsip/src/test/uri_test.c (modified) (19 diffs)
• third_party/ilbc/LPCencode.c (modified) (2 diffs)
• third_party/ilbc/helpfun.c (modified) (2 diffs)
• third_party/ilbc/iLBC_decode.c (modified) (2 diffs)
• third_party/resample/src/resamplesubs.c (modified) (19 diffs)

pjproject/trunk/pjlib-util/src/pjlib-util/cli_console.c

@@ -46 +46 @@
     pj_thread_t        *input_thread;
     pj_bool_t           thread_quit;
-    pj_sem_t           *thread_sem;   
-    pj_cli_console_cfg  cfg;    
+    pj_sem_t           *thread_sem;
+    pj_cli_console_cfg  cfg;
 
     struct async_input_t
-    {        
+    {
         char       *buf;
-        unsigned    maxlen;     
+        unsigned    maxlen;
         pj_sem_t   *sem;
     } input;
@@ -127 +127 @@
     if (!pool)
         return PJ_ENOMEM;
-        
+
     sess = PJ_POOL_ZALLOC_T(pool, pj_cli_sess);
     fe = PJ_POOL_ZALLOC_T(pool, struct cli_console_fe);
@@ -136 +136 @@
     }
     sess->fe = &fe->base;
-    sess->log_level = param->log_level;    
+    sess->log_level = param->log_level;
     sess->op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_sess_op);
     fe->base.op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_front_end_op);
@@ -155 +155 @@
 
     pj_cli_register_front_end(cli, &fe->base);
-    if (param->prompt_str.slen == 0) {  
+    if (param->prompt_str.slen == 0) {
         pj_str_t prompt_sign = pj_str(">>> ");
         fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool, prompt_sign.slen+1);
-        pj_strcpy(&fe->cfg.prompt_str, &prompt_sign);   
+        pj_strcpy(&fe->cfg.prompt_str, &prompt_sign);
     } else {
-        fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool, 
+        fe->cfg.prompt_str.ptr = pj_pool_alloc(fe->pool,
                                                param->prompt_str.slen+1);
         pj_strcpy(&fe->cfg.prompt_str, &param->prompt_str);
-    }    
-    fe->cfg.prompt_str.ptr[fe->cfg.prompt_str.slen] = 0; 
+    }
+    fe->cfg.prompt_str.ptr[fe->cfg.prompt_str.slen] = 0;
 
     if (param->quit_command.slen)
@@ -184 +184 @@
     send_data.ptr = data_str;
     send_data.slen = 0;
-    
+
     pj_strcat(&send_data, &fe->cfg.prompt_str);
     send_data.ptr[send_data.slen] = 0;
@@ -191 +191 @@
 }
 
-static void send_err_arg(pj_cli_sess *sess, 
-                         const pj_cli_exec_info *info, 
+static void send_err_arg(pj_cli_sess *sess,
+                         const pj_cli_exec_info *info,
                          const pj_str_t *msg,
                          pj_bool_t with_return)
@@ -219 +219 @@
 
     send_data.ptr[send_data.slen] = 0;
-    printf("%s", send_data.ptr);    
-}
-
-static void send_inv_arg(pj_cli_sess *sess, 
+    printf("%s", send_data.ptr);
+}
+
+static void send_inv_arg(pj_cli_sess *sess,
                          const pj_cli_exec_info *info,
                          pj_bool_t with_return)
@@ -230 +230 @@
 }
 
-static void send_too_many_arg(pj_cli_sess *sess, 
+static void send_too_many_arg(pj_cli_sess *sess,
                               const pj_cli_exec_info *info,
                               pj_bool_t with_return)
@@ -238 +238 @@
 }
 
-static void send_hint_arg(pj_str_t *send_data, 
+static void send_hint_arg(pj_str_t *send_data,
                           const pj_str_t *desc,
                           pj_ssize_t cmd_len,
@@ -257 +257 @@
 }
 
-static void send_ambi_arg(pj_cli_sess *sess, 
+static void send_ambi_arg(pj_cli_sess *sess,
                           const pj_cli_exec_info *info,
                           pj_bool_t with_return)
@@ -270 +270 @@
     pj_ssize_t max_length = 0;
     pj_ssize_t cmd_length = 0;
-    const pj_str_t *cmd_desc = 0;
     static const pj_str_t sc_type = {"sc", 2};
     static const pj_str_t choice_type = {"choice", 6};
     send_data.ptr = data;
     send_data.slen = 0;
-    
+
     if (with_return)
         pj_strcat2(&send_data, "\r\n");
@@ -284 +283 @@
         pj_strcat2(&send_data, " ");
     }
-    pj_strcat2(&send_data, "^");        
+    pj_strcat2(&send_data, "^");
     /* Get the max length of the command name */
     for (i=0;i<info->hint_cnt;++i) {
-        if ((&hint[i].type) && (hint[i].type.slen > 0)) {           
-            if (pj_stricmp(&hint[i].type, &sc_type) == 0) {             
+        if ((&hint[i].type) && (hint[i].type.slen > 0)) {
+            if (pj_stricmp(&hint[i].type, &sc_type) == 0) {
                 if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) {
                     cmd_length += (hint[i].name.slen + 3);
                 } else {
                     cmd_length = hint[i].name.slen;
-                }               
+                }
             } else {
                 cmd_length = hint[i].name.slen;
             }
-        } else {                    
+        } else {
             cmd_length = hint[i].name.slen;
         }
@@ -308 +307 @@
     cmd_length = 0;
     for (i=0;i<info->hint_cnt;++i) {
-        if ((&hint[i].type) && (hint[i].type.slen > 0)) {           
+        if ((&hint[i].type) && (hint[i].type.slen > 0)) {
             if (pj_stricmp(&hint[i].type, &sc_type) == 0) {
                 parse_state = OP_SHORTCUT;
@@ -316 +315 @@
                 parse_state = OP_TYPE;
             }
-        } else {                    
+        } else {
             parse_state = OP_NORMAL;
         }
@@ -324 +323 @@
             cmd_length = hint[i].name.slen;
         }
-    
+
         switch (parse_state) {
         case OP_CHOICE:
             pj_strcat2(&send_data, "[");
             pj_strcat(&send_data, &hint[i].name);
-            pj_strcat2(&send_data, "]");        
+            pj_strcat2(&send_data, "]");
             break;
         case OP_TYPE:
             pj_strcat2(&send_data, "<");
             pj_strcat(&send_data, &hint[i].type);
-            pj_strcat2(&send_data, ">");        
+            pj_strcat2(&send_data, ">");
             break;
         case OP_SHORTCUT:
             /* Format : "Command | sc |  description" */
-            {           
+            {
                 cmd_length += hint[i].name.slen;
                 if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) {
                     pj_strcat2(&send_data, " | ");
-                    cmd_length += 3;                
+                    cmd_length += 3;
                 } else {
                     pj_strcat2(&send_data, "\r\n  ");
                 }
-                pj_strcat(&send_data, &hint[i].name);   
+                pj_strcat(&send_data, &hint[i].name);
             }
             break;
         default:
             pj_strcat(&send_data, &hint[i].name);
-            cmd_desc = &hint[i].desc;
             break;
         }
-        
-        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) || 
+
+        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) ||
             ((i+1) >= info->hint_cnt) ||
-            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen))) 
+            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen)))
         {
             /* Add description info */
@@ -364 +362 @@
             cmd_length = 0;
         }
-    }  
+    }
     pj_strcat2(&send_data, "\r\n");
     pj_strcat(&send_data, &fe->cfg.prompt_str);
     send_data.ptr[send_data.slen] = 0;
-    printf("%s", send_data.ptr);    
+    printf("%s", send_data.ptr);
 }
 
@@ -375 +373 @@
     pj_status_t status;
     pj_bool_t retval = PJ_TRUE;
-    
+
     pj_pool_t *pool;
     pj_cli_cmd_val *cmd_val;
@@ -388 +386 @@
 
     cmd_val = PJ_POOL_ZALLOC_T(pool, pj_cli_cmd_val);
-    
-    status = pj_cli_sess_parse(sess, recv_buf, cmd_val, 
+
+    status = pj_cli_sess_parse(sess, recv_buf, cmd_val,
                                pool, &info);
 
     switch (status) {
     case PJ_CLI_EINVARG:
-        send_inv_arg(sess, &info, PJ_TRUE);             
+        send_inv_arg(sess, &info, PJ_TRUE);
         break;
     case PJ_CLI_ETOOMANYARGS:
@@ -403 +401 @@
         send_ambi_arg(sess, &info, PJ_TRUE);
         break;
-    case PJ_SUCCESS:    
-        if (info.hint_cnt > 0) {        
-            /* Compelete command */         
-            send_ambi_arg(sess, &info, PJ_TRUE);                        
+    case PJ_SUCCESS:
+        if (info.hint_cnt > 0) {
+            /* Compelete command */
+            send_ambi_arg(sess, &info, PJ_TRUE);
         } else {
             retval = PJ_FALSE;
-        }       
-        break;
-    }
-
-    pj_pool_release(pool);      
-    return retval; 
+        }
+        break;
+    }
+
+    pj_pool_release(pool);
+    return retval;
 }
 
@@ -421 +419 @@
     pj_status_t status;
     pj_bool_t retval = PJ_TRUE;
-    
-    pj_pool_t *pool;    
+
+    pj_pool_t *pool;
     pj_cli_exec_info info;
     pj_cli_t *cli = sess->fe->cli;
     struct cli_console_fe *fe = (struct cli_console_fe *)sess->fe;
     char *recv_buf = fe->input.buf;
-        
+
     printf("\r\n");
 
     pool = pj_pool_create(pj_cli_get_param(cli)->pf, "handle_exec",
                           PJ_CLI_CONSOLE_POOL_SIZE, PJ_CLI_CONSOLE_POOL_INC,
-                          NULL);    
-    
-    status = pj_cli_sess_exec(sess, recv_buf, 
+                          NULL);
+
+    status = pj_cli_sess_exec(sess, recv_buf,
                               pool, &info);
 
     switch (status) {
     case PJ_CLI_EINVARG:
-        send_inv_arg(sess, &info, PJ_FALSE);    
+        send_inv_arg(sess, &info, PJ_FALSE);
         break;
     case PJ_CLI_ETOOMANYARGS:
@@ -452 +450 @@
         break;
     case PJ_SUCCESS:
-        send_prompt_str(sess);  
-        break;
-    }    
-
-    pj_pool_release(pool);      
-    return retval; 
+        send_prompt_str(sess);
+        break;
+    }
+
+    pj_pool_release(pool);
+    return retval;
 }
 
 static int readline_thread(void * p)
-{    
+{
     struct cli_console_fe * fe = (struct cli_console_fe *)p;
 
@@ -473 +471 @@
 
         if (fgets(recv_buf, fe->input.maxlen, stdin) == NULL) {
-            /* 
+            /*
              * Be friendly to users who redirect commands into
              * program, when file ends, resume with kbd.
@@ -488 +486 @@
                 puts("Cannot switch back to console from file redirection");
                 if (fe->cfg.quit_command.slen) {
-                    pj_memcpy(recv_buf, fe->cfg.quit_command.ptr, 
+                    pj_memcpy(recv_buf, fe->cfg.quit_command.ptr,
                               fe->input.maxlen);
                 }
-                recv_buf[fe->cfg.quit_command.slen] = '\0';             
+                recv_buf[fe->cfg.quit_command.slen] = '\0';
             } else {
                 puts("Switched back to console from file redirection");
@@ -506 +504 @@
             break;
         }
-        input_len = pj_ansi_strlen(fe->input.buf);      
+        input_len = pj_ansi_strlen(fe->input.buf);
         if ((input_len > 1) && (fe->input.buf[input_len-2] == '?')) {
             fe->input.buf[input_len-1] = 0;
@@ -516 +514 @@
         }
 
-        pj_sem_post(fe->input.sem);        
+        pj_sem_post(fe->input.sem);
         pj_sem_wait(fe->thread_sem);
-    }    
+    }
 
     return 0;
 }
 
-PJ_DEF(pj_status_t) pj_cli_console_process(pj_cli_sess *sess, 
+PJ_DEF(pj_status_t) pj_cli_console_process(pj_cli_sess *sess,
                                            char *buf,
                                            unsigned maxlen)

pjproject/trunk/pjlib-util/src/pjlib-util/cli_telnet.c

@@ -37 +37 @@
     (defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0)
 
-#define EADDRINUSE WSAEADDRINUSE 
+#define EADDRINUSE WSAEADDRINUSE
 
 #endif
@@ -67 +67 @@
  * This specify the state for the telnet option negotiation.
  */
-enum cli_telnet_option_states 
-{    
+enum cli_telnet_option_states
+{
     OPT_DISABLE,                /* Option disable */
     OPT_ENABLE,                 /* Option enable */
     OPT_EXPECT_DISABLE,         /* Already send disable req, expecting resp */
     OPT_EXPECT_ENABLE,          /* Already send enable req, expecting resp */
-    OPT_EXPECT_DISABLE_REV,     /* Already send disable req, expecting resp, 
+    OPT_EXPECT_DISABLE_REV,     /* Already send disable req, expecting resp,
                                  * need to send enable req */
     OPT_EXPECT_ENABLE_REV       /* Already send enable req, expecting resp,
@@ -199 +199 @@
 };
 
-enum terminal_cmd 
+enum terminal_cmd
 {
     TC_ESC              = 27,
@@ -207 +207 @@
     TC_LEFT             = 68,
     TC_END              = 70,
-    TC_HOME             = 72,    
+    TC_HOME             = 72,
     TC_CTRL_C           = 3,
     TC_CR               = 13,
@@ -229 +229 @@
 
 /**
- * This structure contains the command line shown to the user. 
- * The telnet also needs to maintain and manage command cursor position. 
+ * This structure contains the command line shown to the user.
+ * The telnet also needs to maintain and manage command cursor position.
  * Due to that reason, the insert/delete character process from buffer will
  * consider its current cursor position.
@@ -252 +252 @@
 
 /**
- * This structure contains the command history executed by user. 
+ * This structure contains the command history executed by user.
  * Besides storing the command history, it is necessary to be able
  * to browse it.
@@ -291 +291 @@
     pj_thread_t            *worker_thread;
     pj_bool_t               is_quitting;
-    pj_mutex_t             *mutex;    
+    pj_mutex_t             *mutex;
 } cli_telnet_fe;
 
@@ -305 +305 @@
 
 /**
- * Return the number of characters between the current cursor position 
+ * Return the number of characters between the current cursor position
  * to the end of line.
  */
@@ -314 +314 @@
 
 /**
- * Insert character to the receive buffer. 
- */
-static pj_bool_t recv_buf_insert(telnet_recv_buf *recv_buf, 
-                                 unsigned char *data) 
-{    
+ * Insert character to the receive buffer.
+ */
+static pj_bool_t recv_buf_insert(telnet_recv_buf *recv_buf,
+                                 unsigned char *data)
+{
     if (recv_buf->len+1 >= PJ_CLI_MAX_CMDBUF) {
         return PJ_FALSE;
-    } else {    
+    } else {
         if (*data == '\t' || *data == '?' || *data == '\r') {
             /* Always insert to the end of line */
@@ -328 +328 @@
             /* Insert based on the current cursor pos */
             unsigned cur_pos = recv_buf->cur_pos;
-            unsigned rlen = recv_buf_right_len(recv_buf);           
-            if (rlen > 0) {                 
+            unsigned rlen = recv_buf_right_len(recv_buf);
+            if (rlen > 0) {
                 /* Shift right characters */
-                pj_memmove(&recv_buf->rbuf[cur_pos+1], 
-                           &recv_buf->rbuf[cur_pos], 
+                pj_memmove(&recv_buf->rbuf[cur_pos+1],
+                           &recv_buf->rbuf[cur_pos],
                            rlen+1);
-            } 
+            }
             recv_buf->rbuf[cur_pos] = *data;
         }
@@ -356 +356 @@
             unsigned cur_pos = recv_buf->cur_pos;
             /* Shift left characters */
-            pj_memmove(&recv_buf->rbuf[cur_pos-1], &recv_buf->rbuf[cur_pos], 
+            pj_memmove(&recv_buf->rbuf[cur_pos-1], &recv_buf->rbuf[cur_pos],
                        rlen);
         }
@@ -362 +362 @@
         --recv_buf->len;
         recv_buf->rbuf[recv_buf->len] = 0;
-    }    
+    }
     return PJ_TRUE;
 }
@@ -373 +373 @@
 
 /**
- * Insert the command to history. If the entered command is not on the list, 
- * a new entry will be created. All entered command will be moved to 
- * the first entry of the history. 
- */
-static pj_status_t insert_history(cli_telnet_sess *sess,                                 
+ * Insert the command to history. If the entered command is not on the list,
+ * a new entry will be created. All entered command will be moved to
+ * the first entry of the history.
+ */
+static pj_status_t insert_history(cli_telnet_sess *sess,
                                   char *cmd_val)
 {
@@ -393 +393 @@
     in_history = pj_list_search(sess->history, (void*)&cmd, compare_str);
     if (!in_history) {
-        if (pj_list_size(sess->history) < PJ_CLI_MAX_CMD_HISTORY) {         
+        if (pj_list_size(sess->history) < PJ_CLI_MAX_CMD_HISTORY) {
             char *data_history;
             in_history = PJ_POOL_ZALLOC_T(sess->pool, cmd_history);
             pj_list_init(in_history);
-            data_history = (char *)pj_pool_calloc(sess->pool, 
+            data_history = (char *)pj_pool_calloc(sess->pool,
                            sizeof(char), PJ_CLI_MAX_CMDBUF);
             in_history->command.ptr = data_history;
@@ -404 +404 @@
             /* Get the oldest history */
             in_history = sess->history->prev;
-        }           
+        }
     } else {
         pj_list_insert_nodes_after(in_history->prev, in_history->next);
@@ -416 +416 @@
 
 /**
- * Get the next or previous history of the shown/active history. 
+ * Get the next or previous history of the shown/active history.
  */
 static pj_str_t* get_prev_history(cli_telnet_sess *sess, pj_bool_t is_forward)
@@ -434 +434 @@
         return NULL;
     } else {
-        if (is_forward) {           
-            node = (node->next==root)?node->next->next:node->next;          
+        if (is_forward) {
+            node = (node->next==root)?node->next->next:node->next;
         } else {
-            node = (node->prev==root)?node->prev->prev:node->prev;          
+            node = (node->prev==root)?node->prev->prev:node->prev;
         }
         retval = &node->command;
@@ -451 +451 @@
  * referenced - (RFC-854).
  */
-static pj_bool_t send_telnet_cmd(cli_telnet_sess *sess, 
-                                 cli_telnet_command cmd, 
+static pj_bool_t send_telnet_cmd(cli_telnet_sess *sess,
+                                 cli_telnet_command cmd,
                                  unsigned char option)
-{       
+{
     unsigned char buf[3];
     PJ_ASSERT_RETURN(sess, PJ_FALSE);
@@ -470 +470 @@
  * For local option: send WILL.
  * For remote option: send DO.
- * This method also handle the state transition of the ENABLE 
+ * This method also handle the state transition of the ENABLE
  * negotiation process.
  */
-static pj_bool_t send_enable_option(cli_telnet_sess *sess, 
-                                    pj_bool_t is_local, 
+static pj_bool_t send_enable_option(cli_telnet_sess *sess,
+                                    pj_bool_t is_local,
                                     unsigned char option)
 {
@@ -500 +500 @@
             *state = OPT_EXPECT_ENABLE;
             break;
-        case OPT_EXPECT_DISABLE_REV:        
+        case OPT_EXPECT_DISABLE_REV:
             *state = OPT_DISABLE;
             break;
@@ -509 +509 @@
 }
 
-static pj_bool_t send_cmd_do(cli_telnet_sess *sess, 
+static pj_bool_t send_cmd_do(cli_telnet_sess *sess,
                              unsigned char option)
 {
@@ -515 +515 @@
 }
 
-static pj_bool_t send_cmd_will(cli_telnet_sess *sess, 
+static pj_bool_t send_cmd_will(cli_telnet_sess *sess,
                                unsigned char option)
 {
@@ -523 +523 @@
 /**
  * This method will handle receiving telnet's ENABLE option negotiation.
- * This method also handle the state transition of the ENABLE 
- * negotiation process. 
- */
-static pj_bool_t receive_enable_option(cli_telnet_sess *sess, 
-                                       pj_bool_t is_local, 
+ * This method also handle the state transition of the ENABLE
+ * negotiation process.
+ */
+static pj_bool_t receive_enable_option(cli_telnet_sess *sess,
+                                       pj_bool_t is_local,
                                        unsigned char option)
 {
@@ -550 +550 @@
             }
             break;
-        case OPT_EXPECT_ENABLE:     
+        case OPT_EXPECT_ENABLE:
             *state = OPT_ENABLE;
             break;
-        case OPT_EXPECT_DISABLE:            
+        case OPT_EXPECT_DISABLE:
             *state = OPT_DISABLE;
             break;
         case OPT_EXPECT_ENABLE_REV:
             *state = OPT_EXPECT_DISABLE;
-            send_telnet_cmd(sess, is_local?WONT:DONT, option);      
+            send_telnet_cmd(sess, is_local?WONT:DONT, option);
             break;
         case OPT_EXPECT_DISABLE_REV:
@@ -566 +566 @@
             return PJ_FALSE;
     }
-    return PJ_TRUE;        
+    return PJ_TRUE;
 }
 
 /**
  * This method will handle receiving telnet's DISABLE option negotiation.
- * This method also handle the state transition of the DISABLE 
- * negotiation process. 
- */
-static pj_bool_t receive_disable_option(cli_telnet_sess *sess, 
-                                        pj_bool_t is_local, 
+ * This method also handle the state transition of the DISABLE
+ * negotiation process.
+ */
+static pj_bool_t receive_disable_option(cli_telnet_sess *sess,
+                                        pj_bool_t is_local,
                                         unsigned char option)
 {
@@ -585 +585 @@
     sess_opt = &sess->telnet_option[option];
     state = is_local?(&sess_opt->local_state):(&sess_opt->peer_state);
-    
+
     switch (*state) {
         case OPT_ENABLE:
@@ -595 +595 @@
             /* Ignore if already enabled */
             break;
-        case OPT_EXPECT_ENABLE:     
+        case OPT_EXPECT_ENABLE:
         case OPT_EXPECT_DISABLE:
             *state = OPT_DISABLE;
@@ -601 +601 @@
         case OPT_EXPECT_ENABLE_REV:
             *state = OPT_DISABLE;
-            send_telnet_cmd(sess, is_local?WONT:DONT, option);      
+            send_telnet_cmd(sess, is_local?WONT:DONT, option);
             break;
         case OPT_EXPECT_DISABLE_REV:
@@ -610 +610 @@
             return PJ_FALSE;
     }
-    return PJ_TRUE;       
+    return PJ_TRUE;
 }
 
@@ -633 +633 @@
 }
 
-static void set_local_option(cli_telnet_sess *sess, 
-                             unsigned char option, 
-                             pj_bool_t enable) 
+static void set_local_option(cli_telnet_sess *sess,
+                             unsigned char option,
+                             pj_bool_t enable)
 {
     sess->telnet_option[option].local_is_enable = enable;
 }
 
-static void set_peer_option(cli_telnet_sess *sess, 
-                            unsigned char option, 
-                            pj_bool_t enable) 
+static void set_peer_option(cli_telnet_sess *sess,
+                            unsigned char option,
+                            pj_bool_t enable)
 {
     sess->telnet_option[option].peer_is_enable = enable;
 }
 
-static pj_bool_t is_local_option_state_ena(cli_telnet_sess *sess, 
+static pj_bool_t is_local_option_state_ena(cli_telnet_sess *sess,
                                            unsigned char option)
-{    
+{
     return (sess->telnet_option[option].local_state == OPT_ENABLE);
 }
 
-static void send_return_key(cli_telnet_sess *sess) 
-{    
+static void send_return_key(cli_telnet_sess *sess)
+{
     telnet_sess_send2(sess, (unsigned char*)"\r\n", 2);
 }
@@ -671 +671 @@
     send_data.ptr = data_str;
     send_data.slen = 0;
-    
+
     pj_strcat(&send_data, &fe->cfg.prompt_str);
 
@@ -681 +681 @@
  * the error position of the source command.
  */
-static void send_err_arg(cli_telnet_sess *sess, 
-                         const pj_cli_exec_info *info, 
+static void send_err_arg(cli_telnet_sess *sess,
+                         const pj_cli_exec_info *info,
                          const pj_str_t *msg,
                          pj_bool_t with_return,
@@ -715 +715 @@
 }
 
-static void send_inv_arg(cli_telnet_sess *sess, 
+static void send_inv_arg(cli_telnet_sess *sess,
                          const pj_cli_exec_info *info,
                          pj_bool_t with_return,
@@ -724 +724 @@
 }
 
-static void send_too_many_arg(cli_telnet_sess *sess, 
+static void send_too_many_arg(cli_telnet_sess *sess,
                               const pj_cli_exec_info *info,
                               pj_bool_t with_return,
@@ -733 +733 @@
 }
 
-static void send_hint_arg(cli_telnet_sess *sess, 
-                          pj_str_t *send_data, 
+static void send_hint_arg(cli_telnet_sess *sess,
+                          pj_str_t *send_data,
                           const pj_str_t *desc,
                           pj_ssize_t cmd_len,
@@ -756 +756 @@
  * is ambiguous. It will show the matching command as the hint information.
  */
-static void send_ambi_arg(cli_telnet_sess *sess, 
+static void send_ambi_arg(cli_telnet_sess *sess,
                           const pj_cli_exec_info *info,
                           pj_bool_t with_return,
@@ -770 +770 @@
     pj_ssize_t max_length = 0;
     pj_ssize_t cmd_length = 0;
-    const pj_str_t *cmd_desc = 0;
     static const pj_str_t sc_type = {"sc", 2};
     static const pj_str_t choice_type = {"choice", 6};
     send_data.ptr = data;
     send_data.slen = 0;
-    
+
     if (with_return)
         pj_strcat2(&send_data, "\r\n");
@@ -787 +786 @@
     /* Get the max length of the command name */
     for (i=0;i<info->hint_cnt;++i) {
-        if ((&hint[i].type) && (hint[i].type.slen > 0)) {           
-            if (pj_stricmp(&hint[i].type, &sc_type) == 0) {             
+        if ((&hint[i].type) && (hint[i].type.slen > 0)) {
+            if (pj_stricmp(&hint[i].type, &sc_type) == 0) {
                 if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) {
                     cmd_length += (hint[i].name.slen + 3);
                 } else {
                     cmd_length = hint[i].name.slen;
-                }               
+                }
             } else {
                 cmd_length = hint[i].name.slen;
             }
-        } else {                    
+        } else {
             cmd_length = hint[i].name.slen;
         }
@@ -805 +804 @@
         }
     }
-    
+
     cmd_length = 0;
     /* Build hint information */
-    for (i=0;i<info->hint_cnt;++i) {                    
-        if ((&hint[i].type) && (hint[i].type.slen > 0)) {           
+    for (i=0;i<info->hint_cnt;++i) {
+        if ((&hint[i].type) && (hint[i].type.slen > 0)) {
             if (pj_stricmp(&hint[i].type, &sc_type) == 0) {
                 parse_state = OP_SHORTCUT;
@@ -817 +816 @@
                 parse_state = OP_TYPE;
             }
-        } else {                    
+        } else {
             parse_state = OP_NORMAL;
         }
-        
+
         if (parse_state != OP_SHORTCUT) {
             pj_strcat2(&send_data, "\r\n  ");
             cmd_length = hint[i].name.slen;
-        }           
-        
+        }
+
         switch (parse_state) {
         case OP_CHOICE:
-            /* Format : "[Choice Value]  description" */            
+            /* Format : "[Choice Value]  description" */
             pj_strcat2(&send_data, "[");
             pj_strcat(&send_data, &hint[i].name);
-            pj_strcat2(&send_data, "]");        
+            pj_strcat2(&send_data, "]");
             break;
         case OP_TYPE:
@@ -837 +836 @@
             pj_strcat2(&send_data, "<");
             pj_strcat(&send_data, &hint[i].name);
-            pj_strcat2(&send_data, ">");        
+            pj_strcat2(&send_data, ">");
             break;
         case OP_SHORTCUT:
             /* Format : "Command | sc |  description" */
-            {           
+            {
                 cmd_length += hint[i].name.slen;
                 if ((i > 0) && (!pj_stricmp(&hint[i-1].desc, &hint[i].desc))) {
                     pj_strcat2(&send_data, " | ");
-                    cmd_length += 3;                
+                    cmd_length += 3;
                 } else {
                     pj_strcat2(&send_data, "\r\n  ");
                 }
-                pj_strcat(&send_data, &hint[i].name);   
+                pj_strcat(&send_data, &hint[i].name);
             }
             break;
@@ -855 +854 @@
             /* Command */
             pj_strcat(&send_data, &hint[i].name);
-            cmd_desc = &hint[i].desc;       
-            break;
-        }
-        
-        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) || 
+            break;
+        }
+
+        if ((parse_state == OP_TYPE) || (parse_state == OP_CHOICE) ||
             ((i+1) >= info->hint_cnt) ||
-            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen))) 
+            (pj_strncmp(&hint[i].desc, &hint[i+1].desc, hint[i].desc.slen)))
         {
             /* Add description info */
-            send_hint_arg(sess, &send_data, 
-                          &hint[i].desc, cmd_length, 
+            send_hint_arg(sess, &send_data,
+                          &hint[i].desc, cmd_length,
                           max_length);
 
             cmd_length = 0;
-        }       
-    }  
-    pj_strcat2(&send_data, "\r\n");       
+        }
+    }
+    pj_strcat2(&send_data, "\r\n");
     pj_strcat(&send_data, &fe->cfg.prompt_str);
     if (with_last_cmd)
         pj_strcat2(&send_data, (char *)sess->rcmd->rbuf);
 
-    telnet_sess_send(sess, &send_data);    
+    telnet_sess_send(sess, &send_data);
 }
 
@@ -882 +880 @@
  * This method is to send command completion of the entered command.
  */
-static void send_comp_arg(cli_telnet_sess *sess, 
+static void send_comp_arg(cli_telnet_sess *sess,
                           pj_cli_exec_info *info)
 {
@@ -893 +891 @@
     send_data.slen = 0;
 
-    pj_strcat(&send_data, &info->hint[0].name);        
+    pj_strcat(&send_data, &info->hint[0].name);
 
     telnet_sess_send(sess, &send_data);
@@ -902 +900 @@
  */
 static pj_bool_t handle_alfa_num(cli_telnet_sess *sess, unsigned char *data)
-{        
+{
     if (is_local_option_state_ena(sess, TERM_ECHO)) {
         if (recv_buf_right_len(sess->rcmd) > 0) {
-            /* Cursor is not at EOL, insert character */            
+            /* Cursor is not at EOL, insert character */
             unsigned char echo[5] = {0x1b, 0x5b, 0x31, 0x40, 0x00};
             echo[4] = *data;
@@ -914 +912 @@
         }
         return PJ_TRUE;
-    } 
+    }
     return PJ_FALSE;
 }
@@ -926 +924 @@
     if (recv_buf_backspace(sess->rcmd)) {
         if (rlen) {
-            /* 
-             * Cursor is not at the end of line, move the characters 
+            /*
+             * Cursor is not at the end of line, move the characters
              * after the cursor to left
              */
@@ -934 +932 @@
             telnet_sess_send2(sess, echo, 5);
         } else {
-            const static unsigned char echo[3] = {0x08, 0x20, 0x08};        
+            const static unsigned char echo[3] = {0x08, 0x20, 0x08};
             telnet_sess_send2(sess, echo, 3);
         }
@@ -942 +940 @@
 }
 
-/* 
- * Syntax error handler for parser. 
+/*
+ * Syntax error handler for parser.
  */
 static void on_syntax_error(pj_scanner *scanner)
@@ -958 +956 @@
     pj_scanner scanner;
     PJ_USE_EXCEPTION;
-    pj_scan_init(&scanner, cmd->ptr, cmd->slen, PJ_SCAN_AUTOSKIP_WS, 
+    pj_scan_init(&scanner, cmd->ptr, cmd->slen, PJ_SCAN_AUTOSKIP_WS,
                  &on_syntax_error);
     PJ_TRY {
@@ -966 +964 @@
     }
     PJ_CATCH_ANY {
-        pj_scan_fini(&scanner); 
+        pj_scan_fini(&scanner);
         return PJ_GET_EXCEPTION();
     }
@@ -981 +979 @@
     pj_bool_t retval = PJ_TRUE;
     unsigned len;
-    
+
     pj_pool_t *pool;
     pj_cli_cmd_val *cmd_val;
@@ -990 +988 @@
 
     cmd_val = PJ_POOL_ZALLOC_T(pool, pj_cli_cmd_val);
-    
-    status = pj_cli_sess_parse(&sess->base, (char *)&sess->rcmd->rbuf, cmd_val, 
-                               pool, &info);    
+
+    status = pj_cli_sess_parse(&sess->base, (char *)&sess->rcmd->rbuf, cmd_val,
+                               pool, &info);
 
     len = (unsigned)pj_ansi_strlen((char *)sess->rcmd->rbuf);
@@ -998 +996 @@
     switch (status) {
     case PJ_CLI_EINVARG:
-        send_inv_arg(sess, &info, PJ_TRUE, PJ_TRUE);            
+        send_inv_arg(sess, &info, PJ_TRUE, PJ_TRUE);
         break;
     case PJ_CLI_ETOOMANYARGS:
@@ -1015 +1013 @@
             telnet_sess_send2(sess, data_sent, rlen);
         }
-        if (info.hint_cnt > 0) {        
+        if (info.hint_cnt > 0) {
             /* Complete command */
             pj_str_t cmd = pj_str((char *)sess->rcmd->rbuf);
@@ -1026 +1024 @@
                 if (hint_info->slen >= last_token.slen) {
                     hint_info->slen -= last_token.slen;
-                    pj_memmove(hint_info->ptr, 
-                               &hint_info->ptr[last_token.slen], 
-                               hint_info->slen);                    
-                } 
+                    pj_memmove(hint_info->ptr,
+                               &hint_info->ptr[last_token.slen],
+                               hint_info->slen);
+                }
                 send_comp_arg(sess, &info);
 
-                pj_memcpy(&sess->rcmd->rbuf[len], info.hint[0].name.ptr, 
+                pj_memcpy(&sess->rcmd->rbuf[len], info.hint[0].name.ptr,
                           info.hint[0].name.slen);
 
                 len += (unsigned)info.hint[0].name.slen;
-                sess->rcmd->rbuf[len] = 0;                  
+                sess->rcmd->rbuf[len] = 0;
             }
         } else {
@@ -1046 +1044 @@
     sess->rcmd->cur_pos = sess->rcmd->len;
 
-    pj_pool_release(pool);      
-    return retval; 
+    pj_pool_release(pool);
+    return retval;
 }
 
@@ -1057 +1055 @@
     pj_status_t status;
     pj_bool_t retval = PJ_TRUE;
-    
-    pj_pool_t *pool;    
-    pj_cli_exec_info info;    
-    
+
+    pj_pool_t *pool;
+    pj_cli_exec_info info;
+
     send_return_key(sess);
     insert_history(sess, (char *)&sess->rcmd->rbuf);
@@ -1066 +1064 @@
     pool = pj_pool_create(sess->pool->factory, "handle_return",
                           PJ_CLI_TELNET_POOL_SIZE, PJ_CLI_TELNET_POOL_INC,
-                          NULL);    
-    
-    status = pj_cli_sess_exec(&sess->base, (char *)&sess->rcmd->rbuf, 
+                          NULL);
+
+    status = pj_cli_sess_exec(&sess->base, (char *)&sess->rcmd->rbuf,
                               pool, &info);
 
     switch (status) {
     case PJ_CLI_EINVARG:
-        send_inv_arg(sess, &info, PJ_FALSE, PJ_FALSE);  
+        send_inv_arg(sess, &info, PJ_FALSE, PJ_FALSE);
         break;
     case PJ_CLI_ETOOMANYARGS:
@@ -1088 +1086 @@
         send_prompt_str(sess);
         break;
-    }    
+    }
     if (retval) {
         sess->rcmd->rbuf[0] = 0;
@@ -1095 +1093 @@
     }
 
-    pj_pool_release(pool);      
-    return retval; 
+    pj_pool_release(pool);
+    return retval;
 }
 
@@ -1106 +1104 @@
     if (recv_buf_right_len(sess->rcmd)) {
         unsigned char *data = &sess->rcmd->rbuf[sess->rcmd->cur_pos++];
-        telnet_sess_send2(sess, data, 1);               
+        telnet_sess_send2(sess, data, 1);
         return PJ_TRUE;
     }
@@ -1116 +1114 @@
  */
 static pj_bool_t handle_left_key(cli_telnet_sess *sess)
-{    
+{
     static const unsigned char move_cursor_left = 0x08;
     if (sess->rcmd->cur_pos) {
@@ -1151 +1149 @@
             send_data.slen = sess->rcmd->cur_pos;
         }
-        
+
         if (sess->rcmd->len > (unsigned)history->slen) {
             /* Clear the command currently shown*/
@@ -1159 +1157 @@
 
             /* Move cursor position to the beginning of line */
-            pj_memset(&send_data.ptr[send_data.slen], MOVE_CURSOR_LEFT, 
+            pj_memset(&send_data.ptr[send_data.slen], MOVE_CURSOR_LEFT,
                       buf_len);
             send_data.slen += buf_len;
-        } 
+        }
         /* Send data */
         pj_strcat(&send_data, history);
@@ -1175 +1173 @@
 }
 
-static pj_status_t process_vt100_cmd(cli_telnet_sess *sess, 
+static pj_status_t process_vt100_cmd(cli_telnet_sess *sess,
                                      unsigned char *cmd)
-{    
+{
     pj_status_t status = PJ_TRUE;
     switch (*cmd) {
@@ -1225 +1223 @@
 }
 
-/* 
- * Send a message to a telnet session 
+/*
+ * Send a message to a telnet session
  */
 static pj_status_t telnet_sess_send(cli_telnet_sess *sess,
@@ -1241 +1239 @@
 
     if (sess->buf_len == 0)
-        status = pj_activesock_send(sess->asock, &sess->op_key, 
+        status = pj_activesock_send(sess->asock, &sess->op_key,
                                     str->ptr, &sz, 0);
-    /* If we cannot send now, append it at the end of the buffer 
+    /* If we cannot send now, append it at the end of the buffer
      * to be sent later.
      */
-    if (sess->buf_len > 0 || 
+    if (sess->buf_len > 0 ||
         (status != PJ_SUCCESS && status != PJ_EPENDING))
     {
@@ -1273 +1271 @@
 }
 
-/* 
- * Send a message to a telnet session with formatted text 
+/*
+ * Send a message to a telnet session with formatted text
  * (add single linefeed character with carriage return)
  */
@@ -1288 +1286 @@
     PJ_USE_EXCEPTION;
 
-    pj_scan_init(&scanner, str->ptr, str->slen, 
+    pj_scan_init(&scanner, str->ptr, str->slen,
                  PJ_SCAN_AUTOSKIP_WS, &on_syntax_error);
-    
+
     str_begin = scanner.begin;
 
     PJ_TRY {
-        while (!pj_scan_is_eof(&scanner)) {                 
-            pj_scan_get_until_ch(&scanner, '\n', &out_str);         
+        while (!pj_scan_is_eof(&scanner)) {
+            pj_scan_get_until_ch(&scanner, '\n', &out_str);
             str_len = (int)(scanner.curptr - str_begin);
-            if (*scanner.curptr == '\n') {              
-                if ((str_len > 1) && (out_str.ptr[str_len-2] == '\r')) 
-                {                           
+            if (*scanner.curptr == '\n') {
+                if ((str_len > 1) && (out_str.ptr[str_len-2] == '\r'))
+                {
                     continue;
-                } else {                    
+                } else {
                     int str_pos = (int)(str_begin - scanner.begin);
 
@@ -1314 +1312 @@
                         pj_scan_advance_n(&scanner, 1, PJ_TRUE);
                         str_begin = scanner.curptr;
-                    }               
+                    }
                 }
             } else {
@@ -1355 +1353 @@
     pj_mutex_unlock(tsess->smutex);
     pj_activesock_close(tsess->asock);
-    pj_mutex_destroy(tsess->smutex);    
+    pj_mutex_destroy(tsess->smutex);
     pj_pool_release(tsess->pool);
 }
@@ -1363 +1361 @@
 {
     cli_telnet_fe *tfe = (cli_telnet_fe *)fe;
-    pj_cli_sess *sess;    
+    pj_cli_sess *sess;
 
     pj_mutex_lock(tfe->mutex);
@@ -1371 +1369 @@
         cli_telnet_sess *tsess = (cli_telnet_sess *)sess;
 
-        sess = sess->next;        
+        sess = sess->next;
         if (tsess->base.log_level > level) {
             pj_str_t s;
@@ -1379 +1377 @@
         }
     }
-    
+
     pj_mutex_unlock(tfe->mutex);
 }
@@ -1436 +1434 @@
                             pj_activesock_get_user_data(asock);
 
-    PJ_UNUSED_ARG(op_key);    
+    PJ_UNUSED_ARG(op_key);
 
     if (sent <= 0) {
@@ -1471 +1469 @@
                             pj_activesock_get_user_data(asock);
     cli_telnet_fe *tfe = (cli_telnet_fe *)sess->base.fe;
-    unsigned char *cdata = (unsigned char*)data;    
+    unsigned char *cdata = (unsigned char*)data;
     pj_status_t is_valid = PJ_TRUE;
 
@@ -1483 +1481 @@
         TRACE_((THIS_FILE, "Error on data read %d", status));
         return PJ_FALSE;
-    }    
+    }
 
     pj_mutex_lock(sess->smutex);
@@ -1490 +1488 @@
         case ST_CR:
             sess->parse_state = ST_NORMAL;
-            if (*cdata == 0 || *cdata == '\n')                          
+            if (*cdata == 0 || *cdata == '\n')
                 pj_mutex_unlock(sess->smutex);
                 is_valid = handle_return(sess);
-                if (!is_valid)              
+                if (!is_valid)
                     return PJ_FALSE;
-                pj_mutex_lock(sess->smutex);    
+                pj_mutex_lock(sess->smutex);
                 break;
         case ST_NORMAL:
@@ -1502 +1500 @@
             } else if (*cdata == 127) {
                 is_valid = handle_backspace(sess, cdata);
-            } else if (*cdata == 27) {              
+            } else if (*cdata == 27) {
                 sess->parse_state = ST_ESC;
-            } else { 
+            } else {
                 if (recv_buf_insert(sess->rcmd, cdata)) {
                     if (*cdata == '\r') {
@@ -1519 +1517 @@
             break;
         case ST_ESC:
-            if (*cdata == 91) {         
+            if (*cdata == 91) {
                 sess->parse_state = ST_VT100;
             } else {
@@ -1598 +1596 @@
     if (status != PJ_SUCCESS && status != PJ_EPENDING) {
         TRACE_((THIS_FILE, "Error on data accept %d", status));
-        if (status == PJ_ESOCKETSTOP) 
-            telnet_restart(fe);     
-        
+        if (status == PJ_ESOCKETSTOP)
+            telnet_restart(fe);
+
         return PJ_FALSE;
-    }    
+    }
 
     /* An incoming connection is accepted, create a new session */
@@ -1609 +1607 @@
                           NULL);
     if (!pool) {
-        TRACE_((THIS_FILE, 
+        TRACE_((THIS_FILE,
                 "Not enough memory to create a new telnet session"));
         return PJ_TRUE;
@@ -1632 +1630 @@
     if (sstatus != PJ_SUCCESS)
         goto on_exit;
-    
+
     sstatus = pj_activesock_create(pool, newsock, pj_SOCK_STREAM(),
                                    NULL, fe->cfg.ioqueue,
@@ -1657 +1655 @@
     send_cmd_do(sess, SUPPRESS_GA);
     send_cmd_will(sess, TERM_ECHO);
-    send_cmd_will(sess, STATUS);   
+    send_cmd_will(sess, STATUS);
     send_cmd_will(sess, SUPPRESS_GA);
 
@@ -1682 +1680 @@
     else
         pj_sock_close(newsock);
-    
+
     if (sess->smutex)
         pj_mutex_destroy(sess->smutex);
@@ -1697 +1695 @@
     cli_telnet_fe *fe;
     pj_pool_t *pool;
-    pj_status_t status;   
+    pj_status_t status;
 
     PJ_ASSERT_RETURN(cli, PJ_EINVAL);
@@ -1707 +1705 @@
     if (!fe)
         return PJ_ENOMEM;
-        
+
     fe->base.op = PJ_POOL_ZALLOC_T(pool, struct pj_cli_front_end_op);
 
@@ -1714 +1712 @@
     else
         pj_memcpy(&fe->cfg, param, sizeof(*param));
-        
+
     pj_list_init(&fe->sess_head);
     fe->base.cli = cli;
@@ -1722 +1720 @@
     fe->pool = pool;
 
-    if (!fe->cfg.ioqueue) {     
+    if (!fe->cfg.ioqueue) {
         /* Create own ioqueue if application doesn't supply one */
         status = pj_ioqueue_create(pool, 8, &fe->cfg.ioqueue);
@@ -1762 +1760 @@
     pj_activesock_cb asock_cb;
     pj_sockaddr_in addr;
-    pj_status_t status;   
+    pj_status_t status;
     int val;
     int restart_retry;
@@ -1794 +1792 @@
         PJ_LOG(4,(THIS_FILE, "Address is still in use, retrying.."));
         pj_thread_sleep(msec);
-    }    
-    
-    if (status == PJ_SUCCESS) { 
-        int addr_len = sizeof(addr);    
+    }
+
+    if (status == PJ_SUCCESS) {
+        int addr_len = sizeof(addr);
 
         status = pj_sock_getsockname(sock, &addr, &addr_len);
         if (status != PJ_SUCCESS)
             goto on_exit;
-            
-        fe->cfg.port = pj_sockaddr_in_get_port(&addr);  
+
+        fe->cfg.port = pj_sockaddr_in_get_port(&addr);
 
         if (fe->cfg.prompt_str.slen == 0) {
             pj_str_t prompt_sign = {"> ", 2};
-            char *prompt_data = pj_pool_alloc(fe->pool, 
+            char *prompt_data = pj_pool_alloc(fe->pool,
                                               pj_gethostname()->slen+2);
             fe->cfg.prompt_str.ptr = prompt_data;
@@ -1813 +1811 @@
             pj_strcpy(&fe->cfg.prompt_str, pj_gethostname());
             pj_strcat(&fe->cfg.prompt_str, &prompt_sign);
-        }       
+        }
     } else {
         PJ_LOG(3, (THIS_FILE, "Failed binding the socket"));
@@ -1869 +1867 @@
 {
     pj_status_t status;
-    pj_cli_sess *sess;      
+    pj_cli_sess *sess;
 
     fe->is_quitting = PJ_TRUE;
-    if (fe->worker_thread) {    
+    if (fe->worker_thread) {
         pj_thread_join(fe->worker_thread);
     }
@@ -1911 +1909 @@
 }
 
-PJ_DEF(pj_status_t) pj_cli_telnet_get_info(pj_cli_front_end *fe, 
+PJ_DEF(pj_status_t) pj_cli_telnet_get_info(pj_cli_front_end *fe,
                                            pj_cli_telnet_info *info)
 {
     pj_sockaddr hostip;
     pj_status_t status;
-    cli_telnet_fe *tfe = (cli_telnet_fe*) fe; 
-
-    PJ_ASSERT_RETURN(fe && (fe->type == PJ_CLI_TELNET_FRONT_END) && info, 
+    cli_telnet_fe *tfe = (cli_telnet_fe*) fe;
+
+    PJ_ASSERT_RETURN(fe && (fe->type == PJ_CLI_TELNET_FRONT_END) && info,
                      PJ_EINVAL);
 

pjproject/trunk/pjlib/src/pj/os_core_unix.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 /*
@@ -165 +165 @@
     pj_log_init();
 
-    /* Initialize exception ID for the pool. 
+    /* Initialize exception ID for the pool.
      * Must do so after critical section is configured.
      */
@@ -171 +171 @@
     if (rc != PJ_SUCCESS)
         return rc;
-    
+
     /* Init random seed. */
     /* Or probably not. Let application in charge of this */
@@ -188 +188 @@
         }
     }
-#endif   
+#endif
 
     /* Flag PJLIB as initialized */
@@ -383 +383 @@
  * Get native thread handle
  */
-PJ_DEF(void*) pj_thread_get_os_handle(pj_thread_t *thread) 
+PJ_DEF(void*) pj_thread_get_os_handle(pj_thread_t *thread)
 {
     PJ_ASSERT_RETURN(thread, NULL);
@@ -441 +441 @@
 
     if(cstr_thread_name && pj_strlen(&thread_name) < sizeof(thread->obj_name)-1)
-        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name), 
+        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name),
                          cstr_thread_name, thread->thread);
     else
-        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name), 
+        pj_ansi_snprintf(thread->obj_name, sizeof(thread->obj_name),
                          "thr%p", (void*)thread->thread);
-    
+
     rc = pj_thread_local_set(thread_tls_id, thread);
     if (rc != PJ_SUCCESS) {
@@ -458 +458 @@
     thread->stk_max_usage = 0;
 #else
-    stack_ptr = '\0';
+    PJ_UNUSED_ARG(stack_ptr);
 #endif
 
@@ -533 +533 @@
  * pj_thread_create(...)
  */
-PJ_DEF(pj_status_t) pj_thread_create( pj_pool_t *pool, 
+PJ_DEF(pj_status_t) pj_thread_create( pj_pool_t *pool,
                                       const char *thread_name,
-                                      pj_thread_proc *proc, 
+                                      pj_thread_proc *proc,
                                       void *arg,
-                                      pj_size_t stack_size, 
+                                      pj_size_t stack_size,
                                       unsigned flags,
                                       pj_thread_t **ptr_thread)
@@ -555 +555 @@
     rec = (struct pj_thread_t*) pj_pool_zalloc(pool, sizeof(pj_thread_t));
     PJ_ASSERT_RETURN(rec, PJ_ENOMEM);
-    
+
     /* Set name. */
-    if (!thread_name) 
+    if (!thread_name)
         thread_name = "thr%p";
-    
+
     if (strchr(thread_name, '%')) {
         pj_ansi_snprintf(rec->obj_name, PJ_MAX_OBJ_NAME, thread_name, rec);
@@ -587 +587 @@
         pj_assert(rec->suspended_mutex == NULL);
     }
-    
+
 
     /* Init thread attributes */
@@ -668 +668 @@
 #if PJ_HAS_THREADS
     pj_thread_t *rec = (pj_thread_t*)pj_thread_local_get(thread_tls_id);
-    
+
     if (rec == NULL) {
         pj_assert(!"Calling pjlib from unknown/external thread. You must "
@@ -706 +706 @@
         return PJ_SUCCESS;
     else {
-        /* Calling pthread_join() on a thread that no longer exists and 
-         * getting back ESRCH isn't an error (in this context). 
+        /* Calling pthread_join() on a thread that no longer exists and
+         * getting back ESRCH isn't an error (in this context).
          * Thanks Phil Torre <ptorre@zetron.com>.
          */
@@ -762 +762 @@
     /* MacOS X (reported on 10.5) seems to always set errno to ETIMEDOUT.
      * It does so because usleep() is declared to return int, and we're
-     * supposed to check for errno only when usleep() returns non-zero. 
+     * supposed to check for errno only when usleep() returns non-zero.
      * Unfortunately, usleep() is declared to return void in other platforms
-     * so it's not possible to always check for the return value (unless 
+     * so it's not possible to always check for the return value (unless
      * we add a detection routine in autoconf).
      *
@@ -832 +832 @@
  * pj_atomic_create()
  */
-PJ_DEF(pj_status_t) pj_atomic_create( pj_pool_t *pool, 
+PJ_DEF(pj_status_t) pj_atomic_create( pj_pool_t *pool,
                                       pj_atomic_value_t initial,
                                       pj_atomic_t **ptr_atomic)
@@ -842 +842 @@
 
     PJ_ASSERT_RETURN(atomic_var, PJ_ENOMEM);
-    
+
 #if PJ_HAS_THREADS
     rc = pj_mutex_create(pool, "atm%p", PJ_MUTEX_SIMPLE, &atomic_var->mutex);
@@ -880 +880 @@
 #if PJ_HAS_THREADS
     pj_mutex_unlock( atomic_var->mutex);
-#endif 
+#endif
 }
 
@@ -889 +889 @@
 {
     pj_atomic_value_t oldval;
-    
+
     PJ_CHECK_STACK();
 
@@ -959 +959 @@
 /*
  * pj_atomic_add_and_get()
- */ 
-PJ_DEF(pj_atomic_value_t) pj_atomic_add_and_get( pj_atomic_t *atomic_var, 
+ */
+PJ_DEF(pj_atomic_value_t) pj_atomic_add_and_get( pj_atomic_t *atomic_var,
                                                  pj_atomic_value_t value )
 {
@@ -968 +968 @@
     pj_mutex_lock(atomic_var->mutex);
 #endif
-    
+
     atomic_var->value += value;
     new_value = atomic_var->value;
@@ -981 +981 @@
 /*
  * pj_atomic_add()
- */ 
-PJ_DEF(void) pj_atomic_add( pj_atomic_t *atomic_var, 
+ */
+PJ_DEF(void) pj_atomic_add( pj_atomic_t *atomic_var,
                             pj_atomic_value_t value )
 {
@@ -1012 +1012 @@
             break;
     }
-    if (i == MAX_THREADS) 
+    if (i == MAX_THREADS)
         return PJ_ETOOMANY;
-    
+
     tls_flag[i] = 1;
     tls[i] = NULL;
@@ -1119 +1119 @@
        defined(PJ_PTHREAD_MUTEXATTR_T_HAS_RECURSIVE)
         // Phil Torre <ptorre@zetron.com>:
-        // The RTEMS implementation of POSIX mutexes doesn't include 
+        // The RTEMS implementation of POSIX mutexes doesn't include
         // pthread_mutexattr_settype(), so what follows is a hack
         // until I get RTEMS patched to support the set/get functions.
@@ -1132 +1132 @@
 #endif
     }
-    
+
     if (rc != 0) {
         return PJ_RETURN_OS_ERROR(rc);
@@ -1141 +1141 @@
         return PJ_RETURN_OS_ERROR(rc);
     }
-    
+
     rc = pthread_mutexattr_destroy(&attr);
     if (rc != 0) {
@@ -1176 +1176 @@
  * pj_mutex_create()
  */
-PJ_DEF(pj_status_t) pj_mutex_create(pj_pool_t *pool, 
-                                    const char *name, 
+PJ_DEF(pj_status_t) pj_mutex_create(pj_pool_t *pool,
+                                    const char *name,
                                     int type,
                                     pj_mutex_t **ptr_mutex)
@@ -1192 +1192 @@
     if ((rc=init_mutex(mutex, name, type)) != PJ_SUCCESS)
         return rc;
-    
+
     *ptr_mutex = mutex;
     return PJ_SUCCESS;
@@ -1204 +1204 @@
  * pj_mutex_create_simple()
  */
-PJ_DEF(pj_status_t) pj_mutex_create_simple( pj_pool_t *pool, 
+PJ_DEF(pj_status_t) pj_mutex_create_simple( pj_pool_t *pool,
                                             const char *name,
                                             pj_mutex_t **mutex )
@@ -1233 +1233 @@
 
 #if PJ_DEBUG
-    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting (mutex owner=%s)", 
+    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting (mutex owner=%s)",
                                 pj_thread_this()->obj_name,
                                 mutex->owner_name));
 #else
-    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting", 
+    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is waiting",
                                 pj_thread_this()->obj_name));
 #endif
@@ -1251 +1251 @@
     }
 
-    PJ_LOG(6,(mutex->obj_name, 
-              (status==0 ? 
-                "Mutex acquired by thread %s (level=%d)" : 
+    PJ_LOG(6,(mutex->obj_name,
+              (status==0 ?
+                "Mutex acquired by thread %s (level=%d)" :
                 "Mutex acquisition FAILED by %s (level=%d)"),
               pj_thread_this()->obj_name,
               mutex->nesting_level));
 #else
-    PJ_LOG(6,(mutex->obj_name, 
+    PJ_LOG(6,(mutex->obj_name,
               (status==0 ? "Mutex acquired by thread %s" : "FAILED by %s"),
               pj_thread_this()->obj_name));
@@ -1291 +1291 @@
     }
 
-    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s (level=%d)", 
-                                pj_thread_this()->obj_name, 
+    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s (level=%d)",
+                                pj_thread_this()->obj_name,
                                 mutex->nesting_level));
 #else
-    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s", 
+    PJ_LOG(6,(mutex->obj_name, "Mutex released by thread %s",
                                 pj_thread_this()->obj_name));
 #endif
@@ -1322 +1322 @@
     PJ_ASSERT_RETURN(mutex, PJ_EINVAL);
 
-    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is trying", 
+    PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s is trying",
                                 pj_thread_this()->obj_name));
 
@@ -1333 +1333 @@
         ++mutex->nesting_level;
 
-        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s (level=%d)", 
+        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s (level=%d)",
                                    pj_thread_this()->obj_name,
                                    mutex->nesting_level));
 #else
-        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s", 
+        PJ_LOG(6,(mutex->obj_name, "Mutex acquired by thread %s",
                                   pj_thread_this()->obj_name));
 #endif
     } else {
-        PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s's trylock() failed", 
+        PJ_LOG(6,(mutex->obj_name, "Mutex: thread %s's trylock() failed",
                                     pj_thread_this()->obj_name));
     }
-    
+
     if (status==0)
         return PJ_SUCCESS;
@@ -1426 +1426 @@
 
     PJ_UNUSED_ARG(name);
-    
+
     rwm = PJ_POOL_ALLOC_T(pool, pj_rwmutex_t);
     PJ_ASSERT_RETURN(rwm, PJ_ENOMEM);
@@ -1516 +1516 @@
  * pj_sem_create()
  */
-PJ_DEF(pj_status_t) pj_sem_create( pj_pool_t *pool, 
+PJ_DEF(pj_status_t) pj_sem_create( pj_pool_t *pool,
                                    const char *name,
-                                   unsigned initial, 
+                                   unsigned initial,
                                    unsigned max,
                                    pj_sem_t **ptr_sem)
@@ -1537 +1537 @@
         pj_str_t nam;
 
-        /* We should use SEM_NAME_LEN, but this doesn't seem to be 
+        /* We should use SEM_NAME_LEN, but this doesn't seem to be
          * declared anywhere? The value here is just from trial and error
          * to get the longest name supported.
@@ -1554 +1554 @@
 
         /* Create semaphore */
-        sem->sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IRUSR|S_IWUSR, 
+        sem->sem = sem_open(sem_name, O_CREAT|O_EXCL, S_IRUSR|S_IWUSR,
                             initial);
         if (sem->sem == SEM_FAILED)
@@ -1564 +1564 @@
 #else
     sem->sem = PJ_POOL_ALLOC_T(pool, sem_t);
-    if (sem_init( sem->sem, 0, initial) != 0) 
+    if (sem_init( sem->sem, 0, initial) != 0)
         return PJ_RETURN_OS_ERROR(pj_get_native_os_error());
 #endif
-    
+
     /* Set name. */
     if (!name) {
@@ -1600 +1600 @@
     PJ_ASSERT_RETURN(sem, PJ_EINVAL);
 
-    PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s is waiting", 
+    PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s is waiting",
                               pj_thread_this()->obj_name));
 
     result = sem_wait( sem->sem );
-    
+
     if (result == 0) {
-        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s", 
+        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s",
                                   pj_thread_this()->obj_name));
     } else {
-        PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s FAILED to acquire", 
+        PJ_LOG(6, (sem->obj_name, "Semaphore: thread %s FAILED to acquire",
                                   pj_thread_this()->obj_name));
     }
@@ -1635 +1635 @@
 
     result = sem_trywait( sem->sem );
-    
+
     if (result == 0) {
-        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s", 
+        PJ_LOG(6, (sem->obj_name, "Semaphore acquired by thread %s",
                                   pj_thread_this()->obj_name));
-    } 
+    }
     if (result == 0)
         return PJ_SUCCESS;

pjproject/trunk/pjlib/src/pjlib-test/test.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "test.h"
@@ -39 +39 @@
 const char *param_echo_server = ECHO_SERVER_ADDRESS;
 int param_echo_port = ECHO_SERVER_START_PORT;
-int param_log_decor = PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_TIME | 
+int param_log_decor = PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_TIME |
                       PJ_LOG_HAS_MICRO_SEC;
 
@@ -64 +64 @@
         return rc;
     }
-    
+
     //pj_dump_config();
     pj_caching_pool_init( &caching_pool, NULL, 0 );
@@ -99 +99 @@
     DO_TEST( string_test() );
 #endif
-    
+
 #if INCLUDE_FIFOBUF_TEST
     DO_TEST( fifobuf_test() );
@@ -185 +185 @@
         param_echo_sock_type = pj_SOCK_DGRAM();
 
-    echo_client( param_echo_sock_type, 
-                 param_echo_server, 
+    echo_client( param_echo_sock_type,
+                 param_echo_server,
                  param_echo_port);
 #endif
@@ -197 +197 @@
 
     PJ_LOG(3,("test", ""));
- 
+
     pj_thread_get_stack_info(pj_thread_this(), &filename, &line);
-    PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u", 
+    PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u",
                       pj_thread_get_stack_max_usage(pj_thread_this()),
                       filename, line));
@@ -206 +206 @@
     else
         PJ_LOG(3,("test", "Test completed with error(s)"));
-    
+
     pj_shutdown();
-    
+
     return 0;
 }
@@ -217 +217 @@
 {
     PJ_USE_EXCEPTION;
-
-    pj_AF_INET();
 
     PJ_TRY {
@@ -225 +223 @@
     PJ_CATCH_ANY {
         int id = PJ_GET_EXCEPTION();
-        PJ_LOG(3,("test", "FATAL: unhandled exception id %d (%s)", 
+        PJ_LOG(3,("test", "FATAL: unhandled exception id %d (%s)",
                   id, pj_exception_id_name(id)));
     }

pjproject/trunk/pjlib/src/pjlib-test/thread.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "test.h"
@@ -31 +31 @@
  *  - whether thread timeslicing works, and threads have equal
  *    time-slice proportion.
- * 
+ *
  * APIs tested:
  *  - pj_thread_create()
@@ -78 +78 @@
 
     id = *pcounter;
+    PJ_UNUSED_ARG(id); /* Warning about unused var if TRACE__ is disabled */
     TRACE__((THIS_FILE, "     thread %d running..", id));
 
@@ -121 +122 @@
     pj_status_t rc;
     pj_uint32_t counter = 0;
- 
+
     PJ_LOG(3,(THIS_FILE, "..%s", title));
-    
+
     pool = pj_pool_create(mem, NULL, 4000, 4000, NULL);
     if (!pool)
@@ -153 +154 @@
             return -1015;
         }
-        
+
         rc = pj_thread_resume(thread);
         if (rc != PJ_SUCCESS) {
@@ -160 +161 @@
         }
     }
-    
+
     PJ_LOG(3,(THIS_FILE, "..waiting for thread to quit.."));
 
@@ -174 +175 @@
         return -1025;
     }
-    
+
     PJ_LOG(3,(THIS_FILE, "...%s success", title));
     return PJ_SUCCESS;
@@ -203 +204 @@
     for (i=0; i<NUM_THREADS; ++i) {
         counter[i] = i;
-        rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc, 
-                              &counter[i], 
-                              PJ_THREAD_DEFAULT_STACK_SIZE, 
-                              PJ_THREAD_SUSPENDED, 
+        rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc,
+                              &counter[i],
+                              PJ_THREAD_DEFAULT_STACK_SIZE,
+                              PJ_THREAD_SUSPENDED,
                               &thread[i]);
         if (rc!=PJ_SUCCESS) {
@@ -224 +225 @@
     for (i=0; i<NUM_THREADS; ++i) {
         if (counter[i] > i) {
-            PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!", 
+            PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!",
                       i));
             return -30;
@@ -240 +241 @@
     }
 
-    /* Main thread sleeps for some time to allow threads to run. 
+    /* Main thread sleeps for some time to allow threads to run.
      * The longer we sleep, the more accurate the calculation will be,
      * but it'll make user waits for longer for the test to finish.
@@ -253 +254 @@
     /* Wait until all threads quit, then destroy. */
     for (i=0; i<NUM_THREADS; ++i) {
-        TRACE__((THIS_FILE, "    Main thread joining thread %d [%p]..", 
+        TRACE__((THIS_FILE, "    Main thread joining thread %d [%p]..",
                             i, thread[i]));
         rc = pj_thread_join(thread[i]);
@@ -292 +293 @@
     diff = (highest-lowest)*100 / ((highest+lowest)/2);
     if ( diff >= 50) {
-        PJ_LOG(3,(THIS_FILE, 
+        PJ_LOG(3,(THIS_FILE,
                   "...ERROR: thread didn't have equal timeslice!"));
-        PJ_LOG(3,(THIS_FILE, 
+        PJ_LOG(3,(THIS_FILE,
                   ".....lowest counter=%u, highest counter=%u, diff=%u%%",
                   lowest, highest, diff));
         return -80;
     } else {
-        PJ_LOG(3,(THIS_FILE, 
+        PJ_LOG(3,(THIS_FILE,
                   "...info: timeslice diff between lowest & highest=%u%%",
                   diff));
@@ -315 +316 @@
     if (rc != PJ_SUCCESS)
         return rc;
-    
+
     rc = simple_thread("suspended thread test", PJ_THREAD_SUSPENDED);
     if (rc != PJ_SUCCESS)
         return rc;
-    
+
     rc = timeslice_test();
     if (rc != PJ_SUCCESS)
@@ -329 +330 @@
 #else
 /* To prevent warning about "translation unit is empty"
- * when this test is disabled. 
+ * when this test is disabled.
  */
 int dummy_thread_test;

pjproject/trunk/pjmedia/src/pjmedia-audiodev/bb10_dev.c

@@ -501 +501 @@
                 if (status.status == SND_PCM_STATUS_READY ||
                     status.status == SND_PCM_STATUS_UNDERRUN ||
-                    status.status == SND_PCM_STATUS_ERROR ) 
+                    status.status == SND_PCM_STATUS_ERROR )
                 {
                     if (snd_pcm_plugin_prepare (stream->pb_pcm,
@@ -778 +778 @@
     TRACE_((THIS_FILE, "bb10_open_playback: pb_frames = %d clock = %d",
                        stream->pb_frames, param->clock_rate));
-    
+
     return PJ_SUCCESS;
 }
@@ -864 +864 @@
 
     frame_size = setup.buf.block.frag_size;
+    PJ_UNUSED_ARG(frame_size); /* Warning about unused var */
 
     /* Set clock rate */
@@ -962 +963 @@
 
 
-/* 
+/*
  * API: get running parameter
  * based on ALSA template
@@ -981 +982 @@
 /*
  * API: get capability
- * based on ALSA template 
+ * based on ALSA template
 */
 static pj_status_t bb10_stream_get_cap(pjmedia_aud_stream *s,
@@ -1043 +1044 @@
             ret = bb10_initialize_playback_ctrl(stream,true);
         } else {
-            ret = bb10_initialize_playback_ctrl(stream,false);          
+            ret = bb10_initialize_playback_ctrl(stream,false);
         }
         return ret;

pjproject/trunk/pjmedia/src/pjmedia/echo_suppress.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <pjmedia/types.h>
@@ -78 +78 @@
 #if 0
 #   define TRACE_(expr) PJ_LOG(5,expr)
+
+static const char *state_names[] =
+{
+    "Null",
+    "local talking",
+    "remote silent",
+    "doubletalk",
+    "remote talking"
+};
+
 #else
 #   define TRACE_(expr)
@@ -126 +136 @@
 } talk_state_t;
 
-static const char *state_names[] = 
-{
-    "Null",
-    "local talking",
-    "remote silent",
-    "doubletalk",
-    "remote talking"
-};
-
 
 /* Description:
 
    The echo suppressor tries to find the position of echoed signal by looking
-   at the correlation between signal played to the speaker (played signal) 
+   at the correlation between signal played to the speaker (played signal)
    and the signal captured from the microphone (recorded signal).
 
-   To do this, it first divides the frames (from mic and speaker) into 
+   To do this, it first divides the frames (from mic and speaker) into
    segments, calculate the audio level of the segment, and save the level
    information in the playback and record history (play_hist and rec_hist
@@ -151 +152 @@
 
    The record history size is as large as the template size (tmpl_cnt), since
-   we will use the record history as the template to find the best matching 
+   we will use the record history as the template to find the best matching
    position in the playback history.
 
@@ -188 +189 @@
       similar) the signal is. The correlation value is done over the template
       duration.
-    - the gain scaling factor, that is the ratio between mic signal and 
+    - the gain scaling factor, that is the ratio between mic signal and
       speaker signal. The ES calculates both the minimum and average ratios.
 
@@ -210 +211 @@
    Processing:
 
-   Once learning is done, the ES will change the level of the mic signal 
+   Once learning is done, the ES will change the level of the mic signal
    depending on the state of the conversation and according to the ratio that
    has been found in the learning phase above.
@@ -264 +265 @@
 
 /*
- * Create. 
+ * Create.
  */
 PJ_DEF(pj_status_t) echo_supp_create( pj_pool_t *pool,
@@ -293 +294 @@
     ec->play_hist_cnt = (pj_uint16_t)(ec->tail_cnt+ec->templ_cnt);
 
-    ec->max_calc = (pj_uint16_t)(MAX_CALC_DURATION_SEC * clock_rate / 
+    ec->max_calc = (pj_uint16_t)(MAX_CALC_DURATION_SEC * clock_rate /
                                  ec->samples_per_segment);
 
-    ec->rec_hist = (pj_uint16_t*) 
+    ec->rec_hist = (pj_uint16_t*)
                     pj_pool_alloc(pool, ec->templ_cnt *
                                         sizeof(ec->rec_hist[0]));
 
     /* Note: play history has twice number of elements */
-    ec->play_hist = (pj_uint16_t*) 
+    ec->play_hist = (pj_uint16_t*)
                      pj_pool_alloc(pool, ec->play_hist_cnt *
                                          sizeof(ec->play_hist[0]));
 
     ec->corr_sum = (float*)
-                   pj_pool_alloc(pool, ec->tail_cnt * 
+                   pj_pool_alloc(pool, ec->tail_cnt *
                                        sizeof(ec->corr_sum[0]));
     ec->tmp_corr = (float*)
-                   pj_pool_alloc(pool, ec->tail_cnt * 
+                   pj_pool_alloc(pool, ec->tail_cnt *
                                        sizeof(ec->tmp_corr[0]));
     ec->min_factor = (float*)
-                     pj_pool_alloc(pool, ec->tail_cnt * 
+                     pj_pool_alloc(pool, ec->tail_cnt *
                                          sizeof(ec->min_factor[0]));
     ec->avg_factor = (float*)
-                     pj_pool_alloc(pool, ec->tail_cnt * 
+                     pj_pool_alloc(pool, ec->tail_cnt *
                                          sizeof(ec->avg_factor[0]));
     ec->tmp_factor = (float*)
-                     pj_pool_alloc(pool, ec->tail_cnt * 
+                     pj_pool_alloc(pool, ec->tail_cnt *
                                          sizeof(ec->tmp_factor[0]));
     echo_supp_reset(ec);
@@ -328 +329 @@
 
 /*
- * Destroy. 
+ * Destroy.
  */
 PJ_DEF(pj_status_t) echo_supp_destroy(void *state)
@@ -394 +395 @@
 
 /* Set state */
-static void echo_supp_set_state(echo_supp *ec, talk_state_t state, 
+static void echo_supp_set_state(echo_supp *ec, talk_state_t state,
                                 unsigned level)
 {
@@ -400 +401 @@
 
     if (state != ec->talk_state) {
-        TRACE_((THIS_FILE, "[%03d.%03d] %s --> %s, level=%u", 
-                           (ec->update_cnt * SEGMENT_PTIME / 1000), 
+        TRACE_((THIS_FILE, "[%03d.%03d] %s --> %s, level=%u",
+                           (ec->update_cnt * SEGMENT_PTIME / 1000),
                            ((ec->update_cnt * SEGMENT_PTIME) % 1000),
                            state_names[ec->talk_state],
@@ -470 +471 @@
     } else {
         /* Update from previous calculation */
-        ec->sum_rec_level = ec->sum_rec_level - old_rec_frm_level + 
+        ec->sum_rec_level = ec->sum_rec_level - old_rec_frm_level +
                             ec->rec_hist[ec->templ_cnt-1];
-        ec->rec_corr = ec->rec_corr - ((float)ec->rec_hist[0] / 
+        ec->rec_corr = ec->rec_corr - ((float)ec->rec_hist[0] /
                                               old_rec_frm_level) +
                        ((float)ec->rec_hist[ec->templ_cnt-1] /
@@ -483 +484 @@
      * to detect echo.
      */
-    /* 
-     * First phase: do full calculation for the first position 
+    /*
+     * First phase: do full calculation for the first position
      */
     if (ec->sum_play_level0 == 0) {
@@ -501 +502 @@
     } else {
         /* Update from previous calculation */
-        ec->sum_play_level0 = ec->sum_play_level0 - old_play_frm_level + 
+        ec->sum_play_level0 = ec->sum_play_level0 - old_play_frm_level +
                               ec->play_hist[ec->templ_cnt-1];
-        ec->play_corr0 = ec->play_corr0 - ((float)ec->play_hist[0] / 
+        ec->play_corr0 = ec->play_corr0 - ((float)ec->play_hist[0] /
                                                   old_play_frm_level) +
                          ((float)ec->play_hist[ec->templ_cnt-1] /
@@ -585 +586 @@
         if (ec->tmp_factor[i] < ec->min_factor[i])
             ec->min_factor[i] = ec->tmp_factor[i];
-        ec->avg_factor[i] = ((ec->avg_factor[i] * ec->tail_cnt) + 
+        ec->avg_factor[i] = ((ec->avg_factor[i] * ec->tail_cnt) +
                                     ec->tmp_factor[i]) /
                             (ec->tail_cnt + 1);
@@ -610 +611 @@
         iavg = (int)(ec->avg_factor[ec->tail_index] * 1000);
 
-        PJ_LOG(4,(THIS_FILE, 
+        PJ_LOG(4,(THIS_FILE,
                   "Echo suppressor updated at t=%03d.%03ds, echo tail=%d msec"
                   ", factor min/avg=%d.%03d/%d.%03d",
@@ -634 +635 @@
         iavg = (int)(ec->avg_factor[ec->tail_index] * 1000);
 
-        PJ_LOG(4,(THIS_FILE, 
+        PJ_LOG(4,(THIS_FILE,
                   "Echo suppressor learning done at t=%03d.%03ds, tail=%d ms"
                   ", factor min/avg=%d.%03d/%d.%03d",
@@ -647 +648 @@
 
 /* Amplify frame */
-static void amplify_frame(pj_int16_t *frm, unsigned length, 
+static void amplify_frame(pj_int16_t *frm, unsigned length,
                           pj_ufloat_t factor)
 {
@@ -657 +658 @@
 }
 
-/* 
+/*
  * Perform echo cancellation.
  */
@@ -710 +711 @@
          * if remote user is currently talking
          */
-        for (i=ec->play_hist_cnt -lookup_cnt -tail_cnt; 
-             i<ec->play_hist_cnt-tail_cnt; ++i) 
+        for (i=ec->play_hist_cnt -lookup_cnt -tail_cnt;
+             i<ec->play_hist_cnt-tail_cnt; ++i)
         {
             if (ec->play_hist[i] > play_level)
@@ -733 +734 @@
             } else {
                 /* Speaker is active, but we've picked up large signal in
-                 * the microphone. Assume that this is an echo, so bring 
+                 * the microphone. Assume that this is an echo, so bring
                  * the level down to minimum too.
                  */
@@ -763 +764 @@
 
         /* Amplify frame */
-        amplify_frame(rec_frm, ec->samples_per_frame, 
+        amplify_frame(rec_frm, ec->samples_per_frame,
                       pj_ufloat_from_float(factor));
         ec->last_factor = factor;
@@ -775 +776 @@
 
             /* Accumulate average echo residue to see the ES effectiveness */
-            ec->residue = ((ec->residue * ec->running_cnt) + level) / 
+            ec->residue = ((ec->residue * ec->running_cnt) + level) /
                           (ec->running_cnt + 1);
 

pjproject/trunk/pjmedia/src/pjmedia/jbuf.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 /*
@@ -36 +36 @@
 #define INVALID_OFFSET          -9999
 
-/* Maximum burst length, whenever an operation is bursting longer than 
+/* Maximum burst length, whenever an operation is bursting longer than
  * this value, JB will assume that the opposite operation was idle.
  */
@@ -47 +47 @@
 
 
-/* Minimal difference between JB size and 2*burst-level to perform 
- * JB shrinking in static discard algorithm. 
+/* Minimal difference between JB size and 2*burst-level to perform
+ * JB shrinking in static discard algorithm.
  */
 #define STA_DISC_SAFE_SHRINKING_DIFF    1
@@ -68 +68 @@
     pj_uint32_t     *bit_info;          /**< frame bit info array           */
     pj_uint32_t     *ts;                /**< timestamp array                */
-    
+
     /* States */
     unsigned         head;              /**< index of head, pointed frame
                                              will be returned by next GET   */
-    unsigned         size;              /**< current size of framelist, 
+    unsigned         size;              /**< current size of framelist,
                                              including discarded frames.    */
-    unsigned         discarded_num;     /**< current number of discarded 
+    unsigned         discarded_num;     /**< current number of discarded
                                              frames.                        */
     int              origin;            /**< original index of flist_head   */
@@ -92 +92 @@
     pj_size_t       jb_frame_size;      /**< frame size                     */
     unsigned        jb_frame_ptime;     /**< frame duration.                */
-    pj_size_t       jb_max_count;       /**< capacity of jitter buffer, 
+    pj_size_t       jb_max_count;       /**< capacity of jitter buffer,
                                              in frames                      */
     int             jb_init_prefetch;   /**< Initial prefetch               */
@@ -98 +98 @@
     int             jb_max_prefetch;    /**< Maximum allowable prefetch     */
     int             jb_max_burst;       /**< maximum possible burst, whenever
-                                             burst exceeds this value, it 
-                                             won't be included in level 
+                                             burst exceeds this value, it
+                                             won't be included in level
                                              calculation                    */
     int             jb_min_shrink_gap;  /**< How often can we shrink        */
@@ -108 +108 @@
 
     /* States */
-    int             jb_level;           /**< delay between source & 
-                                             destination (calculated according 
-                                             of the number of burst get/put 
+    int             jb_level;           /**< delay between source &
+                                             destination (calculated according
+                                             of the number of burst get/put
                                              operations)                    */
-    int             jb_max_hist_level;  /**< max level during the last level 
+    int             jb_max_hist_level;  /**< max level during the last level
                                              calculations                   */
-    int             jb_stable_hist;     /**< num of times the delay has been 
+    int             jb_stable_hist;     /**< num of times the delay has been
                                              lower then the prefetch num    */
-    int             jb_last_op;         /**< last operation executed 
+    int             jb_last_op;         /**< last operation executed
                                              (put/get)                      */
     int             jb_eff_level;       /**< effective burst level          */
-    int             jb_prefetch;        /**< no. of frame to insert before 
-                                             removing some (at the beginning 
-                                             of the framelist->content 
+    int             jb_prefetch;        /**< no. of frame to insert before
+                                             removing some (at the beginning
+                                             of the framelist->content
                                              operation), the value may be
                                              continuously updated based on
                                              current frame burst level.     */
     pj_bool_t       jb_prefetching;     /**< flag if jbuf is prefetching.   */
-    int             jb_status;          /**< status is 'init' until the first 
+    int             jb_status;          /**< status is 'init' until the first
                                              'put' operation                */
-    int             jb_init_cycle_cnt;  /**< status is 'init' until the first 
+    int             jb_init_cycle_cnt;  /**< status is 'init' until the first
                                              'put' operation                */
 
@@ -137 +137 @@
 
     /* Statistics */
-    pj_math_stat    jb_delay;           /**< Delay statistics of jitter buffer 
+    pj_math_stat    jb_delay;           /**< Delay statistics of jitter buffer
                                              (in ms)                        */
     pj_math_stat    jb_burst;           /**< Burst statistics (in frames)   */
@@ -165 +165 @@
 
 
-/* Enabling this would log the jitter buffer state about once per 
+/* Enabling this would log the jitter buffer state about once per
  * second.
  */
@@ -181 +181 @@
                                       jb_framelist_t *framelist,
                                       unsigned frame_size,
-                                      unsigned max_count) 
+                                      unsigned max_count)
 {
     PJ_ASSERT_RETURN(pool && framelist, PJ_EINVAL);
@@ -189 +189 @@
     framelist->frame_size   = frame_size;
     framelist->max_count    = max_count;
-    framelist->content      = (char*) 
+    framelist->content      = (char*)
                               pj_pool_alloc(pool,
-                                            framelist->frame_size* 
+                                            framelist->frame_size*
                                             framelist->max_count);
     framelist->frame_type   = (int*)
-                              pj_pool_alloc(pool, 
+                              pj_pool_alloc(pool,
                                             sizeof(framelist->frame_type[0])*
                                             framelist->max_count);
     framelist->content_len  = (pj_size_t*)
-                              pj_pool_alloc(pool, 
+                              pj_pool_alloc(pool,
                                             sizeof(framelist->content_len[0])*
                                             framelist->max_count);
     framelist->bit_info     = (pj_uint32_t*)
-                              pj_pool_alloc(pool, 
+                              pj_pool_alloc(pool,
                                             sizeof(framelist->bit_info[0])*
                                             framelist->max_count);
     framelist->ts           = (pj_uint32_t*)
-                              pj_pool_alloc(pool, 
+                              pj_pool_alloc(pool,
                                             sizeof(framelist->ts[0])*
                                             framelist->max_count);
@@ -214 +214 @@
 }
 
-static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist) 
+static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist)
 {
     PJ_UNUSED_ARG(framelist);
@@ -220 +220 @@
 }
 
-static pj_status_t jb_framelist_reset(jb_framelist_t *framelist) 
+static pj_status_t jb_framelist_reset(jb_framelist_t *framelist)
 {
     framelist->head = 0;
@@ -228 +228 @@
 
 
-    //pj_bzero(framelist->content, 
-    //       framelist->frame_size * 
+    //pj_bzero(framelist->content,
+    //       framelist->frame_size *
     //       framelist->max_count);
 
     pj_memset(framelist->frame_type,
               PJMEDIA_JB_MISSING_FRAME,
-              sizeof(framelist->frame_type[0]) * 
+              sizeof(framelist->frame_type[0]) *
               framelist->max_count);
 
-    pj_bzero(framelist->content_len, 
-             sizeof(framelist->content_len[0]) * 
+    pj_bzero(framelist->content_len,
+             sizeof(framelist->content_len[0]) *
              framelist->max_count);
 
     //pj_bzero(framelist->bit_info,
-    //       sizeof(framelist->bit_info[0]) * 
+    //       sizeof(framelist->bit_info[0]) *
     //       framelist->max_count);
 
@@ -249 +249 @@
 
 
-static unsigned jb_framelist_size(const jb_framelist_t *framelist) 
+static unsigned jb_framelist_size(const jb_framelist_t *framelist)
 {
     return framelist->size;
@@ -255 +255 @@
 
 
-static unsigned jb_framelist_eff_size(const jb_framelist_t *framelist) 
+static unsigned jb_framelist_eff_size(const jb_framelist_t *framelist)
 {
     return (framelist->size - framelist->discarded_num);
 }
 
-static int jb_framelist_origin(const jb_framelist_t *framelist) 
+static int jb_framelist_origin(const jb_framelist_t *framelist)
 {
     return framelist->origin;
@@ -271 +271 @@
                                   pj_uint32_t *bit_info,
                                   pj_uint32_t *ts,
-                                  int *seq) 
+                                  int *seq)
 {
     if (framelist->size) {
@@ -296 +296 @@
                     *bit_info = 0;
             } else {
-                pj_memcpy(frame, 
-                          framelist->content + 
+                pj_memcpy(frame,
+                          framelist->content +
                           framelist->head * framelist->frame_size,
                           framelist->frame_size);
-                *p_type = (pjmedia_jb_frame_type) 
+                *p_type = (pjmedia_jb_frame_type)
                           framelist->frame_type[framelist->head];
                 if (size)
@@ -312 +312 @@
                 *seq = framelist->origin;
 
-            //pj_bzero(framelist->content + 
+            //pj_bzero(framelist->content +
             //   framelist->head * framelist->frame_size,
             //   framelist->frame_size);
@@ -323 +323 @@
             framelist->head = (framelist->head + 1) % framelist->max_count;
             framelist->size--;
-        
+
             return PJ_TRUE;
         }
@@ -342 +342 @@
                                    pj_uint32_t *bit_info,
                                    pj_uint32_t *ts,
-                                   int *seq) 
+                                   int *seq)
 {
     unsigned pos, idx;
@@ -367 +367 @@
         *frame = framelist->content + pos*framelist->frame_size;
     if (type)
-        *type = (pjmedia_jb_frame_type) 
+        *type = (pjmedia_jb_frame_type)
                 framelist->frame_type[pos];
     if (size)
@@ -384 +384 @@
 /* Remove oldest frames as many as param 'count' */
 static unsigned jb_framelist_remove_head(jb_framelist_t *framelist,
-                                         unsigned count) 
-{
-    if (count > framelist->size) 
+                                         unsigned count)
+{
+    if (count > framelist->size)
         count = framelist->size;
 
@@ -410 +410 @@
         }
 
-        //pj_bzero(framelist->content + 
+        //pj_bzero(framelist->content +
         //          framelist->head * framelist->frame_size,
         //          step1*framelist->frame_size);
@@ -440 +440 @@
         framelist->size -= count;
     }
-    
+
     return count;
 }
@@ -549 +549 @@
 
 
-PJ_DEF(pj_status_t) pjmedia_jbuf_create(pj_pool_t *pool, 
+PJ_DEF(pj_status_t) pjmedia_jbuf_create(pj_pool_t *pool,
                                         const pj_str_t *name,
-                                        unsigned frame_size, 
+                                        unsigned frame_size,
                                         unsigned ptime,
                                         unsigned max_count,
@@ -597 +597 @@
     PJ_ASSERT_RETURN(prefetch <= jb->jb_max_count, PJ_EINVAL);
 
-    jb->jb_min_prefetch = jb->jb_max_prefetch = 
+    jb->jb_min_prefetch = jb->jb_max_prefetch =
         jb->jb_prefetch = jb->jb_init_prefetch = prefetch;
 
@@ -676 +676 @@
                "  burst (min/max/avg/dev)=%d/%d/%d/%d frames\n"
                "  lost=%d discard=%d empty=%d",
-               jb_framelist_size(&jb->jb_framelist), 
-               jb_framelist_eff_size(&jb->jb_framelist), 
+               jb_framelist_size(&jb->jb_framelist),
+               jb_framelist_eff_size(&jb->jb_framelist),
                jb->jb_prefetch, jb->jb_eff_level,
-               jb->jb_delay.min, jb->jb_delay.max, jb->jb_delay.mean, 
+               jb->jb_delay.min, jb->jb_delay.max, jb->jb_delay.mean,
                pj_math_stat_get_stddev(&jb->jb_delay),
-               jb->jb_burst.min, jb->jb_burst.max, jb->jb_burst.mean, 
+               jb->jb_burst.min, jb->jb_burst.max, jb->jb_burst.mean,
                pj_math_stat_get_stddev(&jb->jb_burst),
                jb->jb_lost, jb->jb_discard, jb->jb_empty));
@@ -705 +705 @@
 
         enum { STABLE_HISTORY_LIMIT = 20 };
-        
+
         jb->jb_stable_hist++;
-        
-        /* Only update the effective level (and prefetch) if 'stable' 
+
+        /* Only update the effective level (and prefetch) if 'stable'
          * condition is reached (not just short time impulse)
          */
         if (jb->jb_stable_hist > STABLE_HISTORY_LIMIT) {
-        
+
             diff = (jb->jb_eff_level - jb->jb_max_hist_level) / 3;
 
@@ -724 +724 @@
             if (jb->jb_init_prefetch) {
                 jb->jb_prefetch = jb->jb_eff_level;
-                if (jb->jb_prefetch < jb->jb_min_prefetch) 
+                if (jb->jb_prefetch < jb->jb_min_prefetch)
                     jb->jb_prefetch = jb->jb_min_prefetch;
                 if (jb->jb_prefetch > jb->jb_max_prefetch)
@@ -736 +736 @@
             TRACE__((jb->jb_name.ptr,"jb updated(1), lvl=%d pre=%d, size=%d",
                      jb->jb_eff_level, jb->jb_prefetch, cur_size));
+            PJ_UNUSED_ARG(cur_size); /* Warning about unused var */
         }
     }
@@ -759 +760 @@
         //jb->jb_max_hist_level = 0;
 
-        TRACE__((jb->jb_name.ptr,"jb updated(2), lvl=%d pre=%d, size=%d", 
+        TRACE__((jb->jb_name.ptr,"jb updated(2), lvl=%d pre=%d, size=%d",
                  jb->jb_eff_level, jb->jb_prefetch, cur_size));
     }
@@ -778 +779 @@
      *
      * Moreover, normally drift level is quite low, so JB shouldn't need
-     * to shrink aggresively, it will shrink maximum one frame per 
-     * PJMEDIA_JBUF_DISC_MIN_GAP ms. Theoritically, JB may handle drift level 
+     * to shrink aggresively, it will shrink maximum one frame per
+     * PJMEDIA_JBUF_DISC_MIN_GAP ms. Theoritically, JB may handle drift level
      * as much as = FRAME_PTIME/PJMEDIA_JBUF_DISC_MIN_GAP * 100%
      *
-     * Whenever there is drift, where PUT > GET, this method will keep 
+     * Whenever there is drift, where PUT > GET, this method will keep
      * the latency (JB size) as much as twice of burst level.
      */
@@ -797 +798 @@
         int seq_origin;
 
-        /* Check and adjust jb_discard_ref, in case there was 
-         * seq restart 
+        /* Check and adjust jb_discard_ref, in case there was
+         * seq restart
          */
         seq_origin = jb_framelist_origin(&jb->jb_framelist);
@@ -814 +815 @@
             jb->jb_discard += diff;
 
-            TRACE__((jb->jb_name.ptr, 
+            TRACE__((jb->jb_name.ptr,
                      "JB shrinking %d frame(s), cur size=%d", diff,
                      jb_framelist_eff_size(&jb->jb_framelist)));
@@ -846 +847 @@
         T = PJMEDIA_JBUF_PRO_DISC_T2;
     else
-        T = PJMEDIA_JBUF_PRO_DISC_T1 + 
+        T = PJMEDIA_JBUF_PRO_DISC_T1 +
             (PJMEDIA_JBUF_PRO_DISC_T2 - PJMEDIA_JBUF_PRO_DISC_T1) *
             (burst_level - PJMEDIA_JBUF_PRO_DISC_MIN_BURST) /
@@ -874 +875 @@
     if (last_seq >= (jb->jb_discard_ref + (int)jb->jb_discard_dist)) {
         int discard_seq;
-        
+
         discard_seq = jb->jb_discard_ref + jb->jb_discard_dist;
         if (discard_seq < jb_framelist_origin(&jb->jb_framelist))
@@ -881 +882 @@
         jb_framelist_discard(&jb->jb_framelist, discard_seq);
 
-        TRACE__((jb->jb_name.ptr, 
+        TRACE__((jb->jb_name.ptr,
                 "Discard #%d: ref=#%d dist=%d orig=%d size=%d/%d "
                 "burst=%d/%d",
@@ -897 +898 @@
     }
 }
-    
+
 
 PJ_INLINE(void) jbuf_update(pjmedia_jbuf *jb, int oper)
@@ -905 +906 @@
 
         if (jb->jb_status == JB_STATUS_INITIALIZING) {
-            /* Switch status 'initializing' -> 'processing' after some OP 
-             * switch cycles and current OP is GET (burst level is calculated 
+            /* Switch status 'initializing' -> 'processing' after some OP
+             * switch cycles and current OP is GET (burst level is calculated
              * based on PUT burst), so burst calculation is guaranted to be
              * performed right after the status switching.
@@ -922 +923 @@
         }
 
-        /* Perform jitter calculation based on PUT burst-level only, since 
+        /* Perform jitter calculation based on PUT burst-level only, since
          * GET burst-level may not be accurate, e.g: when VAD is active.
          * Note that when burst-level is too big, i.e: exceeds jb_max_burst,
-         * the GET op may be idle, in this case, we better skip the jitter 
+         * the GET op may be idle, in this case, we better skip the jitter
          * calculation.
          */
@@ -940 +941 @@
 }
 
-PJ_DEF(void) pjmedia_jbuf_put_frame( pjmedia_jbuf *jb, 
-                                     const void *frame, 
-                                     pj_size_t frame_size, 
+PJ_DEF(void) pjmedia_jbuf_put_frame( pjmedia_jbuf *jb,
+                                     const void *frame,
+                                     pj_size_t frame_size,
                                      int frame_seq)
 {
@@ -948 +949 @@
 }
 
-PJ_DEF(void) pjmedia_jbuf_put_frame2(pjmedia_jbuf *jb, 
-                                     const void *frame, 
-                                     pj_size_t frame_size, 
+PJ_DEF(void) pjmedia_jbuf_put_frame2(pjmedia_jbuf *jb,
+                                     const void *frame,
+                                     pj_size_t frame_size,
                                      pj_uint32_t bit_info,
                                      int frame_seq,
                                      pj_bool_t *discarded)
 {
-    pjmedia_jbuf_put_frame3(jb, frame, frame_size, bit_info, frame_seq, 0, 
+    pjmedia_jbuf_put_frame3(jb, frame, frame_size, bit_info, frame_seq, 0,
                             discarded);
 }
 
-PJ_DEF(void) pjmedia_jbuf_put_frame3(pjmedia_jbuf *jb, 
-                                     const void *frame, 
-                                     pj_size_t frame_size, 
+PJ_DEF(void) pjmedia_jbuf_put_frame3(pjmedia_jbuf *jb,
+                                     const void *frame,
+                                     pj_size_t frame_size,
                                      pj_uint32_t bit_info,
                                      int frame_seq,
@@ -978 +979 @@
                                  (unsigned)min_frame_size, bit_info, ts,
                                  PJMEDIA_JB_NORMAL_FRAME);
-    
+
     /* Jitter buffer is full, remove some older frames */
     while (status == PJ_ETOOMANY) {
@@ -1010 +1011 @@
     if (status == PJ_SUCCESS) {
         if (jb->jb_prefetching) {
-            TRACE__((jb->jb_name.ptr, "PUT prefetch_cnt=%d/%d", 
+            TRACE__((jb->jb_name.ptr, "PUT prefetch_cnt=%d/%d",
                      new_size, jb->jb_prefetch));
             if (new_size >= jb->jb_prefetch)
@@ -1024 +1025 @@
  * Get frame from jitter buffer.
  */
-PJ_DEF(void) pjmedia_jbuf_get_frame( pjmedia_jbuf *jb, 
-                                     void *frame, 
+PJ_DEF(void) pjmedia_jbuf_get_frame( pjmedia_jbuf *jb,
+                                     void *frame,
                                      char *p_frame_type)
 {
@@ -1035 +1036 @@
  * Get frame from jitter buffer.
  */
-PJ_DEF(void) pjmedia_jbuf_get_frame2(pjmedia_jbuf *jb, 
-                                     void *frame, 
+PJ_DEF(void) pjmedia_jbuf_get_frame2(pjmedia_jbuf *jb,
+                                     void *frame,
                                      pj_size_t *size,
                                      char *p_frame_type,
@@ -1048 +1049 @@
  * Get frame from jitter buffer.
  */
-PJ_DEF(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb, 
-                                     void *frame, 
+PJ_DEF(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb,
+                                     void *frame,
                                      pj_size_t *size,
                                      char *p_frame_type,
@@ -1078 +1079 @@
 
         /* Try to retrieve a frame from frame list */
-        res = jb_framelist_get(&jb->jb_framelist, frame, size, &ftype, 
+        res = jb_framelist_get(&jb->jb_framelist, frame, size, &ftype,
                                bit_info, ts, seq);
         if (res) {
@@ -1097 +1098 @@
                 /* We've just retrieved one frame, so add one to cur_size */
                 cur_size = jb_framelist_eff_size(&jb->jb_framelist) + 1;
-                pj_math_stat_update(&jb->jb_delay, 
+                pj_math_stat_update(&jb->jb_delay,
                                     cur_size*jb->jb_frame_ptime);
             }
@@ -1129 +1130 @@
     state->min_prefetch = jb->jb_min_prefetch;
     state->max_prefetch = jb->jb_max_prefetch;
-    
+
     state->burst = jb->jb_eff_level;
     state->prefetch = jb->jb_prefetch;
     state->size = jb_framelist_eff_size(&jb->jb_framelist);
-    
+
     state->avg_delay = jb->jb_delay.mean;
     state->min_delay = jb->jb_delay.min;
     state->max_delay = jb->jb_delay.max;
     state->dev_delay = pj_math_stat_get_stddev(&jb->jb_delay);
-    
+
     state->avg_burst = jb->jb_burst.mean;
     state->empty = jb->jb_empty;
@@ -1150 +1151 @@
 PJ_DEF(void) pjmedia_jbuf_peek_frame( pjmedia_jbuf *jb,
                                       unsigned offset,
-                                      const void **frame, 
-                                      pj_size_t *size, 
+                                      const void **frame,
+                                      pj_size_t *size,
                                       char *p_frm_type,
                                       pj_uint32_t *bit_info,
@@ -1171 +1172 @@
 
 
-PJ_DEF(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb, 
+PJ_DEF(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb,
                                            unsigned frame_cnt)
 {

pjproject/trunk/pjmedia/src/pjmedia/stream.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <pjmedia/stream.h>
@@ -185 +185 @@
      */
     pj_bool_t                has_g722_mpeg_bug;
-                                            /**< Flag to specify whether 
-                                                 normalization process 
+                                            /**< Flag to specify whether
+                                                 normalization process
                                                  is needed                  */
     unsigned                 rtp_tx_ts_len_per_pkt;
                                             /**< Normalized ts length per packet
-                                                 transmitted according to 
+                                                 transmitted according to
                                                  'erroneous' definition     */
     unsigned                 rtp_rx_ts_len_per_frame;
                                             /**< Normalized ts length per frame
-                                                 received according to 
+                                                 received according to
                                                  'erroneous' definition     */
     unsigned                 rtp_rx_last_cnt;/**< Nb of frames in last pkt  */
@@ -203 +203 @@
 
 #if defined(PJMEDIA_HAS_RTCP_XR) && (PJMEDIA_HAS_RTCP_XR != 0)
-    pj_uint32_t              rtcp_xr_last_tx;  /**< RTCP XR tx time 
+    pj_uint32_t              rtcp_xr_last_tx;  /**< RTCP XR tx time
                                                     in timestamp.           */
     pj_uint32_t              rtcp_xr_interval; /**< Interval, in timestamp. */
-    pj_sockaddr              rtcp_xr_dest;     /**< Additional remote RTCP XR 
-                                                    dest. If sin_family is 
+    pj_sockaddr              rtcp_xr_dest;     /**< Additional remote RTCP XR
+                                                    dest. If sin_family is
                                                     zero, it will be ignored*/
     unsigned                 rtcp_xr_dest_len; /**< Length of RTCP XR dest
@@ -231 +231 @@
 
 /* RFC 2833 digit */
-static const char digitmap[16] = { '0', '1', '2', '3', 
-                                   '4', '5', '6', '7', 
+static const char digitmap[16] = { '0', '1', '2', '3',
+                                   '4', '5', '6', '7',
                                    '8', '9', '*', '#',
                                    'A', 'B', 'C', 'D'};
@@ -285 +285 @@
 }
 
-PJ_INLINE(int) trace_jb_print_state(pjmedia_stream *stream, 
+PJ_INLINE(int) trace_jb_print_state(pjmedia_stream *stream,
                                     char **buf, pj_ssize_t len)
 {
@@ -460 +460 @@
 
 #else
-    
+
     PJ_UNUSED_ARG(stream);
 
@@ -498 +498 @@
     samples_per_frame = stream->codec_param.info.frm_ptime *
                         stream->codec_param.info.clock_rate *
-                        stream->codec_param.info.channel_cnt / 
+                        stream->codec_param.info.channel_cnt /
                         1000;
     p_out_samp = (pj_int16_t*) frame->buf;
 
-    for (samples_count=0; samples_count < samples_required; 
-         samples_count += samples_per_frame) 
+    for (samples_count=0; samples_count < samples_required;
+         samples_count += samples_per_frame)
     {
         char frame_type;
@@ -518 +518 @@
 
         if (frame_type == PJMEDIA_JB_MISSING_FRAME) {
-            
+
             /* Activate PLC */
-            if (stream->codec->op->recover && 
+            if (stream->codec->op->recover &&
                 stream->codec_param.setting.plc &&
-                stream->plc_cnt < stream->max_plc_cnt) 
+                stream->plc_cnt < stream->max_plc_cnt)
             {
                 pjmedia_frame frame_out;
@@ -561 +561 @@
             /* Jitter buffer is empty. If this is the first "empty" state,
              * activate PLC to smoothen the fade-out, otherwise zero
-             * the frame. 
+             * the frame.
              */
             //Using this "if" will only invoke PLC for the first packet
@@ -568 +568 @@
             if (1) {
                 /* Activate PLC to smoothen the missing frame */
-                if (stream->codec->op->recover && 
+                if (stream->codec->op->recover &&
                     stream->codec_param.setting.plc &&
-                    stream->plc_cnt < stream->max_plc_cnt) 
+                    stream->plc_cnt < stream->max_plc_cnt)
                 {
                     pjmedia_frame frame_out;
@@ -590 +590 @@
 
                     with_plc = ", plc invoked";
-                } 
+                }
             }
 
@@ -604 +604 @@
                 /* Report changing frame type event */
                 pjmedia_jbuf_get_state(stream->jb, &jb_state);
-                PJ_LOG(5,(stream->port.info.name.ptr, 
-                          "Jitter buffer empty (prefetch=%d)%s", 
+                PJ_LOG(5,(stream->port.info.name.ptr,
+                          "Jitter buffer empty (prefetch=%d)%s",
                           jb_state.prefetch, with_plc));
 
@@ -623 +623 @@
 
             /* Always activate PLC when it's available.. */
-            if (stream->codec->op->recover && 
+            if (stream->codec->op->recover &&
                 stream->codec_param.setting.plc &&
-                stream->plc_cnt < stream->max_plc_cnt) 
+                stream->plc_cnt < stream->max_plc_cnt)
             {
                 pjmedia_frame frame_out;
@@ -645 +645 @@
 
                 with_plc = ", plc invoked";
-            } 
+            }
 
             if (samples_count < samples_required) {
@@ -658 +658 @@
                 /* Report changing frame type event */
                 pjmedia_jbuf_get_state(stream->jb, &jb_state);
-                PJ_LOG(5,(stream->port.info.name.ptr, 
-                          "Jitter buffer is bufferring (prefetch=%d)%s", 
+                PJ_LOG(5,(stream->port.info.name.ptr,
+                          "Jitter buffer is bufferring (prefetch=%d)%s",
                           jb_state.prefetch, with_plc));
 
@@ -684 +684 @@
             frame_out.size = frame->size - samples_count*BYTES_PER_SAMPLE;
             status = pjmedia_codec_decode( stream->codec, &frame_in,
-                                           (unsigned)frame_out.size, 
+                                           (unsigned)frame_out.size,
                                            &frame_out);
             if (status != 0) {
-                LOGERR_((port->info.name.ptr, "codec decode() error", 
+                LOGERR_((port->info.name.ptr, "codec decode() error",
                          status));
 
-                pjmedia_zero_samples(p_out_samp + samples_count, 
+                pjmedia_zero_samples(p_out_samp + samples_count,
                                      samples_per_frame);
             }
@@ -696 +696 @@
             if (stream->jb_last_frm != frame_type) {
                 /* Report changing frame type event */
-                PJ_LOG(5,(stream->port.info.name.ptr, 
+                PJ_LOG(5,(stream->port.info.name.ptr,
                           "Jitter buffer starts returning normal frames "
                           "(after %d empty/lost)",
@@ -753 +753 @@
     samples_per_frame = stream->codec_param.info.frm_ptime *
                         stream->codec_param.info.clock_rate *
-                        stream->codec_param.info.channel_cnt / 
+                        stream->codec_param.info.channel_cnt /
                         1000;
 
@@ -774 +774 @@
         trace_jb_get(stream, frame_type, frame_size);
 #endif
-        
+
         /* Unlock jitter buffer mutex. */
         pj_mutex_unlock( stream->jb_mutex );
@@ -791 +791 @@
                                            0, frame);
             if (status != PJ_SUCCESS) {
-                LOGERR_((port->info.name.ptr, "codec decode() error", 
+                LOGERR_((port->info.name.ptr, "codec decode() error",
                          status));
                 pjmedia_frame_ext_append_subframe(f, NULL, 0,
@@ -799 +799 @@
             if (stream->jb_last_frm != frame_type) {
                 /* Report changing frame type event */
-                PJ_LOG(5,(stream->port.info.name.ptr, 
+                PJ_LOG(5,(stream->port.info.name.ptr,
                           "Jitter buffer starts returning normal frames "
                           "(after %d empty/lost)",
@@ -817 +817 @@
                 status = pjmedia_codec_recover(stream->codec, 0, frame);
             }
-            
+
             /* No PLC or PLC failed */
             if (!stream->codec->op->recover || status != PJ_SUCCESS) {
@@ -840 +840 @@
                     /* Report changing frame type event */
                     pjmedia_jbuf_get_state(stream->jb, &jb_state);
-                    PJ_LOG(5,(stream->port.info.name.ptr, 
-                              "Jitter buffer empty (prefetch=%d)", 
+                    PJ_LOG(5,(stream->port.info.name.ptr,
+                              "Jitter buffer empty (prefetch=%d)",
                               jb_state.prefetch));
 
@@ -859 +859 @@
                     /* Report changing frame type event */
                     pjmedia_jbuf_get_state(stream->jb, &jb_state);
-                    PJ_LOG(5,(stream->port.info.name.ptr, 
+                    PJ_LOG(5,(stream->port.info.name.ptr,
                               "Jitter buffer is bufferring (prefetch=%d)",
                               jb_state.prefetch));
@@ -879 +879 @@
  * Transmit DTMF
  */
-static void create_dtmf_payload(pjmedia_stream *stream, 
+static void create_dtmf_payload(pjmedia_stream *stream,
                                 struct pjmedia_frame *frame_out,
                                 int forced_last, int *first, int *last)
@@ -885 +885 @@
     pjmedia_rtp_dtmf_event *event;
     struct dtmf *digit = &stream->tx_dtmf_buf[0];
-    pj_uint32_t cur_ts;
 
     pj_assert(sizeof(pjmedia_rtp_dtmf_event) == 4);
@@ -892 +891 @@
 
     event = (pjmedia_rtp_dtmf_event*) frame_out->buf;
-    cur_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts);
 
     if (digit->duration == 0) {
-        PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c", 
+        PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c",
                   digitmap[digit->event]));
         *first = 1;
@@ -988 +986 @@
         /* Update RTCP XR with current JB states */
         pjmedia_jbuf_get_state(stream->jb, &jb_state);
-            
+
         i = jb_state.avg_delay;
-        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                              PJMEDIA_RTCP_XR_INFO_JB_NOM, i);
         pj_assert(status == PJ_SUCCESS);
 
         i = jb_state.max_delay;
-        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        status = pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                              PJMEDIA_RTCP_XR_INFO_JB_MAX, i);
         pj_assert(status == PJ_SUCCESS);
@@ -1008 +1006 @@
             /* Send the RTCP XR to third-party destination if specified */
             if (stream->rtcp_xr_dest_len) {
-                pjmedia_transport_send_rtcp2(stream->transport, 
+                pjmedia_transport_send_rtcp2(stream->transport,
                                              &stream->rtcp_xr_dest,
-                                             stream->rtcp_xr_dest_len, 
+                                             stream->rtcp_xr_dest_len,
                                              xr_pkt, xr_len);
             }
@@ -1050 +1048 @@
 static void check_tx_rtcp(pjmedia_stream *stream, pj_uint32_t timestamp)
 {
-    /* Note that timestamp may represent local or remote timestamp, 
+    /* Note that timestamp may represent local or remote timestamp,
      * depending on whether this function is called from put_frame()
      * or get_frame().
@@ -1056 +1054 @@
 
     if (stream->rtcp_last_tx == 0) {
-        
+
         stream->rtcp_last_tx = timestamp;
 
@@ -1067 +1065 @@
             if (stream->rtcp_xr_last_tx == 0) {
                 stream->rtcp_xr_last_tx = timestamp;
-            } else if (timestamp - stream->rtcp_xr_last_tx >= 
+            } else if (timestamp - stream->rtcp_xr_last_tx >=
                        stream->rtcp_xr_interval)
             {
@@ -1131 +1129 @@
 
     /* How many samples are needed */
-    count = stream->codec_param.info.enc_ptime * 
+    count = stream->codec_param.info.enc_ptime *
             PJMEDIA_PIA_SRATE(&stream->port.info) / 1000;
 
@@ -1154 +1152 @@
  * put_frame_imp()
  */
-static pj_status_t put_frame_imp( pjmedia_port *port, 
+static pj_status_t put_frame_imp( pjmedia_port *port,
                                   pjmedia_frame *frame )
 {
@@ -1175 +1173 @@
         pj_uint32_t dtx_duration;
 
-        dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent, 
+        dtx_duration = pj_timestamp_diff32(&stream->last_frm_ts_sent,
                                            &frame->timestamp);
         if (dtx_duration >
@@ -1194 +1192 @@
     /* Number of samples in the frame */
     if (frame->type == PJMEDIA_FRAME_TYPE_AUDIO)
-        ts_len = ((unsigned)frame->size >> 1) / 
+        ts_len = ((unsigned)frame->size >> 1) /
                  stream->codec_param.info.channel_cnt;
     else if (frame->type == PJMEDIA_FRAME_TYPE_EXTENDED)
@@ -1206 +1204 @@
 
 #if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG!=0)
-    /* Handle special case for audio codec with RTP timestamp inconsistence 
+    /* Handle special case for audio codec with RTP timestamp inconsistence
      * e.g: G722, MPEG audio.
      */
@@ -1225 +1223 @@
 
 
-    /* If we have DTMF digits in the queue, transmit the digits. 
+    /* If we have DTMF digits in the queue, transmit the digits.
      * Otherwise encode the PCM buffer.
      */
@@ -1235 +1233 @@
         /* Encapsulate into RTP packet. Note that:
          *  - RTP marker should be set on the beginning of a new event
-         *  - RTP timestamp is constant for the same packet. 
+         *  - RTP timestamp is constant for the same packet.
          */
-        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
-                                         stream->tx_event_pt, first, 
+        status = pjmedia_rtp_encode_rtp( &channel->rtp,
+                                         stream->tx_event_pt, first,
                                          (int)frame_out.size,
-                                         (first ? rtp_ts_len : 0), 
-                                         (const void**)&rtphdr, 
+                                         (first ? rtp_ts_len : 0),
+                                         (const void**)&rtphdr,
                                          &rtphdrlen);
 
         if (last) {
-            /* This is the last packet for the event. 
+            /* This is the last packet for the event.
              * Increment the RTP timestamp of the RTP session, for next
              * RTP packets.
@@ -1272 +1270 @@
                stream->codec_param.info.channel_cnt *
                stream->codec_param.info.clock_rate/1000 <
-                  PJ_ARRAY_SIZE(zero_frame)) 
+                  PJ_ARRAY_SIZE(zero_frame))
     {
         pjmedia_frame silence_frame;
@@ -1283 +1281 @@
         silence_frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
         silence_frame.timestamp.u32.lo = pj_ntohl(stream->enc->rtp.out_hdr.ts);
-        
+
         /* Encode! */
         status = pjmedia_codec_encode( stream->codec, &silence_frame,
-                                       channel->out_pkt_size - 
+                                       channel->out_pkt_size -
                                        sizeof(pjmedia_rtp_hdr),
                                        &frame_out);
         if (status != PJ_SUCCESS) {
-            LOGERR_((stream->port.info.name.ptr, 
+            LOGERR_((stream->port.info.name.ptr,
                     "Codec encode() error", status));
             return status;
@@ -1296 +1294 @@
 
         /* Encapsulate. */
-        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
-                                         channel->pt, 0, 
-                                         (int)frame_out.size, rtp_ts_len, 
-                                         (const void**)&rtphdr, 
+        status = pjmedia_rtp_encode_rtp( &channel->rtp,
+                                         channel->pt, 0,
+                                         (int)frame_out.size, rtp_ts_len,
+                                         (const void**)&rtphdr,
                                          &rtphdrlen);
 
@@ -1309 +1307 @@
     {
         /* Encode! */
-        status = pjmedia_codec_encode( stream->codec, frame, 
-                                       channel->out_pkt_size - 
+        status = pjmedia_codec_encode( stream->codec, frame,
+                                       channel->out_pkt_size -
                                        sizeof(pjmedia_rtp_hdr),
                                        &frame_out);
         if (status != PJ_SUCCESS) {
-            LOGERR_((stream->port.info.name.ptr, 
+            LOGERR_((stream->port.info.name.ptr,
                     "Codec encode() error", status));
             return status;
@@ -1320 +1318 @@
 
         /* Encapsulate. */
-        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
-                                         channel->pt, 0, 
-                                         (int)frame_out.size, rtp_ts_len, 
-                                         (const void**)&rtphdr, 
+        status = pjmedia_rtp_encode_rtp( &channel->rtp,
+                                         channel->pt, 0,
+                                         (int)frame_out.size, rtp_ts_len,
+                                         (const void**)&rtphdr,
                                          &rtphdrlen);
 
@@ -1329 +1327 @@
 
         /* Just update RTP session's timestamp. */
-        status = pjmedia_rtp_encode_rtp( &channel->rtp, 
-                                         0, 0, 
-                                         0, rtp_ts_len, 
-                                         (const void**)&rtphdr, 
+        status = pjmedia_rtp_encode_rtp( &channel->rtp,
+                                         0, 0,
+                                         0, rtp_ts_len,
+                                         (const void**)&rtphdr,
                                          &rtphdrlen);
 
@@ -1338 +1336 @@
 
     if (status != PJ_SUCCESS) {
-        LOGERR_((stream->port.info.name.ptr, 
+        LOGERR_((stream->port.info.name.ptr,
                 "RTP encode_rtp() error", status));
         return status;
     }
 
-    /* Check if now is the time to transmit RTCP SR/RR report. 
+    /* Check if now is the time to transmit RTCP SR/RR report.
      * We only do this when stream direction is not "decoding only", because
      * when it is, check_tx_rtcp() will be handled by get_frame().
@@ -1414 +1412 @@
  * RTP packet, and transmit to peer.
  */
-static pj_status_t put_frame( pjmedia_port *port, 
+static pj_status_t put_frame( pjmedia_port *port,
                               pjmedia_frame *frame )
 {
@@ -1462 +1460 @@
      */
     if (stream->vad_enabled != stream->codec_param.setting.vad &&
-        (stream->tx_duration - stream->ts_vad_disabled) > 
+        (stream->tx_duration - stream->ts_vad_disabled) >
            PJMEDIA_PIA_SRATE(&stream->port.info) *
           PJMEDIA_STREAM_VAD_SUSPEND_MSEC / 1000)
@@ -1479 +1477 @@
         pj_status_t status = PJ_SUCCESS;
 
-        /* Copy original frame to temporary frame since we need 
+        /* Copy original frame to temporary frame since we need
          * to modify it.
          */
@@ -1546 +1544 @@
  * Handle incoming DTMF digits.
  */
-static void handle_incoming_dtmf( pjmedia_stream *stream, 
+static void handle_incoming_dtmf( pjmedia_stream *stream,
                                   const void *payload, unsigned payloadlen)
 {
@@ -1572 +1570 @@
     /* Ignore unknown event. */
     if (event->event > 15) {
-        PJ_LOG(5,(stream->port.info.name.ptr, 
+        PJ_LOG(5,(stream->port.info.name.ptr,
                   "Ignored RTP pkt with bad DTMF event %d",
                   event->event));
@@ -1591 +1589 @@
     if (stream->dtmf_cb) {
 
-        stream->dtmf_cb(stream, stream->dtmf_cb_user_data, 
+        stream->dtmf_cb(stream, stream->dtmf_cb_user_data,
                         digitmap[event->event]);
 
@@ -1601 +1599 @@
         if (stream->rx_dtmf_count >= PJ_ARRAY_SIZE(stream->rx_dtmf_buf)) {
             /* DTMF digits overflow.  Discard the oldest digit. */
-            pj_array_erase(stream->rx_dtmf_buf, 
+            pj_array_erase(stream->rx_dtmf_buf,
                            sizeof(stream->rx_dtmf_buf[0]),
                            stream->rx_dtmf_count, 0);
@@ -1614 +1612 @@
 /*
  * This callback is called by stream transport on receipt of packets
- * in the RTP socket. 
- */
-static void on_rx_rtp( void *data, 
+ * in the RTP socket.
+ */
+static void on_rx_rtp( void *data,
                        void *pkt,
                        pj_ssize_t bytes_read)
@@ -1632 +1630 @@
     /* Check for errors */
     if (bytes_read < 0) {
-        LOGERR_((stream->port.info.name.ptr, "RTP recv() error", 
+        LOGERR_((stream->port.info.name.ptr, "RTP recv() error",
                 (pj_status_t)-bytes_read));
         return;
@@ -1660 +1658 @@
                                 hdr->pt != stream->rx_event_pt);
     if (seq_st.status.value) {
-        TRC_  ((stream->port.info.name.ptr, 
+        TRC_  ((stream->port.info.name.ptr,
                 "RTP status: badpt=%d, badssrc=%d, dup=%d, "
-                "outorder=%d, probation=%d, restart=%d", 
+                "outorder=%d, probation=%d, restart=%d",
                 seq_st.status.flag.badpt,
                 seq_st.status.flag.badssrc,
@@ -1737 +1735 @@
                                      payloadlen, &ts, &count, frames);
         if (status != PJ_SUCCESS) {
-            LOGERR_((stream->port.info.name.ptr, 
-                     "Codec parse() error", 
+            LOGERR_((stream->port.info.name.ptr,
+                     "Codec parse() error",
                      status));
             count = 0;
@@ -1746 +1744 @@
         /* This code is used to learn the samples per frame value that is put
          * by remote endpoint, for codecs with inconsistent clock rate such
-         * as G.722 or MPEG audio. We need to learn the samples per frame 
+         * as G.722 or MPEG audio. We need to learn the samples per frame
          * value as it is used as divider when inserting frames into the
          * jitter buffer.
@@ -1752 +1750 @@
         if (stream->has_g722_mpeg_bug) {
             if (stream->rtp_rx_check_cnt) {
-                /* Make sure the detection performed only on two consecutive 
+                /* Make sure the detection performed only on two consecutive
                  * packets with valid RTP sequence and no wrapped timestamp.
                  */
-                if (seq_st.diff == 1 && stream->rtp_rx_last_ts && 
-                    ts.u64 > stream->rtp_rx_last_ts && 
+                if (seq_st.diff == 1 && stream->rtp_rx_last_ts &&
+                    ts.u64 > stream->rtp_rx_last_ts &&
                     stream->rtp_rx_last_cnt > 0)
                 {
@@ -1768 +1766 @@
 
                     /* Get remote frame timestamp span */
-                    peer_frm_ts_diff = 
-                        ((pj_uint32_t)ts.u64-stream->rtp_rx_last_ts) / 
+                    peer_frm_ts_diff =
+                        ((pj_uint32_t)ts.u64-stream->rtp_rx_last_ts) /
                         stream->rtp_rx_last_cnt;
 
@@ -1778 +1776 @@
                      */
                     if (stream->codec_param.info.pt == PJMEDIA_RTP_PT_G722 &&
-                        (peer_frm_ts_diff == frm_ts_span || 
+                        (peer_frm_ts_diff == frm_ts_span ||
                          peer_frm_ts_diff == (frm_ts_span>>1)))
                     {
@@ -1790 +1788 @@
                         if (--stream->rtp_rx_check_cnt == 0) {
                             PJ_LOG(4, (THIS_FILE, "G722 codec used, remote"
-                                       " samples per frame detected = %d", 
+                                       " samples per frame detected = %d",
                                        stream->rtp_rx_ts_len_per_frame));
-                            
+
                             /* Reset jitter buffer once detection done */
                             pjmedia_jbuf_reset(stream->jb);
@@ -1811 +1809 @@
 
         } else {
-            ts_span = stream->codec_param.info.frm_ptime * 
+            ts_span = stream->codec_param.info.frm_ptime *
                       stream->codec_param.info.clock_rate /
                       1000;
         }
 #else
-        ts_span = stream->codec_param.info.frm_ptime * 
+        ts_span = stream->codec_param.info.frm_ptime *
                   stream->codec_param.info.clock_rate /
                   1000;
@@ -1842 +1840 @@
 
     /* Check if now is the time to transmit RTCP SR/RR report.
-     * We only do this when stream direction is "decoding only", 
+     * We only do this when stream direction is "decoding only",
      * because otherwise check_tx_rtcp() will be handled by put_frame()
      */
@@ -1850 +1848 @@
 
     if (status != 0) {
-        LOGERR_((stream->port.info.name.ptr, "Jitter buffer put() error", 
+        LOGERR_((stream->port.info.name.ptr, "Jitter buffer put() error",
                 status));
         pkt_discarded = PJ_TRUE;
@@ -1880 +1878 @@
 /*
  * This callback is called by stream transport on receipt of packets
- * in the RTCP socket. 
+ * in the RTCP socket.
  */
 static void on_rx_rtcp( void *data,
-                        void *pkt, 
+                        void *pkt,
                         pj_ssize_t bytes_read)
 {
@@ -1890 +1888 @@
     /* Check for errors */
     if (bytes_read < 0) {
-        LOGERR_((stream->port.info.name.ptr, "RTCP recv() error", 
+        LOGERR_((stream->port.info.name.ptr, "RTCP recv() error",
                 (pj_status_t)-bytes_read));
         return;
@@ -1911 +1909 @@
     pjmedia_channel *channel;
     pj_status_t status;
-    
+
     /* Allocate memory for channel descriptor */
 
@@ -1924 +1922 @@
     channel->pt = pt;
 
-    
+
     /* Allocate buffer for outgoing packet. */
 
     if (param->type == PJMEDIA_TYPE_AUDIO) {
-        channel->out_pkt_size = sizeof(pjmedia_rtp_hdr) + 
-                                stream->codec_param.info.max_bps * 
-                                PJMEDIA_MAX_FRAME_DURATION_MS / 
+        channel->out_pkt_size = sizeof(pjmedia_rtp_hdr) +
+                                stream->codec_param.info.max_bps *
+                                PJMEDIA_MAX_FRAME_DURATION_MS /
                                 8 / 1000;
         if (channel->out_pkt_size > PJMEDIA_MAX_MTU -
@@ -2078 +2076 @@
         stream->codec_param = *info->param;
     else {
-        status = pjmedia_codec_mgr_get_default_param(stream->codec_mgr, 
-                                                     &info->fmt, 
+        status = pjmedia_codec_mgr_get_default_param(stream->codec_mgr,
+                                                     &info->fmt,
                                                      &stream->codec_param);
         if (status != PJ_SUCCESS)
@@ -2137 +2135 @@
     /* If encoder and decoder's ptime are asymmetric, then we need to
      * create buffer on the encoder side. This could happen for example
-     * with iLBC 
+     * with iLBC
      */
     if (stream->codec_param.info.enc_ptime!=0 &&
@@ -2185 +2183 @@
         stream->frame_size = stream->codec_param.info.max_rx_frame_size;
     } else {
-        stream->frame_size = stream->codec_param.info.max_bps * 
+        stream->frame_size = stream->codec_param.info.max_bps *
                              stream->codec_param.info.frm_ptime / 8 / 1000;
         if ((stream->codec_param.info.max_bps *
@@ -2218 +2216 @@
     /* Init jitter buffer parameters: */
     if (info->jb_max >= stream->codec_param.info.frm_ptime)
-        jb_max = (info->jb_max + stream->codec_param.info.frm_ptime - 1) / 
+        jb_max = (info->jb_max + stream->codec_param.info.frm_ptime - 1) /
                  stream->codec_param.info.frm_ptime;
     else
@@ -2243 +2241 @@
     /* Create jitter buffer */
     status = pjmedia_jbuf_create(pool, &stream->port.info.name,
-                                 stream->frame_size, 
+                                 stream->frame_size,
                                  stream->codec_param.info.frm_ptime,
                                  jb_max, &stream->jb);
@@ -2255 +2253 @@
     /* Create decoder channel: */
 
-    status = create_channel( pool, stream, PJMEDIA_DIR_DECODING, 
+    status = create_channel( pool, stream, PJMEDIA_DIR_DECODING,
                              info->rx_pt, info, &stream->dec);
     if (status != PJ_SUCCESS)
@@ -2263 +2261 @@
     /* Create encoder channel: */
 
-    status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING, 
+    status = create_channel( pool, stream, PJMEDIA_DIR_ENCODING,
                              info->tx_pt, info, &stream->enc);
     if (status != PJ_SUCCESS)
@@ -2316 +2314 @@
 
     /* Only attach transport when stream is ready. */
-    status = pjmedia_transport_attach(tp, stream, &info->rem_addr, 
-                                      &info->rem_rtcp, 
-                                      pj_sockaddr_get_len(&info->rem_addr), 
+    status = pjmedia_transport_attach(tp, stream, &info->rem_addr,
+                                      &info->rem_rtcp,
+                                      pj_sockaddr_get_len(&info->rem_addr),
                                       &on_rx_rtp, &on_rx_rtcp);
     if (status != PJ_SUCCESS)
@@ -2336 +2334 @@
             stream->rtcp_xr_interval = info->rtcp_xr_interval;
         else
-            stream->rtcp_xr_interval = (PJMEDIA_RTCP_INTERVAL + 
-                                       (pj_rand() % 8000)) * 
+            stream->rtcp_xr_interval = (PJMEDIA_RTCP_INTERVAL +
+                                       (pj_rand() % 8000)) *
                                        info->fmt.clock_rate / 1000;
 
@@ -2349 +2347 @@
         /* jitter buffer adaptive info */
         i = PJMEDIA_RTCP_XR_JB_ADAPTIVE;
-        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                     PJMEDIA_RTCP_XR_INFO_CONF_JBA,
                                     i);
@@ -2355 +2353 @@
         /* Jitter buffer aggressiveness info (estimated) */
         i = 7;
-        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                     PJMEDIA_RTCP_XR_INFO_CONF_JBR,
                                     i);
@@ -2361 +2359 @@
         /* Jitter buffer absolute maximum delay */
         i = jb_max * stream->codec_param.info.frm_ptime;
-        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                     PJMEDIA_RTCP_XR_INFO_JB_ABS_MAX,
                                     i);
@@ -2374 +2372 @@
             i = PJMEDIA_RTCP_XR_PLC_DIS;
 #endif
-        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session, 
+        pjmedia_rtcp_xr_update_info(&stream->rtcp.xr_session,
                                     PJMEDIA_RTCP_XR_INFO_CONF_PLC,
                                     i);
@@ -2396 +2394 @@
         pj_ssize_t len;
 
-        pj_ansi_snprintf(trace_name, sizeof(trace_name), 
+        pj_ansi_snprintf(trace_name, sizeof(trace_name),
                          TRACE_JB_PATH_PREFIX "%s.csv",
                          stream->port.info.name.ptr);
@@ -2402 +2400 @@
         if (status != PJ_SUCCESS) {
             stream->trace_jb_fd = TRACE_JB_INVALID_FD;
-            PJ_LOG(3,(THIS_FILE, "Failed creating RTP trace file '%s'", 
+            PJ_LOG(3,(THIS_FILE, "Failed creating RTP trace file '%s'",
                       trace_name));
         } else {
@@ -2490 +2488 @@
     }
 
-    /* Detach from transport 
+    /* Detach from transport
      * MUST NOT hold stream mutex while detaching from transport, as
      * it may cause deadlock. See ticket #460 for the details.
@@ -2513 +2511 @@
 
     /* Free mutex */
-    
+
     if (stream->jb_mutex) {
         pj_mutex_destroy(stream->jb_mutex);
@@ -2724 +2722 @@
         return PJMEDIA_RTP_EREMNORFC2833;
     }
-    
+
     pj_mutex_lock(stream->jb_mutex);
-    
+
     if (stream->tx_dtmf_count+digit_char->slen >=
         (long)PJ_ARRAY_SIZE(stream->tx_dtmf_buf))
@@ -2735 +2733 @@
 
         /* convert ASCII digits into payload type first, to make sure
-         * that all digits are valid. 
+         * that all digits are valid.
          */
         for (i=0; i<digit_char->slen; ++i) {
@@ -2744 +2742 @@
             {
                 pt = dig - '0';
-            } 
+            }
             else if (dig >= 'a' && dig <= 'd')
             {
@@ -2830 +2828 @@
  */
 PJ_DEF(pj_status_t) pjmedia_stream_set_dtmf_callback(pjmedia_stream *stream,
-                                 void (*cb)(pjmedia_stream*, 
-                                            void *user_data, 
-                                            int digit), 
+                                 void (*cb)(pjmedia_stream*,
+                                            void *user_data,
+                                            int digit),
                                  void *user_data)
 {

pjproject/trunk/pjmedia/src/pjmedia/transport_srtp.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
@@ -46 +46 @@
 #define MAX_KEY_LEN                 128
 
-/* Initial value of probation counter. When probation counter > 0, 
+/* Initial value of probation counter. When probation counter > 0,
  * it means SRTP is in probation state, and it may restart when
  * srtp_unprotect() returns err_status_replay_*
@@ -77 +77 @@
 
     /* cipher AES_CM, auth HMAC_SHA1, auth tag len = 10 octets */
-    {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10, 
+    {"AES_CM_128_HMAC_SHA1_80", AES_128_ICM, 30, HMAC_SHA1, 20, 10, 10,
         sec_serv_conf_and_auth},
 
@@ -84 +84 @@
         sec_serv_conf_and_auth},
 
-    /* 
+    /*
      * F8_128_HMAC_SHA1_8 not supported by libsrtp?
      * {"F8_128_HMAC_SHA1_8", NULL_CIPHER, 0, NULL_AUTH, 0, 0, 0, sec_serv_none}
@@ -125 +125 @@
                                    void *pkt,
                                    pj_ssize_t size);
-        
+
     /* Transport information */
     pjmedia_transport   *member_tp; /**< Underlying transport.       */
@@ -131 +131 @@
     /* SRTP usage policy of peer. This field is updated when media is starting.
      * This is useful when SRTP is in optional mode and peer is using mandatory
-     * mode, so when local is about to reinvite/update, it should offer 
+     * mode, so when local is about to reinvite/update, it should offer
      * RTP/SAVP instead of offering RTP/AVP.
      */
     pjmedia_srtp_use     peer_use;
 
-    /* When probation counter > 0, it means SRTP is in probation state, 
+    /* When probation counter > 0, it means SRTP is in probation state,
      * and it may restart when srtp_unprotect() returns err_status_replay_*
      */
@@ -206 +206 @@
 
 
-static pjmedia_transport_op transport_srtp_op = 
+static pjmedia_transport_op transport_srtp_op =
 {
     &transport_get_info,
@@ -239 +239 @@
         "couldn't deallocate properly",     /* err_status_dealloc_fail  = 4  */
         "couldn't initialize",              /* err_status_init_fail     = 5  */
-        "can't process as much data as requested", 
+        "can't process as much data as requested",
                                             /* err_status_terminus      = 6  */
         "authentication failure",           /* err_status_auth_fail     = 7  */
         "cipher failure",                   /* err_status_cipher_fail   = 8  */
         "replay check failed (bad index)",  /* err_status_replay_fail   = 9  */
-        "replay check failed (index too old)", 
+        "replay check failed (index too old)",
                                             /* err_status_replay_old    = 10 */
         "algorithm failed test routine",    /* err_status_algo_fail     = 11 */
         "unsupported operation",            /* err_status_no_such_op    = 12 */
         "no appropriate context found",     /* err_status_no_ctx        = 13 */
-        "unable to perform desired validation", 
+        "unable to perform desired validation",
                                             /* err_status_cant_check    = 14 */
         "can't use key any more",           /* err_status_key_expired   = 15 */
@@ -286 +286 @@
 
         err = srtp_init();
-        if (err != err_status_ok) { 
-            PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s", 
+        if (err != err_status_ok) {
+            PJ_LOG(4, (THIS_FILE, "Failed to initialize libsrtp: %s",
                        get_libsrtp_errstr(err)));
             return PJMEDIA_ERRNO_FROM_LIBSRTP(err);
@@ -294 +294 @@
         if (pjmedia_endpt_atexit(endpt, pjmedia_srtp_deinit_lib) != PJ_SUCCESS)
         {
-            /* There will be memory leak when it fails to schedule libsrtp 
+            /* There will be memory leak when it fails to schedule libsrtp
              * deinitialization, however the memory leak could be harmless,
-             * since in modern OS's memory used by an application is released 
+             * since in modern OS's memory used by an application is released
              * when the application terminates.
              */
@@ -307 +307 @@
     PJ_UNUSED_ARG(endpt);
 #endif
-    
+
     return PJ_SUCCESS;
 }
@@ -338 +338 @@
 #endif
     if (err != err_status_ok) {
-        PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s", 
+        PJ_LOG(4, (THIS_FILE, "Failed to deinitialize libsrtp: %s",
                    get_libsrtp_errstr(err)));
     }
@@ -350 +350 @@
     int i;
     int cs_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]);
-    
+
     /* treat unspecified crypto_name as crypto 'NULL' */
     if (crypto_name->slen == 0)
@@ -421 +421 @@
 
     /* Check crypto availability */
-    if (opt && opt->crypto_count == 0 && 
+    if (opt && opt->crypto_count == 0 &&
         opt->use == PJMEDIA_SRTP_MANDATORY)
         return PJMEDIA_SRTP_ESDPREQCRYPTO;
@@ -435 +435 @@
 
             /* check key length */
-            if (opt->crypto[i].key.slen && 
-                opt->crypto[i].key.slen < 
+            if (opt->crypto[i].key.slen &&
+                opt->crypto[i].key.slen <
                 (pj_ssize_t)crypto_suites[cs_idx].cipher_key_len)
                 return PJMEDIA_SRTP_EINKEYLEN;
@@ -506 +506 @@
  */
 PJ_DEF(pj_status_t) pjmedia_transport_srtp_start(
-                           pjmedia_transport *tp, 
+                           pjmedia_transport *tp,
                            const pjmedia_srtp_crypto *tx,
                            const pjmedia_srtp_crypto *rx)
@@ -518 +518 @@
     int              cr_rx_idx = 0;
     int              au_rx_idx = 0;
-    int              crypto_suites_cnt;
     pj_status_t      status = PJ_SUCCESS;
 
@@ -528 +527 @@
         pjmedia_transport_srtp_stop(tp);
     }
-
-    crypto_suites_cnt = sizeof(crypto_suites)/sizeof(crypto_suites[0]);
 
     /* Get encryption and authentication method */
@@ -545 +542 @@
 
     /* Check whether the crypto-suite requested is supported */
-    if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 || 
+    if (cr_tx_idx == -1 || cr_rx_idx == -1 || au_tx_idx == -1 ||
         au_rx_idx == -1)
     {
@@ -648 +645 @@
         else
             b64[b64_len] = '\0';
-        
+
         PJ_LOG(5, (srtp->pool->obj_name, "TX: %s key=%s",
                    srtp->tx_policy.name.ptr, b64));
@@ -700 +697 @@
     err = srtp_dealloc(p_srtp->srtp_rx_ctx);
     if (err != err_status_ok) {
-        PJ_LOG(4, (p_srtp->pool->obj_name, 
+        PJ_LOG(4, (p_srtp->pool->obj_name,
                    "Failed to dealloc RX SRTP context: %s",
                    get_libsrtp_errstr(err)));
@@ -706 +703 @@
     err = srtp_dealloc(p_srtp->srtp_tx_ctx);
     if (err != err_status_ok) {
-        PJ_LOG(4, (p_srtp->pool->obj_name, 
+        PJ_LOG(4, (p_srtp->pool->obj_name,
                    "Failed to dealloc TX SRTP context: %s",
                    get_libsrtp_errstr(err)));
@@ -753 +750 @@
     info->spc_info[spc_info_idx].type = PJMEDIA_TRANSPORT_TYPE_SRTP;
     info->spc_info[spc_info_idx].cbsize = sizeof(srtp_info);
-    pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info, 
+    pj_memcpy(&info->spc_info[spc_info_idx].buffer, &srtp_info,
               sizeof(srtp_info));
 
@@ -782 +779 @@
 
     /* Attach itself to transport */
-    status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr, 
+    status = pjmedia_transport_attach(srtp->member_tp, srtp, rem_addr,
                                       rem_rtcp, addr_len, &srtp_rtp_cb,
                                       &srtp_rtcp_cb);
@@ -842 +839 @@
 
     if (err == err_status_ok) {
-        status = pjmedia_transport_send_rtp(srtp->member_tp, 
+        status = pjmedia_transport_send_rtp(srtp->member_tp,
                                             srtp->rtp_tx_buffer, len);
     } else {
         status = PJMEDIA_ERRNO_FROM_LIBSRTP(err);
     }
-    
+
     return status;
 }
@@ -870 +867 @@
 
     if (srtp->bypass_srtp) {
-        return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len, 
+        return pjmedia_transport_send_rtcp2(srtp->member_tp, addr, addr_len,
                                             pkt, size);
     }
@@ -903 +900 @@
 {
     transport_srtp *srtp = (transport_srtp *) tp;
-    
+
     PJ_ASSERT_RETURN(tp, PJ_EINVAL);
 
@@ -965 +962 @@
     }
     err = srtp_unprotect(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len);
-    if (srtp->probation_cnt > 0 && 
-        (err == err_status_replay_old || err == err_status_replay_fail)) 
+    if (srtp->probation_cnt > 0 &&
+        (err == err_status_replay_old || err == err_status_replay_fail))
     {
         /* Handle such condition that stream is updated (RTP seq is reinited
-         * & SRTP is restarted), but some old packets are still coming 
+         * & SRTP is restarted), but some old packets are still coming
          * so SRTP is learning wrong RTP seq. While the newly inited RTP seq
-         * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect() 
+         * comes, SRTP thinks the RTP seq is replayed, so srtp_unprotect()
          * will return err_status_replay_*. Restarting SRTP can resolve this.
          */
@@ -982 +979 @@
                                               &tx, &rx);
         if (status != PJ_SUCCESS) {
-            PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s", 
+            PJ_LOG(5,(srtp->pool->obj_name, "Failed to restart SRTP, err=%s",
                       get_libsrtp_errstr(err)));
         } else if (!srtp->bypass_srtp) {
@@ -990 +987 @@
 
     if (err != err_status_ok) {
-        PJ_LOG(5,(srtp->pool->obj_name, 
-                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
+        PJ_LOG(5,(srtp->pool->obj_name,
+                  "Failed to unprotect SRTP, pkt size=%d, err=%s",
                   size, get_libsrtp_errstr(err)));
     } else {
@@ -1036 +1033 @@
     err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, (pj_uint8_t*)pkt, &len);
     if (err != err_status_ok) {
-        PJ_LOG(5,(srtp->pool->obj_name, 
+        PJ_LOG(5,(srtp->pool->obj_name,
                   "Failed to unprotect SRTCP, pkt size=%d, err=%s",
                   size, get_libsrtp_errstr(err)));
@@ -1056 +1053 @@
  */
 static pj_status_t generate_crypto_attr_value(pj_pool_t *pool,
-                                              char *buffer, int *buffer_len, 
+                                              char *buffer, int *buffer_len,
                                               pjmedia_srtp_crypto *crypto,
                                               int tag)
@@ -1088 +1085 @@
             key_ok = PJ_TRUE;
 
-            err = crypto_get_random((unsigned char*)key, 
+            err = crypto_get_random((unsigned char*)key,
                                      crypto_suites[cs_idx].cipher_key_len);
             if (err != err_status_ok) {
@@ -1100 +1097 @@
         } while (!key_ok);
         crypto->key.ptr = (char*)
-                          pj_pool_zalloc(pool, 
+                          pj_pool_zalloc(pool,
                                          crypto_suites[cs_idx].cipher_key_len);
         pj_memcpy(crypto->key.ptr, key, crypto_suites[cs_idx].cipher_key_len);
@@ -1118 +1115 @@
 
     b64_key[b64_key_len] = '\0';
-    
+
     PJ_ASSERT_RETURN(*buffer_len >= (crypto->name.slen + \
                      b64_key_len + 16), PJ_ETOOSMALL);
@@ -1124 +1121 @@
     /* Print the crypto attribute value. */
     print_len = pj_ansi_snprintf(buffer, *buffer_len, "%d %s inline:%s",
-                                   tag, 
+                                   tag,
                                    crypto_suites[cs_idx].name,
                                    b64_key);
@@ -1206 +1203 @@
     crypto->key.ptr = (char*) pj_pool_zalloc(pool, MAX_KEY_LEN);
     itmp = MAX_KEY_LEN;
-    status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr, 
+    status = pj_base64_decode(&tmp, (pj_uint8_t*)crypto->key.ptr,
                               &itmp);
     if (status != PJ_SUCCESS) {
@@ -1227 +1224 @@
 
     PJ_ASSERT_RETURN(tp, PJ_EINVAL);
-    
+
     pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg));
     pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg));
@@ -1275 +1272 @@
 
 PROPAGATE_MEDIA_CREATE:
-    return pjmedia_transport_media_create(srtp->member_tp, sdp_pool, 
+    return pjmedia_transport_media_create(srtp->member_tp, sdp_pool,
                                           member_tp_option, sdp_remote,
                                           media_index);
@@ -1297 +1294 @@
 
     PJ_ASSERT_RETURN(tp && sdp_pool && sdp_local, PJ_EINVAL);
-    
+
     pj_bzero(&srtp->rx_policy_neg, sizeof(srtp->rx_policy_neg));
     pj_bzero(&srtp->tx_policy_neg, sizeof(srtp->tx_policy_neg));
@@ -1307 +1304 @@
 
     /* Bypass if media transport is not RTP/AVP or RTP/SAVP */
-    if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 && 
+    if (pj_stricmp(&m_loc->desc.transport, &ID_RTP_AVP)  != 0 &&
         pj_stricmp(&m_loc->desc.transport, &ID_RTP_SAVP) != 0)
         goto BYPASS_SRTP;
@@ -1318 +1315 @@
      */
     /*
-    if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) || 
+    if (pjmedia_sdp_media_find_attr(m_loc, &ID_INACTIVE, NULL) ||
         (m_rem && pjmedia_sdp_media_find_attr(m_rem, &ID_INACTIVE, NULL)))
         goto BYPASS_SRTP;
     */
 
-    /* Check remote media transport & set local media transport 
+    /* Check remote media transport & set local media transport
      * based on SRTP usage option.
      */
@@ -1333 +1330 @@
                 goto BYPASS_SRTP;
             case PJMEDIA_SRTP_OPTIONAL:
-                m_loc->desc.transport = 
+                m_loc->desc.transport =
                                 (srtp->peer_use == PJMEDIA_SRTP_MANDATORY)?
                                 ID_RTP_SAVP : ID_RTP_AVP;
@@ -1356 +1353 @@
                 if (buffer_len) {
                     pj_strset(&attr_value, buffer, buffer_len);
-                    attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr, 
+                    attr = pjmedia_sdp_attr_create(srtp->pool, ID_CRYPTO.ptr,
                                                    &attr_value);
                     m_loc->attr[m_loc->attr_count++] = attr;
@@ -1401 +1398 @@
                 has_crypto_attr = PJ_TRUE;
 
-                status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
+                status = parse_attr_crypto(srtp->pool, m_rem->attr[i],
                                            &tmp_rx_crypto, &tags[cr_attr_count]);
                 if (status != PJ_SUCCESS)
                     return status;
-         
+
                 /* Check duplicated tag */
                 for (j=0; j<cr_attr_count; ++j) {
@@ -1417 +1414 @@
                     /* lets see if the crypto-suite offered is supported */
                     for (j=0; j<srtp->setting.crypto_count; ++j)
-                        if (pj_stricmp(&tmp_rx_crypto.name, 
+                        if (pj_stricmp(&tmp_rx_crypto.name,
                                        &srtp->setting.crypto[j].name) == 0)
                         {
@@ -1434 +1431 @@
                             //          hex_test_key,
                             //          strlen(hex_test_key));
-                            //pj_strset(test_key, raw_test_key, 
+                            //pj_strset(test_key, raw_test_key,
                             //    crypto_suites[cs_idx].cipher_key_len);
                             /* EO Force to use test key */
 
-                            if (tmp_rx_crypto.key.slen != 
+                            if (tmp_rx_crypto.key.slen !=
                                 (int)crypto_suites[cs_idx].cipher_key_len)
                                 return PJMEDIA_SRTP_EINKEYLEN;
@@ -1459 +1456 @@
                 case PJMEDIA_SRTP_OPTIONAL:
                     /* bypass SRTP when no crypto-attr and remote uses RTP/AVP */
-                    if (!has_crypto_attr && 
+                    if (!has_crypto_attr &&
                         pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0)
                         goto BYPASS_SRTP;
                     /* bypass SRTP when nothing match and remote uses RTP/AVP */
-                    else if (matched_idx == -1 && 
+                    else if (matched_idx == -1 &&
                         pj_stricmp(&m_rem->desc.transport, &ID_RTP_AVP) == 0)
                         goto BYPASS_SRTP;
@@ -1485 +1482 @@
             }
 
-            /* we have to generate crypto answer, 
+            /* we have to generate crypto answer,
              * with srtp->tx_policy_neg matched the offer
              * and rem_tag contains matched offer tag.
@@ -1497 +1494 @@
 
             srtp->tx_policy_neg = srtp->setting.crypto[matched_idx];
-            
+
             /* If buffer_len==0, just skip the crypto attribute. */
             if (buffer_len) {
                 pj_strset(&attr_value, buffer, buffer_len);
-                attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr, 
+                attr = pjmedia_sdp_attr_create(sdp_pool, ID_CRYPTO.ptr,
                                                &attr_value);
                 m_loc->attr[m_loc->attr_count++] = attr;
@@ -1508 +1505 @@
             /* At this point, we get valid rx_policy_neg & tx_policy_neg. */
         }
-            
+
     }
     goto PROPAGATE_MEDIA_CREATE;
@@ -1519 +1516 @@
 
 PROPAGATE_MEDIA_CREATE:
-    return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool, 
+    return pjmedia_transport_encode_sdp(srtp->member_tp, sdp_pool,
                                         sdp_local, sdp_remote, media_index);
 }
@@ -1548 +1545 @@
     /* For answerer side, this function will just have to start SRTP */
 
-    /* Check remote media transport & set local media transport 
+    /* Check remote media transport & set local media transport
      * based on SRTP usage option.
      */
@@ -1561 +1558 @@
             // Regardless the answer's transport type (RTP/AVP or RTP/SAVP),
             // the answer must be processed through in optional mode.
-            // Please note that at this point transport type is ensured to be 
+            // Please note that at this point transport type is ensured to be
             // RTP/AVP or RTP/SAVP, see transport_media_create()
             //if (pj_stricmp(&m_rem->desc.transport, &m_loc->desc.transport)) {
@@ -1574 +1571 @@
         }
     }
-    
+
     if (srtp->offerer_side) {
         /* find supported crypto-suite, get the tag, and assign policy_local */
@@ -1593 +1590 @@
             has_crypto_attr = PJ_TRUE;
 
-            status = parse_attr_crypto(srtp->pool, m_rem->attr[i], 
+            status = parse_attr_crypto(srtp->pool, m_rem->attr[i],
                                        &tmp_tx_crypto, &rem_tag);
             if (status != PJ_SUCCESS)
@@ -1606 +1603 @@
 
             /* match the crypto name */
-            if (pj_stricmp(&tmp_tx_crypto.name, 
+            if (pj_stricmp(&tmp_tx_crypto.name,
                 &srtp->setting.crypto[rem_tag-1].name) != 0)
             {
@@ -1634 +1631 @@
 
     /* Make sure we have the SRTP policies */
-    if (srtp_crypto_empty(&srtp->tx_policy_neg) || 
+    if (srtp_crypto_empty(&srtp->tx_policy_neg) ||
         srtp_crypto_empty(&srtp->rx_policy_neg))
     {
@@ -1671 +1668 @@
 
 PROPAGATE_MEDIA_START:
-    return pjmedia_transport_media_start(srtp->member_tp, pool, 
+    return pjmedia_transport_media_start(srtp->member_tp, pool,
                                          sdp_local, sdp_remote,
                                          media_index);
@@ -1685 +1682 @@
     status = pjmedia_transport_media_stop(srtp->member_tp);
     if (status != PJ_SUCCESS)
-        PJ_LOG(4, (srtp->pool->obj_name, 
+        PJ_LOG(4, (srtp->pool->obj_name,
                    "SRTP failed stop underlying media transport."));
 
@@ -1720 +1717 @@
     else
         err = srtp_unprotect_rtcp(srtp->srtp_rx_ctx, pkt, pkt_len);
-    
+
     if (err != err_status_ok) {
-        PJ_LOG(5,(srtp->pool->obj_name, 
-                  "Failed to unprotect SRTP, pkt size=%d, err=%s", 
+        PJ_LOG(5,(srtp->pool->obj_name,
+                  "Failed to unprotect SRTP, pkt size=%d, err=%s",
                   *pkt_len, get_libsrtp_errstr(err)));
     }

pjproject/trunk/pjmedia/src/test/jbuf_test.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <stdio.h>
@@ -48 +48 @@
 } test_cond_t;
 
-static pj_bool_t parse_test_headers(char *line, test_param_t *param, 
+static pj_bool_t parse_test_headers(char *line, test_param_t *param,
                                test_cond_t *cond)
 {
@@ -57 +57 @@
         char mode_st[16];
 
-        sscanf(p+1, "%s %u %u %u", mode_st, &param->init_prefetch, 
+        sscanf(p+1, "%s %u %u %u", mode_st, &param->init_prefetch,
                &param->min_prefetch, &param->max_prefetch);
         param->adaptive = (pj_ansi_stricmp(mode_st, "adaptive") == 0);
@@ -103 +103 @@
 }
 
-static pj_bool_t process_test_data(char data, pjmedia_jbuf *jb, 
+static pj_bool_t process_test_data(char data, pjmedia_jbuf *jb,
                                    pj_uint16_t *seq, pj_uint16_t *last_seq)
 {
@@ -156 +156 @@
 
         pjmedia_jbuf_get_state(jb, &state);
-        printf("seq=%d\t%c\tsize=%d\tprefetch=%d\n", 
+        printf("seq=%d\t%c\tsize=%d\tprefetch=%d\n",
                *last_seq, toupper(data), state.size, state.prefetch);
     }
+#else
+    PJ_UNUSED_ARG(print_state); /* Warning about variable set but unused */
 #endif
 
@@ -171 +173 @@
     int rc = 0;
     const char* input_filename = "Jbtest.dat";
-    const char* input_search_path[] = { 
+    const char* input_search_path[] = {
         "../build",
         "pjmedia/build",
@@ -192 +194 @@
         }
     }
-    
+
     /* Failed to open test data file. */
     if (input == NULL) {
@@ -245 +247 @@
 
         if (param.adaptive) {
-            pjmedia_jbuf_set_adaptive(jb, 
-                                      param.init_prefetch, 
+            pjmedia_jbuf_set_adaptive(jb,
+                                      param.init_prefetch,
                                       param.min_prefetch,
                                       param.max_prefetch);
@@ -255 +257 @@
 #ifdef REPORT
         pjmedia_jbuf_get_state(jb, &state);
-        printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n", 
-               state.size, state.prefetch, state.min_prefetch, 
+        printf("Initial\tsize=%d\tprefetch=%d\tmin.pftch=%d\tmax.pftch=%d\n",
+               state.size, state.prefetch, state.min_prefetch,
                state.max_prefetch);
 #endif
@@ -264 +266 @@
         while (1) {
             char c;
-            
+
             /* Get next line of test data */
             if (!p || *p == 0) {
@@ -302 +304 @@
         printf("  size=%d prefetch=%d\n", state.size, state.prefetch);
         printf("  delay (min/max/avg/dev)=%d/%d/%d/%d ms\n",
-               state.min_delay, state.max_delay, state.avg_delay, 
+               state.min_delay, state.max_delay, state.avg_delay,
                state.dev_delay);
-        printf("  lost=%d discard=%d empty=%d burst(avg)=%d\n", 
+        printf("  lost=%d discard=%d empty=%d burst(avg)=%d\n",
                state.lost, state.discard, state.empty, state.avg_burst);
 
         /* Evaluate test session */
         if (cond.burst >= 0 && (int)state.avg_burst > cond.burst) {
-            printf("! 'Burst' should be %d, it is %d\n", 
+            printf("! 'Burst' should be %d, it is %d\n",
                    cond.burst, state.avg_burst);
             rc |= 1;
         }
         if (cond.delay >= 0 && (int)state.avg_delay/JB_PTIME > cond.delay) {
-            printf("! 'Delay' should be %d, it is %d\n", 
+            printf("! 'Delay' should be %d, it is %d\n",
                    cond.delay, state.avg_delay/JB_PTIME);
             rc |= 2;
         }
         if (cond.delay_min >= 0 && (int)state.min_delay/JB_PTIME > cond.delay_min) {
-            printf("! 'Minimum delay' should be %d, it is %d\n", 
+            printf("! 'Minimum delay' should be %d, it is %d\n",
                    cond.delay_min, state.min_delay/JB_PTIME);
             rc |= 32;
@@ -329 +331 @@
         }
         if (cond.empty >= 0 && (int)state.empty > cond.empty) {
-            printf("! 'Empty' should be %d, it is %d\n", 
+            printf("! 'Empty' should be %d, it is %d\n",
                    cond.empty, state.empty);
             rc |= 8;
         }
         if (cond.lost >= 0 && (int)state.lost > cond.lost) {
-            printf("! 'Lost' should be %d, it is %d\n", 
+            printf("! 'Lost' should be %d, it is %d\n",
                    cond.lost, state.lost);
             rc |= 16;

pjproject/trunk/pjnath/src/pjnath-test/ice_test.c

@@ -1 +1 @@
 /* $Id$ */
-/* 
+/*
  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
@@ -16 +16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "test.h"
@@ -113 +113 @@
 
 static void ice_on_rx_data(pj_ice_strans *ice_st,
-                           unsigned comp_id, 
+                           unsigned comp_id,
                            void *pkt, pj_size_t size,
                            const pj_sockaddr_t *src_addr,
                            unsigned src_addr_len);
-static void ice_on_ice_complete(pj_ice_strans *ice_st, 
+static void ice_on_ice_complete(pj_ice_strans *ice_st,
                                 pj_ice_strans_op op,
                                 pj_status_t status);
@@ -202 +202 @@
     return PJ_SUCCESS;
 }
-                             
+
 /* Create test session */
 static int create_sess(pj_stun_config *stun_cfg,
@@ -239 +239 @@
         return -10;
     }
-    sess->server->turn_respond_allocate = 
+    sess->server->turn_respond_allocate =
         sess->server->turn_respond_refresh = PJ_TRUE;
 
@@ -319 +319 @@
 
 static void ice_on_rx_data(pj_ice_strans *ice_st,
-                           unsigned comp_id, 
+                           unsigned comp_id,
                            void *pkt, pj_size_t size,
                            const pj_sockaddr_t *src_addr,
@@ -336 +336 @@
 
 
-static void ice_on_ice_complete(pj_ice_strans *ice_st, 
+static void ice_on_ice_complete(pj_ice_strans *ice_st,
                                 pj_ice_strans_op op,
                                 pj_status_t status)
@@ -437 +437 @@
     for (; i<max_cnt; ++i) {
         if (ept1->cfg.comp_cnt>i &&
-            pj_ice_strans_get_valid_pair(ept1->ice, i+1) != NULL) 
+            pj_ice_strans_get_valid_pair(ept1->ice, i+1) != NULL)
         {
             PJ_LOG(3,(THIS_FILE, INDENT "err: ice1 shouldn't have valid pair "
@@ -444 +444 @@
         }
         if (ept2->cfg.comp_cnt>i &&
-            pj_ice_strans_get_valid_pair(ept2->ice, i+1) != NULL) 
+            pj_ice_strans_get_valid_pair(ept2->ice, i+1) != NULL)
         {
             PJ_LOG(3,(THIS_FILE, INDENT "err: ice2 shouldn't have valid pair "
@@ -464 +464 @@
                                     pj_gettimeofday(&t); \
                                     if (expr) { \
-                                        rc = PJ_SUCCESS; \