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