git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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