* RTP input format
* Copyright (c) 2002 Fabrice Bellard
*
- * This file is part of FFmpeg.
+ * This file is part of Libav.
*
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "mpegts.h"
#include <unistd.h>
+#include <strings.h>
#include "network.h"
#include "rtpdec.h"
'url_open_dyn_packet_buf')
*/
+static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
+ .enc_name = "X-MP3-draft-00",
+ .codec_type = AVMEDIA_TYPE_AUDIO,
+ .codec_id = CODEC_ID_MP3ADU,
+};
+
/* statistics functions */
-RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
+static RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
{
ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler);
ff_register_dynamic_payload_handler(&ff_mp4a_latm_dynamic_handler);
ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_qcelp_dynamic_handler);
+ ff_register_dynamic_payload_handler(&ff_realmedia_mp3_dynamic_handler);
ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
ff_register_dynamic_payload_handler(&ff_quicktime_rtp_vid_handler);
}
+RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name,
+ enum AVMediaType codec_type)
+{
+ RTPDynamicProtocolHandler *handler;
+ for (handler = RTPFirstDynamicPayloadHandler;
+ handler; handler = handler->next)
+ if (!strcasecmp(name, handler->enc_name) &&
+ codec_type == handler->codec_type)
+ return handler;
+ return NULL;
+}
+
+RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id,
+ enum AVMediaType codec_type)
+{
+ RTPDynamicProtocolHandler *handler;
+ for (handler = RTPFirstDynamicPayloadHandler;
+ handler; handler = handler->next)
+ if (handler->static_payload_id && handler->static_payload_id == id &&
+ codec_type == handler->codec_type)
+ return handler;
+ return NULL;
+}
+
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
{
int payload_len;
payload_len = (AV_RB16(buf + 2) + 1) * 4;
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 = AV_RB32(buf + 16);
+ if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
+ s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
+ if (!s->base_timestamp)
+ s->base_timestamp = s->last_rtcp_timestamp;
+ s->rtcp_ts_offset = s->last_rtcp_timestamp - s->base_timestamp;
+ }
buf += payload_len;
len -= payload_len;
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
{
- ByteIOContext *pb;
+ AVIOContext *pb;
uint8_t *buf;
int len;
int rtcp_bytes;
return -1;
// Receiver Report
- put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
- put_byte(pb, RTCP_RR);
- put_be16(pb, 7); /* length in words - 1 */
+ avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+ avio_w8(pb, RTCP_RR);
+ avio_wb16(pb, 7); /* length in words - 1 */
// our own SSRC: we use the server's SSRC + 1 to avoid conflicts
- put_be32(pb, s->ssrc + 1);
- put_be32(pb, s->ssrc); // server SSRC
+ avio_wb32(pb, s->ssrc + 1);
+ avio_wb32(pb, s->ssrc); // server SSRC
// some placeholders we should really fill...
// RFC 1889/p64
extended_max= stats->cycles + stats->max_seq;
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 */
+ avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
+ avio_wb32(pb, extended_max); /* max sequence received */
+ avio_wb32(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 */
+ avio_wb32(pb, 0); /* last SR timestamp */
+ avio_wb32(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 */
+ avio_wb32(pb, middle_32_bits); /* last SR timestamp */
+ avio_wb32(pb, delay_since_last); /* delay since last SR */
}
// CNAME
- put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
- put_byte(pb, RTCP_SDES);
+ avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
+ avio_w8(pb, RTCP_SDES);
len = strlen(s->hostname);
- put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
- put_be32(pb, s->ssrc);
- put_byte(pb, 0x01);
- put_byte(pb, len);
- put_buffer(pb, s->hostname, len);
+ avio_wb16(pb, (6 + len + 3) / 4); /* length in words - 1 */
+ avio_wb32(pb, s->ssrc);
+ avio_w8(pb, 0x01);
+ avio_w8(pb, len);
+ avio_write(pb, s->hostname, len);
// padding
for (len = (6 + len) % 4; len % 4; len++) {
- put_byte(pb, 0);
+ avio_w8(pb, 0);
}
- put_flush_packet(pb);
+ avio_flush(pb);
len = url_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) {
int result;
- dprintf(s->ic, "sending %d bytes of RR\n", len);
+ av_dlog(s->ic, "sending %d bytes of RR\n", len);
result= url_write(s->rtp_ctx, buf, len);
- dprintf(s->ic, "result from url_write: %d\n", result);
+ av_dlog(s->ic, "result from url_write: %d\n", result);
av_free(buf);
}
return 0;
void rtp_send_punch_packets(URLContext* rtp_handle)
{
- ByteIOContext *pb;
+ AVIOContext *pb;
uint8_t *buf;
int len;
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 */
+ avio_w8(pb, (RTP_VERSION << 6));
+ avio_w8(pb, 0); /* Payload type */
+ avio_wb16(pb, 0); /* Seq */
+ avio_wb32(pb, 0); /* Timestamp */
+ avio_wb32(pb, 0); /* SSRC */
- put_flush_packet(pb);
+ avio_flush(pb);
len = url_close_dyn_buf(pb, &buf);
if ((len > 0) && buf)
url_write(rtp_handle, buf, len);
if (url_open_dyn_buf(&pb) < 0)
return;
- put_byte(pb, (RTP_VERSION << 6));
- put_byte(pb, RTCP_RR); /* receiver report */
- put_be16(pb, 1); /* length in words - 1 */
- put_be32(pb, 0); /* our own SSRC */
+ avio_w8(pb, (RTP_VERSION << 6));
+ avio_w8(pb, RTCP_RR); /* receiver report */
+ avio_wb16(pb, 1); /* length in words - 1 */
+ avio_wb32(pb, 0); /* our own SSRC */
- put_flush_packet(pb);
+ avio_flush(pb);
len = url_close_dyn_buf(pb, &buf);
if ((len > 0) && buf)
url_write(rtp_handle, buf, len);
return NULL;
}
} else {
- av_set_pts_info(st, 32, 1, 90000);
switch(st->codec->codec_id) {
case CODEC_ID_MPEG1VIDEO:
case CODEC_ID_MPEG2VIDEO:
st->need_parsing = AVSTREAM_PARSE_FULL;
break;
case CODEC_ID_ADPCM_G722:
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
/* According to RFC 3551, the stream clock rate is 8000
* even if the sample rate is 16000. */
if (st->codec->sample_rate == 8000)
st->codec->sample_rate = 16000;
break;
default:
- if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- av_set_pts_info(st, 32, 1, st->codec->sample_rate);
- }
break;
}
}
*/
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
{
+ if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE)
+ return; /* Timestamp already set by depacketizer */
if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && timestamp != RTP_NOTS_VALUE) {
int64_t addend;
int delta_timestamp;
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 = s->range_start_offset + addend + delta_timestamp;
+ pkt->pts = s->range_start_offset + s->rtcp_ts_offset + addend +
+ delta_timestamp;
+ return;
}
+ if (timestamp == RTP_NOTS_VALUE)
+ return;
+ if (!s->base_timestamp)
+ s->base_timestamp = timestamp;
+ pkt->pts = s->range_start_offset + timestamp - s->base_timestamp;
}
static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt,
return -1;
}
+ if (buf[0] & 0x20) {
+ int padding = buf[len - 1];
+ if (len >= 12 + padding)
+ len -= padding;
+ }
+
s->seq = seq;
len -= 12;
buf += 12;
if (!st) {
/* specific MPEG2TS demux support */
ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
+ /* The only error that can be returned from ff_mpegts_parse_packet
+ * is "no more data to return from the provided buffer", so return
+ * AVERROR(EAGAIN) for all errors */
if (ret < 0)
- return ret;
+ return AVERROR(EAGAIN);
if (ret < len) {
s->read_buf_size = len - ret;
memcpy(s->buf, buf + ret, s->read_buf_size);
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 ret;
+ return AVERROR(EAGAIN);
s->read_buf_index += ret;
if (s->read_buf_index < s->read_buf_size)
return 1;
projects / ffmpeg / blobdiff