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