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         break;
1733     case CODEC_TYPE_VIDEO:
1734         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1735         break;
1736     default:
1737         val = 1;
1738         break;
1739     }
1740     return enc->codec_id != CODEC_ID_NONE && val != 0;
1741 }
1742
1743 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1744 {
1745     int16_t *samples;
1746     AVCodec *codec;
1747     int got_picture, data_size, ret=0;
1748     AVFrame picture;
1749
1750   if(!st->codec->codec){
1751     codec = avcodec_find_decoder(st->codec->codec_id);
1752     if (!codec)
1753         return -1;
1754     ret = avcodec_open(st->codec, codec);
1755     if (ret < 0)
1756         return ret;
1757   }
1758
1759   if(!has_codec_parameters(st->codec)){
1760     switch(st->codec->codec_type) {
1761     case CODEC_TYPE_VIDEO:
1762         ret = avcodec_decode_video(st->codec, &picture,
1763                                    &got_picture, data, size);
1764         break;
1765     case CODEC_TYPE_AUDIO:
1766         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1767         samples = av_malloc(data_size);
1768         if (!samples)
1769             goto fail;
1770         ret = avcodec_decode_audio2(st->codec, samples,
1771                                     &data_size, data, size);
1772         av_free(samples);
1773         break;
1774     default:
1775         break;
1776     }
1777   }
1778  fail:
1779     return ret;
1780 }
1781
1782 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1783 {
1784     AVInputFormat *fmt;
1785     fmt = av_probe_input_format2(pd, 1, &score);
1786
1787     if (fmt) {
1788         if (strncmp(fmt->name, "mp3", 3) == 0)
1789             st->codec->codec_id = CODEC_ID_MP3;
1790         else if (strncmp(fmt->name, "ac3", 3) == 0)
1791             st->codec->codec_id = CODEC_ID_AC3;
1792     }
1793     return !!fmt;
1794 }
1795
1796 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1797 {
1798     while (tags->id != CODEC_ID_NONE) {
1799         if (tags->id == id)
1800             return tags->tag;
1801         tags++;
1802     }
1803     return 0;
1804 }
1805
1806 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1807 {
1808     int i;
1809     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1810         if(tag == tags[i].tag)
1811             return tags[i].id;
1812     }
1813     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1814         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1815            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1816            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1817            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1818             return tags[i].id;
1819     }
1820     return CODEC_ID_NONE;
1821 }
1822
1823 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1824 {
1825     int i;
1826     for(i=0; tags && tags[i]; i++){
1827         int tag= codec_get_tag(tags[i], id);
1828         if(tag) return tag;
1829     }
1830     return 0;
1831 }
1832
1833 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1834 {
1835     int i;
1836     for(i=0; tags && tags[i]; i++){
1837         enum CodecID id= codec_get_id(tags[i], tag);
1838         if(id!=CODEC_ID_NONE) return id;
1839     }
1840     return CODEC_ID_NONE;
1841 }
1842
1843 static void compute_chapters_end(AVFormatContext *s)
1844 {
1845     unsigned int i;
1846
1847     for (i=0; i+1<s->nb_chapters; i++)
1848         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1849             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1850             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1851             s->chapters[i]->end = s->chapters[i+1]->start;
1852         }
1853
1854     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1855         assert(s->start_time != AV_NOPTS_VALUE);
1856         assert(s->duration > 0);
1857         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1858                                            AV_TIME_BASE_Q,
1859                                            s->chapters[i]->time_base);
1860     }
1861 }
1862
1863 /* absolute maximum size we read until we abort */
1864 #define MAX_READ_SIZE        5000000
1865
1866 #define MAX_STD_TIMEBASES (60*12+5)
1867 static int get_std_framerate(int i){
1868     if(i<60*12) return i*1001;
1869     else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1870 }
1871
1872 /*
1873  * Is the time base unreliable.
1874  * This is a heuristic to balance between quick acceptance of the values in
1875  * the headers vs. some extra checks.
1876  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1877  * MPEG-2 commonly misuses field repeat flags to store different framerates.
1878  * And there are "variable" fps files this needs to detect as well.
1879  */
1880 static int tb_unreliable(AVCodecContext *c){
1881     if(   c->time_base.den >= 101L*c->time_base.num
1882        || c->time_base.den <    5L*c->time_base.num
1883 /*       || c->codec_tag == ff_get_fourcc("DIVX")
1884        || c->codec_tag == ff_get_fourcc("XVID")*/
1885        || c->codec_id == CODEC_ID_MPEG2VIDEO)
1886         return 1;
1887     return 0;
1888 }
1889
1890 int av_find_stream_info(AVFormatContext *ic)
1891 {
1892     int i, count, ret, read_size, j;
1893     AVStream *st;
1894     AVPacket pkt1, *pkt;
1895     int64_t last_dts[MAX_STREAMS];
1896     int duration_count[MAX_STREAMS]={0};
1897     double (*duration_error)[MAX_STD_TIMEBASES];
1898     offset_t old_offset = url_ftell(ic->pb);
1899     int64_t codec_info_duration[MAX_STREAMS]={0};
1900     int codec_info_nb_frames[MAX_STREAMS]={0};
1901     AVProbeData probe_data[MAX_STREAMS];
1902     int codec_identified[MAX_STREAMS]={0};
1903
1904     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1905     if (!duration_error) return AVERROR(ENOMEM);
1906
1907     for(i=0;i<ic->nb_streams;i++) {
1908         st = ic->streams[i];
1909         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1910 /*            if(!st->time_base.num)
1911                 st->time_base= */
1912             if(!st->codec->time_base.num)
1913                 st->codec->time_base= st->time_base;
1914         }
1915         //only for the split stuff
1916         if (!st->parser) {
1917             st->parser = av_parser_init(st->codec->codec_id);
1918             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1919                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1920             }
1921         }
1922     }
1923
1924     for(i=0;i<MAX_STREAMS;i++){
1925         last_dts[i]= AV_NOPTS_VALUE;
1926     }
1927
1928     memset(probe_data, 0, sizeof(probe_data));
1929     count = 0;
1930     read_size = 0;
1931     for(;;) {
1932         /* check if one codec still needs to be handled */
1933         for(i=0;i<ic->nb_streams;i++) {
1934             st = ic->streams[i];
1935             if (!has_codec_parameters(st->codec))
1936                 break;
1937             /* variable fps and no guess at the real fps */
1938             if(   tb_unreliable(st->codec)
1939                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1940                 break;
1941             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1942                 break;
1943             if(st->first_dts == AV_NOPTS_VALUE)
1944                 break;
1945         }
1946         if (i == ic->nb_streams) {
1947             /* NOTE: if the format has no header, then we need to read
1948                some packets to get most of the streams, so we cannot
1949                stop here */
1950             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1951                 /* if we found the info for all the codecs, we can stop */
1952                 ret = count;
1953                 break;
1954             }
1955         }
1956         /* we did not get all the codec info, but we read too much data */
1957         if (read_size >= MAX_READ_SIZE) {
1958             ret = count;
1959             break;
1960         }
1961
1962         /* NOTE: a new stream can be added there if no header in file
1963            (AVFMTCTX_NOHEADER) */
1964         ret = av_read_frame_internal(ic, &pkt1);
1965         if (ret < 0) {
1966             /* EOF or error */
1967             ret = -1; /* we could not have all the codec parameters before EOF */
1968             for(i=0;i<ic->nb_streams;i++) {
1969                 st = ic->streams[i];
1970                 if (!has_codec_parameters(st->codec)){
1971                     char buf[256];
1972                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1973                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1974                 } else {
1975                     ret = 0;
1976                 }
1977             }
1978             break;
1979         }
1980
1981         pkt= add_to_pktbuf(ic, &pkt1);
1982         if(av_dup_packet(pkt) < 0)
1983             return AVERROR(ENOMEM);
1984
1985         read_size += pkt->size;
1986
1987         st = ic->streams[pkt->stream_index];
1988         if(codec_info_nb_frames[st->index]>1)
1989             codec_info_duration[st->index] += pkt->duration;
1990         if (pkt->duration != 0)
1991             codec_info_nb_frames[st->index]++;
1992
1993         {
1994             int index= pkt->stream_index;
1995             int64_t last= last_dts[index];
1996             int64_t duration= pkt->dts - last;
1997
1998             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1999                 double dur= duration * av_q2d(st->time_base);
2000
2001 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2002 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2003                 if(duration_count[index] < 2)
2004                     memset(duration_error[index], 0, sizeof(*duration_error));
2005                 for(i=1; i<MAX_STD_TIMEBASES; i++){
2006                     int framerate= get_std_framerate(i);
2007                     int ticks= lrintf(dur*framerate/(1001*12));
2008                     double error= dur - ticks*1001*12/(double)framerate;
2009                     duration_error[index][i] += error*error;
2010                 }
2011                 duration_count[index]++;
2012             }
2013             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2014                 last_dts[pkt->stream_index]= pkt->dts;
2015
2016             if (st->codec->codec_id == CODEC_ID_NONE) {
2017                 AVProbeData *pd = &(probe_data[st->index]);
2018                 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
2019                 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
2020                 pd->buf_size += pkt->size;
2021                 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
2022             }
2023         }
2024         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2025             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2026             if(i){
2027                 st->codec->extradata_size= i;
2028                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2029                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2030                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2031             }
2032         }
2033
2034         /* if still no information, we try to open the codec and to
2035            decompress the frame. We try to avoid that in most cases as
2036            it takes longer and uses more memory. For MPEG-4, we need to
2037            decompress for QuickTime. */
2038         if (!has_codec_parameters(st->codec) /*&&
2039             (st->codec->codec_id == CODEC_ID_FLV1 ||
2040              st->codec->codec_id == CODEC_ID_H264 ||
2041              st->codec->codec_id == CODEC_ID_H263 ||
2042              st->codec->codec_id == CODEC_ID_H261 ||
2043              st->codec->codec_id == CODEC_ID_VORBIS ||
2044              st->codec->codec_id == CODEC_ID_MJPEG ||
2045              st->codec->codec_id == CODEC_ID_PNG ||
2046              st->codec->codec_id == CODEC_ID_PAM ||
2047              st->codec->codec_id == CODEC_ID_PGM ||
2048              st->codec->codec_id == CODEC_ID_PGMYUV ||
2049              st->codec->codec_id == CODEC_ID_PBM ||
2050              st->codec->codec_id == CODEC_ID_PPM ||
2051              st->codec->codec_id == CODEC_ID_SHORTEN ||
2052              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2053             try_decode_frame(st, pkt->data, pkt->size);
2054
2055         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) {
2056             break;
2057         }
2058         count++;
2059     }
2060
2061     // close codecs which were opened in try_decode_frame()
2062     for(i=0;i<ic->nb_streams;i++) {
2063         st = ic->streams[i];
2064         if(st->codec->codec)
2065             avcodec_close(st->codec);
2066     }
2067     for(i=0;i<ic->nb_streams;i++) {
2068         st = ic->streams[i];
2069         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2070             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2071                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2072
2073             if(duration_count[i]
2074                && tb_unreliable(st->codec) /*&&
2075                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2076                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2077                 double best_error= 2*av_q2d(st->time_base);
2078                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2079
2080                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2081                     double error= duration_error[i][j] * get_std_framerate(j);
2082 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2083 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2084                     if(error < best_error){
2085                         best_error= error;
2086                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2087                     }
2088                 }
2089             }
2090
2091             if (!st->r_frame_rate.num){
2092                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2093                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
2094                     st->r_frame_rate.num = st->codec->time_base.den;
2095                     st->r_frame_rate.den = st->codec->time_base.num;
2096                 }else{
2097                     st->r_frame_rate.num = st->time_base.den;
2098                     st->r_frame_rate.den = st->time_base.num;
2099                 }
2100             }
2101         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2102             if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2103                 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2104                 if (codec_identified[st->index]) {
2105                     st->need_parsing = AVSTREAM_PARSE_FULL;
2106                 }
2107             }
2108             if(!st->codec->bits_per_sample)
2109                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2110         }
2111     }
2112
2113     av_estimate_timings(ic, old_offset);
2114
2115     for(i=0;i<ic->nb_streams;i++) {
2116         st = ic->streams[i];
2117         if (codec_identified[st->index])
2118             break;
2119     }
2120     //FIXME this is a mess
2121     if(i!=ic->nb_streams){
2122         av_read_frame_flush(ic);
2123         for(i=0;i<ic->nb_streams;i++) {
2124             st = ic->streams[i];
2125             if (codec_identified[st->index]) {
2126                 av_seek_frame(ic, st->index, 0.0, 0);
2127             }
2128             st->cur_dts= st->first_dts;
2129         }
2130         url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2131     }
2132
2133     compute_chapters_end(ic);
2134
2135 #if 0
2136     /* correct DTS for B-frame streams with no timestamps */
2137     for(i=0;i<ic->nb_streams;i++) {
2138         st = ic->streams[i];
2139         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2140             if(b-frames){
2141                 ppktl = &ic->packet_buffer;
2142                 while(ppkt1){
2143                     if(ppkt1->stream_index != i)
2144                         continue;
2145                     if(ppkt1->pkt->dts < 0)
2146                         break;
2147                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2148                         break;
2149                     ppkt1->pkt->dts -= delta;
2150                     ppkt1= ppkt1->next;
2151                 }
2152                 if(ppkt1)
2153                     continue;
2154                 st->cur_dts -= delta;
2155             }
2156         }
2157     }
2158 #endif
2159
2160     av_free(duration_error);
2161     for(i=0;i<MAX_STREAMS;i++){
2162         av_freep(&(probe_data[i].buf));
2163     }
2164
2165     return ret;
2166 }
2167
2168 /*******************************************************/
2169
2170 int av_read_play(AVFormatContext *s)
2171 {
2172     if (s->iformat->read_play)
2173         return s->iformat->read_play(s);
2174     if (s->pb)
2175         return av_url_read_fpause(s->pb, 0);
2176     return AVERROR(ENOSYS);
2177 }
2178
2179 int av_read_pause(AVFormatContext *s)
2180 {
2181     if (s->iformat->read_pause)
2182         return s->iformat->read_pause(s);
2183     if (s->pb)
2184         return av_url_read_fpause(s->pb, 1);
2185     return AVERROR(ENOSYS);
2186 }
2187
2188 void av_close_input_stream(AVFormatContext *s)
2189 {
2190     int i;
2191     AVStream *st;
2192
2193     /* free previous packet */
2194     if (s->cur_st && s->cur_st->parser)
2195         av_free_packet(&s->cur_pkt);
2196
2197     if (s->iformat->read_close)
2198         s->iformat->read_close(s);
2199     for(i=0;i<s->nb_streams;i++) {
2200         /* free all data in a stream component */
2201         st = s->streams[i];
2202         if (st->parser) {
2203             av_parser_close(st->parser);
2204         }
2205         av_free(st->index_entries);
2206         av_free(st->codec->extradata);
2207         av_free(st->codec);
2208         av_free(st->filename);
2209         av_free(st->priv_data);
2210         av_free(st);
2211     }
2212     for(i=s->nb_programs-1; i>=0; i--) {
2213         av_freep(&s->programs[i]->provider_name);
2214         av_freep(&s->programs[i]->name);
2215         av_freep(&s->programs[i]->stream_index);
2216         av_freep(&s->programs[i]);
2217     }
2218     av_freep(&s->programs);
2219     flush_packet_queue(s);
2220     av_freep(&s->priv_data);
2221     while(s->nb_chapters--) {
2222         av_free(s->chapters[s->nb_chapters]->title);
2223         av_free(s->chapters[s->nb_chapters]);
2224     }
2225     av_freep(&s->chapters);
2226     av_free(s);
2227 }
2228
2229 void av_close_input_file(AVFormatContext *s)
2230 {
2231     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2232     av_close_input_stream(s);
2233     if (pb)
2234         url_fclose(pb);
2235 }
2236
2237 AVStream *av_new_stream(AVFormatContext *s, int id)
2238 {
2239     AVStream *st;
2240     int i;
2241
2242     if (s->nb_streams >= MAX_STREAMS)
2243         return NULL;
2244
2245     st = av_mallocz(sizeof(AVStream));
2246     if (!st)
2247         return NULL;
2248
2249     st->codec= avcodec_alloc_context();
2250     if (s->iformat) {
2251         /* no default bitrate if decoding */
2252         st->codec->bit_rate = 0;
2253     }
2254     st->index = s->nb_streams;
2255     st->id = id;
2256     st->start_time = AV_NOPTS_VALUE;
2257     st->duration = AV_NOPTS_VALUE;
2258     st->cur_dts = AV_NOPTS_VALUE;
2259     st->first_dts = AV_NOPTS_VALUE;
2260
2261     /* default pts setting is MPEG-like */
2262     av_set_pts_info(st, 33, 1, 90000);
2263     st->last_IP_pts = AV_NOPTS_VALUE;
2264     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2265         st->pts_buffer[i]= AV_NOPTS_VALUE;
2266
2267     s->streams[s->nb_streams++] = st;
2268     return st;
2269 }
2270
2271 AVProgram *av_new_program(AVFormatContext *ac, int id)
2272 {
2273     AVProgram *program=NULL;
2274     int i;
2275
2276 #ifdef DEBUG_SI
2277     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2278 #endif
2279
2280     for(i=0; i<ac->nb_programs; i++)
2281         if(ac->programs[i]->id == id)
2282             program = ac->programs[i];
2283
2284     if(!program){
2285         program = av_mallocz(sizeof(AVProgram));
2286         if (!program)
2287             return NULL;
2288         dynarray_add(&ac->programs, &ac->nb_programs, program);
2289         program->discard = AVDISCARD_NONE;
2290     }
2291     program->id = id;
2292
2293     return program;
2294 }
2295
2296 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2297 {
2298     assert(!provider_name == !name);
2299     if(name){
2300         av_free(program->provider_name);
2301         av_free(program->         name);
2302         program->provider_name = av_strdup(provider_name);
2303         program->         name = av_strdup(         name);
2304     }
2305 }
2306
2307 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2308 {
2309     AVChapter *chapter = NULL;
2310     int i;
2311
2312     for(i=0; i<s->nb_chapters; i++)
2313         if(s->chapters[i]->id == id)
2314             chapter = s->chapters[i];
2315
2316     if(!chapter){
2317         chapter= av_mallocz(sizeof(AVChapter));
2318         if(!chapter)
2319             return NULL;
2320         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2321     }
2322     av_free(chapter->title);
2323     chapter->title = av_strdup(title);
2324     chapter->id    = id;
2325     chapter->time_base= time_base;
2326     chapter->start = start;
2327     chapter->end   = end;
2328
2329     return chapter;
2330 }
2331
2332 /************************************************************/
2333 /* output media file */
2334
2335 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2336 {
2337     int ret;
2338
2339     if (s->oformat->priv_data_size > 0) {
2340         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2341         if (!s->priv_data)
2342             return AVERROR(ENOMEM);
2343     } else
2344         s->priv_data = NULL;
2345
2346     if (s->oformat->set_parameters) {
2347         ret = s->oformat->set_parameters(s, ap);
2348         if (ret < 0)
2349             return ret;
2350     }
2351     return 0;
2352 }
2353
2354 int av_write_header(AVFormatContext *s)
2355 {
2356     int ret, i;
2357     AVStream *st;
2358
2359     // some sanity checks
2360     for(i=0;i<s->nb_streams;i++) {
2361         st = s->streams[i];
2362
2363         switch (st->codec->codec_type) {
2364         case CODEC_TYPE_AUDIO:
2365             if(st->codec->sample_rate<=0){
2366                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2367                 return -1;
2368             }
2369             break;
2370         case CODEC_TYPE_VIDEO:
2371             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2372                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2373                 return -1;
2374             }
2375             if(st->codec->width<=0 || st->codec->height<=0){
2376                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2377                 return -1;
2378             }
2379             break;
2380         }
2381
2382         if(s->oformat->codec_tag){
2383             if(st->codec->codec_tag){
2384                 //FIXME
2385                 //check that tag + id is in the table
2386                 //if neither is in the table -> OK
2387                 //if tag is in the table with another id -> FAIL
2388                 //if id is in the table with another tag -> FAIL unless strict < ?
2389             }else
2390                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2391         }
2392     }
2393
2394     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2395         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2396         if (!s->priv_data)
2397             return AVERROR(ENOMEM);
2398     }
2399
2400     if(s->oformat->write_header){
2401         ret = s->oformat->write_header(s);
2402         if (ret < 0)
2403             return ret;
2404     }
2405
2406     /* init PTS generation */
2407     for(i=0;i<s->nb_streams;i++) {
2408         int64_t den = AV_NOPTS_VALUE;
2409         st = s->streams[i];
2410
2411         switch (st->codec->codec_type) {
2412         case CODEC_TYPE_AUDIO:
2413             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2414             break;
2415         case CODEC_TYPE_VIDEO:
2416             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2417             break;
2418         default:
2419             break;
2420         }
2421         if (den != AV_NOPTS_VALUE) {
2422             if (den <= 0)
2423                 return AVERROR_INVALIDDATA;
2424             av_frac_init(&st->pts, 0, 0, den);
2425         }
2426     }
2427     return 0;
2428 }
2429
2430 //FIXME merge with compute_pkt_fields
2431 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2432     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2433     int num, den, frame_size, i;
2434
2435 //    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);
2436
2437 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2438         return -1;*/
2439
2440     /* duration field */
2441     if (pkt->duration == 0) {
2442         compute_frame_duration(&num, &den, st, NULL, pkt);
2443         if (den && num) {
2444             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2445         }
2446     }
2447
2448     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2449         pkt->pts= pkt->dts;
2450
2451     //XXX/FIXME this is a temporary hack until all encoders output pts
2452     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2453         pkt->dts=
2454 //        pkt->pts= st->cur_dts;
2455         pkt->pts= st->pts.val;
2456     }
2457
2458     //calculate dts from pts
2459     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2460         st->pts_buffer[0]= pkt->pts;
2461         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2462             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2463         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2464             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2465
2466         pkt->dts= st->pts_buffer[0];
2467     }
2468
2469     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2470         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2471         return -1;
2472     }
2473     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2474         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2475         return -1;
2476     }
2477
2478 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2479     st->cur_dts= pkt->dts;
2480     st->pts.val= pkt->dts;
2481
2482     /* update pts */
2483     switch (st->codec->codec_type) {
2484     case CODEC_TYPE_AUDIO:
2485         frame_size = get_audio_frame_size(st->codec, pkt->size);
2486
2487         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2488            likely equal to the encoder delay, but it would be better if we
2489            had the real timestamps from the encoder */
2490         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2491             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2492         }
2493         break;
2494     case CODEC_TYPE_VIDEO:
2495         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2496         break;
2497     default:
2498         break;
2499     }
2500     return 0;
2501 }
2502
2503 static void truncate_ts(AVStream *st, AVPacket *pkt){
2504     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2505
2506 //    if(pkt->dts < 0)
2507 //        pkt->dts= 0;  //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2508
2509     if (pkt->pts != AV_NOPTS_VALUE)
2510         pkt->pts &= pts_mask;
2511     if (pkt->dts != AV_NOPTS_VALUE)
2512         pkt->dts &= pts_mask;
2513 }
2514
2515 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2516 {
2517     int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2518
2519     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2520         return ret;
2521
2522     truncate_ts(s->streams[pkt->stream_index], pkt);
2523
2524     ret= s->oformat->write_packet(s, pkt);
2525     if(!ret)
2526         ret= url_ferror(s->pb);
2527     return ret;
2528 }
2529
2530 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2531     AVPacketList *pktl, **next_point, *this_pktl;
2532     int stream_count=0;
2533     int streams[MAX_STREAMS];
2534
2535     if(pkt){
2536         AVStream *st= s->streams[ pkt->stream_index];
2537
2538 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2539
2540         this_pktl = av_mallocz(sizeof(AVPacketList));
2541         this_pktl->pkt= *pkt;
2542         if(pkt->destruct == av_destruct_packet)
2543             pkt->destruct= NULL; // not shared -> must keep original from being freed
2544         else
2545             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2546
2547         next_point = &s->packet_buffer;
2548         while(*next_point){
2549             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2550             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2551             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2552             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2553                 break;
2554             next_point= &(*next_point)->next;
2555         }
2556         this_pktl->next= *next_point;
2557         *next_point= this_pktl;
2558     }
2559
2560     memset(streams, 0, sizeof(streams));
2561     pktl= s->packet_buffer;
2562     while(pktl){
2563 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2564         if(streams[ pktl->pkt.stream_index ] == 0)
2565             stream_count++;
2566         streams[ pktl->pkt.stream_index ]++;
2567         pktl= pktl->next;
2568     }
2569
2570     if(stream_count && (s->nb_streams == stream_count || flush)){
2571         pktl= s->packet_buffer;
2572         *out= pktl->pkt;
2573
2574         s->packet_buffer= pktl->next;
2575         av_freep(&pktl);
2576         return 1;
2577     }else{
2578         av_init_packet(out);
2579         return 0;
2580     }
2581 }
2582
2583 /**
2584  * Interleaves an AVPacket correctly so it can be muxed.
2585  * @param out the interleaved packet will be output here
2586  * @param in the input packet
2587  * @param flush 1 if no further packets are available as input and all
2588  *              remaining packets should be output
2589  * @return 1 if a packet was output, 0 if no packet could be output,
2590  *         < 0 if an error occurred
2591  */
2592 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2593     if(s->oformat->interleave_packet)
2594         return s->oformat->interleave_packet(s, out, in, flush);
2595     else
2596         return av_interleave_packet_per_dts(s, out, in, flush);
2597 }
2598
2599 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2600     AVStream *st= s->streams[ pkt->stream_index];
2601
2602     //FIXME/XXX/HACK drop zero sized packets
2603     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2604         return 0;
2605
2606 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2607     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2608         return -1;
2609
2610     if(pkt->dts == AV_NOPTS_VALUE)
2611         return -1;
2612
2613     for(;;){
2614         AVPacket opkt;
2615         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2616         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2617             return ret;
2618
2619         truncate_ts(s->streams[opkt.stream_index], &opkt);
2620         ret= s->oformat->write_packet(s, &opkt);
2621
2622         av_free_packet(&opkt);
2623         pkt= NULL;
2624
2625         if(ret<0)
2626             return ret;
2627         if(url_ferror(s->pb))
2628             return url_ferror(s->pb);
2629     }
2630 }
2631
2632 int av_write_trailer(AVFormatContext *s)
2633 {
2634     int ret, i;
2635
2636     for(;;){
2637         AVPacket pkt;
2638         ret= av_interleave_packet(s, &pkt, NULL, 1);
2639         if(ret<0) //FIXME cleanup needed for ret<0 ?
2640             goto fail;
2641         if(!ret)
2642             break;
2643
2644         truncate_ts(s->streams[pkt.stream_index], &pkt);
2645         ret= s->oformat->write_packet(s, &pkt);
2646
2647         av_free_packet(&pkt);
2648
2649         if(ret<0)
2650             goto fail;
2651         if(url_ferror(s->pb))
2652             goto fail;
2653     }
2654
2655     if(s->oformat->write_trailer)
2656         ret = s->oformat->write_trailer(s);
2657 fail:
2658     if(ret == 0)
2659        ret=url_ferror(s->pb);
2660     for(i=0;i<s->nb_streams;i++)
2661         av_freep(&s->streams[i]->priv_data);
2662     av_freep(&s->priv_data);
2663     return ret;
2664 }
2665
2666 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2667 {
2668     int i, j;
2669     AVProgram *program=NULL;
2670     void *tmp;
2671
2672     for(i=0; i<ac->nb_programs; i++){
2673         if(ac->programs[i]->id != progid)
2674             continue;
2675         program = ac->programs[i];
2676         for(j=0; j<program->nb_stream_indexes; j++)
2677             if(program->stream_index[j] == idx)
2678                 return;
2679
2680         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2681         if(!tmp)
2682             return;
2683         program->stream_index = tmp;
2684         program->stream_index[program->nb_stream_indexes++] = idx;
2685         return;
2686     }
2687 }
2688
2689 /* "user interface" functions */
2690 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2691 {
2692     char buf[256];
2693     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2694     AVStream *st = ic->streams[i];
2695     int g = ff_gcd(st->time_base.num, st->time_base.den);
2696     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2697     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2698     /* the pid is an important information, so we display it */
2699     /* XXX: add a generic system */
2700     if (flags & AVFMT_SHOW_IDS)
2701         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2702     if (strlen(st->language) > 0)
2703         av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2704     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2705     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2706     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2707         if(st->r_frame_rate.den && st->r_frame_rate.num)
2708             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2709 /*      else if(st->time_base.den && st->time_base.num)
2710             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2711         else
2712             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2713     }
2714     av_log(NULL, AV_LOG_INFO, "\n");
2715 }
2716
2717 void dump_format(AVFormatContext *ic,
2718                  int index,
2719                  const char *url,
2720                  int is_output)
2721 {
2722     int i;
2723
2724     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2725             is_output ? "Output" : "Input",
2726             index,
2727             is_output ? ic->oformat->name : ic->iformat->name,
2728             is_output ? "to" : "from", url);
2729     if (!is_output) {
2730         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2731         if (ic->duration != AV_NOPTS_VALUE) {
2732             int hours, mins, secs, us;
2733             secs = ic->duration / AV_TIME_BASE;
2734             us = ic->duration % AV_TIME_BASE;
2735             mins = secs / 60;
2736             secs %= 60;
2737             hours = mins / 60;
2738             mins %= 60;
2739             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2740                    (100 * us) / AV_TIME_BASE);
2741         } else {
2742             av_log(NULL, AV_LOG_INFO, "N/A");
2743         }
2744         if (ic->start_time != AV_NOPTS_VALUE) {
2745             int secs, us;
2746             av_log(NULL, AV_LOG_INFO, ", start: ");
2747             secs = ic->start_time / AV_TIME_BASE;
2748             us = ic->start_time % AV_TIME_BASE;
2749             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2750                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2751         }
2752         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2753         if (ic->bit_rate) {
2754             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2755         } else {
2756             av_log(NULL, AV_LOG_INFO, "N/A");
2757         }
2758         av_log(NULL, AV_LOG_INFO, "\n");
2759     }
2760     if(ic->nb_programs) {
2761         int j, k;
2762         for(j=0; j<ic->nb_programs; j++) {
2763             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2764                    ic->programs[j]->name ? ic->programs[j]->name : "");
2765             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2766                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2767          }
2768     } else
2769     for(i=0;i<ic->nb_streams;i++)
2770         dump_stream_format(ic, i, index, is_output);
2771 }
2772
2773 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2774 {
2775     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2776 }
2777
2778 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2779 {
2780     AVRational frame_rate;
2781     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2782     *frame_rate_num= frame_rate.num;
2783     *frame_rate_den= frame_rate.den;
2784     return ret;
2785 }
2786
2787 /**
2788  * Gets the current time in microseconds.
2789  */
2790 int64_t av_gettime(void)
2791 {
2792     struct timeval tv;
2793     gettimeofday(&tv,NULL);
2794     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2795 }
2796
2797 int64_t parse_date(const char *datestr, int duration)
2798 {
2799     const char *p;
2800     int64_t t;
2801     struct tm dt;
2802     int i;
2803     static const char *date_fmt[] = {
2804         "%Y-%m-%d",
2805         "%Y%m%d",
2806     };
2807     static const char *time_fmt[] = {
2808         "%H:%M:%S",
2809         "%H%M%S",
2810     };
2811     const char *q;
2812     int is_utc, len;
2813     char lastch;
2814     int negative = 0;
2815
2816 #undef time
2817     time_t now = time(0);
2818
2819     len = strlen(datestr);
2820     if (len > 0)
2821         lastch = datestr[len - 1];
2822     else
2823         lastch = '\0';
2824     is_utc = (lastch == 'z' || lastch == 'Z');
2825
2826     memset(&dt, 0, sizeof(dt));
2827
2828     p = datestr;
2829     q = NULL;
2830     if (!duration) {
2831         /* parse the year-month-day part */
2832         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2833             q = small_strptime(p, date_fmt[i], &dt);
2834             if (q) {
2835                 break;
2836             }
2837         }
2838
2839         /* if the year-month-day part is missing, then take the
2840          * current year-month-day time */
2841         if (!q) {
2842             if (is_utc) {
2843                 dt = *gmtime(&now);
2844             } else {
2845                 dt = *localtime(&now);
2846             }
2847             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2848         } else {
2849             p = q;
2850         }
2851
2852         if (*p == 'T' || *p == 't' || *p == ' ')
2853             p++;
2854
2855         /* parse the hour-minute-second part */
2856         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2857             q = small_strptime(p, time_fmt[i], &dt);
2858             if (q) {
2859                 break;
2860             }
2861         }
2862     } else {
2863         /* parse datestr as a duration */
2864         if (p[0] == '-') {
2865             negative = 1;
2866             ++p;
2867         }
2868         /* parse datestr as HH:MM:SS */
2869         q = small_strptime(p, time_fmt[0], &dt);
2870         if (!q) {
2871             /* parse datestr as S+ */
2872             dt.tm_sec = strtol(p, (char **)&q, 10);
2873             if (q == p)
2874                 /* the parsing didn't succeed */
2875                 return INT64_MIN;
2876             dt.tm_min = 0;
2877             dt.tm_hour = 0;
2878         }
2879     }
2880
2881     /* Now we have all the fields that we can get */
2882     if (!q) {
2883         return INT64_MIN;
2884     }
2885
2886     if (duration) {
2887         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2888     } else {
2889         dt.tm_isdst = -1;       /* unknown */
2890         if (is_utc) {
2891             t = mktimegm(&dt);
2892         } else {
2893             t = mktime(&dt);
2894         }
2895     }
2896
2897     t *= 1000000;
2898
2899     /* parse the .m... part */
2900     if (*q == '.') {
2901         int val, n;
2902         q++;
2903         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2904             if (!isdigit(*q))
2905                 break;
2906             val += n * (*q - '0');
2907         }
2908         t += val;
2909     }
2910     return negative ? -t : t;
2911 }
2912
2913 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2914 {
2915     const char *p;
2916     char tag[128], *q;
2917
2918     p = info;
2919     if (*p == '?')
2920         p++;
2921     for(;;) {
2922         q = tag;
2923         while (*p != '\0' && *p != '=' && *p != '&') {
2924             if ((q - tag) < sizeof(tag) - 1)
2925                 *q++ = *p;
2926             p++;
2927         }
2928         *q = '\0';
2929         q = arg;
2930         if (*p == '=') {
2931             p++;
2932             while (*p != '&' && *p != '\0') {
2933                 if ((q - arg) < arg_size - 1) {
2934                     if (*p == '+')
2935                         *q++ = ' ';
2936                     else
2937                         *q++ = *p;
2938                 }
2939                 p++;
2940             }
2941             *q = '\0';
2942         }
2943         if (!strcmp(tag, tag1))
2944             return 1;
2945         if (*p != '&')
2946             break;
2947         p++;
2948     }
2949     return 0;
2950 }
2951
2952 int av_get_frame_filename(char *buf, int buf_size,
2953                           const char *path, int number)
2954 {
2955     const char *p;
2956     char *q, buf1[20], c;
2957     int nd, len, percentd_found;
2958
2959     q = buf;
2960     p = path;
2961     percentd_found = 0;
2962     for(;;) {
2963         c = *p++;
2964         if (c == '\0')
2965             break;
2966         if (c == '%') {
2967             do {
2968                 nd = 0;
2969                 while (isdigit(*p)) {
2970                     nd = nd * 10 + *p++ - '0';
2971                 }
2972                 c = *p++;
2973             } while (isdigit(c));
2974
2975             switch(c) {
2976             case '%':
2977                 goto addchar;
2978             case 'd':
2979                 if (percentd_found)
2980                     goto fail;
2981                 percentd_found = 1;
2982                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2983                 len = strlen(buf1);
2984                 if ((q - buf + len) > buf_size - 1)
2985                     goto fail;
2986                 memcpy(q, buf1, len);
2987                 q += len;
2988                 break;
2989             default:
2990                 goto fail;
2991             }
2992         } else {
2993         addchar:
2994             if ((q - buf) < buf_size - 1)
2995                 *q++ = c;
2996         }
2997     }
2998     if (!percentd_found)
2999         goto fail;
3000     *q = '\0';
3001     return 0;
3002  fail:
3003     *q = '\0';
3004     return -1;
3005 }
3006
3007 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3008 {
3009     int len, i, j, c;
3010 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3011
3012     for(i=0;i<size;i+=16) {
3013         len = size - i;
3014         if (len > 16)
3015             len = 16;
3016         PRINT("%08x ", i);
3017         for(j=0;j<16;j++) {
3018             if (j < len)
3019                 PRINT(" %02x", buf[i+j]);
3020             else
3021                 PRINT("   ");
3022         }
3023         PRINT(" ");
3024         for(j=0;j<len;j++) {
3025             c = buf[i+j];
3026             if (c < ' ' || c > '~')
3027                 c = '.';
3028             PRINT("%c", c);
3029         }
3030         PRINT("\n");
3031     }
3032 #undef PRINT
3033 }
3034
3035 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3036 {
3037     hex_dump_internal(NULL, f, 0, buf, size);
3038 }
3039
3040 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3041 {
3042     hex_dump_internal(avcl, NULL, level, buf, size);
3043 }
3044
3045  //FIXME needs to know the time_base
3046 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3047 {
3048 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3049     PRINT("stream #%d:\n", pkt->stream_index);
3050     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3051     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3052     /* DTS is _always_ valid after av_read_frame() */
3053     PRINT("  dts=");
3054     if (pkt->dts == AV_NOPTS_VALUE)
3055         PRINT("N/A");
3056     else
3057         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3058     /* PTS may not be known if B-frames are present. */
3059     PRINT("  pts=");
3060     if (pkt->pts == AV_NOPTS_VALUE)
3061         PRINT("N/A");
3062     else
3063         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3064     PRINT("\n");
3065     PRINT("  size=%d\n", pkt->size);
3066 #undef PRINT
3067     if (dump_payload)
3068         av_hex_dump(f, pkt->data, pkt->size);
3069 }
3070
3071 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3072 {
3073     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3074 }
3075
3076 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3077 {
3078     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3079 }
3080
3081 void url_split(char *proto, int proto_size,
3082                char *authorization, int authorization_size,
3083                char *hostname, int hostname_size,
3084                int *port_ptr,
3085                char *path, int path_size,
3086                const char *url)
3087 {
3088     const char *p, *ls, *at, *col, *brk;
3089
3090     if (port_ptr)               *port_ptr = -1;
3091     if (proto_size > 0)         proto[0] = 0;
3092     if (authorization_size > 0) authorization[0] = 0;
3093     if (hostname_size > 0)      hostname[0] = 0;
3094     if (path_size > 0)          path[0] = 0;
3095
3096     /* parse protocol */
3097     if ((p = strchr(url, ':'))) {
3098         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3099         p++; /* skip ':' */
3100         if (*p == '/') p++;
3101         if (*p == '/') p++;
3102     } else {
3103         /* no protocol means plain filename */
3104         av_strlcpy(path, url, path_size);
3105         return;
3106     }
3107
3108     /* separate path from hostname */
3109     ls = strchr(p, '/');
3110     if(!ls)
3111         ls = strchr(p, '?');
3112     if(ls)
3113         av_strlcpy(path, ls, path_size);
3114     else
3115         ls = &p[strlen(p)]; // XXX
3116
3117     /* the rest is hostname, use that to parse auth/port */
3118     if (ls != p) {
3119         /* authorization (user[:pass]@hostname) */
3120         if ((at = strchr(p, '@')) && at < ls) {
3121             av_strlcpy(authorization, p,
3122                        FFMIN(authorization_size, at + 1 - p));
3123             p = at + 1; /* skip '@' */
3124         }
3125
3126         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3127             /* [host]:port */
3128             av_strlcpy(hostname, p + 1,
3129                        FFMIN(hostname_size, brk - p));
3130             if (brk[1] == ':' && port_ptr)
3131                 *port_ptr = atoi(brk + 2);
3132         } else if ((col = strchr(p, ':')) && col < ls) {
3133             av_strlcpy(hostname, p,
3134                        FFMIN(col + 1 - p, hostname_size));
3135             if (port_ptr) *port_ptr = atoi(col + 1);
3136         } else
3137             av_strlcpy(hostname, p,
3138                        FFMIN(ls + 1 - p, hostname_size));
3139     }
3140 }
3141
3142 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3143                      int pts_num, int pts_den)
3144 {
3145     s->pts_wrap_bits = pts_wrap_bits;
3146     s->time_base.num = pts_num;
3147     s->time_base.den = pts_den;
3148 }
3149
3150 /* fraction handling */
3151
3152 /**
3153  * f = val + (num / den) + 0.5.
3154  *
3155  * 'num' is normalized so that it is such as 0 <= num < den.
3156  *
3157  * @param f fractional number
3158  * @param val integer value
3159  * @param num must be >= 0
3160  * @param den must be >= 1
3161  */
3162 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3163 {
3164     num += (den >> 1);
3165     if (num >= den) {
3166         val += num / den;
3167         num = num % den;
3168     }
3169     f->val = val;
3170     f->num = num;
3171     f->den = den;
3172 }
3173
3174 /**
3175  * Fractional addition to f: f = f + (incr / f->den).
3176  *
3177  * @param f fractional number
3178  * @param incr increment, can be positive or negative
3179  */
3180 static void av_frac_add(AVFrac *f, int64_t incr)
3181 {
3182     int64_t num, den;
3183
3184     num = f->num + incr;
3185     den = f->den;
3186     if (num < 0) {
3187         f->val += num / den;
3188         num = num % den;
3189         if (num < 0) {
3190             num += den;
3191             f->val--;
3192         }
3193     } else if (num >= den) {
3194         f->val += num / den;
3195         num = num % den;
3196     }
3197     f->num = num;
3198 }