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