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 #include "avformat.h"
  22 #include "internal.h"
  23 #include "libavcodec/opt.h"
  24 #include "metadata.h"
  25 #include "libavutil/avstring.h"
  26 #include "riff.h"
  27 #include "audiointerleave.h"
  28 #include <sys/time.h>
  29 #include <time.h>
  30 #include <strings.h>
  31 #include <stdarg.h>
  32 #if CONFIG_NETWORK
  33 #include "network.h"
  34 #endif
  35
  36 #undef NDEBUG
  37 #include <assert.h>
  38
  39 /**
  40  * @file libavformat/utils.c
  41  * various utility functions for use within FFmpeg
  42  */
  43
  44 unsigned avformat_version(void)
  45 {
  46     return LIBAVFORMAT_VERSION_INT;
  47 }
  48
  49 const char *avformat_configuration(void)
  50 {
  51     return FFMPEG_CONFIGURATION;
  52 }
  53
  54 const char *avformat_license(void)
  55 {
  56 #define LICENSE_PREFIX "libavformat license: "
  57     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  58 }
  59
  60 /* fraction handling */
  61
  62 /**
  63  * f = val + (num / den) + 0.5.
  64  *
  65  * 'num' is normalized so that it is such as 0 <= num < den.
  66  *
  67  * @param f fractional number
  68  * @param val integer value
  69  * @param num must be >= 0
  70  * @param den must be >= 1
  71  */
  72 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
  73 {
  74     num += (den >> 1);
  75     if (num >= den) {
  76         val += num / den;
  77         num = num % den;
  78     }
  79     f->val = val;
  80     f->num = num;
  81     f->den = den;
  82 }
  83
  84 /**
  85  * Fractional addition to f: f = f + (incr / f->den).
  86  *
  87  * @param f fractional number
  88  * @param incr increment, can be positive or negative
  89  */
  90 static void av_frac_add(AVFrac *f, int64_t incr)
  91 {
  92     int64_t num, den;
  93
  94     num = f->num + incr;
  95     den = f->den;
  96     if (num < 0) {
  97         f->val += num / den;
  98         num = num % den;
  99         if (num < 0) {
 100             num += den;
 101             f->val--;
 102         }
 103     } else if (num >= den) {
 104         f->val += num / den;
 105         num = num % den;
 106     }
 107     f->num = num;
 108 }
 109
 110 /** head of registered input format linked list */
 111 AVInputFormat *first_iformat = NULL;
 112 /** head of registered output format linked list */
 113 AVOutputFormat *first_oformat = NULL;
 114
 115 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
 116 {
 117     if(f) return f->next;
 118     else  return first_iformat;
 119 }
 120
 121 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
 122 {
 123     if(f) return f->next;
 124     else  return first_oformat;
 125 }
 126
 127 void av_register_input_format(AVInputFormat *format)
 128 {
 129     AVInputFormat **p;
 130     p = &first_iformat;
 131     while (*p != NULL) p = &(*p)->next;
 132     *p = format;
 133     format->next = NULL;
 134 }
 135
 136 void av_register_output_format(AVOutputFormat *format)
 137 {
 138     AVOutputFormat **p;
 139     p = &first_oformat;
 140     while (*p != NULL) p = &(*p)->next;
 141     *p = format;
 142     format->next = NULL;
 143 }
 144
 145 int av_match_ext(const char *filename, const char *extensions)
 146 {
 147     const char *ext, *p;
 148     char ext1[32], *q;
 149
 150     if(!filename)
 151         return 0;
 152
 153     ext = strrchr(filename, '.');
 154     if (ext) {
 155         ext++;
 156         p = extensions;
 157         for(;;) {
 158             q = ext1;
 159             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
 160                 *q++ = *p++;
 161             *q = '\0';
 162             if (!strcasecmp(ext1, ext))
 163                 return 1;
 164             if (*p == '\0')
 165                 break;
 166             p++;
 167         }
 168     }
 169     return 0;
 170 }
 171
 172 static int match_format(const char *name, const char *names)
 173 {
 174     const char *p;
 175     int len, namelen;
 176
 177     if (!name || !names)
 178         return 0;
 179
 180     namelen = strlen(name);
 181     while ((p = strchr(names, ','))) {
 182         len = FFMAX(p - names, namelen);
 183         if (!strncasecmp(name, names, len))
 184             return 1;
 185         names = p+1;
 186     }
 187     return !strcasecmp(name, names);
 188 }
 189
 190 #if LIBAVFORMAT_VERSION_MAJOR < 53
 191 AVOutputFormat *guess_format(const char *short_name, const char *filename,
 192                              const char *mime_type)
 193 {
 194     return av_guess_format(short_name, filename, mime_type);
 195 }
 196 #endif
 197
 198 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
 199                                 const char *mime_type)
 200 {
 201     AVOutputFormat *fmt, *fmt_found;
 202     int score_max, score;
 203
 204     /* specific test for image sequences */
 205 #if CONFIG_IMAGE2_MUXER
 206     if (!short_name && filename &&
 207         av_filename_number_test(filename) &&
 208         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
 209         return av_guess_format("image2", NULL, NULL);
 210     }
 211 #endif
 212     /* Find the proper file type. */
 213     fmt_found = NULL;
 214     score_max = 0;
 215     fmt = first_oformat;
 216     while (fmt != NULL) {
 217         score = 0;
 218         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
 219             score += 100;
 220         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
 221             score += 10;
 222         if (filename && fmt->extensions &&
 223             av_match_ext(filename, fmt->extensions)) {
 224             score += 5;
 225         }
 226         if (score > score_max) {
 227             score_max = score;
 228             fmt_found = fmt;
 229         }
 230         fmt = fmt->next;
 231     }
 232     return fmt_found;
 233 }
 234
 235 #if LIBAVFORMAT_VERSION_MAJOR < 53
 236 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 237                              const char *mime_type)
 238 {
 239     AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
 240
 241     if (fmt) {
 242         AVOutputFormat *stream_fmt;
 243         char stream_format_name[64];
 244
 245         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 246         stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
 247
 248         if (stream_fmt)
 249             fmt = stream_fmt;
 250     }
 251
 252     return fmt;
 253 }
 254 #endif
 255
 256 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
 257                             const char *filename, const char *mime_type, enum CodecType type){
 258     if(type == CODEC_TYPE_VIDEO){
 259         enum CodecID codec_id= CODEC_ID_NONE;
 260
 261 #if CONFIG_IMAGE2_MUXER
 262         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
 263             codec_id= av_guess_image2_codec(filename);
 264         }
 265 #endif
 266         if(codec_id == CODEC_ID_NONE)
 267             codec_id= fmt->video_codec;
 268         return codec_id;
 269     }else if(type == CODEC_TYPE_AUDIO)
 270         return fmt->audio_codec;
 271     else
 272         return CODEC_ID_NONE;
 273 }
 274
 275 AVInputFormat *av_find_input_format(const char *short_name)
 276 {
 277     AVInputFormat *fmt;
 278     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 279         if (match_format(short_name, fmt->name))
 280             return fmt;
 281     }
 282     return NULL;
 283 }
 284
 285 /* memory handling */
 286
 287
 288 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
 289 {
 290     int ret= av_new_packet(pkt, size);
 291
 292     if(ret<0)
 293         return ret;
 294
 295     pkt->pos= url_ftell(s);
 296
 297     ret= get_buffer(s, pkt->data, size);
 298     if(ret<=0)
 299         av_free_packet(pkt);
 300     else
 301         av_shrink_packet(pkt, ret);
 302
 303     return ret;
 304 }
 305
 306
 307 int av_filename_number_test(const char *filename)
 308 {
 309     char buf[1024];
 310     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 311 }
 312
 313 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 314 {
 315     AVInputFormat *fmt1, *fmt;
 316     int score;
 317
 318     fmt = NULL;
 319     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 320         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 321             continue;
 322         score = 0;
 323         if (fmt1->read_probe) {
 324             score = fmt1->read_probe(pd);
 325         } else if (fmt1->extensions) {
 326             if (av_match_ext(pd->filename, fmt1->extensions)) {
 327                 score = 50;
 328             }
 329         }
 330         if (score > *score_max) {
 331             *score_max = score;
 332             fmt = fmt1;
 333         }else if (score == *score_max)
 334             fmt = NULL;
 335     }
 336     return fmt;
 337 }
 338
 339 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 340     int score=0;
 341     return av_probe_input_format2(pd, is_opened, &score);
 342 }
 343
 344 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
 345 {
 346     AVInputFormat *fmt;
 347     fmt = av_probe_input_format2(pd, 1, &score);
 348
 349     if (fmt) {
 350         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 351                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 352         if (!strcmp(fmt->name, "mp3")) {
 353             st->codec->codec_id = CODEC_ID_MP3;
 354             st->codec->codec_type = CODEC_TYPE_AUDIO;
 355         } else if (!strcmp(fmt->name, "ac3")) {
 356             st->codec->codec_id = CODEC_ID_AC3;
 357             st->codec->codec_type = CODEC_TYPE_AUDIO;
 358         } else if (!strcmp(fmt->name, "eac3")) {
 359             st->codec->codec_id = CODEC_ID_EAC3;
 360             st->codec->codec_type = CODEC_TYPE_AUDIO;
 361         } else if (!strcmp(fmt->name, "mpegvideo")) {
 362             st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
 363             st->codec->codec_type = CODEC_TYPE_VIDEO;
 364         } else if (!strcmp(fmt->name, "m4v")) {
 365             st->codec->codec_id = CODEC_ID_MPEG4;
 366             st->codec->codec_type = CODEC_TYPE_VIDEO;
 367         } else if (!strcmp(fmt->name, "h264")) {
 368             st->codec->codec_id = CODEC_ID_H264;
 369             st->codec->codec_type = CODEC_TYPE_VIDEO;
 370         } else if (!strcmp(fmt->name, "dts")) {
 371             st->codec->codec_id = CODEC_ID_DTS;
 372             st->codec->codec_type = CODEC_TYPE_AUDIO;
 373         }
 374     }
 375     return !!fmt;
 376 }
 377
 378 /************************************************************/
 379 /* input media file */
 380
 381 /**
 382  * Open a media file from an IO stream. 'fmt' must be specified.
 383  */
 384 int av_open_input_stream(AVFormatContext **ic_ptr,
 385                          ByteIOContext *pb, const char *filename,
 386                          AVInputFormat *fmt, AVFormatParameters *ap)
 387 {
 388     int err;
 389     AVFormatContext *ic;
 390     AVFormatParameters default_ap;
 391
 392     if(!ap){
 393         ap=&default_ap;
 394         memset(ap, 0, sizeof(default_ap));
 395     }
 396
 397     if(!ap->prealloced_context)
 398         ic = avformat_alloc_context();
 399     else
 400         ic = *ic_ptr;
 401     if (!ic) {
 402         err = AVERROR(ENOMEM);
 403         goto fail;
 404     }
 405     ic->iformat = fmt;
 406     ic->pb = pb;
 407     ic->duration = AV_NOPTS_VALUE;
 408     ic->start_time = AV_NOPTS_VALUE;
 409     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
 410
 411     /* allocate private data */
 412     if (fmt->priv_data_size > 0) {
 413         ic->priv_data = av_mallocz(fmt->priv_data_size);
 414         if (!ic->priv_data) {
 415             err = AVERROR(ENOMEM);
 416             goto fail;
 417         }
 418     } else {
 419         ic->priv_data = NULL;
 420     }
 421
 422     if (ic->iformat->read_header) {
 423         err = ic->iformat->read_header(ic, ap);
 424         if (err < 0)
 425             goto fail;
 426     }
 427
 428     if (pb && !ic->data_offset)
 429         ic->data_offset = url_ftell(ic->pb);
 430
 431 #if LIBAVFORMAT_VERSION_MAJOR < 53
 432     ff_metadata_demux_compat(ic);
 433 #endif
 434
 435     ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 436
 437     *ic_ptr = ic;
 438     return 0;
 439  fail:
 440     if (ic) {
 441         int i;
 442         av_freep(&ic->priv_data);
 443         for(i=0;i<ic->nb_streams;i++) {
 444             AVStream *st = ic->streams[i];
 445             if (st) {
 446                 av_free(st->priv_data);
 447                 av_free(st->codec->extradata);
 448             }
 449             av_free(st);
 450         }
 451     }
 452     av_free(ic);
 453     *ic_ptr = NULL;
 454     return err;
 455 }
 456
 457 /** size of probe buffer, for guessing file type from file contents */
 458 #define PROBE_BUF_MIN 2048
 459 #define PROBE_BUF_MAX (1<<20)
 460
 461 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
 462                           const char *filename, void *logctx,
 463                           unsigned int offset, unsigned int max_probe_size)
 464 {
 465     AVProbeData pd = { filename ? filename : "", NULL, -offset };
 466     unsigned char *buf = NULL;
 467     int ret = 0, probe_size;
 468
 469     if (!max_probe_size) {
 470         max_probe_size = PROBE_BUF_MAX;
 471     } else if (max_probe_size > PROBE_BUF_MAX) {
 472         max_probe_size = PROBE_BUF_MAX;
 473     } else if (max_probe_size < PROBE_BUF_MIN) {
 474         return AVERROR(EINVAL);
 475     }
 476
 477     if (offset >= max_probe_size) {
 478         return AVERROR(EINVAL);
 479     }
 480
 481     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
 482         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
 483         int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
 484         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
 485
 486         if (probe_size < offset) {
 487             continue;
 488         }
 489
 490         /* read probe data */
 491         buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
 492         if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
 493             /* fail if error was not end of file, otherwise, lower score */
 494             if (ret != AVERROR_EOF) {
 495                 av_free(buf);
 496                 return ret;
 497             }
 498             score = 0;
 499             ret = 0;            /* error was end of file, nothing read */
 500         }
 501         pd.buf_size += ret;
 502         pd.buf = &buf[offset];
 503
 504         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
 505
 506         /* guess file format */
 507         *fmt = av_probe_input_format2(&pd, 1, &score);
 508         if(*fmt){
 509             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
 510                 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
 511             }else
 512                 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
 513         }
 514     }
 515
 516     av_free(buf);
 517
 518     if (!*fmt) {
 519         return AVERROR_INVALIDDATA;
 520     }
 521
 522     if (url_fseek(*pb, 0, SEEK_SET) < 0) {
 523         url_fclose(*pb);
 524         if (url_fopen(pb, filename, URL_RDONLY) < 0)
 525             return AVERROR(EIO);
 526     }
 527
 528     return 0;
 529 }
 530
 531 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 532                        AVInputFormat *fmt,
 533                        int buf_size,
 534                        AVFormatParameters *ap)
 535 {
 536     int err;
 537     AVProbeData probe_data, *pd = &probe_data;
 538     ByteIOContext *pb = NULL;
 539     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
 540
 541     pd->filename = "";
 542     if (filename)
 543         pd->filename = filename;
 544     pd->buf = NULL;
 545     pd->buf_size = 0;
 546
 547     if (!fmt) {
 548         /* guess format if no file can be opened */
 549         fmt = av_probe_input_format(pd, 0);
 550     }
 551
 552     /* Do not open file if the format does not need it. XXX: specific
 553        hack needed to handle RTSP/TCP */
 554     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
 555         /* if no file needed do not try to open one */
 556         if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
 557             goto fail;
 558         }
 559         if (buf_size > 0) {
 560             url_setbufsize(pb, buf_size);
 561         }
 562         if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
 563             goto fail;
 564         }
 565     }
 566
 567     /* if still no format found, error */
 568     if (!fmt) {
 569         err = AVERROR_INVALIDDATA;
 570         goto fail;
 571     }
 572
 573     /* check filename in case an image number is expected */
 574     if (fmt->flags & AVFMT_NEEDNUMBER) {
 575         if (!av_filename_number_test(filename)) {
 576             err = AVERROR_NUMEXPECTED;
 577             goto fail;
 578         }
 579     }
 580     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
 581     if (err)
 582         goto fail;
 583     return 0;
 584  fail:
 585     av_freep(&pd->buf);
 586     if (pb)
 587         url_fclose(pb);
 588     if (ap && ap->prealloced_context)
 589         av_free(*ic_ptr);
 590     *ic_ptr = NULL;
 591     return err;
 592
 593 }
 594
 595 /*******************************************************/
 596
 597 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 598                                AVPacketList **plast_pktl){
 599     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 600     if (!pktl)
 601         return NULL;
 602
 603     if (*packet_buffer)
 604         (*plast_pktl)->next = pktl;
 605     else
 606         *packet_buffer = pktl;
 607
 608     /* add the packet in the buffered packet list */
 609     *plast_pktl = pktl;
 610     pktl->pkt= *pkt;
 611     return &pktl->pkt;
 612 }
 613
 614 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 615 {
 616     int ret, i;
 617     AVStream *st;
 618
 619     for(;;){
 620         AVPacketList *pktl = s->raw_packet_buffer;
 621
 622         if (pktl) {
 623             *pkt = pktl->pkt;
 624             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
 625                !s->streams[pkt->stream_index]->probe_packets ||
 626                s->raw_packet_buffer_remaining_size < pkt->size){
 627                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
 628                 av_freep(&pd->buf);
 629                 pd->buf_size = 0;
 630                 s->raw_packet_buffer = pktl->next;
 631                 s->raw_packet_buffer_remaining_size += pkt->size;
 632                 av_free(pktl);
 633                 return 0;
 634             }
 635         }
 636
 637         av_init_packet(pkt);
 638         ret= s->iformat->read_packet(s, pkt);
 639         if (ret < 0) {
 640             if (!pktl || ret == AVERROR(EAGAIN))
 641                 return ret;
 642             for (i = 0; i < s->nb_streams; i++)
 643                 s->streams[i]->probe_packets = 0;
 644             continue;
 645         }
 646         st= s->streams[pkt->stream_index];
 647
 648         switch(st->codec->codec_type){
 649         case CODEC_TYPE_VIDEO:
 650             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 651             break;
 652         case CODEC_TYPE_AUDIO:
 653             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 654             break;
 655         case CODEC_TYPE_SUBTITLE:
 656             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 657             break;
 658         }
 659
 660         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
 661                      !st->probe_packets))
 662             return ret;
 663
 664         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 665         s->raw_packet_buffer_remaining_size -= pkt->size;
 666
 667         if(st->codec->codec_id == CODEC_ID_PROBE){
 668             AVProbeData *pd = &st->probe_data;
 669             av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
 670             --st->probe_packets;
 671
 672             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 673             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 674             pd->buf_size += pkt->size;
 675             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 676
 677             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 678                 set_codec_from_probe_data(s, st, pd, 1);
 679                 if(st->codec->codec_id != CODEC_ID_PROBE){
 680                     pd->buf_size=0;
 681                     av_freep(&pd->buf);
 682                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 683                 }
 684             }
 685         }
 686     }
 687 }
 688
 689 /**********************************************************/
 690
 691 /**
 692  * Get the number of samples of an audio frame. Return -1 on error.
 693  */
 694 static int get_audio_frame_size(AVCodecContext *enc, int size)
 695 {
 696     int frame_size;
 697
 698     if(enc->codec_id == CODEC_ID_VORBIS)
 699         return -1;
 700
 701     if (enc->frame_size <= 1) {
 702         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
 703
 704         if (bits_per_sample) {
 705             if (enc->channels == 0)
 706                 return -1;
 707             frame_size = (size << 3) / (bits_per_sample * enc->channels);
 708         } else {
 709             /* used for example by ADPCM codecs */
 710             if (enc->bit_rate == 0)
 711                 return -1;
 712             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 713         }
 714     } else {
 715         frame_size = enc->frame_size;
 716     }
 717     return frame_size;
 718 }
 719
 720
 721 /**
 722  * Return the frame duration in seconds. Return 0 if not available.
 723  */
 724 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
 725                                    AVCodecParserContext *pc, AVPacket *pkt)
 726 {
 727     int frame_size;
 728
 729     *pnum = 0;
 730     *pden = 0;
 731     switch(st->codec->codec_type) {
 732     case CODEC_TYPE_VIDEO:
 733         if(st->time_base.num*1000LL > st->time_base.den){
 734             *pnum = st->time_base.num;
 735             *pden = st->time_base.den;
 736         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 737             *pnum = st->codec->time_base.num;
 738             *pden = st->codec->time_base.den;
 739             if (pc && pc->repeat_pict) {
 740                 *pnum = (*pnum) * (1 + pc->repeat_pict);
 741             }
 742         }
 743         break;
 744     case CODEC_TYPE_AUDIO:
 745         frame_size = get_audio_frame_size(st->codec, pkt->size);
 746         if (frame_size < 0)
 747             break;
 748         *pnum = frame_size;
 749         *pden = st->codec->sample_rate;
 750         break;
 751     default:
 752         break;
 753     }
 754 }
 755
 756 static int is_intra_only(AVCodecContext *enc){
 757     if(enc->codec_type == CODEC_TYPE_AUDIO){
 758         return 1;
 759     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
 760         switch(enc->codec_id){
 761         case CODEC_ID_MJPEG:
 762         case CODEC_ID_MJPEGB:
 763         case CODEC_ID_LJPEG:
 764         case CODEC_ID_RAWVIDEO:
 765         case CODEC_ID_DVVIDEO:
 766         case CODEC_ID_HUFFYUV:
 767         case CODEC_ID_FFVHUFF:
 768         case CODEC_ID_ASV1:
 769         case CODEC_ID_ASV2:
 770         case CODEC_ID_VCR1:
 771         case CODEC_ID_DNXHD:
 772         case CODEC_ID_JPEG2000:
 773             return 1;
 774         default: break;
 775         }
 776     }
 777     return 0;
 778 }
 779
 780 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 781                                       int64_t dts, int64_t pts)
 782 {
 783     AVStream *st= s->streams[stream_index];
 784     AVPacketList *pktl= s->packet_buffer;
 785
 786     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
 787         return;
 788
 789     st->first_dts= dts - st->cur_dts;
 790     st->cur_dts= dts;
 791
 792     for(; pktl; pktl= pktl->next){
 793         if(pktl->pkt.stream_index != stream_index)
 794             continue;
 795         //FIXME think more about this check
 796         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 797             pktl->pkt.pts += st->first_dts;
 798
 799         if(pktl->pkt.dts != AV_NOPTS_VALUE)
 800             pktl->pkt.dts += st->first_dts;
 801
 802         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 803             st->start_time= pktl->pkt.pts;
 804     }
 805     if (st->start_time == AV_NOPTS_VALUE)
 806         st->start_time = pts;
 807 }
 808
 809 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 810 {
 811     AVPacketList *pktl= s->packet_buffer;
 812     int64_t cur_dts= 0;
 813
 814     if(st->first_dts != AV_NOPTS_VALUE){
 815         cur_dts= st->first_dts;
 816         for(; pktl; pktl= pktl->next){
 817             if(pktl->pkt.stream_index == pkt->stream_index){
 818                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
 819                     break;
 820                 cur_dts -= pkt->duration;
 821             }
 822         }
 823         pktl= s->packet_buffer;
 824         st->first_dts = cur_dts;
 825     }else if(st->cur_dts)
 826         return;
 827
 828     for(; pktl; pktl= pktl->next){
 829         if(pktl->pkt.stream_index != pkt->stream_index)
 830             continue;
 831         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
 832            && !pktl->pkt.duration){
 833             pktl->pkt.dts= cur_dts;
 834             if(!st->codec->has_b_frames)
 835                 pktl->pkt.pts= cur_dts;
 836             cur_dts += pkt->duration;
 837             pktl->pkt.duration= pkt->duration;
 838         }else
 839             break;
 840     }
 841     if(st->first_dts == AV_NOPTS_VALUE)
 842         st->cur_dts= cur_dts;
 843 }
 844
 845 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 846                                AVCodecParserContext *pc, AVPacket *pkt)
 847 {
 848     int num, den, presentation_delayed, delay, i;
 849     int64_t offset;
 850
 851     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 852         pkt->dts= AV_NOPTS_VALUE;
 853
 854     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
 855         //FIXME Set low_delay = 0 when has_b_frames = 1
 856         st->codec->has_b_frames = 1;
 857
 858     /* do we have a video B-frame ? */
 859     delay= st->codec->has_b_frames;
 860     presentation_delayed = 0;
 861     /* XXX: need has_b_frame, but cannot get it if the codec is
 862         not initialized */
 863     if (delay &&
 864         pc && pc->pict_type != FF_B_TYPE)
 865         presentation_delayed = 1;
 866
 867     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
 868        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
 869         pkt->dts -= 1LL<<st->pts_wrap_bits;
 870     }
 871
 872     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
 873     // we take the conservative approach and discard both
 874     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
 875     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
 876         av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
 877         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
 878     }
 879
 880     if (pkt->duration == 0) {
 881         compute_frame_duration(&num, &den, st, pc, pkt);
 882         if (den && num) {
 883             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
 884
 885             if(pkt->duration != 0 && s->packet_buffer)
 886                 update_initial_durations(s, st, pkt);
 887         }
 888     }
 889
 890     /* correct timestamps with byte offset if demuxers only have timestamps
 891        on packet boundaries */
 892     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
 893         /* this will estimate bitrate based on this frame's duration and size */
 894         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
 895         if(pkt->pts != AV_NOPTS_VALUE)
 896             pkt->pts += offset;
 897         if(pkt->dts != AV_NOPTS_VALUE)
 898             pkt->dts += offset;
 899     }
 900
 901     if (pc && pc->dts_sync_point >= 0) {
 902         // we have synchronization info from the parser
 903         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
 904         if (den > 0) {
 905             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
 906             if (pkt->dts != AV_NOPTS_VALUE) {
 907                 // got DTS from the stream, update reference timestamp
 908                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
 909                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 910             } else if (st->reference_dts != AV_NOPTS_VALUE) {
 911                 // compute DTS based on reference timestamp
 912                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
 913                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
 914             }
 915             if (pc->dts_sync_point > 0)
 916                 st->reference_dts = pkt->dts; // new reference
 917         }
 918     }
 919
 920     /* This may be redundant, but it should not hurt. */
 921     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
 922         presentation_delayed = 1;
 923
 924 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
 925     /* interpolate PTS and DTS if they are not present */
 926     //We skip H264 currently because delay and has_b_frames are not reliably set
 927     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
 928         if (presentation_delayed) {
 929             /* DTS = decompression timestamp */
 930             /* PTS = presentation timestamp */
 931             if (pkt->dts == AV_NOPTS_VALUE)
 932                 pkt->dts = st->last_IP_pts;
 933             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
 934             if (pkt->dts == AV_NOPTS_VALUE)
 935                 pkt->dts = st->cur_dts;
 936
 937             /* this is tricky: the dts must be incremented by the duration
 938             of the frame we are displaying, i.e. the last I- or P-frame */
 939             if (st->last_IP_duration == 0)
 940                 st->last_IP_duration = pkt->duration;
 941             if(pkt->dts != AV_NOPTS_VALUE)
 942                 st->cur_dts = pkt->dts + st->last_IP_duration;
 943             st->last_IP_duration  = pkt->duration;
 944             st->last_IP_pts= pkt->pts;
 945             /* cannot compute PTS if not present (we can compute it only
 946             by knowing the future */
 947         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
 948             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
 949                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
 950                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
 951                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
 952                     pkt->pts += pkt->duration;
 953     //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
 954                 }
 955             }
 956
 957             /* presentation is not delayed : PTS and DTS are the same */
 958             if(pkt->pts == AV_NOPTS_VALUE)
 959                 pkt->pts = pkt->dts;
 960             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
 961             if(pkt->pts == AV_NOPTS_VALUE)
 962                 pkt->pts = st->cur_dts;
 963             pkt->dts = pkt->pts;
 964             if(pkt->pts != AV_NOPTS_VALUE)
 965                 st->cur_dts = pkt->pts + pkt->duration;
 966         }
 967     }
 968
 969     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
 970         st->pts_buffer[0]= pkt->pts;
 971         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
 972             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
 973         if(pkt->dts == AV_NOPTS_VALUE)
 974             pkt->dts= st->pts_buffer[0];
 975         if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
 976             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
 977         }
 978         if(pkt->dts > st->cur_dts)
 979             st->cur_dts = pkt->dts;
 980     }
 981
 982 //    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
 983
 984     /* update flags */
 985     if(is_intra_only(st->codec))
 986         pkt->flags |= PKT_FLAG_KEY;
 987     else if (pc) {
 988         pkt->flags = 0;
 989         /* keyframe computation */
 990         if (pc->key_frame == 1)
 991             pkt->flags |= PKT_FLAG_KEY;
 992         else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
 993             pkt->flags |= PKT_FLAG_KEY;
 994     }
 995     if (pc)
 996         pkt->convergence_duration = pc->convergence_duration;
 997 }
 998
 999
1000 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1001 {
1002     AVStream *st;
1003     int len, ret, i;
1004
1005     av_init_packet(pkt);
1006
1007     for(;;) {
1008         /* select current input stream component */
1009         st = s->cur_st;
1010         if (st) {
1011             if (!st->need_parsing || !st->parser) {
1012                 /* no parsing needed: we just output the packet as is */
1013                 /* raw data support */
1014                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1015                 compute_pkt_fields(s, st, NULL, pkt);
1016                 s->cur_st = NULL;
1017                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1018                     (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1019                     ff_reduce_index(s, st->index);
1020                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1021                 }
1022                 break;
1023             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1024                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1025                                        st->cur_ptr, st->cur_len,
1026                                        st->cur_pkt.pts, st->cur_pkt.dts,
1027                                        st->cur_pkt.pos);
1028                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1029                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1030                 /* increment read pointer */
1031                 st->cur_ptr += len;
1032                 st->cur_len -= len;
1033
1034                 /* return packet if any */
1035                 if (pkt->size) {
1036                 got_packet:
1037                     pkt->duration = 0;
1038                     pkt->stream_index = st->index;
1039                     pkt->pts = st->parser->pts;
1040                     pkt->dts = st->parser->dts;
1041                     pkt->pos = st->parser->pos;
1042                     pkt->destruct = NULL;
1043                     compute_pkt_fields(s, st, st->parser, pkt);
1044
1045                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
1046                         ff_reduce_index(s, st->index);
1047                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1048                                            0, 0, AVINDEX_KEYFRAME);
1049                     }
1050
1051                     break;
1052                 }
1053             } else {
1054                 /* free packet */
1055                 av_free_packet(&st->cur_pkt);
1056                 s->cur_st = NULL;
1057             }
1058         } else {
1059             AVPacket cur_pkt;
1060             /* read next packet */
1061             ret = av_read_packet(s, &cur_pkt);
1062             if (ret < 0) {
1063                 if (ret == AVERROR(EAGAIN))
1064                     return ret;
1065                 /* return the last frames, if any */
1066                 for(i = 0; i < s->nb_streams; i++) {
1067                     st = s->streams[i];
1068                     if (st->parser && st->need_parsing) {
1069                         av_parser_parse2(st->parser, st->codec,
1070                                         &pkt->data, &pkt->size,
1071                                         NULL, 0,
1072                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1073                                         AV_NOPTS_VALUE);
1074                         if (pkt->size)
1075                             goto got_packet;
1076                     }
1077                 }
1078                 /* no more packets: really terminate parsing */
1079                 return ret;
1080             }
1081             st = s->streams[cur_pkt.stream_index];
1082             st->cur_pkt= cur_pkt;
1083
1084             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1085                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1086                st->cur_pkt.pts < st->cur_pkt.dts){
1087                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1088                     st->cur_pkt.stream_index,
1089                     st->cur_pkt.pts,
1090                     st->cur_pkt.dts,
1091                     st->cur_pkt.size);
1092 //                av_free_packet(&st->cur_pkt);
1093 //                return -1;
1094             }
1095
1096             if(s->debug & FF_FDEBUG_TS)
1097                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1098                     st->cur_pkt.stream_index,
1099                     st->cur_pkt.pts,
1100                     st->cur_pkt.dts,
1101                     st->cur_pkt.size,
1102                     st->cur_pkt.duration,
1103                     st->cur_pkt.flags);
1104
1105             s->cur_st = st;
1106             st->cur_ptr = st->cur_pkt.data;
1107             st->cur_len = st->cur_pkt.size;
1108             if (st->need_parsing && !st->parser) {
1109                 st->parser = av_parser_init(st->codec->codec_id);
1110                 if (!st->parser) {
1111                     /* no parser available: just output the raw packets */
1112                     st->need_parsing = AVSTREAM_PARSE_NONE;
1113                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1114                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1115                 }
1116                 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1117                     st->parser->next_frame_offset=
1118                     st->parser->cur_offset= st->cur_pkt.pos;
1119                 }
1120             }
1121         }
1122     }
1123     if(s->debug & FF_FDEBUG_TS)
1124         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1125             pkt->stream_index,
1126             pkt->pts,
1127             pkt->dts,
1128             pkt->size,
1129             pkt->duration,
1130             pkt->flags);
1131
1132     return 0;
1133 }
1134
1135 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1136 {
1137     AVPacketList *pktl;
1138     int eof=0;
1139     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1140
1141     for(;;){
1142         pktl = s->packet_buffer;
1143         if (pktl) {
1144             AVPacket *next_pkt= &pktl->pkt;
1145
1146             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1147                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1148                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1149                        && next_pkt->dts < pktl->pkt.dts
1150                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
1151                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1152                         next_pkt->pts= pktl->pkt.dts;
1153                     }
1154                     pktl= pktl->next;
1155                 }
1156                 pktl = s->packet_buffer;
1157             }
1158
1159             if(   next_pkt->pts != AV_NOPTS_VALUE
1160                || next_pkt->dts == AV_NOPTS_VALUE
1161                || !genpts || eof){
1162                 /* read packet from packet buffer, if there is data */
1163                 *pkt = *next_pkt;
1164                 s->packet_buffer = pktl->next;
1165                 av_free(pktl);
1166                 return 0;
1167             }
1168         }
1169         if(genpts){
1170             int ret= av_read_frame_internal(s, pkt);
1171             if(ret<0){
1172                 if(pktl && ret != AVERROR(EAGAIN)){
1173                     eof=1;
1174                     continue;
1175                 }else
1176                     return ret;
1177             }
1178
1179             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1180                                            &s->packet_buffer_end)) < 0)
1181                 return AVERROR(ENOMEM);
1182         }else{
1183             assert(!s->packet_buffer);
1184             return av_read_frame_internal(s, pkt);
1185         }
1186     }
1187 }
1188
1189 /* XXX: suppress the packet queue */
1190 static void flush_packet_queue(AVFormatContext *s)
1191 {
1192     AVPacketList *pktl;
1193
1194     for(;;) {
1195         pktl = s->packet_buffer;
1196         if (!pktl)
1197             break;
1198         s->packet_buffer = pktl->next;
1199         av_free_packet(&pktl->pkt);
1200         av_free(pktl);
1201     }
1202     while(s->raw_packet_buffer){
1203         pktl = s->raw_packet_buffer;
1204         s->raw_packet_buffer = pktl->next;
1205         av_free_packet(&pktl->pkt);
1206         av_free(pktl);
1207     }
1208     s->packet_buffer_end=
1209     s->raw_packet_buffer_end= NULL;
1210     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1211 }
1212
1213 /*******************************************************/
1214 /* seek support */
1215
1216 int av_find_default_stream_index(AVFormatContext *s)
1217 {
1218     int first_audio_index = -1;
1219     int i;
1220     AVStream *st;
1221
1222     if (s->nb_streams <= 0)
1223         return -1;
1224     for(i = 0; i < s->nb_streams; i++) {
1225         st = s->streams[i];
1226         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1227             return i;
1228         }
1229         if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1230             first_audio_index = i;
1231     }
1232     return first_audio_index >= 0 ? first_audio_index : 0;
1233 }
1234
1235 /**
1236  * Flush the frame reader.
1237  */
1238 void ff_read_frame_flush(AVFormatContext *s)
1239 {
1240     AVStream *st;
1241     int i, j;
1242
1243     flush_packet_queue(s);
1244
1245     s->cur_st = NULL;
1246
1247     /* for each stream, reset read state */
1248     for(i = 0; i < s->nb_streams; i++) {
1249         st = s->streams[i];
1250
1251         if (st->parser) {
1252             av_parser_close(st->parser);
1253             st->parser = NULL;
1254             av_free_packet(&st->cur_pkt);
1255         }
1256         st->last_IP_pts = AV_NOPTS_VALUE;
1257         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1258         st->reference_dts = AV_NOPTS_VALUE;
1259         /* fail safe */
1260         st->cur_ptr = NULL;
1261         st->cur_len = 0;
1262
1263         st->probe_packets = MAX_PROBE_PACKETS;
1264
1265         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1266             st->pts_buffer[j]= AV_NOPTS_VALUE;
1267     }
1268 }
1269
1270 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1271     int i;
1272
1273     for(i = 0; i < s->nb_streams; i++) {
1274         AVStream *st = s->streams[i];
1275
1276         st->cur_dts = av_rescale(timestamp,
1277                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1278                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1279     }
1280 }
1281
1282 void ff_reduce_index(AVFormatContext *s, int stream_index)
1283 {
1284     AVStream *st= s->streams[stream_index];
1285     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1286
1287     if((unsigned)st->nb_index_entries >= max_entries){
1288         int i;
1289         for(i=0; 2*i<st->nb_index_entries; i++)
1290             st->index_entries[i]= st->index_entries[2*i];
1291         st->nb_index_entries= i;
1292     }
1293 }
1294
1295 int av_add_index_entry(AVStream *st,
1296                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1297 {
1298     AVIndexEntry *entries, *ie;
1299     int index;
1300
1301     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1302         return -1;
1303
1304     entries = av_fast_realloc(st->index_entries,
1305                               &st->index_entries_allocated_size,
1306                               (st->nb_index_entries + 1) *
1307                               sizeof(AVIndexEntry));
1308     if(!entries)
1309         return -1;
1310
1311     st->index_entries= entries;
1312
1313     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1314
1315     if(index<0){
1316         index= st->nb_index_entries++;
1317         ie= &entries[index];
1318         assert(index==0 || ie[-1].timestamp < timestamp);
1319     }else{
1320         ie= &entries[index];
1321         if(ie->timestamp != timestamp){
1322             if(ie->timestamp <= timestamp)
1323                 return -1;
1324             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1325             st->nb_index_entries++;
1326         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1327             distance= ie->min_distance;
1328     }
1329
1330     ie->pos = pos;
1331     ie->timestamp = timestamp;
1332     ie->min_distance= distance;
1333     ie->size= size;
1334     ie->flags = flags;
1335
1336     return index;
1337 }
1338
1339 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1340                               int flags)
1341 {
1342     AVIndexEntry *entries= st->index_entries;
1343     int nb_entries= st->nb_index_entries;
1344     int a, b, m;
1345     int64_t timestamp;
1346
1347     a = - 1;
1348     b = nb_entries;
1349
1350     //optimize appending index entries at the end
1351     if(b && entries[b-1].timestamp < wanted_timestamp)
1352         a= b-1;
1353
1354     while (b - a > 1) {
1355         m = (a + b) >> 1;
1356         timestamp = entries[m].timestamp;
1357         if(timestamp >= wanted_timestamp)
1358             b = m;
1359         if(timestamp <= wanted_timestamp)
1360             a = m;
1361     }
1362     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1363
1364     if(!(flags & AVSEEK_FLAG_ANY)){
1365         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1366             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1367         }
1368     }
1369
1370     if(m == nb_entries)
1371         return -1;
1372     return  m;
1373 }
1374
1375 #define DEBUG_SEEK
1376
1377 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1378     AVInputFormat *avif= s->iformat;
1379     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1380     int64_t ts_min, ts_max, ts;
1381     int index;
1382     int64_t ret;
1383     AVStream *st;
1384
1385     if (stream_index < 0)
1386         return -1;
1387
1388 #ifdef DEBUG_SEEK
1389     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1390 #endif
1391
1392     ts_max=
1393     ts_min= AV_NOPTS_VALUE;
1394     pos_limit= -1; //gcc falsely says it may be uninitialized
1395
1396     st= s->streams[stream_index];
1397     if(st->index_entries){
1398         AVIndexEntry *e;
1399
1400         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()
1401         index= FFMAX(index, 0);
1402         e= &st->index_entries[index];
1403
1404         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1405             pos_min= e->pos;
1406             ts_min= e->timestamp;
1407 #ifdef DEBUG_SEEK
1408             av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1409                    pos_min,ts_min);
1410 #endif
1411         }else{
1412             assert(index==0);
1413         }
1414
1415         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1416         assert(index < st->nb_index_entries);
1417         if(index >= 0){
1418             e= &st->index_entries[index];
1419             assert(e->timestamp >= target_ts);
1420             pos_max= e->pos;
1421             ts_max= e->timestamp;
1422             pos_limit= pos_max - e->min_distance;
1423 #ifdef DEBUG_SEEK
1424             av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1425                    pos_max,pos_limit, ts_max);
1426 #endif
1427         }
1428     }
1429
1430     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1431     if(pos<0)
1432         return -1;
1433
1434     /* do the seek */
1435     if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1436         return ret;
1437
1438     av_update_cur_dts(s, st, ts);
1439
1440     return 0;
1441 }
1442
1443 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1444     int64_t pos, ts;
1445     int64_t start_pos, filesize;
1446     int no_change;
1447
1448 #ifdef DEBUG_SEEK
1449     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1450 #endif
1451
1452     if(ts_min == AV_NOPTS_VALUE){
1453         pos_min = s->data_offset;
1454         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1455         if (ts_min == AV_NOPTS_VALUE)
1456             return -1;
1457     }
1458
1459     if(ts_max == AV_NOPTS_VALUE){
1460         int step= 1024;
1461         filesize = url_fsize(s->pb);
1462         pos_max = filesize - 1;
1463         do{
1464             pos_max -= step;
1465             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1466             step += step;
1467         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1468         if (ts_max == AV_NOPTS_VALUE)
1469             return -1;
1470
1471         for(;;){
1472             int64_t tmp_pos= pos_max + 1;
1473             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1474             if(tmp_ts == AV_NOPTS_VALUE)
1475                 break;
1476             ts_max= tmp_ts;
1477             pos_max= tmp_pos;
1478             if(tmp_pos >= filesize)
1479                 break;
1480         }
1481         pos_limit= pos_max;
1482     }
1483
1484     if(ts_min > ts_max){
1485         return -1;
1486     }else if(ts_min == ts_max){
1487         pos_limit= pos_min;
1488     }
1489
1490     no_change=0;
1491     while (pos_min < pos_limit) {
1492 #ifdef DEBUG_SEEK
1493         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1494                pos_min, pos_max,
1495                ts_min, ts_max);
1496 #endif
1497         assert(pos_limit <= pos_max);
1498
1499         if(no_change==0){
1500             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1501             // interpolate position (better than dichotomy)
1502             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1503                 + pos_min - approximate_keyframe_distance;
1504         }else if(no_change==1){
1505             // bisection, if interpolation failed to change min or max pos last time
1506             pos = (pos_min + pos_limit)>>1;
1507         }else{
1508             /* linear search if bisection failed, can only happen if there
1509                are very few or no keyframes between min/max */
1510             pos=pos_min;
1511         }
1512         if(pos <= pos_min)
1513             pos= pos_min + 1;
1514         else if(pos > pos_limit)
1515             pos= pos_limit;
1516         start_pos= pos;
1517
1518         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1519         if(pos == pos_max)
1520             no_change++;
1521         else
1522             no_change=0;
1523 #ifdef DEBUG_SEEK
1524         av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1525                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1526                start_pos, no_change);
1527 #endif
1528         if(ts == AV_NOPTS_VALUE){
1529             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1530             return -1;
1531         }
1532         assert(ts != AV_NOPTS_VALUE);
1533         if (target_ts <= ts) {
1534             pos_limit = start_pos - 1;
1535             pos_max = pos;
1536             ts_max = ts;
1537         }
1538         if (target_ts >= ts) {
1539             pos_min = pos;
1540             ts_min = ts;
1541         }
1542     }
1543
1544     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1545     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1546 #ifdef DEBUG_SEEK
1547     pos_min = pos;
1548     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1549     pos_min++;
1550     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1551     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1552            pos, ts_min, target_ts, ts_max);
1553 #endif
1554     *ts_ret= ts;
1555     return pos;
1556 }
1557
1558 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1559     int64_t pos_min, pos_max;
1560 #if 0
1561     AVStream *st;
1562
1563     if (stream_index < 0)
1564         return -1;
1565
1566     st= s->streams[stream_index];
1567 #endif
1568
1569     pos_min = s->data_offset;
1570     pos_max = url_fsize(s->pb) - 1;
1571
1572     if     (pos < pos_min) pos= pos_min;
1573     else if(pos > pos_max) pos= pos_max;
1574
1575     url_fseek(s->pb, pos, SEEK_SET);
1576
1577 #if 0
1578     av_update_cur_dts(s, st, ts);
1579 #endif
1580     return 0;
1581 }
1582
1583 static int av_seek_frame_generic(AVFormatContext *s,
1584                                  int stream_index, int64_t timestamp, int flags)
1585 {
1586     int index;
1587     int64_t ret;
1588     AVStream *st;
1589     AVIndexEntry *ie;
1590
1591     st = s->streams[stream_index];
1592
1593     index = av_index_search_timestamp(st, timestamp, flags);
1594
1595     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1596         return -1;
1597
1598     if(index < 0 || index==st->nb_index_entries-1){
1599         int i;
1600         AVPacket pkt;
1601
1602         if(st->nb_index_entries){
1603             assert(st->index_entries);
1604             ie= &st->index_entries[st->nb_index_entries-1];
1605             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1606                 return ret;
1607             av_update_cur_dts(s, st, ie->timestamp);
1608         }else{
1609             if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1610                 return ret;
1611         }
1612         for(i=0;; i++) {
1613             int ret;
1614             do{
1615                 ret = av_read_frame(s, &pkt);
1616             }while(ret == AVERROR(EAGAIN));
1617             if(ret<0)
1618                 break;
1619             av_free_packet(&pkt);
1620             if(stream_index == pkt.stream_index){
1621                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1622                     break;
1623             }
1624         }
1625         index = av_index_search_timestamp(st, timestamp, flags);
1626     }
1627     if (index < 0)
1628         return -1;
1629
1630     ff_read_frame_flush(s);
1631     if (s->iformat->read_seek){
1632         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1633             return 0;
1634     }
1635     ie = &st->index_entries[index];
1636     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1637         return ret;
1638     av_update_cur_dts(s, st, ie->timestamp);
1639
1640     return 0;
1641 }
1642
1643 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1644 {
1645     int ret;
1646     AVStream *st;
1647
1648     ff_read_frame_flush(s);
1649
1650     if(flags & AVSEEK_FLAG_BYTE)
1651         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1652
1653     if(stream_index < 0){
1654         stream_index= av_find_default_stream_index(s);
1655         if(stream_index < 0)
1656             return -1;
1657
1658         st= s->streams[stream_index];
1659        /* timestamp for default must be expressed in AV_TIME_BASE units */
1660         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1661     }
1662
1663     /* first, we try the format specific seek */
1664     if (s->iformat->read_seek)
1665         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1666     else
1667         ret = -1;
1668     if (ret >= 0) {
1669         return 0;
1670     }
1671
1672     if(s->iformat->read_timestamp)
1673         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1674     else
1675         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1676 }
1677
1678 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1679 {
1680     if(min_ts > ts || max_ts < ts)
1681         return -1;
1682
1683     ff_read_frame_flush(s);
1684
1685     if (s->iformat->read_seek2)
1686         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1687
1688     if(s->iformat->read_timestamp){
1689         //try to seek via read_timestamp()
1690     }
1691
1692     //Fallback to old API if new is not implemented but old is
1693     //Note the old has somewat different sematics
1694     if(s->iformat->read_seek || 1)
1695         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1696
1697     // try some generic seek like av_seek_frame_generic() but with new ts semantics
1698 }
1699
1700 /*******************************************************/
1701
1702 /**
1703  * Returns TRUE if the stream has accurate duration in any stream.
1704  *
1705  * @return TRUE if the stream has accurate duration for at least one component.
1706  */
1707 static int av_has_duration(AVFormatContext *ic)
1708 {
1709     int i;
1710     AVStream *st;
1711
1712     for(i = 0;i < ic->nb_streams; i++) {
1713         st = ic->streams[i];
1714         if (st->duration != AV_NOPTS_VALUE)
1715             return 1;
1716     }
1717     return 0;
1718 }
1719
1720 /**
1721  * Estimate the stream timings from the one of each components.
1722  *
1723  * Also computes the global bitrate if possible.
1724  */
1725 static void av_update_stream_timings(AVFormatContext *ic)
1726 {
1727     int64_t start_time, start_time1, end_time, end_time1;
1728     int64_t duration, duration1;
1729     int i;
1730     AVStream *st;
1731
1732     start_time = INT64_MAX;
1733     end_time = INT64_MIN;
1734     duration = INT64_MIN;
1735     for(i = 0;i < ic->nb_streams; i++) {
1736         st = ic->streams[i];
1737         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1738             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1739             if (start_time1 < start_time)
1740                 start_time = start_time1;
1741             if (st->duration != AV_NOPTS_VALUE) {
1742                 end_time1 = start_time1
1743                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1744                 if (end_time1 > end_time)
1745                     end_time = end_time1;
1746             }
1747         }
1748         if (st->duration != AV_NOPTS_VALUE) {
1749             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1750             if (duration1 > duration)
1751                 duration = duration1;
1752         }
1753     }
1754     if (start_time != INT64_MAX) {
1755         ic->start_time = start_time;
1756         if (end_time != INT64_MIN) {
1757             if (end_time - start_time > duration)
1758                 duration = end_time - start_time;
1759         }
1760     }
1761     if (duration != INT64_MIN) {
1762         ic->duration = duration;
1763         if (ic->file_size > 0) {
1764             /* compute the bitrate */
1765             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1766                 (double)ic->duration;
1767         }
1768     }
1769 }
1770
1771 static void fill_all_stream_timings(AVFormatContext *ic)
1772 {
1773     int i;
1774     AVStream *st;
1775
1776     av_update_stream_timings(ic);
1777     for(i = 0;i < ic->nb_streams; i++) {
1778         st = ic->streams[i];
1779         if (st->start_time == AV_NOPTS_VALUE) {
1780             if(ic->start_time != AV_NOPTS_VALUE)
1781                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1782             if(ic->duration != AV_NOPTS_VALUE)
1783                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1784         }
1785     }
1786 }
1787
1788 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1789 {
1790     int64_t filesize, duration;
1791     int bit_rate, i;
1792     AVStream *st;
1793
1794     /* if bit_rate is already set, we believe it */
1795     if (ic->bit_rate == 0) {
1796         bit_rate = 0;
1797         for(i=0;i<ic->nb_streams;i++) {
1798             st = ic->streams[i];
1799             bit_rate += st->codec->bit_rate;
1800         }
1801         ic->bit_rate = bit_rate;
1802     }
1803
1804     /* if duration is already set, we believe it */
1805     if (ic->duration == AV_NOPTS_VALUE &&
1806         ic->bit_rate != 0 &&
1807         ic->file_size != 0)  {
1808         filesize = ic->file_size;
1809         if (filesize > 0) {
1810             for(i = 0; i < ic->nb_streams; i++) {
1811                 st = ic->streams[i];
1812                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1813                 if (st->duration == AV_NOPTS_VALUE)
1814                     st->duration = duration;
1815             }
1816         }
1817     }
1818 }
1819
1820 #define DURATION_MAX_READ_SIZE 250000
1821 #define DURATION_MAX_RETRY 3
1822
1823 /* only usable for MPEG-PS streams */
1824 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1825 {
1826     AVPacket pkt1, *pkt = &pkt1;
1827     AVStream *st;
1828     int read_size, i, ret;
1829     int64_t end_time, start_time[MAX_STREAMS];
1830     int64_t filesize, offset, duration;
1831     int retry=0;
1832
1833     ic->cur_st = NULL;
1834
1835     /* flush packet queue */
1836     flush_packet_queue(ic);
1837
1838     for(i=0;i<ic->nb_streams;i++) {
1839         st = ic->streams[i];
1840         if(st->start_time != AV_NOPTS_VALUE){
1841             start_time[i]= st->start_time;
1842         }else if(st->first_dts != AV_NOPTS_VALUE){
1843             start_time[i]= st->first_dts;
1844         }else
1845             av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1846
1847         if (st->parser) {
1848             av_parser_close(st->parser);
1849             st->parser= NULL;
1850             av_free_packet(&st->cur_pkt);
1851         }
1852     }
1853
1854     /* estimate the end time (duration) */
1855     /* XXX: may need to support wrapping */
1856     filesize = ic->file_size;
1857     end_time = AV_NOPTS_VALUE;
1858     do{
1859     offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1860     if (offset < 0)
1861         offset = 0;
1862
1863     url_fseek(ic->pb, offset, SEEK_SET);
1864     read_size = 0;
1865     for(;;) {
1866         if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1867             break;
1868
1869         do{
1870             ret = av_read_packet(ic, pkt);
1871         }while(ret == AVERROR(EAGAIN));
1872         if (ret != 0)
1873             break;
1874         read_size += pkt->size;
1875         st = ic->streams[pkt->stream_index];
1876         if (pkt->pts != AV_NOPTS_VALUE &&
1877             start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1878             end_time = pkt->pts;
1879             duration = end_time - start_time[pkt->stream_index];
1880             if (duration < 0)
1881                 duration += 1LL<<st->pts_wrap_bits;
1882             if (duration > 0) {
1883                 if (st->duration == AV_NOPTS_VALUE ||
1884                     st->duration < duration)
1885                     st->duration = duration;
1886             }
1887         }
1888         av_free_packet(pkt);
1889     }
1890     }while(   end_time==AV_NOPTS_VALUE
1891            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1892            && ++retry <= DURATION_MAX_RETRY);
1893
1894     fill_all_stream_timings(ic);
1895
1896     url_fseek(ic->pb, old_offset, SEEK_SET);
1897     for(i=0; i<ic->nb_streams; i++){
1898         st= ic->streams[i];
1899         st->cur_dts= st->first_dts;
1900         st->last_IP_pts = AV_NOPTS_VALUE;
1901     }
1902 }
1903
1904 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1905 {
1906     int64_t file_size;
1907
1908     /* get the file size, if possible */
1909     if (ic->iformat->flags & AVFMT_NOFILE) {
1910         file_size = 0;
1911     } else {
1912         file_size = url_fsize(ic->pb);
1913         if (file_size < 0)
1914             file_size = 0;
1915     }
1916     ic->file_size = file_size;
1917
1918     if ((!strcmp(ic->iformat->name, "mpeg") ||
1919          !strcmp(ic->iformat->name, "mpegts")) &&
1920         file_size && !url_is_streamed(ic->pb)) {
1921         /* get accurate estimate from the PTSes */
1922         av_estimate_timings_from_pts(ic, old_offset);
1923     } else if (av_has_duration(ic)) {
1924         /* at least one component has timings - we use them for all
1925            the components */
1926         fill_all_stream_timings(ic);
1927     } else {
1928         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1929         /* less precise: use bitrate info */
1930         av_estimate_timings_from_bit_rate(ic);
1931     }
1932     av_update_stream_timings(ic);
1933
1934 #if 0
1935     {
1936         int i;
1937         AVStream *st;
1938         for(i = 0;i < ic->nb_streams; i++) {
1939             st = ic->streams[i];
1940         printf("%d: start_time: %0.3f duration: %0.3f\n",
1941                i, (double)st->start_time / AV_TIME_BASE,
1942                (double)st->duration / AV_TIME_BASE);
1943         }
1944         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1945                (double)ic->start_time / AV_TIME_BASE,
1946                (double)ic->duration / AV_TIME_BASE,
1947                ic->bit_rate / 1000);
1948     }
1949 #endif
1950 }
1951
1952 static int has_codec_parameters(AVCodecContext *enc)
1953 {
1954     int val;
1955     switch(enc->codec_type) {
1956     case CODEC_TYPE_AUDIO:
1957         val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1958         if(!enc->frame_size &&
1959            (enc->codec_id == CODEC_ID_VORBIS ||
1960             enc->codec_id == CODEC_ID_AAC ||
1961             enc->codec_id == CODEC_ID_MP1 ||
1962             enc->codec_id == CODEC_ID_MP2 ||
1963             enc->codec_id == CODEC_ID_MP3 ||
1964             enc->codec_id == CODEC_ID_SPEEX))
1965             return 0;
1966         break;
1967     case CODEC_TYPE_VIDEO:
1968         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1969         break;
1970     default:
1971         val = 1;
1972         break;
1973     }
1974     return enc->codec_id != CODEC_ID_NONE && val != 0;
1975 }
1976
1977 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1978 {
1979     int16_t *samples;
1980     AVCodec *codec;
1981     int got_picture, data_size, ret=0;
1982     AVFrame picture;
1983
1984     if(!st->codec->codec){
1985         codec = avcodec_find_decoder(st->codec->codec_id);
1986         if (!codec)
1987             return -1;
1988         ret = avcodec_open(st->codec, codec);
1989         if (ret < 0)
1990             return ret;
1991     }
1992
1993     if(!has_codec_parameters(st->codec)){
1994         switch(st->codec->codec_type) {
1995         case CODEC_TYPE_VIDEO:
1996             avcodec_get_frame_defaults(&picture);
1997             ret = avcodec_decode_video2(st->codec, &picture,
1998                                         &got_picture, avpkt);
1999             break;
2000         case CODEC_TYPE_AUDIO:
2001             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2002             samples = av_malloc(data_size);
2003             if (!samples)
2004                 goto fail;
2005             ret = avcodec_decode_audio3(st->codec, samples,
2006                                         &data_size, avpkt);
2007             av_free(samples);
2008             break;
2009         default:
2010             break;
2011         }
2012     }
2013  fail:
2014     return ret;
2015 }
2016
2017 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2018 {
2019     while (tags->id != CODEC_ID_NONE) {
2020         if (tags->id == id)
2021             return tags->tag;
2022         tags++;
2023     }
2024     return 0;
2025 }
2026
2027 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2028 {
2029     int i;
2030     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2031         if(tag == tags[i].tag)
2032             return tags[i].id;
2033     }
2034     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2035         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2036            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2037            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2038            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2039             return tags[i].id;
2040     }
2041     return CODEC_ID_NONE;
2042 }
2043
2044 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2045 {
2046     int i;
2047     for(i=0; tags && tags[i]; i++){
2048         int tag= ff_codec_get_tag(tags[i], id);
2049         if(tag) return tag;
2050     }
2051     return 0;
2052 }
2053
2054 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2055 {
2056     int i;
2057     for(i=0; tags && tags[i]; i++){
2058         enum CodecID id= ff_codec_get_id(tags[i], tag);
2059         if(id!=CODEC_ID_NONE) return id;
2060     }
2061     return CODEC_ID_NONE;
2062 }
2063
2064 static void compute_chapters_end(AVFormatContext *s)
2065 {
2066     unsigned int i;
2067
2068     for (i=0; i+1<s->nb_chapters; i++)
2069         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2070             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2071             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2072             s->chapters[i]->end = s->chapters[i+1]->start;
2073         }
2074
2075     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2076         assert(s->start_time != AV_NOPTS_VALUE);
2077         assert(s->duration > 0);
2078         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2079                                            AV_TIME_BASE_Q,
2080                                            s->chapters[i]->time_base);
2081     }
2082 }
2083
2084 #define MAX_STD_TIMEBASES (60*12+5)
2085 static int get_std_framerate(int i){
2086     if(i<60*12) return i*1001;
2087     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2088 }
2089
2090 /*
2091  * Is the time base unreliable.
2092  * This is a heuristic to balance between quick acceptance of the values in
2093  * the headers vs. some extra checks.
2094  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2095  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2096  * And there are "variable" fps files this needs to detect as well.
2097  */
2098 static int tb_unreliable(AVCodecContext *c){
2099     if(   c->time_base.den >= 101L*c->time_base.num
2100        || c->time_base.den <    5L*c->time_base.num
2101 /*       || c->codec_tag == AV_RL32("DIVX")
2102        || c->codec_tag == AV_RL32("XVID")*/
2103        || c->codec_id == CODEC_ID_MPEG2VIDEO
2104        || c->codec_id == CODEC_ID_H264
2105        )
2106         return 1;
2107     return 0;
2108 }
2109
2110 int av_find_stream_info(AVFormatContext *ic)
2111 {
2112     int i, count, ret, read_size, j;
2113     AVStream *st;
2114     AVPacket pkt1, *pkt;
2115     int64_t last_dts[MAX_STREAMS];
2116     int64_t duration_gcd[MAX_STREAMS]={0};
2117     int duration_count[MAX_STREAMS]={0};
2118     double (*duration_error)[MAX_STD_TIMEBASES];
2119     int64_t old_offset = url_ftell(ic->pb);
2120     int64_t codec_info_duration[MAX_STREAMS]={0};
2121
2122     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2123     if (!duration_error) return AVERROR(ENOMEM);
2124
2125     for(i=0;i<ic->nb_streams;i++) {
2126         st = ic->streams[i];
2127         if (st->codec->codec_id == CODEC_ID_AAC) {
2128             st->codec->sample_rate = 0;
2129             st->codec->frame_size = 0;
2130             st->codec->channels = 0;
2131         }
2132         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2133 /*            if(!st->time_base.num)
2134                 st->time_base= */
2135             if(!st->codec->time_base.num)
2136                 st->codec->time_base= st->time_base;
2137         }
2138         //only for the split stuff
2139         if (!st->parser) {
2140             st->parser = av_parser_init(st->codec->codec_id);
2141             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2142                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2143             }
2144         }
2145         assert(!st->codec->codec);
2146         //try to just open decoders, in case this is enough to get parameters
2147         if(!has_codec_parameters(st->codec)){
2148             AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2149             if (codec)
2150                 avcodec_open(st->codec, codec);
2151         }
2152     }
2153
2154     for(i=0;i<MAX_STREAMS;i++){
2155         last_dts[i]= AV_NOPTS_VALUE;
2156     }
2157
2158     count = 0;
2159     read_size = 0;
2160     for(;;) {
2161         if(url_interrupt_cb()){
2162             ret= AVERROR(EINTR);
2163             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2164             break;
2165         }
2166
2167         /* check if one codec still needs to be handled */
2168         for(i=0;i<ic->nb_streams;i++) {
2169             st = ic->streams[i];
2170             if (!has_codec_parameters(st->codec))
2171                 break;
2172             /* variable fps and no guess at the real fps */
2173             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2174                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2175                 break;
2176             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2177                 break;
2178             if(st->first_dts == AV_NOPTS_VALUE)
2179                 break;
2180         }
2181         if (i == ic->nb_streams) {
2182             /* NOTE: if the format has no header, then we need to read
2183                some packets to get most of the streams, so we cannot
2184                stop here */
2185             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2186                 /* if we found the info for all the codecs, we can stop */
2187                 ret = count;
2188                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2189                 break;
2190             }
2191         }
2192         /* we did not get all the codec info, but we read too much data */
2193         if (read_size >= ic->probesize) {
2194             ret = count;
2195             av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2196             break;
2197         }
2198
2199         /* NOTE: a new stream can be added there if no header in file
2200            (AVFMTCTX_NOHEADER) */
2201         ret = av_read_frame_internal(ic, &pkt1);
2202         if(ret == AVERROR(EAGAIN))
2203             continue;
2204         if (ret < 0) {
2205             /* EOF or error */
2206             ret = -1; /* we could not have all the codec parameters before EOF */
2207             for(i=0;i<ic->nb_streams;i++) {
2208                 st = ic->streams[i];
2209                 if (!has_codec_parameters(st->codec)){
2210                     char buf[256];
2211                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2212                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2213                 } else {
2214                     ret = 0;
2215                 }
2216             }
2217             break;
2218         }
2219
2220         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2221         if(av_dup_packet(pkt) < 0) {
2222             av_free(duration_error);
2223             return AVERROR(ENOMEM);
2224         }
2225
2226         read_size += pkt->size;
2227
2228         st = ic->streams[pkt->stream_index];
2229         if(st->codec_info_nb_frames>1) {
2230             if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2231                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2232                 break;
2233             }
2234             codec_info_duration[st->index] += pkt->duration;
2235         }
2236             st->codec_info_nb_frames++;
2237
2238         {
2239             int index= pkt->stream_index;
2240             int64_t last= last_dts[index];
2241             int64_t duration= pkt->dts - last;
2242
2243             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2244                 double dur= duration * av_q2d(st->time_base);
2245
2246 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2247 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2248                 if(duration_count[index] < 2)
2249                     memset(duration_error[index], 0, sizeof(*duration_error));
2250                 for(i=1; i<MAX_STD_TIMEBASES; i++){
2251                     int framerate= get_std_framerate(i);
2252                     int ticks= lrintf(dur*framerate/(1001*12));
2253                     double error= dur - ticks*1001*12/(double)framerate;
2254                     duration_error[index][i] += error*error;
2255                 }
2256                 duration_count[index]++;
2257                 // ignore the first 4 values, they might have some random jitter
2258                 if (duration_count[index] > 3)
2259                     duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2260             }
2261             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2262                 last_dts[pkt->stream_index]= pkt->dts;
2263         }
2264         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2265             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2266             if(i){
2267                 st->codec->extradata_size= i;
2268                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2269                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2270                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2271             }
2272         }
2273
2274         /* if still no information, we try to open the codec and to
2275            decompress the frame. We try to avoid that in most cases as
2276            it takes longer and uses more memory. For MPEG-4, we need to
2277            decompress for QuickTime. */
2278         if (!has_codec_parameters(st->codec))
2279             try_decode_frame(st, pkt);
2280
2281         count++;
2282     }
2283
2284     // close codecs which were opened in try_decode_frame()
2285     for(i=0;i<ic->nb_streams;i++) {
2286         st = ic->streams[i];
2287         if(st->codec->codec)
2288             avcodec_close(st->codec);
2289     }
2290     for(i=0;i<ic->nb_streams;i++) {
2291         st = ic->streams[i];
2292         if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2293             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2294                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2295                       codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2296         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2297             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2298                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2299
2300             // the check for tb_unreliable() is not completely correct, since this is not about handling
2301             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2302             // ipmovie.c produces.
2303             if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2304                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2305             if(duration_count[i] && !st->r_frame_rate.num
2306                && tb_unreliable(st->codec) /*&&
2307                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2308                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2309                 int num = 0;
2310                 double best_error= 2*av_q2d(st->time_base);
2311                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2312
2313                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2314                     double error= duration_error[i][j] * get_std_framerate(j);
2315 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2316 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2317                     if(error < best_error){
2318                         best_error= error;
2319                         num = get_std_framerate(j);
2320                     }
2321                 }
2322                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2323                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2324                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2325             }
2326
2327             if (!st->r_frame_rate.num){
2328                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2329                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2330                     st->r_frame_rate.num = st->codec->time_base.den;
2331                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2332                 }else{
2333                     st->r_frame_rate.num = st->time_base.den;
2334                     st->r_frame_rate.den = st->time_base.num;
2335                 }
2336             }
2337         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2338             if(!st->codec->bits_per_coded_sample)
2339                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2340         }
2341     }
2342
2343     av_estimate_timings(ic, old_offset);
2344
2345     compute_chapters_end(ic);
2346
2347 #if 0
2348     /* correct DTS for B-frame streams with no timestamps */
2349     for(i=0;i<ic->nb_streams;i++) {
2350         st = ic->streams[i];
2351         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2352             if(b-frames){
2353                 ppktl = &ic->packet_buffer;
2354                 while(ppkt1){
2355                     if(ppkt1->stream_index != i)
2356                         continue;
2357                     if(ppkt1->pkt->dts < 0)
2358                         break;
2359                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2360                         break;
2361                     ppkt1->pkt->dts -= delta;
2362                     ppkt1= ppkt1->next;
2363                 }
2364                 if(ppkt1)
2365                     continue;
2366                 st->cur_dts -= delta;
2367             }
2368         }
2369     }
2370 #endif
2371
2372     av_free(duration_error);
2373
2374     return ret;
2375 }
2376
2377 /*******************************************************/
2378
2379 int av_read_play(AVFormatContext *s)
2380 {
2381     if (s->iformat->read_play)
2382         return s->iformat->read_play(s);
2383     if (s->pb)
2384         return av_url_read_fpause(s->pb, 0);
2385     return AVERROR(ENOSYS);
2386 }
2387
2388 int av_read_pause(AVFormatContext *s)
2389 {
2390     if (s->iformat->read_pause)
2391         return s->iformat->read_pause(s);
2392     if (s->pb)
2393         return av_url_read_fpause(s->pb, 1);
2394     return AVERROR(ENOSYS);
2395 }
2396
2397 void av_close_input_stream(AVFormatContext *s)
2398 {
2399     int i;
2400     AVStream *st;
2401
2402     if (s->iformat->read_close)
2403         s->iformat->read_close(s);
2404     for(i=0;i<s->nb_streams;i++) {
2405         /* free all data in a stream component */
2406         st = s->streams[i];
2407         if (st->parser) {
2408             av_parser_close(st->parser);
2409             av_free_packet(&st->cur_pkt);
2410         }
2411         av_metadata_free(&st->metadata);
2412         av_free(st->index_entries);
2413         av_free(st->codec->extradata);
2414         av_free(st->codec);
2415 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2416         av_free(st->filename);
2417 #endif
2418         av_free(st->priv_data);
2419         av_free(st);
2420     }
2421     for(i=s->nb_programs-1; i>=0; i--) {
2422 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2423         av_freep(&s->programs[i]->provider_name);
2424         av_freep(&s->programs[i]->name);
2425 #endif
2426         av_metadata_free(&s->programs[i]->metadata);
2427         av_freep(&s->programs[i]->stream_index);
2428         av_freep(&s->programs[i]);
2429     }
2430     av_freep(&s->programs);
2431     flush_packet_queue(s);
2432     av_freep(&s->priv_data);
2433     while(s->nb_chapters--) {
2434 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2435         av_free(s->chapters[s->nb_chapters]->title);
2436 #endif
2437         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2438         av_free(s->chapters[s->nb_chapters]);
2439     }
2440     av_freep(&s->chapters);
2441     av_metadata_free(&s->metadata);
2442     av_free(s);
2443 }
2444
2445 void av_close_input_file(AVFormatContext *s)
2446 {
2447     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2448     av_close_input_stream(s);
2449     if (pb)
2450         url_fclose(pb);
2451 }
2452
2453 AVStream *av_new_stream(AVFormatContext *s, int id)
2454 {
2455     AVStream *st;
2456     int i;
2457
2458     if (s->nb_streams >= MAX_STREAMS)
2459         return NULL;
2460
2461     st = av_mallocz(sizeof(AVStream));
2462     if (!st)
2463         return NULL;
2464
2465     st->codec= avcodec_alloc_context();
2466     if (s->iformat) {
2467         /* no default bitrate if decoding */
2468         st->codec->bit_rate = 0;
2469     }
2470     st->index = s->nb_streams;
2471     st->id = id;
2472     st->start_time = AV_NOPTS_VALUE;
2473     st->duration = AV_NOPTS_VALUE;
2474         /* we set the current DTS to 0 so that formats without any timestamps
2475            but durations get some timestamps, formats with some unknown
2476            timestamps have their first few packets buffered and the
2477            timestamps corrected before they are returned to the user */
2478     st->cur_dts = 0;
2479     st->first_dts = AV_NOPTS_VALUE;
2480     st->probe_packets = MAX_PROBE_PACKETS;
2481
2482     /* default pts setting is MPEG-like */
2483     av_set_pts_info(st, 33, 1, 90000);
2484     st->last_IP_pts = AV_NOPTS_VALUE;
2485     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2486         st->pts_buffer[i]= AV_NOPTS_VALUE;
2487     st->reference_dts = AV_NOPTS_VALUE;
2488
2489     st->sample_aspect_ratio = (AVRational){0,1};
2490
2491     s->streams[s->nb_streams++] = st;
2492     return st;
2493 }
2494
2495 AVProgram *av_new_program(AVFormatContext *ac, int id)
2496 {
2497     AVProgram *program=NULL;
2498     int i;
2499
2500 #ifdef DEBUG_SI
2501     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2502 #endif
2503
2504     for(i=0; i<ac->nb_programs; i++)
2505         if(ac->programs[i]->id == id)
2506             program = ac->programs[i];
2507
2508     if(!program){
2509         program = av_mallocz(sizeof(AVProgram));
2510         if (!program)
2511             return NULL;
2512         dynarray_add(&ac->programs, &ac->nb_programs, program);
2513         program->discard = AVDISCARD_NONE;
2514     }
2515     program->id = id;
2516
2517     return program;
2518 }
2519
2520 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2521 {
2522     AVChapter *chapter = NULL;
2523     int i;
2524
2525     for(i=0; i<s->nb_chapters; i++)
2526         if(s->chapters[i]->id == id)
2527             chapter = s->chapters[i];
2528
2529     if(!chapter){
2530         chapter= av_mallocz(sizeof(AVChapter));
2531         if(!chapter)
2532             return NULL;
2533         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2534     }
2535 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2536     av_free(chapter->title);
2537 #endif
2538     av_metadata_set(&chapter->metadata, "title", title);
2539     chapter->id    = id;
2540     chapter->time_base= time_base;
2541     chapter->start = start;
2542     chapter->end   = end;
2543
2544     return chapter;
2545 }
2546
2547 /************************************************************/
2548 /* output media file */
2549
2550 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2551 {
2552     int ret;
2553
2554     if (s->oformat->priv_data_size > 0) {
2555         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2556         if (!s->priv_data)
2557             return AVERROR(ENOMEM);
2558     } else
2559         s->priv_data = NULL;
2560
2561     if (s->oformat->set_parameters) {
2562         ret = s->oformat->set_parameters(s, ap);
2563         if (ret < 0)
2564             return ret;
2565     }
2566     return 0;
2567 }
2568
2569 int av_write_header(AVFormatContext *s)
2570 {
2571     int ret, i;
2572     AVStream *st;
2573
2574     // some sanity checks
2575     if (s->nb_streams == 0) {
2576         av_log(s, AV_LOG_ERROR, "no streams\n");
2577         return -1;
2578     }
2579
2580     for(i=0;i<s->nb_streams;i++) {
2581         st = s->streams[i];
2582
2583         switch (st->codec->codec_type) {
2584         case CODEC_TYPE_AUDIO:
2585             if(st->codec->sample_rate<=0){
2586                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2587                 return -1;
2588             }
2589             if(!st->codec->block_align)
2590                 st->codec->block_align = st->codec->channels *
2591                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2592             break;
2593         case CODEC_TYPE_VIDEO:
2594             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2595                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2596                 return -1;
2597             }
2598             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2599                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2600                 return -1;
2601             }
2602             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2603                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2604                 return -1;
2605             }
2606             break;
2607         }
2608
2609         if(s->oformat->codec_tag){
2610             if(st->codec->codec_tag){
2611                 //FIXME
2612                 //check that tag + id is in the table
2613                 //if neither is in the table -> OK
2614                 //if tag is in the table with another id -> FAIL
2615                 //if id is in the table with another tag -> FAIL unless strict < ?
2616             }else
2617                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2618         }
2619
2620         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2621             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2622           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2623     }
2624
2625     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2626         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2627         if (!s->priv_data)
2628             return AVERROR(ENOMEM);
2629     }
2630
2631 #if LIBAVFORMAT_VERSION_MAJOR < 53
2632     ff_metadata_mux_compat(s);
2633 #endif
2634
2635     /* set muxer identification string */
2636     if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2637         AVMetadata *m;
2638         AVMetadataTag *t;
2639
2640         if (!(m = av_mallocz(sizeof(AVMetadata))))
2641             return AVERROR(ENOMEM);
2642         av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2643         metadata_conv(&m, s->oformat->metadata_conv, NULL);
2644         if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2645             av_metadata_set2(&s->metadata, t->key, t->value, 0);
2646         av_metadata_free(&m);
2647     }
2648
2649     if(s->oformat->write_header){
2650         ret = s->oformat->write_header(s);
2651         if (ret < 0)
2652             return ret;
2653     }
2654
2655     /* init PTS generation */
2656     for(i=0;i<s->nb_streams;i++) {
2657         int64_t den = AV_NOPTS_VALUE;
2658         st = s->streams[i];
2659
2660         switch (st->codec->codec_type) {
2661         case CODEC_TYPE_AUDIO:
2662             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2663             break;
2664         case CODEC_TYPE_VIDEO:
2665             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2666             break;
2667         default:
2668             break;
2669         }
2670         if (den != AV_NOPTS_VALUE) {
2671             if (den <= 0)
2672                 return AVERROR_INVALIDDATA;
2673             av_frac_init(&st->pts, 0, 0, den);
2674         }
2675     }
2676     return 0;
2677 }
2678
2679 //FIXME merge with compute_pkt_fields
2680 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2681     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2682     int num, den, frame_size, i;
2683
2684 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2685
2686 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2687         return -1;*/
2688
2689     /* duration field */
2690     if (pkt->duration == 0) {
2691         compute_frame_duration(&num, &den, st, NULL, pkt);
2692         if (den && num) {
2693             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2694         }
2695     }
2696
2697     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2698         pkt->pts= pkt->dts;
2699
2700     //XXX/FIXME this is a temporary hack until all encoders output pts
2701     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2702         pkt->dts=
2703 //        pkt->pts= st->cur_dts;
2704         pkt->pts= st->pts.val;
2705     }
2706
2707     //calculate dts from pts
2708     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2709         st->pts_buffer[0]= pkt->pts;
2710         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2711             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2712         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2713             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2714
2715         pkt->dts= st->pts_buffer[0];
2716     }
2717
2718     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2719         av_log(s, AV_LOG_ERROR,
2720                "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2721                st->index, st->cur_dts, pkt->dts);
2722         return -1;
2723     }
2724     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2725         av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2726         return -1;
2727     }
2728
2729 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2730     st->cur_dts= pkt->dts;
2731     st->pts.val= pkt->dts;
2732
2733     /* update pts */
2734     switch (st->codec->codec_type) {
2735     case CODEC_TYPE_AUDIO:
2736         frame_size = get_audio_frame_size(st->codec, pkt->size);
2737
2738         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2739            likely equal to the encoder delay, but it would be better if we
2740            had the real timestamps from the encoder */
2741         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2742             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2743         }
2744         break;
2745     case CODEC_TYPE_VIDEO:
2746         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2747         break;
2748     default:
2749         break;
2750     }
2751     return 0;
2752 }
2753
2754 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2755 {
2756     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2757
2758     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2759         return ret;
2760
2761     ret= s->oformat->write_packet(s, pkt);
2762     if(!ret)
2763         ret= url_ferror(s->pb);
2764     return ret;
2765 }
2766
2767 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2768                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2769 {
2770     AVPacketList **next_point, *this_pktl;
2771
2772     this_pktl = av_mallocz(sizeof(AVPacketList));
2773     this_pktl->pkt= *pkt;
2774     pkt->destruct= NULL;             // do not free original but only the copy
2775     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2776
2777     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2778         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2779     }else
2780         next_point = &s->packet_buffer;
2781
2782     if(*next_point){
2783         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2784             while(!compare(s, &(*next_point)->pkt, pkt)){
2785                 next_point= &(*next_point)->next;
2786             }
2787             goto next_non_null;
2788         }else{
2789             next_point = &(s->packet_buffer_end->next);
2790         }
2791     }
2792     assert(!*next_point);
2793
2794     s->packet_buffer_end= this_pktl;
2795 next_non_null:
2796
2797     this_pktl->next= *next_point;
2798
2799     s->streams[pkt->stream_index]->last_in_packet_buffer=
2800     *next_point= this_pktl;
2801 }
2802
2803 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2804 {
2805     AVStream *st = s->streams[ pkt ->stream_index];
2806     AVStream *st2= s->streams[ next->stream_index];
2807     int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2808     int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2809     return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2810 }
2811
2812 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2813     AVPacketList *pktl;
2814     int stream_count=0;
2815     int i;
2816
2817     if(pkt){
2818         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2819     }
2820
2821     for(i=0; i < s->nb_streams; i++)
2822         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2823
2824     if(stream_count && (s->nb_streams == stream_count || flush)){
2825         pktl= s->packet_buffer;
2826         *out= pktl->pkt;
2827
2828         s->packet_buffer= pktl->next;
2829         if(!s->packet_buffer)
2830             s->packet_buffer_end= NULL;
2831
2832         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2833             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2834         av_freep(&pktl);
2835         return 1;
2836     }else{
2837         av_init_packet(out);
2838         return 0;
2839     }
2840 }
2841
2842 /**
2843  * Interleaves an AVPacket correctly so it can be muxed.
2844  * @param out the interleaved packet will be output here
2845  * @param in the input packet
2846  * @param flush 1 if no further packets are available as input and all
2847  *              remaining packets should be output
2848  * @return 1 if a packet was output, 0 if no packet could be output,
2849  *         < 0 if an error occurred
2850  */
2851 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2852     if(s->oformat->interleave_packet)
2853         return s->oformat->interleave_packet(s, out, in, flush);
2854     else
2855         return av_interleave_packet_per_dts(s, out, in, flush);
2856 }
2857
2858 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2859     AVStream *st= s->streams[ pkt->stream_index];
2860
2861     //FIXME/XXX/HACK drop zero sized packets
2862     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2863         return 0;
2864
2865 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2866     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2867         return -1;
2868
2869     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2870         return -1;
2871
2872     for(;;){
2873         AVPacket opkt;
2874         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2875         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2876             return ret;
2877
2878         ret= s->oformat->write_packet(s, &opkt);
2879
2880         av_free_packet(&opkt);
2881         pkt= NULL;
2882
2883         if(ret<0)
2884             return ret;
2885         if(url_ferror(s->pb))
2886             return url_ferror(s->pb);
2887     }
2888 }
2889
2890 int av_write_trailer(AVFormatContext *s)
2891 {
2892     int ret, i;
2893
2894     for(;;){
2895         AVPacket pkt;
2896         ret= av_interleave_packet(s, &pkt, NULL, 1);
2897         if(ret<0) //FIXME cleanup needed for ret<0 ?
2898             goto fail;
2899         if(!ret)
2900             break;
2901
2902         ret= s->oformat->write_packet(s, &pkt);
2903
2904         av_free_packet(&pkt);
2905
2906         if(ret<0)
2907             goto fail;
2908         if(url_ferror(s->pb))
2909             goto fail;
2910     }
2911
2912     if(s->oformat->write_trailer)
2913         ret = s->oformat->write_trailer(s);
2914 fail:
2915     if(ret == 0)
2916        ret=url_ferror(s->pb);
2917     for(i=0;i<s->nb_streams;i++) {
2918         av_freep(&s->streams[i]->priv_data);
2919         av_freep(&s->streams[i]->index_entries);
2920     }
2921     av_freep(&s->priv_data);
2922     return ret;
2923 }
2924
2925 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2926 {
2927     int i, j;
2928     AVProgram *program=NULL;
2929     void *tmp;
2930
2931     if (idx >= ac->nb_streams) {
2932         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2933         return;
2934     }
2935
2936     for(i=0; i<ac->nb_programs; i++){
2937         if(ac->programs[i]->id != progid)
2938             continue;
2939         program = ac->programs[i];
2940         for(j=0; j<program->nb_stream_indexes; j++)
2941             if(program->stream_index[j] == idx)
2942                 return;
2943
2944         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2945         if(!tmp)
2946             return;
2947         program->stream_index = tmp;
2948         program->stream_index[program->nb_stream_indexes++] = idx;
2949         return;
2950     }
2951 }
2952
2953 static void print_fps(double d, const char *postfix){
2954     uint64_t v= lrintf(d*100);
2955     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2956     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2957     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2958 }
2959
2960 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2961 {
2962     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2963         AVMetadataTag *tag=NULL;
2964
2965         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2966         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2967             if(strcmp("language", tag->key))
2968                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2969         }
2970     }
2971 }
2972
2973 /* "user interface" functions */
2974 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2975 {
2976     char buf[256];
2977     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2978     AVStream *st = ic->streams[i];
2979     int g = av_gcd(st->time_base.num, st->time_base.den);
2980     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2981     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2982     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2983     /* the pid is an important information, so we display it */
2984     /* XXX: add a generic system */
2985     if (flags & AVFMT_SHOW_IDS)
2986         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2987     if (lang)
2988         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2989     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2990     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2991     if (st->sample_aspect_ratio.num && // default
2992         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2993         AVRational display_aspect_ratio;
2994         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2995                   st->codec->width*st->sample_aspect_ratio.num,
2996                   st->codec->height*st->sample_aspect_ratio.den,
2997                   1024*1024);
2998         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2999                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3000                  display_aspect_ratio.num, display_aspect_ratio.den);
3001     }
3002     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
3003         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3004             print_fps(av_q2d(st->avg_frame_rate), "fps");
3005         if(st->r_frame_rate.den && st->r_frame_rate.num)
3006             print_fps(av_q2d(st->r_frame_rate), "tbr");
3007         if(st->time_base.den && st->time_base.num)
3008             print_fps(1/av_q2d(st->time_base), "tbn");
3009         if(st->codec->time_base.den && st->codec->time_base.num)
3010             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3011     }
3012     av_log(NULL, AV_LOG_INFO, "\n");
3013     dump_metadata(NULL, st->metadata, "    ");
3014 }
3015
3016 void dump_format(AVFormatContext *ic,
3017                  int index,
3018                  const char *url,
3019                  int is_output)
3020 {
3021     int i;
3022     uint8_t *printed = av_mallocz(ic->nb_streams);
3023     if (ic->nb_streams && !printed)
3024         return;
3025
3026     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3027             is_output ? "Output" : "Input",
3028             index,
3029             is_output ? ic->oformat->name : ic->iformat->name,
3030             is_output ? "to" : "from", url);
3031     dump_metadata(NULL, ic->metadata, "  ");
3032     if (!is_output) {
3033         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3034         if (ic->duration != AV_NOPTS_VALUE) {
3035             int hours, mins, secs, us;
3036             secs = ic->duration / AV_TIME_BASE;
3037             us = ic->duration % AV_TIME_BASE;
3038             mins = secs / 60;
3039             secs %= 60;
3040             hours = mins / 60;
3041             mins %= 60;
3042             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3043                    (100 * us) / AV_TIME_BASE);
3044         } else {
3045             av_log(NULL, AV_LOG_INFO, "N/A");
3046         }
3047         if (ic->start_time != AV_NOPTS_VALUE) {
3048             int secs, us;
3049             av_log(NULL, AV_LOG_INFO, ", start: ");
3050             secs = ic->start_time / AV_TIME_BASE;
3051             us = ic->start_time % AV_TIME_BASE;
3052             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3053                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3054         }
3055         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3056         if (ic->bit_rate) {
3057             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3058         } else {
3059             av_log(NULL, AV_LOG_INFO, "N/A");
3060         }
3061         av_log(NULL, AV_LOG_INFO, "\n");
3062     }
3063     for (i = 0; i < ic->nb_chapters; i++) {
3064         AVChapter *ch = ic->chapters[i];
3065         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3066         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3067         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3068
3069         dump_metadata(NULL, ch->metadata, "    ");
3070     }
3071     if(ic->nb_programs) {
3072         int j, k, total = 0;
3073         for(j=0; j<ic->nb_programs; j++) {
3074             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3075                                                   "name", NULL, 0);
3076             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3077                    name ? name->value : "");
3078             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3079             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3080                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3081                 printed[ic->programs[j]->stream_index[k]] = 1;
3082             }
3083             total += ic->programs[j]->nb_stream_indexes;
3084         }
3085         if (total < ic->nb_streams)
3086             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3087     }
3088     for(i=0;i<ic->nb_streams;i++)
3089         if (!printed[i])
3090             dump_stream_format(ic, i, index, is_output);
3091
3092     av_free(printed);
3093 }
3094
3095 #if LIBAVFORMAT_VERSION_MAJOR < 53
3096 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3097 {
3098     return av_parse_video_frame_size(width_ptr, height_ptr, str);
3099 }
3100
3101 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3102 {
3103     AVRational frame_rate;
3104     int ret = av_parse_video_frame_rate(&frame_rate, arg);
3105     *frame_rate_num= frame_rate.num;
3106     *frame_rate_den= frame_rate.den;
3107     return ret;
3108 }
3109 #endif
3110
3111 int64_t av_gettime(void)
3112 {
3113     struct timeval tv;
3114     gettimeofday(&tv,NULL);
3115     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3116 }
3117
3118 uint64_t ff_ntp_time(void)
3119 {
3120   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3121 }
3122
3123 int64_t parse_date(const char *datestr, int duration)
3124 {
3125     const char *p;
3126     int64_t t;
3127     struct tm dt;
3128     int i;
3129     static const char * const date_fmt[] = {
3130         "%Y-%m-%d",
3131         "%Y%m%d",
3132     };
3133     static const char * const time_fmt[] = {
3134         "%H:%M:%S",
3135         "%H%M%S",
3136     };
3137     const char *q;
3138     int is_utc, len;
3139     char lastch;
3140     int negative = 0;
3141
3142 #undef time
3143     time_t now = time(0);
3144
3145     len = strlen(datestr);
3146     if (len > 0)
3147         lastch = datestr[len - 1];
3148     else
3149         lastch = '\0';
3150     is_utc = (lastch == 'z' || lastch == 'Z');
3151
3152     memset(&dt, 0, sizeof(dt));
3153
3154     p = datestr;
3155     q = NULL;
3156     if (!duration) {
3157         if (!strncasecmp(datestr, "now", len))
3158             return (int64_t) now * 1000000;
3159
3160         /* parse the year-month-day part */
3161         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3162             q = small_strptime(p, date_fmt[i], &dt);
3163             if (q) {
3164                 break;
3165             }
3166         }
3167
3168         /* if the year-month-day part is missing, then take the
3169          * current year-month-day time */
3170         if (!q) {
3171             if (is_utc) {
3172                 dt = *gmtime(&now);
3173             } else {
3174                 dt = *localtime(&now);
3175             }
3176             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3177         } else {
3178             p = q;
3179         }
3180
3181         if (*p == 'T' || *p == 't' || *p == ' ')
3182             p++;
3183
3184         /* parse the hour-minute-second part */
3185         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3186             q = small_strptime(p, time_fmt[i], &dt);
3187             if (q) {
3188                 break;
3189             }
3190         }
3191     } else {
3192         /* parse datestr as a duration */
3193         if (p[0] == '-') {
3194             negative = 1;
3195             ++p;
3196         }
3197         /* parse datestr as HH:MM:SS */
3198         q = small_strptime(p, time_fmt[0], &dt);
3199         if (!q) {
3200             /* parse datestr as S+ */
3201             dt.tm_sec = strtol(p, (char **)&q, 10);
3202             if (q == p)
3203                 /* the parsing didn't succeed */
3204                 return INT64_MIN;
3205             dt.tm_min = 0;
3206             dt.tm_hour = 0;
3207         }
3208     }
3209
3210     /* Now we have all the fields that we can get */
3211     if (!q) {
3212         return INT64_MIN;
3213     }
3214
3215     if (duration) {
3216         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3217     } else {
3218         dt.tm_isdst = -1;       /* unknown */
3219         if (is_utc) {
3220             t = mktimegm(&dt);
3221         } else {
3222             t = mktime(&dt);
3223         }
3224     }
3225
3226     t *= 1000000;
3227
3228     /* parse the .m... part */
3229     if (*q == '.') {
3230         int val, n;
3231         q++;
3232         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3233             if (!isdigit(*q))
3234                 break;
3235             val += n * (*q - '0');
3236         }
3237         t += val;
3238     }
3239     return negative ? -t : t;
3240 }
3241
3242 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3243 {
3244     const char *p;
3245     char tag[128], *q;
3246
3247     p = info;
3248     if (*p == '?')
3249         p++;
3250     for(;;) {
3251         q = tag;
3252         while (*p != '\0' && *p != '=' && *p != '&') {
3253             if ((q - tag) < sizeof(tag) - 1)
3254                 *q++ = *p;
3255             p++;
3256         }
3257         *q = '\0';
3258         q = arg;
3259         if (*p == '=') {
3260             p++;
3261             while (*p != '&' && *p != '\0') {
3262                 if ((q - arg) < arg_size - 1) {
3263                     if (*p == '+')
3264                         *q++ = ' ';
3265                     else
3266                         *q++ = *p;
3267                 }
3268                 p++;
3269             }
3270             *q = '\0';
3271         }
3272         if (!strcmp(tag, tag1))
3273             return 1;
3274         if (*p != '&')
3275             break;
3276         p++;
3277     }
3278     return 0;
3279 }
3280
3281 int av_get_frame_filename(char *buf, int buf_size,
3282                           const char *path, int number)
3283 {
3284     const char *p;
3285     char *q, buf1[20], c;
3286     int nd, len, percentd_found;
3287
3288     q = buf;
3289     p = path;
3290     percentd_found = 0;
3291     for(;;) {
3292         c = *p++;
3293         if (c == '\0')
3294             break;
3295         if (c == '%') {
3296             do {
3297                 nd = 0;
3298                 while (isdigit(*p)) {
3299                     nd = nd * 10 + *p++ - '0';
3300                 }
3301                 c = *p++;
3302             } while (isdigit(c));
3303
3304             switch(c) {
3305             case '%':
3306                 goto addchar;
3307             case 'd':
3308                 if (percentd_found)
3309                     goto fail;
3310                 percentd_found = 1;
3311                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3312                 len = strlen(buf1);
3313                 if ((q - buf + len) > buf_size - 1)
3314                     goto fail;
3315                 memcpy(q, buf1, len);
3316                 q += len;
3317                 break;
3318             default:
3319                 goto fail;
3320             }
3321         } else {
3322         addchar:
3323             if ((q - buf) < buf_size - 1)
3324                 *q++ = c;
3325         }
3326     }
3327     if (!percentd_found)
3328         goto fail;
3329     *q = '\0';
3330     return 0;
3331  fail:
3332     *q = '\0';
3333     return -1;
3334 }
3335
3336 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3337 {
3338     int len, i, j, c;
3339 #undef fprintf
3340 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3341
3342     for(i=0;i<size;i+=16) {
3343         len = size - i;
3344         if (len > 16)
3345             len = 16;
3346         PRINT("%08x ", i);
3347         for(j=0;j<16;j++) {
3348             if (j < len)
3349                 PRINT(" %02x", buf[i+j]);
3350             else
3351                 PRINT("   ");
3352         }
3353         PRINT(" ");
3354         for(j=0;j<len;j++) {
3355             c = buf[i+j];
3356             if (c < ' ' || c > '~')
3357                 c = '.';
3358             PRINT("%c", c);
3359         }
3360         PRINT("\n");
3361     }
3362 #undef PRINT
3363 }
3364
3365 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3366 {
3367     hex_dump_internal(NULL, f, 0, buf, size);
3368 }
3369
3370 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3371 {
3372     hex_dump_internal(avcl, NULL, level, buf, size);
3373 }
3374
3375  //FIXME needs to know the time_base
3376 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3377 {
3378 #undef fprintf
3379 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3380     PRINT("stream #%d:\n", pkt->stream_index);
3381     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3382     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3383     /* DTS is _always_ valid after av_read_frame() */
3384     PRINT("  dts=");
3385     if (pkt->dts == AV_NOPTS_VALUE)
3386         PRINT("N/A");
3387     else
3388         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3389     /* PTS may not be known if B-frames are present. */
3390     PRINT("  pts=");
3391     if (pkt->pts == AV_NOPTS_VALUE)
3392         PRINT("N/A");
3393     else
3394         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3395     PRINT("\n");
3396     PRINT("  size=%d\n", pkt->size);
3397 #undef PRINT
3398     if (dump_payload)
3399         av_hex_dump(f, pkt->data, pkt->size);
3400 }
3401
3402 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3403 {
3404     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3405 }
3406
3407 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3408 {
3409     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3410 }
3411
3412 void ff_url_split(char *proto, int proto_size,
3413                   char *authorization, int authorization_size,
3414                   char *hostname, int hostname_size,
3415                   int *port_ptr,
3416                   char *path, int path_size,
3417                   const char *url)
3418 {
3419     const char *p, *ls, *at, *col, *brk;
3420
3421     if (port_ptr)               *port_ptr = -1;
3422     if (proto_size > 0)         proto[0] = 0;
3423     if (authorization_size > 0) authorization[0] = 0;
3424     if (hostname_size > 0)      hostname[0] = 0;
3425     if (path_size > 0)          path[0] = 0;
3426
3427     /* parse protocol */
3428     if ((p = strchr(url, ':'))) {
3429         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3430         p++; /* skip ':' */
3431         if (*p == '/') p++;
3432         if (*p == '/') p++;
3433     } else {
3434         /* no protocol means plain filename */
3435         av_strlcpy(path, url, path_size);
3436         return;
3437     }
3438
3439     /* separate path from hostname */
3440     ls = strchr(p, '/');
3441     if(!ls)
3442         ls = strchr(p, '?');
3443     if(ls)
3444         av_strlcpy(path, ls, path_size);
3445     else
3446         ls = &p[strlen(p)]; // XXX
3447
3448     /* the rest is hostname, use that to parse auth/port */
3449     if (ls != p) {
3450         /* authorization (user[:pass]@hostname) */
3451         if ((at = strchr(p, '@')) && at < ls) {
3452             av_strlcpy(authorization, p,
3453                        FFMIN(authorization_size, at + 1 - p));
3454             p = at + 1; /* skip '@' */
3455         }
3456
3457         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3458             /* [host]:port */
3459             av_strlcpy(hostname, p + 1,
3460                        FFMIN(hostname_size, brk - p));
3461             if (brk[1] == ':' && port_ptr)
3462                 *port_ptr = atoi(brk + 2);
3463         } else if ((col = strchr(p, ':')) && col < ls) {
3464             av_strlcpy(hostname, p,
3465                        FFMIN(col + 1 - p, hostname_size));
3466             if (port_ptr) *port_ptr = atoi(col + 1);
3467         } else
3468             av_strlcpy(hostname, p,
3469                        FFMIN(ls + 1 - p, hostname_size));
3470     }
3471 }
3472
3473 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3474 {
3475     int i;
3476     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3477                                            '4', '5', '6', '7',
3478                                            '8', '9', 'A', 'B',
3479                                            'C', 'D', 'E', 'F' };
3480     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3481                                            '4', '5', '6', '7',
3482                                            '8', '9', 'a', 'b',
3483                                            'c', 'd', 'e', 'f' };
3484     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3485
3486     for(i = 0; i < s; i++) {
3487         buff[i * 2]     = hex_table[src[i] >> 4];
3488         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3489     }
3490
3491     return buff;
3492 }
3493
3494 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3495                      unsigned int pts_num, unsigned int pts_den)
3496 {
3497     s->pts_wrap_bits = pts_wrap_bits;
3498
3499     if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3500         if(s->time_base.num != pts_num)
3501             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3502     }else
3503         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3504
3505     if(!s->time_base.num || !s->time_base.den)
3506         s->time_base.num= s->time_base.den= 0;
3507 }
3508
3509 int ff_url_join(char *str, int size, const char *proto,
3510                 const char *authorization, const char *hostname,
3511                 int port, const char *fmt, ...)
3512 {
3513 #if CONFIG_NETWORK
3514     struct addrinfo hints, *ai;
3515 #endif
3516
3517     str[0] = '\0';
3518     if (proto)
3519         av_strlcatf(str, size, "%s://", proto);
3520     if (authorization)
3521         av_strlcatf(str, size, "%s@", authorization);
3522 #if CONFIG_NETWORK && defined(AF_INET6)
3523     /* Determine if hostname is a numerical IPv6 address,
3524      * properly escape it within [] in that case. */
3525     memset(&hints, 0, sizeof(hints));
3526     hints.ai_flags = AI_NUMERICHOST;
3527     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3528         if (ai->ai_family == AF_INET6) {
3529             av_strlcat(str, "[", size);
3530             av_strlcat(str, hostname, size);
3531             av_strlcat(str, "]", size);
3532         } else {
3533             av_strlcat(str, hostname, size);
3534         }
3535         freeaddrinfo(ai);
3536     } else
3537 #endif
3538         /* Not an IPv6 address, just output the plain string. */
3539         av_strlcat(str, hostname, size);
3540
3541     if (port >= 0)
3542         av_strlcatf(str, size, ":%d", port);
3543     if (fmt) {
3544         va_list vl;
3545         int len = strlen(str);
3546
3547         va_start(vl, fmt);
3548         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3549         va_end(vl);
3550     }
3551     return strlen(str);
3552 }