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