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