libavformat/utils.c

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