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