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