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

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