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