git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

   1 /*
   2  * Various utilities for ffmpeg system
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include "avformat.h"
  20
  21 #undef NDEBUG
  22 #include <assert.h>
  23
  24 AVInputFormat *first_iformat;
  25 AVOutputFormat *first_oformat;
  26 AVImageFormat *first_image_format;
  27
  28 void av_register_input_format(AVInputFormat *format)
  29 {
  30     AVInputFormat **p;
  31     p = &first_iformat;
  32     while (*p != NULL) p = &(*p)->next;
  33     *p = format;
  34     format->next = NULL;
  35 }
  36
  37 void av_register_output_format(AVOutputFormat *format)
  38 {
  39     AVOutputFormat **p;
  40     p = &first_oformat;
  41     while (*p != NULL) p = &(*p)->next;
  42     *p = format;
  43     format->next = NULL;
  44 }
  45
  46 int match_ext(const char *filename, const char *extensions)
  47 {
  48     const char *ext, *p;
  49     char ext1[32], *q;
  50
  51     ext = strrchr(filename, '.');
  52     if (ext) {
  53         ext++;
  54         p = extensions;
  55         for(;;) {
  56             q = ext1;
  57             while (*p != '\0' && *p != ',')
  58                 *q++ = *p++;
  59             *q = '\0';
  60             if (!strcasecmp(ext1, ext))
  61                 return 1;
  62             if (*p == '\0')
  63                 break;
  64             p++;
  65         }
  66     }
  67     return 0;
  68 }
  69
  70 AVOutputFormat *guess_format(const char *short_name, const char *filename,
  71                              const char *mime_type)
  72 {
  73     AVOutputFormat *fmt, *fmt_found;
  74     int score_max, score;
  75
  76     /* specific test for image sequences */
  77     if (!short_name && filename &&
  78         filename_number_test(filename) >= 0 &&
  79         guess_image_format(filename)) {
  80         return guess_format("image", NULL, NULL);
  81     }
  82
  83     /* find the proper file type */
  84     fmt_found = NULL;
  85     score_max = 0;
  86     fmt = first_oformat;
  87     while (fmt != NULL) {
  88         score = 0;
  89         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
  90             score += 100;
  91         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
  92             score += 10;
  93         if (filename && fmt->extensions &&
  94             match_ext(filename, fmt->extensions)) {
  95             score += 5;
  96         }
  97         if (score > score_max) {
  98             score_max = score;
  99             fmt_found = fmt;
 100         }
 101         fmt = fmt->next;
 102     }
 103     return fmt_found;
 104 }
 105
 106 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
 107                              const char *mime_type)
 108 {
 109     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
 110
 111     if (fmt) {
 112         AVOutputFormat *stream_fmt;
 113         char stream_format_name[64];
 114
 115         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 116         stream_fmt = guess_format(stream_format_name, NULL, NULL);
 117
 118         if (stream_fmt)
 119             fmt = stream_fmt;
 120     }
 121
 122     return fmt;
 123 }
 124
 125 AVInputFormat *av_find_input_format(const char *short_name)
 126 {
 127     AVInputFormat *fmt;
 128     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 129         if (!strcmp(fmt->name, short_name))
 130             return fmt;
 131     }
 132     return NULL;
 133 }
 134
 135 /* memory handling */
 136
 137 /**
 138  * Default packet destructor
 139  */
 140 static void av_destruct_packet(AVPacket *pkt)
 141 {
 142     av_free(pkt->data);
 143     pkt->data = NULL; pkt->size = 0;
 144 }
 145
 146 /**
 147  * Allocate the payload of a packet and intialized its fields to default values.
 148  *
 149  * @param pkt packet
 150  * @param size wanted payload size
 151  * @return 0 if OK. AVERROR_xxx otherwise.
 152  */
 153 int av_new_packet(AVPacket *pkt, int size)
 154 {
 155     void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 156     if (!data)
 157         return AVERROR_NOMEM;
 158     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 159
 160     av_init_packet(pkt);
 161     pkt->data = data;
 162     pkt->size = size;
 163     pkt->destruct = av_destruct_packet;
 164     return 0;
 165 }
 166
 167 /* This is a hack - the packet memory allocation stuff is broken. The
 168    packet is allocated if it was not really allocated */
 169 int av_dup_packet(AVPacket *pkt)
 170 {
 171     if (pkt->destruct != av_destruct_packet) {
 172         uint8_t *data;
 173         /* we duplicate the packet and don't forget to put the padding
 174            again */
 175         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
 176         if (!data) {
 177             return AVERROR_NOMEM;
 178         }
 179         memcpy(data, pkt->data, pkt->size);
 180         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 181         pkt->data = data;
 182         pkt->destruct = av_destruct_packet;
 183     }
 184     return 0;
 185 }
 186
 187 /* fifo handling */
 188
 189 int fifo_init(FifoBuffer *f, int size)
 190 {
 191     f->buffer = av_malloc(size);
 192     if (!f->buffer)
 193         return -1;
 194     f->end = f->buffer + size;
 195     f->wptr = f->rptr = f->buffer;
 196     return 0;
 197 }
 198
 199 void fifo_free(FifoBuffer *f)
 200 {
 201     av_free(f->buffer);
 202 }
 203
 204 int fifo_size(FifoBuffer *f, uint8_t *rptr)
 205 {
 206     int size;
 207
 208     if (f->wptr >= rptr) {
 209         size = f->wptr - rptr;
 210     } else {
 211         size = (f->end - rptr) + (f->wptr - f->buffer);
 212     }
 213     return size;
 214 }
 215
 216 /* get data from the fifo (return -1 if not enough data) */
 217 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
 218 {
 219     uint8_t *rptr = *rptr_ptr;
 220     int size, len;
 221
 222     if (f->wptr >= rptr) {
 223         size = f->wptr - rptr;
 224     } else {
 225         size = (f->end - rptr) + (f->wptr - f->buffer);
 226     }
 227
 228     if (size < buf_size)
 229         return -1;
 230     while (buf_size > 0) {
 231         len = f->end - rptr;
 232         if (len > buf_size)
 233             len = buf_size;
 234         memcpy(buf, rptr, len);
 235         buf += len;
 236         rptr += len;
 237         if (rptr >= f->end)
 238             rptr = f->buffer;
 239         buf_size -= len;
 240     }
 241     *rptr_ptr = rptr;
 242     return 0;
 243 }
 244
 245 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
 246 {
 247     int len;
 248     uint8_t *wptr;
 249     wptr = *wptr_ptr;
 250     while (size > 0) {
 251         len = f->end - wptr;
 252         if (len > size)
 253             len = size;
 254         memcpy(wptr, buf, len);
 255         wptr += len;
 256         if (wptr >= f->end)
 257             wptr = f->buffer;
 258         buf += len;
 259         size -= len;
 260     }
 261     *wptr_ptr = wptr;
 262 }
 263
 264 int filename_number_test(const char *filename)
 265 {
 266     char buf[1024];
 267     return get_frame_filename(buf, sizeof(buf), filename, 1);
 268 }
 269
 270 /* guess file format */
 271 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
 272 {
 273     AVInputFormat *fmt1, *fmt;
 274     int score, score_max;
 275
 276     fmt = NULL;
 277     score_max = 0;
 278     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 279         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
 280             continue;
 281         score = 0;
 282         if (fmt1->read_probe) {
 283             score = fmt1->read_probe(pd);
 284         } else if (fmt1->extensions) {
 285             if (match_ext(pd->filename, fmt1->extensions)) {
 286                 score = 50;
 287             }
 288         }
 289         if (score > score_max) {
 290             score_max = score;
 291             fmt = fmt1;
 292         }
 293     }
 294     return fmt;
 295 }
 296
 297 /************************************************************/
 298 /* input media file */
 299
 300 /**
 301  * open a media file from an IO stream. 'fmt' must be specified.
 302  */
 303
 304 static const char* format_to_name(void* ptr)
 305 {
 306     AVFormatContext* fc = (AVFormatContext*) ptr;
 307     if(fc->iformat) return fc->iformat->name;
 308     else if(fc->oformat) return fc->oformat->name;
 309     else return "NULL";
 310 }
 311
 312 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
 313
 314 AVFormatContext *av_alloc_format_context(void)
 315 {
 316     AVFormatContext *ic;
 317     ic = av_mallocz(sizeof(AVFormatContext));
 318     if (!ic) return ic;
 319     ic->av_class = &av_format_context_class;
 320     return ic;
 321 }
 322
 323 int av_open_input_stream(AVFormatContext **ic_ptr,
 324                          ByteIOContext *pb, const char *filename,
 325                          AVInputFormat *fmt, AVFormatParameters *ap)
 326 {
 327     int err;
 328     AVFormatContext *ic;
 329
 330     ic = av_alloc_format_context();
 331     if (!ic) {
 332         err = AVERROR_NOMEM;
 333         goto fail;
 334     }
 335     ic->iformat = fmt;
 336     if (pb)
 337         ic->pb = *pb;
 338     ic->duration = AV_NOPTS_VALUE;
 339     ic->start_time = AV_NOPTS_VALUE;
 340     pstrcpy(ic->filename, sizeof(ic->filename), filename);
 341
 342     /* allocate private data */
 343     if (fmt->priv_data_size > 0) {
 344         ic->priv_data = av_mallocz(fmt->priv_data_size);
 345         if (!ic->priv_data) {
 346             err = AVERROR_NOMEM;
 347             goto fail;
 348         }
 349     } else {
 350         ic->priv_data = NULL;
 351     }
 352
 353     /* default pts settings is MPEG like */
 354     av_set_pts_info(ic, 33, 1, 90000);
 355     ic->last_pkt_pts = AV_NOPTS_VALUE;
 356     ic->last_pkt_dts = AV_NOPTS_VALUE;
 357     ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
 358     ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
 359
 360     err = ic->iformat->read_header(ic, ap);
 361     if (err < 0)
 362         goto fail;
 363
 364     if (pb)
 365         ic->data_offset = url_ftell(&ic->pb);
 366
 367     *ic_ptr = ic;
 368     return 0;
 369  fail:
 370     if (ic) {
 371         av_freep(&ic->priv_data);
 372     }
 373     av_free(ic);
 374     *ic_ptr = NULL;
 375     return err;
 376 }
 377
 378 #define PROBE_BUF_SIZE 2048
 379
 380 /**
 381  * Open a media file as input. The codec are not opened. Only the file
 382  * header (if present) is read.
 383  *
 384  * @param ic_ptr the opened media file handle is put here
 385  * @param filename filename to open.
 386  * @param fmt if non NULL, force the file format to use
 387  * @param buf_size optional buffer size (zero if default is OK)
 388  * @param ap additionnal parameters needed when opening the file (NULL if default)
 389  * @return 0 if OK. AVERROR_xxx otherwise.
 390  */
 391 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
 392                        AVInputFormat *fmt,
 393                        int buf_size,
 394                        AVFormatParameters *ap)
 395 {
 396     int err, must_open_file, file_opened;
 397     uint8_t buf[PROBE_BUF_SIZE];
 398     AVProbeData probe_data, *pd = &probe_data;
 399     ByteIOContext pb1, *pb = &pb1;
 400
 401     file_opened = 0;
 402     pd->filename = "";
 403     if (filename)
 404         pd->filename = filename;
 405     pd->buf = buf;
 406     pd->buf_size = 0;
 407
 408     if (!fmt) {
 409         /* guess format if no file can be opened  */
 410         fmt = av_probe_input_format(pd, 0);
 411     }
 412
 413     /* do not open file if the format does not need it. XXX: specific
 414        hack needed to handle RTSP/TCP */
 415     must_open_file = 1;
 416     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
 417         must_open_file = 0;
 418     }
 419
 420     if (!fmt || must_open_file) {
 421         /* if no file needed do not try to open one */
 422         if (url_fopen(pb, filename, URL_RDONLY) < 0) {
 423             err = AVERROR_IO;
 424             goto fail;
 425         }
 426         file_opened = 1;
 427         if (buf_size > 0) {
 428             url_setbufsize(pb, buf_size);
 429         }
 430         if (!fmt) {
 431             /* read probe data */
 432             pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
 433             url_fseek(pb, 0, SEEK_SET);
 434         }
 435     }
 436
 437     /* guess file format */
 438     if (!fmt) {
 439         fmt = av_probe_input_format(pd, 1);
 440     }
 441
 442     /* if still no format found, error */
 443     if (!fmt) {
 444         err = AVERROR_NOFMT;
 445         goto fail;
 446     }
 447
 448     /* XXX: suppress this hack for redirectors */
 449 #ifdef CONFIG_NETWORK
 450     if (fmt == &redir_demux) {
 451         err = redir_open(ic_ptr, pb);
 452         url_fclose(pb);
 453         return err;
 454     }
 455 #endif
 456
 457     /* check filename in case of an image number is expected */
 458     if (fmt->flags & AVFMT_NEEDNUMBER) {
 459         if (filename_number_test(filename) < 0) {
 460             err = AVERROR_NUMEXPECTED;
 461             goto fail;
 462         }
 463     }
 464     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
 465     if (err)
 466         goto fail;
 467     return 0;
 468  fail:
 469     if (file_opened)
 470         url_fclose(pb);
 471     *ic_ptr = NULL;
 472     return err;
 473
 474 }
 475
 476 /*******************************************************/
 477
 478 /**
 479  * Read a transport packet from a media file. This function is
 480  * absolete and should never be used. Use av_read_frame() instead.
 481  *
 482  * @param s media file handle
 483  * @param pkt is filled
 484  * @return 0 if OK. AVERROR_xxx if error.
 485  */
 486 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 487 {
 488     return s->iformat->read_packet(s, pkt);
 489 }
 490
 491 /**********************************************************/
 492
 493 /* convert the packet time stamp units and handle wrapping. The
 494    wrapping is handled by considering the next PTS/DTS as a delta to
 495    the previous value. We handle the delta as a fraction to avoid any
 496    rounding errors. */
 497 static inline int64_t convert_timestamp_units(AVFormatContext *s,
 498                                         int64_t *plast_pkt_pts,
 499                                         int *plast_pkt_pts_frac,
 500                                         int64_t *plast_pkt_stream_pts,
 501                                         int64_t pts)
 502 {
 503     int64_t stream_pts;
 504     int64_t delta_pts;
 505     int shift, pts_frac;
 506
 507     if (pts != AV_NOPTS_VALUE) {
 508         stream_pts = pts;
 509         if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
 510             shift = 64 - s->pts_wrap_bits;
 511             delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
 512             /* XXX: overflow possible but very unlikely as it is a delta */
 513             delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
 514             pts = *plast_pkt_pts + (delta_pts / s->pts_den);
 515             pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
 516             if (pts_frac >= s->pts_den) {
 517                 pts_frac -= s->pts_den;
 518                 pts++;
 519             }
 520         } else {
 521             /* no previous pts, so no wrapping possible */
 522             pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
 523                             (double)s->pts_den);
 524             pts_frac = 0;
 525         }
 526         *plast_pkt_stream_pts = stream_pts;
 527         *plast_pkt_pts = pts;
 528         *plast_pkt_pts_frac = pts_frac;
 529     }
 530     return pts;
 531 }
 532
 533 /* get the number of samples of an audio frame. Return (-1) if error */
 534 static int get_audio_frame_size(AVCodecContext *enc, int size)
 535 {
 536     int frame_size;
 537
 538     if (enc->frame_size <= 1) {
 539         /* specific hack for pcm codecs because no frame size is
 540            provided */
 541         switch(enc->codec_id) {
 542         case CODEC_ID_PCM_S16LE:
 543         case CODEC_ID_PCM_S16BE:
 544         case CODEC_ID_PCM_U16LE:
 545         case CODEC_ID_PCM_U16BE:
 546             if (enc->channels == 0)
 547                 return -1;
 548             frame_size = size / (2 * enc->channels);
 549             break;
 550         case CODEC_ID_PCM_S8:
 551         case CODEC_ID_PCM_U8:
 552         case CODEC_ID_PCM_MULAW:
 553         case CODEC_ID_PCM_ALAW:
 554             if (enc->channels == 0)
 555                 return -1;
 556             frame_size = size / (enc->channels);
 557             break;
 558         default:
 559             /* used for example by ADPCM codecs */
 560             if (enc->bit_rate == 0)
 561                 return -1;
 562             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
 563             break;
 564         }
 565     } else {
 566         frame_size = enc->frame_size;
 567     }
 568     return frame_size;
 569 }
 570
 571
 572 /* return the frame duration in seconds, return 0 if not available */
 573 static void compute_frame_duration(int *pnum, int *pden,
 574                                    AVFormatContext *s, AVStream *st,
 575                                    AVCodecParserContext *pc, AVPacket *pkt)
 576 {
 577     int frame_size;
 578
 579     *pnum = 0;
 580     *pden = 0;
 581     switch(st->codec.codec_type) {
 582     case CODEC_TYPE_VIDEO:
 583         *pnum = st->codec.frame_rate_base;
 584         *pden = st->codec.frame_rate;
 585         if (pc && pc->repeat_pict) {
 586             *pden *= 2;
 587             *pnum = (*pnum) * (2 + pc->repeat_pict);
 588         }
 589         break;
 590     case CODEC_TYPE_AUDIO:
 591         frame_size = get_audio_frame_size(&st->codec, pkt->size);
 592         if (frame_size < 0)
 593             break;
 594         *pnum = frame_size;
 595         *pden = st->codec.sample_rate;
 596         break;
 597     default:
 598         break;
 599     }
 600 }
 601
 602 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 603                                AVCodecParserContext *pc, AVPacket *pkt)
 604 {
 605     int num, den, presentation_delayed;
 606
 607     if (pkt->duration == 0) {
 608         compute_frame_duration(&num, &den, s, st, pc, pkt);
 609         if (den && num) {
 610             pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
 611         }
 612     }
 613
 614     /* do we have a video B frame ? */
 615     presentation_delayed = 0;
 616     if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
 617         /* XXX: need has_b_frame, but cannot get it if the codec is
 618            not initialized */
 619         if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
 620              st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
 621              st->codec.codec_id == CODEC_ID_MPEG4 ||
 622              st->codec.codec_id == CODEC_ID_H264) &&
 623             pc && pc->pict_type != FF_B_TYPE)
 624             presentation_delayed = 1;
 625     }
 626
 627     /* interpolate PTS and DTS if they are not present */
 628     if (presentation_delayed) {
 629         /* DTS = decompression time stamp */
 630         /* PTS = presentation time stamp */
 631         if (pkt->dts == AV_NOPTS_VALUE) {
 632             pkt->dts = st->cur_dts;
 633         } else {
 634             st->cur_dts = pkt->dts;
 635         }
 636         /* this is tricky: the dts must be incremented by the duration
 637            of the frame we are displaying, i.e. the last I or P frame */
 638         if (st->last_IP_duration == 0)
 639             st->cur_dts += pkt->duration;
 640         else
 641             st->cur_dts += st->last_IP_duration;
 642         st->last_IP_duration  = pkt->duration;
 643         /* cannot compute PTS if not present (we can compute it only
 644            by knowing the futur */
 645     } else {
 646         /* presentation is not delayed : PTS and DTS are the same */
 647         if (pkt->pts == AV_NOPTS_VALUE) {
 648             if (pkt->dts == AV_NOPTS_VALUE) {
 649                 pkt->pts = st->cur_dts;
 650                 pkt->dts = st->cur_dts;
 651             }
 652             else {
 653                 st->cur_dts = pkt->dts;
 654                 pkt->pts = pkt->dts;
 655             }
 656         } else {
 657             st->cur_dts = pkt->pts;
 658             pkt->dts = pkt->pts;
 659         }
 660         st->cur_dts += pkt->duration;
 661     }
 662
 663     /* update flags */
 664     if (pc) {
 665         pkt->flags = 0;
 666         /* key frame computation */
 667         switch(st->codec.codec_type) {
 668         case CODEC_TYPE_VIDEO:
 669             if (pc->pict_type == FF_I_TYPE)
 670                 pkt->flags |= PKT_FLAG_KEY;
 671             break;
 672         case CODEC_TYPE_AUDIO:
 673             pkt->flags |= PKT_FLAG_KEY;
 674             break;
 675         default:
 676             break;
 677         }
 678     }
 679
 680 }
 681
 682 static void av_destruct_packet_nofree(AVPacket *pkt)
 683 {
 684     pkt->data = NULL; pkt->size = 0;
 685 }
 686
 687 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
 688 {
 689     AVStream *st;
 690     int len, ret, i;
 691
 692     for(;;) {
 693         /* select current input stream component */
 694         st = s->cur_st;
 695         if (st) {
 696             if (!st->parser) {
 697                 /* no parsing needed: we just output the packet as is */
 698                 /* raw data support */
 699                 *pkt = s->cur_pkt;
 700                 compute_pkt_fields(s, st, NULL, pkt);
 701                 s->cur_st = NULL;
 702                 return 0;
 703             } else if (s->cur_len > 0) {
 704                 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
 705                                       s->cur_ptr, s->cur_len,
 706                                       s->cur_pkt.pts, s->cur_pkt.dts);
 707                 s->cur_pkt.pts = AV_NOPTS_VALUE;
 708                 s->cur_pkt.dts = AV_NOPTS_VALUE;
 709                 /* increment read pointer */
 710                 s->cur_ptr += len;
 711                 s->cur_len -= len;
 712
 713                 /* return packet if any */
 714                 if (pkt->size) {
 715                 got_packet:
 716                     pkt->duration = 0;
 717                     pkt->stream_index = st->index;
 718                     pkt->pts = st->parser->pts;
 719                     pkt->dts = st->parser->dts;
 720                     pkt->destruct = av_destruct_packet_nofree;
 721                     compute_pkt_fields(s, st, st->parser, pkt);
 722                     return 0;
 723                 }
 724             } else {
 725                 /* free packet */
 726                 av_free_packet(&s->cur_pkt);
 727                 s->cur_st = NULL;
 728             }
 729         } else {
 730             /* read next packet */
 731             ret = av_read_packet(s, &s->cur_pkt);
 732             if (ret < 0) {
 733                 if (ret == -EAGAIN)
 734                     return ret;
 735                 /* return the last frames, if any */
 736                 for(i = 0; i < s->nb_streams; i++) {
 737                     st = s->streams[i];
 738                     if (st->parser) {
 739                         av_parser_parse(st->parser, &st->codec,
 740                                         &pkt->data, &pkt->size,
 741                                         NULL, 0,
 742                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
 743                         if (pkt->size)
 744                             goto got_packet;
 745                     }
 746                 }
 747                 /* no more packets: really terminates parsing */
 748                 return ret;
 749             }
 750
 751             /* convert the packet time stamp units and handle wrapping */
 752             s->cur_pkt.pts = convert_timestamp_units(s,
 753                                                &s->last_pkt_pts, &s->last_pkt_pts_frac,
 754                                                &s->last_pkt_stream_pts,
 755                                                s->cur_pkt.pts);
 756             s->cur_pkt.dts = convert_timestamp_units(s,
 757                                                &s->last_pkt_dts,  &s->last_pkt_dts_frac,
 758                                                &s->last_pkt_stream_dts,
 759                                                s->cur_pkt.dts);
 760 #if 0
 761             if (s->cur_pkt.stream_index == 0) {
 762                 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
 763                     printf("PACKET pts=%0.3f\n",
 764                            (double)s->cur_pkt.pts / AV_TIME_BASE);
 765                 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
 766                     printf("PACKET dts=%0.3f\n",
 767                            (double)s->cur_pkt.dts / AV_TIME_BASE);
 768             }
 769 #endif
 770
 771             /* duration field */
 772             if (s->cur_pkt.duration != 0) {
 773                 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
 774                     s->pts_den;
 775             }
 776
 777             st = s->streams[s->cur_pkt.stream_index];
 778             s->cur_st = st;
 779             s->cur_ptr = s->cur_pkt.data;
 780             s->cur_len = s->cur_pkt.size;
 781             if (st->need_parsing && !st->parser) {
 782                 st->parser = av_parser_init(st->codec.codec_id);
 783                 if (!st->parser) {
 784                     /* no parser available : just output the raw packets */
 785                     st->need_parsing = 0;
 786                 }
 787             }
 788         }
 789     }
 790 }
 791
 792 /**
 793  * Return the next frame of a stream. The returned packet is valid
 794  * until the next av_read_frame() or until av_close_input_file() and
 795  * must be freed with av_free_packet. For video, the packet contains
 796  * exactly one frame. For audio, it contains an integer number of
 797  * frames if each frame has a known fixed size (e.g. PCM or ADPCM
 798  * data). If the audio frames have a variable size (e.g. MPEG audio),
 799  * then it contains one frame.
 800  *
 801  * pkt->pts, pkt->dts and pkt->duration are always set to correct
 802  * values in AV_TIME_BASE unit (and guessed if the format cannot
 803  * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
 804  * has B frames, so it is better to rely on pkt->dts if you do not
 805  * decompress the payload.
 806  *
 807  * Return 0 if OK, < 0 if error or end of file.
 808  */
 809 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
 810 {
 811     AVPacketList *pktl;
 812
 813     pktl = s->packet_buffer;
 814     if (pktl) {
 815         /* read packet from packet buffer, if there is data */
 816         *pkt = pktl->pkt;
 817         s->packet_buffer = pktl->next;
 818         av_free(pktl);
 819         return 0;
 820     } else {
 821         return av_read_frame_internal(s, pkt);
 822     }
 823 }
 824
 825 /* XXX: suppress the packet queue */
 826 static void flush_packet_queue(AVFormatContext *s)
 827 {
 828     AVPacketList *pktl;
 829
 830     for(;;) {
 831         pktl = s->packet_buffer;
 832         if (!pktl)
 833             break;
 834         s->packet_buffer = pktl->next;
 835         av_free_packet(&pktl->pkt);
 836         av_free(pktl);
 837     }
 838 }
 839
 840 /*******************************************************/
 841 /* seek support */
 842
 843 int av_find_default_stream_index(AVFormatContext *s)
 844 {
 845     int i;
 846     AVStream *st;
 847
 848     if (s->nb_streams <= 0)
 849         return -1;
 850     for(i = 0; i < s->nb_streams; i++) {
 851         st = s->streams[i];
 852         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
 853             return i;
 854         }
 855     }
 856     return 0;
 857 }
 858
 859 /* flush the frame reader */
 860 static void av_read_frame_flush(AVFormatContext *s)
 861 {
 862     AVStream *st;
 863     int i;
 864
 865     flush_packet_queue(s);
 866
 867     /* free previous packet */
 868     if (s->cur_st) {
 869         if (s->cur_st->parser)
 870             av_free_packet(&s->cur_pkt);
 871         s->cur_st = NULL;
 872     }
 873     /* fail safe */
 874     s->cur_ptr = NULL;
 875     s->cur_len = 0;
 876
 877     /* for each stream, reset read state */
 878     for(i = 0; i < s->nb_streams; i++) {
 879         st = s->streams[i];
 880
 881         if (st->parser) {
 882             av_parser_close(st->parser);
 883             st->parser = NULL;
 884         }
 885         st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
 886     }
 887 }
 888
 889 /* add a index entry into a sorted list updateing if it is already there */
 890 int av_add_index_entry(AVStream *st,
 891                             int64_t pos, int64_t timestamp, int distance, int flags)
 892 {
 893     AVIndexEntry *entries, *ie;
 894     int index;
 895
 896     entries = av_fast_realloc(st->index_entries,
 897                               &st->index_entries_allocated_size,
 898                               (st->nb_index_entries + 1) *
 899                               sizeof(AVIndexEntry));
 900     st->index_entries= entries;
 901
 902     if(st->nb_index_entries){
 903         index= av_index_search_timestamp(st, timestamp);
 904         ie= &entries[index];
 905
 906         if(ie->timestamp != timestamp){
 907             if(ie->timestamp < timestamp){
 908                 index++; //index points to next instead of previous entry, maybe nonexistant
 909                 ie= &st->index_entries[index];
 910             }else
 911                 assert(index==0);
 912
 913             if(index != st->nb_index_entries){
 914                 assert(index < st->nb_index_entries);
 915                 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
 916             }
 917             st->nb_index_entries++;
 918         }else{
 919             if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
 920                 distance= ie->min_distance;
 921         }
 922     }else{
 923         index= st->nb_index_entries++;
 924         ie= &entries[index];
 925     }
 926
 927     ie->pos = pos;
 928     ie->timestamp = timestamp;
 929     ie->min_distance= distance;
 930     ie->flags = flags;
 931
 932     return index;
 933 }
 934
 935 /* build an index for raw streams using a parser */
 936 static void av_build_index_raw(AVFormatContext *s)
 937 {
 938     AVPacket pkt1, *pkt = &pkt1;
 939     int ret;
 940     AVStream *st;
 941
 942     st = s->streams[0];
 943     av_read_frame_flush(s);
 944     url_fseek(&s->pb, s->data_offset, SEEK_SET);
 945
 946     for(;;) {
 947         ret = av_read_frame(s, pkt);
 948         if (ret < 0)
 949             break;
 950         if (pkt->stream_index == 0 && st->parser &&
 951             (pkt->flags & PKT_FLAG_KEY)) {
 952             av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
 953                             0, AVINDEX_KEYFRAME);
 954         }
 955         av_free_packet(pkt);
 956     }
 957 }
 958
 959 /* return TRUE if we deal with a raw stream (raw codec data and
 960    parsing needed) */
 961 static int is_raw_stream(AVFormatContext *s)
 962 {
 963     AVStream *st;
 964
 965     if (s->nb_streams != 1)
 966         return 0;
 967     st = s->streams[0];
 968     if (!st->need_parsing)
 969         return 0;
 970     return 1;
 971 }
 972
 973 /* return the largest index entry whose timestamp is <=
 974    wanted_timestamp */
 975 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
 976 {
 977     AVIndexEntry *entries= st->index_entries;
 978     int nb_entries= st->nb_index_entries;
 979     int a, b, m;
 980     int64_t timestamp;
 981
 982     if (nb_entries <= 0)
 983         return -1;
 984
 985     a = 0;
 986     b = nb_entries - 1;
 987
 988     while (a < b) {
 989         m = (a + b + 1) >> 1;
 990         timestamp = entries[m].timestamp;
 991         if (timestamp > wanted_timestamp) {
 992             b = m - 1;
 993         } else {
 994             a = m;
 995         }
 996     }
 997     return a;
 998 }
 999
1000 static int av_seek_frame_generic(AVFormatContext *s,
1001                                  int stream_index, int64_t timestamp)
1002 {
1003     int index;
1004     AVStream *st;
1005     AVIndexEntry *ie;
1006
1007     if (!s->index_built) {
1008         if (is_raw_stream(s)) {
1009             av_build_index_raw(s);
1010         } else {
1011             return -1;
1012         }
1013         s->index_built = 1;
1014     }
1015
1016     if (stream_index < 0)
1017         stream_index = 0;
1018     st = s->streams[stream_index];
1019     index = av_index_search_timestamp(st, timestamp);
1020     if (index < 0)
1021         return -1;
1022
1023     /* now we have found the index, we can seek */
1024     ie = &st->index_entries[index];
1025     av_read_frame_flush(s);
1026     url_fseek(&s->pb, ie->pos, SEEK_SET);
1027     st->cur_dts = ie->timestamp;
1028     return 0;
1029 }
1030
1031 /**
1032  * Seek to the key frame just before the frame at timestamp
1033  * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1034  * stream is selected
1035  */
1036 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1037 {
1038     int ret;
1039
1040     av_read_frame_flush(s);
1041
1042     /* first, we try the format specific seek */
1043     if (s->iformat->read_seek)
1044         ret = s->iformat->read_seek(s, stream_index, timestamp);
1045     else
1046         ret = -1;
1047     if (ret >= 0) {
1048         return 0;
1049     }
1050
1051     return av_seek_frame_generic(s, stream_index, timestamp);
1052 }
1053
1054 /*******************************************************/
1055
1056 /* return TRUE if the stream has accurate timings for at least one component */
1057 static int av_has_timings(AVFormatContext *ic)
1058 {
1059     int i;
1060     AVStream *st;
1061
1062     for(i = 0;i < ic->nb_streams; i++) {
1063         st = ic->streams[i];
1064         if (st->start_time != AV_NOPTS_VALUE &&
1065             st->duration != AV_NOPTS_VALUE)
1066             return 1;
1067     }
1068     return 0;
1069 }
1070
1071 /* estimate the stream timings from the one of each components. Also
1072    compute the global bitrate if possible */
1073 static void av_update_stream_timings(AVFormatContext *ic)
1074 {
1075     int64_t start_time, end_time, end_time1;
1076     int i;
1077     AVStream *st;
1078
1079     start_time = MAXINT64;
1080     end_time = MININT64;
1081     for(i = 0;i < ic->nb_streams; i++) {
1082         st = ic->streams[i];
1083         if (st->start_time != AV_NOPTS_VALUE) {
1084             if (st->start_time < start_time)
1085                 start_time = st->start_time;
1086             if (st->duration != AV_NOPTS_VALUE) {
1087                 end_time1 = st->start_time + st->duration;
1088                 if (end_time1 > end_time)
1089                     end_time = end_time1;
1090             }
1091         }
1092     }
1093     if (start_time != MAXINT64) {
1094         ic->start_time = start_time;
1095         if (end_time != MAXINT64) {
1096             ic->duration = end_time - start_time;
1097             if (ic->file_size > 0) {
1098                 /* compute the bit rate */
1099                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1100                     (double)ic->duration;
1101             }
1102         }
1103     }
1104
1105 }
1106
1107 static void fill_all_stream_timings(AVFormatContext *ic)
1108 {
1109     int i;
1110     AVStream *st;
1111
1112     av_update_stream_timings(ic);
1113     for(i = 0;i < ic->nb_streams; i++) {
1114         st = ic->streams[i];
1115         if (st->start_time == AV_NOPTS_VALUE) {
1116             st->start_time = ic->start_time;
1117             st->duration = ic->duration;
1118         }
1119     }
1120 }
1121
1122 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1123 {
1124     int64_t filesize, duration;
1125     int bit_rate, i;
1126     AVStream *st;
1127
1128     /* if bit_rate is already set, we believe it */
1129     if (ic->bit_rate == 0) {
1130         bit_rate = 0;
1131         for(i=0;i<ic->nb_streams;i++) {
1132             st = ic->streams[i];
1133             bit_rate += st->codec.bit_rate;
1134         }
1135         ic->bit_rate = bit_rate;
1136     }
1137
1138     /* if duration is already set, we believe it */
1139     if (ic->duration == AV_NOPTS_VALUE &&
1140         ic->bit_rate != 0 &&
1141         ic->file_size != 0)  {
1142         filesize = ic->file_size;
1143         if (filesize > 0) {
1144             duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1145             for(i = 0; i < ic->nb_streams; i++) {
1146                 st = ic->streams[i];
1147                 if (st->start_time == AV_NOPTS_VALUE ||
1148                     st->duration == AV_NOPTS_VALUE) {
1149                     st->start_time = 0;
1150                     st->duration = duration;
1151                 }
1152             }
1153         }
1154     }
1155 }
1156
1157 #define DURATION_MAX_READ_SIZE 250000
1158
1159 /* only usable for MPEG-PS streams */
1160 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1161 {
1162     AVPacket pkt1, *pkt = &pkt1;
1163     AVStream *st;
1164     int read_size, i, ret;
1165     int64_t start_time, end_time, end_time1;
1166     int64_t filesize, offset, duration;
1167
1168     /* free previous packet */
1169     if (ic->cur_st && ic->cur_st->parser)
1170         av_free_packet(&ic->cur_pkt);
1171     ic->cur_st = NULL;
1172
1173     /* flush packet queue */
1174     flush_packet_queue(ic);
1175
1176
1177     /* we read the first packets to get the first PTS (not fully
1178        accurate, but it is enough now) */
1179     url_fseek(&ic->pb, 0, SEEK_SET);
1180     read_size = 0;
1181     for(;;) {
1182         if (read_size >= DURATION_MAX_READ_SIZE)
1183             break;
1184         /* if all info is available, we can stop */
1185         for(i = 0;i < ic->nb_streams; i++) {
1186             st = ic->streams[i];
1187             if (st->start_time == AV_NOPTS_VALUE)
1188                 break;
1189         }
1190         if (i == ic->nb_streams)
1191             break;
1192
1193         ret = av_read_packet(ic, pkt);
1194         if (ret != 0)
1195             break;
1196         read_size += pkt->size;
1197         st = ic->streams[pkt->stream_index];
1198         if (pkt->pts != AV_NOPTS_VALUE) {
1199             if (st->start_time == AV_NOPTS_VALUE)
1200                 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1201         }
1202         av_free_packet(pkt);
1203     }
1204
1205     /* we compute the minimum start_time and use it as default */
1206     start_time = MAXINT64;
1207     for(i = 0; i < ic->nb_streams; i++) {
1208         st = ic->streams[i];
1209         if (st->start_time != AV_NOPTS_VALUE &&
1210             st->start_time < start_time)
1211             start_time = st->start_time;
1212     }
1213     if (start_time != MAXINT64)
1214         ic->start_time = start_time;
1215
1216     /* estimate the end time (duration) */
1217     /* XXX: may need to support wrapping */
1218     filesize = ic->file_size;
1219     offset = filesize - DURATION_MAX_READ_SIZE;
1220     if (offset < 0)
1221         offset = 0;
1222
1223     url_fseek(&ic->pb, offset, SEEK_SET);
1224     read_size = 0;
1225     for(;;) {
1226         if (read_size >= DURATION_MAX_READ_SIZE)
1227             break;
1228         /* if all info is available, we can stop */
1229         for(i = 0;i < ic->nb_streams; i++) {
1230             st = ic->streams[i];
1231             if (st->duration == AV_NOPTS_VALUE)
1232                 break;
1233         }
1234         if (i == ic->nb_streams)
1235             break;
1236
1237         ret = av_read_packet(ic, pkt);
1238         if (ret != 0)
1239             break;
1240         read_size += pkt->size;
1241         st = ic->streams[pkt->stream_index];
1242         if (pkt->pts != AV_NOPTS_VALUE) {
1243             end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1244             duration = end_time - st->start_time;
1245             if (duration > 0) {
1246                 if (st->duration == AV_NOPTS_VALUE ||
1247                     st->duration < duration)
1248                     st->duration = duration;
1249             }
1250         }
1251         av_free_packet(pkt);
1252     }
1253
1254     /* estimate total duration */
1255     end_time = MININT64;
1256     for(i = 0;i < ic->nb_streams; i++) {
1257         st = ic->streams[i];
1258         if (st->duration != AV_NOPTS_VALUE) {
1259             end_time1 = st->start_time + st->duration;
1260             if (end_time1 > end_time)
1261                 end_time = end_time1;
1262         }
1263     }
1264
1265     /* update start_time (new stream may have been created, so we do
1266        it at the end */
1267     if (ic->start_time != AV_NOPTS_VALUE) {
1268         for(i = 0; i < ic->nb_streams; i++) {
1269             st = ic->streams[i];
1270             if (st->start_time == AV_NOPTS_VALUE)
1271                 st->start_time = ic->start_time;
1272         }
1273     }
1274
1275     if (end_time != MININT64) {
1276         /* put dummy values for duration if needed */
1277         for(i = 0;i < ic->nb_streams; i++) {
1278             st = ic->streams[i];
1279             if (st->duration == AV_NOPTS_VALUE &&
1280                 st->start_time != AV_NOPTS_VALUE)
1281                 st->duration = end_time - st->start_time;
1282         }
1283         ic->duration = end_time - ic->start_time;
1284     }
1285
1286     url_fseek(&ic->pb, 0, SEEK_SET);
1287 }
1288
1289 static void av_estimate_timings(AVFormatContext *ic)
1290 {
1291     URLContext *h;
1292     int64_t file_size;
1293
1294     /* get the file size, if possible */
1295     if (ic->iformat->flags & AVFMT_NOFILE) {
1296         file_size = 0;
1297     } else {
1298         h = url_fileno(&ic->pb);
1299         file_size = url_filesize(h);
1300         if (file_size < 0)
1301             file_size = 0;
1302     }
1303     ic->file_size = file_size;
1304
1305     if (ic->iformat == &mpegps_demux) {
1306         /* get accurate estimate from the PTSes */
1307         av_estimate_timings_from_pts(ic);
1308     } else if (av_has_timings(ic)) {
1309         /* at least one components has timings - we use them for all
1310            the components */
1311         fill_all_stream_timings(ic);
1312     } else {
1313         /* less precise: use bit rate info */
1314         av_estimate_timings_from_bit_rate(ic);
1315     }
1316     av_update_stream_timings(ic);
1317
1318 #if 0
1319     {
1320         int i;
1321         AVStream *st;
1322         for(i = 0;i < ic->nb_streams; i++) {
1323             st = ic->streams[i];
1324         printf("%d: start_time: %0.3f duration: %0.3f\n",
1325                i, (double)st->start_time / AV_TIME_BASE,
1326                (double)st->duration / AV_TIME_BASE);
1327         }
1328         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1329                (double)ic->start_time / AV_TIME_BASE,
1330                (double)ic->duration / AV_TIME_BASE,
1331                ic->bit_rate / 1000);
1332     }
1333 #endif
1334 }
1335
1336 static int has_codec_parameters(AVCodecContext *enc)
1337 {
1338     int val;
1339     switch(enc->codec_type) {
1340     case CODEC_TYPE_AUDIO:
1341         val = enc->sample_rate;
1342         break;
1343     case CODEC_TYPE_VIDEO:
1344         val = enc->width;
1345         break;
1346     default:
1347         val = 1;
1348         break;
1349     }
1350     return (val != 0);
1351 }
1352
1353 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1354 {
1355     int16_t *samples;
1356     AVCodec *codec;
1357     int got_picture, ret;
1358     AVFrame picture;
1359
1360     codec = avcodec_find_decoder(st->codec.codec_id);
1361     if (!codec)
1362         return -1;
1363     ret = avcodec_open(&st->codec, codec);
1364     if (ret < 0)
1365         return ret;
1366     switch(st->codec.codec_type) {
1367     case CODEC_TYPE_VIDEO:
1368         ret = avcodec_decode_video(&st->codec, &picture,
1369                                    &got_picture, (uint8_t *)data, size);
1370         break;
1371     case CODEC_TYPE_AUDIO:
1372         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1373         if (!samples)
1374             goto fail;
1375         ret = avcodec_decode_audio(&st->codec, samples,
1376                                    &got_picture, (uint8_t *)data, size);
1377         av_free(samples);
1378         break;
1379     default:
1380         break;
1381     }
1382  fail:
1383     avcodec_close(&st->codec);
1384     return ret;
1385 }
1386
1387 /* absolute maximum size we read until we abort */
1388 #define MAX_READ_SIZE        5000000
1389
1390 /* maximum duration until we stop analysing the stream */
1391 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1392
1393 /**
1394  * Read the beginning of a media file to get stream information. This
1395  * is useful for file formats with no headers such as MPEG. This
1396  * function also compute the real frame rate in case of mpeg2 repeat
1397  * frame mode.
1398  *
1399  * @param ic media file handle
1400  * @return >=0 if OK. AVERROR_xxx if error.
1401  */
1402 int av_find_stream_info(AVFormatContext *ic)
1403 {
1404     int i, count, ret, read_size;
1405     AVStream *st;
1406     AVPacket pkt1, *pkt;
1407     AVPacketList *pktl=NULL, **ppktl;
1408
1409     count = 0;
1410     read_size = 0;
1411     ppktl = &ic->packet_buffer;
1412     for(;;) {
1413         /* check if one codec still needs to be handled */
1414         for(i=0;i<ic->nb_streams;i++) {
1415             st = ic->streams[i];
1416             if (!has_codec_parameters(&st->codec))
1417                 break;
1418         }
1419         if (i == ic->nb_streams) {
1420             /* NOTE: if the format has no header, then we need to read
1421                some packets to get most of the streams, so we cannot
1422                stop here */
1423             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1424                 /* if we found the info for all the codecs, we can stop */
1425                 ret = count;
1426                 break;
1427             }
1428         } else {
1429             /* we did not get all the codec info, but we read too much data */
1430             if (read_size >= MAX_READ_SIZE) {
1431                 ret = count;
1432                 break;
1433             }
1434         }
1435
1436         /* NOTE: a new stream can be added there if no header in file
1437            (AVFMTCTX_NOHEADER) */
1438         ret = av_read_frame_internal(ic, &pkt1);
1439         if (ret < 0) {
1440             /* EOF or error */
1441             ret = -1; /* we could not have all the codec parameters before EOF */
1442             if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1443                 i == ic->nb_streams)
1444                 ret = 0;
1445             break;
1446         }
1447
1448         pktl = av_mallocz(sizeof(AVPacketList));
1449         if (!pktl) {
1450             ret = AVERROR_NOMEM;
1451             break;
1452         }
1453
1454         /* add the packet in the buffered packet list */
1455         *ppktl = pktl;
1456         ppktl = &pktl->next;
1457
1458         pkt = &pktl->pkt;
1459         *pkt = pkt1;
1460
1461         /* duplicate the packet */
1462         if (av_dup_packet(pkt) < 0) {
1463                 ret = AVERROR_NOMEM;
1464                 break;
1465         }
1466
1467         read_size += pkt->size;
1468
1469         st = ic->streams[pkt->stream_index];
1470         st->codec_info_duration += pkt->duration;
1471         if (pkt->duration != 0)
1472             st->codec_info_nb_frames++;
1473
1474         /* if still no information, we try to open the codec and to
1475            decompress the frame. We try to avoid that in most cases as
1476            it takes longer and uses more memory. For MPEG4, we need to
1477            decompress for Quicktime. */
1478         if (!has_codec_parameters(&st->codec) &&
1479             (st->codec.codec_id == CODEC_ID_FLV1 ||
1480              st->codec.codec_id == CODEC_ID_H264 ||
1481              st->codec.codec_id == CODEC_ID_H263 ||
1482              st->codec.codec_id == CODEC_ID_VORBIS ||
1483              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1484             try_decode_frame(st, pkt->data, pkt->size);
1485
1486         if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1487             break;
1488         }
1489         count++;
1490     }
1491
1492     /* set real frame rate info */
1493     for(i=0;i<ic->nb_streams;i++) {
1494         st = ic->streams[i];
1495         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1496             /* compute the real frame rate for telecine */
1497             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1498                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1499                 st->codec.sub_id == 2) {
1500                 if (st->codec_info_nb_frames >= 20) {
1501                     float coded_frame_rate, est_frame_rate;
1502                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1503                         (double)st->codec_info_duration ;
1504                     coded_frame_rate = (double)st->codec.frame_rate /
1505                         (double)st->codec.frame_rate_base;
1506 #if 0
1507                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1508                            coded_frame_rate, est_frame_rate);
1509 #endif
1510                     /* if we detect that it could be a telecine, we
1511                        signal it. It would be better to do it at a
1512                        higher level as it can change in a film */
1513                     if (coded_frame_rate >= 24.97 &&
1514                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1515                         st->r_frame_rate = 24024;
1516                         st->r_frame_rate_base = 1001;
1517                     }
1518                 }
1519             }
1520             /* if no real frame rate, use the codec one */
1521             if (!st->r_frame_rate){
1522                 st->r_frame_rate      = st->codec.frame_rate;
1523                 st->r_frame_rate_base = st->codec.frame_rate_base;
1524             }
1525         }
1526     }
1527
1528     av_estimate_timings(ic);
1529     return ret;
1530 }
1531
1532 /*******************************************************/
1533
1534 /**
1535  * start playing a network based stream (e.g. RTSP stream) at the
1536  * current position
1537  */
1538 int av_read_play(AVFormatContext *s)
1539 {
1540     if (!s->iformat->read_play)
1541         return AVERROR_NOTSUPP;
1542     return s->iformat->read_play(s);
1543 }
1544
1545 /**
1546  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1547  * to resume it.
1548  */
1549 int av_read_pause(AVFormatContext *s)
1550 {
1551     if (!s->iformat->read_pause)
1552         return AVERROR_NOTSUPP;
1553     return s->iformat->read_pause(s);
1554 }
1555
1556 /**
1557  * Close a media file (but not its codecs)
1558  *
1559  * @param s media file handle
1560  */
1561 void av_close_input_file(AVFormatContext *s)
1562 {
1563     int i, must_open_file;
1564     AVStream *st;
1565
1566     /* free previous packet */
1567     if (s->cur_st && s->cur_st->parser)
1568         av_free_packet(&s->cur_pkt);
1569
1570     if (s->iformat->read_close)
1571         s->iformat->read_close(s);
1572     for(i=0;i<s->nb_streams;i++) {
1573         /* free all data in a stream component */
1574         st = s->streams[i];
1575         if (st->parser) {
1576             av_parser_close(st->parser);
1577         }
1578         av_free(st->index_entries);
1579         av_free(st);
1580     }
1581     flush_packet_queue(s);
1582     must_open_file = 1;
1583     if (s->iformat->flags & AVFMT_NOFILE) {
1584         must_open_file = 0;
1585     }
1586     if (must_open_file) {
1587         url_fclose(&s->pb);
1588     }
1589     av_freep(&s->priv_data);
1590     av_free(s);
1591 }
1592
1593 /**
1594  * Add a new stream to a media file. Can only be called in the
1595  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1596  * format context, then new streams can be added in read_packet too.
1597  *
1598  *
1599  * @param s media file handle
1600  * @param id file format dependent stream id
1601  */
1602 AVStream *av_new_stream(AVFormatContext *s, int id)
1603 {
1604     AVStream *st;
1605
1606     if (s->nb_streams >= MAX_STREAMS)
1607         return NULL;
1608
1609     st = av_mallocz(sizeof(AVStream));
1610     if (!st)
1611         return NULL;
1612     avcodec_get_context_defaults(&st->codec);
1613     if (s->iformat) {
1614         /* no default bitrate if decoding */
1615         st->codec.bit_rate = 0;
1616     }
1617     st->index = s->nb_streams;
1618     st->id = id;
1619     st->start_time = AV_NOPTS_VALUE;
1620     st->duration = AV_NOPTS_VALUE;
1621     s->streams[s->nb_streams++] = st;
1622     return st;
1623 }
1624
1625 /************************************************************/
1626 /* output media file */
1627
1628 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1629 {
1630     int ret;
1631
1632     if (s->oformat->priv_data_size > 0) {
1633         s->priv_data = av_mallocz(s->oformat->priv_data_size);
1634         if (!s->priv_data)
1635             return AVERROR_NOMEM;
1636     } else
1637         s->priv_data = NULL;
1638
1639     if (s->oformat->set_parameters) {
1640         ret = s->oformat->set_parameters(s, ap);
1641         if (ret < 0)
1642             return ret;
1643     }
1644     return 0;
1645 }
1646
1647 /**
1648  * allocate the stream private data and write the stream header to an
1649  * output media file
1650  *
1651  * @param s media file handle
1652  * @return 0 if OK. AVERROR_xxx if error.
1653  */
1654 int av_write_header(AVFormatContext *s)
1655 {
1656     int ret, i;
1657     AVStream *st;
1658
1659     /* default pts settings is MPEG like */
1660     av_set_pts_info(s, 33, 1, 90000);
1661     ret = s->oformat->write_header(s);
1662     if (ret < 0)
1663         return ret;
1664
1665     /* init PTS generation */
1666     for(i=0;i<s->nb_streams;i++) {
1667         st = s->streams[i];
1668
1669         switch (st->codec.codec_type) {
1670         case CODEC_TYPE_AUDIO:
1671             av_frac_init(&st->pts, 0, 0,
1672                          (int64_t)s->pts_num * st->codec.sample_rate);
1673             break;
1674         case CODEC_TYPE_VIDEO:
1675             av_frac_init(&st->pts, 0, 0,
1676                          (int64_t)s->pts_num * st->codec.frame_rate);
1677             break;
1678         default:
1679             break;
1680         }
1681     }
1682     return 0;
1683 }
1684
1685 /**
1686  * Write a packet to an output media file. The packet shall contain
1687  * one audio or video frame.
1688  *
1689  * @param s media file handle
1690  * @param stream_index stream index
1691  * @param buf buffer containing the frame data
1692  * @param size size of buffer
1693  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1694  */
1695 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1696                    int size)
1697 {
1698     AVStream *st;
1699     int64_t pts_mask;
1700     int ret, frame_size;
1701
1702     st = s->streams[stream_index];
1703     pts_mask = (1LL << s->pts_wrap_bits) - 1;
1704
1705     /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1706     if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1707         ret = 0;
1708     else
1709         ret = s->oformat->write_packet(s, stream_index, buf, size,
1710                                        st->pts.val & pts_mask);
1711
1712     if (ret < 0)
1713         return ret;
1714
1715     /* update pts */
1716     switch (st->codec.codec_type) {
1717     case CODEC_TYPE_AUDIO:
1718         frame_size = get_audio_frame_size(&st->codec, size);
1719
1720         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1721            but it would be better if we had the real timestamps from the encoder */
1722         if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1723             av_frac_add(&st->pts,
1724                         (int64_t)s->pts_den * frame_size);
1725         }
1726         break;
1727     case CODEC_TYPE_VIDEO:
1728         av_frac_add(&st->pts,
1729                     (int64_t)s->pts_den * st->codec.frame_rate_base);
1730         break;
1731     default:
1732         break;
1733     }
1734     return ret;
1735 }
1736
1737 /**
1738  * write the stream trailer to an output media file and and free the
1739  * file private data.
1740  *
1741  * @param s media file handle
1742  * @return 0 if OK. AVERROR_xxx if error.  */
1743 int av_write_trailer(AVFormatContext *s)
1744 {
1745     int ret;
1746     ret = s->oformat->write_trailer(s);
1747     av_freep(&s->priv_data);
1748     return ret;
1749 }
1750
1751 /* "user interface" functions */
1752
1753 void dump_format(AVFormatContext *ic,
1754                  int index,
1755                  const char *url,
1756                  int is_output)
1757 {
1758     int i, flags;
1759     char buf[256];
1760
1761     av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
1762             is_output ? "Output" : "Input",
1763             index,
1764             is_output ? ic->oformat->name : ic->iformat->name,
1765             is_output ? "to" : "from", url);
1766     if (!is_output) {
1767         av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
1768         if (ic->duration != AV_NOPTS_VALUE) {
1769             int hours, mins, secs, us;
1770             secs = ic->duration / AV_TIME_BASE;
1771             us = ic->duration % AV_TIME_BASE;
1772             mins = secs / 60;
1773             secs %= 60;
1774             hours = mins / 60;
1775             mins %= 60;
1776             av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
1777                    (10 * us) / AV_TIME_BASE);
1778         } else {
1779             av_log(NULL, AV_LOG_DEBUG, "N/A");
1780         }
1781         av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1782         if (ic->bit_rate) {
1783             av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1784         } else {
1785             av_log(NULL, AV_LOG_DEBUG, "N/A");
1786         }
1787         av_log(NULL, AV_LOG_DEBUG, "\n");
1788     }
1789     for(i=0;i<ic->nb_streams;i++) {
1790         AVStream *st = ic->streams[i];
1791         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1792         av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
1793         /* the pid is an important information, so we display it */
1794         /* XXX: add a generic system */
1795         if (is_output)
1796             flags = ic->oformat->flags;
1797         else
1798             flags = ic->iformat->flags;
1799         if (flags & AVFMT_SHOW_IDS) {
1800             av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1801         }
1802         av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1803     }
1804 }
1805
1806 typedef struct {
1807     const char *abv;
1808     int width, height;
1809     int frame_rate, frame_rate_base;
1810 } AbvEntry;
1811
1812 static AbvEntry frame_abvs[] = {
1813     { "ntsc",      720, 480, 30000, 1001 },
1814     { "pal",       720, 576,    25,    1 },
1815     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1816     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
1817     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
1818     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
1819     { "film",      352, 240,    24,    1 },
1820     { "ntsc-film", 352, 240, 24000, 1001 },
1821     { "sqcif",     128,  96,     0,    0 },
1822     { "qcif",      176, 144,     0,    0 },
1823     { "cif",       352, 288,     0,    0 },
1824     { "4cif",      704, 576,     0,    0 },
1825 };
1826
1827 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1828 {
1829     int i;
1830     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1831     const char *p;
1832     int frame_width = 0, frame_height = 0;
1833
1834     for(i=0;i<n;i++) {
1835         if (!strcmp(frame_abvs[i].abv, str)) {
1836             frame_width = frame_abvs[i].width;
1837             frame_height = frame_abvs[i].height;
1838             break;
1839         }
1840     }
1841     if (i == n) {
1842         p = str;
1843         frame_width = strtol(p, (char **)&p, 10);
1844         if (*p)
1845             p++;
1846         frame_height = strtol(p, (char **)&p, 10);
1847     }
1848     if (frame_width <= 0 || frame_height <= 0)
1849         return -1;
1850     *width_ptr = frame_width;
1851     *height_ptr = frame_height;
1852     return 0;
1853 }
1854
1855 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1856 {
1857     int i;
1858     char* cp;
1859
1860     /* First, we check our abbreviation table */
1861     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1862          if (!strcmp(frame_abvs[i].abv, arg)) {
1863              *frame_rate = frame_abvs[i].frame_rate;
1864              *frame_rate_base = frame_abvs[i].frame_rate_base;
1865              return 0;
1866          }
1867
1868     /* Then, we try to parse it as fraction */
1869     cp = strchr(arg, '/');
1870     if (cp) {
1871         char* cpp;
1872         *frame_rate = strtol(arg, &cpp, 10);
1873         if (cpp != arg || cpp == cp)
1874             *frame_rate_base = strtol(cp+1, &cpp, 10);
1875         else
1876            *frame_rate = 0;
1877     }
1878     else {
1879         /* Finally we give up and parse it as double */
1880         *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
1881         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1882     }
1883     if (!*frame_rate || !*frame_rate_base)
1884         return -1;
1885     else
1886         return 0;
1887 }
1888
1889 /* Syntax:
1890  * - If not a duration:
1891  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1892  * Time is localtime unless Z is suffixed to the end. In this case GMT
1893  * Return the date in micro seconds since 1970
1894  * - If duration:
1895  *  HH[:MM[:SS[.m...]]]
1896  *  S+[.m...]
1897  */
1898 int64_t parse_date(const char *datestr, int duration)
1899 {
1900     const char *p;
1901     int64_t t;
1902     struct tm dt;
1903     int i;
1904     static const char *date_fmt[] = {
1905         "%Y-%m-%d",
1906         "%Y%m%d",
1907     };
1908     static const char *time_fmt[] = {
1909         "%H:%M:%S",
1910         "%H%M%S",
1911     };
1912     const char *q;
1913     int is_utc, len;
1914     char lastch;
1915
1916 #undef time
1917     time_t now = time(0);
1918
1919     len = strlen(datestr);
1920     if (len > 0)
1921         lastch = datestr[len - 1];
1922     else
1923         lastch = '\0';
1924     is_utc = (lastch == 'z' || lastch == 'Z');
1925
1926     memset(&dt, 0, sizeof(dt));
1927
1928     p = datestr;
1929     q = NULL;
1930     if (!duration) {
1931         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1932             q = small_strptime(p, date_fmt[i], &dt);
1933             if (q) {
1934                 break;
1935             }
1936         }
1937
1938         if (!q) {
1939             if (is_utc) {
1940                 dt = *gmtime(&now);
1941             } else {
1942                 dt = *localtime(&now);
1943             }
1944             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1945         } else {
1946             p = q;
1947         }
1948
1949         if (*p == 'T' || *p == 't' || *p == ' ')
1950             p++;
1951
1952         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1953             q = small_strptime(p, time_fmt[i], &dt);
1954             if (q) {
1955                 break;
1956             }
1957         }
1958     } else {
1959         q = small_strptime(p, time_fmt[0], &dt);
1960         if (!q) {
1961             dt.tm_sec = strtol(p, (char **)&q, 10);
1962             dt.tm_min = 0;
1963             dt.tm_hour = 0;
1964         }
1965     }
1966
1967     /* Now we have all the fields that we can get */
1968     if (!q) {
1969         if (duration)
1970             return 0;
1971         else
1972             return now * int64_t_C(1000000);
1973     }
1974
1975     if (duration) {
1976         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1977     } else {
1978         dt.tm_isdst = -1;       /* unknown */
1979         if (is_utc) {
1980             t = mktimegm(&dt);
1981         } else {
1982             t = mktime(&dt);
1983         }
1984     }
1985
1986     t *= 1000000;
1987
1988     if (*q == '.') {
1989         int val, n;
1990         q++;
1991         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1992             if (!isdigit(*q))
1993                 break;
1994             val += n * (*q - '0');
1995         }
1996         t += val;
1997     }
1998     return t;
1999 }
2000
2001 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2002    1 if found */
2003 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2004 {
2005     const char *p;
2006     char tag[128], *q;
2007
2008     p = info;
2009     if (*p == '?')
2010         p++;
2011     for(;;) {
2012         q = tag;
2013         while (*p != '\0' && *p != '=' && *p != '&') {
2014             if ((q - tag) < sizeof(tag) - 1)
2015                 *q++ = *p;
2016             p++;
2017         }
2018         *q = '\0';
2019         q = arg;
2020         if (*p == '=') {
2021             p++;
2022             while (*p != '&' && *p != '\0') {
2023                 if ((q - arg) < arg_size - 1) {
2024                     if (*p == '+')
2025                         *q++ = ' ';
2026                     else
2027                         *q++ = *p;
2028                 }
2029                 p++;
2030             }
2031             *q = '\0';
2032         }
2033         if (!strcmp(tag, tag1))
2034             return 1;
2035         if (*p != '&')
2036             break;
2037         p++;
2038     }
2039     return 0;
2040 }
2041
2042 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2043    the '%0nd' format where 'n' is the total number of digits and
2044    '%%'. Return 0 if OK, and -1 if format error */
2045 int get_frame_filename(char *buf, int buf_size,
2046                        const char *path, int number)
2047 {
2048     const char *p;
2049     char *q, buf1[20], c;
2050     int nd, len, percentd_found;
2051
2052     q = buf;
2053     p = path;
2054     percentd_found = 0;
2055     for(;;) {
2056         c = *p++;
2057         if (c == '\0')
2058             break;
2059         if (c == '%') {
2060             do {
2061                 nd = 0;
2062                 while (isdigit(*p)) {
2063                     nd = nd * 10 + *p++ - '0';
2064                 }
2065                 c = *p++;
2066             } while (isdigit(c));
2067
2068             switch(c) {
2069             case '%':
2070                 goto addchar;
2071             case 'd':
2072                 if (percentd_found)
2073                     goto fail;
2074                 percentd_found = 1;
2075                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2076                 len = strlen(buf1);
2077                 if ((q - buf + len) > buf_size - 1)
2078                     goto fail;
2079                 memcpy(q, buf1, len);
2080                 q += len;
2081                 break;
2082             default:
2083                 goto fail;
2084             }
2085         } else {
2086         addchar:
2087             if ((q - buf) < buf_size - 1)
2088                 *q++ = c;
2089         }
2090     }
2091     if (!percentd_found)
2092         goto fail;
2093     *q = '\0';
2094     return 0;
2095  fail:
2096     *q = '\0';
2097     return -1;
2098 }
2099
2100 /**
2101  * Print  nice hexa dump of a buffer
2102  * @param f stream for output
2103  * @param buf buffer
2104  * @param size buffer size
2105  */
2106 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2107 {
2108     int len, i, j, c;
2109
2110     for(i=0;i<size;i+=16) {
2111         len = size - i;
2112         if (len > 16)
2113             len = 16;
2114         fprintf(f, "%08x ", i);
2115         for(j=0;j<16;j++) {
2116             if (j < len)
2117                 fprintf(f, " %02x", buf[i+j]);
2118             else
2119                 fprintf(f, "   ");
2120         }
2121         fprintf(f, " ");
2122         for(j=0;j<len;j++) {
2123             c = buf[i+j];
2124             if (c < ' ' || c > '~')
2125                 c = '.';
2126             fprintf(f, "%c", c);
2127         }
2128         fprintf(f, "\n");
2129     }
2130 }
2131
2132 /**
2133  * Print on 'f' a nice dump of a packet
2134  * @param f stream for output
2135  * @param pkt packet to dump
2136  * @param dump_payload true if the payload must be displayed too
2137  */
2138 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2139 {
2140     fprintf(f, "stream #%d:\n", pkt->stream_index);
2141     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2142     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2143     /* DTS is _always_ valid after av_read_frame() */
2144     fprintf(f, "  dts=");
2145     if (pkt->dts == AV_NOPTS_VALUE)
2146         fprintf(f, "N/A");
2147     else
2148         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2149     /* PTS may be not known if B frames are present */
2150     fprintf(f, "  pts=");
2151     if (pkt->pts == AV_NOPTS_VALUE)
2152         fprintf(f, "N/A");
2153     else
2154         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2155     fprintf(f, "\n");
2156     fprintf(f, "  size=%d\n", pkt->size);
2157     if (dump_payload)
2158         av_hex_dump(f, pkt->data, pkt->size);
2159 }
2160
2161 void url_split(char *proto, int proto_size,
2162                char *hostname, int hostname_size,
2163                int *port_ptr,
2164                char *path, int path_size,
2165                const char *url)
2166 {
2167     const char *p;
2168     char *q;
2169     int port;
2170
2171     port = -1;
2172
2173     p = url;
2174     q = proto;
2175     while (*p != ':' && *p != '\0') {
2176         if ((q - proto) < proto_size - 1)
2177             *q++ = *p;
2178         p++;
2179     }
2180     if (proto_size > 0)
2181         *q = '\0';
2182     if (*p == '\0') {
2183         if (proto_size > 0)
2184             proto[0] = '\0';
2185         if (hostname_size > 0)
2186             hostname[0] = '\0';
2187         p = url;
2188     } else {
2189         p++;
2190         if (*p == '/')
2191             p++;
2192         if (*p == '/')
2193             p++;
2194         q = hostname;
2195         while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2196             if ((q - hostname) < hostname_size - 1)
2197                 *q++ = *p;
2198             p++;
2199         }
2200         if (hostname_size > 0)
2201             *q = '\0';
2202         if (*p == ':') {
2203             p++;
2204             port = strtoul(p, (char **)&p, 10);
2205         }
2206     }
2207     if (port_ptr)
2208         *port_ptr = port;
2209     pstrcpy(path, path_size, p);
2210 }
2211
2212 /**
2213  * Set the pts for a given stream
2214  * @param s stream
2215  * @param pts_wrap_bits number of bits effectively used by the pts
2216  *        (used for wrap control, 33 is the value for MPEG)
2217  * @param pts_num numerator to convert to seconds (MPEG: 1)
2218  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2219  */
2220 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2221                      int pts_num, int pts_den)
2222 {
2223     s->pts_wrap_bits = pts_wrap_bits;
2224     s->pts_num = pts_num;
2225     s->pts_den = pts_den;
2226 }
2227
2228 /* fraction handling */
2229
2230 /**
2231  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2232  * as 0 <= num < den.
2233  *
2234  * @param f fractional number
2235  * @param val integer value
2236  * @param num must be >= 0
2237  * @param den must be >= 1
2238  */
2239 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2240 {
2241     num += (den >> 1);
2242     if (num >= den) {
2243         val += num / den;
2244         num = num % den;
2245     }
2246     f->val = val;
2247     f->num = num;
2248     f->den = den;
2249 }
2250
2251 /* set f to (val + 0.5) */
2252 void av_frac_set(AVFrac *f, int64_t val)
2253 {
2254     f->val = val;
2255     f->num = f->den >> 1;
2256 }
2257
2258 /**
2259  * Fractionnal addition to f: f = f + (incr / f->den)
2260  *
2261  * @param f fractional number
2262  * @param incr increment, can be positive or negative
2263  */
2264 void av_frac_add(AVFrac *f, int64_t incr)
2265 {
2266     int64_t num, den;
2267
2268     num = f->num + incr;
2269     den = f->den;
2270     if (num < 0) {
2271         f->val += num / den;
2272         num = num % den;
2273         if (num < 0) {
2274             num += den;
2275             f->val--;
2276         }
2277     } else if (num >= den) {
2278         f->val += num / den;
2279         num = num % den;
2280     }
2281     f->num = num;
2282 }
2283
2284 /**
2285  * register a new image format
2286  * @param img_fmt Image format descriptor
2287  */
2288 void av_register_image_format(AVImageFormat *img_fmt)
2289 {
2290     AVImageFormat **p;
2291
2292     p = &first_image_format;
2293     while (*p != NULL) p = &(*p)->next;
2294     *p = img_fmt;
2295     img_fmt->next = NULL;
2296 }
2297
2298 /* guess image format */
2299 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2300 {
2301     AVImageFormat *fmt1, *fmt;
2302     int score, score_max;
2303
2304     fmt = NULL;
2305     score_max = 0;
2306     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2307         if (fmt1->img_probe) {
2308             score = fmt1->img_probe(pd);
2309             if (score > score_max) {
2310                 score_max = score;
2311                 fmt = fmt1;
2312             }
2313         }
2314     }
2315     return fmt;
2316 }
2317
2318 AVImageFormat *guess_image_format(const char *filename)
2319 {
2320     AVImageFormat *fmt1;
2321
2322     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2323         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2324             return fmt1;
2325     }
2326     return NULL;
2327 }
2328
2329 /**
2330  * Read an image from a stream.
2331  * @param gb byte stream containing the image
2332  * @param fmt image format, NULL if probing is required
2333  */
2334 int av_read_image(ByteIOContext *pb, const char *filename,
2335                   AVImageFormat *fmt,
2336                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2337 {
2338     char buf[PROBE_BUF_SIZE];
2339     AVProbeData probe_data, *pd = &probe_data;
2340     offset_t pos;
2341     int ret;
2342
2343     if (!fmt) {
2344         pd->filename = filename;
2345         pd->buf = buf;
2346         pos = url_ftell(pb);
2347         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2348         url_fseek(pb, pos, SEEK_SET);
2349         fmt = av_probe_image_format(pd);
2350     }
2351     if (!fmt)
2352         return AVERROR_NOFMT;
2353     ret = fmt->img_read(pb, alloc_cb, opaque);
2354     return ret;
2355 }
2356
2357 /**
2358  * Write an image to a stream.
2359  * @param pb byte stream for the image output
2360  * @param fmt image format
2361  * @param img image data and informations
2362  */
2363 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2364 {
2365     return fmt->img_write(pb, img);
2366 }
2367