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