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