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