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