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