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