libavformat/aviobuf.c

   1 /*
   2  * Buffered I/O for ffmpeg system
   3  * Copyright (c) 2000,2001 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 #include "avio.h"
  21 #include <stdarg.h>
  22
  23 #define IO_BUFFER_SIZE 32768
  24
  25 int init_put_byte(ByteIOContext *s,
  26                   unsigned char *buffer,
  27                   int buffer_size,
  28                   int write_flag,
  29                   void *opaque,
  30                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
  31                   void (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
  32                   int (*seek)(void *opaque, offset_t offset, int whence))
  33 {
  34     s->buffer = buffer;
  35     s->buffer_size = buffer_size;
  36     s->buf_ptr = buffer;
  37     s->write_flag = write_flag;
  38     if (!s->write_flag)
  39         s->buf_end = buffer;
  40     else
  41         s->buf_end = buffer + buffer_size;
  42     s->opaque = opaque;
  43     s->write_packet = write_packet;
  44     s->read_packet = read_packet;
  45     s->seek = seek;
  46     s->pos = 0;
  47     s->must_flush = 0;
  48     s->eof_reached = 0;
  49     s->is_streamed = 0;
  50     s->max_packet_size = 0;
  51     s->checksum_ptr= NULL;
  52     s->update_checksum= NULL;
  53     return 0;
  54 }
  55
  56
  57 #ifdef CONFIG_ENCODERS
  58 static void flush_buffer(ByteIOContext *s)
  59 {
  60     if (s->buf_ptr > s->buffer) {
  61         if (s->write_packet)
  62             s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
  63         if(s->checksum_ptr){
  64             s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
  65             s->checksum_ptr= s->buffer;
  66         }
  67         s->pos += s->buf_ptr - s->buffer;
  68     }
  69     s->buf_ptr = s->buffer;
  70 }
  71
  72 void put_byte(ByteIOContext *s, int b)
  73 {
  74     *(s->buf_ptr)++ = b;
  75     if (s->buf_ptr >= s->buf_end)
  76         flush_buffer(s);
  77 }
  78
  79 void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
  80 {
  81     int len;
  82
  83     while (size > 0) {
  84         len = (s->buf_end - s->buf_ptr);
  85         if (len > size)
  86             len = size;
  87         memcpy(s->buf_ptr, buf, len);
  88         s->buf_ptr += len;
  89
  90         if (s->buf_ptr >= s->buf_end)
  91             flush_buffer(s);
  92
  93         buf += len;
  94         size -= len;
  95     }
  96 }
  97
  98 void put_flush_packet(ByteIOContext *s)
  99 {
 100     flush_buffer(s);
 101     s->must_flush = 0;
 102 }
 103 #endif //CONFIG_ENCODERS
 104
 105 offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)
 106 {
 107     offset_t offset1;
 108
 109     if (whence != SEEK_CUR && whence != SEEK_SET)
 110         return -EINVAL;
 111
 112 #ifdef CONFIG_ENCODERS
 113     if (s->write_flag) {
 114         if (whence == SEEK_CUR) {
 115             offset1 = s->pos + (s->buf_ptr - s->buffer);
 116             if (offset == 0)
 117                 return offset1;
 118             offset += offset1;
 119         }
 120         offset1 = offset - s->pos;
 121         if (!s->must_flush &&
 122             offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
 123             /* can do the seek inside the buffer */
 124             s->buf_ptr = s->buffer + offset1;
 125         } else {
 126             if (!s->seek)
 127                 return -EPIPE;
 128             flush_buffer(s);
 129             s->must_flush = 1;
 130             s->buf_ptr = s->buffer;
 131             s->seek(s->opaque, offset, SEEK_SET);
 132             s->pos = offset;
 133         }
 134     } else
 135 #endif //CONFIG_ENCODERS
 136     {
 137         if (whence == SEEK_CUR) {
 138             offset1 = s->pos - (s->buf_end - s->buffer) + (s->buf_ptr - s->buffer);
 139             if (offset == 0)
 140                 return offset1;
 141             offset += offset1;
 142         }
 143         offset1 = offset - (s->pos - (s->buf_end - s->buffer));
 144         if (offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
 145             /* can do the seek inside the buffer */
 146             s->buf_ptr = s->buffer + offset1;
 147         } else {
 148             if (!s->seek)
 149                 return -EPIPE;
 150             s->buf_ptr = s->buffer;
 151             s->buf_end = s->buffer;
 152             s->seek(s->opaque, offset, SEEK_SET);
 153             s->pos = offset;
 154         }
 155         s->eof_reached = 0;
 156     }
 157     return offset;
 158 }
 159
 160 void url_fskip(ByteIOContext *s, offset_t offset)
 161 {
 162     url_fseek(s, offset, SEEK_CUR);
 163 }
 164
 165 offset_t url_ftell(ByteIOContext *s)
 166 {
 167     return url_fseek(s, 0, SEEK_CUR);
 168 }
 169
 170 int url_feof(ByteIOContext *s)
 171 {
 172     return s->eof_reached;
 173 }
 174
 175 #ifdef CONFIG_ENCODERS
 176 void put_le32(ByteIOContext *s, unsigned int val)
 177 {
 178     put_byte(s, val);
 179     put_byte(s, val >> 8);
 180     put_byte(s, val >> 16);
 181     put_byte(s, val >> 24);
 182 }
 183
 184 void put_be32(ByteIOContext *s, unsigned int val)
 185 {
 186     put_byte(s, val >> 24);
 187     put_byte(s, val >> 16);
 188     put_byte(s, val >> 8);
 189     put_byte(s, val);
 190 }
 191
 192 /* IEEE format is assumed */
 193 void put_be64_double(ByteIOContext *s, double val)
 194 {
 195     union {
 196         double d;
 197         uint64_t ull;
 198     } u;
 199     u.d = val;
 200     put_be64(s, u.ull);
 201 }
 202
 203 void put_strz(ByteIOContext *s, const char *str)
 204 {
 205     if (str)
 206         put_buffer(s, (const unsigned char *) str, strlen(str) + 1);
 207     else
 208         put_byte(s, 0);
 209 }
 210
 211 void put_le64(ByteIOContext *s, uint64_t val)
 212 {
 213     put_le32(s, (uint32_t)(val & 0xffffffff));
 214     put_le32(s, (uint32_t)(val >> 32));
 215 }
 216
 217 void put_be64(ByteIOContext *s, uint64_t val)
 218 {
 219     put_be32(s, (uint32_t)(val >> 32));
 220     put_be32(s, (uint32_t)(val & 0xffffffff));
 221 }
 222
 223 void put_le16(ByteIOContext *s, unsigned int val)
 224 {
 225     put_byte(s, val);
 226     put_byte(s, val >> 8);
 227 }
 228
 229 void put_be16(ByteIOContext *s, unsigned int val)
 230 {
 231     put_byte(s, val >> 8);
 232     put_byte(s, val);
 233 }
 234
 235 void put_tag(ByteIOContext *s, const char *tag)
 236 {
 237     while (*tag) {
 238         put_byte(s, *tag++);
 239     }
 240 }
 241 #endif //CONFIG_ENCODERS
 242
 243 /* Input stream */
 244
 245 static void fill_buffer(ByteIOContext *s)
 246 {
 247     int len;
 248
 249     /* no need to do anything if EOF already reached */
 250     if (s->eof_reached)
 251         return;
 252
 253     if(s->checksum_ptr){
 254         s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr);
 255         s->checksum_ptr= s->buffer;
 256     }
 257
 258     len = s->read_packet(s->opaque, s->buffer, s->buffer_size);
 259     if (len <= 0) {
 260         /* do not modify buffer if EOF reached so that a seek back can
 261            be done without rereading data */
 262         s->eof_reached = 1;
 263     } else {
 264         s->pos += len;
 265         s->buf_ptr = s->buffer;
 266         s->buf_end = s->buffer + len;
 267     }
 268 }
 269
 270 unsigned long get_checksum(ByteIOContext *s){
 271     s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
 272     s->checksum_ptr= NULL;
 273     return s->checksum;
 274 }
 275
 276 void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum){
 277     s->update_checksum= update_checksum;
 278     s->checksum= s->update_checksum(checksum, NULL, 0);
 279     s->checksum_ptr= s->buf_ptr;
 280 }
 281
 282 /* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
 283    necessary */
 284 /* XXX: put an inline version */
 285 int get_byte(ByteIOContext *s)
 286 {
 287     if (s->buf_ptr < s->buf_end) {
 288         return *s->buf_ptr++;
 289     } else {
 290         fill_buffer(s);
 291         if (s->buf_ptr < s->buf_end)
 292             return *s->buf_ptr++;
 293         else
 294             return 0;
 295     }
 296 }
 297
 298 /* NOTE: return URL_EOF (-1) if EOF */
 299 int url_fgetc(ByteIOContext *s)
 300 {
 301     if (s->buf_ptr < s->buf_end) {
 302         return *s->buf_ptr++;
 303     } else {
 304         fill_buffer(s);
 305         if (s->buf_ptr < s->buf_end)
 306             return *s->buf_ptr++;
 307         else
 308             return URL_EOF;
 309     }
 310 }
 311
 312 int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
 313 {
 314     int len, size1;
 315
 316     size1 = size;
 317     while (size > 0) {
 318         len = s->buf_end - s->buf_ptr;
 319         if (len > size)
 320             len = size;
 321         if (len == 0) {
 322             fill_buffer(s);
 323             len = s->buf_end - s->buf_ptr;
 324             if (len == 0)
 325                 break;
 326         } else {
 327             memcpy(buf, s->buf_ptr, len);
 328             buf += len;
 329             s->buf_ptr += len;
 330             size -= len;
 331         }
 332     }
 333     return size1 - size;
 334 }
 335
 336 int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)
 337 {
 338     int len;
 339
 340     len = s->buf_end - s->buf_ptr;
 341     if (len == 0) {
 342         fill_buffer(s);
 343         len = s->buf_end - s->buf_ptr;
 344     }
 345     if (len > size)
 346         len = size;
 347     memcpy(buf, s->buf_ptr, len);
 348     s->buf_ptr += len;
 349     return len;
 350 }
 351
 352 unsigned int get_le16(ByteIOContext *s)
 353 {
 354     unsigned int val;
 355     val = get_byte(s);
 356     val |= get_byte(s) << 8;
 357     return val;
 358 }
 359
 360 unsigned int get_le32(ByteIOContext *s)
 361 {
 362     unsigned int val;
 363     val = get_byte(s);
 364     val |= get_byte(s) << 8;
 365     val |= get_byte(s) << 16;
 366     val |= get_byte(s) << 24;
 367     return val;
 368 }
 369
 370 uint64_t get_le64(ByteIOContext *s)
 371 {
 372     uint64_t val;
 373     val = (uint64_t)get_le32(s);
 374     val |= (uint64_t)get_le32(s) << 32;
 375     return val;
 376 }
 377
 378 unsigned int get_be16(ByteIOContext *s)
 379 {
 380     unsigned int val;
 381     val = get_byte(s) << 8;
 382     val |= get_byte(s);
 383     return val;
 384 }
 385
 386 unsigned int get_be32(ByteIOContext *s)
 387 {
 388     unsigned int val;
 389     val = get_byte(s) << 24;
 390     val |= get_byte(s) << 16;
 391     val |= get_byte(s) << 8;
 392     val |= get_byte(s);
 393     return val;
 394 }
 395
 396 double get_be64_double(ByteIOContext *s)
 397 {
 398     union {
 399         double d;
 400         uint64_t ull;
 401     } u;
 402
 403     u.ull = get_be64(s);
 404     return u.d;
 405 }
 406
 407 char *get_strz(ByteIOContext *s, char *buf, int maxlen)
 408 {
 409     int i = 0;
 410     char c;
 411
 412     while ((c = get_byte(s))) {
 413         if (i < maxlen-1)
 414             buf[i++] = c;
 415     }
 416
 417     buf[i] = 0; /* Ensure null terminated, but may be truncated */
 418
 419     return buf;
 420 }
 421
 422 uint64_t get_be64(ByteIOContext *s)
 423 {
 424     uint64_t val;
 425     val = (uint64_t)get_be32(s) << 32;
 426     val |= (uint64_t)get_be32(s);
 427     return val;
 428 }
 429
 430 /* link with avio functions */
 431
 432 #ifdef CONFIG_ENCODERS
 433 static void url_write_packet(void *opaque, uint8_t *buf, int buf_size)
 434 {
 435     URLContext *h = opaque;
 436     url_write(h, buf, buf_size);
 437 }
 438 #else
 439 #define url_write_packet NULL
 440 #endif //CONFIG_ENCODERS
 441
 442 static int url_read_packet(void *opaque, uint8_t *buf, int buf_size)
 443 {
 444     URLContext *h = opaque;
 445     return url_read(h, buf, buf_size);
 446 }
 447
 448 static int url_seek_packet(void *opaque, int64_t offset, int whence)
 449 {
 450     URLContext *h = opaque;
 451     url_seek(h, offset, whence);
 452     return 0;
 453 }
 454
 455 int url_fdopen(ByteIOContext *s, URLContext *h)
 456 {
 457     uint8_t *buffer;
 458     int buffer_size, max_packet_size;
 459
 460
 461     max_packet_size = url_get_max_packet_size(h);
 462     if (max_packet_size) {
 463         buffer_size = max_packet_size; /* no need to bufferize more than one packet */
 464     } else {
 465         buffer_size = IO_BUFFER_SIZE;
 466     }
 467     buffer = av_malloc(buffer_size);
 468     if (!buffer)
 469         return -ENOMEM;
 470
 471     if (init_put_byte(s, buffer, buffer_size,
 472                       (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
 473                       url_read_packet, url_write_packet, url_seek_packet) < 0) {
 474         av_free(buffer);
 475         return -EIO;
 476     }
 477     s->is_streamed = h->is_streamed;
 478     s->max_packet_size = max_packet_size;
 479     return 0;
 480 }
 481
 482 /* XXX: must be called before any I/O */
 483 int url_setbufsize(ByteIOContext *s, int buf_size)
 484 {
 485     uint8_t *buffer;
 486     buffer = av_malloc(buf_size);
 487     if (!buffer)
 488         return -ENOMEM;
 489
 490     av_free(s->buffer);
 491     s->buffer = buffer;
 492     s->buffer_size = buf_size;
 493     s->buf_ptr = buffer;
 494     if (!s->write_flag)
 495         s->buf_end = buffer;
 496     else
 497         s->buf_end = buffer + buf_size;
 498     return 0;
 499 }
 500
 501 /* NOTE: when opened as read/write, the buffers are only used for
 502    reading */
 503 int url_fopen(ByteIOContext *s, const char *filename, int flags)
 504 {
 505     URLContext *h;
 506     int err;
 507
 508     err = url_open(&h, filename, flags);
 509     if (err < 0)
 510         return err;
 511     err = url_fdopen(s, h);
 512     if (err < 0) {
 513         url_close(h);
 514         return err;
 515     }
 516     return 0;
 517 }
 518
 519 int url_fclose(ByteIOContext *s)
 520 {
 521     URLContext *h = s->opaque;
 522
 523     av_free(s->buffer);
 524     memset(s, 0, sizeof(ByteIOContext));
 525     return url_close(h);
 526 }
 527
 528 URLContext *url_fileno(ByteIOContext *s)
 529 {
 530     return s->opaque;
 531 }
 532
 533 #ifdef CONFIG_ENCODERS
 534 /* XXX: currently size is limited */
 535 int url_fprintf(ByteIOContext *s, const char *fmt, ...)
 536 {
 537     va_list ap;
 538     char buf[4096];
 539     int ret;
 540
 541     va_start(ap, fmt);
 542     ret = vsnprintf(buf, sizeof(buf), fmt, ap);
 543     va_end(ap);
 544     put_buffer(s, buf, strlen(buf));
 545     return ret;
 546 }
 547 #endif //CONFIG_ENCODERS
 548
 549 /* note: unlike fgets, the EOL character is not returned and a whole
 550    line is parsed. return NULL if first char read was EOF */
 551 char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
 552 {
 553     int c;
 554     char *q;
 555
 556     c = url_fgetc(s);
 557     if (c == EOF)
 558         return NULL;
 559     q = buf;
 560     for(;;) {
 561         if (c == EOF || c == '\n')
 562             break;
 563         if ((q - buf) < buf_size - 1)
 564             *q++ = c;
 565         c = url_fgetc(s);
 566     }
 567     if (buf_size > 0)
 568         *q = '\0';
 569     return buf;
 570 }
 571
 572 /*
 573  * Return the maximum packet size associated to packetized buffered file
 574  * handle. If the file is not packetized (stream like http or file on
 575  * disk), then 0 is returned.
 576  *
 577  * @param h buffered file handle
 578  * @return maximum packet size in bytes
 579  */
 580 int url_fget_max_packet_size(ByteIOContext *s)
 581 {
 582     return s->max_packet_size;
 583 }
 584
 585 #ifdef CONFIG_ENCODERS
 586 /* buffer handling */
 587 int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags)
 588 {
 589     return init_put_byte(s, buf, buf_size,
 590                          (flags & URL_WRONLY || flags & URL_RDWR),
 591                          NULL, NULL, NULL, NULL);
 592 }
 593
 594 /* return the written or read size */
 595 int url_close_buf(ByteIOContext *s)
 596 {
 597     put_flush_packet(s);
 598     return s->buf_ptr - s->buffer;
 599 }
 600
 601 /* output in a dynamic buffer */
 602
 603 typedef struct DynBuffer {
 604     int pos, size, allocated_size;
 605     uint8_t *buffer;
 606     int io_buffer_size;
 607     uint8_t io_buffer[1];
 608 } DynBuffer;
 609
 610 static void dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
 611 {
 612     DynBuffer *d = opaque;
 613     int new_size, new_allocated_size;
 614
 615     /* reallocate buffer if needed */
 616     new_size = d->pos + buf_size;
 617     new_allocated_size = d->allocated_size;
 618     while (new_size > new_allocated_size) {
 619         if (!new_allocated_size)
 620             new_allocated_size = new_size;
 621         else
 622             new_allocated_size = (new_allocated_size * 3) / 2 + 1;
 623     }
 624
 625     if (new_allocated_size > d->allocated_size) {
 626         d->buffer = av_realloc(d->buffer, new_allocated_size);
 627         if(d->buffer == NULL)
 628              return ;
 629         d->allocated_size = new_allocated_size;
 630     }
 631     memcpy(d->buffer + d->pos, buf, buf_size);
 632     d->pos = new_size;
 633     if (d->pos > d->size)
 634         d->size = d->pos;
 635 }
 636
 637 static void dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
 638 {
 639     unsigned char buf1[4];
 640
 641     /* packetized write: output the header */
 642     buf1[0] = (buf_size >> 24);
 643     buf1[1] = (buf_size >> 16);
 644     buf1[2] = (buf_size >> 8);
 645     buf1[3] = (buf_size);
 646     dyn_buf_write(opaque, buf1, 4);
 647
 648     /* then the data */
 649     dyn_buf_write(opaque, buf, buf_size);
 650 }
 651
 652 static int dyn_buf_seek(void *opaque, offset_t offset, int whence)
 653 {
 654     DynBuffer *d = opaque;
 655
 656     if (whence == SEEK_CUR)
 657         offset += d->pos;
 658     else if (whence == SEEK_END)
 659         offset += d->size;
 660     if (offset < 0 || offset > 0x7fffffffLL)
 661         return -1;
 662     d->pos = offset;
 663     return 0;
 664 }
 665
 666 static int url_open_dyn_buf_internal(ByteIOContext *s, int max_packet_size)
 667 {
 668     DynBuffer *d;
 669     int io_buffer_size, ret;
 670
 671     if (max_packet_size)
 672         io_buffer_size = max_packet_size;
 673     else
 674         io_buffer_size = 1024;
 675
 676     d = av_malloc(sizeof(DynBuffer) + io_buffer_size);
 677     if (!d)
 678         return -1;
 679     d->io_buffer_size = io_buffer_size;
 680     d->buffer = NULL;
 681     d->pos = 0;
 682     d->size = 0;
 683     d->allocated_size = 0;
 684     ret = init_put_byte(s, d->io_buffer, io_buffer_size,
 685                         1, d, NULL,
 686                         max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
 687                         max_packet_size ? NULL : dyn_buf_seek);
 688     if (ret == 0) {
 689         s->max_packet_size = max_packet_size;
 690     }
 691     return ret;
 692 }
 693
 694 /*
 695  * Open a write only memory stream.
 696  *
 697  * @param s new IO context
 698  * @return zero if no error.
 699  */
 700 int url_open_dyn_buf(ByteIOContext *s)
 701 {
 702     return url_open_dyn_buf_internal(s, 0);
 703 }
 704
 705 /*
 706  * Open a write only packetized memory stream with a maximum packet
 707  * size of 'max_packet_size'.  The stream is stored in a memory buffer
 708  * with a big endian 4 byte header giving the packet size in bytes.
 709  *
 710  * @param s new IO context
 711  * @param max_packet_size maximum packet size (must be > 0)
 712  * @return zero if no error.
 713  */
 714 int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size)
 715 {
 716     if (max_packet_size <= 0)
 717         return -1;
 718     return url_open_dyn_buf_internal(s, max_packet_size);
 719 }
 720
 721 /*
 722  * Return the written size and a pointer to the buffer. The buffer
 723  *  must be freed with av_free().
 724  * @param s IO context
 725  * @param pointer to a byte buffer
 726  * @return the length of the byte buffer
 727  */
 728 int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
 729 {
 730     DynBuffer *d = s->opaque;
 731     int size;
 732
 733     put_flush_packet(s);
 734
 735     *pbuffer = d->buffer;
 736     size = d->size;
 737     av_free(d);
 738     return size;
 739 }
 740 #endif //CONFIG_ENCODERS