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