git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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