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, int64_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, int64_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     int64_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             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2461                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2462                 return -1;
2463             }
2464             break;
2465         }
2466
2467         if(s->oformat->codec_tag){
2468             if(st->codec->codec_tag){
2469                 //FIXME
2470                 //check that tag + id is in the table
2471                 //if neither is in the table -> OK
2472                 //if tag is in the table with another id -> FAIL
2473                 //if id is in the table with another tag -> FAIL unless strict < ?
2474             }else
2475                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2476         }
2477     }
2478
2479     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2480         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2481         if (!s->priv_data)
2482             return AVERROR(ENOMEM);
2483     }
2484
2485     if(s->oformat->write_header){
2486         ret = s->oformat->write_header(s);
2487         if (ret < 0)
2488             return ret;
2489     }
2490
2491     /* init PTS generation */
2492     for(i=0;i<s->nb_streams;i++) {
2493         int64_t den = AV_NOPTS_VALUE;
2494         st = s->streams[i];
2495
2496         switch (st->codec->codec_type) {
2497         case CODEC_TYPE_AUDIO:
2498             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2499             break;
2500         case CODEC_TYPE_VIDEO:
2501             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2502             break;
2503         default:
2504             break;
2505         }
2506         if (den != AV_NOPTS_VALUE) {
2507             if (den <= 0)
2508                 return AVERROR_INVALIDDATA;
2509             av_frac_init(&st->pts, 0, 0, den);
2510         }
2511     }
2512     return 0;
2513 }
2514
2515 //FIXME merge with compute_pkt_fields
2516 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2517     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2518     int num, den, frame_size, i;
2519
2520 //    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);
2521
2522 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2523         return -1;*/
2524
2525     /* duration field */
2526     if (pkt->duration == 0) {
2527         compute_frame_duration(&num, &den, st, NULL, pkt);
2528         if (den && num) {
2529             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2530         }
2531     }
2532
2533     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2534         pkt->pts= pkt->dts;
2535
2536     //XXX/FIXME this is a temporary hack until all encoders output pts
2537     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2538         pkt->dts=
2539 //        pkt->pts= st->cur_dts;
2540         pkt->pts= st->pts.val;
2541     }
2542
2543     //calculate dts from pts
2544     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2545         st->pts_buffer[0]= pkt->pts;
2546         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2547             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2548         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2549             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2550
2551         pkt->dts= st->pts_buffer[0];
2552     }
2553
2554     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2555         av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2556         return -1;
2557     }
2558     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2559         av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2560         return -1;
2561     }
2562
2563 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2564     st->cur_dts= pkt->dts;
2565     st->pts.val= pkt->dts;
2566
2567     /* update pts */
2568     switch (st->codec->codec_type) {
2569     case CODEC_TYPE_AUDIO:
2570         frame_size = get_audio_frame_size(st->codec, pkt->size);
2571
2572         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2573            likely equal to the encoder delay, but it would be better if we
2574            had the real timestamps from the encoder */
2575         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2576             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2577         }
2578         break;
2579     case CODEC_TYPE_VIDEO:
2580         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2581         break;
2582     default:
2583         break;
2584     }
2585     return 0;
2586 }
2587
2588 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2589 {
2590     int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2591
2592     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2593         return ret;
2594
2595     ret= s->oformat->write_packet(s, pkt);
2596     if(!ret)
2597         ret= url_ferror(s->pb);
2598     return ret;
2599 }
2600
2601 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2602     AVPacketList *pktl, **next_point, *this_pktl;
2603     int stream_count=0;
2604     int streams[MAX_STREAMS];
2605
2606     if(pkt){
2607         AVStream *st= s->streams[ pkt->stream_index];
2608
2609 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2610
2611         this_pktl = av_mallocz(sizeof(AVPacketList));
2612         this_pktl->pkt= *pkt;
2613         if(pkt->destruct == av_destruct_packet)
2614             pkt->destruct= NULL; // not shared -> must keep original from being freed
2615         else
2616             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2617
2618         next_point = &s->packet_buffer;
2619         while(*next_point){
2620             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2621             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2622             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2623             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2624                 break;
2625             next_point= &(*next_point)->next;
2626         }
2627         this_pktl->next= *next_point;
2628         *next_point= this_pktl;
2629     }
2630
2631     memset(streams, 0, sizeof(streams));
2632     pktl= s->packet_buffer;
2633     while(pktl){
2634 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2635         if(streams[ pktl->pkt.stream_index ] == 0)
2636             stream_count++;
2637         streams[ pktl->pkt.stream_index ]++;
2638         pktl= pktl->next;
2639     }
2640
2641     if(stream_count && (s->nb_streams == stream_count || flush)){
2642         pktl= s->packet_buffer;
2643         *out= pktl->pkt;
2644
2645         s->packet_buffer= pktl->next;
2646         av_freep(&pktl);
2647         return 1;
2648     }else{
2649         av_init_packet(out);
2650         return 0;
2651     }
2652 }
2653
2654 /**
2655  * Interleaves an AVPacket correctly so it can be muxed.
2656  * @param out the interleaved packet will be output here
2657  * @param in the input packet
2658  * @param flush 1 if no further packets are available as input and all
2659  *              remaining packets should be output
2660  * @return 1 if a packet was output, 0 if no packet could be output,
2661  *         < 0 if an error occurred
2662  */
2663 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2664     if(s->oformat->interleave_packet)
2665         return s->oformat->interleave_packet(s, out, in, flush);
2666     else
2667         return av_interleave_packet_per_dts(s, out, in, flush);
2668 }
2669
2670 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2671     AVStream *st= s->streams[ pkt->stream_index];
2672
2673     //FIXME/XXX/HACK drop zero sized packets
2674     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2675         return 0;
2676
2677 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2678     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2679         return -1;
2680
2681     if(pkt->dts == AV_NOPTS_VALUE)
2682         return -1;
2683
2684     for(;;){
2685         AVPacket opkt;
2686         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2687         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2688             return ret;
2689
2690         ret= s->oformat->write_packet(s, &opkt);
2691
2692         av_free_packet(&opkt);
2693         pkt= NULL;
2694
2695         if(ret<0)
2696             return ret;
2697         if(url_ferror(s->pb))
2698             return url_ferror(s->pb);
2699     }
2700 }
2701
2702 int av_write_trailer(AVFormatContext *s)
2703 {
2704     int ret, i;
2705
2706     for(;;){
2707         AVPacket pkt;
2708         ret= av_interleave_packet(s, &pkt, NULL, 1);
2709         if(ret<0) //FIXME cleanup needed for ret<0 ?
2710             goto fail;
2711         if(!ret)
2712             break;
2713
2714         ret= s->oformat->write_packet(s, &pkt);
2715
2716         av_free_packet(&pkt);
2717
2718         if(ret<0)
2719             goto fail;
2720         if(url_ferror(s->pb))
2721             goto fail;
2722     }
2723
2724     if(s->oformat->write_trailer)
2725         ret = s->oformat->write_trailer(s);
2726 fail:
2727     if(ret == 0)
2728        ret=url_ferror(s->pb);
2729     for(i=0;i<s->nb_streams;i++)
2730         av_freep(&s->streams[i]->priv_data);
2731     av_freep(&s->priv_data);
2732     return ret;
2733 }
2734
2735 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2736 {
2737     int i, j;
2738     AVProgram *program=NULL;
2739     void *tmp;
2740
2741     for(i=0; i<ac->nb_programs; i++){
2742         if(ac->programs[i]->id != progid)
2743             continue;
2744         program = ac->programs[i];
2745         for(j=0; j<program->nb_stream_indexes; j++)
2746             if(program->stream_index[j] == idx)
2747                 return;
2748
2749         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2750         if(!tmp)
2751             return;
2752         program->stream_index = tmp;
2753         program->stream_index[program->nb_stream_indexes++] = idx;
2754         return;
2755     }
2756 }
2757
2758 /* "user interface" functions */
2759 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2760 {
2761     char buf[256];
2762     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2763     AVStream *st = ic->streams[i];
2764     int g = ff_gcd(st->time_base.num, st->time_base.den);
2765     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2766     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2767     /* the pid is an important information, so we display it */
2768     /* XXX: add a generic system */
2769     if (flags & AVFMT_SHOW_IDS)
2770         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2771     if (strlen(st->language) > 0)
2772         av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2773     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2774     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2775     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2776         if(st->r_frame_rate.den && st->r_frame_rate.num)
2777             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2778 /*      else if(st->time_base.den && st->time_base.num)
2779             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2780         else
2781             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2782     }
2783     av_log(NULL, AV_LOG_INFO, "\n");
2784 }
2785
2786 void dump_format(AVFormatContext *ic,
2787                  int index,
2788                  const char *url,
2789                  int is_output)
2790 {
2791     int i;
2792
2793     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2794             is_output ? "Output" : "Input",
2795             index,
2796             is_output ? ic->oformat->name : ic->iformat->name,
2797             is_output ? "to" : "from", url);
2798     if (!is_output) {
2799         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2800         if (ic->duration != AV_NOPTS_VALUE) {
2801             int hours, mins, secs, us;
2802             secs = ic->duration / AV_TIME_BASE;
2803             us = ic->duration % AV_TIME_BASE;
2804             mins = secs / 60;
2805             secs %= 60;
2806             hours = mins / 60;
2807             mins %= 60;
2808             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2809                    (100 * us) / AV_TIME_BASE);
2810         } else {
2811             av_log(NULL, AV_LOG_INFO, "N/A");
2812         }
2813         if (ic->start_time != AV_NOPTS_VALUE) {
2814             int secs, us;
2815             av_log(NULL, AV_LOG_INFO, ", start: ");
2816             secs = ic->start_time / AV_TIME_BASE;
2817             us = ic->start_time % AV_TIME_BASE;
2818             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2819                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2820         }
2821         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2822         if (ic->bit_rate) {
2823             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2824         } else {
2825             av_log(NULL, AV_LOG_INFO, "N/A");
2826         }
2827         av_log(NULL, AV_LOG_INFO, "\n");
2828     }
2829     if(ic->nb_programs) {
2830         int j, k;
2831         for(j=0; j<ic->nb_programs; j++) {
2832             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2833                    ic->programs[j]->name ? ic->programs[j]->name : "");
2834             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2835                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2836          }
2837     } else
2838     for(i=0;i<ic->nb_streams;i++)
2839         dump_stream_format(ic, i, index, is_output);
2840 }
2841
2842 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2843 {
2844     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2845 }
2846
2847 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2848 {
2849     AVRational frame_rate;
2850     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2851     *frame_rate_num= frame_rate.num;
2852     *frame_rate_den= frame_rate.den;
2853     return ret;
2854 }
2855
2856 int64_t av_gettime(void)
2857 {
2858     struct timeval tv;
2859     gettimeofday(&tv,NULL);
2860     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2861 }
2862
2863 int64_t parse_date(const char *datestr, int duration)
2864 {
2865     const char *p;
2866     int64_t t;
2867     struct tm dt;
2868     int i;
2869     static const char * const date_fmt[] = {
2870         "%Y-%m-%d",
2871         "%Y%m%d",
2872     };
2873     static const char * const time_fmt[] = {
2874         "%H:%M:%S",
2875         "%H%M%S",
2876     };
2877     const char *q;
2878     int is_utc, len;
2879     char lastch;
2880     int negative = 0;
2881
2882 #undef time
2883     time_t now = time(0);
2884
2885     len = strlen(datestr);
2886     if (len > 0)
2887         lastch = datestr[len - 1];
2888     else
2889         lastch = '\0';
2890     is_utc = (lastch == 'z' || lastch == 'Z');
2891
2892     memset(&dt, 0, sizeof(dt));
2893
2894     p = datestr;
2895     q = NULL;
2896     if (!duration) {
2897         /* parse the year-month-day part */
2898         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2899             q = small_strptime(p, date_fmt[i], &dt);
2900             if (q) {
2901                 break;
2902             }
2903         }
2904
2905         /* if the year-month-day part is missing, then take the
2906          * current year-month-day time */
2907         if (!q) {
2908             if (is_utc) {
2909                 dt = *gmtime(&now);
2910             } else {
2911                 dt = *localtime(&now);
2912             }
2913             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2914         } else {
2915             p = q;
2916         }
2917
2918         if (*p == 'T' || *p == 't' || *p == ' ')
2919             p++;
2920
2921         /* parse the hour-minute-second part */
2922         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2923             q = small_strptime(p, time_fmt[i], &dt);
2924             if (q) {
2925                 break;
2926             }
2927         }
2928     } else {
2929         /* parse datestr as a duration */
2930         if (p[0] == '-') {
2931             negative = 1;
2932             ++p;
2933         }
2934         /* parse datestr as HH:MM:SS */
2935         q = small_strptime(p, time_fmt[0], &dt);
2936         if (!q) {
2937             /* parse datestr as S+ */
2938             dt.tm_sec = strtol(p, (char **)&q, 10);
2939             if (q == p)
2940                 /* the parsing didn't succeed */
2941                 return INT64_MIN;
2942             dt.tm_min = 0;
2943             dt.tm_hour = 0;
2944         }
2945     }
2946
2947     /* Now we have all the fields that we can get */
2948     if (!q) {
2949         return INT64_MIN;
2950     }
2951
2952     if (duration) {
2953         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2954     } else {
2955         dt.tm_isdst = -1;       /* unknown */
2956         if (is_utc) {
2957             t = mktimegm(&dt);
2958         } else {
2959             t = mktime(&dt);
2960         }
2961     }
2962
2963     t *= 1000000;
2964
2965     /* parse the .m... part */
2966     if (*q == '.') {
2967         int val, n;
2968         q++;
2969         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2970             if (!isdigit(*q))
2971                 break;
2972             val += n * (*q - '0');
2973         }
2974         t += val;
2975     }
2976     return negative ? -t : t;
2977 }
2978
2979 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2980 {
2981     const char *p;
2982     char tag[128], *q;
2983
2984     p = info;
2985     if (*p == '?')
2986         p++;
2987     for(;;) {
2988         q = tag;
2989         while (*p != '\0' && *p != '=' && *p != '&') {
2990             if ((q - tag) < sizeof(tag) - 1)
2991                 *q++ = *p;
2992             p++;
2993         }
2994         *q = '\0';
2995         q = arg;
2996         if (*p == '=') {
2997             p++;
2998             while (*p != '&' && *p != '\0') {
2999                 if ((q - arg) < arg_size - 1) {
3000                     if (*p == '+')
3001                         *q++ = ' ';
3002                     else
3003                         *q++ = *p;
3004                 }
3005                 p++;
3006             }
3007             *q = '\0';
3008         }
3009         if (!strcmp(tag, tag1))
3010             return 1;
3011         if (*p != '&')
3012             break;
3013         p++;
3014     }
3015     return 0;
3016 }
3017
3018 int av_get_frame_filename(char *buf, int buf_size,
3019                           const char *path, int number)
3020 {
3021     const char *p;
3022     char *q, buf1[20], c;
3023     int nd, len, percentd_found;
3024
3025     q = buf;
3026     p = path;
3027     percentd_found = 0;
3028     for(;;) {
3029         c = *p++;
3030         if (c == '\0')
3031             break;
3032         if (c == '%') {
3033             do {
3034                 nd = 0;
3035                 while (isdigit(*p)) {
3036                     nd = nd * 10 + *p++ - '0';
3037                 }
3038                 c = *p++;
3039             } while (isdigit(c));
3040
3041             switch(c) {
3042             case '%':
3043                 goto addchar;
3044             case 'd':
3045                 if (percentd_found)
3046                     goto fail;
3047                 percentd_found = 1;
3048                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3049                 len = strlen(buf1);
3050                 if ((q - buf + len) > buf_size - 1)
3051                     goto fail;
3052                 memcpy(q, buf1, len);
3053                 q += len;
3054                 break;
3055             default:
3056                 goto fail;
3057             }
3058         } else {
3059         addchar:
3060             if ((q - buf) < buf_size - 1)
3061                 *q++ = c;
3062         }
3063     }
3064     if (!percentd_found)
3065         goto fail;
3066     *q = '\0';
3067     return 0;
3068  fail:
3069     *q = '\0';
3070     return -1;
3071 }
3072
3073 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3074 {
3075     int len, i, j, c;
3076 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3077
3078     for(i=0;i<size;i+=16) {
3079         len = size - i;
3080         if (len > 16)
3081             len = 16;
3082         PRINT("%08x ", i);
3083         for(j=0;j<16;j++) {
3084             if (j < len)
3085                 PRINT(" %02x", buf[i+j]);
3086             else
3087                 PRINT("   ");
3088         }
3089         PRINT(" ");
3090         for(j=0;j<len;j++) {
3091             c = buf[i+j];
3092             if (c < ' ' || c > '~')
3093                 c = '.';
3094             PRINT("%c", c);
3095         }
3096         PRINT("\n");
3097     }
3098 #undef PRINT
3099 }
3100
3101 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3102 {
3103     hex_dump_internal(NULL, f, 0, buf, size);
3104 }
3105
3106 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3107 {
3108     hex_dump_internal(avcl, NULL, level, buf, size);
3109 }
3110
3111  //FIXME needs to know the time_base
3112 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3113 {
3114 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3115     PRINT("stream #%d:\n", pkt->stream_index);
3116     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3117     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3118     /* DTS is _always_ valid after av_read_frame() */
3119     PRINT("  dts=");
3120     if (pkt->dts == AV_NOPTS_VALUE)
3121         PRINT("N/A");
3122     else
3123         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3124     /* PTS may not be known if B-frames are present. */
3125     PRINT("  pts=");
3126     if (pkt->pts == AV_NOPTS_VALUE)
3127         PRINT("N/A");
3128     else
3129         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3130     PRINT("\n");
3131     PRINT("  size=%d\n", pkt->size);
3132 #undef PRINT
3133     if (dump_payload)
3134         av_hex_dump(f, pkt->data, pkt->size);
3135 }
3136
3137 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3138 {
3139     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3140 }
3141
3142 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3143 {
3144     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3145 }
3146
3147 void url_split(char *proto, int proto_size,
3148                char *authorization, int authorization_size,
3149                char *hostname, int hostname_size,
3150                int *port_ptr,
3151                char *path, int path_size,
3152                const char *url)
3153 {
3154     const char *p, *ls, *at, *col, *brk;
3155
3156     if (port_ptr)               *port_ptr = -1;
3157     if (proto_size > 0)         proto[0] = 0;
3158     if (authorization_size > 0) authorization[0] = 0;
3159     if (hostname_size > 0)      hostname[0] = 0;
3160     if (path_size > 0)          path[0] = 0;
3161
3162     /* parse protocol */
3163     if ((p = strchr(url, ':'))) {
3164         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3165         p++; /* skip ':' */
3166         if (*p == '/') p++;
3167         if (*p == '/') p++;
3168     } else {
3169         /* no protocol means plain filename */
3170         av_strlcpy(path, url, path_size);
3171         return;
3172     }
3173
3174     /* separate path from hostname */
3175     ls = strchr(p, '/');
3176     if(!ls)
3177         ls = strchr(p, '?');
3178     if(ls)
3179         av_strlcpy(path, ls, path_size);
3180     else
3181         ls = &p[strlen(p)]; // XXX
3182
3183     /* the rest is hostname, use that to parse auth/port */
3184     if (ls != p) {
3185         /* authorization (user[:pass]@hostname) */
3186         if ((at = strchr(p, '@')) && at < ls) {
3187             av_strlcpy(authorization, p,
3188                        FFMIN(authorization_size, at + 1 - p));
3189             p = at + 1; /* skip '@' */
3190         }
3191
3192         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3193             /* [host]:port */
3194             av_strlcpy(hostname, p + 1,
3195                        FFMIN(hostname_size, brk - p));
3196             if (brk[1] == ':' && port_ptr)
3197                 *port_ptr = atoi(brk + 2);
3198         } else if ((col = strchr(p, ':')) && col < ls) {
3199             av_strlcpy(hostname, p,
3200                        FFMIN(col + 1 - p, hostname_size));
3201             if (port_ptr) *port_ptr = atoi(col + 1);
3202         } else
3203             av_strlcpy(hostname, p,
3204                        FFMIN(ls + 1 - p, hostname_size));
3205     }
3206 }
3207
3208 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3209 {
3210     int i;
3211     static const char hex_table[16] = { '0', '1', '2', '3',
3212                                         '4', '5', '6', '7',
3213                                         '8', '9', 'A', 'B',
3214                                         'C', 'D', 'E', 'F' };
3215
3216     for(i = 0; i < s; i++) {
3217         buff[i * 2]     = hex_table[src[i] >> 4];
3218         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3219     }
3220
3221     return buff;
3222 }
3223
3224 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3225                      int pts_num, int pts_den)
3226 {
3227     unsigned int gcd= ff_gcd(pts_num, pts_den);
3228     s->pts_wrap_bits = pts_wrap_bits;
3229     s->time_base.num = pts_num/gcd;
3230     s->time_base.den = pts_den/gcd;
3231
3232     if(gcd>1)
3233         av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3234 }