libavformat/utils.c

   1 /*
   2  * various utility functions for use within Libav
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /* #define DEBUG */
  23
  24 #include "avformat.h"
  25 #include "avio_internal.h"
  26 #include "internal.h"
  27 #include "libavcodec/internal.h"
  28 #include "libavutil/opt.h"
  29 #include "libavutil/dict.h"
  30 #include "libavutil/pixdesc.h"
  31 #include "metadata.h"
  32 #include "id3v2.h"
  33 #include "libavutil/avstring.h"
  34 #include "libavutil/mathematics.h"
  35 #include "riff.h"
  36 #include "audiointerleave.h"
  37 #include "url.h"
  38 #include <sys/time.h>
  39 #include <time.h>
  40 #include <strings.h>
  41 #include <stdarg.h>
  42 #if CONFIG_NETWORK
  43 #include "network.h"
  44 #endif
  45
  46 #undef NDEBUG
  47 #include <assert.h>
  48
  49 /**
  50  * @file
  51  * various utility functions for use within Libav
  52  */
  53
  54 unsigned avformat_version(void)
  55 {
  56     return LIBAVFORMAT_VERSION_INT;
  57 }
  58
  59 const char *avformat_configuration(void)
  60 {
  61     return LIBAV_CONFIGURATION;
  62 }
  63
  64 const char *avformat_license(void)
  65 {
  66 #define LICENSE_PREFIX "libavformat license: "
  67     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  68 }
  69
  70 /* fraction handling */
  71
  72 /**
  73  * f = val + (num / den) + 0.5.
  74  *
  75  * 'num' is normalized so that it is such as 0 <= num < den.
  76  *
  77  * @param f fractional number
  78  * @param val integer value
  79  * @param num must be >= 0
  80  * @param den must be >= 1
  81  */
  82 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
  83 {
  84     num += (den >> 1);
  85     if (num >= den) {
  86         val += num / den;
  87         num = num % den;
  88     }
  89     f->val = val;
  90     f->num = num;
  91     f->den = den;
  92 }
  93
  94 /**
  95  * Fractional addition to f: f = f + (incr / f->den).
  96  *
  97  * @param f fractional number
  98  * @param incr increment, can be positive or negative
  99  */
 100 static void av_frac_add(AVFrac *f, int64_t incr)
 101 {
 102     int64_t num, den;
 103
 104     num = f->num + incr;
 105     den = f->den;
 106     if (num < 0) {
 107         f->val += num / den;
 108         num = num % den;
 109         if (num < 0) {
 110             num += den;
 111             f->val--;
 112         }
 113     } else if (num >= den) {
 114         f->val += num / den;
 115         num = num % den;
 116     }
 117     f->num = num;
 118 }
 119
 120 /** head of registered input format linked list */
 121 static AVInputFormat *first_iformat = NULL;
 122 /** head of registered output format linked list */
 123 static AVOutputFormat *first_oformat = NULL;
 124
 125 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
 126 {
 127     if(f) return f->next;
 128     else  return first_iformat;
 129 }
 130
 131 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
 132 {
 133     if(f) return f->next;
 134     else  return first_oformat;
 135 }
 136
 137 void av_register_input_format(AVInputFormat *format)
 138 {
 139     AVInputFormat **p;
 140     p = &first_iformat;
 141     while (*p != NULL) p = &(*p)->next;
 142     *p = format;
 143     format->next = NULL;
 144 }
 145
 146 void av_register_output_format(AVOutputFormat *format)
 147 {
 148     AVOutputFormat **p;
 149     p = &first_oformat;
 150     while (*p != NULL) p = &(*p)->next;
 151     *p = format;
 152     format->next = NULL;
 153 }
 154
 155 int av_match_ext(const char *filename, const char *extensions)
 156 {
 157     const char *ext, *p;
 158     char ext1[32], *q;
 159
 160     if(!filename)
 161         return 0;
 162
 163     ext = strrchr(filename, '.');
 164     if (ext) {
 165         ext++;
 166         p = extensions;
 167         for(;;) {
 168             q = ext1;
 169             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
 170                 *q++ = *p++;
 171             *q = '\0';
 172             if (!strcasecmp(ext1, ext))
 173                 return 1;
 174             if (*p == '\0')
 175                 break;
 176             p++;
 177         }
 178     }
 179     return 0;
 180 }
 181
 182 static int match_format(const char *name, const char *names)
 183 {
 184     const char *p;
 185     int len, namelen;
 186
 187     if (!name || !names)
 188         return 0;
 189
 190     namelen = strlen(name);
 191     while ((p = strchr(names, ','))) {
 192         len = FFMAX(p - names, namelen);
 193         if (!strncasecmp(name, names, len))
 194             return 1;
 195         names = p+1;
 196     }
 197     return !strcasecmp(name, names);
 198 }
 199
 200 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
 201                                 const char *mime_type)
 202 {
 203     AVOutputFormat *fmt = NULL, *fmt_found;
 204     int score_max, score;
 205
 206     /* specific test for image sequences */
 207 #if CONFIG_IMAGE2_MUXER
 208     if (!short_name && filename &&
 209         av_filename_number_test(filename) &&
 210         ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
 211         return av_guess_format("image2", NULL, NULL);
 212     }
 213 #endif
 214     /* Find the proper file type. */
 215     fmt_found = NULL;
 216     score_max = 0;
 217     while ((fmt = av_oformat_next(fmt))) {
 218         score = 0;
 219         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 220             score += 100;
 221         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 222             score += 10;
 223         if (filename && fmt->extensions &&
 224             av_match_ext(filename, fmt->extensions)) {
 225             score += 5;
 226         }
 227         if (score > score_max) {
 228             score_max = score;
 229             fmt_found = fmt;
 230         }
 231     }
 232     return fmt_found;
 233 }
 234
 235 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 236                             const char *filename, const char *mime_type, enum AVMediaType type){
 237     if(type == AVMEDIA_TYPE_VIDEO){
 238         enum CodecID codec_id= CODEC_ID_NONE;
 239
 240 #if CONFIG_IMAGE2_MUXER
 241         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 242             codec_id= ff_guess_image2_codec(filename);
 243         }
 244 #endif
 245         if(codec_id == CODEC_ID_NONE)
 246             codec_id= fmt->video_codec;
 247         return codec_id;
 248     }else if(type == AVMEDIA_TYPE_AUDIO)
 249         return fmt->audio_codec;
 250     else if (type == AVMEDIA_TYPE_SUBTITLE)
 251         return fmt->subtitle_codec;
 252     else
 253         return CODEC_ID_NONE;
 254 }
 255
 256 AVInputFormat *av_find_input_format(const char *short_name)
 257 {
 258     AVInputFormat *fmt = NULL;
 259     while ((fmt = av_iformat_next(fmt))) {
 260         if (match_format(short_name, fmt->name))
 261             return fmt;
 262     }
 263     return NULL;
 264 }
 265
 266
 267 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 268 {
 269     int ret= av_new_packet(pkt, size);
 270
 271     if(ret<0)
 272         return ret;
 273
 274     pkt->pos= avio_tell(s);
 275
 276     ret= avio_read(s, pkt->data, size);
 277     if(ret<=0)
 278         av_free_packet(pkt);
 279     else
 280         av_shrink_packet(pkt, ret);
 281
 282     return ret;
 283 }
 284
 285 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 286 {
 287     int ret;
 288     int old_size;
 289     if (!pkt->size)
 290         return av_get_packet(s, pkt, size);
 291     old_size = pkt->size;
 292     ret = av_grow_packet(pkt, size);
 293     if (ret < 0)
 294         return ret;
 295     ret = avio_read(s, pkt->data + old_size, size);
 296     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
 297     return ret;
 298 }
 299
 300
 301 int av_filename_number_test(const char *filename)
 302 {
 303     char buf[1024];
 304     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 305 }
 306
 307 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 308 {
 309     AVProbeData lpd = *pd;
 310     AVInputFormat *fmt1 = NULL, *fmt;
 311     int score, id3 = 0;
 312
 313     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 314         int id3len = ff_id3v2_tag_len(lpd.buf);
 315         if (lpd.buf_size > id3len + 16) {
 316             lpd.buf += id3len;
 317             lpd.buf_size -= id3len;
 318         }
 319         id3 = 1;
 320     }
 321
 322     fmt = NULL;
 323     while ((fmt1 = av_iformat_next(fmt1))) {
 324         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 325             continue;
 326         score = 0;
 327         if (fmt1->read_probe) {
 328             score = fmt1->read_probe(&lpd);
 329         } else if (fmt1->extensions) {
 330             if (av_match_ext(lpd.filename, fmt1->extensions)) {
 331                 score = 50;
 332             }
 333         }
 334         if (score > *score_max) {
 335             *score_max = score;
 336             fmt = fmt1;
 337         }else if (score == *score_max)
 338             fmt = NULL;
 339     }
 340
 341     /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
 342     if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
 343         while ((fmt = av_iformat_next(fmt)))
 344             if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
 345                 *score_max = AVPROBE_SCORE_MAX/4;
 346                 break;
 347             }
 348     }
 349
 350     return fmt;
 351 }
 352
 353 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 354     int score=0;
 355     return av_probe_input_format2(pd, is_opened, &score);
 356 }
 357
 358 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 359 {
 360     static const struct {
 361         const char *name; enum CodecID id; enum AVMediaType type;
 362     } fmt_id_type[] = {
 363         { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
 364         { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
 365         { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
 366         { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
 367         { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 368         { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
 369         { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
 370         { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 371         { 0 }
 372     };
 373     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
 374
 375     if (fmt) {
 376         int i;
 377         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 378                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 379         for (i = 0; fmt_id_type[i].name; i++) {
 380             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 381                 st->codec->codec_id   = fmt_id_type[i].id;
 382                 st->codec->codec_type = fmt_id_type[i].type;
 383                 break;
 384             }
 385         }
 386     }
 387     return !!fmt;
 388 }
 389
 390 /************************************************************/
 391 /* input media file */
 392
 393 #if FF_API_FORMAT_PARAMETERS
 394 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
 395 {
 396     char buf[1024];
 397     AVDictionary *opts = NULL;
 398
 399     if (!ap)
 400         return NULL;
 401
 402     if (ap->time_base.num) {
 403         snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
 404         av_dict_set(&opts, "framerate", buf, 0);
 405     }
 406     if (ap->sample_rate) {
 407         snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
 408         av_dict_set(&opts, "sample_rate", buf, 0);
 409     }
 410     if (ap->channels) {
 411         snprintf(buf, sizeof(buf), "%d", ap->channels);
 412         av_dict_set(&opts, "channels", buf, 0);
 413     }
 414     if (ap->width || ap->height) {
 415         snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
 416         av_dict_set(&opts, "video_size", buf, 0);
 417     }
 418     if (ap->pix_fmt != PIX_FMT_NONE) {
 419         av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
 420     }
 421     if (ap->channel) {
 422         snprintf(buf, sizeof(buf), "%d", ap->channel);
 423         av_dict_set(&opts, "channel", buf, 0);
 424     }
 425     if (ap->standard) {
 426         av_dict_set(&opts, "standard", ap->standard, 0);
 427     }
 428     if (ap->mpeg2ts_compute_pcr) {
 429         av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
 430     }
 431     if (ap->initial_pause) {
 432         av_dict_set(&opts, "initial_pause", "1", 0);
 433     }
 434     return opts;
 435 }
 436
 437 /**
 438  * Open a media file from an IO stream. 'fmt' must be specified.
 439  */
 440 int av_open_input_stream(AVFormatContext **ic_ptr,
 441                          AVIOContext *pb, const char *filename,
 442                          AVInputFormat *fmt, AVFormatParameters *ap)
 443 {
 444     int err;
 445     AVDictionary *opts;
 446     AVFormatContext *ic;
 447     AVFormatParameters default_ap;
 448
 449     if(!ap){
 450         ap=&default_ap;
 451         memset(ap, 0, sizeof(default_ap));
 452     }
 453     opts = convert_format_parameters(ap);
 454
 455     if(!ap->prealloced_context)
 456         ic = avformat_alloc_context();
 457     else
 458         ic = *ic_ptr;
 459     if (!ic) {
 460         err = AVERROR(ENOMEM);
 461         goto fail;
 462     }
 463     if (pb && fmt && fmt->flags & AVFMT_NOFILE)
 464         av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 465                                    "will be ignored with AVFMT_NOFILE format.\n");
 466     else
 467         ic->pb = pb;
 468
 469     err = avformat_open_input(&ic, filename, fmt, &opts);
 470     ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
 471
 472     *ic_ptr = ic;
 473 fail:
 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, AVDictionary **options)
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_open2(st->codec, codec, options);
2089         if (ret < 0)
2090             return ret;
2091     }
2092
2093     if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2094        (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2095         switch(st->codec->codec_type) {
2096         case AVMEDIA_TYPE_VIDEO:
2097             avcodec_get_frame_defaults(&picture);
2098             ret = avcodec_decode_video2(st->codec, &picture,
2099                                         &got_picture, avpkt);
2100             break;
2101         case AVMEDIA_TYPE_AUDIO:
2102             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2103             samples = av_malloc(data_size);
2104             if (!samples)
2105                 goto fail;
2106             ret = avcodec_decode_audio3(st->codec, samples,
2107                                         &data_size, avpkt);
2108             av_free(samples);
2109             break;
2110         default:
2111             break;
2112         }
2113     }
2114  fail:
2115     return ret;
2116 }
2117
2118 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2119 {
2120     while (tags->id != CODEC_ID_NONE) {
2121         if (tags->id == id)
2122             return tags->tag;
2123         tags++;
2124     }
2125     return 0;
2126 }
2127
2128 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2129 {
2130     int i;
2131     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2132         if(tag == tags[i].tag)
2133             return tags[i].id;
2134     }
2135     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2136         if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2137             return tags[i].id;
2138     }
2139     return CODEC_ID_NONE;
2140 }
2141
2142 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2143 {
2144     int i;
2145     for(i=0; tags && tags[i]; i++){
2146         int tag= ff_codec_get_tag(tags[i], id);
2147         if(tag) return tag;
2148     }
2149     return 0;
2150 }
2151
2152 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2153 {
2154     int i;
2155     for(i=0; tags && tags[i]; i++){
2156         enum CodecID id= ff_codec_get_id(tags[i], tag);
2157         if(id!=CODEC_ID_NONE) return id;
2158     }
2159     return CODEC_ID_NONE;
2160 }
2161
2162 static void compute_chapters_end(AVFormatContext *s)
2163 {
2164     unsigned int i, j;
2165     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2166
2167     for (i = 0; i < s->nb_chapters; i++)
2168         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2169             AVChapter *ch = s->chapters[i];
2170             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2171                                      : INT64_MAX;
2172
2173             for (j = 0; j < s->nb_chapters; j++) {
2174                 AVChapter *ch1 = s->chapters[j];
2175                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2176                 if (j != i && next_start > ch->start && next_start < end)
2177                     end = next_start;
2178             }
2179             ch->end = (end == INT64_MAX) ? ch->start : end;
2180         }
2181 }
2182
2183 static int get_std_framerate(int i){
2184     if(i<60*12) return i*1001;
2185     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2186 }
2187
2188 /*
2189  * Is the time base unreliable.
2190  * This is a heuristic to balance between quick acceptance of the values in
2191  * the headers vs. some extra checks.
2192  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2193  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2194  * And there are "variable" fps files this needs to detect as well.
2195  */
2196 static int tb_unreliable(AVCodecContext *c){
2197     if(   c->time_base.den >= 101L*c->time_base.num
2198        || c->time_base.den <    5L*c->time_base.num
2199 /*       || c->codec_tag == AV_RL32("DIVX")
2200        || c->codec_tag == AV_RL32("XVID")*/
2201        || c->codec_id == CODEC_ID_MPEG2VIDEO
2202        || c->codec_id == CODEC_ID_H264
2203        )
2204         return 1;
2205     return 0;
2206 }
2207
2208 #if FF_API_FORMAT_PARAMETERS
2209 int av_find_stream_info(AVFormatContext *ic)
2210 {
2211     return avformat_find_stream_info(ic, NULL);
2212 }
2213 #endif
2214
2215 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2216 {
2217     int i, count, ret, read_size, j;
2218     AVStream *st;
2219     AVPacket pkt1, *pkt;
2220     int64_t old_offset = avio_tell(ic->pb);
2221     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2222
2223     for(i=0;i<ic->nb_streams;i++) {
2224         AVCodec *codec;
2225         st = ic->streams[i];
2226
2227         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2228             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2229 /*            if(!st->time_base.num)
2230                 st->time_base= */
2231             if(!st->codec->time_base.num)
2232                 st->codec->time_base= st->time_base;
2233         }
2234         //only for the split stuff
2235         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2236             st->parser = av_parser_init(st->codec->codec_id);
2237             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2238                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2239             }
2240         }
2241         assert(!st->codec->codec);
2242         codec = avcodec_find_decoder(st->codec->codec_id);
2243
2244         /* Ensure that subtitle_header is properly set. */
2245         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2246             && codec && !st->codec->codec)
2247             avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2248
2249         //try to just open decoders, in case this is enough to get parameters
2250         if(!has_codec_parameters(st->codec)){
2251             if (codec && !st->codec->codec)
2252                 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2253         }
2254     }
2255
2256     for (i=0; i<ic->nb_streams; i++) {
2257         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2258     }
2259
2260     count = 0;
2261     read_size = 0;
2262     for(;;) {
2263         if(url_interrupt_cb()){
2264             ret= AVERROR_EXIT;
2265             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2266             break;
2267         }
2268
2269         /* check if one codec still needs to be handled */
2270         for(i=0;i<ic->nb_streams;i++) {
2271             int fps_analyze_framecount = 20;
2272
2273             st = ic->streams[i];
2274             if (!has_codec_parameters(st->codec))
2275                 break;
2276             /* if the timebase is coarse (like the usual millisecond precision
2277                of mkv), we need to analyze more frames to reliably arrive at
2278                the correct fps */
2279             if (av_q2d(st->time_base) > 0.0005)
2280                 fps_analyze_framecount *= 2;
2281             if (ic->fps_probe_size >= 0)
2282                 fps_analyze_framecount = ic->fps_probe_size;
2283             /* variable fps and no guess at the real fps */
2284             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2285                && st->info->duration_count < fps_analyze_framecount
2286                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2287                 break;
2288             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2289                 break;
2290             if(st->first_dts == AV_NOPTS_VALUE)
2291                 break;
2292         }
2293         if (i == ic->nb_streams) {
2294             /* NOTE: if the format has no header, then we need to read
2295                some packets to get most of the streams, so we cannot
2296                stop here */
2297             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2298                 /* if we found the info for all the codecs, we can stop */
2299                 ret = count;
2300                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2301                 break;
2302             }
2303         }
2304         /* we did not get all the codec info, but we read too much data */
2305         if (read_size >= ic->probesize) {
2306             ret = count;
2307             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2308             break;
2309         }
2310
2311         /* NOTE: a new stream can be added there if no header in file
2312            (AVFMTCTX_NOHEADER) */
2313         ret = av_read_frame_internal(ic, &pkt1);
2314         if (ret == AVERROR(EAGAIN))
2315             continue;
2316
2317         if (ret < 0) {
2318             /* EOF or error */
2319             ret = -1; /* we could not have all the codec parameters before EOF */
2320             for(i=0;i<ic->nb_streams;i++) {
2321                 st = ic->streams[i];
2322                 if (!has_codec_parameters(st->codec)){
2323                     char buf[256];
2324                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2325                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2326                 } else {
2327                     ret = 0;
2328                 }
2329             }
2330             break;
2331         }
2332
2333         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2334         if ((ret = av_dup_packet(pkt)) < 0)
2335             goto find_stream_info_err;
2336
2337         read_size += pkt->size;
2338
2339         st = ic->streams[pkt->stream_index];
2340         if (st->codec_info_nb_frames>1) {
2341             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) {
2342                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2343                 break;
2344             }
2345             st->info->codec_info_duration += pkt->duration;
2346         }
2347         {
2348             int64_t last = st->info->last_dts;
2349             int64_t duration= pkt->dts - last;
2350
2351             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2352                 double dur= duration * av_q2d(st->time_base);
2353
2354 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2355 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2356                 if (st->info->duration_count < 2)
2357                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2358                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2359                     int framerate= get_std_framerate(i);
2360                     int ticks= lrintf(dur*framerate/(1001*12));
2361                     double error= dur - ticks*1001*12/(double)framerate;
2362                     st->info->duration_error[i] += error*error;
2363                 }
2364                 st->info->duration_count++;
2365                 // ignore the first 4 values, they might have some random jitter
2366                 if (st->info->duration_count > 3)
2367                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2368             }
2369             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2370                 st->info->last_dts = pkt->dts;
2371         }
2372         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2373             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2374             if(i){
2375                 st->codec->extradata_size= i;
2376                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2377                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2378                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2379             }
2380         }
2381
2382         /* if still no information, we try to open the codec and to
2383            decompress the frame. We try to avoid that in most cases as
2384            it takes longer and uses more memory. For MPEG-4, we need to
2385            decompress for QuickTime.
2386
2387            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2388            least one frame of codec data, this makes sure the codec initializes
2389            the channel configuration and does not only trust the values from the container.
2390         */
2391         try_decode_frame(st, pkt, (options && i <= orig_nb_streams )? &options[i] : NULL);
2392
2393         st->codec_info_nb_frames++;
2394         count++;
2395     }
2396
2397     // close codecs which were opened in try_decode_frame()
2398     for(i=0;i<ic->nb_streams;i++) {
2399         st = ic->streams[i];
2400         if(st->codec->codec)
2401             avcodec_close(st->codec);
2402     }
2403     for(i=0;i<ic->nb_streams;i++) {
2404         st = ic->streams[i];
2405         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2406             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2407                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2408                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2409         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2410             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2411                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2412
2413             // the check for tb_unreliable() is not completely correct, since this is not about handling
2414             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2415             // ipmovie.c produces.
2416             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2417                 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);
2418             if (st->info->duration_count && !st->r_frame_rate.num
2419                && tb_unreliable(st->codec) /*&&
2420                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2421                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2422                 int num = 0;
2423                 double best_error= 2*av_q2d(st->time_base);
2424                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2425
2426                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2427                     double error = st->info->duration_error[j] * get_std_framerate(j);
2428 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2429 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2430                     if(error < best_error){
2431                         best_error= error;
2432                         num = get_std_framerate(j);
2433                     }
2434                 }
2435                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2436                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2437                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2438             }
2439
2440             if (!st->r_frame_rate.num){
2441                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2442                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2443                     st->r_frame_rate.num = st->codec->time_base.den;
2444                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2445                 }else{
2446                     st->r_frame_rate.num = st->time_base.den;
2447                     st->r_frame_rate.den = st->time_base.num;
2448                 }
2449             }
2450         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2451             if(!st->codec->bits_per_coded_sample)
2452                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2453             // set stream disposition based on audio service type
2454             switch (st->codec->audio_service_type) {
2455             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2456                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2457             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2458                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2459             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2460                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2461             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2462                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2463             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2464                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2465             }
2466         }
2467     }
2468
2469     av_estimate_timings(ic, old_offset);
2470
2471     compute_chapters_end(ic);
2472
2473 #if 0
2474     /* correct DTS for B-frame streams with no timestamps */
2475     for(i=0;i<ic->nb_streams;i++) {
2476         st = ic->streams[i];
2477         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2478             if(b-frames){
2479                 ppktl = &ic->packet_buffer;
2480                 while(ppkt1){
2481                     if(ppkt1->stream_index != i)
2482                         continue;
2483                     if(ppkt1->pkt->dts < 0)
2484                         break;
2485                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2486                         break;
2487                     ppkt1->pkt->dts -= delta;
2488                     ppkt1= ppkt1->next;
2489                 }
2490                 if(ppkt1)
2491                     continue;
2492                 st->cur_dts -= delta;
2493             }
2494         }
2495     }
2496 #endif
2497
2498  find_stream_info_err:
2499     for (i=0; i < ic->nb_streams; i++)
2500         av_freep(&ic->streams[i]->info);
2501     return ret;
2502 }
2503
2504 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2505 {
2506     int i, j;
2507
2508     for (i = 0; i < ic->nb_programs; i++)
2509         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2510             if (ic->programs[i]->stream_index[j] == s)
2511                 return ic->programs[i];
2512     return NULL;
2513 }
2514
2515 int av_find_best_stream(AVFormatContext *ic,
2516                         enum AVMediaType type,
2517                         int wanted_stream_nb,
2518                         int related_stream,
2519                         AVCodec **decoder_ret,
2520                         int flags)
2521 {
2522     int i, nb_streams = ic->nb_streams;
2523     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2524     unsigned *program = NULL;
2525     AVCodec *decoder = NULL, *best_decoder = NULL;
2526
2527     if (related_stream >= 0 && wanted_stream_nb < 0) {
2528         AVProgram *p = find_program_from_stream(ic, related_stream);
2529         if (p) {
2530             program = p->stream_index;
2531             nb_streams = p->nb_stream_indexes;
2532         }
2533     }
2534     for (i = 0; i < nb_streams; i++) {
2535         int real_stream_index = program ? program[i] : i;
2536         AVStream *st = ic->streams[real_stream_index];
2537         AVCodecContext *avctx = st->codec;
2538         if (avctx->codec_type != type)
2539             continue;
2540         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2541             continue;
2542         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2543             continue;
2544         if (decoder_ret) {
2545             decoder = avcodec_find_decoder(st->codec->codec_id);
2546             if (!decoder) {
2547                 if (ret < 0)
2548                     ret = AVERROR_DECODER_NOT_FOUND;
2549                 continue;
2550             }
2551         }
2552         if (best_count >= st->codec_info_nb_frames)
2553             continue;
2554         best_count = st->codec_info_nb_frames;
2555         ret = real_stream_index;
2556         best_decoder = decoder;
2557         if (program && i == nb_streams - 1 && ret < 0) {
2558             program = NULL;
2559             nb_streams = ic->nb_streams;
2560             i = 0; /* no related stream found, try again with everything */
2561         }
2562     }
2563     if (decoder_ret)
2564         *decoder_ret = best_decoder;
2565     return ret;
2566 }
2567
2568 /*******************************************************/
2569
2570 int av_read_play(AVFormatContext *s)
2571 {
2572     if (s->iformat->read_play)
2573         return s->iformat->read_play(s);
2574     if (s->pb)
2575         return avio_pause(s->pb, 0);
2576     return AVERROR(ENOSYS);
2577 }
2578
2579 int av_read_pause(AVFormatContext *s)
2580 {
2581     if (s->iformat->read_pause)
2582         return s->iformat->read_pause(s);
2583     if (s->pb)
2584         return avio_pause(s->pb, 1);
2585     return AVERROR(ENOSYS);
2586 }
2587
2588 void av_close_input_stream(AVFormatContext *s)
2589 {
2590     flush_packet_queue(s);
2591     if (s->iformat->read_close)
2592         s->iformat->read_close(s);
2593     avformat_free_context(s);
2594 }
2595
2596 void avformat_free_context(AVFormatContext *s)
2597 {
2598     int i;
2599     AVStream *st;
2600
2601     av_opt_free(s);
2602     if (s->iformat && s->iformat->priv_class && s->priv_data)
2603         av_opt_free(s->priv_data);
2604
2605     for(i=0;i<s->nb_streams;i++) {
2606         /* free all data in a stream component */
2607         st = s->streams[i];
2608         if (st->parser) {
2609             av_parser_close(st->parser);
2610             av_free_packet(&st->cur_pkt);
2611         }
2612         av_dict_free(&st->metadata);
2613         av_free(st->index_entries);
2614         av_free(st->codec->extradata);
2615         av_free(st->codec->subtitle_header);
2616         av_free(st->codec);
2617         av_free(st->priv_data);
2618         av_free(st->info);
2619         av_free(st);
2620     }
2621     for(i=s->nb_programs-1; i>=0; i--) {
2622         av_dict_free(&s->programs[i]->metadata);
2623         av_freep(&s->programs[i]->stream_index);
2624         av_freep(&s->programs[i]);
2625     }
2626     av_freep(&s->programs);
2627     av_freep(&s->priv_data);
2628     while(s->nb_chapters--) {
2629         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2630         av_free(s->chapters[s->nb_chapters]);
2631     }
2632     av_freep(&s->chapters);
2633     av_dict_free(&s->metadata);
2634     av_freep(&s->streams);
2635     av_free(s);
2636 }
2637
2638 void av_close_input_file(AVFormatContext *s)
2639 {
2640     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2641                        NULL : s->pb;
2642     av_close_input_stream(s);
2643     if (pb)
2644         avio_close(pb);
2645 }
2646
2647 AVStream *av_new_stream(AVFormatContext *s, int id)
2648 {
2649     AVStream *st;
2650     int i;
2651     AVStream **streams;
2652
2653     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2654         return NULL;
2655     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2656     if (!streams)
2657         return NULL;
2658     s->streams = streams;
2659
2660     st = av_mallocz(sizeof(AVStream));
2661     if (!st)
2662         return NULL;
2663     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2664         av_free(st);
2665         return NULL;
2666     }
2667
2668     st->codec = avcodec_alloc_context3(NULL);
2669     if (s->iformat) {
2670         /* no default bitrate if decoding */
2671         st->codec->bit_rate = 0;
2672     }
2673     st->index = s->nb_streams;
2674     st->id = id;
2675     st->start_time = AV_NOPTS_VALUE;
2676     st->duration = AV_NOPTS_VALUE;
2677         /* we set the current DTS to 0 so that formats without any timestamps
2678            but durations get some timestamps, formats with some unknown
2679            timestamps have their first few packets buffered and the
2680            timestamps corrected before they are returned to the user */
2681     st->cur_dts = 0;
2682     st->first_dts = AV_NOPTS_VALUE;
2683     st->probe_packets = MAX_PROBE_PACKETS;
2684
2685     /* default pts setting is MPEG-like */
2686     av_set_pts_info(st, 33, 1, 90000);
2687     st->last_IP_pts = AV_NOPTS_VALUE;
2688     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2689         st->pts_buffer[i]= AV_NOPTS_VALUE;
2690     st->reference_dts = AV_NOPTS_VALUE;
2691
2692     st->sample_aspect_ratio = (AVRational){0,1};
2693
2694     s->streams[s->nb_streams++] = st;
2695     return st;
2696 }
2697
2698 AVProgram *av_new_program(AVFormatContext *ac, int id)
2699 {
2700     AVProgram *program=NULL;
2701     int i;
2702
2703     av_dlog(ac, "new_program: id=0x%04x\n", id);
2704
2705     for(i=0; i<ac->nb_programs; i++)
2706         if(ac->programs[i]->id == id)
2707             program = ac->programs[i];
2708
2709     if(!program){
2710         program = av_mallocz(sizeof(AVProgram));
2711         if (!program)
2712             return NULL;
2713         dynarray_add(&ac->programs, &ac->nb_programs, program);
2714         program->discard = AVDISCARD_NONE;
2715     }
2716     program->id = id;
2717
2718     return program;
2719 }
2720
2721 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2722 {
2723     AVChapter *chapter = NULL;
2724     int i;
2725
2726     for(i=0; i<s->nb_chapters; i++)
2727         if(s->chapters[i]->id == id)
2728             chapter = s->chapters[i];
2729
2730     if(!chapter){
2731         chapter= av_mallocz(sizeof(AVChapter));
2732         if(!chapter)
2733             return NULL;
2734         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2735     }
2736     av_dict_set(&chapter->metadata, "title", title, 0);
2737     chapter->id    = id;
2738     chapter->time_base= time_base;
2739     chapter->start = start;
2740     chapter->end   = end;
2741
2742     return chapter;
2743 }
2744
2745 /************************************************************/
2746 /* output media file */
2747
2748 #if FF_API_FORMAT_PARAMETERS
2749 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2750 {
2751     int ret;
2752
2753     if (s->oformat->priv_data_size > 0) {
2754         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2755         if (!s->priv_data)
2756             return AVERROR(ENOMEM);
2757         if (s->oformat->priv_class) {
2758             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2759             av_opt_set_defaults(s->priv_data);
2760         }
2761     } else
2762         s->priv_data = NULL;
2763
2764     if (s->oformat->set_parameters) {
2765         ret = s->oformat->set_parameters(s, ap);
2766         if (ret < 0)
2767             return ret;
2768     }
2769     return 0;
2770 }
2771 #endif
2772
2773 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2774 {
2775     const AVCodecTag *avctag;
2776     int n;
2777     enum CodecID id = CODEC_ID_NONE;
2778     unsigned int tag = 0;
2779
2780     /**
2781      * Check that tag + id is in the table
2782      * If neither is in the table -> OK
2783      * If tag is in the table with another id -> FAIL
2784      * If id is in the table with another tag -> FAIL unless strict < normal
2785      */
2786     for (n = 0; s->oformat->codec_tag[n]; n++) {
2787         avctag = s->oformat->codec_tag[n];
2788         while (avctag->id != CODEC_ID_NONE) {
2789             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2790                 id = avctag->id;
2791                 if (id == st->codec->codec_id)
2792                     return 1;
2793             }
2794             if (avctag->id == st->codec->codec_id)
2795                 tag = avctag->tag;
2796             avctag++;
2797         }
2798     }
2799     if (id != CODEC_ID_NONE)
2800         return 0;
2801     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2802         return 0;
2803     return 1;
2804 }
2805
2806 #if FF_API_FORMAT_PARAMETERS
2807 int av_write_header(AVFormatContext *s)
2808 {
2809     return avformat_write_header(s, NULL);
2810 }
2811 #endif
2812
2813 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2814 {
2815     int ret = 0, i;
2816     AVStream *st;
2817     AVDictionary *tmp = NULL;
2818
2819     if (options)
2820         av_dict_copy(&tmp, *options, 0);
2821     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2822         goto fail;
2823
2824     // some sanity checks
2825     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2826         av_log(s, AV_LOG_ERROR, "no streams\n");
2827         ret = AVERROR(EINVAL);
2828         goto fail;
2829     }
2830
2831     for(i=0;i<s->nb_streams;i++) {
2832         st = s->streams[i];
2833
2834         switch (st->codec->codec_type) {
2835         case AVMEDIA_TYPE_AUDIO:
2836             if(st->codec->sample_rate<=0){
2837                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2838                 ret = AVERROR(EINVAL);
2839                 goto fail;
2840             }
2841             if(!st->codec->block_align)
2842                 st->codec->block_align = st->codec->channels *
2843                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2844             break;
2845         case AVMEDIA_TYPE_VIDEO:
2846             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2847                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2848                 ret = AVERROR(EINVAL);
2849                 goto fail;
2850             }
2851             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2852                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2853                 ret = AVERROR(EINVAL);
2854                 goto fail;
2855             }
2856             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2857                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2858                 ret = AVERROR(EINVAL);
2859                 goto fail;
2860             }
2861             break;
2862         }
2863
2864         if(s->oformat->codec_tag){
2865             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)){
2866                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2867                 st->codec->codec_tag= 0;
2868             }
2869             if(st->codec->codec_tag){
2870                 if (!validate_codec_tag(s, st)) {
2871                     char tagbuf[32];
2872                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2873                     av_log(s, AV_LOG_ERROR,
2874                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2875                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2876                     ret = AVERROR_INVALIDDATA;
2877                     goto fail;
2878                 }
2879             }else
2880                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2881         }
2882
2883         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2884             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2885           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2886     }
2887
2888     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2889         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2890         if (!s->priv_data) {
2891             ret = AVERROR(ENOMEM);
2892             goto fail;
2893         }
2894         if (s->oformat->priv_class) {
2895             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2896             av_opt_set_defaults(s->priv_data);
2897             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2898                 goto fail;
2899         }
2900     }
2901
2902     /* set muxer identification string */
2903     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2904         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2905     }
2906
2907     if(s->oformat->write_header){
2908         ret = s->oformat->write_header(s);
2909         if (ret < 0)
2910             goto fail;
2911     }
2912
2913     /* init PTS generation */
2914     for(i=0;i<s->nb_streams;i++) {
2915         int64_t den = AV_NOPTS_VALUE;
2916         st = s->streams[i];
2917
2918         switch (st->codec->codec_type) {
2919         case AVMEDIA_TYPE_AUDIO:
2920             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2921             break;
2922         case AVMEDIA_TYPE_VIDEO:
2923             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2924             break;
2925         default:
2926             break;
2927         }
2928         if (den != AV_NOPTS_VALUE) {
2929             if (den <= 0) {
2930                 ret = AVERROR_INVALIDDATA;
2931                 goto fail;
2932             }
2933             av_frac_init(&st->pts, 0, 0, den);
2934         }
2935     }
2936
2937     if (options) {
2938         av_dict_free(options);
2939         *options = tmp;
2940     }
2941     return 0;
2942 fail:
2943     av_dict_free(&tmp);
2944     return ret;
2945 }
2946
2947 //FIXME merge with compute_pkt_fields
2948 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2949     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2950     int num, den, frame_size, i;
2951
2952     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2953             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2954
2955 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2956         return AVERROR(EINVAL);*/
2957
2958     /* duration field */
2959     if (pkt->duration == 0) {
2960         compute_frame_duration(&num, &den, st, NULL, pkt);
2961         if (den && num) {
2962             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2963         }
2964     }
2965
2966     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2967         pkt->pts= pkt->dts;
2968
2969     //XXX/FIXME this is a temporary hack until all encoders output pts
2970     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2971         pkt->dts=
2972 //        pkt->pts= st->cur_dts;
2973         pkt->pts= st->pts.val;
2974     }
2975
2976     //calculate dts from pts
2977     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2978         st->pts_buffer[0]= pkt->pts;
2979         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2980             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2981         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2982             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2983
2984         pkt->dts= st->pts_buffer[0];
2985     }
2986
2987     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2988         av_log(s, AV_LOG_ERROR,
2989                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2990                st->index, st->cur_dts, pkt->dts);
2991         return AVERROR(EINVAL);
2992     }
2993     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2994         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2995         return AVERROR(EINVAL);
2996     }
2997
2998 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2999     st->cur_dts= pkt->dts;
3000     st->pts.val= pkt->dts;
3001
3002     /* update pts */
3003     switch (st->codec->codec_type) {
3004     case AVMEDIA_TYPE_AUDIO:
3005         frame_size = get_audio_frame_size(st->codec, pkt->size);
3006
3007         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3008            likely equal to the encoder delay, but it would be better if we
3009            had the real timestamps from the encoder */
3010         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3011             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3012         }
3013         break;
3014     case AVMEDIA_TYPE_VIDEO:
3015         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3016         break;
3017     default:
3018         break;
3019     }
3020     return 0;
3021 }
3022
3023 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3024 {
3025     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3026
3027     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3028         return ret;
3029
3030     ret= s->oformat->write_packet(s, pkt);
3031
3032     if (ret >= 0)
3033         s->streams[pkt->stream_index]->nb_frames++;
3034     return ret;
3035 }
3036
3037 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3038                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3039 {
3040     AVPacketList **next_point, *this_pktl;
3041
3042     this_pktl = av_mallocz(sizeof(AVPacketList));
3043     this_pktl->pkt= *pkt;
3044     pkt->destruct= NULL;             // do not free original but only the copy
3045     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3046
3047     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3048         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3049     }else
3050         next_point = &s->packet_buffer;
3051
3052     if(*next_point){
3053         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3054             while(!compare(s, &(*next_point)->pkt, pkt)){
3055                 next_point= &(*next_point)->next;
3056             }
3057             goto next_non_null;
3058         }else{
3059             next_point = &(s->packet_buffer_end->next);
3060         }
3061     }
3062     assert(!*next_point);
3063
3064     s->packet_buffer_end= this_pktl;
3065 next_non_null:
3066
3067     this_pktl->next= *next_point;
3068
3069     s->streams[pkt->stream_index]->last_in_packet_buffer=
3070     *next_point= this_pktl;
3071 }
3072
3073 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3074 {
3075     AVStream *st = s->streams[ pkt ->stream_index];
3076     AVStream *st2= s->streams[ next->stream_index];
3077     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3078                              st->time_base);
3079
3080     if (comp == 0)
3081         return pkt->stream_index < next->stream_index;
3082     return comp > 0;
3083 }
3084
3085 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3086     AVPacketList *pktl;
3087     int stream_count=0;
3088     int i;
3089
3090     if(pkt){
3091         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3092     }
3093
3094     for(i=0; i < s->nb_streams; i++)
3095         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3096
3097     if(stream_count && (s->nb_streams == stream_count || flush)){
3098         pktl= s->packet_buffer;
3099         *out= pktl->pkt;
3100
3101         s->packet_buffer= pktl->next;
3102         if(!s->packet_buffer)
3103             s->packet_buffer_end= NULL;
3104
3105         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3106             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3107         av_freep(&pktl);
3108         return 1;
3109     }else{
3110         av_init_packet(out);
3111         return 0;
3112     }
3113 }
3114
3115 /**
3116  * Interleave an AVPacket correctly so it can be muxed.
3117  * @param out the interleaved packet will be output here
3118  * @param in the input packet
3119  * @param flush 1 if no further packets are available as input and all
3120  *              remaining packets should be output
3121  * @return 1 if a packet was output, 0 if no packet could be output,
3122  *         < 0 if an error occurred
3123  */
3124 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3125     if(s->oformat->interleave_packet)
3126         return s->oformat->interleave_packet(s, out, in, flush);
3127     else
3128         return av_interleave_packet_per_dts(s, out, in, flush);
3129 }
3130
3131 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3132     AVStream *st= s->streams[ pkt->stream_index];
3133     int ret;
3134
3135     //FIXME/XXX/HACK drop zero sized packets
3136     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3137         return 0;
3138
3139     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3140             pkt->size, pkt->dts, pkt->pts);
3141     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3142         return ret;
3143
3144     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3145         return AVERROR(EINVAL);
3146
3147     for(;;){
3148         AVPacket opkt;
3149         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3150         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3151             return ret;
3152
3153         ret= s->oformat->write_packet(s, &opkt);
3154         if (ret >= 0)
3155             s->streams[opkt.stream_index]->nb_frames++;
3156
3157         av_free_packet(&opkt);
3158         pkt= NULL;
3159
3160         if(ret<0)
3161             return ret;
3162     }
3163 }
3164
3165 int av_write_trailer(AVFormatContext *s)
3166 {
3167     int ret, i;
3168
3169     for(;;){
3170         AVPacket pkt;
3171         ret= av_interleave_packet(s, &pkt, NULL, 1);
3172         if(ret<0) //FIXME cleanup needed for ret<0 ?
3173             goto fail;
3174         if(!ret)
3175             break;
3176
3177         ret= s->oformat->write_packet(s, &pkt);
3178         if (ret >= 0)
3179             s->streams[pkt.stream_index]->nb_frames++;
3180
3181         av_free_packet(&pkt);
3182
3183         if(ret<0)
3184             goto fail;
3185     }
3186
3187     if(s->oformat->write_trailer)
3188         ret = s->oformat->write_trailer(s);
3189 fail:
3190     for(i=0;i<s->nb_streams;i++) {
3191         av_freep(&s->streams[i]->priv_data);
3192         av_freep(&s->streams[i]->index_entries);
3193     }
3194     if (s->iformat && s->iformat->priv_class)
3195         av_opt_free(s->priv_data);
3196     av_freep(&s->priv_data);
3197     return ret;
3198 }
3199
3200 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3201 {
3202     int i, j;
3203     AVProgram *program=NULL;
3204     void *tmp;
3205
3206     if (idx >= ac->nb_streams) {
3207         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3208         return;
3209     }
3210
3211     for(i=0; i<ac->nb_programs; i++){
3212         if(ac->programs[i]->id != progid)
3213             continue;
3214         program = ac->programs[i];
3215         for(j=0; j<program->nb_stream_indexes; j++)
3216             if(program->stream_index[j] == idx)
3217                 return;
3218
3219         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3220         if(!tmp)
3221             return;
3222         program->stream_index = tmp;
3223         program->stream_index[program->nb_stream_indexes++] = idx;
3224         return;
3225     }
3226 }
3227
3228 static void print_fps(double d, const char *postfix){
3229     uint64_t v= lrintf(d*100);
3230     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3231     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3232     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3233 }
3234
3235 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3236 {
3237     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3238         AVDictionaryEntry *tag=NULL;
3239
3240         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3241         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3242             if(strcmp("language", tag->key))
3243                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3244         }
3245     }
3246 }
3247
3248 /* "user interface" functions */
3249 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3250 {
3251     char buf[256];
3252     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3253     AVStream *st = ic->streams[i];
3254     int g = av_gcd(st->time_base.num, st->time_base.den);
3255     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3256     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3257     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3258     /* the pid is an important information, so we display it */
3259     /* XXX: add a generic system */
3260     if (flags & AVFMT_SHOW_IDS)
3261         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3262     if (lang)
3263         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3264     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3265     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3266     if (st->sample_aspect_ratio.num && // default
3267         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3268         AVRational display_aspect_ratio;
3269         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3270                   st->codec->width*st->sample_aspect_ratio.num,
3271                   st->codec->height*st->sample_aspect_ratio.den,
3272                   1024*1024);
3273         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3274                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3275                  display_aspect_ratio.num, display_aspect_ratio.den);
3276     }
3277     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3278         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3279             print_fps(av_q2d(st->avg_frame_rate), "fps");
3280         if(st->r_frame_rate.den && st->r_frame_rate.num)
3281             print_fps(av_q2d(st->r_frame_rate), "tbr");
3282         if(st->time_base.den && st->time_base.num)
3283             print_fps(1/av_q2d(st->time_base), "tbn");
3284         if(st->codec->time_base.den && st->codec->time_base.num)
3285             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3286     }
3287     if (st->disposition & AV_DISPOSITION_DEFAULT)
3288         av_log(NULL, AV_LOG_INFO, " (default)");
3289     if (st->disposition & AV_DISPOSITION_DUB)
3290         av_log(NULL, AV_LOG_INFO, " (dub)");
3291     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3292         av_log(NULL, AV_LOG_INFO, " (original)");
3293     if (st->disposition & AV_DISPOSITION_COMMENT)
3294         av_log(NULL, AV_LOG_INFO, " (comment)");
3295     if (st->disposition & AV_DISPOSITION_LYRICS)
3296         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3297     if (st->disposition & AV_DISPOSITION_KARAOKE)
3298         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3299     if (st->disposition & AV_DISPOSITION_FORCED)
3300         av_log(NULL, AV_LOG_INFO, " (forced)");
3301     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3302         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3303     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3304         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3305     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3306         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3307     av_log(NULL, AV_LOG_INFO, "\n");
3308     dump_metadata(NULL, st->metadata, "    ");
3309 }
3310
3311 #if FF_API_DUMP_FORMAT
3312 void dump_format(AVFormatContext *ic,
3313                  int index,
3314                  const char *url,
3315                  int is_output)
3316 {
3317     av_dump_format(ic, index, url, is_output);
3318 }
3319 #endif
3320
3321 void av_dump_format(AVFormatContext *ic,
3322                     int index,
3323                     const char *url,
3324                     int is_output)
3325 {
3326     int i;
3327     uint8_t *printed = av_mallocz(ic->nb_streams);
3328     if (ic->nb_streams && !printed)
3329         return;
3330
3331     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3332             is_output ? "Output" : "Input",
3333             index,
3334             is_output ? ic->oformat->name : ic->iformat->name,
3335             is_output ? "to" : "from", url);
3336     dump_metadata(NULL, ic->metadata, "  ");
3337     if (!is_output) {
3338         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3339         if (ic->duration != AV_NOPTS_VALUE) {
3340             int hours, mins, secs, us;
3341             secs = ic->duration / AV_TIME_BASE;
3342             us = ic->duration % AV_TIME_BASE;
3343             mins = secs / 60;
3344             secs %= 60;
3345             hours = mins / 60;
3346             mins %= 60;
3347             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3348                    (100 * us) / AV_TIME_BASE);
3349         } else {
3350             av_log(NULL, AV_LOG_INFO, "N/A");
3351         }
3352         if (ic->start_time != AV_NOPTS_VALUE) {
3353             int secs, us;
3354             av_log(NULL, AV_LOG_INFO, ", start: ");
3355             secs = ic->start_time / AV_TIME_BASE;
3356             us = abs(ic->start_time % AV_TIME_BASE);
3357             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3358                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3359         }
3360         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3361         if (ic->bit_rate) {
3362             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3363         } else {
3364             av_log(NULL, AV_LOG_INFO, "N/A");
3365         }
3366         av_log(NULL, AV_LOG_INFO, "\n");
3367     }
3368     for (i = 0; i < ic->nb_chapters; i++) {
3369         AVChapter *ch = ic->chapters[i];
3370         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3371         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3372         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3373
3374         dump_metadata(NULL, ch->metadata, "    ");
3375     }
3376     if(ic->nb_programs) {
3377         int j, k, total = 0;
3378         for(j=0; j<ic->nb_programs; j++) {
3379             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3380                                                   "name", NULL, 0);
3381             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3382                    name ? name->value : "");
3383             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3384             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3385                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3386                 printed[ic->programs[j]->stream_index[k]] = 1;
3387             }
3388             total += ic->programs[j]->nb_stream_indexes;
3389         }
3390         if (total < ic->nb_streams)
3391             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3392     }
3393     for(i=0;i<ic->nb_streams;i++)
3394         if (!printed[i])
3395             dump_stream_format(ic, i, index, is_output);
3396
3397     av_free(printed);
3398 }
3399
3400 int64_t av_gettime(void)
3401 {
3402     struct timeval tv;
3403     gettimeofday(&tv,NULL);
3404     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3405 }
3406
3407 uint64_t ff_ntp_time(void)
3408 {
3409   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3410 }
3411
3412 #if FF_API_PARSE_DATE
3413 #include "libavutil/parseutils.h"
3414
3415 int64_t parse_date(const char *timestr, int duration)
3416 {
3417     int64_t timeval;
3418     av_parse_time(&timeval, timestr, duration);
3419     return timeval;
3420 }
3421 #endif
3422
3423 #if FF_API_FIND_INFO_TAG
3424 #include "libavutil/parseutils.h"
3425
3426 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3427 {
3428     return av_find_info_tag(arg, arg_size, tag1, info);
3429 }
3430 #endif
3431
3432 int av_get_frame_filename(char *buf, int buf_size,
3433                           const char *path, int number)
3434 {
3435     const char *p;
3436     char *q, buf1[20], c;
3437     int nd, len, percentd_found;
3438
3439     q = buf;
3440     p = path;
3441     percentd_found = 0;
3442     for(;;) {
3443         c = *p++;
3444         if (c == '\0')
3445             break;
3446         if (c == '%') {
3447             do {
3448                 nd = 0;
3449                 while (isdigit(*p)) {
3450                     nd = nd * 10 + *p++ - '0';
3451                 }
3452                 c = *p++;
3453             } while (isdigit(c));
3454
3455             switch(c) {
3456             case '%':
3457                 goto addchar;
3458             case 'd':
3459                 if (percentd_found)
3460                     goto fail;
3461                 percentd_found = 1;
3462                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3463                 len = strlen(buf1);
3464                 if ((q - buf + len) > buf_size - 1)
3465                     goto fail;
3466                 memcpy(q, buf1, len);
3467                 q += len;
3468                 break;
3469             default:
3470                 goto fail;
3471             }
3472         } else {
3473         addchar:
3474             if ((q - buf) < buf_size - 1)
3475                 *q++ = c;
3476         }
3477     }
3478     if (!percentd_found)
3479         goto fail;
3480     *q = '\0';
3481     return 0;
3482  fail:
3483     *q = '\0';
3484     return -1;
3485 }
3486
3487 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3488 {
3489     int len, i, j, c;
3490 #undef fprintf
3491 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3492
3493     for(i=0;i<size;i+=16) {
3494         len = size - i;
3495         if (len > 16)
3496             len = 16;
3497         PRINT("%08x ", i);
3498         for(j=0;j<16;j++) {
3499             if (j < len)
3500                 PRINT(" %02x", buf[i+j]);
3501             else
3502                 PRINT("   ");
3503         }
3504         PRINT(" ");
3505         for(j=0;j<len;j++) {
3506             c = buf[i+j];
3507             if (c < ' ' || c > '~')
3508                 c = '.';
3509             PRINT("%c", c);
3510         }
3511         PRINT("\n");
3512     }
3513 #undef PRINT
3514 }
3515
3516 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3517 {
3518     hex_dump_internal(NULL, f, 0, buf, size);
3519 }
3520
3521 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3522 {
3523     hex_dump_internal(avcl, NULL, level, buf, size);
3524 }
3525
3526 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3527 {
3528 #undef fprintf
3529 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3530     PRINT("stream #%d:\n", pkt->stream_index);
3531     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3532     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3533     /* DTS is _always_ valid after av_read_frame() */
3534     PRINT("  dts=");
3535     if (pkt->dts == AV_NOPTS_VALUE)
3536         PRINT("N/A");
3537     else
3538         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3539     /* PTS may not be known if B-frames are present. */
3540     PRINT("  pts=");
3541     if (pkt->pts == AV_NOPTS_VALUE)
3542         PRINT("N/A");
3543     else
3544         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3545     PRINT("\n");
3546     PRINT("  size=%d\n", pkt->size);
3547 #undef PRINT
3548     if (dump_payload)
3549         av_hex_dump(f, pkt->data, pkt->size);
3550 }
3551
3552 #if FF_API_PKT_DUMP
3553 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3554 {
3555     AVRational tb = { 1, AV_TIME_BASE };
3556     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3557 }
3558 #endif
3559
3560 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3561 {
3562     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3563 }
3564
3565 #if FF_API_PKT_DUMP
3566 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3567 {
3568     AVRational tb = { 1, AV_TIME_BASE };
3569     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3570 }
3571 #endif
3572
3573 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3574                       AVStream *st)
3575 {
3576     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3577 }
3578
3579 void av_url_split(char *proto, int proto_size,
3580                   char *authorization, int authorization_size,
3581                   char *hostname, int hostname_size,
3582                   int *port_ptr,
3583                   char *path, int path_size,
3584                   const char *url)
3585 {
3586     const char *p, *ls, *at, *col, *brk;
3587
3588     if (port_ptr)               *port_ptr = -1;
3589     if (proto_size > 0)         proto[0] = 0;
3590     if (authorization_size > 0) authorization[0] = 0;
3591     if (hostname_size > 0)      hostname[0] = 0;
3592     if (path_size > 0)          path[0] = 0;
3593
3594     /* parse protocol */
3595     if ((p = strchr(url, ':'))) {
3596         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3597         p++; /* skip ':' */
3598         if (*p == '/') p++;
3599         if (*p == '/') p++;
3600     } else {
3601         /* no protocol means plain filename */
3602         av_strlcpy(path, url, path_size);
3603         return;
3604     }
3605
3606     /* separate path from hostname */
3607     ls = strchr(p, '/');
3608     if(!ls)
3609         ls = strchr(p, '?');
3610     if(ls)
3611         av_strlcpy(path, ls, path_size);
3612     else
3613         ls = &p[strlen(p)]; // XXX
3614
3615     /* the rest is hostname, use that to parse auth/port */
3616     if (ls != p) {
3617         /* authorization (user[:pass]@hostname) */
3618         if ((at = strchr(p, '@')) && at < ls) {
3619             av_strlcpy(authorization, p,
3620                        FFMIN(authorization_size, at + 1 - p));
3621             p = at + 1; /* skip '@' */
3622         }
3623
3624         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3625             /* [host]:port */
3626             av_strlcpy(hostname, p + 1,
3627                        FFMIN(hostname_size, brk - p));
3628             if (brk[1] == ':' && port_ptr)
3629                 *port_ptr = atoi(brk + 2);
3630         } else if ((col = strchr(p, ':')) && col < ls) {
3631             av_strlcpy(hostname, p,
3632                        FFMIN(col + 1 - p, hostname_size));
3633             if (port_ptr) *port_ptr = atoi(col + 1);
3634         } else
3635             av_strlcpy(hostname, p,
3636                        FFMIN(ls + 1 - p, hostname_size));
3637     }
3638 }
3639
3640 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3641 {
3642     int i;
3643     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3644                                            '4', '5', '6', '7',
3645                                            '8', '9', 'A', 'B',
3646                                            'C', 'D', 'E', 'F' };
3647     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3648                                            '4', '5', '6', '7',
3649                                            '8', '9', 'a', 'b',
3650                                            'c', 'd', 'e', 'f' };
3651     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3652
3653     for(i = 0; i < s; i++) {
3654         buff[i * 2]     = hex_table[src[i] >> 4];
3655         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3656     }
3657
3658     return buff;
3659 }
3660
3661 int ff_hex_to_data(uint8_t *data, const char *p)
3662 {
3663     int c, len, v;
3664
3665     len = 0;
3666     v = 1;
3667     for (;;) {
3668         p += strspn(p, SPACE_CHARS);
3669         if (*p == '\0')
3670             break;
3671         c = toupper((unsigned char) *p++);
3672         if (c >= '0' && c <= '9')
3673             c = c - '0';
3674         else if (c >= 'A' && c <= 'F')
3675             c = c - 'A' + 10;
3676         else
3677             break;
3678         v = (v << 4) | c;
3679         if (v & 0x100) {
3680             if (data)
3681                 data[len] = v;
3682             len++;
3683             v = 1;
3684         }
3685     }
3686     return len;
3687 }
3688
3689 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3690                      unsigned int pts_num, unsigned int pts_den)
3691 {
3692     AVRational new_tb;
3693     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3694         if(new_tb.num != pts_num)
3695             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3696     }else
3697         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3698
3699     if(new_tb.num <= 0 || new_tb.den <= 0) {
3700         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3701         return;
3702     }
3703     s->time_base = new_tb;
3704     s->pts_wrap_bits = pts_wrap_bits;
3705 }
3706
3707 int ff_url_join(char *str, int size, const char *proto,
3708                 const char *authorization, const char *hostname,
3709                 int port, const char *fmt, ...)
3710 {
3711 #if CONFIG_NETWORK
3712     struct addrinfo hints, *ai;
3713 #endif
3714
3715     str[0] = '\0';
3716     if (proto)
3717         av_strlcatf(str, size, "%s://", proto);
3718     if (authorization && authorization[0])
3719         av_strlcatf(str, size, "%s@", authorization);
3720 #if CONFIG_NETWORK && defined(AF_INET6)
3721     /* Determine if hostname is a numerical IPv6 address,
3722      * properly escape it within [] in that case. */
3723     memset(&hints, 0, sizeof(hints));
3724     hints.ai_flags = AI_NUMERICHOST;
3725     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3726         if (ai->ai_family == AF_INET6) {
3727             av_strlcat(str, "[", size);
3728             av_strlcat(str, hostname, size);
3729             av_strlcat(str, "]", size);
3730         } else {
3731             av_strlcat(str, hostname, size);
3732         }
3733         freeaddrinfo(ai);
3734     } else
3735 #endif
3736         /* Not an IPv6 address, just output the plain string. */
3737         av_strlcat(str, hostname, size);
3738
3739     if (port >= 0)
3740         av_strlcatf(str, size, ":%d", port);
3741     if (fmt) {
3742         va_list vl;
3743         int len = strlen(str);
3744
3745         va_start(vl, fmt);
3746         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3747         va_end(vl);
3748     }
3749     return strlen(str);
3750 }
3751
3752 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3753                      AVFormatContext *src)
3754 {
3755     AVPacket local_pkt;
3756
3757     local_pkt = *pkt;
3758     local_pkt.stream_index = dst_stream;
3759     if (pkt->pts != AV_NOPTS_VALUE)
3760         local_pkt.pts = av_rescale_q(pkt->pts,
3761                                      src->streams[pkt->stream_index]->time_base,
3762                                      dst->streams[dst_stream]->time_base);
3763     if (pkt->dts != AV_NOPTS_VALUE)
3764         local_pkt.dts = av_rescale_q(pkt->dts,
3765                                      src->streams[pkt->stream_index]->time_base,
3766                                      dst->streams[dst_stream]->time_base);
3767     return av_write_frame(dst, &local_pkt);
3768 }
3769
3770 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3771                         void *context)
3772 {
3773     const char *ptr = str;
3774
3775     /* Parse key=value pairs. */
3776     for (;;) {
3777         const char *key;
3778         char *dest = NULL, *dest_end;
3779         int key_len, dest_len = 0;
3780
3781         /* Skip whitespace and potential commas. */
3782         while (*ptr && (isspace(*ptr) || *ptr == ','))
3783             ptr++;
3784         if (!*ptr)
3785             break;
3786
3787         key = ptr;
3788
3789         if (!(ptr = strchr(key, '=')))
3790             break;
3791         ptr++;
3792         key_len = ptr - key;
3793
3794         callback_get_buf(context, key, key_len, &dest, &dest_len);
3795         dest_end = dest + dest_len - 1;
3796
3797         if (*ptr == '\"') {
3798             ptr++;
3799             while (*ptr && *ptr != '\"') {
3800                 if (*ptr == '\\') {
3801                     if (!ptr[1])
3802                         break;
3803                     if (dest && dest < dest_end)
3804                         *dest++ = ptr[1];
3805                     ptr += 2;
3806                 } else {
3807                     if (dest && dest < dest_end)
3808                         *dest++ = *ptr;
3809                     ptr++;
3810                 }
3811             }
3812             if (*ptr == '\"')
3813                 ptr++;
3814         } else {
3815             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3816                 if (dest && dest < dest_end)
3817                     *dest++ = *ptr;
3818         }
3819         if (dest)
3820             *dest = 0;
3821     }
3822 }
3823
3824 int ff_find_stream_index(AVFormatContext *s, int id)
3825 {
3826     int i;
3827     for (i = 0; i < s->nb_streams; i++) {
3828         if (s->streams[i]->id == id)
3829             return i;
3830     }
3831     return -1;
3832 }
3833
3834 void ff_make_absolute_url(char *buf, int size, const char *base,
3835                           const char *rel)
3836 {
3837     char *sep;
3838     /* Absolute path, relative to the current server */
3839     if (base && strstr(base, "://") && rel[0] == '/') {
3840         if (base != buf)
3841             av_strlcpy(buf, base, size);
3842         sep = strstr(buf, "://");
3843         if (sep) {
3844             sep += 3;
3845             sep = strchr(sep, '/');
3846             if (sep)
3847                 *sep = '\0';
3848         }
3849         av_strlcat(buf, rel, size);
3850         return;
3851     }
3852     /* If rel actually is an absolute url, just copy it */
3853     if (!base || strstr(rel, "://") || rel[0] == '/') {
3854         av_strlcpy(buf, rel, size);
3855         return;
3856     }
3857     if (base != buf)
3858         av_strlcpy(buf, base, size);
3859     /* Remove the file name from the base url */
3860     sep = strrchr(buf, '/');
3861     if (sep)
3862         sep[1] = '\0';
3863     else
3864         buf[0] = '\0';
3865     while (av_strstart(rel, "../", NULL) && sep) {
3866         /* Remove the path delimiter at the end */
3867         sep[0] = '\0';
3868         sep = strrchr(buf, '/');
3869         /* If the next directory name to pop off is "..", break here */
3870         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3871             /* Readd the slash we just removed */
3872             av_strlcat(buf, "/", size);
3873             break;
3874         }
3875         /* Cut off the directory name */
3876         if (sep)
3877             sep[1] = '\0';
3878         else
3879             buf[0] = '\0';
3880         rel += 3;
3881     }
3882     av_strlcat(buf, rel, size);
3883 }
3884
3885 int64_t ff_iso8601_to_unix_time(const char *datestr)
3886 {
3887 #if HAVE_STRPTIME
3888     struct tm time = {0};
3889     strptime(datestr, "%Y - %m - %dT%T", &time);
3890     return mktime(&time);
3891 #else
3892     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3893                                  "the date string.\n");
3894     return 0;
3895 #endif
3896 }