ebc2f749103af00edb0c2585f70550404cdc308f
[ffmpeg.git] / 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