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

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