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