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 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2578 {
2579     int i, j;
2580
2581     for (i = 0; i < ic->nb_programs; i++) {
2582         if (ic->programs[i] == last) {
2583             last = NULL;
2584         } else {
2585             if (!last)
2586                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2587                     if (ic->programs[i]->stream_index[j] == s)
2588                         return ic->programs[i];
2589         }
2590     }
2591     return NULL;
2592 }
2593
2594 int av_find_best_stream(AVFormatContext *ic,
2595                         enum AVMediaType type,
2596                         int wanted_stream_nb,
2597                         int related_stream,
2598                         AVCodec **decoder_ret,
2599                         int flags)
2600 {
2601     int i, nb_streams = ic->nb_streams;
2602     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2603     unsigned *program = NULL;
2604     AVCodec *decoder = NULL, *best_decoder = NULL;
2605
2606     if (related_stream >= 0 && wanted_stream_nb < 0) {
2607         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2608         if (p) {
2609             program = p->stream_index;
2610             nb_streams = p->nb_stream_indexes;
2611         }
2612     }
2613     for (i = 0; i < nb_streams; i++) {
2614         int real_stream_index = program ? program[i] : i;
2615         AVStream *st = ic->streams[real_stream_index];
2616         AVCodecContext *avctx = st->codec;
2617         if (avctx->codec_type != type)
2618             continue;
2619         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2620             continue;
2621         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2622             continue;
2623         if (decoder_ret) {
2624             decoder = avcodec_find_decoder(st->codec->codec_id);
2625             if (!decoder) {
2626                 if (ret < 0)
2627                     ret = AVERROR_DECODER_NOT_FOUND;
2628                 continue;
2629             }
2630         }
2631         if (best_count >= st->codec_info_nb_frames)
2632             continue;
2633         best_count = st->codec_info_nb_frames;
2634         ret = real_stream_index;
2635         best_decoder = decoder;
2636         if (program && i == nb_streams - 1 && ret < 0) {
2637             program = NULL;
2638             nb_streams = ic->nb_streams;
2639             i = 0; /* no related stream found, try again with everything */
2640         }
2641     }
2642     if (decoder_ret)
2643         *decoder_ret = best_decoder;
2644     return ret;
2645 }
2646
2647 /*******************************************************/
2648
2649 int av_read_play(AVFormatContext *s)
2650 {
2651     if (s->iformat->read_play)
2652         return s->iformat->read_play(s);
2653     if (s->pb)
2654         return avio_pause(s->pb, 0);
2655     return AVERROR(ENOSYS);
2656 }
2657
2658 int av_read_pause(AVFormatContext *s)
2659 {
2660     if (s->iformat->read_pause)
2661         return s->iformat->read_pause(s);
2662     if (s->pb)
2663         return avio_pause(s->pb, 1);
2664     return AVERROR(ENOSYS);
2665 }
2666
2667 void av_close_input_stream(AVFormatContext *s)
2668 {
2669     flush_packet_queue(s);
2670     if (s->iformat->read_close)
2671         s->iformat->read_close(s);
2672     avformat_free_context(s);
2673 }
2674
2675 void avformat_free_context(AVFormatContext *s)
2676 {
2677     int i;
2678     AVStream *st;
2679
2680     av_opt_free(s);
2681     if (s->iformat && s->iformat->priv_class && s->priv_data)
2682         av_opt_free(s->priv_data);
2683
2684     for(i=0;i<s->nb_streams;i++) {
2685         /* free all data in a stream component */
2686         st = s->streams[i];
2687         if (st->parser) {
2688             av_parser_close(st->parser);
2689             av_free_packet(&st->cur_pkt);
2690         }
2691         av_dict_free(&st->metadata);
2692         av_free(st->index_entries);
2693         av_free(st->codec->extradata);
2694         av_free(st->codec->subtitle_header);
2695         av_free(st->codec);
2696         av_free(st->priv_data);
2697         av_free(st->info);
2698         av_free(st);
2699     }
2700     for(i=s->nb_programs-1; i>=0; i--) {
2701         av_dict_free(&s->programs[i]->metadata);
2702         av_freep(&s->programs[i]->stream_index);
2703         av_freep(&s->programs[i]);
2704     }
2705     av_freep(&s->programs);
2706     av_freep(&s->priv_data);
2707     while(s->nb_chapters--) {
2708         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2709         av_free(s->chapters[s->nb_chapters]);
2710     }
2711     av_freep(&s->chapters);
2712     av_dict_free(&s->metadata);
2713     av_freep(&s->streams);
2714     av_free(s);
2715 }
2716
2717 void av_close_input_file(AVFormatContext *s)
2718 {
2719     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2720                        NULL : s->pb;
2721     av_close_input_stream(s);
2722     if (pb)
2723         avio_close(pb);
2724 }
2725
2726 AVStream *av_new_stream(AVFormatContext *s, int id)
2727 {
2728     AVStream *st;
2729     int i;
2730     AVStream **streams;
2731
2732     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2733         return NULL;
2734     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2735     if (!streams)
2736         return NULL;
2737     s->streams = streams;
2738
2739     st = av_mallocz(sizeof(AVStream));
2740     if (!st)
2741         return NULL;
2742     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2743         av_free(st);
2744         return NULL;
2745     }
2746
2747     st->codec = avcodec_alloc_context3(NULL);
2748     if (s->iformat) {
2749         /* no default bitrate if decoding */
2750         st->codec->bit_rate = 0;
2751     }
2752     st->index = s->nb_streams;
2753     st->id = id;
2754     st->start_time = AV_NOPTS_VALUE;
2755     st->duration = AV_NOPTS_VALUE;
2756         /* we set the current DTS to 0 so that formats without any timestamps
2757            but durations get some timestamps, formats with some unknown
2758            timestamps have their first few packets buffered and the
2759            timestamps corrected before they are returned to the user */
2760     st->cur_dts = 0;
2761     st->first_dts = AV_NOPTS_VALUE;
2762     st->probe_packets = MAX_PROBE_PACKETS;
2763
2764     /* default pts setting is MPEG-like */
2765     av_set_pts_info(st, 33, 1, 90000);
2766     st->last_IP_pts = AV_NOPTS_VALUE;
2767     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2768         st->pts_buffer[i]= AV_NOPTS_VALUE;
2769     st->reference_dts = AV_NOPTS_VALUE;
2770
2771     st->sample_aspect_ratio = (AVRational){0,1};
2772
2773     s->streams[s->nb_streams++] = st;
2774     return st;
2775 }
2776
2777 AVProgram *av_new_program(AVFormatContext *ac, int id)
2778 {
2779     AVProgram *program=NULL;
2780     int i;
2781
2782     av_dlog(ac, "new_program: id=0x%04x\n", id);
2783
2784     for(i=0; i<ac->nb_programs; i++)
2785         if(ac->programs[i]->id == id)
2786             program = ac->programs[i];
2787
2788     if(!program){
2789         program = av_mallocz(sizeof(AVProgram));
2790         if (!program)
2791             return NULL;
2792         dynarray_add(&ac->programs, &ac->nb_programs, program);
2793         program->discard = AVDISCARD_NONE;
2794     }
2795     program->id = id;
2796
2797     return program;
2798 }
2799
2800 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2801 {
2802     AVChapter *chapter = NULL;
2803     int i;
2804
2805     for(i=0; i<s->nb_chapters; i++)
2806         if(s->chapters[i]->id == id)
2807             chapter = s->chapters[i];
2808
2809     if(!chapter){
2810         chapter= av_mallocz(sizeof(AVChapter));
2811         if(!chapter)
2812             return NULL;
2813         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2814     }
2815     av_dict_set(&chapter->metadata, "title", title, 0);
2816     chapter->id    = id;
2817     chapter->time_base= time_base;
2818     chapter->start = start;
2819     chapter->end   = end;
2820
2821     return chapter;
2822 }
2823
2824 /************************************************************/
2825 /* output media file */
2826
2827 #if FF_API_FORMAT_PARAMETERS
2828 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2829 {
2830     if (s->oformat->priv_data_size > 0) {
2831         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2832         if (!s->priv_data)
2833             return AVERROR(ENOMEM);
2834         if (s->oformat->priv_class) {
2835             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2836             av_opt_set_defaults(s->priv_data);
2837         }
2838     } else
2839         s->priv_data = NULL;
2840
2841     return 0;
2842 }
2843 #endif
2844
2845 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2846                                    const char *format, const char *filename)
2847 {
2848     AVFormatContext *s = avformat_alloc_context();
2849     int ret = 0;
2850
2851     *avctx = NULL;
2852     if (!s)
2853         goto nomem;
2854
2855     if (!oformat) {
2856         if (format) {
2857             oformat = av_guess_format(format, NULL, NULL);
2858             if (!oformat) {
2859                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2860                 ret = AVERROR(EINVAL);
2861                 goto error;
2862             }
2863         } else {
2864             oformat = av_guess_format(NULL, filename, NULL);
2865             if (!oformat) {
2866                 ret = AVERROR(EINVAL);
2867                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2868                        filename);
2869                 goto error;
2870             }
2871         }
2872     }
2873
2874     s->oformat = oformat;
2875     if (s->oformat->priv_data_size > 0) {
2876         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2877         if (!s->priv_data)
2878             goto nomem;
2879         if (s->oformat->priv_class) {
2880             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2881             av_opt_set_defaults(s->priv_data);
2882         }
2883     } else
2884         s->priv_data = NULL;
2885
2886     if (filename)
2887         av_strlcpy(s->filename, filename, sizeof(s->filename));
2888     *avctx = s;
2889     return 0;
2890 nomem:
2891     av_log(s, AV_LOG_ERROR, "Out of memory\n");
2892     ret = AVERROR(ENOMEM);
2893 error:
2894     avformat_free_context(s);
2895     return ret;
2896 }
2897
2898 #if FF_API_ALLOC_OUTPUT_CONTEXT
2899 AVFormatContext *avformat_alloc_output_context(const char *format,
2900                                                AVOutputFormat *oformat, const char *filename)
2901 {
2902     AVFormatContext *avctx;
2903     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2904     return ret < 0 ? NULL : avctx;
2905 }
2906 #endif
2907
2908 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2909 {
2910     const AVCodecTag *avctag;
2911     int n;
2912     enum CodecID id = CODEC_ID_NONE;
2913     unsigned int tag = 0;
2914
2915     /**
2916      * Check that tag + id is in the table
2917      * If neither is in the table -> OK
2918      * If tag is in the table with another id -> FAIL
2919      * If id is in the table with another tag -> FAIL unless strict < normal
2920      */
2921     for (n = 0; s->oformat->codec_tag[n]; n++) {
2922         avctag = s->oformat->codec_tag[n];
2923         while (avctag->id != CODEC_ID_NONE) {
2924             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2925                 id = avctag->id;
2926                 if (id == st->codec->codec_id)
2927                     return 1;
2928             }
2929             if (avctag->id == st->codec->codec_id)
2930                 tag = avctag->tag;
2931             avctag++;
2932         }
2933     }
2934     if (id != CODEC_ID_NONE)
2935         return 0;
2936     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2937         return 0;
2938     return 1;
2939 }
2940
2941 #if FF_API_FORMAT_PARAMETERS
2942 int av_write_header(AVFormatContext *s)
2943 {
2944     return avformat_write_header(s, NULL);
2945 }
2946 #endif
2947
2948 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2949 {
2950     int ret = 0, i;
2951     AVStream *st;
2952     AVDictionary *tmp = NULL;
2953
2954     if (options)
2955         av_dict_copy(&tmp, *options, 0);
2956     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2957         goto fail;
2958     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2959         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2960         goto fail;
2961
2962     // some sanity checks
2963     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2964         av_log(s, AV_LOG_ERROR, "no streams\n");
2965         ret = AVERROR(EINVAL);
2966         goto fail;
2967     }
2968
2969     for(i=0;i<s->nb_streams;i++) {
2970         st = s->streams[i];
2971
2972         switch (st->codec->codec_type) {
2973         case AVMEDIA_TYPE_AUDIO:
2974             if(st->codec->sample_rate<=0){
2975                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2976                 ret = AVERROR(EINVAL);
2977                 goto fail;
2978             }
2979             if(!st->codec->block_align)
2980                 st->codec->block_align = st->codec->channels *
2981                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2982             break;
2983         case AVMEDIA_TYPE_VIDEO:
2984             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2985                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2986                 ret = AVERROR(EINVAL);
2987                 goto fail;
2988             }
2989             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2990                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2991                 ret = AVERROR(EINVAL);
2992                 goto fail;
2993             }
2994             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2995                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2996                 ret = AVERROR(EINVAL);
2997                 goto fail;
2998             }
2999             break;
3000         }
3001
3002         if(s->oformat->codec_tag){
3003             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)){
3004                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3005                 st->codec->codec_tag= 0;
3006             }
3007             if(st->codec->codec_tag){
3008                 if (!validate_codec_tag(s, st)) {
3009                     char tagbuf[32];
3010                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3011                     av_log(s, AV_LOG_ERROR,
3012                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3013                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
3014                     ret = AVERROR_INVALIDDATA;
3015                     goto fail;
3016                 }
3017             }else
3018                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3019         }
3020
3021         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3022             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3023           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3024     }
3025
3026     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3027         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3028         if (!s->priv_data) {
3029             ret = AVERROR(ENOMEM);
3030             goto fail;
3031         }
3032         if (s->oformat->priv_class) {
3033             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3034             av_opt_set_defaults(s->priv_data);
3035             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3036                 goto fail;
3037         }
3038     }
3039
3040     /* set muxer identification string */
3041     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3042         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3043     }
3044
3045     if(s->oformat->write_header){
3046         ret = s->oformat->write_header(s);
3047         if (ret < 0)
3048             goto fail;
3049     }
3050
3051     /* init PTS generation */
3052     for(i=0;i<s->nb_streams;i++) {
3053         int64_t den = AV_NOPTS_VALUE;
3054         st = s->streams[i];
3055
3056         switch (st->codec->codec_type) {
3057         case AVMEDIA_TYPE_AUDIO:
3058             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3059             break;
3060         case AVMEDIA_TYPE_VIDEO:
3061             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3062             break;
3063         default:
3064             break;
3065         }
3066         if (den != AV_NOPTS_VALUE) {
3067             if (den <= 0) {
3068                 ret = AVERROR_INVALIDDATA;
3069                 goto fail;
3070             }
3071             frac_init(&st->pts, 0, 0, den);
3072         }
3073     }
3074
3075     if (options) {
3076         av_dict_free(options);
3077         *options = tmp;
3078     }
3079     return 0;
3080 fail:
3081     av_dict_free(&tmp);
3082     return ret;
3083 }
3084
3085 //FIXME merge with compute_pkt_fields
3086 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3087     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3088     int num, den, frame_size, i;
3089
3090     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3091             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3092
3093 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3094         return AVERROR(EINVAL);*/
3095
3096     /* duration field */
3097     if (pkt->duration == 0) {
3098         compute_frame_duration(&num, &den, st, NULL, pkt);
3099         if (den && num) {
3100             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3101         }
3102     }
3103
3104     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3105         pkt->pts= pkt->dts;
3106
3107     //XXX/FIXME this is a temporary hack until all encoders output pts
3108     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3109         pkt->dts=
3110 //        pkt->pts= st->cur_dts;
3111         pkt->pts= st->pts.val;
3112     }
3113
3114     //calculate dts from pts
3115     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3116         st->pts_buffer[0]= pkt->pts;
3117         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3118             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3119         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3120             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3121
3122         pkt->dts= st->pts_buffer[0];
3123     }
3124
3125     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)){
3126         av_log(s, AV_LOG_ERROR,
3127                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3128                st->index, st->cur_dts, pkt->dts);
3129         return AVERROR(EINVAL);
3130     }
3131     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3132         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3133         return AVERROR(EINVAL);
3134     }
3135
3136 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3137     st->cur_dts= pkt->dts;
3138     st->pts.val= pkt->dts;
3139
3140     /* update pts */
3141     switch (st->codec->codec_type) {
3142     case AVMEDIA_TYPE_AUDIO:
3143         frame_size = get_audio_frame_size(st->codec, pkt->size);
3144
3145         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3146            likely equal to the encoder delay, but it would be better if we
3147            had the real timestamps from the encoder */
3148         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3149             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3150         }
3151         break;
3152     case AVMEDIA_TYPE_VIDEO:
3153         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3154         break;
3155     default:
3156         break;
3157     }
3158     return 0;
3159 }
3160
3161 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3162 {
3163     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3164
3165     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3166         return ret;
3167
3168     ret= s->oformat->write_packet(s, pkt);
3169
3170     if (ret >= 0)
3171         s->streams[pkt->stream_index]->nb_frames++;
3172     return ret;
3173 }
3174
3175 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3176                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3177 {
3178     AVPacketList **next_point, *this_pktl;
3179
3180     this_pktl = av_mallocz(sizeof(AVPacketList));
3181     this_pktl->pkt= *pkt;
3182     pkt->destruct= NULL;             // do not free original but only the copy
3183     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3184
3185     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3186         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3187     }else
3188         next_point = &s->packet_buffer;
3189
3190     if(*next_point){
3191         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3192             while(!compare(s, &(*next_point)->pkt, pkt)){
3193                 next_point= &(*next_point)->next;
3194             }
3195             goto next_non_null;
3196         }else{
3197             next_point = &(s->packet_buffer_end->next);
3198         }
3199     }
3200     assert(!*next_point);
3201
3202     s->packet_buffer_end= this_pktl;
3203 next_non_null:
3204
3205     this_pktl->next= *next_point;
3206
3207     s->streams[pkt->stream_index]->last_in_packet_buffer=
3208     *next_point= this_pktl;
3209 }
3210
3211 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3212 {
3213     AVStream *st = s->streams[ pkt ->stream_index];
3214     AVStream *st2= s->streams[ next->stream_index];
3215     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3216                              st->time_base);
3217
3218     if (comp == 0)
3219         return pkt->stream_index < next->stream_index;
3220     return comp > 0;
3221 }
3222
3223 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3224     AVPacketList *pktl;
3225     int stream_count=0;
3226     int i;
3227
3228     if(pkt){
3229         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3230     }
3231
3232     for(i=0; i < s->nb_streams; i++)
3233         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3234
3235     if(stream_count && (s->nb_streams == stream_count || flush)){
3236         pktl= s->packet_buffer;
3237         *out= pktl->pkt;
3238
3239         s->packet_buffer= pktl->next;
3240         if(!s->packet_buffer)
3241             s->packet_buffer_end= NULL;
3242
3243         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3244             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3245         av_freep(&pktl);
3246         return 1;
3247     }else{
3248         av_init_packet(out);
3249         return 0;
3250     }
3251 }
3252
3253 /**
3254  * Interleave an AVPacket correctly so it can be muxed.
3255  * @param out the interleaved packet will be output here
3256  * @param in the input packet
3257  * @param flush 1 if no further packets are available as input and all
3258  *              remaining packets should be output
3259  * @return 1 if a packet was output, 0 if no packet could be output,
3260  *         < 0 if an error occurred
3261  */
3262 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3263     if(s->oformat->interleave_packet)
3264         return s->oformat->interleave_packet(s, out, in, flush);
3265     else
3266         return av_interleave_packet_per_dts(s, out, in, flush);
3267 }
3268
3269 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3270     AVStream *st= s->streams[ pkt->stream_index];
3271     int ret;
3272
3273     //FIXME/XXX/HACK drop zero sized packets
3274     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3275         return 0;
3276
3277     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3278             pkt->size, pkt->dts, pkt->pts);
3279     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3280         return ret;
3281
3282     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3283         return AVERROR(EINVAL);
3284
3285     for(;;){
3286         AVPacket opkt;
3287         int ret= interleave_packet(s, &opkt, pkt, 0);
3288         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3289             return ret;
3290
3291         ret= s->oformat->write_packet(s, &opkt);
3292         if (ret >= 0)
3293             s->streams[opkt.stream_index]->nb_frames++;
3294
3295         av_free_packet(&opkt);
3296         pkt= NULL;
3297
3298         if(ret<0)
3299             return ret;
3300         if(url_ferror(s->pb))
3301             return url_ferror(s->pb);
3302     }
3303 }
3304
3305 int av_write_trailer(AVFormatContext *s)
3306 {
3307     int ret, i;
3308
3309     for(;;){
3310         AVPacket pkt;
3311         ret= interleave_packet(s, &pkt, NULL, 1);
3312         if(ret<0) //FIXME cleanup needed for ret<0 ?
3313             goto fail;
3314         if(!ret)
3315             break;
3316
3317         ret= s->oformat->write_packet(s, &pkt);
3318         if (ret >= 0)
3319             s->streams[pkt.stream_index]->nb_frames++;
3320
3321         av_free_packet(&pkt);
3322
3323         if(ret<0)
3324             goto fail;
3325         if(url_ferror(s->pb))
3326             goto fail;
3327     }
3328
3329     if(s->oformat->write_trailer)
3330         ret = s->oformat->write_trailer(s);
3331 fail:
3332     if(ret == 0)
3333        ret=url_ferror(s->pb);
3334     for(i=0;i<s->nb_streams;i++) {
3335         av_freep(&s->streams[i]->priv_data);
3336         av_freep(&s->streams[i]->index_entries);
3337     }
3338     if (s->iformat && s->iformat->priv_class)
3339         av_opt_free(s->priv_data);
3340     av_freep(&s->priv_data);
3341     return ret;
3342 }
3343
3344 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3345                             int64_t *dts, int64_t *wall)
3346 {
3347     if (!s->oformat || !s->oformat->get_output_timestamp)
3348         return AVERROR(ENOSYS);
3349     s->oformat->get_output_timestamp(s, stream, dts, wall);
3350     return 0;
3351 }
3352
3353 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3354 {
3355     int i, j;
3356     AVProgram *program=NULL;
3357     void *tmp;
3358
3359     if (idx >= ac->nb_streams) {
3360         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3361         return;
3362     }
3363
3364     for(i=0; i<ac->nb_programs; i++){
3365         if(ac->programs[i]->id != progid)
3366             continue;
3367         program = ac->programs[i];
3368         for(j=0; j<program->nb_stream_indexes; j++)
3369             if(program->stream_index[j] == idx)
3370                 return;
3371
3372         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3373         if(!tmp)
3374             return;
3375         program->stream_index = tmp;
3376         program->stream_index[program->nb_stream_indexes++] = idx;
3377         return;
3378     }
3379 }
3380
3381 static void print_fps(double d, const char *postfix){
3382     uint64_t v= lrintf(d*100);
3383     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3384     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3385     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3386 }
3387
3388 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3389 {
3390     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3391         AVDictionaryEntry *tag=NULL;
3392
3393         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3394         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3395             if(strcmp("language", tag->key)){
3396                 char tmp[256];
3397                 int i;
3398                 av_strlcpy(tmp, tag->value, sizeof(tmp));
3399                 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3400                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tmp);
3401             }
3402         }
3403     }
3404 }
3405
3406 /* "user interface" functions */
3407 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3408 {
3409     char buf[256];
3410     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3411     AVStream *st = ic->streams[i];
3412     int g = av_gcd(st->time_base.num, st->time_base.den);
3413     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3414     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3415     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3416     /* the pid is an important information, so we display it */
3417     /* XXX: add a generic system */
3418     if (flags & AVFMT_SHOW_IDS)
3419         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3420     if (lang)
3421         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3422     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3423     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3424     if (st->sample_aspect_ratio.num && // default
3425         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3426         AVRational display_aspect_ratio;
3427         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3428                   st->codec->width*st->sample_aspect_ratio.num,
3429                   st->codec->height*st->sample_aspect_ratio.den,
3430                   1024*1024);
3431         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3432                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3433                  display_aspect_ratio.num, display_aspect_ratio.den);
3434     }
3435     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3436         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3437             print_fps(av_q2d(st->avg_frame_rate), "fps");
3438         if(st->r_frame_rate.den && st->r_frame_rate.num)
3439             print_fps(av_q2d(st->r_frame_rate), "tbr");
3440         if(st->time_base.den && st->time_base.num)
3441             print_fps(1/av_q2d(st->time_base), "tbn");
3442         if(st->codec->time_base.den && st->codec->time_base.num)
3443             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3444     }
3445     if (st->disposition & AV_DISPOSITION_DEFAULT)
3446         av_log(NULL, AV_LOG_INFO, " (default)");
3447     if (st->disposition & AV_DISPOSITION_DUB)
3448         av_log(NULL, AV_LOG_INFO, " (dub)");
3449     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3450         av_log(NULL, AV_LOG_INFO, " (original)");
3451     if (st->disposition & AV_DISPOSITION_COMMENT)
3452         av_log(NULL, AV_LOG_INFO, " (comment)");
3453     if (st->disposition & AV_DISPOSITION_LYRICS)
3454         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3455     if (st->disposition & AV_DISPOSITION_KARAOKE)
3456         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3457     if (st->disposition & AV_DISPOSITION_FORCED)
3458         av_log(NULL, AV_LOG_INFO, " (forced)");
3459     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3460         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3461     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3462         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3463     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3464         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3465     av_log(NULL, AV_LOG_INFO, "\n");
3466     dump_metadata(NULL, st->metadata, "    ");
3467 }
3468
3469 #if FF_API_DUMP_FORMAT
3470 void dump_format(AVFormatContext *ic,
3471                  int index,
3472                  const char *url,
3473                  int is_output)
3474 {
3475     av_dump_format(ic, index, url, is_output);
3476 }
3477 #endif
3478
3479 void av_dump_format(AVFormatContext *ic,
3480                     int index,
3481                     const char *url,
3482                     int is_output)
3483 {
3484     int i;
3485     uint8_t *printed = av_mallocz(ic->nb_streams);
3486     if (ic->nb_streams && !printed)
3487         return;
3488
3489     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3490             is_output ? "Output" : "Input",
3491             index,
3492             is_output ? ic->oformat->name : ic->iformat->name,
3493             is_output ? "to" : "from", url);
3494     dump_metadata(NULL, ic->metadata, "  ");
3495     if (!is_output) {
3496         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3497         if (ic->duration != AV_NOPTS_VALUE) {
3498             int hours, mins, secs, us;
3499             secs = ic->duration / AV_TIME_BASE;
3500             us = ic->duration % AV_TIME_BASE;
3501             mins = secs / 60;
3502             secs %= 60;
3503             hours = mins / 60;
3504             mins %= 60;
3505             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3506                    (100 * us) / AV_TIME_BASE);
3507         } else {
3508             av_log(NULL, AV_LOG_INFO, "N/A");
3509         }
3510         if (ic->start_time != AV_NOPTS_VALUE) {
3511             int secs, us;
3512             av_log(NULL, AV_LOG_INFO, ", start: ");
3513             secs = ic->start_time / AV_TIME_BASE;
3514             us = abs(ic->start_time % AV_TIME_BASE);
3515             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3516                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3517         }
3518         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3519         if (ic->bit_rate) {
3520             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3521         } else {
3522             av_log(NULL, AV_LOG_INFO, "N/A");
3523         }
3524         av_log(NULL, AV_LOG_INFO, "\n");
3525     }
3526     for (i = 0; i < ic->nb_chapters; i++) {
3527         AVChapter *ch = ic->chapters[i];
3528         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3529         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3530         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3531
3532         dump_metadata(NULL, ch->metadata, "    ");
3533     }
3534     if(ic->nb_programs) {
3535         int j, k, total = 0;
3536         for(j=0; j<ic->nb_programs; j++) {
3537             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3538                                                   "name", NULL, 0);
3539             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3540                    name ? name->value : "");
3541             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3542             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3543                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3544                 printed[ic->programs[j]->stream_index[k]] = 1;
3545             }
3546             total += ic->programs[j]->nb_stream_indexes;
3547         }
3548         if (total < ic->nb_streams)
3549             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3550     }
3551     for(i=0;i<ic->nb_streams;i++)
3552         if (!printed[i])
3553             dump_stream_format(ic, i, index, is_output);
3554
3555     av_free(printed);
3556 }
3557
3558 int64_t av_gettime(void)
3559 {
3560     struct timeval tv;
3561     gettimeofday(&tv,NULL);
3562     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3563 }
3564
3565 uint64_t ff_ntp_time(void)
3566 {
3567   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3568 }
3569
3570 #if FF_API_PARSE_DATE
3571 #include "libavutil/parseutils.h"
3572
3573 int64_t parse_date(const char *timestr, int duration)
3574 {
3575     int64_t timeval;
3576     av_parse_time(&timeval, timestr, duration);
3577     return timeval;
3578 }
3579 #endif
3580
3581 #if FF_API_FIND_INFO_TAG
3582 #include "libavutil/parseutils.h"
3583
3584 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3585 {
3586     return av_find_info_tag(arg, arg_size, tag1, info);
3587 }
3588 #endif
3589
3590 int av_get_frame_filename(char *buf, int buf_size,
3591                           const char *path, int number)
3592 {
3593     const char *p;
3594     char *q, buf1[20], c;
3595     int nd, len, percentd_found;
3596
3597     q = buf;
3598     p = path;
3599     percentd_found = 0;
3600     for(;;) {
3601         c = *p++;
3602         if (c == '\0')
3603             break;
3604         if (c == '%') {
3605             do {
3606                 nd = 0;
3607                 while (isdigit(*p)) {
3608                     nd = nd * 10 + *p++ - '0';
3609                 }
3610                 c = *p++;
3611             } while (isdigit(c));
3612
3613             switch(c) {
3614             case '%':
3615                 goto addchar;
3616             case 'd':
3617                 if (percentd_found)
3618                     goto fail;
3619                 percentd_found = 1;
3620                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3621                 len = strlen(buf1);
3622                 if ((q - buf + len) > buf_size - 1)
3623                     goto fail;
3624                 memcpy(q, buf1, len);
3625                 q += len;
3626                 break;
3627             default:
3628                 goto fail;
3629             }
3630         } else {
3631         addchar:
3632             if ((q - buf) < buf_size - 1)
3633                 *q++ = c;
3634         }
3635     }
3636     if (!percentd_found)
3637         goto fail;
3638     *q = '\0';
3639     return 0;
3640  fail:
3641     *q = '\0';
3642     return -1;
3643 }
3644
3645 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3646 {
3647     int len, i, j, c;
3648 #undef fprintf
3649 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3650
3651     for(i=0;i<size;i+=16) {
3652         len = size - i;
3653         if (len > 16)
3654             len = 16;
3655         PRINT("%08x ", i);
3656         for(j=0;j<16;j++) {
3657             if (j < len)
3658                 PRINT(" %02x", buf[i+j]);
3659             else
3660                 PRINT("   ");
3661         }
3662         PRINT(" ");
3663         for(j=0;j<len;j++) {
3664             c = buf[i+j];
3665             if (c < ' ' || c > '~')
3666                 c = '.';
3667             PRINT("%c", c);
3668         }
3669         PRINT("\n");
3670     }
3671 #undef PRINT
3672 }
3673
3674 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3675 {
3676     hex_dump_internal(NULL, f, 0, buf, size);
3677 }
3678
3679 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3680 {
3681     hex_dump_internal(avcl, NULL, level, buf, size);
3682 }
3683
3684 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3685 {
3686 #undef fprintf
3687 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3688     PRINT("stream #%d:\n", pkt->stream_index);
3689     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3690     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3691     /* DTS is _always_ valid after av_read_frame() */
3692     PRINT("  dts=");
3693     if (pkt->dts == AV_NOPTS_VALUE)
3694         PRINT("N/A");
3695     else
3696         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3697     /* PTS may not be known if B-frames are present. */
3698     PRINT("  pts=");
3699     if (pkt->pts == AV_NOPTS_VALUE)
3700         PRINT("N/A");
3701     else
3702         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3703     PRINT("\n");
3704     PRINT("  size=%d\n", pkt->size);
3705 #undef PRINT
3706     if (dump_payload)
3707         av_hex_dump(f, pkt->data, pkt->size);
3708 }
3709
3710 #if FF_API_PKT_DUMP
3711 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3712 {
3713     AVRational tb = { 1, AV_TIME_BASE };
3714     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3715 }
3716 #endif
3717
3718 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3719 {
3720     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3721 }
3722
3723 #if FF_API_PKT_DUMP
3724 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3725 {
3726     AVRational tb = { 1, AV_TIME_BASE };
3727     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3728 }
3729 #endif
3730
3731 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3732                       AVStream *st)
3733 {
3734     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3735 }
3736
3737 void av_url_split(char *proto, int proto_size,
3738                   char *authorization, int authorization_size,
3739                   char *hostname, int hostname_size,
3740                   int *port_ptr,
3741                   char *path, int path_size,
3742                   const char *url)
3743 {
3744     const char *p, *ls, *at, *col, *brk;
3745
3746     if (port_ptr)               *port_ptr = -1;
3747     if (proto_size > 0)         proto[0] = 0;
3748     if (authorization_size > 0) authorization[0] = 0;
3749     if (hostname_size > 0)      hostname[0] = 0;
3750     if (path_size > 0)          path[0] = 0;
3751
3752     /* parse protocol */
3753     if ((p = strchr(url, ':'))) {
3754         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3755         p++; /* skip ':' */
3756         if (*p == '/') p++;
3757         if (*p == '/') p++;
3758     } else {
3759         /* no protocol means plain filename */
3760         av_strlcpy(path, url, path_size);
3761         return;
3762     }
3763
3764     /* separate path from hostname */
3765     ls = strchr(p, '/');
3766     if(!ls)
3767         ls = strchr(p, '?');
3768     if(ls)
3769         av_strlcpy(path, ls, path_size);
3770     else
3771         ls = &p[strlen(p)]; // XXX
3772
3773     /* the rest is hostname, use that to parse auth/port */
3774     if (ls != p) {
3775         /* authorization (user[:pass]@hostname) */
3776         if ((at = strchr(p, '@')) && at < ls) {
3777             av_strlcpy(authorization, p,
3778                        FFMIN(authorization_size, at + 1 - p));
3779             p = at + 1; /* skip '@' */
3780         }
3781
3782         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3783             /* [host]:port */
3784             av_strlcpy(hostname, p + 1,
3785                        FFMIN(hostname_size, brk - p));
3786             if (brk[1] == ':' && port_ptr)
3787                 *port_ptr = atoi(brk + 2);
3788         } else if ((col = strchr(p, ':')) && col < ls) {
3789             av_strlcpy(hostname, p,
3790                        FFMIN(col + 1 - p, hostname_size));
3791             if (port_ptr) *port_ptr = atoi(col + 1);
3792         } else
3793             av_strlcpy(hostname, p,
3794                        FFMIN(ls + 1 - p, hostname_size));
3795     }
3796 }
3797
3798 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3799 {
3800     int i;
3801     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3802                                            '4', '5', '6', '7',
3803                                            '8', '9', 'A', 'B',
3804                                            'C', 'D', 'E', 'F' };
3805     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3806                                            '4', '5', '6', '7',
3807                                            '8', '9', 'a', 'b',
3808                                            'c', 'd', 'e', 'f' };
3809     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3810
3811     for(i = 0; i < s; i++) {
3812         buff[i * 2]     = hex_table[src[i] >> 4];
3813         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3814     }
3815
3816     return buff;
3817 }
3818
3819 int ff_hex_to_data(uint8_t *data, const char *p)
3820 {
3821     int c, len, v;
3822
3823     len = 0;
3824     v = 1;
3825     for (;;) {
3826         p += strspn(p, SPACE_CHARS);
3827         if (*p == '\0')
3828             break;
3829         c = toupper((unsigned char) *p++);
3830         if (c >= '0' && c <= '9')
3831             c = c - '0';
3832         else if (c >= 'A' && c <= 'F')
3833             c = c - 'A' + 10;
3834         else
3835             break;
3836         v = (v << 4) | c;
3837         if (v & 0x100) {
3838             if (data)
3839                 data[len] = v;
3840             len++;
3841             v = 1;
3842         }
3843     }
3844     return len;
3845 }
3846
3847 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3848                      unsigned int pts_num, unsigned int pts_den)
3849 {
3850     AVRational new_tb;
3851     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3852         if(new_tb.num != pts_num)
3853             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3854     }else
3855         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3856
3857     if(new_tb.num <= 0 || new_tb.den <= 0) {
3858         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3859         return;
3860     }
3861     s->time_base = new_tb;
3862     s->pts_wrap_bits = pts_wrap_bits;
3863 }
3864
3865 int ff_url_join(char *str, int size, const char *proto,
3866                 const char *authorization, const char *hostname,
3867                 int port, const char *fmt, ...)
3868 {
3869 #if CONFIG_NETWORK
3870     struct addrinfo hints, *ai;
3871 #endif
3872
3873     str[0] = '\0';
3874     if (proto)
3875         av_strlcatf(str, size, "%s://", proto);
3876     if (authorization && authorization[0])
3877         av_strlcatf(str, size, "%s@", authorization);
3878 #if CONFIG_NETWORK && defined(AF_INET6)
3879     /* Determine if hostname is a numerical IPv6 address,
3880      * properly escape it within [] in that case. */
3881     memset(&hints, 0, sizeof(hints));
3882     hints.ai_flags = AI_NUMERICHOST;
3883     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3884         if (ai->ai_family == AF_INET6) {
3885             av_strlcat(str, "[", size);
3886             av_strlcat(str, hostname, size);
3887             av_strlcat(str, "]", size);
3888         } else {
3889             av_strlcat(str, hostname, size);
3890         }
3891         freeaddrinfo(ai);
3892     } else
3893 #endif
3894         /* Not an IPv6 address, just output the plain string. */
3895         av_strlcat(str, hostname, size);
3896
3897     if (port >= 0)
3898         av_strlcatf(str, size, ":%d", port);
3899     if (fmt) {
3900         va_list vl;
3901         int len = strlen(str);
3902
3903         va_start(vl, fmt);
3904         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3905         va_end(vl);
3906     }
3907     return strlen(str);
3908 }
3909
3910 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3911                      AVFormatContext *src)
3912 {
3913     AVPacket local_pkt;
3914
3915     local_pkt = *pkt;
3916     local_pkt.stream_index = dst_stream;
3917     if (pkt->pts != AV_NOPTS_VALUE)
3918         local_pkt.pts = av_rescale_q(pkt->pts,
3919                                      src->streams[pkt->stream_index]->time_base,
3920                                      dst->streams[dst_stream]->time_base);
3921     if (pkt->dts != AV_NOPTS_VALUE)
3922         local_pkt.dts = av_rescale_q(pkt->dts,
3923                                      src->streams[pkt->stream_index]->time_base,
3924                                      dst->streams[dst_stream]->time_base);
3925     return av_write_frame(dst, &local_pkt);
3926 }
3927
3928 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3929                         void *context)
3930 {
3931     const char *ptr = str;
3932
3933     /* Parse key=value pairs. */
3934     for (;;) {
3935         const char *key;
3936         char *dest = NULL, *dest_end;
3937         int key_len, dest_len = 0;
3938
3939         /* Skip whitespace and potential commas. */
3940         while (*ptr && (isspace(*ptr) || *ptr == ','))
3941             ptr++;
3942         if (!*ptr)
3943             break;
3944
3945         key = ptr;
3946
3947         if (!(ptr = strchr(key, '=')))
3948             break;
3949         ptr++;
3950         key_len = ptr - key;
3951
3952         callback_get_buf(context, key, key_len, &dest, &dest_len);
3953         dest_end = dest + dest_len - 1;
3954
3955         if (*ptr == '\"') {
3956             ptr++;
3957             while (*ptr && *ptr != '\"') {
3958                 if (*ptr == '\\') {
3959                     if (!ptr[1])
3960                         break;
3961                     if (dest && dest < dest_end)
3962                         *dest++ = ptr[1];
3963                     ptr += 2;
3964                 } else {
3965                     if (dest && dest < dest_end)
3966                         *dest++ = *ptr;
3967                     ptr++;
3968                 }
3969             }
3970             if (*ptr == '\"')
3971                 ptr++;
3972         } else {
3973             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3974                 if (dest && dest < dest_end)
3975                     *dest++ = *ptr;
3976         }
3977         if (dest)
3978             *dest = 0;
3979     }
3980 }
3981
3982 int ff_find_stream_index(AVFormatContext *s, int id)
3983 {
3984     int i;
3985     for (i = 0; i < s->nb_streams; i++) {
3986         if (s->streams[i]->id == id)
3987             return i;
3988     }
3989     return -1;
3990 }
3991
3992 void ff_make_absolute_url(char *buf, int size, const char *base,
3993                           const char *rel)
3994 {
3995     char *sep;
3996     /* Absolute path, relative to the current server */
3997     if (base && strstr(base, "://") && rel[0] == '/') {
3998         if (base != buf)
3999             av_strlcpy(buf, base, size);
4000         sep = strstr(buf, "://");
4001         if (sep) {
4002             sep += 3;
4003             sep = strchr(sep, '/');
4004             if (sep)
4005                 *sep = '\0';
4006         }
4007         av_strlcat(buf, rel, size);
4008         return;
4009     }
4010     /* If rel actually is an absolute url, just copy it */
4011     if (!base || strstr(rel, "://") || rel[0] == '/') {
4012         av_strlcpy(buf, rel, size);
4013         return;
4014     }
4015     if (base != buf)
4016         av_strlcpy(buf, base, size);
4017     /* Remove the file name from the base url */
4018     sep = strrchr(buf, '/');
4019     if (sep)
4020         sep[1] = '\0';
4021     else
4022         buf[0] = '\0';
4023     while (av_strstart(rel, "../", NULL) && sep) {
4024         /* Remove the path delimiter at the end */
4025         sep[0] = '\0';
4026         sep = strrchr(buf, '/');
4027         /* If the next directory name to pop off is "..", break here */
4028         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4029             /* Readd the slash we just removed */
4030             av_strlcat(buf, "/", size);
4031             break;
4032         }
4033         /* Cut off the directory name */
4034         if (sep)
4035             sep[1] = '\0';
4036         else
4037             buf[0] = '\0';
4038         rel += 3;
4039     }
4040     av_strlcat(buf, rel, size);
4041 }
4042
4043 int64_t ff_iso8601_to_unix_time(const char *datestr)
4044 {
4045 #if HAVE_STRPTIME
4046     struct tm time = {0};
4047     strptime(datestr, "%Y - %m - %dT%T", &time);
4048     return mktime(&time);
4049 #else
4050     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4051                                  "the date string.\n");
4052     return 0;
4053 #endif
4054 }
4055
4056 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4057 {
4058     if (ofmt) {
4059         if (ofmt->query_codec)
4060             return ofmt->query_codec(codec_id, std_compliance);
4061         else if (ofmt->codec_tag)
4062             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4063         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4064                  codec_id == ofmt->subtitle_codec)
4065             return 1;
4066     }
4067     return AVERROR_PATCHWELCOME;
4068 }