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

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