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