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