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