lavf: free probe data in case we close before probing finished
[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
22 /* #define DEBUG */
23
24 #include "avformat.h"
25 #include "avio_internal.h"
26 #include "internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/raw.h"
29 #include "libavcodec/bytestream.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/dict.h"
33 #include "libavutil/pixdesc.h"
34 #include "metadata.h"
35 #include "id3v2.h"
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/time.h"
41 #include "libavutil/timestamp.h"
42 #include "riff.h"
43 #include "audiointerleave.h"
44 #include "url.h"
45 #include <stdarg.h>
46 #if CONFIG_NETWORK
47 #include "network.h"
48 #endif
49
50 #undef NDEBUG
51 #include <assert.h>
52
53 /**
54  * @file
55  * various utility functions for use within FFmpeg
56  */
57
58 unsigned avformat_version(void)
59 {
60     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
61     return LIBAVFORMAT_VERSION_INT;
62 }
63
64 const char *avformat_configuration(void)
65 {
66     return FFMPEG_CONFIGURATION;
67 }
68
69 const char *avformat_license(void)
70 {
71 #define LICENSE_PREFIX "libavformat license: "
72     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
73 }
74
75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
76
77 static int is_relative(int64_t ts) {
78     return ts > (RELATIVE_TS_BASE - (1LL<<48));
79 }
80
81 /* fraction handling */
82
83 /**
84  * f = val + (num / den) + 0.5.
85  *
86  * 'num' is normalized so that it is such as 0 <= num < den.
87  *
88  * @param f fractional number
89  * @param val integer value
90  * @param num must be >= 0
91  * @param den must be >= 1
92  */
93 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
94 {
95     num += (den >> 1);
96     if (num >= den) {
97         val += num / den;
98         num = num % den;
99     }
100     f->val = val;
101     f->num = num;
102     f->den = den;
103 }
104
105 /**
106  * Fractional addition to f: f = f + (incr / f->den).
107  *
108  * @param f fractional number
109  * @param incr increment, can be positive or negative
110  */
111 static void frac_add(AVFrac *f, int64_t incr)
112 {
113     int64_t num, den;
114
115     num = f->num + incr;
116     den = f->den;
117     if (num < 0) {
118         f->val += num / den;
119         num = num % den;
120         if (num < 0) {
121             num += den;
122             f->val--;
123         }
124     } else if (num >= den) {
125         f->val += num / den;
126         num = num % den;
127     }
128     f->num = num;
129 }
130
131 /** head of registered input format linked list */
132 static AVInputFormat *first_iformat = NULL;
133 /** head of registered output format linked list */
134 static AVOutputFormat *first_oformat = NULL;
135
136 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
137 {
138     if(f) return f->next;
139     else  return first_iformat;
140 }
141
142 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
143 {
144     if(f) return f->next;
145     else  return first_oformat;
146 }
147
148 void av_register_input_format(AVInputFormat *format)
149 {
150     AVInputFormat **p;
151     p = &first_iformat;
152     while (*p != NULL) p = &(*p)->next;
153     *p = format;
154     format->next = NULL;
155 }
156
157 void av_register_output_format(AVOutputFormat *format)
158 {
159     AVOutputFormat **p;
160     p = &first_oformat;
161     while (*p != NULL) p = &(*p)->next;
162     *p = format;
163     format->next = NULL;
164 }
165
166 int av_match_ext(const char *filename, const char *extensions)
167 {
168     const char *ext, *p;
169     char ext1[32], *q;
170
171     if(!filename)
172         return 0;
173
174     ext = strrchr(filename, '.');
175     if (ext) {
176         ext++;
177         p = extensions;
178         for(;;) {
179             q = ext1;
180             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
181                 *q++ = *p++;
182             *q = '\0';
183             if (!av_strcasecmp(ext1, ext))
184                 return 1;
185             if (*p == '\0')
186                 break;
187             p++;
188         }
189     }
190     return 0;
191 }
192
193 static int match_format(const char *name, const char *names)
194 {
195     const char *p;
196     int len, namelen;
197
198     if (!name || !names)
199         return 0;
200
201     namelen = strlen(name);
202     while ((p = strchr(names, ','))) {
203         len = FFMAX(p - names, namelen);
204         if (!av_strncasecmp(name, names, len))
205             return 1;
206         names = p+1;
207     }
208     return !av_strcasecmp(name, names);
209 }
210
211 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
212                                 const char *mime_type)
213 {
214     AVOutputFormat *fmt = NULL, *fmt_found;
215     int score_max, score;
216
217     /* specific test for image sequences */
218 #if CONFIG_IMAGE2_MUXER
219     if (!short_name && filename &&
220         av_filename_number_test(filename) &&
221         ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
222         return av_guess_format("image2", NULL, NULL);
223     }
224 #endif
225     /* Find the proper file type. */
226     fmt_found = NULL;
227     score_max = 0;
228     while ((fmt = av_oformat_next(fmt))) {
229         score = 0;
230         if (fmt->name && short_name && match_format(short_name, fmt->name))
231             score += 100;
232         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
233             score += 10;
234         if (filename && fmt->extensions &&
235             av_match_ext(filename, fmt->extensions)) {
236             score += 5;
237         }
238         if (score > score_max) {
239             score_max = score;
240             fmt_found = fmt;
241         }
242     }
243     return fmt_found;
244 }
245
246 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
247                             const char *filename, const char *mime_type, enum AVMediaType type){
248     if(type == AVMEDIA_TYPE_VIDEO){
249         enum AVCodecID codec_id= AV_CODEC_ID_NONE;
250
251 #if CONFIG_IMAGE2_MUXER
252         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
253             codec_id= ff_guess_image2_codec(filename);
254         }
255 #endif
256         if(codec_id == AV_CODEC_ID_NONE)
257             codec_id= fmt->video_codec;
258         return codec_id;
259     }else if(type == AVMEDIA_TYPE_AUDIO)
260         return fmt->audio_codec;
261     else if (type == AVMEDIA_TYPE_SUBTITLE)
262         return fmt->subtitle_codec;
263     else
264         return AV_CODEC_ID_NONE;
265 }
266
267 AVInputFormat *av_find_input_format(const char *short_name)
268 {
269     AVInputFormat *fmt = NULL;
270     while ((fmt = av_iformat_next(fmt))) {
271         if (match_format(short_name, fmt->name))
272             return fmt;
273     }
274     return NULL;
275 }
276
277 int ffio_limit(AVIOContext *s, int size)
278 {
279     if(s->maxsize>=0){
280         int64_t remaining= s->maxsize - avio_tell(s);
281         if(remaining < size){
282             int64_t newsize= avio_size(s);
283             if(!s->maxsize || s->maxsize<newsize)
284                 s->maxsize= newsize - !newsize;
285             remaining= s->maxsize - avio_tell(s);
286             remaining= FFMAX(remaining, 0);
287         }
288
289         if(s->maxsize>=0 && remaining+1 < size){
290             av_log(0, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
291             size= remaining+1;
292         }
293     }
294     return size;
295 }
296
297 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
298 {
299     int ret;
300     int orig_size = size;
301     size= ffio_limit(s, size);
302
303     ret= av_new_packet(pkt, size);
304
305     if(ret<0)
306         return ret;
307
308     pkt->pos= avio_tell(s);
309
310     ret= avio_read(s, pkt->data, size);
311     if(ret<=0)
312         av_free_packet(pkt);
313     else
314         av_shrink_packet(pkt, ret);
315     if (pkt->size < orig_size)
316         pkt->flags |= AV_PKT_FLAG_CORRUPT;
317
318     return ret;
319 }
320
321 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
322 {
323     int ret;
324     int old_size;
325     if (!pkt->size)
326         return av_get_packet(s, pkt, size);
327     old_size = pkt->size;
328     ret = av_grow_packet(pkt, size);
329     if (ret < 0)
330         return ret;
331     ret = avio_read(s, pkt->data + old_size, size);
332     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
333     return ret;
334 }
335
336
337 int av_filename_number_test(const char *filename)
338 {
339     char buf[1024];
340     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
341 }
342
343 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
344 {
345     AVProbeData lpd = *pd;
346     AVInputFormat *fmt1 = NULL, *fmt;
347     int score, nodat = 0, score_max=0;
348
349     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
350         int id3len = ff_id3v2_tag_len(lpd.buf);
351         if (lpd.buf_size > id3len + 16) {
352             lpd.buf += id3len;
353             lpd.buf_size -= id3len;
354         }else
355             nodat = 1;
356     }
357
358     fmt = NULL;
359     while ((fmt1 = av_iformat_next(fmt1))) {
360         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
361             continue;
362         score = 0;
363         if (fmt1->read_probe) {
364             score = fmt1->read_probe(&lpd);
365             if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
366                 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
367         } else if (fmt1->extensions) {
368             if (av_match_ext(lpd.filename, fmt1->extensions)) {
369                 score = 50;
370             }
371         }
372         if (score > score_max) {
373             score_max = score;
374             fmt = fmt1;
375         }else if (score == score_max)
376             fmt = NULL;
377     }
378     *score_ret= score_max;
379
380     return fmt;
381 }
382
383 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
384 {
385     int score_ret;
386     AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
387     if(score_ret > *score_max){
388         *score_max= score_ret;
389         return fmt;
390     }else
391         return NULL;
392 }
393
394 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
395     int score=0;
396     return av_probe_input_format2(pd, is_opened, &score);
397 }
398
399 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
400 {
401     static const struct {
402         const char *name; enum AVCodecID id; enum AVMediaType type;
403     } fmt_id_type[] = {
404         { "aac"      , AV_CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
405         { "ac3"      , AV_CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
406         { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
407         { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
408         { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
409         { "loas"     , AV_CODEC_ID_AAC_LATM  , AVMEDIA_TYPE_AUDIO },
410         { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
411         { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
412         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
413         { 0 }
414     };
415     int score;
416     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
417
418     if (fmt && st->request_probe <= score) {
419         int i;
420         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
421                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
422         for (i = 0; fmt_id_type[i].name; i++) {
423             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
424                 st->codec->codec_id   = fmt_id_type[i].id;
425                 st->codec->codec_type = fmt_id_type[i].type;
426                 break;
427             }
428         }
429     }
430     return score;
431 }
432
433 /************************************************************/
434 /* input media file */
435
436 int av_demuxer_open(AVFormatContext *ic){
437     int err;
438
439     if (ic->iformat->read_header) {
440         err = ic->iformat->read_header(ic);
441         if (err < 0)
442             return err;
443     }
444
445     if (ic->pb && !ic->data_offset)
446         ic->data_offset = avio_tell(ic->pb);
447
448     return 0;
449 }
450
451
452 /** size of probe buffer, for guessing file type from file contents */
453 #define PROBE_BUF_MIN 2048
454 #define PROBE_BUF_MAX (1<<20)
455
456 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
457                           const char *filename, void *logctx,
458                           unsigned int offset, unsigned int max_probe_size)
459 {
460     AVProbeData pd = { filename ? filename : "", NULL, -offset };
461     unsigned char *buf = NULL;
462     int ret = 0, probe_size;
463
464     if (!max_probe_size) {
465         max_probe_size = PROBE_BUF_MAX;
466     } else if (max_probe_size > PROBE_BUF_MAX) {
467         max_probe_size = PROBE_BUF_MAX;
468     } else if (max_probe_size < PROBE_BUF_MIN) {
469         return AVERROR(EINVAL);
470     }
471
472     if (offset >= max_probe_size) {
473         return AVERROR(EINVAL);
474     }
475
476     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
477         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
478         int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
479         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
480         void *buftmp;
481
482         if (probe_size < offset) {
483             continue;
484         }
485
486         /* read probe data */
487         buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
488         if(!buftmp){
489             av_free(buf);
490             return AVERROR(ENOMEM);
491         }
492         buf=buftmp;
493         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
494             /* fail if error was not end of file, otherwise, lower score */
495             if (ret != AVERROR_EOF) {
496                 av_free(buf);
497                 return ret;
498             }
499             score = 0;
500             ret = 0;            /* error was end of file, nothing read */
501         }
502         pd.buf_size += ret;
503         pd.buf = &buf[offset];
504
505         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
506
507         /* guess file format */
508         *fmt = av_probe_input_format2(&pd, 1, &score);
509         if(*fmt){
510             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
511                 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
512             }else
513                 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
514         }
515     }
516
517     if (!*fmt) {
518         av_free(buf);
519         return AVERROR_INVALIDDATA;
520     }
521
522     /* rewind. reuse probe buffer to avoid seeking */
523     if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
524         av_free(buf);
525
526     return ret;
527 }
528
529 /* open input file and probe the format if necessary */
530 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
531 {
532     int ret;
533     AVProbeData pd = {filename, NULL, 0};
534
535     if (s->pb) {
536         s->flags |= AVFMT_FLAG_CUSTOM_IO;
537         if (!s->iformat)
538             return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
539         else if (s->iformat->flags & AVFMT_NOFILE)
540             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
541                                       "will be ignored with AVFMT_NOFILE format.\n");
542         return 0;
543     }
544
545     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
546         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
547         return 0;
548
549     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
550                           &s->interrupt_callback, options)) < 0)
551         return ret;
552     if (s->iformat)
553         return 0;
554     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
555 }
556
557 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
558                                AVPacketList **plast_pktl){
559     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
560     if (!pktl)
561         return NULL;
562
563     if (*packet_buffer)
564         (*plast_pktl)->next = pktl;
565     else
566         *packet_buffer = pktl;
567
568     /* add the packet in the buffered packet list */
569     *plast_pktl = pktl;
570     pktl->pkt= *pkt;
571     return &pktl->pkt;
572 }
573
574 void avformat_queue_attached_pictures(AVFormatContext *s)
575 {
576     int i;
577     for (i = 0; i < s->nb_streams; i++)
578         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
579             s->streams[i]->discard < AVDISCARD_ALL) {
580             AVPacket copy = s->streams[i]->attached_pic;
581             copy.destruct = NULL;
582             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
583         }
584 }
585
586 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
587 {
588     AVFormatContext *s = *ps;
589     int ret = 0;
590     AVDictionary *tmp = NULL;
591     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
592
593     if (!s && !(s = avformat_alloc_context()))
594         return AVERROR(ENOMEM);
595     if (!s->av_class){
596         av_log(0, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
597         return AVERROR(EINVAL);
598     }
599     if (fmt)
600         s->iformat = fmt;
601
602     if (options)
603         av_dict_copy(&tmp, *options, 0);
604
605     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
606         goto fail;
607
608     if ((ret = init_input(s, filename, &tmp)) < 0)
609         goto fail;
610
611     /* check filename in case an image number is expected */
612     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
613         if (!av_filename_number_test(filename)) {
614             ret = AVERROR(EINVAL);
615             goto fail;
616         }
617     }
618
619     s->duration = s->start_time = AV_NOPTS_VALUE;
620     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
621
622     /* allocate private data */
623     if (s->iformat->priv_data_size > 0) {
624         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
625             ret = AVERROR(ENOMEM);
626             goto fail;
627         }
628         if (s->iformat->priv_class) {
629             *(const AVClass**)s->priv_data = s->iformat->priv_class;
630             av_opt_set_defaults(s->priv_data);
631             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
632                 goto fail;
633         }
634     }
635
636     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
637     if (s->pb)
638         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
639
640     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
641         if ((ret = s->iformat->read_header(s)) < 0)
642             goto fail;
643
644     if (id3v2_extra_meta) {
645         if (!strcmp(s->iformat->name, "mp3")) {
646             if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
647                 goto fail;
648         } else
649             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
650     }
651     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
652
653     avformat_queue_attached_pictures(s);
654
655     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
656         s->data_offset = avio_tell(s->pb);
657
658     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
659
660     if (options) {
661         av_dict_free(options);
662         *options = tmp;
663     }
664     *ps = s;
665     return 0;
666
667 fail:
668     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
669     av_dict_free(&tmp);
670     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
671         avio_close(s->pb);
672     avformat_free_context(s);
673     *ps = NULL;
674     return ret;
675 }
676
677 /*******************************************************/
678
679 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
680 {
681     if(st->request_probe>0){
682         AVProbeData *pd = &st->probe_data;
683         int end;
684         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
685         --st->probe_packets;
686
687         if (pkt) {
688             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
689             if(!new_buf)
690                 goto no_packet;
691             pd->buf = new_buf;
692             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
693             pd->buf_size += pkt->size;
694             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
695         } else {
696 no_packet:
697             st->probe_packets = 0;
698             if (!pd->buf_size) {
699                 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
700                        st->index);
701             }
702         }
703
704         end=    s->raw_packet_buffer_remaining_size <= 0
705                 || st->probe_packets<=0;
706
707         if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
708             int score= set_codec_from_probe_data(s, st, pd);
709             if(    (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
710                 || end){
711                 pd->buf_size=0;
712                 av_freep(&pd->buf);
713                 st->request_probe= -1;
714                 if(st->codec->codec_id != AV_CODEC_ID_NONE){
715                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
716                 }else
717                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
718             }
719         }
720     }
721 }
722
723 static void force_codec_ids(AVFormatContext *s, AVStream *st)
724 {
725     switch(st->codec->codec_type){
726     case AVMEDIA_TYPE_VIDEO:
727         if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
728         break;
729     case AVMEDIA_TYPE_AUDIO:
730         if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
731         break;
732     case AVMEDIA_TYPE_SUBTITLE:
733         if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
734         break;
735     }
736 }
737
738 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
739 {
740     int ret, i;
741     AVStream *st;
742
743     for(;;){
744         AVPacketList *pktl = s->raw_packet_buffer;
745
746         if (pktl) {
747             *pkt = pktl->pkt;
748             st = s->streams[pkt->stream_index];
749             if(st->request_probe <= 0){
750                 s->raw_packet_buffer = pktl->next;
751                 s->raw_packet_buffer_remaining_size += pkt->size;
752                 av_free(pktl);
753                 return 0;
754             }
755         }
756
757         pkt->data = NULL;
758         pkt->size = 0;
759         av_init_packet(pkt);
760         ret= s->iformat->read_packet(s, pkt);
761         if (ret < 0) {
762             if (!pktl || ret == AVERROR(EAGAIN))
763                 return ret;
764             for (i = 0; i < s->nb_streams; i++) {
765                 st = s->streams[i];
766                 if (st->probe_packets) {
767                     probe_codec(s, st, NULL);
768                 }
769                 av_assert0(st->request_probe <= 0);
770             }
771             continue;
772         }
773
774         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
775             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
776             av_log(s, AV_LOG_WARNING,
777                    "Dropped corrupted packet (stream = %d)\n",
778                    pkt->stream_index);
779             av_free_packet(pkt);
780             continue;
781         }
782
783         if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
784             av_packet_merge_side_data(pkt);
785
786         if(pkt->stream_index >= (unsigned)s->nb_streams){
787             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
788             continue;
789         }
790
791         st= s->streams[pkt->stream_index];
792
793         force_codec_ids(s, st);
794
795         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
796         if (s->use_wallclock_as_timestamps)
797             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
798
799         if(!pktl && st->request_probe <= 0)
800             return ret;
801
802         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
803         s->raw_packet_buffer_remaining_size -= pkt->size;
804
805         probe_codec(s, st, pkt);
806     }
807 }
808
809 #if FF_API_READ_PACKET
810 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
811 {
812     return ff_read_packet(s, pkt);
813 }
814 #endif
815
816
817 /**********************************************************/
818
819 static int determinable_frame_size(AVCodecContext *avctx)
820 {
821     if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
822         avctx->codec_id == AV_CODEC_ID_MP1 ||
823         avctx->codec_id == AV_CODEC_ID_MP2 ||
824         avctx->codec_id == AV_CODEC_ID_MP3/* ||
825         avctx->codec_id == AV_CODEC_ID_CELT*/)
826         return 1;
827     return 0;
828 }
829
830 /**
831  * Get the number of samples of an audio frame. Return -1 on error.
832  */
833 static int get_audio_frame_size(AVCodecContext *enc, int size, int mux)
834 {
835     int frame_size;
836
837     /* give frame_size priority if demuxing */
838     if (!mux && enc->frame_size > 1)
839         return enc->frame_size;
840
841     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
842         return frame_size;
843
844     /* fallback to using frame_size if muxing */
845     if (enc->frame_size > 1)
846         return enc->frame_size;
847
848     return -1;
849 }
850
851
852 /**
853  * Return the frame duration in seconds. Return 0 if not available.
854  */
855 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
856                                    AVCodecParserContext *pc, AVPacket *pkt)
857 {
858     int frame_size;
859
860     *pnum = 0;
861     *pden = 0;
862     switch(st->codec->codec_type) {
863     case AVMEDIA_TYPE_VIDEO:
864         if (st->r_frame_rate.num && !pc) {
865             *pnum = st->r_frame_rate.den;
866             *pden = st->r_frame_rate.num;
867         } else if(st->time_base.num*1000LL > st->time_base.den) {
868             *pnum = st->time_base.num;
869             *pden = st->time_base.den;
870         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
871             *pnum = st->codec->time_base.num;
872             *pden = st->codec->time_base.den;
873             if (pc && pc->repeat_pict) {
874                 *pnum = (*pnum) * (1 + pc->repeat_pict);
875             }
876             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
877             //Thus if we have no parser in such case leave duration undefined.
878             if(st->codec->ticks_per_frame>1 && !pc){
879                 *pnum = *pden = 0;
880             }
881         }
882         break;
883     case AVMEDIA_TYPE_AUDIO:
884         frame_size = get_audio_frame_size(st->codec, pkt->size, 0);
885         if (frame_size <= 0 || st->codec->sample_rate <= 0)
886             break;
887         *pnum = frame_size;
888         *pden = st->codec->sample_rate;
889         break;
890     default:
891         break;
892     }
893 }
894
895 static int is_intra_only(AVCodecContext *enc){
896     const AVCodecDescriptor *desc;
897
898     if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
899         return 1;
900
901     desc = av_codec_get_codec_descriptor(enc);
902     if (!desc) {
903         desc = avcodec_descriptor_get(enc->codec_id);
904         av_codec_set_codec_descriptor(enc, desc);
905     }
906     if (desc)
907         return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
908     return 0;
909 }
910
911 static int has_decode_delay_been_guessed(AVStream *st)
912 {
913     if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
914     if(!st->info) // if we have left find_stream_info then nb_decoded_frames wont increase anymore for stream copy
915         return 1;
916 #if CONFIG_H264_DECODER
917     if(st->codec->has_b_frames &&
918        avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
919         return 1;
920 #endif
921     if(st->codec->has_b_frames<3)
922         return st->nb_decoded_frames >= 7;
923     else if(st->codec->has_b_frames<4)
924         return st->nb_decoded_frames >= 18;
925     else
926         return st->nb_decoded_frames >= 20;
927 }
928
929 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
930 {
931     if (pktl->next)
932         return pktl->next;
933     if (pktl == s->parse_queue_end)
934         return s->packet_buffer;
935     return NULL;
936 }
937
938 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
939                                       int64_t dts, int64_t pts)
940 {
941     AVStream *st= s->streams[stream_index];
942     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
943     int64_t pts_buffer[MAX_REORDER_DELAY];
944     int64_t shift;
945     int i, delay;
946
947     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
948         return;
949
950     delay = st->codec->has_b_frames;
951     st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
952     st->cur_dts= dts;
953     shift = st->first_dts - RELATIVE_TS_BASE;
954
955     for (i=0; i<MAX_REORDER_DELAY; i++)
956         pts_buffer[i] = AV_NOPTS_VALUE;
957
958     if (is_relative(pts))
959         pts += shift;
960
961     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
962         if(pktl->pkt.stream_index != stream_index)
963             continue;
964         if(is_relative(pktl->pkt.pts))
965             pktl->pkt.pts += shift;
966
967         if(is_relative(pktl->pkt.dts))
968             pktl->pkt.dts += shift;
969
970         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
971             st->start_time= pktl->pkt.pts;
972
973         if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
974             pts_buffer[0]= pktl->pkt.pts;
975             for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
976                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
977             if(pktl->pkt.dts == AV_NOPTS_VALUE)
978                 pktl->pkt.dts= pts_buffer[0];
979         }
980     }
981     if (st->start_time == AV_NOPTS_VALUE)
982         st->start_time = pts;
983 }
984
985 static void update_initial_durations(AVFormatContext *s, AVStream *st,
986                                      int stream_index, int duration)
987 {
988     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
989     int64_t cur_dts= RELATIVE_TS_BASE;
990
991     if(st->first_dts != AV_NOPTS_VALUE){
992         cur_dts= st->first_dts;
993         for(; pktl; pktl= get_next_pkt(s, st, pktl)){
994             if(pktl->pkt.stream_index == stream_index){
995                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
996                     break;
997                 cur_dts -= duration;
998             }
999         }
1000         if(pktl && pktl->pkt.dts != st->first_dts) {
1001             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in que\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
1002             return;
1003         }
1004         if(!pktl) {
1005             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in ques\n", av_ts2str(st->first_dts));
1006             return;
1007         }
1008         pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1009         st->first_dts = cur_dts;
1010     }else if(st->cur_dts != RELATIVE_TS_BASE)
1011         return;
1012
1013     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1014         if(pktl->pkt.stream_index != stream_index)
1015             continue;
1016         if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1017            && !pktl->pkt.duration){
1018             pktl->pkt.dts= cur_dts;
1019             if(!st->codec->has_b_frames)
1020                 pktl->pkt.pts= cur_dts;
1021 //            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1022                 pktl->pkt.duration = duration;
1023         }else
1024             break;
1025         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1026     }
1027     if(!pktl)
1028         st->cur_dts= cur_dts;
1029 }
1030
1031 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1032                                AVCodecParserContext *pc, AVPacket *pkt)
1033 {
1034     int num, den, presentation_delayed, delay, i;
1035     int64_t offset;
1036
1037     if (s->flags & AVFMT_FLAG_NOFILLIN)
1038         return;
1039
1040     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1041         pkt->dts= AV_NOPTS_VALUE;
1042
1043     if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1044         //FIXME Set low_delay = 0 when has_b_frames = 1
1045         st->codec->has_b_frames = 1;
1046
1047     /* do we have a video B-frame ? */
1048     delay= st->codec->has_b_frames;
1049     presentation_delayed = 0;
1050
1051     /* XXX: need has_b_frame, but cannot get it if the codec is
1052         not initialized */
1053     if (delay &&
1054         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1055         presentation_delayed = 1;
1056
1057     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && st->pts_wrap_bits<63 && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts){
1058         if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1059             pkt->dts -= 1LL<<st->pts_wrap_bits;
1060         } else
1061             pkt->pts += 1LL<<st->pts_wrap_bits;
1062     }
1063
1064     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1065     // we take the conservative approach and discard both
1066     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1067     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1068         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1069         if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1070             pkt->dts= AV_NOPTS_VALUE;
1071     }
1072
1073     if (pkt->duration == 0) {
1074         compute_frame_duration(&num, &den, st, pc, pkt);
1075         if (den && num) {
1076             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1077         }
1078     }
1079     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1080         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1081
1082     /* correct timestamps with byte offset if demuxers only have timestamps
1083        on packet boundaries */
1084     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1085         /* this will estimate bitrate based on this frame's duration and size */
1086         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1087         if(pkt->pts != AV_NOPTS_VALUE)
1088             pkt->pts += offset;
1089         if(pkt->dts != AV_NOPTS_VALUE)
1090             pkt->dts += offset;
1091     }
1092
1093     if (pc && pc->dts_sync_point >= 0) {
1094         // we have synchronization info from the parser
1095         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1096         if (den > 0) {
1097             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1098             if (pkt->dts != AV_NOPTS_VALUE) {
1099                 // got DTS from the stream, update reference timestamp
1100                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1101                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1102             } else if (st->reference_dts != AV_NOPTS_VALUE) {
1103                 // compute DTS based on reference timestamp
1104                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1105                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1106             }
1107             if (pc->dts_sync_point > 0)
1108                 st->reference_dts = pkt->dts; // new reference
1109         }
1110     }
1111
1112     /* This may be redundant, but it should not hurt. */
1113     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1114         presentation_delayed = 1;
1115
1116 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1117 //           presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1118     /* interpolate PTS and DTS if they are not present */
1119     //We skip H264 currently because delay and has_b_frames are not reliably set
1120     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1121         if (presentation_delayed) {
1122             /* DTS = decompression timestamp */
1123             /* PTS = presentation timestamp */
1124             if (pkt->dts == AV_NOPTS_VALUE)
1125                 pkt->dts = st->last_IP_pts;
1126             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1127             if (pkt->dts == AV_NOPTS_VALUE)
1128                 pkt->dts = st->cur_dts;
1129
1130             /* this is tricky: the dts must be incremented by the duration
1131             of the frame we are displaying, i.e. the last I- or P-frame */
1132             if (st->last_IP_duration == 0)
1133                 st->last_IP_duration = pkt->duration;
1134             if(pkt->dts != AV_NOPTS_VALUE)
1135                 st->cur_dts = pkt->dts + st->last_IP_duration;
1136             st->last_IP_duration  = pkt->duration;
1137             st->last_IP_pts= pkt->pts;
1138             /* cannot compute PTS if not present (we can compute it only
1139             by knowing the future */
1140         } else if (pkt->pts != AV_NOPTS_VALUE ||
1141                    pkt->dts != AV_NOPTS_VALUE ||
1142                    pkt->duration                ) {
1143             int duration = pkt->duration;
1144
1145             if(st->cur_dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && duration){
1146                 int64_t old_diff= FFABS(st->cur_dts - duration - pkt->pts);
1147                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1148                 if(   old_diff < new_diff && old_diff < (duration>>3)
1149                    && st->codec->codec_type == AVMEDIA_TYPE_VIDEO
1150                    && (!strcmp(s->iformat->name, "mpeg") ||
1151                        !strcmp(s->iformat->name, "mpegts"))){
1152                     pkt->pts += duration;
1153                     av_log(s, AV_LOG_WARNING, "Adjusting PTS forward\n");
1154 //                    av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%s size:%d\n",
1155 //                           pkt->stream_index, old_diff, new_diff, pkt->duration, av_ts2str(st->cur_dts), pkt->size);
1156                 }
1157             }
1158
1159             /* presentation is not delayed : PTS and DTS are the same */
1160             if (pkt->pts == AV_NOPTS_VALUE)
1161                 pkt->pts = pkt->dts;
1162             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1163                                       pkt->pts);
1164             if (pkt->pts == AV_NOPTS_VALUE)
1165                 pkt->pts = st->cur_dts;
1166             pkt->dts = pkt->pts;
1167             if (pkt->pts != AV_NOPTS_VALUE)
1168                 st->cur_dts = pkt->pts + duration;
1169         }
1170     }
1171
1172     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1173         st->pts_buffer[0]= pkt->pts;
1174         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1175             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1176         if(pkt->dts == AV_NOPTS_VALUE)
1177             pkt->dts= st->pts_buffer[0];
1178     }
1179     if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1180         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1181     }
1182     if(pkt->dts > st->cur_dts)
1183         st->cur_dts = pkt->dts;
1184
1185 //    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1186 //           presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1187
1188     /* update flags */
1189     if (is_intra_only(st->codec))
1190         pkt->flags |= AV_PKT_FLAG_KEY;
1191     if (pc)
1192         pkt->convergence_duration = pc->convergence_duration;
1193 }
1194
1195 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1196 {
1197     while (*pkt_buf) {
1198         AVPacketList *pktl = *pkt_buf;
1199         *pkt_buf = pktl->next;
1200         av_free_packet(&pktl->pkt);
1201         av_freep(&pktl);
1202     }
1203     *pkt_buf_end = NULL;
1204 }
1205
1206 /**
1207  * Parse a packet, add all split parts to parse_queue
1208  *
1209  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1210  */
1211 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1212 {
1213     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1214     AVStream     *st = s->streams[stream_index];
1215     uint8_t    *data = pkt ? pkt->data : NULL;
1216     int         size = pkt ? pkt->size : 0;
1217     int ret = 0, got_output = 0;
1218
1219     if (!pkt) {
1220         av_init_packet(&flush_pkt);
1221         pkt = &flush_pkt;
1222         got_output = 1;
1223     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1224         // preserve 0-size sync packets
1225         compute_pkt_fields(s, st, st->parser, pkt);
1226     }
1227
1228     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1229         int len;
1230
1231         av_init_packet(&out_pkt);
1232         len = av_parser_parse2(st->parser,  st->codec,
1233                                &out_pkt.data, &out_pkt.size, data, size,
1234                                pkt->pts, pkt->dts, pkt->pos);
1235
1236         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1237         pkt->pos = -1;
1238         /* increment read pointer */
1239         data += len;
1240         size -= len;
1241
1242         got_output = !!out_pkt.size;
1243
1244         if (!out_pkt.size)
1245             continue;
1246
1247         /* set the duration */
1248         out_pkt.duration = 0;
1249         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1250             if (st->codec->sample_rate > 0) {
1251                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1252                                                     (AVRational){ 1, st->codec->sample_rate },
1253                                                     st->time_base,
1254                                                     AV_ROUND_DOWN);
1255             }
1256         } else if (st->codec->time_base.num != 0 &&
1257                    st->codec->time_base.den != 0) {
1258             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1259                                                 st->codec->time_base,
1260                                                 st->time_base,
1261                                                 AV_ROUND_DOWN);
1262         }
1263
1264         out_pkt.stream_index = st->index;
1265         out_pkt.pts = st->parser->pts;
1266         out_pkt.dts = st->parser->dts;
1267         out_pkt.pos = st->parser->pos;
1268
1269         if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1270             out_pkt.pos = st->parser->frame_offset;
1271
1272         if (st->parser->key_frame == 1 ||
1273             (st->parser->key_frame == -1 &&
1274              st->parser->pict_type == AV_PICTURE_TYPE_I))
1275             out_pkt.flags |= AV_PKT_FLAG_KEY;
1276
1277         if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1278             out_pkt.flags |= AV_PKT_FLAG_KEY;
1279
1280         compute_pkt_fields(s, st, st->parser, &out_pkt);
1281
1282         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1283             out_pkt.destruct = pkt->destruct;
1284             pkt->destruct = NULL;
1285         }
1286         if ((ret = av_dup_packet(&out_pkt)) < 0)
1287             goto fail;
1288
1289         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1290             av_free_packet(&out_pkt);
1291             ret = AVERROR(ENOMEM);
1292             goto fail;
1293         }
1294     }
1295
1296
1297     /* end of the stream => close and free the parser */
1298     if (pkt == &flush_pkt) {
1299         av_parser_close(st->parser);
1300         st->parser = NULL;
1301     }
1302
1303 fail:
1304     av_free_packet(pkt);
1305     return ret;
1306 }
1307
1308 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1309                                    AVPacketList **pkt_buffer_end,
1310                                    AVPacket      *pkt)
1311 {
1312     AVPacketList *pktl;
1313     av_assert0(*pkt_buffer);
1314     pktl = *pkt_buffer;
1315     *pkt = pktl->pkt;
1316     *pkt_buffer = pktl->next;
1317     if (!pktl->next)
1318         *pkt_buffer_end = NULL;
1319     av_freep(&pktl);
1320     return 0;
1321 }
1322
1323 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1324 {
1325     int ret = 0, i, got_packet = 0;
1326
1327     av_init_packet(pkt);
1328
1329     while (!got_packet && !s->parse_queue) {
1330         AVStream *st;
1331         AVPacket cur_pkt;
1332
1333         /* read next packet */
1334         ret = ff_read_packet(s, &cur_pkt);
1335         if (ret < 0) {
1336             if (ret == AVERROR(EAGAIN))
1337                 return ret;
1338             /* flush the parsers */
1339             for(i = 0; i < s->nb_streams; i++) {
1340                 st = s->streams[i];
1341                 if (st->parser && st->need_parsing)
1342                     parse_packet(s, NULL, st->index);
1343             }
1344             /* all remaining packets are now in parse_queue =>
1345              * really terminate parsing */
1346             break;
1347         }
1348         ret = 0;
1349         st  = s->streams[cur_pkt.stream_index];
1350
1351         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1352             cur_pkt.dts != AV_NOPTS_VALUE &&
1353             cur_pkt.pts < cur_pkt.dts) {
1354             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1355                    cur_pkt.stream_index,
1356                    av_ts2str(cur_pkt.pts),
1357                    av_ts2str(cur_pkt.dts),
1358                    cur_pkt.size);
1359         }
1360         if (s->debug & FF_FDEBUG_TS)
1361             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1362                    cur_pkt.stream_index,
1363                    av_ts2str(cur_pkt.pts),
1364                    av_ts2str(cur_pkt.dts),
1365                    cur_pkt.size,
1366                    cur_pkt.duration,
1367                    cur_pkt.flags);
1368
1369         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1370             st->parser = av_parser_init(st->codec->codec_id);
1371             if (!st->parser) {
1372                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1373                        "%s, packets or times may be invalid.\n",
1374                        avcodec_get_name(st->codec->codec_id));
1375                 /* no parser available: just output the raw packets */
1376                 st->need_parsing = AVSTREAM_PARSE_NONE;
1377             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1378                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1379             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1380                 st->parser->flags |= PARSER_FLAG_ONCE;
1381             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1382                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1383             }
1384         }
1385
1386         if (!st->need_parsing || !st->parser) {
1387             /* no parsing needed: we just output the packet as is */
1388             *pkt = cur_pkt;
1389             compute_pkt_fields(s, st, NULL, pkt);
1390             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1391                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1392                 ff_reduce_index(s, st->index);
1393                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1394             }
1395             got_packet = 1;
1396         } else if (st->discard < AVDISCARD_ALL) {
1397             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1398                 return ret;
1399         } else {
1400             /* free packet */
1401             av_free_packet(&cur_pkt);
1402         }
1403         if (pkt->flags & AV_PKT_FLAG_KEY)
1404             st->skip_to_keyframe = 0;
1405         if (st->skip_to_keyframe) {
1406             av_free_packet(&cur_pkt);
1407             got_packet = 0;
1408         }
1409     }
1410
1411     if (!got_packet && s->parse_queue)
1412         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1413
1414     if(s->debug & FF_FDEBUG_TS)
1415         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1416             pkt->stream_index,
1417             av_ts2str(pkt->pts),
1418             av_ts2str(pkt->dts),
1419             pkt->size,
1420             pkt->duration,
1421             pkt->flags);
1422
1423     return ret;
1424 }
1425
1426 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1427 {
1428     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1429     int          eof = 0;
1430     int ret;
1431     AVStream *st;
1432
1433     if (!genpts) {
1434         ret = s->packet_buffer ?
1435             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1436             read_frame_internal(s, pkt);
1437         if (ret < 0)
1438             return ret;
1439         goto return_packet;
1440     }
1441
1442     for (;;) {
1443         AVPacketList *pktl = s->packet_buffer;
1444
1445         if (pktl) {
1446             AVPacket *next_pkt = &pktl->pkt;
1447
1448             if (next_pkt->dts != AV_NOPTS_VALUE) {
1449                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1450                 // last dts seen for this stream. if any of packets following
1451                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1452                 int64_t last_dts = next_pkt->dts;
1453                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1454                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1455                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1456                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1457                             next_pkt->pts = pktl->pkt.dts;
1458                         }
1459                         if (last_dts != AV_NOPTS_VALUE) {
1460                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1461                             last_dts = pktl->pkt.dts;
1462                         }
1463                     }
1464                     pktl = pktl->next;
1465                 }
1466                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1467                     // Fixing the last reference frame had none pts issue (For MXF etc).
1468                     // We only do this when
1469                     // 1. eof.
1470                     // 2. we are not able to resolve a pts value for current packet.
1471                     // 3. the packets for this stream at the end of the files had valid dts.
1472                     next_pkt->pts = last_dts + next_pkt->duration;
1473                 }
1474                 pktl = s->packet_buffer;
1475             }
1476
1477             /* read packet from packet buffer, if there is data */
1478             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1479                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1480                 ret = read_from_packet_buffer(&s->packet_buffer,
1481                                                &s->packet_buffer_end, pkt);
1482                 goto return_packet;
1483             }
1484         }
1485
1486         ret = read_frame_internal(s, pkt);
1487         if (ret < 0) {
1488             if (pktl && ret != AVERROR(EAGAIN)) {
1489                 eof = 1;
1490                 continue;
1491             } else
1492                 return ret;
1493         }
1494
1495         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1496                           &s->packet_buffer_end)) < 0)
1497             return AVERROR(ENOMEM);
1498     }
1499
1500 return_packet:
1501
1502     st = s->streams[pkt->stream_index];
1503     if (st->skip_samples) {
1504         uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1505         AV_WL32(p, st->skip_samples);
1506         av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1507         st->skip_samples = 0;
1508     }
1509
1510     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1511         ff_reduce_index(s, st->index);
1512         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1513     }
1514
1515     if (is_relative(pkt->dts))
1516         pkt->dts -= RELATIVE_TS_BASE;
1517     if (is_relative(pkt->pts))
1518         pkt->pts -= RELATIVE_TS_BASE;
1519
1520     return ret;
1521 }
1522
1523 /* XXX: suppress the packet queue */
1524 static void flush_packet_queue(AVFormatContext *s)
1525 {
1526     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1527     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1528     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1529
1530     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1531 }
1532
1533 /*******************************************************/
1534 /* seek support */
1535
1536 int av_find_default_stream_index(AVFormatContext *s)
1537 {
1538     int first_audio_index = -1;
1539     int i;
1540     AVStream *st;
1541
1542     if (s->nb_streams <= 0)
1543         return -1;
1544     for(i = 0; i < s->nb_streams; i++) {
1545         st = s->streams[i];
1546         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1547             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1548             return i;
1549         }
1550         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1551             first_audio_index = i;
1552     }
1553     return first_audio_index >= 0 ? first_audio_index : 0;
1554 }
1555
1556 /**
1557  * Flush the frame reader.
1558  */
1559 void ff_read_frame_flush(AVFormatContext *s)
1560 {
1561     AVStream *st;
1562     int i, j;
1563
1564     flush_packet_queue(s);
1565
1566     /* for each stream, reset read state */
1567     for(i = 0; i < s->nb_streams; i++) {
1568         st = s->streams[i];
1569
1570         if (st->parser) {
1571             av_parser_close(st->parser);
1572             st->parser = NULL;
1573         }
1574         st->last_IP_pts = AV_NOPTS_VALUE;
1575         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1576         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1577         st->reference_dts = AV_NOPTS_VALUE;
1578
1579         st->probe_packets = MAX_PROBE_PACKETS;
1580
1581         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1582             st->pts_buffer[j]= AV_NOPTS_VALUE;
1583     }
1584 }
1585
1586 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1587 {
1588     int i;
1589
1590     for(i = 0; i < s->nb_streams; i++) {
1591         AVStream *st = s->streams[i];
1592
1593         st->cur_dts = av_rescale(timestamp,
1594                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1595                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1596     }
1597 }
1598
1599 void ff_reduce_index(AVFormatContext *s, int stream_index)
1600 {
1601     AVStream *st= s->streams[stream_index];
1602     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1603
1604     if((unsigned)st->nb_index_entries >= max_entries){
1605         int i;
1606         for(i=0; 2*i<st->nb_index_entries; i++)
1607             st->index_entries[i]= st->index_entries[2*i];
1608         st->nb_index_entries= i;
1609     }
1610 }
1611
1612 int ff_add_index_entry(AVIndexEntry **index_entries,
1613                        int *nb_index_entries,
1614                        unsigned int *index_entries_allocated_size,
1615                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1616 {
1617     AVIndexEntry *entries, *ie;
1618     int index;
1619
1620     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1621         return -1;
1622
1623     if(timestamp == AV_NOPTS_VALUE)
1624         return AVERROR(EINVAL);
1625
1626     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1627         timestamp -= RELATIVE_TS_BASE;
1628
1629     entries = av_fast_realloc(*index_entries,
1630                               index_entries_allocated_size,
1631                               (*nb_index_entries + 1) *
1632                               sizeof(AVIndexEntry));
1633     if(!entries)
1634         return -1;
1635
1636     *index_entries= entries;
1637
1638     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1639
1640     if(index<0){
1641         index= (*nb_index_entries)++;
1642         ie= &entries[index];
1643         assert(index==0 || ie[-1].timestamp < timestamp);
1644     }else{
1645         ie= &entries[index];
1646         if(ie->timestamp != timestamp){
1647             if(ie->timestamp <= timestamp)
1648                 return -1;
1649             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1650             (*nb_index_entries)++;
1651         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1652             distance= ie->min_distance;
1653     }
1654
1655     ie->pos = pos;
1656     ie->timestamp = timestamp;
1657     ie->min_distance= distance;
1658     ie->size= size;
1659     ie->flags = flags;
1660
1661     return index;
1662 }
1663
1664 int av_add_index_entry(AVStream *st,
1665                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1666 {
1667     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1668                               &st->index_entries_allocated_size, pos,
1669                               timestamp, size, distance, flags);
1670 }
1671
1672 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1673                               int64_t wanted_timestamp, int flags)
1674 {
1675     int a, b, m;
1676     int64_t timestamp;
1677
1678     a = - 1;
1679     b = nb_entries;
1680
1681     //optimize appending index entries at the end
1682     if(b && entries[b-1].timestamp < wanted_timestamp)
1683         a= b-1;
1684
1685     while (b - a > 1) {
1686         m = (a + b) >> 1;
1687         timestamp = entries[m].timestamp;
1688         if(timestamp >= wanted_timestamp)
1689             b = m;
1690         if(timestamp <= wanted_timestamp)
1691             a = m;
1692     }
1693     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1694
1695     if(!(flags & AVSEEK_FLAG_ANY)){
1696         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1697             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1698         }
1699     }
1700
1701     if(m == nb_entries)
1702         return -1;
1703     return  m;
1704 }
1705
1706 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1707                               int flags)
1708 {
1709     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1710                                      wanted_timestamp, flags);
1711 }
1712
1713 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1714 {
1715     AVInputFormat *avif= s->iformat;
1716     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1717     int64_t ts_min, ts_max, ts;
1718     int index;
1719     int64_t ret;
1720     AVStream *st;
1721
1722     if (stream_index < 0)
1723         return -1;
1724
1725     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1726
1727     ts_max=
1728     ts_min= AV_NOPTS_VALUE;
1729     pos_limit= -1; //gcc falsely says it may be uninitialized
1730
1731     st= s->streams[stream_index];
1732     if(st->index_entries){
1733         AVIndexEntry *e;
1734
1735         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()
1736         index= FFMAX(index, 0);
1737         e= &st->index_entries[index];
1738
1739         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1740             pos_min= e->pos;
1741             ts_min= e->timestamp;
1742             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1743                     pos_min, av_ts2str(ts_min));
1744         }else{
1745             assert(index==0);
1746         }
1747
1748         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1749         assert(index < st->nb_index_entries);
1750         if(index >= 0){
1751             e= &st->index_entries[index];
1752             assert(e->timestamp >= target_ts);
1753             pos_max= e->pos;
1754             ts_max= e->timestamp;
1755             pos_limit= pos_max - e->min_distance;
1756             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1757                     pos_max, pos_limit, av_ts2str(ts_max));
1758         }
1759     }
1760
1761     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1762     if(pos<0)
1763         return -1;
1764
1765     /* do the seek */
1766     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1767         return ret;
1768
1769     ff_read_frame_flush(s);
1770     ff_update_cur_dts(s, st, ts);
1771
1772     return 0;
1773 }
1774
1775 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1776                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1777                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1778                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1779 {
1780     int64_t pos, ts;
1781     int64_t start_pos, filesize;
1782     int no_change;
1783
1784     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1785
1786     if(ts_min == AV_NOPTS_VALUE){
1787         pos_min = s->data_offset;
1788         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1789         if (ts_min == AV_NOPTS_VALUE)
1790             return -1;
1791     }
1792
1793     if(ts_min >= target_ts){
1794         *ts_ret= ts_min;
1795         return pos_min;
1796     }
1797
1798     if(ts_max == AV_NOPTS_VALUE){
1799         int step= 1024;
1800         filesize = avio_size(s->pb);
1801         pos_max = filesize - 1;
1802         do{
1803             pos_max -= step;
1804             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1805             step += step;
1806         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1807         if (ts_max == AV_NOPTS_VALUE)
1808             return -1;
1809
1810         for(;;){
1811             int64_t tmp_pos= pos_max + 1;
1812             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1813             if(tmp_ts == AV_NOPTS_VALUE)
1814                 break;
1815             ts_max= tmp_ts;
1816             pos_max= tmp_pos;
1817             if(tmp_pos >= filesize)
1818                 break;
1819         }
1820         pos_limit= pos_max;
1821     }
1822
1823     if(ts_max <= target_ts){
1824         *ts_ret= ts_max;
1825         return pos_max;
1826     }
1827
1828     if(ts_min > ts_max){
1829         return -1;
1830     }else if(ts_min == ts_max){
1831         pos_limit= pos_min;
1832     }
1833
1834     no_change=0;
1835     while (pos_min < pos_limit) {
1836         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1837                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1838         assert(pos_limit <= pos_max);
1839
1840         if(no_change==0){
1841             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1842             // interpolate position (better than dichotomy)
1843             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1844                 + pos_min - approximate_keyframe_distance;
1845         }else if(no_change==1){
1846             // bisection, if interpolation failed to change min or max pos last time
1847             pos = (pos_min + pos_limit)>>1;
1848         }else{
1849             /* linear search if bisection failed, can only happen if there
1850                are very few or no keyframes between min/max */
1851             pos=pos_min;
1852         }
1853         if(pos <= pos_min)
1854             pos= pos_min + 1;
1855         else if(pos > pos_limit)
1856             pos= pos_limit;
1857         start_pos= pos;
1858
1859         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1860         if(pos == pos_max)
1861             no_change++;
1862         else
1863             no_change=0;
1864         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1865                 pos_min, pos, pos_max,
1866                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1867                 pos_limit, start_pos, no_change);
1868         if(ts == AV_NOPTS_VALUE){
1869             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1870             return -1;
1871         }
1872         assert(ts != AV_NOPTS_VALUE);
1873         if (target_ts <= ts) {
1874             pos_limit = start_pos - 1;
1875             pos_max = pos;
1876             ts_max = ts;
1877         }
1878         if (target_ts >= ts) {
1879             pos_min = pos;
1880             ts_min = ts;
1881         }
1882     }
1883
1884     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1885     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1886 #if 0
1887     pos_min = pos;
1888     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1889     pos_min++;
1890     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1891     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1892             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1893 #endif
1894     *ts_ret= ts;
1895     return pos;
1896 }
1897
1898 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1899     int64_t pos_min, pos_max;
1900
1901     pos_min = s->data_offset;
1902     pos_max = avio_size(s->pb) - 1;
1903
1904     if     (pos < pos_min) pos= pos_min;
1905     else if(pos > pos_max) pos= pos_max;
1906
1907     avio_seek(s->pb, pos, SEEK_SET);
1908
1909     return 0;
1910 }
1911
1912 static int seek_frame_generic(AVFormatContext *s,
1913                                  int stream_index, int64_t timestamp, int flags)
1914 {
1915     int index;
1916     int64_t ret;
1917     AVStream *st;
1918     AVIndexEntry *ie;
1919
1920     st = s->streams[stream_index];
1921
1922     index = av_index_search_timestamp(st, timestamp, flags);
1923
1924     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1925         return -1;
1926
1927     if(index < 0 || index==st->nb_index_entries-1){
1928         AVPacket pkt;
1929         int nonkey=0;
1930
1931         if(st->nb_index_entries){
1932             assert(st->index_entries);
1933             ie= &st->index_entries[st->nb_index_entries-1];
1934             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1935                 return ret;
1936             ff_update_cur_dts(s, st, ie->timestamp);
1937         }else{
1938             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1939                 return ret;
1940         }
1941         for (;;) {
1942             int read_status;
1943             do{
1944                 read_status = av_read_frame(s, &pkt);
1945             } while (read_status == AVERROR(EAGAIN));
1946             if (read_status < 0)
1947                 break;
1948             av_free_packet(&pkt);
1949             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1950                 if(pkt.flags & AV_PKT_FLAG_KEY)
1951                     break;
1952                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1953                     av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1954                     break;
1955                 }
1956             }
1957         }
1958         index = av_index_search_timestamp(st, timestamp, flags);
1959     }
1960     if (index < 0)
1961         return -1;
1962
1963     ff_read_frame_flush(s);
1964     if (s->iformat->read_seek){
1965         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1966             return 0;
1967     }
1968     ie = &st->index_entries[index];
1969     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1970         return ret;
1971     ff_update_cur_dts(s, st, ie->timestamp);
1972
1973     return 0;
1974 }
1975
1976 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1977                                int64_t timestamp, int flags)
1978 {
1979     int ret;
1980     AVStream *st;
1981
1982     if (flags & AVSEEK_FLAG_BYTE) {
1983         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1984             return -1;
1985         ff_read_frame_flush(s);
1986         return seek_frame_byte(s, stream_index, timestamp, flags);
1987     }
1988
1989     if(stream_index < 0){
1990         stream_index= av_find_default_stream_index(s);
1991         if(stream_index < 0)
1992             return -1;
1993
1994         st= s->streams[stream_index];
1995         /* timestamp for default must be expressed in AV_TIME_BASE units */
1996         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1997     }
1998
1999     /* first, we try the format specific seek */
2000     if (s->iformat->read_seek) {
2001         ff_read_frame_flush(s);
2002         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2003     } else
2004         ret = -1;
2005     if (ret >= 0) {
2006         return 0;
2007     }
2008
2009     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2010         ff_read_frame_flush(s);
2011         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2012     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2013         ff_read_frame_flush(s);
2014         return seek_frame_generic(s, stream_index, timestamp, flags);
2015     }
2016     else
2017         return -1;
2018 }
2019
2020 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2021 {
2022     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
2023
2024     if (ret >= 0)
2025         avformat_queue_attached_pictures(s);
2026
2027     return ret;
2028 }
2029
2030 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2031 {
2032     if(min_ts > ts || max_ts < ts)
2033         return -1;
2034
2035     if (s->iformat->read_seek2) {
2036         int ret;
2037         ff_read_frame_flush(s);
2038         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2039
2040         if (ret >= 0)
2041             avformat_queue_attached_pictures(s);
2042         return ret;
2043     }
2044
2045     if(s->iformat->read_timestamp){
2046         //try to seek via read_timestamp()
2047     }
2048
2049     //Fallback to old API if new is not implemented but old is
2050     //Note the old has somewhat different semantics
2051     if (s->iformat->read_seek || 1) {
2052         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2053         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2054         if (ret<0 && ts != min_ts && max_ts != ts) {
2055             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2056             if (ret >= 0)
2057                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2058         }
2059         return ret;
2060     }
2061
2062     // try some generic seek like seek_frame_generic() but with new ts semantics
2063 }
2064
2065 /*******************************************************/
2066
2067 /**
2068  * Return TRUE if the stream has accurate duration in any stream.
2069  *
2070  * @return TRUE if the stream has accurate duration for at least one component.
2071  */
2072 static int has_duration(AVFormatContext *ic)
2073 {
2074     int i;
2075     AVStream *st;
2076
2077     for(i = 0;i < ic->nb_streams; i++) {
2078         st = ic->streams[i];
2079         if (st->duration != AV_NOPTS_VALUE)
2080             return 1;
2081     }
2082     if (ic->duration != AV_NOPTS_VALUE)
2083         return 1;
2084     return 0;
2085 }
2086
2087 /**
2088  * Estimate the stream timings from the one of each components.
2089  *
2090  * Also computes the global bitrate if possible.
2091  */
2092 static void update_stream_timings(AVFormatContext *ic)
2093 {
2094     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2095     int64_t duration, duration1, filesize;
2096     int i;
2097     AVStream *st;
2098
2099     start_time = INT64_MAX;
2100     start_time_text = INT64_MAX;
2101     end_time = INT64_MIN;
2102     duration = INT64_MIN;
2103     for(i = 0;i < ic->nb_streams; i++) {
2104         st = ic->streams[i];
2105         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2106             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2107             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2108                 if (start_time1 < start_time_text)
2109                     start_time_text = start_time1;
2110             } else
2111                 start_time = FFMIN(start_time, start_time1);
2112             if (st->duration != AV_NOPTS_VALUE) {
2113                 end_time1 = start_time1
2114                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2115                 end_time = FFMAX(end_time, end_time1);
2116             }
2117         }
2118         if (st->duration != AV_NOPTS_VALUE) {
2119             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2120             duration = FFMAX(duration, duration1);
2121         }
2122     }
2123     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2124         start_time = start_time_text;
2125     else if(start_time > start_time_text)
2126         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2127
2128     if (start_time != INT64_MAX) {
2129         ic->start_time = start_time;
2130         if (end_time != INT64_MIN)
2131             duration = FFMAX(duration, end_time - start_time);
2132     }
2133     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2134         ic->duration = duration;
2135     }
2136         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2137             /* compute the bitrate */
2138             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2139                 (double)ic->duration;
2140         }
2141 }
2142
2143 static void fill_all_stream_timings(AVFormatContext *ic)
2144 {
2145     int i;
2146     AVStream *st;
2147
2148     update_stream_timings(ic);
2149     for(i = 0;i < ic->nb_streams; i++) {
2150         st = ic->streams[i];
2151         if (st->start_time == AV_NOPTS_VALUE) {
2152             if(ic->start_time != AV_NOPTS_VALUE)
2153                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2154             if(ic->duration != AV_NOPTS_VALUE)
2155                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2156         }
2157     }
2158 }
2159
2160 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2161 {
2162     int64_t filesize, duration;
2163     int bit_rate, i;
2164     AVStream *st;
2165
2166     /* if bit_rate is already set, we believe it */
2167     if (ic->bit_rate <= 0) {
2168         bit_rate = 0;
2169         for(i=0;i<ic->nb_streams;i++) {
2170             st = ic->streams[i];
2171             if (st->codec->bit_rate > 0)
2172             bit_rate += st->codec->bit_rate;
2173         }
2174         ic->bit_rate = bit_rate;
2175     }
2176
2177     /* if duration is already set, we believe it */
2178     if (ic->duration == AV_NOPTS_VALUE &&
2179         ic->bit_rate != 0) {
2180         filesize = ic->pb ? avio_size(ic->pb) : 0;
2181         if (filesize > 0) {
2182             for(i = 0; i < ic->nb_streams; i++) {
2183                 st = ic->streams[i];
2184                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2185                 if (st->duration == AV_NOPTS_VALUE)
2186                     st->duration = duration;
2187             }
2188         }
2189     }
2190 }
2191
2192 #define DURATION_MAX_READ_SIZE 250000
2193 #define DURATION_MAX_RETRY 3
2194
2195 /* only usable for MPEG-PS streams */
2196 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2197 {
2198     AVPacket pkt1, *pkt = &pkt1;
2199     AVStream *st;
2200     int read_size, i, ret;
2201     int64_t end_time;
2202     int64_t filesize, offset, duration;
2203     int retry=0;
2204
2205     /* flush packet queue */
2206     flush_packet_queue(ic);
2207
2208     for (i=0; i<ic->nb_streams; i++) {
2209         st = ic->streams[i];
2210         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2211             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2212
2213         if (st->parser) {
2214             av_parser_close(st->parser);
2215             st->parser= NULL;
2216         }
2217     }
2218
2219     /* estimate the end time (duration) */
2220     /* XXX: may need to support wrapping */
2221     filesize = ic->pb ? avio_size(ic->pb) : 0;
2222     end_time = AV_NOPTS_VALUE;
2223     do{
2224         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2225         if (offset < 0)
2226             offset = 0;
2227
2228         avio_seek(ic->pb, offset, SEEK_SET);
2229         read_size = 0;
2230         for(;;) {
2231             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2232                 break;
2233
2234             do {
2235                 ret = ff_read_packet(ic, pkt);
2236             } while(ret == AVERROR(EAGAIN));
2237             if (ret != 0)
2238                 break;
2239             read_size += pkt->size;
2240             st = ic->streams[pkt->stream_index];
2241             if (pkt->pts != AV_NOPTS_VALUE &&
2242                 (st->start_time != AV_NOPTS_VALUE ||
2243                  st->first_dts  != AV_NOPTS_VALUE)) {
2244                 duration = end_time = pkt->pts;
2245                 if (st->start_time != AV_NOPTS_VALUE)
2246                     duration -= st->start_time;
2247                 else
2248                     duration -= st->first_dts;
2249                 if (duration < 0)
2250                     duration += 1LL<<st->pts_wrap_bits;
2251                 if (duration > 0) {
2252                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2253                         st->duration = duration;
2254                 }
2255             }
2256             av_free_packet(pkt);
2257         }
2258     }while(   end_time==AV_NOPTS_VALUE
2259            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2260            && ++retry <= DURATION_MAX_RETRY);
2261
2262     fill_all_stream_timings(ic);
2263
2264     avio_seek(ic->pb, old_offset, SEEK_SET);
2265     for (i=0; i<ic->nb_streams; i++) {
2266         st= ic->streams[i];
2267         st->cur_dts= st->first_dts;
2268         st->last_IP_pts = AV_NOPTS_VALUE;
2269         st->reference_dts = AV_NOPTS_VALUE;
2270     }
2271 }
2272
2273 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2274 {
2275     int64_t file_size;
2276
2277     /* get the file size, if possible */
2278     if (ic->iformat->flags & AVFMT_NOFILE) {
2279         file_size = 0;
2280     } else {
2281         file_size = avio_size(ic->pb);
2282         file_size = FFMAX(0, file_size);
2283     }
2284
2285     if ((!strcmp(ic->iformat->name, "mpeg") ||
2286          !strcmp(ic->iformat->name, "mpegts")) &&
2287         file_size && ic->pb->seekable) {
2288         /* get accurate estimate from the PTSes */
2289         estimate_timings_from_pts(ic, old_offset);
2290         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2291     } else if (has_duration(ic)) {
2292         /* at least one component has timings - we use them for all
2293            the components */
2294         fill_all_stream_timings(ic);
2295         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2296     } else {
2297         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2298         /* less precise: use bitrate info */
2299         estimate_timings_from_bit_rate(ic);
2300         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2301     }
2302     update_stream_timings(ic);
2303
2304     {
2305         int i;
2306         AVStream av_unused *st;
2307         for(i = 0;i < ic->nb_streams; i++) {
2308             st = ic->streams[i];
2309             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2310                     (double) st->start_time / AV_TIME_BASE,
2311                     (double) st->duration   / AV_TIME_BASE);
2312         }
2313         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2314                 (double) ic->start_time / AV_TIME_BASE,
2315                 (double) ic->duration   / AV_TIME_BASE,
2316                 ic->bit_rate / 1000);
2317     }
2318 }
2319
2320 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2321 {
2322     AVCodecContext *avctx = st->codec;
2323
2324 #define FAIL(errmsg) do {                                         \
2325         if (errmsg_ptr)                                           \
2326             *errmsg_ptr = errmsg;                                 \
2327         return 0;                                                 \
2328     } while (0)
2329
2330     switch (avctx->codec_type) {
2331     case AVMEDIA_TYPE_AUDIO:
2332         if (!avctx->frame_size && determinable_frame_size(avctx))
2333             FAIL("unspecified frame size");
2334         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2335             FAIL("unspecified sample format");
2336         if (!avctx->sample_rate)
2337             FAIL("unspecified sample rate");
2338         if (!avctx->channels)
2339             FAIL("unspecified number of channels");
2340         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2341             FAIL("no decodable DTS frames");
2342         break;
2343     case AVMEDIA_TYPE_VIDEO:
2344         if (!avctx->width)
2345             FAIL("unspecified size");
2346         if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2347             FAIL("unspecified pixel format");
2348         break;
2349     case AVMEDIA_TYPE_SUBTITLE:
2350         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2351             FAIL("unspecified size");
2352         break;
2353     case AVMEDIA_TYPE_DATA:
2354         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2355     }
2356
2357     if (avctx->codec_id == AV_CODEC_ID_NONE)
2358         FAIL("unknown codec");
2359     return 1;
2360 }
2361
2362 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2363 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2364 {
2365     const AVCodec *codec;
2366     int got_picture = 1, ret = 0;
2367     AVFrame *frame = avcodec_alloc_frame();
2368     AVSubtitle subtitle;
2369     AVPacket pkt = *avpkt;
2370
2371     if (!frame)
2372         return AVERROR(ENOMEM);
2373
2374     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2375         AVDictionary *thread_opt = NULL;
2376
2377         codec = st->codec->codec ? st->codec->codec :
2378                                    avcodec_find_decoder(st->codec->codec_id);
2379
2380         if (!codec) {
2381             st->info->found_decoder = -1;
2382             ret = -1;
2383             goto fail;
2384         }
2385
2386         /* force thread count to 1 since the h264 decoder will not extract SPS
2387          *  and PPS to extradata during multi-threaded decoding */
2388         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2389         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2390         if (!options)
2391             av_dict_free(&thread_opt);
2392         if (ret < 0) {
2393             st->info->found_decoder = -1;
2394             goto fail;
2395         }
2396         st->info->found_decoder = 1;
2397     } else if (!st->info->found_decoder)
2398         st->info->found_decoder = 1;
2399
2400     if (st->info->found_decoder < 0) {
2401         ret = -1;
2402         goto fail;
2403     }
2404
2405     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2406            ret >= 0 &&
2407            (!has_codec_parameters(st, NULL)   ||
2408            !has_decode_delay_been_guessed(st) ||
2409            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2410         got_picture = 0;
2411         avcodec_get_frame_defaults(frame);
2412         switch(st->codec->codec_type) {
2413         case AVMEDIA_TYPE_VIDEO:
2414             ret = avcodec_decode_video2(st->codec, frame,
2415                                         &got_picture, &pkt);
2416             break;
2417         case AVMEDIA_TYPE_AUDIO:
2418             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2419             break;
2420         case AVMEDIA_TYPE_SUBTITLE:
2421             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2422                                            &got_picture, &pkt);
2423             ret = pkt.size;
2424             break;
2425         default:
2426             break;
2427         }
2428         if (ret >= 0) {
2429             if (got_picture)
2430                 st->nb_decoded_frames++;
2431             pkt.data += ret;
2432             pkt.size -= ret;
2433             ret       = got_picture;
2434         }
2435     }
2436
2437     if(!pkt.data && !got_picture)
2438         ret = -1;
2439
2440 fail:
2441     avcodec_free_frame(&frame);
2442     return ret;
2443 }
2444
2445 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2446 {
2447     while (tags->id != AV_CODEC_ID_NONE) {
2448         if (tags->id == id)
2449             return tags->tag;
2450         tags++;
2451     }
2452     return 0;
2453 }
2454
2455 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2456 {
2457     int i;
2458     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2459         if(tag == tags[i].tag)
2460             return tags[i].id;
2461     }
2462     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2463         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2464             return tags[i].id;
2465     }
2466     return AV_CODEC_ID_NONE;
2467 }
2468
2469 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2470 {
2471     int i;
2472     for(i=0; tags && tags[i]; i++){
2473         int tag= ff_codec_get_tag(tags[i], id);
2474         if(tag) return tag;
2475     }
2476     return 0;
2477 }
2478
2479 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2480 {
2481     int i;
2482     for(i=0; tags && tags[i]; i++){
2483         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2484         if(id!=AV_CODEC_ID_NONE) return id;
2485     }
2486     return AV_CODEC_ID_NONE;
2487 }
2488
2489 static void compute_chapters_end(AVFormatContext *s)
2490 {
2491     unsigned int i, j;
2492     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2493
2494     for (i = 0; i < s->nb_chapters; i++)
2495         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2496             AVChapter *ch = s->chapters[i];
2497             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2498                                      : INT64_MAX;
2499
2500             for (j = 0; j < s->nb_chapters; j++) {
2501                 AVChapter *ch1 = s->chapters[j];
2502                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2503                 if (j != i && next_start > ch->start && next_start < end)
2504                     end = next_start;
2505             }
2506             ch->end = (end == INT64_MAX) ? ch->start : end;
2507         }
2508 }
2509
2510 static int get_std_framerate(int i){
2511     if(i<60*12) return (i+1)*1001;
2512     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2513 }
2514
2515 /*
2516  * Is the time base unreliable.
2517  * This is a heuristic to balance between quick acceptance of the values in
2518  * the headers vs. some extra checks.
2519  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2520  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2521  * And there are "variable" fps files this needs to detect as well.
2522  */
2523 static int tb_unreliable(AVCodecContext *c){
2524     if(   c->time_base.den >= 101L*c->time_base.num
2525        || c->time_base.den <    5L*c->time_base.num
2526 /*       || c->codec_tag == AV_RL32("DIVX")
2527        || c->codec_tag == AV_RL32("XVID")*/
2528        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2529        || c->codec_id == AV_CODEC_ID_H264
2530        )
2531         return 1;
2532     return 0;
2533 }
2534
2535 #if FF_API_FORMAT_PARAMETERS
2536 int av_find_stream_info(AVFormatContext *ic)
2537 {
2538     return avformat_find_stream_info(ic, NULL);
2539 }
2540 #endif
2541
2542 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2543 {
2544     int i, count, ret, read_size, j;
2545     AVStream *st;
2546     AVPacket pkt1, *pkt;
2547     int64_t old_offset = avio_tell(ic->pb);
2548     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2549     int flush_codecs = ic->probesize > 0;
2550
2551     if(ic->pb)
2552         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2553
2554     for(i=0;i<ic->nb_streams;i++) {
2555         const AVCodec *codec;
2556         AVDictionary *thread_opt = NULL;
2557         st = ic->streams[i];
2558
2559         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2560             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2561 /*            if(!st->time_base.num)
2562                 st->time_base= */
2563             if(!st->codec->time_base.num)
2564                 st->codec->time_base= st->time_base;
2565         }
2566         //only for the split stuff
2567         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2568             st->parser = av_parser_init(st->codec->codec_id);
2569             if(st->parser){
2570                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2571                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2572                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2573                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2574                 }
2575             } else if (st->need_parsing) {
2576                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2577                        "%s, packets or times may be invalid.\n",
2578                        avcodec_get_name(st->codec->codec_id));
2579             }
2580         }
2581         codec = st->codec->codec ? st->codec->codec :
2582                                    avcodec_find_decoder(st->codec->codec_id);
2583
2584         /* force thread count to 1 since the h264 decoder will not extract SPS
2585          *  and PPS to extradata during multi-threaded decoding */
2586         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2587
2588         /* Ensure that subtitle_header is properly set. */
2589         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2590             && codec && !st->codec->codec)
2591             avcodec_open2(st->codec, codec, options ? &options[i]
2592                               : &thread_opt);
2593
2594         //try to just open decoders, in case this is enough to get parameters
2595         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2596             if (codec && !st->codec->codec)
2597                 avcodec_open2(st->codec, codec, options ? &options[i]
2598                               : &thread_opt);
2599         }
2600         if (!options)
2601             av_dict_free(&thread_opt);
2602     }
2603
2604     for (i=0; i<ic->nb_streams; i++) {
2605 #if FF_API_R_FRAME_RATE
2606         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2607 #endif
2608         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2609         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2610     }
2611
2612     count = 0;
2613     read_size = 0;
2614     for(;;) {
2615         if (ff_check_interrupt(&ic->interrupt_callback)){
2616             ret= AVERROR_EXIT;
2617             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2618             break;
2619         }
2620
2621         /* check if one codec still needs to be handled */
2622         for(i=0;i<ic->nb_streams;i++) {
2623             int fps_analyze_framecount = 20;
2624
2625             st = ic->streams[i];
2626             if (!has_codec_parameters(st, NULL))
2627                 break;
2628             /* if the timebase is coarse (like the usual millisecond precision
2629                of mkv), we need to analyze more frames to reliably arrive at
2630                the correct fps */
2631             if (av_q2d(st->time_base) > 0.0005)
2632                 fps_analyze_framecount *= 2;
2633             if (ic->fps_probe_size >= 0)
2634                 fps_analyze_framecount = ic->fps_probe_size;
2635             /* variable fps and no guess at the real fps */
2636             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2637                && st->info->duration_count < fps_analyze_framecount
2638                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2639                 break;
2640             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2641                 break;
2642             if (st->first_dts == AV_NOPTS_VALUE &&
2643                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2644                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2645                 break;
2646         }
2647         if (i == ic->nb_streams) {
2648             /* NOTE: if the format has no header, then we need to read
2649                some packets to get most of the streams, so we cannot
2650                stop here */
2651             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2652                 /* if we found the info for all the codecs, we can stop */
2653                 ret = count;
2654                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2655                 flush_codecs = 0;
2656                 break;
2657             }
2658         }
2659         /* we did not get all the codec info, but we read too much data */
2660         if (read_size >= ic->probesize) {
2661             ret = count;
2662             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2663             for (i = 0; i < ic->nb_streams; i++)
2664                 if (!ic->streams[i]->r_frame_rate.num &&
2665                     ic->streams[i]->info->duration_count <= 1)
2666                     av_log(ic, AV_LOG_WARNING,
2667                            "Stream #%d: not enough frames to estimate rate; "
2668                            "consider increasing probesize\n", i);
2669             break;
2670         }
2671
2672         /* NOTE: a new stream can be added there if no header in file
2673            (AVFMTCTX_NOHEADER) */
2674         ret = read_frame_internal(ic, &pkt1);
2675         if (ret == AVERROR(EAGAIN))
2676             continue;
2677
2678         if (ret < 0) {
2679             /* EOF or error*/
2680             break;
2681         }
2682
2683         if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2684             pkt = &pkt1;
2685         } else {
2686             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2687                                 &ic->packet_buffer_end);
2688             if ((ret = av_dup_packet(pkt)) < 0)
2689                 goto find_stream_info_err;
2690         }
2691
2692         read_size += pkt->size;
2693
2694         st = ic->streams[pkt->stream_index];
2695         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2696             /* check for non-increasing dts */
2697             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2698                 st->info->fps_last_dts >= pkt->dts) {
2699                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2700                        "packet %d with DTS %"PRId64", packet %d with DTS "
2701                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2702                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2703                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2704             }
2705             /* check for a discontinuity in dts - if the difference in dts
2706              * is more than 1000 times the average packet duration in the sequence,
2707              * we treat it as a discontinuity */
2708             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2709                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2710                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2711                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2712                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2713                        "packet %d with DTS %"PRId64", packet %d with DTS "
2714                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2715                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2716                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2717             }
2718
2719             /* update stored dts values */
2720             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2721                 st->info->fps_first_dts     = pkt->dts;
2722                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2723             }
2724             st->info->fps_last_dts = pkt->dts;
2725             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2726         }
2727         if (st->codec_info_nb_frames>1) {
2728             int64_t t=0;
2729             if (st->time_base.den > 0)
2730                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2731             if (st->avg_frame_rate.num > 0)
2732                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2733
2734             if (t >= ic->max_analyze_duration) {
2735                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2736                 break;
2737             }
2738             st->info->codec_info_duration += pkt->duration;
2739         }
2740 #if FF_API_R_FRAME_RATE
2741         {
2742             int64_t last = st->info->last_dts;
2743
2744             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2745                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2746                 int64_t duration= pkt->dts - last;
2747
2748 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2749 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2750                 for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2751                     int framerate= get_std_framerate(i);
2752                     double sdts= dts*framerate/(1001*12);
2753                     for(j=0; j<2; j++){
2754                         int ticks= lrintf(sdts+j*0.5);
2755                         double error= sdts - ticks + j*0.5;
2756                         st->info->duration_error[j][0][i] += error;
2757                         st->info->duration_error[j][1][i] += error*error;
2758                     }
2759                 }
2760                 st->info->duration_count++;
2761                 // ignore the first 4 values, they might have some random jitter
2762                 if (st->info->duration_count > 3)
2763                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2764             }
2765             if (pkt->dts != AV_NOPTS_VALUE)
2766                 st->info->last_dts = pkt->dts;
2767         }
2768 #endif
2769         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2770             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2771             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2772                 st->codec->extradata_size= i;
2773                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2774                 if (!st->codec->extradata)
2775                     return AVERROR(ENOMEM);
2776                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2777                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2778             }
2779         }
2780
2781         /* if still no information, we try to open the codec and to
2782            decompress the frame. We try to avoid that in most cases as
2783            it takes longer and uses more memory. For MPEG-4, we need to
2784            decompress for QuickTime.
2785
2786            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2787            least one frame of codec data, this makes sure the codec initializes
2788            the channel configuration and does not only trust the values from the container.
2789         */
2790         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2791
2792         st->codec_info_nb_frames++;
2793         count++;
2794     }
2795
2796     if (flush_codecs) {
2797         AVPacket empty_pkt = { 0 };
2798         int err = 0;
2799         av_init_packet(&empty_pkt);
2800
2801         ret = -1; /* we could not have all the codec parameters before EOF */
2802         for(i=0;i<ic->nb_streams;i++) {
2803             const char *errmsg;
2804
2805             st = ic->streams[i];
2806
2807             /* flush the decoders */
2808             if (st->info->found_decoder == 1) {
2809                 do {
2810                     err = try_decode_frame(st, &empty_pkt,
2811                                             (options && i < orig_nb_streams) ?
2812                                             &options[i] : NULL);
2813                 } while (err > 0 && !has_codec_parameters(st, NULL));
2814
2815                 if (err < 0) {
2816                     av_log(ic, AV_LOG_INFO,
2817                         "decoding for stream %d failed\n", st->index);
2818                 }
2819             }
2820
2821             if (!has_codec_parameters(st, &errmsg)) {
2822                 char buf[256];
2823                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2824                 av_log(ic, AV_LOG_WARNING,
2825                        "Could not find codec parameters for stream %d (%s): %s\n"
2826                        "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2827                        i, buf, errmsg);
2828             } else {
2829                 ret = 0;
2830             }
2831         }
2832     }
2833
2834     // close codecs which were opened in try_decode_frame()
2835     for(i=0;i<ic->nb_streams;i++) {
2836         st = ic->streams[i];
2837         avcodec_close(st->codec);
2838     }
2839     for(i=0;i<ic->nb_streams;i++) {
2840         st = ic->streams[i];
2841         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2842             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2843                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2844                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2845                     st->codec->codec_tag= tag;
2846             }
2847
2848             /* estimate average framerate if not set by demuxer */
2849             if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration) {
2850                 int      best_fps = 0;
2851                 double best_error = 0.01;
2852
2853                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2854                           (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2855                           st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2856
2857                 /* round guessed framerate to a "standard" framerate if it's
2858                  * within 1% of the original estimate*/
2859                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2860                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
2861                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2862
2863                     if (error < best_error) {
2864                         best_error = error;
2865                         best_fps   = std_fps.num;
2866                     }
2867                 }
2868                 if (best_fps) {
2869                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2870                               best_fps, 12*1001, INT_MAX);
2871                 }
2872             }
2873             // the check for tb_unreliable() is not completely correct, since this is not about handling
2874             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2875             // ipmovie.c produces.
2876             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2877                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2878             if (st->info->duration_count && !st->r_frame_rate.num
2879                 && tb_unreliable(st->codec)) {
2880                 int num = 0;
2881                 double best_error= 0.01;
2882
2883                 for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2884                     int k;
2885
2886                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2887                         continue;
2888                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2889                         continue;
2890                     for(k=0; k<2; k++){
2891                         int n= st->info->duration_count;
2892                         double a= st->info->duration_error[k][0][j] / n;
2893                         double error= st->info->duration_error[k][1][j]/n - a*a;
2894
2895                         if(error < best_error && best_error> 0.000000001){
2896                             best_error= error;
2897                             num = get_std_framerate(j);
2898                         }
2899                         if(error < 0.02)
2900                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2901                     }
2902                 }
2903                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2904                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2905                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2906             }
2907
2908             if (!st->r_frame_rate.num){
2909                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2910                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2911                     st->r_frame_rate.num = st->codec->time_base.den;
2912                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2913                 }else{
2914                     st->r_frame_rate.num = st->time_base.den;
2915                     st->r_frame_rate.den = st->time_base.num;
2916                 }
2917             }
2918         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2919             if(!st->codec->bits_per_coded_sample)
2920                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2921             // set stream disposition based on audio service type
2922             switch (st->codec->audio_service_type) {
2923             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2924                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2925             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2926                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2927             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2928                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2929             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2930                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2931             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2932                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2933             }
2934         }
2935     }
2936
2937     if(ic->probesize)
2938     estimate_timings(ic, old_offset);
2939
2940     compute_chapters_end(ic);
2941
2942  find_stream_info_err:
2943     for (i=0; i < ic->nb_streams; i++) {
2944         if (ic->streams[i]->codec)
2945             ic->streams[i]->codec->thread_count = 0;
2946         av_freep(&ic->streams[i]->info);
2947     }
2948     if(ic->pb)
2949         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2950     return ret;
2951 }
2952
2953 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2954 {
2955     int i, j;
2956
2957     for (i = 0; i < ic->nb_programs; i++) {
2958         if (ic->programs[i] == last) {
2959             last = NULL;
2960         } else {
2961             if (!last)
2962                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2963                     if (ic->programs[i]->stream_index[j] == s)
2964                         return ic->programs[i];
2965         }
2966     }
2967     return NULL;
2968 }
2969
2970 int av_find_best_stream(AVFormatContext *ic,
2971                         enum AVMediaType type,
2972                         int wanted_stream_nb,
2973                         int related_stream,
2974                         AVCodec **decoder_ret,
2975                         int flags)
2976 {
2977     int i, nb_streams = ic->nb_streams;
2978     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2979     unsigned *program = NULL;
2980     AVCodec *decoder = NULL, *best_decoder = NULL;
2981
2982     if (related_stream >= 0 && wanted_stream_nb < 0) {
2983         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2984         if (p) {
2985             program = p->stream_index;
2986             nb_streams = p->nb_stream_indexes;
2987         }
2988     }
2989     for (i = 0; i < nb_streams; i++) {
2990         int real_stream_index = program ? program[i] : i;
2991         AVStream *st = ic->streams[real_stream_index];
2992         AVCodecContext *avctx = st->codec;
2993         if (avctx->codec_type != type)
2994             continue;
2995         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2996             continue;
2997         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2998             continue;
2999         if (decoder_ret) {
3000             decoder = avcodec_find_decoder(st->codec->codec_id);
3001             if (!decoder) {
3002                 if (ret < 0)
3003                     ret = AVERROR_DECODER_NOT_FOUND;
3004                 continue;
3005             }
3006         }
3007         if (best_count >= st->codec_info_nb_frames)
3008             continue;
3009         best_count = st->codec_info_nb_frames;
3010         ret = real_stream_index;
3011         best_decoder = decoder;
3012         if (program && i == nb_streams - 1 && ret < 0) {
3013             program = NULL;
3014             nb_streams = ic->nb_streams;
3015             i = 0; /* no related stream found, try again with everything */
3016         }
3017     }
3018     if (decoder_ret)
3019         *decoder_ret = best_decoder;
3020     return ret;
3021 }
3022
3023 /*******************************************************/
3024
3025 int av_read_play(AVFormatContext *s)
3026 {
3027     if (s->iformat->read_play)
3028         return s->iformat->read_play(s);
3029     if (s->pb)
3030         return avio_pause(s->pb, 0);
3031     return AVERROR(ENOSYS);
3032 }
3033
3034 int av_read_pause(AVFormatContext *s)
3035 {
3036     if (s->iformat->read_pause)
3037         return s->iformat->read_pause(s);
3038     if (s->pb)
3039         return avio_pause(s->pb, 1);
3040     return AVERROR(ENOSYS);
3041 }
3042
3043 void ff_free_stream(AVFormatContext *s, AVStream *st){
3044     av_assert0(s->nb_streams>0);
3045     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3046
3047     if (st->parser) {
3048         av_parser_close(st->parser);
3049     }
3050     if (st->attached_pic.data)
3051         av_free_packet(&st->attached_pic);
3052     av_dict_free(&st->metadata);
3053     av_freep(&st->index_entries);
3054     av_freep(&st->codec->extradata);
3055     av_freep(&st->codec->subtitle_header);
3056     av_freep(&st->codec);
3057     av_freep(&st->priv_data);
3058     av_freep(&st->info);
3059     av_freep(&st->probe_data.buf);
3060     av_freep(&s->streams[ --s->nb_streams ]);
3061 }
3062
3063 void avformat_free_context(AVFormatContext *s)
3064 {
3065     int i;
3066
3067     av_opt_free(s);
3068     if (s->iformat && s->iformat->priv_class && s->priv_data)
3069         av_opt_free(s->priv_data);
3070
3071     for(i=s->nb_streams-1; i>=0; i--) {
3072         ff_free_stream(s, s->streams[i]);
3073     }
3074     for(i=s->nb_programs-1; i>=0; i--) {
3075         av_dict_free(&s->programs[i]->metadata);
3076         av_freep(&s->programs[i]->stream_index);
3077         av_freep(&s->programs[i]);
3078     }
3079     av_freep(&s->programs);
3080     av_freep(&s->priv_data);
3081     while(s->nb_chapters--) {
3082         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3083         av_freep(&s->chapters[s->nb_chapters]);
3084     }
3085     av_freep(&s->chapters);
3086     av_dict_free(&s->metadata);
3087     av_freep(&s->streams);
3088     av_free(s);
3089 }
3090
3091 #if FF_API_CLOSE_INPUT_FILE
3092 void av_close_input_file(AVFormatContext *s)
3093 {
3094     avformat_close_input(&s);
3095 }
3096 #endif
3097
3098 void avformat_close_input(AVFormatContext **ps)
3099 {
3100     AVFormatContext *s = *ps;
3101     AVIOContext *pb = s->pb;
3102
3103     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3104         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3105         pb = NULL;
3106
3107     flush_packet_queue(s);
3108
3109     if (s->iformat) {
3110         if (s->iformat->read_close)
3111             s->iformat->read_close(s);
3112     }
3113
3114     avformat_free_context(s);
3115
3116     *ps = NULL;
3117
3118     avio_close(pb);
3119 }
3120
3121 #if FF_API_NEW_STREAM
3122 AVStream *av_new_stream(AVFormatContext *s, int id)
3123 {
3124     AVStream *st = avformat_new_stream(s, NULL);
3125     if (st)
3126         st->id = id;
3127     return st;
3128 }
3129 #endif
3130
3131 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
3132 {
3133     AVStream *st;
3134     int i;
3135     AVStream **streams;
3136
3137     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3138         return NULL;
3139     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3140     if (!streams)
3141         return NULL;
3142     s->streams = streams;
3143
3144     st = av_mallocz(sizeof(AVStream));
3145     if (!st)
3146         return NULL;
3147     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3148         av_free(st);
3149         return NULL;
3150     }
3151     st->info->last_dts = AV_NOPTS_VALUE;
3152
3153     st->codec = avcodec_alloc_context3(c);
3154     if (s->iformat) {
3155         /* no default bitrate if decoding */
3156         st->codec->bit_rate = 0;
3157     }
3158     st->index = s->nb_streams;
3159     st->start_time = AV_NOPTS_VALUE;
3160     st->duration = AV_NOPTS_VALUE;
3161         /* we set the current DTS to 0 so that formats without any timestamps
3162            but durations get some timestamps, formats with some unknown
3163            timestamps have their first few packets buffered and the
3164            timestamps corrected before they are returned to the user */
3165     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3166     st->first_dts = AV_NOPTS_VALUE;
3167     st->probe_packets = MAX_PROBE_PACKETS;
3168
3169     /* default pts setting is MPEG-like */
3170     avpriv_set_pts_info(st, 33, 1, 90000);
3171     st->last_IP_pts = AV_NOPTS_VALUE;
3172     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3173         st->pts_buffer[i]= AV_NOPTS_VALUE;
3174     st->reference_dts = AV_NOPTS_VALUE;
3175
3176     st->sample_aspect_ratio = (AVRational){0,1};
3177
3178 #if FF_API_R_FRAME_RATE
3179     st->info->last_dts      = AV_NOPTS_VALUE;
3180 #endif
3181     st->info->fps_first_dts = AV_NOPTS_VALUE;
3182     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3183
3184     s->streams[s->nb_streams++] = st;
3185     return st;
3186 }
3187
3188 AVProgram *av_new_program(AVFormatContext *ac, int id)
3189 {
3190     AVProgram *program=NULL;
3191     int i;
3192
3193     av_dlog(ac, "new_program: id=0x%04x\n", id);
3194
3195     for(i=0; i<ac->nb_programs; i++)
3196         if(ac->programs[i]->id == id)
3197             program = ac->programs[i];
3198
3199     if(!program){
3200         program = av_mallocz(sizeof(AVProgram));
3201         if (!program)
3202             return NULL;
3203         dynarray_add(&ac->programs, &ac->nb_programs, program);
3204         program->discard = AVDISCARD_NONE;
3205     }
3206     program->id = id;
3207
3208     return program;
3209 }
3210
3211 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3212 {
3213     AVChapter *chapter = NULL;
3214     int i;
3215
3216     for(i=0; i<s->nb_chapters; i++)
3217         if(s->chapters[i]->id == id)
3218             chapter = s->chapters[i];
3219
3220     if(!chapter){
3221         chapter= av_mallocz(sizeof(AVChapter));
3222         if(!chapter)
3223             return NULL;
3224         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3225     }
3226     av_dict_set(&chapter->metadata, "title", title, 0);
3227     chapter->id    = id;
3228     chapter->time_base= time_base;
3229     chapter->start = start;
3230     chapter->end   = end;
3231
3232     return chapter;
3233 }
3234
3235 /************************************************************/
3236 /* output media file */
3237
3238 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
3239                                    const char *format, const char *filename)
3240 {
3241     AVFormatContext *s = avformat_alloc_context();
3242     int ret = 0;
3243
3244     *avctx = NULL;
3245     if (!s)
3246         goto nomem;
3247
3248     if (!oformat) {
3249         if (format) {
3250             oformat = av_guess_format(format, NULL, NULL);
3251             if (!oformat) {
3252                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
3253                 ret = AVERROR(EINVAL);
3254                 goto error;
3255             }
3256         } else {
3257             oformat = av_guess_format(NULL, filename, NULL);
3258             if (!oformat) {
3259                 ret = AVERROR(EINVAL);
3260                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
3261                        filename);
3262                 goto error;
3263             }
3264         }
3265     }
3266
3267     s->oformat = oformat;
3268     if (s->oformat->priv_data_size > 0) {
3269         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3270         if (!s->priv_data)
3271             goto nomem;
3272         if (s->oformat->priv_class) {
3273             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3274             av_opt_set_defaults(s->priv_data);
3275         }
3276     } else
3277         s->priv_data = NULL;
3278
3279     if (filename)
3280         av_strlcpy(s->filename, filename, sizeof(s->filename));
3281     *avctx = s;
3282     return 0;
3283 nomem:
3284     av_log(s, AV_LOG_ERROR, "Out of memory\n");
3285     ret = AVERROR(ENOMEM);
3286 error:
3287     avformat_free_context(s);
3288     return ret;
3289 }
3290
3291 #if FF_API_ALLOC_OUTPUT_CONTEXT
3292 AVFormatContext *avformat_alloc_output_context(const char *format,
3293                                                AVOutputFormat *oformat, const char *filename)
3294 {
3295     AVFormatContext *avctx;
3296     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
3297     return ret < 0 ? NULL : avctx;
3298 }
3299 #endif
3300
3301 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
3302 {
3303     const AVCodecTag *avctag;
3304     int n;
3305     enum AVCodecID id = AV_CODEC_ID_NONE;
3306     unsigned int tag = 0;
3307
3308     /**
3309      * Check that tag + id is in the table
3310      * If neither is in the table -> OK
3311      * If tag is in the table with another id -> FAIL
3312      * If id is in the table with another tag -> FAIL unless strict < normal
3313      */
3314     for (n = 0; s->oformat->codec_tag[n]; n++) {
3315         avctag = s->oformat->codec_tag[n];
3316         while (avctag->id != AV_CODEC_ID_NONE) {
3317             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3318                 id = avctag->id;
3319                 if (id == st->codec->codec_id)
3320                     return 1;
3321             }
3322             if (avctag->id == st->codec->codec_id)
3323                 tag = avctag->tag;
3324             avctag++;
3325         }
3326     }
3327     if (id != AV_CODEC_ID_NONE)
3328         return 0;
3329     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3330         return 0;
3331     return 1;
3332 }
3333
3334 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3335 {
3336     int ret = 0, i;
3337     AVStream *st;
3338     AVDictionary *tmp = NULL;
3339
3340     if (options)
3341         av_dict_copy(&tmp, *options, 0);
3342     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3343         goto fail;
3344     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3345         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3346         goto fail;
3347
3348     // some sanity checks
3349     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3350         av_log(s, AV_LOG_ERROR, "no streams\n");
3351         ret = AVERROR(EINVAL);
3352         goto fail;
3353     }
3354
3355     for(i=0;i<s->nb_streams;i++) {
3356         st = s->streams[i];
3357
3358         switch (st->codec->codec_type) {
3359         case AVMEDIA_TYPE_AUDIO:
3360             if(st->codec->sample_rate<=0){
3361                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3362                 ret = AVERROR(EINVAL);
3363                 goto fail;
3364             }
3365             if(!st->codec->block_align)
3366                 st->codec->block_align = st->codec->channels *
3367                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
3368             break;
3369         case AVMEDIA_TYPE_VIDEO:
3370             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3371                 av_log(s, AV_LOG_ERROR, "time base not set\n");
3372                 ret = AVERROR(EINVAL);
3373                 goto fail;
3374             }
3375             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3376                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3377                 ret = AVERROR(EINVAL);
3378                 goto fail;
3379             }
3380             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3381                && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3382             ){
3383                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
3384                        "(%d/%d) and encoder layer (%d/%d)\n",
3385                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3386                        st->codec->sample_aspect_ratio.num,
3387                        st->codec->sample_aspect_ratio.den);
3388                 ret = AVERROR(EINVAL);
3389                 goto fail;
3390             }
3391             break;
3392         }
3393
3394         if(s->oformat->codec_tag){
3395             if(   st->codec->codec_tag
3396                && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO
3397                && (av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 || av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) ==MKTAG('r', 'a', 'w', ' '))
3398                && !validate_codec_tag(s, st)){
3399                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi/mov, we override it here
3400                 st->codec->codec_tag= 0;
3401             }
3402             if(st->codec->codec_tag){
3403                 if (!validate_codec_tag(s, st)) {
3404                     char tagbuf[32], cortag[32];
3405                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3406                     av_get_codec_tag_string(cortag, sizeof(cortag), av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id));
3407                     av_log(s, AV_LOG_ERROR,
3408                            "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
3409                            tagbuf, st->codec->codec_tag, st->codec->codec_id, cortag);
3410                     ret = AVERROR_INVALIDDATA;
3411                     goto fail;
3412                 }
3413             }else
3414                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3415         }
3416
3417         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3418             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3419           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3420     }
3421
3422     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3423         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3424         if (!s->priv_data) {
3425             ret = AVERROR(ENOMEM);
3426             goto fail;
3427         }
3428         if (s->oformat->priv_class) {
3429             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3430             av_opt_set_defaults(s->priv_data);
3431             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3432                 goto fail;
3433         }
3434     }
3435
3436     /* set muxer identification string */
3437     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3438         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3439     }
3440
3441     if(s->oformat->write_header){
3442         ret = s->oformat->write_header(s);
3443         if (ret >= 0 && s->pb && s->pb->error < 0)
3444             ret = s->pb->error;
3445         if (ret < 0)
3446             goto fail;
3447     }
3448
3449     /* init PTS generation */
3450     for(i=0;i<s->nb_streams;i++) {
3451         int64_t den = AV_NOPTS_VALUE;
3452         st = s->streams[i];
3453
3454         switch (st->codec->codec_type) {
3455         case AVMEDIA_TYPE_AUDIO:
3456             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3457             break;
3458         case AVMEDIA_TYPE_VIDEO:
3459             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3460             break;
3461         default:
3462             break;
3463         }
3464         if (den != AV_NOPTS_VALUE) {
3465             if (den <= 0) {
3466                 ret = AVERROR_INVALIDDATA;
3467                 goto fail;
3468             }
3469             frac_init(&st->pts, 0, 0, den);
3470         }
3471     }
3472
3473     if (options) {
3474         av_dict_free(options);
3475         *options = tmp;
3476     }
3477     return 0;
3478 fail:
3479     av_dict_free(&tmp);
3480     return ret;
3481 }
3482
3483 //FIXME merge with compute_pkt_fields
3484 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3485     int delay = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames > 0);
3486     int num, den, frame_size, i;
3487
3488     av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
3489             av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);
3490
3491     /* duration field */
3492     if (pkt->duration == 0) {
3493         compute_frame_duration(&num, &den, st, NULL, pkt);
3494         if (den && num) {
3495             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3496         }
3497     }
3498
3499     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3500         pkt->pts= pkt->dts;
3501
3502     //XXX/FIXME this is a temporary hack until all encoders output pts
3503     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3504         static int warned;
3505         if (!warned) {
3506             av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
3507             warned = 1;
3508         }
3509         pkt->dts=
3510 //        pkt->pts= st->cur_dts;
3511         pkt->pts= st->pts.val;
3512     }
3513
3514     //calculate dts from pts
3515     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3516         st->pts_buffer[0]= pkt->pts;
3517         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3518             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3519         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3520             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3521
3522         pkt->dts= st->pts_buffer[0];
3523     }
3524
3525     if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
3526         ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
3527           st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
3528         av_log(s, AV_LOG_ERROR,
3529                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
3530                st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
3531         return AVERROR(EINVAL);
3532     }
3533     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3534         av_log(s, AV_LOG_ERROR, "pts (%s) < dts (%s) in stream %d\n",
3535                av_ts2str(pkt->pts), av_ts2str(pkt->dts), st->index);
3536         return AVERROR(EINVAL);
3537     }
3538
3539 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%s dts2:%s\n", av_ts2str(pkt->pts), av_ts2str(pkt->dts));
3540     st->cur_dts= pkt->dts;
3541     st->pts.val= pkt->dts;
3542
3543     /* update pts */
3544     switch (st->codec->codec_type) {
3545     case AVMEDIA_TYPE_AUDIO:
3546         frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3547
3548         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3549            likely equal to the encoder delay, but it would be better if we
3550            had the real timestamps from the encoder */
3551         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3552             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3553         }
3554         break;
3555     case AVMEDIA_TYPE_VIDEO:
3556         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3557         break;
3558     default:
3559         break;
3560     }
3561     return 0;
3562 }
3563
3564 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3565 {
3566     int ret;
3567
3568     if (!pkt) {
3569         if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
3570             ret = s->oformat->write_packet(s, pkt);
3571             if (ret >= 0 && s->pb && s->pb->error < 0)
3572                 ret = s->pb->error;
3573             return ret;
3574         }
3575         return 1;
3576     }
3577
3578     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3579
3580     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3581         return ret;
3582
3583     ret= s->oformat->write_packet(s, pkt);
3584     if (ret >= 0 && s->pb && s->pb->error < 0)
3585         ret = s->pb->error;
3586
3587     if (ret >= 0)
3588         s->streams[pkt->stream_index]->nb_frames++;
3589     return ret;
3590 }
3591
3592 #define CHUNK_START 0x1000
3593
3594 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3595                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3596 {
3597     AVPacketList **next_point, *this_pktl;
3598     AVStream *st= s->streams[pkt->stream_index];
3599     int chunked= s->max_chunk_size || s->max_chunk_duration;
3600
3601     this_pktl = av_mallocz(sizeof(AVPacketList));
3602     if (!this_pktl)
3603         return AVERROR(ENOMEM);
3604     this_pktl->pkt= *pkt;
3605     pkt->destruct= NULL;             // do not free original but only the copy
3606     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-allocated memory
3607
3608     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3609         next_point = &(st->last_in_packet_buffer->next);
3610     }else{
3611         next_point = &s->packet_buffer;
3612     }
3613
3614     if(*next_point){
3615         if(chunked){
3616             uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3617             if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
3618                && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3619                 st->interleaver_chunk_size     += pkt->size;
3620                 st->interleaver_chunk_duration += pkt->duration;
3621                 goto next_non_null;
3622             }else{
3623                 st->interleaver_chunk_size     =
3624                 st->interleaver_chunk_duration = 0;
3625                 this_pktl->pkt.flags |= CHUNK_START;
3626             }
3627         }
3628
3629         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3630             while(   *next_point
3631                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3632                       || !compare(s, &(*next_point)->pkt, pkt))){
3633                 next_point= &(*next_point)->next;
3634             }
3635             if(*next_point)
3636                 goto next_non_null;
3637         }else{
3638             next_point = &(s->packet_buffer_end->next);
3639         }
3640     }
3641     assert(!*next_point);
3642
3643     s->packet_buffer_end= this_pktl;
3644 next_non_null:
3645
3646     this_pktl->next= *next_point;
3647
3648     s->streams[pkt->stream_index]->last_in_packet_buffer=
3649     *next_point= this_pktl;
3650     return 0;
3651 }
3652
3653 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3654 {
3655     AVStream *st = s->streams[ pkt ->stream_index];
3656     AVStream *st2= s->streams[ next->stream_index];
3657     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3658                              st->time_base);
3659     if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3660         int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3661         int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3662         if(ts == ts2){
3663             ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
3664                -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
3665             ts2=0;
3666         }
3667         comp= (ts>ts2) - (ts<ts2);
3668     }
3669
3670     if (comp == 0)
3671         return pkt->stream_index < next->stream_index;
3672     return comp > 0;
3673 }
3674
3675 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3676                                  AVPacket *pkt, int flush)
3677 {
3678     AVPacketList *pktl;
3679     int stream_count=0, noninterleaved_count=0;
3680     int64_t delta_dts_max = 0;
3681     int i, ret;
3682
3683     if(pkt){
3684         ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3685         if (ret < 0)
3686             return ret;
3687     }
3688
3689     for(i=0; i < s->nb_streams; i++) {
3690         if (s->streams[i]->last_in_packet_buffer) {
3691             ++stream_count;
3692         } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3693             ++noninterleaved_count;
3694         }
3695     }
3696
3697     if (s->nb_streams == stream_count) {
3698         flush = 1;
3699     } else if (!flush){
3700         for(i=0; i < s->nb_streams; i++) {
3701             if (s->streams[i]->last_in_packet_buffer) {
3702                 int64_t delta_dts =
3703                     av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3704                                 s->streams[i]->time_base,
3705                                 AV_TIME_BASE_Q) -
3706                     av_rescale_q(s->packet_buffer->pkt.dts,
3707                                 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3708                                 AV_TIME_BASE_Q);
3709                 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3710             }
3711         }
3712         if(s->nb_streams == stream_count+noninterleaved_count &&
3713            delta_dts_max > 20*AV_TIME_BASE) {
3714             av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3715             flush = 1;
3716         }
3717     }
3718     if(stream_count && flush){
3719         AVStream *st;
3720         pktl= s->packet_buffer;
3721         *out= pktl->pkt;
3722         st = s->streams[out->stream_index];
3723
3724         s->packet_buffer= pktl->next;
3725         if(!s->packet_buffer)
3726             s->packet_buffer_end= NULL;
3727
3728         if(st->last_in_packet_buffer == pktl)
3729             st->last_in_packet_buffer= NULL;
3730         av_freep(&pktl);
3731
3732         if (s->avoid_negative_ts > 0) {
3733             if (out->dts != AV_NOPTS_VALUE) {
3734                 if (!st->mux_ts_offset && out->dts < 0) {
3735                     for(i=0; i < s->nb_streams; i++) {
3736                         s->streams[i]->mux_ts_offset =
3737                             av_rescale_q_rnd(-out->dts,
3738                                              st->time_base,
3739                                              s->streams[i]->time_base,
3740                                              AV_ROUND_UP);
3741                     }
3742                 }
3743                 out->dts += st->mux_ts_offset;
3744             }
3745             if (out->pts != AV_NOPTS_VALUE)
3746                 out->pts += st->mux_ts_offset;
3747         }
3748
3749         return 1;
3750     }else{
3751         av_init_packet(out);
3752         return 0;
3753     }
3754 }
3755
3756 #if FF_API_INTERLEAVE_PACKET
3757 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3758                                  AVPacket *pkt, int flush)
3759 {
3760     return ff_interleave_packet_per_dts(s, out, pkt, flush);
3761 }
3762 #endif
3763
3764 /**
3765  * Interleave an AVPacket correctly so it can be muxed.
3766  * @param out the interleaved packet will be output here
3767  * @param in the input packet
3768  * @param flush 1 if no further packets are available as input and all
3769  *              remaining packets should be output
3770  * @return 1 if a packet was output, 0 if no packet could be output,
3771  *         < 0 if an error occurred
3772  */
3773 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3774     if (s->oformat->interleave_packet) {
3775         int ret = s->oformat->interleave_packet(s, out, in, flush);
3776         if (in)
3777             av_free_packet(in);
3778         return ret;
3779     } else
3780         return ff_interleave_packet_per_dts(s, out, in, flush);
3781 }
3782
3783 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3784     int ret, flush = 0;
3785
3786     if (pkt) {
3787         AVStream *st= s->streams[ pkt->stream_index];
3788
3789         //FIXME/XXX/HACK drop zero sized packets
3790         if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3791             return 0;
3792
3793         av_dlog(s, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
3794                 pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));
3795         if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3796             return ret;
3797
3798         if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3799             return AVERROR(EINVAL);
3800     } else {
3801         av_dlog(s, "av_interleaved_write_frame FLUSH\n");
3802         flush = 1;
3803     }
3804
3805     for(;;){
3806         AVPacket opkt;
3807         int ret= interleave_packet(s, &opkt, pkt, flush);
3808         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3809             return ret;
3810
3811         ret= s->oformat->write_packet(s, &opkt);
3812         if (ret >= 0)
3813             s->streams[opkt.stream_index]->nb_frames++;
3814
3815         av_free_packet(&opkt);
3816         pkt= NULL;
3817
3818         if(ret<0)
3819             return ret;
3820         if(s->pb && s->pb->error)
3821             return s->pb->error;
3822     }
3823 }
3824
3825 int av_write_trailer(AVFormatContext *s)
3826 {
3827     int ret, i;
3828
3829     for (;;) {
3830         AVPacket pkt;
3831         ret = interleave_packet(s, &pkt, NULL, 1);
3832         if (ret < 0) //FIXME cleanup needed for ret<0 ?
3833             goto fail;
3834         if (!ret)
3835             break;
3836
3837         ret = s->oformat->write_packet(s, &pkt);
3838         if (ret >= 0)
3839             s->streams[pkt.stream_index]->nb_frames++;
3840
3841         av_free_packet(&pkt);
3842
3843         if (ret < 0)
3844             goto fail;
3845         if(s->pb && s->pb->error)
3846             goto fail;
3847     }
3848
3849     if (s->oformat->write_trailer)
3850         ret = s->oformat->write_trailer(s);
3851
3852 fail:
3853     if (s->pb)
3854        avio_flush(s->pb);
3855     if (ret == 0)
3856        ret = s->pb ? s->pb->error : 0;
3857     for (i = 0; i < s->nb_streams; i++) {
3858         av_freep(&s->streams[i]->priv_data);
3859         av_freep(&s->streams[i]->index_entries);
3860     }
3861     if (s->oformat->priv_class)
3862         av_opt_free(s->priv_data);
3863     av_freep(&s->priv_data);
3864     return ret;
3865 }
3866
3867 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3868                             int64_t *dts, int64_t *wall)
3869 {
3870     if (!s->oformat || !s->oformat->get_output_timestamp)
3871         return AVERROR(ENOSYS);
3872     s->oformat->get_output_timestamp(s, stream, dts, wall);
3873     return 0;
3874 }
3875
3876 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3877 {
3878     int i, j;
3879     AVProgram *program=NULL;
3880     void *tmp;
3881
3882     if (idx >= ac->nb_streams) {
3883         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3884         return;
3885     }
3886
3887     for(i=0; i<ac->nb_programs; i++){
3888         if(ac->programs[i]->id != progid)
3889             continue;
3890         program = ac->programs[i];
3891         for(j=0; j<program->nb_stream_indexes; j++)
3892             if(program->stream_index[j] == idx)
3893                 return;
3894
3895         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3896         if(!tmp)
3897             return;
3898         program->stream_index = tmp;
3899         program->stream_index[program->nb_stream_indexes++] = idx;
3900         return;
3901     }
3902 }
3903
3904 static void print_fps(double d, const char *postfix){
3905     uint64_t v= lrintf(d*100);
3906     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3907     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3908     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3909 }
3910
3911 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3912 {
3913     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3914         AVDictionaryEntry *tag=NULL;
3915
3916         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3917         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3918             if(strcmp("language", tag->key)){
3919                 const char *p = tag->value;
3920                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3921                 while(*p) {
3922                     char tmp[256];
3923                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3924                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3925                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3926                     p += len;
3927                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3928                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3929                     if (*p) p++;
3930                 }
3931                 av_log(ctx, AV_LOG_INFO, "\n");
3932             }
3933         }
3934     }
3935 }
3936
3937 /* "user interface" functions */
3938 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3939 {
3940     char buf[256];
3941     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3942     AVStream *st = ic->streams[i];
3943     int g = av_gcd(st->time_base.num, st->time_base.den);
3944     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3945     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3946     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3947     /* the pid is an important information, so we display it */
3948     /* XXX: add a generic system */
3949     if (flags & AVFMT_SHOW_IDS)
3950         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3951     if (lang)
3952         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3953     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3954     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3955     if (st->sample_aspect_ratio.num && // default
3956         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3957         AVRational display_aspect_ratio;
3958         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3959                   st->codec->width*st->sample_aspect_ratio.num,
3960                   st->codec->height*st->sample_aspect_ratio.den,
3961                   1024*1024);
3962         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3963                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3964                  display_aspect_ratio.num, display_aspect_ratio.den);
3965     }
3966     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3967         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3968             print_fps(av_q2d(st->avg_frame_rate), "fps");
3969 #if FF_API_R_FRAME_RATE
3970         if(st->r_frame_rate.den && st->r_frame_rate.num)
3971             print_fps(av_q2d(st->r_frame_rate), "tbr");
3972 #endif
3973         if(st->time_base.den && st->time_base.num)
3974             print_fps(1/av_q2d(st->time_base), "tbn");
3975         if(st->codec->time_base.den && st->codec->time_base.num)
3976             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3977     }
3978     if (st->disposition & AV_DISPOSITION_DEFAULT)
3979         av_log(NULL, AV_LOG_INFO, " (default)");
3980     if (st->disposition & AV_DISPOSITION_DUB)
3981         av_log(NULL, AV_LOG_INFO, " (dub)");
3982     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3983         av_log(NULL, AV_LOG_INFO, " (original)");
3984     if (st->disposition & AV_DISPOSITION_COMMENT)
3985         av_log(NULL, AV_LOG_INFO, " (comment)");
3986     if (st->disposition & AV_DISPOSITION_LYRICS)
3987         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3988     if (st->disposition & AV_DISPOSITION_KARAOKE)
3989         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3990     if (st->disposition & AV_DISPOSITION_FORCED)
3991         av_log(NULL, AV_LOG_INFO, " (forced)");
3992     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3993         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3994     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3995         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3996     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3997         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3998     av_log(NULL, AV_LOG_INFO, "\n");
3999     dump_metadata(NULL, st->metadata, "    ");
4000 }
4001
4002 void av_dump_format(AVFormatContext *ic,
4003                     int index,
4004                     const char *url,
4005                     int is_output)
4006 {
4007     int i;
4008     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
4009     if (ic->nb_streams && !printed)
4010         return;
4011
4012     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
4013             is_output ? "Output" : "Input",
4014             index,
4015             is_output ? ic->oformat->name : ic->iformat->name,
4016             is_output ? "to" : "from", url);
4017     dump_metadata(NULL, ic->metadata, "  ");
4018     if (!is_output) {
4019         av_log(NULL, AV_LOG_INFO, "  Duration: ");
4020         if (ic->duration != AV_NOPTS_VALUE) {
4021             int hours, mins, secs, us;
4022             secs = ic->duration / AV_TIME_BASE;
4023             us = ic->duration % AV_TIME_BASE;
4024             mins = secs / 60;
4025             secs %= 60;
4026             hours = mins / 60;
4027             mins %= 60;
4028             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
4029                    (100 * us) / AV_TIME_BASE);
4030         } else {
4031             av_log(NULL, AV_LOG_INFO, "N/A");
4032         }
4033         if (ic->start_time != AV_NOPTS_VALUE) {
4034             int secs, us;
4035             av_log(NULL, AV_LOG_INFO, ", start: ");
4036             secs = ic->start_time / AV_TIME_BASE;
4037             us = abs(ic->start_time % AV_TIME_BASE);
4038             av_log(NULL, AV_LOG_INFO, "%d.%06d",
4039                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
4040         }
4041         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
4042         if (ic->bit_rate) {
4043             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
4044         } else {
4045             av_log(NULL, AV_LOG_INFO, "N/A");
4046         }
4047         av_log(NULL, AV_LOG_INFO, "\n");
4048     }
4049     for (i = 0; i < ic->nb_chapters; i++) {
4050         AVChapter *ch = ic->chapters[i];
4051         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
4052         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
4053         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
4054
4055         dump_metadata(NULL, ch->metadata, "    ");
4056     }
4057     if(ic->nb_programs) {
4058         int j, k, total = 0;
4059         for(j=0; j<ic->nb_programs; j++) {
4060             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
4061                                                   "name", NULL, 0);
4062             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
4063                    name ? name->value : "");
4064             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
4065             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
4066                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
4067                 printed[ic->programs[j]->stream_index[k]] = 1;
4068             }
4069             total += ic->programs[j]->nb_stream_indexes;
4070         }
4071         if (total < ic->nb_streams)
4072             av_log(NULL, AV_LOG_INFO, "  No Program\n");
4073     }
4074     for(i=0;i<ic->nb_streams;i++)
4075         if (!printed[i])
4076             dump_stream_format(ic, i, index, is_output);
4077
4078     av_free(printed);
4079 }
4080
4081 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
4082 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
4083 {
4084     return av_gettime();
4085 }
4086 #endif
4087
4088 uint64_t ff_ntp_time(void)
4089 {
4090   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4091 }
4092
4093 int av_get_frame_filename(char *buf, int buf_size,
4094                           const char *path, int number)
4095 {
4096     const char *p;
4097     char *q, buf1[20], c;
4098     int nd, len, percentd_found;
4099
4100     q = buf;
4101     p = path;
4102     percentd_found = 0;
4103     for(;;) {
4104         c = *p++;
4105         if (c == '\0')
4106             break;
4107         if (c == '%') {
4108             do {
4109                 nd = 0;
4110                 while (isdigit(*p)) {
4111                     nd = nd * 10 + *p++ - '0';
4112                 }
4113                 c = *p++;
4114             } while (isdigit(c));
4115
4116             switch(c) {
4117             case '%':
4118                 goto addchar;
4119             case 'd':
4120                 if (percentd_found)
4121                     goto fail;
4122                 percentd_found = 1;
4123                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4124                 len = strlen(buf1);
4125                 if ((q - buf + len) > buf_size - 1)
4126                     goto fail;
4127                 memcpy(q, buf1, len);
4128                 q += len;
4129                 break;
4130             default:
4131                 goto fail;
4132             }
4133         } else {
4134         addchar:
4135             if ((q - buf) < buf_size - 1)
4136                 *q++ = c;
4137         }
4138     }
4139     if (!percentd_found)
4140         goto fail;
4141     *q = '\0';
4142     return 0;
4143  fail:
4144     *q = '\0';
4145     return -1;
4146 }
4147
4148 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
4149 {
4150     int len, i, j, c;
4151 #undef fprintf
4152 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
4153
4154     for(i=0;i<size;i+=16) {
4155         len = size - i;
4156         if (len > 16)
4157             len = 16;
4158         PRINT("%08x ", i);
4159         for(j=0;j<16;j++) {
4160             if (j < len)
4161                 PRINT(" %02x", buf[i+j]);
4162             else
4163                 PRINT("   ");
4164         }
4165         PRINT(" ");
4166         for(j=0;j<len;j++) {
4167             c = buf[i+j];
4168             if (c < ' ' || c > '~')
4169                 c = '.';
4170             PRINT("%c", c);
4171         }
4172         PRINT("\n");
4173     }
4174 #undef PRINT
4175 }
4176
4177 void av_hex_dump(FILE *f, uint8_t *buf, int size)
4178 {
4179     hex_dump_internal(NULL, f, 0, buf, size);
4180 }
4181
4182 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
4183 {
4184     hex_dump_internal(avcl, NULL, level, buf, size);
4185 }
4186
4187 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
4188 {
4189 #undef fprintf
4190 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
4191     PRINT("stream #%d:\n", pkt->stream_index);
4192     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
4193     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
4194     /* DTS is _always_ valid after av_read_frame() */
4195     PRINT("  dts=");
4196     if (pkt->dts == AV_NOPTS_VALUE)
4197         PRINT("N/A");
4198     else
4199         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
4200     /* PTS may not be known if B-frames are present. */
4201     PRINT("  pts=");
4202     if (pkt->pts == AV_NOPTS_VALUE)
4203         PRINT("N/A");
4204     else
4205         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
4206     PRINT("\n");
4207     PRINT("  size=%d\n", pkt->size);
4208 #undef PRINT
4209     if (dump_payload)
4210         av_hex_dump(f, pkt->data, pkt->size);
4211 }
4212
4213 #if FF_API_PKT_DUMP
4214 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
4215 {
4216     AVRational tb = { 1, AV_TIME_BASE };
4217     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
4218 }
4219 #endif
4220
4221 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
4222 {
4223   &nb