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