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