/*
* RTP input format
- * Copyright (c) 2002 Fabrice Bellard.
+ * Copyright (c) 2002 Fabrice Bellard
*
* This file is part of FFmpeg.
*
/* needed for gethostname() */
#define _XOPEN_SOURCE 600
-#include "libavcodec/bitstream.h"
+#include "libavcodec/get_bits.h"
#include "avformat.h"
#include "mpegts.h"
#include <unistd.h>
#include "network.h"
-#include "rtp_internal.h"
-#include "rtp_h264.h"
+#include "rtpdec.h"
+#include "rtpdec_amr.h"
+#include "rtpdec_asf.h"
+#include "rtpdec_h263.h"
+#include "rtpdec_h264.h"
+#include "rtpdec_xiph.h"
//#define DEBUG
/* statistics functions */
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_AAC};
+static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4};
+static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC};
void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
{
{
ff_register_dynamic_payload_handler(&mp4v_es_handler);
ff_register_dynamic_payload_handler(&mpeg4_generic_handler);
+ ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
+
+ ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
+ ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
}
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
return 0;
}
+void rtp_send_punch_packets(URLContext* rtp_handle)
+{
+ ByteIOContext *pb;
+ uint8_t *buf;
+ int len;
+
+ /* Send a small RTP packet */
+ if (url_open_dyn_buf(&pb) < 0)
+ return;
+
+ put_byte(pb, (RTP_VERSION << 6));
+ put_byte(pb, 0); /* Payload type */
+ put_be16(pb, 0); /* Seq */
+ put_be32(pb, 0); /* Timestamp */
+ put_be32(pb, 0); /* SSRC */
+
+ put_flush_packet(pb);
+ len = url_close_dyn_buf(pb, &buf);
+ if ((len > 0) && buf)
+ url_write(rtp_handle, buf, len);
+ av_free(buf);
+
+ /* Send a minimal RTCP RR */
+ if (url_open_dyn_buf(&pb) < 0)
+ return;
+
+ put_byte(pb, (RTP_VERSION << 6));
+ put_byte(pb, 201); /* receiver report */
+ put_be16(pb, 1); /* length in words - 1 */
+ put_be32(pb, 0); /* our own SSRC */
+
+ put_flush_packet(pb);
+ len = url_close_dyn_buf(pb, &buf);
+ if ((len > 0) && buf)
+ url_write(rtp_handle, buf, len);
+ av_free(buf);
+}
+
+
/**
* open a new RTP parse context for stream 'st'. 'st' can be NULL for
* MPEG2TS streams to indicate that they should be demuxed inside the
* rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
* TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
*/
-RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
+RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
{
RTPDemuxContext *s;
s->rtp_payload_data = rtp_payload_data;
rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
- s->ts = mpegts_parse_open(s->ic);
+ s->ts = ff_mpegts_parse_open(s->ic);
if (s->ts == NULL) {
av_free(s);
return NULL;
case CODEC_ID_MP2:
case CODEC_ID_MP3:
case CODEC_ID_MPEG4:
+ case CODEC_ID_H263:
case CODEC_ID_H264:
st->need_parsing = AVSTREAM_PARSE_FULL;
break;
default:
- if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
+ if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
av_set_pts_info(st, 32, 1, st->codec->sample_rate);
}
break;
return s;
}
+void
+rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
+ RTPDynamicProtocolHandler *handler)
+{
+ s->dynamic_protocol_context = ctx;
+ s->parse_packet = handler->parse_packet;
+}
+
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
{
int au_headers_length, au_header_size, i;
GetBitContext getbitcontext;
- rtp_payload_data_t *infos;
+ RTPPayloadData *infos;
infos = s->rtp_payload_data;
return -1;
infos->nb_au_headers = au_headers_length / au_header_size;
- infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
+ if (!infos->au_headers || infos->au_headers_allocated < infos->nb_au_headers) {
+ av_free(infos->au_headers);
+ infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
+ infos->au_headers_allocated = 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 does not behave correctly when sending each AU one by one
delta_timestamp = timestamp - s->last_rtcp_timestamp;
/* convert to the PTS timebase */
addend = av_rescale(s->last_rtcp_ntp_time - s->first_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
- pkt->pts = addend + delta_timestamp;
+ pkt->pts = s->range_start_offset + addend + delta_timestamp;
}
- pkt->stream_index = s->st->index;
}
/**
/* return the next packets, if any */
if(s->st && s->parse_packet) {
timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
- rv= s->parse_packet(s, pkt, ×tamp, NULL, 0, flags);
+ rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
+ s->st, pkt, ×tamp, NULL, 0, flags);
finalize_packet(s, pkt, timestamp);
return rv;
} else {
// TODO: Move to a dynamic packet handler (like above)
if (s->read_buf_index >= s->read_buf_size)
return -1;
- ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
+ ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
s->read_buf_size - s->read_buf_index);
if (ret < 0)
return -1;
return -1;
}
payload_type = buf[1] & 0x7f;
+ if (buf[1] & 0x80)
+ flags |= RTP_FLAG_MARKER;
seq = AV_RB16(buf + 2);
timestamp = AV_RB32(buf + 4);
ssrc = AV_RB32(buf + 8);
if (!st) {
/* specific MPEG2TS demux support */
- ret = mpegts_parse_packet(s->ts, pkt, buf, len);
+ ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
if (ret < 0)
return -1;
if (ret < len) {
s->read_buf_index = 0;
return 1;
}
+ return 0;
} else if (s->parse_packet) {
- rv = s->parse_packet(s, pkt, ×tamp, buf, len, flags);
+ rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
+ s->st, pkt, ×tamp, buf, len, flags);
} else {
// at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise.
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
+ case CODEC_ID_MP3:
/* better than nothing: skip mpeg audio RTP header */
if (len <= 4)
return -1;
if (rtp_parse_mp4_au(s, buf))
return -1;
{
- rtp_payload_data_t *infos = s->rtp_payload_data;
+ RTPPayloadData *infos = s->rtp_payload_data;
if (infos == NULL)
return -1;
buf += infos->au_headers_length_bytes + 2;
break;
}
- // now perform timestamp things....
- finalize_packet(s, pkt, timestamp);
+ pkt->stream_index = st->index;
}
+
+ // now perform timestamp things....
+ finalize_packet(s, pkt, timestamp);
+
return rv;
}
void rtp_parse_close(RTPDemuxContext *s)
{
// TODO: fold this into the protocol specific data fields.
+ av_free(s->rtp_payload_data->mode);
+ av_free(s->rtp_payload_data->au_headers);
if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
- mpegts_parse_close(s->ts);
+ ff_mpegts_parse_close(s->ts);
}
av_free(s);
}