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