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