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