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