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 of %d bytes 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" microseconds\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                && pkt->dts - (uint64_t)last < INT64_MAX){
2866                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2867                 int64_t duration= pkt->dts - last;
2868
2869 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2870 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2871                 for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2872                     int framerate= get_std_framerate(i);
2873                     double sdts= dts*framerate/(1001*12);
2874                     for(j=0; j<2; j++){
2875                         int64_t ticks= llrint(sdts+j*0.5);
2876                         double error= sdts - ticks + j*0.5;
2877                         st->info->duration_error[j][0][i] += error;
2878                         st->info->duration_error[j][1][i] += error*error;
2879                     }
2880                 }
2881                 st->info->duration_count++;
2882                 // ignore the first 4 values, they might have some random jitter
2883                 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2884                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2885             }
2886             if (pkt->dts != AV_NOPTS_VALUE)
2887                 st->info->last_dts = pkt->dts;
2888         }
2889 #endif
2890         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2891             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2892             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2893                 st->codec->extradata_size= i;
2894                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2895                 if (!st->codec->extradata)
2896                     return AVERROR(ENOMEM);
2897                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2898                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2899             }
2900         }
2901
2902         /* if still no information, we try to open the codec and to
2903            decompress the frame. We try to avoid that in most cases as
2904            it takes longer and uses more memory. For MPEG-4, we need to
2905            decompress for QuickTime.
2906
2907            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2908            least one frame of codec data, this makes sure the codec initializes
2909            the channel configuration and does not only trust the values from the container.
2910         */
2911         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2912
2913         st->codec_info_nb_frames++;
2914         count++;
2915     }
2916
2917     if (flush_codecs) {
2918         AVPacket empty_pkt = { 0 };
2919         int err = 0;
2920         av_init_packet(&empty_pkt);
2921
2922         ret = -1; /* we could not have all the codec parameters before EOF */
2923         for(i=0;i<ic->nb_streams;i++) {
2924             const char *errmsg;
2925
2926             st = ic->streams[i];
2927
2928             /* flush the decoders */
2929             if (st->info->found_decoder == 1) {
2930                 do {
2931                     err = try_decode_frame(st, &empty_pkt,
2932                                             (options && i < orig_nb_streams) ?
2933                                             &options[i] : NULL);
2934                 } while (err > 0 && !has_codec_parameters(st, NULL));
2935
2936                 if (err < 0) {
2937                     av_log(ic, AV_LOG_INFO,
2938                         "decoding for stream %d failed\n", st->index);
2939                 }
2940             }
2941
2942             if (!has_codec_parameters(st, &errmsg)) {
2943                 char buf[256];
2944                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2945                 av_log(ic, AV_LOG_WARNING,
2946                        "Could not find codec parameters for stream %d (%s): %s\n"
2947                        "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2948                        i, buf, errmsg);
2949             } else {
2950                 ret = 0;
2951             }
2952         }
2953     }
2954
2955     // close codecs which were opened in try_decode_frame()
2956     for(i=0;i<ic->nb_streams;i++) {
2957         st = ic->streams[i];
2958         avcodec_close(st->codec);
2959     }
2960     for(i=0;i<ic->nb_streams;i++) {
2961         st = ic->streams[i];
2962         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2963             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2964                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2965                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2966                     st->codec->codec_tag= tag;
2967             }
2968
2969             /* estimate average framerate if not set by demuxer */
2970             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
2971                 int      best_fps = 0;
2972                 double best_error = 0.01;
2973
2974                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2975                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
2976                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
2977
2978                 /* round guessed framerate to a "standard" framerate if it's
2979                  * within 1% of the original estimate*/
2980                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2981                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
2982                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2983
2984                     if (error < best_error) {
2985                         best_error = error;
2986                         best_fps   = std_fps.num;
2987                     }
2988                 }
2989                 if (best_fps) {
2990                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2991                               best_fps, 12*1001, INT_MAX);
2992                 }
2993             }
2994             // the check for tb_unreliable() is not completely correct, since this is not about handling
2995             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2996             // ipmovie.c produces.
2997             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)
2998                 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);
2999             if (st->info->duration_count>1 && !st->r_frame_rate.num
3000                 && tb_unreliable(st->codec)) {
3001                 int num = 0;
3002                 double best_error= 0.01;
3003
3004                 for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
3005                     int k;
3006
3007                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3008                         continue;
3009                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3010                         continue;
3011                     for(k=0; k<2; k++){
3012                         int n= st->info->duration_count;
3013                         double a= st->info->duration_error[k][0][j] / n;
3014                         double error= st->info->duration_error[k][1][j]/n - a*a;
3015
3016                         if(error < best_error && best_error> 0.000000001){
3017                             best_error= error;
3018                             num = get_std_framerate(j);
3019                         }
3020                         if(error < 0.02)
3021                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3022                     }
3023                 }
3024                 // do not increase frame rate by more than 1 % in order to match a standard rate.
3025                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3026                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3027             }
3028
3029             if (!st->r_frame_rate.num){
3030                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3031                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3032                     st->r_frame_rate.num = st->codec->time_base.den;
3033                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3034                 }else{
3035                     st->r_frame_rate.num = st->time_base.den;
3036                     st->r_frame_rate.den = st->time_base.num;
3037                 }
3038             }
3039         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3040             if(!st->codec->bits_per_coded_sample)
3041                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3042             // set stream disposition based on audio service type
3043             switch (st->codec->audio_service_type) {
3044             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3045                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3046             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3047                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3048             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3049                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3050             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3051                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3052             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3053                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3054             }
3055         }
3056     }
3057
3058     if(ic->probesize)
3059     estimate_timings(ic, old_offset);
3060
3061     compute_chapters_end(ic);
3062
3063  find_stream_info_err:
3064     for (i=0; i < ic->nb_streams; i++) {
3065         if (ic->streams[i]->codec)
3066             ic->streams[i]->codec->thread_count = 0;
3067         av_freep(&ic->streams[i]->info);
3068     }
3069     if(ic->pb)
3070         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3071     return ret;
3072 }
3073
3074 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3075 {
3076     int i, j;
3077
3078     for (i = 0; i < ic->nb_programs; i++) {
3079         if (ic->programs[i] == last) {
3080             last = NULL;
3081         } else {
3082             if (!last)
3083                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3084                     if (ic->programs[i]->stream_index[j] == s)
3085                         return ic->programs[i];
3086         }
3087     }
3088     return NULL;
3089 }
3090
3091 int av_find_best_stream(AVFormatContext *ic,
3092                         enum AVMediaType type,
3093                         int wanted_stream_nb,
3094                         int related_stream,
3095                         AVCodec **decoder_ret,
3096                         int flags)
3097 {
3098     int i, nb_streams = ic->nb_streams;
3099     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3100     unsigned *program = NULL;
3101     AVCodec *decoder = NULL, *best_decoder = NULL;
3102
3103     if (related_stream >= 0 && wanted_stream_nb < 0) {
3104         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3105         if (p) {
3106             program = p->stream_index;
3107             nb_streams = p->nb_stream_indexes;
3108         }
3109     }
3110     for (i = 0; i < nb_streams; i++) {
3111         int real_stream_index = program ? program[i] : i;
3112         AVStream *st = ic->streams[real_stream_index];
3113         AVCodecContext *avctx = st->codec;
3114         if (avctx->codec_type != type)
3115             continue;
3116         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3117             continue;
3118         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3119             continue;
3120         if (decoder_ret) {
3121             decoder = avcodec_find_decoder(st->codec->codec_id);
3122             if (!decoder) {
3123                 if (ret < 0)
3124                     ret = AVERROR_DECODER_NOT_FOUND;
3125                 continue;
3126             }
3127         }
3128         count = st->codec_info_nb_frames;
3129         bitrate = avctx->bit_rate;
3130         multiframe = FFMIN(5, count);
3131         if ((best_multiframe >  multiframe) ||
3132             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3133             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3134             continue;
3135         best_count = count;
3136         best_bitrate = bitrate;
3137         best_multiframe = multiframe;
3138         ret = real_stream_index;
3139         best_decoder = decoder;
3140         if (program && i == nb_streams - 1 && ret < 0) {
3141             program = NULL;
3142             nb_streams = ic->nb_streams;
3143             i = 0; /* no related stream found, try again with everything */
3144         }
3145     }
3146     if (decoder_ret)
3147         *decoder_ret = best_decoder;
3148     return ret;
3149 }
3150
3151 /*******************************************************/
3152
3153 int av_read_play(AVFormatContext *s)
3154 {
3155     if (s->iformat->read_play)
3156         return s->iformat->read_play(s);
3157     if (s->pb)
3158         return avio_pause(s->pb, 0);
3159     return AVERROR(ENOSYS);
3160 }
3161
3162 int av_read_pause(AVFormatContext *s)
3163 {
3164     if (s->iformat->read_pause)
3165         return s->iformat->read_pause(s);
3166     if (s->pb)
3167         return avio_pause(s->pb, 1);
3168     return AVERROR(ENOSYS);
3169 }
3170
3171 void ff_free_stream(AVFormatContext *s, AVStream *st){
3172     av_assert0(s->nb_streams>0);
3173     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3174
3175     if (st->parser) {
3176         av_parser_close(st->parser);
3177     }
3178     if (st->attached_pic.data)
3179         av_free_packet(&st->attached_pic);
3180     av_dict_free(&st->metadata);
3181     av_freep(&st->index_entries);
3182     av_freep(&st->codec->extradata);
3183     av_freep(&st->codec->subtitle_header);
3184     av_freep(&st->codec);
3185     av_freep(&st->priv_data);
3186     av_freep(&st->info);
3187     av_freep(&st->probe_data.buf);
3188     av_freep(&s->streams[ --s->nb_streams ]);
3189 }
3190
3191 void avformat_free_context(AVFormatContext *s)
3192 {
3193     int i;
3194
3195     if (!s)
3196         return;
3197
3198     av_opt_free(s);
3199     if (s->iformat && s->iformat->priv_class && s->priv_data)
3200         av_opt_free(s->priv_data);
3201
3202     for(i=s->nb_streams-1; i>=0; i--) {
3203         ff_free_stream(s, s->streams[i]);
3204     }
3205     for(i=s->nb_programs-1; i>=0; i--) {
3206         av_dict_free(&s->programs[i]->metadata);
3207         av_freep(&s->programs[i]->stream_index);
3208         av_freep(&s->programs[i]);
3209     }
3210     av_freep(&s->programs);
3211     av_freep(&s->priv_data);
3212     while(s->nb_chapters--) {
3213         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3214         av_freep(&s->chapters[s->nb_chapters]);
3215     }
3216     av_freep(&s->chapters);
3217     av_dict_free(&s->metadata);
3218     av_freep(&s->streams);
3219     av_free(s);
3220 }
3221
3222 #if FF_API_CLOSE_INPUT_FILE
3223 void av_close_input_file(AVFormatContext *s)
3224 {
3225     avformat_close_input(&s);
3226 }
3227 #endif
3228
3229 void avformat_close_input(AVFormatContext **ps)
3230 {
3231     AVFormatContext *s = *ps;
3232     AVIOContext *pb = s->pb;
3233
3234     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3235         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3236         pb = NULL;
3237
3238     flush_packet_queue(s);
3239
3240     if (s->iformat) {
3241         if (s->iformat->read_close)
3242             s->iformat->read_close(s);
3243     }
3244
3245     avformat_free_context(s);
3246
3247     *ps = NULL;
3248
3249     avio_close(pb);
3250 }
3251
3252 #if FF_API_NEW_STREAM
3253 AVStream *av_new_stream(AVFormatContext *s, int id)
3254 {
3255     AVStream *st = avformat_new_stream(s, NULL);
3256     if (st)
3257         st->id = id;
3258     return st;
3259 }
3260 #endif
3261
3262 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3263 {
3264     AVStream *st;
3265     int i;
3266     AVStream **streams;
3267
3268     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3269         return NULL;
3270     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3271     if (!streams)
3272         return NULL;
3273     s->streams = streams;
3274
3275     st = av_mallocz(sizeof(AVStream));
3276     if (!st)
3277         return NULL;
3278     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3279         av_free(st);
3280         return NULL;
3281     }
3282     st->info->last_dts = AV_NOPTS_VALUE;
3283
3284     st->codec = avcodec_alloc_context3(c);
3285     if (s->iformat) {
3286         /* no default bitrate if decoding */
3287         st->codec->bit_rate = 0;
3288     }
3289     st->index = s->nb_streams;
3290     st->start_time = AV_NOPTS_VALUE;
3291     st->duration = AV_NOPTS_VALUE;
3292         /* we set the current DTS to 0 so that formats without any timestamps
3293            but durations get some timestamps, formats with some unknown
3294            timestamps have their first few packets buffered and the
3295            timestamps corrected before they are returned to the user */
3296     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3297     st->first_dts = AV_NOPTS_VALUE;
3298     st->probe_packets = MAX_PROBE_PACKETS;
3299     st->pts_wrap_reference = AV_NOPTS_VALUE;
3300     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3301
3302     /* default pts setting is MPEG-like */
3303     avpriv_set_pts_info(st, 33, 1, 90000);
3304     st->last_IP_pts = AV_NOPTS_VALUE;
3305     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3306         st->pts_buffer[i]= AV_NOPTS_VALUE;
3307     st->reference_dts = AV_NOPTS_VALUE;
3308
3309     st->sample_aspect_ratio = (AVRational){0,1};
3310
3311 #if FF_API_R_FRAME_RATE
3312     st->info->last_dts      = AV_NOPTS_VALUE;
3313 #endif
3314     st->info->fps_first_dts = AV_NOPTS_VALUE;
3315     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3316
3317     s->streams[s->nb_streams++] = st;
3318     return st;
3319 }
3320
3321 AVProgram *av_new_program(AVFormatContext *ac, int id)
3322 {
3323     AVProgram *program=NULL;
3324     int i;
3325
3326     av_dlog(ac, "new_program: id=0x%04x\n", id);
3327
3328     for(i=0; i<ac->nb_programs; i++)
3329         if(ac->programs[i]->id == id)
3330             program = ac->programs[i];
3331
3332     if(!program){
3333         program = av_mallocz(sizeof(AVProgram));
3334         if (!program)
3335             return NULL;
3336         dynarray_add(&ac->programs, &ac->nb_programs, program);
3337         program->discard = AVDISCARD_NONE;
3338     }
3339     program->id = id;
3340     program->pts_wrap_reference = AV_NOPTS_VALUE;
3341     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3342
3343     program->start_time =
3344     program->end_time   = AV_NOPTS_VALUE;
3345
3346     return program;
3347 }
3348
3349 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3350 {
3351     AVChapter *chapter = NULL;
3352     int i;
3353
3354     for(i=0; i<s->nb_chapters; i++)
3355         if(s->chapters[i]->id == id)
3356             chapter = s->chapters[i];
3357
3358     if(!chapter){
3359         chapter= av_mallocz(sizeof(AVChapter));
3360         if(!chapter)
3361             return NULL;
3362         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3363     }
3364     av_dict_set(&chapter->metadata, "title", title, 0);
3365     chapter->id    = id;
3366     chapter->time_base= time_base;
3367     chapter->start = start;
3368     chapter->end   = end;
3369
3370     return chapter;
3371 }
3372
3373 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3374 {
3375     int i, j;
3376     AVProgram *program=NULL;
3377     void *tmp;
3378
3379     if (idx >= ac->nb_streams) {
3380         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3381         return;
3382     }
3383
3384     for(i=0; i<ac->nb_programs; i++){
3385         if(ac->programs[i]->id != progid)
3386             continue;
3387         program = ac->programs[i];
3388         for(j=0; j<program->nb_stream_indexes; j++)
3389             if(program->stream_index[j] == idx)
3390                 return;
3391
3392         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3393         if(!tmp)
3394             return;
3395         program->stream_index = tmp;
3396         program->stream_index[program->nb_stream_indexes++] = idx;
3397         return;
3398     }
3399 }
3400
3401 static void print_fps(double d, const char *postfix){
3402     uint64_t v= lrintf(d*100);
3403     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3404     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3405     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3406 }
3407
3408 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3409 {
3410     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3411         AVDictionaryEntry *tag=NULL;
3412
3413         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3414         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3415             if(strcmp("language", tag->key)){
3416                 const char *p = tag->value;
3417                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3418                 while(*p) {
3419                     char tmp[256];
3420                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3421                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3422                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3423                     p += len;
3424                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3425                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3426                     if (*p) p++;
3427                 }
3428                 av_log(ctx, AV_LOG_INFO, "\n");
3429             }
3430         }
3431     }
3432 }
3433
3434 /* "user interface" functions */
3435 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3436 {
3437     char buf[256];
3438     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3439     AVStream *st = ic->streams[i];
3440     int g = av_gcd(st->time_base.num, st->time_base.den);
3441     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3442     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3443     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3444     /* the pid is an important information, so we display it */
3445     /* XXX: add a generic system */
3446     if (flags & AVFMT_SHOW_IDS)
3447         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3448     if (lang)
3449         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3450     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3451     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3452     if (st->sample_aspect_ratio.num && // default
3453         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3454         AVRational display_aspect_ratio;
3455         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3456                   st->codec->width*st->sample_aspect_ratio.num,
3457                   st->codec->height*st->sample_aspect_ratio.den,
3458                   1024*1024);
3459         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3460                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3461                  display_aspect_ratio.num, display_aspect_ratio.den);
3462     }
3463     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3464         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3465             print_fps(av_q2d(st->avg_frame_rate), "fps");
3466 #if FF_API_R_FRAME_RATE
3467         if(st->r_frame_rate.den && st->r_frame_rate.num)
3468             print_fps(av_q2d(st->r_frame_rate), "tbr");
3469 #endif
3470         if(st->time_base.den && st->time_base.num)
3471             print_fps(1/av_q2d(st->time_base), "tbn");
3472         if(st->codec->time_base.den && st->codec->time_base.num)
3473             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3474     }
3475     if (st->disposition & AV_DISPOSITION_DEFAULT)
3476         av_log(NULL, AV_LOG_INFO, " (default)");
3477     if (st->disposition & AV_DISPOSITION_DUB)
3478         av_log(NULL, AV_LOG_INFO, " (dub)");
3479     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3480         av_log(NULL, AV_LOG_INFO, " (original)");
3481     if (st->disposition & AV_DISPOSITION_COMMENT)
3482         av_log(NULL, AV_LOG_INFO, " (comment)");
3483     if (st->disposition & AV_DISPOSITION_LYRICS)
3484         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3485     if (st->disposition & AV_DISPOSITION_KARAOKE)
3486         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3487     if (st->disposition & AV_DISPOSITION_FORCED)
3488         av_log(NULL, AV_LOG_INFO, " (forced)");
3489     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3490         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3491     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3492         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3493     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3494         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3495     av_log(NULL, AV_LOG_INFO, "\n");
3496     dump_metadata(NULL, st->metadata, "    ");
3497 }
3498
3499 void av_dump_format(AVFormatContext *ic,
3500                     int index,
3501                     const char *url,
3502                     int is_output)
3503 {
3504     int i;
3505     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3506     if (ic->nb_streams && !printed)
3507         return;
3508
3509     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3510             is_output ? "Output" : "Input",
3511             index,
3512             is_output ? ic->oformat->name : ic->iformat->name,
3513             is_output ? "to" : "from", url);
3514     dump_metadata(NULL, ic->metadata, "  ");
3515     if (!is_output) {
3516         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3517         if (ic->duration != AV_NOPTS_VALUE) {
3518             int hours, mins, secs, us;
3519             int64_t duration = ic->duration + 5000;
3520             secs = duration / AV_TIME_BASE;
3521             us = duration % AV_TIME_BASE;
3522             mins = secs / 60;
3523             secs %= 60;
3524             hours = mins / 60;
3525             mins %= 60;
3526             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3527                    (100 * us) / AV_TIME_BASE);
3528         } else {
3529             av_log(NULL, AV_LOG_INFO, "N/A");
3530         }
3531         if (ic->start_time != AV_NOPTS_VALUE) {
3532             int secs, us;
3533             av_log(NULL, AV_LOG_INFO, ", start: ");
3534             secs = ic->start_time / AV_TIME_BASE;
3535             us = abs(ic->start_time % AV_TIME_BASE);
3536             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3537                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3538         }
3539         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3540         if (ic->bit_rate) {
3541             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3542         } else {
3543             av_log(NULL, AV_LOG_INFO, "N/A");
3544         }
3545         av_log(NULL, AV_LOG_INFO, "\n");
3546     }
3547     for (i = 0; i < ic->nb_chapters; i++) {
3548         AVChapter *ch = ic->chapters[i];
3549         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3550         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3551         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3552
3553         dump_metadata(NULL, ch->metadata, "    ");
3554     }
3555     if(ic->nb_programs) {
3556         int j, k, total = 0;
3557         for(j=0; j<ic->nb_programs; j++) {
3558             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3559                                                   "name", NULL, 0);
3560             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3561                    name ? name->value : "");
3562             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3563             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3564                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3565                 printed[ic->programs[j]->stream_index[k]] = 1;
3566             }
3567             total += ic->programs[j]->nb_stream_indexes;
3568         }
3569         if (total < ic->nb_streams)
3570             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3571     }
3572     for(i=0;i<ic->nb_streams;i++)
3573         if (!printed[i])
3574             dump_stream_format(ic, i, index, is_output);
3575
3576     av_free(printed);
3577 }
3578
3579 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3580 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3581 {
3582     return av_gettime();
3583 }
3584 #endif
3585
3586 uint64_t ff_ntp_time(void)
3587 {
3588   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3589 }
3590
3591 int av_get_frame_filename(char *buf, int buf_size,
3592                           const char *path, int number)
3593 {
3594     const char *p;
3595     char *q, buf1[20], c;
3596     int nd, len, percentd_found;
3597
3598     q = buf;
3599     p = path;
3600     percentd_found = 0;
3601     for(;;) {
3602         c = *p++;
3603         if (c == '\0')
3604             break;
3605         if (c == '%') {
3606             do {
3607                 nd = 0;
3608                 while (isdigit(*p)) {
3609                     nd = nd * 10 + *p++ - '0';
3610                 }
3611                 c = *p++;
3612             } while (isdigit(c));
3613
3614             switch(c) {
3615             case '%':
3616                 goto addchar;
3617             case 'd':
3618                 if (percentd_found)
3619                     goto fail;
3620                 percentd_found = 1;
3621                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3622                 len = strlen(buf1);
3623                 if ((q - buf + len) > buf_size - 1)
3624                     goto fail;
3625                 memcpy(q, buf1, len);
3626                 q += len;
3627                 break;
3628             default:
3629                 goto fail;
3630             }
3631         } else {
3632         addchar:
3633             if ((q - buf) < buf_size - 1)
3634                 *q++ = c;
3635         }
3636     }
3637     if (!percentd_found)
3638         goto fail;
3639     *q = '\0';
3640     return 0;
3641  fail:
3642     *q = '\0';
3643     return -1;
3644 }
3645
3646 static void hex_dump_internal(void *avcl, FILE *f, int level,
3647                               const uint8_t *buf, int size)
3648 {
3649     int len, i, j, c;
3650 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3651
3652     for(i=0;i<size;i+=16) {
3653         len = size - i;
3654         if (len > 16)
3655             len = 16;
3656         PRINT("%08x ", i);
3657         for(j=0;j<16;j++) {
3658             if (j < len)
3659                 PRINT(" %02x", buf[i+j]);
3660             else
3661                 PRINT("   ");
3662         }
3663         PRINT(" ");
3664         for(j=0;j<len;j++) {
3665             c = buf[i+j];
3666             if (c < ' ' || c > '~')
3667                 c = '.';
3668             PRINT("%c", c);
3669         }
3670         PRINT("\n");
3671     }
3672 #undef PRINT
3673 }
3674
3675 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3676 {
3677     hex_dump_internal(NULL, f, 0, buf, size);
3678 }
3679
3680 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3681 {
3682     hex_dump_internal(avcl, NULL, level, buf, size);
3683 }
3684
3685 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3686 {
3687 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3688     PRINT("stream #%d:\n", pkt->stream_index);
3689     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3690     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3691     /* DTS is _always_ valid after av_read_frame() */
3692     PRINT("  dts=");
3693     if (pkt->dts == AV_NOPTS_VALUE)
3694         PRINT("N/A");
3695     else
3696         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3697     /* PTS may not be known if B-frames are present. */
3698     PRINT("  pts=");
3699     if (pkt->pts == AV_NOPTS_VALUE)
3700         PRINT("N/A");
3701     else
3702         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3703     PRINT("\n");
3704     PRINT("  size=%d\n", pkt->size);
3705 #undef PRINT
3706     if (dump_payload)
3707         av_hex_dump(f, pkt->data, pkt->size);
3708 }
3709
3710 #if FF_API_PKT_DUMP
3711 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3712 {
3713     AVRational tb = { 1, AV_TIME_BASE };
3714     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3715 }
3716 #endif
3717
3718 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3719 {
3720     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3721 }
3722
3723 #if FF_API_PKT_DUMP
3724 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3725 {
3726     AVRational tb = { 1, AV_TIME_BASE };
3727     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3728 }
3729 #endif
3730
3731 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3732                       AVStream *st)
3733 {
3734     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3735 }
3736
3737 void av_url_split(char *proto, int proto_size,
3738                   char *authorization, int authorization_size,
3739                   char *hostname, int hostname_size,
3740                   int *port_ptr,
3741                   char *path, int path_size,
3742                   const char *url)
3743 {
3744     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3745
3746     if (port_ptr)               *port_ptr = -1;
3747     if (proto_size > 0)         proto[0] = 0;
3748     if (authorization_size > 0) authorization[0] = 0;
3749     if (hostname_size > 0)      hostname[0] = 0;
3750     if (path_size > 0)          path[0] = 0;
3751
3752     /* parse protocol */
3753     if ((p = strchr(url, ':'))) {
3754         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3755         p++; /* skip ':' */
3756         if (*p == '/') p++;
3757         if (*p == '/') p++;
3758     } else {
3759         /* no protocol means plain filename */
3760         av_strlcpy(path, url, path_size);
3761         return;
3762     }
3763
3764     /* separate path from hostname */
3765     ls = strchr(p, '/');
3766     ls2 = strchr(p, '?');
3767     if(!ls)
3768         ls = ls2;
3769     else if (ls && ls2)
3770         ls = FFMIN(ls, ls2);
3771     if(ls)
3772         av_strlcpy(path, ls, path_size);
3773     else
3774         ls = &p[strlen(p)]; // XXX
3775
3776     /* the rest is hostname, use that to parse auth/port */
3777     if (ls != p) {
3778         /* authorization (user[:pass]@hostname) */
3779         at2 = p;
3780         while ((at = strchr(p, '@')) && at < ls) {
3781             av_strlcpy(authorization, at2,
3782                        FFMIN(authorization_size, at + 1 - at2));
3783             p = at + 1; /* skip '@' */
3784         }
3785
3786         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3787             /* [host]:port */
3788             av_strlcpy(hostname, p + 1,
3789                        FFMIN(hostname_size, brk - p));
3790             if (brk[1] == ':' && port_ptr)
3791                 *port_ptr = atoi(brk + 2);
3792         } else if ((col = strchr(p, ':')) && col < ls) {
3793             av_strlcpy(hostname, p,
3794                        FFMIN(col + 1 - p, hostname_size));
3795             if (port_ptr) *port_ptr = atoi(col + 1);
3796         } else
3797             av_strlcpy(hostname, p,
3798                        FFMIN(ls + 1 - p, hostname_size));
3799     }
3800 }
3801
3802 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3803 {
3804     int i;
3805     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3806                                            '4', '5', '6', '7',
3807                                            '8', '9', 'A', 'B',
3808                                            'C', 'D', 'E', 'F' };
3809     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3810                                            '4', '5', '6', '7',
3811                                            '8', '9', 'a', 'b',
3812                                            'c', 'd', 'e', 'f' };
3813     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3814
3815     for(i = 0; i < s; i++) {
3816         buff[i * 2]     = hex_table[src[i] >> 4];
3817         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3818     }
3819
3820     return buff;
3821 }
3822
3823 int ff_hex_to_data(uint8_t *data, const char *p)
3824 {
3825     int c, len, v;
3826
3827     len = 0;
3828     v = 1;
3829     for (;;) {
3830         p += strspn(p, SPACE_CHARS);
3831         if (*p == '\0')
3832             break;
3833         c = toupper((unsigned char) *p++);
3834         if (c >= '0' && c <= '9')
3835             c = c - '0';
3836         else if (c >= 'A' && c <= 'F')
3837             c = c - 'A' + 10;
3838         else
3839             break;
3840         v = (v << 4) | c;
3841         if (v & 0x100) {
3842             if (data)
3843                 data[len] = v;
3844             len++;
3845             v = 1;
3846         }
3847     }
3848     return len;
3849 }
3850
3851 #if FF_API_SET_PTS_INFO
3852 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3853                      unsigned int pts_num, unsigned int pts_den)
3854 {
3855     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3856 }
3857 #endif
3858
3859 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3860                          unsigned int pts_num, unsigned int pts_den)
3861 {
3862     AVRational new_tb;
3863     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3864         if(new_tb.num != pts_num)
3865             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3866     }else
3867         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3868
3869     if(new_tb.num <= 0 || new_tb.den <= 0) {
3870         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);
3871         return;
3872     }
3873     s->time_base = new_tb;
3874     av_codec_set_pkt_timebase(s->codec, new_tb);
3875     s->pts_wrap_bits = pts_wrap_bits;
3876 }
3877
3878 int ff_url_join(char *str, int size, const char *proto,
3879                 const char *authorization, const char *hostname,
3880                 int port, const char *fmt, ...)
3881 {
3882 #if CONFIG_NETWORK
3883     struct addrinfo hints = { 0 }, *ai;
3884 #endif
3885
3886     str[0] = '\0';
3887     if (proto)
3888         av_strlcatf(str, size, "%s://", proto);
3889     if (authorization && authorization[0])
3890         av_strlcatf(str, size, "%s@", authorization);
3891 #if CONFIG_NETWORK && defined(AF_INET6)
3892     /* Determine if hostname is a numerical IPv6 address,
3893      * properly escape it within [] in that case. */
3894     hints.ai_flags = AI_NUMERICHOST;
3895     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3896         if (ai->ai_family == AF_INET6) {
3897             av_strlcat(str, "[", size);
3898             av_strlcat(str, hostname, size);
3899             av_strlcat(str, "]", size);
3900         } else {
3901             av_strlcat(str, hostname, size);
3902         }
3903         freeaddrinfo(ai);
3904     } else
3905 #endif
3906         /* Not an IPv6 address, just output the plain string. */
3907         av_strlcat(str, hostname, size);
3908
3909     if (port >= 0)
3910         av_strlcatf(str, size, ":%d", port);
3911     if (fmt) {
3912         va_list vl;
3913         int len = strlen(str);
3914
3915         va_start(vl, fmt);
3916         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3917         va_end(vl);
3918     }
3919     return strlen(str);
3920 }
3921
3922 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3923                      AVFormatContext *src)
3924 {
3925     AVPacket local_pkt;
3926
3927     local_pkt = *pkt;
3928     local_pkt.stream_index = dst_stream;
3929     if (pkt->pts != AV_NOPTS_VALUE)
3930         local_pkt.pts = av_rescale_q(pkt->pts,
3931                                      src->streams[pkt->stream_index]->time_base,
3932                                      dst->streams[dst_stream]->time_base);
3933     if (pkt->dts != AV_NOPTS_VALUE)
3934         local_pkt.dts = av_rescale_q(pkt->dts,
3935                                      src->streams[pkt->stream_index]->time_base,
3936                                      dst->streams[dst_stream]->time_base);
3937     return av_write_frame(dst, &local_pkt);
3938 }
3939
3940 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3941                         void *context)
3942 {
3943     const char *ptr = str;
3944
3945     /* Parse key=value pairs. */
3946     for (;;) {
3947         const char *key;
3948         char *dest = NULL, *dest_end;
3949         int key_len, dest_len = 0;
3950
3951         /* Skip whitespace and potential commas. */
3952         while (*ptr && (isspace(*ptr) || *ptr == ','))
3953             ptr++;
3954         if (!*ptr)
3955             break;
3956
3957         key = ptr;
3958
3959         if (!(ptr = strchr(key, '=')))
3960             break;
3961         ptr++;
3962         key_len = ptr - key;
3963
3964         callback_get_buf(context, key, key_len, &dest, &dest_len);
3965         dest_end = dest + dest_len - 1;
3966
3967         if (*ptr == '\"') {
3968             ptr++;
3969             while (*ptr && *ptr != '\"') {
3970                 if (*ptr == '\\') {
3971                     if (!ptr[1])
3972                         break;
3973                     if (dest && dest < dest_end)
3974                         *dest++ = ptr[1];
3975                     ptr += 2;
3976                 } else {
3977                     if (dest && dest < dest_end)
3978                         *dest++ = *ptr;
3979                     ptr++;
3980                 }
3981             }
3982             if (*ptr == '\"')
3983                 ptr++;
3984         } else {
3985             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3986                 if (dest && dest < dest_end)
3987                     *dest++ = *ptr;
3988         }
3989         if (dest)
3990             *dest = 0;
3991     }
3992 }
3993
3994 int ff_find_stream_index(AVFormatContext *s, int id)
3995 {
3996     int i;
3997     for (i = 0; i < s->nb_streams; i++) {
3998         if (s->streams[i]->id == id)
3999             return i;
4000     }
4001     return -1;
4002 }
4003
4004 void ff_make_absolute_url(char *buf, int size, const char *base,
4005                           const char *rel)
4006 {
4007     char *sep, *path_query;
4008     /* Absolute path, relative to the current server */
4009     if (base && strstr(base, "://") && rel[0] == '/') {
4010         if (base != buf)
4011             av_strlcpy(buf, base, size);
4012         sep = strstr(buf, "://");
4013         if (sep) {
4014             /* Take scheme from base url */
4015             if (rel[1] == '/') {
4016                 sep[1] = '\0';
4017             } else {
4018                 /* Take scheme and host from base url */
4019                 sep += 3;
4020                 sep = strchr(sep, '/');
4021                 if (sep)
4022                     *sep = '\0';
4023             }
4024         }
4025         av_strlcat(buf, rel, size);
4026         return;
4027     }
4028     /* If rel actually is an absolute url, just copy it */
4029     if (!base || strstr(rel, "://") || rel[0] == '/') {
4030         av_strlcpy(buf, rel, size);
4031         return;
4032     }
4033     if (base != buf)
4034         av_strlcpy(buf, base, size);
4035
4036     /* Strip off any query string from base */
4037     path_query = strchr(buf, '?');
4038     if (path_query != NULL)
4039         *path_query = '\0';
4040
4041     /* Is relative path just a new query part? */
4042     if (rel[0] == '?') {
4043         av_strlcat(buf, rel, size);
4044         return;
4045     }
4046
4047     /* Remove the file name from the base url */
4048     sep = strrchr(buf, '/');
4049     if (sep)
4050         sep[1] = '\0';
4051     else
4052         buf[0] = '\0';
4053     while (av_strstart(rel, "../", NULL) && sep) {
4054         /* Remove the path delimiter at the end */
4055         sep[0] = '\0';
4056         sep = strrchr(buf, '/');
4057         /* If the next directory name to pop off is "..", break here */
4058         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4059             /* Readd the slash we just removed */
4060             av_strlcat(buf, "/", size);
4061             break;
4062         }
4063         /* Cut off the directory name */
4064         if (sep)
4065             sep[1] = '\0';
4066         else
4067             buf[0] = '\0';
4068         rel += 3;
4069     }
4070     av_strlcat(buf, rel, size);
4071 }
4072
4073 int64_t ff_iso8601_to_unix_time(const char *datestr)
4074 {
4075     struct tm time1 = {0}, time2 = {0};
4076     char *ret1, *ret2;
4077     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4078     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4079     if (ret2 && !ret1)
4080         return av_timegm(&time2);
4081     else
4082         return av_timegm(&time1);
4083 }
4084
4085 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4086 {
4087     if (ofmt) {
4088         if (ofmt->query_codec)
4089             return ofmt->query_codec(codec_id, std_compliance);
4090         else if (ofmt->codec_tag)
4091             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4092         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4093                  codec_id == ofmt->subtitle_codec)
4094             return 1;
4095     }
4096     return AVERROR_PATCHWELCOME;
4097 }
4098
4099 int avformat_network_init(void)
4100 {
4101 #if CONFIG_NETWORK
4102     int ret;
4103     ff_network_inited_globally = 1;
4104     if ((ret = ff_network_init()) < 0)
4105         return ret;
4106     ff_tls_init();
4107 #endif
4108     return 0;
4109 }
4110
4111 int avformat_network_deinit(void)
4112 {
4113 #if CONFIG_NETWORK
4114     ff_network_close();
4115     ff_tls_deinit();
4116 #endif
4117     return 0;
4118 }
4119
4120 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4121                         uint64_t channel_layout, int32_t sample_rate,
4122                         int32_t width, int32_t height)
4123 {
4124     uint32_t flags = 0;
4125     int size = 4;
4126     uint8_t *data;
4127     if (!pkt)
4128         return AVERROR(EINVAL);
4129     if (channels) {
4130         size += 4;
4131         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4132     }
4133     if (channel_layout) {
4134         size += 8;
4135         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4136     }
4137     if (sample_rate) {
4138         size += 4;
4139         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4140     }
4141     if (width || height) {
4142         size += 8;
4143         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4144     }
4145     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4146     if (!data)
4147         return AVERROR(ENOMEM);
4148     bytestream_put_le32(&data, flags);
4149     if (channels)
4150         bytestream_put_le32(&data, channels);
4151     if (channel_layout)
4152         bytestream_put_le64(&data, channel_layout);
4153     if (sample_rate)
4154         bytestream_put_le32(&data, sample_rate);
4155     if (width || height) {
4156         bytestream_put_le32(&data, width);
4157         bytestream_put_le32(&data, height);
4158     }
4159     return 0;
4160 }
4161
4162 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4163 {
4164     return ff_codec_bmp_tags;
4165 }
4166 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4167 {
4168     return ff_codec_wav_tags;
4169 }
4170
4171 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4172 {
4173     AVRational undef = {0, 1};
4174     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4175     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4176     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4177
4178     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4179                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4180     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4181         stream_sample_aspect_ratio = undef;
4182
4183     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4184                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4185     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4186         frame_sample_aspect_ratio = undef;
4187
4188     if (stream_sample_aspect_ratio.num)
4189         return stream_sample_aspect_ratio;
4190     else
4191         return frame_sample_aspect_ratio;
4192 }
4193
4194 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4195                                     const char *spec)
4196 {
4197     if (*spec <= '9' && *spec >= '0') /* opt:index */
4198         return strtol(spec, NULL, 0) == st->index;
4199     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4200              *spec == 't') { /* opt:[vasdt] */
4201         enum AVMediaType type;
4202
4203         switch (*spec++) {
4204         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4205         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4206         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4207         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4208         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4209         default:  av_assert0(0);
4210         }
4211         if (type != st->codec->codec_type)
4212             return 0;
4213         if (*spec++ == ':') { /* possibly followed by :index */
4214             int i, index = strtol(spec, NULL, 0);
4215             for (i = 0; i < s->nb_streams; i++)
4216                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4217                    return i == st->index;
4218             return 0;
4219         }
4220         return 1;
4221     } else if (*spec == 'p' && *(spec + 1) == ':') {
4222         int prog_id, i, j;
4223         char *endptr;
4224         spec += 2;
4225         prog_id = strtol(spec, &endptr, 0);
4226         for (i = 0; i < s->nb_programs; i++) {
4227             if (s->programs[i]->id != prog_id)
4228                 continue;
4229
4230             if (*endptr++ == ':') {
4231                 int stream_idx = strtol(endptr, NULL, 0);
4232                 return stream_idx >= 0 &&
4233                     stream_idx < s->programs[i]->nb_stream_indexes &&
4234                     st->index == s->programs[i]->stream_index[stream_idx];
4235             }
4236
4237             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4238                 if (st->index == s->programs[i]->stream_index[j])
4239                     return 1;
4240         }
4241         return 0;
4242     } else if (*spec == '#') {
4243         int sid;
4244         char *endptr;
4245         sid = strtol(spec + 1, &endptr, 0);
4246         if (!*endptr)
4247             return st->id == sid;
4248     } else if (!*spec) /* empty specifier, matches everything */
4249         return 1;
4250
4251     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4252     return AVERROR(EINVAL);
4253 }
4254
4255 void ff_generate_avci_extradata(AVStream *st)
4256 {
4257     static const uint8_t avci100_1080p_extradata[] = {
4258         // SPS
4259         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4260         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4261         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4262         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4263         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4264         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4265         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4266         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4267         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4268         // PPS
4269         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4270         0xd0
4271     };
4272     static const uint8_t avci100_1080i_extradata[] = {
4273         // SPS
4274         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4275         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4276         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4277         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4278         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4279         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4280         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4281         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4282         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4283         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4284         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4285         // PPS
4286         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4287         0xd0
4288     };
4289     static const uint8_t avci50_1080i_extradata[] = {
4290         // SPS
4291         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4292         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4293         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4294         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4295         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4296         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4297         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4298         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4299         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4300         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4301         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4302         // PPS
4303         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4304         0x11
4305     };
4306     static const uint8_t avci100_720p_extradata[] = {
4307         // SPS
4308         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4309         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4310         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4311         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4312         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4313         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4314         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4315         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4316         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4317         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4318         // PPS
4319         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4320         0x11
4321     };
4322     int size = 0;
4323     const uint8_t *data = 0;
4324     if (st->codec->width == 1920) {
4325         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4326             data = avci100_1080p_extradata;
4327             size = sizeof(avci100_1080p_extradata);
4328         } else {
4329             data = avci100_1080i_extradata;
4330             size = sizeof(avci100_1080i_extradata);
4331         }
4332     } else if (st->codec->width == 1440) {
4333         data = avci50_1080i_extradata;
4334         size = sizeof(avci50_1080i_extradata);
4335     } else if (st->codec->width == 1280) {
4336         data = avci100_720p_extradata;
4337         size = sizeof(avci100_720p_extradata);
4338     }
4339     if (!size)
4340         return;
4341     av_freep(&st->codec->extradata);
4342     st->codec->extradata_size = 0;
4343     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4344     if (!st->codec->extradata)
4345         return;
4346     memcpy(st->codec->extradata, data, size);
4347     st->codec->extradata_size = size;
4348 }