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