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