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
2211         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2212             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2213 /*            if(!st->time_base.num)
2214                 st->time_base= */
2215             if(!st->codec->time_base.num)
2216                 st->codec->time_base= st->time_base;
2217         }
2218         //only for the split stuff
2219         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2220             st->parser = av_parser_init(st->codec->codec_id);
2221             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2222                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2223             }
2224         }
2225         assert(!st->codec->codec);
2226         codec = avcodec_find_decoder(st->codec->codec_id);
2227
2228         /* Ensure that subtitle_header is properly set. */
2229         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2230             && codec && !st->codec->codec)
2231             avcodec_open(st->codec, codec);
2232
2233         //try to just open decoders, in case this is enough to get parameters
2234         if(!has_codec_parameters(st->codec)){
2235             if (codec && !st->codec->codec)
2236                 avcodec_open(st->codec, codec);
2237         }
2238     }
2239
2240     for (i=0; i<ic->nb_streams; i++) {
2241         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2242     }
2243
2244     count = 0;
2245     read_size = 0;
2246     for(;;) {
2247         if(url_interrupt_cb()){
2248             ret= AVERROR_EXIT;
2249             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2250             break;
2251         }
2252
2253         /* check if one codec still needs to be handled */
2254         for(i=0;i<ic->nb_streams;i++) {
2255             int fps_analyze_framecount = 20;
2256
2257             st = ic->streams[i];
2258             if (!has_codec_parameters(st->codec))
2259                 break;
2260             /* if the timebase is coarse (like the usual millisecond precision
2261                of mkv), we need to analyze more frames to reliably arrive at
2262                the correct fps */
2263             if (av_q2d(st->time_base) > 0.0005)
2264                 fps_analyze_framecount *= 2;
2265             if (ic->fps_probe_size >= 0)
2266                 fps_analyze_framecount = ic->fps_probe_size;
2267             /* variable fps and no guess at the real fps */
2268             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2269                && st->info->duration_count < fps_analyze_framecount
2270                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2271                 break;
2272             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2273                 break;
2274             if(st->first_dts == AV_NOPTS_VALUE)
2275                 break;
2276         }
2277         if (i == ic->nb_streams) {
2278             /* NOTE: if the format has no header, then we need to read
2279                some packets to get most of the streams, so we cannot
2280                stop here */
2281             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2282                 /* if we found the info for all the codecs, we can stop */
2283                 ret = count;
2284                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2285                 break;
2286             }
2287         }
2288         /* we did not get all the codec info, but we read too much data */
2289         if (read_size >= ic->probesize) {
2290             ret = count;
2291             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2292             break;
2293         }
2294
2295         /* NOTE: a new stream can be added there if no header in file
2296            (AVFMTCTX_NOHEADER) */
2297         ret = av_read_frame_internal(ic, &pkt1);
2298         if (ret == AVERROR(EAGAIN))
2299             continue;
2300
2301         if (ret < 0) {
2302             /* EOF or error */
2303             ret = -1; /* we could not have all the codec parameters before EOF */
2304             for(i=0;i<ic->nb_streams;i++) {
2305                 st = ic->streams[i];
2306                 if (!has_codec_parameters(st->codec)){
2307                     char buf[256];
2308                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2309                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2310                 } else {
2311                     ret = 0;
2312                 }
2313             }
2314             break;
2315         }
2316
2317         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2318         if ((ret = av_dup_packet(pkt)) < 0)
2319             goto find_stream_info_err;
2320
2321         read_size += pkt->size;
2322
2323         st = ic->streams[pkt->stream_index];
2324         if (st->codec_info_nb_frames>1) {
2325             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) {
2326                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2327                 break;
2328             }
2329             st->info->codec_info_duration += pkt->duration;
2330         }
2331         {
2332             int64_t last = st->info->last_dts;
2333             int64_t duration= pkt->dts - last;
2334
2335             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2336                 double dur= duration * av_q2d(st->time_base);
2337
2338 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2339 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2340                 if (st->info->duration_count < 2)
2341                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2342                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2343                     int framerate= get_std_framerate(i);
2344                     int ticks= lrintf(dur*framerate/(1001*12));
2345                     double error= dur - ticks*1001*12/(double)framerate;
2346                     st->info->duration_error[i] += error*error;
2347                 }
2348                 st->info->duration_count++;
2349                 // ignore the first 4 values, they might have some random jitter
2350                 if (st->info->duration_count > 3)
2351                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2352             }
2353             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2354                 st->info->last_dts = pkt->dts;
2355         }
2356         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2357             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2358             if(i){
2359                 st->codec->extradata_size= i;
2360                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2361                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2362                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2363             }
2364         }
2365
2366         /* if still no information, we try to open the codec and to
2367            decompress the frame. We try to avoid that in most cases as
2368            it takes longer and uses more memory. For MPEG-4, we need to
2369            decompress for QuickTime.
2370
2371            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2372            least one frame of codec data, this makes sure the codec initializes
2373            the channel configuration and does not only trust the values from the container.
2374         */
2375         if (!has_codec_parameters(st->codec) ||
2376             !has_decode_delay_been_guessed(st) ||
2377             (st->codec->codec &&
2378              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))
2379             try_decode_frame(st, pkt);
2380
2381         st->codec_info_nb_frames++;
2382         count++;
2383     }
2384
2385     // close codecs which were opened in try_decode_frame()
2386     for(i=0;i<ic->nb_streams;i++) {
2387         st = ic->streams[i];
2388         if(st->codec->codec)
2389             avcodec_close(st->codec);
2390     }
2391     for(i=0;i<ic->nb_streams;i++) {
2392         st = ic->streams[i];
2393         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2394             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2395                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2396                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2397         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2398             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2399                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2400
2401             // the check for tb_unreliable() is not completely correct, since this is not about handling
2402             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2403             // ipmovie.c produces.
2404             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2405                 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);
2406             if (st->info->duration_count && !st->r_frame_rate.num
2407                && tb_unreliable(st->codec) /*&&
2408                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2409                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2410                 int num = 0;
2411                 double best_error= 2*av_q2d(st->time_base);
2412                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2413
2414                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2415                     double error = st->info->duration_error[j] * get_std_framerate(j);
2416 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2417 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2418                     if(error < best_error){
2419                         best_error= error;
2420                         num = get_std_framerate(j);
2421                     }
2422                 }
2423                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2424                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2425                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2426             }
2427
2428             if (!st->r_frame_rate.num){
2429                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2430                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2431                     st->r_frame_rate.num = st->codec->time_base.den;
2432                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2433                 }else{
2434                     st->r_frame_rate.num = st->time_base.den;
2435                     st->r_frame_rate.den = st->time_base.num;
2436                 }
2437             }
2438         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2439             if(!st->codec->bits_per_coded_sample)
2440                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2441             // set stream disposition based on audio service type
2442             switch (st->codec->audio_service_type) {
2443             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2444                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2445             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2446                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2447             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2448                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2449             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2450                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2451             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2452                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2453             }
2454         }
2455     }
2456
2457     av_estimate_timings(ic, old_offset);
2458
2459     compute_chapters_end(ic);
2460
2461 #if 0
2462     /* correct DTS for B-frame streams with no timestamps */
2463     for(i=0;i<ic->nb_streams;i++) {
2464         st = ic->streams[i];
2465         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2466             if(b-frames){
2467                 ppktl = &ic->packet_buffer;
2468                 while(ppkt1){
2469                     if(ppkt1->stream_index != i)
2470                         continue;
2471                     if(ppkt1->pkt->dts < 0)
2472                         break;
2473                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2474                         break;
2475                     ppkt1->pkt->dts -= delta;
2476                     ppkt1= ppkt1->next;
2477                 }
2478                 if(ppkt1)
2479                     continue;
2480                 st->cur_dts -= delta;
2481             }
2482         }
2483     }
2484 #endif
2485
2486  find_stream_info_err:
2487     for (i=0; i < ic->nb_streams; i++)
2488         av_freep(&ic->streams[i]->info);
2489     return ret;
2490 }
2491
2492 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2493 {
2494     int i, j;
2495
2496     for (i = 0; i < ic->nb_programs; i++)
2497         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2498             if (ic->programs[i]->stream_index[j] == s)
2499                 return ic->programs[i];
2500     return NULL;
2501 }
2502
2503 int av_find_best_stream(AVFormatContext *ic,
2504                         enum AVMediaType type,
2505                         int wanted_stream_nb,
2506                         int related_stream,
2507                         AVCodec **decoder_ret,
2508                         int flags)
2509 {
2510     int i, nb_streams = ic->nb_streams;
2511     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2512     unsigned *program = NULL;
2513     AVCodec *decoder = NULL, *best_decoder = NULL;
2514
2515     if (related_stream >= 0 && wanted_stream_nb < 0) {
2516         AVProgram *p = find_program_from_stream(ic, related_stream);
2517         if (p) {
2518             program = p->stream_index;
2519             nb_streams = p->nb_stream_indexes;
2520         }
2521     }
2522     for (i = 0; i < nb_streams; i++) {
2523         int real_stream_index = program ? program[i] : i;
2524         AVStream *st = ic->streams[real_stream_index];
2525         AVCodecContext *avctx = st->codec;
2526         if (avctx->codec_type != type)
2527             continue;
2528         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2529             continue;
2530         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2531             continue;
2532         if (decoder_ret) {
2533             decoder = avcodec_find_decoder(st->codec->codec_id);
2534             if (!decoder) {
2535                 if (ret < 0)
2536                     ret = AVERROR_DECODER_NOT_FOUND;
2537                 continue;
2538             }
2539         }
2540         if (best_count >= st->codec_info_nb_frames)
2541             continue;
2542         best_count = st->codec_info_nb_frames;
2543         ret = real_stream_index;
2544         best_decoder = decoder;
2545         if (program && i == nb_streams - 1 && ret < 0) {
2546             program = NULL;
2547             nb_streams = ic->nb_streams;
2548             i = 0; /* no related stream found, try again with everything */
2549         }
2550     }
2551     if (decoder_ret)
2552         *decoder_ret = best_decoder;
2553     return ret;
2554 }
2555
2556 /*******************************************************/
2557
2558 int av_read_play(AVFormatContext *s)
2559 {
2560     if (s->iformat->read_play)
2561         return s->iformat->read_play(s);
2562     if (s->pb)
2563         return avio_pause(s->pb, 0);
2564     return AVERROR(ENOSYS);
2565 }
2566
2567 int av_read_pause(AVFormatContext *s)
2568 {
2569     if (s->iformat->read_pause)
2570         return s->iformat->read_pause(s);
2571     if (s->pb)
2572         return avio_pause(s->pb, 1);
2573     return AVERROR(ENOSYS);
2574 }
2575
2576 void av_close_input_stream(AVFormatContext *s)
2577 {
2578     flush_packet_queue(s);
2579     if (s->iformat->read_close)
2580         s->iformat->read_close(s);
2581     avformat_free_context(s);
2582 }
2583
2584 void avformat_free_context(AVFormatContext *s)
2585 {
2586     int i;
2587     AVStream *st;
2588
2589     av_opt_free(s);
2590     if (s->iformat && s->iformat->priv_class && s->priv_data)
2591         av_opt_free(s->priv_data);
2592
2593     for(i=0;i<s->nb_streams;i++) {
2594         /* free all data in a stream component */
2595         st = s->streams[i];
2596         if (st->parser) {
2597             av_parser_close(st->parser);
2598             av_free_packet(&st->cur_pkt);
2599         }
2600         av_dict_free(&st->metadata);
2601         av_free(st->index_entries);
2602         av_free(st->codec->extradata);
2603         av_free(st->codec->subtitle_header);
2604         av_free(st->codec);
2605         av_free(st->priv_data);
2606         av_free(st->info);
2607         av_free(st);
2608     }
2609     for(i=s->nb_programs-1; i>=0; i--) {
2610         av_dict_free(&s->programs[i]->metadata);
2611         av_freep(&s->programs[i]->stream_index);
2612         av_freep(&s->programs[i]);
2613     }
2614     av_freep(&s->programs);
2615     av_freep(&s->priv_data);
2616     while(s->nb_chapters--) {
2617         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2618         av_free(s->chapters[s->nb_chapters]);
2619     }
2620     av_freep(&s->chapters);
2621     av_dict_free(&s->metadata);
2622     av_freep(&s->streams);
2623     av_free(s);
2624 }
2625
2626 void av_close_input_file(AVFormatContext *s)
2627 {
2628     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2629                        NULL : s->pb;
2630     av_close_input_stream(s);
2631     if (pb)
2632         avio_close(pb);
2633 }
2634
2635 AVStream *av_new_stream(AVFormatContext *s, int id)
2636 {
2637     AVStream *st;
2638     int i;
2639     AVStream **streams;
2640
2641     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2642         return NULL;
2643     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2644     if (!streams)
2645         return NULL;
2646     s->streams = streams;
2647
2648     st = av_mallocz(sizeof(AVStream));
2649     if (!st)
2650         return NULL;
2651     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2652         av_free(st);
2653         return NULL;
2654     }
2655
2656     st->codec= avcodec_alloc_context();
2657     if (s->iformat) {
2658         /* no default bitrate if decoding */
2659         st->codec->bit_rate = 0;
2660     }
2661     st->index = s->nb_streams;
2662     st->id = id;
2663     st->start_time = AV_NOPTS_VALUE;
2664     st->duration = AV_NOPTS_VALUE;
2665         /* we set the current DTS to 0 so that formats without any timestamps
2666            but durations get some timestamps, formats with some unknown
2667            timestamps have their first few packets buffered and the
2668            timestamps corrected before they are returned to the user */
2669     st->cur_dts = 0;
2670     st->first_dts = AV_NOPTS_VALUE;
2671     st->probe_packets = MAX_PROBE_PACKETS;
2672
2673     /* default pts setting is MPEG-like */
2674     av_set_pts_info(st, 33, 1, 90000);
2675     st->last_IP_pts = AV_NOPTS_VALUE;
2676     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2677         st->pts_buffer[i]= AV_NOPTS_VALUE;
2678     st->reference_dts = AV_NOPTS_VALUE;
2679
2680     st->sample_aspect_ratio = (AVRational){0,1};
2681
2682     s->streams[s->nb_streams++] = st;
2683     return st;
2684 }
2685
2686 AVProgram *av_new_program(AVFormatContext *ac, int id)
2687 {
2688     AVProgram *program=NULL;
2689     int i;
2690
2691     av_dlog(ac, "new_program: id=0x%04x\n", id);
2692
2693     for(i=0; i<ac->nb_programs; i++)
2694         if(ac->programs[i]->id == id)
2695             program = ac->programs[i];
2696
2697     if(!program){
2698         program = av_mallocz(sizeof(AVProgram));
2699         if (!program)
2700             return NULL;
2701         dynarray_add(&ac->programs, &ac->nb_programs, program);
2702         program->discard = AVDISCARD_NONE;
2703     }
2704     program->id = id;
2705
2706     return program;
2707 }
2708
2709 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2710 {
2711     AVChapter *chapter = NULL;
2712     int i;
2713
2714     for(i=0; i<s->nb_chapters; i++)
2715         if(s->chapters[i]->id == id)
2716             chapter = s->chapters[i];
2717
2718     if(!chapter){
2719         chapter= av_mallocz(sizeof(AVChapter));
2720         if(!chapter)
2721             return NULL;
2722         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2723     }
2724     av_dict_set(&chapter->metadata, "title", title, 0);
2725     chapter->id    = id;
2726     chapter->time_base= time_base;
2727     chapter->start = start;
2728     chapter->end   = end;
2729
2730     return chapter;
2731 }
2732
2733 /************************************************************/
2734 /* output media file */
2735
2736 #if FF_API_FORMAT_PARAMETERS
2737 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2738 {
2739     int ret;
2740
2741     if (s->oformat->priv_data_size > 0) {
2742         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2743         if (!s->priv_data)
2744             return AVERROR(ENOMEM);
2745         if (s->oformat->priv_class) {
2746             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2747             av_opt_set_defaults(s->priv_data);
2748         }
2749     } else
2750         s->priv_data = NULL;
2751
2752     if (s->oformat->set_parameters) {
2753         ret = s->oformat->set_parameters(s, ap);
2754         if (ret < 0)
2755             return ret;
2756     }
2757     return 0;
2758 }
2759 #endif
2760
2761 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2762 {
2763     const AVCodecTag *avctag;
2764     int n;
2765     enum CodecID id = CODEC_ID_NONE;
2766     unsigned int tag = 0;
2767
2768     /**
2769      * Check that tag + id is in the table
2770      * If neither is in the table -> OK
2771      * If tag is in the table with another id -> FAIL
2772      * If id is in the table with another tag -> FAIL unless strict < normal
2773      */
2774     for (n = 0; s->oformat->codec_tag[n]; n++) {
2775         avctag = s->oformat->codec_tag[n];
2776         while (avctag->id != CODEC_ID_NONE) {
2777             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2778                 id = avctag->id;
2779                 if (id == st->codec->codec_id)
2780                     return 1;
2781             }
2782             if (avctag->id == st->codec->codec_id)
2783                 tag = avctag->tag;
2784             avctag++;
2785         }
2786     }
2787     if (id != CODEC_ID_NONE)
2788         return 0;
2789     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2790         return 0;
2791     return 1;
2792 }
2793
2794 #if FF_API_FORMAT_PARAMETERS
2795 int av_write_header(AVFormatContext *s)
2796 {
2797     return avformat_write_header(s, NULL);
2798 }
2799 #endif
2800
2801 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2802 {
2803     int ret = 0, i;
2804     AVStream *st;
2805     AVDictionary *tmp = NULL;
2806
2807     if (options)
2808         av_dict_copy(&tmp, *options, 0);
2809     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2810         goto fail;
2811
2812     // some sanity checks
2813     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2814         av_log(s, AV_LOG_ERROR, "no streams\n");
2815         ret = AVERROR(EINVAL);
2816         goto fail;
2817     }
2818
2819     for(i=0;i<s->nb_streams;i++) {
2820         st = s->streams[i];
2821
2822         switch (st->codec->codec_type) {
2823         case AVMEDIA_TYPE_AUDIO:
2824             if(st->codec->sample_rate<=0){
2825                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2826                 ret = AVERROR(EINVAL);
2827                 goto fail;
2828             }
2829             if(!st->codec->block_align)
2830                 st->codec->block_align = st->codec->channels *
2831                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2832             break;
2833         case AVMEDIA_TYPE_VIDEO:
2834             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2835                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2836                 ret = AVERROR(EINVAL);
2837                 goto fail;
2838             }
2839             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2840                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2841                 ret = AVERROR(EINVAL);
2842                 goto fail;
2843             }
2844             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2845                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2846                 ret = AVERROR(EINVAL);
2847                 goto fail;
2848             }
2849             break;
2850         }
2851
2852         if(s->oformat->codec_tag){
2853             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)){
2854                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2855                 st->codec->codec_tag= 0;
2856             }
2857             if(st->codec->codec_tag){
2858                 if (!validate_codec_tag(s, st)) {
2859                     char tagbuf[32];
2860                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2861                     av_log(s, AV_LOG_ERROR,
2862                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2863                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2864                     ret = AVERROR_INVALIDDATA;
2865                     goto fail;
2866                 }
2867             }else
2868                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2869         }
2870
2871         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2872             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2873           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2874     }
2875
2876     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2877         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2878         if (!s->priv_data) {
2879             ret = AVERROR(ENOMEM);
2880             goto fail;
2881         }
2882         if (s->oformat->priv_class) {
2883             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2884             av_opt_set_defaults(s->priv_data);
2885             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2886                 goto fail;
2887         }
2888     }
2889
2890     /* set muxer identification string */
2891     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2892         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2893     }
2894
2895     if(s->oformat->write_header){
2896         ret = s->oformat->write_header(s);
2897         if (ret < 0)
2898             goto fail;
2899     }
2900
2901     /* init PTS generation */
2902     for(i=0;i<s->nb_streams;i++) {
2903         int64_t den = AV_NOPTS_VALUE;
2904         st = s->streams[i];
2905
2906         switch (st->codec->codec_type) {
2907         case AVMEDIA_TYPE_AUDIO:
2908             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2909             break;
2910         case AVMEDIA_TYPE_VIDEO:
2911             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2912             break;
2913         default:
2914             break;
2915         }
2916         if (den != AV_NOPTS_VALUE) {
2917             if (den <= 0) {
2918                 ret = AVERROR_INVALIDDATA;
2919                 goto fail;
2920             }
2921             av_frac_init(&st->pts, 0, 0, den);
2922         }
2923     }
2924
2925     if (options) {
2926         av_dict_free(options);
2927         *options = tmp;
2928     }
2929     return 0;
2930 fail:
2931     av_dict_free(&tmp);
2932     return ret;
2933 }
2934
2935 //FIXME merge with compute_pkt_fields
2936 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2937     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2938     int num, den, frame_size, i;
2939
2940     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2941             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2942
2943 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2944         return AVERROR(EINVAL);*/
2945
2946     /* duration field */
2947     if (pkt->duration == 0) {
2948         compute_frame_duration(&num, &den, st, NULL, pkt);
2949         if (den && num) {
2950             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2951         }
2952     }
2953
2954     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2955         pkt->pts= pkt->dts;
2956
2957     //XXX/FIXME this is a temporary hack until all encoders output pts
2958     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2959         pkt->dts=
2960 //        pkt->pts= st->cur_dts;
2961         pkt->pts= st->pts.val;
2962     }
2963
2964     //calculate dts from pts
2965     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2966         st->pts_buffer[0]= pkt->pts;
2967         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2968             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2969         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2970             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2971
2972         pkt->dts= st->pts_buffer[0];
2973     }
2974
2975     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2976         av_log(s, AV_LOG_ERROR,
2977                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2978                st->index, st->cur_dts, pkt->dts);
2979         return AVERROR(EINVAL);
2980     }
2981     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2982         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2983         return AVERROR(EINVAL);
2984     }
2985
2986 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2987     st->cur_dts= pkt->dts;
2988     st->pts.val= pkt->dts;
2989
2990     /* update pts */
2991     switch (st->codec->codec_type) {
2992     case AVMEDIA_TYPE_AUDIO:
2993         frame_size = get_audio_frame_size(st->codec, pkt->size);
2994
2995         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2996            likely equal to the encoder delay, but it would be better if we
2997            had the real timestamps from the encoder */
2998         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2999             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3000         }
3001         break;
3002     case AVMEDIA_TYPE_VIDEO:
3003         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3004         break;
3005     default:
3006         break;
3007     }
3008     return 0;
3009 }
3010
3011 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3012 {
3013     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3014
3015     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3016         return ret;
3017
3018     ret= s->oformat->write_packet(s, pkt);
3019     return ret;
3020 }
3021
3022 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3023                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3024 {
3025     AVPacketList **next_point, *this_pktl;
3026
3027     this_pktl = av_mallocz(sizeof(AVPacketList));
3028     this_pktl->pkt= *pkt;
3029     pkt->destruct= NULL;             // do not free original but only the copy
3030     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3031
3032     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3033         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3034     }else
3035         next_point = &s->packet_buffer;
3036
3037     if(*next_point){
3038         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3039             while(!compare(s, &(*next_point)->pkt, pkt)){
3040                 next_point= &(*next_point)->next;
3041             }
3042             goto next_non_null;
3043         }else{
3044             next_point = &(s->packet_buffer_end->next);
3045         }
3046     }
3047     assert(!*next_point);
3048
3049     s->packet_buffer_end= this_pktl;
3050 next_non_null:
3051
3052     this_pktl->next= *next_point;
3053
3054     s->streams[pkt->stream_index]->last_in_packet_buffer=
3055     *next_point= this_pktl;
3056 }
3057
3058 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3059 {
3060     AVStream *st = s->streams[ pkt ->stream_index];
3061     AVStream *st2= s->streams[ next->stream_index];
3062     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3063                              st->time_base);
3064
3065     if (comp == 0)
3066         return pkt->stream_index < next->stream_index;
3067     return comp > 0;
3068 }
3069
3070 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3071     AVPacketList *pktl;
3072     int stream_count=0;
3073     int i;
3074
3075     if(pkt){
3076         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3077     }
3078
3079     for(i=0; i < s->nb_streams; i++)
3080         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3081
3082     if(stream_count && (s->nb_streams == stream_count || flush)){
3083         pktl= s->packet_buffer;
3084         *out= pktl->pkt;
3085
3086         s->packet_buffer= pktl->next;
3087         if(!s->packet_buffer)
3088             s->packet_buffer_end= NULL;
3089
3090         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3091             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3092         av_freep(&pktl);
3093         return 1;
3094     }else{
3095         av_init_packet(out);
3096         return 0;
3097     }
3098 }
3099
3100 /**
3101  * Interleave an AVPacket correctly so it can be muxed.
3102  * @param out the interleaved packet will be output here
3103  * @param in the input packet
3104  * @param flush 1 if no further packets are available as input and all
3105  *              remaining packets should be output
3106  * @return 1 if a packet was output, 0 if no packet could be output,
3107  *         < 0 if an error occurred
3108  */
3109 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3110     if(s->oformat->interleave_packet)
3111         return s->oformat->interleave_packet(s, out, in, flush);
3112     else
3113         return av_interleave_packet_per_dts(s, out, in, flush);
3114 }
3115
3116 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3117     AVStream *st= s->streams[ pkt->stream_index];
3118     int ret;
3119
3120     //FIXME/XXX/HACK drop zero sized packets
3121     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3122         return 0;
3123
3124     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3125             pkt->size, pkt->dts, pkt->pts);
3126     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3127         return ret;
3128
3129     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3130         return AVERROR(EINVAL);
3131
3132     for(;;){
3133         AVPacket opkt;
3134         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3135         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3136             return ret;
3137
3138         ret= s->oformat->write_packet(s, &opkt);
3139
3140         av_free_packet(&opkt);
3141         pkt= NULL;
3142
3143         if(ret<0)
3144             return ret;
3145     }
3146 }
3147
3148 int av_write_trailer(AVFormatContext *s)
3149 {
3150     int ret, i;
3151
3152     for(;;){
3153         AVPacket pkt;
3154         ret= av_interleave_packet(s, &pkt, NULL, 1);
3155         if(ret<0) //FIXME cleanup needed for ret<0 ?
3156             goto fail;
3157         if(!ret)
3158             break;
3159
3160         ret= s->oformat->write_packet(s, &pkt);
3161
3162         av_free_packet(&pkt);
3163
3164         if(ret<0)
3165             goto fail;
3166     }
3167
3168     if(s->oformat->write_trailer)
3169         ret = s->oformat->write_trailer(s);
3170 fail:
3171     for(i=0;i<s->nb_streams;i++) {
3172         av_freep(&s->streams[i]->priv_data);
3173         av_freep(&s->streams[i]->index_entries);
3174     }
3175     if (s->iformat && s->iformat->priv_class)
3176         av_opt_free(s->priv_data);
3177     av_freep(&s->priv_data);
3178     return ret;
3179 }
3180
3181 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3182 {
3183     int i, j;
3184     AVProgram *program=NULL;
3185     void *tmp;
3186
3187     if (idx >= ac->nb_streams) {
3188         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3189         return;
3190     }
3191
3192     for(i=0; i<ac->nb_programs; i++){
3193         if(ac->programs[i]->id != progid)
3194             continue;
3195         program = ac->programs[i];
3196         for(j=0; j<program->nb_stream_indexes; j++)
3197             if(program->stream_index[j] == idx)
3198                 return;
3199
3200         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3201         if(!tmp)
3202             return;
3203         program->stream_index = tmp;
3204         program->stream_index[program->nb_stream_indexes++] = idx;
3205         return;
3206     }
3207 }
3208
3209 static void print_fps(double d, const char *postfix){
3210     uint64_t v= lrintf(d*100);
3211     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3212     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3213     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3214 }
3215
3216 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3217 {
3218     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3219         AVDictionaryEntry *tag=NULL;
3220
3221         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3222         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3223             if(strcmp("language", tag->key))
3224                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3225         }
3226     }
3227 }
3228
3229 /* "user interface" functions */
3230 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3231 {
3232     char buf[256];
3233     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3234     AVStream *st = ic->streams[i];
3235     int g = av_gcd(st->time_base.num, st->time_base.den);
3236     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3237     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3238     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3239     /* the pid is an important information, so we display it */
3240     /* XXX: add a generic system */
3241     if (flags & AVFMT_SHOW_IDS)
3242         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3243     if (lang)
3244         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3245     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3246     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3247     if (st->sample_aspect_ratio.num && // default
3248         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3249         AVRational display_aspect_ratio;
3250         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3251                   st->codec->width*st->sample_aspect_ratio.num,
3252                   st->codec->height*st->sample_aspect_ratio.den,
3253                   1024*1024);
3254         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3255                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3256                  display_aspect_ratio.num, display_aspect_ratio.den);
3257     }
3258     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3259         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3260             print_fps(av_q2d(st->avg_frame_rate), "fps");
3261         if(st->r_frame_rate.den && st->r_frame_rate.num)
3262             print_fps(av_q2d(st->r_frame_rate), "tbr");
3263         if(st->time_base.den && st->time_base.num)
3264             print_fps(1/av_q2d(st->time_base), "tbn");
3265         if(st->codec->time_base.den && st->codec->time_base.num)
3266             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3267     }
3268     if (st->disposition & AV_DISPOSITION_DEFAULT)
3269         av_log(NULL, AV_LOG_INFO, " (default)");
3270     if (st->disposition & AV_DISPOSITION_DUB)
3271         av_log(NULL, AV_LOG_INFO, " (dub)");
3272     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3273         av_log(NULL, AV_LOG_INFO, " (original)");
3274     if (st->disposition & AV_DISPOSITION_COMMENT)
3275         av_log(NULL, AV_LOG_INFO, " (comment)");
3276     if (st->disposition & AV_DISPOSITION_LYRICS)
3277         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3278     if (st->disposition & AV_DISPOSITION_KARAOKE)
3279         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3280     if (st->disposition & AV_DISPOSITION_FORCED)
3281         av_log(NULL, AV_LOG_INFO, " (forced)");
3282     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3283         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3284     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3285         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3286     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3287         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3288     av_log(NULL, AV_LOG_INFO, "\n");
3289     dump_metadata(NULL, st->metadata, "    ");
3290 }
3291
3292 #if FF_API_DUMP_FORMAT
3293 void dump_format(AVFormatContext *ic,
3294                  int index,
3295                  const char *url,
3296                  int is_output)
3297 {
3298     av_dump_format(ic, index, url, is_output);
3299 }
3300 #endif
3301
3302 void av_dump_format(AVFormatContext *ic,
3303                     int index,
3304                     const char *url,
3305                     int is_output)
3306 {
3307     int i;
3308     uint8_t *printed = av_mallocz(ic->nb_streams);
3309     if (ic->nb_streams && !printed)
3310         return;
3311
3312     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3313             is_output ? "Output" : "Input",
3314             index,
3315             is_output ? ic->oformat->name : ic->iformat->name,
3316             is_output ? "to" : "from", url);
3317     dump_metadata(NULL, ic->metadata, "  ");
3318     if (!is_output) {
3319         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3320         if (ic->duration != AV_NOPTS_VALUE) {
3321             int hours, mins, secs, us;
3322             secs = ic->duration / AV_TIME_BASE;
3323             us = ic->duration % AV_TIME_BASE;
3324             mins = secs / 60;
3325             secs %= 60;
3326             hours = mins / 60;
3327             mins %= 60;
3328             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3329                    (100 * us) / AV_TIME_BASE);
3330         } else {
3331             av_log(NULL, AV_LOG_INFO, "N/A");
3332         }
3333         if (ic->start_time != AV_NOPTS_VALUE) {
3334             int secs, us;
3335             av_log(NULL, AV_LOG_INFO, ", start: ");
3336             secs = ic->start_time / AV_TIME_BASE;
3337             us = abs(ic->start_time % AV_TIME_BASE);
3338             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3339                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3340         }
3341         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3342         if (ic->bit_rate) {
3343             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3344         } else {
3345             av_log(NULL, AV_LOG_INFO, "N/A");
3346         }
3347         av_log(NULL, AV_LOG_INFO, "\n");
3348     }
3349     for (i = 0; i < ic->nb_chapters; i++) {
3350         AVChapter *ch = ic->chapters[i];
3351         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3352         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3353         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3354
3355         dump_metadata(NULL, ch->metadata, "    ");
3356     }
3357     if(ic->nb_programs) {
3358         int j, k, total = 0;
3359         for(j=0; j<ic->nb_programs; j++) {
3360             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3361                                                   "name", NULL, 0);
3362             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3363                    name ? name->value : "");
3364             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3365             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3366                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3367                 printed[ic->programs[j]->stream_index[k]] = 1;
3368             }
3369             total += ic->programs[j]->nb_stream_indexes;
3370         }
3371         if (total < ic->nb_streams)
3372             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3373     }
3374     for(i=0;i<ic->nb_streams;i++)
3375         if (!printed[i])
3376             dump_stream_format(ic, i, index, is_output);
3377
3378     av_free(printed);
3379 }
3380
3381 int64_t av_gettime(void)
3382 {
3383     struct timeval tv;
3384     gettimeofday(&tv,NULL);
3385     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3386 }
3387
3388 uint64_t ff_ntp_time(void)
3389 {
3390   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3391 }
3392
3393 #if FF_API_PARSE_DATE
3394 #include "libavutil/parseutils.h"
3395
3396 int64_t parse_date(const char *timestr, int duration)
3397 {
3398     int64_t timeval;
3399     av_parse_time(&timeval, timestr, duration);
3400     return timeval;
3401 }
3402 #endif
3403
3404 #if FF_API_FIND_INFO_TAG
3405 #include "libavutil/parseutils.h"
3406
3407 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3408 {
3409     return av_find_info_tag(arg, arg_size, tag1, info);
3410 }
3411 #endif
3412
3413 int av_get_frame_filename(char *buf, int buf_size,
3414                           const char *path, int number)
3415 {
3416     const char *p;
3417     char *q, buf1[20], c;
3418     int nd, len, percentd_found;
3419
3420     q = buf;
3421     p = path;
3422     percentd_found = 0;
3423     for(;;) {
3424         c = *p++;
3425         if (c == '\0')
3426             break;
3427         if (c == '%') {
3428             do {
3429                 nd = 0;
3430                 while (isdigit(*p)) {
3431                     nd = nd * 10 + *p++ - '0';
3432                 }
3433                 c = *p++;
3434             } while (isdigit(c));
3435
3436             switch(c) {
3437             case '%':
3438                 goto addchar;
3439             case 'd':
3440                 if (percentd_found)
3441                     goto fail;
3442                 percentd_found = 1;
3443                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3444                 len = strlen(buf1);
3445                 if ((q - buf + len) > buf_size - 1)
3446                     goto fail;
3447                 memcpy(q, buf1, len);
3448                 q += len;
3449                 break;
3450             default:
3451                 goto fail;
3452             }
3453         } else {
3454         addchar:
3455             if ((q - buf) < buf_size - 1)
3456                 *q++ = c;
3457         }
3458     }
3459     if (!percentd_found)
3460         goto fail;
3461     *q = '\0';
3462     return 0;
3463  fail:
3464     *q = '\0';
3465     return -1;
3466 }
3467
3468 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3469 {
3470     int len, i, j, c;
3471 #undef fprintf
3472 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3473
3474     for(i=0;i<size;i+=16) {
3475         len = size - i;
3476         if (len > 16)
3477             len = 16;
3478         PRINT("%08x ", i);
3479         for(j=0;j<16;j++) {
3480             if (j < len)
3481                 PRINT(" %02x", buf[i+j]);
3482             else
3483                 PRINT("   ");
3484         }
3485         PRINT(" ");
3486         for(j=0;j<len;j++) {
3487             c = buf[i+j];
3488             if (c < ' ' || c > '~')
3489                 c = '.';
3490             PRINT("%c", c);
3491         }
3492         PRINT("\n");
3493     }
3494 #undef PRINT
3495 }
3496
3497 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3498 {
3499     hex_dump_internal(NULL, f, 0, buf, size);
3500 }
3501
3502 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3503 {
3504     hex_dump_internal(avcl, NULL, level, buf, size);
3505 }
3506
3507 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3508 {
3509 #undef fprintf
3510 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3511     PRINT("stream #%d:\n", pkt->stream_index);
3512     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3513     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3514     /* DTS is _always_ valid after av_read_frame() */
3515     PRINT("  dts=");
3516     if (pkt->dts == AV_NOPTS_VALUE)
3517         PRINT("N/A");
3518     else
3519         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3520     /* PTS may not be known if B-frames are present. */
3521     PRINT("  pts=");
3522     if (pkt->pts == AV_NOPTS_VALUE)
3523         PRINT("N/A");
3524     else
3525         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3526     PRINT("\n");
3527     PRINT("  size=%d\n", pkt->size);
3528 #undef PRINT
3529     if (dump_payload)
3530         av_hex_dump(f, pkt->data, pkt->size);
3531 }
3532
3533 #if FF_API_PKT_DUMP
3534 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3535 {
3536     AVRational tb = { 1, AV_TIME_BASE };
3537     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3538 }
3539 #endif
3540
3541 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3542 {
3543     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3544 }
3545
3546 #if FF_API_PKT_DUMP
3547 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3548 {
3549     AVRational tb = { 1, AV_TIME_BASE };
3550     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3551 }
3552 #endif
3553
3554 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3555                       AVStream *st)
3556 {
3557     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3558 }
3559
3560 void av_url_split(char *proto, int proto_size,
3561                   char *authorization, int authorization_size,
3562                   char *hostname, int hostname_size,
3563                   int *port_ptr,
3564                   char *path, int path_size,
3565                   const char *url)
3566 {
3567     const char *p, *ls, *at, *col, *brk;
3568
3569     if (port_ptr)               *port_ptr = -1;
3570     if (proto_size > 0)         proto[0] = 0;
3571     if (authorization_size > 0) authorization[0] = 0;
3572     if (hostname_size > 0)      hostname[0] = 0;
3573     if (path_size > 0)          path[0] = 0;
3574
3575     /* parse protocol */
3576     if ((p = strchr(url, ':'))) {
3577         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3578         p++; /* skip ':' */
3579         if (*p == '/') p++;
3580         if (*p == '/') p++;
3581     } else {
3582         /* no protocol means plain filename */
3583         av_strlcpy(path, url, path_size);
3584         return;
3585     }
3586
3587     /* separate path from hostname */
3588     ls = strchr(p, '/');
3589     if(!ls)
3590         ls = strchr(p, '?');
3591     if(ls)
3592         av_strlcpy(path, ls, path_size);
3593     else
3594         ls = &p[strlen(p)]; // XXX
3595
3596     /* the rest is hostname, use that to parse auth/port */
3597     if (ls != p) {
3598         /* authorization (user[:pass]@hostname) */
3599         if ((at = strchr(p, '@')) && at < ls) {
3600             av_strlcpy(authorization, p,
3601                        FFMIN(authorization_size, at + 1 - p));
3602             p = at + 1; /* skip '@' */
3603         }
3604
3605         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3606             /* [host]:port */
3607             av_strlcpy(hostname, p + 1,
3608                        FFMIN(hostname_size, brk - p));
3609             if (brk[1] == ':' && port_ptr)
3610                 *port_ptr = atoi(brk + 2);
3611         } else if ((col = strchr(p, ':')) && col < ls) {
3612             av_strlcpy(hostname, p,
3613                        FFMIN(col + 1 - p, hostname_size));
3614             if (port_ptr) *port_ptr = atoi(col + 1);
3615         } else
3616             av_strlcpy(hostname, p,
3617                        FFMIN(ls + 1 - p, hostname_size));
3618     }
3619 }
3620
3621 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3622 {
3623     int i;
3624     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3625                                            '4', '5', '6', '7',
3626                                            '8', '9', 'A', 'B',
3627                                            'C', 'D', 'E', 'F' };
3628     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3629                                            '4', '5', '6', '7',
3630                                            '8', '9', 'a', 'b',
3631                                            'c', 'd', 'e', 'f' };
3632     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3633
3634     for(i = 0; i < s; i++) {
3635         buff[i * 2]     = hex_table[src[i] >> 4];
3636         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3637     }
3638
3639     return buff;
3640 }
3641
3642 int ff_hex_to_data(uint8_t *data, const char *p)
3643 {
3644     int c, len, v;
3645
3646     len = 0;
3647     v = 1;
3648     for (;;) {
3649         p += strspn(p, SPACE_CHARS);
3650         if (*p == '\0')
3651             break;
3652         c = toupper((unsigned char) *p++);
3653         if (c >= '0' && c <= '9')
3654             c = c - '0';
3655         else if (c >= 'A' && c <= 'F')
3656             c = c - 'A' + 10;
3657         else
3658             break;
3659         v = (v << 4) | c;
3660         if (v & 0x100) {
3661             if (data)
3662                 data[len] = v;
3663             len++;
3664             v = 1;
3665         }
3666     }
3667     return len;
3668 }
3669
3670 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3671                      unsigned int pts_num, unsigned int pts_den)
3672 {
3673     AVRational new_tb;
3674     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3675         if(new_tb.num != pts_num)
3676             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3677     }else
3678         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3679
3680     if(new_tb.num <= 0 || new_tb.den <= 0) {
3681         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3682         return;
3683     }
3684     s->time_base = new_tb;
3685     s->pts_wrap_bits = pts_wrap_bits;
3686 }
3687
3688 int ff_url_join(char *str, int size, const char *proto,
3689                 const char *authorization, const char *hostname,
3690                 int port, const char *fmt, ...)
3691 {
3692 #if CONFIG_NETWORK
3693     struct addrinfo hints, *ai;
3694 #endif
3695
3696     str[0] = '\0';
3697     if (proto)
3698         av_strlcatf(str, size, "%s://", proto);
3699     if (authorization && authorization[0])
3700         av_strlcatf(str, size, "%s@", authorization);
3701 #if CONFIG_NETWORK && defined(AF_INET6)
3702     /* Determine if hostname is a numerical IPv6 address,
3703      * properly escape it within [] in that case. */
3704     memset(&hints, 0, sizeof(hints));
3705     hints.ai_flags = AI_NUMERICHOST;
3706     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3707         if (ai->ai_family == AF_INET6) {
3708             av_strlcat(str, "[", size);
3709             av_strlcat(str, hostname, size);
3710             av_strlcat(str, "]", size);
3711         } else {
3712             av_strlcat(str, hostname, size);
3713         }
3714         freeaddrinfo(ai);
3715     } else
3716 #endif
3717         /* Not an IPv6 address, just output the plain string. */
3718         av_strlcat(str, hostname, size);
3719
3720     if (port >= 0)
3721         av_strlcatf(str, size, ":%d", port);
3722     if (fmt) {
3723         va_list vl;
3724         int len = strlen(str);
3725
3726         va_start(vl, fmt);
3727         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3728         va_end(vl);
3729     }
3730     return strlen(str);
3731 }
3732
3733 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3734                      AVFormatContext *src)
3735 {
3736     AVPacket local_pkt;
3737
3738     local_pkt = *pkt;
3739     local_pkt.stream_index = dst_stream;
3740     if (pkt->pts != AV_NOPTS_VALUE)
3741         local_pkt.pts = av_rescale_q(pkt->pts,
3742                                      src->streams[pkt->stream_index]->time_base,
3743                                      dst->streams[dst_stream]->time_base);
3744     if (pkt->dts != AV_NOPTS_VALUE)
3745         local_pkt.dts = av_rescale_q(pkt->dts,
3746                                      src->streams[pkt->stream_index]->time_base,
3747                                      dst->streams[dst_stream]->time_base);
3748     return av_write_frame(dst, &local_pkt);
3749 }
3750
3751 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3752                         void *context)
3753 {
3754     const char *ptr = str;
3755
3756     /* Parse key=value pairs. */
3757     for (;;) {
3758         const char *key;
3759         char *dest = NULL, *dest_end;
3760         int key_len, dest_len = 0;
3761
3762         /* Skip whitespace and potential commas. */
3763         while (*ptr && (isspace(*ptr) || *ptr == ','))
3764             ptr++;
3765         if (!*ptr)
3766             break;
3767
3768         key = ptr;
3769
3770         if (!(ptr = strchr(key, '=')))
3771             break;
3772         ptr++;
3773         key_len = ptr - key;
3774
3775         callback_get_buf(context, key, key_len, &dest, &dest_len);
3776         dest_end = dest + dest_len - 1;
3777
3778         if (*ptr == '\"') {
3779             ptr++;
3780             while (*ptr && *ptr != '\"') {
3781                 if (*ptr == '\\') {
3782                     if (!ptr[1])
3783                         break;
3784                     if (dest && dest < dest_end)
3785                         *dest++ = ptr[1];
3786                     ptr += 2;
3787                 } else {
3788                     if (dest && dest < dest_end)
3789                         *dest++ = *ptr;
3790                     ptr++;
3791                 }
3792             }
3793             if (*ptr == '\"')
3794                 ptr++;
3795         } else {
3796             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3797                 if (dest && dest < dest_end)
3798                     *dest++ = *ptr;
3799         }
3800         if (dest)
3801             *dest = 0;
3802     }
3803 }
3804
3805 int ff_find_stream_index(AVFormatContext *s, int id)
3806 {
3807     int i;
3808     for (i = 0; i < s->nb_streams; i++) {
3809         if (s->streams[i]->id == id)
3810             return i;
3811     }
3812     return -1;
3813 }
3814
3815 void ff_make_absolute_url(char *buf, int size, const char *base,
3816                           const char *rel)
3817 {
3818     char *sep;
3819     /* Absolute path, relative to the current server */
3820     if (base && strstr(base, "://") && rel[0] == '/') {
3821         if (base != buf)
3822             av_strlcpy(buf, base, size);
3823         sep = strstr(buf, "://");
3824         if (sep) {
3825             sep += 3;
3826             sep = strchr(sep, '/');
3827             if (sep)
3828                 *sep = '\0';
3829         }
3830         av_strlcat(buf, rel, size);
3831         return;
3832     }
3833     /* If rel actually is an absolute url, just copy it */
3834     if (!base || strstr(rel, "://") || rel[0] == '/') {
3835         av_strlcpy(buf, rel, size);
3836         return;
3837     }
3838     if (base != buf)
3839         av_strlcpy(buf, base, size);
3840     /* Remove the file name from the base url */
3841     sep = strrchr(buf, '/');
3842     if (sep)
3843         sep[1] = '\0';
3844     else
3845         buf[0] = '\0';
3846     while (av_strstart(rel, "../", NULL) && sep) {
3847         /* Remove the path delimiter at the end */
3848         sep[0] = '\0';
3849         sep = strrchr(buf, '/');
3850         /* If the next directory name to pop off is "..", break here */
3851         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3852             /* Readd the slash we just removed */
3853             av_strlcat(buf, "/", size);
3854             break;
3855         }
3856         /* Cut off the directory name */
3857         if (sep)
3858             sep[1] = '\0';
3859         else
3860             buf[0] = '\0';
3861         rel += 3;
3862     }
3863     av_strlcat(buf, rel, size);
3864 }