git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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