80171ca9036da3dff811d6c3a28d0ee3582bf2eb
[ffmpeg.git] / libavformat / utils.c
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 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 #include "avformat.h"
22 #include "internal.h"
23 #include "libavcodec/opt.h"
24 #include "libavutil/avstring.h"
25 #include "riff.h"
26 #include <sys/time.h>
27 #include <time.h>
28 #include <strings.h>
29
30 #undef NDEBUG
31 #include <assert.h>
32
33 /**
34  * @file libavformat/utils.c
35  * various utility functions for use within FFmpeg
36  */
37
38 unsigned avformat_version(void)
39 {
40     return LIBAVFORMAT_VERSION_INT;
41 }
42
43 /* fraction handling */
44
45 /**
46  * f = val + (num / den) + 0.5.
47  *
48  * 'num' is normalized so that it is such as 0 <= num < den.
49  *
50  * @param f fractional number
51  * @param val integer value
52  * @param num must be >= 0
53  * @param den must be >= 1
54  */
55 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
56 {
57     num += (den >> 1);
58     if (num >= den) {
59         val += num / den;
60         num = num % den;
61     }
62     f->val = val;
63     f->num = num;
64     f->den = den;
65 }
66
67 /**
68  * Fractional addition to f: f = f + (incr / f->den).
69  *
70  * @param f fractional number
71  * @param incr increment, can be positive or negative
72  */
73 static void av_frac_add(AVFrac *f, int64_t incr)
74 {
75     int64_t num, den;
76
77     num = f->num + incr;
78     den = f->den;
79     if (num < 0) {
80         f->val += num / den;
81         num = num % den;
82         if (num < 0) {
83             num += den;
84             f->val--;
85         }
86     } else if (num >= den) {
87         f->val += num / den;
88         num = num % den;
89     }
90     f->num = num;
91 }
92
93 /** head of registered input format linked list */
94 AVInputFormat *first_iformat = NULL;
95 /** head of registered output format linked list */
96 AVOutputFormat *first_oformat = NULL;
97
98 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
99 {
100     if(f) return f->next;
101     else  return first_iformat;
102 }
103
104 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
105 {
106     if(f) return f->next;
107     else  return first_oformat;
108 }
109
110 void av_register_input_format(AVInputFormat *format)
111 {
112     AVInputFormat **p;
113     p = &first_iformat;
114     while (*p != NULL) p = &(*p)->next;
115     *p = format;
116     format->next = NULL;
117 }
118
119 void av_register_output_format(AVOutputFormat *format)
120 {
121     AVOutputFormat **p;
122     p = &first_oformat;
123     while (*p != NULL) p = &(*p)->next;
124     *p = format;
125     format->next = NULL;
126 }
127
128 int match_ext(const char *filename, const char *extensions)
129 {
130     const char *ext, *p;
131     char ext1[32], *q;
132
133     if(!filename)
134         return 0;
135
136     ext = strrchr(filename, '.');
137     if (ext) {
138         ext++;
139         p = extensions;
140         for(;;) {
141             q = ext1;
142             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
143                 *q++ = *p++;
144             *q = '\0';
145             if (!strcasecmp(ext1, ext))
146                 return 1;
147             if (*p == '\0')
148                 break;
149             p++;
150         }
151     }
152     return 0;
153 }
154
155 AVOutputFormat *guess_format(const char *short_name, const char *filename,
156                              const char *mime_type)
157 {
158     AVOutputFormat *fmt, *fmt_found;
159     int score_max, score;
160
161     /* specific test for image sequences */
162 #ifdef CONFIG_IMAGE2_MUXER
163     if (!short_name && filename &&
164         av_filename_number_test(filename) &&
165         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
166         return guess_format("image2", NULL, NULL);
167     }
168 #endif
169     /* Find the proper file type. */
170     fmt_found = NULL;
171     score_max = 0;
172     fmt = first_oformat;
173     while (fmt != NULL) {
174         score = 0;
175         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
176             score += 100;
177         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
178             score += 10;
179         if (filename && fmt->extensions &&
180             match_ext(filename, fmt->extensions)) {
181             score += 5;
182         }
183         if (score > score_max) {
184             score_max = score;
185             fmt_found = fmt;
186         }
187         fmt = fmt->next;
188     }
189     return fmt_found;
190 }
191
192 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
193                              const char *mime_type)
194 {
195     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
196
197     if (fmt) {
198         AVOutputFormat *stream_fmt;
199         char stream_format_name[64];
200
201         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
202         stream_fmt = guess_format(stream_format_name, NULL, NULL);
203
204         if (stream_fmt)
205             fmt = stream_fmt;
206     }
207
208     return fmt;
209 }
210
211 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
212                             const char *filename, const char *mime_type, enum CodecType type){
213     if(type == CODEC_TYPE_VIDEO){
214         enum CodecID codec_id= CODEC_ID_NONE;
215
216 #ifdef CONFIG_IMAGE2_MUXER
217         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
218             codec_id= av_guess_image2_codec(filename);
219         }
220 #endif
221         if(codec_id == CODEC_ID_NONE)
222             codec_id= fmt->video_codec;
223         return codec_id;
224     }else if(type == CODEC_TYPE_AUDIO)
225         return fmt->audio_codec;
226     else
227         return CODEC_ID_NONE;
228 }
229
230 AVInputFormat *av_find_input_format(const char *short_name)
231 {
232     AVInputFormat *fmt;
233     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
234         if (!strcmp(fmt->name, short_name))
235             return fmt;
236     }
237     return NULL;
238 }
239
240 /* memory handling */
241
242 void av_destruct_packet(AVPacket *pkt)
243 {
244     av_free(pkt->data);
245     pkt->data = NULL; pkt->size = 0;
246 }
247
248 void av_init_packet(AVPacket *pkt)
249 {
250     pkt->pts   = AV_NOPTS_VALUE;
251     pkt->dts   = AV_NOPTS_VALUE;
252     pkt->pos   = -1;
253     pkt->duration = 0;
254     pkt->convergence_duration = 0;
255     pkt->flags = 0;
256     pkt->stream_index = 0;
257     pkt->destruct= av_destruct_packet_nofree;
258 }
259
260 int av_new_packet(AVPacket *pkt, int size)
261 {
262     uint8_t *data;
263     if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
264         return AVERROR(ENOMEM);
265     data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
266     if (!data)
267         return AVERROR(ENOMEM);
268     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
269
270     av_init_packet(pkt);
271     pkt->data = data;
272     pkt->size = size;
273     pkt->destruct = av_destruct_packet;
274     return 0;
275 }
276
277 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
278 {
279     int ret= av_new_packet(pkt, size);
280
281     if(ret<0)
282         return ret;
283
284     pkt->pos= url_ftell(s);
285
286     ret= get_buffer(s, pkt->data, size);
287     if(ret<=0)
288         av_free_packet(pkt);
289     else
290         pkt->size= ret;
291
292     return ret;
293 }
294
295 int av_dup_packet(AVPacket *pkt)
296 {
297     if (pkt->destruct != av_destruct_packet) {
298         uint8_t *data;
299         /* We duplicate the packet and don't forget to add the padding again. */
300         if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
301             return AVERROR(ENOMEM);
302         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
303         if (!data) {
304             return AVERROR(ENOMEM);
305         }
306         memcpy(data, pkt->data, pkt->size);
307         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
308         pkt->data = data;
309         pkt->destruct = av_destruct_packet;
310     }
311     return 0;
312 }
313
314 int av_filename_number_test(const char *filename)
315 {
316     char buf[1024];
317     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
318 }
319
320 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
321 {
322     AVInputFormat *fmt1, *fmt;
323     int score;
324
325     fmt = NULL;
326     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
327         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
328             continue;
329         score = 0;
330         if (fmt1->read_probe) {
331             score = fmt1->read_probe(pd);
332         } else if (fmt1->extensions) {
333             if (match_ext(pd->filename, fmt1->extensions)) {
334                 score = 50;
335             }
336         }
337         if (score > *score_max) {
338             *score_max = score;
339             fmt = fmt1;
340         }else if (score == *score_max)
341             fmt = NULL;
342     }
343     return fmt;
344 }
345
346 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
347     int score=0;
348     return av_probe_input_format2(pd, is_opened, &score);
349 }
350
351 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
352 {
353     AVInputFormat *fmt;
354     fmt = av_probe_input_format2(pd, 1, &score);
355
356     if (fmt) {
357         if (!strcmp(fmt->name, "mp3")) {
358             st->codec->codec_id = CODEC_ID_MP3;
359             st->codec->codec_type = CODEC_TYPE_AUDIO;
360         } else if (!strcmp(fmt->name, "ac3")) {
361             st->codec->codec_id = CODEC_ID_AC3;
362             st->codec->codec_type = CODEC_TYPE_AUDIO;
363         } else if (!strcmp(fmt->name, "mpegvideo")) {
364             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
365             st->codec->codec_type = CODEC_TYPE_VIDEO;
366         } else if (!strcmp(fmt->name, "m4v")) {
367             st->codec->codec_id = CODEC_ID_MPEG4;
368             st->codec->codec_type = CODEC_TYPE_VIDEO;
369         } else if (!strcmp(fmt->name, "h264")) {
370             st->codec->codec_id = CODEC_ID_H264;
371             st->codec->codec_type = CODEC_TYPE_VIDEO;
372         }
373     }
374     return !!fmt;
375 }
376
377 /************************************************************/
378 /* input media file */
379
380 /**
381  * Open a media file from an IO stream. 'fmt' must be specified.
382  */
383 static const char* format_to_name(void* ptr)
384 {
385     AVFormatContext* fc = (AVFormatContext*) ptr;
386     if(fc->iformat) return fc->iformat->name;
387     else if(fc->oformat) return fc->oformat->name;
388     else return "NULL";
389 }
390
391 #define OFFSET(x) offsetof(AVFormatContext,x)
392 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
393 //these names are too long to be readable
394 #define E AV_OPT_FLAG_ENCODING_PARAM
395 #define D AV_OPT_FLAG_DECODING_PARAM
396
397 static const AVOption options[]={
398 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
399 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
400 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
401 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
402 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
403 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
404 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
405 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
406 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
407 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
408 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
409 {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
410 {"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
411 {"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
412 {NULL},
413 };
414
415 #undef E
416 #undef D
417 #undef DEFAULT
418
419 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
420
421 static void avformat_get_context_defaults(AVFormatContext *s)
422 {
423     memset(s, 0, sizeof(AVFormatContext));
424
425     s->av_class = &av_format_context_class;
426
427     av_opt_set_defaults(s);
428 }
429
430 AVFormatContext *av_alloc_format_context(void)
431 {
432     AVFormatContext *ic;
433     ic = av_malloc(sizeof(AVFormatContext));
434     if (!ic) return ic;
435     avformat_get_context_defaults(ic);
436     ic->av_class = &av_format_context_class;
437     return ic;
438 }
439
440 int av_open_input_stream(AVFormatContext **ic_ptr,
441                          ByteIOContext *pb, const char *filename,
442                          AVInputFormat *fmt, AVFormatParameters *ap)
443 {
444     int err;
445     AVFormatContext *ic;
446     AVFormatParameters default_ap;
447
448     if(!ap){
449         ap=&default_ap;
450         memset(ap, 0, sizeof(default_ap));
451     }
452
453     if(!ap->prealloced_context)
454         ic = av_alloc_format_context();
455     else
456         ic = *ic_ptr;
457     if (!ic) {
458         err = AVERROR(ENOMEM);
459         goto fail;
460     }
461     ic->iformat = fmt;
462     ic->pb = pb;
463     ic->duration = AV_NOPTS_VALUE;
464     ic->start_time = AV_NOPTS_VALUE;
465     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
466
467     /* allocate private data */
468     if (fmt->priv_data_size > 0) {
469         ic->priv_data = av_mallocz(fmt->priv_data_size);
470         if (!ic->priv_data) {
471             err = AVERROR(ENOMEM);
472             goto fail;
473         }
474     } else {
475         ic->priv_data = NULL;
476     }
477
478     if (ic->iformat->read_header) {
479         err = ic->iformat->read_header(ic, ap);
480         if (err < 0)
481             goto fail;
482     }
483
484     if (pb && !ic->data_offset)
485         ic->data_offset = url_ftell(ic->pb);
486
487     *ic_ptr = ic;
488     return 0;
489  fail:
490     if (ic) {
491         int i;
492         av_freep(&ic->priv_data);
493         for(i=0;i<ic->nb_streams;i++) {
494             AVStream *st = ic->streams[i];
495             if (st) {
496                 av_free(st->priv_data);
497                 av_free(st->codec->extradata);
498             }
499             av_free(st);
500         }
501     }
502     av_free(ic);
503     *ic_ptr = NULL;
504     return err;
505 }
506
507 /** size of probe buffer, for guessing file type from file contents */
508 #define PROBE_BUF_MIN 2048
509 #define PROBE_BUF_MAX (1<<20)
510
511 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
512                        AVInputFormat *fmt,
513                        int buf_size,
514                        AVFormatParameters *ap)
515 {
516     int err, probe_size;
517     AVProbeData probe_data, *pd = &probe_data;
518     ByteIOContext *pb = NULL;
519
520     pd->filename = "";
521     if (filename)
522         pd->filename = filename;
523     pd->buf = NULL;
524     pd->buf_size = 0;
525
526     if (!fmt) {
527         /* guess format if no file can be opened */
528         fmt = av_probe_input_format(pd, 0);
529     }
530
531     /* Do not open file if the format does not need it. XXX: specific
532        hack needed to handle RTSP/TCP */
533     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
534         /* if no file needed do not try to open one */
535         if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
536             goto fail;
537         }
538         if (buf_size > 0) {
539             url_setbufsize(pb, buf_size);
540         }
541
542         for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
543             int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
544             /* read probe data */
545             pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
546             pd->buf_size = get_buffer(pb, pd->buf, probe_size);
547             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
548             if (url_fseek(pb, 0, SEEK_SET) < 0) {
549                 url_fclose(pb);
550                 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
551                     pb = NULL;
552                     err = AVERROR(EIO);
553                     goto fail;
554                 }
555             }
556             /* guess file format */
557             fmt = av_probe_input_format2(pd, 1, &score);
558         }
559         av_freep(&pd->buf);
560     }
561
562     /* if still no format found, error */
563     if (!fmt) {
564         err = AVERROR_NOFMT;
565         goto fail;
566     }
567
568     /* check filename in case an image number is expected */
569     if (fmt->flags & AVFMT_NEEDNUMBER) {
570         if (!av_filename_number_test(filename)) {
571             err = AVERROR_NUMEXPECTED;
572             goto fail;
573         }
574     }
575     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
576     if (err)
577         goto fail;
578     return 0;
579  fail:
580     av_freep(&pd->buf);
581     if (pb)
582         url_fclose(pb);
583     *ic_ptr = NULL;
584     return err;
585
586 }
587
588 /*******************************************************/
589
590 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
591                                AVPacketList **plast_pktl){
592     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
593     if (!pktl)
594         return NULL;
595
596     if (*packet_buffer)
597         (*plast_pktl)->next = pktl;
598     else
599         *packet_buffer = pktl;
600
601     /* add the packet in the buffered packet list */
602     *plast_pktl = pktl;
603     pktl->pkt= *pkt;
604     return &pktl->pkt;
605 }
606
607 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
608 {
609     int ret;
610     AVStream *st;
611
612     for(;;){
613         AVPacketList *pktl = s->raw_packet_buffer;
614
615         if (pktl) {
616             *pkt = pktl->pkt;
617             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
618                 s->raw_packet_buffer = pktl->next;
619                 av_free(pktl);
620                 return 0;
621             }
622         }
623
624         av_init_packet(pkt);
625         ret= s->iformat->read_packet(s, pkt);
626         if (ret < 0)
627             return ret;
628         st= s->streams[pkt->stream_index];
629
630         switch(st->codec->codec_type){
631         case CODEC_TYPE_VIDEO:
632             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
633             break;
634         case CODEC_TYPE_AUDIO:
635             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
636             break;
637         case CODEC_TYPE_SUBTITLE:
638             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
639             break;
640         }
641
642         if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
643             return ret;
644
645         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
646
647         if(st->codec->codec_id == CODEC_ID_PROBE){
648             AVProbeData *pd = &st->probe_data;
649
650             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
651             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
652             pd->buf_size += pkt->size;
653             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
654
655             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
656                 set_codec_from_probe_data(st, pd, 1);
657                 if(st->codec->codec_id != CODEC_ID_PROBE){
658                     pd->buf_size=0;
659                     av_freep(&pd->buf);
660                 }
661             }
662         }
663     }
664 }
665
666 /**********************************************************/
667
668 /**
669  * Get the number of samples of an audio frame. Return -1 on error.
670  */
671 static int get_audio_frame_size(AVCodecContext *enc, int size)
672 {
673     int frame_size;
674
675     if(enc->codec_id == CODEC_ID_VORBIS)
676         return -1;
677
678     if (enc->frame_size <= 1) {
679         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
680
681         if (bits_per_sample) {
682             if (enc->channels == 0)
683                 return -1;
684             frame_size = (size << 3) / (bits_per_sample * enc->channels);
685         } else {
686             /* used for example by ADPCM codecs */
687             if (enc->bit_rate == 0)
688                 return -1;
689             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
690         }
691     } else {
692         frame_size = enc->frame_size;
693     }
694     return frame_size;
695 }
696
697
698 /**
699  * Return the frame duration in seconds. Return 0 if not available.
700  */
701 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
702                                    AVCodecParserContext *pc, AVPacket *pkt)
703 {
704     int frame_size;
705
706     *pnum = 0;
707     *pden = 0;
708     switch(st->codec->codec_type) {
709     case CODEC_TYPE_VIDEO:
710         if(st->time_base.num*1000LL > st->time_base.den){
711             *pnum = st->time_base.num;
712             *pden = st->time_base.den;
713         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
714             *pnum = st->codec->time_base.num;
715             *pden = st->codec->time_base.den;
716             if (pc && pc->repeat_pict) {
717                 *pden *= 2;
718                 *pnum = (*pnum) * (2 + pc->repeat_pict);
719             }
720         }
721         break;
722     case CODEC_TYPE_AUDIO:
723         frame_size = get_audio_frame_size(st->codec, pkt->size);
724         if (frame_size < 0)
725             break;
726         *pnum = frame_size;
727         *pden = st->codec->sample_rate;
728         break;
729     default:
730         break;
731     }
732 }
733
734 static int is_intra_only(AVCodecContext *enc){
735     if(enc->codec_type == CODEC_TYPE_AUDIO){
736         return 1;
737     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
738         switch(enc->codec_id){
739         case CODEC_ID_MJPEG:
740         case CODEC_ID_MJPEGB:
741         case CODEC_ID_LJPEG:
742         case CODEC_ID_RAWVIDEO:
743         case CODEC_ID_DVVIDEO:
744         case CODEC_ID_HUFFYUV:
745         case CODEC_ID_FFVHUFF:
746         case CODEC_ID_ASV1:
747         case CODEC_ID_ASV2:
748         case CODEC_ID_VCR1:
749         case CODEC_ID_DNXHD:
750             return 1;
751         default: break;
752         }
753     }
754     return 0;
755 }
756
757 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
758                                       int64_t dts, int64_t pts)
759 {
760     AVStream *st= s->streams[stream_index];
761     AVPacketList *pktl= s->packet_buffer;
762
763     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
764         return;
765
766     st->first_dts= dts - st->cur_dts;
767     st->cur_dts= dts;
768
769     for(; pktl; pktl= pktl->next){
770         if(pktl->pkt.stream_index != stream_index)
771             continue;
772         //FIXME think more about this check
773         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
774             pktl->pkt.pts += st->first_dts;
775
776         if(pktl->pkt.dts != AV_NOPTS_VALUE)
777             pktl->pkt.dts += st->first_dts;
778
779         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
780             st->start_time= pktl->pkt.pts;
781     }
782     if (st->start_time == AV_NOPTS_VALUE)
783         st->start_time = pts;
784 }
785
786 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
787 {
788     AVPacketList *pktl= s->packet_buffer;
789     int64_t cur_dts= 0;
790
791     if(st->first_dts != AV_NOPTS_VALUE){
792         cur_dts= st->first_dts;
793         for(; pktl; pktl= pktl->next){
794             if(pktl->pkt.stream_index == pkt->stream_index){
795                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
796                     break;
797                 cur_dts -= pkt->duration;
798             }
799         }
800         pktl= s->packet_buffer;
801         st->first_dts = cur_dts;
802     }else if(st->cur_dts)
803         return;
804
805     for(; pktl; pktl= pktl->next){
806         if(pktl->pkt.stream_index != pkt->stream_index)
807             continue;
808         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
809            && !pktl->pkt.duration){
810             pktl->pkt.dts= cur_dts;
811             if(!st->codec->has_b_frames)
812                 pktl->pkt.pts= cur_dts;
813             cur_dts += pkt->duration;
814             pktl->pkt.duration= pkt->duration;
815         }else
816             break;
817     }
818     if(st->first_dts == AV_NOPTS_VALUE)
819         st->cur_dts= cur_dts;
820 }
821
822 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
823                                AVCodecParserContext *pc, AVPacket *pkt)
824 {
825     int num, den, presentation_delayed, delay, i;
826     int64_t offset;
827
828     /* do we have a video B-frame ? */
829     delay= st->codec->has_b_frames;
830     presentation_delayed = 0;
831     /* XXX: need has_b_frame, but cannot get it if the codec is
832         not initialized */
833     if (delay &&
834         pc && pc->pict_type != FF_B_TYPE)
835         presentation_delayed = 1;
836
837     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
838        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
839         pkt->dts -= 1LL<<st->pts_wrap_bits;
840     }
841
842     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
843     // we take the conservative approach and discard both
844     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
845     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
846         av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
847         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
848     }
849
850     if (pkt->duration == 0) {
851         compute_frame_duration(&num, &den, st, pc, pkt);
852         if (den && num) {
853             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
854
855             if(pkt->duration != 0 && s->packet_buffer)
856                 update_initial_durations(s, st, pkt);
857         }
858     }
859
860     /* correct timestamps with byte offset if demuxers only have timestamps
861        on packet boundaries */
862     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
863         /* this will estimate bitrate based on this frame's duration and size */
864         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
865         if(pkt->pts != AV_NOPTS_VALUE)
866             pkt->pts += offset;
867         if(pkt->dts != AV_NOPTS_VALUE)
868             pkt->dts += offset;
869     }
870
871     /* This may be redundant, but it should not hurt. */
872     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
873         presentation_delayed = 1;
874
875 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
876     /* interpolate PTS and DTS if they are not present */
877     if(delay==0 || (delay==1 && pc)){
878         if (presentation_delayed) {
879             /* DTS = decompression timestamp */
880             /* PTS = presentation timestamp */
881             if (pkt->dts == AV_NOPTS_VALUE)
882                 pkt->dts = st->last_IP_pts;
883             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
884             if (pkt->dts == AV_NOPTS_VALUE)
885                 pkt->dts = st->cur_dts;
886
887             /* this is tricky: the dts must be incremented by the duration
888             of the frame we are displaying, i.e. the last I- or P-frame */
889             if (st->last_IP_duration == 0)
890                 st->last_IP_duration = pkt->duration;
891             if(pkt->dts != AV_NOPTS_VALUE)
892                 st->cur_dts = pkt->dts + st->last_IP_duration;
893             st->last_IP_duration  = pkt->duration;
894             st->last_IP_pts= pkt->pts;
895             /* cannot compute PTS if not present (we can compute it only
896             by knowing the future */
897         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
898             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
899                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
900                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
901                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
902                     pkt->pts += pkt->duration;
903     //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
904                 }
905             }
906
907             /* presentation is not delayed : PTS and DTS are the same */
908             if(pkt->pts == AV_NOPTS_VALUE)
909                 pkt->pts = pkt->dts;
910             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
911             if(pkt->pts == AV_NOPTS_VALUE)
912                 pkt->pts = st->cur_dts;
913             pkt->dts = pkt->pts;
914             if(pkt->pts != AV_NOPTS_VALUE)
915                 st->cur_dts = pkt->pts + pkt->duration;
916         }
917     }
918
919     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
920         st->pts_buffer[0]= pkt->pts;
921         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
922             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
923         if(pkt->dts == AV_NOPTS_VALUE)
924             pkt->dts= st->pts_buffer[0];
925         if(delay>1){
926             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
927         }
928         if(pkt->dts > st->cur_dts)
929             st->cur_dts = pkt->dts;
930     }
931
932 //    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
933
934     /* update flags */
935     if(is_intra_only(st->codec))
936         pkt->flags |= PKT_FLAG_KEY;
937     else if (pc) {
938         pkt->flags = 0;
939         /* keyframe computation */
940             if (pc->pict_type == FF_I_TYPE)
941                 pkt->flags |= PKT_FLAG_KEY;
942     }
943 }
944
945 void av_destruct_packet_nofree(AVPacket *pkt)
946 {
947     pkt->data = NULL; pkt->size = 0;
948 }
949
950 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
951 {
952     AVStream *st;
953     int len, ret, i;
954
955     av_init_packet(pkt);
956
957     for(;;) {
958         /* select current input stream component */
959         st = s->cur_st;
960         if (st) {
961             if (!st->need_parsing || !st->parser) {
962                 /* no parsing needed: we just output the packet as is */
963                 /* raw data support */
964                 *pkt = s->cur_pkt;
965                 compute_pkt_fields(s, st, NULL, pkt);
966                 s->cur_st = NULL;
967                 break;
968             } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
969                 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
970                                       s->cur_ptr, s->cur_len,
971                                       s->cur_pkt.pts, s->cur_pkt.dts);
972                 s->cur_pkt.pts = AV_NOPTS_VALUE;
973                 s->cur_pkt.dts = AV_NOPTS_VALUE;
974                 /* increment read pointer */
975                 s->cur_ptr += len;
976                 s->cur_len -= len;
977
978                 /* return packet if any */
979                 if (pkt->size) {
980                 got_packet:
981                     pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
982                     pkt->duration = 0;
983                     pkt->stream_index = st->index;
984                     pkt->pts = st->parser->pts;
985                     pkt->dts = st->parser->dts;
986                     pkt->destruct = av_destruct_packet_nofree;
987                     compute_pkt_fields(s, st, st->parser, pkt);
988
989                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
990                         ff_reduce_index(s, st->index);
991                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
992                                            0, 0, AVINDEX_KEYFRAME);
993                     }
994
995                     break;
996                 }
997             } else {
998                 /* free packet */
999                 av_free_packet(&s->cur_pkt);
1000                 s->cur_st = NULL;
1001             }
1002         } else {
1003             /* read next packet */
1004             ret = av_read_packet(s, &s->cur_pkt);
1005             if (ret < 0) {
1006                 if (ret == AVERROR(EAGAIN))
1007                     return ret;
1008                 /* return the last frames, if any */
1009                 for(i = 0; i < s->nb_streams; i++) {
1010                     st = s->streams[i];
1011                     if (st->parser && st->need_parsing) {
1012                         av_parser_parse(st->parser, st->codec,
1013                                         &pkt->data, &pkt->size,
1014                                         NULL, 0,
1015                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1016                         if (pkt->size)
1017                             goto got_packet;
1018                     }
1019                 }
1020                 /* no more packets: really terminate parsing */
1021                 return ret;
1022             }
1023
1024             if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
1025                s->cur_pkt.dts != AV_NOPTS_VALUE &&
1026                s->cur_pkt.pts < s->cur_pkt.dts){
1027                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1028                     s->cur_pkt.stream_index,
1029                     s->cur_pkt.pts,
1030                     s->cur_pkt.dts,
1031                     s->cur_pkt.size);
1032 //                av_free_packet(&s->cur_pkt);
1033 //                return -1;
1034             }
1035
1036             st = s->streams[s->cur_pkt.stream_index];
1037             if(s->debug & FF_FDEBUG_TS)
1038                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1039                     s->cur_pkt.stream_index,
1040                     s->cur_pkt.pts,
1041                     s->cur_pkt.dts,
1042                     s->cur_pkt.size,
1043                     s->cur_pkt.flags);
1044
1045             s->cur_st = st;
1046             s->cur_ptr = s->cur_pkt.data;
1047             s->cur_len = s->cur_pkt.size;
1048             if (st->need_parsing && !st->parser) {
1049                 st->parser = av_parser_init(st->codec->codec_id);
1050                 if (!st->parser) {
1051                     /* no parser available: just output the raw packets */
1052                     st->need_parsing = AVSTREAM_PARSE_NONE;
1053                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1054                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1055                 }
1056                 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1057                     st->parser->next_frame_offset=
1058                     st->parser->cur_offset= s->cur_pkt.pos;
1059                 }
1060             }
1061         }
1062     }
1063     if(s->debug & FF_FDEBUG_TS)
1064         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1065             pkt->stream_index,
1066             pkt->pts,
1067             pkt->dts,
1068             pkt->size,
1069             pkt->flags);
1070
1071     return 0;
1072 }
1073
1074 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1075 {
1076     AVPacketList *pktl;
1077     int eof=0;
1078     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1079
1080     for(;;){
1081         pktl = s->packet_buffer;
1082         if (pktl) {
1083             AVPacket *next_pkt= &pktl->pkt;
1084
1085             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1086                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1087                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1088                        && next_pkt->dts < pktl->pkt.dts
1089                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
1090                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1091                         next_pkt->pts= pktl->pkt.dts;
1092                     }
1093                     pktl= pktl->next;
1094                 }
1095                 pktl = s->packet_buffer;
1096             }
1097
1098             if(   next_pkt->pts != AV_NOPTS_VALUE
1099                || next_pkt->dts == AV_NOPTS_VALUE
1100                || !genpts || eof){
1101                 /* read packet from packet buffer, if there is data */
1102                 *pkt = *next_pkt;
1103                 s->packet_buffer = pktl->next;
1104                 av_free(pktl);
1105                 return 0;
1106             }
1107         }
1108         if(genpts){
1109             int ret= av_read_frame_internal(s, pkt);
1110             if(ret<0){
1111                 if(pktl && ret != AVERROR(EAGAIN)){
1112                     eof=1;
1113                     continue;
1114                 }else
1115                     return ret;
1116             }
1117
1118             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1119                                            &s->packet_buffer_end)) < 0)
1120                 return AVERROR(ENOMEM);
1121         }else{
1122             assert(!s->packet_buffer);
1123             return av_read_frame_internal(s, pkt);
1124         }
1125     }
1126 }
1127
1128 /* XXX: suppress the packet queue */
1129 static void flush_packet_queue(AVFormatContext *s)
1130 {
1131     AVPacketList *pktl;
1132
1133     for(;;) {
1134         pktl = s->packet_buffer;
1135         if (!pktl)
1136             break;
1137         s->packet_buffer = pktl->next;
1138         av_free_packet(&pktl->pkt);
1139         av_free(pktl);
1140     }
1141 }
1142
1143 /*******************************************************/
1144 /* seek support */
1145
1146 int av_find_default_stream_index(AVFormatContext *s)
1147 {
1148     int first_audio_index = -1;
1149     int i;
1150     AVStream *st;
1151
1152     if (s->nb_streams <= 0)
1153         return -1;
1154     for(i = 0; i < s->nb_streams; i++) {
1155         st = s->streams[i];
1156         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1157             return i;
1158         }
1159         if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1160             first_audio_index = i;
1161     }
1162     return first_audio_index >= 0 ? first_audio_index : 0;
1163 }
1164
1165 /**
1166  * Flush the frame reader.
1167  */
1168 static void av_read_frame_flush(AVFormatContext *s)
1169 {
1170     AVStream *st;
1171     int i;
1172
1173     flush_packet_queue(s);
1174
1175     /* free previous packet */
1176     if (s->cur_st) {
1177         if (s->cur_st->parser)
1178             av_free_packet(&s->cur_pkt);
1179         s->cur_st = NULL;
1180     }
1181     /* fail safe */
1182     s->cur_ptr = NULL;
1183     s->cur_len = 0;
1184
1185     /* for each stream, reset read state */
1186     for(i = 0; i < s->nb_streams; i++) {
1187         st = s->streams[i];
1188
1189         if (st->parser) {
1190             av_parser_close(st->parser);
1191             st->parser = NULL;
1192         }
1193         st->last_IP_pts = AV_NOPTS_VALUE;
1194         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1195     }
1196 }
1197
1198 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1199     int i;
1200
1201     for(i = 0; i < s->nb_streams; i++) {
1202         AVStream *st = s->streams[i];
1203
1204         st->cur_dts = av_rescale(timestamp,
1205                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1206                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1207     }
1208 }
1209
1210 void ff_reduce_index(AVFormatContext *s, int stream_index)
1211 {
1212     AVStream *st= s->streams[stream_index];
1213     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1214
1215     if((unsigned)st->nb_index_entries >= max_entries){
1216         int i;
1217         for(i=0; 2*i<st->nb_index_entries; i++)
1218             st->index_entries[i]= st->index_entries[2*i];
1219         st->nb_index_entries= i;
1220     }
1221 }
1222
1223 int av_add_index_entry(AVStream *st,
1224                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1225 {
1226     AVIndexEntry *entries, *ie;
1227     int index;
1228
1229     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1230         return -1;
1231
1232     entries = av_fast_realloc(st->index_entries,
1233                               &st->index_entries_allocated_size,
1234                               (st->nb_index_entries + 1) *
1235                               sizeof(AVIndexEntry));
1236     if(!entries)
1237         return -1;
1238
1239     st->index_entries= entries;
1240
1241     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1242
1243     if(index<0){
1244         index= st->nb_index_entries++;
1245         ie= &entries[index];
1246         assert(index==0 || ie[-1].timestamp < timestamp);
1247     }else{
1248         ie= &entries[index];
1249         if(ie->timestamp != timestamp){
1250             if(ie->timestamp <= timestamp)
1251                 return -1;
1252             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1253             st->nb_index_entries++;
1254         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1255             distance= ie->min_distance;
1256     }
1257
1258     ie->pos = pos;
1259     ie->timestamp = timestamp;
1260     ie->min_distance= distance;
1261     ie->size= size;
1262     ie->flags = flags;
1263
1264     return index;
1265 }
1266
1267 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1268                               int flags)
1269 {
1270     AVIndexEntry *entries= st->index_entries;
1271     int nb_entries= st->nb_index_entries;
1272     int a, b, m;
1273     int64_t timestamp;
1274
1275     a = - 1;
1276     b = nb_entries;
1277
1278     while (b - a > 1) {
1279         m = (a + b) >> 1;
1280         timestamp = entries[m].timestamp;
1281         if(timestamp >= wanted_timestamp)
1282             b = m;
1283         if(timestamp <= wanted_timestamp)
1284             a = m;
1285     }
1286     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1287
1288     if(!(flags & AVSEEK_FLAG_ANY)){
1289         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1290             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1291         }
1292     }
1293
1294     if(m == nb_entries)
1295         return -1;
1296     return  m;
1297 }
1298
1299 #define DEBUG_SEEK
1300
1301 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1302     AVInputFormat *avif= s->iformat;
1303     int64_t pos_min, pos_max, pos, pos_limit;
1304     int64_t ts_min, ts_max, ts;
1305     int index;
1306     AVStream *st;
1307
1308     if (stream_index < 0)
1309         return -1;
1310
1311 #ifdef DEBUG_SEEK
1312     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1313 #endif
1314
1315     ts_max=
1316     ts_min= AV_NOPTS_VALUE;
1317     pos_limit= -1; //gcc falsely says it may be uninitialized
1318
1319     st= s->streams[stream_index];
1320     if(st->index_entries){
1321         AVIndexEntry *e;
1322
1323         index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1324         index= FFMAX(index, 0);
1325         e= &st->index_entries[index];
1326
1327         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1328             pos_min= e->pos;
1329             ts_min= e->timestamp;
1330 #ifdef DEBUG_SEEK
1331         av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1332                pos_min,ts_min);
1333 #endif
1334         }else{
1335             assert(index==0);
1336         }
1337
1338         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1339         assert(index < st->nb_index_entries);
1340         if(index >= 0){
1341             e= &st->index_entries[index];
1342             assert(e->timestamp >= target_ts);
1343             pos_max= e->pos;
1344             ts_max= e->timestamp;
1345             pos_limit= pos_max - e->min_distance;
1346 #ifdef DEBUG_SEEK
1347         av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1348                pos_max,pos_limit, ts_max);
1349 #endif
1350         }
1351     }
1352
1353     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1354     if(pos<0)
1355         return -1;
1356
1357     /* do the seek */
1358     url_fseek(s->pb, pos, SEEK_SET);
1359
1360     av_update_cur_dts(s, st, ts);
1361
1362     return 0;
1363 }
1364
1365 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1366     int64_t pos, ts;
1367     int64_t start_pos, filesize;
1368     int no_change;
1369
1370 #ifdef DEBUG_SEEK
1371     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1372 #endif
1373
1374     if(ts_min == AV_NOPTS_VALUE){
1375         pos_min = s->data_offset;
1376         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1377         if (ts_min == AV_NOPTS_VALUE)
1378             return -1;
1379     }
1380
1381     if(ts_max == AV_NOPTS_VALUE){
1382         int step= 1024;
1383         filesize = url_fsize(s->pb);
1384         pos_max = filesize - 1;
1385         do{
1386             pos_max -= step;
1387             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1388             step += step;
1389         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1390         if (ts_max == AV_NOPTS_VALUE)
1391             return -1;
1392
1393         for(;;){
1394             int64_t tmp_pos= pos_max + 1;
1395             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1396             if(tmp_ts == AV_NOPTS_VALUE)
1397                 break;
1398             ts_max= tmp_ts;
1399             pos_max= tmp_pos;
1400             if(tmp_pos >= filesize)
1401                 break;
1402         }
1403         pos_limit= pos_max;
1404     }
1405
1406     if(ts_min > ts_max){
1407         return -1;
1408     }else if(ts_min == ts_max){
1409         pos_limit= pos_min;
1410     }
1411
1412     no_change=0;
1413     while (pos_min < pos_limit) {
1414 #ifdef DEBUG_SEEK
1415         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1416                pos_min, pos_max,
1417                ts_min, ts_max);
1418 #endif
1419         assert(pos_limit <= pos_max);
1420
1421         if(no_change==0){
1422             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1423             // interpolate position (better than dichotomy)
1424             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1425                 + pos_min - approximate_keyframe_distance;
1426         }else if(no_change==1){
1427             // bisection, if interpolation failed to change min or max pos last time
1428             pos = (pos_min + pos_limit)>>1;
1429         }else{
1430             /* linear search if bisection failed, can only happen if there
1431                are very few or no keyframes between min/max */
1432             pos=pos_min;
1433         }
1434         if(pos <= pos_min)
1435             pos= pos_min + 1;
1436         else if(pos > pos_limit)
1437             pos= pos_limit;
1438         start_pos= pos;
1439
1440         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1441         if(pos == pos_max)
1442             no_change++;
1443         else
1444             no_change=0;
1445 #ifdef DEBUG_SEEK
1446 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1447 #endif
1448         if(ts == AV_NOPTS_VALUE){
1449             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1450             return -1;
1451         }
1452         assert(ts != AV_NOPTS_VALUE);
1453         if (target_ts <= ts) {
1454             pos_limit = start_pos - 1;
1455             pos_max = pos;
1456             ts_max = ts;
1457         }
1458         if (target_ts >= ts) {
1459             pos_min = pos;
1460             ts_min = ts;
1461         }
1462     }
1463
1464     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1465     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1466 #ifdef DEBUG_SEEK
1467     pos_min = pos;
1468     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1469     pos_min++;
1470     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1471     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1472            pos, ts_min, target_ts, ts_max);
1473 #endif
1474     *ts_ret= ts;
1475     return pos;
1476 }
1477
1478 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1479     int64_t pos_min, pos_max;
1480 #if 0
1481     AVStream *st;
1482
1483     if (stream_index < 0)
1484         return -1;
1485
1486     st= s->streams[stream_index];
1487 #endif
1488
1489     pos_min = s->data_offset;
1490     pos_max = url_fsize(s->pb) - 1;
1491
1492     if     (pos < pos_min) pos= pos_min;
1493     else if(pos > pos_max) pos= pos_max;
1494
1495     url_fseek(s->pb, pos, SEEK_SET);
1496
1497 #if 0
1498     av_update_cur_dts(s, st, ts);
1499 #endif
1500     return 0;
1501 }
1502
1503 static int av_seek_frame_generic(AVFormatContext *s,
1504                                  int stream_index, int64_t timestamp, int flags)
1505 {
1506     int index, ret;
1507     AVStream *st;
1508     AVIndexEntry *ie;
1509
1510     st = s->streams[stream_index];
1511
1512     index = av_index_search_timestamp(st, timestamp, flags);
1513
1514     if(index < 0 || index==st->nb_index_entries-1){
1515         int i;
1516         AVPacket pkt;
1517
1518         if(st->nb_index_entries){
1519             assert(st->index_entries);
1520             ie= &st->index_entries[st->nb_index_entries-1];
1521             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1522                 return ret;
1523             av_update_cur_dts(s, st, ie->timestamp);
1524         }else{
1525             if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1526                 return ret;
1527         }
1528         for(i=0;; i++) {
1529             int ret = av_read_frame(s, &pkt);
1530             if(ret<0)
1531                 break;
1532             av_free_packet(&pkt);
1533             if(stream_index == pkt.stream_index){
1534                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1535                     break;
1536             }
1537         }
1538         index = av_index_search_timestamp(st, timestamp, flags);
1539     }
1540     if (index < 0)
1541         return -1;
1542
1543     av_read_frame_flush(s);
1544     if (s->iformat->read_seek){
1545         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1546             return 0;
1547     }
1548     ie = &st->index_entries[index];
1549     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1550         return ret;
1551     av_update_cur_dts(s, st, ie->timestamp);
1552
1553     return 0;
1554 }
1555
1556 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1557 {
1558     int ret;
1559     AVStream *st;
1560
1561     av_read_frame_flush(s);
1562
1563     if(flags & AVSEEK_FLAG_BYTE)
1564         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1565
1566     if(stream_index < 0){
1567         stream_index= av_find_default_stream_index(s);
1568         if(stream_index < 0)
1569             return -1;
1570
1571         st= s->streams[stream_index];
1572        /* timestamp for default must be expressed in AV_TIME_BASE units */
1573         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1574     }
1575
1576     /* first, we try the format specific seek */
1577     if (s->iformat->read_seek)
1578         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1579     else
1580         ret = -1;
1581     if (ret >= 0) {
1582         return 0;
1583     }
1584
1585     if(s->iformat->read_timestamp)
1586         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1587     else
1588         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1589 }
1590
1591 /*******************************************************/
1592
1593 /**
1594  * Returns TRUE if the stream has accurate duration in any stream.
1595  *
1596  * @return TRUE if the stream has accurate duration for at least one component.
1597  */
1598 static int av_has_duration(AVFormatContext *ic)
1599 {
1600     int i;
1601     AVStream *st;
1602
1603     for(i = 0;i < ic->nb_streams; i++) {
1604         st = ic->streams[i];
1605         if (st->duration != AV_NOPTS_VALUE)
1606             return 1;
1607     }
1608     return 0;
1609 }
1610
1611 /**
1612  * Estimate the stream timings from the one of each components.
1613  *
1614  * Also computes the global bitrate if possible.
1615  */
1616 static void av_update_stream_timings(AVFormatContext *ic)
1617 {
1618     int64_t start_time, start_time1, end_time, end_time1;
1619     int64_t duration, duration1;
1620     int i;
1621     AVStream *st;
1622
1623     start_time = INT64_MAX;
1624     end_time = INT64_MIN;
1625     duration = INT64_MIN;
1626     for(i = 0;i < ic->nb_streams; i++) {
1627         st = ic->streams[i];
1628         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1629             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1630             if (start_time1 < start_time)
1631                 start_time = start_time1;
1632             if (st->duration != AV_NOPTS_VALUE) {
1633                 end_time1 = start_time1
1634                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1635                 if (end_time1 > end_time)
1636                     end_time = end_time1;
1637             }
1638         }
1639         if (st->duration != AV_NOPTS_VALUE) {
1640             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1641             if (duration1 > duration)
1642                 duration = duration1;
1643         }
1644     }
1645     if (start_time != INT64_MAX) {
1646         ic->start_time = start_time;
1647         if (end_time != INT64_MIN) {
1648             if (end_time - start_time > duration)
1649                 duration = end_time - start_time;
1650         }
1651     }
1652     if (duration != INT64_MIN) {
1653         ic->duration = duration;
1654         if (ic->file_size > 0) {
1655             /* compute the bitrate */
1656             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1657                 (double)ic->duration;
1658         }
1659     }
1660 }
1661
1662 static void fill_all_stream_timings(AVFormatContext *ic)
1663 {
1664     int i;
1665     AVStream *st;
1666
1667     av_update_stream_timings(ic);
1668     for(i = 0;i < ic->nb_streams; i++) {
1669         st = ic->streams[i];
1670         if (st->start_time == AV_NOPTS_VALUE) {
1671             if(ic->start_time != AV_NOPTS_VALUE)
1672                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1673             if(ic->duration != AV_NOPTS_VALUE)
1674                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1675         }
1676     }
1677 }
1678
1679 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1680 {
1681     int64_t filesize, duration;
1682     int bit_rate, i;
1683     AVStream *st;
1684
1685     /* if bit_rate is already set, we believe it */
1686     if (ic->bit_rate == 0) {
1687         bit_rate = 0;
1688         for(i=0;i<ic->nb_streams;i++) {
1689             st = ic->streams[i];
1690             bit_rate += st->codec->bit_rate;
1691         }
1692         ic->bit_rate = bit_rate;
1693     }
1694
1695     /* if duration is already set, we believe it */
1696     if (ic->duration == AV_NOPTS_VALUE &&
1697         ic->bit_rate != 0 &&
1698         ic->file_size != 0)  {
1699         filesize = ic->file_size;
1700         if (filesize > 0) {
1701             for(i = 0; i < ic->nb_streams; i++) {
1702                 st = ic->streams[i];
1703                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1704                 if (st->duration == AV_NOPTS_VALUE)
1705                     st->duration = duration;
1706             }
1707         }
1708     }
1709 }
1710
1711 #define DURATION_MAX_READ_SIZE 250000
1712
1713 /* only usable for MPEG-PS streams */
1714 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1715 {
1716     AVPacket pkt1, *pkt = &pkt1;
1717     AVStream *st;
1718     int read_size, i, ret;
1719     int64_t end_time;
1720     int64_t filesize, offset, duration;
1721
1722     /* free previous packet */
1723     if (ic->cur_st && ic->cur_st->parser)
1724         av_free_packet(&ic->cur_pkt);
1725     ic->cur_st = NULL;
1726
1727     /* flush packet queue */
1728     flush_packet_queue(ic);
1729
1730     for(i=0;i<ic->nb_streams;i++) {
1731         st = ic->streams[i];
1732         if (st->parser) {
1733             av_parser_close(st->parser);
1734             st->parser= NULL;
1735         }
1736     }
1737
1738     /* we read the first packets to get the first PTS (not fully
1739        accurate, but it is enough now) */
1740     url_fseek(ic->pb, 0, SEEK_SET);
1741     read_size = 0;
1742     for(;;) {
1743         if (read_size >= DURATION_MAX_READ_SIZE)
1744             break;
1745         /* if all info is available, we can stop */
1746         for(i = 0;i < ic->nb_streams; i++) {
1747             st = ic->streams[i];
1748             if (st->start_time == AV_NOPTS_VALUE)
1749                 break;
1750         }
1751         if (i == ic->nb_streams)
1752             break;
1753
1754         ret = av_read_packet(ic, pkt);
1755         if (ret != 0)
1756             break;
1757         read_size += pkt->size;
1758         st = ic->streams[pkt->stream_index];
1759         if (pkt->pts != AV_NOPTS_VALUE) {
1760             if (st->start_time == AV_NOPTS_VALUE)
1761                 st->start_time = pkt->pts;
1762         }
1763         av_free_packet(pkt);
1764     }
1765
1766     /* estimate the end time (duration) */
1767     /* XXX: may need to support wrapping */
1768     filesize = ic->file_size;
1769     offset = filesize - DURATION_MAX_READ_SIZE;
1770     if (offset < 0)
1771         offset = 0;
1772
1773     url_fseek(ic->pb, offset, SEEK_SET);
1774     read_size = 0;
1775     for(;;) {
1776         if (read_size >= DURATION_MAX_READ_SIZE)
1777             break;
1778
1779         ret = av_read_packet(ic, pkt);
1780         if (ret != 0)
1781             break;
1782         read_size += pkt->size;
1783         st = ic->streams[pkt->stream_index];
1784         if (pkt->pts != AV_NOPTS_VALUE &&
1785             st->start_time != AV_NOPTS_VALUE) {
1786             end_time = pkt->pts;
1787             duration = end_time - st->start_time;
1788             if (duration > 0) {
1789                 if (st->duration == AV_NOPTS_VALUE ||
1790                     st->duration < duration)
1791                     st->duration = duration;
1792             }
1793         }
1794         av_free_packet(pkt);
1795     }
1796
1797     fill_all_stream_timings(ic);
1798
1799     url_fseek(ic->pb, old_offset, SEEK_SET);
1800     for(i=0; i<ic->nb_streams; i++){
1801         st= ic->streams[i];
1802         st->cur_dts= st->first_dts;
1803         st->last_IP_pts = AV_NOPTS_VALUE;
1804     }
1805 }
1806
1807 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1808 {
1809     int64_t file_size;
1810
1811     /* get the file size, if possible */
1812     if (ic->iformat->flags & AVFMT_NOFILE) {
1813         file_size = 0;
1814     } else {
1815         file_size = url_fsize(ic->pb);
1816         if (file_size < 0)
1817             file_size = 0;
1818     }
1819     ic->file_size = file_size;
1820
1821     if ((!strcmp(ic->iformat->name, "mpeg") ||
1822          !strcmp(ic->iformat->name, "mpegts")) &&
1823         file_size && !url_is_streamed(ic->pb)) {
1824         /* get accurate estimate from the PTSes */
1825         av_estimate_timings_from_pts(ic, old_offset);
1826     } else if (av_has_duration(ic)) {
1827         /* at least one component has timings - we use them for all
1828            the components */
1829         fill_all_stream_timings(ic);
1830     } else {
1831         /* less precise: use bitrate info */
1832         av_estimate_timings_from_bit_rate(ic);
1833     }
1834     av_update_stream_timings(ic);
1835
1836 #if 0
1837     {
1838         int i;
1839         AVStream *st;
1840         for(i = 0;i < ic->nb_streams; i++) {
1841             st = ic->streams[i];
1842         printf("%d: start_time: %0.3f duration: %0.3f\n",
1843                i, (double)st->start_time / AV_TIME_BASE,
1844                (double)st->duration / AV_TIME_BASE);
1845         }
1846         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1847                (double)ic->start_time / AV_TIME_BASE,
1848                (double)ic->duration / AV_TIME_BASE,
1849                ic->bit_rate / 1000);
1850     }
1851 #endif
1852 }
1853
1854 static int has_codec_parameters(AVCodecContext *enc)
1855 {
1856     int val;
1857     switch(enc->codec_type) {
1858     case CODEC_TYPE_AUDIO:
1859         val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1860         if(!enc->frame_size &&
1861            (enc->codec_id == CODEC_ID_VORBIS ||
1862             enc->codec_id == CODEC_ID_AAC))
1863             return 0;
1864         break;
1865     case CODEC_TYPE_VIDEO:
1866         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1867         break;
1868     default:
1869         val = 1;
1870         break;
1871     }
1872     return enc->codec_id != CODEC_ID_NONE && val != 0;
1873 }
1874
1875 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1876 {
1877     int16_t *samples;
1878     AVCodec *codec;
1879     int got_picture, data_size, ret=0;
1880     AVFrame picture;
1881
1882   if(!st->codec->codec){
1883     codec = avcodec_find_decoder(st->codec->codec_id);
1884     if (!codec)
1885         return -1;
1886     ret = avcodec_open(st->codec, codec);
1887     if (ret < 0)
1888         return ret;
1889   }
1890
1891   if(!has_codec_parameters(st->codec)){
1892     switch(st->codec->codec_type) {
1893     case CODEC_TYPE_VIDEO:
1894         ret = avcodec_decode_video(st->codec, &picture,
1895                                    &got_picture, data, size);
1896         break;
1897     case CODEC_TYPE_AUDIO:
1898         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1899         samples = av_malloc(data_size);
1900         if (!samples)
1901             goto fail;
1902         ret = avcodec_decode_audio2(st->codec, samples,
1903                                     &data_size, data, size);
1904         av_free(samples);
1905         break;
1906     default:
1907         break;
1908     }
1909   }
1910  fail:
1911     return ret;
1912 }
1913
1914 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1915 {
1916     while (tags->id != CODEC_ID_NONE) {
1917         if (tags->id == id)
1918             return tags->tag;
1919         tags++;
1920     }
1921     return 0;
1922 }
1923
1924 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1925 {
1926     int i;
1927     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1928         if(tag == tags[i].tag)
1929             return tags[i].id;
1930     }
1931     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1932         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1933            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1934            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1935            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1936             return tags[i].id;
1937     }
1938     return CODEC_ID_NONE;
1939 }
1940
1941 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1942 {
1943     int i;
1944     for(i=0; tags && tags[i]; i++){
1945         int tag= codec_get_tag(tags[i], id);
1946         if(tag) return tag;
1947     }
1948     return 0;
1949 }
1950
1951 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1952 {
1953     int i;
1954     for(i=0; tags && tags[i]; i++){
1955         enum CodecID id= codec_get_id(tags[i], tag);
1956         if(id!=CODEC_ID_NONE) return id;
1957     }
1958     return CODEC_ID_NONE;
1959 }
1960
1961 static void compute_chapters_end(AVFormatContext *s)
1962 {
1963     unsigned int i;
1964
1965     for (i=0; i+1<s->nb_chapters; i++)
1966         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1967             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1968             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1969             s->chapters[i]->end = s->chapters[i+1]->start;
1970         }
1971
1972     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1973         assert(s->start_time != AV_NOPTS_VALUE);
1974         assert(s->duration > 0);
1975         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1976                                            AV_TIME_BASE_Q,
1977                                            s->chapters[i]->time_base);
1978     }
1979 }
1980
1981 /* absolute maximum size we read until we abort */
1982 #define MAX_READ_SIZE        5000000
1983
1984 #define MAX_STD_TIMEBASES (60*12+5)
1985 static int get_std_framerate(int i){
1986     if(i<60*12) return i*1001;
1987     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1988 }
1989
1990 /*
1991  * Is the time base unreliable.
1992  * This is a heuristic to balance between quick acceptance of the values in
1993  * the headers vs. some extra checks.
1994  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1995  * MPEG-2 commonly misuses field repeat flags to store different framerates.
1996  * And there are "variable" fps files this needs to detect as well.
1997  */
1998 static int tb_unreliable(AVCodecContext *c){
1999     if(   c->time_base.den >= 101L*c->time_base.num
2000        || c->time_base.den <    5L*c->time_base.num
2001 /*       || c->codec_tag == ff_get_fourcc("DIVX")
2002        || c->codec_tag == ff_get_fourcc("XVID")*/
2003        || c->codec_id == CODEC_ID_MPEG2VIDEO)
2004         return 1;
2005     return 0;
2006 }
2007
2008 int av_find_stream_info(AVFormatContext *ic)
2009 {
2010     int i, count, ret, read_size, j;
2011     AVStream *st;
2012     AVPacket pkt1, *pkt;
2013     int64_t last_dts[MAX_STREAMS];
2014     int duration_count[MAX_STREAMS]={0};
2015     double (*duration_error)[MAX_STD_TIMEBASES];
2016     int64_t old_offset = url_ftell(ic->pb);
2017     int64_t codec_info_duration[MAX_STREAMS]={0};
2018     int codec_info_nb_frames[MAX_STREAMS]={0};
2019
2020     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2021     if (!duration_error) return AVERROR(ENOMEM);
2022
2023     for(i=0;i<ic->nb_streams;i++) {
2024         st = ic->streams[i];
2025         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2026 /*            if(!st->time_base.num)
2027                 st->time_base= */
2028             if(!st->codec->time_base.num)
2029                 st->codec->time_base= st->time_base;
2030         }
2031         //only for the split stuff
2032         if (!st->parser) {
2033             st->parser = av_parser_init(st->codec->codec_id);
2034             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2035                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2036             }
2037         }
2038     }
2039
2040     for(i=0;i<MAX_STREAMS;i++){
2041         last_dts[i]= AV_NOPTS_VALUE;
2042     }
2043
2044     count = 0;
2045     read_size = 0;
2046     for(;;) {
2047         /* check if one codec still needs to be handled */
2048         for(i=0;i<ic->nb_streams;i++) {
2049             st = ic->streams[i];
2050             if (!has_codec_parameters(st->codec))
2051                 break;
2052             /* variable fps and no guess at the real fps */
2053             if(   tb_unreliable(st->codec)
2054                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2055                 break;
2056             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2057                 break;
2058             if(st->first_dts == AV_NOPTS_VALUE)
2059                 break;
2060         }
2061         if (i == ic->nb_streams) {
2062             /* NOTE: if the format has no header, then we need to read
2063                some packets to get most of the streams, so we cannot
2064                stop here */
2065             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2066                 /* if we found the info for all the codecs, we can stop */
2067                 ret = count;
2068                 break;
2069             }
2070         }
2071         /* we did not get all the codec info, but we read too much data */
2072         if (read_size >= MAX_READ_SIZE) {
2073             ret = count;
2074             break;
2075         }
2076
2077         /* NOTE: a new stream can be added there if no header in file
2078            (AVFMTCTX_NOHEADER) */
2079         ret = av_read_frame_internal(ic, &pkt1);
2080         if (ret < 0) {
2081             /* EOF or error */
2082             ret = -1; /* we could not have all the codec parameters before EOF */
2083             for(i=0;i<ic->nb_streams;i++) {
2084                 st = ic->streams[i];
2085                 if (!has_codec_parameters(st->codec)){
2086                     char buf[256];
2087                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2088                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2089                 } else {
2090                     ret = 0;
2091                 }
2092             }
2093             break;
2094         }
2095
2096         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2097         if(av_dup_packet(pkt) < 0) {
2098             av_free(duration_error);
2099             return AVERROR(ENOMEM);
2100         }
2101
2102         read_size += pkt->size;
2103
2104         st = ic->streams[pkt->stream_index];
2105         if(codec_info_nb_frames[st->index]>1)
2106             codec_info_duration[st->index] += pkt->duration;
2107         if (pkt->duration != 0)
2108             codec_info_nb_frames[st->index]++;
2109
2110         {
2111             int index= pkt->stream_index;
2112             int64_t last= last_dts[index];
2113             int64_t duration= pkt->dts - last;
2114
2115             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2116                 double dur= duration * av_q2d(st->time_base);
2117
2118 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2119 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2120                 if(duration_count[index] < 2)
2121                     memset(duration_error[index], 0, sizeof(*duration_error));
2122                 for(i=1; i<MAX_STD_TIMEBASES; i++){
2123                     int framerate= get_std_framerate(i);
2124                     int ticks= lrintf(dur*framerate/(1001*12));
2125                     double error= dur - ticks*1001*12/(double)framerate;
2126                     duration_error[index][i] += error*error;
2127                 }
2128                 duration_count[index]++;
2129             }
2130             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2131                 last_dts[pkt->stream_index]= pkt->dts;
2132         }
2133         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2134             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2135             if(i){
2136                 st->codec->extradata_size= i;
2137                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2138                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2139                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2140             }
2141         }
2142
2143         /* if still no information, we try to open the codec and to
2144            decompress the frame. We try to avoid that in most cases as
2145            it takes longer and uses more memory. For MPEG-4, we need to
2146            decompress for QuickTime. */
2147         if (!has_codec_parameters(st->codec) /*&&
2148             (st->codec->codec_id == CODEC_ID_FLV1 ||
2149              st->codec->codec_id == CODEC_ID_H264 ||
2150              st->codec->codec_id == CODEC_ID_H263 ||
2151              st->codec->codec_id == CODEC_ID_H261 ||
2152              st->codec->codec_id == CODEC_ID_VORBIS ||
2153              st->codec->codec_id == CODEC_ID_MJPEG ||
2154              st->codec->codec_id == CODEC_ID_PNG ||
2155              st->codec->codec_id == CODEC_ID_PAM ||
2156              st->codec->codec_id == CODEC_ID_PGM ||
2157              st->codec->codec_id == CODEC_ID_PGMYUV ||
2158              st->codec->codec_id == CODEC_ID_PBM ||
2159              st->codec->codec_id == CODEC_ID_PPM ||
2160              st->codec->codec_id == CODEC_ID_SHORTEN ||
2161              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2162             try_decode_frame(st, pkt->data, pkt->size);
2163
2164         if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2165             break;
2166         }
2167         count++;
2168     }
2169
2170     // close codecs which were opened in try_decode_frame()
2171     for(i=0;i<ic->nb_streams;i++) {
2172         st = ic->streams[i];
2173         if(st->codec->codec)
2174             avcodec_close(st->codec);
2175     }
2176     for(i=0;i<ic->nb_streams;i++) {
2177         st = ic->streams[i];
2178         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2179             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2180                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2181
2182             if(duration_count[i]
2183                && tb_unreliable(st->codec) /*&&
2184                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2185                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2186                 double best_error= 2*av_q2d(st->time_base);
2187                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2188
2189                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2190                     double error= duration_error[i][j] * get_std_framerate(j);
2191 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2192 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2193                     if(error < best_error){
2194                         best_error= error;
2195                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2196                     }
2197                 }
2198             }
2199
2200             if (!st->r_frame_rate.num){
2201                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2202                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
2203                     st->r_frame_rate.num = st->codec->time_base.den;
2204                     st->r_frame_rate.den = st->codec->time_base.num;
2205                 }else{
2206                     st->r_frame_rate.num = st->time_base.den;
2207                     st->r_frame_rate.den = st->time_base.num;
2208                 }
2209             }
2210         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2211             if(!st->codec->bits_per_coded_sample)
2212                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2213         }
2214     }
2215
2216     av_estimate_timings(ic, old_offset);
2217
2218     compute_chapters_end(ic);
2219
2220 #if 0
2221     /* correct DTS for B-frame streams with no timestamps */
2222     for(i=0;i<ic->nb_streams;i++) {
2223         st = ic->streams[i];
2224         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2225             if(b-frames){
2226                 ppktl = &ic->packet_buffer;
2227                 while(ppkt1){
2228                     if(ppkt1->stream_index != i)
2229                         continue;
2230                     if(ppkt1->pkt->dts < 0)
2231                         break;
2232                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2233                         break;
2234                     ppkt1->pkt->dts -= delta;
2235                     ppkt1= ppkt1->next;
2236                 }
2237                 if(ppkt1)
2238                     continue;
2239                 st->cur_dts -= delta;
2240             }
2241         }
2242     }
2243 #endif
2244
2245     av_free(duration_error);
2246
2247     return ret;
2248 }
2249
2250 /*******************************************************/
2251
2252 int av_read_play(AVFormatContext *s)
2253 {
2254     if (s->iformat->read_play)
2255         return s->iformat->read_play(s);
2256     if (s->pb)
2257         return av_url_read_fpause(s->pb, 0);
2258     return AVERROR(ENOSYS);
2259 }
2260
2261 int av_read_pause(AVFormatContext *s)
2262 {
2263     if (s->iformat->read_pause)
2264         return s->iformat->read_pause(s);
2265     if (s->pb)
2266         return av_url_read_fpause(s->pb, 1);
2267     return AVERROR(ENOSYS);
2268 }
2269
2270 void av_close_input_stream(AVFormatContext *s)
2271 {
2272     int i;
2273     AVStream *st;
2274
2275     /* free previous packet */
2276     if (s->cur_st && s->cur_st->parser)
2277         av_free_packet(&s->cur_pkt);
2278
2279     if (s->iformat->read_close)
2280         s->iformat->read_close(s);
2281     for(i=0;i<s->nb_streams;i++) {
2282         /* free all data in a stream component */
2283         st = s->streams[i];
2284         if (st->parser) {
2285             av_parser_close(st->parser);
2286         }
2287         av_free(st->index_entries);
2288         av_free(st->codec->extradata);
2289         av_free(st->codec);
2290         av_free(st->filename);
2291         av_free(st->priv_data);
2292         av_free(st);
2293     }
2294     for(i=s->nb_programs-1; i>=0; i--) {
2295         av_freep(&s->programs[i]->provider_name);
2296         av_freep(&s->programs[i]->name);
2297         av_freep(&s->programs[i]->stream_index);
2298         av_freep(&s->programs[i]);
2299     }
2300     av_freep(&s->programs);
2301     flush_packet_queue(s);
2302     av_freep(&s->priv_data);
2303     while(s->nb_chapters--) {
2304         av_free(s->chapters[s->nb_chapters]->title);
2305         av_free(s->chapters[s->nb_chapters]);
2306     }
2307     av_freep(&s->chapters);
2308     av_free(s);
2309 }
2310
2311 void av_close_input_file(AVFormatContext *s)
2312 {
2313     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2314     av_close_input_stream(s);
2315     if (pb)
2316         url_fclose(pb);
2317 }
2318
2319 AVStream *av_new_stream(AVFormatContext *s, int id)
2320 {
2321     AVStream *st;
2322     int i;
2323
2324     if (s->nb_streams >= MAX_STREAMS)
2325         return NULL;
2326
2327     st = av_mallocz(sizeof(AVStream));
2328     if (!st)
2329         return NULL;
2330
2331     st->codec= avcodec_alloc_context();
2332     if (s->iformat) {
2333         /* no default bitrate if decoding */
2334         st->codec->bit_rate = 0;
2335     }
2336     st->index = s->nb_streams;
2337     st->id = id;
2338     st->start_time = AV_NOPTS_VALUE;
2339     st->duration = AV_NOPTS_VALUE;
2340         /* we set the current DTS to 0 so that formats without any timestamps
2341            but durations get some timestamps, formats with some unknown
2342            timestamps have their first few packets buffered and the
2343            timestamps corrected before they are returned to the user */
2344     st->cur_dts = 0;
2345     st->first_dts = AV_NOPTS_VALUE;
2346
2347     /* default pts setting is MPEG-like */
2348     av_set_pts_info(st, 33, 1, 90000);
2349     st->last_IP_pts = AV_NOPTS_VALUE;
2350     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2351         st->pts_buffer[i]= AV_NOPTS_VALUE;
2352
2353     st->sample_aspect_ratio = (AVRational){0,1};
2354
2355     s->streams[s->nb_streams++] = st;
2356     return st;
2357 }
2358
2359 AVProgram *av_new_program(AVFormatContext *ac, int id)
2360 {
2361     AVProgram *program=NULL;
2362     int i;
2363
2364 #ifdef DEBUG_SI
2365     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2366 #endif
2367
2368     for(i=0; i<ac->nb_programs; i++)
2369         if(ac->programs[i]->id == id)
2370             program = ac->programs[i];
2371
2372     if(!program){
2373         program = av_mallocz(sizeof(AVProgram));
2374         if (!program)
2375             return NULL;
2376         dynarray_add(&ac->programs, &ac->nb_programs, program);
2377         program->discard = AVDISCARD_NONE;
2378     }
2379     program->id = id;
2380
2381     return program;
2382 }
2383
2384 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2385 {
2386     assert(!provider_name == !name);
2387     if(name){
2388         av_free(program->provider_name);
2389         av_free(program->         name);
2390         program->provider_name = av_strdup(provider_name);
2391         program->         name = av_strdup(         name);
2392     }
2393 }
2394
2395 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2396 {
2397     AVChapter *chapter = NULL;
2398     int i;
2399
2400     for(i=0; i<s->nb_chapters; i++)
2401         if(s->chapters[i]->id == id)
2402             chapter = s->chapters[i];
2403
2404     if(!chapter){
2405         chapter= av_mallocz(sizeof(AVChapter));
2406         if(!chapter)
2407             return NULL;
2408         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2409     }
2410     av_free(chapter->title);
2411     chapter->title = av_strdup(title);
2412     chapter->id    = id;
2413     chapter->time_base= time_base;
2414     chapter->start = start;
2415     chapter->end   = end;
2416
2417     return chapter;
2418 }
2419
2420 /************************************************************/
2421 /* output media file */
2422
2423 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2424 {
2425     int ret;
2426
2427     if (s->oformat->priv_data_size > 0) {
2428         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2429         if (!s->priv_data)
2430             return AVERROR(ENOMEM);
2431     } else
2432         s->priv_data = NULL;
2433
2434     if (s->oformat->set_parameters) {
2435         ret = s->oformat->set_parameters(s, ap);
2436         if (ret < 0)
2437             return ret;
2438     }
2439     return 0;
2440 }
2441
2442 int av_write_header(AVFormatContext *s)
2443 {
2444     int ret, i;
2445     AVStream *st;
2446
2447     // some sanity checks
2448     for(i=0;i<s->nb_streams;i++) {
2449         st = s->streams[i];
2450
2451         switch (st->codec->codec_type) {
2452         case CODEC_TYPE_AUDIO:
2453             if(st->codec->sample_rate<=0){
2454                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2455                 return -1;
2456             }
2457             if(!st->codec->block_align)
2458                 st->codec->block_align = st->codec->channels *
2459                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2460             break;
2461         case CODEC_TYPE_VIDEO:
2462             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2463                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2464                 return -1;
2465             }
2466             if(st->codec->width<=0 || st->codec->height<=0){
2467                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2468                 return -1;
2469             }
2470             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2471                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2472                 return -1;
2473             }
2474             break;
2475         }
2476
2477         if(s->oformat->codec_tag){
2478             if(st->codec->codec_tag){
2479                 //FIXME
2480                 //check that tag + id is in the table
2481                 //if neither is in the table -> OK
2482                 //if tag is in the table with another id -> FAIL
2483                 //if id is in the table with another tag -> FAIL unless strict < ?
2484             }else
2485                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2486         }
2487     }
2488
2489     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2490         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2491         if (!s->priv_data)
2492             return AVERROR(ENOMEM);
2493     }
2494
2495     if(s->oformat->write_header){
2496         ret = s->oformat->write_header(s);
2497         if (ret < 0)
2498             return ret;
2499     }
2500
2501     /* init PTS generation */
2502     for(i=0;i<s->nb_streams;i++) {
2503         int64_t den = AV_NOPTS_VALUE;
2504         st = s->streams[i];
2505
2506         switch (st->codec->codec_type) {
2507         case CODEC_TYPE_AUDIO:
2508             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2509             break;
2510         case CODEC_TYPE_VIDEO:
2511             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2512             break;
2513         default:
2514             break;
2515         }
2516         if (den != AV_NOPTS_VALUE) {
2517             if (den <= 0)
2518                 return AVERROR_INVALIDDATA;
2519             av_frac_init(&st->pts, 0, 0, den);
2520         }
2521     }
2522     return 0;
2523 }
2524
2525 //FIXME merge with compute_pkt_fields
2526 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2527     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2528     int num, den, frame_size, i;
2529
2530 //    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2531
2532 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2533         return -1;*/
2534
2535     /* duration field */
2536     if (pkt->duration == 0) {
2537         compute_frame_duration(&num, &den, st, NULL, pkt);
2538         if (den && num) {
2539             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2540         }
2541     }
2542
2543     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2544         pkt->pts= pkt->dts;
2545
2546     //XXX/FIXME this is a temporary hack until all encoders output pts
2547     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2548         pkt->dts=
2549 //        pkt->pts= st->cur_dts;
2550         pkt->pts= st->pts.val;
2551     }
2552
2553     //calculate dts from pts
2554     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2555         st->pts_buffer[0]= pkt->pts;
2556         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2557             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2558         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2559             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2560
2561         pkt->dts= st->pts_buffer[0];
2562     }
2563
2564     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2565         av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2566         return -1;
2567     }
2568     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2569         av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2570         return -1;
2571     }
2572
2573 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2574     st->cur_dts= pkt->dts;
2575     st->pts.val= pkt->dts;
2576
2577     /* update pts */
2578     switch (st->codec->codec_type) {
2579     case CODEC_TYPE_AUDIO:
2580         frame_size = get_audio_frame_size(st->codec, pkt->size);
2581
2582         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2583            likely equal to the encoder delay, but it would be better if we
2584            had the real timestamps from the encoder */
2585         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2586             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2587         }
2588         break;
2589     case CODEC_TYPE_VIDEO:
2590         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2591         break;
2592     default:
2593         break;
2594     }
2595     return 0;
2596 }
2597
2598 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2599 {
2600     int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2601
2602     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2603         return ret;
2604
2605     ret= s->oformat->write_packet(s, pkt);
2606     if(!ret)
2607         ret= url_ferror(s->pb);
2608     return ret;
2609 }
2610
2611 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2612     AVPacketList *pktl, **next_point, *this_pktl;
2613     int stream_count=0;
2614     int streams[MAX_STREAMS];
2615
2616     if(pkt){
2617         AVStream *st= s->streams[ pkt->stream_index];
2618
2619 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2620
2621         this_pktl = av_mallocz(sizeof(AVPacketList));
2622         this_pktl->pkt= *pkt;
2623         if(pkt->destruct == av_destruct_packet)
2624             pkt->destruct= NULL; // not shared -> must keep original from being freed
2625         else
2626             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2627
2628         next_point = &s->packet_buffer;
2629         while(*next_point){
2630             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2631             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2632             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2633             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2634                 break;
2635             next_point= &(*next_point)->next;
2636         }
2637         this_pktl->next= *next_point;
2638         *next_point= this_pktl;
2639     }
2640
2641     memset(streams, 0, sizeof(streams));
2642     pktl= s->packet_buffer;
2643     while(pktl){
2644 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2645         if(streams[ pktl->pkt.stream_index ] == 0)
2646             stream_count++;
2647         streams[ pktl->pkt.stream_index ]++;
2648         pktl= pktl->next;
2649     }
2650
2651     if(stream_count && (s->nb_streams == stream_count || flush)){
2652         pktl= s->packet_buffer;
2653         *out= pktl->pkt;
2654
2655         s->packet_buffer= pktl->next;
2656         av_freep(&pktl);
2657         return 1;
2658     }else{
2659         av_init_packet(out);
2660         return 0;
2661     }
2662 }
2663
2664 /**
2665  * Interleaves an AVPacket correctly so it can be muxed.
2666  * @param out the interleaved packet will be output here
2667  * @param in the input packet
2668  * @param flush 1 if no further packets are available as input and all
2669  *              remaining packets should be output
2670  * @return 1 if a packet was output, 0 if no packet could be output,
2671  *         < 0 if an error occurred
2672  */
2673 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2674     if(s->oformat->interleave_packet)
2675         return s->oformat->interleave_packet(s, out, in, flush);
2676     else
2677         return av_interleave_packet_per_dts(s, out, in, flush);
2678 }
2679
2680 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2681     AVStream *st= s->streams[ pkt->stream_index];
2682
2683     //FIXME/XXX/HACK drop zero sized packets
2684     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2685         return 0;
2686
2687 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2688     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2689         return -1;
2690
2691     if(pkt->dts == AV_NOPTS_VALUE)
2692         return -1;
2693
2694     for(;;){
2695         AVPacket opkt;
2696         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2697         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2698             return ret;
2699
2700         ret= s->oformat->write_packet(s, &opkt);
2701
2702         av_free_packet(&opkt);
2703         pkt= NULL;
2704
2705         if(ret<0)
2706             return ret;
2707         if(url_ferror(s->pb))
2708             return url_ferror(s->pb);
2709     }
2710 }
2711
2712 int av_write_trailer(AVFormatContext *s)
2713 {
2714     int ret, i;
2715
2716     for(;;){
2717         AVPacket pkt;
2718         ret= av_interleave_packet(s, &pkt, NULL, 1);
2719         if(ret<0) //FIXME cleanup needed for ret<0 ?
2720             goto fail;
2721         if(!ret)
2722             break;
2723
2724         ret= s->oformat->write_packet(s, &pkt);
2725
2726         av_free_packet(&pkt);
2727
2728         if(ret<0)
2729             goto fail;
2730         if(url_ferror(s->pb))
2731             goto fail;
2732     }
2733
2734     if(s->oformat->write_trailer)
2735         ret = s->oformat->write_trailer(s);
2736 fail:
2737     if(ret == 0)
2738        ret=url_ferror(s->pb);
2739     for(i=0;i<s->nb_streams;i++)
2740         av_freep(&s->streams[i]->priv_data);
2741     av_freep(&s->priv_data);
2742     return ret;
2743 }
2744
2745 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2746 {
2747     int i, j;
2748     AVProgram *program=NULL;
2749     void *tmp;
2750
2751     for(i=0; i<ac->nb_programs; i++){
2752         if(ac->programs[i]->id != progid)
2753             continue;
2754         program = ac->programs[i];
2755         for(j=0; j<program->nb_stream_indexes; j++)
2756             if(program->stream_index[j] == idx)
2757                 return;
2758
2759         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2760         if(!tmp)
2761             return;
2762         program->stream_index = tmp;
2763         program->stream_index[program->nb_stream_indexes++] = idx;
2764         return;
2765     }
2766 }
2767
2768 /* "user interface" functions */
2769 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2770 {
2771     char buf[256];
2772     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2773     AVStream *st = ic->streams[i];
2774     int g = ff_gcd(st->time_base.num, st->time_base.den);
2775     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2776     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2777     /* the pid is an important information, so we display it */
2778     /* XXX: add a generic system */
2779     if (flags & AVFMT_SHOW_IDS)
2780         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2781     if (strlen(st->language) > 0)
2782         av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2783     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2784     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2785     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2786         if(st->r_frame_rate.den && st->r_frame_rate.num)
2787             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2788 /*      else if(st->time_base.den && st->time_base.num)
2789             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2790         else
2791             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2792     }
2793     av_log(NULL, AV_LOG_INFO, "\n");
2794 }
2795
2796 void dump_format(AVFormatContext *ic,
2797                  int index,
2798                  const char *url,
2799                  int is_output)
2800 {
2801     int i;
2802
2803     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2804             is_output ? "Output" : "Input",
2805             index,
2806             is_output ? ic->oformat->name : ic->iformat->name,
2807             is_output ? "to" : "from", url);
2808     if (!is_output) {
2809         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2810         if (ic->duration != AV_NOPTS_VALUE) {
2811             int hours, mins, secs, us;
2812             secs = ic->duration / AV_TIME_BASE;
2813             us = ic->duration % AV_TIME_BASE;
2814             mins = secs / 60;
2815             secs %= 60;
2816             hours = mins / 60;
2817             mins %= 60;
2818             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2819                    (100 * us) / AV_TIME_BASE);
2820         } else {
2821             av_log(NULL, AV_LOG_INFO, "N/A");
2822         }
2823         if (ic->start_time != AV_NOPTS_VALUE) {
2824             int secs, us;
2825             av_log(NULL, AV_LOG_INFO, ", start: ");
2826             secs = ic->start_time / AV_TIME_BASE;
2827             us = ic->start_time % AV_TIME_BASE;
2828             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2829                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2830         }
2831         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2832         if (ic->bit_rate) {
2833             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2834         } else {
2835             av_log(NULL, AV_LOG_INFO, "N/A");
2836         }
2837         av_log(NULL, AV_LOG_INFO, "\n");
2838     }
2839     if(ic->nb_programs) {
2840         int j, k;
2841         for(j=0; j<ic->nb_programs; j++) {
2842             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2843                    ic->programs[j]->name ? ic->programs[j]->name : "");
2844             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2845                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2846          }
2847     } else
2848     for(i=0;i<ic->nb_streams;i++)
2849         dump_stream_format(ic, i, index, is_output);
2850 }
2851
2852 #if LIBAVFORMAT_VERSION_MAJOR < 53
2853 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2854 {
2855     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2856 }
2857
2858 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2859 {
2860     AVRational frame_rate;
2861     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2862     *frame_rate_num= frame_rate.num;
2863     *frame_rate_den= frame_rate.den;
2864     return ret;
2865 }
2866 #endif
2867
2868 int64_t av_gettime(void)
2869 {
2870     struct timeval tv;
2871     gettimeofday(&tv,NULL);
2872     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2873 }
2874
2875 int64_t parse_date(const char *datestr, int duration)
2876 {
2877     const char *p;
2878     int64_t t;
2879     struct tm dt;
2880     int i;
2881     static const char * const date_fmt[] = {
2882         "%Y-%m-%d",
2883         "%Y%m%d",
2884     };
2885     static const char * const time_fmt[] = {
2886         "%H:%M:%S",
2887         "%H%M%S",
2888     };
2889     const char *q;
2890     int is_utc, len;
2891     char lastch;
2892     int negative = 0;
2893
2894 #undef time
2895     time_t now = time(0);
2896
2897     len = strlen(datestr);
2898     if (len > 0)
2899         lastch = datestr[len - 1];
2900     else
2901         lastch = '\0';
2902     is_utc = (lastch == 'z' || lastch == 'Z');
2903
2904     memset(&dt, 0, sizeof(dt));
2905
2906     p = datestr;
2907     q = NULL;
2908     if (!duration) {
2909         /* parse the year-month-day part */
2910         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2911             q = small_strptime(p, date_fmt[i], &dt);
2912             if (q) {
2913                 break;
2914             }
2915         }
2916
2917         /* if the year-month-day part is missing, then take the
2918          * current year-month-day time */
2919         if (!q) {
2920             if (is_utc) {
2921                 dt = *gmtime(&now);
2922             } else {
2923                 dt = *localtime(&now);
2924             }
2925             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2926         } else {
2927             p = q;
2928         }
2929
2930         if (*p == 'T' || *p == 't' || *p == ' ')
2931             p++;
2932
2933         /* parse the hour-minute-second part */
2934         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2935             q = small_strptime(p, time_fmt[i], &dt);
2936             if (q) {
2937                 break;
2938             }
2939         }
2940     } else {
2941         /* parse datestr as a duration */
2942         if (p[0] == '-') {
2943             negative = 1;
2944             ++p;
2945         }
2946         /* parse datestr as HH:MM:SS */
2947         q = small_strptime(p, time_fmt[0], &dt);
2948         if (!q) {
2949             /* parse datestr as S+ */
2950             dt.tm_sec = strtol(p, (char **)&q, 10);
2951             if (q == p)
2952                 /* the parsing didn't succeed */
2953                 return INT64_MIN;
2954             dt.tm_min = 0;
2955             dt.tm_hour = 0;
2956         }
2957     }
2958
2959     /* Now we have all the fields that we can get */
2960     if (!q) {
2961         return INT64_MIN;
2962     }
2963
2964     if (duration) {
2965         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2966     } else {
2967         dt.tm_isdst = -1;       /* unknown */
2968         if (is_utc) {
2969             t = mktimegm(&dt);
2970         } else {
2971             t = mktime(&dt);
2972         }
2973     }
2974
2975     t *= 1000000;
2976
2977     /* parse the .m... part */
2978     if (*q == '.') {
2979         int val, n;
2980         q++;
2981         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2982             if (!isdigit(*q))
2983                 break;
2984             val += n * (*q - '0');
2985         }
2986         t += val;
2987     }
2988     return negative ? -t : t;
2989 }
2990
2991 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2992 {
2993     const char *p;
2994     char tag[128], *q;
2995
2996     p = info;
2997     if (*p == '?')
2998         p++;
2999     for(;;) {
3000         q = tag;
3001         while (*p != '\0' && *p != '=' && *p != '&') {
3002             if ((q - tag) < sizeof(tag) - 1)
3003                 *q++ = *p;
3004             p++;
3005         }
3006         *q = '\0';
3007         q = arg;
3008         if (*p == '=') {
3009             p++;
3010             while (*p != '&' && *p != '\0') {
3011                 if ((q - arg) < arg_size - 1) {
3012                     if (*p == '+')
3013                         *q++ = ' ';
3014                     else
3015                         *q++ = *p;
3016                 }
3017                 p++;
3018             }
3019             *q = '\0';
3020         }
3021         if (!strcmp(tag, tag1))
3022             return 1;
3023         if (*p != '&')
3024             break;
3025         p++;
3026     }
3027     return 0;
3028 }
3029
3030 int av_get_frame_filename(char *buf, int buf_size,
3031                           const char *path, int number)
3032 {
3033     const char *p;
3034     char *q, buf1[20], c;
3035     int nd, len, percentd_found;
3036
3037     q = buf;
3038     p = path;
3039     percentd_found = 0;
3040     for(;;) {
3041         c = *p++;
3042         if (c == '\0')
3043             break;
3044         if (c == '%') {
3045             do {
3046                 nd = 0;
3047                 while (isdigit(*p)) {
3048                     nd = nd * 10 + *p++ - '0';
3049                 }
3050                 c = *p++;
3051             } while (isdigit(c));
3052
3053             switch(c) {
3054             case '%':
3055                 goto addchar;
3056             case 'd':
3057                 if (percentd_found)
3058                     goto fail;
3059                 percentd_found = 1;
3060                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3061                 len = strlen(buf1);
3062                 if ((q - buf + len) > buf_size - 1)
3063                     goto fail;
3064                 memcpy(q, buf1, len);
3065                 q += len;
3066                 break;
3067             default:
3068                 goto fail;
3069             }
3070         } else {
3071         addchar:
3072             if ((q - buf) < buf_size - 1)
3073                 *q++ = c;
3074         }
3075     }
3076     if (!percentd_found)
3077         goto fail;
3078     *q = '\0';
3079     return 0;
3080  fail:
3081     *q = '\0';
3082     return -1;
3083 }
3084
3085 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3086 {
3087     int len, i, j, c;
3088 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3089
3090     for(i=0;i<size;i+=16) {
3091         len = size - i;
3092         if (len > 16)
3093             len = 16;
3094         PRINT("%08x ", i);
3095         for(j=0;j<16;j++) {
3096             if (j < len)
3097                 PRINT(" %02x", buf[i+j]);
3098             else
3099                 PRINT("   ");
3100         }
3101         PRINT(" ");
3102         for(j=0;j<len;j++) {
3103             c = buf[i+j];
3104             if (c < ' ' || c > '~')
3105                 c = '.';
3106             PRINT("%c", c);
3107         }
3108         PRINT("\n");
3109     }
3110 #undef PRINT
3111 }
3112
3113 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3114 {
3115     hex_dump_internal(NULL, f, 0, buf, size);
3116 }
3117
3118 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3119 {
3120     hex_dump_internal(avcl, NULL, level, buf, size);
3121 }
3122
3123  //FIXME needs to know the time_base
3124 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3125 {
3126 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3127     PRINT("stream #%d:\n", pkt->stream_index);
3128     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3129     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3130     /* DTS is _always_ valid after av_read_frame() */
3131     PRINT("  dts=");
3132     if (pkt->dts == AV_NOPTS_VALUE)
3133         PRINT("N/A");
3134     else
3135         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3136     /* PTS may not be known if B-frames are present. */
3137     PRINT("  pts=");
3138     if (pkt->pts == AV_NOPTS_VALUE)
3139         PRINT("N/A");
3140     else
3141         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3142     PRINT("\n");
3143     PRINT("  size=%d\n", pkt->size);
3144 #undef PRINT
3145     if (dump_payload)
3146         av_hex_dump(f, pkt->data, pkt->size);
3147 }
3148
3149 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3150 {
3151     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3152 }
3153
3154 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3155 {
3156     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3157 }
3158
3159 void url_split(char *proto, int proto_size,
3160                char *authorization, int authorization_size,
3161                char *hostname, int hostname_size,
3162                int *port_ptr,
3163                char *path, int path_size,
3164                const char *url)
3165 {
3166     const char *p, *ls, *at, *col, *brk;
3167
3168     if (port_ptr)               *port_ptr = -1;
3169     if (proto_size > 0)         proto[0] = 0;
3170     if (authorization_size > 0) authorization[0] = 0;
3171     if (hostname_size > 0)      hostname[0] = 0;
3172     if (path_size > 0)          path[0] = 0;
3173
3174     /* parse protocol */
3175     if ((p = strchr(url, ':'))) {
3176         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3177         p++; /* skip ':' */
3178         if (*p == '/') p++;
3179         if (*p == '/') p++;
3180     } else {
3181         /* no protocol means plain filename */
3182         av_strlcpy(path, url, path_size);
3183         return;
3184     }
3185
3186     /* separate path from hostname */
3187     ls = strchr(p, '/');
3188     if(!ls)
3189         ls = strchr(p, '?');
3190     if(ls)
3191         av_strlcpy(path, ls, path_size);
3192     else
3193         ls = &p[strlen(p)]; // XXX
3194
3195     /* the rest is hostname, use that to parse auth/port */
3196     if (ls != p) {
3197         /* authorization (user[:pass]@hostname) */
3198         if ((at = strchr(p, '@')) && at < ls) {
3199             av_strlcpy(authorization, p,
3200                        FFMIN(authorization_size, at + 1 - p));
3201             p = at + 1; /* skip '@' */
3202         }
3203
3204         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3205             /* [host]:port */
3206             av_strlcpy(hostname, p + 1,
3207                        FFMIN(hostname_size, brk - p));
3208             if (brk[1] == ':' && port_ptr)
3209                 *port_ptr = atoi(brk + 2);
3210         } else if ((col = strchr(p, ':')) && col < ls) {
3211             av_strlcpy(hostname, p,
3212                        FFMIN(col + 1 - p, hostname_size));
3213             if (port_ptr) *port_ptr = atoi(col + 1);
3214         } else
3215             av_strlcpy(hostname, p,
3216                        FFMIN(ls + 1 - p, hostname_size));
3217     }
3218 }
3219
3220 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3221 {
3222     int i;
3223     static const char hex_table[16] = { '0', '1', '2', '3',
3224                                         '4', '5', '6', '7',
3225                                         '8', '9', 'A', 'B',
3226                                         'C', 'D', 'E', 'F' };
3227
3228     for(i = 0; i < s; i++) {
3229         buff[i * 2]     = hex_table[src[i] >> 4];
3230         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3231     }
3232
3233     return buff;
3234 }
3235
3236 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3237                      int pts_num, int pts_den)
3238 {
3239     unsigned int gcd= ff_gcd(pts_num, pts_den);
3240     s->pts_wrap_bits = pts_wrap_bits;
3241     s->time_base.num = pts_num/gcd;
3242     s->time_base.den = pts_den/gcd;
3243
3244     if(gcd>1)
3245         av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3246 }