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