cb5f2790f7195a993600b1d9ebef72c3c211d673
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "avio_internal.h"
27 #include "internal.h"
28 #include <stdarg.h>
29
30 #define IO_BUFFER_SIZE 32768
31
32 /**
33  * Do seeks within this distance ahead of the current buffer by skipping
34  * data instead of calling the protocol seek function, for seekable
35  * protocols.
36  */
37 #define SHORT_SEEK_THRESHOLD 4096
38
39 static void fill_buffer(AVIOContext *s);
40 #if !FF_API_URL_RESETBUF
41 static int url_resetbuf(AVIOContext *s, int flags);
42 #endif
43
44 int ffio_init_context(AVIOContext *s,
45                   unsigned char *buffer,
46                   int buffer_size,
47                   int write_flag,
48                   void *opaque,
49                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
50                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
51                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
52 {
53     s->buffer = buffer;
54     s->buffer_size = buffer_size;
55     s->buf_ptr = buffer;
56     s->opaque = opaque;
57     url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY);
58     s->write_packet = write_packet;
59     s->read_packet = read_packet;
60     s->seek = seek;
61     s->pos = 0;
62     s->must_flush = 0;
63     s->eof_reached = 0;
64     s->error = 0;
65 #if FF_API_OLD_AVIO
66     s->is_streamed = 0;
67 #endif
68     s->seekable = AVIO_SEEKABLE_NORMAL;
69     s->max_packet_size = 0;
70     s->update_checksum= NULL;
71     if(!read_packet && !write_flag){
72         s->pos = buffer_size;
73         s->buf_end = s->buffer + buffer_size;
74     }
75     s->read_pause = NULL;
76     s->read_seek  = NULL;
77     return 0;
78 }
79
80 #if FF_API_OLD_AVIO
81 int init_put_byte(AVIOContext *s,
82                   unsigned char *buffer,
83                   int buffer_size,
84                   int write_flag,
85                   void *opaque,
86                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
87                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
88                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
89 {
90     return ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
91                                 read_packet, write_packet, seek);
92 }
93 AVIOContext *av_alloc_put_byte(
94                   unsigned char *buffer,
95                   int buffer_size,
96                   int write_flag,
97                   void *opaque,
98                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
99                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
100                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
101 {
102     return avio_alloc_context(buffer, buffer_size, write_flag, opaque,
103                               read_packet, write_packet, seek);
104 }
105 #endif
106
107 AVIOContext *avio_alloc_context(
108                   unsigned char *buffer,
109                   int buffer_size,
110                   int write_flag,
111                   void *opaque,
112                   int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
113                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
114                   int64_t (*seek)(void *opaque, int64_t offset, int whence))
115 {
116     AVIOContext *s = av_mallocz(sizeof(AVIOContext));
117     ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
118                   read_packet, write_packet, seek);
119     return s;
120 }
121
122 static void flush_buffer(AVIOContext *s)
123 {
124     if (s->buf_ptr > s->buffer) {
125         if (s->write_packet && !s->error){
126             int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
127             if(ret < 0){
128                 s->error = ret;
129             }
130         }
131         if(s->update_checksum){
132             s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
133             s->checksum_ptr= s->buffer;
134         }
135         s->pos += s->buf_ptr - s->buffer;
136     }
137     s->buf_ptr = s->buffer;
138 }
139
140 void avio_w8(AVIOContext *s, int b)
141 {
142     *(s->buf_ptr)++ = b;
143     if (s->buf_ptr >= s->buf_end)
144         flush_buffer(s);
145 }
146
147 void ffio_fill(AVIOContext *s, int b, int count)
148 {
149     while (count > 0) {
150         int len = FFMIN(s->buf_end - s->buf_ptr, count);
151         memset(s->buf_ptr, b, len);
152         s->buf_ptr += len;
153
154         if (s->buf_ptr >= s->buf_end)
155             flush_buffer(s);
156
157         count -= len;
158     }
159 }
160
161 void avio_write(AVIOContext *s, const unsigned char *buf, int size)
162 {
163     while (size > 0) {
164         int len = FFMIN(s->buf_end - s->buf_ptr, size);
165         memcpy(s->buf_ptr, buf, len);
166         s->buf_ptr += len;
167
168         if (s->buf_ptr >= s->buf_end)
169             flush_buffer(s);
170
171         buf += len;
172         size -= len;
173     }
174 }
175
176 void avio_flush(AVIOContext *s)
177 {
178     flush_buffer(s);
179     s->must_flush = 0;
180 }
181
182 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
183 {
184     int64_t offset1;
185     int64_t pos;
186     int force = whence & AVSEEK_FORCE;
187     whence &= ~AVSEEK_FORCE;
188
189     if(!s)
190         return AVERROR(EINVAL);
191
192     pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
193
194     if (whence != SEEK_CUR && whence != SEEK_SET)
195         return AVERROR(EINVAL);
196
197     if (whence == SEEK_CUR) {
198         offset1 = pos + (s->buf_ptr - s->buffer);
199         if (offset == 0)
200             return offset1;
201         offset += offset1;
202     }
203     offset1 = offset - pos;
204     if (!s->must_flush &&
205         offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
206         /* can do the seek inside the buffer */
207         s->buf_ptr = s->buffer + offset1;
208     } else if ((!s->seekable ||
209                offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
210                !s->write_flag && offset1 >= 0 &&
211               (whence != SEEK_END || force)) {
212         while(s->pos < offset && !s->eof_reached)
213             fill_buffer(s);
214         if (s->eof_reached)
215             return AVERROR_EOF;
216         s->buf_ptr = s->buf_end + offset - s->pos;
217     } else {
218         int64_t res;
219
220 #if CONFIG_MUXERS || CONFIG_NETWORK
221         if (s->write_flag) {
222             flush_buffer(s);
223             s->must_flush = 1;
224         }
225 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */
226         if (!s->seek)
227             return AVERROR(EPIPE);
228         if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
229             return res;
230         if (!s->write_flag)
231             s->buf_end = s->buffer;
232         s->buf_ptr = s->buffer;
233         s->pos = offset;
234     }
235     s->eof_reached = 0;
236     return offset;
237 }
238
239 #if FF_API_OLD_AVIO
240 int url_fskip(AVIOContext *s, int64_t offset)
241 {
242     int64_t ret = avio_seek(s, offset, SEEK_CUR);
243     return ret < 0 ? ret : 0;
244 }
245
246 int64_t url_ftell(AVIOContext *s)
247 {
248     return avio_seek(s, 0, SEEK_CUR);
249 }
250 #endif
251
252 int64_t avio_size(AVIOContext *s)
253 {
254     int64_t size;
255
256     if(!s)
257         return AVERROR(EINVAL);
258
259     if (!s->seek)
260         return AVERROR(ENOSYS);
261     size = s->seek(s->opaque, 0, AVSEEK_SIZE);
262     if(size<0){
263         if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0)
264             return size;
265         size++;
266         s->seek(s->opaque, s->pos, SEEK_SET);
267     }
268     return size;
269 }
270
271 #if FF_API_OLD_AVIO
272 int url_feof(AVIOContext *s)
273 {
274     if(!s)
275         return 0;
276     return s->eof_reached;
277 }
278
279 int url_ferror(AVIOContext *s)
280 {
281     if(!s)
282         return 0;
283     return s->error;
284 }
285 #endif
286
287 void avio_wl32(AVIOContext *s, unsigned int val)
288 {
289     avio_w8(s, val);
290     avio_w8(s, val >> 8);
291     avio_w8(s, val >> 16);
292     avio_w8(s, val >> 24);
293 }
294
295 void avio_wb32(AVIOContext *s, unsigned int val)
296 {
297     avio_w8(s, val >> 24);
298     avio_w8(s, val >> 16);
299     avio_w8(s, val >> 8);
300     avio_w8(s, val);
301 }
302
303 #if FF_API_OLD_AVIO
304 void put_strz(AVIOContext *s, const char *str)
305 {
306     avio_put_str(s, str);
307 }
308
309 #define GET(name, type) \
310     type get_be ##name(AVIOContext *s) \
311 {\
312     return avio_rb ##name(s);\
313 }\
314     type get_le ##name(AVIOContext *s) \
315 {\
316     return avio_rl ##name(s);\
317 }
318
319 GET(16, unsigned int)
320 GET(24, unsigned int)
321 GET(32, unsigned int)
322 GET(64, uint64_t)
323
324 #undef GET
325
326 #define PUT(name, type ) \
327     void put_le ##name(AVIOContext *s, type val)\
328 {\
329         avio_wl ##name(s, val);\
330 }\
331     void put_be ##name(AVIOContext *s, type val)\
332 {\
333         avio_wb ##name(s, val);\
334 }
335
336 PUT(16, unsigned int)
337 PUT(24, unsigned int)
338 PUT(32, unsigned int)
339 PUT(64, uint64_t)
340 #undef PUT
341
342 int get_byte(AVIOContext *s)
343 {
344    return avio_r8(s);
345 }
346 int get_buffer(AVIOContext *s, unsigned char *buf, int size)
347 {
348     return avio_read(s, buf, size);
349 }
350 int get_partial_buffer(AVIOContext *s, unsigned char *buf, int size)
351 {
352     return ffio_read_partial(s, buf, size);
353 }
354 void put_byte(AVIOContext *s, int val)
355 {
356     avio_w8(s, val);
357 }
358 void put_buffer(AVIOContext *s, const unsigned char *buf, int size)
359 {
360     avio_write(s, buf, size);
361 }
362 void put_nbyte(AVIOContext *s, int b, int count)
363 {
364     ffio_fill(s, b, count);
365 }
366
367 int url_fopen(AVIOContext **s, const char *filename, int flags)
368 {
369     return avio_open(s, filename, flags);
370 }
371 int url_fclose(AVIOContext *s)
372 {
373     return avio_close(s);
374 }
375 int64_t url_fseek(AVIOContext *s, int64_t offset, int whence)
376 {
377     return avio_seek(s, offset, whence);
378 }
379 int64_t url_fsize(AVIOContext *s)
380 {
381     return avio_size(s);
382 }
383 int url_setbufsize(AVIOContext *s, int buf_size)
384 {
385     return ffio_set_buf_size(s, buf_size);
386 }
387 int url_fprintf(AVIOContext *s, const char *fmt, ...)
388 {
389     va_list ap;
390     char buf[4096];
391     int ret;
392
393     va_start(ap, fmt);
394     ret = vsnprintf(buf, sizeof(buf), fmt, ap);
395     va_end(ap);
396     avio_write(s, buf, strlen(buf));
397     return ret;
398 }
399 void put_flush_packet(AVIOContext *s)
400 {
401     avio_flush(s);
402 }
403 int av_url_read_fpause(AVIOContext *s, int pause)
404 {
405     return ffio_read_pause(s, pause);
406 }
407 int64_t av_url_read_fseek(AVIOContext *s, int stream_index,
408                          int64_t timestamp, int flags)
409 {
410     return ffio_read_seek(s, stream_index, timestamp, flags);
411 }
412 void init_checksum(AVIOContext *s,
413                    unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
414                    unsigned long checksum)
415 {
416     ffio_init_checksum(s, update_checksum, checksum);
417 }
418 unsigned long get_checksum(AVIOContext *s)
419 {
420     return ffio_get_checksum(s);
421 }
422 int url_open_dyn_buf(AVIOContext **s)
423 {
424     return avio_open_dyn_buf(s);
425 }
426 int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
427 {
428     return avio_close_dyn_buf(s, pbuffer);
429 }
430 #endif
431
432 int avio_put_str(AVIOContext *s, const char *str)
433 {
434     int len = 1;
435     if (str) {
436         len += strlen(str);
437         avio_write(s, (const unsigned char *) str, len);
438     } else
439         avio_w8(s, 0);
440     return len;
441 }
442
443 int avio_put_str16le(AVIOContext *s, const char *str)
444 {
445     const uint8_t *q = str;
446     int ret = 0;
447
448     while (*q) {
449         uint32_t ch;
450         uint16_t tmp;
451
452         GET_UTF8(ch, *q++, break;)
453         PUT_UTF16(ch, tmp, avio_wl16(s, tmp);ret += 2;)
454     }
455     avio_wl16(s, 0);
456     ret += 2;
457     return ret;
458 }
459
460 int ff_get_v_length(uint64_t val){
461     int i=1;
462
463     while(val>>=7)
464         i++;
465
466     return i;
467 }
468
469 void ff_put_v(AVIOContext *bc, uint64_t val){
470     int i= ff_get_v_length(val);
471
472     while(--i>0)
473         avio_w8(bc, 128 | (val>>(7*i)));
474
475     avio_w8(bc, val&127);
476 }
477
478 void avio_wl64(AVIOContext *s, uint64_t val)
479 {
480     avio_wl32(s, (uint32_t)(val & 0xffffffff));
481     avio_wl32(s, (uint32_t)(val >> 32));
482 }
483
484 void avio_wb64(AVIOContext *s, uint64_t val)
485 {
486     avio_wb32(s, (uint32_t)(val >> 32));
487     avio_wb32(s, (uint32_t)(val & 0xffffffff));
488 }
489
490 void avio_wl16(AVIOContext *s, unsigned int val)
491 {
492     avio_w8(s, val);
493     avio_w8(s, val >> 8);
494 }
495
496 void avio_wb16(AVIOContext *s, unsigned int val)
497 {
498     avio_w8(s, val >> 8);
499     avio_w8(s, val);
500 }
501
502 void avio_wl24(AVIOContext *s, unsigned int val)
503 {
504     avio_wl16(s, val & 0xffff);
505     avio_w8(s, val >> 16);
506 }
507
508 void avio_wb24(AVIOContext *s, unsigned int val)
509 {
510     avio_wb16(s, val >> 8);
511     avio_w8(s, val);
512 }
513
514 #if FF_API_OLD_AVIO
515 void put_tag(AVIOContext *s, const char *tag)
516 {
517     while (*tag) {
518         avio_w8(s, *tag++);
519     }
520 }
521 #endif
522
523 /* Input stream */
524
525 static void fill_buffer(AVIOContext *s)
526 {
527     uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_end : s->buffer;
528     int len= s->buffer_size - (dst - s->buffer);
529     int max_buffer_size = s->max_packet_size ? s->max_packet_size : IO_BUFFER_SIZE;
530
531     /* no need to do anything if EOF already reached */
532     if (s->eof_reached)
533         return;
534
535     if(s->update_checksum && dst == s->buffer){
536         if(s->buf_end > s->checksum_ptr)
537             s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr);
538         s->checksum_ptr= s->buffer;
539     }
540
541     /* make buffer smaller in case it ended up large after probing */
542     if (s->buffer_size > max_buffer_size) {
543         ffio_set_buf_size(s, max_buffer_size);
544
545         s->checksum_ptr = dst = s->buffer;
546         len = s->buffer_size;
547     }
548
549     if(s->read_packet)
550         len = s->read_packet(s->opaque, dst, len);
551     else
552         len = 0;
553     if (len <= 0) {
554         /* do not modify buffer if EOF reached so that a seek back can
555            be done without rereading data */
556         s->eof_reached = 1;
557         if(len<0)
558             s->error= len;
559     } else {
560         s->pos += len;
561         s->buf_ptr = dst;
562         s->buf_end = dst + len;
563     }
564 }
565
566 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf,
567                                     unsigned int len)
568 {
569     return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
570 }
571
572 unsigned long ffio_get_checksum(AVIOContext *s)
573 {
574     s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
575     s->update_checksum= NULL;
576     return s->checksum;
577 }
578
579 void ffio_init_checksum(AVIOContext *s,
580                    unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
581                    unsigned long checksum)
582 {
583     s->update_checksum= update_checksum;
584     if(s->update_checksum){
585         s->checksum= checksum;
586         s->checksum_ptr= s->buf_ptr;
587     }
588 }
589
590 /* XXX: put an inline version */
591 int avio_r8(AVIOContext *s)
592 {
593     if (s->buf_ptr >= s->buf_end)
594         fill_buffer(s);
595     if (s->buf_ptr < s->buf_end)
596         return *s->buf_ptr++;
597     return 0;
598 }
599
600 #if FF_API_OLD_AVIO
601 int url_fgetc(AVIOContext *s)
602 {
603     if (s->buf_ptr >= s->buf_end)
604         fill_buffer(s);
605     if (s->buf_ptr < s->buf_end)
606         return *s->buf_ptr++;
607     return URL_EOF;
608 }
609 #endif
610
611 int avio_read(AVIOContext *s, unsigned char *buf, int size)
612 {
613     int len, size1;
614
615     size1 = size;
616     while (size > 0) {
617         len = s->buf_end - s->buf_ptr;
618         if (len > size)
619             len = size;
620         if (len == 0) {
621             if(size > s->buffer_size && !s->update_checksum){
622                 if(s->read_packet)
623                     len = s->read_packet(s->opaque, buf, size);
624                 if (len <= 0) {
625                     /* do not modify buffer if EOF reached so that a seek back can
626                     be done without rereading data */
627                     s->eof_reached = 1;
628                     if(len<0)
629                         s->error= len;
630                     break;
631                 } else {
632                     s->pos += len;
633                     size -= len;
634                     buf += len;
635                     s->buf_ptr = s->buffer;
636                     s->buf_end = s->buffer/* + len*/;
637                 }
638             }else{
639                 fill_buffer(s);
640                 len = s->buf_end - s->buf_ptr;
641                 if (len == 0)
642                     break;
643             }
644         } else {
645             memcpy(buf, s->buf_ptr, len);
646             buf += len;
647             s->buf_ptr += len;
648             size -= len;
649         }
650     }
651     if (size1 == size) {
652         if (s->error)         return s->error;
653         if (s->eof_reached)   return AVERROR_EOF;
654     }
655     return size1 - size;
656 }
657
658 int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
659 {
660     int len;
661
662     if(size<0)
663         return -1;
664
665     len = s->buf_end - s->buf_ptr;
666     if (len == 0) {
667         fill_buffer(s);
668         len = s->buf_end - s->buf_ptr;
669     }
670     if (len > size)
671         len = size;
672     memcpy(buf, s->buf_ptr, len);
673     s->buf_ptr += len;
674     if (!len) {
675         if (s->error)         return s->error;
676         if (s->eof_reached)   return AVERROR_EOF;
677     }
678     return len;
679 }
680
681 unsigned int avio_rl16(AVIOContext *s)
682 {
683     unsigned int val;
684     val = avio_r8(s);
685     val |= avio_r8(s) << 8;
686     return val;
687 }
688
689 unsigned int avio_rl24(AVIOContext *s)
690 {
691     unsigned int val;
692     val = avio_rl16(s);
693     val |= avio_r8(s) << 16;
694     return val;
695 }
696
697 unsigned int avio_rl32(AVIOContext *s)
698 {
699     unsigned int val;
700     val = avio_rl16(s);
701     val |= avio_rl16(s) << 16;
702     return val;
703 }
704
705 uint64_t avio_rl64(AVIOContext *s)
706 {
707     uint64_t val;
708     val = (uint64_t)avio_rl32(s);
709     val |= (uint64_t)avio_rl32(s) << 32;
710     return val;
711 }
712
713 unsigned int avio_rb16(AVIOContext *s)
714 {
715     unsigned int val;
716     val = avio_r8(s) << 8;
717     val |= avio_r8(s);
718     return val;
719 }
720
721 unsigned int avio_rb24(AVIOContext *s)
722 {
723     unsigned int val;
724     val = avio_rb16(s) << 8;
725     val |= avio_r8(s);
726     return val;
727 }
728 unsigned int avio_rb32(AVIOContext *s)
729 {
730     unsigned int val;
731     val = avio_rb16(s) << 16;
732     val |= avio_rb16(s);
733     return val;
734 }
735
736 #if FF_API_OLD_AVIO
737 char *get_strz(AVIOContext *s, char *buf, int maxlen)
738 {
739     avio_get_str(s, INT_MAX, buf, maxlen);
740     return buf;
741 }
742 #endif
743
744 int ff_get_line(AVIOContext *s, char *buf, int maxlen)
745 {
746     int i = 0;
747     char c;
748
749     do {
750         c = avio_r8(s);
751         if (c && i < maxlen-1)
752             buf[i++] = c;
753     } while (c != '\n' && c);
754
755     buf[i] = 0;
756     return i;
757 }
758
759 int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
760 {
761     int i;
762
763     // reserve 1 byte for terminating 0
764     buflen = FFMIN(buflen - 1, maxlen);
765     for (i = 0; i < buflen; i++)
766         if (!(buf[i] = avio_r8(s)))
767             return i + 1;
768     if (buflen)
769         buf[i] = 0;
770     for (; i < maxlen; i++)
771         if (!avio_r8(s))
772             return i + 1;
773     return maxlen;
774 }
775
776 #define GET_STR16(type, read) \
777     int avio_get_str16 ##type(AVIOContext *pb, int maxlen, char *buf, int buflen)\
778 {\
779     char* q = buf;\
780     int ret = 0;\
781     while (ret + 1 < maxlen) {\
782         uint8_t tmp;\
783         uint32_t ch;\
784         GET_UTF16(ch, (ret += 2) <= maxlen ? read(pb) : 0, break;)\
785         if (!ch)\
786             break;\
787         PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)\
788     }\
789     *q = 0;\
790     return ret;\
791 }\
792
793 GET_STR16(le, avio_rl16)
794 GET_STR16(be, avio_rb16)
795
796 #undef GET_STR16
797
798 uint64_t avio_rb64(AVIOContext *s)
799 {
800     uint64_t val;
801     val = (uint64_t)avio_rb32(s) << 32;
802     val |= (uint64_t)avio_rb32(s);
803     return val;
804 }
805
806 uint64_t ffio_read_varlen(AVIOContext *bc){
807     uint64_t val = 0;
808     int tmp;
809
810     do{
811         tmp = avio_r8(bc);
812         val= (val<<7) + (tmp&127);
813     }while(tmp&128);
814     return val;
815 }
816
817 int url_fdopen(AVIOContext **s, URLContext *h)
818 {
819     uint8_t *buffer;
820     int buffer_size, max_packet_size;
821
822     max_packet_size = url_get_max_packet_size(h);
823     if (max_packet_size) {
824         buffer_size = max_packet_size; /* no need to bufferize more than one packet */
825     } else {
826         buffer_size = IO_BUFFER_SIZE;
827     }
828     buffer = av_malloc(buffer_size);
829     if (!buffer)
830         return AVERROR(ENOMEM);
831
832     *s = av_mallocz(sizeof(AVIOContext));
833     if(!*s) {
834         av_free(buffer);
835         return AVERROR(ENOMEM);
836     }
837
838     if (ffio_init_context(*s, buffer, buffer_size,
839                       (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
840                       url_read, url_write, url_seek) < 0) {
841         av_free(buffer);
842         av_freep(s);
843         return AVERROR(EIO);
844     }
845 #if FF_API_OLD_AVIO
846     (*s)->is_streamed = h->is_streamed;
847 #endif
848     (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
849     (*s)->max_packet_size = max_packet_size;
850     if(h->prot) {
851         (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
852         (*s)->read_seek  = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek;
853     }
854     return 0;
855 }
856
857 int ffio_set_buf_size(AVIOContext *s, int buf_size)
858 {
859     uint8_t *buffer;
860     buffer = av_malloc(buf_size);
861     if (!buffer)
862         return AVERROR(ENOMEM);
863
864     av_free(s->buffer);
865     s->buffer = buffer;
866     s->buffer_size = buf_size;
867     s->buf_ptr = buffer;
868     url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY);
869     return 0;
870 }
871
872 #if FF_API_URL_RESETBUF
873 int url_resetbuf(AVIOContext *s, int flags)
874 #else
875 static int url_resetbuf(AVIOContext *s, int flags)
876 #endif
877 {
878 #if FF_API_URL_RESETBUF
879     if (flags & URL_RDWR)
880         return AVERROR(EINVAL);
881 #else
882     assert(flags == URL_WRONLY || flags == URL_RDONLY);
883 #endif
884
885     if (flags & URL_WRONLY) {
886         s->buf_end = s->buffer + s->buffer_size;
887         s->write_flag = 1;
888     } else {
889         s->buf_end = s->buffer;
890         s->write_flag = 0;
891     }
892     return 0;
893 }
894
895 int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char *buf, int buf_size)
896 {
897     int64_t buffer_start;
898     int buffer_size;
899     int overlap, new_size, alloc_size;
900
901     if (s->write_flag)
902         return AVERROR(EINVAL);
903
904     buffer_size = s->buf_end - s->buffer;
905
906     /* the buffers must touch or overlap */
907     if ((buffer_start = s->pos - buffer_size) > buf_size)
908         return AVERROR(EINVAL);
909
910     overlap = buf_size - buffer_start;
911     new_size = buf_size + buffer_size - overlap;
912
913     alloc_size = FFMAX(s->buffer_size, new_size);
914     if (alloc_size > buf_size)
915         if (!(buf = av_realloc(buf, alloc_size)))
916             return AVERROR(ENOMEM);
917
918     if (new_size > buf_size) {
919         memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
920         buf_size = new_size;
921     }
922
923     av_free(s->buffer);
924     s->buf_ptr = s->buffer = buf;
925     s->buffer_size = alloc_size;
926     s->pos = buf_size;
927     s->buf_end = s->buf_ptr + buf_size;
928     s->eof_reached = 0;
929     s->must_flush = 0;
930
931     return 0;
932 }
933
934 int avio_open(AVIOContext **s, const char *filename, int flags)
935 {
936     URLContext *h;
937     int err;
938
939     err = url_open(&h, filename, flags);
940     if (err < 0)
941         return err;
942     err = url_fdopen(s, h);
943     if (err < 0) {
944         url_close(h);
945         return err;
946     }
947     return 0;
948 }
949
950 int avio_close(AVIOContext *s)
951 {
952     URLContext *h = s->opaque;
953
954     av_free(s->buffer);
955     av_free(s);
956     return url_close(h);
957 }
958
959 #if FF_API_OLD_AVIO
960 URLContext *url_fileno(AVIOContext *s)
961 {
962     return s->opaque;
963 }
964 #endif
965
966 int avio_printf(AVIOContext *s, const char *fmt, ...)
967 {
968     va_list ap;
969     char buf[4096];
970     int ret;
971
972     va_start(ap, fmt);
973     ret = vsnprintf(buf, sizeof(buf), fmt, ap);
974     va_end(ap);
975     avio_write(s, buf, strlen(buf));
976     return ret;
977 }
978
979 #if FF_API_OLD_AVIO
980 char *url_fgets(AVIOContext *s, char *buf, int buf_size)
981 {
982     int c;
983     char *q;
984
985     c = avio_r8(s);
986     if (s->eof_reached)
987         return NULL;
988     q = buf;
989     for(;;) {
990         if (s->eof_reached || c == '\n')
991             break;
992         if ((q - buf) < buf_size - 1)
993             *q++ = c;
994         c = avio_r8(s);
995     }
996     if (buf_size > 0)
997         *q = '\0';
998     return buf;
999 }
1000
1001 int url_fget_max_packet_size(AVIOContext *s)
1002 {
1003     return s->max_packet_size;
1004 }
1005 #endif
1006
1007 int ffio_read_pause(AVIOContext *s, int pause)
1008 {
1009     if (!s->read_pause)
1010         return AVERROR(ENOSYS);
1011     return s->read_pause(s->opaque, pause);
1012 }
1013
1014 int64_t ffio_read_seek(AVIOContext *s, int stream_index,
1015                        int64_t timestamp, int flags)
1016 {
1017     URLContext *h = s->opaque;
1018     int64_t ret;
1019     if (!s->read_seek)
1020         return AVERROR(ENOSYS);
1021     ret = s->read_seek(h, stream_index, timestamp, flags);
1022     if(ret >= 0) {
1023         int64_t pos;
1024         s->buf_ptr = s->buf_end; // Flush buffer
1025         pos = s->seek(h, 0, SEEK_CUR);
1026         if (pos >= 0)
1027             s->pos = pos;
1028         else if (pos != AVERROR(ENOSYS))
1029             ret = pos;
1030     }
1031     return ret;
1032 }
1033
1034 /* avio_open_dyn_buf and avio_close_dyn_buf are used in rtp.c to send a response
1035  * back to the server even if CONFIG_MUXERS is false. */
1036 #if CONFIG_MUXERS || CONFIG_NETWORK
1037 /* buffer handling */
1038 #if FF_API_OLD_AVIO
1039 int url_open_buf(AVIOContext **s, uint8_t *buf, int buf_size, int flags)
1040 {
1041     int ret;
1042     *s = av_mallocz(sizeof(AVIOContext));
1043     if(!*s)
1044         return AVERROR(ENOMEM);
1045     ret = ffio_init_context(*s, buf, buf_size,
1046                         (flags & URL_WRONLY || flags & URL_RDWR),
1047                         NULL, NULL, NULL, NULL);
1048     if(ret != 0)
1049         av_freep(s);
1050     return ret;
1051 }
1052
1053 int url_close_buf(AVIOContext *s)
1054 {
1055     avio_flush(s);
1056     return s->buf_ptr - s->buffer;
1057 }
1058 #endif
1059
1060 /* output in a dynamic buffer */
1061
1062 typedef struct DynBuffer {
1063     int pos, size, allocated_size;
1064     uint8_t *buffer;
1065     int io_buffer_size;
1066     uint8_t io_buffer[1];
1067 } DynBuffer;
1068
1069 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size)
1070 {
1071     DynBuffer *d = opaque;
1072     unsigned new_size, new_allocated_size;
1073
1074     /* reallocate buffer if needed */
1075     new_size = d->pos + buf_size;
1076     new_allocated_size = d->allocated_size;
1077     if(new_size < d->pos || new_size > INT_MAX/2)
1078         return -1;
1079     while (new_size > new_allocated_size) {
1080         if (!new_allocated_size)
1081             new_allocated_size = new_size;
1082         else
1083             new_allocated_size += new_allocated_size / 2 + 1;
1084     }
1085
1086     if (new_allocated_size > d->allocated_size) {
1087         d->buffer = av_realloc(d->buffer, new_allocated_size);
1088         if(d->buffer == NULL)
1089              return AVERROR(ENOMEM);
1090         d->allocated_size = new_allocated_size;
1091     }
1092     memcpy(d->buffer + d->pos, buf, buf_size);
1093     d->pos = new_size;
1094     if (d->pos > d->size)
1095         d->size = d->pos;
1096     return buf_size;
1097 }
1098
1099 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size)
1100 {
1101     unsigned char buf1[4];
1102     int ret;
1103
1104     /* packetized write: output the header */
1105     AV_WB32(buf1, buf_size);
1106     ret= dyn_buf_write(opaque, buf1, 4);
1107     if(ret < 0)
1108         return ret;
1109
1110     /* then the data */
1111     return dyn_buf_write(opaque, buf, buf_size);
1112 }
1113
1114 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence)
1115 {
1116     DynBuffer *d = opaque;
1117
1118     if (whence == SEEK_CUR)
1119         offset += d->pos;
1120     else if (whence == SEEK_END)
1121         offset += d->size;
1122     if (offset < 0 || offset > 0x7fffffffLL)
1123         return -1;
1124     d->pos = offset;
1125     return 0;
1126 }
1127
1128 static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
1129 {
1130     DynBuffer *d;
1131     int ret;
1132     unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
1133
1134     if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
1135         return -1;
1136     d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
1137     if (!d)
1138         return AVERROR(ENOMEM);
1139     *s = av_mallocz(sizeof(AVIOContext));
1140     if(!*s) {
1141         av_free(d);
1142         return AVERROR(ENOMEM);
1143     }
1144     d->io_buffer_size = io_buffer_size;
1145     ret = ffio_init_context(*s, d->io_buffer, io_buffer_size,
1146                         1, d, NULL,
1147                         max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
1148                         max_packet_size ? NULL : dyn_buf_seek);
1149     if (ret == 0) {
1150         (*s)->max_packet_size = max_packet_size;
1151     } else {
1152         av_free(d);
1153         av_freep(s);
1154     }
1155     return ret;
1156 }
1157
1158 int avio_open_dyn_buf(AVIOContext **s)
1159 {
1160     return url_open_dyn_buf_internal(s, 0);
1161 }
1162
1163 int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
1164 {
1165     if (max_packet_size <= 0)
1166         return -1;
1167     return url_open_dyn_buf_internal(s, max_packet_size);
1168 }
1169
1170 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
1171 {
1172     DynBuffer *d = s->opaque;
1173     int size;
1174     static const char padbuf[FF_INPUT_BUFFER_PADDING_SIZE] = {0};
1175     int padding = 0;
1176
1177     /* don't attempt to pad fixed-size packet buffers */
1178     if (!s->max_packet_size) {
1179         avio_write(s, padbuf, sizeof(padbuf));
1180         padding = FF_INPUT_BUFFER_PADDING_SIZE;
1181     }
1182
1183     avio_flush(s);
1184
1185     *pbuffer = d->buffer;
1186     size = d->size;
1187     av_free(d);
1188     av_free(s);
1189     return size - padding;
1190 }
1191 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */