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

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