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