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