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