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