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)
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_open(st->codec, codec);
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 int av_find_stream_info(AVFormatContext *ic)
2247 {
2248     int i, count, ret, read_size, j;
2249     AVStream *st;
2250     AVPacket pkt1, *pkt;
2251     int64_t old_offset = avio_tell(ic->pb);
2252
2253     for(i=0;i<ic->nb_streams;i++) {
2254         AVCodec *codec;
2255         st = ic->streams[i];
2256
2257         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2258             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2259 /*            if(!st->time_base.num)
2260                 st->time_base= */
2261             if(!st->codec->time_base.num)
2262                 st->codec->time_base= st->time_base;
2263         }
2264         //only for the split stuff
2265         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2266             st->parser = av_parser_init(st->codec->codec_id);
2267             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2268                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2269             }
2270         }
2271         assert(!st->codec->codec);
2272         codec = avcodec_find_decoder(st->codec->codec_id);
2273
2274         /* Ensure that subtitle_header is properly set. */
2275         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2276             && codec && !st->codec->codec)
2277             avcodec_open(st->codec, codec);
2278
2279         //try to just open decoders, in case this is enough to get parameters
2280         if(!has_codec_parameters(st->codec)){
2281             if (codec && !st->codec->codec)
2282                 avcodec_open(st->codec, codec);
2283         }
2284     }
2285
2286     for (i=0; i<ic->nb_streams; i++) {
2287         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2288     }
2289
2290     count = 0;
2291     read_size = 0;
2292     for(;;) {
2293         if(url_interrupt_cb()){
2294             ret= AVERROR_EXIT;
2295             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2296             break;
2297         }
2298
2299         /* check if one codec still needs to be handled */
2300         for(i=0;i<ic->nb_streams;i++) {
2301             int fps_analyze_framecount = 20;
2302
2303             st = ic->streams[i];
2304             if (!has_codec_parameters(st->codec))
2305                 break;
2306             /* if the timebase is coarse (like the usual millisecond precision
2307                of mkv), we need to analyze more frames to reliably arrive at
2308                the correct fps */
2309             if (av_q2d(st->time_base) > 0.0005)
2310                 fps_analyze_framecount *= 2;
2311             if (ic->fps_probe_size >= 0)
2312                 fps_analyze_framecount = ic->fps_probe_size;
2313             /* variable fps and no guess at the real fps */
2314             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2315                && st->info->duration_count < fps_analyze_framecount
2316                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2317                 break;
2318             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2319                 break;
2320             if(st->first_dts == AV_NOPTS_VALUE)
2321                 break;
2322         }
2323         if (i == ic->nb_streams) {
2324             /* NOTE: if the format has no header, then we need to read
2325                some packets to get most of the streams, so we cannot
2326                stop here */
2327             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2328                 /* if we found the info for all the codecs, we can stop */
2329                 ret = count;
2330                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2331                 break;
2332             }
2333         }
2334         /* we did not get all the codec info, but we read too much data */
2335         if (read_size >= ic->probesize) {
2336             ret = count;
2337             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2338             break;
2339         }
2340
2341         /* NOTE: a new stream can be added there if no header in file
2342            (AVFMTCTX_NOHEADER) */
2343         ret = av_read_frame_internal(ic, &pkt1);
2344         if (ret == AVERROR(EAGAIN))
2345             continue;
2346
2347         if (ret < 0) {
2348             /* EOF or error */
2349             ret = -1; /* we could not have all the codec parameters before EOF */
2350             for(i=0;i<ic->nb_streams;i++) {
2351                 st = ic->streams[i];
2352                 if (!has_codec_parameters(st->codec)){
2353                     char buf[256];
2354                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2355                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2356                 } else {
2357                     ret = 0;
2358                 }
2359             }
2360             break;
2361         }
2362
2363         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2364         if ((ret = av_dup_packet(pkt)) < 0)
2365             goto find_stream_info_err;
2366
2367         read_size += pkt->size;
2368
2369         st = ic->streams[pkt->stream_index];
2370         if (st->codec_info_nb_frames>1) {
2371             int64_t t;
2372             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) {
2373                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2374                 break;
2375             }
2376             st->info->codec_info_duration += pkt->duration;
2377         }
2378         {
2379             int64_t last = st->info->last_dts;
2380             int64_t duration= pkt->dts - last;
2381
2382             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2383                 double dur= duration * av_q2d(st->time_base);
2384
2385 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2386 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2387                 if (st->info->duration_count < 2)
2388                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2389                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2390                     int framerate= get_std_framerate(i);
2391                     int ticks= lrintf(dur*framerate/(1001*12));
2392                     double error= dur - ticks*1001*12/(double)framerate;
2393                     st->info->duration_error[i] += error*error;
2394                 }
2395                 st->info->duration_count++;
2396                 // ignore the first 4 values, they might have some random jitter
2397                 if (st->info->duration_count > 3)
2398                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2399             }
2400             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2401                 st->info->last_dts = pkt->dts;
2402         }
2403         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2404             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2405             if(i){
2406                 st->codec->extradata_size= i;
2407                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2408                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2409                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2410             }
2411         }
2412
2413         /* if still no information, we try to open the codec and to
2414            decompress the frame. We try to avoid that in most cases as
2415            it takes longer and uses more memory. For MPEG-4, we need to
2416            decompress for QuickTime.
2417
2418            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2419            least one frame of codec data, this makes sure the codec initializes
2420            the channel configuration and does not only trust the values from the container.
2421         */
2422         if (!has_codec_parameters(st->codec) ||
2423             !has_decode_delay_been_guessed(st) ||
2424             (st->codec->codec &&
2425              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))
2426             try_decode_frame(st, pkt);
2427
2428         st->codec_info_nb_frames++;
2429         count++;
2430     }
2431
2432     // close codecs which were opened in try_decode_frame()
2433     for(i=0;i<ic->nb_streams;i++) {
2434         st = ic->streams[i];
2435         if(st->codec->codec)
2436             avcodec_close(st->codec);
2437     }
2438     for(i=0;i<ic->nb_streams;i++) {
2439         st = ic->streams[i];
2440         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2441             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2442                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2443                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2444         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2445             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2446                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2447                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2448                     st->codec->codec_tag= tag;
2449             }
2450
2451             // the check for tb_unreliable() is not completely correct, since this is not about handling
2452             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2453             // ipmovie.c produces.
2454             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)
2455                 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);
2456             if (st->info->duration_count && !st->r_frame_rate.num
2457                && tb_unreliable(st->codec) /*&&
2458                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2459                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2460                 int num = 0;
2461                 double best_error= 2*av_q2d(st->time_base);
2462                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2463
2464                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2465                     double error = st->info->duration_error[j] * get_std_framerate(j);
2466 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2467 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2468                     if(error < best_error){
2469                         best_error= error;
2470                         num = get_std_framerate(j);
2471                     }
2472                 }
2473                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2474                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2475                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2476             }
2477
2478             if (!st->r_frame_rate.num){
2479                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2480                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2481                     st->r_frame_rate.num = st->codec->time_base.den;
2482                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2483                 }else{
2484                     st->r_frame_rate.num = st->time_base.den;
2485                     st->r_frame_rate.den = st->time_base.num;
2486                 }
2487             }
2488         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2489             if(!st->codec->bits_per_coded_sample)
2490                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2491             // set stream disposition based on audio service type
2492             switch (st->codec->audio_service_type) {
2493             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2494                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2495             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2496                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2497             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2498                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2499             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2500                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2501             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2502                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2503             }
2504         }
2505     }
2506
2507     av_estimate_timings(ic, old_offset);
2508
2509     compute_chapters_end(ic);
2510
2511 #if 0
2512     /* correct DTS for B-frame streams with no timestamps */
2513     for(i=0;i<ic->nb_streams;i++) {
2514         st = ic->streams[i];
2515         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2516             if(b-frames){
2517                 ppktl = &ic->packet_buffer;
2518                 while(ppkt1){
2519                     if(ppkt1->stream_index != i)
2520                         continue;
2521                     if(ppkt1->pkt->dts < 0)
2522                         break;
2523                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2524                         break;
2525                     ppkt1->pkt->dts -= delta;
2526                     ppkt1= ppkt1->next;
2527                 }
2528                 if(ppkt1)
2529                     continue;
2530                 st->cur_dts -= delta;
2531             }
2532         }
2533     }
2534 #endif
2535
2536  find_stream_info_err:
2537     for (i=0; i < ic->nb_streams; i++)
2538         av_freep(&ic->streams[i]->info);
2539     return ret;
2540 }
2541
2542 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2543 {
2544     int i, j;
2545
2546     for (i = 0; i < ic->nb_programs; i++)
2547         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2548             if (ic->programs[i]->stream_index[j] == s)
2549                 return ic->programs[i];
2550     return NULL;
2551 }
2552
2553 int av_find_best_stream(AVFormatContext *ic,
2554                         enum AVMediaType type,
2555                         int wanted_stream_nb,
2556                         int related_stream,
2557                         AVCodec **decoder_ret,
2558                         int flags)
2559 {
2560     int i, nb_streams = ic->nb_streams;
2561     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2562     unsigned *program = NULL;
2563     AVCodec *decoder = NULL, *best_decoder = NULL;
2564
2565     if (related_stream >= 0 && wanted_stream_nb < 0) {
2566         AVProgram *p = find_program_from_stream(ic, related_stream);
2567         if (p) {
2568             program = p->stream_index;
2569             nb_streams = p->nb_stream_indexes;
2570         }
2571     }
2572     for (i = 0; i < nb_streams; i++) {
2573         int real_stream_index = program ? program[i] : i;
2574         AVStream *st = ic->streams[real_stream_index];
2575         AVCodecContext *avctx = st->codec;
2576         if (avctx->codec_type != type)
2577             continue;
2578         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2579             continue;
2580         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2581             continue;
2582         if (decoder_ret) {
2583             decoder = avcodec_find_decoder(st->codec->codec_id);
2584             if (!decoder) {
2585                 if (ret < 0)
2586                     ret = AVERROR_DECODER_NOT_FOUND;
2587                 continue;
2588             }
2589         }
2590         if (best_count >= st->codec_info_nb_frames)
2591             continue;
2592         best_count = st->codec_info_nb_frames;
2593         ret = real_stream_index;
2594         best_decoder = decoder;
2595         if (program && i == nb_streams - 1 && ret < 0) {
2596             program = NULL;
2597             nb_streams = ic->nb_streams;
2598             i = 0; /* no related stream found, try again with everything */
2599         }
2600     }
2601     if (decoder_ret)
2602         *decoder_ret = best_decoder;
2603     return ret;
2604 }
2605
2606 /*******************************************************/
2607
2608 int av_read_play(AVFormatContext *s)
2609 {
2610     if (s->iformat->read_play)
2611         return s->iformat->read_play(s);
2612     if (s->pb)
2613         return avio_pause(s->pb, 0);
2614     return AVERROR(ENOSYS);
2615 }
2616
2617 int av_read_pause(AVFormatContext *s)
2618 {
2619     if (s->iformat->read_pause)
2620         return s->iformat->read_pause(s);
2621     if (s->pb)
2622         return avio_pause(s->pb, 1);
2623     return AVERROR(ENOSYS);
2624 }
2625
2626 void av_close_input_stream(AVFormatContext *s)
2627 {
2628     flush_packet_queue(s);
2629     if (s->iformat->read_close)
2630         s->iformat->read_close(s);
2631     avformat_free_context(s);
2632 }
2633
2634 void avformat_free_context(AVFormatContext *s)
2635 {
2636     int i;
2637     AVStream *st;
2638
2639     av_opt_free(s);
2640     if (s->iformat && s->iformat->priv_class && s->priv_data)
2641         av_opt_free(s->priv_data);
2642
2643     for(i=0;i<s->nb_streams;i++) {
2644         /* free all data in a stream component */
2645         st = s->streams[i];
2646         if (st->parser) {
2647             av_parser_close(st->parser);
2648             av_free_packet(&st->cur_pkt);
2649         }
2650         av_dict_free(&st->metadata);
2651         av_free(st->index_entries);
2652         av_free(st->codec->extradata);
2653         av_free(st->codec->subtitle_header);
2654         av_free(st->codec);
2655         av_free(st->priv_data);
2656         av_free(st->info);
2657         av_free(st);
2658     }
2659     for(i=s->nb_programs-1; i>=0; i--) {
2660         av_dict_free(&s->programs[i]->metadata);
2661         av_freep(&s->programs[i]->stream_index);
2662         av_freep(&s->programs[i]);
2663     }
2664     av_freep(&s->programs);
2665     av_freep(&s->priv_data);
2666     while(s->nb_chapters--) {
2667         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2668         av_free(s->chapters[s->nb_chapters]);
2669     }
2670     av_freep(&s->chapters);
2671     av_dict_free(&s->metadata);
2672     av_freep(&s->streams);
2673     av_free(s);
2674 }
2675
2676 void av_close_input_file(AVFormatContext *s)
2677 {
2678     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2679                        NULL : s->pb;
2680     av_close_input_stream(s);
2681     if (pb)
2682         avio_close(pb);
2683 }
2684
2685 AVStream *av_new_stream(AVFormatContext *s, int id)
2686 {
2687     AVStream *st;
2688     int i;
2689     AVStream **streams;
2690
2691     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2692         return NULL;
2693     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2694     if (!streams)
2695         return NULL;
2696     s->streams = streams;
2697
2698     st = av_mallocz(sizeof(AVStream));
2699     if (!st)
2700         return NULL;
2701     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2702         av_free(st);
2703         return NULL;
2704     }
2705
2706     st->codec= avcodec_alloc_context();
2707     if (s->iformat) {
2708         /* no default bitrate if decoding */
2709         st->codec->bit_rate = 0;
2710     }
2711     st->index = s->nb_streams;
2712     st->id = id;
2713     st->start_time = AV_NOPTS_VALUE;
2714     st->duration = AV_NOPTS_VALUE;
2715         /* we set the current DTS to 0 so that formats without any timestamps
2716            but durations get some timestamps, formats with some unknown
2717            timestamps have their first few packets buffered and the
2718            timestamps corrected before they are returned to the user */
2719     st->cur_dts = 0;
2720     st->first_dts = AV_NOPTS_VALUE;
2721     st->probe_packets = MAX_PROBE_PACKETS;
2722
2723     /* default pts setting is MPEG-like */
2724     av_set_pts_info(st, 33, 1, 90000);
2725     st->last_IP_pts = AV_NOPTS_VALUE;
2726     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2727         st->pts_buffer[i]= AV_NOPTS_VALUE;
2728     st->reference_dts = AV_NOPTS_VALUE;
2729
2730     st->sample_aspect_ratio = (AVRational){0,1};
2731
2732     s->streams[s->nb_streams++] = st;
2733     return st;
2734 }
2735
2736 AVProgram *av_new_program(AVFormatContext *ac, int id)
2737 {
2738     AVProgram *program=NULL;
2739     int i;
2740
2741     av_dlog(ac, "new_program: id=0x%04x\n", id);
2742
2743     for(i=0; i<ac->nb_programs; i++)
2744         if(ac->programs[i]->id == id)
2745             program = ac->programs[i];
2746
2747     if(!program){
2748         program = av_mallocz(sizeof(AVProgram));
2749         if (!program)
2750             return NULL;
2751         dynarray_add(&ac->programs, &ac->nb_programs, program);
2752         program->discard = AVDISCARD_NONE;
2753     }
2754     program->id = id;
2755
2756     return program;
2757 }
2758
2759 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2760 {
2761     AVChapter *chapter = NULL;
2762     int i;
2763
2764     for(i=0; i<s->nb_chapters; i++)
2765         if(s->chapters[i]->id == id)
2766             chapter = s->chapters[i];
2767
2768     if(!chapter){
2769         chapter= av_mallocz(sizeof(AVChapter));
2770         if(!chapter)
2771             return NULL;
2772         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2773     }
2774     av_dict_set(&chapter->metadata, "title", title, 0);
2775     chapter->id    = id;
2776     chapter->time_base= time_base;
2777     chapter->start = start;
2778     chapter->end   = end;
2779
2780     return chapter;
2781 }
2782
2783 /************************************************************/
2784 /* output media file */
2785
2786 #if FF_API_FORMAT_PARAMETERS
2787 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2788 {
2789     if (s->oformat->priv_data_size > 0) {
2790         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2791         if (!s->priv_data)
2792             return AVERROR(ENOMEM);
2793         if (s->oformat->priv_class) {
2794             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2795             av_opt_set_defaults(s->priv_data);
2796         }
2797     } else
2798         s->priv_data = NULL;
2799
2800     return 0;
2801 }
2802 #endif
2803
2804 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2805                                    const char *format, const char *filename)
2806 {
2807     AVFormatContext *s = avformat_alloc_context();
2808     int ret = 0;
2809
2810     *avctx = NULL;
2811     if (!s)
2812         goto nomem;
2813
2814     if (!oformat) {
2815         if (format) {
2816             oformat = av_guess_format(format, NULL, NULL);
2817             if (!oformat) {
2818                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2819                 ret = AVERROR(EINVAL);
2820                 goto error;
2821             }
2822         } else {
2823             oformat = av_guess_format(NULL, filename, NULL);
2824             if (!oformat) {
2825                 ret = AVERROR(EINVAL);
2826                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2827                        filename);
2828                 goto error;
2829             }
2830         }
2831     }
2832
2833     s->oformat = oformat;
2834     if (s->oformat->priv_data_size > 0) {
2835         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2836         if (!s->priv_data)
2837             goto nomem;
2838         if (s->oformat->priv_class) {
2839             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2840             av_opt_set_defaults(s->priv_data);
2841         }
2842     } else
2843         s->priv_data = NULL;
2844
2845     if (filename)
2846         av_strlcpy(s->filename, filename, sizeof(s->filename));
2847     *avctx = s;
2848     return 0;
2849 nomem:
2850     av_log(s, AV_LOG_ERROR, "Out of memory\n");
2851     ret = AVERROR(ENOMEM);
2852 error:
2853     avformat_free_context(s);
2854     return ret;
2855 }
2856
2857 #if FF_API_ALLOC_OUTPUT_CONTEXT
2858 AVFormatContext *avformat_alloc_output_context(const char *format,
2859                                                AVOutputFormat *oformat, const char *filename)
2860 {
2861     AVFormatContext *avctx;
2862     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2863     return ret < 0 ? NULL : avctx;
2864 }
2865 #endif
2866
2867 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2868 {
2869     const AVCodecTag *avctag;
2870     int n;
2871     enum CodecID id = CODEC_ID_NONE;
2872     unsigned int tag = 0;
2873
2874     /**
2875      * Check that tag + id is in the table
2876      * If neither is in the table -> OK
2877      * If tag is in the table with another id -> FAIL
2878      * If id is in the table with another tag -> FAIL unless strict < normal
2879      */
2880     for (n = 0; s->oformat->codec_tag[n]; n++) {
2881         avctag = s->oformat->codec_tag[n];
2882         while (avctag->id != CODEC_ID_NONE) {
2883             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2884                 id = avctag->id;
2885                 if (id == st->codec->codec_id)
2886                     return 1;
2887             }
2888             if (avctag->id == st->codec->codec_id)
2889                 tag = avctag->tag;
2890             avctag++;
2891         }
2892     }
2893     if (id != CODEC_ID_NONE)
2894         return 0;
2895     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2896         return 0;
2897     return 1;
2898 }
2899
2900 #if FF_API_FORMAT_PARAMETERS
2901 int av_write_header(AVFormatContext *s)
2902 {
2903     return avformat_write_header(s, NULL);
2904 }
2905 #endif
2906
2907 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2908 {
2909     int ret = 0, i;
2910     AVStream *st;
2911     AVDictionary *tmp = NULL;
2912
2913     if (options)
2914         av_dict_copy(&tmp, *options, 0);
2915     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2916         goto fail;
2917
2918     // some sanity checks
2919     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2920         av_log(s, AV_LOG_ERROR, "no streams\n");
2921         ret = AVERROR(EINVAL);
2922         goto fail;
2923     }
2924
2925     for(i=0;i<s->nb_streams;i++) {
2926         st = s->streams[i];
2927
2928         switch (st->codec->codec_type) {
2929         case AVMEDIA_TYPE_AUDIO:
2930             if(st->codec->sample_rate<=0){
2931                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2932                 ret = AVERROR(EINVAL);
2933                 goto fail;
2934             }
2935             if(!st->codec->block_align)
2936                 st->codec->block_align = st->codec->channels *
2937                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2938             break;
2939         case AVMEDIA_TYPE_VIDEO:
2940             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2941                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2942                 ret = AVERROR(EINVAL);
2943                 goto fail;
2944             }
2945             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2946                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2947                 ret = AVERROR(EINVAL);
2948                 goto fail;
2949             }
2950             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2951                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2952                 ret = AVERROR(EINVAL);
2953                 goto fail;
2954             }
2955             break;
2956         }
2957
2958         if(s->oformat->codec_tag){
2959             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)){
2960                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2961                 st->codec->codec_tag= 0;
2962             }
2963             if(st->codec->codec_tag){
2964                 if (!validate_codec_tag(s, st)) {
2965                     char tagbuf[32];
2966                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2967                     av_log(s, AV_LOG_ERROR,
2968                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2969                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2970                     ret = AVERROR_INVALIDDATA;
2971                     goto fail;
2972                 }
2973             }else
2974                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2975         }
2976
2977         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2978             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2979           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2980     }
2981
2982     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2983         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2984         if (!s->priv_data) {
2985             ret = AVERROR(ENOMEM);
2986             goto fail;
2987         }
2988         if (s->oformat->priv_class) {
2989             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2990             av_opt_set_defaults(s->priv_data);
2991             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2992                 goto fail;
2993         }
2994     }
2995
2996     /* set muxer identification string */
2997     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2998         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2999     }
3000
3001     if(s->oformat->write_header){
3002         ret = s->oformat->write_header(s);
3003         if (ret < 0)
3004             goto fail;
3005     }
3006
3007     /* init PTS generation */
3008     for(i=0;i<s->nb_streams;i++) {
3009         int64_t den = AV_NOPTS_VALUE;
3010         st = s->streams[i];
3011
3012         switch (st->codec->codec_type) {
3013         case AVMEDIA_TYPE_AUDIO:
3014             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3015             break;
3016         case AVMEDIA_TYPE_VIDEO:
3017             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3018             break;
3019         default:
3020             break;
3021         }
3022         if (den != AV_NOPTS_VALUE) {
3023             if (den <= 0) {
3024                 ret = AVERROR_INVALIDDATA;
3025                 goto fail;
3026             }
3027             av_frac_init(&st->pts, 0, 0, den);
3028         }
3029     }
3030
3031     if (options) {
3032         av_dict_free(options);
3033         *options = tmp;
3034     }
3035     return 0;
3036 fail:
3037     av_dict_free(&tmp);
3038     return ret;
3039 }
3040
3041 //FIXME merge with compute_pkt_fields
3042 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3043     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3044     int num, den, frame_size, i;
3045
3046     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3047             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3048
3049 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3050         return AVERROR(EINVAL);*/
3051
3052     /* duration field */
3053     if (pkt->duration == 0) {
3054         compute_frame_duration(&num, &den, st, NULL, pkt);
3055         if (den && num) {
3056             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3057         }
3058     }
3059
3060     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3061         pkt->pts= pkt->dts;
3062
3063     //XXX/FIXME this is a temporary hack until all encoders output pts
3064     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3065         pkt->dts=
3066 //        pkt->pts= st->cur_dts;
3067         pkt->pts= st->pts.val;
3068     }
3069
3070     //calculate dts from pts
3071     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3072         st->pts_buffer[0]= pkt->pts;
3073         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3074             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3075         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3076             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3077
3078         pkt->dts= st->pts_buffer[0];
3079     }
3080
3081     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)){
3082         av_log(s, AV_LOG_ERROR,
3083                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3084                st->index, st->cur_dts, pkt->dts);
3085         return AVERROR(EINVAL);
3086     }
3087     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3088         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3089         return AVERROR(EINVAL);
3090     }
3091
3092 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3093     st->cur_dts= pkt->dts;
3094     st->pts.val= pkt->dts;
3095
3096     /* update pts */
3097     switch (st->codec->codec_type) {
3098     case AVMEDIA_TYPE_AUDIO:
3099         frame_size = get_audio_frame_size(st->codec, pkt->size);
3100
3101         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3102            likely equal to the encoder delay, but it would be better if we
3103            had the real timestamps from the encoder */
3104         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3105             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3106         }
3107         break;
3108     case AVMEDIA_TYPE_VIDEO:
3109         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3110         break;
3111     default:
3112         break;
3113     }
3114     return 0;
3115 }
3116
3117 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3118 {
3119     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3120
3121     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3122         return ret;
3123
3124     ret= s->oformat->write_packet(s, pkt);
3125
3126     if (ret >= 0)
3127         s->streams[pkt->stream_index]->nb_frames++;
3128     return ret;
3129 }
3130
3131 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3132                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3133 {
3134     AVPacketList **next_point, *this_pktl;
3135
3136     this_pktl = av_mallocz(sizeof(AVPacketList));
3137     this_pktl->pkt= *pkt;
3138     pkt->destruct= NULL;             // do not free original but only the copy
3139     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3140
3141     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3142         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3143     }else
3144         next_point = &s->packet_buffer;
3145
3146     if(*next_point){
3147         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3148             while(!compare(s, &(*next_point)->pkt, pkt)){
3149                 next_point= &(*next_point)->next;
3150             }
3151             goto next_non_null;
3152         }else{
3153             next_point = &(s->packet_buffer_end->next);
3154         }
3155     }
3156     assert(!*next_point);
3157
3158     s->packet_buffer_end= this_pktl;
3159 next_non_null:
3160
3161     this_pktl->next= *next_point;
3162
3163     s->streams[pkt->stream_index]->last_in_packet_buffer=
3164     *next_point= this_pktl;
3165 }
3166
3167 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3168 {
3169     AVStream *st = s->streams[ pkt ->stream_index];
3170     AVStream *st2= s->streams[ next->stream_index];
3171     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3172                              st->time_base);
3173
3174     if (comp == 0)
3175         return pkt->stream_index < next->stream_index;
3176     return comp > 0;
3177 }
3178
3179 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3180     AVPacketList *pktl;
3181     int stream_count=0;
3182     int i;
3183
3184     if(pkt){
3185         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3186     }
3187
3188     for(i=0; i < s->nb_streams; i++)
3189         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3190
3191     if(stream_count && (s->nb_streams == stream_count || flush)){
3192         pktl= s->packet_buffer;
3193         *out= pktl->pkt;
3194
3195         s->packet_buffer= pktl->next;
3196         if(!s->packet_buffer)
3197             s->packet_buffer_end= NULL;
3198
3199         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3200             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3201         av_freep(&pktl);
3202         return 1;
3203     }else{
3204         av_init_packet(out);
3205         return 0;
3206     }
3207 }
3208
3209 /**
3210  * Interleave an AVPacket correctly so it can be muxed.
3211  * @param out the interleaved packet will be output here
3212  * @param in the input packet
3213  * @param flush 1 if no further packets are available as input and all
3214  *              remaining packets should be output
3215  * @return 1 if a packet was output, 0 if no packet could be output,
3216  *         < 0 if an error occurred
3217  */
3218 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3219     if(s->oformat->interleave_packet)
3220         return s->oformat->interleave_packet(s, out, in, flush);
3221     else
3222         return av_interleave_packet_per_dts(s, out, in, flush);
3223 }
3224
3225 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3226     AVStream *st= s->streams[ pkt->stream_index];
3227     int ret;
3228
3229     //FIXME/XXX/HACK drop zero sized packets
3230     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3231         return 0;
3232
3233     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3234             pkt->size, pkt->dts, pkt->pts);
3235     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3236         return ret;
3237
3238     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3239         return AVERROR(EINVAL);
3240
3241     for(;;){
3242         AVPacket opkt;
3243         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3244         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3245             return ret;
3246
3247         ret= s->oformat->write_packet(s, &opkt);
3248         if (ret >= 0)
3249             s->streams[opkt.stream_index]->nb_frames++;
3250
3251         av_free_packet(&opkt);
3252         pkt= NULL;
3253
3254         if(ret<0)
3255             return ret;
3256         if(url_ferror(s->pb))
3257             return url_ferror(s->pb);
3258     }
3259 }
3260
3261 int av_write_trailer(AVFormatContext *s)
3262 {
3263     int ret, i;
3264
3265     for(;;){
3266         AVPacket pkt;
3267         ret= av_interleave_packet(s, &pkt, NULL, 1);
3268         if(ret<0) //FIXME cleanup needed for ret<0 ?
3269             goto fail;
3270         if(!ret)
3271             break;
3272
3273         ret= s->oformat->write_packet(s, &pkt);
3274         if (ret >= 0)
3275             s->streams[pkt.stream_index]->nb_frames++;
3276
3277         av_free_packet(&pkt);
3278
3279         if(ret<0)
3280             goto fail;
3281         if(url_ferror(s->pb))
3282             goto fail;
3283     }
3284
3285     if(s->oformat->write_trailer)
3286         ret = s->oformat->write_trailer(s);
3287 fail:
3288     if(ret == 0)
3289        ret=url_ferror(s->pb);
3290     for(i=0;i<s->nb_streams;i++) {
3291         av_freep(&s->streams[i]->priv_data);
3292         av_freep(&s->streams[i]->index_entries);
3293     }
3294     if (s->iformat && s->iformat->priv_class)
3295         av_opt_free(s->priv_data);
3296     av_freep(&s->priv_data);
3297     return ret;
3298 }
3299
3300 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3301                             int64_t *dts, int64_t *wall)
3302 {
3303     if (!s->oformat || !s->oformat->get_output_timestamp)
3304         return AVERROR(ENOSYS);
3305     s->oformat->get_output_timestamp(s, stream, dts, wall);
3306     return 0;
3307 }
3308
3309 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3310 {
3311     int i, j;
3312     AVProgram *program=NULL;
3313     void *tmp;
3314
3315     if (idx >= ac->nb_streams) {
3316         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3317         return;
3318     }
3319
3320     for(i=0; i<ac->nb_programs; i++){
3321         if(ac->programs[i]->id != progid)
3322             continue;
3323         program = ac->programs[i];
3324         for(j=0; j<program->nb_stream_indexes; j++)
3325             if(program->stream_index[j] == idx)
3326                 return;
3327
3328         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3329         if(!tmp)
3330             return;
3331         program->stream_index = tmp;
3332         program->stream_index[program->nb_stream_indexes++] = idx;
3333         return;
3334     }
3335 }
3336
3337 static void print_fps(double d, const char *postfix){
3338     uint64_t v= lrintf(d*100);
3339     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3340     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3341     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3342 }
3343
3344 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3345 {
3346     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3347         AVDictionaryEntry *tag=NULL;
3348
3349         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3350         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3351             if(strcmp("language", tag->key)){
3352                 char tmp[256];
3353                 int i;
3354                 av_strlcpy(tmp, tag->value, sizeof(tmp));
3355                 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3356                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tmp);
3357             }
3358         }
3359     }
3360 }
3361
3362 /* "user interface" functions */
3363 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3364 {
3365     char buf[256];
3366     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3367     AVStream *st = ic->streams[i];
3368     int g = av_gcd(st->time_base.num, st->time_base.den);
3369     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3370     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3371     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3372     /* the pid is an important information, so we display it */
3373     /* XXX: add a generic system */
3374     if (flags & AVFMT_SHOW_IDS)
3375         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3376     if (lang)
3377         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3378     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3379     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3380     if (st->sample_aspect_ratio.num && // default
3381         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3382         AVRational display_aspect_ratio;
3383         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3384                   st->codec->width*st->sample_aspect_ratio.num,
3385                   st->codec->height*st->sample_aspect_ratio.den,
3386                   1024*1024);
3387         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3388                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3389                  display_aspect_ratio.num, display_aspect_ratio.den);
3390     }
3391     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3392         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3393             print_fps(av_q2d(st->avg_frame_rate), "fps");
3394         if(st->r_frame_rate.den && st->r_frame_rate.num)
3395             print_fps(av_q2d(st->r_frame_rate), "tbr");
3396         if(st->time_base.den && st->time_base.num)
3397             print_fps(1/av_q2d(st->time_base), "tbn");
3398         if(st->codec->time_base.den && st->codec->time_base.num)
3399             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3400     }
3401     if (st->disposition & AV_DISPOSITION_DEFAULT)
3402         av_log(NULL, AV_LOG_INFO, " (default)");
3403     if (st->disposition & AV_DISPOSITION_DUB)
3404         av_log(NULL, AV_LOG_INFO, " (dub)");
3405     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3406         av_log(NULL, AV_LOG_INFO, " (original)");
3407     if (st->disposition & AV_DISPOSITION_COMMENT)
3408         av_log(NULL, AV_LOG_INFO, " (comment)");
3409     if (st->disposition & AV_DISPOSITION_LYRICS)
3410         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3411     if (st->disposition & AV_DISPOSITION_KARAOKE)
3412         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3413     if (st->disposition & AV_DISPOSITION_FORCED)
3414         av_log(NULL, AV_LOG_INFO, " (forced)");
3415     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3416         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3417     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3418         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3419     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3420         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3421     av_log(NULL, AV_LOG_INFO, "\n");
3422     dump_metadata(NULL, st->metadata, "    ");
3423 }
3424
3425 #if FF_API_DUMP_FORMAT
3426 void dump_format(AVFormatContext *ic,
3427                  int index,
3428                  const char *url,
3429                  int is_output)
3430 {
3431     av_dump_format(ic, index, url, is_output);
3432 }
3433 #endif
3434
3435 void av_dump_format(AVFormatContext *ic,
3436                     int index,
3437                     const char *url,
3438                     int is_output)
3439 {
3440     int i;
3441     uint8_t *printed = av_mallocz(ic->nb_streams);
3442     if (ic->nb_streams && !printed)
3443         return;
3444
3445     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3446             is_output ? "Output" : "Input",
3447             index,
3448             is_output ? ic->oformat->name : ic->iformat->name,
3449             is_output ? "to" : "from", url);
3450     dump_metadata(NULL, ic->metadata, "  ");
3451     if (!is_output) {
3452         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3453         if (ic->duration != AV_NOPTS_VALUE) {
3454             int hours, mins, secs, us;
3455             secs = ic->duration / AV_TIME_BASE;
3456             us = ic->duration % AV_TIME_BASE;
3457             mins = secs / 60;
3458             secs %= 60;
3459             hours = mins / 60;
3460             mins %= 60;
3461             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3462                    (100 * us) / AV_TIME_BASE);
3463         } else {
3464             av_log(NULL, AV_LOG_INFO, "N/A");
3465         }
3466         if (ic->start_time != AV_NOPTS_VALUE) {
3467             int secs, us;
3468             av_log(NULL, AV_LOG_INFO, ", start: ");
3469             secs = ic->start_time / AV_TIME_BASE;
3470             us = abs(ic->start_time % AV_TIME_BASE);
3471             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3472                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3473         }
3474         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3475         if (ic->bit_rate) {
3476             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3477         } else {
3478             av_log(NULL, AV_LOG_INFO, "N/A");
3479         }
3480         av_log(NULL, AV_LOG_INFO, "\n");
3481     }
3482     for (i = 0; i < ic->nb_chapters; i++) {
3483         AVChapter *ch = ic->chapters[i];
3484         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3485         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3486         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3487
3488         dump_metadata(NULL, ch->metadata, "    ");
3489     }
3490     if(ic->nb_programs) {
3491         int j, k, total = 0;
3492         for(j=0; j<ic->nb_programs; j++) {
3493             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3494                                                   "name", NULL, 0);
3495             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3496                    name ? name->value : "");
3497             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3498             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3499                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3500                 printed[ic->programs[j]->stream_index[k]] = 1;
3501             }
3502             total += ic->programs[j]->nb_stream_indexes;
3503         }
3504         if (total < ic->nb_streams)
3505             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3506     }
3507     for(i=0;i<ic->nb_streams;i++)
3508         if (!printed[i])
3509             dump_stream_format(ic, i, index, is_output);
3510
3511     av_free(printed);
3512 }
3513
3514 int64_t av_gettime(void)
3515 {
3516     struct timeval tv;
3517     gettimeofday(&tv,NULL);
3518     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3519 }
3520
3521 uint64_t ff_ntp_time(void)
3522 {
3523   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3524 }
3525
3526 #if FF_API_PARSE_DATE
3527 #include "libavutil/parseutils.h"
3528
3529 int64_t parse_date(const char *timestr, int duration)
3530 {
3531     int64_t timeval;
3532     av_parse_time(&timeval, timestr, duration);
3533     return timeval;
3534 }
3535 #endif
3536
3537 #if FF_API_FIND_INFO_TAG
3538 #include "libavutil/parseutils.h"
3539
3540 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3541 {
3542     return av_find_info_tag(arg, arg_size, tag1, info);
3543 }
3544 #endif
3545
3546 int av_get_frame_filename(char *buf, int buf_size,
3547                           const char *path, int number)
3548 {
3549     const char *p;
3550     char *q, buf1[20], c;
3551     int nd, len, percentd_found;
3552
3553     q = buf;
3554     p = path;
3555     percentd_found = 0;
3556     for(;;) {
3557         c = *p++;
3558         if (c == '\0')
3559             break;
3560         if (c == '%') {
3561             do {
3562                 nd = 0;
3563                 while (isdigit(*p)) {
3564                     nd = nd * 10 + *p++ - '0';
3565                 }
3566                 c = *p++;
3567             } while (isdigit(c));
3568
3569             switch(c) {
3570             case '%':
3571                 goto addchar;
3572             case 'd':
3573                 if (percentd_found)
3574                     goto fail;
3575                 percentd_found = 1;
3576                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3577                 len = strlen(buf1);
3578                 if ((q - buf + len) > buf_size - 1)
3579                     goto fail;
3580                 memcpy(q, buf1, len);
3581                 q += len;
3582                 break;
3583             default:
3584                 goto fail;
3585             }
3586         } else {
3587         addchar:
3588             if ((q - buf) < buf_size - 1)
3589                 *q++ = c;
3590         }
3591     }
3592     if (!percentd_found)
3593         goto fail;
3594     *q = '\0';
3595     return 0;
3596  fail:
3597     *q = '\0';
3598     return -1;
3599 }
3600
3601 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3602 {
3603     int len, i, j, c;
3604 #undef fprintf
3605 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3606
3607     for(i=0;i<size;i+=16) {
3608         len = size - i;
3609         if (len > 16)
3610             len = 16;
3611         PRINT("%08x ", i);
3612         for(j=0;j<16;j++) {
3613             if (j < len)
3614                 PRINT(" %02x", buf[i+j]);
3615             else
3616                 PRINT("   ");
3617         }
3618         PRINT(" ");
3619         for(j=0;j<len;j++) {
3620             c = buf[i+j];
3621             if (c < ' ' || c > '~')
3622                 c = '.';
3623             PRINT("%c", c);
3624         }
3625         PRINT("\n");
3626     }
3627 #undef PRINT
3628 }
3629
3630 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3631 {
3632     hex_dump_internal(NULL, f, 0, buf, size);
3633 }
3634
3635 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3636 {
3637     hex_dump_internal(avcl, NULL, level, buf, size);
3638 }
3639
3640 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3641 {
3642 #undef fprintf
3643 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3644     PRINT("stream #%d:\n", pkt->stream_index);
3645     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3646     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3647     /* DTS is _always_ valid after av_read_frame() */
3648     PRINT("  dts=");
3649     if (pkt->dts == AV_NOPTS_VALUE)
3650         PRINT("N/A");
3651     else
3652         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3653     /* PTS may not be known if B-frames are present. */
3654     PRINT("  pts=");
3655     if (pkt->pts == AV_NOPTS_VALUE)
3656         PRINT("N/A");
3657     else
3658         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3659     PRINT("\n");
3660     PRINT("  size=%d\n", pkt->size);
3661 #undef PRINT
3662     if (dump_payload)
3663         av_hex_dump(f, pkt->data, pkt->size);
3664 }
3665
3666 #if FF_API_PKT_DUMP
3667 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3668 {
3669     AVRational tb = { 1, AV_TIME_BASE };
3670     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3671 }
3672 #endif
3673
3674 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3675 {
3676     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3677 }
3678
3679 #if FF_API_PKT_DUMP
3680 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3681 {
3682     AVRational tb = { 1, AV_TIME_BASE };
3683     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3684 }
3685 #endif
3686
3687 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3688                       AVStream *st)
3689 {
3690     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3691 }
3692
3693 void av_url_split(char *proto, int proto_size,
3694                   char *authorization, int authorization_size,
3695                   char *hostname, int hostname_size,
3696                   int *port_ptr,
3697                   char *path, int path_size,
3698                   const char *url)
3699 {
3700     const char *p, *ls, *at, *col, *brk;
3701
3702     if (port_ptr)               *port_ptr = -1;
3703     if (proto_size > 0)         proto[0] = 0;
3704     if (authorization_size > 0) authorization[0] = 0;
3705     if (hostname_size > 0)      hostname[0] = 0;
3706     if (path_size > 0)          path[0] = 0;
3707
3708     /* parse protocol */
3709     if ((p = strchr(url, ':'))) {
3710         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3711         p++; /* skip ':' */
3712         if (*p == '/') p++;
3713         if (*p == '/') p++;
3714     } else {
3715         /* no protocol means plain filename */
3716         av_strlcpy(path, url, path_size);
3717         return;
3718     }
3719
3720     /* separate path from hostname */
3721     ls = strchr(p, '/');
3722     if(!ls)
3723         ls = strchr(p, '?');
3724     if(ls)
3725         av_strlcpy(path, ls, path_size);
3726     else
3727         ls = &p[strlen(p)]; // XXX
3728
3729     /* the rest is hostname, use that to parse auth/port */
3730     if (ls != p) {
3731         /* authorization (user[:pass]@hostname) */
3732         if ((at = strchr(p, '@')) && at < ls) {
3733             av_strlcpy(authorization, p,
3734                        FFMIN(authorization_size, at + 1 - p));
3735             p = at + 1; /* skip '@' */
3736         }
3737
3738         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3739             /* [host]:port */
3740             av_strlcpy(hostname, p + 1,
3741                        FFMIN(hostname_size, brk - p));
3742             if (brk[1] == ':' && port_ptr)
3743                 *port_ptr = atoi(brk + 2);
3744         } else if ((col = strchr(p, ':')) && col < ls) {
3745             av_strlcpy(hostname, p,
3746                        FFMIN(col + 1 - p, hostname_size));
3747             if (port_ptr) *port_ptr = atoi(col + 1);
3748         } else
3749             av_strlcpy(hostname, p,
3750                        FFMIN(ls + 1 - p, hostname_size));
3751     }
3752 }
3753
3754 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3755 {
3756     int i;
3757     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3758                                            '4', '5', '6', '7',
3759                                            '8', '9', 'A', 'B',
3760                                            'C', 'D', 'E', 'F' };
3761     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3762                                            '4', '5', '6', '7',
3763                                            '8', '9', 'a', 'b',
3764                                            'c', 'd', 'e', 'f' };
3765     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3766
3767     for(i = 0; i < s; i++) {
3768         buff[i * 2]     = hex_table[src[i] >> 4];
3769         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3770     }
3771
3772     return buff;
3773 }
3774
3775 int ff_hex_to_data(uint8_t *data, const char *p)
3776 {
3777     int c, len, v;
3778
3779     len = 0;
3780     v = 1;
3781     for (;;) {
3782         p += strspn(p, SPACE_CHARS);
3783         if (*p == '\0')
3784             break;
3785         c = toupper((unsigned char) *p++);
3786         if (c >= '0' && c <= '9')
3787             c = c - '0';
3788         else if (c >= 'A' && c <= 'F')
3789             c = c - 'A' + 10;
3790         else
3791             break;
3792         v = (v << 4) | c;
3793         if (v & 0x100) {
3794             if (data)
3795                 data[len] = v;
3796             len++;
3797             v = 1;
3798         }
3799     }
3800     return len;
3801 }
3802
3803 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3804                      unsigned int pts_num, unsigned int pts_den)
3805 {
3806     AVRational new_tb;
3807     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3808         if(new_tb.num != pts_num)
3809             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3810     }else
3811         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3812
3813     if(new_tb.num <= 0 || new_tb.den <= 0) {
3814         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3815         return;
3816     }
3817     s->time_base = new_tb;
3818     s->pts_wrap_bits = pts_wrap_bits;
3819 }
3820
3821 int ff_url_join(char *str, int size, const char *proto,
3822                 const char *authorization, const char *hostname,
3823                 int port, const char *fmt, ...)
3824 {
3825 #if CONFIG_NETWORK
3826     struct addrinfo hints, *ai;
3827 #endif
3828
3829     str[0] = '\0';
3830     if (proto)
3831         av_strlcatf(str, size, "%s://", proto);
3832     if (authorization && authorization[0])
3833         av_strlcatf(str, size, "%s@", authorization);
3834 #if CONFIG_NETWORK && defined(AF_INET6)
3835     /* Determine if hostname is a numerical IPv6 address,
3836      * properly escape it within [] in that case. */
3837     memset(&hints, 0, sizeof(hints));
3838     hints.ai_flags = AI_NUMERICHOST;
3839     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3840         if (ai->ai_family == AF_INET6) {
3841             av_strlcat(str, "[", size);
3842             av_strlcat(str, hostname, size);
3843             av_strlcat(str, "]", size);
3844         } else {
3845             av_strlcat(str, hostname, size);
3846         }
3847         freeaddrinfo(ai);
3848     } else
3849 #endif
3850         /* Not an IPv6 address, just output the plain string. */
3851         av_strlcat(str, hostname, size);
3852
3853     if (port >= 0)
3854         av_strlcatf(str, size, ":%d", port);
3855     if (fmt) {
3856         va_list vl;
3857         int len = strlen(str);
3858
3859         va_start(vl, fmt);
3860         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3861         va_end(vl);
3862     }
3863     return strlen(str);
3864 }
3865
3866 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3867                      AVFormatContext *src)
3868 {
3869     AVPacket local_pkt;
3870
3871     local_pkt = *pkt;
3872     local_pkt.stream_index = dst_stream;
3873     if (pkt->pts != AV_NOPTS_VALUE)
3874         local_pkt.pts = av_rescale_q(pkt->pts,
3875                                      src->streams[pkt->stream_index]->time_base,
3876                                      dst->streams[dst_stream]->time_base);
3877     if (pkt->dts != AV_NOPTS_VALUE)
3878         local_pkt.dts = av_rescale_q(pkt->dts,
3879                                      src->streams[pkt->stream_index]->time_base,
3880                                      dst->streams[dst_stream]->time_base);
3881     return av_write_frame(dst, &local_pkt);
3882 }
3883
3884 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3885                         void *context)
3886 {
3887     const char *ptr = str;
3888
3889     /* Parse key=value pairs. */
3890     for (;;) {
3891         const char *key;
3892         char *dest = NULL, *dest_end;
3893         int key_len, dest_len = 0;
3894
3895         /* Skip whitespace and potential commas. */
3896         while (*ptr && (isspace(*ptr) || *ptr == ','))
3897             ptr++;
3898         if (!*ptr)
3899             break;
3900
3901         key = ptr;
3902
3903         if (!(ptr = strchr(key, '=')))
3904             break;
3905         ptr++;
3906         key_len = ptr - key;
3907
3908         callback_get_buf(context, key, key_len, &dest, &dest_len);
3909         dest_end = dest + dest_len - 1;
3910
3911         if (*ptr == '\"') {
3912             ptr++;
3913             while (*ptr && *ptr != '\"') {
3914                 if (*ptr == '\\') {
3915                     if (!ptr[1])
3916                         break;
3917                     if (dest && dest < dest_end)
3918                         *dest++ = ptr[1];
3919                     ptr += 2;
3920                 } else {
3921                     if (dest && dest < dest_end)
3922                         *dest++ = *ptr;
3923                     ptr++;
3924                 }
3925             }
3926             if (*ptr == '\"')
3927                 ptr++;
3928         } else {
3929             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3930                 if (dest && dest < dest_end)
3931                     *dest++ = *ptr;
3932         }
3933         if (dest)
3934             *dest = 0;
3935     }
3936 }
3937
3938 int ff_find_stream_index(AVFormatContext *s, int id)
3939 {
3940     int i;
3941     for (i = 0; i < s->nb_streams; i++) {
3942         if (s->streams[i]->id == id)
3943             return i;
3944     }
3945     return -1;
3946 }
3947
3948 void ff_make_absolute_url(char *buf, int size, const char *base,
3949                           const char *rel)
3950 {
3951     char *sep;
3952     /* Absolute path, relative to the current server */
3953     if (base && strstr(base, "://") && rel[0] == '/') {
3954         if (base != buf)
3955             av_strlcpy(buf, base, size);
3956         sep = strstr(buf, "://");
3957         if (sep) {
3958             sep += 3;
3959             sep = strchr(sep, '/');
3960             if (sep)
3961                 *sep = '\0';
3962         }
3963         av_strlcat(buf, rel, size);
3964         return;
3965     }
3966     /* If rel actually is an absolute url, just copy it */
3967     if (!base || strstr(rel, "://") || rel[0] == '/') {
3968         av_strlcpy(buf, rel, size);
3969         return;
3970     }
3971     if (base != buf)
3972         av_strlcpy(buf, base, size);
3973     /* Remove the file name from the base url */
3974     sep = strrchr(buf, '/');
3975     if (sep)
3976         sep[1] = '\0';
3977     else
3978         buf[0] = '\0';
3979     while (av_strstart(rel, "../", NULL) && sep) {
3980         /* Remove the path delimiter at the end */
3981         sep[0] = '\0';
3982         sep = strrchr(buf, '/');
3983         /* If the next directory name to pop off is "..", break here */
3984         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3985             /* Readd the slash we just removed */
3986             av_strlcat(buf, "/", size);
3987             break;
3988         }
3989         /* Cut off the directory name */
3990         if (sep)
3991             sep[1] = '\0';
3992         else
3993             buf[0] = '\0';
3994         rel += 3;
3995     }
3996     av_strlcat(buf, rel, size);
3997 }