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