git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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