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