Ignore:
Timestamp:
Jan 20, 2010 1:02:37 AM (12 years ago)
Author:
nanang
Message:

Ticket #969:

  • implemented progressive discard algorithm, discard rate is calculated from ratio of effective size to effective burst level.
  • updated jbuf to clarify prefetch and burst level distinction, previously they are stored in same var, i.e: prefetch, while the semantic is actually different.
  • updated STABLE_HISTORY_LIMIT in jbuf, it is now 20 (was 100), to adjust burst level faster.
  • added test case of periodic-spike-burst-case in jbtest.dat for testing the new algorithm.
  • updated stream to limit the rate of jbuf empty/lost log messages, it will only log first empty/lost event, then log again once jbuf returning normal frame (also counter of previous empty/lost frames).
  • minor updates on jbuf.c: variable names, logs, added burst to jbuf state.
  • minor updates on jbuf_test.c: handle comment in test session header, seq jump is now 20 (was 5000).
File:
1 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjmedia/src/pjmedia/stream.c

    r3061 r3065  
    121121    pjmedia_jbuf            *jb;            /**< Jitter buffer.             */ 
    122122    char                     jb_last_frm;   /**< Last frame type from jb    */ 
     123    unsigned                 jb_last_frm_cnt;/**< Last JB frame type counter*/ 
    123124 
    124125    pjmedia_rtcp_session     rtcp;          /**< RTCP for incoming RTP.     */ 
     
    326327                pjmedia_zero_samples(p_out_samp + samples_count, 
    327328                                     samples_required - samples_count); 
    328                 PJ_LOG(5,(stream->port.info.name.ptr,  "Frame lost!")); 
    329  
     329            } 
     330 
     331            if (frame_type != stream->jb_last_frm) { 
     332                /* Report changing frame type event */ 
     333                PJ_LOG(5,(stream->port.info.name.ptr, "Frame lost%s!", 
     334                          (status == PJ_SUCCESS? ", recovered":""))); 
     335 
     336                stream->jb_last_frm = frame_type; 
     337                stream->jb_last_frm_cnt = 1; 
    330338            } else { 
    331                 PJ_LOG(5,(stream->port.info.name.ptr,  
    332                           "Lost frame recovered")); 
     339                stream->jb_last_frm_cnt++; 
    333340            } 
    334341 
    335342        } else if (frame_type == PJMEDIA_JB_ZERO_EMPTY_FRAME) { 
     343 
     344            const char *with_plc = ""; 
    336345 
    337346            /* Jitter buffer is empty. If this is the first "empty" state, 
     
    343352            //if (frame_type != stream->jb_last_frm) { 
    344353            if (1) { 
    345                 pjmedia_jb_state jb_state; 
    346                 const char *with_plc = ""; 
    347  
    348354                /* Activate PLC to smoothen the missing frame */ 
    349355                if (stream->codec->op->recover &&  
     
    370376                    with_plc = ", plc invoked"; 
    371377                }  
    372  
    373                 /* Report the state of jitter buffer */ 
    374                 pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    375                 PJ_LOG(5,(stream->port.info.name.ptr,  
    376                           "Jitter buffer empty (prefetch=%d)%s",  
    377                           jb_state.prefetch, with_plc)); 
    378  
    379378            } 
    380379 
     
    385384            } 
    386385 
    387             stream->jb_last_frm = frame_type; 
     386            if (stream->jb_last_frm != frame_type) { 
     387                pjmedia_jb_state jb_state; 
     388 
     389                /* Report changing frame type event */ 
     390                pjmedia_jbuf_get_state(stream->jb, &jb_state); 
     391                PJ_LOG(5,(stream->port.info.name.ptr,  
     392                          "Jitter buffer empty (prefetch=%d)%s",  
     393                          jb_state.prefetch, with_plc)); 
     394 
     395                stream->jb_last_frm = frame_type; 
     396                stream->jb_last_frm_cnt = 1; 
     397            } else { 
     398                stream->jb_last_frm_cnt++; 
     399            } 
    388400            break; 
    389401 
    390402        } else if (frame_type != PJMEDIA_JB_NORMAL_FRAME) { 
    391403 
    392             pjmedia_jb_state jb_state; 
     404            const char *with_plc = ""; 
    393405 
    394406            /* It can only be PJMEDIA_JB_ZERO_PREFETCH frame */ 
    395407            pj_assert(frame_type == PJMEDIA_JB_ZERO_PREFETCH_FRAME); 
    396  
    397             /* Get the state of jitter buffer */ 
    398             pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    399408 
    400409            /* Always activate PLC when it's available.. */ 
     
    420429                         stream->plc_cnt < stream->max_plc_cnt); 
    421430 
    422                 //if (stream->jb_last_frm != frame_type) { 
    423                 if (1) { 
    424                     PJ_LOG(5,(stream->port.info.name.ptr,  
    425                               "Jitter buffer is bufferring with plc (prefetch=%d)", 
    426                               jb_state.prefetch)); 
    427                 } 
    428  
     431                with_plc = ", plc invoked"; 
    429432            }  
    430433 
     
    433436                                     samples_required - samples_count); 
    434437                samples_count = samples_required; 
     438            } 
     439 
     440            if (stream->jb_last_frm != frame_type) { 
     441                pjmedia_jb_state jb_state; 
     442 
     443                /* Report changing frame type event */ 
     444                pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    435445                PJ_LOG(5,(stream->port.info.name.ptr,  
    436                           "Jitter buffer is bufferring (prefetch=%d)..",  
    437                           jb_state.prefetch)); 
     446                          "Jitter buffer is bufferring (prefetch=%d)%s",  
     447                          jb_state.prefetch, with_plc)); 
     448 
     449                stream->jb_last_frm = frame_type; 
     450                stream->jb_last_frm_cnt = 1; 
     451            } else { 
     452                stream->jb_last_frm_cnt++; 
    438453            } 
    439  
    440             stream->jb_last_frm = frame_type; 
    441454            break; 
    442455 
     
    464477                                     samples_per_frame); 
    465478            } 
     479 
     480            if (stream->jb_last_frm != frame_type) { 
     481                /* Report changing frame type event */ 
     482                PJ_LOG(5,(stream->port.info.name.ptr,  
     483                          "Jitter buffer starts returning normal frames " 
     484                          "(after %d empty/lost)", 
     485                          stream->jb_last_frm_cnt, stream->jb_last_frm)); 
     486 
     487                stream->jb_last_frm = frame_type; 
     488                stream->jb_last_frm_cnt = 1; 
     489            } else { 
     490                stream->jb_last_frm_cnt++; 
     491            } 
    466492        } 
    467  
    468         stream->jb_last_frm = frame_type; 
    469493    } 
    470494 
     
    552576                                            (pj_uint16_t)samples_per_frame); 
    553577            } 
     578 
     579            if (stream->jb_last_frm != frame_type) { 
     580                /* Report changing frame type event */ 
     581                PJ_LOG(5,(stream->port.info.name.ptr,  
     582                          "Jitter buffer starts returning normal frames " 
     583                          "(after %d empty/lost)", 
     584                          stream->jb_last_frm_cnt, stream->jb_last_frm)); 
     585 
     586                stream->jb_last_frm = frame_type; 
     587                stream->jb_last_frm_cnt = 1; 
     588            } else { 
     589                stream->jb_last_frm_cnt++; 
     590            } 
     591 
    554592        } else { 
    555593            status = (*stream->codec->op->recover)(stream->codec, 
     
    561599 
    562600            if (frame_type == PJMEDIA_JB_MISSING_FRAME) { 
    563                 PJ_LOG(5,(stream->port.info.name.ptr,  "Frame lost!")); 
     601                if (frame_type != stream->jb_last_frm) { 
     602                    /* Report changing frame type event */ 
     603                    PJ_LOG(5,(stream->port.info.name.ptr, "Frame lost!")); 
     604 
     605                    stream->jb_last_frm = frame_type; 
     606                    stream->jb_last_frm_cnt = 1; 
     607                } else { 
     608                    stream->jb_last_frm_cnt++; 
     609                } 
    564610            } else if (frame_type == PJMEDIA_JB_ZERO_EMPTY_FRAME) { 
    565                 /* Jitter buffer is empty. Check if this is the first "empty"  
    566                  * state. 
    567                  */ 
    568611                if (frame_type != stream->jb_last_frm) { 
    569612                    pjmedia_jb_state jb_state; 
    570613 
    571                     /* Report the state of jitter buffer */ 
     614                    /* Report changing frame type event */ 
    572615                    pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    573616                    PJ_LOG(5,(stream->port.info.name.ptr,  
    574617                              "Jitter buffer empty (prefetch=%d)",  
    575618                              jb_state.prefetch)); 
     619 
     620                    stream->jb_last_frm = frame_type; 
     621                    stream->jb_last_frm_cnt = 1; 
     622                } else { 
     623                    stream->jb_last_frm_cnt++; 
    576624                } 
    577625            } else { 
    578                 pjmedia_jb_state jb_state; 
    579626 
    580627                /* It can only be PJMEDIA_JB_ZERO_PREFETCH frame */ 
    581628                pj_assert(frame_type == PJMEDIA_JB_ZERO_PREFETCH_FRAME); 
    582629 
    583                 /* Get the state of jitter buffer */ 
    584                 pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    585  
    586630                if (stream->jb_last_frm != frame_type) { 
     631                    pjmedia_jb_state jb_state; 
     632 
     633                    /* Report changing frame type event */ 
     634                    pjmedia_jbuf_get_state(stream->jb, &jb_state); 
    587635                    PJ_LOG(5,(stream->port.info.name.ptr,  
    588636                              "Jitter buffer is bufferring (prefetch=%d)", 
    589637                              jb_state.prefetch)); 
     638 
     639                    stream->jb_last_frm = frame_type; 
     640                    stream->jb_last_frm_cnt = 1; 
     641                } else { 
     642                    stream->jb_last_frm_cnt++; 
    590643                } 
    591644            } 
    592645        } 
    593  
    594         stream->jb_last_frm = frame_type; 
    595646    } 
    596647 
     
    17161767    stream->rx_event_pt = info->rx_event_pt ? info->rx_event_pt : -1; 
    17171768    stream->last_dtmf = -1; 
     1769    stream->jb_last_frm = PJMEDIA_JB_NORMAL_FRAME; 
    17181770 
    17191771    /* Build random RTCP CNAME. CNAME has user@host format */ 
Note: See TracChangeset for help on using the changeset viewer.