2 * Buffered I/O for ffmpeg system
3 * Copyright (c) 2000,2001 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/crc.h"
27 #define IO_BUFFER_SIZE 32768
29 static void fill_buffer(ByteIOContext
*s
);
31 int init_put_byte(ByteIOContext
*s
,
32 unsigned char *buffer
,
36 int (*read_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
37 int (*write_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
38 offset_t (*seek
)(void *opaque
, offset_t offset
, int whence
))
41 s
->buffer_size
= buffer_size
;
43 url_resetbuf(s
, write_flag
? URL_WRONLY
: URL_RDONLY
);
45 s
->write_packet
= write_packet
;
46 s
->read_packet
= read_packet
;
53 s
->max_packet_size
= 0;
54 s
->update_checksum
= NULL
;
55 if(!read_packet
&& !write_flag
){
57 s
->buf_end
= s
->buffer
+ buffer_size
;
64 ByteIOContext
*av_alloc_put_byte(
65 unsigned char *buffer
,
69 int (*read_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
70 int (*write_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
71 offset_t (*seek
)(void *opaque
, offset_t offset
, int whence
)) {
72 ByteIOContext
*s
= av_mallocz(sizeof(ByteIOContext
));
73 init_put_byte(s
, buffer
, buffer_size
, write_flag
, opaque
,
74 read_packet
, write_packet
, seek
);
78 static void flush_buffer(ByteIOContext
*s
)
80 if (s
->buf_ptr
> s
->buffer
) {
81 if (s
->write_packet
&& !s
->error
){
82 int ret
= s
->write_packet(s
->opaque
, s
->buffer
, s
->buf_ptr
- s
->buffer
);
87 if(s
->update_checksum
){
88 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_ptr
- s
->checksum_ptr
);
89 s
->checksum_ptr
= s
->buffer
;
91 s
->pos
+= s
->buf_ptr
- s
->buffer
;
93 s
->buf_ptr
= s
->buffer
;
96 void put_byte(ByteIOContext
*s
, int b
)
99 if (s
->buf_ptr
>= s
->buf_end
)
103 void put_buffer(ByteIOContext
*s
, const unsigned char *buf
, int size
)
108 len
= (s
->buf_end
- s
->buf_ptr
);
111 memcpy(s
->buf_ptr
, buf
, len
);
114 if (s
->buf_ptr
>= s
->buf_end
)
122 void put_flush_packet(ByteIOContext
*s
)
128 offset_t
url_fseek(ByteIOContext
*s
, offset_t offset
, int whence
)
134 return AVERROR(EINVAL
);
136 pos
= s
->pos
- (s
->write_flag
? 0 : (s
->buf_end
- s
->buffer
));
138 if (whence
!= SEEK_CUR
&& whence
!= SEEK_SET
)
139 return AVERROR(EINVAL
);
141 if (whence
== SEEK_CUR
) {
142 offset1
= pos
+ (s
->buf_ptr
- s
->buffer
);
147 offset1
= offset
- pos
;
148 if (!s
->must_flush
&&
149 offset1
>= 0 && offset1
< (s
->buf_end
- s
->buffer
)) {
150 /* can do the seek inside the buffer */
151 s
->buf_ptr
= s
->buffer
+ offset1
;
152 } else if(s
->is_streamed
&& !s
->write_flag
&&
153 offset1
>= 0 && offset1
< (s
->buf_end
- s
->buffer
) + (1<<16)){
154 while(s
->pos
< offset
&& !s
->eof_reached
)
157 return AVERROR(EPIPE
);
158 s
->buf_ptr
= s
->buf_end
+ offset
- s
->pos
;
160 offset_t res
= AVERROR(EPIPE
);
162 #if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK)
167 #endif /* defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) */
168 if (!s
->seek
|| (res
= s
->seek(s
->opaque
, offset
, SEEK_SET
)) < 0)
171 s
->buf_end
= s
->buffer
;
172 s
->buf_ptr
= s
->buffer
;
179 void url_fskip(ByteIOContext
*s
, offset_t offset
)
181 url_fseek(s
, offset
, SEEK_CUR
);
184 offset_t
url_ftell(ByteIOContext
*s
)
186 return url_fseek(s
, 0, SEEK_CUR
);
189 offset_t
url_fsize(ByteIOContext
*s
)
194 return AVERROR(EINVAL
);
197 return AVERROR(EPIPE
);
198 size
= s
->seek(s
->opaque
, 0, AVSEEK_SIZE
);
200 if ((size
= s
->seek(s
->opaque
, -1, SEEK_END
)) < 0)
203 s
->seek(s
->opaque
, s
->pos
, SEEK_SET
);
208 int url_feof(ByteIOContext
*s
)
212 return s
->eof_reached
;
215 int url_ferror(ByteIOContext
*s
)
222 void put_le32(ByteIOContext
*s
, unsigned int val
)
225 put_byte(s
, val
>> 8);
226 put_byte(s
, val
>> 16);
227 put_byte(s
, val
>> 24);
230 void put_be32(ByteIOContext
*s
, unsigned int val
)
232 put_byte(s
, val
>> 24);
233 put_byte(s
, val
>> 16);
234 put_byte(s
, val
>> 8);
238 void put_strz(ByteIOContext
*s
, const char *str
)
241 put_buffer(s
, (const unsigned char *) str
, strlen(str
) + 1);
246 void put_le64(ByteIOContext
*s
, uint64_t val
)
248 put_le32(s
, (uint32_t)(val
& 0xffffffff));
249 put_le32(s
, (uint32_t)(val
>> 32));
252 void put_be64(ByteIOContext
*s
, uint64_t val
)
254 put_be32(s
, (uint32_t)(val
>> 32));
255 put_be32(s
, (uint32_t)(val
& 0xffffffff));
258 void put_le16(ByteIOContext
*s
, unsigned int val
)
261 put_byte(s
, val
>> 8);
264 void put_be16(ByteIOContext
*s
, unsigned int val
)
266 put_byte(s
, val
>> 8);
270 void put_le24(ByteIOContext
*s
, unsigned int val
)
272 put_le16(s
, val
& 0xffff);
273 put_byte(s
, val
>> 16);
276 void put_be24(ByteIOContext
*s
, unsigned int val
)
278 put_be16(s
, val
>> 8);
282 void put_tag(ByteIOContext
*s
, const char *tag
)
291 static void fill_buffer(ByteIOContext
*s
)
295 /* no need to do anything if EOF already reached */
299 if(s
->update_checksum
){
300 if(s
->buf_end
> s
->checksum_ptr
)
301 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_end
- s
->checksum_ptr
);
302 s
->checksum_ptr
= s
->buffer
;
306 len
= s
->read_packet(s
->opaque
, s
->buffer
, s
->buffer_size
);
308 /* do not modify buffer if EOF reached so that a seek back can
309 be done without rereading data */
315 s
->buf_ptr
= s
->buffer
;
316 s
->buf_end
= s
->buffer
+ len
;
320 unsigned long ff_crc04C11DB7_update(unsigned long checksum
, const uint8_t *buf
, unsigned int len
){
321 return av_crc(av_crc_get_table(AV_CRC_32_IEEE
), checksum
, buf
, len
);
324 unsigned long get_checksum(ByteIOContext
*s
){
325 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_ptr
- s
->checksum_ptr
);
326 s
->update_checksum
= NULL
;
330 void init_checksum(ByteIOContext
*s
, unsigned long (*update_checksum
)(unsigned long c
, const uint8_t *p
, unsigned int len
), unsigned long checksum
){
331 s
->update_checksum
= update_checksum
;
332 if(s
->update_checksum
){
333 s
->checksum
= checksum
;
334 s
->checksum_ptr
= s
->buf_ptr
;
338 /* XXX: put an inline version */
339 int get_byte(ByteIOContext
*s
)
341 if (s
->buf_ptr
< s
->buf_end
) {
342 return *s
->buf_ptr
++;
345 if (s
->buf_ptr
< s
->buf_end
)
346 return *s
->buf_ptr
++;
352 int url_fgetc(ByteIOContext
*s
)
354 if (s
->buf_ptr
< s
->buf_end
) {
355 return *s
->buf_ptr
++;
358 if (s
->buf_ptr
< s
->buf_end
)
359 return *s
->buf_ptr
++;
365 int get_buffer(ByteIOContext
*s
, unsigned char *buf
, int size
)
371 len
= s
->buf_end
- s
->buf_ptr
;
375 if(size
> s
->buffer_size
&& !s
->update_checksum
){
377 len
= s
->read_packet(s
->opaque
, buf
, size
);
379 /* do not modify buffer if EOF reached so that a seek back can
380 be done without rereading data */
389 s
->buf_ptr
= s
->buffer
;
390 s
->buf_end
= s
->buffer
/* + len*/;
394 len
= s
->buf_end
- s
->buf_ptr
;
399 memcpy(buf
, s
->buf_ptr
, len
);
408 int get_partial_buffer(ByteIOContext
*s
, unsigned char *buf
, int size
)
415 len
= s
->buf_end
- s
->buf_ptr
;
418 len
= s
->buf_end
- s
->buf_ptr
;
422 memcpy(buf
, s
->buf_ptr
, len
);
427 unsigned int get_le16(ByteIOContext
*s
)
431 val
|= get_byte(s
) << 8;
435 unsigned int get_le24(ByteIOContext
*s
)
439 val
|= get_byte(s
) << 16;
443 unsigned int get_le32(ByteIOContext
*s
)
447 val
|= get_le16(s
) << 16;
451 uint64_t get_le64(ByteIOContext
*s
)
454 val
= (uint64_t)get_le32(s
);
455 val
|= (uint64_t)get_le32(s
) << 32;
459 unsigned int get_be16(ByteIOContext
*s
)
462 val
= get_byte(s
) << 8;
467 unsigned int get_be24(ByteIOContext
*s
)
470 val
= get_be16(s
) << 8;
474 unsigned int get_be32(ByteIOContext
*s
)
477 val
= get_be16(s
) << 16;
482 char *get_strz(ByteIOContext
*s
, char *buf
, int maxlen
)
487 while ((c
= get_byte(s
))) {
492 buf
[i
] = 0; /* Ensure null terminated, but may be truncated */
497 uint64_t get_be64(ByteIOContext
*s
)
500 val
= (uint64_t)get_be32(s
) << 32;
501 val
|= (uint64_t)get_be32(s
);
505 uint64_t ff_get_v(ByteIOContext
*bc
){
511 val
= (val
<<7) + (tmp
&127);
516 int url_fdopen(ByteIOContext
**s
, URLContext
*h
)
519 int buffer_size
, max_packet_size
;
522 max_packet_size
= url_get_max_packet_size(h
);
523 if (max_packet_size
) {
524 buffer_size
= max_packet_size
; /* no need to bufferize more than one packet */
526 buffer_size
= IO_BUFFER_SIZE
;
528 buffer
= av_malloc(buffer_size
);
530 return AVERROR(ENOMEM
);
532 *s
= av_mallocz(sizeof(ByteIOContext
));
535 return AVERROR(ENOMEM
);
538 if (init_put_byte(*s
, buffer
, buffer_size
,
539 (h
->flags
& URL_WRONLY
|| h
->flags
& URL_RDWR
), h
,
540 url_read
, url_write
, url_seek
) < 0) {
545 (*s
)->is_streamed
= h
->is_streamed
;
546 (*s
)->max_packet_size
= max_packet_size
;
548 (*s
)->read_pause
= (int (*)(void *, int))h
->prot
->url_read_pause
;
549 (*s
)->read_seek
= (offset_t (*)(void *, int, int64_t, int))h
->prot
->url_read_seek
;
554 int url_setbufsize(ByteIOContext
*s
, int buf_size
)
557 buffer
= av_malloc(buf_size
);
559 return AVERROR(ENOMEM
);
563 s
->buffer_size
= buf_size
;
565 url_resetbuf(s
, s
->write_flag
? URL_WRONLY
: URL_RDONLY
);
569 int url_resetbuf(ByteIOContext
*s
, int flags
)
571 URLContext
*h
= s
->opaque
;
572 if ((flags
& URL_RDWR
) || (h
&& h
->flags
!= flags
&& !h
->flags
& URL_RDWR
))
573 return AVERROR(EINVAL
);
575 if (flags
& URL_WRONLY
) {
576 s
->buf_end
= s
->buffer
+ s
->buffer_size
;
579 s
->buf_end
= s
->buffer
;
585 int url_fopen(ByteIOContext
**s
, const char *filename
, int flags
)
590 err
= url_open(&h
, filename
, flags
);
593 err
= url_fdopen(s
, h
);
601 int url_fclose(ByteIOContext
*s
)
603 URLContext
*h
= s
->opaque
;
610 URLContext
*url_fileno(ByteIOContext
*s
)
616 int url_fprintf(ByteIOContext
*s
, const char *fmt
, ...)
623 ret
= vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
625 put_buffer(s
, buf
, strlen(buf
));
628 #endif //CONFIG_MUXERS
630 char *url_fgets(ByteIOContext
*s
, char *buf
, int buf_size
)
640 if (c
== EOF
|| c
== '\n')
642 if ((q
- buf
) < buf_size
- 1)
651 int url_fget_max_packet_size(ByteIOContext
*s
)
653 return s
->max_packet_size
;
656 int av_url_read_fpause(ByteIOContext
*s
, int pause
)
659 return AVERROR(ENOSYS
);
660 return s
->read_pause(s
->opaque
, pause
);
663 offset_t
av_url_read_fseek(ByteIOContext
*s
,
664 int stream_index
, int64_t timestamp
, int flags
)
666 URLContext
*h
= s
->opaque
;
669 return AVERROR(ENOSYS
);
670 ret
= s
->read_seek(h
, stream_index
, timestamp
, flags
);
672 s
->buf_ptr
= s
->buf_end
; // Flush buffer
673 s
->pos
= s
->seek(h
, 0, SEEK_CUR
);
678 /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
679 * back to the server even if CONFIG_MUXERS is not set. */
680 #if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK)
681 /* buffer handling */
682 int url_open_buf(ByteIOContext
**s
, uint8_t *buf
, int buf_size
, int flags
)
685 *s
= av_mallocz(sizeof(ByteIOContext
));
687 return AVERROR(ENOMEM
);
688 ret
= init_put_byte(*s
, buf
, buf_size
,
689 (flags
& URL_WRONLY
|| flags
& URL_RDWR
),
690 NULL
, NULL
, NULL
, NULL
);
696 int url_close_buf(ByteIOContext
*s
)
699 return s
->buf_ptr
- s
->buffer
;
702 /* output in a dynamic buffer */
704 typedef struct DynBuffer
{
705 int pos
, size
, allocated_size
;
708 uint8_t io_buffer
[1];
711 static int dyn_buf_write(void *opaque
, uint8_t *buf
, int buf_size
)
713 DynBuffer
*d
= opaque
;
714 int new_size
, new_allocated_size
;
716 /* reallocate buffer if needed */
717 new_size
= d
->pos
+ buf_size
;
718 new_allocated_size
= d
->allocated_size
;
719 if(new_size
< d
->pos
|| new_size
> INT_MAX
/2)
721 while (new_size
> new_allocated_size
) {
722 if (!new_allocated_size
)
723 new_allocated_size
= new_size
;
725 new_allocated_size
+= new_allocated_size
/ 2 + 1;
728 if (new_allocated_size
> d
->allocated_size
) {
729 d
->buffer
= av_realloc(d
->buffer
, new_allocated_size
);
730 if(d
->buffer
== NULL
)
732 d
->allocated_size
= new_allocated_size
;
734 memcpy(d
->buffer
+ d
->pos
, buf
, buf_size
);
736 if (d
->pos
> d
->size
)
741 static int dyn_packet_buf_write(void *opaque
, uint8_t *buf
, int buf_size
)
743 unsigned char buf1
[4];
746 /* packetized write: output the header */
747 buf1
[0] = (buf_size
>> 24);
748 buf1
[1] = (buf_size
>> 16);
749 buf1
[2] = (buf_size
>> 8);
750 buf1
[3] = (buf_size
);
751 ret
= dyn_buf_write(opaque
, buf1
, 4);
756 return dyn_buf_write(opaque
, buf
, buf_size
);
759 static offset_t
dyn_buf_seek(void *opaque
, offset_t offset
, int whence
)
761 DynBuffer
*d
= opaque
;
763 if (whence
== SEEK_CUR
)
765 else if (whence
== SEEK_END
)
767 if (offset
< 0 || offset
> 0x7fffffffLL
)
773 static int url_open_dyn_buf_internal(ByteIOContext
**s
, int max_packet_size
)
776 int io_buffer_size
, ret
;
779 io_buffer_size
= max_packet_size
;
781 io_buffer_size
= 1024;
783 if(sizeof(DynBuffer
) + io_buffer_size
< io_buffer_size
)
785 d
= av_malloc(sizeof(DynBuffer
) + io_buffer_size
);
788 *s
= av_mallocz(sizeof(ByteIOContext
));
791 return AVERROR(ENOMEM
);
793 d
->io_buffer_size
= io_buffer_size
;
797 d
->allocated_size
= 0;
798 ret
= init_put_byte(*s
, d
->io_buffer
, io_buffer_size
,
800 max_packet_size
? dyn_packet_buf_write
: dyn_buf_write
,
801 max_packet_size
? NULL
: dyn_buf_seek
);
803 (*s
)->max_packet_size
= max_packet_size
;
811 int url_open_dyn_buf(ByteIOContext
**s
)
813 return url_open_dyn_buf_internal(s
, 0);
816 int url_open_dyn_packet_buf(ByteIOContext
**s
, int max_packet_size
)
818 if (max_packet_size
<= 0)
820 return url_open_dyn_buf_internal(s
, max_packet_size
);
823 int url_close_dyn_buf(ByteIOContext
*s
, uint8_t **pbuffer
)
825 DynBuffer
*d
= s
->opaque
;
830 *pbuffer
= d
->buffer
;
836 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */