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