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