Ignore:
Timestamp:
Feb 9, 2006 2:01:40 PM (18 years ago)
Author:
bennylp
Message:

Updated with new jitter buffer, and statistics in pjsua

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r164 r169  
    4040#define PJMEDIA_MAX_MTU                 1500 
    4141 
    42 struct jb_frame 
    43 { 
    44     unsigned size; 
    45     void    *buf; 
    46 }; 
    47  
    48 #define pj_fifobuf_alloc(fifo,size)     malloc(size) 
    49 #define pj_fifobuf_unalloc(fifo,buf)    free(buf) 
    50 #define pj_fifobuf_free(fifo, buf)      free(buf) 
    5142 
    5243 
    … …  
    8980    pjmedia_codec_mgr       *codec_mgr;     /**< Codec manager instance.    */ 
    9081    pjmedia_codec           *codec;         /**< Codec instance being used. */ 
    91  
     82    pj_size_t                frame_size;    /**< Size of encoded frame.     */ 
    9283    pj_mutex_t              *jb_mutex; 
    93     pj_jitter_buffer         jb;            /**< Jitter buffer.             */ 
    94  
    95     pj_sock_t                rtp_sock;      /**< RTP socket.                */ 
    96     pj_sock_t                rtcp_sock;     /**< RTCP socket.               */ 
    97     pj_sockaddr_in           dst_addr;      /**< Destination RTP address.   */ 
     84    pjmedia_jbuf            *jb;            /**< Jitter buffer.             */ 
     85 
     86    pjmedia_sock_info        skinfo;        /**< Transport info.            */ 
     87    pj_sockaddr_in           rem_rtp_addr;  /**< Remote RTP address.        */ 
     88    pj_sockaddr_in           rem_rtcp_addr; /**< Remote RTCP address.       */ 
    9889 
    9990    pj_rtcp_session          rtcp;          /**< RTCP for incoming RTP.     */ 
    … …  
    118109    pjmedia_channel *channel = user_data; 
    119110    pjmedia_stream *stream = channel->stream; 
    120     struct jb_frame *jb_frame; 
    121     void *p; 
    122     pj_uint32_t extseq; 
     111    char frame_type; 
    123112    pj_status_t status; 
    124113    struct pjmedia_frame frame_in, frame_out; 
    … …  
    134123 
    135124    /* Get frame from jitter buffer. */ 
    136     status = pj_jb_get(&stream->jb, &extseq, &p); 
     125    status = pjmedia_jbuf_get_frame(stream->jb, channel->out_pkt, 
     126                                    &frame_type); 
    137127 
    138128    /* Unlock jitter buffer mutex. */ 
    139129    pj_mutex_unlock( stream->jb_mutex ); 
    140130 
    141     jb_frame = p; 
    142     if (status != PJ_SUCCESS || jb_frame == NULL) { 
     131    if (status != PJ_SUCCESS || frame_type == PJMEDIA_JB_ZERO_FRAME || 
     132        frame_type == PJMEDIA_JB_MISSING_FRAME)  
     133    { 
    143134        pj_memset(frame, 0, size); 
    144135        return 0; 
    145136    } 
    146137 
     138 
    147139    /* Decode */ 
    148     frame_in.buf = jb_frame->buf; 
    149     frame_in.size = jb_frame->size; 
     140    frame_in.buf = channel->out_pkt; 
     141    frame_in.size = stream->frame_size; 
    150142    frame_in.type = PJMEDIA_FRAME_TYPE_AUDIO;  /* ignored */ 
    151143    frame_out.buf = channel->pcm_buf; 
    … …  
    156148 
    157149        pj_memset(frame, 0, size); 
    158         pj_fifobuf_free (&channel->fifobuf, jb_frame); 
    159150        return 0; 
    160151    } 
    … …  
    168159 
    169160    pj_memcpy(frame, frame_out.buf, size); 
    170     pj_fifobuf_free (&channel->fifobuf, jb_frame); 
    171161 
    172162    return 0; 
    … …  
    239229    /* Send. */ 
    240230    sent = frame_out.size+sizeof(pj_rtp_hdr); 
    241     status = pj_sock_sendto(stream->rtp_sock, channel->out_pkt, &sent, 0,  
    242                             &stream->dst_addr, sizeof(stream->dst_addr)); 
     231    status = pj_sock_sendto(stream->skinfo.rtp_sock, channel->out_pkt, &sent, 0,  
     232                            &stream->rem_rtp_addr, sizeof(stream->rem_rtp_addr)); 
    243233    if (status != PJ_SUCCESS) 
    244234        return status; 
    … …  
    261251    pjmedia_channel *channel = stream->dec; 
    262252 
     253 
    263254    while (!stream->quit_flag) { 
    264         pj_ssize_t len, size; 
     255        pj_ssize_t len; 
    265256        const pj_rtp_hdr *hdr; 
    266257        const void *payload; 
    267258        unsigned payloadlen; 
    268259        int status; 
    269         struct jb_frame *jb_frame; 
    270260 
    271261        /* Wait for packet. */ 
    … …  
    274264 
    275265        PJ_FD_ZERO (&fds); 
    276         PJ_FD_SET (stream->rtp_sock, &fds); 
     266        PJ_FD_SET (stream->skinfo.rtp_sock, &fds); 
    277267        timeout.sec = 0; 
    278268        timeout.msec = 1; 
    279269 
    280270        /* Wait with timeout. */ 
    281         status = pj_sock_select(stream->rtp_sock, &fds, NULL, NULL, &timeout); 
    282         if (status != 1) 
     271        status = pj_sock_select(FD_SETSIZE, &fds, NULL, NULL, &timeout); 
     272        if (status < 0) { 
     273            char errmsg[PJ_ERR_MSG_SIZE]; 
     274            pj_strerror(pj_get_netos_error(), errmsg, sizeof(errmsg)); 
     275            TRACE_((THIS_FILE, "Jitter buffer select() error: %s", 
     276                    errmsg)); 
     277            pj_thread_sleep(500); 
     278            continue; 
     279        } else if (status == 0) 
    283280            continue; 
    284281 
    285282        /* Get packet from socket. */ 
    286283        len = channel->in_pkt_size; 
    287         status = pj_sock_recv(stream->rtp_sock, channel->in_pkt, &len, 0); 
     284        status = pj_sock_recv(stream->skinfo.rtp_sock,  
     285                              channel->in_pkt, &len, 0); 
    288286        if (len < 1 || status != PJ_SUCCESS) { 
    289287            if (pj_get_netos_error() == PJ_STATUS_FROM_OS(OSERR_ECONNRESET)) { 
    … …  
    326324        stream->stat.dec.bytes += len; 
    327325 
    328         /* Copy to FIFO buffer. */ 
    329         size = payloadlen+sizeof(struct jb_frame); 
    330         jb_frame = pj_fifobuf_alloc (&channel->fifobuf, size); 
    331         if (jb_frame == NULL) { 
    332             TRACE_((THIS_FILE, "Unable to allocate %d bytes FIFO buffer",  
    333                     size)); 
    334             continue; 
    335         } 
    336  
    337         /* Copy the payload */ 
    338         jb_frame->size = payloadlen; 
    339         jb_frame->buf = ((char*)jb_frame) + sizeof(struct jb_frame); 
    340         pj_memcpy (jb_frame->buf, payload, payloadlen); 
    341  
    342326        /* Put to jitter buffer. */ 
    343327        pj_mutex_lock( stream->jb_mutex ); 
    344         status = pj_jb_put(&stream->jb, pj_ntohs(hdr->seq), jb_frame); 
     328        status = pjmedia_jbuf_put_frame(stream->jb, payload, payloadlen, pj_ntohs(hdr->seq)); 
    345329        pj_mutex_unlock( stream->jb_mutex ); 
    346330 
    347331        if (status != 0) { 
    348             pj_fifobuf_unalloc (&channel->fifobuf, jb_frame); 
    349              
    350332            TRACE_((THIS_FILE,  
    351333                    "Jitter buffer put() has returned error status %d",  
    … …  
    486468    stream->dir = info->dir; 
    487469    stream->codec_mgr = pjmedia_endpt_get_codec_mgr(endpt); 
     470    stream->skinfo = info->sock_info; 
     471    stream->rem_rtp_addr = info->rem_addr; 
     472 
     473    PJ_TODO(INITIALIZE_RTCP_REMOTE_ADDRESS); 
    488474 
    489475    /* Create mutex to protect jitter buffer: */ 
    … …  
    516502 
    517503 
     504    /* Get the frame size: */ 
     505 
     506    stream->frame_size = (codec_param.avg_bps / 8) * codec_param.ptime / 1000; 
     507 
     508 
    518509    /* Init RTCP session: */ 
    519510 
    … …  
    521512 
    522513 
    523     /* Init jitter buffer: */ 
    524  
    525     status = pj_jb_init(&stream->jb, pool,  
    526                         info->jb_min, info->jb_max, info->jb_maxcnt); 
     514    /* Create jitter buffer: */ 
     515 
     516    status = pjmedia_jbuf_create(pool, stream->frame_size, 15, 100, 
     517                                 &stream->jb); 
    527518    if (status != PJ_SUCCESS) 
    528519        goto err_cleanup; 
    … …  
    533524    status = pj_thread_create(pool, "decode",  
    534525                              &jitter_buffer_thread, stream, 
    535                               0, 0, &stream->thread); 
     526                              0, PJ_THREAD_SUSPENDED, &stream->thread); 
    536527    if (status != PJ_SUCCESS) 
    537528        goto err_cleanup; 
    … …  
    553544        goto err_cleanup; 
    554545 
     546    /* Resume jitter buffer thread. */ 
     547    status = pj_thread_resume( stream->thread ); 
     548    if (status != PJ_SUCCESS) 
     549        goto err_cleanup; 
    555550 
    556551    /* Success! */ 
Note: See TracChangeset for help on using the changeset viewer.