git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

   1 /*
   2  * various utility functions for use within FFmpeg
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21 #include "avformat.h"
  22 #include "internal.h"
  23 #include "libavcodec/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                     char tagbuf[32];
2660                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2661                     av_log(s, AV_LOG_ERROR,
2662                            "Tag %s/0x%08x incompatible with output codec '%s'\n",
2663                            tagbuf, st->codec->codec_tag, st->codec->codec->name);
2664                     return AVERROR_INVALIDDATA;
2665                 }
2666             }else
2667                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2668         }
2669
2670         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2671             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2672           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2673     }
2674
2675     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2676         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2677         if (!s->priv_data)
2678             return AVERROR(ENOMEM);
2679     }
2680
2681 #if LIBAVFORMAT_VERSION_MAJOR < 53
2682     ff_metadata_mux_compat(s);
2683 #endif
2684
2685     /* set muxer identification string */
2686     if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2687         AVMetadata *m;
2688         AVMetadataTag *t;
2689
2690         if (!(m = av_mallocz(sizeof(AVMetadata))))
2691             return AVERROR(ENOMEM);
2692         av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2693         metadata_conv(&m, s->oformat->metadata_conv, NULL);
2694         if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2695             av_metadata_set2(&s->metadata, t->key, t->value, 0);
2696         av_metadata_free(&m);
2697     }
2698
2699     if(s->oformat->write_header){
2700         ret = s->oformat->write_header(s);
2701         if (ret < 0)
2702             return ret;
2703     }
2704
2705     /* init PTS generation */
2706     for(i=0;i<s->nb_streams;i++) {
2707         int64_t den = AV_NOPTS_VALUE;
2708         st = s->streams[i];
2709
2710         switch (st->codec->codec_type) {
2711         case AVMEDIA_TYPE_AUDIO:
2712             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2713             break;
2714         case AVMEDIA_TYPE_VIDEO:
2715             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2716             break;
2717         default:
2718             break;
2719         }
2720         if (den != AV_NOPTS_VALUE) {
2721             if (den <= 0)
2722                 return AVERROR_INVALIDDATA;
2723             av_frac_init(&st->pts, 0, 0, den);
2724         }
2725     }
2726     return 0;
2727 }
2728
2729 //FIXME merge with compute_pkt_fields
2730 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2731     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2732     int num, den, frame_size, i;
2733
2734 //    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);
2735
2736 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2737         return -1;*/
2738
2739     /* duration field */
2740     if (pkt->duration == 0) {
2741         compute_frame_duration(&num, &den, st, NULL, pkt);
2742         if (den && num) {
2743             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2744         }
2745     }
2746
2747     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2748         pkt->pts= pkt->dts;
2749
2750     //XXX/FIXME this is a temporary hack until all encoders output pts
2751     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2752         pkt->dts=
2753 //        pkt->pts= st->cur_dts;
2754         pkt->pts= st->pts.val;
2755     }
2756
2757     //calculate dts from pts
2758     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2759         st->pts_buffer[0]= pkt->pts;
2760         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2761             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2762         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2763             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2764
2765         pkt->dts= st->pts_buffer[0];
2766     }
2767
2768     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2769         av_log(s, AV_LOG_ERROR,
2770                "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2771                st->index, st->cur_dts, pkt->dts);
2772         return -1;
2773     }
2774     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2775         av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2776         return -1;
2777     }
2778
2779 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2780     st->cur_dts= pkt->dts;
2781     st->pts.val= pkt->dts;
2782
2783     /* update pts */
2784     switch (st->codec->codec_type) {
2785     case AVMEDIA_TYPE_AUDIO:
2786         frame_size = get_audio_frame_size(st->codec, pkt->size);
2787
2788         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2789            likely equal to the encoder delay, but it would be better if we
2790            had the real timestamps from the encoder */
2791         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2792             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2793         }
2794         break;
2795     case AVMEDIA_TYPE_VIDEO:
2796         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2797         break;
2798     default:
2799         break;
2800     }
2801     return 0;
2802 }
2803
2804 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2805 {
2806     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2807
2808     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2809         return ret;
2810
2811     ret= s->oformat->write_packet(s, pkt);
2812     if(!ret)
2813         ret= url_ferror(s->pb);
2814     return ret;
2815 }
2816
2817 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2818                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2819 {
2820     AVPacketList **next_point, *this_pktl;
2821
2822     this_pktl = av_mallocz(sizeof(AVPacketList));
2823     this_pktl->pkt= *pkt;
2824     pkt->destruct= NULL;             // do not free original but only the copy
2825     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2826
2827     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2828         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2829     }else
2830         next_point = &s->packet_buffer;
2831
2832     if(*next_point){
2833         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2834             while(!compare(s, &(*next_point)->pkt, pkt)){
2835                 next_point= &(*next_point)->next;
2836             }
2837             goto next_non_null;
2838         }else{
2839             next_point = &(s->packet_buffer_end->next);
2840         }
2841     }
2842     assert(!*next_point);
2843
2844     s->packet_buffer_end= this_pktl;
2845 next_non_null:
2846
2847     this_pktl->next= *next_point;
2848
2849     s->streams[pkt->stream_index]->last_in_packet_buffer=
2850     *next_point= this_pktl;
2851 }
2852
2853 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2854 {
2855     AVStream *st = s->streams[ pkt ->stream_index];
2856     AVStream *st2= s->streams[ next->stream_index];
2857     int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2858     int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2859     return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2860 }
2861
2862 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2863     AVPacketList *pktl;
2864     int stream_count=0;
2865     int i;
2866
2867     if(pkt){
2868         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2869     }
2870
2871     for(i=0; i < s->nb_streams; i++)
2872         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2873
2874     if(stream_count && (s->nb_streams == stream_count || flush)){
2875         pktl= s->packet_buffer;
2876         *out= pktl->pkt;
2877
2878         s->packet_buffer= pktl->next;
2879         if(!s->packet_buffer)
2880             s->packet_buffer_end= NULL;
2881
2882         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2883             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2884         av_freep(&pktl);
2885         return 1;
2886     }else{
2887         av_init_packet(out);
2888         return 0;
2889     }
2890 }
2891
2892 /**
2893  * Interleaves an AVPacket correctly so it can be muxed.
2894  * @param out the interleaved packet will be output here
2895  * @param in the input packet
2896  * @param flush 1 if no further packets are available as input and all
2897  *              remaining packets should be output
2898  * @return 1 if a packet was output, 0 if no packet could be output,
2899  *         < 0 if an error occurred
2900  */
2901 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2902     if(s->oformat->interleave_packet)
2903         return s->oformat->interleave_packet(s, out, in, flush);
2904     else
2905         return av_interleave_packet_per_dts(s, out, in, flush);
2906 }
2907
2908 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2909     AVStream *st= s->streams[ pkt->stream_index];
2910
2911     //FIXME/XXX/HACK drop zero sized packets
2912     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2913         return 0;
2914
2915 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2916     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2917         return -1;
2918
2919     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2920         return -1;
2921
2922     for(;;){
2923         AVPacket opkt;
2924         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2925         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2926             return ret;
2927
2928         ret= s->oformat->write_packet(s, &opkt);
2929
2930         av_free_packet(&opkt);
2931         pkt= NULL;
2932
2933         if(ret<0)
2934             return ret;
2935         if(url_ferror(s->pb))
2936             return url_ferror(s->pb);
2937     }
2938 }
2939
2940 int av_write_trailer(AVFormatContext *s)
2941 {
2942     int ret, i;
2943
2944     for(;;){
2945         AVPacket pkt;
2946         ret= av_interleave_packet(s, &pkt, NULL, 1);
2947         if(ret<0) //FIXME cleanup needed for ret<0 ?
2948             goto fail;
2949         if(!ret)
2950             break;
2951
2952         ret= s->oformat->write_packet(s, &pkt);
2953
2954         av_free_packet(&pkt);
2955
2956         if(ret<0)
2957             goto fail;
2958         if(url_ferror(s->pb))
2959             goto fail;
2960     }
2961
2962     if(s->oformat->write_trailer)
2963         ret = s->oformat->write_trailer(s);
2964 fail:
2965     if(ret == 0)
2966        ret=url_ferror(s->pb);
2967     for(i=0;i<s->nb_streams;i++) {
2968         av_freep(&s->streams[i]->priv_data);
2969         av_freep(&s->streams[i]->index_entries);
2970     }
2971     av_freep(&s->priv_data);
2972     return ret;
2973 }
2974
2975 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2976 {
2977     int i, j;
2978     AVProgram *program=NULL;
2979     void *tmp;
2980
2981     if (idx >= ac->nb_streams) {
2982         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2983         return;
2984     }
2985
2986     for(i=0; i<ac->nb_programs; i++){
2987         if(ac->programs[i]->id != progid)
2988             continue;
2989         program = ac->programs[i];
2990         for(j=0; j<program->nb_stream_indexes; j++)
2991             if(program->stream_index[j] == idx)
2992                 return;
2993
2994         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2995         if(!tmp)
2996             return;
2997         program->stream_index = tmp;
2998         program->stream_index[program->nb_stream_indexes++] = idx;
2999         return;
3000     }
3001 }
3002
3003 static void print_fps(double d, const char *postfix){
3004     uint64_t v= lrintf(d*100);
3005     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3006     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3007     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3008 }
3009
3010 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3011 {
3012     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3013         AVMetadataTag *tag=NULL;
3014
3015         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3016         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3017             if(strcmp("language", tag->key))
3018                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3019         }
3020     }
3021 }
3022
3023 /* "user interface" functions */
3024 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3025 {
3026     char buf[256];
3027     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3028     AVStream *st = ic->streams[i];
3029     int g = av_gcd(st->time_base.num, st->time_base.den);
3030     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3031     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3032     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3033     /* the pid is an important information, so we display it */
3034     /* XXX: add a generic system */
3035     if (flags & AVFMT_SHOW_IDS)
3036         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3037     if (lang)
3038         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3039     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3040     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3041     if (st->sample_aspect_ratio.num && // default
3042         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3043         AVRational display_aspect_ratio;
3044         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3045                   st->codec->width*st->sample_aspect_ratio.num,
3046                   st->codec->height*st->sample_aspect_ratio.den,
3047                   1024*1024);
3048         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3049                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3050                  display_aspect_ratio.num, display_aspect_ratio.den);
3051     }
3052     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3053         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3054             print_fps(av_q2d(st->avg_frame_rate), "fps");
3055         if(st->r_frame_rate.den && st->r_frame_rate.num)
3056             print_fps(av_q2d(st->r_frame_rate), "tbr");
3057         if(st->time_base.den && st->time_base.num)
3058             print_fps(1/av_q2d(st->time_base), "tbn");
3059         if(st->codec->time_base.den && st->codec->time_base.num)
3060             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3061     }
3062     av_log(NULL, AV_LOG_INFO, "\n");
3063     dump_metadata(NULL, st->metadata, "    ");
3064 }
3065
3066 void dump_format(AVFormatContext *ic,
3067                  int index,
3068                  const char *url,
3069                  int is_output)
3070 {
3071     int i;
3072     uint8_t *printed = av_mallocz(ic->nb_streams);
3073     if (ic->nb_streams && !printed)
3074         return;
3075
3076     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3077             is_output ? "Output" : "Input",
3078             index,
3079             is_output ? ic->oformat->name : ic->iformat->name,
3080             is_output ? "to" : "from", url);
3081     dump_metadata(NULL, ic->metadata, "  ");
3082     if (!is_output) {
3083         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3084         if (ic->duration != AV_NOPTS_VALUE) {
3085             int hours, mins, secs, us;
3086             secs = ic->duration / AV_TIME_BASE;
3087             us = ic->duration % AV_TIME_BASE;
3088             mins = secs / 60;
3089             secs %= 60;
3090             hours = mins / 60;
3091             mins %= 60;
3092             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3093                    (100 * us) / AV_TIME_BASE);
3094         } else {
3095             av_log(NULL, AV_LOG_INFO, "N/A");
3096         }
3097         if (ic->start_time != AV_NOPTS_VALUE) {
3098             int secs, us;
3099             av_log(NULL, AV_LOG_INFO, ", start: ");
3100             secs = ic->start_time / AV_TIME_BASE;
3101             us = ic->start_time % AV_TIME_BASE;
3102             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3103                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3104         }
3105         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3106         if (ic->bit_rate) {
3107             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3108         } else {
3109             av_log(NULL, AV_LOG_INFO, "N/A");
3110         }
3111         av_log(NULL, AV_LOG_INFO, "\n");
3112     }
3113     for (i = 0; i < ic->nb_chapters; i++) {
3114         AVChapter *ch = ic->chapters[i];
3115         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3116         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3117         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3118
3119         dump_metadata(NULL, ch->metadata, "    ");
3120     }
3121     if(ic->nb_programs) {
3122         int j, k, total = 0;
3123         for(j=0; j<ic->nb_programs; j++) {
3124             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3125                                                   "name", NULL, 0);
3126             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3127                    name ? name->value : "");
3128             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3129             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3130                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3131                 printed[ic->programs[j]->stream_index[k]] = 1;
3132             }
3133             total += ic->programs[j]->nb_stream_indexes;
3134         }
3135         if (total < ic->nb_streams)
3136             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3137     }
3138     for(i=0;i<ic->nb_streams;i++)
3139         if (!printed[i])
3140             dump_stream_format(ic, i, index, is_output);
3141
3142     av_free(printed);
3143 }
3144
3145 #if LIBAVFORMAT_VERSION_MAJOR < 53
3146 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3147 {
3148     return av_parse_video_frame_size(width_ptr, height_ptr, str);
3149 }
3150
3151 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3152 {
3153     AVRational frame_rate;
3154     int ret = av_parse_video_frame_rate(&frame_rate, arg);
3155     *frame_rate_num= frame_rate.num;
3156     *frame_rate_den= frame_rate.den;
3157     return ret;
3158 }
3159 #endif
3160
3161 int64_t av_gettime(void)
3162 {
3163     struct timeval tv;
3164     gettimeofday(&tv,NULL);
3165     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3166 }
3167
3168 uint64_t ff_ntp_time(void)
3169 {
3170   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3171 }
3172
3173 int64_t parse_date(const char *datestr, int duration)
3174 {
3175     const char *p;
3176     int64_t t;
3177     struct tm dt;
3178     int i;
3179     static const char * const date_fmt[] = {
3180         "%Y-%m-%d",
3181         "%Y%m%d",
3182     };
3183     static const char * const time_fmt[] = {
3184         "%H:%M:%S",
3185         "%H%M%S",
3186     };
3187     const char *q;
3188     int is_utc, len;
3189     char lastch;
3190     int negative = 0;
3191
3192 #undef time
3193     time_t now = time(0);
3194
3195     len = strlen(datestr);
3196     if (len > 0)
3197         lastch = datestr[len - 1];
3198     else
3199         lastch = '\0';
3200     is_utc = (lastch == 'z' || lastch == 'Z');
3201
3202     memset(&dt, 0, sizeof(dt));
3203
3204     p = datestr;
3205     q = NULL;
3206     if (!duration) {
3207         if (!strncasecmp(datestr, "now", len))
3208             return (int64_t) now * 1000000;
3209
3210         /* parse the year-month-day part */
3211         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3212             q = small_strptime(p, date_fmt[i], &dt);
3213             if (q) {
3214                 break;
3215             }
3216         }
3217
3218         /* if the year-month-day part is missing, then take the
3219          * current year-month-day time */
3220         if (!q) {
3221             if (is_utc) {
3222                 dt = *gmtime(&now);
3223             } else {
3224                 dt = *localtime(&now);
3225             }
3226             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3227         } else {
3228             p = q;
3229         }
3230
3231         if (*p == 'T' || *p == 't' || *p == ' ')
3232             p++;
3233
3234         /* parse the hour-minute-second part */
3235         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3236             q = small_strptime(p, time_fmt[i], &dt);
3237             if (q) {
3238                 break;
3239             }
3240         }
3241     } else {
3242         /* parse datestr as a duration */
3243         if (p[0] == '-') {
3244             negative = 1;
3245             ++p;
3246         }
3247         /* parse datestr as HH:MM:SS */
3248         q = small_strptime(p, time_fmt[0], &dt);
3249         if (!q) {
3250             /* parse datestr as S+ */
3251             dt.tm_sec = strtol(p, (char **)&q, 10);
3252             if (q == p)
3253                 /* the parsing didn't succeed */
3254                 return INT64_MIN;
3255             dt.tm_min = 0;
3256             dt.tm_hour = 0;
3257         }
3258     }
3259
3260     /* Now we have all the fields that we can get */
3261     if (!q) {
3262         return INT64_MIN;
3263     }
3264
3265     if (duration) {
3266         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3267     } else {
3268         dt.tm_isdst = -1;       /* unknown */
3269         if (is_utc) {
3270             t = mktimegm(&dt);
3271         } else {
3272             t = mktime(&dt);
3273         }
3274     }
3275
3276     t *= 1000000;
3277
3278     /* parse the .m... part */
3279     if (*q == '.') {
3280         int val, n;
3281         q++;
3282         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3283             if (!isdigit(*q))
3284                 break;
3285             val += n * (*q - '0');
3286         }
3287         t += val;
3288     }
3289     return negative ? -t : t;
3290 }
3291
3292 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3293 {
3294     const char *p;
3295     char tag[128], *q;
3296
3297     p = info;
3298     if (*p == '?')
3299         p++;
3300     for(;;) {
3301         q = tag;
3302         while (*p != '\0' && *p != '=' && *p != '&') {
3303             if ((q - tag) < sizeof(tag) - 1)
3304                 *q++ = *p;
3305             p++;
3306         }
3307         *q = '\0';
3308         q = arg;
3309         if (*p == '=') {
3310             p++;
3311             while (*p != '&' && *p != '\0') {
3312                 if ((q - arg) < arg_size - 1) {
3313                     if (*p == '+')
3314                         *q++ = ' ';
3315                     else
3316                         *q++ = *p;
3317                 }
3318                 p++;
3319             }
3320             *q = '\0';
3321         }
3322         if (!strcmp(tag, tag1))
3323             return 1;
3324         if (*p != '&')
3325             break;
3326         p++;
3327     }
3328     return 0;
3329 }
3330
3331 int av_get_frame_filename(char *buf, int buf_size,
3332                           const char *path, int number)
3333 {
3334     const char *p;
3335     char *q, buf1[20], c;
3336     int nd, len, percentd_found;
3337
3338     q = buf;
3339     p = path;
3340     percentd_found = 0;
3341     for(;;) {
3342         c = *p++;
3343         if (c == '\0')
3344             break;
3345         if (c == '%') {
3346             do {
3347                 nd = 0;
3348                 while (isdigit(*p)) {
3349                     nd = nd * 10 + *p++ - '0';
3350                 }
3351                 c = *p++;
3352             } while (isdigit(c));
3353
3354             switch(c) {
3355             case '%':
3356                 goto addchar;
3357             case 'd':
3358                 if (percentd_found)
3359                     goto fail;
3360                 percentd_found = 1;
3361                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3362                 len = strlen(buf1);
3363                 if ((q - buf + len) > buf_size - 1)
3364                     goto fail;
3365                 memcpy(q, buf1, len);
3366                 q += len;
3367                 break;
3368             default:
3369                 goto fail;
3370             }
3371         } else {
3372         addchar:
3373             if ((q - buf) < buf_size - 1)
3374                 *q++ = c;
3375         }
3376     }
3377     if (!percentd_found)
3378         goto fail;
3379     *q = '\0';
3380     return 0;
3381  fail:
3382     *q = '\0';
3383     return -1;
3384 }
3385
3386 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3387 {
3388     int len, i, j, c;
3389 #undef fprintf
3390 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3391
3392     for(i=0;i<size;i+=16) {
3393         len = size - i;
3394         if (len > 16)
3395             len = 16;
3396         PRINT("%08x ", i);
3397         for(j=0;j<16;j++) {
3398             if (j < len)
3399                 PRINT(" %02x", buf[i+j]);
3400             else
3401                 PRINT("   ");
3402         }
3403         PRINT(" ");
3404         for(j=0;j<len;j++) {
3405             c = buf[i+j];
3406             if (c < ' ' || c > '~')
3407                 c = '.';
3408             PRINT("%c", c);
3409         }
3410         PRINT("\n");
3411     }
3412 #undef PRINT
3413 }
3414
3415 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3416 {
3417     hex_dump_internal(NULL, f, 0, buf, size);
3418 }
3419
3420 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3421 {
3422     hex_dump_internal(avcl, NULL, level, buf, size);
3423 }
3424
3425  //FIXME needs to know the time_base
3426 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3427 {
3428 #undef fprintf
3429 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3430     PRINT("stream #%d:\n", pkt->stream_index);
3431     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3432     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3433     /* DTS is _always_ valid after av_read_frame() */
3434     PRINT("  dts=");
3435     if (pkt->dts == AV_NOPTS_VALUE)
3436         PRINT("N/A");
3437     else
3438         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3439     /* PTS may not be known if B-frames are present. */
3440     PRINT("  pts=");
3441     if (pkt->pts == AV_NOPTS_VALUE)
3442         PRINT("N/A");
3443     else
3444         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3445     PRINT("\n");
3446     PRINT("  size=%d\n", pkt->size);
3447 #undef PRINT
3448     if (dump_payload)
3449         av_hex_dump(f, pkt->data, pkt->size);
3450 }
3451
3452 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3453 {
3454     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3455 }
3456
3457 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3458 {
3459     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3460 }
3461
3462 void ff_url_split(char *proto, int proto_size,
3463                   char *authorization, int authorization_size,
3464                   char *hostname, int hostname_size,
3465                   int *port_ptr,
3466                   char *path, int path_size,
3467                   const char *url)
3468 {
3469     const char *p, *ls, *at, *col, *brk;
3470
3471     if (port_ptr)               *port_ptr = -1;
3472     if (proto_size > 0)         proto[0] = 0;
3473     if (authorization_size > 0) authorization[0] = 0;
3474     if (hostname_size > 0)      hostname[0] = 0;
3475     if (path_size > 0)          path[0] = 0;
3476
3477     /* parse protocol */
3478     if ((p = strchr(url, ':'))) {
3479         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3480         p++; /* skip ':' */
3481         if (*p == '/') p++;
3482         if (*p == '/') p++;
3483     } else {
3484         /* no protocol means plain filename */
3485         av_strlcpy(path, url, path_size);
3486         return;
3487     }
3488
3489     /* separate path from hostname */
3490     ls = strchr(p, '/');
3491     if(!ls)
3492         ls = strchr(p, '?');
3493     if(ls)
3494         av_strlcpy(path, ls, path_size);
3495     else
3496         ls = &p[strlen(p)]; // XXX
3497
3498     /* the rest is hostname, use that to parse auth/port */
3499     if (ls != p) {
3500         /* authorization (user[:pass]@hostname) */
3501         if ((at = strchr(p, '@')) && at < ls) {
3502             av_strlcpy(authorization, p,
3503                        FFMIN(authorization_size, at + 1 - p));
3504             p = at + 1; /* skip '@' */
3505         }
3506
3507         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3508             /* [host]:port */
3509             av_strlcpy(hostname, p + 1,
3510                        FFMIN(hostname_size, brk - p));
3511             if (brk[1] == ':' && port_ptr)
3512                 *port_ptr = atoi(brk + 2);
3513         } else if ((col = strchr(p, ':')) && col < ls) {
3514             av_strlcpy(hostname, p,
3515                        FFMIN(col + 1 - p, hostname_size));
3516             if (port_ptr) *port_ptr = atoi(col + 1);
3517         } else
3518             av_strlcpy(hostname, p,
3519                        FFMIN(ls + 1 - p, hostname_size));
3520     }
3521 }
3522
3523 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3524 {
3525     int i;
3526     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3527                                            '4', '5', '6', '7',
3528                                            '8', '9', 'A', 'B',
3529                                            'C', 'D', 'E', 'F' };
3530     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3531                                            '4', '5', '6', '7',
3532                                            '8', '9', 'a', 'b',
3533                                            'c', 'd', 'e', 'f' };
3534     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3535
3536     for(i = 0; i < s; i++) {
3537         buff[i * 2]     = hex_table[src[i] >> 4];
3538         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3539     }
3540
3541     return buff;
3542 }
3543
3544 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3545                      unsigned int pts_num, unsigned int pts_den)
3546 {
3547     s->pts_wrap_bits = pts_wrap_bits;
3548
3549     if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3550         if(s->time_base.num != pts_num)
3551             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3552     }else
3553         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3554
3555     if(!s->time_base.num || !s->time_base.den)
3556         s->time_base.num= s->time_base.den= 0;
3557 }
3558
3559 int ff_url_join(char *str, int size, const char *proto,
3560                 const char *authorization, const char *hostname,
3561                 int port, const char *fmt, ...)
3562 {
3563 #if CONFIG_NETWORK
3564     struct addrinfo hints, *ai;
3565 #endif
3566
3567     str[0] = '\0';
3568     if (proto)
3569         av_strlcatf(str, size, "%s://", proto);
3570     if (authorization)
3571         av_strlcatf(str, size, "%s@", authorization);
3572 #if CONFIG_NETWORK && defined(AF_INET6)
3573     /* Determine if hostname is a numerical IPv6 address,
3574      * properly escape it within [] in that case. */
3575     memset(&hints, 0, sizeof(hints));
3576     hints.ai_flags = AI_NUMERICHOST;
3577     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3578         if (ai->ai_family == AF_INET6) {
3579             av_strlcat(str, "[", size);
3580             av_strlcat(str, hostname, size);
3581             av_strlcat(str, "]", size);
3582         } else {
3583             av_strlcat(str, hostname, size);
3584         }
3585         freeaddrinfo(ai);
3586     } else
3587 #endif
3588         /* Not an IPv6 address, just output the plain string. */
3589         av_strlcat(str, hostname, size);
3590
3591     if (port >= 0)
3592         av_strlcatf(str, size, ":%d", port);
3593     if (fmt) {
3594         va_list vl;
3595         int len = strlen(str);
3596
3597         va_start(vl, fmt);
3598         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3599         va_end(vl);
3600     }
3601     return strlen(str);
3602 }
3603
3604 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3605                      AVFormatContext *src)
3606 {
3607     AVPacket local_pkt;
3608
3609     local_pkt = *pkt;
3610     local_pkt.stream_index = dst_stream;
3611     if (pkt->pts != AV_NOPTS_VALUE)
3612         local_pkt.pts = av_rescale_q(pkt->pts,
3613                                      src->streams[pkt->stream_index]->time_base,
3614                                      dst->streams[dst_stream]->time_base);
3615     if (pkt->dts != AV_NOPTS_VALUE)
3616         local_pkt.dts = av_rescale_q(pkt->dts,
3617                                      src->streams[pkt->stream_index]->time_base,
3618                                      dst->streams[dst_stream]->time_base);
3619     return av_write_frame(dst, &local_pkt);
3620 }
3621