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