void CPlayerMedia::rtp_init (bool do_tcp)
{
rtp_stream_params_t rsp;
connect_desc_t *cptr;
double bw;
if (m_rtp_session == NULL) {
m_rtp_session_from_outside = false;
rtp_default_params(&rsp);
if (find_rtcp_bandwidth_from_media(m_media_info, &bw) < 0) {
bw = 5000.0;
}
rsp.rtcp_bandwidth = bw;
cptr = get_connect_desc_from_media(m_media_info);
rsp.rtp_addr = m_source_addr == NULL ? cptr->conn_addr : m_source_addr;
rsp.rtp_rx_port = m_our_port;
rsp.rtp_tx_port = m_server_port;
rsp.rtp_ttl = cptr == NULL ? 1 : cptr->ttl;
rsp.rtp_callback = c_recv_callback;
if (do_tcp) {
rsp.dont_init_sockets = 1;
rsp.rtcp_send_packet = c_rtcp_send_packet;
} else {
// udp. See if we have a seperate rtcp field
if (m_media_info->rtcp_connect.used) {
rsp.rtcp_rx_port = m_media_info->rtcp_port;
rsp.rtcp_addr = m_media_info->rtcp_connect.conn_addr;
rsp.rtcp_ttl = m_media_info->rtcp_connect.ttl;
}
if (config.get_config_string(CONFIG_MULTICAST_RX_IF) != NULL) {
struct in_addr if_addr;
if (getIpAddressFromInterface(config.get_config_string(CONFIG_MULTICAST_RX_IF),
&if_addr) >= 0) {
rsp.physical_interface_addr = inet_ntoa(if_addr);
}
}
}
rsp.recv_userdata = this;
m_rtp_session = rtp_init_stream(&rsp);
rtp_set_option(m_rtp_session, RTP_OPT_WEAK_VALIDATION, FALSE);
rtp_set_option(m_rtp_session, RTP_OPT_PROMISC, TRUE);
if (strncasecmp(m_media_info->proto, "RTP/SVP", strlen("RTP/SVP")) == 0) {
srtp_init();
}
} else {
m_rtp_session_from_outside = true;
rtp_set_rtp_callback(m_rtp_session, c_recv_callback, this);
}
m_rtp_inited = 1;
}
void CPlayerMedia::rtp_start (void)
{
if (m_rtp_ssrc_set == TRUE) {
rtp_set_my_ssrc(m_rtp_session, m_rtp_ssrc);
} else {
// For now - we'll set up not to wait for RTCP validation
// before indicating if rtp library should accept.
rtp_set_option(m_rtp_session, RTP_OPT_WEAK_VALIDATION, FALSE);
rtp_set_option(m_rtp_session, RTP_OPT_PROMISC, TRUE);
}
if (m_rtp_byte_stream != NULL) {
//m_rtp_byte_stream->reset(); - gets called when pausing
// m_rtp_byte_stream->flush_rtp_packets();
}
m_rtp_buffering = 0;
}
rtp_session_t * init_rtp_session(uint32_t port, char *addr){
rtp_session_t *rtp;
char *mcast_if = NULL;
double rtcp_bw = DEFAULT_RTCP_BW;
int ttl = DEFAULT_TTL;
struct module tmod;
struct tx *tx_session;
rtp = (rtp_session_t *) malloc(sizeof(rtp_session_t));
if (rtp == NULL){
error_msg("rtp_session: malloc error");
return NULL;
}
rtp->port = port;
rtp->addr = addr;
module_init_default(&tmod);
struct rtp *rtp_conn = rtp_init_if(addr, mcast_if,
0, port, ttl,
rtcp_bw, 0, dummy_callback,
(void *)NULL, 0);
if (rtp_conn == NULL){
error_msg("rtp_session: rtp_init error");
return NULL;
}
rtp_set_option(rtp_conn, RTP_OPT_WEAK_VALIDATION, 1);
rtp_set_sdes(rtp_conn, rtp_my_ssrc(rtp_conn), RTCP_SDES_TOOL, PACKAGE_STRING, strlen(PACKAGE_STRING));
rtp_set_send_buf(rtp_conn, DEFAULT_SEND_BUFFER_SIZE);
tx_session = tx_init_h264(&tmod, MTU, TX_MEDIA_VIDEO, NULL, NULL);
if (tx_session == NULL){
error_msg("rtp_session: tx_init error");
return NULL;
}
rtp->rtp = rtp_conn;
rtp->tx_session = tx_session;
return rtp;
}
int
os_sound_start (call_t * ca, int port)
{
int p, cond;
int bits = 16;
int stereo = 0; /* 0 is mono */
int rate = 8000;
int blocksize = 512;
if (ca->local_sendrecv == _SENDRECV || ca->local_sendrecv == _RECVONLY)
{
ca->fd = open (AUDIO_DEVICE, O_RDWR | O_NONBLOCK);
if (ca->fd < 0)
return -EWOULDBLOCK;
fcntl (ca->fd, F_SETFL, fcntl (ca->fd, F_GETFL) & ~O_NONBLOCK);
ioctl (ca->fd, SNDCTL_DSP_RESET, 0);
p = bits; /* 16 bits */
ioctl (ca->fd, SNDCTL_DSP_SAMPLESIZE, &p);
p = stereo; /* number of channels */
ioctl (ca->fd, SNDCTL_DSP_CHANNELS, &p);
#ifdef USE_PCM
p = AFMT_S16_NE; /* choose LE or BE (endian) */
ioctl (ca->fd, SNDCTL_DSP_SETFMT, &p);
#else
if (ca->payload == 0)
p = AFMT_MU_LAW;
else if (ca->payload == 8)
p = AFMT_A_LAW;
else if (ca->payload == 110 || ca->payload == 111)
p = AFMT_S16_NE; /* choose LE or BE (endian) */
ioctl (ca->fd, SNDCTL_DSP_SETFMT, &p);
#endif
p = rate; /* rate in khz */
ioctl (ca->fd, SNDCTL_DSP_SPEED, &p);
ioctl (ca->fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size > blocksize)
{
cond = 1;
p = min_size / blocksize;
while (cond)
{
int i = ioctl (ca->fd, SNDCTL_DSP_SUBDIVIDE, &p);
/* fprintf(stderr, "SUB_DIVIDE said error=%i,errno=%i\n",i,errno); */
if ((i == 0) || (p == 1))
cond = 0;
else
p = p / 2;
}
}
ioctl (ca->fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size > blocksize)
{
fprintf (stderr, "dsp block size set to %i.", min_size);
exit (0);
} else
{
/* no need to access the card with less latency than needed */
min_size = blocksize;
}
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"blocksize = %i\n", min_size));
} else
{
/* send a wav file! */
ca->fd = open (ca->wav_file, O_RDONLY);
if (ca->fd < 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"Could not open wav file: %s\n", ca->wav_file));
return -1;
}
}
#ifdef SPEEX_SUPPORT
{
float vbr_qual;
int value;
int quality;
ca->speex_enc = speex_encoder_init (&speex_nb_mode); /* 8kHz */
/* 16kHz speex_enc = speex_encoder_init(&speex_wb_mode); */
/* 32kHz speex_enc = speex_encoder_init(&speex_uwb_mode); */
ca->speex_dec = speex_decoder_init (&speex_nb_mode);
value = 1;
speex_decoder_ctl (ca->speex_dec, SPEEX_SET_ENH, &value);
quality = 8; /* 15kb */
speex_encoder_ctl (ca->speex_enc, SPEEX_SET_QUALITY, &quality);
/* ou bien le bit rate:
value = 15000; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_BITRATE, &value);
*/
/* silence suppression (VAD)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VAD, &value);
Discontinuous transmission (DTX)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_DTX, &value);
Variable Bit Rate (VBR)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR, &value);
vbr_qual = 5,0; // between 0 and 10
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR_QUALITY, &vbr_qual);
Average bit rate: (ABR)
value = 15000; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_ABR, &value);
*/
speex_encoder_ctl (ca->speex_enc, SPEEX_GET_FRAME_SIZE, &ca->speex_fsize);
ca->speex_nb_packet = 1;
speex_bits_init (&(ca->speex_bits));
speex_bits_init (&(ca->dec_speex_bits));
}
#endif
if (ca->local_sendrecv == _SENDRECV)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting sendrecv session\n"));
} else if (ca->local_sendrecv == _SENDONLY)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting sendonly session\n"));
} else
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting recvonly session\n"));
}
ca->rtp_session = rtp_init (ca->remote_sdp_audio_ip,
port,
ca->remote_sdp_audio_port,
16, 64000, rtp_event_handler, (void *) ca);
if (ca->rtp_session)
{
const char *username = "******"; /* should be taken from the SDP */
const char *telephone = "0033-MY-NUMBER";
const char *app_name = "josua";
uint32_t my_ssrc = rtp_my_ssrc (ca->rtp_session);
/* set local participant info */
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_NAME,
username, strlen (username));
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_PHONE,
telephone, strlen (telephone));
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_TOOL,
app_name, strlen (app_name));
/* Filter out local packets if requested */
/* rtp_set_option(ca->rtp_session, RTP_OPT_FILTER_MY_PACKETS, filter_me); */
rtp_set_option (ca->rtp_session, RTP_OPT_WEAK_VALIDATION, TRUE);
ca->enable_audio = 1;
ca->audio_thread = osip_thread_create (20000, os_sound_start_thread, ca);
} else
{
fprintf (stderr, "Could not initialize session for %s port %d\n",
ca->remote_sdp_audio_ip, ca->remote_sdp_audio_port);
}
return 0;
}
