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