Changeset 1447


Ignore:
Timestamp:
Sep 20, 2007 1:19:03 PM (13 years ago)
Author:
bennylp
Message:

Ticket #13: Send RTCP RR if stream is not transmitting any RTP packets

Location:
pjproject/branches/pjproject-0.5-stable
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • pjproject/branches/pjproject-0.5-stable/pjmedia/include/pjmedia/rtcp.h

    r974 r1447  
    5959struct pjmedia_rtcp_sr 
    6060{ 
    61     pj_uint32_t     ssrc;           /**< SSRC identification.           */ 
    6261    pj_uint32_t     ntp_sec;        /**< NTP time, seconds part.        */ 
    6362    pj_uint32_t     ntp_frac;       /**< NTP time, fractions part.      */ 
     
    118117#endif 
    119118    unsigned        length:16;  /**< packet length          */ 
     119    pj_uint32_t     ssrc;       /**< SSRC identification    */ 
    120120}; 
    121121 
     
    130130 * manually by application. 
    131131 */ 
    132 struct pjmedia_rtcp_pkt 
     132typedef struct pjmedia_rtcp_sr_pkt 
    133133{ 
    134134    pjmedia_rtcp_common  common;        /**< Common header.         */ 
    135135    pjmedia_rtcp_sr      sr;            /**< Sender report.         */ 
    136136    pjmedia_rtcp_rr      rr;            /**< variable-length list   */ 
    137 }; 
    138  
    139 /** 
    140  * @see pjmedia_rtcp_pkt 
    141  */ 
    142 typedef struct pjmedia_rtcp_pkt pjmedia_rtcp_pkt; 
     137} pjmedia_rtcp_sr_pkt; 
     138 
     139/** 
     140 * This structure declares RTCP RR (Receiver Report) packet. 
     141 */ 
     142typedef struct pjmedia_rtcp_rr_pkt 
     143{ 
     144    pjmedia_rtcp_common  common;        /**< Common header.         */ 
     145    pjmedia_rtcp_rr      rr;            /**< variable-length list   */ 
     146} pjmedia_rtcp_rr_pkt; 
    143147 
    144148 
     
    251255{ 
    252256    char                   *name;       /**< Name identification.           */ 
    253     pjmedia_rtcp_pkt        rtcp_pkt;   /**< Cached RTCP packet.            */ 
     257    pjmedia_rtcp_sr_pkt     rtcp_sr_pkt;/**< Cached RTCP packet.            */ 
     258    pjmedia_rtcp_rr_pkt     rtcp_rr_pkt;/**< Cached RTCP RR packet.         */ 
    254259     
    255260    pjmedia_rtp_seq_session seq_ctrl;   /**< RTCP sequence number control.  */ 
     
    310315 * @return                  PJ_SUCCESS on success. 
    311316 */ 
    312 PJ_DEF(pj_status_t) pjmedia_rtcp_get_ntp_time(const pjmedia_rtcp_session *sess, 
    313                                               pjmedia_rtcp_ntp_rec *ntp); 
     317PJ_DECL(pj_status_t) pjmedia_rtcp_get_ntp_time(const pjmedia_rtcp_session *sess, 
     318                                               pjmedia_rtcp_ntp_rec *ntp); 
    314319 
    315320 
     
    364369 
    365370/** 
    366  * Build a RTCP SR+RR packet to be transmitted to remote RTP peer. 
     371 * Build a RTCP packet to be transmitted to remote RTP peer. This will 
     372 * create RTCP Sender Report (SR) or Receiver Report (RR) depending on 
     373 * whether the endpoint has been transmitting RTP since the last interval. 
    367374 * Note that this function will reset the interval counters (such as 
    368375 * the ones to calculate fraction lost) in the session. 
     
    370377 * @param session   The RTCP session. 
    371378 * @param rtcp_pkt  Upon return, it will contain pointer to the  
    372  *                  RTCP packet. 
     379 *                  RTCP packet, which can be RTCP SR or RR. 
    373380 * @param len       Upon return, it will indicate the size of  
    374381 *                  the RTCP packet. 
    375382 */ 
    376383PJ_DECL(void) pjmedia_rtcp_build_rtcp( pjmedia_rtcp_session *session,  
    377                                        pjmedia_rtcp_pkt **rtcp_pkt,  
    378                                        int *len); 
     384                                       void **rtcp_pkt, int *len); 
    379385 
    380386 
  • pjproject/branches/pjproject-0.5-stable/pjmedia/src/pjmedia/rtcp.c

    r974 r1447  
    131131                               pj_uint32_t ssrc) 
    132132{ 
    133     pjmedia_rtcp_pkt *rtcp_pkt = &sess->rtcp_pkt; 
     133    pjmedia_rtcp_sr_pkt *sr_pkt = &sess->rtcp_sr_pkt; 
    134134    pj_time_val now; 
    135135     
     
    141141 
    142142    /* Name */ 
    143     sess->name = name ? name : THIS_FILE, 
     143    sess->name = name ? name : (char*)THIS_FILE, 
    144144 
    145145    /* Set clock rate */ 
     
    147147    sess->pkt_size = samples_per_frame; 
    148148 
    149     /* Init common RTCP header */ 
    150     rtcp_pkt->common.version = 2; 
    151     rtcp_pkt->common.count = 1; 
    152     rtcp_pkt->common.pt = RTCP_SR; 
    153     rtcp_pkt->common.length = pj_htons(12); 
    154      
    155     /* Init SR */ 
    156     rtcp_pkt->sr.ssrc = pj_htonl(ssrc); 
    157      
     149    /* Init common RTCP SR header */ 
     150    sr_pkt->common.version = 2; 
     151    sr_pkt->common.count = 1; 
     152    sr_pkt->common.pt = RTCP_SR; 
     153    sr_pkt->common.length = pj_htons(12); 
     154    sr_pkt->common.ssrc = pj_htonl(ssrc); 
     155     
     156    /* Copy to RTCP RR header */ 
     157    pj_memcpy(&sess->rtcp_rr_pkt.common, &sr_pkt->common,  
     158              sizeof(pjmedia_rtcp_common)); 
     159    sess->rtcp_rr_pkt.common.pt = RTCP_RR; 
     160    sess->rtcp_rr_pkt.common.length = pj_htons(7); 
     161 
    158162    /* Get time and timestamp base and frequency */ 
    159163    pj_gettimeofday(&now); 
     
    333337                                   pj_size_t size) 
    334338{ 
    335     const pjmedia_rtcp_common *common = pkt; 
     339    pjmedia_rtcp_common *common = (pjmedia_rtcp_common*) pkt; 
    336340    const pjmedia_rtcp_rr *rr = NULL; 
    337341    const pjmedia_rtcp_sr *sr = NULL; 
     
    341345    if (common->pt == RTCP_SR) { 
    342346        sr = (pjmedia_rtcp_sr*) (((char*)pkt) + sizeof(pjmedia_rtcp_common)); 
    343         if (common->count > 0 && size >= (sizeof(pjmedia_rtcp_pkt))) { 
     347        if (common->count > 0 && size >= (sizeof(pjmedia_rtcp_sr_pkt))) { 
    344348            rr = (pjmedia_rtcp_rr*)(((char*)pkt) + (sizeof(pjmedia_rtcp_common) 
    345349                                    + sizeof(pjmedia_rtcp_sr))); 
    346350        } 
    347351    } else if (common->pt == RTCP_RR && common->count > 0) 
    348         rr = (pjmedia_rtcp_rr*)(((char*)pkt) +sizeof(pjmedia_rtcp_common) +4); 
     352        rr = (pjmedia_rtcp_rr*)(((char*)pkt) + sizeof(pjmedia_rtcp_common)); 
    349353 
    350354 
     
    530534 
    531535PJ_DEF(void) pjmedia_rtcp_build_rtcp(pjmedia_rtcp_session *sess,  
    532                                      pjmedia_rtcp_pkt **ret_p_pkt,  
    533                                      int *len) 
     536                                     void **ret_p_pkt, int *len) 
    534537{ 
    535538    pj_uint32_t expected, expected_interval, received_interval, lost_interval; 
    536     pjmedia_rtcp_pkt *rtcp_pkt = &sess->rtcp_pkt; 
     539    pjmedia_rtcp_common *common; 
     540    pjmedia_rtcp_sr *sr; 
     541    pjmedia_rtcp_rr *rr; 
    537542    pj_timestamp ts_now; 
    538543    pjmedia_rtcp_ntp_rec ntp; 
    539      
    540     /* Packet count */ 
    541     rtcp_pkt->sr.sender_pcount = pj_htonl(sess->stat.tx.pkt); 
    542  
    543     /* Octets count */ 
    544     rtcp_pkt->sr.sender_bcount = pj_htonl(sess->stat.tx.bytes); 
     544 
     545    /* Get current NTP time. */ 
     546    pj_get_timestamp(&ts_now); 
     547    pjmedia_rtcp_get_ntp_time(sess, &ntp); 
     548 
     549 
     550    /* See if we have transmitted RTP packets since last time we 
     551     * sent RTCP SR. 
     552     */ 
     553    if (sess->stat.tx.pkt != pj_ntohl(sess->rtcp_sr_pkt.sr.sender_pcount)) { 
     554 
     555        /* So we should send RTCP SR */ 
     556        *ret_p_pkt = (void*) &sess->rtcp_sr_pkt; 
     557        *len = sizeof(pjmedia_rtcp_sr_pkt); 
     558        common = &sess->rtcp_sr_pkt.common; 
     559        rr = &sess->rtcp_sr_pkt.rr; 
     560        sr = &sess->rtcp_sr_pkt.sr; 
     561 
     562        /* Update packet count */ 
     563        sr->sender_pcount = pj_htonl(sess->stat.tx.pkt); 
     564 
     565        /* Update octets count */ 
     566        sr->sender_bcount = pj_htonl(sess->stat.tx.bytes); 
     567 
     568        /* Fill in NTP timestamp in SR. */ 
     569        sr->ntp_sec = pj_htonl(ntp.hi); 
     570        sr->ntp_frac = pj_htonl(ntp.lo); 
     571 
     572        TRACE_((sess->name, "TX RTCP SR: ntp_ts=%p",  
     573                           ((ntp.hi & 0xFFFF) << 16) + ((ntp.lo & 0xFFFF0000)  
     574                                >> 16))); 
     575 
     576 
     577    } else { 
     578        /* We should send RTCP RR then */ 
     579        *ret_p_pkt = (void*) &sess->rtcp_rr_pkt; 
     580        *len = sizeof(pjmedia_rtcp_rr_pkt); 
     581        common = &sess->rtcp_rr_pkt.common; 
     582        rr = &sess->rtcp_rr_pkt.rr; 
     583        sr = NULL; 
     584    } 
    545585     
    546586    /* SSRC and last_seq */ 
    547     rtcp_pkt->rr.ssrc = pj_htonl(sess->peer_ssrc); 
    548     rtcp_pkt->rr.last_seq = (sess->seq_ctrl.cycles & 0xFFFF0000L); 
    549     rtcp_pkt->rr.last_seq += sess->seq_ctrl.max_seq; 
    550     rtcp_pkt->rr.last_seq = pj_htonl(rtcp_pkt->rr.last_seq); 
     587    rr->ssrc = pj_htonl(sess->peer_ssrc); 
     588    rr->last_seq = (sess->seq_ctrl.cycles & 0xFFFF0000L); 
     589    /* Since this is an "+=" operation, make sure we update last_seq on 
     590     * both RR and SR. 
     591     */ 
     592    sess->rtcp_sr_pkt.rr.last_seq += sess->seq_ctrl.max_seq; 
     593    sess->rtcp_rr_pkt.rr.last_seq += sess->seq_ctrl.max_seq; 
     594    rr->last_seq = pj_htonl(rr->last_seq); 
    551595 
    552596 
    553597    /* Jitter */ 
    554     rtcp_pkt->rr.jitter = pj_htonl(sess->jitter >> 4); 
     598    rr->jitter = pj_htonl(sess->jitter >> 4); 
    555599     
    556600     
    557601    /* Total lost. */ 
    558     expected = pj_ntohl(rtcp_pkt->rr.last_seq) - sess->seq_ctrl.base_seq; 
     602    expected = pj_ntohl(rr->last_seq) - sess->seq_ctrl.base_seq; 
    559603 
    560604    /* This is bug: total lost already calculated on each incoming RTP! 
     
    565609    */ 
    566610 
    567     rtcp_pkt->rr.total_lost_2 = (sess->stat.rx.loss >> 16) & 0xFF; 
    568     rtcp_pkt->rr.total_lost_1 = (sess->stat.rx.loss >> 8) & 0xFF; 
    569     rtcp_pkt->rr.total_lost_0 = (sess->stat.rx.loss & 0xFF); 
     611    rr->total_lost_2 = (sess->stat.rx.loss >> 16) & 0xFF; 
     612    rr->total_lost_1 = (sess->stat.rx.loss >> 8) & 0xFF; 
     613    rr->total_lost_0 = (sess->stat.rx.loss & 0xFF); 
    570614 
    571615    /* Fraction lost calculation */ 
     
    576620    sess->rx_prior = sess->received; 
    577621     
    578     lost_interval = expected_interval - received_interval; 
     622    if (expected_interval >= received_interval) 
     623        lost_interval = expected_interval - received_interval; 
     624    else 
     625        lost_interval = 0; 
    579626     
    580627    if (expected_interval==0 || lost_interval == 0) { 
    581         rtcp_pkt->rr.fract_lost = 0; 
     628        rr->fract_lost = 0; 
    582629    } else { 
    583         rtcp_pkt->rr.fract_lost = (lost_interval << 8) / expected_interval; 
    584     } 
    585      
    586     /* Get current NTP time. */ 
    587     pj_get_timestamp(&ts_now); 
    588     pjmedia_rtcp_get_ntp_time(sess, &ntp); 
    589      
    590     /* Fill in NTP timestamp in SR. */ 
    591     rtcp_pkt->sr.ntp_sec = pj_htonl(ntp.hi); 
    592     rtcp_pkt->sr.ntp_frac = pj_htonl(ntp.lo); 
    593  
    594     TRACE_((sess->name, "TX RTCP SR: ntp_ts=%p",  
    595                        ((ntp.hi & 0xFFFF) << 16) + ((ntp.lo & 0xFFFF0000)  
    596                             >> 16))); 
    597  
     630        rr->fract_lost = (lost_interval << 8) / expected_interval; 
     631    } 
     632     
    598633    if (sess->rx_lsr_time.u64 == 0 || sess->rx_lsr == 0) { 
    599         rtcp_pkt->rr.lsr = 0; 
    600         rtcp_pkt->rr.dlsr = 0; 
     634        rr->lsr = 0; 
     635        rr->dlsr = 0; 
    601636    } else { 
    602637        pj_timestamp ts; 
     
    611646           LSR is the middle 32bit of the last SR NTP time received. 
    612647         */ 
    613         rtcp_pkt->rr.lsr = pj_htonl(lsr); 
     648        rr->lsr = pj_htonl(lsr); 
    614649         
    615650        /* Fill in DLSR. 
     
    623658        /* Get DLSR */ 
    624659        dlsr = (pj_uint32_t)(ts.u64 - lsr_time); 
    625         rtcp_pkt->rr.dlsr = pj_htonl(dlsr); 
     660        rr->dlsr = pj_htonl(dlsr); 
    626661 
    627662        TRACE_((sess->name,"Tx RTCP RR: lsr=%p, lsr_time=%p, now=%p, dlsr=%p" 
     
    638673    pj_gettimeofday(&sess->stat.rx.update); 
    639674    sess->stat.rx.update_cnt++; 
    640  
    641  
    642     /* Return pointer. */ 
    643     *ret_p_pkt = rtcp_pkt; 
    644     *len = sizeof(pjmedia_rtcp_pkt); 
    645675} 
    646676 
  • pjproject/branches/pjproject-0.5-stable/pjmedia/src/pjmedia/stream.c

    r1047 r1447  
    6363{ 
    6464    int             event; 
    65     pj_uint32_t     start_ts; 
     65    pj_uint32_t     duration; 
    6666}; 
    6767 
     
    167167static pj_status_t get_frame( pjmedia_port *port, pjmedia_frame *frame) 
    168168{ 
    169     pjmedia_stream *stream = port->port_data.pdata; 
     169    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    170170    pjmedia_channel *channel = stream->dec; 
    171171    unsigned samples_count, samples_per_frame, samples_required; 
     
    192192                        stream->codec_param.info.channel_cnt /  
    193193                        1000; 
    194     p_out_samp = frame->buf; 
     194    p_out_samp = (pj_int16_t*) frame->buf; 
    195195 
    196196    for (samples_count=0; samples_count < samples_required;  
     
    374374 */ 
    375375static void create_dtmf_payload(pjmedia_stream *stream,  
    376                           struct pjmedia_frame *frame_out) 
     376                                struct pjmedia_frame *frame_out, 
     377                                int *first, int *last) 
    377378{ 
    378379    pjmedia_rtp_dtmf_event *event; 
    379380    struct dtmf *digit = &stream->tx_dtmf_buf[0]; 
    380     unsigned duration; 
    381381    pj_uint32_t cur_ts; 
    382382 
    383383    pj_assert(sizeof(pjmedia_rtp_dtmf_event) == 4); 
    384384 
    385     event = frame_out->buf; 
     385    *first = *last = 0; 
     386 
     387    event = (pjmedia_rtp_dtmf_event*) frame_out->buf; 
    386388    cur_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts); 
    387     duration = cur_ts - digit->start_ts; 
     389 
     390    if (digit->duration == 0) { 
     391        PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c",  
     392                  digitmap[digit->event])); 
     393        *first = 1; 
     394    } 
     395 
     396    digit->duration += stream->port.info.samples_per_frame; 
    388397 
    389398    event->event = (pj_uint8_t)digit->event; 
    390399    event->e_vol = 10; 
    391     event->duration = pj_htons((pj_uint16_t)duration); 
    392  
    393     if (duration >= PJMEDIA_DTMF_DURATION) { 
     400    event->duration = pj_htons((pj_uint16_t)digit->duration); 
     401 
     402 
     403    if (digit->duration >= PJMEDIA_DTMF_DURATION) { 
     404 
    394405        event->e_vol |= 0x80; 
     406        *last = 1; 
    395407 
    396408        /* Prepare next digit. */ 
    397409        pj_mutex_lock(stream->jb_mutex); 
     410 
    398411        pj_array_erase(stream->tx_dtmf_buf, sizeof(stream->tx_dtmf_buf[0]), 
    399412                       stream->tx_dtmf_count, 0); 
    400413        --stream->tx_dtmf_count; 
    401414 
    402         stream->tx_dtmf_buf[0].start_ts = cur_ts; 
    403415        pj_mutex_unlock(stream->jb_mutex); 
    404  
    405         if (stream->tx_dtmf_count) { 
    406             PJ_LOG(5,(stream->port.info.name.ptr, 
    407                       "Sending DTMF digit id %c",  
    408                       digitmap[stream->tx_dtmf_buf[0].event])); 
    409         } 
    410  
    411     } else if (duration == 0) { 
    412         PJ_LOG(5,(stream->port.info.name.ptr, "Sending DTMF digit id %c",  
    413                   digitmap[digit->event])); 
    414     } 
    415  
     416    } 
    416417 
    417418    frame_out->size = 4; 
     
    439440    } else if (timestamp - stream->rtcp_last_tx >= stream->rtcp_interval) { 
    440441         
    441         pjmedia_rtcp_pkt *rtcp_pkt; 
     442        void *rtcp_pkt; 
    442443        int len; 
    443444 
     
    515516                                  const pjmedia_frame *frame ) 
    516517{ 
    517     pjmedia_stream *stream = port->port_data.pdata; 
     518    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    518519    pjmedia_channel *channel = stream->enc; 
    519520    pj_status_t status = 0; 
     
    522523    void *rtphdr; 
    523524    int rtphdrlen; 
    524  
     525    int inc_timestamp = 0; 
    525526 
    526527    /* Don't do anything if stream is paused */ 
     
    551552     */ 
    552553    if (stream->tx_dtmf_count) { 
    553  
    554         create_dtmf_payload(stream, &frame_out); 
    555  
    556         /* Encapsulate. */ 
     554        int first=0, last=0; 
     555 
     556        create_dtmf_payload(stream, &frame_out, &first, &last); 
     557 
     558        /* Encapsulate into RTP packet. Note that: 
     559         *  - RTP marker should be set on the beginning of a new event 
     560         *  - RTP timestamp is constant for the same packet.  
     561         */ 
    557562        status = pjmedia_rtp_encode_rtp( &channel->rtp,  
    558                                          stream->tx_event_pt, 0,  
    559                                          frame_out.size, ts_len,  
     563                                         stream->tx_event_pt, first,  
     564                                         frame_out.size, (first?ts_len:0),  
    560565                                         (const void**)&rtphdr,  
    561566                                         &rtphdrlen); 
     567 
     568        if (last) { 
     569            /* This is the last packet for the event.  
     570             * Increment the RTP timestamp of the RTP session, for next 
     571             * RTP packets. 
     572             */ 
     573            inc_timestamp = PJMEDIA_DTMF_DURATION - ts_len; 
     574        } 
    562575 
    563576    } else if (frame->type != PJMEDIA_FRAME_TYPE_NONE) { 
     
    663676    pj_memcpy(channel->out_pkt, rtphdr, sizeof(pjmedia_rtp_hdr)); 
    664677 
     678    /* Special case for DTMF: timestamp remains constant for 
     679     * the same event, and is only updated after a complete event 
     680     * has been transmitted. 
     681     */ 
     682    if (inc_timestamp) { 
     683        pjmedia_rtp_encode_rtp( &channel->rtp, stream->tx_event_pt, 0, 
     684                                0, inc_timestamp, NULL, NULL); 
     685    } 
    665686 
    666687    /* Set RTP marker bit if currently not streaming */ 
    667688    if (stream->is_streaming == PJ_FALSE) { 
    668         pjmedia_rtp_hdr *rtp = channel->out_pkt; 
     689        pjmedia_rtp_hdr *rtp = (pjmedia_rtp_hdr*) channel->out_pkt; 
    669690 
    670691        rtp->m = 1; 
     
    698719                              const pjmedia_frame *frame ) 
    699720{ 
    700     pjmedia_stream *stream = port->port_data.pdata; 
     721    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata; 
    701722    pjmedia_frame tmp_zero_frame; 
    702723    unsigned samples_per_frame; 
     
    831852                                  const void *payload, unsigned payloadlen) 
    832853{ 
    833     const pjmedia_rtp_dtmf_event *event = payload; 
     854    pjmedia_rtp_dtmf_event *event = (pjmedia_rtp_dtmf_event*) payload; 
    834855 
    835856    /* Check compiler packing. */ 
     
    903924 
    904925{ 
    905     pjmedia_stream *stream = data; 
     926    pjmedia_stream *stream = (pjmedia_stream*) data; 
    906927    pjmedia_channel *channel = stream->dec; 
    907928    const pjmedia_rtp_hdr *hdr; 
     
    919940 
    920941    /* Ignore keep-alive packets */ 
    921     if (bytes_read < sizeof(pjmedia_rtp_hdr)) 
     942    if (bytes_read < (pj_ssize_t) sizeof(pjmedia_rtp_hdr)) 
    922943        return; 
    923944 
     
    10531074                        pj_ssize_t bytes_read) 
    10541075{ 
    1055     pjmedia_stream *stream = data; 
     1076    pjmedia_stream *stream = (pjmedia_stream*) data; 
    10561077 
    10571078    /* Check for errors */ 
     
    10811102    /* Allocate memory for channel descriptor */ 
    10821103 
    1083     channel = pj_pool_zalloc(pool, sizeof(pjmedia_channel)); 
     1104    channel = (pjmedia_channel*) pj_pool_zalloc(pool, sizeof(pjmedia_channel)); 
    10841105    PJ_ASSERT_RETURN(channel != NULL, PJ_ENOMEM); 
    10851106 
     
    11471168    /* Allocate the media stream: */ 
    11481169 
    1149     stream = pj_pool_zalloc(pool, sizeof(pjmedia_stream)); 
     1170    stream = (pjmedia_stream*) pj_pool_zalloc(pool, sizeof(pjmedia_stream)); 
    11501171    PJ_ASSERT_RETURN(stream != NULL, PJ_ENOMEM); 
    11511172 
    11521173    /* Init stream/port name */ 
    1153     name.ptr = pj_pool_alloc(pool, M); 
     1174    name.ptr = (char*) pj_pool_alloc(pool, M); 
    11541175    name.slen = pj_ansi_snprintf(name.ptr, M, "strm%p", stream); 
    11551176 
     
    12631284        /* Allocate buffer */ 
    12641285        stream->enc_buf_size = stream->port.info.clock_rate * ptime / 1000; 
    1265         stream->enc_buf = pj_pool_alloc(pool, stream->enc_buf_size * 2); 
     1286        stream->enc_buf = (pj_int16_t*) 
     1287                          pj_pool_alloc(pool, stream->enc_buf_size * 2); 
    12661288 
    12671289    } else { 
     
    15361558     
    15371559    if (stream->tx_dtmf_count+digit_char->slen >= 
    1538         PJ_ARRAY_SIZE(stream->tx_dtmf_buf)) 
     1560        (long)PJ_ARRAY_SIZE(stream->tx_dtmf_buf)) 
    15391561    { 
    15401562        status = PJ_ETOOMANY; 
     
    15721594 
    15731595            stream->tx_dtmf_buf[stream->tx_dtmf_count+i].event = pt; 
     1596            stream->tx_dtmf_buf[stream->tx_dtmf_count+i].duration = 0; 
    15741597        } 
    15751598 
     
    15771600            goto on_return; 
    15781601 
    1579         /* Init start_ts and end_ts only for the first digit. 
    1580          * Subsequent digits are initialized on the fly. 
    1581          */ 
    1582         if (stream->tx_dtmf_count ==0) { 
    1583             pj_uint32_t start_ts; 
    1584  
    1585             start_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts); 
    1586             stream->tx_dtmf_buf[0].start_ts = start_ts; 
    1587         } 
    1588  
    15891602        /* Increment digit count only if all digits are valid. */ 
    15901603        stream->tx_dtmf_count += digit_char->slen; 
    1591  
    15921604    } 
    15931605 
     
    16461658 * Set callback to be called upon receiving DTMF digits. 
    16471659 */ 
    1648 PJ_DEF(pj_status_t) 
    1649 pjmedia_stream_set_dtmf_callback(pjmedia_stream *stream, 
     1660PJ_DEF(pj_status_t) pjmedia_stream_set_dtmf_callback(pjmedia_stream *stream, 
    16501661                                 void (*cb)(pjmedia_stream*,  
    16511662                                            void *user_data,  
  • pjproject/branches/pjproject-0.5-stable/pjsip-apps/src/samples/siprtp.c

    r974 r1447  
    7575#include <stdlib.h> 
    7676 
     77/* Uncomment these to disable threads. 
     78 * NOTE: 
     79 *   when threading is disabled, siprtp won't transmit any 
     80 *   RTP packets. 
     81 */ 
     82/* 
     83#undef PJ_HAS_THREADS 
     84#define PJ_HAS_THREADS 0 
     85*/ 
     86 
    7787 
    7888#if PJ_HAS_HIGH_RES_TIMER==0 
     
    402412     * initialized. 
    403413     */ 
     414#if PJ_HAS_THREADS 
    404415    status = pjmedia_endpt_create(&app.cp.factory, NULL, 1, &app.med_endpt); 
     416#else 
     417    status = pjmedia_endpt_create(&app.cp.factory,  
     418                                  pjsip_endpt_get_ioqueue(app.sip_endpt), 
     419                                  0, &app.med_endpt); 
     420#endif 
    405421    PJ_ASSERT_RETURN(status == PJ_SUCCESS, status); 
    406422 
     
    13271343             * Time to send RTCP packet. 
    13281344             */ 
    1329             pjmedia_rtcp_pkt *rtcp_pkt; 
     1345            void *rtcp_pkt; 
    13301346            int rtcp_len; 
    13311347            pj_ssize_t size; 
     
    14361452    /* Start media thread. */ 
    14371453    audio->thread_quit_flag = 0; 
     1454#if PJ_HAS_THREADS 
    14381455    status = pj_thread_create( inv->pool, "media", &media_thread, audio, 
    14391456                               0, 0, &audio->thread); 
     
    14421459        return; 
    14431460    } 
     1461#endif 
    14441462 
    14451463    /* Set the media as active */ 
     
    20712089 
    20722090    /* Start worker threads */ 
     2091#if PJ_HAS_THREADS 
    20732092    for (i=0; i<app.thread_count; ++i) { 
    20742093        pj_thread_create( app.pool, "app", &sip_worker_thread, NULL, 
    20752094                          0, 0, &app.sip_thread[i]); 
    20762095    } 
     2096#endif 
    20772097 
    20782098    /* If URL is specified, then make call immediately */ 
     
    20972117            pj_thread_sleep(200); 
    20982118        } else { 
     2119#if PJ_HAS_THREADS 
    20992120            /* Start user interface loop */ 
    21002121            console_main(); 
     2122#endif 
    21012123        } 
    21022124 
     
    21062128                  app.max_calls)); 
    21072129 
     2130#if PJ_HAS_THREADS 
    21082131        /* Start user interface loop */ 
    21092132        console_main(); 
    2110  
    2111     } 
    2112  
     2133#endif 
     2134    } 
     2135 
     2136#if !PJ_HAS_THREADS 
     2137    PJ_LOG(3,(THIS_FILE, "Press Ctrl-C to quit")); 
     2138    for (;;) { 
     2139        pj_time_val t = {0, 10}; 
     2140        pjsip_endpt_handle_events(app.sip_endpt, &t); 
     2141    } 
     2142#endif 
    21132143     
    21142144    /* Shutting down... */ 
Note: See TracChangeset for help on using the changeset viewer.