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     int64_t codec_info_duration[MAX_STREAMS]={0};
1683     int codec_info_nb_frames[MAX_STREAMS]={0};
1684
1685     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1686     if (!duration_error) return AVERROR_NOMEM;
1687
1688     for(i=0;i<ic->nb_streams;i++) {
1689         st = ic->streams[i];
1690         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1691 /*            if(!st->time_base.num)
1692                 st->time_base= */
1693             if(!st->codec->time_base.num)
1694                 st->codec->time_base= st->time_base;
1695         }
1696         //only for the split stuff
1697         if (!st->parser) {
1698             st->parser = av_parser_init(st->codec->codec_id);
1699             if(st->need_parsing == 2 && st->parser){
1700                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1701             }
1702         }
1703     }
1704
1705     for(i=0;i<MAX_STREAMS;i++){
1706         last_dts[i]= AV_NOPTS_VALUE;
1707     }
1708
1709     count = 0;
1710     read_size = 0;
1711     ppktl = &ic->packet_buffer;
1712     for(;;) {
1713         /* check if one codec still needs to be handled */
1714         for(i=0;i<ic->nb_streams;i++) {
1715             st = ic->streams[i];
1716             if (!has_codec_parameters(st->codec))
1717                 break;
1718             /* variable fps and no guess at the real fps */
1719             if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1720                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1721                 break;
1722             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1723                 break;
1724         }
1725         if (i == ic->nb_streams) {
1726             /* NOTE: if the format has no header, then we need to read
1727                some packets to get most of the streams, so we cannot
1728                stop here */
1729             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1730                 /* if we found the info for all the codecs, we can stop */
1731                 ret = count;
1732                 break;
1733             }
1734         }
1735         /* we did not get all the codec info, but we read too much data */
1736         if (read_size >= MAX_READ_SIZE) {
1737             ret = count;
1738             break;
1739         }
1740
1741         /* NOTE: a new stream can be added there if no header in file
1742            (AVFMTCTX_NOHEADER) */
1743         ret = av_read_frame_internal(ic, &pkt1);
1744         if (ret < 0) {
1745             /* EOF or error */
1746             ret = -1; /* we could not have all the codec parameters before EOF */
1747             for(i=0;i<ic->nb_streams;i++) {
1748                 st = ic->streams[i];
1749                 if (!has_codec_parameters(st->codec)){
1750                     char buf[256];
1751                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1752                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1753                 } else {
1754                     ret = 0;
1755                 }
1756             }
1757             break;
1758         }
1759
1760         pktl = av_mallocz(sizeof(AVPacketList));
1761         if (!pktl) {
1762             ret = AVERROR_NOMEM;
1763             break;
1764         }
1765
1766         /* add the packet in the buffered packet list */
1767         *ppktl = pktl;
1768         ppktl = &pktl->next;
1769
1770         pkt = &pktl->pkt;
1771         *pkt = pkt1;
1772
1773         /* duplicate the packet */
1774         if (av_dup_packet(pkt) < 0) {
1775             ret = AVERROR_NOMEM;
1776             break;
1777         }
1778
1779         read_size += pkt->size;
1780
1781         st = ic->streams[pkt->stream_index];
1782         if(codec_info_nb_frames[st->index]>1)
1783             codec_info_duration[st->index] += pkt->duration;
1784         if (pkt->duration != 0)
1785             codec_info_nb_frames[st->index]++;
1786
1787         {
1788             int index= pkt->stream_index;
1789             int64_t last= last_dts[index];
1790             int64_t duration= pkt->dts - last;
1791
1792             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1793                 double dur= duration * av_q2d(st->time_base);
1794
1795 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1796 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1797                 if(duration_count[index] < 2)
1798                     memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1799                 for(i=1; i<MAX_STD_TIMEBASES; i++){
1800                     int framerate= get_std_framerate(i);
1801                     int ticks= lrintf(dur*framerate/(1001*12));
1802                     double error= dur - ticks*1001*12/(double)framerate;
1803                     duration_error[index][i] += error*error;
1804                 }
1805                 duration_count[index]++;
1806             }
1807             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1808                 last_dts[pkt->stream_index]= pkt->dts;
1809         }
1810         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1811             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1812             if(i){
1813                 st->codec->extradata_size= i;
1814                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1815                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1816                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1817             }
1818         }
1819
1820         /* if still no information, we try to open the codec and to
1821            decompress the frame. We try to avoid that in most cases as
1822            it takes longer and uses more memory. For MPEG4, we need to
1823            decompress for Quicktime. */
1824         if (!has_codec_parameters(st->codec) /*&&
1825             (st->codec->codec_id == CODEC_ID_FLV1 ||
1826              st->codec->codec_id == CODEC_ID_H264 ||
1827              st->codec->codec_id == CODEC_ID_H263 ||
1828              st->codec->codec_id == CODEC_ID_H261 ||
1829              st->codec->codec_id == CODEC_ID_VORBIS ||
1830              st->codec->codec_id == CODEC_ID_MJPEG ||
1831              st->codec->codec_id == CODEC_ID_PNG ||
1832              st->codec->codec_id == CODEC_ID_PAM ||
1833              st->codec->codec_id == CODEC_ID_PGM ||
1834              st->codec->codec_id == CODEC_ID_PGMYUV ||
1835              st->codec->codec_id == CODEC_ID_PBM ||
1836              st->codec->codec_id == CODEC_ID_PPM ||
1837              st->codec->codec_id == CODEC_ID_SHORTEN ||
1838              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1839             try_decode_frame(st, pkt->data, pkt->size);
1840
1841         if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1842             break;
1843         }
1844         count++;
1845     }
1846
1847     // close codecs which where opened in try_decode_frame()
1848     for(i=0;i<ic->nb_streams;i++) {
1849         st = ic->streams[i];
1850         if(st->codec->codec)
1851             avcodec_close(st->codec);
1852     }
1853     for(i=0;i<ic->nb_streams;i++) {
1854         st = ic->streams[i];
1855         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1856             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1857                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1858
1859             if(duration_count[i]
1860                && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1861                //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1862                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1863                 double best_error= 2*av_q2d(st->time_base);
1864                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1865
1866                 for(j=1; j<MAX_STD_TIMEBASES; j++){
1867                     double error= duration_error[i][j] * get_std_framerate(j);
1868 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1869 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1870                     if(error < best_error){
1871                         best_error= error;
1872                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1873                     }
1874                 }
1875             }
1876
1877             if (!st->r_frame_rate.num){
1878                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
1879                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
1880                     st->r_frame_rate.num = st->codec->time_base.den;
1881                     st->r_frame_rate.den = st->codec->time_base.num;
1882                 }else{
1883                     st->r_frame_rate.num = st->time_base.den;
1884                     st->r_frame_rate.den = st->time_base.num;
1885                 }
1886             }
1887         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1888             if(!st->codec->bits_per_sample)
1889                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1890         }
1891     }
1892
1893     av_estimate_timings(ic, old_offset);
1894 #if 0
1895     /* correct DTS for b frame streams with no timestamps */
1896     for(i=0;i<ic->nb_streams;i++) {
1897         st = ic->streams[i];
1898         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1899             if(b-frames){
1900                 ppktl = &ic->packet_buffer;
1901                 while(ppkt1){
1902                     if(ppkt1->stream_index != i)
1903                         continue;
1904                     if(ppkt1->pkt->dts < 0)
1905                         break;
1906                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1907                         break;
1908                     ppkt1->pkt->dts -= delta;
1909                     ppkt1= ppkt1->next;
1910                 }
1911                 if(ppkt1)
1912                     continue;
1913                 st->cur_dts -= delta;
1914             }
1915         }
1916     }
1917 #endif
1918
1919     av_free(duration_error);
1920
1921     return ret;
1922 }
1923
1924 /*******************************************************/
1925
1926 int av_read_play(AVFormatContext *s)
1927 {
1928     if (!s->iformat->read_play)
1929         return AVERROR_NOTSUPP;
1930     return s->iformat->read_play(s);
1931 }
1932
1933 int av_read_pause(AVFormatContext *s)
1934 {
1935     if (!s->iformat->read_pause)
1936         return AVERROR_NOTSUPP;
1937     return s->iformat->read_pause(s);
1938 }
1939
1940 void av_close_input_file(AVFormatContext *s)
1941 {
1942     int i, must_open_file;
1943     AVStream *st;
1944
1945     /* free previous packet */
1946     if (s->cur_st && s->cur_st->parser)
1947         av_free_packet(&s->cur_pkt);
1948
1949     if (s->iformat->read_close)
1950         s->iformat->read_close(s);
1951     for(i=0;i<s->nb_streams;i++) {
1952         /* free all data in a stream component */
1953         st = s->streams[i];
1954         if (st->parser) {
1955             av_parser_close(st->parser);
1956         }
1957         av_free(st->index_entries);
1958         av_free(st->codec->extradata);
1959         av_free(st->codec);
1960         av_free(st);
1961     }
1962     flush_packet_queue(s);
1963     must_open_file = 1;
1964     if (s->iformat->flags & AVFMT_NOFILE) {
1965         must_open_file = 0;
1966     }
1967     if (must_open_file) {
1968         url_fclose(&s->pb);
1969     }
1970     av_freep(&s->priv_data);
1971     av_free(s);
1972 }
1973
1974 AVStream *av_new_stream(AVFormatContext *s, int id)
1975 {
1976     AVStream *st;
1977     int i;
1978
1979     if (s->nb_streams >= MAX_STREAMS)
1980         return NULL;
1981
1982     st = av_mallocz(sizeof(AVStream));
1983     if (!st)
1984         return NULL;
1985
1986     st->codec= avcodec_alloc_context();
1987     if (s->iformat) {
1988         /* no default bitrate if decoding */
1989         st->codec->bit_rate = 0;
1990     }
1991     st->index = s->nb_streams;
1992     st->id = id;
1993     st->start_time = AV_NOPTS_VALUE;
1994     st->duration = AV_NOPTS_VALUE;
1995     st->cur_dts = AV_NOPTS_VALUE;
1996
1997     /* default pts settings is MPEG like */
1998     av_set_pts_info(st, 33, 1, 90000);
1999     st->last_IP_pts = AV_NOPTS_VALUE;
2000     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2001         st->pts_buffer[i]= AV_NOPTS_VALUE;
2002
2003     s->streams[s->nb_streams++] = st;
2004     return st;
2005 }
2006
2007 /************************************************************/
2008 /* output media file */
2009
2010 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2011 {
2012     int ret;
2013
2014     if (s->oformat->priv_data_size > 0) {
2015         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2016         if (!s->priv_data)
2017             return AVERROR_NOMEM;
2018     } else
2019         s->priv_data = NULL;
2020
2021     if (s->oformat->set_parameters) {
2022         ret = s->oformat->set_parameters(s, ap);
2023         if (ret < 0)
2024             return ret;
2025     }
2026     return 0;
2027 }
2028
2029 int av_write_header(AVFormatContext *s)
2030 {
2031     int ret, i;
2032     AVStream *st;
2033
2034     // some sanity checks
2035     for(i=0;i<s->nb_streams;i++) {
2036         st = s->streams[i];
2037
2038         switch (st->codec->codec_type) {
2039         case CODEC_TYPE_AUDIO:
2040             if(st->codec->sample_rate<=0){
2041                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2042                 return -1;
2043             }
2044             break;
2045         case CODEC_TYPE_VIDEO:
2046             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2047                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2048                 return -1;
2049             }
2050             if(st->codec->width<=0 || st->codec->height<=0){
2051                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2052                 return -1;
2053             }
2054             break;
2055         }
2056
2057         if(s->oformat->codec_tag){
2058             if(st->codec->codec_tag){
2059                 //FIXME
2060                 //check that tag + id is in the table
2061                 //if neither is in the table -> ok
2062                 //if tag is in the table with another id -> FAIL
2063                 //if id is in the table with another tag -> FAIL unless strict < ?
2064             }else
2065                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2066         }
2067     }
2068
2069     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2070         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2071         if (!s->priv_data)
2072             return AVERROR_NOMEM;
2073     }
2074
2075     if(s->oformat->write_header){
2076         ret = s->oformat->write_header(s);
2077         if (ret < 0)
2078             return ret;
2079     }
2080
2081     /* init PTS generation */
2082     for(i=0;i<s->nb_streams;i++) {
2083         int64_t den = AV_NOPTS_VALUE;
2084         st = s->streams[i];
2085
2086         switch (st->codec->codec_type) {
2087         case CODEC_TYPE_AUDIO:
2088             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2089             break;
2090         case CODEC_TYPE_VIDEO:
2091             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2092             break;
2093         default:
2094             break;
2095         }
2096         if (den != AV_NOPTS_VALUE) {
2097             if (den <= 0)
2098                 return AVERROR_INVALIDDATA;
2099             av_frac_init(&st->pts, 0, 0, den);
2100         }
2101     }
2102     return 0;
2103 }
2104
2105 //FIXME merge with compute_pkt_fields
2106 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2107     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2108     int num, den, frame_size, i;
2109
2110 //    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);
2111
2112 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2113         return -1;*/
2114
2115     /* duration field */
2116     if (pkt->duration == 0) {
2117         compute_frame_duration(&num, &den, st, NULL, pkt);
2118         if (den && num) {
2119             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2120         }
2121     }
2122
2123     //XXX/FIXME this is a temporary hack until all encoders output pts
2124     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2125         pkt->dts=
2126 //        pkt->pts= st->cur_dts;
2127         pkt->pts= st->pts.val;
2128     }
2129
2130     //calculate dts from pts
2131     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2132         st->pts_buffer[0]= pkt->pts;
2133         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2134             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2135         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2136             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2137
2138         pkt->dts= st->pts_buffer[0];
2139     }
2140
2141     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2142         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2143         return -1;
2144     }
2145     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2146         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2147         return -1;
2148     }
2149
2150 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2151     st->cur_dts= pkt->dts;
2152     st->pts.val= pkt->dts;
2153
2154     /* update pts */
2155     switch (st->codec->codec_type) {
2156     case CODEC_TYPE_AUDIO:
2157         frame_size = get_audio_frame_size(st->codec, pkt->size);
2158
2159         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2160            but it would be better if we had the real timestamps from the encoder */
2161         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2162             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2163         }
2164         break;
2165     case CODEC_TYPE_VIDEO:
2166         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2167         break;
2168     default:
2169         break;
2170     }
2171     return 0;
2172 }
2173
2174 static void truncate_ts(AVStream *st, AVPacket *pkt){
2175     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2176
2177 //    if(pkt->dts < 0)
2178 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2179
2180     if (pkt->pts != AV_NOPTS_VALUE)
2181         pkt->pts &= pts_mask;
2182     if (pkt->dts != AV_NOPTS_VALUE)
2183         pkt->dts &= pts_mask;
2184 }
2185
2186 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2187 {
2188     int ret;
2189
2190     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2191     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2192         return ret;
2193
2194     truncate_ts(s->streams[pkt->stream_index], pkt);
2195
2196     ret= s->oformat->write_packet(s, pkt);
2197     if(!ret)
2198         ret= url_ferror(&s->pb);
2199     return ret;
2200 }
2201
2202 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2203     AVPacketList *pktl, **next_point, *this_pktl;
2204     int stream_count=0;
2205     int streams[MAX_STREAMS];
2206
2207     if(pkt){
2208         AVStream *st= s->streams[ pkt->stream_index];
2209
2210 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2211
2212         this_pktl = av_mallocz(sizeof(AVPacketList));
2213         this_pktl->pkt= *pkt;
2214         if(pkt->destruct == av_destruct_packet)
2215             pkt->destruct= NULL; // non shared -> must keep original from being freed
2216         else
2217             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2218
2219         next_point = &s->packet_buffer;
2220         while(*next_point){
2221             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2222             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2223             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2224             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2225                 break;
2226             next_point= &(*next_point)->next;
2227         }
2228         this_pktl->next= *next_point;
2229         *next_point= this_pktl;
2230     }
2231
2232     memset(streams, 0, sizeof(streams));
2233     pktl= s->packet_buffer;
2234     while(pktl){
2235 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2236         if(streams[ pktl->pkt.stream_index ] == 0)
2237             stream_count++;
2238         streams[ pktl->pkt.stream_index ]++;
2239         pktl= pktl->next;
2240     }
2241
2242     if(s->nb_streams == stream_count || (flush && stream_count)){
2243         pktl= s->packet_buffer;
2244         *out= pktl->pkt;
2245
2246         s->packet_buffer= pktl->next;
2247         av_freep(&pktl);
2248         return 1;
2249     }else{
2250         av_init_packet(out);
2251         return 0;
2252     }
2253 }
2254
2255 /**
2256  * Interleaves a AVPacket correctly so it can be muxed.
2257  * @param out the interleaved packet will be output here
2258  * @param in the input packet
2259  * @param flush 1 if no further packets are available as input and all
2260  *              remaining packets should be output
2261  * @return 1 if a packet was output, 0 if no packet could be output,
2262  *         < 0 if an error occured
2263  */
2264 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2265     if(s->oformat->interleave_packet)
2266         return s->oformat->interleave_packet(s, out, in, flush);
2267     else
2268         return av_interleave_packet_per_dts(s, out, in, flush);
2269 }
2270
2271 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2272     AVStream *st= s->streams[ pkt->stream_index];
2273
2274     //FIXME/XXX/HACK drop zero sized packets
2275     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2276         return 0;
2277
2278 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2279     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2280         return -1;
2281
2282     if(pkt->dts == AV_NOPTS_VALUE)
2283         return -1;
2284
2285     for(;;){
2286         AVPacket opkt;
2287         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2288         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2289             return ret;
2290
2291         truncate_ts(s->streams[opkt.stream_index], &opkt);
2292         ret= s->oformat->write_packet(s, &opkt);
2293
2294         av_free_packet(&opkt);
2295         pkt= NULL;
2296
2297         if(ret<0)
2298             return ret;
2299         if(url_ferror(&s->pb))
2300             return url_ferror(&s->pb);
2301     }
2302 }
2303
2304 int av_write_trailer(AVFormatContext *s)
2305 {
2306     int ret, i;
2307
2308     for(;;){
2309         AVPacket pkt;
2310         ret= av_interleave_packet(s, &pkt, NULL, 1);
2311         if(ret<0) //FIXME cleanup needed for ret<0 ?
2312             goto fail;
2313         if(!ret)
2314             break;
2315
2316         truncate_ts(s->streams[pkt.stream_index], &pkt);
2317         ret= s->oformat->write_packet(s, &pkt);
2318
2319         av_free_packet(&pkt);
2320
2321         if(ret<0)
2322             goto fail;
2323         if(url_ferror(&s->pb))
2324             goto fail;
2325     }
2326
2327     if(s->oformat->write_trailer)
2328         ret = s->oformat->write_trailer(s);
2329 fail:
2330     if(ret == 0)
2331        ret=url_ferror(&s->pb);
2332     for(i=0;i<s->nb_streams;i++)
2333         av_freep(&s->streams[i]->priv_data);
2334     av_freep(&s->priv_data);
2335     return ret;
2336 }
2337
2338 /* "user interface" functions */
2339
2340 void dump_format(AVFormatContext *ic,
2341                  int index,
2342                  const char *url,
2343                  int is_output)
2344 {
2345     int i, flags;
2346     char buf[256];
2347
2348     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2349             is_output ? "Output" : "Input",
2350             index,
2351             is_output ? ic->oformat->name : ic->iformat->name,
2352             is_output ? "to" : "from", url);
2353     if (!is_output) {
2354         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2355         if (ic->duration != AV_NOPTS_VALUE) {
2356             int hours, mins, secs, us;
2357             secs = ic->duration / AV_TIME_BASE;
2358             us = ic->duration % AV_TIME_BASE;
2359             mins = secs / 60;
2360             secs %= 60;
2361             hours = mins / 60;
2362             mins %= 60;
2363             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2364                    (10 * us) / AV_TIME_BASE);
2365         } else {
2366             av_log(NULL, AV_LOG_INFO, "N/A");
2367         }
2368         if (ic->start_time != AV_NOPTS_VALUE) {
2369             int secs, us;
2370             av_log(NULL, AV_LOG_INFO, ", start: ");
2371             secs = ic->start_time / AV_TIME_BASE;
2372             us = ic->start_time % AV_TIME_BASE;
2373             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2374                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2375         }
2376         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2377         if (ic->bit_rate) {
2378             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2379         } else {
2380             av_log(NULL, AV_LOG_INFO, "N/A");
2381         }
2382         av_log(NULL, AV_LOG_INFO, "\n");
2383     }
2384     for(i=0;i<ic->nb_streams;i++) {
2385         AVStream *st = ic->streams[i];
2386         int g= ff_gcd(st->time_base.num, st->time_base.den);
2387         avcodec_string(buf, sizeof(buf), st->codec, is_output);
2388         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2389         /* the pid is an important information, so we display it */
2390         /* XXX: add a generic system */
2391         if (is_output)
2392             flags = ic->oformat->flags;
2393         else
2394             flags = ic->iformat->flags;
2395         if (flags & AVFMT_SHOW_IDS) {
2396             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2397         }
2398         if (strlen(st->language) > 0) {
2399             av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2400         }
2401         av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2402         av_log(NULL, AV_LOG_INFO, ": %s", buf);
2403         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2404             if(st->r_frame_rate.den && st->r_frame_rate.num)
2405                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2406 /*            else if(st->time_base.den && st->time_base.num)
2407                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2408             else
2409                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2410         }
2411         av_log(NULL, AV_LOG_INFO, "\n");
2412     }
2413 }
2414
2415 typedef struct {
2416     const char *abv;
2417     int width, height;
2418     int frame_rate, frame_rate_base;
2419 } AbvEntry;
2420
2421 static AbvEntry frame_abvs[] = {
2422     { "ntsc",      720, 480, 30000, 1001 },
2423     { "pal",       720, 576,    25,    1 },
2424     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2425     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2426     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2427     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2428     { "film",      352, 240,    24,    1 },
2429     { "ntsc-film", 352, 240, 24000, 1001 },
2430     { "sqcif",     128,  96,     0,    0 },
2431     { "qcif",      176, 144,     0,    0 },
2432     { "cif",       352, 288,     0,    0 },
2433     { "4cif",      704, 576,     0,    0 },
2434 };
2435
2436 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2437 {
2438     int i;
2439     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2440     const char *p;
2441     int frame_width = 0, frame_height = 0;
2442
2443     for(i=0;i<n;i++) {
2444         if (!strcmp(frame_abvs[i].abv, str)) {
2445             frame_width = frame_abvs[i].width;
2446             frame_height = frame_abvs[i].height;
2447             break;
2448         }
2449     }
2450     if (i == n) {
2451         p = str;
2452         frame_width = strtol(p, (char **)&p, 10);
2453         if (*p)
2454             p++;
2455         frame_height = strtol(p, (char **)&p, 10);
2456     }
2457     if (frame_width <= 0 || frame_height <= 0)
2458         return -1;
2459     *width_ptr = frame_width;
2460     *height_ptr = frame_height;
2461     return 0;
2462 }
2463
2464 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2465 {
2466     int i;
2467     char* cp;
2468
2469     /* First, we check our abbreviation table */
2470     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2471          if (!strcmp(frame_abvs[i].abv, arg)) {
2472              *frame_rate = frame_abvs[i].frame_rate;
2473              *frame_rate_base = frame_abvs[i].frame_rate_base;
2474              return 0;
2475          }
2476
2477     /* Then, we try to parse it as fraction */
2478     cp = strchr(arg, '/');
2479     if (!cp)
2480         cp = strchr(arg, ':');
2481     if (cp) {
2482         char* cpp;
2483         *frame_rate = strtol(arg, &cpp, 10);
2484         if (cpp != arg || cpp == cp)
2485             *frame_rate_base = strtol(cp+1, &cpp, 10);
2486         else
2487            *frame_rate = 0;
2488     }
2489     else {
2490         /* Finally we give up and parse it as double */
2491         AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2492         *frame_rate_base = time_base.den;
2493         *frame_rate = time_base.num;
2494     }
2495     if (!*frame_rate || !*frame_rate_base)
2496         return -1;
2497     else
2498         return 0;
2499 }
2500
2501 #ifndef CONFIG_WINCE
2502 int64_t parse_date(const char *datestr, int duration)
2503 {
2504     const char *p;
2505     int64_t t;
2506     struct tm dt;
2507     int i;
2508     static const char *date_fmt[] = {
2509         "%Y-%m-%d",
2510         "%Y%m%d",
2511     };
2512     static const char *time_fmt[] = {
2513         "%H:%M:%S",
2514         "%H%M%S",
2515     };
2516     const char *q;
2517     int is_utc, len;
2518     char lastch;
2519     int negative = 0;
2520
2521 #undef time
2522     time_t now = time(0);
2523
2524     len = strlen(datestr);
2525     if (len > 0)
2526         lastch = datestr[len - 1];
2527     else
2528         lastch = '\0';
2529     is_utc = (lastch == 'z' || lastch == 'Z');
2530
2531     memset(&dt, 0, sizeof(dt));
2532
2533     p = datestr;
2534     q = NULL;
2535     if (!duration) {
2536         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2537             q = small_strptime(p, date_fmt[i], &dt);
2538             if (q) {
2539                 break;
2540             }
2541         }
2542
2543         if (!q) {
2544             if (is_utc) {
2545                 dt = *gmtime(&now);
2546             } else {
2547                 dt = *localtime(&now);
2548             }
2549             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2550         } else {
2551             p = q;
2552         }
2553
2554         if (*p == 'T' || *p == 't' || *p == ' ')
2555             p++;
2556
2557         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2558             q = small_strptime(p, time_fmt[i], &dt);
2559             if (q) {
2560                 break;
2561             }
2562         }
2563     } else {
2564         if (p[0] == '-') {
2565             negative = 1;
2566             ++p;
2567         }
2568         q = small_strptime(p, time_fmt[0], &dt);
2569         if (!q) {
2570             dt.tm_sec = strtol(p, (char **)&q, 10);
2571             dt.tm_min = 0;
2572             dt.tm_hour = 0;
2573         }
2574     }
2575
2576     /* Now we have all the fields that we can get */
2577     if (!q) {
2578         if (duration)
2579             return 0;
2580         else
2581             return now * INT64_C(1000000);
2582     }
2583
2584     if (duration) {
2585         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2586     } else {
2587         dt.tm_isdst = -1;       /* unknown */
2588         if (is_utc) {
2589             t = mktimegm(&dt);
2590         } else {
2591             t = mktime(&dt);
2592         }
2593     }
2594
2595     t *= 1000000;
2596
2597     if (*q == '.') {
2598         int val, n;
2599         q++;
2600         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2601             if (!isdigit(*q))
2602                 break;
2603             val += n * (*q - '0');
2604         }
2605         t += val;
2606     }
2607     return negative ? -t : t;
2608 }
2609 #endif /* CONFIG_WINCE */
2610
2611 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2612 {
2613     const char *p;
2614     char tag[128], *q;
2615
2616     p = info;
2617     if (*p == '?')
2618         p++;
2619     for(;;) {
2620         q = tag;
2621         while (*p != '\0' && *p != '=' && *p != '&') {
2622             if ((q - tag) < sizeof(tag) - 1)
2623                 *q++ = *p;
2624             p++;
2625         }
2626         *q = '\0';
2627         q = arg;
2628         if (*p == '=') {
2629             p++;
2630             while (*p != '&' && *p != '\0') {
2631                 if ((q - arg) < arg_size - 1) {
2632                     if (*p == '+')
2633                         *q++ = ' ';
2634                     else
2635                         *q++ = *p;
2636                 }
2637                 p++;
2638             }
2639             *q = '\0';
2640         }
2641         if (!strcmp(tag, tag1))
2642             return 1;
2643         if (*p != '&')
2644             break;
2645         p++;
2646     }
2647     return 0;
2648 }
2649
2650 int av_get_frame_filename(char *buf, int buf_size,
2651                           const char *path, int number)
2652 {
2653     const char *p;
2654     char *q, buf1[20], c;
2655     int nd, len, percentd_found;
2656
2657     q = buf;
2658     p = path;
2659     percentd_found = 0;
2660     for(;;) {
2661         c = *p++;
2662         if (c == '\0')
2663             break;
2664         if (c == '%') {
2665             do {
2666                 nd = 0;
2667                 while (isdigit(*p)) {
2668                     nd = nd * 10 + *p++ - '0';
2669                 }
2670                 c = *p++;
2671             } while (isdigit(c));
2672
2673             switch(c) {
2674             case '%':
2675                 goto addchar;
2676             case 'd':
2677                 if (percentd_found)
2678                     goto fail;
2679                 percentd_found = 1;
2680                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2681                 len = strlen(buf1);
2682                 if ((q - buf + len) > buf_size - 1)
2683                     goto fail;
2684                 memcpy(q, buf1, len);
2685                 q += len;
2686                 break;
2687             default:
2688                 goto fail;
2689             }
2690         } else {
2691         addchar:
2692             if ((q - buf) < buf_size - 1)
2693                 *q++ = c;
2694         }
2695     }
2696     if (!percentd_found)
2697         goto fail;
2698     *q = '\0';
2699     return 0;
2700  fail:
2701     *q = '\0';
2702     return -1;
2703 }
2704
2705 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2706 {
2707     int len, i, j, c;
2708 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2709
2710     for(i=0;i<size;i+=16) {
2711         len = size - i;
2712         if (len > 16)
2713             len = 16;
2714         PRINT("%08x ", i);
2715         for(j=0;j<16;j++) {
2716             if (j < len)
2717                 PRINT(" %02x", buf[i+j]);
2718             else
2719                 PRINT("   ");
2720         }
2721         PRINT(" ");
2722         for(j=0;j<len;j++) {
2723             c = buf[i+j];
2724             if (c < ' ' || c > '~')
2725                 c = '.';
2726             PRINT("%c", c);
2727         }
2728         PRINT("\n");
2729     }
2730 #undef PRINT
2731 }
2732
2733 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2734 {
2735     hex_dump_internal(NULL, f, 0, buf, size);
2736 }
2737
2738 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2739 {
2740     hex_dump_internal(avcl, NULL, level, buf, size);
2741 }
2742
2743  //FIXME needs to know the time_base
2744 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2745 {
2746 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2747     PRINT("stream #%d:\n", pkt->stream_index);
2748     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2749     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2750     /* DTS is _always_ valid after av_read_frame() */
2751     PRINT("  dts=");
2752     if (pkt->dts == AV_NOPTS_VALUE)
2753         PRINT("N/A");
2754     else
2755         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2756     /* PTS may be not known if B frames are present */
2757     PRINT("  pts=");
2758     if (pkt->pts == AV_NOPTS_VALUE)
2759         PRINT("N/A");
2760     else
2761         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2762     PRINT("\n");
2763     PRINT("  size=%d\n", pkt->size);
2764 #undef PRINT
2765     if (dump_payload)
2766         av_hex_dump(f, pkt->data, pkt->size);
2767 }
2768
2769 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2770 {
2771     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2772 }
2773
2774 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2775 {
2776     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2777 }
2778
2779 void url_split(char *proto, int proto_size,
2780                char *authorization, int authorization_size,
2781                char *hostname, int hostname_size,
2782                int *port_ptr,
2783                char *path, int path_size,
2784                const char *url)
2785 {
2786     const char *p;
2787     char *q;
2788     int port;
2789
2790     port = -1;
2791
2792     p = url;
2793     q = proto;
2794     while (*p != ':' && *p != '\0') {
2795         if ((q - proto) < proto_size - 1)
2796             *q++ = *p;
2797         p++;
2798     }
2799     if (proto_size > 0)
2800         *q = '\0';
2801     if (authorization_size > 0)
2802         authorization[0] = '\0';
2803     if (*p == '\0') {
2804         if (proto_size > 0)
2805             proto[0] = '\0';
2806         if (hostname_size > 0)
2807             hostname[0] = '\0';
2808         p = url;
2809     } else {
2810         char *at,*slash; // PETR: position of '@' character and '/' character
2811
2812         p++;
2813         if (*p == '/')
2814             p++;
2815         if (*p == '/')
2816             p++;
2817         at = strchr(p,'@'); // PETR: get the position of '@'
2818         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2819         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2820
2821         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2822
2823          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2824             if (*p == '@') {    // PETR: passed '@'
2825               if (authorization_size > 0)
2826                   *q = '\0';
2827               q = hostname;
2828               at = NULL;
2829             } else if (!at) {   // PETR: hostname
2830               if ((q - hostname) < hostname_size - 1)
2831                   *q++ = *p;
2832             } else {
2833               if ((q - authorization) < authorization_size - 1)
2834                 *q++ = *p;
2835             }
2836             p++;
2837         }
2838         if (hostname_size > 0)
2839             *q = '\0';
2840         if (*p == ':') {
2841             p++;
2842             port = strtoul(p, (char **)&p, 10);
2843         }
2844     }
2845     if (port_ptr)
2846         *port_ptr = port;
2847     pstrcpy(path, path_size, p);
2848 }
2849
2850 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2851                      int pts_num, int pts_den)
2852 {
2853     s->pts_wrap_bits = pts_wrap_bits;
2854     s->time_base.num = pts_num;
2855     s->time_base.den = pts_den;
2856 }
2857
2858 /* fraction handling */
2859
2860 /**
2861  * f = val + (num / den) + 0.5.
2862  *
2863  * 'num' is normalized so that it is such as 0 <= num < den.
2864  *
2865  * @param f fractional number
2866  * @param val integer value
2867  * @param num must be >= 0
2868  * @param den must be >= 1
2869  */
2870 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2871 {
2872     num += (den >> 1);
2873     if (num >= den) {
2874         val += num / den;
2875         num = num % den;
2876     }
2877     f->val = val;
2878     f->num = num;
2879     f->den = den;
2880 }
2881
2882 /**
2883  * Fractionnal addition to f: f = f + (incr / f->den).
2884  *
2885  * @param f fractional number
2886  * @param incr increment, can be positive or negative
2887  */
2888 static void av_frac_add(AVFrac *f, int64_t incr)
2889 {
2890     int64_t num, den;
2891
2892     num = f->num + incr;
2893     den = f->den;
2894     if (num < 0) {
2895         f->val += num / den;
2896         num = num % den;
2897         if (num < 0) {
2898             num += den;
2899             f->val--;
2900         }
2901     } else if (num >= den) {
2902         f->val += num / den;
2903         num = num % den;
2904     }
2905     f->num = num;
2906 }