2 * Realmedia RTSP protocol (RDT) support.
3 * Copyright (c) 2007 Ronald S. Bultje
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * @brief Realmedia RTSP protocol (RDT) support
25 * @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
28 #include "libavcodec/bitstream.h"
31 #include "libavutil/avstring.h"
34 #include "libavutil/base64.h"
35 #include "libavutil/md5.h"
38 #include "avio_internal.h"
40 struct RDTDemuxContext {
41 AVFormatContext *ic; /**< the containing (RTSP) demux context */
42 /** Each RDT stream-set (represented by one RTSPStream) can contain
43 * multiple streams (of the same content, but with possibly different
44 * codecs/bitrates). Each such stream is represented by one AVStream
45 * in the AVFormatContext, and this variable points to the offset in
46 * that array such that the first is the first stream of this set. */
48 int n_streams; /**< streams with identical content in this set */
49 void *dynamic_protocol_context;
50 DynamicPayloadPacketHandlerProc parse_packet;
51 uint32_t prev_timestamp;
52 int prev_set_id, prev_stream_id;
56 ff_rdt_parse_open(AVFormatContext *ic, int first_stream_of_set_idx,
57 void *priv_data, RTPDynamicProtocolHandler *handler)
59 RDTDemuxContext *s = av_mallocz(sizeof(RDTDemuxContext));
64 s->streams = &ic->streams[first_stream_of_set_idx];
67 } while (first_stream_of_set_idx + s->n_streams < ic->nb_streams &&
68 s->streams[s->n_streams]->id == s->streams[0]->id);
70 s->prev_stream_id = -1;
71 s->prev_timestamp = -1;
72 s->parse_packet = handler ? handler->parse_packet : NULL;
73 s->dynamic_protocol_context = priv_data;
79 ff_rdt_parse_close(RDTDemuxContext *s)
84 struct PayloadContext {
85 AVFormatContext *rmctx;
89 unsigned int mlti_data_size;
90 char buffer[RTP_MAX_PACKET_LENGTH + AV_INPUT_BUFFER_PADDING_SIZE];
91 int audio_pkt_cnt; /**< remaining audio packets in rmdec */
95 ff_rdt_calc_response_and_checksum(char response[41], char chksum[9],
96 const char *challenge)
98 int ch_len = strlen (challenge), i;
99 unsigned char zres[16],
100 buf[64] = { 0xa1, 0xe9, 0x14, 0x9d, 0x0e, 0x6b, 0x3b, 0x59 };
101 #define XOR_TABLE_SIZE 37
102 static const unsigned char xor_table[XOR_TABLE_SIZE] = {
103 0x05, 0x18, 0x74, 0xd0, 0x0d, 0x09, 0x02, 0x53,
104 0xc0, 0x01, 0x05, 0x05, 0x67, 0x03, 0x19, 0x70,
105 0x08, 0x27, 0x66, 0x10, 0x10, 0x72, 0x08, 0x09,
106 0x63, 0x11, 0x03, 0x71, 0x08, 0x08, 0x70, 0x02,
107 0x10, 0x57, 0x05, 0x18, 0x54 };
109 /* some (length) checks */
110 if (ch_len == 40) /* what a hack... */
112 else if (ch_len > 56)
114 memcpy(buf + 8, challenge, ch_len);
116 /* xor challenge bytewise with xor_table */
117 for (i = 0; i < XOR_TABLE_SIZE; i++)
118 buf[8 + i] ^= xor_table[i];
120 av_md5_sum(zres, buf, 64);
121 ff_data_to_hex(response, zres, 16, 1);
124 strcpy (response + 32, "01d0a8e3");
126 /* calculate checksum */
127 for (i = 0; i < 8; i++)
128 chksum[i] = response[i * 4];
133 rdt_load_mdpr (PayloadContext *rdt, AVStream *st, int rule_nr)
140 * Layout of the MLTI chunk:
142 * 2: number of streams
143 * Then for each stream ([number_of_streams] times):
145 * 2: number of mdpr chunks
146 * Then for each mdpr chunk ([number_of_mdpr_chunks] times):
149 * we skip MDPR chunks until we reach the one of the stream
150 * we're interested in, and forward that ([size]+[data]) to
151 * the RM demuxer to parse the stream-specific header data.
155 ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0,
156 NULL, NULL, NULL, NULL);
157 tag = avio_rl32(&pb);
158 if (tag == MKTAG('M', 'L', 'T', 'I')) {
161 /* read index of MDPR chunk numbers */
162 num = avio_rb16(&pb);
163 if (rule_nr < 0 || rule_nr >= num)
165 avio_skip(&pb, rule_nr * 2);
166 chunk_nr = avio_rb16(&pb);
167 avio_skip(&pb, (num - 1 - rule_nr) * 2);
169 /* read MDPR chunks */
170 num = avio_rb16(&pb);
174 avio_skip(&pb, avio_rb32(&pb));
175 size = avio_rb32(&pb);
177 size = rdt->mlti_data_size;
178 avio_seek(&pb, 0, SEEK_SET);
180 if (ff_rm_read_mdpr_codecdata(rdt->rmctx, &pb, st, rdt->rmst[st->index], size) < 0)
187 * Actual data handling.
191 ff_rdt_parse_header(const uint8_t *buf, int len,
192 int *pset_id, int *pseq_no, int *pstream_id,
193 int *pis_keyframe, uint32_t *ptimestamp)
196 int consumed = 0, set_id, seq_no, stream_id, is_keyframe,
197 len_included, need_reliable;
200 /* skip status packets */
201 while (len >= 5 && buf[1] == 0xFF /* status packet */) {
204 if (!(buf[0] & 0x80))
205 return -1; /* not followed by a data packet */
207 pkt_len = AV_RB16(buf+3);
215 * Layout of the header (in bits):
217 * Flag indicating whether this header includes a length field;
218 * this can be used to concatenate multiple RDT packets in a
219 * single UDP/TCP data frame and is used to precede RDT data
220 * by stream status packets
222 * Flag indicating whether this header includes a "reliable
223 * sequence number"; these are apparently sequence numbers of
224 * data packets alone. For data packets, this flag is always
225 * set, according to the Real documentation [1]
227 * ID of a set of streams of identical content, possibly with
228 * different codecs or bitrates
230 * Flag set for certain streams deemed less tolerable for packet
233 * Packet sequence number; if >=0xFF00, this is a non-data packet
234 * containing stream status info, the second byte indicates the
235 * type of status packet (see wireshark docs / source code [2])
236 * if (len_included) {
239 * packet_len = remainder of UDP/TCP frame
242 * Back-to-Back flag; used for timing, set for one in every 10
243 * packets, according to the Real documentation [1]
245 * Slow-data flag; currently unused, according to Real docs [1]
247 * ID of the stream within this particular set of streams
249 * Non-keyframe flag (unset if packet belongs to a keyframe)
250 * 32: timestamp (PTS)
251 * if (set_id == 0x1F) {
252 * 16: set_id (extended set-of-streams ID; see set_id)
254 * if (need_reliable) {
255 * 16: reliable_seq_no
256 * Reliable sequence number (see need_reliable)
258 * if (stream_id == 0x3F) {
259 * 16: stream_id (extended stream ID; see stream_id)
261 * [1] https://protocol.helixcommunity.org/files/2005/devdocs/RDT_Feature_Level_20.txt
262 * [2] http://www.wireshark.org/docs/dfref/r/rdt.html and
263 * http://anonsvn.wireshark.org/viewvc/trunk/epan/dissectors/packet-rdt.c
265 bitstream_init(&bc, buf, len << 3);
266 len_included = bitstream_read_bit(&bc);
267 need_reliable = bitstream_read_bit(&bc);
268 set_id = bitstream_read(&bc, 5);
269 bitstream_skip(&bc, 1);
270 seq_no = bitstream_read(&bc, 16);
272 bitstream_skip(&bc, 16);
273 bitstream_skip(&bc, 2);
274 stream_id = bitstream_read(&bc, 5);
275 is_keyframe = !bitstream_read_bit(&bc);
276 timestamp = bitstream_read(&bc, 32);
278 set_id = bitstream_read(&bc, 16);
280 bitstream_skip(&bc, 16);
281 if (stream_id == 0x1f)
282 stream_id = bitstream_read(&bc, 16);
284 if (pset_id) *pset_id = set_id;
285 if (pseq_no) *pseq_no = seq_no;
286 if (pstream_id) *pstream_id = stream_id;
287 if (pis_keyframe) *pis_keyframe = is_keyframe;
288 if (ptimestamp) *ptimestamp = timestamp;
290 return consumed + (bitstream_tell(&bc) >> 3);
293 /**< return 0 on packet, no more left, 1 on packet, 1 on partial packet... */
295 rdt_parse_packet (AVFormatContext *ctx, PayloadContext *rdt, AVStream *st,
296 AVPacket *pkt, uint32_t *timestamp,
297 const uint8_t *buf, int len, uint16_t rtp_seq, int flags)
302 if (rdt->audio_pkt_cnt == 0) {
305 ffio_init_context(&pb, buf, len, 0, NULL, NULL, NULL, NULL);
306 rmflags = (flags & RTP_FLAG_KEY) ? 2 : 0;
307 res = ff_rm_parse_packet (rdt->rmctx, &pb, st, rdt->rmst[st->index], len, pkt,
308 &seq, rmflags, *timestamp);
309 pos = avio_tell(&pb);
313 if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
314 memcpy (rdt->buffer, buf + pos, len - pos);
315 rdt->rmctx->pb = avio_alloc_context (rdt->buffer, len - pos, 0,
316 NULL, NULL, NULL, NULL);
323 ff_rm_retrieve_cache (rdt->rmctx, rdt->rmctx->pb,
324 st, rdt->rmst[st->index], pkt);
325 if (rdt->audio_pkt_cnt == 0 &&
326 st->codecpar->codec_id == AV_CODEC_ID_AAC)
327 av_freep(&rdt->rmctx->pb);
329 pkt->stream_index = st->index;
330 pkt->pts = *timestamp;
332 return rdt->audio_pkt_cnt > 0;
336 ff_rdt_parse_packet(RDTDemuxContext *s, AVPacket *pkt,
337 uint8_t **bufptr, int len)
339 uint8_t *buf = bufptr ? *bufptr : NULL;
340 int seq_no, flags = 0, stream_id, set_id, is_keyframe;
344 if (!s->parse_packet)
347 if (!buf && s->prev_stream_id != -1) {
348 /* return the next packets, if any */
349 timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
350 rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
351 s->streams[s->prev_stream_id],
352 pkt, ×tamp, NULL, 0, 0, flags);
358 rv = ff_rdt_parse_header(buf, len, &set_id, &seq_no, &stream_id, &is_keyframe, ×tamp);
362 (set_id != s->prev_set_id || timestamp != s->prev_timestamp ||
363 stream_id != s->prev_stream_id)) {
364 flags |= RTP_FLAG_KEY;
365 s->prev_set_id = set_id;
366 s->prev_timestamp = timestamp;
368 s->prev_stream_id = stream_id;
372 if (s->prev_stream_id >= s->n_streams) {
373 s->prev_stream_id = -1;
377 rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
378 s->streams[s->prev_stream_id],
379 pkt, ×tamp, buf, len, 0, flags);
385 ff_rdt_subscribe_rule (char *cmd, int size,
386 int stream_nr, int rule_nr)
388 av_strlcatf(cmd, size, "stream=%d;rule=%d,stream=%d;rule=%d",
389 stream_nr, rule_nr * 2, stream_nr, rule_nr * 2 + 1);
392 static unsigned char *
393 rdt_parse_b64buf (unsigned int *target_len, const char *p)
395 unsigned char *target;
399 len -= 2; /* skip embracing " at start/end */
401 *target_len = len * 3 / 4;
402 target = av_mallocz(*target_len + AV_INPUT_BUFFER_PADDING_SIZE);
405 av_base64_decode(target, p, *target_len);
410 rdt_parse_sdp_line (AVFormatContext *s, int st_index,
411 PayloadContext *rdt, const char *line)
413 AVStream *stream = s->streams[st_index];
414 const char *p = line;
416 if (av_strstart(p, "OpaqueData:buffer;", &p)) {
417 rdt->mlti_data = rdt_parse_b64buf(&rdt->mlti_data_size, p);
418 } else if (av_strstart(p, "StartTime:integer;", &p))
419 stream->first_dts = atoi(p);
420 else if (av_strstart(p, "ASMRuleBook:string;", &p)) {
423 for (n = 0; n < s->nb_streams; n++)
424 if (s->streams[n]->id == stream->id) {
425 int count = s->streams[n]->index + 1, err;
426 if (first == -1) first = n;
427 if (rdt->nb_rmst < count) {
428 if ((err = av_reallocp(&rdt->rmst,
429 count * sizeof(*rdt->rmst))) < 0) {
433 memset(rdt->rmst + rdt->nb_rmst, 0,
434 (count - rdt->nb_rmst) * sizeof(*rdt->rmst));
435 rdt->nb_rmst = count;
437 rdt->rmst[s->streams[n]->index] = ff_rm_alloc_rmstream();
438 if (!rdt->rmst[s->streams[n]->index])
439 return AVERROR(ENOMEM);
440 rdt_load_mdpr(rdt, s->streams[n], (n - first) * 2);
448 real_parse_asm_rule(AVStream *st, const char *p, const char *end)
451 /* can be either averagebandwidth= or AverageBandwidth= */
452 if (sscanf(p, " %*1[Aa]verage%*1[Bb]andwidth=%d", &st->codecpar->bit_rate) == 1)
454 if (!(p = strchr(p, ',')) || p > end)
461 add_dstream(AVFormatContext *s, AVStream *orig_st)
465 if (!(st = avformat_new_stream(s, NULL)))
467 st->id = orig_st->id;
468 st->codecpar->codec_type = orig_st->codecpar->codec_type;
469 st->first_dts = orig_st->first_dts;
475 real_parse_asm_rulebook(AVFormatContext *s, AVStream *orig_st,
479 int n_rules = 0, odd = 0;
483 * The ASMRuleBook contains a list of comma-separated strings per rule,
484 * and each rule is separated by a ;. The last one also has a ; at the
485 * end so we can use it as delimiter.
486 * Every rule occurs twice, once for when the RTSP packet header marker
487 * is set and once for if it isn't. We only read the first because we
488 * don't care much (that's what the "odd" variable is for).
489 * Each rule contains a set of one or more statements, optionally
490 * preceded by a single condition. If there's a condition, the rule
491 * starts with a '#'. Multiple conditions are merged between brackets,
492 * so there are never multiple conditions spread out over separate
493 * statements. Generally, these conditions are bitrate limits (min/max)
494 * for multi-bitrate streams.
498 if (!(end = strchr(p, ';')))
500 if (!odd && end != p) {
502 st = add_dstream(s, orig_st);
507 real_parse_asm_rule(st, p, end);
516 ff_real_parse_sdp_a_line (AVFormatContext *s, int stream_index,
519 const char *p = line;
521 if (av_strstart(p, "ASMRuleBook:string;", &p))
522 real_parse_asm_rulebook(s, s->streams[stream_index], p);
525 static av_cold int rdt_init(AVFormatContext *s, int st_index, PayloadContext *rdt)
527 return avformat_open_input(&rdt->rmctx, "", &ff_rdt_demuxer, NULL);
531 rdt_close_context (PayloadContext *rdt)
535 for (i = 0; i < rdt->nb_rmst; i++)
537 ff_rm_free_rmstream(rdt->rmst[i]);
538 av_freep(&rdt->rmst[i]);
541 avformat_close_input(&rdt->rmctx);
542 av_freep(&rdt->mlti_data);
543 av_freep(&rdt->rmst);
546 #define RDT_HANDLER(n, s, t) \
547 static RTPDynamicProtocolHandler rdt_ ## n ## _handler = { \
550 .codec_id = AV_CODEC_ID_NONE, \
551 .priv_data_size = sizeof(PayloadContext), \
553 .parse_sdp_a_line = rdt_parse_sdp_line, \
554 .close = rdt_close_context, \
555 .parse_packet = rdt_parse_packet \
558 RDT_HANDLER(live_video, "x-pn-multirate-realvideo-live", AVMEDIA_TYPE_VIDEO);
559 RDT_HANDLER(live_audio, "x-pn-multirate-realaudio-live", AVMEDIA_TYPE_AUDIO);
560 RDT_HANDLER(video, "x-pn-realvideo", AVMEDIA_TYPE_VIDEO);
561 RDT_HANDLER(audio, "x-pn-realaudio", AVMEDIA_TYPE_AUDIO);
563 void ff_register_rdt_dynamic_payload_handlers(void)
565 ff_register_dynamic_payload_handler(&rdt_video_handler);
566 ff_register_dynamic_payload_handler(&rdt_audio_handler);
567 ff_register_dynamic_payload_handler(&rdt_live_video_handler);
568 ff_register_dynamic_payload_handler(&rdt_live_audio_handler);