git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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