Ignore:
Timestamp:
Jun 22, 2006 6:49:45 PM (16 years ago)
Author:
bennylp
Message:

Added better API for media transport, and fixed bugs with pending RTP write operation in UDP media transport

File:
1 edited

Legend:

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

    r518 r539  
    6767     * about remote RTP address to send the packet and some callbacks to be  
    6868     * called for incoming packets. 
     69     * 
     70     * Application should call #pjmedia_transport_attach() instead of  
     71     * calling this function directly. 
    6972     */ 
    7073    pj_status_t (*attach)(pjmedia_transport *tp, 
    71                           pjmedia_stream *strm, 
     74                          void *user_data, 
    7275                          const pj_sockaddr_t *rem_addr, 
    7376                          unsigned addr_len, 
    74                           void (*rtp_cb)(pjmedia_stream*, 
    75                                          const void*, 
    76                                          pj_ssize_t), 
    77                           void (*rtcp_cb)(pjmedia_stream*, 
    78                                           const void*, 
    79                                           pj_ssize_t)); 
     77                          void (*rtp_cb)(void *user_data, 
     78                                         const void *pkt, 
     79                                         pj_ssize_t size), 
     80                          void (*rtcp_cb)(void *user_data, 
     81                                          const void *pkt, 
     82                                          pj_ssize_t size)); 
    8083 
    8184    /** 
    8285     * This function is called by the stream when the stream is no longer 
    8386     * need the transport (normally when the stream is about to be closed). 
     87     * 
     88     * Application should call #pjmedia_transport_detach() instead of  
     89     * calling this function directly. 
    8490     */ 
    8591    void (*detach)(pjmedia_transport *tp, 
    86                    pjmedia_stream *strm); 
     92                   void *user_data); 
    8793 
    8894    /** 
    8995     * This function is called by the stream to send RTP packet using the  
    9096     * transport. 
     97     * 
     98     * Application should call #pjmedia_transport_send_rtp() instead of  
     99     * calling this function directly. 
    91100     */ 
    92101    pj_status_t (*send_rtp)(pjmedia_transport *tp, 
     
    97106     * This function is called by the stream to send RTCP packet using the 
    98107     * transport. 
     108     * 
     109     * Application should call #pjmedia_transport_send_rtcp() instead of  
     110     * calling this function directly. 
    99111     */ 
    100112    pj_status_t (*send_rtcp)(pjmedia_transport *tp, 
     
    104116    /** 
    105117     * This function can be called to destroy this transport. 
     118     * 
     119     * Application should call #pjmedia_transport_close() instead of  
     120     * calling this function directly. 
    106121     */ 
    107122    pj_status_t (*destroy)(pjmedia_transport *tp); 
     
    130145 
    131146 
     147 
     148/** 
     149 * Attach callbacks to be called on receipt of incoming RTP/RTCP packets. 
     150 * This is just a simple wrapper which calls <tt>attach()</tt> member of  
     151 * the transport. 
     152 * 
     153 * @param tp        The media transport. 
     154 * @param user_data Arbitrary user data to be set when the callbacks are  
     155 *                  called. 
     156 * @param rem_addr  Remote RTP address to send RTP packet to. 
     157 * @param addr_len  Length of the remote address. 
     158 * @param rtp_cb    Callback to be called when RTP packet is received on 
     159 *                  the transport. 
     160 * @param rtcp_cb   Callback to be called when RTCP packet is received on 
     161 *                  the transport. 
     162 * 
     163 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     164 */ 
     165PJ_INLINE(pj_status_t) pjmedia_transport_attach(pjmedia_transport *tp, 
     166                                                void *user_data, 
     167                                                const pj_sockaddr_t *rem_addr, 
     168                                                unsigned addr_len, 
     169                                                void (*rtp_cb)(void *user_data, 
     170                                                               const void *pkt, 
     171                                                               pj_ssize_t), 
     172                                                void (*rtcp_cb)(void *usr_data, 
     173                                                                const void*pkt, 
     174                                                                pj_ssize_t)) 
     175{ 
     176    return tp->op->attach(tp, user_data, rem_addr, addr_len, rtp_cb, rtcp_cb); 
     177} 
     178 
     179 
     180/** 
     181 * Detach callbacks from the transport. 
     182 * This is just a simple wrapper which calls <tt>attach()</tt> member of  
     183 * the transport. 
     184 * 
     185 * @param tp        The media transport. 
     186 * @param user_data User data which must match the previously set value 
     187 *                  on attachment. 
     188 */ 
     189PJ_INLINE(void) pjmedia_transport_detach(pjmedia_transport *tp, 
     190                                         void *user_data) 
     191{ 
     192    tp->op->detach(tp, user_data); 
     193} 
     194 
     195 
     196/** 
     197 * Send RTP packet with the specified media transport. This is just a simple 
     198 * wrapper which calls <tt>send_rtp()</tt> member of the transport. 
     199 * 
     200 * @param tp        The media transport. 
     201 * @param pkt       The packet to send. 
     202 * @param size      Size of the packet. 
     203 * 
     204 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     205 */ 
     206PJ_INLINE(pj_status_t) pjmedia_transport_send_rtp(pjmedia_transport *tp, 
     207                                                  const void *pkt, 
     208                                                  pj_size_t size) 
     209{ 
     210    return (*tp->op->send_rtp)(tp, pkt, size); 
     211} 
     212 
     213 
     214/** 
     215 * Send RTCP packet with the specified media transport. This is just a simple 
     216 * wrapper which calls <tt>send_rtcp()</tt> member of the transport. 
     217 * 
     218 * @param tp        The media transport. 
     219 * @param pkt       The packet to send. 
     220 * @param size      Size of the packet. 
     221 * 
     222 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     223 */ 
     224PJ_INLINE(pj_status_t) pjmedia_transport_send_rtcp(pjmedia_transport *tp, 
     225                                                  const void *pkt, 
     226                                                  pj_size_t size) 
     227{ 
     228    return (*tp->op->send_rtcp)(tp, pkt, size); 
     229} 
     230 
     231 
     232/** 
     233 * Close media transport. This is just a simple wrapper which calls  
     234 * <tt>destroy()</tt> member of the transport. 
     235 * 
     236 * @param tp        The media transport. 
     237 * 
     238 * @return          PJ_SUCCESS on success, or the appropriate error code. 
     239 */ 
     240PJ_INLINE(pj_status_t) pjmedia_transport_close(pjmedia_transport *tp) 
     241{ 
     242    if (tp->op->destroy) 
     243        return (*tp->op->destroy)(tp); 
     244    else 
     245        return PJ_SUCCESS; 
     246} 
     247 
     248 
    132249PJ_END_DECL 
    133250 
Note: See TracChangeset for help on using the changeset viewer.