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