#include "bitstream.h"
#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#ifndef __BEOS__
-# include <arpa/inet.h>
-#else
-# include "barpainet.h"
-#endif
-#include <netdb.h>
+#include "network.h"
#include "rtp_internal.h"
-
-//#define RTP_H264
-#ifdef RTP_H264
- #include "rtp_h264.h"
-#endif
+#include "rtp_h264.h"
+#include "rtp_mpv.h"
+#include "rtp_aac.h"
//#define DEBUG
+#define RTCP_SR_SIZE 28
/* TODO: - add RTCP statistics reporting (should be optional).
RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
-static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_MPEG4AAC};
+static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
{
RTPFirstDynamicPayloadHandler= handler;
}
-void av_register_rtp_dynamic_payload_handlers()
+void av_register_rtp_dynamic_payload_handlers(void)
{
register_dynamic_payload_handler(&mp4v_es_handler);
register_dynamic_payload_handler(&mpeg4_generic_handler);
-#ifdef RTP_H264
register_dynamic_payload_handler(&ff_h264_dynamic_handler);
-#endif
}
int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
return -1;
}
-/* return < 0 if unknown payload type */
int rtp_get_payload_type(AVCodecContext *codec)
{
int i, payload_type;
return payload_type;
}
-static inline uint32_t decode_be32(const uint8_t *p)
-{
- return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
-}
-
-static inline uint64_t decode_be64(const uint8_t *p)
-{
- return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
-}
-
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
{
if (buf[1] != 200)
return -1;
- s->last_rtcp_ntp_time = decode_be64(buf + 8);
+ s->last_rtcp_ntp_time = AV_RB64(buf + 8);
if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
- s->last_rtcp_timestamp = decode_be32(buf + 16);
+ s->last_rtcp_timestamp = AV_RB32(buf + 16);
return 0;
}
+#define RTP_SEQ_MOD (1<<16)
+
/**
- * some rtp servers assume client is dead if they don't hear from them...
- * so we send a Receiver Report to the provided ByteIO context
- * (we don't have access to the rtcp handle from here)
- */
+* called on parse open packet
+*/
+static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
+{
+ memset(s, 0, sizeof(RTPStatistics));
+ s->max_seq= base_sequence;
+ s->probation= 1;
+}
+
+/**
+* called whenever there is a large jump in sequence numbers, or when they get out of probation...
+*/
+static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
+{
+ s->max_seq= seq;
+ s->cycles= 0;
+ s->base_seq= seq -1;
+ s->bad_seq= RTP_SEQ_MOD + 1;
+ s->received= 0;
+ s->expected_prior= 0;
+ s->received_prior= 0;
+ s->jitter= 0;
+ s->transit= 0;
+}
+
+/**
+* returns 1 if we should handle this packet.
+*/
+static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
+{
+ uint16_t udelta= seq - s->max_seq;
+ const int MAX_DROPOUT= 3000;
+ const int MAX_MISORDER = 100;
+ const int MIN_SEQUENTIAL = 2;
+
+ /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
+ if(s->probation)
+ {
+ if(seq==s->max_seq + 1) {
+ s->probation--;
+ s->max_seq= seq;
+ if(s->probation==0) {
+ rtp_init_sequence(s, seq);
+ s->received++;
+ return 1;
+ }
+ } else {
+ s->probation= MIN_SEQUENTIAL - 1;
+ s->max_seq = seq;
+ }
+ } else if (udelta < MAX_DROPOUT) {
+ // in order, with permissible gap
+ if(seq < s->max_seq) {
+ //sequence number wrapped; count antother 64k cycles
+ s->cycles += RTP_SEQ_MOD;
+ }
+ s->max_seq= seq;
+ } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
+ // sequence made a large jump...
+ if(seq==s->bad_seq) {
+ // two sequential packets-- assume that the other side restarted without telling us; just resync.
+ rtp_init_sequence(s, seq);
+ } else {
+ s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
+ return 0;
+ }
+ } else {
+ // duplicate or reordered packet...
+ }
+ s->received++;
+ return 1;
+}
+
+#if 0
+/**
+* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
+* difference between the arrival and sent timestamp. As a result, the jitter and transit statistics values
+* never change. I left this in in case someone else can see a way. (rdm)
+*/
+static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
+{
+ uint32_t transit= arrival_timestamp - sent_timestamp;
+ int d;
+ s->transit= transit;
+ d= FFABS(transit - s->transit);
+ s->jitter += d - ((s->jitter + 8)>>4);
+}
+#endif
+
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
{
ByteIOContext pb;
uint8_t *buf;
int len;
int rtcp_bytes;
+ RTPStatistics *stats= &s->statistics;
+ uint32_t lost;
+ uint32_t extended_max;
+ uint32_t expected_interval;
+ uint32_t received_interval;
+ uint32_t lost_interval;
+ uint32_t expected;
+ uint32_t fraction;
+ uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
if (!s->rtp_ctx || (count < 1))
return -1;
+ /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
/* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
s->octet_count += count;
rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
put_be32(&pb, s->ssrc); // our own SSRC
put_be32(&pb, s->ssrc); // XXX: should be the server's here!
// some placeholders we should really fill...
- put_be32(&pb, ((0 << 24) | (0 & 0x0ffffff))); /* 0% lost, total 0 lost */
- put_be32(&pb, (0 << 16) | s->seq);
- put_be32(&pb, 0x68); /* jitter */
- put_be32(&pb, -1); /* last SR timestamp */
- put_be32(&pb, 1); /* delay since last SR */
+ // RFC 1889/p64
+ extended_max= stats->cycles + stats->max_seq;
+ expected= extended_max - stats->base_seq + 1;
+ lost= expected - stats->received;
+ lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
+ expected_interval= expected - stats->expected_prior;
+ stats->expected_prior= expected;
+ received_interval= stats->received - stats->received_prior;
+ stats->received_prior= stats->received;
+ lost_interval= expected_interval - received_interval;
+ if (expected_interval==0 || lost_interval<=0) fraction= 0;
+ else fraction = (lost_interval<<8)/expected_interval;
+
+ fraction= (fraction<<24) | lost;
+
+ put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
+ put_be32(&pb, extended_max); /* max sequence received */
+ put_be32(&pb, stats->jitter>>4); /* jitter */
+
+ if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
+ {
+ put_be32(&pb, 0); /* last SR timestamp */
+ put_be32(&pb, 0); /* delay since last SR */
+ } else {
+ uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
+ uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
+
+ put_be32(&pb, middle_32_bits); /* last SR timestamp */
+ put_be32(&pb, delay_since_last); /* delay since last SR */
+ }
// CNAME
put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
put_flush_packet(&pb);
len = url_close_dyn_buf(&pb, &buf);
if ((len > 0) && buf) {
+ int result;
#if defined(DEBUG)
printf("sending %d bytes of RR\n", len);
#endif
- url_write(s->rtp_ctx, buf, len);
+ result= url_write(s->rtp_ctx, buf, len);
+#if defined(DEBUG)
+ printf("result from url_write: %d\n", result);
+#endif
av_free(buf);
}
return 0;
s->ic = s1;
s->st = st;
s->rtp_payload_data = rtp_payload_data;
+ rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
s->ts = mpegts_parse_open(s->ic);
if (s->ts == NULL) {
case CODEC_ID_MP2:
case CODEC_ID_MP3:
case CODEC_ID_MPEG4:
-#ifdef RTP_H264
case CODEC_ID_H264:
-#endif
- st->need_parsing = 1;
+ st->need_parsing = AVSTREAM_PARSE_FULL;
break;
default:
break;
/* decode the first 2 bytes where are stored the AUHeader sections
length in bits */
- au_headers_length = BE_16(buf);
+ au_headers_length = AV_RB16(buf);
if (au_headers_length > RTP_MAX_PACKET_LENGTH)
return -1;
infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
/* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
- In my test, the faad decoder doesnt behave correctly when sending each AU one by one
+ In my test, the FAAD decoder does not behave correctly when sending each AU one by one
but does when sending the whole as one big packet... */
infos->au_headers[0].size = 0;
infos->au_headers[0].index = 0;
pkt->pts = addend + delta_timestamp;
}
break;
- case CODEC_ID_MPEG4AAC:
+ case CODEC_ID_AAC:
case CODEC_ID_H264:
case CODEC_ID_MPEG4:
pkt->pts = timestamp;
return -1;
}
payload_type = buf[1] & 0x7f;
- seq = (buf[2] << 8) | buf[3];
- timestamp = decode_be32(buf + 4);
- ssrc = decode_be32(buf + 8);
+ seq = AV_RB16(buf + 2);
+ timestamp = AV_RB32(buf + 4);
+ ssrc = AV_RB32(buf + 8);
/* store the ssrc in the RTPDemuxContext */
s->ssrc = ssrc;
return -1;
st = s->st;
-#if defined(DEBUG) || 1
- if (seq != ((s->seq + 1) & 0xffff)) {
+ // only do something with this if all the rtp checks pass...
+ if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
+ {
av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
payload_type, seq, ((s->seq + 1) & 0xffff));
+ return -1;
}
-#endif
+
s->seq = seq;
len -= 12;
buf += 12;
/* better than nothing: skip mpeg audio RTP header */
if (len <= 4)
return -1;
- h = decode_be32(buf);
+ h = AV_RB32(buf);
len -= 4;
buf += 4;
av_new_packet(pkt, len);
/* better than nothing: skip mpeg video RTP header */
if (len <= 4)
return -1;
- h = decode_be32(buf);
+ h = AV_RB32(buf);
buf += 4;
len -= 4;
if (h & (1 << 26)) {
// moved from below, verbatim. this is because this section handles packets, and the lower switch handles
// timestamps.
// TODO: Put this into a dynamic packet handler...
- case CODEC_ID_MPEG4AAC:
+ case CODEC_ID_AAC:
if (rtp_parse_mp4_au(s, buf))
return -1;
{
len -= infos->au_headers[0].size;
}
s->read_buf_size = len;
- s->buf_ptr = buf;
rv= 0;
break;
default:
// following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
s->timestamp = s->base_timestamp;
+ s->cur_timestamp = 0;
s->ssrc = 0; /* FIXME: was random(), what should this be? */
s->first_packet = 1;
+ s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
max_packet_size = url_fget_max_packet_size(&s1->pb);
if (max_packet_size <= 12)
- return AVERROR_IO;
+ return AVERROR(EIO);
s->max_payload_size = max_packet_size - 12;
+ s->max_frames_per_packet = 0;
+ if (s1->max_delay) {
+ if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ if (st->codec->frame_size == 0) {
+ av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
+ } else {
+ s->max_frames_per_packet = av_rescale_rnd(s1->max_delay, st->codec->sample_rate, AV_TIME_BASE * st->codec->frame_size, AV_ROUND_DOWN);
+ }
+ }
+ if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
+ /* FIXME: We should round down here... */
+ s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
+ }
+ }
+
+ av_set_pts_info(st, 32, 1, 90000);
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
case CODEC_ID_MP3:
s->buf_ptr = s->buf + 4;
- s->cur_timestamp = 0;
break;
case CODEC_ID_MPEG1VIDEO:
- s->cur_timestamp = 0;
break;
case CODEC_ID_MPEG2TS:
n = s->max_payload_size / TS_PACKET_SIZE;
s->max_payload_size = n * TS_PACKET_SIZE;
s->buf_ptr = s->buf;
break;
+ case CODEC_ID_AAC:
+ s->read_buf_index = 0;
default:
+ if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+ }
s->buf_ptr = s->buf;
break;
}
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
{
RTPDemuxContext *s = s1->priv_data;
+ uint32_t rtp_ts;
+
#if defined(DEBUG)
printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
#endif
+
+ if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
+ s->last_rtcp_ntp_time = ntp_time;
+ rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
+ s1->streams[0]->time_base) + s->base_timestamp;
put_byte(&s1->pb, (RTP_VERSION << 6));
put_byte(&s1->pb, 200);
put_be16(&s1->pb, 6); /* length in words - 1 */
put_be32(&s1->pb, s->ssrc);
- put_be64(&s1->pb, ntp_time);
- put_be32(&s1->pb, s->timestamp);
+ put_be32(&s1->pb, ntp_time / 1000000);
+ put_be32(&s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
+ put_be32(&s1->pb, rtp_ts);
put_be32(&s1->pb, s->packet_count);
put_be32(&s1->pb, s->octet_count);
put_flush_packet(&s1->pb);
/* send an rtp packet. sequence number is incremented, but the caller
must update the timestamp itself */
-static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
+void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
{
RTPDemuxContext *s = s1->priv_data;
/* not needed, but who nows */
if ((size % sample_size) != 0)
av_abort();
+ n = 0;
while (size > 0) {
- len = (max_packet_size - (s->buf_ptr - s->buf));
- if (len > size)
- len = size;
+ s->buf_ptr = s->buf;
+ len = FFMIN(max_packet_size, size);
/* copy data */
memcpy(s->buf_ptr, buf1, len);
s->buf_ptr += len;
buf1 += len;
size -= len;
- n = (s->buf_ptr - s->buf);
- /* if buffer full, then send it */
- if (n >= max_packet_size) {
- rtp_send_data(s1, s->buf, n, 0);
- s->buf_ptr = s->buf;
- /* update timestamp */
- s->timestamp += n / sample_size;
- }
+ s->timestamp = s->cur_timestamp + n / sample_size;
+ ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
+ n += (s->buf_ptr - s->buf);
}
}
const uint8_t *buf1, int size)
{
RTPDemuxContext *s = s1->priv_data;
- AVStream *st = s1->streams[0];
int len, count, max_packet_size;
max_packet_size = s->max_payload_size;
len = (s->buf_ptr - s->buf);
if ((len + size) > max_packet_size) {
if (len > 4) {
- rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
+ ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
s->buf_ptr = s->buf + 4;
- /* 90 KHz time stamp */
- s->timestamp = s->base_timestamp +
- (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
}
}
+ if (s->buf_ptr == s->buf + 4) {
+ s->timestamp = s->cur_timestamp;
+ }
/* add the packet */
if (size > max_packet_size) {
s->buf[2] = count >> 8;
s->buf[3] = count;
memcpy(s->buf + 4, buf1, len);
- rtp_send_data(s1, s->buf, len + 4, 0);
+ ff_rtp_send_data(s1, s->buf, len + 4, 0);
size -= len;
buf1 += len;
count += len;
memcpy(s->buf_ptr, buf1, size);
s->buf_ptr += size;
}
- s->cur_timestamp += st->codec->frame_size;
-}
-
-/* NOTE: a single frame must be passed with sequence header if
- needed. XXX: use slices. */
-static void rtp_send_mpegvideo(AVFormatContext *s1,
- const uint8_t *buf1, int size)
-{
- RTPDemuxContext *s = s1->priv_data;
- AVStream *st = s1->streams[0];
- int len, h, max_packet_size;
- uint8_t *q;
-
- max_packet_size = s->max_payload_size;
-
- while (size > 0) {
- /* XXX: more correct headers */
- h = 0;
- if (st->codec->sub_id == 2)
- h |= 1 << 26; /* mpeg 2 indicator */
- q = s->buf;
- *q++ = h >> 24;
- *q++ = h >> 16;
- *q++ = h >> 8;
- *q++ = h;
-
- if (st->codec->sub_id == 2) {
- h = 0;
- *q++ = h >> 24;
- *q++ = h >> 16;
- *q++ = h >> 8;
- *q++ = h;
- }
-
- len = max_packet_size - (q - s->buf);
- if (len > size)
- len = size;
-
- memcpy(q, buf1, len);
- q += len;
-
- /* 90 KHz time stamp */
- s->timestamp = s->base_timestamp +
- av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
- rtp_send_data(s1, s->buf, q - s->buf, (len == size));
-
- buf1 += len;
- size -= len;
- }
- s->cur_timestamp++;
}
static void rtp_send_raw(AVFormatContext *s1,
const uint8_t *buf1, int size)
{
RTPDemuxContext *s = s1->priv_data;
- AVStream *st = s1->streams[0];
int len, max_packet_size;
max_packet_size = s->max_payload_size;
if (len > size)
len = size;
- /* 90 KHz time stamp */
- s->timestamp = s->base_timestamp +
- av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
- rtp_send_data(s1, buf1, len, (len == size));
+ s->timestamp = s->cur_timestamp;
+ ff_rtp_send_data(s1, buf1, len, (len == size));
buf1 += len;
size -= len;
}
- s->cur_timestamp++;
}
/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
out_len = s->buf_ptr - s->buf;
if (out_len >= s->max_payload_size) {
- rtp_send_data(s1, s->buf, out_len, 0);
+ ff_rtp_send_data(s1, s->buf, out_len, 0);
s->buf_ptr = s->buf;
}
}
RTPDemuxContext *s = s1->priv_data;
AVStream *st = s1->streams[0];
int rtcp_bytes;
- int64_t ntp_time;
int size= pkt->size;
uint8_t *buf1= pkt->data;
/* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
RTCP_TX_RATIO_DEN;
- if (s->first_packet || rtcp_bytes >= 28) {
- /* compute NTP time */
- /* XXX: 90 kHz timestamp hardcoded */
- ntp_time = (pkt->pts << 28) / 5625;
- rtcp_send_sr(s1, ntp_time);
+ if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
+ (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
+ rtcp_send_sr(s1, av_gettime());
s->last_octet_count = s->octet_count;
s->first_packet = 0;
}
+ s->cur_timestamp = s->base_timestamp + pkt->pts;
switch(st->codec->codec_id) {
case CODEC_ID_PCM_MULAW:
rtp_send_mpegaudio(s1, buf1, size);
break;
case CODEC_ID_MPEG1VIDEO:
- rtp_send_mpegvideo(s1, buf1, size);
+ ff_rtp_send_mpegvideo(s1, buf1, size);
+ break;
+ case CODEC_ID_AAC:
+ ff_rtp_send_aac(s1, buf1, size);
break;
case CODEC_ID_MPEG2TS:
rtp_send_mpegts_raw(s1, buf1, size);
return 0;
}
-static int rtp_write_trailer(AVFormatContext *s1)
-{
- // RTPDemuxContext *s = s1->priv_data;
- return 0;
-}
-
AVOutputFormat rtp_muxer = {
"rtp",
"RTP output format",
CODEC_ID_NONE,
rtp_write_header,
rtp_write_packet,
- rtp_write_trailer,
};
projects / ffmpeg / blobdiff