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

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