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