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