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