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