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