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