libavformat/utils.c

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