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

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