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