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