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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

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