Changeset 5478


Ignore:
Timestamp:
Nov 3, 2016 9:39:20 AM (3 years ago)
Author:
riza
Message:

Re #1977: Add attach2() and pjmedia_transport_attach2() to pjmedia transport interface.

Location:
pjproject/trunk/pjmedia
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjmedia/include/pjmedia/transport.h

    r4811 r5478  
    242242 
    243243/** 
     244 * Forward declaration for media transport attach param. 
     245 */ 
     246typedef struct pjmedia_transport_attach_param pjmedia_transport_attach_param; 
     247 
     248/** 
    244249 * This enumeration specifies the general behaviour of media processing 
    245250 */ 
     
    304309     * to be used by the stream for the first time, and it tells the transport 
    305310     * about remote RTP address to send the packet and some callbacks to be  
    306      * called for incoming packets. 
     311     * called for incoming packets. This function exists for backwards 
     312     * compatibility. Transports should implement attach2 instead. 
    307313     * 
    308314     * Application should call #pjmedia_transport_attach() instead of  
     
    434440     */ 
    435441    pj_status_t (*destroy)(pjmedia_transport *tp); 
     442 
     443    /** 
     444     * This function is called by the stream when the transport is about 
     445     * to be used by the stream for the first time, and it tells the transport 
     446     * about remote RTP address to send the packet and some callbacks to be 
     447     * called for incoming packets. 
     448     * 
     449     * Application should call #pjmedia_transport_attach2() instead of 
     450     * calling this function directly. 
     451     */ 
     452    pj_status_t (*attach2)(pjmedia_transport *tp, 
     453                           pjmedia_transport_attach_param *att_param); 
    436454}; 
    437455 
     
    546564}; 
    547565 
     566 
     567/** 
     568 * This structure describes the data passed when calling 
     569 * #pjmedia_transport_attach2(). 
     570 */ 
     571struct pjmedia_transport_attach_param 
     572{ 
     573    /** 
     574     * The media stream. 
     575     */ 
     576    void *stream; 
     577 
     578    /** 
     579     * Indicate the stream type, either it's audio (PJMEDIA_TYPE_AUDIO)  
     580     * or video (PJMEDIA_TYPE_VIDEO). 
     581     */ 
     582    pjmedia_type media_type; 
     583 
     584    /** 
     585     * Remote RTP address to send RTP packet to. 
     586     */ 
     587    pj_sockaddr rem_addr; 
     588 
     589    /** 
     590     * Optional remote RTCP address. If the argument is NULL 
     591     * or if the address is zero, the RTCP address will be 
     592     * calculated from the RTP address (which is RTP port plus one). 
     593     */ 
     594    pj_sockaddr rem_rtcp; 
     595 
     596    /** 
     597     * Length of the remote address. 
     598     */ 
     599    unsigned addr_len; 
     600 
     601    /** 
     602     * Arbitrary user data to be set when the callbacks are called. 
     603     */ 
     604    void *user_data; 
     605 
     606    /** 
     607     * Callback to be called when RTP packet is received on the transport. 
     608     */ 
     609    void (*rtp_cb)(void *user_data, void *pkt, pj_ssize_t); 
     610 
     611    /** 
     612     * Callback to be called when RTCP packet is received on the transport. 
     613     */ 
     614    void (*rtcp_cb)(void *user_data, void *pkt, pj_ssize_t); 
     615}; 
    548616 
    549617/** 
     
    600668    } 
    601669    return NULL; 
     670} 
     671 
     672 
     673/** 
     674 * Attach callbacks to be called on receipt of incoming RTP/RTCP packets. 
     675 * This is just a simple wrapper which calls <tt>attach2()</tt> member of 
     676 * the transport if it is implemented, otherwise it calls <tt>attach()</tt> 
     677 * member of the transport. 
     678 * 
     679 * @param tp        The media transport. 
     680 * @param att_param The transport attach param. 
     681 * 
     682 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     683 */ 
     684PJ_INLINE(pj_status_t) pjmedia_transport_attach2(pjmedia_transport *tp, 
     685                                      pjmedia_transport_attach_param *att_param) 
     686{ 
     687    if (tp->op->attach2) { 
     688        return tp->op->attach2(tp, att_param); 
     689    } else { 
     690        return tp->op->attach(tp, att_param->user_data,  
     691                              (pj_sockaddr_t*)&att_param->rem_addr,  
     692                              (pj_sockaddr_t*)&att_param->rem_rtcp,  
     693                              att_param->addr_len, att_param->rtp_cb,  
     694                              att_param->rtcp_cb); 
     695    } 
    602696} 
    603697 
  • pjproject/trunk/pjmedia/src/pjmedia/stream.c

    r5434 r5478  
    20062006    char *p; 
    20072007    pj_status_t status; 
     2008    pjmedia_transport_attach_param att_param; 
    20082009 
    20092010    PJ_ASSERT_RETURN(endpt && info && p_stream, PJ_EINVAL); 
     
    23472348 
    23482349    stream->out_rtcp_pkt = pj_pool_alloc(pool, stream->out_rtcp_pkt_size); 
     2350    att_param.stream = stream; 
     2351    att_param.media_type = PJMEDIA_TYPE_AUDIO; 
     2352    att_param.user_data = stream; 
     2353    pj_sockaddr_cp(&att_param.rem_addr, &info->rem_addr); 
     2354    pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_rtcp); 
     2355    att_param.addr_len = pj_sockaddr_get_len(&info->rem_addr); 
     2356    att_param.rtp_cb = &on_rx_rtp; 
     2357    att_param.rtcp_cb = &on_rx_rtcp; 
    23492358 
    23502359    /* Only attach transport when stream is ready. */ 
    2351     status = pjmedia_transport_attach(tp, stream, &info->rem_addr, 
    2352                                       &info->rem_rtcp, 
    2353                                       pj_sockaddr_get_len(&info->rem_addr), 
    2354                                       &on_rx_rtp, &on_rx_rtcp); 
     2360    status = pjmedia_transport_attach2(tp, &att_param); 
    23552361    if (status != PJ_SUCCESS) 
    23562362        goto err_cleanup; 
  • pjproject/trunk/pjmedia/src/pjmedia/transport_adapter_sample.c

    r3841 r5478  
    2727static pj_status_t transport_get_info (pjmedia_transport *tp, 
    2828                                       pjmedia_transport_info *info); 
    29 static pj_status_t transport_attach   (pjmedia_transport *tp, 
    30                                        void *user_data, 
    31                                        const pj_sockaddr_t *rem_addr, 
    32                                        const pj_sockaddr_t *rem_rtcp, 
    33                                        unsigned addr_len, 
    34                                        void (*rtp_cb)(void*, 
    35                                                       void*, 
    36                                                       pj_ssize_t), 
    37                                        void (*rtcp_cb)(void*, 
    38                                                        void*, 
    39                                                        pj_ssize_t)); 
     29static pj_status_t transport_attach2  (pjmedia_transport *tp, 
     30                                       pjmedia_transport_attach_param *att_prm); 
    4031static void        transport_detach   (pjmedia_transport *tp, 
    4132                                       void *strm); 
     
    7768{ 
    7869    &transport_get_info, 
    79     &transport_attach, 
     70    NULL, 
    8071    &transport_detach, 
    8172    &transport_send_rtp, 
     
    8778    &transport_media_stop, 
    8879    &transport_simulate_lost, 
    89     &transport_destroy 
     80    &transport_destroy, 
     81    &transport_attach2, 
    9082}; 
    9183 
     
    10193    /* Stream information. */ 
    10294    void                *stream_user_data; 
     95    void                *stream_ref; 
    10396    void               (*stream_rtp_cb)(void *user_data, 
    10497                                        void *pkt, 
     
    191184} 
    192185 
    193  
    194 /* 
    195  * attach() is called by stream to register callbacks that we should 
     186/* 
     187 * attach2() is called by stream to register callbacks that we should 
    196188 * call on receipt of RTP and RTCP packets. 
    197189 */ 
    198 static pj_status_t transport_attach(pjmedia_transport *tp, 
    199                                     void *user_data, 
    200                                     const pj_sockaddr_t *rem_addr, 
    201                                     const pj_sockaddr_t *rem_rtcp, 
    202                                     unsigned addr_len, 
    203                                     void (*rtp_cb)(void*, 
    204                                                    void*, 
    205                                                    pj_ssize_t), 
    206                                     void (*rtcp_cb)(void*, 
    207                                                     void*, 
    208                                                     pj_ssize_t)) 
     190static pj_status_t transport_attach2(pjmedia_transport *tp, 
     191                                     pjmedia_transport_attach_param *att_param) 
    209192{ 
    210193    struct tp_adapter *adapter = (struct tp_adapter*)tp; 
     
    216199     */ 
    217200    pj_assert(adapter->stream_user_data == NULL); 
    218     adapter->stream_user_data = user_data; 
    219     adapter->stream_rtp_cb = rtp_cb; 
    220     adapter->stream_rtcp_cb = rtcp_cb; 
    221  
    222     status = pjmedia_transport_attach(adapter->slave_tp, adapter, rem_addr, 
    223                                       rem_rtcp, addr_len, &transport_rtp_cb, 
    224                                       &transport_rtcp_cb); 
     201    adapter->stream_user_data = att_param->user_data; 
     202    adapter->stream_rtp_cb = att_param->rtp_cb; 
     203    adapter->stream_rtcp_cb = att_param->rtcp_cb; 
     204    adapter->stream_ref = att_param->stream; 
     205 
     206    att_param->rtp_cb = &transport_rtp_cb; 
     207    att_param->rtcp_cb = &transport_rtcp_cb; 
     208    att_param->user_data = adapter; 
     209         
     210    status = pjmedia_transport_attach2(adapter->slave_tp, att_param); 
    225211    if (status != PJ_SUCCESS) { 
    226212        adapter->stream_user_data = NULL; 
    227213        adapter->stream_rtp_cb = NULL; 
    228214        adapter->stream_rtcp_cb = NULL; 
     215        adapter->stream_ref = NULL; 
    229216        return status; 
    230217    } 
     
    248235        adapter->stream_rtp_cb = NULL; 
    249236        adapter->stream_rtcp_cb = NULL; 
     237        adapter->stream_ref = NULL; 
    250238    } 
    251239} 
  • pjproject/trunk/pjmedia/src/pjmedia/vid_stream.c

    r5434 r5478  
    14251425    char *p; 
    14261426    pj_status_t status; 
     1427    pjmedia_transport_attach_param att_param; 
    14271428 
    14281429    if (!pool) { 
     
    16661667 
    16671668    stream->out_rtcp_pkt = pj_pool_alloc(pool, stream->out_rtcp_pkt_size); 
     1669    att_param.stream = stream; 
     1670    att_param.media_type = PJMEDIA_TYPE_VIDEO; 
     1671    att_param.user_data = stream; 
     1672    pj_sockaddr_cp(&att_param.rem_addr, &info->rem_addr); 
     1673    pj_sockaddr_cp(&att_param.rem_rtcp, &info->rem_rtcp); 
     1674    att_param.addr_len = pj_sockaddr_get_len(&info->rem_addr); 
     1675    att_param.rtp_cb = &on_rx_rtp; 
     1676    att_param.rtcp_cb = &on_rx_rtcp; 
    16681677 
    16691678    /* Only attach transport when stream is ready. */ 
    1670     status = pjmedia_transport_attach(tp, stream, &info->rem_addr,  
    1671                                       &info->rem_rtcp,  
    1672                                       pj_sockaddr_get_len(&info->rem_addr),  
    1673                                       &on_rx_rtp, &on_rx_rtcp); 
     1679    status = pjmedia_transport_attach2(tp, &att_param); 
    16741680    if (status != PJ_SUCCESS) 
    16751681        return status; 
Note: See TracChangeset for help on using the changeset viewer.