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