#include <netinet/in.h>
#include "asterisk/frame.h"
#include "asterisk/io.h"
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/linkedlists.h"
Include dependency graph for rtp.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Data Structures | |
struct | ast_rtp_protocol |
struct | ast_rtp_quality |
Defines | |
#define | AST_RTP_CISCO_DTMF (1 << 2) |
#define | AST_RTP_CN (1 << 1) |
#define | AST_RTP_DTMF (1 << 0) |
#define | AST_RTP_MAX AST_RTP_CISCO_DTMF |
#define | FLAG_3389_WARNING (1 << 0) |
#define | MAX_RTP_PT 256 |
Typedefs | |
typedef int(*) | ast_rtp_callback (struct ast_rtp *rtp, struct ast_frame *f, void *data) |
Enumerations | |
enum | ast_rtp_get_result { AST_RTP_GET_FAILED = 0, AST_RTP_TRY_PARTIAL, AST_RTP_TRY_NATIVE } |
enum | ast_rtp_options { AST_RTP_OPT_G726_NONSTANDARD = (1 << 0) } |
Functions | |
int | ast_rtcp_fd (struct ast_rtp *rtp) |
ast_frame * | ast_rtcp_read (struct ast_rtp *rtp) |
int | ast_rtcp_send_h261fur (void *data) |
Send an H.261 fast update request. Some devices need this rather than the XML message in SIP. | |
size_t | ast_rtp_alloc_size (void) |
Get the amount of space required to hold an RTP session. | |
int | ast_rtp_bridge (struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms) |
Bridge calls. If possible and allowed, initiate re-invite so the peers exchange media directly outside of Asterisk. | |
int | ast_rtp_codec_getformat (int pt) |
ast_codec_pref * | ast_rtp_codec_getpref (struct ast_rtp *rtp) |
int | ast_rtp_codec_setpref (struct ast_rtp *rtp, struct ast_codec_pref *prefs) |
void | ast_rtp_destroy (struct ast_rtp *rtp) |
int | ast_rtp_early_bridge (struct ast_channel *dest, struct ast_channel *src) |
If possible, create an early bridge directly between the devices without having to send a re-invite later. | |
int | ast_rtp_fd (struct ast_rtp *rtp) |
ast_rtp * | ast_rtp_get_bridged (struct ast_rtp *rtp) |
void | ast_rtp_get_current_formats (struct ast_rtp *rtp, int *astFormats, int *nonAstFormats) |
Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs. | |
int | ast_rtp_get_peer (struct ast_rtp *rtp, struct sockaddr_in *them) |
char * | ast_rtp_get_quality (struct ast_rtp *rtp, struct ast_rtp_quality *qual) |
Return RTCP quality string. | |
int | ast_rtp_get_rtpholdtimeout (struct ast_rtp *rtp) |
Get rtp hold timeout. | |
int | ast_rtp_get_rtpkeepalive (struct ast_rtp *rtp) |
Get RTP keepalive interval. | |
int | ast_rtp_get_rtptimeout (struct ast_rtp *rtp) |
Get rtp timeout. | |
void | ast_rtp_get_us (struct ast_rtp *rtp, struct sockaddr_in *us) |
int | ast_rtp_getnat (struct ast_rtp *rtp) |
void | ast_rtp_init (void) |
Initialize the RTP system in Asterisk. | |
int | ast_rtp_lookup_code (struct ast_rtp *rtp, int isAstFormat, int code) |
Looks up an RTP code out of our *static* outbound list. | |
char * | ast_rtp_lookup_mime_multiple (char *buf, size_t size, const int capability, const int isAstFormat, enum ast_rtp_options options) |
Build a string of MIME subtype names from a capability list. | |
const char * | ast_rtp_lookup_mime_subtype (int isAstFormat, int code, enum ast_rtp_options options) |
Mapping an Asterisk code into a MIME subtype (string):. | |
rtpPayloadType | ast_rtp_lookup_pt (struct ast_rtp *rtp, int pt) |
Mapping between RTP payload format codes and Asterisk codes:. | |
int | ast_rtp_make_compatible (struct ast_channel *dest, struct ast_channel *src, int media) |
ast_rtp * | ast_rtp_new (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode) |
Initializate a RTP session. | |
void | ast_rtp_new_init (struct ast_rtp *rtp) |
Initialize a new RTP structure. | |
ast_rtp * | ast_rtp_new_with_bindaddr (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr in) |
Initializate a RTP session using an in_addr structure. | |
int | ast_rtp_proto_register (struct ast_rtp_protocol *proto) |
Register interface to channel driver. | |
void | ast_rtp_proto_unregister (struct ast_rtp_protocol *proto) |
Unregister interface to channel driver. | |
void | ast_rtp_pt_clear (struct ast_rtp *rtp) |
Setting RTP payload types from lines in a SDP description:. | |
void | ast_rtp_pt_copy (struct ast_rtp *dest, struct ast_rtp *src) |
Copy payload types between RTP structures. | |
void | ast_rtp_pt_default (struct ast_rtp *rtp) |
Set payload types to defaults. | |
ast_frame * | ast_rtp_read (struct ast_rtp *rtp) |
int | ast_rtp_reload (void) |
void | ast_rtp_reset (struct ast_rtp *rtp) |
int | ast_rtp_sendcng (struct ast_rtp *rtp, int level) |
generate comfort noice (CNG) | |
int | ast_rtp_senddigit_begin (struct ast_rtp *rtp, char digit) |
Send begin frames for DTMF. | |
int | ast_rtp_senddigit_end (struct ast_rtp *rtp, char digit) |
void | ast_rtp_set_callback (struct ast_rtp *rtp, ast_rtp_callback callback) |
void | ast_rtp_set_data (struct ast_rtp *rtp, void *data) |
void | ast_rtp_set_m_type (struct ast_rtp *rtp, int pt) |
Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line). | |
void | ast_rtp_set_peer (struct ast_rtp *rtp, struct sockaddr_in *them) |
void | ast_rtp_set_rtpholdtimeout (struct ast_rtp *rtp, int timeout) |
Set rtp hold timeout. | |
void | ast_rtp_set_rtpkeepalive (struct ast_rtp *rtp, int period) |
set RTP keepalive interval | |
void | ast_rtp_set_rtpmap_type (struct ast_rtp *rtp, int pt, char *mimeType, char *mimeSubtype, enum ast_rtp_options options) |
Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line. | |
void | ast_rtp_set_rtptimeout (struct ast_rtp *rtp, int timeout) |
Set rtp timeout. | |
void | ast_rtp_set_rtptimers_onhold (struct ast_rtp *rtp) |
void | ast_rtp_setdtmf (struct ast_rtp *rtp, int dtmf) |
Indicate whether this RTP session is carrying DTMF or not. | |
void | ast_rtp_setdtmfcompensate (struct ast_rtp *rtp, int compensate) |
Compensate for devices that send RFC2833 packets all at once. | |
void | ast_rtp_setnat (struct ast_rtp *rtp, int nat) |
void | ast_rtp_setstun (struct ast_rtp *rtp, int stun_enable) |
Enable STUN capability. | |
int | ast_rtp_settos (struct ast_rtp *rtp, int tos) |
void | ast_rtp_stop (struct ast_rtp *rtp) |
void | ast_rtp_stun_request (struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username) |
int | ast_rtp_write (struct ast_rtp *rtp, struct ast_frame *f) |
RTP is defined in RFC 3550.
Definition in file rtp.h.
#define AST_RTP_CISCO_DTMF (1 << 2) |
#define AST_RTP_CN (1 << 1) |
'Comfort Noise' (RFC3389)
Definition at line 45 of file rtp.h.
Referenced by ast_rtp_read(), and ast_rtp_sendcng().
#define AST_RTP_DTMF (1 << 0) |
DTMF (RFC2833)
Definition at line 43 of file rtp.h.
Referenced by add_noncodec_to_sdp(), ast_rtp_read(), ast_rtp_senddigit_begin(), bridge_p2p_rtp_write(), check_user_full(), create_addr(), create_addr_from_peer(), oh323_alloc(), oh323_request(), process_sdp(), sip_alloc(), and sip_dtmfmode().
#define AST_RTP_MAX AST_RTP_CISCO_DTMF |
Maximum RTP-specific code
Definition at line 49 of file rtp.h.
Referenced by add_sdp(), and ast_rtp_lookup_mime_multiple().
#define MAX_RTP_PT 256 |
Definition at line 51 of file rtp.h.
Referenced by ast_rtp_get_current_formats(), ast_rtp_lookup_code(), ast_rtp_lookup_pt(), ast_rtp_pt_clear(), ast_rtp_pt_copy(), ast_rtp_pt_default(), ast_rtp_set_m_type(), and ast_rtp_set_rtpmap_type().
typedef int(*) ast_rtp_callback(struct ast_rtp *rtp, struct ast_frame *f, void *data) |
enum ast_rtp_get_result |
Definition at line 57 of file rtp.h.
00057 { 00058 /*! Failed to find the RTP structure */ 00059 AST_RTP_GET_FAILED = 0, 00060 /*! RTP structure exists but true native bridge can not occur so try partial */ 00061 AST_RTP_TRY_PARTIAL, 00062 /*! RTP structure exists and native bridge can occur */ 00063 AST_RTP_TRY_NATIVE, 00064 };
enum ast_rtp_options |
int ast_rtcp_fd | ( | struct ast_rtp * | rtp | ) |
Definition at line 517 of file rtp.c.
References ast_rtp::rtcp, and ast_rtcp::s.
Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), sip_new(), and start_rtp().
Definition at line 822 of file rtp.c.
References ast_rtcp::accumulated_transit, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_verbose(), CRASH, ast_frame::datalen, ast_rtp::f, f, ast_frame::frametype, len, LOG_DEBUG, LOG_WARNING, ast_frame::mallocd, ast_rtcp::maxrtt, ast_rtcp::minrtt, ast_rtp::nat, option_debug, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, rtcp_debug_test_addr(), RTCP_PT_BYE, RTCP_PT_FUR, RTCP_PT_RR, RTCP_PT_SDES, RTCP_PT_SR, ast_rtcp::rtt, ast_rtcp::rxlsr, ast_rtcp::s, ast_frame::samples, ast_rtcp::soc, ast_rtcp::spc, ast_frame::src, ast_frame::subclass, ast_rtcp::them, ast_rtcp::themrxlsr, and timeval2ntp().
Referenced by oh323_read(), sip_rtp_read(), and skinny_rtp_read().
00823 { 00824 socklen_t len; 00825 int position, i, packetwords; 00826 int res; 00827 struct sockaddr_in sin; 00828 unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET]; 00829 unsigned int *rtcpheader; 00830 int pt; 00831 struct timeval now; 00832 unsigned int length; 00833 int rc; 00834 double rtt = 0; 00835 double a; 00836 double dlsr; 00837 double lsr; 00838 unsigned int msw; 00839 unsigned int lsw; 00840 unsigned int comp; 00841 struct ast_frame *f = &ast_null_frame; 00842 00843 if (!rtp || !rtp->rtcp) 00844 return &ast_null_frame; 00845 00846 len = sizeof(sin); 00847 00848 res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 00849 0, (struct sockaddr *)&sin, &len); 00850 rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET); 00851 00852 if (res < 0) { 00853 if (errno == EBADF) 00854 CRASH; 00855 if (errno != EAGAIN) { 00856 ast_log(LOG_WARNING, "RTCP Read error: %s. Hanging up.\n", strerror(errno)); 00857 return NULL; 00858 } 00859 return &ast_null_frame; 00860 } 00861 00862 packetwords = res / 4; 00863 00864 if (rtp->nat) { 00865 /* Send to whoever sent to us */ 00866 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || 00867 (rtp->rtcp->them.sin_port != sin.sin_port)) { 00868 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); 00869 if (option_debug || rtpdebug) 00870 ast_log(LOG_DEBUG, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); 00871 } 00872 } 00873 00874 if (option_debug) 00875 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res); 00876 00877 /* Process a compound packet */ 00878 position = 0; 00879 while (position < packetwords) { 00880 i = position; 00881 length = ntohl(rtcpheader[i]); 00882 pt = (length & 0xff0000) >> 16; 00883 rc = (length & 0x1f000000) >> 24; 00884 length &= 0xffff; 00885 00886 if ((i + length) > packetwords) { 00887 ast_log(LOG_WARNING, "RTCP Read too short\n"); 00888 return &ast_null_frame; 00889 } 00890 00891 if (rtcp_debug_test_addr(&sin)) { 00892 ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)); 00893 ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown"); 00894 ast_verbose("Reception reports: %d\n", rc); 00895 ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]); 00896 } 00897 00898 i += 2; /* Advance past header and ssrc */ 00899 00900 switch (pt) { 00901 case RTCP_PT_SR: 00902 gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */ 00903 rtp->rtcp->spc = ntohl(rtcpheader[i+3]); 00904 rtp->rtcp->soc = ntohl(rtcpheader[i + 4]); 00905 rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/ 00906 00907 if (rtcp_debug_test_addr(&sin)) { 00908 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096); 00909 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2])); 00910 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4])); 00911 } 00912 i += 5; 00913 if (rc < 1) 00914 break; 00915 /* Intentional fall through */ 00916 case RTCP_PT_RR: 00917 /* This is the place to calculate RTT */ 00918 /* Don't handle multiple reception reports (rc > 1) yet */ 00919 gettimeofday(&now, NULL); 00920 timeval2ntp(now, &msw, &lsw); 00921 /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */ 00922 if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */ 00923 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16); 00924 a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.); 00925 lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.); 00926 dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.); 00927 rtt = a - dlsr - lsr; 00928 if (rtt >= 0) { 00929 rtp->rtcp->accumulated_transit += rtt; 00930 rtp->rtcp->rtt = rtt; 00931 if (rtp->rtcp->maxrtt < rtt) 00932 rtp->rtcp->maxrtt = rtt; 00933 if (rtp->rtcp->minrtt > rtt) 00934 rtp->rtcp->minrtt = rtt; 00935 } 00936 } 00937 rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]); 00938 rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff; 00939 if (rtcp_debug_test_addr(&sin)) { 00940 ast_verbose(" Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24)); 00941 ast_verbose(" Packets lost so far: %d\n", rtp->rtcp->reported_lost); 00942 ast_verbose(" Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff)); 00943 ast_verbose(" Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16); 00944 ast_verbose(" Interarrival jitter: %u\n", rtp->rtcp->reported_jitter); 00945 ast_verbose(" Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096); 00946 ast_verbose(" DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0); 00947 if (rtt) 00948 ast_verbose(" RTT: %f(sec)\n", rtt); 00949 } 00950 break; 00951 case RTCP_PT_FUR: 00952 if (rtcp_debug_test_addr(&sin)) 00953 ast_verbose("Received an RTCP Fast Update Request\n"); 00954 rtp->f.frametype = AST_FRAME_CONTROL; 00955 rtp->f.subclass = AST_CONTROL_VIDUPDATE; 00956 rtp->f.datalen = 0; 00957 rtp->f.samples = 0; 00958 rtp->f.mallocd = 0; 00959 rtp->f.src = "RTP"; 00960 f = &rtp->f; 00961 break; 00962 case RTCP_PT_SDES: 00963 if (rtcp_debug_test_addr(&sin)) 00964 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); 00965 break; 00966 case RTCP_PT_BYE: 00967 if (rtcp_debug_test_addr(&sin)) 00968 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); 00969 break; 00970 default: 00971 if (option_debug) 00972 ast_log(LOG_DEBUG, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); 00973 break; 00974 } 00975 position += (length + 1); 00976 } 00977 00978 return f; 00979 }
int ast_rtcp_send_h261fur | ( | void * | data | ) |
Send an H.261 fast update request. Some devices need this rather than the XML message in SIP.
Definition at line 2291 of file rtp.c.
References ast_rtcp_write(), ast_rtp::rtcp, and ast_rtcp::sendfur.
02292 { 02293 struct ast_rtp *rtp = data; 02294 int res; 02295 02296 rtp->rtcp->sendfur = 1; 02297 res = ast_rtcp_write(data); 02298 02299 return res; 02300 }
size_t ast_rtp_alloc_size | ( | void | ) |
Get the amount of space required to hold an RTP session.
Definition at line 397 of file rtp.c.
Referenced by process_sdp().
00398 { 00399 return sizeof(struct ast_rtp); 00400 }
int ast_rtp_bridge | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1, | |||
int | flags, | |||
struct ast_frame ** | fo, | |||
struct ast_channel ** | rc, | |||
int | timeoutms | |||
) |
Bridge calls. If possible and allowed, initiate re-invite so the peers exchange media directly outside of Asterisk.
Definition at line 3185 of file rtp.c.
References AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, ast_set_flag, ast_test_flag, ast_verbose(), bridge_native_loop(), bridge_p2p_loop(), FLAG_DTMF_COMPENSATE, FLAG_HAS_DTMF, FLAG_P2P_NEED_DTMF, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_WARNING, option_debug, option_verbose, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel_tech::send_digit_begin, ast_channel::tech, ast_channel::tech_pvt, and VERBOSE_PREFIX_3.
03186 { 03187 struct ast_rtp *p0 = NULL, *p1 = NULL; /* Audio RTP Channels */ 03188 struct ast_rtp *vp0 = NULL, *vp1 = NULL; /* Video RTP channels */ 03189 struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL; 03190 enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED; 03191 enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED; 03192 enum ast_bridge_result res = AST_BRIDGE_FAILED; 03193 int codec0 = 0, codec1 = 0; 03194 void *pvt0 = NULL, *pvt1 = NULL; 03195 03196 /* Lock channels */ 03197 ast_channel_lock(c0); 03198 while(ast_channel_trylock(c1)) { 03199 ast_channel_unlock(c0); 03200 usleep(1); 03201 ast_channel_lock(c0); 03202 } 03203 03204 /* Find channel driver interfaces */ 03205 if (!(pr0 = get_proto(c0))) { 03206 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name); 03207 ast_channel_unlock(c0); 03208 ast_channel_unlock(c1); 03209 return AST_BRIDGE_FAILED; 03210 } 03211 if (!(pr1 = get_proto(c1))) { 03212 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name); 03213 ast_channel_unlock(c0); 03214 ast_channel_unlock(c1); 03215 return AST_BRIDGE_FAILED; 03216 } 03217 03218 /* Get channel specific interface structures */ 03219 pvt0 = c0->tech_pvt; 03220 pvt1 = c1->tech_pvt; 03221 03222 /* Get audio and video interface (if native bridge is possible) */ 03223 audio_p0_res = pr0->get_rtp_info(c0, &p0); 03224 video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED; 03225 audio_p1_res = pr1->get_rtp_info(c1, &p1); 03226 video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED; 03227 03228 /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */ 03229 if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE)) 03230 audio_p0_res = AST_RTP_GET_FAILED; 03231 if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE)) 03232 audio_p1_res = AST_RTP_GET_FAILED; 03233 03234 /* Check if a bridge is possible (partial/native) */ 03235 if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) { 03236 /* Somebody doesn't want to play... */ 03237 ast_channel_unlock(c0); 03238 ast_channel_unlock(c1); 03239 return AST_BRIDGE_FAILED_NOWARN; 03240 } 03241 03242 /* If we need to feed DTMF frames into the core then only do a partial native bridge */ 03243 if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) { 03244 ast_set_flag(p0, FLAG_P2P_NEED_DTMF); 03245 audio_p0_res = AST_RTP_TRY_PARTIAL; 03246 } 03247 03248 if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) { 03249 ast_set_flag(p1, FLAG_P2P_NEED_DTMF); 03250 audio_p1_res = AST_RTP_TRY_PARTIAL; 03251 } 03252 03253 /* If both sides are not using the same method of DTMF transmission 03254 * (ie: one is RFC2833, other is INFO... then we can not do direct media. 03255 * -------------------------------------------------- 03256 * | DTMF Mode | HAS_DTMF | Accepts Begin Frames | 03257 * |-----------|------------|-----------------------| 03258 * | Inband | False | True | 03259 * | RFC2833 | True | True | 03260 * | SIP INFO | False | False | 03261 * -------------------------------------------------- 03262 * However, if DTMF from both channels is being monitored by the core, then 03263 * we can still do packet-to-packet bridging, because passing through the 03264 * core will handle DTMF mode translation. 03265 */ 03266 if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) || 03267 (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) { 03268 if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) { 03269 ast_channel_unlock(c0); 03270 ast_channel_unlock(c1); 03271 return AST_BRIDGE_FAILED_NOWARN; 03272 } 03273 audio_p0_res = AST_RTP_TRY_PARTIAL; 03274 audio_p1_res = AST_RTP_TRY_PARTIAL; 03275 } 03276 03277 /* If the core will need to compensate and the P2P bridge will need to feed up DTMF frames then we can not reliably do so yet, so do not P2P bridge */ 03278 if ((audio_p0_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p0, FLAG_P2P_NEED_DTMF) && ast_test_flag(p0, FLAG_DTMF_COMPENSATE)) || 03279 (audio_p1_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p1, FLAG_P2P_NEED_DTMF) && ast_test_flag(p1, FLAG_DTMF_COMPENSATE))) { 03280 ast_channel_unlock(c0); 03281 ast_channel_unlock(c1); 03282 return AST_BRIDGE_FAILED_NOWARN; 03283 } 03284 03285 /* Get codecs from both sides */ 03286 codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0; 03287 codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0; 03288 if (codec0 && codec1 && !(codec0 & codec1)) { 03289 /* Hey, we can't do native bridging if both parties speak different codecs */ 03290 if (option_debug) 03291 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1); 03292 ast_channel_unlock(c0); 03293 ast_channel_unlock(c1); 03294 return AST_BRIDGE_FAILED_NOWARN; 03295 } 03296 03297 /* If either side can only do a partial bridge, then don't try for a true native bridge */ 03298 if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) { 03299 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */ 03300 if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) { 03301 if (option_debug) 03302 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n"); 03303 ast_channel_unlock(c0); 03304 ast_channel_unlock(c1); 03305 return AST_BRIDGE_FAILED_NOWARN; 03306 } 03307 if (option_verbose > 2) 03308 ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name); 03309 res = bridge_p2p_loop(c0, c1, p0, p1, timeoutms, flags, fo, rc, pvt0, pvt1); 03310 } else { 03311 if (option_verbose > 2) 03312 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name); 03313 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1); 03314 } 03315 03316 return res; 03317 }
int ast_rtp_codec_getformat | ( | int | pt | ) |
Definition at line 2671 of file rtp.c.
References rtpPayloadType::code, and static_RTP_PT.
Referenced by process_sdp().
02672 { 02673 if (pt < 0 || pt > MAX_RTP_PT) 02674 return 0; /* bogus payload type */ 02675 02676 if (static_RTP_PT[pt].isAstFormat) 02677 return static_RTP_PT[pt].code; 02678 else 02679 return 0; 02680 }
struct ast_codec_pref* ast_rtp_codec_getpref | ( | struct ast_rtp * | rtp | ) |
Definition at line 2666 of file rtp.c.
References ast_rtp::pref.
Referenced by add_codec_to_sdp(), and process_sdp().
02667 { 02668 return &rtp->pref; 02669 }
int ast_rtp_codec_setpref | ( | struct ast_rtp * | rtp, | |
struct ast_codec_pref * | prefs | |||
) |
Definition at line 2653 of file rtp.c.
References ast_smoother_free(), ast_codec_pref::framing, ast_codec_pref::order, ast_rtp::pref, prefs, and ast_rtp::smoother.
Referenced by __oh323_rtp_create(), check_user_full(), create_addr_from_peer(), process_sdp(), register_verify(), set_peer_capabilities(), start_rtp(), and transmit_response_with_sdp().
02654 { 02655 int x; 02656 for (x = 0; x < 32; x++) { /* Ugly way */ 02657 rtp->pref.order[x] = prefs->order[x]; 02658 rtp->pref.framing[x] = prefs->framing[x]; 02659 } 02660 if (rtp->smoother) 02661 ast_smoother_free(rtp->smoother); 02662 rtp->smoother = NULL; 02663 return 0; 02664 }
void ast_rtp_destroy | ( | struct ast_rtp * | rtp | ) |
Definition at line 2073 of file rtp.c.
References ast_io_remove(), ast_mutex_destroy(), ast_sched_del(), ast_smoother_free(), ast_verbose(), ast_rtp::bridge_lock, ast_rtcp::expected_prior, free, ast_rtp::io, ast_rtp::ioid, ast_rtcp::received_prior, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtcp::rr_count, ast_rtp::rtcp, rtcp_debug_test_addr(), ast_rtcp::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::rxtransit, ast_rtcp::s, ast_rtp::s, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::smoother, ast_rtcp::sr_count, ast_rtp::ssrc, ast_rtp::them, ast_rtp::themssrc, and ast_rtp::txcount.
Referenced by __oh323_destroy(), __sip_destroy(), check_user_full(), cleanup_connection(), create_addr_from_peer(), destroy_endpoint(), gtalk_free_pvt(), mgcp_hangup(), oh323_alloc(), skinny_hangup(), start_rtp(), and unalloc_sub().
02074 { 02075 if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) { 02076 /*Print some info on the call here */ 02077 ast_verbose(" RTP-stats\n"); 02078 ast_verbose("* Our Receiver:\n"); 02079 ast_verbose(" SSRC: %u\n", rtp->themssrc); 02080 ast_verbose(" Received packets: %u\n", rtp->rxcount); 02081 ast_verbose(" Lost packets: %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior); 02082 ast_verbose(" Jitter: %.4f\n", rtp->rxjitter); 02083 ast_verbose(" Transit: %.4f\n", rtp->rxtransit); 02084 ast_verbose(" RR-count: %u\n", rtp->rtcp->rr_count); 02085 ast_verbose("* Our Sender:\n"); 02086 ast_verbose(" SSRC: %u\n", rtp->ssrc); 02087 ast_verbose(" Sent packets: %u\n", rtp->txcount); 02088 ast_verbose(" Lost packets: %u\n", rtp->rtcp->reported_lost); 02089 ast_verbose(" Jitter: %u\n", rtp->rtcp->reported_jitter); 02090 ast_verbose(" SR-count: %u\n", rtp->rtcp->sr_count); 02091 ast_verbose(" RTT: %f\n", rtp->rtcp->rtt); 02092 } 02093 02094 if (rtp->smoother) 02095 ast_smoother_free(rtp->smoother); 02096 if (rtp->ioid) 02097 ast_io_remove(rtp->io, rtp->ioid); 02098 if (rtp->s > -1) 02099 close(rtp->s); 02100 if (rtp->rtcp) { 02101 if (rtp->rtcp->schedid > 0) 02102 ast_sched_del(rtp->sched, rtp->rtcp->schedid); 02103 close(rtp->rtcp->s); 02104 free(rtp->rtcp); 02105 rtp->rtcp=NULL; 02106 } 02107 02108 ast_mutex_destroy(&rtp->bridge_lock); 02109 02110 free(rtp); 02111 }
int ast_rtp_early_bridge | ( | struct ast_channel * | dest, | |
struct ast_channel * | src | |||
) |
If possible, create an early bridge directly between the devices without having to send a re-invite later.
Definition at line 1459 of file rtp.c.
References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer.
Referenced by wait_for_answer().
01460 { 01461 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ 01462 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ 01463 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; 01464 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; 01465 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 01466 int srccodec, destcodec, nat_active = 0; 01467 01468 /* Lock channels */ 01469 ast_channel_lock(dest); 01470 if (src) { 01471 while(ast_channel_trylock(src)) { 01472 ast_channel_unlock(dest); 01473 usleep(1); 01474 ast_channel_lock(dest); 01475 } 01476 } 01477 01478 /* Find channel driver interfaces */ 01479 destpr = get_proto(dest); 01480 if (src) 01481 srcpr = get_proto(src); 01482 if (!destpr) { 01483 if (option_debug) 01484 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name); 01485 ast_channel_unlock(dest); 01486 if (src) 01487 ast_channel_unlock(src); 01488 return 0; 01489 } 01490 if (!srcpr) { 01491 if (option_debug) 01492 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src ? src->name : "<unspecified>"); 01493 ast_channel_unlock(dest); 01494 if (src) 01495 ast_channel_unlock(src); 01496 return 0; 01497 } 01498 01499 /* Get audio and video interface (if native bridge is possible) */ 01500 audio_dest_res = destpr->get_rtp_info(dest, &destp); 01501 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED; 01502 if (srcpr) { 01503 audio_src_res = srcpr->get_rtp_info(src, &srcp); 01504 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED; 01505 } 01506 01507 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ 01508 if (audio_dest_res != AST_RTP_TRY_NATIVE) { 01509 /* Somebody doesn't want to play... */ 01510 ast_channel_unlock(dest); 01511 if (src) 01512 ast_channel_unlock(src); 01513 return 0; 01514 } 01515 if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec) 01516 srccodec = srcpr->get_codec(src); 01517 else 01518 srccodec = 0; 01519 if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec) 01520 destcodec = destpr->get_codec(dest); 01521 else 01522 destcodec = 0; 01523 /* Ensure we have at least one matching codec */ 01524 if (!(srccodec & destcodec)) { 01525 ast_channel_unlock(dest); 01526 if (src) 01527 ast_channel_unlock(src); 01528 return 0; 01529 } 01530 /* Consider empty media as non-existant */ 01531 if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr) 01532 srcp = NULL; 01533 /* If the client has NAT stuff turned on then just safe NAT is active */ 01534 if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE))) 01535 nat_active = 1; 01536 /* Bridge media early */ 01537 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, nat_active)) 01538 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src ? src->name : "<unspecified>"); 01539 ast_channel_unlock(dest); 01540 if (src) 01541 ast_channel_unlock(src); 01542 if (option_debug) 01543 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", dest->name, src ? src->name : "<unspecified>"); 01544 return 1; 01545 }
int ast_rtp_fd | ( | struct ast_rtp * | rtp | ) |
Definition at line 512 of file rtp.c.
References ast_rtp::s.
Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), mgcp_new(), sip_new(), skinny_new(), and start_rtp().
00513 { 00514 return rtp->s; 00515 }
Definition at line 1995 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, and ast_rtp::bridged.
Referenced by ast_rtp_read(), and do_monitor().
01996 { 01997 struct ast_rtp *bridged = NULL; 01998 01999 ast_mutex_lock(&rtp->bridge_lock); 02000 bridged = rtp->bridged; 02001 ast_mutex_unlock(&rtp->bridge_lock); 02002 02003 return bridged; 02004 }
void ast_rtp_get_current_formats | ( | struct ast_rtp * | rtp, | |
int * | astFormats, | |||
int * | nonAstFormats | |||
) |
Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs.
Definition at line 1665 of file rtp.c.
References ast_mutex_lock(), ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, and MAX_RTP_PT.
Referenced by process_sdp().
01667 { 01668 int pt; 01669 01670 ast_mutex_lock(&rtp->bridge_lock); 01671 01672 *astFormats = *nonAstFormats = 0; 01673 for (pt = 0; pt < MAX_RTP_PT; ++pt) { 01674 if (rtp->current_RTP_PT[pt].isAstFormat) { 01675 *astFormats |= rtp->current_RTP_PT[pt].code; 01676 } else { 01677 *nonAstFormats |= rtp->current_RTP_PT[pt].code; 01678 } 01679 } 01680 01681 ast_mutex_unlock(&rtp->bridge_lock); 01682 01683 return; 01684 }
int ast_rtp_get_peer | ( | struct ast_rtp * | rtp, | |
struct sockaddr_in * | them | |||
) |
Definition at line 1977 of file rtp.c.
References ast_rtp::them.
Referenced by add_sdp(), bridge_native_loop(), do_monitor(), oh323_set_rtp_peer(), sip_set_rtp_peer(), and transmit_modify_with_sdp().
01978 { 01979 if ((them->sin_family != AF_INET) || 01980 (them->sin_port != rtp->them.sin_port) || 01981 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) { 01982 them->sin_family = AF_INET; 01983 them->sin_port = rtp->them.sin_port; 01984 them->sin_addr = rtp->them.sin_addr; 01985 return 1; 01986 } 01987 return 0; 01988 }
char* ast_rtp_get_quality | ( | struct ast_rtp * | rtp, | |
struct ast_rtp_quality * | qual | |||
) |
Return RTCP quality string.
Definition at line 2043 of file rtp.c.
References ast_rtcp::expected_prior, ast_rtp_quality::local_count, ast_rtp_quality::local_jitter, ast_rtp_quality::local_lostpackets, ast_rtp_quality::local_ssrc, ast_rtcp::quality, ast_rtcp::received_prior, ast_rtp_quality::remote_count, ast_rtp_quality::remote_jitter, ast_rtp_quality::remote_lostpackets, ast_rtp_quality::remote_ssrc, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, ast_rtcp::rtt, ast_rtp_quality::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::ssrc, ast_rtp::themssrc, and ast_rtp::txcount.
Referenced by acf_channel_read(), handle_request_bye(), and sip_hangup().
02044 { 02045 /* 02046 *ssrc our ssrc 02047 *themssrc their ssrc 02048 *lp lost packets 02049 *rxjitter our calculated jitter(rx) 02050 *rxcount no. received packets 02051 *txjitter reported jitter of the other end 02052 *txcount transmitted packets 02053 *rlp remote lost packets 02054 *rtt round trip time 02055 */ 02056 02057 if (qual) { 02058 qual->local_ssrc = rtp->ssrc; 02059 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior; 02060 qual->local_jitter = rtp->rxjitter; 02061 qual->local_count = rtp->rxcount; 02062 qual->remote_ssrc = rtp->themssrc; 02063 qual->remote_lostpackets = rtp->rtcp->reported_lost; 02064 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0; 02065 qual->remote_count = rtp->txcount; 02066 qual->rtt = rtp->rtcp->rtt; 02067 } 02068 snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt); 02069 02070 return rtp->rtcp->quality; 02071 }
int ast_rtp_get_rtpholdtimeout | ( | struct ast_rtp * | rtp | ) |
Get rtp hold timeout.
Definition at line 567 of file rtp.c.
References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout.
Referenced by do_monitor().
00568 { 00569 if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ 00570 return 0; 00571 return rtp->rtpholdtimeout; 00572 }
int ast_rtp_get_rtpkeepalive | ( | struct ast_rtp * | rtp | ) |
Get RTP keepalive interval.
Definition at line 575 of file rtp.c.
References ast_rtp::rtpkeepalive.
Referenced by do_monitor().
00576 { 00577 return rtp->rtpkeepalive; 00578 }
int ast_rtp_get_rtptimeout | ( | struct ast_rtp * | rtp | ) |
Get rtp timeout.
Definition at line 559 of file rtp.c.
References ast_rtp::rtptimeout.
Referenced by do_monitor().
00560 { 00561 if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ 00562 return 0; 00563 return rtp->rtptimeout; 00564 }
void ast_rtp_get_us | ( | struct ast_rtp * | rtp, | |
struct sockaddr_in * | us | |||
) |
Definition at line 1990 of file rtp.c.
References ast_rtp::us.
Referenced by add_sdp(), external_rtp_create(), gtalk_create_candidates(), handle_open_receive_channel_ack_message(), and oh323_set_rtp_peer().
int ast_rtp_getnat | ( | struct ast_rtp * | rtp | ) |
Definition at line 595 of file rtp.c.
References ast_test_flag, and FLAG_NAT_ACTIVE.
Referenced by sip_get_rtp_peer().
00596 { 00597 return ast_test_flag(rtp, FLAG_NAT_ACTIVE); 00598 }
void ast_rtp_init | ( | void | ) |
Initialize the RTP system in Asterisk.
Definition at line 3702 of file rtp.c.
References ast_cli_register_multiple(), ast_rtp_reload(), and cli_rtp.
Referenced by main().
03703 { 03704 ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry)); 03705 ast_rtp_reload(); 03706 }
int ast_rtp_lookup_code | ( | struct ast_rtp * | rtp, | |
int | isAstFormat, | |||
int | code | |||
) |
Looks up an RTP code out of our *static* outbound list.
Definition at line 1708 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.
Referenced by add_codec_to_answer(), add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_write(), and bridge_p2p_rtp_write().
01709 { 01710 int pt = 0; 01711 01712 ast_mutex_lock(&rtp->bridge_lock); 01713 01714 if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat && 01715 code == rtp->rtp_lookup_code_cache_code) { 01716 /* Use our cached mapping, to avoid the overhead of the loop below */ 01717 pt = rtp->rtp_lookup_code_cache_result; 01718 ast_mutex_unlock(&rtp->bridge_lock); 01719 return pt; 01720 } 01721 01722 /* Check the dynamic list first */ 01723 for (pt = 0; pt < MAX_RTP_PT; ++pt) { 01724 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) { 01725 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; 01726 rtp->rtp_lookup_code_cache_code = code; 01727 rtp->rtp_lookup_code_cache_result = pt; 01728 ast_mutex_unlock(&rtp->bridge_lock); 01729 return pt; 01730 } 01731 } 01732 01733 /* Then the static list */ 01734 for (pt = 0; pt < MAX_RTP_PT; ++pt) { 01735 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) { 01736 rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; 01737 rtp->rtp_lookup_code_cache_code = code; 01738 rtp->rtp_lookup_code_cache_result = pt; 01739 ast_mutex_unlock(&rtp->bridge_lock); 01740 return pt; 01741 } 01742 } 01743 01744 ast_mutex_unlock(&rtp->bridge_lock); 01745 01746 return -1; 01747 }
char* ast_rtp_lookup_mime_multiple | ( | char * | buf, | |
size_t | size, | |||
const int | capability, | |||
const int | isAstFormat, | |||
enum ast_rtp_options | options | |||
) |
Build a string of MIME subtype names from a capability list.
Definition at line 1768 of file rtp.c.
References ast_rtp_lookup_mime_subtype(), AST_RTP_MAX, format, len, and name.
Referenced by process_sdp().
01770 { 01771 int format; 01772 unsigned len; 01773 char *end = buf; 01774 char *start = buf; 01775 01776 if (!buf || !size) 01777 return NULL; 01778 01779 snprintf(end, size, "0x%x (", capability); 01780 01781 len = strlen(end); 01782 end += len; 01783 size -= len; 01784 start = end; 01785 01786 for (format = 1; format < AST_RTP_MAX; format <<= 1) { 01787 if (capability & format) { 01788 const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options); 01789 01790 snprintf(end, size, "%s|", name); 01791 len = strlen(end); 01792 end += len; 01793 size -= len; 01794 } 01795 } 01796 01797 if (start == end) 01798 snprintf(start, size, "nothing)"); 01799 else if (size > 1) 01800 *(end -1) = ')'; 01801 01802 return buf; 01803 }
const char* ast_rtp_lookup_mime_subtype | ( | int | isAstFormat, | |
int | code, | |||
enum ast_rtp_options | options | |||
) |
Mapping an Asterisk code into a MIME subtype (string):.
Definition at line 1749 of file rtp.c.
References AST_FORMAT_G726_AAL2, AST_RTP_OPT_G726_NONSTANDARD, rtpPayloadType::code, mimeTypes, and payloadType.
Referenced by add_codec_to_sdp(), add_noncodec_to_sdp(), add_sdp(), ast_rtp_lookup_mime_multiple(), transmit_connect_with_sdp(), and transmit_modify_with_sdp().
01751 { 01752 unsigned int i; 01753 01754 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { 01755 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) { 01756 if (isAstFormat && 01757 (code == AST_FORMAT_G726_AAL2) && 01758 (options & AST_RTP_OPT_G726_NONSTANDARD)) 01759 return "G726-32"; 01760 else 01761 return mimeTypes[i].subtype; 01762 } 01763 } 01764 01765 return ""; 01766 }
struct rtpPayloadType ast_rtp_lookup_pt | ( | struct ast_rtp * | rtp, | |
int | pt | |||
) |
Mapping between RTP payload format codes and Asterisk codes:.
Definition at line 1686 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), MAX_RTP_PT, result, and static_RTP_PT.
Referenced by ast_rtp_read(), bridge_p2p_rtp_write(), and setup_rtp_connection().
01687 { 01688 struct rtpPayloadType result; 01689 01690 result.isAstFormat = result.code = 0; 01691 01692 if (pt < 0 || pt > MAX_RTP_PT) 01693 return result; /* bogus payload type */ 01694 01695 /* Start with negotiated codecs */ 01696 ast_mutex_lock(&rtp->bridge_lock); 01697 result = rtp->current_RTP_PT[pt]; 01698 ast_mutex_unlock(&rtp->bridge_lock); 01699 01700 /* If it doesn't exist, check our static RTP type list, just in case */ 01701 if (!result.code) 01702 result = static_RTP_PT[pt]; 01703 01704 return result; 01705 }
int ast_rtp_make_compatible | ( | struct ast_channel * | dest, | |
struct ast_channel * | src, | |||
int | media | |||
) |
Definition at line 1547 of file rtp.c.
References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, ast_rtp_pt_copy(), AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer.
Referenced by wait_for_answer().
01548 { 01549 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ 01550 struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ 01551 struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; 01552 enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; 01553 enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 01554 int srccodec, destcodec; 01555 01556 /* Lock channels */ 01557 ast_channel_lock(dest); 01558 while(ast_channel_trylock(src)) { 01559 ast_channel_unlock(dest); 01560 usleep(1); 01561 ast_channel_lock(dest); 01562 } 01563 01564 /* Find channel driver interfaces */ 01565 if (!(destpr = get_proto(dest))) { 01566 if (option_debug) 01567 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name); 01568 ast_channel_unlock(dest); 01569 ast_channel_unlock(src); 01570 return 0; 01571 } 01572 if (!(srcpr = get_proto(src))) { 01573 if (option_debug) 01574 ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name); 01575 ast_channel_unlock(dest); 01576 ast_channel_unlock(src); 01577 return 0; 01578 } 01579 01580 /* Get audio and video interface (if native bridge is possible) */ 01581 audio_dest_res = destpr->get_rtp_info(dest, &destp); 01582 video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED; 01583 audio_src_res = srcpr->get_rtp_info(src, &srcp); 01584 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED; 01585 01586 /* Ensure we have at least one matching codec */ 01587 if (srcpr->get_codec) 01588 srccodec = srcpr->get_codec(src); 01589 else 01590 srccodec = 0; 01591 if (destpr->get_codec) 01592 destcodec = destpr->get_codec(dest); 01593 else 01594 destcodec = 0; 01595 01596 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ 01597 if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) { 01598 /* Somebody doesn't want to play... */ 01599 ast_channel_unlock(dest); 01600 ast_channel_unlock(src); 01601 return 0; 01602 } 01603 ast_rtp_pt_copy(destp, srcp); 01604 if (vdestp && vsrcp) 01605 ast_rtp_pt_copy(vdestp, vsrcp); 01606 if (media) { 01607 /* Bridge early */ 01608 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE))) 01609 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name); 01610 } 01611 ast_channel_unlock(dest); 01612 ast_channel_unlock(src); 01613 if (option_debug) 01614 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name); 01615 return 1; 01616 }
struct ast_rtp* ast_rtp_new | ( | struct sched_context * | sched, | |
struct io_context * | io, | |||
int | rtcpenable, | |||
int | callbackmode | |||
) |
Initializate a RTP session.
sched | ||
io | ||
rtcpenable | ||
callbackmode |
Definition at line 1949 of file rtp.c.
References ast_rtp_new_with_bindaddr(), io, and sched.
01950 { 01951 struct in_addr ia; 01952 01953 memset(&ia, 0, sizeof(ia)); 01954 return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia); 01955 }
void ast_rtp_new_init | ( | struct ast_rtp * | rtp | ) |
Initialize a new RTP structure.
Definition at line 1849 of file rtp.c.
References ast_mutex_init(), ast_random(), ast_set_flag, ast_rtp::bridge_lock, FLAG_HAS_DTMF, ast_rtp::seqno, ast_rtp::ssrc, ast_rtp::them, and ast_rtp::us.
Referenced by ast_rtp_new_with_bindaddr(), and process_sdp().
01850 { 01851 ast_mutex_init(&rtp->bridge_lock); 01852 01853 rtp->them.sin_family = AF_INET; 01854 rtp->us.sin_family = AF_INET; 01855 rtp->ssrc = ast_random(); 01856 rtp->seqno = ast_random() & 0xffff; 01857 ast_set_flag(rtp, FLAG_HAS_DTMF); 01858 01859 return; 01860 }
struct ast_rtp* ast_rtp_new_with_bindaddr | ( | struct sched_context * | sched, | |
struct io_context * | io, | |||
int | rtcpenable, | |||
int | callbackmode, | |||
struct in_addr | in | |||
) |
Initializate a RTP session using an in_addr structure.
This fuction gets called by ast_rtp_new().
sched | ||
io | ||
rtcpenable | ||
callbackmode | ||
in |
Definition at line 1862 of file rtp.c.
References ast_calloc, ast_io_add(), AST_IO_IN, ast_log(), ast_random(), ast_rtcp_new(), ast_rtp_new_init(), ast_rtp_pt_default(), ast_set_flag, FLAG_CALLBACK_MODE, free, io, LOG_ERROR, rtp_socket(), rtpread(), and sched.
Referenced by __oh323_rtp_create(), ast_rtp_new(), gtalk_alloc(), sip_alloc(), and start_rtp().
01863 { 01864 struct ast_rtp *rtp; 01865 int x; 01866 int first; 01867 int startplace; 01868 01869 if (!(rtp = ast_calloc(1, sizeof(*rtp)))) 01870 return NULL; 01871 01872 ast_rtp_new_init(rtp); 01873 01874 rtp->s = rtp_socket(); 01875 if (rtp->s < 0) { 01876 free(rtp); 01877 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno)); 01878 return NULL; 01879 } 01880 if (sched && rtcpenable) { 01881 rtp->sched = sched; 01882 rtp->rtcp = ast_rtcp_new(); 01883 } 01884 01885 /* Select a random port number in the range of possible RTP */ 01886 x = (ast_random() % (rtpend-rtpstart)) + rtpstart; 01887 x = x & ~1; 01888 /* Save it for future references. */ 01889 startplace = x; 01890 /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */ 01891 for (;;) { 01892 /* Must be an even port number by RTP spec */ 01893 rtp->us.sin_port = htons(x); 01894 rtp->us.sin_addr = addr; 01895 /* If there's rtcp, initialize it as well. */ 01896 if (rtp->rtcp) { 01897 rtp->rtcp->us.sin_port = htons(x + 1); 01898 rtp->rtcp->us.sin_addr = addr; 01899 } 01900 /* Try to bind it/them. */ 01901 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) && 01902 (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))) 01903 break; 01904 if (!first) { 01905 /* Primary bind succeeded! Gotta recreate it */ 01906 close(rtp->s); 01907 rtp->s = rtp_socket(); 01908 } 01909 if (errno != EADDRINUSE) { 01910 /* We got an error that wasn't expected, abort! */ 01911 ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno)); 01912 close(rtp->s); 01913 if (rtp->rtcp) { 01914 close(rtp->rtcp->s); 01915 free(rtp->rtcp); 01916 } 01917 free(rtp); 01918 return NULL; 01919 } 01920 /* The port was used, increment it (by two). */ 01921 x += 2; 01922 /* Did we go over the limit ? */ 01923 if (x > rtpend) 01924 /* then, start from the begingig. */ 01925 x = (rtpstart + 1) & ~1; 01926 /* Check if we reached the place were we started. */ 01927 if (x == startplace) { 01928 /* If so, there's no ports available. */ 01929 ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n"); 01930 close(rtp->s); 01931 if (rtp->rtcp) { 01932 close(rtp->rtcp->s); 01933 free(rtp->rtcp); 01934 } 01935 free(rtp); 01936 return NULL; 01937 } 01938 } 01939 rtp->sched = sched; 01940 rtp->io = io; 01941 if (callbackmode) { 01942 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp); 01943 ast_set_flag(rtp, FLAG_CALLBACK_MODE); 01944 } 01945 ast_rtp_pt_default(rtp); 01946 return rtp; 01947 }
int ast_rtp_proto_register | ( | struct ast_rtp_protocol * | proto | ) |
Register interface to channel driver.
Definition at line 2770 of file rtp.c.
References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), LOG_WARNING, protos, and ast_rtp_protocol::type.
Referenced by load_module().
02771 { 02772 struct ast_rtp_protocol *cur; 02773 02774 AST_LIST_LOCK(&protos); 02775 AST_LIST_TRAVERSE(&protos, cur, list) { 02776 if (!strcmp(cur->type, proto->type)) { 02777 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type); 02778 AST_LIST_UNLOCK(&protos); 02779 return -1; 02780 } 02781 } 02782 AST_LIST_INSERT_HEAD(&protos, proto, list); 02783 AST_LIST_UNLOCK(&protos); 02784 02785 return 0; 02786 }
void ast_rtp_proto_unregister | ( | struct ast_rtp_protocol * | proto | ) |
Unregister interface to channel driver.
Definition at line 2762 of file rtp.c.
References AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, and protos.
Referenced by load_module(), and unload_module().
02763 { 02764 AST_LIST_LOCK(&protos); 02765 AST_LIST_REMOVE(&protos, proto, list); 02766 AST_LIST_UNLOCK(&protos); 02767 }
void ast_rtp_pt_clear | ( | struct ast_rtp * | rtp | ) |
Setting RTP payload types from lines in a SDP description:.
Definition at line 1383 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.
Referenced by process_sdp().
01384 { 01385 int i; 01386 01387 if (!rtp) 01388 return; 01389 01390 ast_mutex_lock(&rtp->bridge_lock); 01391 01392 for (i = 0; i < MAX_RTP_PT; ++i) { 01393 rtp->current_RTP_PT[i].isAstFormat = 0; 01394 rtp->current_RTP_PT[i].code = 0; 01395 } 01396 01397 rtp->rtp_lookup_code_cache_isAstFormat = 0; 01398 rtp->rtp_lookup_code_cache_code = 0; 01399 rtp->rtp_lookup_code_cache_result = 0; 01400 01401 ast_mutex_unlock(&rtp->bridge_lock); 01402 }
Copy payload types between RTP structures.
Definition at line 1423 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result.
Referenced by ast_rtp_make_compatible(), and process_sdp().
01424 { 01425 unsigned int i; 01426 01427 ast_mutex_lock(&dest->bridge_lock); 01428 ast_mutex_lock(&src->bridge_lock); 01429 01430 for (i=0; i < MAX_RTP_PT; ++i) { 01431 dest->current_RTP_PT[i].isAstFormat = 01432 src->current_RTP_PT[i].isAstFormat; 01433 dest->current_RTP_PT[i].code = 01434 src->current_RTP_PT[i].code; 01435 } 01436 dest->rtp_lookup_code_cache_isAstFormat = 0; 01437 dest->rtp_lookup_code_cache_code = 0; 01438 dest->rtp_lookup_code_cache_result = 0; 01439 01440 ast_mutex_unlock(&src->bridge_lock); 01441 ast_mutex_unlock(&dest->bridge_lock); 01442 }
void ast_rtp_pt_default | ( | struct ast_rtp * | rtp | ) |
Set payload types to defaults.
Definition at line 1404 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, ast_rtp::rtp_lookup_code_cache_result, and static_RTP_PT.
Referenced by ast_rtp_new_with_bindaddr().
01405 { 01406 int i; 01407 01408 ast_mutex_lock(&rtp->bridge_lock); 01409 01410 /* Initialize to default payload types */ 01411 for (i = 0; i < MAX_RTP_PT; ++i) { 01412 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat; 01413 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code; 01414 } 01415 01416 rtp->rtp_lookup_code_cache_isAstFormat = 0; 01417 rtp->rtp_lookup_code_cache_code = 0; 01418 rtp->rtp_lookup_code_cache_result = 0; 01419 01420 ast_mutex_unlock(&rtp->bridge_lock); 01421 }
Definition at line 1081 of file rtp.c.
References ast_backtrace(), ast_codec_get_samples(), AST_FORMAT_MAX_AUDIO, AST_FORMAT_SLINEAR, ast_frame_byteswap_be, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_rtcp_calc_interval(), ast_rtcp_write(), AST_RTP_CISCO_DTMF, AST_RTP_CN, AST_RTP_DTMF, ast_rtp_get_bridged(), ast_rtp_lookup_pt(), ast_rtp_senddigit_continuation(), ast_sched_add(), ast_set_flag, ast_verbose(), bridge_p2p_rtp_write(), ast_rtp::bridged, calc_rxstamp(), rtpPayloadType::code, CRASH, ast_rtp::cycles, ast_frame::data, ast_frame::datalen, ast_frame::delivery, event, ext, ast_rtp::f, f, FLAG_NAT_ACTIVE, ast_frame::frametype, ast_frame::has_timing_info, rtpPayloadType::isAstFormat, ast_rtp::lastevent, ast_rtp::lastividtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxseqno, ast_rtp::lastrxts, ast_frame::len, len, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, ast_rtp::nat, ast_frame::offset, option_debug, process_cisco_dtmf(), process_rfc2833(), process_rfc3389(), ast_rtp::rawdata, ast_rtp::rtcp, rtp_debug_test_addr(), RTP_SEQ_MOD, ast_rtp::rxcount, ast_rtp::rxseqno, ast_rtp::rxssrc, ast_rtp::s, ast_frame::samples, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seedrxseqno, ast_rtp::sending_digit, ast_frame::seqno, ast_frame::src, STUN_ACCEPT, stun_handle_packet(), ast_frame::subclass, ast_rtcp::them, ast_rtp::them, ast_rtp::themssrc, and ast_frame::ts.
Referenced by gtalk_rtp_read(), mgcp_rtp_read(), oh323_rtp_read(), rtpread(), sip_rtp_read(), and skinny_rtp_read().
01082 { 01083 int res; 01084 struct sockaddr_in sin; 01085 socklen_t len; 01086 unsigned int seqno; 01087 int version; 01088 int payloadtype; 01089 int hdrlen = 12; 01090 int padding; 01091 int mark; 01092 int ext; 01093 unsigned int ssrc; 01094 unsigned int timestamp; 01095 unsigned int *rtpheader; 01096 struct rtpPayloadType rtpPT; 01097 struct ast_rtp *bridged = NULL; 01098 01099 if( !rtp ) { 01100 ast_log(LOG_ERROR, "ast_rtp_read(): called with rtp == NULL\n"); 01101 ast_backtrace(); 01102 return &ast_null_frame; 01103 } 01104 01105 /* If time is up, kill it */ 01106 if (rtp->sending_digit) 01107 ast_rtp_senddigit_continuation(rtp); 01108 01109 len = sizeof(sin); 01110 01111 /* Cache where the header will go */ 01112 res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 01113 0, (struct sockaddr *)&sin, &len); 01114 01115 rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET); 01116 if (res < 0) { 01117 if (errno == EBADF) 01118 CRASH; 01119 if (errno != EAGAIN) { 01120 ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno)); 01121 return NULL; 01122 } 01123 return &ast_null_frame; 01124 } 01125 01126 if (res < hdrlen) { 01127 ast_log(LOG_WARNING, "RTP Read too short\n"); 01128 return &ast_null_frame; 01129 } 01130 01131 /* Get fields */ 01132 seqno = ntohl(rtpheader[0]); 01133 01134 /* Check RTP version */ 01135 version = (seqno & 0xC0000000) >> 30; 01136 if (!version) { 01137 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) && 01138 (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) { 01139 memcpy(&rtp->them, &sin, sizeof(rtp->them)); 01140 } 01141 return &ast_null_frame; 01142 } 01143 01144 #if 0 /* Allow to receive RTP stream with closed transmission path */ 01145 /* If we don't have the other side's address, then ignore this */ 01146 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) 01147 return &ast_null_frame; 01148 #endif 01149 01150 /* Send to whoever send to us if NAT is turned on */ 01151 if (rtp->nat) { 01152 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || 01153 (rtp->them.sin_port != sin.sin_port)) { 01154 rtp->them = sin; 01155 if (rtp->rtcp) { 01156 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); 01157 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1); 01158 } 01159 rtp->rxseqno = 0; 01160 ast_set_flag(rtp, FLAG_NAT_ACTIVE); 01161 if (option_debug || rtpdebug) 01162 ast_log(LOG_DEBUG, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port)); 01163 } 01164 } 01165 01166 /* If we are bridged to another RTP stream, send direct */ 01167 if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen)) 01168 return &ast_null_frame; 01169 01170 if (version != 2) 01171 return &ast_null_frame; 01172 01173 payloadtype = (seqno & 0x7f0000) >> 16; 01174 padding = seqno & (1 << 29); 01175 mark = seqno & (1 << 23); 01176 ext = seqno & (1 << 28); 01177 seqno &= 0xffff; 01178 timestamp = ntohl(rtpheader[1]); 01179 ssrc = ntohl(rtpheader[2]); 01180 01181 if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) { 01182 if (option_debug || rtpdebug) 01183 ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n"); 01184 mark = 1; 01185 } 01186 01187 rtp->rxssrc = ssrc; 01188 01189 if (padding) { 01190 /* Remove padding bytes */ 01191 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1]; 01192 } 01193 01194 if (ext) { 01195 /* RTP Extension present */ 01196 hdrlen += 4; 01197 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2; 01198 if (option_debug) { 01199 int profile; 01200 profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16; 01201 if (profile == 0x505a) 01202 ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n"); 01203 else 01204 ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile); 01205 } 01206 } 01207 01208 if (res < hdrlen) { 01209 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen); 01210 return &ast_null_frame; 01211 } 01212 01213 rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */ 01214 01215 if (rtp->rxcount==1) { 01216 /* This is the first RTP packet successfully received from source */ 01217 rtp->seedrxseqno = seqno; 01218 } 01219 01220 /* Do not schedule RR if RTCP isn't run */ 01221 if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) { 01222 /* Schedule transmission of Receiver Report */ 01223 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp); 01224 } 01225 if ( (int)rtp->lastrxseqno - (int)seqno > 100) /* if so it would indicate that the sender cycled; allow for misordering */ 01226 rtp->cycles += RTP_SEQ_MOD; 01227 01228 rtp->lastrxseqno = seqno; 01229 01230 if (rtp->themssrc==0) 01231 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */ 01232 01233 if (rtp_debug_test_addr(&sin)) 01234 ast_verbose("Got RTP packet from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", 01235 ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen); 01236 01237 rtpPT = ast_rtp_lookup_pt(rtp, payloadtype); 01238 if (!rtpPT.isAstFormat) { 01239 struct ast_frame *f = NULL; 01240 01241 /* This is special in-band data that's not one of our codecs */ 01242 if (rtpPT.code == AST_RTP_DTMF) { 01243 /* It's special -- rfc2833 process it */ 01244 if (rtp_debug_test_addr(&sin)) { 01245 unsigned char *data; 01246 unsigned int event; 01247 unsigned int event_end; 01248 unsigned int duration; 01249 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen; 01250 event = ntohl(*((unsigned int *)(data))); 01251 event >>= 24; 01252 event_end = ntohl(*((unsigned int *)(data))); 01253 event_end <<= 8; 01254 event_end >>= 24; 01255 duration = ntohl(*((unsigned int *)(data))); 01256 duration &= 0xFFFF; 01257 ast_verbose("Got RTP RFC2833 from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration); 01258 } 01259 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp); 01260 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) { 01261 /* It's really special -- process it the Cisco way */ 01262 if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) { 01263 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); 01264 rtp->lastevent = seqno; 01265 } 01266 } else if (rtpPT.code == AST_RTP_CN) { 01267 /* Comfort Noise */ 01268 f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); 01269 } else { 01270 ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr)); 01271 } 01272 return f ? f : &ast_null_frame; 01273 } 01274 rtp->lastrxformat = rtp->f.subclass = rtpPT.code; 01275 rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO; 01276 01277 if (!rtp->lastrxts) 01278 rtp->lastrxts = timestamp; 01279 01280 rtp->rxseqno = seqno; 01281 01282 /* Record received timestamp as last received now */ 01283 rtp->lastrxts = timestamp; 01284 01285 rtp->f.mallocd = 0; 01286 rtp->f.datalen = res - hdrlen; 01287 rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET; 01288 rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET; 01289 if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) { 01290 rtp->f.samples = ast_codec_get_samples(&rtp->f); 01291 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 01292 ast_frame_byteswap_be(&rtp->f); 01293 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark); 01294 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */ 01295 rtp->f.has_timing_info = 1; 01296 rtp->f.ts = timestamp / 8; 01297 rtp->f.len = rtp->f.samples / 8; 01298 rtp->f.seqno = seqno; 01299 } else { 01300 /* Video -- samples is # of samples vs. 90000 */ 01301 if (!rtp->lastividtimestamp) 01302 rtp->lastividtimestamp = timestamp; 01303 rtp->f.samples = timestamp - rtp->lastividtimestamp; 01304 rtp->lastividtimestamp = timestamp; 01305 rtp->f.delivery.tv_sec = 0; 01306 rtp->f.delivery.tv_usec = 0; 01307 if (mark) 01308 rtp->f.subclass |= 0x1; 01309 01310 } 01311 rtp->f.src = "RTP"; 01312 return &rtp->f; 01313 }
int ast_rtp_reload | ( | void | ) |
Definition at line 3637 of file rtp.c.
References ast_config_destroy(), ast_config_load(), ast_false(), ast_log(), ast_variable_retrieve(), ast_verbose(), DEFAULT_DTMF_TIMEOUT, LOG_WARNING, option_verbose, RTCP_MAX_INTERVALMS, RTCP_MIN_INTERVALMS, s, and VERBOSE_PREFIX_2.
Referenced by ast_rtp_init().
03638 { 03639 struct ast_config *cfg; 03640 const char *s; 03641 03642 rtpstart = 5000; 03643 rtpend = 31000; 03644 dtmftimeout = DEFAULT_DTMF_TIMEOUT; 03645 cfg = ast_config_load("rtp.conf"); 03646 if (cfg) { 03647 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) { 03648 rtpstart = atoi(s); 03649 if (rtpstart < 1024) 03650 rtpstart = 1024; 03651 if (rtpstart > 65535) 03652 rtpstart = 65535; 03653 } 03654 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) { 03655 rtpend = atoi(s); 03656 if (rtpend < 1024) 03657 rtpend = 1024; 03658 if (rtpend > 65535) 03659 rtpend = 65535; 03660 } 03661 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) { 03662 rtcpinterval = atoi(s); 03663 if (rtcpinterval == 0) 03664 rtcpinterval = 0; /* Just so we're clear... it's zero */ 03665 if (rtcpinterval < RTCP_MIN_INTERVALMS) 03666 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */ 03667 if (rtcpinterval > RTCP_MAX_INTERVALMS) 03668 rtcpinterval = RTCP_MAX_INTERVALMS; 03669 } 03670 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) { 03671 #ifdef SO_NO_CHECK 03672 if (ast_false(s)) 03673 nochecksums = 1; 03674 else 03675 nochecksums = 0; 03676 #else 03677 if (ast_false(s)) 03678 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n"); 03679 #endif 03680 } 03681 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) { 03682 dtmftimeout = atoi(s); 03683 if ((dtmftimeout < 0) || (dtmftimeout > 20000)) { 03684 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n", 03685 dtmftimeout, DEFAULT_DTMF_TIMEOUT); 03686 dtmftimeout = DEFAULT_DTMF_TIMEOUT; 03687 }; 03688 } 03689 ast_config_destroy(cfg); 03690 } 03691 if (rtpstart >= rtpend) { 03692 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n"); 03693 rtpstart = 5000; 03694 rtpend = 31000; 03695 } 03696 if (option_verbose > 1) 03697 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend); 03698 return 0; 03699 }
void ast_rtp_reset | ( | struct ast_rtp * | rtp | ) |
Definition at line 2023 of file rtp.c.
References ast_rtp::dtmfcount, ast_rtp::dtmfmute, ast_rtp::dtmfsamples, ast_rtp::lastdigitts, ast_rtp::lastevent, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastovidtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxts, ast_rtp::lastts, ast_rtp::lasttxformat, ast_rtp::rxcore, ast_rtp::rxseqno, ast_rtp::seqno, and ast_rtp::txcore.
02024 { 02025 memset(&rtp->rxcore, 0, sizeof(rtp->rxcore)); 02026 memset(&rtp->txcore, 0, sizeof(rtp->txcore)); 02027 memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute)); 02028 rtp->lastts = 0; 02029 rtp->lastdigitts = 0; 02030 rtp->lastrxts = 0; 02031 rtp->lastividtimestamp = 0; 02032 rtp->lastovidtimestamp = 0; 02033 rtp->lasteventseqn = 0; 02034 rtp->lastevent = 0; 02035 rtp->lasttxformat = 0; 02036 rtp->lastrxformat = 0; 02037 rtp->dtmfcount = 0; 02038 rtp->dtmfsamples = 0; 02039 rtp->seqno = 0; 02040 rtp->rxseqno = 0; 02041 }
int ast_rtp_sendcng | ( | struct ast_rtp * | rtp, | |
int | level | |||
) |
generate comfort noice (CNG)
Definition at line 2530 of file rtp.c.
References ast_inet_ntoa(), ast_log(), AST_RTP_CN, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::data, ast_rtp::dtmfmute, ast_rtp::lastts, LOG_ERROR, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them.
Referenced by do_monitor().
02531 { 02532 unsigned int *rtpheader; 02533 int hdrlen = 12; 02534 int res; 02535 int payload; 02536 char data[256]; 02537 level = 127 - (level & 0x7f); 02538 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN); 02539 02540 /* If we have no peer, return immediately */ 02541 if (!rtp->them.sin_addr.s_addr) 02542 return 0; 02543 02544 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); 02545 02546 /* Get a pointer to the header */ 02547 rtpheader = (unsigned int *)data; 02548 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++)); 02549 rtpheader[1] = htonl(rtp->lastts); 02550 rtpheader[2] = htonl(rtp->ssrc); 02551 data[12] = level; 02552 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) { 02553 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them)); 02554 if (res <0) 02555 ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); 02556 if (rtp_debug_test_addr(&rtp->them)) 02557 ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n" 02558 , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen); 02559 02560 } 02561 return 0; 02562 }
int ast_rtp_senddigit_begin | ( | struct ast_rtp * | rtp, | |
char | digit | |||
) |
Send begin frames for DTMF.
Definition at line 2133 of file rtp.c.
References ast_inet_ntoa(), ast_log(), AST_RTP_DTMF, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastdigitts, LOG_ERROR, LOG_WARNING, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::send_digit, ast_rtp::send_duration, ast_rtp::send_payload, ast_rtp::sending_digit, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them.
Referenced by oh323_digit_begin(), and sip_senddigit_begin().
02134 { 02135 unsigned int *rtpheader; 02136 int hdrlen = 12, res = 0, i = 0, payload = 0; 02137 char data[256]; 02138 02139 if ((digit <= '9') && (digit >= '0')) 02140 digit -= '0'; 02141 else if (digit == '*') 02142 digit = 10; 02143 else if (digit == '#') 02144 digit = 11; 02145 else if ((digit >= 'A') && (digit <= 'D')) 02146 digit = digit - 'A' + 12; 02147 else if ((digit >= 'a') && (digit <= 'd')) 02148 digit = digit - 'a' + 12; 02149 else { 02150 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit); 02151 return 0; 02152 } 02153 02154 /* If we have no peer, return immediately */ 02155 if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) 02156 return 0; 02157 02158 payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF); 02159 02160 rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); 02161 rtp->send_duration = 160; 02162 02163 /* Get a pointer to the header */ 02164 rtpheader = (unsigned int *)data; 02165 rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno)); 02166 rtpheader[1] = htonl(rtp->lastdigitts); 02167 rtpheader[2] = htonl(rtp->ssrc); 02168 02169 for (i = 0; i < 2; i++) { 02170 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration)); 02171 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them)); 02172 if (res < 0) 02173 ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n", 02174 ast_inet_ntoa(rtp->them.sin_addr), 02175 ntohs(rtp->them.sin_port), strerror(errno)); 02176 if (rtp_debug_test_addr(&rtp->them)) 02177 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", 02178 ast_inet_ntoa(rtp->them.sin_addr), 02179 ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen); 02180 /* Increment sequence number */ 02181 rtp->seqno++; 02182 /* Increment duration */ 02183 rtp->send_duration += 160; 02184 /* Clear marker bit and set seqno */ 02185 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno)); 02186 } 02187 02188 /* Since we received a begin, we can safely store the digit and disable any compensation */ 02189 rtp->sending_digit = 1; 02190 rtp->send_digit = digit; 02191 rtp->send_payload = payload; 02192 02193 return 0; 02194 }
int ast_rtp_senddigit_end | ( | struct ast_rtp * | rtp, | |
char | digit | |||
) |
void ast_rtp_set_callback | ( | struct ast_rtp * | rtp, | |
ast_rtp_callback | callback | |||
) |
Definition at line 585 of file rtp.c.
References ast_rtp::callback.
Referenced by start_rtp().
00586 { 00587 rtp->callback = callback; 00588 }
void ast_rtp_set_data | ( | struct ast_rtp * | rtp, | |
void * | data | |||
) |
Definition at line 580 of file rtp.c.
References ast_rtp::data.
Referenced by start_rtp().
00581 { 00582 rtp->data = data; 00583 }
void ast_rtp_set_m_type | ( | struct ast_rtp * | rtp, | |
int | pt | |||
) |
Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line).
Definition at line 1622 of file rtp.c.
References ast_mutex_lock(), ast_mutex_unlock(), ast_rtp::bridge_lock, ast_rtp::current_RTP_PT, MAX_RTP_PT, and static_RTP_PT.
Referenced by gtalk_newcall(), and process_sdp().
01623 { 01624 if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 01625 return; /* bogus payload type */ 01626 01627 ast_mutex_lock(&rtp->bridge_lock); 01628 rtp->current_RTP_PT[pt] = static_RTP_PT[pt]; 01629 ast_mutex_unlock(&rtp->bridge_lock); 01630 }
void ast_rtp_set_peer | ( | struct ast_rtp * | rtp, | |
struct sockaddr_in * | them | |||
) |
Definition at line 1966 of file rtp.c.
References ast_rtp::rtcp, ast_rtp::rxseqno, ast_rtcp::them, and ast_rtp::them.
Referenced by handle_open_receive_channel_ack_message(), process_sdp(), and setup_rtp_connection().
01967 { 01968 rtp->them.sin_port = them->sin_port; 01969 rtp->them.sin_addr = them->sin_addr; 01970 if (rtp->rtcp) { 01971 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1); 01972 rtp->rtcp->them.sin_addr = them->sin_addr; 01973 } 01974 rtp->rxseqno = 0; 01975 }
void ast_rtp_set_rtpholdtimeout | ( | struct ast_rtp * | rtp, | |
int | timeout | |||
) |
Set rtp hold timeout.
Definition at line 547 of file rtp.c.
References ast_rtp::rtpholdtimeout.
Referenced by create_addr_from_peer(), do_monitor(), and sip_alloc().
00548 { 00549 rtp->rtpholdtimeout = timeout; 00550 }
void ast_rtp_set_rtpkeepalive | ( | struct ast_rtp * | rtp, | |
int | period | |||
) |
set RTP keepalive interval
Definition at line 553 of file rtp.c.
References ast_rtp::rtpkeepalive.
Referenced by create_addr_from_peer(), and sip_alloc().
00554 { 00555 rtp->rtpkeepalive = period; 00556 }
void ast_rtp_set_rtpmap_type | ( | struct ast_rtp * | rtp, | |
int | pt, | |||
char * | mimeType, | |||
char * | mimeSubtype, | |||
enum ast_rtp_options | options | |||
) |
Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line.
Definition at line 1635 of file rtp.c.
References AST_FORMAT_G726, AST_FORMAT_G726_AAL2, ast_mutex_lock(), ast_mutex_unlock(), AST_RTP_OPT_G726_NONSTANDARD, ast_rtp::bridge_lock, rtpPayloadType::code, ast_rtp::current_RTP_PT, MAX_RTP_PT, mimeTypes, payloadType, subtype, and type.
Referenced by __oh323_rtp_create(), gtalk_newcall(), process_sdp(), and set_dtmf_payload().
01638 { 01639 unsigned int i; 01640 01641 if (pt < 0 || pt > MAX_RTP_PT) 01642 return; /* bogus payload type */ 01643 01644 ast_mutex_lock(&rtp->bridge_lock); 01645 01646 for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { 01647 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 && 01648 strcasecmp(mimeType, mimeTypes[i].type) == 0) { 01649 rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType; 01650 if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) && 01651 mimeTypes[i].payloadType.isAstFormat && 01652 (options & AST_RTP_OPT_G726_NONSTANDARD)) 01653 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2; 01654 break; 01655 } 01656 } 01657 01658 ast_mutex_unlock(&rtp->bridge_lock); 01659 01660 return; 01661 }
void ast_rtp_set_rtptimeout | ( | struct ast_rtp * | rtp, | |
int | timeout | |||
) |
Set rtp timeout.
Definition at line 541 of file rtp.c.
References ast_rtp::rtptimeout.
Referenced by create_addr_from_peer(), do_monitor(), and sip_alloc().
00542 { 00543 rtp->rtptimeout = timeout; 00544 }
void ast_rtp_set_rtptimers_onhold | ( | struct ast_rtp * | rtp | ) |
Definition at line 534 of file rtp.c.
References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout.
Referenced by handle_response_invite().
00535 { 00536 rtp->rtptimeout = (-1) * rtp->rtptimeout; 00537 rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout; 00538 }
void ast_rtp_setdtmf | ( | struct ast_rtp * | rtp, | |
int | dtmf | |||
) |
Indicate whether this RTP session is carrying DTMF or not.
Definition at line 600 of file rtp.c.
References ast_set2_flag, and FLAG_HAS_DTMF.
Referenced by create_addr_from_peer(), handle_request_invite(), process_sdp(), sip_alloc(), and sip_dtmfmode().
00601 { 00602 ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF); 00603 }
void ast_rtp_setdtmfcompensate | ( | struct ast_rtp * | rtp, | |
int | compensate | |||
) |
Compensate for devices that send RFC2833 packets all at once.
Definition at line 605 of file rtp.c.
References ast_set2_flag, and FLAG_DTMF_COMPENSATE.
Referenced by create_addr_from_peer(), handle_request_invite(), process_sdp(), and sip_alloc().
00606 { 00607 ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE); 00608 }
void ast_rtp_setnat | ( | struct ast_rtp * | rtp, | |
int | nat | |||
) |
Definition at line 590 of file rtp.c.
References ast_rtp::nat.
Referenced by __oh323_rtp_create(), do_setnat(), oh323_rtp_read(), and start_rtp().
void ast_rtp_setstun | ( | struct ast_rtp * | rtp, | |
int | stun_enable | |||
) |
Enable STUN capability.
Definition at line 610 of file rtp.c.
References ast_set2_flag, and FLAG_HAS_STUN.
Referenced by gtalk_new().
00611 { 00612 ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN); 00613 }
int ast_rtp_settos | ( | struct ast_rtp * | rtp, | |
int | tos | |||
) |
Definition at line 1957 of file rtp.c.
References ast_log(), LOG_WARNING, and ast_rtp::s.
Referenced by __oh323_rtp_create(), and sip_alloc().
01958 { 01959 int res; 01960 01961 if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 01962 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos); 01963 return res; 01964 }
void ast_rtp_stop | ( | struct ast_rtp * | rtp | ) |
Definition at line 2006 of file rtp.c.
References ast_clear_flag, ast_sched_del(), FLAG_P2P_SENT_MARK, ast_rtp::rtcp, ast_rtp::sched, ast_rtcp::schedid, ast_rtcp::them, and ast_rtp::them.
Referenced by process_sdp(), setup_rtp_connection(), and stop_media_flows().
02007 { 02008 if (rtp->rtcp && rtp->rtcp->schedid > 0) { 02009 ast_sched_del(rtp->sched, rtp->rtcp->schedid); 02010 rtp->rtcp->schedid = -1; 02011 } 02012 02013 memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr)); 02014 memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port)); 02015 if (rtp->rtcp) { 02016 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr)); 02017 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port)); 02018 } 02019 02020 ast_clear_flag(rtp, FLAG_P2P_SENT_MARK); 02021 }
void ast_rtp_stun_request | ( | struct ast_rtp * | rtp, | |
struct sockaddr_in * | suggestion, | |||
const char * | username | |||
) |
Definition at line 402 of file rtp.c.
References append_attr_string(), stun_attr::attr, ast_rtp::s, STUN_BINDREQ, stun_req_id(), stun_send(), and STUN_USERNAME.
Referenced by gtalk_update_stun().
00403 { 00404 struct stun_header *req; 00405 unsigned char reqdata[1024]; 00406 int reqlen, reqleft; 00407 struct stun_attr *attr; 00408 00409 req = (struct stun_header *)reqdata; 00410 stun_req_id(req); 00411 reqlen = 0; 00412 reqleft = sizeof(reqdata) - sizeof(struct stun_header); 00413 req->msgtype = 0; 00414 req->msglen = 0; 00415 attr = (struct stun_attr *)req->ies; 00416 if (username) 00417 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft); 00418 req->msglen = htons(reqlen); 00419 req->msgtype = htons(STUN_BINDREQ); 00420 stun_send(rtp->s, suggestion, req); 00421 }
Definition at line 2682 of file rtp.c.
References ast_codec_pref_getsize(), AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_getformatname(), ast_log(), ast_rtp_lookup_code(), ast_rtp_raw_write(), ast_smoother_feed, ast_smoother_feed_be, AST_SMOOTHER_FLAG_BE, ast_smoother_free(), ast_smoother_new(), ast_smoother_read(), ast_smoother_set_flags(), ast_smoother_test_flag(), ast_frame::datalen, f, fmt, ast_frame::frametype, ast_rtp::lasttxformat, LOG_DEBUG, LOG_WARNING, ast_frame::offset, option_debug, ast_rtp::pref, ast_rtp::smoother, ast_frame::subclass, and ast_rtp::them.
Referenced by gtalk_write(), mgcp_write(), oh323_write(), sip_write(), and skinny_write().
02683 { 02684 struct ast_frame *f; 02685 int codec; 02686 int hdrlen = 12; 02687 int subclass; 02688 02689 02690 /* If we have no peer, return immediately */ 02691 if (!rtp->them.sin_addr.s_addr) 02692 return 0; 02693 02694 /* If there is no data length, return immediately */ 02695 if (!_f->datalen) 02696 return 0; 02697 02698 /* Make sure we have enough space for RTP header */ 02699 if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) { 02700 ast_log(LOG_WARNING, "RTP can only send voice and video\n"); 02701 return -1; 02702 } 02703 02704 subclass = _f->subclass; 02705 if (_f->frametype == AST_FRAME_VIDEO) 02706 subclass &= ~0x1; 02707 02708 codec = ast_rtp_lookup_code(rtp, 1, subclass); 02709 if (codec < 0) { 02710 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass)); 02711 return -1; 02712 } 02713 02714 if (rtp->lasttxformat != subclass) { 02715 /* New format, reset the smoother */ 02716 if (option_debug) 02717 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass)); 02718 rtp->lasttxformat = subclass; 02719 if (rtp->smoother) 02720 ast_smoother_free(rtp->smoother); 02721 rtp->smoother = NULL; 02722 } 02723 02724 if (!rtp->smoother) { 02725 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass); 02726 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */ 02727 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) { 02728 ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms)); 02729 return -1; 02730 } 02731 if (fmt.flags) 02732 ast_smoother_set_flags(rtp->smoother, fmt.flags); 02733 if (option_debug) 02734 ast_log(LOG_DEBUG, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms)); 02735 } 02736 } 02737 if (rtp->smoother) { 02738 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) { 02739 ast_smoother_feed_be(rtp->smoother, _f); 02740 } else { 02741 ast_smoother_feed(rtp->smoother, _f); 02742 } 02743 02744 while((f = ast_smoother_read(rtp->smoother))) 02745 ast_rtp_raw_write(rtp, f, codec); 02746 } else { 02747 /* Don't buffer outgoing frames; send them one-per-packet: */ 02748 if (_f->offset < hdrlen) { 02749 f = ast_frdup(_f); 02750 } else { 02751 f = _f; 02752 } 02753 ast_rtp_raw_write(rtp, f, codec); 02754 if (f != _f) 02755 ast_frfree(f); 02756 } 02757 02758 return 0; 02759 }