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