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