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

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