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

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