libavformat/utils.c

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