* 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
*/
-/* needed for gethostname() */
-#define _XOPEN_SOURCE 600
-
#include "libavcodec/get_bits.h"
#include "avformat.h"
#include "mpegts.h"
+#include "url.h"
#include <unistd.h>
#include <strings.h>
buffer to 'rtp_write_packet' contains all the packets for ONE
frame. Each packet should have a four byte header containing
the length in big endian format (same trick as
- 'url_open_dyn_packet_buf')
+ 'ffio_open_dyn_packet_buf')
*/
-RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = {
+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)
{
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;
s->last_octet_count = s->octet_count;
- if (url_open_dyn_buf(&pb) < 0)
+ if (avio_open_dyn_buf(&pb) < 0)
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);
- len = url_close_dyn_buf(pb, &buf);
+ avio_flush(pb);
+ len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf) {
- int result;
- dprintf(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);
+ int av_unused result;
+ av_dlog(s->ic, "sending %d bytes of RR\n", len);
+ result= ffurl_write(s->rtp_ctx, buf, len);
+ av_dlog(s->ic, "result from ffurl_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;
/* Send a small RTP packet */
- if (url_open_dyn_buf(&pb) < 0)
+ if (avio_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);
- len = url_close_dyn_buf(pb, &buf);
+ avio_flush(pb);
+ len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf)
- url_write(rtp_handle, buf, len);
+ ffurl_write(rtp_handle, buf, len);
av_free(buf);
/* Send a minimal RTCP RR */
- if (url_open_dyn_buf(&pb) < 0)
+ if (avio_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);
- len = url_close_dyn_buf(pb, &buf);
+ avio_flush(pb);
+ len = avio_close_dyn_buf(pb, &buf);
if ((len > 0) && buf)
- url_write(rtp_handle, buf, len);
+ ffurl_write(rtp_handle, buf, len);
av_free(buf);
}
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,
projects / ffmpeg / blobdiff