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->seek2any>0)
2096         flags |= AVSEEK_FLAG_ANY;
2097
2098     if (s->iformat->read_seek2) {
2099         int ret;
2100         ff_read_frame_flush(s);
2101
2102         if (stream_index == -1 && s->nb_streams == 1) {
2103             AVRational time_base = s->streams[0]->time_base;
2104             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2105             min_ts = av_rescale_rnd(min_ts, time_base.den,
2106                                     time_base.num * (int64_t)AV_TIME_BASE,
2107                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2108             max_ts = av_rescale_rnd(max_ts, time_base.den,
2109                                     time_base.num * (int64_t)AV_TIME_BASE,
2110                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2111         }
2112
2113         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2114
2115         if (ret >= 0)
2116             avformat_queue_attached_pictures(s);
2117         return ret;
2118     }
2119
2120     if(s->iformat->read_timestamp){
2121         //try to seek via read_timestamp()
2122     }
2123
2124     //Fallback to old API if new is not implemented but old is
2125     //Note the old has somewhat different semantics
2126     if (s->iformat->read_seek || 1) {
2127         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2128         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2129         if (ret<0 && ts != min_ts && max_ts != ts) {
2130             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2131             if (ret >= 0)
2132                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2133         }
2134         return ret;
2135     }
2136
2137     // try some generic seek like seek_frame_generic() but with new ts semantics
2138     return -1; //unreachable
2139 }
2140
2141 /*******************************************************/
2142
2143 /**
2144  * Return TRUE if the stream has accurate duration in any stream.
2145  *
2146  * @return TRUE if the stream has accurate duration for at least one component.
2147  */
2148 static int has_duration(AVFormatContext *ic)
2149 {
2150     int i;
2151     AVStream *st;
2152
2153     for(i = 0;i < ic->nb_streams; i++) {
2154         st = ic->streams[i];
2155         if (st->duration != AV_NOPTS_VALUE)
2156             return 1;
2157     }
2158     if (ic->duration != AV_NOPTS_VALUE)
2159         return 1;
2160     return 0;
2161 }
2162
2163 /**
2164  * Estimate the stream timings from the one of each components.
2165  *
2166  * Also computes the global bitrate if possible.
2167  */
2168 static void update_stream_timings(AVFormatContext *ic)
2169 {
2170     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2171     int64_t duration, duration1, filesize;
2172     int i;
2173     AVStream *st;
2174     AVProgram *p;
2175
2176     start_time = INT64_MAX;
2177     start_time_text = INT64_MAX;
2178     end_time = INT64_MIN;
2179     duration = INT64_MIN;
2180     for(i = 0;i < ic->nb_streams; i++) {
2181         st = ic->streams[i];
2182         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2183             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2184             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2185                 if (start_time1 < start_time_text)
2186                     start_time_text = start_time1;
2187             } else
2188                 start_time = FFMIN(start_time, start_time1);
2189             end_time1 = AV_NOPTS_VALUE;
2190             if (st->duration != AV_NOPTS_VALUE) {
2191                 end_time1 = start_time1
2192                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2193                 end_time = FFMAX(end_time, end_time1);
2194             }
2195             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2196                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2197                     p->start_time = start_time1;
2198                 if(p->end_time < end_time1)
2199                     p->end_time = end_time1;
2200             }
2201         }
2202         if (st->duration != AV_NOPTS_VALUE) {
2203             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2204             duration = FFMAX(duration, duration1);
2205         }
2206     }
2207     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2208         start_time = start_time_text;
2209     else if(start_time > start_time_text)
2210         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2211
2212     if (start_time != INT64_MAX) {
2213         ic->start_time = start_time;
2214         if (end_time != INT64_MIN) {
2215             if (ic->nb_programs) {
2216                 for (i=0; i<ic->nb_programs; i++) {
2217                     p = ic->programs[i];
2218                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2219                         duration = FFMAX(duration, p->end_time - p->start_time);
2220                 }
2221             } else
2222                 duration = FFMAX(duration, end_time - start_time);
2223         }
2224     }
2225     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2226         ic->duration = duration;
2227     }
2228         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2229             /* compute the bitrate */
2230             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2231                 (double)ic->duration;
2232         }
2233 }
2234
2235 static void fill_all_stream_timings(AVFormatContext *ic)
2236 {
2237     int i;
2238     AVStream *st;
2239
2240     update_stream_timings(ic);
2241     for(i = 0;i < ic->nb_streams; i++) {
2242         st = ic->streams[i];
2243         if (st->start_time == AV_NOPTS_VALUE) {
2244             if(ic->start_time != AV_NOPTS_VALUE)
2245                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2246             if(ic->duration != AV_NOPTS_VALUE)
2247                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2248         }
2249     }
2250 }
2251
2252 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2253 {
2254     int64_t filesize, duration;
2255     int bit_rate, i;
2256     AVStream *st;
2257
2258     /* if bit_rate is already set, we believe it */
2259     if (ic->bit_rate <= 0) {
2260         bit_rate = 0;
2261         for(i=0;i<ic->nb_streams;i++) {
2262             st = ic->streams[i];
2263             if (st->codec->bit_rate > 0)
2264             bit_rate += st->codec->bit_rate;
2265         }
2266         ic->bit_rate = bit_rate;
2267     }
2268
2269     /* if duration is already set, we believe it */
2270     if (ic->duration == AV_NOPTS_VALUE &&
2271         ic->bit_rate != 0) {
2272         filesize = ic->pb ? avio_size(ic->pb) : 0;
2273         if (filesize > 0) {
2274             for(i = 0; i < ic->nb_streams; i++) {
2275                 st = ic->streams[i];
2276                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2277                 if (st->duration == AV_NOPTS_VALUE)
2278                     st->duration = duration;
2279             }
2280         }
2281     }
2282 }
2283
2284 #define DURATION_MAX_READ_SIZE 250000LL
2285 #define DURATION_MAX_RETRY 4
2286
2287 /* only usable for MPEG-PS streams */
2288 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2289 {
2290     AVPacket pkt1, *pkt = &pkt1;
2291     AVStream *st;
2292     int read_size, i, ret;
2293     int64_t end_time;
2294     int64_t filesize, offset, duration;
2295     int retry=0;
2296
2297     /* flush packet queue */
2298     flush_packet_queue(ic);
2299
2300     for (i=0; i<ic->nb_streams; i++) {
2301         st = ic->streams[i];
2302         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2303             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2304
2305         if (st->parser) {
2306             av_parser_close(st->parser);
2307             st->parser= NULL;
2308         }
2309     }
2310
2311     /* estimate the end time (duration) */
2312     /* XXX: may need to support wrapping */
2313     filesize = ic->pb ? avio_size(ic->pb) : 0;
2314     end_time = AV_NOPTS_VALUE;
2315     do{
2316         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2317         if (offset < 0)
2318             offset = 0;
2319
2320         avio_seek(ic->pb, offset, SEEK_SET);
2321         read_size = 0;
2322         for(;;) {
2323             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2324                 break;
2325
2326             do {
2327                 ret = ff_read_packet(ic, pkt);
2328             } while(ret == AVERROR(EAGAIN));
2329             if (ret != 0)
2330                 break;
2331             read_size += pkt->size;
2332             st = ic->streams[pkt->stream_index];
2333             if (pkt->pts != AV_NOPTS_VALUE &&
2334                 (st->start_time != AV_NOPTS_VALUE ||
2335                  st->first_dts  != AV_NOPTS_VALUE)) {
2336                 duration = end_time = pkt->pts;
2337                 if (st->start_time != AV_NOPTS_VALUE)
2338                     duration -= st->start_time;
2339                 else
2340                     duration -= st->first_dts;
2341                 if (duration > 0) {
2342                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2343                         st->duration = duration;
2344                 }
2345             }
2346             av_free_packet(pkt);
2347         }
2348     }while(   end_time==AV_NOPTS_VALUE
2349            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2350            && ++retry <= DURATION_MAX_RETRY);
2351
2352     fill_all_stream_timings(ic);
2353
2354     avio_seek(ic->pb, old_offset, SEEK_SET);
2355     for (i=0; i<ic->nb_streams; i++) {
2356         st= ic->streams[i];
2357         st->cur_dts= st->first_dts;
2358         st->last_IP_pts = AV_NOPTS_VALUE;
2359         st->reference_dts = AV_NOPTS_VALUE;
2360     }
2361 }
2362
2363 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2364 {
2365     int64_t file_size;
2366
2367     /* get the file size, if possible */
2368     if (ic->iformat->flags & AVFMT_NOFILE) {
2369         file_size = 0;
2370     } else {
2371         file_size = avio_size(ic->pb);
2372         file_size = FFMAX(0, file_size);
2373     }
2374
2375     if ((!strcmp(ic->iformat->name, "mpeg") ||
2376          !strcmp(ic->iformat->name, "mpegts")) &&
2377         file_size && ic->pb->seekable) {
2378         /* get accurate estimate from the PTSes */
2379         estimate_timings_from_pts(ic, old_offset);
2380         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2381     } else if (has_duration(ic)) {
2382         /* at least one component has timings - we use them for all
2383            the components */
2384         fill_all_stream_timings(ic);
2385         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2386     } else {
2387         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2388         /* less precise: use bitrate info */
2389         estimate_timings_from_bit_rate(ic);
2390         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2391     }
2392     update_stream_timings(ic);
2393
2394     {
2395         int i;
2396         AVStream av_unused *st;
2397         for(i = 0;i < ic->nb_streams; i++) {
2398             st = ic->streams[i];
2399             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2400                     (double) st->start_time / AV_TIME_BASE,
2401                     (double) st->duration   / AV_TIME_BASE);
2402         }
2403         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2404                 (double) ic->start_time / AV_TIME_BASE,
2405                 (double) ic->duration   / AV_TIME_BASE,
2406                 ic->bit_rate / 1000);
2407     }
2408 }
2409
2410 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2411 {
2412     AVCodecContext *avctx = st->codec;
2413
2414 #define FAIL(errmsg) do {                                         \
2415         if (errmsg_ptr)                                           \
2416             *errmsg_ptr = errmsg;                                 \
2417         return 0;                                                 \
2418     } while (0)
2419
2420     switch (avctx->codec_type) {
2421     case AVMEDIA_TYPE_AUDIO:
2422         if (!avctx->frame_size && determinable_frame_size(avctx))
2423             FAIL("unspecified frame size");
2424         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2425             FAIL("unspecified sample format");
2426         if (!avctx->sample_rate)
2427             FAIL("unspecified sample rate");
2428         if (!avctx->channels)
2429             FAIL("unspecified number of channels");
2430         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2431             FAIL("no decodable DTS frames");
2432         break;
2433     case AVMEDIA_TYPE_VIDEO:
2434         if (!avctx->width)
2435             FAIL("unspecified size");
2436         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2437             FAIL("unspecified pixel format");
2438         break;
2439     case AVMEDIA_TYPE_SUBTITLE:
2440         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2441             FAIL("unspecified size");
2442         break;
2443     case AVMEDIA_TYPE_DATA:
2444         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2445     }
2446
2447     if (avctx->codec_id == AV_CODEC_ID_NONE)
2448         FAIL("unknown codec");
2449     return 1;
2450 }
2451
2452 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2453 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2454 {
2455     const AVCodec *codec;
2456     int got_picture = 1, ret = 0;
2457     AVFrame *frame = avcodec_alloc_frame();
2458     AVSubtitle subtitle;
2459     AVPacket pkt = *avpkt;
2460
2461     if (!frame)
2462         return AVERROR(ENOMEM);
2463
2464     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2465         AVDictionary *thread_opt = NULL;
2466
2467         codec = st->codec->codec ? st->codec->codec :
2468                                    avcodec_find_decoder(st->codec->codec_id);
2469
2470         if (!codec) {
2471             st->info->found_decoder = -1;
2472             ret = -1;
2473             goto fail;
2474         }
2475
2476         /* force thread count to 1 since the h264 decoder will not extract SPS
2477          *  and PPS to extradata during multi-threaded decoding */
2478         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2479         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2480         if (!options)
2481             av_dict_free(&thread_opt);
2482         if (ret < 0) {
2483             st->info->found_decoder = -1;
2484             goto fail;
2485         }
2486         st->info->found_decoder = 1;
2487     } else if (!st->info->found_decoder)
2488         st->info->found_decoder = 1;
2489
2490     if (st->info->found_decoder < 0) {
2491         ret = -1;
2492         goto fail;
2493     }
2494
2495     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2496            ret >= 0 &&
2497            (!has_codec_parameters(st, NULL)   ||
2498            !has_decode_delay_been_guessed(st) ||
2499            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2500         got_picture = 0;
2501         avcodec_get_frame_defaults(frame);
2502         switch(st->codec->codec_type) {
2503         case AVMEDIA_TYPE_VIDEO:
2504             ret = avcodec_decode_video2(st->codec, frame,
2505                                         &got_picture, &pkt);
2506             break;
2507         case AVMEDIA_TYPE_AUDIO:
2508             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2509             break;
2510         case AVMEDIA_TYPE_SUBTITLE:
2511             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2512                                            &got_picture, &pkt);
2513             ret = pkt.size;
2514             break;
2515         default:
2516             break;
2517         }
2518         if (ret >= 0) {
2519             if (got_picture)
2520                 st->nb_decoded_frames++;
2521             pkt.data += ret;
2522             pkt.size -= ret;
2523             ret       = got_picture;
2524         }
2525     }
2526
2527     if(!pkt.data && !got_picture)
2528         ret = -1;
2529
2530 fail:
2531     avcodec_free_frame(&frame);
2532     return ret;
2533 }
2534
2535 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2536 {
2537     while (tags->id != AV_CODEC_ID_NONE) {
2538         if (tags->id == id)
2539             return tags->tag;
2540         tags++;
2541     }
2542     return 0;
2543 }
2544
2545 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2546 {
2547     int i;
2548     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2549         if(tag == tags[i].tag)
2550             return tags[i].id;
2551     }
2552     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2553         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2554             return tags[i].id;
2555     }
2556     return AV_CODEC_ID_NONE;
2557 }
2558
2559 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2560 {
2561     if (flt) {
2562         switch (bps) {
2563         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2564         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2565         default: return AV_CODEC_ID_NONE;
2566         }
2567     } else {
2568         bps  += 7;
2569         bps >>= 3;
2570         if (sflags & (1 << (bps - 1))) {
2571             switch (bps) {
2572             case 1:  return AV_CODEC_ID_PCM_S8;
2573             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2574             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2575             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2576             default: return AV_CODEC_ID_NONE;
2577             }
2578         } else {
2579             switch (bps) {
2580             case 1:  return AV_CODEC_ID_PCM_U8;
2581             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2582             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2583             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2584             default: return AV_CODEC_ID_NONE;
2585             }
2586         }
2587     }
2588 }
2589
2590 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2591 {
2592     unsigned int tag;
2593     if (!av_codec_get_tag2(tags, id, &tag))
2594         return 0;
2595     return tag;
2596 }
2597
2598 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2599                       unsigned int *tag)
2600 {
2601     int i;
2602     for(i=0; tags && tags[i]; i++){
2603         const AVCodecTag *codec_tags = tags[i];
2604         while (codec_tags->id != AV_CODEC_ID_NONE) {
2605             if (codec_tags->id == id) {
2606                 *tag = codec_tags->tag;
2607                 return 1;
2608             }
2609             codec_tags++;
2610         }
2611     }
2612     return 0;
2613 }
2614
2615 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2616 {
2617     int i;
2618     for(i=0; tags && tags[i]; i++){
2619         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2620         if(id!=AV_CODEC_ID_NONE) return id;
2621     }
2622     return AV_CODEC_ID_NONE;
2623 }
2624
2625 static void compute_chapters_end(AVFormatContext *s)
2626 {
2627     unsigned int i, j;
2628     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2629
2630     for (i = 0; i < s->nb_chapters; i++)
2631         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2632             AVChapter *ch = s->chapters[i];
2633             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2634                                      : INT64_MAX;
2635
2636             for (j = 0; j < s->nb_chapters; j++) {
2637                 AVChapter *ch1 = s->chapters[j];
2638                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2639                 if (j != i && next_start > ch->start && next_start < end)
2640                     end = next_start;
2641             }
2642             ch->end = (end == INT64_MAX) ? ch->start : end;
2643         }
2644 }
2645
2646 static int get_std_framerate(int i){
2647     if(i<60*12) return (i+1)*1001;
2648     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2649 }
2650
2651 /*
2652  * Is the time base unreliable.
2653  * This is a heuristic to balance between quick acceptance of the values in
2654  * the headers vs. some extra checks.
2655  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2656  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2657  * And there are "variable" fps files this needs to detect as well.
2658  */
2659 static int tb_unreliable(AVCodecContext *c){
2660     if(   c->time_base.den >= 101L*c->time_base.num
2661        || c->time_base.den <    5L*c->time_base.num
2662 /*       || c->codec_tag == AV_RL32("DIVX")
2663        || c->codec_tag == AV_RL32("XVID")*/
2664        || c->codec_tag == AV_RL32("mp4v")
2665        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2666        || c->codec_id == AV_CODEC_ID_H264
2667        )
2668         return 1;
2669     return 0;
2670 }
2671
2672 #if FF_API_FORMAT_PARAMETERS
2673 int av_find_stream_info(AVFormatContext *ic)
2674 {
2675     return avformat_find_stream_info(ic, NULL);
2676 }
2677 #endif
2678
2679 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2680 {
2681     int i, count, ret, read_size, j;
2682     AVStream *st;
2683     AVPacket pkt1, *pkt;
2684     int64_t old_offset = avio_tell(ic->pb);
2685     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2686     int flush_codecs = ic->probesize > 0;
2687
2688     if(ic->pb)
2689         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2690
2691     for(i=0;i<ic->nb_streams;i++) {
2692         const AVCodec *codec;
2693         AVDictionary *thread_opt = NULL;
2694         st = ic->streams[i];
2695
2696         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2697             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2698 /*            if(!st->time_base.num)
2699                 st->time_base= */
2700             if(!st->codec->time_base.num)
2701                 st->codec->time_base= st->time_base;
2702         }
2703         //only for the split stuff
2704         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2705             st->parser = av_parser_init(st->codec->codec_id);
2706             if(st->parser){
2707                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2708                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2709                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2710                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2711                 }
2712             } else if (st->need_parsing) {
2713                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2714                        "%s, packets or times may be invalid.\n",
2715                        avcodec_get_name(st->codec->codec_id));
2716             }
2717         }
2718         codec = st->codec->codec ? st->codec->codec :
2719                                    avcodec_find_decoder(st->codec->codec_id);
2720
2721         /* force thread count to 1 since the h264 decoder will not extract SPS
2722          *  and PPS to extradata during multi-threaded decoding */
2723         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2724
2725         /* Ensure that subtitle_header is properly set. */
2726         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2727             && codec && !st->codec->codec)
2728             avcodec_open2(st->codec, codec, options ? &options[i]
2729                               : &thread_opt);
2730
2731         //try to just open decoders, in case this is enough to get parameters
2732         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2733             if (codec && !st->codec->codec)
2734                 avcodec_open2(st->codec, codec, options ? &options[i]
2735                               : &thread_opt);
2736         }
2737         if (!options)
2738             av_dict_free(&thread_opt);
2739     }
2740
2741     for (i=0; i<ic->nb_streams; i++) {
2742 #if FF_API_R_FRAME_RATE
2743         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2744 #endif
2745         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2746         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2747     }
2748
2749     count = 0;
2750     read_size = 0;
2751     for(;;) {
2752         if (ff_check_interrupt(&ic->interrupt_callback)){
2753             ret= AVERROR_EXIT;
2754             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2755             break;
2756         }
2757
2758         /* check if one codec still needs to be handled */
2759         for(i=0;i<ic->nb_streams;i++) {
2760             int fps_analyze_framecount = 20;
2761
2762             st = ic->streams[i];
2763             if (!has_codec_parameters(st, NULL))
2764                 break;
2765             /* if the timebase is coarse (like the usual millisecond precision
2766                of mkv), we need to analyze more frames to reliably arrive at
2767                the correct fps */
2768             if (av_q2d(st->time_base) > 0.0005)
2769                 fps_analyze_framecount *= 2;
2770             if (ic->fps_probe_size >= 0)
2771                 fps_analyze_framecount = ic->fps_probe_size;
2772             /* variable fps and no guess at the real fps */
2773             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2774                && st->info->duration_count < fps_analyze_framecount
2775                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2776                 break;
2777             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2778                 break;
2779             if (st->first_dts == AV_NOPTS_VALUE &&
2780                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2781                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2782                 break;
2783         }
2784         if (i == ic->nb_streams) {
2785             /* NOTE: if the format has no header, then we need to read
2786                some packets to get most of the streams, so we cannot
2787                stop here */
2788             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2789                 /* if we found the info for all the codecs, we can stop */
2790                 ret = count;
2791                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2792                 flush_codecs = 0;
2793                 break;
2794             }
2795         }
2796         /* we did not get all the codec info, but we read too much data */
2797         if (read_size >= ic->probesize) {
2798             ret = count;
2799             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2800             for (i = 0; i < ic->nb_streams; i++)
2801                 if (!ic->streams[i]->r_frame_rate.num &&
2802                     ic->streams[i]->info->duration_count <= 1)
2803                     av_log(ic, AV_LOG_WARNING,
2804                            "Stream #%d: not enough frames to estimate rate; "
2805                            "consider increasing probesize\n", i);
2806             break;
2807         }
2808
2809         /* NOTE: a new stream can be added there if no header in file
2810            (AVFMTCTX_NOHEADER) */
2811         ret = read_frame_internal(ic, &pkt1);
2812         if (ret == AVERROR(EAGAIN))
2813             continue;
2814
2815         if (ret < 0) {
2816             /* EOF or error*/
2817             break;
2818         }
2819
2820         if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2821             pkt = &pkt1;
2822         } else {
2823             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2824                                 &ic->packet_buffer_end);
2825             if ((ret = av_dup_packet(pkt)) < 0)
2826                 goto find_stream_info_err;
2827         }
2828
2829         read_size += pkt->size;
2830
2831         st = ic->streams[pkt->stream_index];
2832         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2833             /* check for non-increasing dts */
2834             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2835                 st->info->fps_last_dts >= pkt->dts) {
2836                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2837                        "packet %d with DTS %"PRId64", packet %d with DTS "
2838                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2839                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2840                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2841             }
2842             /* check for a discontinuity in dts - if the difference in dts
2843              * is more than 1000 times the average packet duration in the sequence,
2844              * we treat it as a discontinuity */
2845             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2846                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2847                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2848                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2849                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2850                        "packet %d with DTS %"PRId64", packet %d with DTS "
2851                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2852                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2853                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2854             }
2855
2856             /* update stored dts values */
2857             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2858                 st->info->fps_first_dts     = pkt->dts;
2859                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2860             }
2861             st->info->fps_last_dts = pkt->dts;
2862             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2863         }
2864         if (st->codec_info_nb_frames>1) {
2865             int64_t t=0;
2866             if (st->time_base.den > 0)
2867                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2868             if (st->avg_frame_rate.num > 0)
2869                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2870
2871             if (t >= ic->max_analyze_duration) {
2872                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2873                 break;
2874             }
2875             if (pkt->duration) {
2876                 st->info->codec_info_duration        += pkt->duration;
2877                 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2878             }
2879         }
2880 #if FF_API_R_FRAME_RATE
2881         {
2882             int64_t last = st->info->last_dts;
2883
2884             if(   pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2885                && pkt->dts - (uint64_t)last < INT64_MAX){
2886                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2887                 int64_t duration= pkt->dts - last;
2888
2889 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2890 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2891                 for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2892                     int framerate= get_std_framerate(i);
2893                     double sdts= dts*framerate/(1001*12);
2894                     for(j=0; j<2; j++){
2895                         int64_t ticks= llrint(sdts+j*0.5);
2896                         double error= sdts - ticks + j*0.5;
2897                         st->info->duration_error[j][0][i] += error;
2898                         st->info->duration_error[j][1][i] += error*error;
2899                     }
2900                 }
2901                 st->info->duration_count++;
2902                 // ignore the first 4 values, they might have some random jitter
2903                 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2904                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2905             }
2906             if (pkt->dts != AV_NOPTS_VALUE)
2907                 st->info->last_dts = pkt->dts;
2908         }
2909 #endif
2910         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2911             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2912             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2913                 st->codec->extradata_size= i;
2914                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2915                 if (!st->codec->extradata)
2916                     return AVERROR(ENOMEM);
2917                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2918                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2919             }
2920         }
2921
2922         /* if still no information, we try to open the codec and to
2923            decompress the frame. We try to avoid that in most cases as
2924            it takes longer and uses more memory. For MPEG-4, we need to
2925            decompress for QuickTime.
2926
2927            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2928            least one frame of codec data, this makes sure the codec initializes
2929            the channel configuration and does not only trust the values from the container.
2930         */
2931         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2932
2933         st->codec_info_nb_frames++;
2934         count++;
2935     }
2936
2937     if (flush_codecs) {
2938         AVPacket empty_pkt = { 0 };
2939         int err = 0;
2940         av_init_packet(&empty_pkt);
2941
2942         ret = -1; /* we could not have all the codec parameters before EOF */
2943         for(i=0;i<ic->nb_streams;i++) {
2944             const char *errmsg;
2945
2946             st = ic->streams[i];
2947
2948             /* flush the decoders */
2949             if (st->info->found_decoder == 1) {
2950                 do {
2951                     err = try_decode_frame(st, &empty_pkt,
2952                                             (options && i < orig_nb_streams) ?
2953                                             &options[i] : NULL);
2954                 } while (err > 0 && !has_codec_parameters(st, NULL));
2955
2956                 if (err < 0) {
2957                     av_log(ic, AV_LOG_INFO,
2958                         "decoding for stream %d failed\n", st->index);
2959                 }
2960             }
2961
2962             if (!has_codec_parameters(st, &errmsg)) {
2963                 char buf[256];
2964                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2965                 av_log(ic, AV_LOG_WARNING,
2966                        "Could not find codec parameters for stream %d (%s): %s\n"
2967                        "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2968                        i, buf, errmsg);
2969             } else {
2970                 ret = 0;
2971             }
2972         }
2973     }
2974
2975     // close codecs which were opened in try_decode_frame()
2976     for(i=0;i<ic->nb_streams;i++) {
2977         st = ic->streams[i];
2978         avcodec_close(st->codec);
2979     }
2980     for(i=0;i<ic->nb_streams;i++) {
2981         st = ic->streams[i];
2982         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2983             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2984                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2985                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2986                     st->codec->codec_tag= tag;
2987             }
2988
2989             /* estimate average framerate if not set by demuxer */
2990             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
2991                 int      best_fps = 0;
2992                 double best_error = 0.01;
2993
2994                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2995                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
2996                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
2997
2998                 /* round guessed framerate to a "standard" framerate if it's
2999                  * within 1% of the original estimate*/
3000                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3001                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3002                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3003
3004                     if (error < best_error) {
3005                         best_error = error;
3006                         best_fps   = std_fps.num;
3007                     }
3008                 }
3009                 if (best_fps) {
3010                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3011                               best_fps, 12*1001, INT_MAX);
3012                 }
3013             }
3014             // the check for tb_unreliable() is not completely correct, since this is not about handling
3015             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3016             // ipmovie.c produces.
3017             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)
3018                 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);
3019             if (st->info->duration_count>1 && !st->r_frame_rate.num
3020                 && tb_unreliable(st->codec)) {
3021                 int num = 0;
3022                 double best_error= 0.01;
3023
3024                 for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
3025                     int k;
3026
3027                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3028                         continue;
3029                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3030                         continue;
3031                     for(k=0; k<2; k++){
3032                         int n= st->info->duration_count;
3033                         double a= st->info->duration_error[k][0][j] / n;
3034                         double error= st->info->duration_error[k][1][j]/n - a*a;
3035
3036                         if(error < best_error && best_error> 0.000000001){
3037                             best_error= error;
3038                             num = get_std_framerate(j);
3039                         }
3040                         if(error < 0.02)
3041                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3042                     }
3043                 }
3044                 // do not increase frame rate by more than 1 % in order to match a standard rate.
3045                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3046                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3047             }
3048
3049             if (!st->r_frame_rate.num){
3050                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3051                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3052                     st->r_frame_rate.num = st->codec->time_base.den;
3053                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3054                 }else{
3055                     st->r_frame_rate.num = st->time_base.den;
3056                     st->r_frame_rate.den = st->time_base.num;
3057                 }
3058             }
3059         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3060             if(!st->codec->bits_per_coded_sample)
3061                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3062             // set stream disposition based on audio service type
3063             switch (st->codec->audio_service_type) {
3064             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3065                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3066             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3067                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3068             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3069                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3070             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3071                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3072             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3073                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3074             }
3075         }
3076     }
3077
3078     if(ic->probesize)
3079     estimate_timings(ic, old_offset);
3080
3081     compute_chapters_end(ic);
3082
3083  find_stream_info_err:
3084     for (i=0; i < ic->nb_streams; i++) {
3085         if (ic->streams[i]->codec)
3086             ic->streams[i]->codec->thread_count = 0;
3087         av_freep(&ic->streams[i]->info);
3088     }
3089     if(ic->pb)
3090         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3091     return ret;
3092 }
3093
3094 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3095 {
3096     int i, j;
3097
3098     for (i = 0; i < ic->nb_programs; i++) {
3099         if (ic->programs[i] == last) {
3100             last = NULL;
3101         } else {
3102             if (!last)
3103                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3104                     if (ic->programs[i]->stream_index[j] == s)
3105                         return ic->programs[i];
3106         }
3107     }
3108     return NULL;
3109 }
3110
3111 int av_find_best_stream(AVFormatContext *ic,
3112                         enum AVMediaType type,
3113                         int wanted_stream_nb,
3114                         int related_stream,
3115                         AVCodec **decoder_ret,
3116                         int flags)
3117 {
3118     int i, nb_streams = ic->nb_streams;
3119     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3120     unsigned *program = NULL;
3121     AVCodec *decoder = NULL, *best_decoder = NULL;
3122
3123     if (related_stream >= 0 && wanted_stream_nb < 0) {
3124         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3125         if (p) {
3126             program = p->stream_index;
3127             nb_streams = p->nb_stream_indexes;
3128         }
3129     }
3130     for (i = 0; i < nb_streams; i++) {
3131         int real_stream_index = program ? program[i] : i;
3132         AVStream *st = ic->streams[real_stream_index];
3133         AVCodecContext *avctx = st->codec;
3134         if (avctx->codec_type != type)
3135             continue;
3136         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3137             continue;
3138         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3139             continue;
3140         if (decoder_ret) {
3141             decoder = avcodec_find_decoder(st->codec->codec_id);
3142             if (!decoder) {
3143                 if (ret < 0)
3144                     ret = AVERROR_DECODER_NOT_FOUND;
3145                 continue;
3146             }
3147         }
3148         count = st->codec_info_nb_frames;
3149         bitrate = avctx->bit_rate;
3150         multiframe = FFMIN(5, count);
3151         if ((best_multiframe >  multiframe) ||
3152             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3153             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3154             continue;
3155         best_count = count;
3156         best_bitrate = bitrate;
3157         best_multiframe = multiframe;
3158         ret = real_stream_index;
3159         best_decoder = decoder;
3160         if (program && i == nb_streams - 1 && ret < 0) {
3161             program = NULL;
3162             nb_streams = ic->nb_streams;
3163             i = 0; /* no related stream found, try again with everything */
3164         }
3165     }
3166     if (decoder_ret)
3167         *decoder_ret = best_decoder;
3168     return ret;
3169 }
3170
3171 /*******************************************************/
3172
3173 int av_read_play(AVFormatContext *s)
3174 {
3175     if (s->iformat->read_play)
3176         return s->iformat->read_play(s);
3177     if (s->pb)
3178         return avio_pause(s->pb, 0);
3179     return AVERROR(ENOSYS);
3180 }
3181
3182 int av_read_pause(AVFormatContext *s)
3183 {
3184     if (s->iformat->read_pause)
3185         return s->iformat->read_pause(s);
3186     if (s->pb)
3187         return avio_pause(s->pb, 1);
3188     return AVERROR(ENOSYS);
3189 }
3190
3191 void ff_free_stream(AVFormatContext *s, AVStream *st){
3192     av_assert0(s->nb_streams>0);
3193     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3194
3195     if (st->parser) {
3196         av_parser_close(st->parser);
3197     }
3198     if (st->attached_pic.data)
3199         av_free_packet(&st->attached_pic);
3200     av_dict_free(&st->metadata);
3201     av_freep(&st->index_entries);
3202     av_freep(&st->codec->extradata);
3203     av_freep(&st->codec->subtitle_header);
3204     av_freep(&st->codec);
3205     av_freep(&st->priv_data);
3206     av_freep(&st->info);
3207     av_freep(&st->probe_data.buf);
3208     av_freep(&s->streams[ --s->nb_streams ]);
3209 }
3210
3211 void avformat_free_context(AVFormatContext *s)
3212 {
3213     int i;
3214
3215     if (!s)
3216         return;
3217
3218     av_opt_free(s);
3219     if (s->iformat && s->iformat->priv_class && s->priv_data)
3220         av_opt_free(s->priv_data);
3221
3222     for(i=s->nb_streams-1; i>=0; i--) {
3223         ff_free_stream(s, s->streams[i]);
3224     }
3225     for(i=s->nb_programs-1; i>=0; i--) {
3226         av_dict_free(&s->programs[i]->metadata);
3227         av_freep(&s->programs[i]->stream_index);
3228         av_freep(&s->programs[i]);
3229     }
3230     av_freep(&s->programs);
3231     av_freep(&s->priv_data);
3232     while(s->nb_chapters--) {
3233         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3234         av_freep(&s->chapters[s->nb_chapters]);
3235     }
3236     av_freep(&s->chapters);
3237     av_dict_free(&s->metadata);
3238     av_freep(&s->streams);
3239     av_free(s);
3240 }
3241
3242 #if FF_API_CLOSE_INPUT_FILE
3243 void av_close_input_file(AVFormatContext *s)
3244 {
3245     avformat_close_input(&s);
3246 }
3247 #endif
3248
3249 void avformat_close_input(AVFormatContext **ps)
3250 {
3251     AVFormatContext *s = *ps;
3252     AVIOContext *pb = s->pb;
3253
3254     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3255         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3256         pb = NULL;
3257
3258     flush_packet_queue(s);
3259
3260     if (s->iformat) {
3261         if (s->iformat->read_close)
3262             s->iformat->read_close(s);
3263     }
3264
3265     avformat_free_context(s);
3266
3267     *ps = NULL;
3268
3269     avio_close(pb);
3270 }
3271
3272 #if FF_API_NEW_STREAM
3273 AVStream *av_new_stream(AVFormatContext *s, int id)
3274 {
3275     AVStream *st = avformat_new_stream(s, NULL);
3276     if (st)
3277         st->id = id;
3278     return st;
3279 }
3280 #endif
3281
3282 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3283 {
3284     AVStream *st;
3285     int i;
3286     AVStream **streams;
3287
3288     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3289         return NULL;
3290     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3291     if (!streams)
3292         return NULL;
3293     s->streams = streams;
3294
3295     st = av_mallocz(sizeof(AVStream));
3296     if (!st)
3297         return NULL;
3298     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3299         av_free(st);
3300         return NULL;
3301     }
3302     st->info->last_dts = AV_NOPTS_VALUE;
3303
3304     st->codec = avcodec_alloc_context3(c);
3305     if (s->iformat) {
3306         /* no default bitrate if decoding */
3307         st->codec->bit_rate = 0;
3308     }
3309     st->index = s->nb_streams;
3310     st->start_time = AV_NOPTS_VALUE;
3311     st->duration = AV_NOPTS_VALUE;
3312         /* we set the current DTS to 0 so that formats without any timestamps
3313            but durations get some timestamps, formats with some unknown
3314            timestamps have their first few packets buffered and the
3315            timestamps corrected before they are returned to the user */
3316     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3317     st->first_dts = AV_NOPTS_VALUE;
3318     st->probe_packets = MAX_PROBE_PACKETS;
3319     st->pts_wrap_reference = AV_NOPTS_VALUE;
3320     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3321
3322     /* default pts setting is MPEG-like */
3323     avpriv_set_pts_info(st, 33, 1, 90000);
3324     st->last_IP_pts = AV_NOPTS_VALUE;
3325     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3326         st->pts_buffer[i]= AV_NOPTS_VALUE;
3327     st->reference_dts = AV_NOPTS_VALUE;
3328
3329     st->sample_aspect_ratio = (AVRational){0,1};
3330
3331 #if FF_API_R_FRAME_RATE
3332     st->info->last_dts      = AV_NOPTS_VALUE;
3333 #endif
3334     st->info->fps_first_dts = AV_NOPTS_VALUE;
3335     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3336
3337     s->streams[s->nb_streams++] = st;
3338     return st;
3339 }
3340
3341 AVProgram *av_new_program(AVFormatContext *ac, int id)
3342 {
3343     AVProgram *program=NULL;
3344     int i;
3345
3346     av_dlog(ac, "new_program: id=0x%04x\n", id);
3347
3348     for(i=0; i<ac->nb_programs; i++)
3349         if(ac->programs[i]->id == id)
3350             program = ac->programs[i];
3351
3352     if(!program){
3353         program = av_mallocz(sizeof(AVProgram));
3354         if (!program)
3355             return NULL;
3356         dynarray_add(&ac->programs, &ac->nb_programs, program);
3357         program->discard = AVDISCARD_NONE;
3358     }
3359     program->id = id;
3360     program->pts_wrap_reference = AV_NOPTS_VALUE;
3361     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3362
3363     program->start_time =
3364     program->end_time   = AV_NOPTS_VALUE;
3365
3366     return program;
3367 }
3368
3369 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3370 {
3371     AVChapter *chapter = NULL;
3372     int i;
3373
3374     for(i=0; i<s->nb_chapters; i++)
3375         if(s->chapters[i]->id == id)
3376             chapter = s->chapters[i];
3377
3378     if(!chapter){
3379         chapter= av_mallocz(sizeof(AVChapter));
3380         if(!chapter)
3381             return NULL;
3382         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3383     }
3384     av_dict_set(&chapter->metadata, "title", title, 0);
3385     chapter->id    = id;
3386     chapter->time_base= time_base;
3387     chapter->start = start;
3388     chapter->end   = end;
3389
3390     return chapter;
3391 }
3392
3393 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3394 {
3395     int i, j;
3396     AVProgram *program=NULL;
3397     void *tmp;
3398
3399     if (idx >= ac->nb_streams) {
3400         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3401         return;
3402     }
3403
3404     for(i=0; i<ac->nb_programs; i++){
3405         if(ac->programs[i]->id != progid)
3406             continue;
3407         program = ac->programs[i];
3408         for(j=0; j<program->nb_stream_indexes; j++)
3409             if(program->stream_index[j] == idx)
3410                 return;
3411
3412         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3413         if(!tmp)
3414             return;
3415         program->stream_index = tmp;
3416         program->stream_index[program->nb_stream_indexes++] = idx;
3417         return;
3418     }
3419 }
3420
3421 static void print_fps(double d, const char *postfix){
3422     uint64_t v= lrintf(d*100);
3423     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3424     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3425     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3426 }
3427
3428 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3429 {
3430     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3431         AVDictionaryEntry *tag=NULL;
3432
3433         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3434         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3435             if(strcmp("language", tag->key)){
3436                 const char *p = tag->value;
3437                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3438                 while(*p) {
3439                     char tmp[256];
3440                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3441                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3442                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3443                     p += len;
3444                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3445                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3446                     if (*p) p++;
3447                 }
3448                 av_log(ctx, AV_LOG_INFO, "\n");
3449             }
3450         }
3451     }
3452 }
3453
3454 /* "user interface" functions */
3455 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3456 {
3457     char buf[256];
3458     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3459     AVStream *st = ic->streams[i];
3460     int g = av_gcd(st->time_base.num, st->time_base.den);
3461     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3462     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3463     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3464     /* the pid is an important information, so we display it */
3465     /* XXX: add a generic system */
3466     if (flags & AVFMT_SHOW_IDS)
3467         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3468     if (lang)
3469         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3470     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3471     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3472     if (st->sample_aspect_ratio.num && // default
3473         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3474         AVRational display_aspect_ratio;
3475         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3476                   st->codec->width*st->sample_aspect_ratio.num,
3477                   st->codec->height*st->sample_aspect_ratio.den,
3478                   1024*1024);
3479         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3480                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3481                  display_aspect_ratio.num, display_aspect_ratio.den);
3482     }
3483     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3484         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3485             print_fps(av_q2d(st->avg_frame_rate), "fps");
3486 #if FF_API_R_FRAME_RATE
3487         if(st->r_frame_rate.den && st->r_frame_rate.num)
3488             print_fps(av_q2d(st->r_frame_rate), "tbr");
3489 #endif
3490         if(st->time_base.den && st->time_base.num)
3491             print_fps(1/av_q2d(st->time_base), "tbn");
3492         if(st->codec->time_base.den && st->codec->time_base.num)
3493             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3494     }
3495     if (st->disposition & AV_DISPOSITION_DEFAULT)
3496         av_log(NULL, AV_LOG_INFO, " (default)");
3497     if (st->disposition & AV_DISPOSITION_DUB)
3498         av_log(NULL, AV_LOG_INFO, " (dub)");
3499     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3500         av_log(NULL, AV_LOG_INFO, " (original)");
3501     if (st->disposition & AV_DISPOSITION_COMMENT)
3502         av_log(NULL, AV_LOG_INFO, " (comment)");
3503     if (st->disposition & AV_DISPOSITION_LYRICS)
3504         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3505     if (st->disposition & AV_DISPOSITION_KARAOKE)
3506         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3507     if (st->disposition & AV_DISPOSITION_FORCED)
3508         av_log(NULL, AV_LOG_INFO, " (forced)");
3509     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3510         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3511     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3512         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3513     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3514         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3515     av_log(NULL, AV_LOG_INFO, "\n");
3516     dump_metadata(NULL, st->metadata, "    ");
3517 }
3518
3519 void av_dump_format(AVFormatContext *ic,
3520                     int index,
3521                     const char *url,
3522                     int is_output)
3523 {
3524     int i;
3525     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3526     if (ic->nb_streams && !printed)
3527         return;
3528
3529     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3530             is_output ? "Output" : "Input",
3531             index,
3532             is_output ? ic->oformat->name : ic->iformat->name,
3533             is_output ? "to" : "from", url);
3534     dump_metadata(NULL, ic->metadata, "  ");
3535     if (!is_output) {
3536         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3537         if (ic->duration != AV_NOPTS_VALUE) {
3538             int hours, mins, secs, us;
3539             int64_t duration = ic->duration + 5000;
3540             secs = duration / AV_TIME_BASE;
3541             us = duration % AV_TIME_BASE;
3542             mins = secs / 60;
3543             secs %= 60;
3544             hours = mins / 60;
3545             mins %= 60;
3546             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3547                    (100 * us) / AV_TIME_BASE);
3548         } else {
3549             av_log(NULL, AV_LOG_INFO, "N/A");
3550         }
3551         if (ic->start_time != AV_NOPTS_VALUE) {
3552             int secs, us;
3553             av_log(NULL, AV_LOG_INFO, ", start: ");
3554             secs = ic->start_time / AV_TIME_BASE;
3555             us = abs(ic->start_time % AV_TIME_BASE);
3556             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3557                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3558         }
3559         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3560         if (ic->bit_rate) {
3561             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3562         } else {
3563             av_log(NULL, AV_LOG_INFO, "N/A");
3564         }
3565         av_log(NULL, AV_LOG_INFO, "\n");
3566     }
3567     for (i = 0; i < ic->nb_chapters; i++) {
3568         AVChapter *ch = ic->chapters[i];
3569         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3570         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3571         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3572
3573         dump_metadata(NULL, ch->metadata, "    ");
3574     }
3575     if(ic->nb_programs) {
3576         int j, k, total = 0;
3577         for(j=0; j<ic->nb_programs; j++) {
3578             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3579                                                   "name", NULL, 0);
3580             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3581                    name ? name->value : "");
3582             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3583             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3584                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3585                 printed[ic->programs[j]->stream_index[k]] = 1;
3586             }
3587             total += ic->programs[j]->nb_stream_indexes;
3588         }
3589         if (total < ic->nb_streams)
3590             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3591     }
3592     for(i=0;i<ic->nb_streams;i++)
3593         if (!printed[i])
3594             dump_stream_format(ic, i, index, is_output);
3595
3596     av_free(printed);
3597 }
3598
3599 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3600 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3601 {
3602     return av_gettime();
3603 }
3604 #endif
3605
3606 uint64_t ff_ntp_time(void)
3607 {
3608   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3609 }
3610
3611 int av_get_frame_filename(char *buf, int buf_size,
3612                           const char *path, int number)
3613 {
3614     const char *p;
3615     char *q, buf1[20], c;
3616     int nd, len, percentd_found;
3617
3618     q = buf;
3619     p = path;
3620     percentd_found = 0;
3621     for(;;) {
3622         c = *p++;
3623         if (c == '\0')
3624             break;
3625         if (c == '%') {
3626             do {
3627                 nd = 0;
3628                 while (isdigit(*p)) {
3629                     nd = nd * 10 + *p++ - '0';
3630                 }
3631                 c = *p++;
3632             } while (isdigit(c));
3633
3634             switch(c) {
3635             case '%':
3636                 goto addchar;
3637             case 'd':
3638                 if (percentd_found)
3639                     goto fail;
3640                 percentd_found = 1;
3641                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3642                 len = strlen(buf1);
3643                 if ((q - buf + len) > buf_size - 1)
3644                     goto fail;
3645                 memcpy(q, buf1, len);
3646                 q += len;
3647                 break;
3648             default:
3649                 goto fail;
3650             }
3651         } else {
3652         addchar:
3653             if ((q - buf) < buf_size - 1)
3654                 *q++ = c;
3655         }
3656     }
3657     if (!percentd_found)
3658         goto fail;
3659     *q = '\0';
3660     return 0;
3661  fail:
3662     *q = '\0';
3663     return -1;
3664 }
3665
3666 static void hex_dump_internal(void *avcl, FILE *f, int level,
3667                               const uint8_t *buf, int size)
3668 {
3669     int len, i, j, c;
3670 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3671
3672     for(i=0;i<size;i+=16) {
3673         len = size - i;
3674         if (len > 16)
3675             len = 16;
3676         PRINT("%08x ", i);
3677         for(j=0;j<16;j++) {
3678             if (j < len)
3679                 PRINT(" %02x", buf[i+j]);
3680             else
3681                 PRINT("   ");
3682         }
3683         PRINT(" ");
3684         for(j=0;j<len;j++) {
3685             c = buf[i+j];
3686             if (c < ' ' || c > '~')
3687                 c = '.';
3688             PRINT("%c", c);
3689         }
3690         PRINT("\n");
3691     }
3692 #undef PRINT
3693 }
3694
3695 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3696 {
3697     hex_dump_internal(NULL, f, 0, buf, size);
3698 }
3699
3700 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3701 {
3702     hex_dump_internal(avcl, NULL, level, buf, size);
3703 }
3704
3705 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3706 {
3707 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3708     PRINT("stream #%d:\n", pkt->stream_index);
3709     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3710     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3711     /* DTS is _always_ valid after av_read_frame() */
3712     PRINT("  dts=");
3713     if (pkt->dts == AV_NOPTS_VALUE)
3714         PRINT("N/A");
3715     else
3716         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3717     /* PTS may not be known if B-frames are present. */
3718     PRINT("  pts=");
3719     if (pkt->pts == AV_NOPTS_VALUE)
3720         PRINT("N/A");
3721     else
3722         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3723     PRINT("\n");
3724     PRINT("  size=%d\n", pkt->size);
3725 #undef PRINT
3726     if (dump_payload)
3727         av_hex_dump(f, pkt->data, pkt->size);
3728 }
3729
3730 #if FF_API_PKT_DUMP
3731 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3732 {
3733     AVRational tb = { 1, AV_TIME_BASE };
3734     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3735 }
3736 #endif
3737
3738 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3739 {
3740     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3741 }
3742
3743 #if FF_API_PKT_DUMP
3744 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3745 {
3746     AVRational tb = { 1, AV_TIME_BASE };
3747     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3748 }
3749 #endif
3750
3751 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3752                       AVStream *st)
3753 {
3754     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3755 }
3756
3757 void av_url_split(char *proto, int proto_size,
3758                   char *authorization, int authorization_size,
3759                   char *hostname, int hostname_size,
3760                   int *port_ptr,
3761                   char *path, int path_size,
3762                   const char *url)
3763 {
3764     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3765
3766     if (port_ptr)               *port_ptr = -1;
3767     if (proto_size > 0)         proto[0] = 0;
3768     if (authorization_size > 0) authorization[0] = 0;
3769     if (hostname_size > 0)      hostname[0] = 0;
3770     if (path_size > 0)          path[0] = 0;
3771
3772     /* parse protocol */
3773     if ((p = strchr(url, ':'))) {
3774         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3775         p++; /* skip ':' */
3776         if (*p == '/') p++;
3777         if (*p == '/') p++;
3778     } else {
3779         /* no protocol means plain filename */
3780         av_strlcpy(path, url, path_size);
3781         return;
3782     }
3783
3784     /* separate path from hostname */
3785     ls = strchr(p, '/');
3786     ls2 = strchr(p, '?');
3787     if(!ls)
3788         ls = ls2;
3789     else if (ls && ls2)
3790         ls = FFMIN(ls, ls2);
3791     if(ls)
3792         av_strlcpy(path, ls, path_size);
3793     else
3794         ls = &p[strlen(p)]; // XXX
3795
3796     /* the rest is hostname, use that to parse auth/port */
3797     if (ls != p) {
3798         /* authorization (user[:pass]@hostname) */
3799         at2 = p;
3800         while ((at = strchr(p, '@')) && at < ls) {
3801             av_strlcpy(authorization, at2,
3802                        FFMIN(authorization_size, at + 1 - at2));
3803             p = at + 1; /* skip '@' */
3804         }
3805
3806         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3807             /* [host]:port */
3808             av_strlcpy(hostname, p + 1,
3809                        FFMIN(hostname_size, brk - p));
3810             if (brk[1] == ':' && port_ptr)
3811                 *port_ptr = atoi(brk + 2);
3812         } else if ((col = strchr(p, ':')) && col < ls) {
3813             av_strlcpy(hostname, p,
3814                        FFMIN(col + 1 - p, hostname_size));
3815             if (port_ptr) *port_ptr = atoi(col + 1);
3816         } else
3817             av_strlcpy(hostname, p,
3818                        FFMIN(ls + 1 - p, hostname_size));
3819     }
3820 }
3821
3822 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3823 {
3824     int i;
3825     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3826                                            '4', '5', '6', '7',
3827                                            '8', '9', 'A', 'B',
3828                                            'C', 'D', 'E', 'F' };
3829     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3830                                            '4', '5', '6', '7',
3831                                            '8', '9', 'a', 'b',
3832                                            'c', 'd', 'e', 'f' };
3833     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3834
3835     for(i = 0; i < s; i++) {
3836         buff[i * 2]     = hex_table[src[i] >> 4];
3837         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3838     }
3839
3840     return buff;
3841 }
3842
3843 int ff_hex_to_data(uint8_t *data, const char *p)
3844 {
3845     int c, len, v;
3846
3847     len = 0;
3848     v = 1;
3849     for (;;) {
3850         p += strspn(p, SPACE_CHARS);
3851         if (*p == '\0')
3852             break;
3853         c = toupper((unsigned char) *p++);
3854         if (c >= '0' && c <= '9')
3855             c = c - '0';
3856         else if (c >= 'A' && c <= 'F')
3857             c = c - 'A' + 10;
3858         else
3859             break;
3860         v = (v << 4) | c;
3861         if (v & 0x100) {
3862             if (data)
3863                 data[len] = v;
3864             len++;
3865             v = 1;
3866         }
3867     }
3868     return len;
3869 }
3870
3871 #if FF_API_SET_PTS_INFO
3872 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3873                      unsigned int pts_num, unsigned int pts_den)
3874 {
3875     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3876 }
3877 #endif
3878
3879 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3880                          unsigned int pts_num, unsigned int pts_den)
3881 {
3882     AVRational new_tb;
3883     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3884         if(new_tb.num != pts_num)
3885             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3886     }else
3887         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3888
3889     if(new_tb.num <= 0 || new_tb.den <= 0) {
3890         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);
3891         return;
3892     }
3893     s->time_base = new_tb;
3894     av_codec_set_pkt_timebase(s->codec, new_tb);
3895     s->pts_wrap_bits = pts_wrap_bits;
3896 }
3897
3898 int ff_url_join(char *str, int size, const char *proto,
3899                 const char *authorization, const char *hostname,
3900                 int port, const char *fmt, ...)
3901 {
3902 #if CONFIG_NETWORK
3903     struct addrinfo hints = { 0 }, *ai;
3904 #endif
3905
3906     str[0] = '\0';
3907     if (proto)
3908         av_strlcatf(str, size, "%s://", proto);
3909     if (authorization && authorization[0])
3910         av_strlcatf(str, size, "%s@", authorization);
3911 #if CONFIG_NETWORK && defined(AF_INET6)
3912     /* Determine if hostname is a numerical IPv6 address,
3913      * properly escape it within [] in that case. */
3914     hints.ai_flags = AI_NUMERICHOST;
3915     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3916         if (ai->ai_family == AF_INET6) {
3917             av_strlcat(str, "[", size);
3918             av_strlcat(str, hostname, size);
3919             av_strlcat(str, "]", size);
3920         } else {
3921             av_strlcat(str, hostname, size);
3922         }
3923         freeaddrinfo(ai);
3924     } else
3925 #endif
3926         /* Not an IPv6 address, just output the plain string. */
3927         av_strlcat(str, hostname, size);
3928
3929     if (port >= 0)
3930         av_strlcatf(str, size, ":%d", port);
3931     if (fmt) {
3932         va_list vl;
3933         int len = strlen(str);
3934
3935         va_start(vl, fmt);
3936         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3937         va_end(vl);
3938     }
3939     return strlen(str);
3940 }
3941
3942 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3943                      AVFormatContext *src)
3944 {
3945     AVPacket local_pkt;
3946
3947     local_pkt = *pkt;
3948     local_pkt.stream_index = dst_stream;
3949     if (pkt->pts != AV_NOPTS_VALUE)
3950         local_pkt.pts = av_rescale_q(pkt->pts,
3951                                      src->streams[pkt->stream_index]->time_base,
3952                                      dst->streams[dst_stream]->time_base);
3953     if (pkt->dts != AV_NOPTS_VALUE)
3954         local_pkt.dts = av_rescale_q(pkt->dts,
3955                                      src->streams[pkt->stream_index]->time_base,
3956                                      dst->streams[dst_stream]->time_base);
3957     return av_write_frame(dst, &local_pkt);
3958 }
3959
3960 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3961                         void *context)
3962 {
3963     const char *ptr = str;
3964
3965     /* Parse key=value pairs. */
3966     for (;;) {
3967         const char *key;
3968         char *dest = NULL, *dest_end;
3969         int key_len, dest_len = 0;
3970
3971         /* Skip whitespace and potential commas. */
3972         while (*ptr && (isspace(*ptr) || *ptr == ','))
3973             ptr++;
3974         if (!*ptr)
3975             break;
3976
3977         key = ptr;
3978
3979         if (!(ptr = strchr(key, '=')))
3980             break;
3981         ptr++;
3982         key_len = ptr - key;
3983
3984         callback_get_buf(context, key, key_len, &dest, &dest_len);
3985         dest_end = dest + dest_len - 1;
3986
3987         if (*ptr == '\"') {
3988             ptr++;
3989             while (*ptr && *ptr != '\"') {
3990                 if (*ptr == '\\') {
3991                     if (!ptr[1])
3992                         break;
3993                     if (dest && dest < dest_end)
3994                         *dest++ = ptr[1];
3995                     ptr += 2;
3996                 } else {
3997                     if (dest && dest < dest_end)
3998                         *dest++ = *ptr;
3999                     ptr++;
4000                 }
4001             }
4002             if (*ptr == '\"')
4003                 ptr++;
4004         } else {
4005             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4006                 if (dest && dest < dest_end)
4007                     *dest++ = *ptr;
4008         }
4009         if (dest)
4010             *dest = 0;
4011     }
4012 }
4013
4014 int ff_find_stream_index(AVFormatContext *s, int id)
4015 {
4016     int i;
4017     for (i = 0; i < s->nb_streams; i++) {
4018         if (s->streams[i]->id == id)
4019             return i;
4020     }
4021     return -1;
4022 }
4023
4024 void ff_make_absolute_url(char *buf, int size, const char *base,
4025                           const char *rel)
4026 {
4027     char *sep, *path_query;
4028     /* Absolute path, relative to the current server */
4029     if (base && strstr(base, "://") && rel[0] == '/') {
4030         if (base != buf)
4031             av_strlcpy(buf, base, size);
4032         sep = strstr(buf, "://");
4033         if (sep) {
4034             /* Take scheme from base url */
4035             if (rel[1] == '/') {
4036                 sep[1] = '\0';
4037             } else {
4038                 /* Take scheme and host from base url */
4039                 sep += 3;
4040                 sep = strchr(sep, '/');
4041                 if (sep)
4042                     *sep = '\0';
4043             }
4044         }
4045         av_strlcat(buf, rel, size);
4046         return;
4047     }
4048     /* If rel actually is an absolute url, just copy it */
4049     if (!base || strstr(rel, "://") || rel[0] == '/') {
4050         av_strlcpy(buf, rel, size);
4051         return;
4052     }
4053     if (base != buf)
4054         av_strlcpy(buf, base, size);
4055
4056     /* Strip off any query string from base */
4057     path_query = strchr(buf, '?');
4058     if (path_query != NULL)
4059         *path_query = '\0';
4060
4061     /* Is relative path just a new query part? */
4062     if (rel[0] == '?') {
4063         av_strlcat(buf, rel, size);
4064         return;
4065     }
4066
4067     /* Remove the file name from the base url */
4068     sep = strrchr(buf, '/');
4069     if (sep)
4070         sep[1] = '\0';
4071     else
4072         buf[0] = '\0';
4073     while (av_strstart(rel, "../", NULL) && sep) {
4074         /* Remove the path delimiter at the end */
4075         sep[0] = '\0';
4076         sep = strrchr(buf, '/');
4077         /* If the next directory name to pop off is "..", break here */
4078         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4079             /* Readd the slash we just removed */
4080             av_strlcat(buf, "/", size);
4081             break;
4082         }
4083         /* Cut off the directory name */
4084         if (sep)
4085             sep[1] = '\0';
4086         else
4087             buf[0] = '\0';
4088         rel += 3;
4089     }
4090     av_strlcat(buf, rel, size);
4091 }
4092
4093 int64_t ff_iso8601_to_unix_time(const char *datestr)
4094 {
4095     struct tm time1 = {0}, time2 = {0};
4096     char *ret1, *ret2;
4097     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4098     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4099     if (ret2 && !ret1)
4100         return av_timegm(&time2);
4101     else
4102         return av_timegm(&time1);
4103 }
4104
4105 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4106 {
4107     if (ofmt) {
4108         if (ofmt->query_codec)
4109             return ofmt->query_codec(codec_id, std_compliance);
4110         else if (ofmt->codec_tag)
4111             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4112         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4113                  codec_id == ofmt->subtitle_codec)
4114             return 1;
4115     }
4116     return AVERROR_PATCHWELCOME;
4117 }
4118
4119 int avformat_network_init(void)
4120 {
4121 #if CONFIG_NETWORK
4122     int ret;
4123     ff_network_inited_globally = 1;
4124     if ((ret = ff_network_init()) < 0)
4125         return ret;
4126     ff_tls_init();
4127 #endif
4128     return 0;
4129 }
4130
4131 int avformat_network_deinit(void)
4132 {
4133 #if CONFIG_NETWORK
4134     ff_network_close();
4135     ff_tls_deinit();
4136 #endif
4137     return 0;
4138 }
4139
4140 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4141                         uint64_t channel_layout, int32_t sample_rate,
4142                         int32_t width, int32_t height)
4143 {
4144     uint32_t flags = 0;
4145     int size = 4;
4146     uint8_t *data;
4147     if (!pkt)
4148         return AVERROR(EINVAL);
4149     if (channels) {
4150         size += 4;
4151         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4152     }
4153     if (channel_layout) {
4154         size += 8;
4155         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4156     }
4157     if (sample_rate) {
4158         size += 4;
4159         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4160     }
4161     if (width || height) {
4162         size += 8;
4163         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4164     }
4165     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4166     if (!data)
4167         return AVERROR(ENOMEM);
4168     bytestream_put_le32(&data, flags);
4169     if (channels)
4170         bytestream_put_le32(&data, channels);
4171     if (channel_layout)
4172         bytestream_put_le64(&data, channel_layout);
4173     if (sample_rate)
4174         bytestream_put_le32(&data, sample_rate);
4175     if (width || height) {
4176         bytestream_put_le32(&data, width);
4177         bytestream_put_le32(&data, height);
4178     }
4179     return 0;
4180 }
4181
4182 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4183 {
4184     return ff_codec_bmp_tags;
4185 }
4186 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4187 {
4188     return ff_codec_wav_tags;
4189 }
4190
4191 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4192 {
4193     AVRational undef = {0, 1};
4194     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4195     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4196     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4197
4198     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4199                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4200     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4201         stream_sample_aspect_ratio = undef;
4202
4203     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4204                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4205     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4206         frame_sample_aspect_ratio = undef;
4207
4208     if (stream_sample_aspect_ratio.num)
4209         return stream_sample_aspect_ratio;
4210     else
4211         return frame_sample_aspect_ratio;
4212 }
4213
4214 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4215                                     const char *spec)
4216 {
4217     if (*spec <= '9' && *spec >= '0') /* opt:index */
4218         return strtol(spec, NULL, 0) == st->index;
4219     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4220              *spec == 't') { /* opt:[vasdt] */
4221         enum AVMediaType type;
4222
4223         switch (*spec++) {
4224         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4225         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4226         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4227         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4228         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4229         default:  av_assert0(0);
4230         }
4231         if (type != st->codec->codec_type)
4232             return 0;
4233         if (*spec++ == ':') { /* possibly followed by :index */
4234             int i, index = strtol(spec, NULL, 0);
4235             for (i = 0; i < s->nb_streams; i++)
4236                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4237                    return i == st->index;
4238             return 0;
4239         }
4240         return 1;
4241     } else if (*spec == 'p' && *(spec + 1) == ':') {
4242         int prog_id, i, j;
4243         char *endptr;
4244         spec += 2;
4245         prog_id = strtol(spec, &endptr, 0);
4246         for (i = 0; i < s->nb_programs; i++) {
4247             if (s->programs[i]->id != prog_id)
4248                 continue;
4249
4250             if (*endptr++ == ':') {
4251                 int stream_idx = strtol(endptr, NULL, 0);
4252                 return stream_idx >= 0 &&
4253                     stream_idx < s->programs[i]->nb_stream_indexes &&
4254                     st->index == s->programs[i]->stream_index[stream_idx];
4255             }
4256
4257             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4258                 if (st->index == s->programs[i]->stream_index[j])
4259                     return 1;
4260         }
4261         return 0;
4262     } else if (*spec == '#') {
4263         int sid;
4264         char *endptr;
4265         sid = strtol(spec + 1, &endptr, 0);
4266         if (!*endptr)
4267             return st->id == sid;
4268     } else if (!*spec) /* empty specifier, matches everything */
4269         return 1;
4270
4271     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4272     return AVERROR(EINVAL);
4273 }
4274
4275 void ff_generate_avci_extradata(AVStream *st)
4276 {
4277     static const uint8_t avci100_1080p_extradata[] = {
4278         // SPS
4279         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4280         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4281         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4282         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4283         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4284         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4285         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4286         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4287         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4288         // PPS
4289         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4290         0xd0
4291     };
4292     static const uint8_t avci100_1080i_extradata[] = {
4293         // SPS
4294         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4295         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4296         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4297         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4298         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4299         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4300         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4301         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4302         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4303         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4304         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4305         // PPS
4306         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4307         0xd0
4308     };
4309     static const uint8_t avci50_1080i_extradata[] = {
4310         // SPS
4311         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4312         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4313         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4314         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4315         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4316         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4317         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4318         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4319         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4320         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4321         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4322         // PPS
4323         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4324         0x11
4325     };
4326     static const uint8_t avci100_720p_extradata[] = {
4327         // SPS
4328         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4329         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4330         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4331         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4332         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4333         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4334         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4335         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4336         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4337         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4338         // PPS
4339         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4340         0x11
4341     };
4342     int size = 0;
4343     const uint8_t *data = 0;
4344     if (st->codec->width == 1920) {
4345         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4346             data = avci100_1080p_extradata;
4347             size = sizeof(avci100_1080p_extradata);
4348         } else {
4349             data = avci100_1080i_extradata;
4350             size = sizeof(avci100_1080i_extradata);
4351         }
4352     } else if (st->codec->width == 1440) {
4353         data = avci50_1080i_extradata;
4354         size = sizeof(avci50_1080i_extradata);
4355     } else if (st->codec->width == 1280) {
4356         data = avci100_720p_extradata;
4357         size = sizeof(avci100_720p_extradata);
4358     }
4359     if (!size)
4360         return;
4361     av_freep(&st->codec->extradata);
4362     st->codec->extradata_size = 0;
4363     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4364     if (!st->codec->extradata)
4365         return;
4366     memcpy(st->codec->extradata, data, size);
4367     st->codec->extradata_size = size;
4368 }