libavformat/aviobuf.c

   1 /*
   2  * Buffered I/O for ffmpeg system
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/crc.h"
  23 #include "libavutil/intreadwrite.h"
  24 #include "avformat.h"
  25 #include "avio.h"
  26 #include <stdarg.h>
  27
  28 #define IO_BUFFER_SIZE 32768
  29
  30 static void fill_buffer(ByteIOContext *s);
  31
  32 int init_put_byte(ByteIOContext *s,
  33                   unsigned char *buffer,
  34                   int buffer_size,
  35                   int write_flag,
  36                   void *opaque,
  37                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
  38                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
  39                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
  40 {
  41     s->buffer = buffer;
  42     s->buffer_size = buffer_size;
  43     s->buf_ptr = buffer;
  44     s->opaque = opaque;
  45     url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY);
  46     s->write_packet = write_packet;
  47     s->read_packet = read_packet;
  48     s->seek = seek;
  49     s->pos = 0;
  50     s->must_flush = 0;
  51     s->eof_reached = 0;
  52     s->error = 0;
  53     s->is_streamed = 0;
  54     s->max_packet_size = 0;
  55     s->update_checksum= NULL;
  56     if(!read_packet && !write_flag){
  57         s->pos = buffer_size;
  58         s->buf_end = s->buffer + buffer_size;
  59     }
  60     s->read_pause = NULL;
  61     s->read_seek  = NULL;
  62     return 0;
  63 }
  64
  65 ByteIOContext *av_alloc_put_byte(
  66                   unsigned char *buffer,
  67                   int buffer_size,
  68                   int write_flag,
  69                   void *opaque,
  70                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
  71                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
  72                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
  73 {
  74     ByteIOContext *s = av_mallocz(sizeof(ByteIOContext));
  75     init_put_byte(s, buffer, buffer_size, write_flag, opaque,
  76                   read_packet, write_packet, seek);
  77     return s;
  78 }
  79
  80 static void flush_buffer(ByteIOContext *s)
  81 {
  82     if (s->buf_ptr > s->buffer) {
  83         if (s->write_packet && !s->error){
  84             int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
  85             if(ret < 0){
  86                 s->error = ret;
  87             }
  88         }
  89         if(s->update_checksum){
  90             s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
  91             s->checksum_ptr= s->buffer;
  92         }
  93         s->pos += s->buf_ptr - s->buffer;
  94     }
  95     s->buf_ptr = s->buffer;
  96 }
  97
  98 void put_byte(ByteIOContext *s, int b)
  99 {
 100     *(s->buf_ptr)++ = b;
 101     if (s->buf_ptr >= s->buf_end)
 102         flush_buffer(s);
 103 }
 104
 105 void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
 106 {
 107     while (size > 0) {
 108         int len = FFMIN(s->buf_end - s->buf_ptr, size);
 109         memcpy(s->buf_ptr, buf, len);
 110         s->buf_ptr += len;
 111
 112         if (s->buf_ptr >= s->buf_end)
 113             flush_buffer(s);
 114
 115         buf += len;
 116         size -= len;
 117     }
 118 }
 119
 120 void put_flush_packet(ByteIOContext *s)
 121 {
 122     flush_buffer(s);
 123     s->must_flush = 0;
 124 }
 125
 126 int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence)
 127 {
 128     int64_t offset1;
 129     int64_t pos;
 130
 131     if(!s)
 132         return AVERROR(EINVAL);
 133
 134     pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
 135
 136     if (whence != SEEK_CUR && whence != SEEK_SET)
 137         return AVERROR(EINVAL);
 138
 139     if (whence == SEEK_CUR) {
 140         offset1 = pos + (s->buf_ptr - s->buffer);
 141         if (offset == 0)
 142             return offset1;
 143         offset += offset1;
 144     }
 145     offset1 = offset - pos;
 146     if (!s->must_flush &&
 147         offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
 148         /* can do the seek inside the buffer */
 149         s->buf_ptr = s->buffer + offset1;
 150     } else if(s->is_streamed && !s->write_flag &&
 151               offset1 >= 0 && offset1 < (s->buf_end - s->buffer) + (1<<16)){
 152         while(s->pos < offset && !s->eof_reached)
 153             fill_buffer(s);
 154         if (s->eof_reached)
 155             return AVERROR(EPIPE);
 156         s->buf_ptr = s->buf_end + offset - s->pos;
 157     } else {
 158         int64_t res = AVERROR(EPIPE);
 159
 160 #if CONFIG_MUXERS || CONFIG_NETWORK
 161         if (s->write_flag) {
 162             flush_buffer(s);
 163             s->must_flush = 1;
 164         }
 165 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */
 166         if (!s->seek || (res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
 167             return res;
 168         if (!s->write_flag)
 169             s->buf_end = s->buffer;
 170         s->buf_ptr = s->buffer;
 171         s->pos = offset;
 172     }
 173     s->eof_reached = 0;
 174     return offset;
 175 }
 176
 177 void url_fskip(ByteIOContext *s, int64_t offset)
 178 {
 179     url_fseek(s, offset, SEEK_CUR);
 180 }
 181
 182 int64_t url_ftell(ByteIOContext *s)
 183 {
 184     return url_fseek(s, 0, SEEK_CUR);
 185 }
 186
 187 int64_t url_fsize(ByteIOContext *s)
 188 {
 189     int64_t size;
 190
 191     if(!s)
 192         return AVERROR(EINVAL);
 193
 194     if (!s->seek)
 195         return AVERROR(EPIPE);
 196     size = s->seek(s->opaque, 0, AVSEEK_SIZE);
 197     if(size<0){
 198         if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
 199             return size;
 200         size++;
 201         s->seek(s->opaque, s->pos, SEEK_SET);
 202     }
 203     return size;
 204 }
 205
 206 int url_feof(ByteIOContext *s)
 207 {
 208     if(!s)
 209         return 0;
 210     return s->eof_reached;
 211 }
 212
 213 int url_ferror(ByteIOContext *s)
 214 {
 215     if(!s)
 216         return 0;
 217     return s->error;
 218 }
 219
 220 void put_le32(ByteIOContext *s, unsigned int val)
 221 {
 222     put_byte(s, val);
 223     put_byte(s, val >> 8);
 224     put_byte(s, val >> 16);
 225     put_byte(s, val >> 24);
 226 }
 227
 228 void put_be32(ByteIOContext *s, unsigned int val)
 229 {
 230     put_byte(s, val >> 24);
 231     put_byte(s, val >> 16);
 232     put_byte(s, val >> 8);
 233     put_byte(s, val);
 234 }
 235
 236 void put_strz(ByteIOContext *s, const char *str)
 237 {
 238     if (str)
 239         put_buffer(s, (const unsigned char *) str, strlen(str) + 1);
 240     else
 241         put_byte(s, 0);
 242 }
 243
 244 void put_le64(ByteIOContext *s, uint64_t val)
 245 {
 246     put_le32(s, (uint32_t)(val & 0xffffffff));
 247     put_le32(s, (uint32_t)(val >> 32));
 248 }
 249
 250 void put_be64(ByteIOContext *s, uint64_t val)
 251 {
 252     put_be32(s, (uint32_t)(val >> 32));
 253     put_be32(s, (uint32_t)(val & 0xffffffff));
 254 }
 255
 256 void put_le16(ByteIOContext *s, unsigned int val)
 257 {
 258     put_byte(s, val);
 259     put_byte(s, val >> 8);
 260 }
 261
 262 void put_be16(ByteIOContext *s, unsigned int val)
 263 {
 264     put_byte(s, val >> 8);
 265     put_byte(s, val);
 266 }
 267
 268 void put_le24(ByteIOContext *s, unsigned int val)
 269 {
 270     put_le16(s, val & 0xffff);
 271     put_byte(s, val >> 16);
 272 }
 273
 274 void put_be24(ByteIOContext *s, unsigned int val)
 275 {
 276     put_be16(s, val >> 8);
 277     put_byte(s, val);
 278 }
 279
 280 void put_tag(ByteIOContext *s, const char *tag)
 281 {
 282     while (*tag) {
 283         put_byte(s, *tag++);
 284     }
 285 }
 286
 287 /* Input stream */
 288
 289 static void fill_buffer(ByteIOContext *s)
 290 {
 291     uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_ptr : s->buffer;
 292     int len= s->buffer_size - (dst - s->buffer);
 293
 294     assert(s->buf_ptr == s->buf_end);
 295
 296     /* no need to do anything if EOF already reached */
 297     if (s->eof_reached)
 298         return;
 299
 300     if(s->update_checksum && dst == s->buffer){
 301         if(s->buf_end > s->checksum_ptr)
 302             s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr);
 303         s->checksum_ptr= s->buffer;
 304     }
 305
 306     if(s->read_packet)
 307         len = s->read_packet(s->opaque, dst, len);
 308     else
 309         len = 0;
 310     if (len <= 0) {
 311         /* do not modify buffer if EOF reached so that a seek back can
 312            be done without rereading data */
 313         s->eof_reached = 1;
 314         if(len<0)
 315             s->error= len;
 316     } else {
 317         s->pos += len;
 318         s->buf_ptr = dst;
 319         s->buf_end = dst + len;
 320     }
 321 }
 322
 323 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
 324                                     unsigned int len)
 325 {
 326     return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
 327 }
 328
 329 unsigned long get_checksum(ByteIOContext *s)
 330 {
 331     s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
 332     s->update_checksum= NULL;
 333     return s->checksum;
 334 }
 335
 336 void init_checksum(ByteIOContext *s,
 337                    unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
 338                    unsigned long checksum)
 339 {
 340     s->update_checksum= update_checksum;
 341     if(s->update_checksum){
 342         s->checksum= checksum;
 343         s->checksum_ptr= s->buf_ptr;
 344     }
 345 }
 346
 347 /* XXX: put an inline version */
 348 int get_byte(ByteIOContext *s)
 349 {
 350     if (s->buf_ptr < s->buf_end) {
 351         return *s->buf_ptr++;
 352     } else {
 353         fill_buffer(s);
 354         if (s->buf_ptr < s->buf_end)
 355             return *s->buf_ptr++;
 356         else
 357             return 0;
 358     }
 359 }
 360
 361 int url_fgetc(ByteIOContext *s)
 362 {
 363     if (s->buf_ptr < s->buf_end) {
 364         return *s->buf_ptr++;
 365     } else {
 366         fill_buffer(s);
 367         if (s->buf_ptr < s->buf_end)
 368             return *s->buf_ptr++;
 369         else
 370             return URL_EOF;
 371     }
 372 }
 373
 374 int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
 375 {
 376     int len, size1;
 377
 378     size1 = size;
 379     while (size > 0) {
 380         len = s->buf_end - s->buf_ptr;
 381         if (len > size)
 382             len = size;
 383         if (len == 0) {
 384             if(size > s->buffer_size && !s->update_checksum){
 385                 if(s->read_packet)
 386                     len = s->read_packet(s->opaque, buf, size);
 387                 if (len <= 0) {
 388                     /* do not modify buffer if EOF reached so that a seek back can
 389                     be done without rereading data */
 390                     s->eof_reached = 1;
 391                     if(len<0)
 392                         s->error= len;
 393                     break;
 394                 } else {
 395                     s->pos += len;
 396                     size -= len;
 397                     buf += len;
 398                     s->buf_ptr = s->buffer;
 399                     s->buf_end = s->buffer/* + len*/;
 400                 }
 401             }else{
 402                 fill_buffer(s);
 403                 len = s->buf_end - s->buf_ptr;
 404                 if (len == 0)
 405                     break;
 406             }
 407         } else {
 408             memcpy(buf, s->buf_ptr, len);
 409             buf += len;
 410             s->buf_ptr += len;
 411             size -= len;
 412         }
 413     }
 414     if (size1 == size) {
 415         if (url_ferror(s)) return url_ferror(s);
 416         if (url_feof(s))   return AVERROR_EOF;
 417     }
 418     return size1 - size;
 419 }
 420
 421 int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)
 422 {
 423     int len;
 424
 425     if(size<0)
 426         return -1;
 427
 428     len = s->buf_end - s->buf_ptr;
 429     if (len == 0) {
 430         fill_buffer(s);
 431         len = s->buf_end - s->buf_ptr;
 432     }
 433     if (len > size)
 434         len = size;
 435     memcpy(buf, s->buf_ptr, len);
 436     s->buf_ptr += len;
 437     if (!len) {
 438         if (url_ferror(s)) return url_ferror(s);
 439         if (url_feof(s))   return AVERROR_EOF;
 440     }
 441     return len;
 442 }
 443
 444 unsigned int get_le16(ByteIOContext *s)
 445 {
 446     unsigned int val;
 447     val = get_byte(s);
 448     val |= get_byte(s) << 8;
 449     return val;
 450 }
 451
 452 unsigned int get_le24(ByteIOContext *s)
 453 {
 454     unsigned int val;
 455     val = get_le16(s);
 456     val |= get_byte(s) << 16;
 457     return val;
 458 }
 459
 460 unsigned int get_le32(ByteIOContext *s)
 461 {
 462     unsigned int val;
 463     val = get_le16(s);
 464     val |= get_le16(s) << 16;
 465     return val;
 466 }
 467
 468 uint64_t get_le64(ByteIOContext *s)
 469 {
 470     uint64_t val;
 471     val = (uint64_t)get_le32(s);
 472     val |= (uint64_t)get_le32(s) << 32;
 473     return val;
 474 }
 475
 476 unsigned int get_be16(ByteIOContext *s)
 477 {
 478     unsigned int val;
 479     val = get_byte(s) << 8;
 480     val |= get_byte(s);
 481     return val;
 482 }
 483
 484 unsigned int get_be24(ByteIOContext *s)
 485 {
 486     unsigned int val;
 487     val = get_be16(s) << 8;
 488     val |= get_byte(s);
 489     return val;
 490 }
 491 unsigned int get_be32(ByteIOContext *s)
 492 {
 493     unsigned int val;
 494     val = get_be16(s) << 16;
 495     val |= get_be16(s);
 496     return val;
 497 }
 498
 499 char *get_strz(ByteIOContext *s, char *buf, int maxlen)
 500 {
 501     int i = 0;
 502     char c;
 503
 504     while ((c = get_byte(s))) {
 505         if (i < maxlen-1)
 506             buf[i++] = c;
 507     }
 508
 509     buf[i] = 0; /* Ensure null terminated, but may be truncated */
 510
 511     return buf;
 512 }
 513
 514 uint64_t get_be64(ByteIOContext *s)
 515 {
 516     uint64_t val;
 517     val = (uint64_t)get_be32(s) << 32;
 518     val |= (uint64_t)get_be32(s);
 519     return val;
 520 }
 521
 522 uint64_t ff_get_v(ByteIOContext *bc){
 523     uint64_t val = 0;
 524     int tmp;
 525
 526     do{
 527         tmp = get_byte(bc);
 528         val= (val<<7) + (tmp&127);
 529     }while(tmp&128);
 530     return val;
 531 }
 532
 533 int url_fdopen(ByteIOContext **s, URLContext *h)
 534 {
 535     uint8_t *buffer;
 536     int buffer_size, max_packet_size;
 537
 538
 539     max_packet_size = url_get_max_packet_size(h);
 540     if (max_packet_size) {
 541         buffer_size = max_packet_size; /* no need to bufferize more than one packet */
 542     } else {
 543         buffer_size = IO_BUFFER_SIZE;
 544     }
 545     buffer = av_malloc(buffer_size);
 546     if (!buffer)
 547         return AVERROR(ENOMEM);
 548
 549     *s = av_mallocz(sizeof(ByteIOContext));
 550     if(!*s) {
 551         av_free(buffer);
 552         return AVERROR(ENOMEM);
 553     }
 554
 555     if (init_put_byte(*s, buffer, buffer_size,
 556                       (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
 557                       url_read, url_write, url_seek) < 0) {
 558         av_free(buffer);
 559         av_freep(s);
 560         return AVERROR(EIO);
 561     }
 562     (*s)->is_streamed = h->is_streamed;
 563     (*s)->max_packet_size = max_packet_size;
 564     if(h->prot) {
 565         (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
 566         (*s)->read_seek  = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
 567     }
 568     return 0;
 569 }
 570
 571 int url_setbufsize(ByteIOContext *s, int buf_size)
 572 {
 573     uint8_t *buffer;
 574     buffer = av_malloc(buf_size);
 575     if (!buffer)
 576         return AVERROR(ENOMEM);
 577
 578     av_free(s->buffer);
 579     s->buffer = buffer;
 580     s->buffer_size = buf_size;
 581     s->buf_ptr = buffer;
 582     url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY);
 583     return 0;
 584 }
 585
 586 int url_resetbuf(ByteIOContext *s, int flags)
 587 {
 588     URLContext *h = s->opaque;
 589     if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR))
 590         return AVERROR(EINVAL);
 591
 592     if (flags & URL_WRONLY) {
 593         s->buf_end = s->buffer + s->buffer_size;
 594         s->write_flag = 1;
 595     } else {
 596         s->buf_end = s->buffer;
 597         s->write_flag = 0;
 598     }
 599     return 0;
 600 }
 601
 602 int url_fopen(ByteIOContext **s, const char *filename, int flags)
 603 {
 604     URLContext *h;
 605     int err;
 606
 607     err = url_open(&h, filename, flags);
 608     if (err < 0)
 609         return err;
 610     err = url_fdopen(s, h);
 611     if (err < 0) {
 612         url_close(h);
 613         return err;
 614     }
 615     return 0;
 616 }
 617
 618 int url_fclose(ByteIOContext *s)
 619 {
 620     URLContext *h = s->opaque;
 621
 622     av_free(s->buffer);
 623     av_free(s);
 624     return url_close(h);
 625 }
 626
 627 URLContext *url_fileno(ByteIOContext *s)
 628 {
 629     return s->opaque;
 630 }
 631
 632 #if CONFIG_MUXERS
 633 int url_fprintf(ByteIOContext *s, const char *fmt, ...)
 634 {
 635     va_list ap;
 636     char buf[4096];
 637     int ret;
 638
 639     va_start(ap, fmt);
 640     ret = vsnprintf(buf, sizeof(buf), fmt, ap);
 641     va_end(ap);
 642     put_buffer(s, buf, strlen(buf));
 643     return ret;
 644 }
 645 #endif //CONFIG_MUXERS
 646
 647 char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
 648 {
 649     int c;
 650     char *q;
 651
 652     c = url_fgetc(s);
 653     if (c == EOF)
 654         return NULL;
 655     q = buf;
 656     for(;;) {
 657         if (c == EOF || c == '\n')
 658             break;
 659         if ((q - buf) < buf_size - 1)
 660             *q++ = c;
 661         c = url_fgetc(s);
 662     }
 663     if (buf_size > 0)
 664         *q = '\0';
 665     return buf;
 666 }
 667
 668 int url_fget_max_packet_size(ByteIOContext *s)
 669 {
 670     return s->max_packet_size;
 671 }
 672
 673 int av_url_read_fpause(ByteIOContext *s, int pause)
 674 {
 675     if (!s->read_pause)
 676         return AVERROR(ENOSYS);
 677     return s->read_pause(s->opaque, pause);
 678 }
 679
 680 int64_t av_url_read_fseek(ByteIOContext *s, int stream_index,
 681                           int64_t timestamp, int flags)
 682 {
 683     URLContext *h = s->opaque;
 684     int64_t ret;
 685     if (!s->read_seek)
 686         return AVERROR(ENOSYS);
 687     ret = s->read_seek(h, stream_index, timestamp, flags);
 688     if(ret >= 0) {
 689         s->buf_ptr = s->buf_end; // Flush buffer
 690         s->pos = s->seek(h, 0, SEEK_CUR);
 691     }
 692     return ret;
 693 }
 694
 695 /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
 696  * back to the server even if CONFIG_MUXERS is false. */
 697 #if CONFIG_MUXERS || CONFIG_NETWORK
 698 /* buffer handling */
 699 int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags)
 700 {
 701     int ret;
 702     *s = av_mallocz(sizeof(ByteIOContext));
 703     if(!*s)
 704         return AVERROR(ENOMEM);
 705     ret = init_put_byte(*s, buf, buf_size,
 706                         (flags & URL_WRONLY || flags & URL_RDWR),
 707                         NULL, NULL, NULL, NULL);
 708     if(ret != 0)
 709         av_freep(s);
 710     return ret;
 711 }
 712
 713 int url_close_buf(ByteIOContext *s)
 714 {
 715     put_flush_packet(s);
 716     return s->buf_ptr - s->buffer;
 717 }
 718
 719 /* output in a dynamic buffer */
 720
 721 typedef struct DynBuffer {
 722     int pos, size, allocated_size;
 723     uint8_t *buffer;
 724     int io_buffer_size;
 725     uint8_t io_buffer[1];
 726 } DynBuffer;
 727
 728 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
 729 {
 730     DynBuffer *d = opaque;
 731     unsigned new_size, new_allocated_size;
 732
 733     /* reallocate buffer if needed */
 734     new_size = d->pos + buf_size;
 735     new_allocated_size = d->allocated_size;
 736     if(new_size < d->pos || new_size > INT_MAX/2)
 737         return -1;
 738     while (new_size > new_allocated_size) {
 739         if (!new_allocated_size)
 740             new_allocated_size = new_size;
 741         else
 742             new_allocated_size += new_allocated_size / 2 + 1;
 743     }
 744
 745     if (new_allocated_size > d->allocated_size) {
 746         d->buffer = av_realloc(d->buffer, new_allocated_size);
 747         if(d->buffer == NULL)
 748              return AVERROR(ENOMEM);
 749         d->allocated_size = new_allocated_size;
 750     }
 751     memcpy(d->buffer + d->pos, buf, buf_size);
 752     d->pos = new_size;
 753     if (d->pos > d->size)
 754         d->size = d->pos;
 755     return buf_size;
 756 }
 757
 758 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
 759 {
 760     unsigned char buf1[4];
 761     int ret;
 762
 763     /* packetized write: output the header */
 764     AV_WB32(buf1, buf_size);
 765     ret= dyn_buf_write(opaque, buf1, 4);
 766     if(ret < 0)
 767         return ret;
 768
 769     /* then the data */
 770     return dyn_buf_write(opaque, buf, buf_size);
 771 }
 772
 773 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
 774 {
 775     DynBuffer *d = opaque;
 776
 777     if (whence == SEEK_CUR)
 778         offset += d->pos;
 779     else if (whence == SEEK_END)
 780         offset += d->size;
 781     if (offset < 0 || offset > 0x7fffffffLL)
 782         return -1;
 783     d->pos = offset;
 784     return 0;
 785 }
 786
 787 static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size)
 788 {
 789     DynBuffer *d;
 790     int ret;
 791     unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
 792
 793     if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
 794         return -1;
 795     d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
 796     if (!d)
 797         return AVERROR(ENOMEM);
 798     *s = av_mallocz(sizeof(ByteIOContext));
 799     if(!*s) {
 800         av_free(d);
 801         return AVERROR(ENOMEM);
 802     }
 803     d->io_buffer_size = io_buffer_size;
 804     ret = init_put_byte(*s, d->io_buffer, io_buffer_size,
 805                         1, d, NULL,
 806                         max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
 807                         max_packet_size ? NULL : dyn_buf_seek);
 808     if (ret == 0) {
 809         (*s)->max_packet_size = max_packet_size;
 810     } else {
 811         av_free(d);
 812         av_freep(s);
 813     }
 814     return ret;
 815 }
 816
 817 int url_open_dyn_buf(ByteIOContext **s)
 818 {
 819     return url_open_dyn_buf_internal(s, 0);
 820 }
 821
 822 int url_open_dyn_packet_buf(ByteIOContext **s, int max_packet_size)
 823 {
 824     if (max_packet_size <= 0)
 825         return -1;
 826     return url_open_dyn_buf_internal(s, max_packet_size);
 827 }
 828
 829 int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
 830 {
 831     DynBuffer *d = s->opaque;
 832     int size;
 833
 834     put_flush_packet(s);
 835
 836     *pbuffer = d->buffer;
 837     size = d->size;
 838     av_free(d);
 839     av_free(s);
 840     return size;
 841 }
 842 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */