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