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

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