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