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 "libavutil/parseutils.h"
  37 #include "riff.h"
  38 #include "audiointerleave.h"
  39 #include "url.h"
  40 #include <sys/time.h>
  41 #include <time.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 (!av_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 (!av_strncasecmp(name, names, len))
 195             return 1;
 196         names = p+1;
 197     }
 198     return !av_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, AVDictionary **options)
 607 {
 608     int ret;
 609     AVProbeData pd = {filename, NULL, 0};
 610
 611     if(s->iformat && !strlen(filename))
 612         return 0;
 613
 614     if (s->pb) {
 615         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 616         if (!s->iformat)
 617             return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
 618         else if (s->iformat->flags & AVFMT_NOFILE)
 619             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 620                                       "will be ignored with AVFMT_NOFILE format.\n");
 621         return 0;
 622     }
 623
 624     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 625         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
 626         return 0;
 627
 628     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
 629                           &s->interrupt_callback, options)) < 0)
 630         return ret;
 631     if (s->iformat)
 632         return 0;
 633     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
 634 }
 635
 636 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
 637 {
 638     AVFormatContext *s = *ps;
 639     int ret = 0;
 640     AVFormatParameters ap = { { 0 } };
 641     AVDictionary *tmp = NULL;
 642
 643     if (!s && !(s = avformat_alloc_context()))
 644         return AVERROR(ENOMEM);
 645     if (fmt)
 646         s->iformat = fmt;
 647
 648     if (options)
 649         av_dict_copy(&tmp, *options, 0);
 650
 651     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 652         goto fail;
 653
 654     if ((ret = init_input(s, filename, &tmp)) < 0)
 655         goto fail;
 656
 657     /* check filename in case an image number is expected */
 658     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 659         if (!av_filename_number_test(filename)) {
 660             ret = AVERROR(EINVAL);
 661             goto fail;
 662         }
 663     }
 664
 665     s->duration = s->start_time = AV_NOPTS_VALUE;
 666     av_strlcpy(s->filename, filename, sizeof(s->filename));
 667
 668     /* allocate private data */
 669     if (s->iformat->priv_data_size > 0) {
 670         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 671             ret = AVERROR(ENOMEM);
 672             goto fail;
 673         }
 674         if (s->iformat->priv_class) {
 675             *(const AVClass**)s->priv_data = s->iformat->priv_class;
 676             av_opt_set_defaults(s->priv_data);
 677             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 678                 goto fail;
 679         }
 680     }
 681
 682     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 683     if (s->pb)
 684         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
 685
 686     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
 687         if ((ret = s->iformat->read_header(s, &ap)) < 0)
 688             goto fail;
 689
 690     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
 691         s->data_offset = avio_tell(s->pb);
 692
 693     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 694
 695     if (options) {
 696         av_dict_free(options);
 697         *options = tmp;
 698     }
 699     *ps = s;
 700     return 0;
 701
 702 fail:
 703     av_dict_free(&tmp);
 704     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 705         avio_close(s->pb);
 706     avformat_free_context(s);
 707     *ps = NULL;
 708     return ret;
 709 }
 710
 711 /*******************************************************/
 712
 713 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 714                                AVPacketList **plast_pktl){
 715     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 716     if (!pktl)
 717         return NULL;
 718
 719     if (*packet_buffer)
 720         (*plast_pktl)->next = pktl;
 721     else
 722         *packet_buffer = pktl;
 723
 724     /* add the packet in the buffered packet list */
 725     *plast_pktl = pktl;
 726     pktl->pkt= *pkt;
 727     return &pktl->pkt;
 728 }
 729
 730 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 731 {
 732     int ret, i;
 733     AVStream *st;
 734
 735     for(;;){
 736         AVPacketList *pktl = s->raw_packet_buffer;
 737
 738         if (pktl) {
 739             *pkt = pktl->pkt;
 740             if(s->streams[pkt->stream_index]->request_probe <= 0){
 741                 s->raw_packet_buffer = pktl->next;
 742                 s->raw_packet_buffer_remaining_size += pkt->size;
 743                 av_free(pktl);
 744                 return 0;
 745             }
 746         }
 747
 748         av_init_packet(pkt);
 749         ret= s->iformat->read_packet(s, pkt);
 750         if (ret < 0) {
 751             if (!pktl || ret == AVERROR(EAGAIN))
 752                 return ret;
 753             for (i = 0; i < s->nb_streams; i++)
 754                 if(s->streams[i]->request_probe > 0)
 755                     s->streams[i]->request_probe = -1;
 756             continue;
 757         }
 758
 759         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 760             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 761             av_log(s, AV_LOG_WARNING,
 762                    "Dropped corrupted packet (stream = %d)\n",
 763                    pkt->stream_index);
 764             av_free_packet(pkt);
 765             continue;
 766         }
 767
 768         if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
 769             av_packet_merge_side_data(pkt);
 770
 771         if(pkt->stream_index >= (unsigned)s->nb_streams){
 772             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
 773             continue;
 774         }
 775
 776         st= s->streams[pkt->stream_index];
 777
 778         switch(st->codec->codec_type){
 779         case AVMEDIA_TYPE_VIDEO:
 780             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 781             break;
 782         case AVMEDIA_TYPE_AUDIO:
 783             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 784             break;
 785         case AVMEDIA_TYPE_SUBTITLE:
 786             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 787             break;
 788         }
 789
 790         if(!pktl && st->request_probe <= 0)
 791             return ret;
 792
 793         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 794         s->raw_packet_buffer_remaining_size -= pkt->size;
 795
 796         if(st->request_probe>0){
 797             AVProbeData *pd = &st->probe_data;
 798             int end;
 799             av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
 800             --st->probe_packets;
 801
 802             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 803             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 804             pd->buf_size += pkt->size;
 805             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 806
 807             end=    s->raw_packet_buffer_remaining_size <= 0
 808                  || st->probe_packets<=0;
 809
 810             if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 811                 int score= set_codec_from_probe_data(s, st, pd);
 812                 if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
 813                     || end){
 814                     pd->buf_size=0;
 815                     av_freep(&pd->buf);
 816                     st->request_probe= -1;
 817                     if(st->codec->codec_id != CODEC_ID_NONE){
 818                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 819                     }else
 820                         av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
 821                 }
 822             }
 823         }
 824     }
 825 }
 826
 827 /**********************************************************/
 828
 829 /**
 830  * Get the number of samples of an audio frame. Return -1 on error.
 831  */
 832 static int get_audio_frame_size(AVCodecContext *enc, int size)
 833 {
 834     int frame_size;
 835
 836     if(enc->codec_id == CODEC_ID_VORBIS)
 837         return -1;
 838
 839     if (enc->frame_size <= 1) {
 840         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 841
 842         if (bits_per_sample) {
 843             if (enc->channels == 0)
 844                 return -1;
 845             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 846         } else {
 847             /* used for example by ADPCM codecs */
 848             if (enc->bit_rate == 0)
 849                 return -1;
 850             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 851         }
 852     } else {
 853         frame_size = enc->frame_size;
 854     }
 855     return frame_size;
 856 }
 857
 858
 859 /**
 860  * Return the frame duration in seconds. Return 0 if not available.
 861  */
 862 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 863                                    AVCodecParserContext *pc, AVPacket *pkt)
 864 {
 865     int frame_size;
 866
 867     *pnum = 0;
 868     *pden = 0;
 869     switch(st->codec->codec_type) {
 870     case AVMEDIA_TYPE_VIDEO:
 871         if(st->time_base.num*1000LL > st->time_base.den){
 872             *pnum = st->time_base.num;
 873             *pden = st->time_base.den;
 874         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 875             *pnum = st->codec->time_base.num;
 876             *pden = st->codec->time_base.den;
 877             if (pc && pc->repeat_pict) {
 878                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 879             }
 880             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
 881             //Thus if we have no parser in such case leave duration undefined.
 882             if(st->codec->ticks_per_frame>1 && !pc){
 883                 *pnum = *pden = 0;
 884             }
 885         }
 886         break;
 887     case AVMEDIA_TYPE_AUDIO:
 888         frame_size = get_audio_frame_size(st->codec, pkt->size);
 889         if (frame_size <= 0 || st->codec->sample_rate <= 0)
 890             break;
 891         *pnum = frame_size;
 892         *pden = st->codec->sample_rate;
 893         break;
 894     default:
 895         break;
 896     }
 897 }
 898
 899 static int is_intra_only(AVCodecContext *enc){
 900     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
 901         return 1;
 902     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
 903         switch(enc->codec_id){
 904         case CODEC_ID_MJPEG:
 905         case CODEC_ID_MJPEGB:
 906         case CODEC_ID_LJPEG:
 907         case CODEC_ID_PRORES:
 908         case CODEC_ID_RAWVIDEO:
 909         case CODEC_ID_DVVIDEO:
 910         case CODEC_ID_HUFFYUV:
 911         case CODEC_ID_FFVHUFF:
 912         case CODEC_ID_ASV1:
 913         case CODEC_ID_ASV2:
 914         case CODEC_ID_VCR1:
 915         case CODEC_ID_DNXHD:
 916         case CODEC_ID_JPEG2000:
 917             return 1;
 918         default: break;
 919         }
 920     }
 921     return 0;
 922 }
 923
 924 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 925                                       int64_t dts, int64_t pts)
 926 {
 927     AVStream *st= s->streams[stream_index];
 928     AVPacketList *pktl= s->packet_buffer;
 929
 930     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 931         return;
 932
 933     st->first_dts= dts - st->cur_dts;
 934     st->cur_dts= dts;
 935
 936     for(; pktl; pktl= pktl->next){
 937         if(pktl->pkt.stream_index != stream_index)
 938             continue;
 939         //FIXME think more about this check
 940         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 941             pktl->pkt.pts += st->first_dts;
 942
 943         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 944             pktl->pkt.dts += st->first_dts;
 945
 946         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 947             st->start_time= pktl->pkt.pts;
 948     }
 949     if (st->start_time == AV_NOPTS_VALUE)
 950         st->start_time = pts;
 951 }
 952
 953 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 954 {
 955     AVPacketList *pktl= s->packet_buffer;
 956     int64_t cur_dts= 0;
 957
 958     if(st->first_dts != AV_NOPTS_VALUE){
 959         cur_dts= st->first_dts;
 960         for(; pktl; pktl= pktl->next){
 961             if(pktl->pkt.stream_index == pkt->stream_index){
 962                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 963                     break;
 964                 cur_dts -= pkt->duration;
 965             }
 966         }
 967         pktl= s->packet_buffer;
 968         st->first_dts = cur_dts;
 969     }else if(st->cur_dts)
 970         return;
 971
 972     for(; pktl; pktl= pktl->next){
 973         if(pktl->pkt.stream_index != pkt->stream_index)
 974             continue;
 975         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 976            && !pktl->pkt.duration){
 977             pktl->pkt.dts= cur_dts;
 978             if(!st->codec->has_b_frames)
 979                 pktl->pkt.pts= cur_dts;
 980             cur_dts += pkt->duration;
 981             pktl->pkt.duration= pkt->duration;
 982         }else
 983             break;
 984     }
 985     if(st->first_dts == AV_NOPTS_VALUE)
 986         st->cur_dts= cur_dts;
 987 }
 988
 989 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 990                                AVCodecParserContext *pc, AVPacket *pkt)
 991 {
 992     int num, den, presentation_delayed, delay, i;
 993     int64_t offset;
 994
 995     if (s->flags & AVFMT_FLAG_NOFILLIN)
 996         return;
 997
 998     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 999         pkt->dts= AV_NOPTS_VALUE;
1000
1001     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1002         //FIXME Set low_delay = 0 when has_b_frames = 1
1003         st->codec->has_b_frames = 1;
1004
1005     /* do we have a video B-frame ? */
1006     delay= st->codec->has_b_frames;
1007     presentation_delayed = 0;
1008
1009     /* XXX: need has_b_frame, but cannot get it if the codec is
1010         not initialized */
1011     if (delay &&
1012         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1013         presentation_delayed = 1;
1014
1015     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){
1016         pkt->dts -= 1LL<<st->pts_wrap_bits;
1017     }
1018
1019     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1020     // we take the conservative approach and discard both
1021     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1022     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1023         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1024         pkt->dts= AV_NOPTS_VALUE;
1025     }
1026
1027     if (pkt->duration == 0) {
1028         compute_frame_duration(&num, &den, st, pc, pkt);
1029         if (den && num) {
1030             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1031
1032             if(pkt->duration != 0 && s->packet_buffer)
1033                 update_initial_durations(s, st, pkt);
1034         }
1035     }
1036
1037     /* correct timestamps with byte offset if demuxers only have timestamps
1038        on packet boundaries */
1039     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1040         /* this will estimate bitrate based on this frame's duration and size */
1041         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1042         if(pkt->pts != AV_NOPTS_VALUE)
1043             pkt->pts += offset;
1044         if(pkt->dts != AV_NOPTS_VALUE)
1045             pkt->dts += offset;
1046     }
1047
1048     if (pc && pc->dts_sync_point >= 0) {
1049         // we have synchronization info from the parser
1050         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1051         if (den > 0) {
1052             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1053             if (pkt->dts != AV_NOPTS_VALUE) {
1054                 // got DTS from the stream, update reference timestamp
1055                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1056                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1057             } else if (st->reference_dts != AV_NOPTS_VALUE) {
1058                 // compute DTS based on reference timestamp
1059                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1060                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1061             }
1062             if (pc->dts_sync_point > 0)
1063                 st->reference_dts = pkt->dts; // new reference
1064         }
1065     }
1066
1067     /* This may be redundant, but it should not hurt. */
1068     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1069         presentation_delayed = 1;
1070
1071 //    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);
1072     /* interpolate PTS and DTS if they are not present */
1073     //We skip H264 currently because delay and has_b_frames are not reliably set
1074     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1075         if (presentation_delayed) {
1076             /* DTS = decompression timestamp */
1077             /* PTS = presentation timestamp */
1078             if (pkt->dts == AV_NOPTS_VALUE)
1079                 pkt->dts = st->last_IP_pts;
1080             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1081             if (pkt->dts == AV_NOPTS_VALUE)
1082                 pkt->dts = st->cur_dts;
1083
1084             /* this is tricky: the dts must be incremented by the duration
1085             of the frame we are displaying, i.e. the last I- or P-frame */
1086             if (st->last_IP_duration == 0)
1087                 st->last_IP_duration = pkt->duration;
1088             if(pkt->dts != AV_NOPTS_VALUE)
1089                 st->cur_dts = pkt->dts + st->last_IP_duration;
1090             st->last_IP_duration  = pkt->duration;
1091             st->last_IP_pts= pkt->pts;
1092             /* cannot compute PTS if not present (we can compute it only
1093             by knowing the future */
1094         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1095             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1096                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1097                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1098                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1099                     pkt->pts += pkt->duration;
1100     //                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);
1101                 }
1102             }
1103
1104             /* presentation is not delayed : PTS and DTS are the same */
1105             if(pkt->pts == AV_NOPTS_VALUE)
1106                 pkt->pts = pkt->dts;
1107             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1108             if(pkt->pts == AV_NOPTS_VALUE)
1109                 pkt->pts = st->cur_dts;
1110             pkt->dts = pkt->pts;
1111             if(pkt->pts != AV_NOPTS_VALUE)
1112                 st->cur_dts = pkt->pts + pkt->duration;
1113         }
1114     }
1115
1116     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1117         st->pts_buffer[0]= pkt->pts;
1118         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1119             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1120         if(pkt->dts == AV_NOPTS_VALUE)
1121             pkt->dts= st->pts_buffer[0];
1122         if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1123             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1124         }
1125         if(pkt->dts > st->cur_dts)
1126             st->cur_dts = pkt->dts;
1127     }
1128
1129 //    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);
1130
1131     /* update flags */
1132     if(is_intra_only(st->codec))
1133         pkt->flags |= AV_PKT_FLAG_KEY;
1134     else if (pc) {
1135         pkt->flags = 0;
1136         /* keyframe computation */
1137         if (pc->key_frame == 1)
1138             pkt->flags |= AV_PKT_FLAG_KEY;
1139         else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1140             pkt->flags |= AV_PKT_FLAG_KEY;
1141     }
1142     if (pc)
1143         pkt->convergence_duration = pc->convergence_duration;
1144 }
1145
1146
1147 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1148 {
1149     AVStream *st;
1150     int len, ret, i;
1151
1152     av_init_packet(pkt);
1153
1154     for(;;) {
1155         /* select current input stream component */
1156         st = s->cur_st;
1157         if (st) {
1158             if (!st->need_parsing || !st->parser) {
1159                 /* no parsing needed: we just output the packet as is */
1160                 /* raw data support */
1161                 *pkt = st->cur_pkt;
1162                 st->cur_pkt.data= NULL;
1163                 st->cur_pkt.side_data_elems = 0;
1164                 st->cur_pkt.side_data = NULL;
1165                 compute_pkt_fields(s, st, NULL, pkt);
1166                 s->cur_st = NULL;
1167                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1168                     (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1169                     ff_reduce_index(s, st->index);
1170                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1171                 }
1172                 break;
1173             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1174                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1175                                        st->cur_ptr, st->cur_len,
1176                                        st->cur_pkt.pts, st->cur_pkt.dts,
1177                                        st->cur_pkt.pos);
1178                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1179                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1180                 /* increment read pointer */
1181                 st->cur_ptr += len;
1182                 st->cur_len -= len;
1183
1184                 /* return packet if any */
1185                 if (pkt->size) {
1186                 got_packet:
1187                     pkt->duration = 0;
1188                     pkt->stream_index = st->index;
1189                     pkt->pts = st->parser->pts;
1190                     pkt->dts = st->parser->dts;
1191                     pkt->pos = st->parser->pos;
1192                     if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1193                         s->cur_st = NULL;
1194                         pkt->destruct= st->cur_pkt.destruct;
1195                         st->cur_pkt.destruct= NULL;
1196                         st->cur_pkt.data    = NULL;
1197                         assert(st->cur_len == 0);
1198                     }else{
1199                         pkt->destruct = NULL;
1200                     }
1201                     compute_pkt_fields(s, st, st->parser, pkt);
1202
1203                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1204                         int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1205                         ff_reduce_index(s, st->index);
1206                         av_add_index_entry(st, pos, pkt->dts,
1207                                            0, 0, AVINDEX_KEYFRAME);
1208                     }
1209
1210                     break;
1211                 }
1212             } else {
1213                 /* free packet */
1214                 av_free_packet(&st->cur_pkt);
1215                 s->cur_st = NULL;
1216             }
1217         } else {
1218             AVPacket cur_pkt;
1219             /* read next packet */
1220             ret = av_read_packet(s, &cur_pkt);
1221             if (ret < 0) {
1222                 if (ret == AVERROR(EAGAIN))
1223                     return ret;
1224                 /* return the last frames, if any */
1225                 for(i = 0; i < s->nb_streams; i++) {
1226                     st = s->streams[i];
1227                     if (st->parser && st->need_parsing) {
1228                         av_parser_parse2(st->parser, st->codec,
1229                                         &pkt->data, &pkt->size,
1230                                         NULL, 0,
1231                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1232                                         AV_NOPTS_VALUE);
1233                         if (pkt->size)
1234                             goto got_packet;
1235                     }
1236                 }
1237                 /* no more packets: really terminate parsing */
1238                 return ret;
1239             }
1240             st = s->streams[cur_pkt.stream_index];
1241             st->cur_pkt= cur_pkt;
1242
1243             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1244                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1245                st->cur_pkt.pts < st->cur_pkt.dts){
1246                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1247                     st->cur_pkt.stream_index,
1248                     st->cur_pkt.pts,
1249                     st->cur_pkt.dts,
1250                     st->cur_pkt.size);
1251 //                av_free_packet(&st->cur_pkt);
1252 //                return -1;
1253             }
1254
1255             if(s->debug & FF_FDEBUG_TS)
1256                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1257                     st->cur_pkt.stream_index,
1258                     st->cur_pkt.pts,
1259                     st->cur_pkt.dts,
1260                     st->cur_pkt.size,
1261                     st->cur_pkt.duration,
1262                     st->cur_pkt.flags);
1263
1264             s->cur_st = st;
1265             st->cur_ptr = st->cur_pkt.data;
1266             st->cur_len = st->cur_pkt.size;
1267             if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1268                 st->parser = av_parser_init(st->codec->codec_id);
1269                 if (!st->parser) {
1270                     av_log(s, AV_LOG_WARNING, "parser not found for codec "
1271                            "%s, packets or times may be invalid.\n",
1272                            avcodec_get_name(st->codec->codec_id));
1273                     /* no parser available: just output the raw packets */
1274                     st->need_parsing = AVSTREAM_PARSE_NONE;
1275                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1276                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1277                 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1278                     st->parser->flags |= PARSER_FLAG_ONCE;
1279                 }
1280             }
1281         }
1282     }
1283     if(s->debug & FF_FDEBUG_TS)
1284         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1285             pkt->stream_index,
1286             pkt->pts,
1287             pkt->dts,
1288             pkt->size,
1289             pkt->duration,
1290             pkt->flags);
1291
1292     return 0;
1293 }
1294
1295 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1296 {
1297     AVPacketList *pktl;
1298     int eof=0;
1299     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1300
1301     for(;;){
1302         pktl = s->packet_buffer;
1303         if (pktl) {
1304             AVPacket *next_pkt= &pktl->pkt;
1305
1306             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1307                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1308                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1309                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1310                        && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1311                        && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1312                         next_pkt->pts= pktl->pkt.dts;
1313                     }
1314                     pktl= pktl->next;
1315                 }
1316                 pktl = s->packet_buffer;
1317             }
1318
1319             if(   next_pkt->pts != AV_NOPTS_VALUE
1320                || next_pkt->dts == AV_NOPTS_VALUE
1321                || !genpts || eof){
1322                 /* read packet from packet buffer, if there is data */
1323                 *pkt = *next_pkt;
1324                 s->packet_buffer = pktl->next;
1325                 av_free(pktl);
1326                 return 0;
1327             }
1328         }
1329         if(genpts){
1330             int ret= read_frame_internal(s, pkt);
1331             if(ret<0){
1332                 if(pktl && ret != AVERROR(EAGAIN)){
1333                     eof=1;
1334                     continue;
1335                 }else
1336                     return ret;
1337             }
1338
1339             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1340                                            &s->packet_buffer_end)) < 0)
1341                 return AVERROR(ENOMEM);
1342         }else{
1343             assert(!s->packet_buffer);
1344             return read_frame_internal(s, pkt);
1345         }
1346     }
1347 }
1348
1349 /* XXX: suppress the packet queue */
1350 static void flush_packet_queue(AVFormatContext *s)
1351 {
1352     AVPacketList *pktl;
1353
1354     for(;;) {
1355         pktl = s->packet_buffer;
1356         if (!pktl)
1357             break;
1358         s->packet_buffer = pktl->next;
1359         av_free_packet(&pktl->pkt);
1360         av_free(pktl);
1361     }
1362     while(s->raw_packet_buffer){
1363         pktl = s->raw_packet_buffer;
1364         s->raw_packet_buffer = pktl->next;
1365         av_free_packet(&pktl->pkt);
1366         av_free(pktl);
1367     }
1368     s->packet_buffer_end=
1369     s->raw_packet_buffer_end= NULL;
1370     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1371 }
1372
1373 /*******************************************************/
1374 /* seek support */
1375
1376 int av_find_default_stream_index(AVFormatContext *s)
1377 {
1378     int first_audio_index = -1;
1379     int i;
1380     AVStream *st;
1381
1382     if (s->nb_streams <= 0)
1383         return -1;
1384     for(i = 0; i < s->nb_streams; i++) {
1385         st = s->streams[i];
1386         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1387             return i;
1388         }
1389         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1390             first_audio_index = i;
1391     }
1392     return first_audio_index >= 0 ? first_audio_index : 0;
1393 }
1394
1395 /**
1396  * Flush the frame reader.
1397  */
1398 void ff_read_frame_flush(AVFormatContext *s)
1399 {
1400     AVStream *st;
1401     int i, j;
1402
1403     flush_packet_queue(s);
1404
1405     s->cur_st = NULL;
1406
1407     /* for each stream, reset read state */
1408     for(i = 0; i < s->nb_streams; i++) {
1409         st = s->streams[i];
1410
1411         if (st->parser) {
1412             av_parser_close(st->parser);
1413             st->parser = NULL;
1414             av_free_packet(&st->cur_pkt);
1415         }
1416         st->last_IP_pts = AV_NOPTS_VALUE;
1417         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = 0;
1418         else                                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     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 (ff_check_interrupt(&ic->interrupt_callback)){
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     /* duration field */
3184     if (pkt->duration == 0) {
3185         compute_frame_duration(&num, &den, st, NULL, pkt);
3186         if (den && num) {
3187             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3188         }
3189     }
3190
3191     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3192         pkt->pts= pkt->dts;
3193
3194     //XXX/FIXME this is a temporary hack until all encoders output pts
3195     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3196         pkt->dts=
3197 //        pkt->pts= st->cur_dts;
3198         pkt->pts= st->pts.val;
3199     }
3200
3201     //calculate dts from pts
3202     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3203         st->pts_buffer[0]= pkt->pts;
3204         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3205             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3206         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3207             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3208
3209         pkt->dts= st->pts_buffer[0];
3210     }
3211
3212     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)){
3213         av_log(s, AV_LOG_ERROR,
3214                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3215                st->index, st->cur_dts, pkt->dts);
3216         return AVERROR(EINVAL);
3217     }
3218     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3219         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3220         return AVERROR(EINVAL);
3221     }
3222
3223 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3224     st->cur_dts= pkt->dts;
3225     st->pts.val= pkt->dts;
3226
3227     /* update pts */
3228     switch (st->codec->codec_type) {
3229     case AVMEDIA_TYPE_AUDIO:
3230         frame_size = get_audio_frame_size(st->codec, pkt->size);
3231
3232         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3233            likely equal to the encoder delay, but it would be better if we
3234            had the real timestamps from the encoder */
3235         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3236             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3237         }
3238         break;
3239     case AVMEDIA_TYPE_VIDEO:
3240         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3241         break;
3242     default:
3243         break;
3244     }
3245     return 0;
3246 }
3247
3248 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3249 {
3250     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3251
3252     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3253         return ret;
3254
3255     ret= s->oformat->write_packet(s, pkt);
3256
3257     if (ret >= 0)
3258         s->streams[pkt->stream_index]->nb_frames++;
3259     return ret;
3260 }
3261
3262 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3263                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3264 {
3265     AVPacketList **next_point, *this_pktl;
3266
3267     this_pktl = av_mallocz(sizeof(AVPacketList));
3268     if (!this_pktl)
3269         return AVERROR(ENOMEM);
3270     this_pktl->pkt= *pkt;
3271     pkt->destruct= NULL;             // do not free original but only the copy
3272     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3273
3274     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3275         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3276     }else
3277         next_point = &s->packet_buffer;
3278
3279     if(*next_point){
3280         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3281             while(!compare(s, &(*next_point)->pkt, pkt)){
3282                 next_point= &(*next_point)->next;
3283             }
3284             goto next_non_null;
3285         }else{
3286             next_point = &(s->packet_buffer_end->next);
3287         }
3288     }
3289     assert(!*next_point);
3290
3291     s->packet_buffer_end= this_pktl;
3292 next_non_null:
3293
3294     this_pktl->next= *next_point;
3295
3296     s->streams[pkt->stream_index]->last_in_packet_buffer=
3297     *next_point= this_pktl;
3298     return 0;
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, ret;
3318
3319     if(pkt){
3320         ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3321         if (ret < 0)
3322             return ret;
3323     }
3324
3325     for(i=0; i < s->nb_streams; i++) {
3326         if (s->streams[i]->last_in_packet_buffer) {
3327             ++stream_count;
3328         } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3329             ++noninterleaved_count;
3330         }
3331     }
3332
3333     if (s->nb_streams == stream_count) {
3334         flush = 1;
3335     } else if (!flush){
3336         for(i=0; i < s->nb_streams; i++) {
3337             if (s->streams[i]->last_in_packet_buffer) {
3338                 int64_t delta_dts =
3339                     av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3340                                 s->streams[i]->time_base,
3341                                 AV_TIME_BASE_Q) -
3342                     av_rescale_q(s->packet_buffer->pkt.dts,
3343                                 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3344                                 AV_TIME_BASE_Q);
3345                 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3346             }
3347         }
3348         if(s->nb_streams == stream_count+noninterleaved_count &&
3349            delta_dts_max > 20*AV_TIME_BASE) {
3350             av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3351             flush = 1;
3352         }
3353     }
3354     if(stream_count && flush){
3355         pktl= s->packet_buffer;
3356         *out= pktl->pkt;
3357
3358         s->packet_buffer= pktl->next;
3359         if(!s->packet_buffer)
3360             s->packet_buffer_end= NULL;
3361
3362         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3363             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3364         av_freep(&pktl);
3365         return 1;
3366     }else{
3367         av_init_packet(out);
3368         return 0;
3369     }
3370 }
3371
3372 /**
3373  * Interleave an AVPacket correctly so it can be muxed.
3374  * @param out the interleaved packet will be output here
3375  * @param in the input packet
3376  * @param flush 1 if no further packets are available as input and all
3377  *              remaining packets should be output
3378  * @return 1 if a packet was output, 0 if no packet could be output,
3379  *         < 0 if an error occurred
3380  */
3381 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3382     if(s->oformat->interleave_packet)
3383         return s->oformat->interleave_packet(s, out, in, flush);
3384     else
3385         return av_interleave_packet_per_dts(s, out, in, flush);
3386 }
3387
3388 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3389     AVStream *st= s->streams[ pkt->stream_index];
3390     int ret;
3391
3392     //FIXME/XXX/HACK drop zero sized packets
3393     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3394         return 0;
3395
3396     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3397             pkt->size, pkt->dts, pkt->pts);
3398     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3399         return ret;
3400
3401     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3402         return AVERROR(EINVAL);
3403
3404     for(;;){
3405         AVPacket opkt;
3406         int ret= interleave_packet(s, &opkt, pkt, 0);
3407         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3408             return ret;
3409
3410         ret= s->oformat->write_packet(s, &opkt);
3411         if (ret >= 0)
3412             s->streams[opkt.stream_index]->nb_frames++;
3413
3414         av_free_packet(&opkt);
3415         pkt= NULL;
3416
3417         if(ret<0)
3418             return ret;
3419         if(s->pb && s->pb->error)
3420             return s->pb->error;
3421     }
3422 }
3423
3424 int av_write_trailer(AVFormatContext *s)
3425 {
3426     int ret, i;
3427
3428     for(;;){
3429         AVPacket pkt;
3430         ret= interleave_packet(s, &pkt, NULL, 1);
3431         if(ret<0) //FIXME cleanup needed for ret<0 ?
3432             goto fail;
3433         if(!ret)
3434             break;
3435
3436         ret= s->oformat->write_packet(s, &pkt);
3437         if (ret >= 0)
3438             s->streams[pkt.stream_index]->nb_frames++;
3439
3440         av_free_packet(&pkt);
3441
3442         if(ret<0)
3443             goto fail;
3444         if(s->pb && s->pb->error)
3445             goto fail;
3446     }
3447
3448     if(s->oformat->write_trailer)
3449         ret = s->oformat->write_trailer(s);
3450 fail:
3451     if(ret == 0)
3452        ret = s->pb ? s->pb->error : 0;
3453     for(i=0;i<s->nb_streams;i++) {
3454         av_freep(&s->streams[i]->priv_data);
3455         av_freep(&s->streams[i]->index_entries);
3456     }
3457     if (s->iformat && s->iformat->priv_class)
3458         av_opt_free(s->priv_data);
3459     av_freep(&s->priv_data);
3460     return ret;
3461 }
3462
3463 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3464                             int64_t *dts, int64_t *wall)
3465 {
3466     if (!s->oformat || !s->oformat->get_output_timestamp)
3467         return AVERROR(ENOSYS);
3468     s->oformat->get_output_timestamp(s, stream, dts, wall);
3469     return 0;
3470 }
3471
3472 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3473 {
3474     int i, j;
3475     AVProgram *program=NULL;
3476     void *tmp;
3477
3478     if (idx >= ac->nb_streams) {
3479         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3480         return;
3481     }
3482
3483     for(i=0; i<ac->nb_programs; i++){
3484         if(ac->programs[i]->id != progid)
3485             continue;
3486         program = ac->programs[i];
3487         for(j=0; j<program->nb_stream_indexes; j++)
3488             if(program->stream_index[j] == idx)
3489                 return;
3490
3491         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3492         if(!tmp)
3493             return;
3494         program->stream_index = tmp;
3495         program->stream_index[program->nb_stream_indexes++] = idx;
3496         return;
3497     }
3498 }
3499
3500 static void print_fps(double d, const char *postfix){
3501     uint64_t v= lrintf(d*100);
3502     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3503     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3504     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3505 }
3506
3507 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3508 {
3509     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3510         AVDictionaryEntry *tag=NULL;
3511
3512         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3513         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3514             if(strcmp("language", tag->key)){
3515                 char tmp[256];
3516                 int i;
3517                 av_strlcpy(tmp, tag->value, sizeof(tmp));
3518                 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3519                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tmp);
3520             }
3521         }
3522     }
3523 }
3524
3525 /* "user interface" functions */
3526 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3527 {
3528     char buf[256];
3529     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3530     AVStream *st = ic->streams[i];
3531     int g = av_gcd(st->time_base.num, st->time_base.den);
3532     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3533     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3534     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3535     /* the pid is an important information, so we display it */
3536     /* XXX: add a generic system */
3537     if (flags & AVFMT_SHOW_IDS)
3538         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3539     if (lang)
3540         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3541     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3542     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3543     if (st->sample_aspect_ratio.num && // default
3544         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3545         AVRational display_aspect_ratio;
3546         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3547                   st->codec->width*st->sample_aspect_ratio.num,
3548                   st->codec->height*st->sample_aspect_ratio.den,
3549                   1024*1024);
3550         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3551                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3552                  display_aspect_ratio.num, display_aspect_ratio.den);
3553     }
3554     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3555         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3556             print_fps(av_q2d(st->avg_frame_rate), "fps");
3557         if(st->r_frame_rate.den && st->r_frame_rate.num)
3558             print_fps(av_q2d(st->r_frame_rate), "tbr");
3559         if(st->time_base.den && st->time_base.num)
3560             print_fps(1/av_q2d(st->time_base), "tbn");
3561         if(st->codec->time_base.den && st->codec->time_base.num)
3562             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3563     }
3564     if (st->disposition & AV_DISPOSITION_DEFAULT)
3565         av_log(NULL, AV_LOG_INFO, " (default)");
3566     if (st->disposition & AV_DISPOSITION_DUB)
3567         av_log(NULL, AV_LOG_INFO, " (dub)");
3568     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3569         av_log(NULL, AV_LOG_INFO, " (original)");
3570     if (st->disposition & AV_DISPOSITION_COMMENT)
3571         av_log(NULL, AV_LOG_INFO, " (comment)");
3572     if (st->disposition & AV_DISPOSITION_LYRICS)
3573         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3574     if (st->disposition & AV_DISPOSITION_KARAOKE)
3575         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3576     if (st->disposition & AV_DISPOSITION_FORCED)
3577         av_log(NULL, AV_LOG_INFO, " (forced)");
3578     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3579         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3580     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3581         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3582     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3583         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3584     av_log(NULL, AV_LOG_INFO, "\n");
3585     dump_metadata(NULL, st->metadata, "    ");
3586 }
3587
3588 #if FF_API_DUMP_FORMAT
3589 void dump_format(AVFormatContext *ic,
3590                  int index,
3591                  const char *url,
3592                  int is_output)
3593 {
3594     av_dump_format(ic, index, url, is_output);
3595 }
3596 #endif
3597
3598 void av_dump_format(AVFormatContext *ic,
3599                     int index,
3600                     const char *url,
3601                     int is_output)
3602 {
3603     int i;
3604     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3605     if (ic->nb_streams && !printed)
3606         return;
3607
3608     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3609             is_output ? "Output" : "Input",
3610             index,
3611             is_output ? ic->oformat->name : ic->iformat->name,
3612             is_output ? "to" : "from", url);
3613     dump_metadata(NULL, ic->metadata, "  ");
3614     if (!is_output) {
3615         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3616         if (ic->duration != AV_NOPTS_VALUE) {
3617             int hours, mins, secs, us;
3618             secs = ic->duration / AV_TIME_BASE;
3619             us = ic->duration % AV_TIME_BASE;
3620             mins = secs / 60;
3621             secs %= 60;
3622             hours = mins / 60;
3623             mins %= 60;
3624             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3625                    (100 * us) / AV_TIME_BASE);
3626         } else {
3627             av_log(NULL, AV_LOG_INFO, "N/A");
3628         }
3629         if (ic->start_time != AV_NOPTS_VALUE) {
3630             int secs, us;
3631             av_log(NULL, AV_LOG_INFO, ", start: ");
3632             secs = ic->start_time / AV_TIME_BASE;
3633             us = abs(ic->start_time % AV_TIME_BASE);
3634             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3635                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3636         }
3637         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3638         if (ic->bit_rate) {
3639             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3640         } else {
3641             av_log(NULL, AV_LOG_INFO, "N/A");
3642         }
3643         av_log(NULL, AV_LOG_INFO, "\n");
3644     }
3645     for (i = 0; i < ic->nb_chapters; i++) {
3646         AVChapter *ch = ic->chapters[i];
3647         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3648         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3649         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3650
3651         dump_metadata(NULL, ch->metadata, "    ");
3652     }
3653     if(ic->nb_programs) {
3654         int j, k, total = 0;
3655         for(j=0; j<ic->nb_programs; j++) {
3656             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3657                                                   "name", NULL, 0);
3658             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3659                    name ? name->value : "");
3660             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3661             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3662                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3663                 printed[ic->programs[j]->stream_index[k]] = 1;
3664             }
3665             total += ic->programs[j]->nb_stream_indexes;
3666         }
3667         if (total < ic->nb_streams)
3668             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3669     }
3670     for(i=0;i<ic->nb_streams;i++)
3671         if (!printed[i])
3672             dump_stream_format(ic, i, index, is_output);
3673
3674     av_free(printed);
3675 }
3676
3677 int64_t av_gettime(void)
3678 {
3679     struct timeval tv;
3680     gettimeofday(&tv,NULL);
3681     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3682 }
3683
3684 uint64_t ff_ntp_time(void)
3685 {
3686   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3687 }
3688
3689 #if FF_API_PARSE_DATE
3690 #include "libavutil/parseutils.h"
3691
3692 int64_t parse_date(const char *timestr, int duration)
3693 {
3694     int64_t timeval;
3695     av_parse_time(&timeval, timestr, duration);
3696     return timeval;
3697 }
3698 #endif
3699
3700 #if FF_API_FIND_INFO_TAG
3701 #include "libavutil/parseutils.h"
3702
3703 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3704 {
3705     return av_find_info_tag(arg, arg_size, tag1, info);
3706 }
3707 #endif
3708
3709 int av_get_frame_filename(char *buf, int buf_size,
3710                           const char *path, int number)
3711 {
3712     const char *p;
3713     char *q, buf1[20], c;
3714     int nd, len, percentd_found;
3715
3716     q = buf;
3717     p = path;
3718     percentd_found = 0;
3719     for(;;) {
3720         c = *p++;
3721         if (c == '\0')
3722             break;
3723         if (c == '%') {
3724             do {
3725                 nd = 0;
3726                 while (isdigit(*p)) {
3727                     nd = nd * 10 + *p++ - '0';
3728                 }
3729                 c = *p++;
3730             } while (isdigit(c));
3731
3732             switch(c) {
3733             case '%':
3734                 goto addchar;
3735             case 'd':
3736                 if (percentd_found)
3737                     goto fail;
3738                 percentd_found = 1;
3739                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3740                 len = strlen(buf1);
3741                 if ((q - buf + len) > buf_size - 1)
3742                     goto fail;
3743                 memcpy(q, buf1, len);
3744                 q += len;
3745                 break;
3746             default:
3747                 goto fail;
3748             }
3749         } else {
3750         addchar:
3751             if ((q - buf) < buf_size - 1)
3752                 *q++ = c;
3753         }
3754     }
3755     if (!percentd_found)
3756         goto fail;
3757     *q = '\0';
3758     return 0;
3759  fail:
3760     *q = '\0';
3761     return -1;
3762 }
3763
3764 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3765 {
3766     int len, i, j, c;
3767 #undef fprintf
3768 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3769
3770     for(i=0;i<size;i+=16) {
3771         len = size - i;
3772         if (len > 16)
3773             len = 16;
3774         PRINT("%08x ", i);
3775         for(j=0;j<16;j++) {
3776             if (j < len)
3777                 PRINT(" %02x", buf[i+j]);
3778             else
3779                 PRINT("   ");
3780         }
3781         PRINT(" ");
3782         for(j=0;j<len;j++) {
3783             c = buf[i+j];
3784             if (c < ' ' || c > '~')
3785                 c = '.';
3786             PRINT("%c", c);
3787         }
3788         PRINT("\n");
3789     }
3790 #undef PRINT
3791 }
3792
3793 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3794 {
3795     hex_dump_internal(NULL, f, 0, buf, size);
3796 }
3797
3798 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3799 {
3800     hex_dump_internal(avcl, NULL, level, buf, size);
3801 }
3802
3803 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3804 {
3805 #undef fprintf
3806 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3807     PRINT("stream #%d:\n", pkt->stream_index);
3808     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3809     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3810     /* DTS is _always_ valid after av_read_frame() */
3811     PRINT("  dts=");
3812     if (pkt->dts == AV_NOPTS_VALUE)
3813         PRINT("N/A");
3814     else
3815         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3816     /* PTS may not be known if B-frames are present. */
3817     PRINT("  pts=");
3818     if (pkt->pts == AV_NOPTS_VALUE)
3819         PRINT("N/A");
3820     else
3821         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3822     PRINT("\n");
3823     PRINT("  size=%d\n", pkt->size);
3824 #undef PRINT
3825     if (dump_payload)
3826         av_hex_dump(f, pkt->data, pkt->size);
3827 }
3828
3829 #if FF_API_PKT_DUMP
3830 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3831 {
3832     AVRational tb = { 1, AV_TIME_BASE };
3833     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3834 }
3835 #endif
3836
3837 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3838 {
3839     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3840 }
3841
3842 #if FF_API_PKT_DUMP
3843 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3844 {
3845     AVRational tb = { 1, AV_TIME_BASE };
3846     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3847 }
3848 #endif
3849
3850 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3851                       AVStream *st)
3852 {
3853     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3854 }
3855
3856 void av_url_split(char *proto, int proto_size,
3857                   char *authorization, int authorization_size,
3858                   char *hostname, int hostname_size,
3859                   int *port_ptr,
3860                   char *path, int path_size,
3861                   const char *url)
3862 {
3863     const char *p, *ls, *at, *col, *brk;
3864
3865     if (port_ptr)               *port_ptr = -1;
3866     if (proto_size > 0)         proto[0] = 0;
3867     if (authorization_size > 0) authorization[0] = 0;
3868     if (hostname_size > 0)      hostname[0] = 0;
3869     if (path_size > 0)          path[0] = 0;
3870
3871     /* parse protocol */
3872     if ((p = strchr(url, ':'))) {
3873         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3874         p++; /* skip ':' */
3875         if (*p == '/') p++;
3876         if (*p == '/') p++;
3877     } else {
3878         /* no protocol means plain filename */
3879         av_strlcpy(path, url, path_size);
3880         return;
3881     }
3882
3883     /* separate path from hostname */
3884     ls = strchr(p, '/');
3885     if(!ls)
3886         ls = strchr(p, '?');
3887     if(ls)
3888         av_strlcpy(path, ls, path_size);
3889     else
3890         ls = &p[strlen(p)]; // XXX
3891
3892     /* the rest is hostname, use that to parse auth/port */
3893     if (ls != p) {
3894         /* authorization (user[:pass]@hostname) */
3895         if ((at = strchr(p, '@')) && at < ls) {
3896             av_strlcpy(authorization, p,
3897                        FFMIN(authorization_size, at + 1 - p));
3898             p = at + 1; /* skip '@' */
3899         }
3900
3901         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3902             /* [host]:port */
3903             av_strlcpy(hostname, p + 1,
3904                        FFMIN(hostname_size, brk - p));
3905             if (brk[1] == ':' && port_ptr)
3906                 *port_ptr = atoi(brk + 2);
3907         } else if ((col = strchr(p, ':')) && col < ls) {
3908             av_strlcpy(hostname, p,
3909                        FFMIN(col + 1 - p, hostname_size));
3910             if (port_ptr) *port_ptr = atoi(col + 1);
3911         } else
3912             av_strlcpy(hostname, p,
3913                        FFMIN(ls + 1 - p, hostname_size));
3914     }
3915 }
3916
3917 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3918 {
3919     int i;
3920     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3921                                            '4', '5', '6', '7',
3922                                            '8', '9', 'A', 'B',
3923                                            'C', 'D', 'E', 'F' };
3924     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3925                                            '4', '5', '6', '7',
3926                                            '8', '9', 'a', 'b',
3927                                            'c', 'd', 'e', 'f' };
3928     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3929
3930     for(i = 0; i < s; i++) {
3931         buff[i * 2]     = hex_table[src[i] >> 4];
3932         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3933     }
3934
3935     return buff;
3936 }
3937
3938 int ff_hex_to_data(uint8_t *data, const char *p)
3939 {
3940     int c, len, v;
3941
3942     len = 0;
3943     v = 1;
3944     for (;;) {
3945         p += strspn(p, SPACE_CHARS);
3946         if (*p == '\0')
3947             break;
3948         c = toupper((unsigned char) *p++);
3949         if (c >= '0' && c <= '9')
3950             c = c - '0';
3951         else if (c >= 'A' && c <= 'F')
3952             c = c - 'A' + 10;
3953         else
3954             break;
3955         v = (v << 4) | c;
3956         if (v & 0x100) {
3957             if (data)
3958                 data[len] = v;
3959             len++;
3960             v = 1;
3961         }
3962     }
3963     return len;
3964 }
3965
3966 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3967                      unsigned int pts_num, unsigned int pts_den)
3968 {
3969     AVRational new_tb;
3970     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3971         if(new_tb.num != pts_num)
3972             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3973     }else
3974         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3975
3976     if(new_tb.num <= 0 || new_tb.den <= 0) {
3977         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3978         return;
3979     }
3980     s->time_base = new_tb;
3981     s->pts_wrap_bits = pts_wrap_bits;
3982 }
3983
3984 int ff_url_join(char *str, int size, const char *proto,
3985                 const char *authorization, const char *hostname,
3986                 int port, const char *fmt, ...)
3987 {
3988 #if CONFIG_NETWORK
3989     struct addrinfo hints, *ai;
3990 #endif
3991
3992     str[0] = '\0';
3993     if (proto)
3994         av_strlcatf(str, size, "%s://", proto);
3995     if (authorization && authorization[0])
3996         av_strlcatf(str, size, "%s@", authorization);
3997 #if CONFIG_NETWORK && defined(AF_INET6)
3998     /* Determine if hostname is a numerical IPv6 address,
3999      * properly escape it within [] in that case. */
4000     memset(&hints, 0, sizeof(hints));
4001     hints.ai_flags = AI_NUMERICHOST;
4002     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4003         if (ai->ai_family == AF_INET6) {
4004             av_strlcat(str, "[", size);
4005             av_strlcat(str, hostname, size);
4006             av_strlcat(str, "]", size);
4007         } else {
4008             av_strlcat(str, hostname, size);
4009         }
4010         freeaddrinfo(ai);
4011     } else
4012 #endif
4013         /* Not an IPv6 address, just output the plain string. */
4014         av_strlcat(str, hostname, size);
4015
4016     if (port >= 0)
4017         av_strlcatf(str, size, ":%d", port);
4018     if (fmt) {
4019         va_list vl;
4020         int len = strlen(str);
4021
4022         va_start(vl, fmt);
4023         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4024         va_end(vl);
4025     }
4026     return strlen(str);
4027 }
4028
4029 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4030                      AVFormatContext *src)
4031 {
4032     AVPacket local_pkt;
4033
4034     local_pkt = *pkt;
4035     local_pkt.stream_index = dst_stream;
4036     if (pkt->pts != AV_NOPTS_VALUE)
4037         local_pkt.pts = av_rescale_q(pkt->pts,
4038                                      src->streams[pkt->stream_index]->time_base,
4039                                      dst->streams[dst_stream]->time_base);
4040     if (pkt->dts != AV_NOPTS_VALUE)
4041         local_pkt.dts = av_rescale_q(pkt->dts,
4042                                      src->streams[pkt->stream_index]->time_base,
4043                                      dst->streams[dst_stream]->time_base);
4044     return av_write_frame(dst, &local_pkt);
4045 }
4046
4047 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4048                         void *context)
4049 {
4050     const char *ptr = str;
4051
4052     /* Parse key=value pairs. */
4053     for (;;) {
4054         const char *key;
4055         char *dest = NULL, *dest_end;
4056         int key_len, dest_len = 0;
4057
4058         /* Skip whitespace and potential commas. */
4059         while (*ptr && (isspace(*ptr) || *ptr == ','))
4060             ptr++;
4061         if (!*ptr)
4062             break;
4063
4064         key = ptr;
4065
4066         if (!(ptr = strchr(key, '=')))
4067             break;
4068         ptr++;
4069         key_len = ptr - key;
4070
4071         callback_get_buf(context, key, key_len, &dest, &dest_len);
4072         dest_end = dest + dest_len - 1;
4073
4074         if (*ptr == '\"') {
4075             ptr++;
4076             while (*ptr && *ptr != '\"') {
4077                 if (*ptr == '\\') {
4078                     if (!ptr[1])
4079                         break;
4080                     if (dest && dest < dest_end)
4081                         *dest++ = ptr[1];
4082                     ptr += 2;
4083                 } else {
4084                     if (dest && dest < dest_end)
4085                         *dest++ = *ptr;
4086                     ptr++;
4087                 }
4088             }
4089             if (*ptr == '\"')
4090                 ptr++;
4091         } else {
4092             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4093                 if (dest && dest < dest_end)
4094                     *dest++ = *ptr;
4095         }
4096         if (dest)
4097             *dest = 0;
4098     }
4099 }
4100
4101 int ff_find_stream_index(AVFormatContext *s, int id)
4102 {
4103     int i;
4104     for (i = 0; i < s->nb_streams; i++) {
4105         if (s->streams[i]->id == id)
4106             return i;
4107     }
4108     return -1;
4109 }
4110
4111 void ff_make_absolute_url(char *buf, int size, const char *base,
4112                           const char *rel)
4113 {
4114     char *sep;
4115     /* Absolute path, relative to the current server */
4116     if (base && strstr(base, "://") && rel[0] == '/') {
4117         if (base != buf)
4118             av_strlcpy(buf, base, size);
4119         sep = strstr(buf, "://");
4120         if (sep) {
4121             sep += 3;
4122             sep = strchr(sep, '/');
4123             if (sep)
4124                 *sep = '\0';
4125         }
4126         av_strlcat(buf, rel, size);
4127         return;
4128     }
4129     /* If rel actually is an absolute url, just copy it */
4130     if (!base || strstr(rel, "://") || rel[0] == '/') {
4131         av_strlcpy(buf, rel, size);
4132         return;
4133     }
4134     if (base != buf)
4135         av_strlcpy(buf, base, size);
4136     /* Remove the file name from the base url */
4137     sep = strrchr(buf, '/');
4138     if (sep)
4139         sep[1] = '\0';
4140     else
4141         buf[0] = '\0';
4142     while (av_strstart(rel, "../", NULL) && sep) {
4143         /* Remove the path delimiter at the end */
4144         sep[0] = '\0';
4145         sep = strrchr(buf, '/');
4146         /* If the next directory name to pop off is "..", break here */
4147         if (!strcmp(sep ? &sep[1] : buf, "..")) {
4148             /* Readd the slash we just removed */
4149             av_strlcat(buf, "/", size);
4150             break;
4151         }
4152         /* Cut off the directory name */
4153         if (sep)
4154             sep[1] = '\0';
4155         else
4156             buf[0] = '\0';
4157         rel += 3;
4158     }
4159     av_strlcat(buf, rel, size);
4160 }
4161
4162 int64_t ff_iso8601_to_unix_time(const char *datestr)
4163 {
4164 #if HAVE_STRPTIME
4165     struct tm time1 = {0}, time2 = {0};
4166     char *ret1, *ret2;
4167     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4168     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4169     if (ret2 && !ret1)
4170         return av_timegm(&time2);
4171     else
4172         return av_timegm(&time1);
4173 #else
4174     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4175                                  "the date string.\n");
4176     return 0;
4177 #endif
4178 }
4179
4180 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4181 {
4182     if (ofmt) {
4183         if (ofmt->query_codec)
4184             return ofmt->query_codec(codec_id, std_compliance);
4185         else if (ofmt->codec_tag)
4186             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4187         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4188                  codec_id == ofmt->subtitle_codec)
4189             return 1;
4190     }
4191     return AVERROR_PATCHWELCOME;
4192 }
4193
4194 int avformat_network_init(void)
4195 {
4196 #if CONFIG_NETWORK
4197     int ret;
4198     ff_network_inited_globally = 1;
4199     if ((ret = ff_network_init()) < 0)
4200         return ret;
4201     ff_tls_init();
4202 #endif
4203     return 0;
4204 }
4205
4206 int avformat_network_deinit(void)
4207 {
4208 #if CONFIG_NETWORK
4209     ff_network_close();
4210     ff_tls_deinit();
4211 #endif
4212     return 0;
4213 }