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