main(int argc, char **argv)
{
int i;
if (argc != 2)
{
fprintf(stderr, "usage: %s logfilename\n", argv[0]);
exit(1);
}
if (strcmp(argv[1], "syslogd") == 0)
{
rtp_loginit(argv[1], LOG_LOCAL1, NULL, argv[0]);
}
else
{
rtp_loginit(argv[1], 0, NULL, argv[0]);
}
for (i = 0; i < 1024; i++)
rtp_log(RTP_INFO, "duplicate message\n");
while (1)
{
rtp_log(RTP_INFO, "log entry %d\n", i++);
sleep(1);
}
} /* end main() */
void WriteToOrb(SERVER *orb, UINT8 *das, int verbose, BOOL UseLoc)
{
static int count = 0;
double samprate, tstamp;
char buf[256];
struct reftek_dt dt;
int nbytes;
char *packet;
static int packetsz = 0;
static char srcname[ORBSRCNAME_SIZE];
static char *fid = "WriteToOrb";
/* Only deal with DT packets for which we can get sample rate */
if (reftek_type(das) != REFTEK_DT) return;
if (!reftek_dt(&dt, das, TRUE)) {
rtp_log(RTP_ERR, "%s: DAS pkt dropped (can't decode)\n", fid);
return;
}
if (!DeriveSampleRate(&dt, &samprate)) {
rtp_log(RTP_ERR, "%s: DAS pkt dropped (unknown sample rate): %s\n",
fid, reftek_str(das, buf)
);
return;
}
/* Note decompression errors, if any */
if (dt.dcerr) rtp_log(RTP_ERR, "%s: decompression error %d: %s\n",
fid, dt.dcerr, reftek_str(das, buf)
);
/* Convert to GENC format and send to ORB */
ConvertPacket(&dt, samprate, UseLoc);
if (stuffPkt(Pkt, srcname, &tstamp, &packet, &nbytes, &packetsz) < 0) {
rtp_log(RTP_ERR, "stuffPkt routine failed for %s\n", Pkt->pkttype->name);
return;
}
++count;
if (verbose) {
showPkt(0, srcname, tstamp, packet, nbytes, stdout, PKT_TERSE);
}
if (orbput(orb->fd, srcname, dt.tstamp, packet, nbytes) != 0) {
rtp_log(RTP_ERR, "orbput fails\n");
}
}
VOID rtp_cmdpkt_decode(UINT8 *buf, RTP_CMDPKT *cmdpkt)
{
UINT16 stmp; size_t slen = 2;
UINT8 *ptr;
static CHAR *fid = "rtp_cmdpkt_decode";
if (buf == (UINT8 *) NULL || cmdpkt == (RTP_CMDPKT *) NULL) {
rtp_log(RTP_ERR, "%s: null input(s)", fid);
errno = EINVAL;
}
ptr = buf;
memcpy((void *) &stmp, (void *) ptr, slen);
cmdpkt->unit = (UINT16) ntohs((u_short) stmp);
ptr += slen;
memcpy((void *) &stmp, (void *) ptr, slen);
cmdpkt->len = (UINT16) ntohs((u_short) stmp);
ptr += slen;
if (cmdpkt->len > RTP_MAXMSGLEN) cmdpkt->len = RTP_MAXMSGLEN;
memcpy((void *) cmdpkt->data, (void *) ptr, cmdpkt->len);
return;
}
/**
* return used bandwidth
*/
int rtp_open_capables(media_format_t *mf, rtpcap_set_t *rtpcapset, media_control_t *ctrl, char *mode, int bandwidth)
{
int sno=0;
rtp_stream_t *strm;
rtpcap_descript_t *rtpcap;
xlist_user_t u;
rtp_format_t *rtp = (rtp_format_t *)mf;
rtp_log(("rtp_open_capables: open %d capables\n", xlist_size(rtpcapset->rtpcaps)));
if(strlen(mode) >= MAX_MODEBYTES)
{
rtp_log(("rtp_open_capables: mode unacceptable\n"));
return MP_INVALID;
}
strcpy(mf->default_mode, mode);
mf->control = ctrl;
rtp->rtp_in = (dev_rtp_t*)ctrl->find_device(ctrl, "rtp", "input");
rtp_log(("rtp_open_capables: bandwidth[%d]\n", bandwidth));
rtpcap = xlist_first(rtpcapset->rtpcaps, &u);
while(rtpcap)
{
if(rtpcapset->rtpcap_selection == RTPCAP_ALL_CAPABLES || (rtpcapset->rtpcap_selection == RTPCAP_SELECTED_CAPABLES && rtpcap->enable))
{
strm = rtp_open_stream(rtp, sno++, rtpcap, ctrl, mode, bandwidth, rtpcapset);
if(strm)
{
rtp_log(("rtp_open_capables: stream bandwidth[%d]\n", strm->bandwidth));
bandwidth -= strm->bandwidth;
}
}
else
rtp_log(("rtp_open_capables: mime[%s] disabled\n", rtpcap->profile_mime));
rtpcap = xlist_next(rtpcapset->rtpcaps, &u);
}
return rtp->bandwidth;
}
int rtp_support_type (media_format_t *mf, char *type, char *subtype)
{
if(!strcmp(type, "mime") && !strcmp(subtype, "application/sdp"))
{
rtp_log(("rtp_support_type: support mime:application/sdp\n"));
return 1;
}
return 0;
}
int rtp_new_all_player(media_format_t *mf, media_control_t* ctrl, char* mode, void* mode_param)
{
int c=0;
media_stream_t *cur = mf->first;
if(!mode)
mode = "rtp";
while (cur != NULL)
{
cur->player = ctrl->find_player(ctrl, mode, cur->media_info->mime, cur->media_info->fourcc);
if(!cur->player)
{
cur->playable = -1;
rtp_log(("rtp_new_all_player: No %s player\n", cur->media_info->mime));
}
else if( cur->player->open_stream(cur->player, cur, cur->media_info) < MP_OK)
{
cur->playable = -1;
rtp_log(("rtp_new_all_player: open %s stream fail!\n", cur->media_info->mime));
}
else
{
cur->playable = 1;
c++;
rtp_log(("ogm_new_mime_player: %s stream ok\n", cur->media_info->mime));
}
cur = cur->next;
}
return c;
}
static BOOL peer_info(RTP *rtp)
{
int addrlen;
struct sockaddr_in cli_addr, *cli_addrp;
struct hostent *hp;
static CHAR *fid = "peer_info";
addrlen = sizeof(cli_addr);
cli_addrp = &cli_addr;
if (getpeername(rtp->sd, (struct sockaddr *)cli_addrp, &addrlen) != 0) {
rtp_log(RTP_ERR, "%s: getpeername: %s", fid, strerror(errno));
return FALSE;
}
rtp->addr = (CHAR *) strdup(inet_ntoa(cli_addrp->sin_addr));
MUTEX_LOCK(&mutex);
hp = gethostbyaddr(
(char *) &cli_addrp->sin_addr,
sizeof(struct in_addr),
cli_addrp->sin_family
);
if (hp != NULL) {
rtp->peer = (CHAR *) strdup(hp->h_name);
} else {
rtp->peer = (CHAR *) strdup(rtp->addr);
}
MUTEX_UNLOCK(&mutex);
if (rtp->peer == (CHAR *) NULL) {
rtp_log(RTP_ERR, "%s: strdup: %s", fid, strerror(errno));
return FALSE;
}
rtp->port = (UINT16) ntohs(cli_addr.sin_port);
return TRUE;
}
BOOL rtp_pid_decode(UINT8 *buf, INT32 *pid)
{
UINT32 ltmp; size_t llen = 4;
static CHAR *fid = "rtp_pid_decode";
if (buf == (UINT8 *) NULL || pid == (INT32 *) NULL) {
rtp_log(RTP_ERR, "%s: null input(s)", fid);
return FALSE;
}
memcpy((void *) <mp, (void *) buf, llen);
*pid = (INT32) ntohl((u_long) ltmp);
return TRUE;
}
int rtp_set_player (media_format_t * mf, media_player_t * player)
{
int ret;
char * type;
type = player->media_type(player);
if ( (ret = rtp_set_mime_player (mf, type, player)) >= MP_OK )
{
rtp_log (("rtp_set_player: '%s' stream playable\n", type));
return ret;
}
type = player->codec_type(player);
if ( (ret = rtp_set_mime_player (mf, type, player)) >= MP_OK )
{
rtp_log (("rtp_set_player: play '%s' stream\n", type));
return ret;
}
rtp_debug(("rtp_set_player: can't play the media with player\n"));
return ret;
}
int rtp_stream_on_member_update(void *gen, uint32 ssrc, char *cn, int cnlen)
{
media_stream_t *strm = (media_stream_t*)gen;
rtp_stream_t *rtpstrm = (rtp_stream_t*)gen;
if(strcmp(rtpstrm->source_cname, cn) != 0)
{
rtp_log(("rtp_stream_on_member_update: start stream[%s]\n", cn));
rtpstrm->source_cname = xstr_clone(cn);
}
rtp_debug(("\rrtp_stream_on_member_update: stream[%s] ok\n\n\n", cn));
strm->start(strm);
return MP_OK;
}
BOOL rtp_cmdpkt_send(RTP *rtp, RTP_CMDPKT *cmdpkt)
{
INT32 datlen;
UINT8 msg[sizeof(RTP_CMDPKT)];
static CHAR *fid = "rtp_cmdpkt_send";
if (rtp == (RTP *) NULL || cmdpkt == (RTP_CMDPKT *) NULL) {
rtp_log(RTP_ERR, "%s: null input(s)", fid);
errno = EINVAL;
return FALSE;
}
datlen = rtp_cmdpkt_encode(msg, cmdpkt);
return rtp_send(rtp, msg, RTP_MSG_CMDPKT, datlen);
}
int rtp_set_mime_player (media_format_t * mf, char * mime, media_player_t * player)
{
media_stream_t *cur = mf->first;
while (cur != NULL)
{
if (!strcmp(cur->mime, mime))
{
cur->player = player;
return MP_OK;
}
cur = cur->next;
}
rtp_log(("rtp_set_mime_player: stream '%s' not exist\n", mime));
return MP_FAIL;
}
/* New stream add to group */
int rtp_add_stream(media_format_t * rtp, media_stream_t *strm, int strmno, unsigned char type)
{
media_stream_t *cur = rtp->first;
if (rtp->first == NULL)
{
rtp->first = strm;
rtp->first->next = NULL;
}
else
{
cur = rtp->first;
while (cur->next != NULL)
cur = cur->next;
cur->next = strm;
strm->next = NULL;
}
switch(type)
{
case(MP_AUDIO): rtp->nastreams++;
/* default first audio stream as time reference */
if (rtp->nastreams == 1)
{
rtp_log(("rtp_add_stream: stream #%d as default time stream\n", rtp->numstreams));
rtp->time_ref = strmno;
}
break;
case(MP_VIDEO): rtp->nvstreams++; break;
case(MP_TEXT): rtp->ntstreams++; break;
}
rtp->numstreams++;
return MP_OK;
}
media_player_t* rtp_new_stream_player(media_format_t *mf, int strmno, media_control_t* ctrl, char* mode, void* mode_param)
{
media_stream_t *cur = mf->first;
if(!mode)
mode = "rtp";
while (cur != NULL)
{
rtp_stream_t* rtp_strm = (rtp_stream_t*)cur;
if (rtp_strm->sno == strmno)
{
cur->player = ctrl->find_player(ctrl, mode, cur->media_info->mime, cur->media_info->fourcc);
if(!cur->player)
{
rtp_debug(("rtp_new_stream_player: stream can't be played\n"));
cur->playable = -1;
return NULL;
}
if( cur->player->open_stream(cur->player, cur, cur->media_info) < MP_OK)
{
cur->playable = -1;
return NULL;
}
cur->playable = 1;
rtp_log(("rtp_new_stream_player: player ok\n"));
return cur->player;
}
cur = cur->next;
}
return NULL;
}
int rtp_set_fourcc_player (media_format_t * mf, media_player_t * player, const char *fourcc)
{
media_stream_t *cur = mf->first;
while (cur != NULL)
{
if ( !strncmp(cur->fourcc, fourcc, 4) )
{
cur->player = player;
return MP_OK;
}
cur = cur->next;
}
rtp_log(("rtp_set_fourcc_player: stream [%c%c%c%c] not exist\n"
, fourcc[0], fourcc[1], fourcc[2], fourcc[3]));
return MP_FAIL;
}
media_player_t * rtp_new_mime_player(media_format_t * mf, char * mime, media_control_t* ctrl, char* mode, void* mode_param)
{
media_stream_t *cur = mf->first;
if(!mode)
mode = "rtp";
while (cur != NULL)
{
if (!strcmp(cur->mime, mime))
{
cur->player = ctrl->find_player(ctrl, mode, mime, NULL);
if(!cur->player)
{
rtp_debug(("rtp_new_mime_player: stream can't be played\n"));
cur->playable = -1;
return NULL;
}
if( cur->player->open_stream(cur->player, cur, cur->media_info) < MP_OK)
{
cur->playable = -1;
return NULL;
}
cur->playable = 1;
rtp_log(("rtp_new_mime_player: player ok\n"));
}
cur = cur->next;
}
return NULL;
}
module_interface_t * media_new_format()
{
media_format_t * mf = NULL;
rtp_format_t * rtp = xmalloc(sizeof(struct rtp_format_s));
if(!rtp)
{
rtp_log(("rtp_new_rtp_group: No memery to allocate\n"));
return NULL;
}
memset(rtp, 0, sizeof(struct rtp_format_s));
rtp->open_capables = rtp_open_capables;
mf = (media_format_t *)rtp;
/* release a format */
mf->done = rtp_done_format;
mf->support_type = rtp_support_type;
/* Open/Close a media source */
mf->open = rtp_open;
mf->close = rtp_close;
/* Stream management */
mf->add_stream = rtp_add_stream;
mf->find_stream = rtp_find_stream;
mf->find_mime = rtp_find_mime;
mf->find_fourcc = rtp_find_fourcc;
mf->set_control = rtp_set_control;
mf->set_player = rtp_set_player;
/* Stream info */
mf->nstream = rtp_nstream;
mf->stream_mime = rtp_stream_mime;
mf->stream_fourcc = rtp_stream_fourcc;
mf->stream_player = rtp_stream_player;
mf->mime_player = rtp_mime_player;
mf->fourcc_player = rtp_fourcc_player;
mf->new_all_player = rtp_new_all_player;
mf->new_stream_player = rtp_new_stream_player;
mf->new_mime_player = rtp_new_mime_player;
mf->set_mime_player = rtp_set_mime_player;
mf->players = rtp_players;
/* Seek the media by time */
mf->seek_millisecond = rtp_seek_millisecond;
/* demux next sync stream group */
mf->demux_next = rtp_demux_next;
return mf;
}
static BOOL handshake(RTP *rtp)
{
UINT16 type;
INT16 client_version;
INT32 unused;
struct rtp_attr attr;
UINT8 msgbuf[RTP_MAXMSGLEN];
static CHAR *fid = "handshake";
/* Get the client protocol version number */
rtp_log(RTP_DEBUG, "%s: read client protocol version", fid);
if ((client_version = rtp_version_recv(rtp)) < 0) {
rtp_log(RTP_ERR, "%s: rtp_version_recv: error %d",
fid, client_version
);
return FALSE;
}
rtp_log(RTP_DEBUG, "%s: client version is %d", fid, client_version);
/* Send back our version number */
rtp_log(RTP_DEBUG, "%s: send server protcol version %d",
fid, RTP_VERSION
);
if (!rtp_version_send(rtp)) {
rtp_log(RTP_ERR, "%s: rtp_version_send failed", fid);
return FALSE;
}
/* If the client is a higher version, protocol says quit now */
if (client_version > RTP_VERSION) {
rtp_log(RTP_ERR, "%s: unsupported protocol version (%d)",
fid, client_version
);
return FALSE;
}
/* Following is specific to protocol version */
if (client_version == 1) {
/* client should begin with its process id */
if (!rtp_recv(rtp, msgbuf, &type, &unused)) {
rtp_log(RTP_ERR, "%s: rtp_recv failed", fid);
return FALSE;
}
if (type != RTP_MSG_PID) {
rtp_log(RTP_ERR, "%s: unexpected message type %d != %d",
fid, type, RTP_MSG_ATTR
);
errno = EPROTO;
return FALSE;
}
rtp_pid_decode(msgbuf, &rtp->pid);
rtp_log(RTP_DEBUG, "%s: client process id is %d", fid, rtp->pid);
/* which we acknowledge with our process id */
rtp_log(RTP_DEBUG, "%s: send pid ack", fid);
if (!rtp_pid_send(rtp)) {
rtp_log(RTP_ERR, "%s: rtp_pid_send failed", fid);
return FALSE;
}
/* client should then send its attribute request */
if (!rtp_recv(rtp, msgbuf, &type, &unused)) {
rtp_log(RTP_ERR, "%s: rtp_recv failed", fid);
return FALSE;
}
if (type != RTP_MSG_ATTR) {
rtp_log(RTP_ERR, "%s: unexpected message type %d != %d",
fid, type, RTP_MSG_ATTR
);
errno = EPROTO;
return FALSE;
}
rtp_attr_decode(msgbuf, &attr);
rtp_log(RTP_DEBUG, "%s: client attribute request received", fid);
/* which will load in and echo back (maybe change it, too) */
if (!set_attr(rtp, &attr)) {
rtp_log(RTP_ERR, "%s: set_attr failed", fid);
rtp_break(rtp);
return FALSE;
}
rtp_log(RTP_DEBUG, "%s: send attribute ack", fid);
if (!rtp_attr_send(rtp, &attr)) {
return FALSE;
}
} else {
rtp_log(RTP_ERR, "%s: unsupported protocol version (%d)",
fid, client_version
);
errno = EPROTO;
rtp_break(rtp);
return FALSE;
}
rtp_log(RTP_DEBUG, "%s: handshake complete", fid);
return TRUE;
}
/* Can not seek, unless talk to server with rtsp */
int rtp_seek_millisecond (media_format_t *mf, int ms)
{
rtp_log (("rtp_seek_millisecond: unseekable to %dms\n", ms));
return 0;
}
RTP *rtp_accept(RTP *server)
{
RTP *rtp;
struct sockaddr_in cli_addr;
int client, len = sizeof(cli_addr);
static CHAR *fid = "rtp_accept";
/* Create/fill the handle */
if ((rtp = (RTP *) malloc(sizeof(RTP))) == (RTP *) NULL) {
rtp_log(RTP_ERR, "%s: malloc: %s", fid, strerror(errno));
return (RTP *) NULL;
}
rtp->sd = server->sd;
rtp->port = server->port;
rtp->attr = server->attr;
rtp->soh.sh_tstamp = -1;
rtp->soh.sh_nslot = RTP_DEFNSLOT;
rtp->soh.sh_ndas = 0;
rtp->soh.sh_index = -1;
rtp->soh.sh_stat = (struct rtp_stat *)
malloc(sizeof(struct rtp_stat)*rtp->soh.sh_nslot);
if (rtp->soh.sh_stat == (struct rtp_stat *) NULL) {
rtp_log(RTP_ERR, "%s: malloc: %s", fid, strerror(errno));
free(rtp);
return (RTP *) NULL;
}
/* Accept a new connection */
client = INVALID_SOCKET;
while (client == INVALID_SOCKET) {
client = accept(server->sd, (struct sockaddr *) &cli_addr, &len);
if (client == INVALID_SOCKET && errno != EINTR) {
rtp_log(RTP_ERR, "%s: accept: %s", fid, strerror(errno));
free(rtp->soh.sh_stat);
free(rtp);
return (RTP *) NULL;
}
}
/* Complete the handle */
rtp->sd = client;
MUTEX_INIT(&rtp->rcv.mutex);
MUTEX_INIT(&rtp->snd.mutex);
if (!peer_info(rtp)) {
rtp_log(RTP_DEBUG, "%s: peer_info failed", fid);
free(rtp->soh.sh_stat);
free(rtp);
return (RTP *) NULL;
}
/* Windows NT defaults non-blocking */
#ifndef WINNT
if (fcntl(rtp->sd, F_SETFL, O_NONBLOCK) == -1) {
rtp_log(RTP_ERR, "%s: fcntl: %s", fid, strerror(errno));
free(rtp->soh.sh_stat);
free(rtp);
return (RTP *) NULL;
}
#endif
rtp_log(RTP_DEBUG, "%s: incoming connection from %s:%hu",
fid, rtp->peer, rtp->port
);
/* Do the handshake */
if (!handshake(rtp)) {
rtp_log(RTP_ERR, "%s: handshake failed", fid);
free(rtp->soh.sh_stat);
free(rtp);
return (RTP *) NULL;
}
/* Return handle for this connection */
return rtp;
}
rtp_stream_t* rtp_open_stream(rtp_format_t *rtp_format, int sno, rtpcap_descript_t *rtpcap, media_control_t *ctrl, char *mode, int bw_budget, void* extra)
{
unsigned char stype;
rtp_stream_t *strm;
rtp_stream_t *peer;
rtp_setting_t *rset = NULL;
int rtp_portno, rtcp_portno;
module_catalog_t *cata = ctrl->modules(ctrl);
rtpcap_set_t* rtpcapset = (rtpcap_set_t*)extra;
user_profile_t* user_prof = rtpcapset->user_profile;
char* remote_nettype;
char* remote_addrtype;
char* remote_netaddr;
if(strncmp(rtpcap->profile_mime, "audio", 5) == 0)
{
rtp_log(("rtp_open_stream: audio media\n"));
stype = MP_AUDIO;
}
else if(strncmp(rtpcap->profile_mime, "video", 5) == 0)
{
rtp_log(("rtp_open_stream: video media type\n"));
stype = MP_VIDEO;
}
else if(strncmp(rtpcap->profile_mime, "text", 4) == 0)
{
rtp_log(("rtp_open_stream: text media type\n"));
stype = MP_TEXT;
}
else
{
rtp_debug(("rtp_open_stream: Unknown media type\n"));
return NULL;
}
strm = xmalloc(sizeof(rtp_stream_t));
if(!strm)
{
rtp_debug(("rtp_open_stream: No memory for rtp stream\n"));
return NULL;
}
peer = xmalloc(sizeof(rtp_stream_t));
if(!peer)
{
rtp_debug(("rtp_open_stream: No memory for rtp stream\n"));
xfree(strm);
return NULL;
}
memset(strm, 0, sizeof(rtp_stream_t));
memset(peer, 0, sizeof(rtp_stream_t));
strm->stream.peer = (media_stream_t*)peer;
peer->stream.peer = (media_stream_t*)strm;
rset = (rtp_setting_t*)ctrl->fetch_setting(ctrl, "rtp", (media_device_t*)rtp_format->rtp_in);
if(!rset)
{
rtp_debug(("rtp_open_stream: No rtp setting\n"));
xfree(strm);
return NULL;
}
strm->session = rtp_format->rtp_in->rtp_session(rtp_format->rtp_in, cata, ctrl,
user_prof->cname, strlen(user_prof->cname)+1,
user_prof->user->nettype, user_prof->user->addrtype,
user_prof->user->netaddr,
rset->default_rtp_portno, rset->default_rtcp_portno,
rtpcap->profile_no, rtpcap->profile_mime,
rtpcap->clockrate, rtpcap->coding_param,
bw_budget, rtpcap);
if(!strm->session)
{
xfree(strm);
rtp_debug(("rtp_open_stream: no session created\n"));
return NULL;
}
strm->session->media_stream = strm;
rtp_debug(("\rrtp_open_stream: strm@%x\n", (int)strm));
/* get real portno and payload type */
session_portno(strm->session, &rtp_portno, &rtcp_portno);
rtpcap->profile_no = session_payload_type(strm->session);
strm->rtp_format = rtp_format;
peer->rtp_format = rtp_format;
strm->rtp_cap = rtpcap;
peer->rtp_cap = rtpcap;
strm->stream.media_info = session_mediainfo(strm->session);
peer->stream.media_info = strm->stream.media_info;
peer->session = strm->session;
strm->stream.start = rtp_start_stream;
strm->stream.stop = rtp_stop_stream;
peer->stream.start = rtp_start_stream;
peer->stream.stop = rtp_stop_stream;
rtp_log(("rtp_open_stream: FIXME - stream mime string overflow possible!!\n"));
strcpy(strm->stream.mime, rtpcap->profile_mime);
rtp_add_stream((media_format_t*)rtp_format, (media_stream_t*)strm, sno, stype);
if(rtpcap->netaddr)
{
remote_nettype = rtpcap->nettype;
remote_addrtype = rtpcap->addrtype;
remote_netaddr = rtpcap->netaddr;
}
else
{
remote_nettype = rtpcapset->nettype;
remote_addrtype = rtpcapset->addrtype;
remote_netaddr = rtpcapset->netaddr;
}
rtp_log(("rtp_open_stream: for %s:%s(%u|%u)\n", rtpcapset->cname, remote_netaddr, rtpcap->rtp_portno, rtpcap->rtcp_portno));
rtp_log(("rtp_open_stream: mime[%s] pt[%d]\n", rtpcap->profile_mime, rtpcap->profile_no));
session_add_cname(strm->session, rtpcapset->cname, strlen(rtpcapset->cname), remote_netaddr, rtpcap->rtp_portno, rtpcap->rtcp_portno, rtpcap, ctrl);
/* waiting to source to be available */
strm->source_cname = xstr_clone(rtpcapset->cname);
strm->bandwidth = session_bandwidth(strm->session);
peer->source_cname = xstr_clone(user_prof->cname);
peer->bandwidth = strm->bandwidth;
rtp_format->bandwidth += strm->bandwidth + peer->bandwidth;
session_set_callback(strm->session, CALLBACK_SESSION_MEMBER_UPDATE, rtp_stream_on_member_update, strm);
rtp_log(("rtp_open_stream: stream opened, bandwidth[%d]\n", strm->bandwidth));
return strm;
}
BOOL decode_steim( VOID *ptr, INT16 *n, INT32 *samples, INT32 *prev ) {
BOOL skip_ird;
INT8 f_ndx, c_ndx, n_difs;
INT16 i, n_samp;
INT32 sum, difs[4], fi_con, ri_con;
UINT32 flags;
STEIM *rec;
n_samp = *n;
/* Get the integration constants */
rec = (STEIM *)((INT8 *)ptr+64);
fi_con = swap_l( rec->frame[0].chunk[0].l );
ri_con = swap_l( rec->frame[0].chunk[1].l );
/* Init the running sum and save the first sample */
sum = fi_con;
n_samp--;
*samples++ = sum;
/* Skip the inter-record delta, i.e., the difference between records */
skip_ird = TRUE;
/* Process up to 15 frames */
for( f_ndx=0; f_ndx<15; f_ndx++ ) {
/* Get the frame flags */
flags = swap_l( rec->frame[f_ndx].flags );
/* Process 15 chunks per frame */
for( c_ndx=0; c_ndx<15; c_ndx++ ) {
/* Count down samples to 0 */
if( n_samp <= 0 )
break;
/* Process a chunk based on type */
switch( _chunk_type( flags, c_ndx ) ) {
case CHUNK_NULL:
continue;
case CHUNK_BYTES:
for( i=0; i<4; i++ )
difs[i] = (INT32)rec->frame[f_ndx].chunk[c_ndx].b[i];
n_difs = 4;
break;
case CHUNK_WORDS:
for( i=0; i<2; i++ )
difs[i] = (INT32)swap_w( rec->frame[f_ndx].chunk[c_ndx].w[i] );
n_difs = 2;
break;
case CHUNK_LONG:
difs[0] = swap_l( rec->frame[f_ndx].chunk[c_ndx].l );
n_difs = 1;
break;
}
/* Save the decoded samples */
for( i=0; i<n_difs; i++ ) {
if( skip_ird ) {
skip_ird = FALSE;
*prev = fi_con - difs[0];
// *prev = 0;
}
else {
sum += difs[i];
*samples++ = sum;
n_samp--;
if( n_samp <= 0 )
break;
}
}
}
}
if( n_samp > 0 ) {
#ifdef DEBUG
printf( "WARNING: Partial decompression of sample data, n_samp = %d\n", n_samp );
#endif
rtp_log(RTP_WARN, "WARNING: Partial decompression of sample data, n_samp = %d\n", n_samp );
*n = n_samp;
return( FALSE );
}
if( sum != ri_con ) {
#ifdef DEBUG
printf( "WARNING: Unreconciled reverse integrating constant: %ld, sum: %ld\n",
ri_con, sum );
#endif
rtp_log(RTP_WARN, "WARNING: Unreconciled reverse integrating constant: %ld, sum: %ld\n",
ri_con, sum );
return( FALSE );
}
return( TRUE );
}
