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

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