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

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