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