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

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