1/* 2 * RTP input format 3 * Copyright (c) 2002 Fabrice Bellard 4 * 5 * This file is part of FFmpeg. 6 * 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. 11 * 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. 16 * 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 20 */ 21 22/* needed for gethostname() */ 23#define _XOPEN_SOURCE 600 24 25#include "libavcodec/get_bits.h" 26#include "avformat.h" 27#include "mpegts.h" 28 29#include <unistd.h> 30#include "network.h" 31 32#include "rtpdec.h" 33#include "rtpdec_amr.h" 34#include "rtpdec_asf.h" 35#include "rtpdec_h263.h" 36#include "rtpdec_h264.h" 37#include "rtpdec_xiph.h" 38 39//#define DEBUG 40 41/* TODO: - add RTCP statistics reporting (should be optional). 42 43 - add support for h263/mpeg4 packetized output : IDEA: send a 44 buffer to 'rtp_write_packet' contains all the packets for ONE 45 frame. Each packet should have a four byte header containing 46 the length in big endian format (same trick as 47 'url_open_dyn_packet_buf') 48*/ 49 50/* statistics functions */ 51RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL; 52 53static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4}; 54static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC}; 55 56void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler) 57{ 58 handler->next= RTPFirstDynamicPayloadHandler; 59 RTPFirstDynamicPayloadHandler= handler; 60} 61 62void av_register_rtp_dynamic_payload_handlers(void) 63{ 64 ff_register_dynamic_payload_handler(&mp4v_es_handler); 65 ff_register_dynamic_payload_handler(&mpeg4_generic_handler); 66 ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler); 67 ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler); 68 ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler); 69 ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler); 70 ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler); 71 ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler); 72 ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler); 73 74 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler); 75 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler); 76} 77 78static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len) 79{ 80 if (buf[1] != 200) 81 return -1; 82 s->last_rtcp_ntp_time = AV_RB64(buf + 8); 83 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) 84 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time; 85 s->last_rtcp_timestamp = AV_RB32(buf + 16); 86 return 0; 87} 88 89#define RTP_SEQ_MOD (1<<16) 90 91/** 92* called on parse open packet 93*/ 94static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet. 95{ 96 memset(s, 0, sizeof(RTPStatistics)); 97 s->max_seq= base_sequence; 98 s->probation= 1; 99} 100 101/** 102* called whenever there is a large jump in sequence numbers, or when they get out of probation... 103*/ 104static void rtp_init_sequence(RTPStatistics *s, uint16_t seq) 105{ 106 s->max_seq= seq; 107 s->cycles= 0; 108 s->base_seq= seq -1; 109 s->bad_seq= RTP_SEQ_MOD + 1; 110 s->received= 0; 111 s->expected_prior= 0; 112 s->received_prior= 0; 113 s->jitter= 0; 114 s->transit= 0; 115} 116 117/** 118* returns 1 if we should handle this packet. 119*/ 120static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq) 121{ 122 uint16_t udelta= seq - s->max_seq; 123 const int MAX_DROPOUT= 3000; 124 const int MAX_MISORDER = 100; 125 const int MIN_SEQUENTIAL = 2; 126 127 /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */ 128 if(s->probation) 129 { 130 if(seq==s->max_seq + 1) { 131 s->probation--; 132 s->max_seq= seq; 133 if(s->probation==0) { 134 rtp_init_sequence(s, seq); 135 s->received++; 136 return 1; 137 } 138 } else { 139 s->probation= MIN_SEQUENTIAL - 1; 140 s->max_seq = seq; 141 } 142 } else if (udelta < MAX_DROPOUT) { 143 // in order, with permissible gap 144 if(seq < s->max_seq) { 145 //sequence number wrapped; count antother 64k cycles 146 s->cycles += RTP_SEQ_MOD; 147 } 148 s->max_seq= seq; 149 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) { 150 // sequence made a large jump... 151 if(seq==s->bad_seq) { 152 // two sequential packets-- assume that the other side restarted without telling us; just resync. 153 rtp_init_sequence(s, seq); 154 } else { 155 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1); 156 return 0; 157 } 158 } else { 159 // duplicate or reordered packet... 160 } 161 s->received++; 162 return 1; 163} 164 165#if 0 166/** 167* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the 168* difference between the arrival and sent timestamp. As a result, the jitter and transit statistics values 169* never change. I left this in in case someone else can see a way. (rdm) 170*/ 171static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp) 172{ 173 uint32_t transit= arrival_timestamp - sent_timestamp; 174 int d; 175 s->transit= transit; 176 d= FFABS(transit - s->transit); 177 s->jitter += d - ((s->jitter + 8)>>4); 178} 179#endif 180 181int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count) 182{ 183 ByteIOContext *pb; 184 uint8_t *buf; 185 int len; 186 int rtcp_bytes; 187 RTPStatistics *stats= &s->statistics; 188 uint32_t lost; 189 uint32_t extended_max; 190 uint32_t expected_interval; 191 uint32_t received_interval; 192 uint32_t lost_interval; 193 uint32_t expected; 194 uint32_t fraction; 195 uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time? 196 197 if (!s->rtp_ctx || (count < 1)) 198 return -1; 199 200 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */ 201 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */ 202 s->octet_count += count; 203 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / 204 RTCP_TX_RATIO_DEN; 205 rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !? 206 if (rtcp_bytes < 28) 207 return -1; 208 s->last_octet_count = s->octet_count; 209 210 if (url_open_dyn_buf(&pb) < 0) 211 return -1; 212 213 // Receiver Report 214 put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ 215 put_byte(pb, 201); 216 put_be16(pb, 7); /* length in words - 1 */ 217 put_be32(pb, s->ssrc); // our own SSRC 218 put_be32(pb, s->ssrc); // XXX: should be the server's here! 219 // some placeholders we should really fill... 220 // RFC 1889/p64 221 extended_max= stats->cycles + stats->max_seq; 222 expected= extended_max - stats->base_seq + 1; 223 lost= expected - stats->received; 224 lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits... 225 expected_interval= expected - stats->expected_prior; 226 stats->expected_prior= expected; 227 received_interval= stats->received - stats->received_prior; 228 stats->received_prior= stats->received; 229 lost_interval= expected_interval - received_interval; 230 if (expected_interval==0 || lost_interval<=0) fraction= 0; 231 else fraction = (lost_interval<<8)/expected_interval; 232 233 fraction= (fraction<<24) | lost; 234 235 put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */ 236 put_be32(pb, extended_max); /* max sequence received */ 237 put_be32(pb, stats->jitter>>4); /* jitter */ 238 239 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE) 240 { 241 put_be32(pb, 0); /* last SR timestamp */ 242 put_be32(pb, 0); /* delay since last SR */ 243 } else { 244 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special? 245 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time; 246 247 put_be32(pb, middle_32_bits); /* last SR timestamp */ 248 put_be32(pb, delay_since_last); /* delay since last SR */ 249 } 250 251 // CNAME 252 put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ 253 put_byte(pb, 202); 254 len = strlen(s->hostname); 255 put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */ 256 put_be32(pb, s->ssrc); 257 put_byte(pb, 0x01); 258 put_byte(pb, len); 259 put_buffer(pb, s->hostname, len); 260 // padding 261 for (len = (6 + len) % 4; len % 4; len++) { 262 put_byte(pb, 0); 263 } 264 265 put_flush_packet(pb); 266 len = url_close_dyn_buf(pb, &buf); 267 if ((len > 0) && buf) { 268 int result; 269 dprintf(s->ic, "sending %d bytes of RR\n", len); 270 result= url_write(s->rtp_ctx, buf, len); 271 dprintf(s->ic, "result from url_write: %d\n", result); 272 av_free(buf); 273 } 274 return 0; 275} 276 277void rtp_send_punch_packets(URLContext* rtp_handle) 278{ 279 ByteIOContext *pb; 280 uint8_t *buf; 281 int len; 282 283 /* Send a small RTP packet */ 284 if (url_open_dyn_buf(&pb) < 0) 285 return; 286 287 put_byte(pb, (RTP_VERSION << 6)); 288 put_byte(pb, 0); /* Payload type */ 289 put_be16(pb, 0); /* Seq */ 290 put_be32(pb, 0); /* Timestamp */ 291 put_be32(pb, 0); /* SSRC */ 292 293 put_flush_packet(pb); 294 len = url_close_dyn_buf(pb, &buf); 295 if ((len > 0) && buf) 296 url_write(rtp_handle, buf, len); 297 av_free(buf); 298 299 /* Send a minimal RTCP RR */ 300 if (url_open_dyn_buf(&pb) < 0) 301 return; 302 303 put_byte(pb, (RTP_VERSION << 6)); 304 put_byte(pb, 201); /* receiver report */ 305 put_be16(pb, 1); /* length in words - 1 */ 306 put_be32(pb, 0); /* our own SSRC */ 307 308 put_flush_packet(pb); 309 len = url_close_dyn_buf(pb, &buf); 310 if ((len > 0) && buf) 311 url_write(rtp_handle, buf, len); 312 av_free(buf); 313} 314 315 316/** 317 * open a new RTP parse context for stream 'st'. 'st' can be NULL for 318 * MPEG2TS streams to indicate that they should be demuxed inside the 319 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned) 320 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system. 321 */ 322RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data) 323{ 324 RTPDemuxContext *s; 325 326 s = av_mallocz(sizeof(RTPDemuxContext)); 327 if (!s) 328 return NULL; 329 s->payload_type = payload_type; 330 s->last_rtcp_ntp_time = AV_NOPTS_VALUE; 331 s->first_rtcp_ntp_time = AV_NOPTS_VALUE; 332 s->ic = s1; 333 s->st = st; 334 s->rtp_payload_data = rtp_payload_data; 335 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp? 336 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) { 337 s->ts = ff_mpegts_parse_open(s->ic); 338 if (s->ts == NULL) { 339 av_free(s); 340 return NULL; 341 } 342 } else { 343 av_set_pts_info(st, 32, 1, 90000); 344 switch(st->codec->codec_id) { 345 case CODEC_ID_MPEG1VIDEO: 346 case CODEC_ID_MPEG2VIDEO: 347 case CODEC_ID_MP2: 348 case CODEC_ID_MP3: 349 case CODEC_ID_MPEG4: 350 case CODEC_ID_H263: 351 case CODEC_ID_H264: 352 st->need_parsing = AVSTREAM_PARSE_FULL; 353 break; 354 default: 355 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 356 av_set_pts_info(st, 32, 1, st->codec->sample_rate); 357 } 358 break; 359 } 360 } 361 // needed to send back RTCP RR in RTSP sessions 362 s->rtp_ctx = rtpc; 363 gethostname(s->hostname, sizeof(s->hostname)); 364 return s; 365} 366 367void 368rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, 369 RTPDynamicProtocolHandler *handler) 370{ 371 s->dynamic_protocol_context = ctx; 372 s->parse_packet = handler->parse_packet; 373} 374 375static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf) 376{ 377 int au_headers_length, au_header_size, i; 378 GetBitContext getbitcontext; 379 RTPPayloadData *infos; 380 381 infos = s->rtp_payload_data; 382 383 if (infos == NULL) 384 return -1; 385 386 /* decode the first 2 bytes where the AUHeader sections are stored 387 length in bits */ 388 au_headers_length = AV_RB16(buf); 389 390 if (au_headers_length > RTP_MAX_PACKET_LENGTH) 391 return -1; 392 393 infos->au_headers_length_bytes = (au_headers_length + 7) / 8; 394 395 /* skip AU headers length section (2 bytes) */ 396 buf += 2; 397 398 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8); 399 400 /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */ 401 au_header_size = infos->sizelength + infos->indexlength; 402 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0)) 403 return -1; 404 405 infos->nb_au_headers = au_headers_length / au_header_size; 406 if (!infos->au_headers || infos->au_headers_allocated < infos->nb_au_headers) { 407 av_free(infos->au_headers); 408 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers); 409 infos->au_headers_allocated = infos->nb_au_headers; 410 } 411 412 /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving) 413 In my test, the FAAD decoder does not behave correctly when sending each AU one by one 414 but does when sending the whole as one big packet... */ 415 infos->au_headers[0].size = 0; 416 infos->au_headers[0].index = 0; 417 for (i = 0; i < infos->nb_au_headers; ++i) { 418 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength); 419 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength); 420 } 421 422 infos->nb_au_headers = 1; 423 424 return 0; 425} 426 427/** 428 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc. 429 */ 430static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp) 431{ 432 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) { 433 int64_t addend; 434 int delta_timestamp; 435 436 /* compute pts from timestamp with received ntp_time */ 437 delta_timestamp = timestamp - s->last_rtcp_timestamp; 438 /* convert to the PTS timebase */ 439 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); 440 pkt->pts = s->range_start_offset + addend + delta_timestamp; 441 } 442} 443 444/** 445 * Parse an RTP or RTCP packet directly sent as a buffer. 446 * @param s RTP parse context. 447 * @param pkt returned packet 448 * @param buf input buffer or NULL to read the next packets 449 * @param len buffer len 450 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow 451 * (use buf as NULL to read the next). -1 if no packet (error or no more packet). 452 */ 453int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, 454 const uint8_t *buf, int len) 455{ 456 unsigned int ssrc, h; 457 int payload_type, seq, ret, flags = 0; 458 AVStream *st; 459 uint32_t timestamp; 460 int rv= 0; 461 462 if (!buf) { 463 /* return the next packets, if any */ 464 if(s->st && s->parse_packet) { 465 timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned.... 466 rv= s->parse_packet(s->ic, s->dynamic_protocol_context, 467 s->st, pkt, ×tamp, NULL, 0, flags); 468 finalize_packet(s, pkt, timestamp); 469 return rv; 470 } else { 471 // TODO: Move to a dynamic packet handler (like above) 472 if (s->read_buf_index >= s->read_buf_size) 473 return -1; 474 ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, 475 s->read_buf_size - s->read_buf_index); 476 if (ret < 0) 477 return -1; 478 s->read_buf_index += ret; 479 if (s->read_buf_index < s->read_buf_size) 480 return 1; 481 else 482 return 0; 483 } 484 } 485 486 if (len < 12) 487 return -1; 488 489 if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) 490 return -1; 491 if (buf[1] >= 200 && buf[1] <= 204) { 492 rtcp_parse_packet(s, buf, len); 493 return -1; 494 } 495 payload_type = buf[1] & 0x7f; 496 if (buf[1] & 0x80) 497 flags |= RTP_FLAG_MARKER; 498 seq = AV_RB16(buf + 2); 499 timestamp = AV_RB32(buf + 4); 500 ssrc = AV_RB32(buf + 8); 501 /* store the ssrc in the RTPDemuxContext */ 502 s->ssrc = ssrc; 503 504 /* NOTE: we can handle only one payload type */ 505 if (s->payload_type != payload_type) 506 return -1; 507 508 st = s->st; 509 // only do something with this if all the rtp checks pass... 510 if(!rtp_valid_packet_in_sequence(&s->statistics, seq)) 511 { 512 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n", 513 payload_type, seq, ((s->seq + 1) & 0xffff)); 514 return -1; 515 } 516 517 s->seq = seq; 518 len -= 12; 519 buf += 12; 520 521 if (!st) { 522 /* specific MPEG2TS demux support */ 523 ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len); 524 if (ret < 0) 525 return -1; 526 if (ret < len) { 527 s->read_buf_size = len - ret; 528 memcpy(s->buf, buf + ret, s->read_buf_size); 529 s->read_buf_index = 0; 530 return 1; 531 } 532 return 0; 533 } else if (s->parse_packet) { 534 rv = s->parse_packet(s->ic, s->dynamic_protocol_context, 535 s->st, pkt, ×tamp, buf, len, flags); 536 } else { 537 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise. 538 switch(st->codec->codec_id) { 539 case CODEC_ID_MP2: 540 case CODEC_ID_MP3: 541 /* better than nothing: skip mpeg audio RTP header */ 542 if (len <= 4) 543 return -1; 544 h = AV_RB32(buf); 545 len -= 4; 546 buf += 4; 547 av_new_packet(pkt, len); 548 memcpy(pkt->data, buf, len); 549 break; 550 case CODEC_ID_MPEG1VIDEO: 551 case CODEC_ID_MPEG2VIDEO: 552 /* better than nothing: skip mpeg video RTP header */ 553 if (len <= 4) 554 return -1; 555 h = AV_RB32(buf); 556 buf += 4; 557 len -= 4; 558 if (h & (1 << 26)) { 559 /* mpeg2 */ 560 if (len <= 4) 561 return -1; 562 buf += 4; 563 len -= 4; 564 } 565 av_new_packet(pkt, len); 566 memcpy(pkt->data, buf, len); 567 break; 568 // moved from below, verbatim. this is because this section handles packets, and the lower switch handles 569 // timestamps. 570 // TODO: Put this into a dynamic packet handler... 571 case CODEC_ID_AAC: 572 if (rtp_parse_mp4_au(s, buf)) 573 return -1; 574 { 575 RTPPayloadData *infos = s->rtp_payload_data; 576 if (infos == NULL) 577 return -1; 578 buf += infos->au_headers_length_bytes + 2; 579 len -= infos->au_headers_length_bytes + 2; 580 581 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define 582 one au_header */ 583 av_new_packet(pkt, infos->au_headers[0].size); 584 memcpy(pkt->data, buf, infos->au_headers[0].size); 585 buf += infos->au_headers[0].size; 586 len -= infos->au_headers[0].size; 587 } 588 s->read_buf_size = len; 589 rv= 0; 590 break; 591 default: 592 av_new_packet(pkt, len); 593 memcpy(pkt->data, buf, len); 594 break; 595 } 596 597 pkt->stream_index = st->index; 598 } 599 600 // now perform timestamp things.... 601 finalize_packet(s, pkt, timestamp); 602 603 return rv; 604} 605 606void rtp_parse_close(RTPDemuxContext *s) 607{ 608 // TODO: fold this into the protocol specific data fields. 609 av_free(s->rtp_payload_data->mode); 610 av_free(s->rtp_payload_data->au_headers); 611 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) { 612 ff_mpegts_parse_close(s->ts); 613 } 614 av_free(s); 615} 616