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

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