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