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

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