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