libavformat/utils.c

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