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

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