1/* 2 * RTP input format 3 * Copyright (c) 2002 Fabrice Bellard 4 * 5 * This file is part of Libav. 6 * 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. 11 * 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. 16 * 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 20 */ 21 22#include "libavutil/mathematics.h" 23#include "libavutil/avstring.h" 24#include "libavcodec/get_bits.h" 25#include "avformat.h" 26#include "mpegts.h" 27#include "url.h" 28 29#include <unistd.h> 30#include "network.h" 31 32#include "rtpdec.h" 33#include "rtpdec_formats.h" 34 35//#define DEBUG 36 37/* TODO: - add RTCP statistics reporting (should be optional). 38 39 - add support for h263/mpeg4 packetized output : IDEA: send a 40 buffer to 'rtp_write_packet' contains all the packets for ONE 41 frame. Each packet should have a four byte header containing 42 the length in big endian format (same trick as 43 'ffio_open_dyn_packet_buf') 44*/ 45 46static RTPDynamicProtocolHandler ff_realmedia_mp3_dynamic_handler = { 47 .enc_name = "X-MP3-draft-00", 48 .codec_type = AVMEDIA_TYPE_AUDIO, 49 .codec_id = CODEC_ID_MP3ADU, 50}; 51 52/* statistics functions */ 53static RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL; 54 55void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler) 56{ 57 handler->next= RTPFirstDynamicPayloadHandler; 58 RTPFirstDynamicPayloadHandler= handler; 59} 60 61void av_register_rtp_dynamic_payload_handlers(void) 62{ 63 ff_register_dynamic_payload_handler(&ff_mp4v_es_dynamic_handler); 64 ff_register_dynamic_payload_handler(&ff_mpeg4_generic_dynamic_handler); 65 ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler); 66 ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler); 67 ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler); 68 ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler); 69 ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler); 70 ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler); 71 ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler); 72 ff_register_dynamic_payload_handler(&ff_qdm2_dynamic_handler); 73 ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler); 74 ff_register_dynamic_payload_handler(&ff_mp4a_latm_dynamic_handler); 75 ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler); 76 ff_register_dynamic_payload_handler(&ff_qcelp_dynamic_handler); 77 ff_register_dynamic_payload_handler(&ff_realmedia_mp3_dynamic_handler); 78 79 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler); 80 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler); 81 82 ff_register_dynamic_payload_handler(&ff_qt_rtp_aud_handler); 83 ff_register_dynamic_payload_handler(&ff_qt_rtp_vid_handler); 84 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_aud_handler); 85 ff_register_dynamic_payload_handler(&ff_quicktime_rtp_vid_handler); 86 87 ff_register_dynamic_payload_handler(&ff_g726_16_dynamic_handler); 88 ff_register_dynamic_payload_handler(&ff_g726_24_dynamic_handler); 89 ff_register_dynamic_payload_handler(&ff_g726_32_dynamic_handler); 90 ff_register_dynamic_payload_handler(&ff_g726_40_dynamic_handler); 91} 92 93RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name, 94 enum AVMediaType codec_type) 95{ 96 RTPDynamicProtocolHandler *handler; 97 for (handler = RTPFirstDynamicPayloadHandler; 98 handler; handler = handler->next) 99 if (!av_strcasecmp(name, handler->enc_name) && 100 codec_type == handler->codec_type) 101 return handler; 102 return NULL; 103} 104 105RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id, 106 enum AVMediaType codec_type) 107{ 108 RTPDynamicProtocolHandler *handler; 109 for (handler = RTPFirstDynamicPayloadHandler; 110 handler; handler = handler->next) 111 if (handler->static_payload_id && handler->static_payload_id == id && 112 codec_type == handler->codec_type) 113 return handler; 114 return NULL; 115} 116 117static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len) 118{ 119 int payload_len; 120 while (len >= 4) { 121 payload_len = FFMIN(len, (AV_RB16(buf + 2) + 1) * 4); 122 123 switch (buf[1]) { 124 case RTCP_SR: 125 if (payload_len < 20) { 126 av_log(NULL, AV_LOG_ERROR, "Invalid length for RTCP SR packet\n"); 127 return AVERROR_INVALIDDATA; 128 } 129 130 s->last_rtcp_ntp_time = AV_RB64(buf + 8); 131 s->last_rtcp_timestamp = AV_RB32(buf + 16); 132 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) { 133 s->first_rtcp_ntp_time = s->last_rtcp_ntp_time; 134 if (!s->base_timestamp) 135 s->base_timestamp = s->last_rtcp_timestamp; 136 s->rtcp_ts_offset = s->last_rtcp_timestamp - s->base_timestamp; 137 } 138 139 break; 140 case RTCP_BYE: 141 return -RTCP_BYE; 142 } 143 144 buf += payload_len; 145 len -= payload_len; 146 } 147 return -1; 148} 149 150#define RTP_SEQ_MOD (1<<16) 151 152/** 153* called on parse open packet 154*/ 155static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet. 156{ 157 memset(s, 0, sizeof(RTPStatistics)); 158 s->max_seq= base_sequence; 159 s->probation= 1; 160} 161 162/** 163* called whenever there is a large jump in sequence numbers, or when they get out of probation... 164*/ 165static void rtp_init_sequence(RTPStatistics *s, uint16_t seq) 166{ 167 s->max_seq= seq; 168 s->cycles= 0; 169 s->base_seq= seq -1; 170 s->bad_seq= RTP_SEQ_MOD + 1; 171 s->received= 0; 172 s->expected_prior= 0; 173 s->received_prior= 0; 174 s->jitter= 0; 175 s->transit= 0; 176} 177 178/** 179* returns 1 if we should handle this packet. 180*/ 181static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq) 182{ 183 uint16_t udelta= seq - s->max_seq; 184 const int MAX_DROPOUT= 3000; 185 const int MAX_MISORDER = 100; 186 const int MIN_SEQUENTIAL = 2; 187 188 /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */ 189 if(s->probation) 190 { 191 if(seq==s->max_seq + 1) { 192 s->probation--; 193 s->max_seq= seq; 194 if(s->probation==0) { 195 rtp_init_sequence(s, seq); 196 s->received++; 197 return 1; 198 } 199 } else { 200 s->probation= MIN_SEQUENTIAL - 1; 201 s->max_seq = seq; 202 } 203 } else if (udelta < MAX_DROPOUT) { 204 // in order, with permissible gap 205 if(seq < s->max_seq) { 206 //sequence number wrapped; count antother 64k cycles 207 s->cycles += RTP_SEQ_MOD; 208 } 209 s->max_seq= seq; 210 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) { 211 // sequence made a large jump... 212 if(seq==s->bad_seq) { 213 // two sequential packets-- assume that the other side restarted without telling us; just resync. 214 rtp_init_sequence(s, seq); 215 } else { 216 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1); 217 return 0; 218 } 219 } else { 220 // duplicate or reordered packet... 221 } 222 s->received++; 223 return 1; 224} 225 226int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, int count) 227{ 228 AVIOContext *pb; 229 uint8_t *buf; 230 int len; 231 int rtcp_bytes; 232 RTPStatistics *stats= &s->statistics; 233 uint32_t lost; 234 uint32_t extended_max; 235 uint32_t expected_interval; 236 uint32_t received_interval; 237 uint32_t lost_interval; 238 uint32_t expected; 239 uint32_t fraction; 240 uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time? 241 242 if (!s->rtp_ctx || (count < 1)) 243 return -1; 244 245 /* TODO: I think this is way too often; RFC 1889 has algorithm for this */ 246 /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */ 247 s->octet_count += count; 248 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / 249 RTCP_TX_RATIO_DEN; 250 rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !? 251 if (rtcp_bytes < 28) 252 return -1; 253 s->last_octet_count = s->octet_count; 254 255 if (avio_open_dyn_buf(&pb) < 0) 256 return -1; 257 258 // Receiver Report 259 avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ 260 avio_w8(pb, RTCP_RR); 261 avio_wb16(pb, 7); /* length in words - 1 */ 262 // our own SSRC: we use the server's SSRC + 1 to avoid conflicts 263 avio_wb32(pb, s->ssrc + 1); 264 avio_wb32(pb, s->ssrc); // server SSRC 265 // some placeholders we should really fill... 266 // RFC 1889/p64 267 extended_max= stats->cycles + stats->max_seq; 268 expected= extended_max - stats->base_seq + 1; 269 lost= expected - stats->received; 270 lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits... 271 expected_interval= expected - stats->expected_prior; 272 stats->expected_prior= expected; 273 received_interval= stats->received - stats->received_prior; 274 stats->received_prior= stats->received; 275 lost_interval= expected_interval - received_interval; 276 if (expected_interval==0 || lost_interval<=0) fraction= 0; 277 else fraction = (lost_interval<<8)/expected_interval; 278 279 fraction= (fraction<<24) | lost; 280 281 avio_wb32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */ 282 avio_wb32(pb, extended_max); /* max sequence received */ 283 avio_wb32(pb, stats->jitter>>4); /* jitter */ 284 285 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE) 286 { 287 avio_wb32(pb, 0); /* last SR timestamp */ 288 avio_wb32(pb, 0); /* delay since last SR */ 289 } else { 290 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special? 291 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time; 292 293 avio_wb32(pb, middle_32_bits); /* last SR timestamp */ 294 avio_wb32(pb, delay_since_last); /* delay since last SR */ 295 } 296 297 // CNAME 298 avio_w8(pb, (RTP_VERSION << 6) + 1); /* 1 report block */ 299 avio_w8(pb, RTCP_SDES); 300 len = strlen(s->hostname); 301 avio_wb16(pb, (6 + len + 3) / 4); /* length in words - 1 */ 302 avio_wb32(pb, s->ssrc); 303 avio_w8(pb, 0x01); 304 avio_w8(pb, len); 305 avio_write(pb, s->hostname, len); 306 // padding 307 for (len = (6 + len) % 4; len % 4; len++) { 308 avio_w8(pb, 0); 309 } 310 311 avio_flush(pb); 312 len = avio_close_dyn_buf(pb, &buf); 313 if ((len > 0) && buf) { 314 int av_unused result; 315 av_dlog(s->ic, "sending %d bytes of RR\n", len); 316 result= ffurl_write(s->rtp_ctx, buf, len); 317 av_dlog(s->ic, "result from ffurl_write: %d\n", result); 318 av_free(buf); 319 } 320 return 0; 321} 322 323void ff_rtp_send_punch_packets(URLContext* rtp_handle) 324{ 325 AVIOContext *pb; 326 uint8_t *buf; 327 int len; 328 329 /* Send a small RTP packet */ 330 if (avio_open_dyn_buf(&pb) < 0) 331 return; 332 333 avio_w8(pb, (RTP_VERSION << 6)); 334 avio_w8(pb, 0); /* Payload type */ 335 avio_wb16(pb, 0); /* Seq */ 336 avio_wb32(pb, 0); /* Timestamp */ 337 avio_wb32(pb, 0); /* SSRC */ 338 339 avio_flush(pb); 340 len = avio_close_dyn_buf(pb, &buf); 341 if ((len > 0) && buf) 342 ffurl_write(rtp_handle, buf, len); 343 av_free(buf); 344 345 /* Send a minimal RTCP RR */ 346 if (avio_open_dyn_buf(&pb) < 0) 347 return; 348 349 avio_w8(pb, (RTP_VERSION << 6)); 350 avio_w8(pb, RTCP_RR); /* receiver report */ 351 avio_wb16(pb, 1); /* length in words - 1 */ 352 avio_wb32(pb, 0); /* our own SSRC */ 353 354 avio_flush(pb); 355 len = avio_close_dyn_buf(pb, &buf); 356 if ((len > 0) && buf) 357 ffurl_write(rtp_handle, buf, len); 358 av_free(buf); 359} 360 361 362/** 363 * open a new RTP parse context for stream 'st'. 'st' can be NULL for 364 * MPEG2TS streams to indicate that they should be demuxed inside the 365 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned) 366 */ 367RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, int queue_size) 368{ 369 RTPDemuxContext *s; 370 371 s = av_mallocz(sizeof(RTPDemuxContext)); 372 if (!s) 373 return NULL; 374 s->payload_type = payload_type; 375 s->last_rtcp_ntp_time = AV_NOPTS_VALUE; 376 s->first_rtcp_ntp_time = AV_NOPTS_VALUE; 377 s->ic = s1; 378 s->st = st; 379 s->queue_size = queue_size; 380 rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp? 381 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) { 382 s->ts = ff_mpegts_parse_open(s->ic); 383 if (s->ts == NULL) { 384 av_free(s); 385 return NULL; 386 } 387 } else { 388 switch(st->codec->codec_id) { 389 case CODEC_ID_MPEG1VIDEO: 390 case CODEC_ID_MPEG2VIDEO: 391 case CODEC_ID_MP2: 392 case CODEC_ID_MP3: 393 case CODEC_ID_MPEG4: 394 case CODEC_ID_H263: 395 case CODEC_ID_H264: 396 st->need_parsing = AVSTREAM_PARSE_FULL; 397 break; 398 case CODEC_ID_ADPCM_G722: 399 /* According to RFC 3551, the stream clock rate is 8000 400 * even if the sample rate is 16000. */ 401 if (st->codec->sample_rate == 8000) 402 st->codec->sample_rate = 16000; 403 break; 404 default: 405 break; 406 } 407 } 408 // needed to send back RTCP RR in RTSP sessions 409 s->rtp_ctx = rtpc; 410 gethostname(s->hostname, sizeof(s->hostname)); 411 return s; 412} 413 414void 415ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx, 416 RTPDynamicProtocolHandler *handler) 417{ 418 s->dynamic_protocol_context = ctx; 419 s->parse_packet = handler->parse_packet; 420} 421 422/** 423 * This was the second switch in rtp_parse packet. Normalizes time, if required, sets stream_index, etc. 424 */ 425static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp) 426{ 427 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE) 428 return; /* Timestamp already set by depacketizer */ 429 if (timestamp == RTP_NOTS_VALUE) 430 return; 431 432 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE && s->ic->nb_streams > 1) { 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 + s->rtcp_ts_offset + addend + 441 delta_timestamp; 442 return; 443 } 444 445 if (!s->base_timestamp) 446 s->base_timestamp = timestamp; 447 /* assume that the difference is INT32_MIN < x < INT32_MAX, but allow the first timestamp to exceed INT32_MAX */ 448 if (!s->timestamp) 449 s->unwrapped_timestamp += timestamp; 450 else 451 s->unwrapped_timestamp += (int32_t)(timestamp - s->timestamp); 452 s->timestamp = timestamp; 453 pkt->pts = s->unwrapped_timestamp + s->range_start_offset - s->base_timestamp; 454} 455 456static int rtp_parse_packet_internal(RTPDemuxContext *s, AVPacket *pkt, 457 const uint8_t *buf, int len) 458{ 459 unsigned int ssrc, h; 460 int payload_type, seq, ret, flags = 0; 461 int ext; 462 AVStream *st; 463 uint32_t timestamp; 464 int rv= 0; 465 466 ext = buf[0] & 0x10; 467 payload_type = buf[1] & 0x7f; 468 if (buf[1] & 0x80) 469 flags |= RTP_FLAG_MARKER; 470 seq = AV_RB16(buf + 2); 471 timestamp = AV_RB32(buf + 4); 472 ssrc = AV_RB32(buf + 8); 473 /* store the ssrc in the RTPDemuxContext */ 474 s->ssrc = ssrc; 475 476 /* NOTE: we can handle only one payload type */ 477 if (s->payload_type != payload_type) 478 return -1; 479 480 st = s->st; 481 // only do something with this if all the rtp checks pass... 482 if(!rtp_valid_packet_in_sequence(&s->statistics, seq)) 483 { 484 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n", 485 payload_type, seq, ((s->seq + 1) & 0xffff)); 486 return -1; 487 } 488 489 if (buf[0] & 0x20) { 490 int padding = buf[len - 1]; 491 if (len >= 12 + padding) 492 len -= padding; 493 } 494 495 s->seq = seq; 496 len -= 12; 497 buf += 12; 498 499 /* RFC 3550 Section 5.3.1 RTP Header Extension handling */ 500 if (ext) { 501 if (len < 4) 502 return -1; 503 /* calculate the header extension length (stored as number 504 * of 32-bit words) */ 505 ext = (AV_RB16(buf + 2) + 1) << 2; 506 507 if (len < ext) 508 return -1; 509 // skip past RTP header extension 510 len -= ext; 511 buf += ext; 512 } 513 514 if (!st) { 515 /* specific MPEG2TS demux support */ 516 ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len); 517 /* The only error that can be returned from ff_mpegts_parse_packet 518 * is "no more data to return from the provided buffer", so return 519 * AVERROR(EAGAIN) for all errors */ 520 if (ret < 0) 521 return AVERROR(EAGAIN); 522 if (ret < len) { 523 s->read_buf_size = len - ret; 524 memcpy(s->buf, buf + ret, s->read_buf_size); 525 s->read_buf_index = 0; 526 return 1; 527 } 528 return 0; 529 } else if (s->parse_packet) { 530 rv = s->parse_packet(s->ic, s->dynamic_protocol_context, 531 s->st, pkt, ×tamp, buf, len, flags); 532 } else { 533 // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise. 534 switch(st->codec->codec_id) { 535 case CODEC_ID_MP2: 536 case CODEC_ID_MP3: 537 /* better than nothing: skip mpeg audio RTP header */ 538 if (len <= 4) 539 return -1; 540 h = AV_RB32(buf); 541 len -= 4; 542 buf += 4; 543 av_new_packet(pkt, len); 544 memcpy(pkt->data, buf, len); 545 break; 546 case CODEC_ID_MPEG1VIDEO: 547 case CODEC_ID_MPEG2VIDEO: 548 /* better than nothing: skip mpeg video RTP header */ 549 if (len <= 4) 550 return -1; 551 h = AV_RB32(buf); 552 buf += 4; 553 len -= 4; 554 if (h & (1 << 26)) { 555 /* mpeg2 */ 556 if (len <= 4) 557 return -1; 558 buf += 4; 559 len -= 4; 560 } 561 av_new_packet(pkt, len); 562 memcpy(pkt->data, buf, len); 563 break; 564 default: 565 av_new_packet(pkt, len); 566 memcpy(pkt->data, buf, len); 567 break; 568 } 569 570 pkt->stream_index = st->index; 571 } 572 573 // now perform timestamp things.... 574 finalize_packet(s, pkt, timestamp); 575 576 return rv; 577} 578 579void ff_rtp_reset_packet_queue(RTPDemuxContext *s) 580{ 581 while (s->queue) { 582 RTPPacket *next = s->queue->next; 583 av_free(s->queue->buf); 584 av_free(s->queue); 585 s->queue = next; 586 } 587 s->seq = 0; 588 s->queue_len = 0; 589 s->prev_ret = 0; 590} 591 592static void enqueue_packet(RTPDemuxContext *s, uint8_t *buf, int len) 593{ 594 uint16_t seq = AV_RB16(buf + 2); 595 RTPPacket *cur = s->queue, *prev = NULL, *packet; 596 597 /* Find the correct place in the queue to insert the packet */ 598 while (cur) { 599 int16_t diff = seq - cur->seq; 600 if (diff < 0) 601 break; 602 prev = cur; 603 cur = cur->next; 604 } 605 606 packet = av_mallocz(sizeof(*packet)); 607 if (!packet) 608 return; 609 packet->recvtime = av_gettime(); 610 packet->seq = seq; 611 packet->len = len; 612 packet->buf = buf; 613 packet->next = cur; 614 if (prev) 615 prev->next = packet; 616 else 617 s->queue = packet; 618 s->queue_len++; 619} 620 621static int has_next_packet(RTPDemuxContext *s) 622{ 623 return s->queue && s->queue->seq == (uint16_t) (s->seq + 1); 624} 625 626int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s) 627{ 628 return s->queue ? s->queue->recvtime : 0; 629} 630 631static int rtp_parse_queued_packet(RTPDemuxContext *s, AVPacket *pkt) 632{ 633 int rv; 634 RTPPacket *next; 635 636 if (s->queue_len <= 0) 637 return -1; 638 639 if (!has_next_packet(s)) 640 av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING, 641 "RTP: missed %d packets\n", s->queue->seq - s->seq - 1); 642 643 /* Parse the first packet in the queue, and dequeue it */ 644 rv = rtp_parse_packet_internal(s, pkt, s->queue->buf, s->queue->len); 645 next = s->queue->next; 646 av_free(s->queue->buf); 647 av_free(s->queue); 648 s->queue = next; 649 s->queue_len--; 650 return rv; 651} 652 653static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt, 654 uint8_t **bufptr, int len) 655{ 656 uint8_t* buf = bufptr ? *bufptr : NULL; 657 int ret, flags = 0; 658 uint32_t timestamp; 659 int rv= 0; 660 661 if (!buf) { 662 /* If parsing of the previous packet actually returned 0 or an error, 663 * there's nothing more to be parsed from that packet, but we may have 664 * indicated that we can return the next enqueued packet. */ 665 if (s->prev_ret <= 0) 666 return rtp_parse_queued_packet(s, pkt); 667 /* return the next packets, if any */ 668 if(s->st && s->parse_packet) { 669 /* timestamp should be overwritten by parse_packet, if not, 670 * the packet is left with pts == AV_NOPTS_VALUE */ 671 timestamp = RTP_NOTS_VALUE; 672 rv= s->parse_packet(s->ic, s->dynamic_protocol_context, 673 s->st, pkt, ×tamp, NULL, 0, flags); 674 finalize_packet(s, pkt, timestamp); 675 return rv; 676 } else { 677 // TODO: Move to a dynamic packet handler (like above) 678 if (s->read_buf_index >= s->read_buf_size) 679 return AVERROR(EAGAIN); 680 ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, 681 s->read_buf_size - s->read_buf_index); 682 if (ret < 0) 683 return AVERROR(EAGAIN); 684 s->read_buf_index += ret; 685 if (s->read_buf_index < s->read_buf_size) 686 return 1; 687 else 688 return 0; 689 } 690 } 691 692 if (len < 12) 693 return -1; 694 695 if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) 696 return -1; 697 if (buf[1] >= RTCP_SR && buf[1] <= RTCP_APP) { 698 return rtcp_parse_packet(s, buf, len); 699 } 700 701 if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) { 702 /* First packet, or no reordering */ 703 return rtp_parse_packet_internal(s, pkt, buf, len); 704 } else { 705 uint16_t seq = AV_RB16(buf + 2); 706 int16_t diff = seq - s->seq; 707 if (diff < 0) { 708 /* Packet older than the previously emitted one, drop */ 709 av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING, 710 "RTP: dropping old packet received too late\n"); 711 return -1; 712 } else if (diff <= 1) { 713 /* Correct packet */ 714 rv = rtp_parse_packet_internal(s, pkt, buf, len); 715 return rv; 716 } else { 717 /* Still missing some packet, enqueue this one. */ 718 enqueue_packet(s, buf, len); 719 *bufptr = NULL; 720 /* Return the first enqueued packet if the queue is full, 721 * even if we're missing something */ 722 if (s->queue_len >= s->queue_size) 723 return rtp_parse_queued_packet(s, pkt); 724 return -1; 725 } 726 } 727} 728 729/** 730 * Parse an RTP or RTCP packet directly sent as a buffer. 731 * @param s RTP parse context. 732 * @param pkt returned packet 733 * @param bufptr pointer to the input buffer or NULL to read the next packets 734 * @param len buffer len 735 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow 736 * (use buf as NULL to read the next). -1 if no packet (error or no more packet). 737 */ 738int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, 739 uint8_t **bufptr, int len) 740{ 741 int rv = rtp_parse_one_packet(s, pkt, bufptr, len); 742 s->prev_ret = rv; 743 while (rv == AVERROR(EAGAIN) && has_next_packet(s)) 744 rv = rtp_parse_queued_packet(s, pkt); 745 return rv ? rv : has_next_packet(s); 746} 747 748void ff_rtp_parse_close(RTPDemuxContext *s) 749{ 750 ff_rtp_reset_packet_queue(s); 751 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) { 752 ff_mpegts_parse_close(s->ts); 753 } 754 av_free(s); 755} 756 757int ff_parse_fmtp(AVStream *stream, PayloadContext *data, const char *p, 758 int (*parse_fmtp)(AVStream *stream, 759 PayloadContext *data, 760 char *attr, char *value)) 761{ 762 char attr[256]; 763 char *value; 764 int res; 765 int value_size = strlen(p) + 1; 766 767 if (!(value = av_malloc(value_size))) { 768 av_log(stream, AV_LOG_ERROR, "Failed to allocate data for FMTP."); 769 return AVERROR(ENOMEM); 770 } 771 772 // remove protocol identifier 773 while (*p && *p == ' ') p++; // strip spaces 774 while (*p && *p != ' ') p++; // eat protocol identifier 775 while (*p && *p == ' ') p++; // strip trailing spaces 776 777 while (ff_rtsp_next_attr_and_value(&p, 778 attr, sizeof(attr), 779 value, value_size)) { 780 781 res = parse_fmtp(stream, data, attr, value); 782 if (res < 0 && res != AVERROR_PATCHWELCOME) { 783 av_free(value); 784 return res; 785 } 786 } 787 av_free(value); 788 return 0; 789} 790