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