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