2 * Realmedia RTSP protocol (RDT) support.
3 * Copyright (c) 2007 Ronald S. Bultje
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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>
29 #include "libavutil/avstring.h"
32 #include "libavutil/base64.h"
33 #include "libavutil/md5.h"
36 #include "avio_internal.h"
37 #include "libavcodec/get_bits.h"
39 struct RDTDemuxContext {
40 AVFormatContext *ic; /**< the containing (RTSP) demux context */
41 /** Each RDT stream-set (represented by one RTSPStream) can contain
42 * multiple streams (of the same content, but with possibly different
43 * codecs/bitrates). Each such stream is represented by one AVStream
44 * in the AVFormatContext, and this variable points to the offset in
45 * that array such that the first is the first stream of this set. */
47 int n_streams; /**< streams with identifical content in this set */
48 void *dynamic_protocol_context;
49 DynamicPayloadPacketHandlerProc parse_packet;
50 uint32_t prev_timestamp;
51 int prev_set_id, prev_stream_id;
55 ff_rdt_parse_open(AVFormatContext *ic, int first_stream_of_set_idx,
56 void *priv_data, RTPDynamicProtocolHandler *handler)
58 RDTDemuxContext *s = av_mallocz(sizeof(RDTDemuxContext));
63 s->streams = &ic->streams[first_stream_of_set_idx];
66 } while (first_stream_of_set_idx + s->n_streams < ic->nb_streams &&
67 s->streams[s->n_streams]->id == s->streams[0]->id);
69 s->prev_stream_id = -1;
70 s->prev_timestamp = -1;
71 s->parse_packet = handler ? handler->parse_packet : NULL;
72 s->dynamic_protocol_context = priv_data;
78 ff_rdt_parse_close(RDTDemuxContext *s)
83 struct PayloadContext {
84 AVFormatContext *rmctx;
88 unsigned int mlti_data_size;
89 char buffer[RTP_MAX_PACKET_LENGTH + FF_INPUT_BUFFER_PADDING_SIZE];
90 int audio_pkt_cnt; /**< remaining audio packets in rmdec */
94 ff_rdt_calc_response_and_checksum(char response[41], char chksum[9],
95 const char *challenge)
97 int ch_len = strlen (challenge), i;
98 unsigned char zres[16],
99 buf[64] = { 0xa1, 0xe9, 0x14, 0x9d, 0x0e, 0x6b, 0x3b, 0x59 };
100 #define XOR_TABLE_SIZE 37
101 static const unsigned char xor_table[XOR_TABLE_SIZE] = {
102 0x05, 0x18, 0x74, 0xd0, 0x0d, 0x09, 0x02, 0x53,
103 0xc0, 0x01, 0x05, 0x05, 0x67, 0x03, 0x19, 0x70,
104 0x08, 0x27, 0x66, 0x10, 0x10, 0x72, 0x08, 0x09,
105 0x63, 0x11, 0x03, 0x71, 0x08, 0x08, 0x70, 0x02,
106 0x10, 0x57, 0x05, 0x18, 0x54 };
108 /* some (length) checks */
109 if (ch_len == 40) /* what a hack... */
111 else if (ch_len > 56)
113 memcpy(buf + 8, challenge, ch_len);
115 /* xor challenge bytewise with xor_table */
116 for (i = 0; i < XOR_TABLE_SIZE; i++)
117 buf[8 + i] ^= xor_table[i];
119 av_md5_sum(zres, buf, 64);
120 ff_data_to_hex(response, zres, 16, 1);
123 strcpy (response + 32, "01d0a8e3");
125 /* calculate checksum */
126 for (i = 0; i < 8; i++)
127 chksum[i] = response[i * 4];
132 rdt_load_mdpr (PayloadContext *rdt, AVStream *st, int rule_nr)
139 * Layout of the MLTI chunk:
141 * 2: number of streams
142 * Then for each stream ([number_of_streams] times):
144 * 2: number of mdpr chunks
145 * Then for each mdpr chunk ([number_of_mdpr_chunks] times):
148 * we skip MDPR chunks until we reach the one of the stream
149 * we're interested in, and forward that ([size]+[data]) to
150 * the RM demuxer to parse the stream-specific header data.
154 ffio_init_context(&pb, rdt->mlti_data, rdt->mlti_data_size, 0,
155 NULL, NULL, NULL, NULL);
156 tag = avio_rl32(&pb);
157 if (tag == MKTAG('M', 'L', 'T', 'I')) {
160 /* read index of MDPR chunk numbers */
161 num = avio_rb16(&pb);
162 if (rule_nr < 0 || rule_nr >= num)
164 avio_skip(&pb, rule_nr * 2);
165 chunk_nr = avio_rb16(&pb);
166 avio_skip(&pb, (num - 1 - rule_nr) * 2);
168 /* read MDPR chunks */
169 num = avio_rb16(&pb);
173 avio_skip(&pb, avio_rb32(&pb));
174 size = avio_rb32(&pb);
176 size = rdt->mlti_data_size;
177 avio_seek(&pb, 0, SEEK_SET);
179 if (ff_rm_read_mdpr_codecdata(rdt->rmctx, &pb, st, rdt->rmst[st->index], size, NULL) < 0)
186 * Actual data handling.
190 ff_rdt_parse_header(const uint8_t *buf, int len,
191 int *pset_id, int *pseq_no, int *pstream_id,
192 int *pis_keyframe, uint32_t *ptimestamp)
195 int consumed = 0, set_id, seq_no, stream_id, is_keyframe,
196 len_included, need_reliable;
199 /* skip status packets */
200 while (len >= 5 && buf[1] == 0xFF /* status packet */) {
203 if (!(buf[0] & 0x80))
204 return -1; /* not followed by a data packet */
206 pkt_len = AV_RB16(buf+3);
214 * Layout of the header (in bits):
216 * Flag indicating whether this header includes a length field;
217 * this can be used to concatenate multiple RDT packets in a
218 * single UDP/TCP data frame and is used to precede RDT data
219 * by stream status packets
221 * Flag indicating whether this header includes a "reliable
222 * sequence number"; these are apparently sequence numbers of
223 * data packets alone. For data packets, this flag is always
224 * set, according to the Real documentation [1]
226 * ID of a set of streams of identical content, possibly with
227 * different codecs or bitrates
229 * Flag set for certain streams deemed less tolerable for packet
232 * Packet sequence number; if >=0xFF00, this is a non-data packet
233 * containing stream status info, the second byte indicates the
234 * type of status packet (see wireshark docs / source code [2])
235 * if (len_included) {
238 * packet_len = remainder of UDP/TCP frame
241 * Back-to-Back flag; used for timing, set for one in every 10
242 * packets, according to the Real documentation [1]
244 * Slow-data flag; currently unused, according to Real docs [1]
246 * ID of the stream within this particular set of streams
248 * Non-keyframe flag (unset if packet belongs to a keyframe)
249 * 32: timestamp (PTS)
250 * if (set_id == 0x1F) {
251 * 16: set_id (extended set-of-streams ID; see set_id)
253 * if (need_reliable) {
254 * 16: reliable_seq_no
255 * Reliable sequence number (see need_reliable)
257 * if (stream_id == 0x3F) {
258 * 16: stream_id (extended stream ID; see stream_id)
260 * [1] https://protocol.helixcommunity.org/files/2005/devdocs/RDT_Feature_Level_20.txt
261 * [2] http://www.wireshark.org/docs/dfref/r/rdt.html and
262 * http://anonsvn.wireshark.org/viewvc/trunk/epan/dissectors/packet-rdt.c
264 init_get_bits(&gb, buf, len << 3);
265 len_included = get_bits1(&gb);
266 need_reliable = get_bits1(&gb);
267 set_id = get_bits(&gb, 5);
269 seq_no = get_bits(&gb, 16);
273 stream_id = get_bits(&gb, 5);
274 is_keyframe = !get_bits1(&gb);
275 timestamp = get_bits_long(&gb, 32);
277 set_id = get_bits(&gb, 16);
280 if (stream_id == 0x1f)
281 stream_id = get_bits(&gb, 16);
283 if (pset_id) *pset_id = set_id;
284 if (pseq_no) *pseq_no = seq_no;
285 if (pstream_id) *pstream_id = stream_id;
286 if (pis_keyframe) *pis_keyframe = is_keyframe;
287 if (ptimestamp) *ptimestamp = timestamp;
289 return consumed + (get_bits_count(&gb) >> 3);
292 /**< return 0 on packet, no more left, 1 on packet, 1 on partial packet... */
294 rdt_parse_packet (AVFormatContext *ctx, PayloadContext *rdt, AVStream *st,
295 AVPacket *pkt, uint32_t *timestamp,
296 const uint8_t *buf, int len, uint16_t rtp_seq, int flags)
301 if (rdt->audio_pkt_cnt == 0) {
304 ffio_init_context(&pb, buf, len, 0, NULL, NULL, NULL, NULL);
305 flags = (flags & RTP_FLAG_KEY) ? 2 : 0;
306 res = ff_rm_parse_packet (rdt->rmctx, &pb, st, rdt->rmst[st->index], len, pkt,
307 &seq, flags, *timestamp);
308 pos = avio_tell(&pb);
312 if (st->codec->codec_id == AV_CODEC_ID_AAC) {
313 memcpy (rdt->buffer, buf + pos, len - pos);
314 rdt->rmctx->pb = avio_alloc_context (rdt->buffer, len - pos, 0,
315 NULL, NULL, NULL, NULL);
322 ff_rm_retrieve_cache (rdt->rmctx, rdt->rmctx->pb,
323 st, rdt->rmst[st->index], pkt);
324 if (rdt->audio_pkt_cnt == 0 &&
325 st->codec->codec_id == AV_CODEC_ID_AAC)
326 av_freep(&rdt->rmctx->pb);
328 pkt->stream_index = st->index;
329 pkt->pts = *timestamp;
331 return rdt->audio_pkt_cnt > 0;
335 ff_rdt_parse_packet(RDTDemuxContext *s, AVPacket *pkt,
336 uint8_t **bufptr, int len)
338 uint8_t *buf = bufptr ? *bufptr : NULL;
339 int seq_no, flags = 0, stream_id, set_id, is_keyframe;
343 if (!s->parse_packet)
346 if (!buf && s->prev_stream_id != -1) {
347 /* return the next packets, if any */
348 timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
349 rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
350 s->streams[s->prev_stream_id],
351 pkt, ×tamp, NULL, 0, 0, flags);
357 rv = ff_rdt_parse_header(buf, len, &set_id, &seq_no, &stream_id, &is_keyframe, ×tamp);
361 (set_id != s->prev_set_id || timestamp != s->prev_timestamp ||
362 stream_id != s->prev_stream_id)) {
363 flags |= RTP_FLAG_KEY;
364 s->prev_set_id = set_id;
365 s->prev_timestamp = timestamp;
367 s->prev_stream_id = stream_id;
371 if (s->prev_stream_id >= s->n_streams) {
372 s->prev_stream_id = -1;
376 rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
377 s->streams[s->prev_stream_id],
378 pkt, ×tamp, buf, len, 0, flags);
384 ff_rdt_subscribe_rule (char *cmd, int size,
385 int stream_nr, int rule_nr)
387 av_strlcatf(cmd, size, "stream=%d;rule=%d,stream=%d;rule=%d",
388 stream_nr, rule_nr * 2, stream_nr, rule_nr * 2 + 1);
391 static unsigned char *
392 rdt_parse_b64buf (unsigned int *target_len, const char *p)
394 unsigned char *target;
398 len -= 2; /* skip embracing " at start/end */
400 *target_len = len * 3 / 4;
401 target = av_mallocz(*target_len + FF_INPUT_BUFFER_PADDING_SIZE);
402 av_base64_decode(target, p, *target_len);
407 rdt_parse_sdp_line (AVFormatContext *s, int st_index,
408 PayloadContext *rdt, const char *line)
410 AVStream *stream = s->streams[st_index];
411 const char *p = line;
413 if (av_strstart(p, "OpaqueData:buffer;", &p)) {
414 rdt->mlti_data = rdt_parse_b64buf(&rdt->mlti_data_size, p);
415 } else if (av_strstart(p, "StartTime:integer;", &p))
416 stream->first_dts = atoi(p);
417 else if (av_strstart(p, "ASMRuleBook:string;", &p)) {
420 for (n = 0; n < s->nb_streams; n++)
421 if (s->streams[n]->id == stream->id) {
422 int count = s->streams[n]->index + 1;
423 if (first == -1) first = n;
424 if (rdt->nb_rmst < count) {
425 RMStream **rmst= av_realloc(rdt->rmst, count*sizeof(*rmst));
427 return AVERROR(ENOMEM);
428 memset(rmst + rdt->nb_rmst, 0,
429 (count - rdt->nb_rmst) * sizeof(*rmst));
431 rdt->nb_rmst = count;
433 rdt->rmst[s->streams[n]->index] = ff_rm_alloc_rmstream();
434 rdt_load_mdpr(rdt, s->streams[n], (n - first) * 2);
442 real_parse_asm_rule(AVStream *st, const char *p, const char *end)
445 /* can be either averagebandwidth= or AverageBandwidth= */
446 if (sscanf(p, " %*1[Aa]verage%*1[Bb]andwidth=%d", &st->codec->bit_rate) == 1)
448 if (!(p = strchr(p, ',')) || p > end)
455 add_dstream(AVFormatContext *s, AVStream *orig_st)
459 if (!(st = avformat_new_stream(s, NULL)))
461 st->id = orig_st->id;
462 st->codec->codec_type = orig_st->codec->codec_type;
463 st->first_dts = orig_st->first_dts;
469 real_parse_asm_rulebook(AVFormatContext *s, AVStream *orig_st,
473 int n_rules = 0, odd = 0;
477 * The ASMRuleBook contains a list of comma-separated strings per rule,
478 * and each rule is separated by a ;. The last one also has a ; at the
479 * end so we can use it as delimiter.
480 * Every rule occurs twice, once for when the RTSP packet header marker
481 * is set and once for if it isn't. We only read the first because we
482 * don't care much (that's what the "odd" variable is for).
483 * Each rule contains a set of one or more statements, optionally
484 * preceded by a single condition. If there's a condition, the rule
485 * starts with a '#'. Multiple conditions are merged between brackets,
486 * so there are never multiple conditions spread out over separate
487 * statements. Generally, these conditions are bitrate limits (min/max)
488 * for multi-bitrate streams.
492 if (!(end = strchr(p, ';')))
494 if (!odd && end != p) {
496 st = add_dstream(s, orig_st);
501 real_parse_asm_rule(st, p, end);
510 ff_real_parse_sdp_a_line (AVFormatContext *s, int stream_index,
513 const char *p = line;
515 if (av_strstart(p, "ASMRuleBook:string;", &p))
516 real_parse_asm_rulebook(s, s->streams[stream_index], p);
519 static PayloadContext *
520 rdt_new_context (void)
522 PayloadContext *rdt = av_mallocz(sizeof(PayloadContext));
524 int ret = avformat_open_input(&rdt->rmctx, "", &ff_rdt_demuxer, NULL);
534 rdt_free_context (PayloadContext *rdt)
538 for (i = 0; i < rdt->nb_rmst; i++)
540 ff_rm_free_rmstream(rdt->rmst[i]);
541 av_freep(&rdt->rmst[i]);
544 avformat_close_input(&rdt->rmctx);
545 av_freep(&rdt->mlti_data);
546 av_freep(&rdt->rmst);
550 #define RDT_HANDLER(n, s, t) \
551 static RTPDynamicProtocolHandler rdt_ ## n ## _handler = { \
554 .codec_id = AV_CODEC_ID_NONE, \
555 .parse_sdp_a_line = rdt_parse_sdp_line, \
556 .alloc = rdt_new_context, \
557 .free = rdt_free_context, \
558 .parse_packet = rdt_parse_packet \
561 RDT_HANDLER(live_video, "x-pn-multirate-realvideo-live", AVMEDIA_TYPE_VIDEO);
562 RDT_HANDLER(live_audio, "x-pn-multirate-realaudio-live", AVMEDIA_TYPE_AUDIO);
563 RDT_HANDLER(video, "x-pn-realvideo", AVMEDIA_TYPE_VIDEO);
564 RDT_HANDLER(audio, "x-pn-realaudio", AVMEDIA_TYPE_AUDIO);
566 void av_register_rdt_dynamic_payload_handlers(void)
568 ff_register_dynamic_payload_handler(&rdt_video_handler);
569 ff_register_dynamic_payload_handler(&rdt_audio_handler);
570 ff_register_dynamic_payload_handler(&rdt_live_video_handler);
571 ff_register_dynamic_payload_handler(&rdt_live_audio_handler);