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