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