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