libavformat/utils.c

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