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