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