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

   1 /*
   2  * various utility functions for use within FFmpeg
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /* #define DEBUG */
  23
  24 #include "avformat.h"
  25 #include "avio_internal.h"
  26 #include "internal.h"
  27 #include "libavcodec/internal.h"
  28 #include "libavcodec/raw.h"
  29 #include "libavcodec/bytestream.h"
  30 #include "libavutil/avassert.h"
  31 #include "libavutil/opt.h"
  32 #include "libavutil/dict.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "metadata.h"
  35 #include "id3v2.h"
  36 #include "libavutil/avassert.h"
  37 #include "libavutil/avstring.h"
  38 #include "libavutil/mathematics.h"
  39 #include "libavutil/parseutils.h"
  40 #include "libavutil/time.h"
  41 #include "libavutil/timestamp.h"
  42 #include "riff.h"
  43 #include "audiointerleave.h"
  44 #include "url.h"
  45 #include <stdarg.h>
  46 #if CONFIG_NETWORK
  47 #include "network.h"
  48 #endif
  49
  50 #undef NDEBUG
  51 #include <assert.h>
  52
  53 /**
  54  * @file
  55  * various utility functions for use within FFmpeg
  56  */
  57
  58 unsigned avformat_version(void)
  59 {
  60     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
  61     return LIBAVFORMAT_VERSION_INT;
  62 }
  63
  64 const char *avformat_configuration(void)
  65 {
  66     return FFMPEG_CONFIGURATION;
  67 }
  68
  69 const char *avformat_license(void)
  70 {
  71 #define LICENSE_PREFIX "libavformat license: "
  72     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  73 }
  74
  75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
  76
  77 static int is_relative(int64_t ts) {
  78     return ts > (RELATIVE_TS_BASE - (1LL<<48));
  79 }
  80
  81 /**
  82  * Wrap a given time stamp, if there is an indication for an overflow
  83  *
  84  * @param st stream
  85  * @param timestamp the time stamp to wrap
  86  * @return resulting time stamp
  87  */
  88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
  89 {
  90     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
  91         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
  92         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
  93             timestamp < st->pts_wrap_reference)
  94             return timestamp + (1ULL<<st->pts_wrap_bits);
  95         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
  96             timestamp >= st->pts_wrap_reference)
  97             return timestamp - (1ULL<<st->pts_wrap_bits);
  98     }
  99     return timestamp;
 100 }
 101
 102 #define MAKE_ACCESSORS(str, name, type, field) \
 103     type av_##name##_get_##field(const str *s) { return s->field; } \
 104     void av_##name##_set_##field(str *s, type v) { s->field = v; }
 105
 106 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
 107
 108 /** head of registered input format linked list */
 109 static AVInputFormat *first_iformat = NULL;
 110 /** head of registered output format linked list */
 111 static AVOutputFormat *first_oformat = NULL;
 112
 113 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
 114 {
 115     if(f) return f->next;
 116     else  return first_iformat;
 117 }
 118
 119 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
 120 {
 121     if(f) return f->next;
 122     else  return first_oformat;
 123 }
 124
 125 void av_register_input_format(AVInputFormat *format)
 126 {
 127     AVInputFormat **p;
 128     p = &first_iformat;
 129     while (*p != NULL) p = &(*p)->next;
 130     *p = format;
 131     format->next = NULL;
 132 }
 133
 134 void av_register_output_format(AVOutputFormat *format)
 135 {
 136     AVOutputFormat **p;
 137     p = &first_oformat;
 138     while (*p != NULL) p = &(*p)->next;
 139     *p = format;
 140     format->next = NULL;
 141 }
 142
 143 int av_match_ext(const char *filename, const char *extensions)
 144 {
 145     const char *ext, *p;
 146     char ext1[32], *q;
 147
 148     if(!filename)
 149         return 0;
 150
 151     ext = strrchr(filename, '.');
 152     if (ext) {
 153         ext++;
 154         p = extensions;
 155         for(;;) {
 156             q = ext1;
 157             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
 158                 *q++ = *p++;
 159             *q = '\0';
 160             if (!av_strcasecmp(ext1, ext))
 161                 return 1;
 162             if (*p == '\0')
 163                 break;
 164             p++;
 165         }
 166     }
 167     return 0;
 168 }
 169
 170 static int match_format(const char *name, const char *names)
 171 {
 172     const char *p;
 173     int len, namelen;
 174
 175     if (!name || !names)
 176         return 0;
 177
 178     namelen = strlen(name);
 179     while ((p = strchr(names, ','))) {
 180         len = FFMAX(p - names, namelen);
 181         if (!av_strncasecmp(name, names, len))
 182             return 1;
 183         names = p+1;
 184     }
 185     return !av_strcasecmp(name, names);
 186 }
 187
 188 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
 189                                 const char *mime_type)
 190 {
 191     AVOutputFormat *fmt = NULL, *fmt_found;
 192     int score_max, score;
 193
 194     /* specific test for image sequences */
 195 #if CONFIG_IMAGE2_MUXER
 196     if (!short_name && filename &&
 197         av_filename_number_test(filename) &&
 198         ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
 199         return av_guess_format("image2", NULL, NULL);
 200     }
 201 #endif
 202     /* Find the proper file type. */
 203     fmt_found = NULL;
 204     score_max = 0;
 205     while ((fmt = av_oformat_next(fmt))) {
 206         score = 0;
 207         if (fmt->name && short_name && match_format(short_name, fmt->name))
 208             score += 100;
 209         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 210             score += 10;
 211         if (filename && fmt->extensions &&
 212             av_match_ext(filename, fmt->extensions)) {
 213             score += 5;
 214         }
 215         if (score > score_max) {
 216             score_max = score;
 217             fmt_found = fmt;
 218         }
 219     }
 220     return fmt_found;
 221 }
 222
 223 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 224                             const char *filename, const char *mime_type, enum AVMediaType type){
 225     if (!strcmp(fmt->name, "segment") || !strcmp(fmt->name, "ssegment")) {
 226         fmt = av_guess_format(NULL, filename, NULL);
 227     }
 228
 229     if(type == AVMEDIA_TYPE_VIDEO){
 230         enum AVCodecID codec_id= AV_CODEC_ID_NONE;
 231
 232 #if CONFIG_IMAGE2_MUXER
 233         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 234             codec_id= ff_guess_image2_codec(filename);
 235         }
 236 #endif
 237         if(codec_id == AV_CODEC_ID_NONE)
 238             codec_id= fmt->video_codec;
 239         return codec_id;
 240     }else if(type == AVMEDIA_TYPE_AUDIO)
 241         return fmt->audio_codec;
 242     else if (type == AVMEDIA_TYPE_SUBTITLE)
 243         return fmt->subtitle_codec;
 244     else
 245         return AV_CODEC_ID_NONE;
 246 }
 247
 248 AVInputFormat *av_find_input_format(const char *short_name)
 249 {
 250     AVInputFormat *fmt = NULL;
 251     while ((fmt = av_iformat_next(fmt))) {
 252         if (match_format(short_name, fmt->name))
 253             return fmt;
 254     }
 255     return NULL;
 256 }
 257
 258 /* an arbitrarily chosen "sane" max packet size -- 50M */
 259 #define SANE_CHUNK_SIZE (50000000)
 260
 261 int ffio_limit(AVIOContext *s, int size)
 262 {
 263     if(s->maxsize>=0){
 264         int64_t remaining= s->maxsize - avio_tell(s);
 265         if(remaining < size){
 266             int64_t newsize= avio_size(s);
 267             if(!s->maxsize || s->maxsize<newsize)
 268                 s->maxsize= newsize - !newsize;
 269             remaining= s->maxsize - avio_tell(s);
 270             remaining= FFMAX(remaining, 0);
 271         }
 272
 273         if(s->maxsize>=0 && remaining+1 < size){
 274             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
 275             size= remaining+1;
 276         }
 277     }
 278     return size;
 279 }
 280
 281 /*
 282  * Read the data in sane-sized chunks and append to pkt.
 283  * Return the number of bytes read or an error.
 284  */
 285 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
 286 {
 287     int orig_pos       = pkt->pos; // av_grow_packet might reset pos
 288     int orig_size      = pkt->size;
 289     int ret;
 290
 291     do {
 292         int prev_size = pkt->size;
 293         int read_size;
 294
 295         /*
 296          * When the caller requests a lot of data, limit it to the amount left
 297          * in file or SANE_CHUNK_SIZE when it is not known
 298          */
 299         read_size = size;
 300         if (read_size > SANE_CHUNK_SIZE/10) {
 301             read_size = ffio_limit(s, read_size);
 302             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
 303             if (s->maxsize < 0)
 304                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
 305         }
 306
 307         ret = av_grow_packet(pkt, read_size);
 308         if (ret < 0)
 309             break;
 310
 311         ret = avio_read(s, pkt->data + prev_size, read_size);
 312         if (ret != read_size) {
 313             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
 314             break;
 315         }
 316
 317         size -= read_size;
 318     } while (size > 0);
 319     if (size > 0)
 320         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 321
 322     pkt->pos = orig_pos;
 323     if (!pkt->size)
 324         av_free_packet(pkt);
 325     return pkt->size > orig_size ? pkt->size - orig_size : ret;
 326 }
 327
 328 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 329 {
 330     av_init_packet(pkt);
 331     pkt->data = NULL;
 332     pkt->size = 0;
 333     pkt->pos  = avio_tell(s);
 334
 335     return append_packet_chunked(s, pkt, size);
 336 }
 337
 338 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 339 {
 340     if (!pkt->size)
 341         return av_get_packet(s, pkt, size);
 342     return append_packet_chunked(s, pkt, size);
 343 }
 344
 345
 346 int av_filename_number_test(const char *filename)
 347 {
 348     char buf[1024];
 349     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 350 }
 351
 352 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
 353 {
 354     AVProbeData lpd = *pd;
 355     AVInputFormat *fmt1 = NULL, *fmt;
 356     int score, nodat = 0, score_max=0;
 357     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
 358
 359     if (!lpd.buf)
 360         lpd.buf = zerobuffer;
 361
 362     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 363         int id3len = ff_id3v2_tag_len(lpd.buf);
 364         if (lpd.buf_size > id3len + 16) {
 365             lpd.buf += id3len;
 366             lpd.buf_size -= id3len;
 367         }else
 368             nodat = 1;
 369     }
 370
 371     fmt = NULL;
 372     while ((fmt1 = av_iformat_next(fmt1))) {
 373         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 374             continue;
 375         score = 0;
 376         if (fmt1->read_probe) {
 377             score = fmt1->read_probe(&lpd);
 378             if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
 379                 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
 380         } else if (fmt1->extensions) {
 381             if (av_match_ext(lpd.filename, fmt1->extensions)) {
 382                 score = 50;
 383             }
 384         }
 385         if (score > score_max) {
 386             score_max = score;
 387             fmt = fmt1;
 388         }else if (score == score_max)
 389             fmt = NULL;
 390     }
 391     *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     /* fallback to 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             got_packet = 0;
1510         }
1511     }
1512
1513     if (!got_packet && s->parse_queue)
1514         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1515
1516     if(s->debug & FF_FDEBUG_TS)
1517         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1518             pkt->stream_index,
1519             av_ts2str(pkt->pts),
1520             av_ts2str(pkt->dts),
1521             pkt->size,
1522             pkt->duration,
1523             pkt->flags);
1524
1525     return ret;
1526 }
1527
1528 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1529 {
1530     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1531     int          eof = 0;
1532     int ret;
1533     AVStream *st;
1534
1535     if (!genpts) {
1536         ret = s->packet_buffer ?
1537             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1538             read_frame_internal(s, pkt);
1539         if (ret < 0)
1540             return ret;
1541         goto return_packet;
1542     }
1543
1544     for (;;) {
1545         AVPacketList *pktl = s->packet_buffer;
1546
1547         if (pktl) {
1548             AVPacket *next_pkt = &pktl->pkt;
1549
1550             if (next_pkt->dts != AV_NOPTS_VALUE) {
1551                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1552                 // last dts seen for this stream. if any of packets following
1553                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1554                 int64_t last_dts = next_pkt->dts;
1555                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1556                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1557                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1558                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1559                             next_pkt->pts = pktl->pkt.dts;
1560                         }
1561                         if (last_dts != AV_NOPTS_VALUE) {
1562                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1563                             last_dts = pktl->pkt.dts;
1564                         }
1565                     }
1566                     pktl = pktl->next;
1567                 }
1568                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1569                     // Fixing the last reference frame had none pts issue (For MXF etc).
1570                     // We only do this when
1571                     // 1. eof.
1572                     // 2. we are not able to resolve a pts value for current packet.
1573                     // 3. the packets for this stream at the end of the files had valid dts.
1574                     next_pkt->pts = last_dts + next_pkt->duration;
1575                 }
1576                 pktl = s->packet_buffer;
1577             }
1578
1579             /* read packet from packet buffer, if there is data */
1580             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1581                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1582                 ret = read_from_packet_buffer(&s->packet_buffer,
1583                                                &s->packet_buffer_end, pkt);
1584                 goto return_packet;
1585             }
1586         }
1587
1588         ret = read_frame_internal(s, pkt);
1589         if (ret < 0) {
1590             if (pktl && ret != AVERROR(EAGAIN)) {
1591                 eof = 1;
1592                 continue;
1593             } else
1594                 return ret;
1595         }
1596
1597         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1598                           &s->packet_buffer_end)) < 0)
1599             return AVERROR(ENOMEM);
1600     }
1601
1602 return_packet:
1603
1604     st = s->streams[pkt->stream_index];
1605     if (st->skip_samples) {
1606         uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1607         AV_WL32(p, st->skip_samples);
1608         av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1609         st->skip_samples = 0;
1610     }
1611
1612     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1613         ff_reduce_index(s, st->index);
1614         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1615     }
1616
1617     if (is_relative(pkt->dts))
1618         pkt->dts -= RELATIVE_TS_BASE;
1619     if (is_relative(pkt->pts))
1620         pkt->pts -= RELATIVE_TS_BASE;
1621
1622     return ret;
1623 }
1624
1625 /* XXX: suppress the packet queue */
1626 static void flush_packet_queue(AVFormatContext *s)
1627 {
1628     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1629     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1630     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1631
1632     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1633 }
1634
1635 /*******************************************************/
1636 /* seek support */
1637
1638 int av_find_default_stream_index(AVFormatContext *s)
1639 {
1640     int first_audio_index = -1;
1641     int i;
1642     AVStream *st;
1643
1644     if (s->nb_streams <= 0)
1645         return -1;
1646     for(i = 0; i < s->nb_streams; i++) {
1647         st = s->streams[i];
1648         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1649             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1650             return i;
1651         }
1652         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1653             first_audio_index = i;
1654     }
1655     return first_audio_index >= 0 ? first_audio_index : 0;
1656 }
1657
1658 /**
1659  * Flush the frame reader.
1660  */
1661 void ff_read_frame_flush(AVFormatContext *s)
1662 {
1663     AVStream *st;
1664     int i, j;
1665
1666     flush_packet_queue(s);
1667
1668     /* for each stream, reset read state */
1669     for(i = 0; i < s->nb_streams; i++) {
1670         st = s->streams[i];
1671
1672         if (st->parser) {
1673             av_parser_close(st->parser);
1674             st->parser = NULL;
1675         }
1676         st->last_IP_pts = AV_NOPTS_VALUE;
1677         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1678         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1679         st->reference_dts = AV_NOPTS_VALUE;
1680
1681         st->probe_packets = MAX_PROBE_PACKETS;
1682
1683         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1684             st->pts_buffer[j]= AV_NOPTS_VALUE;
1685     }
1686 }
1687
1688 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1689 {
1690     int i;
1691
1692     for(i = 0; i < s->nb_streams; i++) {
1693         AVStream *st = s->streams[i];
1694
1695         st->cur_dts = av_rescale(timestamp,
1696                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1697                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1698     }
1699 }
1700
1701 void ff_reduce_index(AVFormatContext *s, int stream_index)
1702 {
1703     AVStream *st= s->streams[stream_index];
1704     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1705
1706     if((unsigned)st->nb_index_entries >= max_entries){
1707         int i;
1708         for(i=0; 2*i<st->nb_index_entries; i++)
1709             st->index_entries[i]= st->index_entries[2*i];
1710         st->nb_index_entries= i;
1711     }
1712 }
1713
1714 int ff_add_index_entry(AVIndexEntry **index_entries,
1715                        int *nb_index_entries,
1716                        unsigned int *index_entries_allocated_size,
1717                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1718 {
1719     AVIndexEntry *entries, *ie;
1720     int index;
1721
1722     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1723         return -1;
1724
1725     if(timestamp == AV_NOPTS_VALUE)
1726         return AVERROR(EINVAL);
1727
1728     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1729         timestamp -= RELATIVE_TS_BASE;
1730
1731     entries = av_fast_realloc(*index_entries,
1732                               index_entries_allocated_size,
1733                               (*nb_index_entries + 1) *
1734                               sizeof(AVIndexEntry));
1735     if(!entries)
1736         return -1;
1737
1738     *index_entries= entries;
1739
1740     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1741
1742     if(index<0){
1743         index= (*nb_index_entries)++;
1744         ie= &entries[index];
1745         av_assert0(index==0 || ie[-1].timestamp < timestamp);
1746     }else{
1747         ie= &entries[index];
1748         if(ie->timestamp != timestamp){
1749             if(ie->timestamp <= timestamp)
1750                 return -1;
1751             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1752             (*nb_index_entries)++;
1753         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1754             distance= ie->min_distance;
1755     }
1756
1757     ie->pos = pos;
1758     ie->timestamp = timestamp;
1759     ie->min_distance= distance;
1760     ie->size= size;
1761     ie->flags = flags;
1762
1763     return index;
1764 }
1765
1766 int av_add_index_entry(AVStream *st,
1767                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1768 {
1769     timestamp = wrap_timestamp(st, timestamp);
1770     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1771                               &st->index_entries_allocated_size, pos,
1772                               timestamp, size, distance, flags);
1773 }
1774
1775 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1776                               int64_t wanted_timestamp, int flags)
1777 {
1778     int a, b, m;
1779     int64_t timestamp;
1780
1781     a = - 1;
1782     b = nb_entries;
1783
1784     //optimize appending index entries at the end
1785     if(b && entries[b-1].timestamp < wanted_timestamp)
1786         a= b-1;
1787
1788     while (b - a > 1) {
1789         m = (a + b) >> 1;
1790         timestamp = entries[m].timestamp;
1791         if(timestamp >= wanted_timestamp)
1792             b = m;
1793         if(timestamp <= wanted_timestamp)
1794             a = m;
1795     }
1796     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1797
1798     if(!(flags & AVSEEK_FLAG_ANY)){
1799         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1800             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1801         }
1802     }
1803
1804     if(m == nb_entries)
1805         return -1;
1806     return  m;
1807 }
1808
1809 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1810                               int flags)
1811 {
1812     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1813                                      wanted_timestamp, flags);
1814 }
1815
1816 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1817                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1818 {
1819     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1820     if (stream_index >= 0)
1821         ts = wrap_timestamp(s->streams[stream_index], ts);
1822     return ts;
1823 }
1824
1825 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1826 {
1827     AVInputFormat *avif= s->iformat;
1828     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1829     int64_t ts_min, ts_max, ts;
1830     int index;
1831     int64_t ret;
1832     AVStream *st;
1833
1834     if (stream_index < 0)
1835         return -1;
1836
1837     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1838
1839     ts_max=
1840     ts_min= AV_NOPTS_VALUE;
1841     pos_limit= -1; //gcc falsely says it may be uninitialized
1842
1843     st= s->streams[stream_index];
1844     if(st->index_entries){
1845         AVIndexEntry *e;
1846
1847         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()
1848         index= FFMAX(index, 0);
1849         e= &st->index_entries[index];
1850
1851         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1852             pos_min= e->pos;
1853             ts_min= e->timestamp;
1854             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1855                     pos_min, av_ts2str(ts_min));
1856         }else{
1857             assert(index==0);
1858         }
1859
1860         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1861         av_assert0(index < st->nb_index_entries);
1862         if(index >= 0){
1863             e= &st->index_entries[index];
1864             assert(e->timestamp >= target_ts);
1865             pos_max= e->pos;
1866             ts_max= e->timestamp;
1867             pos_limit= pos_max - e->min_distance;
1868             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1869                     pos_max, pos_limit, av_ts2str(ts_max));
1870         }
1871     }
1872
1873     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1874     if(pos<0)
1875         return -1;
1876
1877     /* do the seek */
1878     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1879         return ret;
1880
1881     ff_read_frame_flush(s);
1882     ff_update_cur_dts(s, st, ts);
1883
1884     return 0;
1885 }
1886
1887 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1888                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1889                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1890                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1891 {
1892     int64_t pos, ts;
1893     int64_t start_pos, filesize;
1894     int no_change;
1895
1896     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1897
1898     if(ts_min == AV_NOPTS_VALUE){
1899         pos_min = s->data_offset;
1900         ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1901         if (ts_min == AV_NOPTS_VALUE)
1902             return -1;
1903     }
1904
1905     if(ts_min >= target_ts){
1906         *ts_ret= ts_min;
1907         return pos_min;
1908     }
1909
1910     if(ts_max == AV_NOPTS_VALUE){
1911         int step= 1024;
1912         filesize = avio_size(s->pb);
1913         pos_max = filesize - 1;
1914         do{
1915             pos_max = FFMAX(0, pos_max - step);
1916             ts_max = ff_read_timestamp(s, stream_index, &pos_max, pos_max + step, read_timestamp);
1917             step += step;
1918         }while(ts_max == AV_NOPTS_VALUE && pos_max > 0);
1919         if (ts_max == AV_NOPTS_VALUE)
1920             return -1;
1921
1922         for(;;){
1923             int64_t tmp_pos= pos_max + 1;
1924             int64_t tmp_ts= ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1925             if(tmp_ts == AV_NOPTS_VALUE)
1926                 break;
1927             ts_max= tmp_ts;
1928             pos_max= tmp_pos;
1929             if(tmp_pos >= filesize)
1930                 break;
1931         }
1932         pos_limit= pos_max;
1933     }
1934
1935     if(ts_max <= target_ts){
1936         *ts_ret= ts_max;
1937         return pos_max;
1938     }
1939
1940     if(ts_min > ts_max){
1941         return -1;
1942     }else if(ts_min == ts_max){
1943         pos_limit= pos_min;
1944     }
1945
1946     no_change=0;
1947     while (pos_min < pos_limit) {
1948         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1949                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1950         assert(pos_limit <= pos_max);
1951
1952         if(no_change==0){
1953             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1954             // interpolate position (better than dichotomy)
1955             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1956                 + pos_min - approximate_keyframe_distance;
1957         }else if(no_change==1){
1958             // bisection, if interpolation failed to change min or max pos last time
1959             pos = (pos_min + pos_limit)>>1;
1960         }else{
1961             /* linear search if bisection failed, can only happen if there
1962                are very few or no keyframes between min/max */
1963             pos=pos_min;
1964         }
1965         if(pos <= pos_min)
1966             pos= pos_min + 1;
1967         else if(pos > pos_limit)
1968             pos= pos_limit;
1969         start_pos= pos;
1970
1971         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1972         if(pos == pos_max)
1973             no_change++;
1974         else
1975             no_change=0;
1976         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1977                 pos_min, pos, pos_max,
1978                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1979                 pos_limit, start_pos, no_change);
1980         if(ts == AV_NOPTS_VALUE){
1981             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1982             return -1;
1983         }
1984         assert(ts != AV_NOPTS_VALUE);
1985         if (target_ts <= ts) {
1986             pos_limit = start_pos - 1;
1987             pos_max = pos;
1988             ts_max = ts;
1989         }
1990         if (target_ts >= ts) {
1991             pos_min = pos;
1992             ts_min = ts;
1993         }
1994     }
1995
1996     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1997     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1998 #if 0
1999     pos_min = pos;
2000     ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2001     pos_min++;
2002     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2003     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2004             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2005 #endif
2006     *ts_ret= ts;
2007     return pos;
2008 }
2009
2010 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
2011     int64_t pos_min, pos_max;
2012
2013     pos_min = s->data_offset;
2014     pos_max = avio_size(s->pb) - 1;
2015
2016     if     (pos < pos_min) pos= pos_min;
2017     else if(pos > pos_max) pos= pos_max;
2018
2019     avio_seek(s->pb, pos, SEEK_SET);
2020
2021     s->io_repositioned = 1;
2022
2023     return 0;
2024 }
2025
2026 static int seek_frame_generic(AVFormatContext *s,
2027                                  int stream_index, int64_t timestamp, int flags)
2028 {
2029     int index;
2030     int64_t ret;
2031     AVStream *st;
2032     AVIndexEntry *ie;
2033
2034     st = s->streams[stream_index];
2035
2036     index = av_index_search_timestamp(st, timestamp, flags);
2037
2038     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2039         return -1;
2040
2041     if(index < 0 || index==st->nb_index_entries-1){
2042         AVPacket pkt;
2043         int nonkey=0;
2044
2045         if(st->nb_index_entries){
2046             av_assert0(st->index_entries);
2047             ie= &st->index_entries[st->nb_index_entries-1];
2048             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2049                 return ret;
2050             ff_update_cur_dts(s, st, ie->timestamp);
2051         }else{
2052             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2053                 return ret;
2054         }
2055         for (;;) {
2056             int read_status;
2057             do{
2058                 read_status = av_read_frame(s, &pkt);
2059             } while (read_status == AVERROR(EAGAIN));
2060             if (read_status < 0)
2061                 break;
2062             av_free_packet(&pkt);
2063             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
2064                 if(pkt.flags & AV_PKT_FLAG_KEY)
2065                     break;
2066                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
2067                     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);
2068                     break;
2069                 }
2070             }
2071         }
2072         index = av_index_search_timestamp(st, timestamp, flags);
2073     }
2074     if (index < 0)
2075         return -1;
2076
2077     ff_read_frame_flush(s);
2078     if (s->iformat->read_seek){
2079         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2080             return 0;
2081     }
2082     ie = &st->index_entries[index];
2083     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2084         return ret;
2085     ff_update_cur_dts(s, st, ie->timestamp);
2086
2087     return 0;
2088 }
2089
2090 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2091                                int64_t timestamp, int flags)
2092 {
2093     int ret;
2094     AVStream *st;
2095
2096     if (flags & AVSEEK_FLAG_BYTE) {
2097         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2098             return -1;
2099         ff_read_frame_flush(s);
2100         return seek_frame_byte(s, stream_index, timestamp, flags);
2101     }
2102
2103     if(stream_index < 0){
2104         stream_index= av_find_default_stream_index(s);
2105         if(stream_index < 0)
2106             return -1;
2107
2108         st= s->streams[stream_index];
2109         /* timestamp for default must be expressed in AV_TIME_BASE units */
2110         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2111     }
2112
2113     /* first, we try the format specific seek */
2114     if (s->iformat->read_seek) {
2115         ff_read_frame_flush(s);
2116         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2117     } else
2118         ret = -1;
2119     if (ret >= 0) {
2120         return 0;
2121     }
2122
2123     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2124         ff_read_frame_flush(s);
2125         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2126     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2127         ff_read_frame_flush(s);
2128         return seek_frame_generic(s, stream_index, timestamp, flags);
2129     }
2130     else
2131         return -1;
2132 }
2133
2134 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2135 {
2136     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
2137
2138     if (ret >= 0)
2139         ret = avformat_queue_attached_pictures(s);
2140
2141     return ret;
2142 }
2143
2144 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2145 {
2146     if(min_ts > ts || max_ts < ts)
2147         return -1;
2148     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2149         return AVERROR(EINVAL);
2150
2151     if(s->seek2any>0)
2152         flags |= AVSEEK_FLAG_ANY;
2153
2154     if (s->iformat->read_seek2) {
2155         int ret;
2156         ff_read_frame_flush(s);
2157
2158         if (stream_index == -1 && s->nb_streams == 1) {
2159             AVRational time_base = s->streams[0]->time_base;
2160             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2161             min_ts = av_rescale_rnd(min_ts, time_base.den,
2162                                     time_base.num * (int64_t)AV_TIME_BASE,
2163                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2164             max_ts = av_rescale_rnd(max_ts, time_base.den,
2165                                     time_base.num * (int64_t)AV_TIME_BASE,
2166                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2167         }
2168
2169         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2170
2171         if (ret >= 0)
2172             ret = avformat_queue_attached_pictures(s);
2173         return ret;
2174     }
2175
2176     if(s->iformat->read_timestamp){
2177         //try to seek via read_timestamp()
2178     }
2179
2180     //Fallback to old API if new is not implemented but old is
2181     //Note the old has somewhat different semantics
2182     if (s->iformat->read_seek || 1) {
2183         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2184         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2185         if (ret<0 && ts != min_ts && max_ts != ts) {
2186             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2187             if (ret >= 0)
2188                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2189         }
2190         return ret;
2191     }
2192
2193     // try some generic seek like seek_frame_generic() but with new ts semantics
2194     return -1; //unreachable
2195 }
2196
2197 /*******************************************************/
2198
2199 /**
2200  * Return TRUE if the stream has accurate duration in any stream.
2201  *
2202  * @return TRUE if the stream has accurate duration for at least one component.
2203  */
2204 static int has_duration(AVFormatContext *ic)
2205 {
2206     int i;
2207     AVStream *st;
2208
2209     for(i = 0;i < ic->nb_streams; i++) {
2210         st = ic->streams[i];
2211         if (st->duration != AV_NOPTS_VALUE)
2212             return 1;
2213     }
2214     if (ic->duration != AV_NOPTS_VALUE)
2215         return 1;
2216     return 0;
2217 }
2218
2219 /**
2220  * Estimate the stream timings from the one of each components.
2221  *
2222  * Also computes the global bitrate if possible.
2223  */
2224 static void update_stream_timings(AVFormatContext *ic)
2225 {
2226     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2227     int64_t duration, duration1, filesize;
2228     int i;
2229     AVStream *st;
2230     AVProgram *p;
2231
2232     start_time = INT64_MAX;
2233     start_time_text = INT64_MAX;
2234     end_time = INT64_MIN;
2235     duration = INT64_MIN;
2236     for(i = 0;i < ic->nb_streams; i++) {
2237         st = ic->streams[i];
2238         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2239             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2240             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2241                 if (start_time1 < start_time_text)
2242                     start_time_text = start_time1;
2243             } else
2244                 start_time = FFMIN(start_time, start_time1);
2245             end_time1 = AV_NOPTS_VALUE;
2246             if (st->duration != AV_NOPTS_VALUE) {
2247                 end_time1 = start_time1
2248                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2249                 end_time = FFMAX(end_time, end_time1);
2250             }
2251             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2252                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2253                     p->start_time = start_time1;
2254                 if(p->end_time < end_time1)
2255                     p->end_time = end_time1;
2256             }
2257         }
2258         if (st->duration != AV_NOPTS_VALUE) {
2259             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2260             duration = FFMAX(duration, duration1);
2261         }
2262     }
2263     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2264         start_time = start_time_text;
2265     else if(start_time > start_time_text)
2266         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2267
2268     if (start_time != INT64_MAX) {
2269         ic->start_time = start_time;
2270         if (end_time != INT64_MIN) {
2271             if (ic->nb_programs) {
2272                 for (i=0; i<ic->nb_programs; i++) {
2273                     p = ic->programs[i];
2274                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2275                         duration = FFMAX(duration, p->end_time - p->start_time);
2276                 }
2277             } else
2278                 duration = FFMAX(duration, end_time - start_time);
2279         }
2280     }
2281     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2282         ic->duration = duration;
2283     }
2284         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2285             /* compute the bitrate */
2286             double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2287                 (double)ic->duration;
2288             if (bitrate >= 0 && bitrate <= INT_MAX)
2289                 ic->bit_rate = bitrate;
2290         }
2291 }
2292
2293 static void fill_all_stream_timings(AVFormatContext *ic)
2294 {
2295     int i;
2296     AVStream *st;
2297
2298     update_stream_timings(ic);
2299     for(i = 0;i < ic->nb_streams; i++) {
2300         st = ic->streams[i];
2301         if (st->start_time == AV_NOPTS_VALUE) {
2302             if(ic->start_time != AV_NOPTS_VALUE)
2303                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2304             if(ic->duration != AV_NOPTS_VALUE)
2305                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2306         }
2307     }
2308 }
2309
2310 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2311 {
2312     int64_t filesize, duration;
2313     int bit_rate, i, show_warning = 0;
2314     AVStream *st;
2315
2316     /* if bit_rate is already set, we believe it */
2317     if (ic->bit_rate <= 0) {
2318         bit_rate = 0;
2319         for(i=0;i<ic->nb_streams;i++) {
2320             st = ic->streams[i];
2321             if (st->codec->bit_rate > 0)
2322             bit_rate += st->codec->bit_rate;
2323         }
2324         ic->bit_rate = bit_rate;
2325     }
2326
2327     /* if duration is already set, we believe it */
2328     if (ic->duration == AV_NOPTS_VALUE &&
2329         ic->bit_rate != 0) {
2330         filesize = ic->pb ? avio_size(ic->pb) : 0;
2331         if (filesize > 0) {
2332             for(i = 0; i < ic->nb_streams; i++) {
2333                 st = ic->streams[i];
2334                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2335                     && st->duration == AV_NOPTS_VALUE) {
2336                     duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2337                     st->duration = duration;
2338                     show_warning = 1;
2339                 }
2340             }
2341         }
2342     }
2343     if (show_warning)
2344         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2345 }
2346
2347 #define DURATION_MAX_READ_SIZE 250000LL
2348 #define DURATION_MAX_RETRY 4
2349
2350 /* only usable for MPEG-PS streams */
2351 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2352 {
2353     AVPacket pkt1, *pkt = &pkt1;
2354     AVStream *st;
2355     int read_size, i, ret;
2356     int64_t end_time;
2357     int64_t filesize, offset, duration;
2358     int retry=0;
2359
2360     /* flush packet queue */
2361     flush_packet_queue(ic);
2362
2363     for (i=0; i<ic->nb_streams; i++) {
2364         st = ic->streams[i];
2365         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2366             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2367
2368         if (st->parser) {
2369             av_parser_close(st->parser);
2370             st->parser= NULL;
2371         }
2372     }
2373
2374     /* estimate the end time (duration) */
2375     /* XXX: may need to support wrapping */
2376     filesize = ic->pb ? avio_size(ic->pb) : 0;
2377     end_time = AV_NOPTS_VALUE;
2378     do{
2379         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2380         if (offset < 0)
2381             offset = 0;
2382
2383         avio_seek(ic->pb, offset, SEEK_SET);
2384         read_size = 0;
2385         for(;;) {
2386             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2387                 break;
2388
2389             do {
2390                 ret = ff_read_packet(ic, pkt);
2391             } while(ret == AVERROR(EAGAIN));
2392             if (ret != 0)
2393                 break;
2394             read_size += pkt->size;
2395             st = ic->streams[pkt->stream_index];
2396             if (pkt->pts != AV_NOPTS_VALUE &&
2397                 (st->start_time != AV_NOPTS_VALUE ||
2398                  st->first_dts  != AV_NOPTS_VALUE)) {
2399                 duration = end_time = pkt->pts;
2400                 if (st->start_time != AV_NOPTS_VALUE)
2401                     duration -= st->start_time;
2402                 else
2403                     duration -= st->first_dts;
2404                 if (duration > 0) {
2405                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2406                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2407                         st->duration = duration;
2408                     st->info->last_duration = duration;
2409                 }
2410             }
2411             av_free_packet(pkt);
2412         }
2413     }while(   end_time==AV_NOPTS_VALUE
2414            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2415            && ++retry <= DURATION_MAX_RETRY);
2416
2417     fill_all_stream_timings(ic);
2418
2419     avio_seek(ic->pb, old_offset, SEEK_SET);
2420     for (i=0; i<ic->nb_streams; i++) {
2421         st= ic->streams[i];
2422         st->cur_dts= st->first_dts;
2423         st->last_IP_pts = AV_NOPTS_VALUE;
2424         st->reference_dts = AV_NOPTS_VALUE;
2425     }
2426 }
2427
2428 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2429 {
2430     int64_t file_size;
2431
2432     /* get the file size, if possible */
2433     if (ic->iformat->flags & AVFMT_NOFILE) {
2434         file_size = 0;
2435     } else {
2436         file_size = avio_size(ic->pb);
2437         file_size = FFMAX(0, file_size);
2438     }
2439
2440     if ((!strcmp(ic->iformat->name, "mpeg") ||
2441          !strcmp(ic->iformat->name, "mpegts")) &&
2442         file_size && ic->pb->seekable) {
2443         /* get accurate estimate from the PTSes */
2444         estimate_timings_from_pts(ic, old_offset);
2445         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2446     } else if (has_duration(ic)) {
2447         /* at least one component has timings - we use them for all
2448            the components */
2449         fill_all_stream_timings(ic);
2450         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2451     } else {
2452         /* less precise: use bitrate info */
2453         estimate_timings_from_bit_rate(ic);
2454         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2455     }
2456     update_stream_timings(ic);
2457
2458     {
2459         int i;
2460         AVStream av_unused *st;
2461         for(i = 0;i < ic->nb_streams; i++) {
2462             st = ic->streams[i];
2463             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2464                     (double) st->start_time / AV_TIME_BASE,
2465                     (double) st->duration   / AV_TIME_BASE);
2466         }
2467         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2468                 (double) ic->start_time / AV_TIME_BASE,
2469                 (double) ic->duration   / AV_TIME_BASE,
2470                 ic->bit_rate / 1000);
2471     }
2472 }
2473
2474 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2475 {
2476     AVCodecContext *avctx = st->codec;
2477
2478 #define FAIL(errmsg) do {                                         \
2479         if (errmsg_ptr)                                           \
2480             *errmsg_ptr = errmsg;                                 \
2481         return 0;                                                 \
2482     } while (0)
2483
2484     switch (avctx->codec_type) {
2485     case AVMEDIA_TYPE_AUDIO:
2486         if (!avctx->frame_size && determinable_frame_size(avctx))
2487             FAIL("unspecified frame size");
2488         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2489             FAIL("unspecified sample format");
2490         if (!avctx->sample_rate)
2491             FAIL("unspecified sample rate");
2492         if (!avctx->channels)
2493             FAIL("unspecified number of channels");
2494         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2495             FAIL("no decodable DTS frames");
2496         break;
2497     case AVMEDIA_TYPE_VIDEO:
2498         if (!avctx->width)
2499             FAIL("unspecified size");
2500         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2501             FAIL("unspecified pixel format");
2502         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2503             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2504                 FAIL("no frame in rv30/40 and no sar");
2505         break;
2506     case AVMEDIA_TYPE_SUBTITLE:
2507         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2508             FAIL("unspecified size");
2509         break;
2510     case AVMEDIA_TYPE_DATA:
2511         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2512     }
2513
2514     if (avctx->codec_id == AV_CODEC_ID_NONE)
2515         FAIL("unknown codec");
2516     return 1;
2517 }
2518
2519 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2520 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2521 {
2522     const AVCodec *codec;
2523     int got_picture = 1, ret = 0;
2524     AVFrame *frame = avcodec_alloc_frame();
2525     AVSubtitle subtitle;
2526     AVPacket pkt = *avpkt;
2527
2528     if (!frame)
2529         return AVERROR(ENOMEM);
2530
2531     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2532         AVDictionary *thread_opt = NULL;
2533
2534         codec = st->codec->codec ? st->codec->codec :
2535                                    avcodec_find_decoder(st->codec->codec_id);
2536
2537         if (!codec) {
2538             st->info->found_decoder = -1;
2539             ret = -1;
2540             goto fail;
2541         }
2542
2543         /* force thread count to 1 since the h264 decoder will not extract SPS
2544          *  and PPS to extradata during multi-threaded decoding */
2545         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2546         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2547         if (!options)
2548             av_dict_free(&thread_opt);
2549         if (ret < 0) {
2550             st->info->found_decoder = -1;
2551             goto fail;
2552         }
2553         st->info->found_decoder = 1;
2554     } else if (!st->info->found_decoder)
2555         st->info->found_decoder = 1;
2556
2557     if (st->info->found_decoder < 0) {
2558         ret = -1;
2559         goto fail;
2560     }
2561
2562     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2563            ret >= 0 &&
2564            (!has_codec_parameters(st, NULL)   ||
2565            !has_decode_delay_been_guessed(st) ||
2566            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2567         got_picture = 0;
2568         avcodec_get_frame_defaults(frame);
2569         switch(st->codec->codec_type) {
2570         case AVMEDIA_TYPE_VIDEO:
2571             ret = avcodec_decode_video2(st->codec, frame,
2572                                         &got_picture, &pkt);
2573             break;
2574         case AVMEDIA_TYPE_AUDIO:
2575             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2576             break;
2577         case AVMEDIA_TYPE_SUBTITLE:
2578             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2579                                            &got_picture, &pkt);
2580             ret = pkt.size;
2581             break;
2582         default:
2583             break;
2584         }
2585         if (ret >= 0) {
2586             if (got_picture)
2587                 st->nb_decoded_frames++;
2588             pkt.data += ret;
2589             pkt.size -= ret;
2590             ret       = got_picture;
2591         }
2592     }
2593
2594     if(!pkt.data && !got_picture)
2595         ret = -1;
2596
2597 fail:
2598     avcodec_free_frame(&frame);
2599     return ret;
2600 }
2601
2602 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2603 {
2604     while (tags->id != AV_CODEC_ID_NONE) {
2605         if (tags->id == id)
2606             return tags->tag;
2607         tags++;
2608     }
2609     return 0;
2610 }
2611
2612 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2613 {
2614     int i;
2615     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2616         if(tag == tags[i].tag)
2617             return tags[i].id;
2618     }
2619     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2620         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2621             return tags[i].id;
2622     }
2623     return AV_CODEC_ID_NONE;
2624 }
2625
2626 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2627 {
2628     if (flt) {
2629         switch (bps) {
2630         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2631         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2632         default: return AV_CODEC_ID_NONE;
2633         }
2634     } else {
2635         bps  += 7;
2636         bps >>= 3;
2637         if (sflags & (1 << (bps - 1))) {
2638             switch (bps) {
2639             case 1:  return AV_CODEC_ID_PCM_S8;
2640             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2641             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2642             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2643             default: return AV_CODEC_ID_NONE;
2644             }
2645         } else {
2646             switch (bps) {
2647             case 1:  return AV_CODEC_ID_PCM_U8;
2648             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2649             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2650             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2651             default: return AV_CODEC_ID_NONE;
2652             }
2653         }
2654     }
2655 }
2656
2657 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2658 {
2659     unsigned int tag;
2660     if (!av_codec_get_tag2(tags, id, &tag))
2661         return 0;
2662     return tag;
2663 }
2664
2665 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2666                       unsigned int *tag)
2667 {
2668     int i;
2669     for(i=0; tags && tags[i]; i++){
2670         const AVCodecTag *codec_tags = tags[i];
2671         while (codec_tags->id != AV_CODEC_ID_NONE) {
2672             if (codec_tags->id == id) {
2673                 *tag = codec_tags->tag;
2674                 return 1;
2675             }
2676             codec_tags++;
2677         }
2678     }
2679     return 0;
2680 }
2681
2682 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2683 {
2684     int i;
2685     for(i=0; tags && tags[i]; i++){
2686         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2687         if(id!=AV_CODEC_ID_NONE) return id;
2688     }
2689     return AV_CODEC_ID_NONE;
2690 }
2691
2692 static void compute_chapters_end(AVFormatContext *s)
2693 {
2694     unsigned int i, j;
2695     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2696
2697     for (i = 0; i < s->nb_chapters; i++)
2698         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2699             AVChapter *ch = s->chapters[i];
2700             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2701                                      : INT64_MAX;
2702
2703             for (j = 0; j < s->nb_chapters; j++) {
2704                 AVChapter *ch1 = s->chapters[j];
2705                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2706                 if (j != i && next_start > ch->start && next_start < end)
2707                     end = next_start;
2708             }
2709             ch->end = (end == INT64_MAX) ? ch->start : end;
2710         }
2711 }
2712
2713 static int get_std_framerate(int i){
2714     if(i<60*12) return (i+1)*1001;
2715     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2716 }
2717
2718 /*
2719  * Is the time base unreliable.
2720  * This is a heuristic to balance between quick acceptance of the values in
2721  * the headers vs. some extra checks.
2722  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2723  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2724  * And there are "variable" fps files this needs to detect as well.
2725  */
2726 static int tb_unreliable(AVCodecContext *c){
2727     if(   c->time_base.den >= 101L*c->time_base.num
2728        || c->time_base.den <    5L*c->time_base.num
2729 /*       || c->codec_tag == AV_RL32("DIVX")
2730        || c->codec_tag == AV_RL32("XVID")*/
2731        || c->codec_tag == AV_RL32("mp4v")
2732        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2733        || c->codec_id == AV_CODEC_ID_H264
2734        )
2735         return 1;
2736     return 0;
2737 }
2738
2739 #if FF_API_FORMAT_PARAMETERS
2740 int av_find_stream_info(AVFormatContext *ic)
2741 {
2742     return avformat_find_stream_info(ic, NULL);
2743 }
2744 #endif
2745
2746 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2747 {
2748     int i, count, ret, j;
2749     int64_t read_size;
2750     AVStream *st;
2751     AVPacket pkt1, *pkt;
2752     int64_t old_offset = avio_tell(ic->pb);
2753     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2754     int flush_codecs = ic->probesize > 0;
2755
2756     if(ic->pb)
2757         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2758
2759     for(i=0;i<ic->nb_streams;i++) {
2760         const AVCodec *codec;
2761         AVDictionary *thread_opt = NULL;
2762         st = ic->streams[i];
2763
2764         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2765             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2766 /*            if(!st->time_base.num)
2767                 st->time_base= */
2768             if(!st->codec->time_base.num)
2769                 st->codec->time_base= st->time_base;
2770         }
2771         //only for the split stuff
2772         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2773             st->parser = av_parser_init(st->codec->codec_id);
2774             if(st->parser){
2775                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2776                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2777                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2778                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2779                 }
2780             } else if (st->need_parsing) {
2781                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2782                        "%s, packets or times may be invalid.\n",
2783                        avcodec_get_name(st->codec->codec_id));
2784             }
2785         }
2786         codec = st->codec->codec ? st->codec->codec :
2787                                    avcodec_find_decoder(st->codec->codec_id);
2788
2789         /* force thread count to 1 since the h264 decoder will not extract SPS
2790          *  and PPS to extradata during multi-threaded decoding */
2791         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2792
2793         /* Ensure that subtitle_header is properly set. */
2794         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2795             && codec && !st->codec->codec)
2796             avcodec_open2(st->codec, codec, options ? &options[i]
2797                               : &thread_opt);
2798
2799         //try to just open decoders, in case this is enough to get parameters
2800         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2801             if (codec && !st->codec->codec)
2802                 avcodec_open2(st->codec, codec, options ? &options[i]
2803                               : &thread_opt);
2804         }
2805         if (!options)
2806             av_dict_free(&thread_opt);
2807     }
2808
2809     for (i=0; i<ic->nb_streams; i++) {
2810 #if FF_API_R_FRAME_RATE
2811         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2812 #endif
2813         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2814         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2815     }
2816
2817     count = 0;
2818     read_size = 0;
2819     for(;;) {
2820         if (ff_check_interrupt(&ic->interrupt_callback)){
2821             ret= AVERROR_EXIT;
2822             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2823             break;
2824         }
2825
2826         /* check if one codec still needs to be handled */
2827         for(i=0;i<ic->nb_streams;i++) {
2828             int fps_analyze_framecount = 20;
2829
2830             st = ic->streams[i];
2831             if (!has_codec_parameters(st, NULL))
2832                 break;
2833             /* if the timebase is coarse (like the usual millisecond precision
2834                of mkv), we need to analyze more frames to reliably arrive at
2835                the correct fps */
2836             if (av_q2d(st->time_base) > 0.0005)
2837                 fps_analyze_framecount *= 2;
2838             if (ic->fps_probe_size >= 0)
2839                 fps_analyze_framecount = ic->fps_probe_size;
2840             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2841                 fps_analyze_framecount = 0;
2842             /* variable fps and no guess at the real fps */
2843             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2844                && st->info->duration_count < fps_analyze_framecount
2845                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2846                 break;
2847             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2848                 break;
2849             if (st->first_dts == AV_NOPTS_VALUE &&
2850                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2851                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2852                 break;
2853         }
2854         if (i == ic->nb_streams) {
2855             /* NOTE: if the format has no header, then we need to read
2856                some packets to get most of the streams, so we cannot
2857                stop here */
2858             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2859                 /* if we found the info for all the codecs, we can stop */
2860                 ret = count;
2861                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2862                 flush_codecs = 0;
2863                 break;
2864             }
2865         }
2866         /* we did not get all the codec info, but we read too much data */
2867         if (read_size >= ic->probesize) {
2868             ret = count;
2869             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2870             for (i = 0; i < ic->nb_streams; i++)
2871                 if (!ic->streams[i]->r_frame_rate.num &&
2872                     ic->streams[i]->info->duration_count <= 1)
2873                     av_log(ic, AV_LOG_WARNING,
2874                            "Stream #%d: not enough frames to estimate rate; "
2875                            "consider increasing probesize\n", i);
2876             break;
2877         }
2878
2879         /* NOTE: a new stream can be added there if no header in file
2880            (AVFMTCTX_NOHEADER) */
2881         ret = read_frame_internal(ic, &pkt1);
2882         if (ret == AVERROR(EAGAIN))
2883             continue;
2884
2885         if (ret < 0) {
2886             /* EOF or error*/
2887             break;
2888         }
2889
2890         if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2891             pkt = &pkt1;
2892         } else {
2893             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2894                                 &ic->packet_buffer_end);
2895             if ((ret = av_dup_packet(pkt)) < 0)
2896                 goto find_stream_info_err;
2897         }
2898
2899         read_size += pkt->size;
2900
2901         st = ic->streams[pkt->stream_index];
2902         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2903             /* check for non-increasing dts */
2904             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2905                 st->info->fps_last_dts >= pkt->dts) {
2906                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2907                        "packet %d with DTS %"PRId64", packet %d with DTS "
2908                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2909                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2910                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2911             }
2912             /* check for a discontinuity in dts - if the difference in dts
2913              * is more than 1000 times the average packet duration in the sequence,
2914              * we treat it as a discontinuity */
2915             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2916                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2917                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2918                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2919                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2920                        "packet %d with DTS %"PRId64", packet %d with DTS "
2921                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2922                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2923                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2924             }
2925
2926             /* update stored dts values */
2927             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2928                 st->info->fps_first_dts     = pkt->dts;
2929                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2930             }
2931             st->info->fps_last_dts = pkt->dts;
2932             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2933         }
2934         if (st->codec_info_nb_frames>1) {
2935             int64_t t=0;
2936             if (st->time_base.den > 0)
2937                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2938             if (st->avg_frame_rate.num > 0)
2939                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2940
2941             if (t >= ic->max_analyze_duration) {
2942                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2943                 break;
2944             }
2945             if (pkt->duration) {
2946                 st->info->codec_info_duration        += pkt->duration;
2947                 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2948             }
2949         }
2950 #if FF_API_R_FRAME_RATE
2951         {
2952             int64_t last = st->info->last_dts;
2953
2954             if(   pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2955                && pkt->dts - (uint64_t)last < INT64_MAX){
2956                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2957                 int64_t duration= pkt->dts - last;
2958
2959                 if (!st->info->duration_error)
2960                     st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2961
2962 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2963 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2964                 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2965                     int framerate= get_std_framerate(i);
2966                     double sdts= dts*framerate/(1001*12);
2967                     for(j=0; j<2; j++){
2968                         int64_t ticks= llrint(sdts+j*0.5);
2969                         double error= sdts - ticks + j*0.5;
2970                         st->info->duration_error[j][0][i] += error;
2971                         st->info->duration_error[j][1][i] += error*error;
2972                     }
2973                 }
2974                 st->info->duration_count++;
2975                 // ignore the first 4 values, they might have some random jitter
2976                 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2977                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2978             }
2979             if (pkt->dts != AV_NOPTS_VALUE)
2980                 st->info->last_dts = pkt->dts;
2981         }
2982 #endif
2983         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2984             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2985             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2986                 st->codec->extradata_size= i;
2987                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2988                 if (!st->codec->extradata)
2989                     return AVERROR(ENOMEM);
2990                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2991                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2992             }
2993         }
2994
2995         /* if still no information, we try to open the codec and to
2996            decompress the frame. We try to avoid that in most cases as
2997            it takes longer and uses more memory. For MPEG-4, we need to
2998            decompress for QuickTime.
2999
3000            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3001            least one frame of codec data, this makes sure the codec initializes
3002            the channel configuration and does not only trust the values from the container.
3003         */
3004         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3005
3006         st->codec_info_nb_frames++;
3007         count++;
3008     }
3009
3010     if (flush_codecs) {
3011         AVPacket empty_pkt = { 0 };
3012         int err = 0;
3013         av_init_packet(&empty_pkt);
3014
3015         ret = -1; /* we could not have all the codec parameters before EOF */
3016         for(i=0;i<ic->nb_streams;i++) {
3017             const char *errmsg;
3018
3019             st = ic->streams[i];
3020
3021             /* flush the decoders */
3022             if (st->info->found_decoder == 1) {
3023                 do {
3024                     err = try_decode_frame(st, &empty_pkt,
3025                                             (options && i < orig_nb_streams) ?
3026                                             &options[i] : NULL);
3027                 } while (err > 0 && !has_codec_parameters(st, NULL));
3028
3029                 if (err < 0) {
3030                     av_log(ic, AV_LOG_INFO,
3031                         "decoding for stream %d failed\n", st->index);
3032                 }
3033             }
3034
3035             if (!has_codec_parameters(st, &errmsg)) {
3036                 char buf[256];
3037                 avcodec_string(buf, sizeof(buf), st->codec, 0);
3038                 av_log(ic, AV_LOG_WARNING,
3039                        "Could not find codec parameters for stream %d (%s): %s\n"
3040                        "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3041                        i, buf, errmsg);
3042             } else {
3043                 ret = 0;
3044             }
3045         }
3046     }
3047
3048     // close codecs which were opened in try_decode_frame()
3049     for(i=0;i<ic->nb_streams;i++) {
3050         st = ic->streams[i];
3051         avcodec_close(st->codec);
3052     }
3053     for(i=0;i<ic->nb_streams;i++) {
3054         st = ic->streams[i];
3055         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3056             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3057                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3058                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3059                     st->codec->codec_tag= tag;
3060             }
3061
3062             /* estimate average framerate if not set by demuxer */
3063             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3064                 int      best_fps = 0;
3065                 double best_error = 0.01;
3066
3067                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3068                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3069                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3070
3071                 /* round guessed framerate to a "standard" framerate if it's
3072                  * within 1% of the original estimate*/
3073                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3074                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3075                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3076
3077                     if (error < best_error) {
3078                         best_error = error;
3079                         best_fps   = std_fps.num;
3080                     }
3081                 }
3082                 if (best_fps) {
3083                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3084                               best_fps, 12*1001, INT_MAX);
3085                 }
3086             }
3087             // the check for tb_unreliable() is not completely correct, since this is not about handling
3088             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3089             // ipmovie.c produces.
3090             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)
3091                 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);
3092             if (st->info->duration_count>1 && !st->r_frame_rate.num
3093                 && tb_unreliable(st->codec)) {
3094                 int num = 0;
3095                 double best_error= 0.01;
3096
3097                 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3098                     int k;
3099
3100                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3101                         continue;
3102                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3103                         continue;
3104                     for(k=0; k<2; k++){
3105                         int n= st->info->duration_count;
3106                         double a= st->info->duration_error[k][0][j] / n;
3107                         double error= st->info->duration_error[k][1][j]/n - a*a;
3108
3109                         if(error < best_error && best_error> 0.000000001){
3110                             best_error= error;
3111                             num = get_std_framerate(j);
3112                         }
3113                         if(error < 0.02)
3114                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3115                     }
3116                 }
3117                 // do not increase frame rate by more than 1 % in order to match a standard rate.
3118                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3119                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3120             }
3121
3122             if (!st->r_frame_rate.num){
3123                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3124                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3125                     st->r_frame_rate.num = st->codec->time_base.den;
3126                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3127                 }else{
3128                     st->r_frame_rate.num = st->time_base.den;
3129                     st->r_frame_rate.den = st->time_base.num;
3130                 }
3131             }
3132         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3133             if(!st->codec->bits_per_coded_sample)
3134                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3135             // set stream disposition based on audio service type
3136             switch (st->codec->audio_service_type) {
3137             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3138                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3139             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3140                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3141             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3142                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3143             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3144                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3145             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3146                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3147             }
3148         }
3149     }
3150
3151     if(ic->probesize)
3152     estimate_timings(ic, old_offset);
3153
3154     compute_chapters_end(ic);
3155
3156  find_stream_info_err:
3157     for (i=0; i < ic->nb_streams; i++) {
3158         st = ic->streams[i];
3159         if (ic->streams[i]->codec)
3160             ic->streams[i]->codec->thread_count = 0;
3161         if (st->info)
3162             av_freep(&st->info->duration_error);
3163         av_freep(&ic->streams[i]->info);
3164     }
3165     if(ic->pb)
3166         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3167     return ret;
3168 }
3169
3170 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3171 {
3172     int i, j;
3173
3174     for (i = 0; i < ic->nb_programs; i++) {
3175         if (ic->programs[i] == last) {
3176             last = NULL;
3177         } else {
3178             if (!last)
3179                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3180                     if (ic->programs[i]->stream_index[j] == s)
3181                         return ic->programs[i];
3182         }
3183     }
3184     return NULL;
3185 }
3186
3187 int av_find_best_stream(AVFormatContext *ic,
3188                         enum AVMediaType type,
3189                         int wanted_stream_nb,
3190                         int related_stream,
3191                         AVCodec **decoder_ret,
3192                         int flags)
3193 {
3194     int i, nb_streams = ic->nb_streams;
3195     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3196     unsigned *program = NULL;
3197     AVCodec *decoder = NULL, *best_decoder = NULL;
3198
3199     if (related_stream >= 0 && wanted_stream_nb < 0) {
3200         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3201         if (p) {
3202             program = p->stream_index;
3203             nb_streams = p->nb_stream_indexes;
3204         }
3205     }
3206     for (i = 0; i < nb_streams; i++) {
3207         int real_stream_index = program ? program[i] : i;
3208         AVStream *st = ic->streams[real_stream_index];
3209         AVCodecContext *avctx = st->codec;
3210         if (avctx->codec_type != type)
3211             continue;
3212         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3213             continue;
3214         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3215             continue;
3216         if (decoder_ret) {
3217             decoder = avcodec_find_decoder(st->codec->codec_id);
3218             if (!decoder) {
3219                 if (ret < 0)
3220                     ret = AVERROR_DECODER_NOT_FOUND;
3221                 continue;
3222             }
3223         }
3224         count = st->codec_info_nb_frames;
3225         bitrate = avctx->bit_rate;
3226         multiframe = FFMIN(5, count);
3227         if ((best_multiframe >  multiframe) ||
3228             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3229             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3230             continue;
3231         best_count = count;
3232         best_bitrate = bitrate;
3233         best_multiframe = multiframe;
3234         ret = real_stream_index;
3235         best_decoder = decoder;
3236         if (program && i == nb_streams - 1 && ret < 0) {
3237             program = NULL;
3238             nb_streams = ic->nb_streams;
3239             i = 0; /* no related stream found, try again with everything */
3240         }
3241     }
3242     if (decoder_ret)
3243         *decoder_ret = best_decoder;
3244     return ret;
3245 }
3246
3247 /*******************************************************/
3248
3249 int av_read_play(AVFormatContext *s)
3250 {
3251     if (s->iformat->read_play)
3252         return s->iformat->read_play(s);
3253     if (s->pb)
3254         return avio_pause(s->pb, 0);
3255     return AVERROR(ENOSYS);
3256 }
3257
3258 int av_read_pause(AVFormatContext *s)
3259 {
3260     if (s->iformat->read_pause)
3261         return s->iformat->read_pause(s);
3262     if (s->pb)
3263         return avio_pause(s->pb, 1);
3264     return AVERROR(ENOSYS);
3265 }
3266
3267 void ff_free_stream(AVFormatContext *s, AVStream *st){
3268     av_assert0(s->nb_streams>0);
3269     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3270
3271     if (st->parser) {
3272         av_parser_close(st->parser);
3273     }
3274     if (st->attached_pic.data)
3275         av_free_packet(&st->attached_pic);
3276     av_dict_free(&st->metadata);
3277     av_freep(&st->probe_data.buf);
3278     av_freep(&st->index_entries);
3279     av_freep(&st->codec->extradata);
3280     av_freep(&st->codec->subtitle_header);
3281     av_freep(&st->codec);
3282     av_freep(&st->priv_data);
3283     if (st->info)
3284         av_freep(&st->info->duration_error);
3285     av_freep(&st->info);
3286     av_freep(&s->streams[ --s->nb_streams ]);
3287 }
3288
3289 void avformat_free_context(AVFormatContext *s)
3290 {
3291     int i;
3292
3293     if (!s)
3294         return;
3295
3296     av_opt_free(s);
3297     if (s->iformat && s->iformat->priv_class && s->priv_data)
3298         av_opt_free(s->priv_data);
3299
3300     for(i=s->nb_streams-1; i>=0; i--) {
3301         ff_free_stream(s, s->streams[i]);
3302     }
3303     for(i=s->nb_programs-1; i>=0; i--) {
3304         av_dict_free(&s->programs[i]->metadata);
3305         av_freep(&s->programs[i]->stream_index);
3306         av_freep(&s->programs[i]);
3307     }
3308     av_freep(&s->programs);
3309     av_freep(&s->priv_data);
3310     while(s->nb_chapters--) {
3311         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3312         av_freep(&s->chapters[s->nb_chapters]);
3313     }
3314     av_freep(&s->chapters);
3315     av_dict_free(&s->metadata);
3316     av_freep(&s->streams);
3317     av_free(s);
3318 }
3319
3320 #if FF_API_CLOSE_INPUT_FILE
3321 void av_close_input_file(AVFormatContext *s)
3322 {
3323     avformat_close_input(&s);
3324 }
3325 #endif
3326
3327 void avformat_close_input(AVFormatContext **ps)
3328 {
3329     AVFormatContext *s = *ps;
3330     AVIOContext *pb = s->pb;
3331
3332     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3333         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3334         pb = NULL;
3335
3336     flush_packet_queue(s);
3337
3338     if (s->iformat) {
3339         if (s->iformat->read_close)
3340             s->iformat->read_close(s);
3341     }
3342
3343     avformat_free_context(s);
3344
3345     *ps = NULL;
3346
3347     avio_close(pb);
3348 }
3349
3350 #if FF_API_NEW_STREAM
3351 AVStream *av_new_stream(AVFormatContext *s, int id)
3352 {
3353     AVStream *st = avformat_new_stream(s, NULL);
3354     if (st)
3355         st->id = id;
3356     return st;
3357 }
3358 #endif
3359
3360 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3361 {
3362     AVStream *st;
3363     int i;
3364     AVStream **streams;
3365
3366     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3367         return NULL;
3368     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3369     if (!streams)
3370         return NULL;
3371     s->streams = streams;
3372
3373     st = av_mallocz(sizeof(AVStream));
3374     if (!st)
3375         return NULL;
3376     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3377         av_free(st);
3378         return NULL;
3379     }
3380     st->info->last_dts = AV_NOPTS_VALUE;
3381
3382     st->codec = avcodec_alloc_context3(c);
3383     if (s->iformat) {
3384         /* no default bitrate if decoding */
3385         st->codec->bit_rate = 0;
3386     }
3387     st->index = s->nb_streams;
3388     st->start_time = AV_NOPTS_VALUE;
3389     st->duration = AV_NOPTS_VALUE;
3390         /* we set the current DTS to 0 so that formats without any timestamps
3391            but durations get some timestamps, formats with some unknown
3392            timestamps have their first few packets buffered and the
3393            timestamps corrected before they are returned to the user */
3394     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3395     st->first_dts = AV_NOPTS_VALUE;
3396     st->probe_packets = MAX_PROBE_PACKETS;
3397     st->pts_wrap_reference = AV_NOPTS_VALUE;
3398     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3399
3400     /* default pts setting is MPEG-like */
3401     avpriv_set_pts_info(st, 33, 1, 90000);
3402     st->last_IP_pts = AV_NOPTS_VALUE;
3403     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3404         st->pts_buffer[i]= AV_NOPTS_VALUE;
3405     st->reference_dts = AV_NOPTS_VALUE;
3406
3407     st->sample_aspect_ratio = (AVRational){0,1};
3408
3409 #if FF_API_R_FRAME_RATE
3410     st->info->last_dts      = AV_NOPTS_VALUE;
3411 #endif
3412     st->info->fps_first_dts = AV_NOPTS_VALUE;
3413     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3414
3415     s->streams[s->nb_streams++] = st;
3416     return st;
3417 }
3418
3419 AVProgram *av_new_program(AVFormatContext *ac, int id)
3420 {
3421     AVProgram *program=NULL;
3422     int i;
3423
3424     av_dlog(ac, "new_program: id=0x%04x\n", id);
3425
3426     for(i=0; i<ac->nb_programs; i++)
3427         if(ac->programs[i]->id == id)
3428             program = ac->programs[i];
3429
3430     if(!program){
3431         program = av_mallocz(sizeof(AVProgram));
3432         if (!program)
3433             return NULL;
3434         dynarray_add(&ac->programs, &ac->nb_programs, program);
3435         program->discard = AVDISCARD_NONE;
3436     }
3437     program->id = id;
3438     program->pts_wrap_reference = AV_NOPTS_VALUE;
3439     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3440
3441     program->start_time =
3442     program->end_time   = AV_NOPTS_VALUE;
3443
3444     return program;
3445 }
3446
3447 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3448 {
3449     AVChapter *chapter = NULL;
3450     int i;
3451
3452     for(i=0; i<s->nb_chapters; i++)
3453         if(s->chapters[i]->id == id)
3454             chapter = s->chapters[i];
3455
3456     if(!chapter){
3457         chapter= av_mallocz(sizeof(AVChapter));
3458         if(!chapter)
3459             return NULL;
3460         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3461     }
3462     av_dict_set(&chapter->metadata, "title", title, 0);
3463     chapter->id    = id;
3464     chapter->time_base= time_base;
3465     chapter->start = start;
3466     chapter->end   = end;
3467
3468     return chapter;
3469 }
3470
3471 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3472 {
3473     int i, j;
3474     AVProgram *program=NULL;
3475     void *tmp;
3476
3477     if (idx >= ac->nb_streams) {
3478         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3479         return;
3480     }
3481
3482     for(i=0; i<ac->nb_programs; i++){
3483         if(ac->programs[i]->id != progid)
3484             continue;
3485         program = ac->programs[i];
3486         for(j=0; j<program->nb_stream_indexes; j++)
3487             if(program->stream_index[j] == idx)
3488                 return;
3489
3490         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3491         if(!tmp)
3492             return;
3493         program->stream_index = tmp;
3494         program->stream_index[program->nb_stream_indexes++] = idx;
3495         return;
3496     }
3497 }
3498
3499 static void print_fps(double d, const char *postfix){
3500     uint64_t v= lrintf(d*100);
3501     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3502     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3503     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3504 }
3505
3506 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3507 {
3508     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3509         AVDictionaryEntry *tag=NULL;
3510
3511         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3512         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3513             if(strcmp("language", tag->key)){
3514                 const char *p = tag->value;
3515                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3516                 while(*p) {
3517                     char tmp[256];
3518                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3519                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3520                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3521                     p += len;
3522                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3523                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3524                     if (*p) p++;
3525                 }
3526                 av_log(ctx, AV_LOG_INFO, "\n");
3527             }
3528         }
3529     }
3530 }
3531
3532 /* "user interface" functions */
3533 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3534 {
3535     char buf[256];
3536     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3537     AVStream *st = ic->streams[i];
3538     int g = av_gcd(st->time_base.num, st->time_base.den);
3539     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3540     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3541     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3542     /* the pid is an important information, so we display it */
3543     /* XXX: add a generic system */
3544     if (flags & AVFMT_SHOW_IDS)
3545         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3546     if (lang)
3547         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3548     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3549     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3550     if (st->sample_aspect_ratio.num && // default
3551         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3552         AVRational display_aspect_ratio;
3553         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3554                   st->codec->width*st->sample_aspect_ratio.num,
3555                   st->codec->height*st->sample_aspect_ratio.den,
3556                   1024*1024);
3557         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3558                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3559                  display_aspect_ratio.num, display_aspect_ratio.den);
3560     }
3561     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3562         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3563             print_fps(av_q2d(st->avg_frame_rate), "fps");
3564 #if FF_API_R_FRAME_RATE
3565         if(st->r_frame_rate.den && st->r_frame_rate.num)
3566             print_fps(av_q2d(st->r_frame_rate), "tbr");
3567 #endif
3568         if(st->time_base.den && st->time_base.num)
3569             print_fps(1/av_q2d(st->time_base), "tbn");
3570         if(st->codec->time_base.den && st->codec->time_base.num)
3571             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3572     }
3573     if (st->disposition & AV_DISPOSITION_DEFAULT)
3574         av_log(NULL, AV_LOG_INFO, " (default)");
3575     if (st->disposition & AV_DISPOSITION_DUB)
3576         av_log(NULL, AV_LOG_INFO, " (dub)");
3577     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3578         av_log(NULL, AV_LOG_INFO, " (original)");
3579     if (st->disposition & AV_DISPOSITION_COMMENT)
3580         av_log(NULL, AV_LOG_INFO, " (comment)");
3581     if (st->disposition & AV_DISPOSITION_LYRICS)
3582         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3583     if (st->disposition & AV_DISPOSITION_KARAOKE)
3584         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3585     if (st->disposition & AV_DISPOSITION_FORCED)
3586         av_log(NULL, AV_LOG_INFO, " (forced)");
3587     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3588         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3589     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3590         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3591     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3592         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3593     av_log(NULL, AV_LOG_INFO, "\n");
3594     dump_metadata(NULL, st->metadata, "    ");
3595 }
3596
3597 void av_dump_format(AVFormatContext *ic,
3598                     int index,
3599                     const char *url,
3600                     int is_output)
3601 {
3602     int i;
3603     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3604     if (ic->nb_streams && !printed)
3605         return;
3606
3607     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3608             is_output ? "Output" : "Input",
3609             index,
3610             is_output ? ic->oformat->name : ic->iformat->name,
3611             is_output ? "to" : "from", url);
3612     dump_metadata(NULL, ic->metadata, "  ");
3613     if (!is_output) {
3614         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3615         if (ic->duration != AV_NOPTS_VALUE) {
3616             int hours, mins, secs, us;
3617             int64_t duration = ic->duration + 5000;
3618             secs = duration / AV_TIME_BASE;
3619             us = duration % AV_TIME_BASE;
3620             mins = secs / 60;
3621             secs %= 60;
3622             hours = mins / 60;
3623             mins %= 60;
3624             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3625                    (100 * us) / AV_TIME_BASE);
3626         } else {
3627             av_log(NULL, AV_LOG_INFO, "N/A");
3628         }
3629         if (ic->start_time != AV_NOPTS_VALUE) {
3630             int secs, us;
3631             av_log(NULL, AV_LOG_INFO, ", start: ");
3632             secs = ic->start_time / AV_TIME_BASE;
3633             us = abs(ic->start_time % AV_TIME_BASE);
3634             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3635                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3636         }
3637         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3638         if (ic->bit_rate) {
3639             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3640         } else {
3641             av_log(NULL, AV_LOG_INFO, "N/A");
3642         }
3643         av_log(NULL, AV_LOG_INFO, "\n");
3644     }
3645     for (i = 0; i < ic->nb_chapters; i++) {
3646         AVChapter *ch = ic->chapters[i];
3647         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3648         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3649         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3650
3651         dump_metadata(NULL, ch->metadata, "    ");
3652     }
3653     if(ic->nb_programs) {
3654         int j, k, total = 0;
3655         for(j=0; j<ic->nb_programs; j++) {
3656             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3657                                                   "name", NULL, 0);
3658             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3659                    name ? name->value : "");
3660             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3661             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3662                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3663                 printed[ic->programs[j]->stream_index[k]] = 1;
3664             }
3665             total += ic->programs[j]->nb_stream_indexes;
3666         }
3667         if (total < ic->nb_streams)
3668             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3669     }
3670     for(i=0;i<ic->nb_streams;i++)
3671         if (!printed[i])
3672             dump_stream_format(ic, i, index, is_output);
3673
3674     av_free(printed);
3675 }
3676
3677 uint64_t ff_ntp_time(void)
3678 {
3679   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3680 }
3681
3682 int av_get_frame_filename(char *buf, int buf_size,
3683                           const char *path, int number)
3684 {
3685     const char *p;
3686     char *q, buf1[20], c;
3687     int nd, len, percentd_found;
3688
3689     q = buf;
3690     p = path;
3691     percentd_found = 0;
3692     for(;;) {
3693         c = *p++;
3694         if (c == '\0')
3695             break;
3696         if (c == '%') {
3697             do {
3698                 nd = 0;
3699                 while (av_isdigit(*p)) {
3700                     nd = nd * 10 + *p++ - '0';
3701                 }
3702                 c = *p++;
3703             } while (av_isdigit(c));
3704
3705             switch(c) {
3706             case '%':
3707                 goto addchar;
3708             case 'd':
3709                 if (percentd_found)
3710                     goto fail;
3711                 percentd_found = 1;
3712                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3713                 len = strlen(buf1);
3714                 if ((q - buf + len) > buf_size - 1)
3715                     goto fail;
3716                 memcpy(q, buf1, len);
3717                 q += len;
3718                 break;
3719             default:
3720                 goto fail;
3721             }
3722         } else {
3723         addchar:
3724             if ((q - buf) < buf_size - 1)
3725                 *q++ = c;
3726         }
3727     }
3728     if (!percentd_found)
3729         goto fail;
3730     *q = '\0';
3731     return 0;
3732  fail:
3733     *q = '\0';
3734     return -1;
3735 }
3736
3737 static void hex_dump_internal(void *avcl, FILE *f, int level,
3738                               const uint8_t *buf, int size)
3739 {
3740     int len, i, j, c;
3741 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3742
3743     for(i=0;i<size;i+=16) {
3744         len = size - i;
3745         if (len > 16)
3746             len = 16;
3747         PRINT("%08x ", i);
3748         for(j=0;j<16;j++) {
3749             if (j < len)
3750                 PRINT(" %02x", buf[i+j]);
3751             else
3752                 PRINT("   ");
3753         }
3754         PRINT(" ");
3755         for(j=0;j<len;j++) {
3756             c = buf[i+j];
3757             if (c < ' ' || c > '~')
3758                 c = '.';
3759             PRINT("%c", c);
3760         }
3761         PRINT("\n");
3762     }
3763 #undef PRINT
3764 }
3765
3766 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3767 {
3768     hex_dump_internal(NULL, f, 0, buf, size);
3769 }
3770
3771 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3772 {
3773     hex_dump_internal(avcl, NULL, level, buf, size);
3774 }
3775
3776 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3777 {
3778 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3779     PRINT("stream #%d:\n", pkt->stream_index);
3780     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3781     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3782     /* DTS is _always_ valid after av_read_frame() */
3783     PRINT("  dts=");
3784     if (pkt->dts == AV_NOPTS_VALUE)
3785         PRINT("N/A");
3786     else
3787         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3788     /* PTS may not be known if B-frames are present. */
3789     PRINT("  pts=");
3790     if (pkt->pts == AV_NOPTS_VALUE)
3791         PRINT("N/A");
3792     else
3793         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3794     PRINT("\n");
3795     PRINT("  size=%d\n", pkt->size);
3796 #undef PRINT
3797     if (dump_payload)
3798         av_hex_dump(f, pkt->data, pkt->size);
3799 }
3800
3801 #if FF_API_PKT_DUMP
3802 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3803 {
3804     AVRational tb = { 1, AV_TIME_BASE };
3805     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3806 }
3807 #endif
3808
3809 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3810 {
3811     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3812 }
3813
3814 #if FF_API_PKT_DUMP
3815 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3816 {
3817     AVRational tb = { 1, AV_TIME_BASE };
3818     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3819 }
3820 #endif
3821
3822 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3823                       AVStream *st)
3824 {
3825     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3826 }
3827
3828 void av_url_split(char *proto, int proto_size,
3829                   char *authorization, int authorization_size,
3830                   char *hostname, int hostname_size,
3831                   int *port_ptr,
3832                   char *path, int path_size,
3833                   const char *url)
3834 {
3835     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3836
3837     if (port_ptr)               *port_ptr = -1;
3838     if (proto_size > 0)         proto[0] = 0;
3839     if (authorization_size > 0) authorization[0] = 0;
3840     if (hostname_size > 0)      hostname[0] = 0;
3841     if (path_size > 0)          path[0] = 0;
3842
3843     /* parse protocol */
3844     if ((p = strchr(url, ':'))) {
3845         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3846         p++; /* skip ':' */
3847         if (*p == '/') p++;
3848         if (*p == '/') p++;
3849     } else {
3850         /* no protocol means plain filename */
3851         av_strlcpy(path, url, path_size);
3852         return;
3853     }
3854
3855     /* separate path from hostname */
3856     ls = strchr(p, '/');
3857     ls2 = strchr(p, '?');
3858     if(!ls)
3859         ls = ls2;
3860     else if (ls && ls2)
3861         ls = FFMIN(ls, ls2);
3862     if(ls)
3863         av_strlcpy(path, ls, path_size);
3864     else
3865         ls = &p[strlen(p)]; // XXX
3866
3867     /* the rest is hostname, use that to parse auth/port */
3868     if (ls != p) {
3869         /* authorization (user[:pass]@hostname) */
3870         at2 = p;
3871         while ((at = strchr(p, '@')) && at < ls) {
3872             av_strlcpy(authorization, at2,
3873                        FFMIN(authorization_size, at + 1 - at2));
3874             p = at + 1; /* skip '@' */
3875         }
3876
3877         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3878             /* [host]:port */
3879             av_strlcpy(hostname, p + 1,
3880                        FFMIN(hostname_size, brk - p));
3881             if (brk[1] == ':' && port_ptr)
3882                 *port_ptr = atoi(brk + 2);
3883         } else if ((col = strchr(p, ':')) && col < ls) {
3884             av_strlcpy(hostname, p,
3885                        FFMIN(col + 1 - p, hostname_size));
3886             if (port_ptr) *port_ptr = atoi(col + 1);
3887         } else
3888             av_strlcpy(hostname, p,
3889                        FFMIN(ls + 1 - p, hostname_size));
3890     }
3891 }
3892
3893 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3894 {
3895     int i;
3896     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3897                                            '4', '5', '6', '7',
3898                                            '8', '9', 'A', 'B',
3899                                            'C', 'D', 'E', 'F' };
3900     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3901                                            '4', '5', '6', '7',
3902                                            '8', '9', 'a', 'b',
3903                                            'c', 'd', 'e', 'f' };
3904     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3905
3906     for(i = 0; i < s; i++) {
3907         buff[i * 2]     = hex_table[src[i] >> 4];
3908         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3909     }
3910
3911     return buff;
3912 }
3913
3914 int ff_hex_to_data(uint8_t *data, const char *p)
3915 {
3916     int c, len, v;
3917
3918     len = 0;
3919     v = 1;
3920     for (;;) {
3921         p += strspn(p, SPACE_CHARS);
3922         if (*p == '\0')
3923             break;
3924         c = av_toupper((unsigned char) *p++);
3925         if (c >= '0' && c <= '9')
3926             c = c - '0';
3927         else if (c >= 'A' && c <= 'F')
3928             c = c - 'A' + 10;
3929         else
3930             break;
3931         v = (v << 4) | c;
3932         if (v & 0x100) {
3933             if (data)
3934                 data[len] = v;
3935             len++;
3936             v = 1;
3937         }
3938     }
3939     return len;
3940 }
3941
3942 #if FF_API_SET_PTS_INFO
3943 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3944                      unsigned int pts_num, unsigned int pts_den)
3945 {
3946     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3947 }
3948 #endif
3949
3950 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3951                          unsigned int pts_num, unsigned int pts_den)
3952 {
3953     AVRational new_tb;
3954     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3955         if(new_tb.num != pts_num)
3956             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3957     }else
3958         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3959
3960     if(new_tb.num <= 0 || new_tb.den <= 0) {
3961         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);
3962         return;
3963     }
3964     s->time_base = new_tb;
3965     av_codec_set_pkt_timebase(s->codec, new_tb);
3966     s->pts_wrap_bits = pts_wrap_bits;
3967 }
3968
3969 int ff_url_join(char *str, int size, const char *proto,
3970                 const char *authorization, const char *hostname,
3971                 int port, const char *fmt, ...)
3972 {
3973 #if CONFIG_NETWORK
3974     struct addrinfo hints = { 0 }, *ai;
3975 #endif
3976
3977     str[0] = '\0';
3978     if (proto)
3979         av_strlcatf(str, size, "%s://", proto);
3980     if (authorization && authorization[0])
3981         av_strlcatf(str, size, "%s@", authorization);
3982 #if CONFIG_NETWORK && defined(AF_INET6)
3983     /* Determine if hostname is a numerical IPv6 address,
3984      * properly escape it within [] in that case. */
3985     hints.ai_flags = AI_NUMERICHOST;
3986     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3987         if (ai->ai_family == AF_INET6) {
3988             av_strlcat(str, "[", size);
3989             av_strlcat(str, hostname, size);
3990             av_strlcat(str, "]", size);
3991         } else {
3992             av_strlcat(str, hostname, size);
3993         }
3994         freeaddrinfo(ai);
3995     } else
3996 #endif
3997         /* Not an IPv6 address, just output the plain string. */
3998         av_strlcat(str, hostname, size);
3999
4000     if (port >= 0)
4001         av_strlcatf(str, size, ":%d", port);
4002     if (fmt) {
4003         va_list vl;
4004         int len = strlen(str);
4005
4006         va_start(vl, fmt);
4007         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4008         va_end(vl);
4009     }
4010     return strlen(str);
4011 }
4012
4013 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4014                      AVFormatContext *src)
4015 {
4016     AVPacket local_pkt;
4017
4018     local_pkt = *pkt;
4019     local_pkt.stream_index = dst_stream;
4020     if (pkt->pts != AV_NOPTS_VALUE)
4021         local_pkt.pts = av_rescale_q(pkt->pts,
4022                                      src->streams[pkt->stream_index]->time_base,
4023                                      dst->streams[dst_stream]->time_base);
4024     if (pkt->dts != AV_NOPTS_VALUE)
4025         local_pkt.dts = av_rescale_q(pkt->dts,
4026                                      src->streams[pkt->stream_index]->time_base,
4027                                      dst->streams[dst_stream]->time_base);
4028     if (pkt->duration)
4029         local_pkt.duration = av_rescale_q(pkt->duration,
4030                                           src->streams[pkt->stream_index]->time_base,
4031                                           dst->streams[dst_stream]->time_base);
4032     return av_write_frame(dst, &local_pkt);
4033 }
4034
4035 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4036                         void *context)
4037 {
4038     const char *ptr = str;
4039
4040     /* Parse key=value pairs. */
4041     for (;;) {
4042         const char *key;
4043         char *dest = NULL, *dest_end;
4044         int key_len, dest_len = 0;
4045
4046         /* Skip whitespace and potential commas. */
4047         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4048             ptr++;
4049         if (!*ptr)
4050             break;
4051
4052         key = ptr;
4053
4054         if (!(ptr = strchr(key, '=')))
4055             break;
4056         ptr++;
4057         key_len = ptr - key;
4058
4059         callback_get_buf(context, key, key_len, &dest, &dest_len);
4060         dest_end = dest + dest_len - 1;
4061
4062         if (*ptr == '\"') {
4063             ptr++;
4064             while (*ptr && *ptr != '\"') {
4065                 if (*ptr == '\\') {
4066                     if (!ptr[1])
4067                         break;
4068                     if (dest && dest < dest_end)
4069                         *dest++ = ptr[1];
4070                     ptr += 2;
4071                 } else {
4072                     if (dest && dest < dest_end)
4073                         *dest++ = *ptr;
4074                     ptr++;
4075                 }
4076             }
4077             if (*ptr == '\"')
4078                 ptr++;
4079         } else {
4080             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4081                 if (dest && dest < dest_end)
4082                     *dest++ = *ptr;
4083         }
4084         if (dest)
4085             *dest = 0;
4086     }
4087 }
4088
4089 int ff_find_stream_index(AVFormatContext *s, int id)
4090 {
4091     int i;
4092     for (i = 0; i < s->nb_streams; i++) {
4093         if (s->streams[i]->id == id)
4094             return i;
4095     }
4096     return -1;
4097 }
4098
4099 void ff_make_absolute_url(char *buf, int size, const char *base,
4100                           const char *rel)
4101 {
4102     char *sep, *path_query;
4103     /* Absolute path, relative to the current server */
4104     if (base && strstr(base, "://") && rel[0] == '/') {
4105         if (base != buf)
4106             av_strlcpy(buf, base, size);
4107         sep = strstr(buf, "://");
4108         if (sep) {
4109             /* Take scheme from base url */
4110             if (rel[1] == '/') {
4111                 sep[1] = '\0';
4112             } else {
4113                 /* Take scheme and host from base url */
4114                 sep += 3;
4115                 sep = strchr(sep, '/');
4116                 if (sep)
4117                     *sep = '\0';
4118             }
4119         }
4120         av_strlcat(buf, rel, size);
4121         return;
4122     }
4123     /* If rel actually is an absolute url, just copy it */
4124     if (!base || strstr(rel, "://") || rel[0] == '/') {
4125         av_strlcpy(buf, rel, size);
4126         return;
4127     }
4128     if (base != buf)
4129         av_strlcpy(buf, base, size);
4130
4131     /* Strip off any query string from base */
4132     path_query = strchr(buf, '?');
4133     if (path_query != NULL)
4134         *path_query = '\0';
4135
4136     /* Is relative path just a new query part? */
4137     if (rel[0] == '?') {
4138         av_strlcat(buf, rel, size);
4139         return;
4140     }
4141
4142     /* Remove the file name from the base url */
4143     sep = strrchr(buf, '/');
4144     if (sep)
4145         sep[1] = '\0';
4146     else
4147         buf[0] = '\0';
4148     while (av_strstart(rel, "../", NULL) && sep) {
4149         /* Remove the path delimiter at the end */
4150         sep[0] = '\0';
4151         sep = strrchr(buf, '/');
4152         /* If the next directory name to pop off is "..", break here */
4153         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4154             /* Readd the slash we just removed */
4155             av_strlcat(buf, "/", size);
4156             break;
4157         }
4158         /* Cut off the directory name */
4159         if (sep)
4160             sep[1] = '\0';
4161         else
4162             buf[0] = '\0';
4163         rel += 3;
4164     }
4165     av_strlcat(buf, rel, size);
4166 }
4167
4168 int64_t ff_iso8601_to_unix_time(const char *datestr)
4169 {
4170     struct tm time1 = {0}, time2 = {0};
4171     char *ret1, *ret2;
4172     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4173     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4174     if (ret2 && !ret1)
4175         return av_timegm(&time2);
4176     else
4177         return av_timegm(&time1);
4178 }
4179
4180 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4181 {
4182     if (ofmt) {
4183         if (ofmt->query_codec)
4184             return ofmt->query_codec(codec_id, std_compliance);
4185         else if (ofmt->codec_tag)
4186             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4187         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4188                  codec_id == ofmt->subtitle_codec)
4189             return 1;
4190     }
4191     return AVERROR_PATCHWELCOME;
4192 }
4193
4194 int avformat_network_init(void)
4195 {
4196 #if CONFIG_NETWORK
4197     int ret;
4198     ff_network_inited_globally = 1;
4199     if ((ret = ff_network_init()) < 0)
4200         return ret;
4201     ff_tls_init();
4202 #endif
4203     return 0;
4204 }
4205
4206 int avformat_network_deinit(void)
4207 {
4208 #if CONFIG_NETWORK
4209     ff_network_close();
4210     ff_tls_deinit();
4211 #endif
4212     return 0;
4213 }
4214
4215 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4216                         uint64_t channel_layout, int32_t sample_rate,
4217                         int32_t width, int32_t height)
4218 {
4219     uint32_t flags = 0;
4220     int size = 4;
4221     uint8_t *data;
4222     if (!pkt)
4223         return AVERROR(EINVAL);
4224     if (channels) {
4225         size += 4;
4226         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4227     }
4228     if (channel_layout) {
4229         size += 8;
4230         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4231     }
4232     if (sample_rate) {
4233         size += 4;
4234         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4235     }
4236     if (width || height) {
4237         size += 8;
4238         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4239     }
4240     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4241     if (!data)
4242         return AVERROR(ENOMEM);
4243     bytestream_put_le32(&data, flags);
4244     if (channels)
4245         bytestream_put_le32(&data, channels);
4246     if (channel_layout)
4247         bytestream_put_le64(&data, channel_layout);
4248     if (sample_rate)
4249         bytestream_put_le32(&data, sample_rate);
4250     if (width || height) {
4251         bytestream_put_le32(&data, width);
4252         bytestream_put_le32(&data, height);
4253     }
4254     return 0;
4255 }
4256
4257 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4258 {
4259     return ff_codec_bmp_tags;
4260 }
4261 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4262 {
4263     return ff_codec_wav_tags;
4264 }
4265
4266 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4267 {
4268     AVRational undef = {0, 1};
4269     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4270     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4271     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4272
4273     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4274                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4275     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4276         stream_sample_aspect_ratio = undef;
4277
4278     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4279                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4280     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4281         frame_sample_aspect_ratio = undef;
4282
4283     if (stream_sample_aspect_ratio.num)
4284         return stream_sample_aspect_ratio;
4285     else
4286         return frame_sample_aspect_ratio;
4287 }
4288
4289 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4290 {
4291     AVRational fr = st->r_frame_rate;
4292
4293     if (st->codec->ticks_per_frame > 1) {
4294         AVRational codec_fr = av_inv_q(st->codec->time_base);
4295         AVRational   avg_fr = st->avg_frame_rate;
4296         codec_fr.den *= st->codec->ticks_per_frame;
4297         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4298             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4299             fr = codec_fr;
4300     }
4301
4302     return fr;
4303 }
4304
4305 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4306                                     const char *spec)
4307 {
4308     if (*spec <= '9' && *spec >= '0') /* opt:index */
4309         return strtol(spec, NULL, 0) == st->index;
4310     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4311              *spec == 't') { /* opt:[vasdt] */
4312         enum AVMediaType type;
4313
4314         switch (*spec++) {
4315         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4316         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4317         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4318         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4319         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4320         default:  av_assert0(0);
4321         }
4322         if (type != st->codec->codec_type)
4323             return 0;
4324         if (*spec++ == ':') { /* possibly followed by :index */
4325             int i, index = strtol(spec, NULL, 0);
4326             for (i = 0; i < s->nb_streams; i++)
4327                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4328                    return i == st->index;
4329             return 0;
4330         }
4331         return 1;
4332     } else if (*spec == 'p' && *(spec + 1) == ':') {
4333         int prog_id, i, j;
4334         char *endptr;
4335         spec += 2;
4336         prog_id = strtol(spec, &endptr, 0);
4337         for (i = 0; i < s->nb_programs; i++) {
4338             if (s->programs[i]->id != prog_id)
4339                 continue;
4340
4341             if (*endptr++ == ':') {
4342                 int stream_idx = strtol(endptr, NULL, 0);
4343                 return stream_idx >= 0 &&
4344                     stream_idx < s->programs[i]->nb_stream_indexes &&
4345                     st->index == s->programs[i]->stream_index[stream_idx];
4346             }
4347
4348             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4349                 if (st->index == s->programs[i]->stream_index[j])
4350                     return 1;
4351         }
4352         return 0;
4353     } else if (*spec == '#') {
4354         int sid;
4355         char *endptr;
4356         sid = strtol(spec + 1, &endptr, 0);
4357         if (!*endptr)
4358             return st->id == sid;
4359     } else if (!*spec) /* empty specifier, matches everything */
4360         return 1;
4361
4362     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4363     return AVERROR(EINVAL);
4364 }
4365
4366 void ff_generate_avci_extradata(AVStream *st)
4367 {
4368     static const uint8_t avci100_1080p_extradata[] = {
4369         // SPS
4370         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4371         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4372         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4373         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4374         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4375         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4376         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4377         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4378         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4379         // PPS
4380         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4381         0xd0
4382     };
4383     static const uint8_t avci100_1080i_extradata[] = {
4384         // SPS
4385         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4386         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4387         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4388         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4389         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4390         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4391         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4392         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4393         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4394         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4395         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4396         // PPS
4397         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4398         0xd0
4399     };
4400     static const uint8_t avci50_1080i_extradata[] = {
4401         // SPS
4402         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4403         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4404         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4405         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4406         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4407         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4408         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4409         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4410         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4411         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4412         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4413         // PPS
4414         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4415         0x11
4416     };
4417     static const uint8_t avci100_720p_extradata[] = {
4418         // SPS
4419         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4420         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4421         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4422         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4423         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4424         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4425         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4426         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4427         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4428         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4429         // PPS
4430         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4431         0x11
4432     };
4433     int size = 0;
4434     const uint8_t *data = 0;
4435     if (st->codec->width == 1920) {
4436         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4437             data = avci100_1080p_extradata;
4438             size = sizeof(avci100_1080p_extradata);
4439         } else {
4440             data = avci100_1080i_extradata;
4441             size = sizeof(avci100_1080i_extradata);
4442         }
4443     } else if (st->codec->width == 1440) {
4444         data = avci50_1080i_extradata;
4445         size = sizeof(avci50_1080i_extradata);
4446     } else if (st->codec->width == 1280) {
4447         data = avci100_720p_extradata;
4448         size = sizeof(avci100_720p_extradata);
4449     }
4450     if (!size)
4451         return;
4452     av_freep(&st->codec->extradata);
4453     st->codec->extradata_size = 0;
4454     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4455     if (!st->codec->extradata)
4456         return;
4457     memcpy(st->codec->extradata, data, size);
4458     st->codec->extradata_size = size;
4459 }
4460
4461 static int match_host_pattern(const char *pattern, const char *hostname)
4462 {
4463     int len_p, len_h;
4464     if (!strcmp(pattern, "*"))
4465         return 1;
4466     // Skip a possible *. at the start of the pattern
4467     if (pattern[0] == '*')
4468         pattern++;
4469     if (pattern[0] == '.')
4470         pattern++;
4471     len_p = strlen(pattern);
4472     len_h = strlen(hostname);
4473     if (len_p > len_h)
4474         return 0;
4475     // Simply check if the end of hostname is equal to 'pattern'
4476     if (!strcmp(pattern, &hostname[len_h - len_p])) {
4477         if (len_h == len_p)
4478             return 1; // Exact match
4479         if (hostname[len_h - len_p - 1] == '.')
4480             return 1; // The matched substring is a domain and not just a substring of a domain
4481     }
4482     return 0;
4483 }
4484
4485 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
4486 {
4487     char *buf, *start;
4488     int ret = 0;
4489     if (!no_proxy)
4490         return 0;
4491     if (!hostname)
4492         return 0;
4493     buf = av_strdup(no_proxy);
4494     if (!buf)
4495         return 0;
4496     start = buf;
4497     while (start) {
4498         char *sep, *next = NULL;
4499         start += strspn(start, " ,");
4500         sep = start + strcspn(start, " ,");
4501         if (*sep) {
4502             next = sep + 1;
4503             *sep = '\0';
4504         }
4505         if (match_host_pattern(start, hostname)) {
4506             ret = 1;
4507             break;
4508         }
4509         start = next;
4510     }
4511     av_free(buf);
4512     return ret;
4513 }