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