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