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

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