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