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