Ticket #528: ticket528.patch

File ticket528.patch, 7.7 KB (added by nanang, 11 years ago)

Added new API for sending RTCP with destination address param

  • pjmedia/include/pjmedia/transport.h

     
    306306                             pj_size_t size); 
    307307 
    308308    /** 
     309     * This function is called by the stream to send RTCP packet using the 
     310     * transport with destination address other than default specified in 
     311     * #pjmedia_transport_attach(). 
     312     * 
     313     * Application should call #pjmedia_transport_send_rtcp2() instead of  
     314     * calling this function directly. 
     315     */ 
     316    pj_status_t (*send_rtcp2)(pjmedia_transport *tp, 
     317                              const pj_sockaddr_t *addr, 
     318                              unsigned addr_len, 
     319                              const void *pkt, 
     320                              pj_size_t size); 
     321 
     322    /** 
    309323     * This function is called by application to generate the SDP parts 
    310324     * related to transport type, e.g: ICE, SRTP. 
    311325     * 
     
    587601 
    588602 
    589603/** 
     604 * Send RTCP packet with the specified media transport. This is just a simple 
     605 * wrapper which calls <tt>send_rtcp2()</tt> member of the transport. The  
     606 * RTCP packet will be delivered to the destination address specified in 
     607 * param addr, if addr is NULL, RTCP packet will be delivered to destination  
     608 * address specified in #pjmedia_transport_attach() function. 
     609 * 
     610 * @param tp        The media transport. 
     611 * @param addr      The destination address. 
     612 * @param addr_len  Length of destination address. 
     613 * @param pkt       The packet to send. 
     614 * @param size      Size of the packet. 
     615 * 
     616 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     617 */ 
     618PJ_INLINE(pj_status_t) pjmedia_transport_send_rtcp2(pjmedia_transport *tp, 
     619                                                    const pj_sockaddr_t *addr, 
     620                                                    unsigned addr_len, 
     621                                                    const void *pkt, 
     622                                                    pj_size_t size) 
     623{ 
     624    return (*tp->op->send_rtcp2)(tp, addr, addr_len, pkt, size); 
     625} 
     626 
     627 
     628/** 
    590629 * Generate local SDP parts that are related to the specified media transport. 
    591630 * Remote SDP might be needed as reference when application is in deciding 
    592631 * side of negotiation (callee side), otherwise it should be NULL. 
  • pjmedia/src/pjmedia/transport_udp.c

     
    121121static pj_status_t transport_send_rtcp(pjmedia_transport *tp, 
    122122                                       const void *pkt, 
    123123                                       pj_size_t size); 
     124static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     125                                       const pj_sockaddr_t *addr, 
     126                                       unsigned addr_len, 
     127                                       const void *pkt, 
     128                                       pj_size_t size); 
    124129static pj_status_t transport_media_create(pjmedia_transport *tp, 
    125130                                       pj_pool_t *pool, 
    126131                                       unsigned options, 
     
    146151    &transport_detach, 
    147152    &transport_send_rtp, 
    148153    &transport_send_rtcp, 
     154    &transport_send_rtcp2, 
    149155    &transport_media_create, 
    150156    &transport_media_start, 
    151157    &transport_media_stop, 
     
    748754                                       const void *pkt, 
    749755                                       pj_size_t size) 
    750756{ 
     757    return transport_send_rtcp2(tp, NULL, 0, pkt, size); 
     758} 
     759 
     760 
     761/* Called by application to send RTCP packet */ 
     762static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     763                                        const pj_sockaddr_t *addr, 
     764                                        unsigned addr_len, 
     765                                        const void *pkt, 
     766                                        pj_size_t size) 
     767{ 
    751768    struct transport_udp *udp = (struct transport_udp*)tp; 
    752769    pj_ssize_t sent; 
    753770    pj_status_t status; 
    754771 
    755772    PJ_ASSERT_RETURN(udp->attached, PJ_EINVALIDOP); 
    756773 
     774    if (addr == NULL) { 
     775        addr = &udp->rem_rtcp_addr; 
     776        addr_len = udp->addr_len; 
     777    } 
     778 
    757779    sent = size; 
    758780    status = pj_ioqueue_sendto( udp->rtcp_key, &udp->rtcp_write_op, 
    759                                 pkt, &sent, 0, 
    760                                 &udp->rem_rtcp_addr, udp->addr_len); 
     781                                pkt, &sent, 0, addr, addr_len); 
    761782 
    762783    if (status==PJ_SUCCESS || status==PJ_EPENDING) 
    763784        return PJ_SUCCESS; 
  • pjmedia/src/pjmedia/transport_ice.c

     
    7575static pj_status_t transport_send_rtcp(pjmedia_transport *tp, 
    7676                                       const void *pkt, 
    7777                                       pj_size_t size); 
     78static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     79                                       const pj_sockaddr_t *addr, 
     80                                       unsigned addr_len, 
     81                                       const void *pkt, 
     82                                       pj_size_t size); 
    7883static pj_status_t transport_media_create(pjmedia_transport *tp, 
    7984                                       pj_pool_t *pool, 
    8085                                       unsigned options, 
     
    110115    &transport_detach, 
    111116    &transport_send_rtp, 
    112117    &transport_send_rtcp, 
     118    &transport_send_rtcp2, 
    113119    &transport_media_create, 
    114120    &transport_media_start, 
    115121    &transport_media_stop, 
     
    770776                                       const void *pkt, 
    771777                                       pj_size_t size) 
    772778{ 
     779    return transport_send_rtcp2(tp, NULL, 0, pkt, size); 
     780} 
     781 
     782static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     783                                        const pj_sockaddr_t *addr, 
     784                                        unsigned addr_len, 
     785                                        const void *pkt, 
     786                                        pj_size_t size) 
     787{ 
    773788    struct transport_ice *tp_ice = (struct transport_ice*)tp; 
    774789    if (tp_ice->ice_st->comp_cnt > 1) { 
    775         return pj_ice_strans_sendto(tp_ice->ice_st, 2,  
    776                                     pkt, size, &tp_ice->remote_rtcp, 
    777                                     sizeof(pj_sockaddr_in)); 
     790        if (addr == NULL) { 
     791            addr = &tp_ice->remote_rtcp; 
     792            addr_len = pj_sockaddr_get_len(addr); 
     793        } 
     794        return pj_ice_strans_sendto(tp_ice->ice_st, 2, pkt, size,  
     795                                    addr, addr_len); 
    778796    } else { 
    779797        return PJ_SUCCESS; 
    780798    } 
  • pjmedia/src/pjmedia/transport_srtp.c

     
    145145static pj_status_t transport_send_rtcp(pjmedia_transport *tp, 
    146146                                       const void *pkt, 
    147147                                       pj_size_t size); 
     148static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     149                                       const pj_sockaddr_t *addr, 
     150                                       unsigned addr_len, 
     151                                       const void *pkt, 
     152                                       pj_size_t size); 
    148153static pj_status_t transport_media_create(pjmedia_transport *tp, 
    149154                                       pj_pool_t *pool, 
    150155                                       unsigned options, 
     
    171176    &transport_detach, 
    172177    &transport_send_rtp, 
    173178    &transport_send_rtcp, 
     179    &transport_send_rtcp2, 
    174180    &transport_media_create, 
    175181    &transport_media_start, 
    176182    &transport_media_stop, 
     
    657663                                       const void *pkt, 
    658664                                       pj_size_t size) 
    659665{ 
     666    return transport_send_rtcp2(tp, NULL, 0, pkt, size); 
     667} 
     668 
     669static pj_status_t transport_send_rtcp2(pjmedia_transport *tp, 
     670                                        const pj_sockaddr_t *addr, 
     671                                        unsigned addr_len, 
     672                                        const void *pkt, 
     673                                        pj_size_t size) 
     674{ 
    660675    pj_status_t status; 
    661676    transport_srtp *srtp = (transport_srtp*) tp; 
    662677    int len = size; 
    663678    err_status_t err; 
    664679 
    665     if (srtp->bypass_srtp) 
    666         return pjmedia_transport_send_rtcp(srtp->real_tp, pkt, size); 
     680    if (srtp->bypass_srtp) { 
     681        return pjmedia_transport_send_rtcp2(srtp->real_tp, addr, addr_len,  
     682                                            pkt, size); 
     683    } 
    667684 
    668685    if (!srtp->session_inited) 
    669686        return PJ_SUCCESS; 
     
    677694    err = srtp_protect_rtcp(srtp->srtp_tx_ctx, srtp->tx_buffer, &len); 
    678695     
    679696    if (err == err_status_ok) { 
    680         status = pjmedia_transport_send_rtcp(srtp->real_tp, srtp->tx_buffer,  
    681                                              len); 
     697        status = pjmedia_transport_send_rtcp2(srtp->real_tp, addr, addr_len, 
     698                                              srtp->tx_buffer, len); 
    682699    } else { 
    683700        status = PJMEDIA_ERRNO_FROM_LIBSRTP(err); 
    684701    } 
     
    688705    return status; 
    689706} 
    690707 
     708 
    691709static pj_status_t transport_simulate_lost(pjmedia_transport *tp, 
    692710                                           pjmedia_dir dir, 
    693711                                           unsigned pct_lost)