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