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"
23 #include "libavutil/intreadwrite.h"
28 #define IO_BUFFER_SIZE 32768
30 static void fill_buffer(ByteIOContext
*s
);
32 int init_put_byte(ByteIOContext
*s
,
33 unsigned char *buffer
,
37 int (*read_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
38 int (*write_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
39 int64_t (*seek
)(void *opaque
, int64_t offset
, int whence
))
42 s
->buffer_size
= buffer_size
;
45 url_resetbuf(s
, write_flag
? URL_WRONLY
: URL_RDONLY
);
46 s
->write_packet
= write_packet
;
47 s
->read_packet
= read_packet
;
54 s
->max_packet_size
= 0;
55 s
->update_checksum
= NULL
;
56 if(!read_packet
&& !write_flag
){
58 s
->buf_end
= s
->buffer
+ buffer_size
;
65 ByteIOContext
*av_alloc_put_byte(
66 unsigned char *buffer
,
70 int (*read_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
71 int (*write_packet
)(void *opaque
, uint8_t *buf
, int buf_size
),
72 int64_t (*seek
)(void *opaque
, int64_t offset
, int whence
))
74 ByteIOContext
*s
= av_mallocz(sizeof(ByteIOContext
));
75 init_put_byte(s
, buffer
, buffer_size
, write_flag
, opaque
,
76 read_packet
, write_packet
, seek
);
80 static void flush_buffer(ByteIOContext
*s
)
82 if (s
->buf_ptr
> s
->buffer
) {
83 if (s
->write_packet
&& !s
->error
){
84 int ret
= s
->write_packet(s
->opaque
, s
->buffer
, s
->buf_ptr
- s
->buffer
);
89 if(s
->update_checksum
){
90 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_ptr
- s
->checksum_ptr
);
91 s
->checksum_ptr
= s
->buffer
;
93 s
->pos
+= s
->buf_ptr
- s
->buffer
;
95 s
->buf_ptr
= s
->buffer
;
98 void put_byte(ByteIOContext
*s
, int b
)
101 if (s
->buf_ptr
>= s
->buf_end
)
105 void put_buffer(ByteIOContext
*s
, const unsigned char *buf
, int size
)
110 len
= FFMIN(s
->buf_end
- s
->buf_ptr
, size
);
111 memcpy(s
->buf_ptr
, buf
, len
);
114 if (s
->buf_ptr
>= s
->buf_end
)
122 void put_flush_packet(ByteIOContext
*s
)
128 int64_t url_fseek(ByteIOContext
*s
, int64_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 int64_t res
= AVERROR(EPIPE
);
162 #if CONFIG_MUXERS || CONFIG_NETWORK
167 #endif /* CONFIG_MUXERS || 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
, int64_t offset
)
181 url_fseek(s
, offset
, SEEK_CUR
);
184 int64_t url_ftell(ByteIOContext
*s
)
186 return url_fseek(s
, 0, SEEK_CUR
);
189 int64_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
)
293 uint8_t *dst
= !s
->max_packet_size
&& s
->buf_end
- s
->buffer
< s
->buffer_size
? s
->buf_ptr
: s
->buffer
;
294 int len
= s
->buffer_size
- (dst
- s
->buffer
);
296 assert(s
->buf_ptr
== s
->buf_end
);
298 /* no need to do anything if EOF already reached */
302 if(s
->update_checksum
&& dst
== s
->buffer
){
303 if(s
->buf_end
> s
->checksum_ptr
)
304 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_end
- s
->checksum_ptr
);
305 s
->checksum_ptr
= s
->buffer
;
309 len
= s
->read_packet(s
->opaque
, dst
, len
);
313 /* do not modify buffer if EOF reached so that a seek back can
314 be done without rereading data */
321 s
->buf_end
= dst
+ len
;
325 unsigned long ff_crc04C11DB7_update(unsigned long checksum
, const uint8_t *buf
,
328 return av_crc(av_crc_get_table(AV_CRC_32_IEEE
), checksum
, buf
, len
);
331 unsigned long get_checksum(ByteIOContext
*s
)
333 s
->checksum
= s
->update_checksum(s
->checksum
, s
->checksum_ptr
, s
->buf_ptr
- s
->checksum_ptr
);
334 s
->update_checksum
= NULL
;
338 void init_checksum(ByteIOContext
*s
,
339 unsigned long (*update_checksum
)(unsigned long c
, const uint8_t *p
, unsigned int len
),
340 unsigned long checksum
)
342 s
->update_checksum
= update_checksum
;
343 if(s
->update_checksum
){
344 s
->checksum
= checksum
;
345 s
->checksum_ptr
= s
->buf_ptr
;
349 /* XXX: put an inline version */
350 int get_byte(ByteIOContext
*s
)
352 if (s
->buf_ptr
< s
->buf_end
) {
353 return *s
->buf_ptr
++;
356 if (s
->buf_ptr
< s
->buf_end
)
357 return *s
->buf_ptr
++;
363 int url_fgetc(ByteIOContext
*s
)
365 if (s
->buf_ptr
< s
->buf_end
) {
366 return *s
->buf_ptr
++;
369 if (s
->buf_ptr
< s
->buf_end
)
370 return *s
->buf_ptr
++;
376 int get_buffer(ByteIOContext
*s
, unsigned char *buf
, int size
)
382 len
= s
->buf_end
- s
->buf_ptr
;
386 if(size
> s
->buffer_size
&& !s
->update_checksum
){
388 len
= s
->read_packet(s
->opaque
, buf
, size
);
390 /* do not modify buffer if EOF reached so that a seek back can
391 be done without rereading data */
400 s
->buf_ptr
= s
->buffer
;
401 s
->buf_end
= s
->buffer
/* + len*/;
405 len
= s
->buf_end
- s
->buf_ptr
;
410 memcpy(buf
, s
->buf_ptr
, len
);
417 if (url_ferror(s
)) return url_ferror(s
);
418 if (url_feof(s
)) return AVERROR_EOF
;
423 int get_partial_buffer(ByteIOContext
*s
, unsigned char *buf
, int size
)
430 len
= s
->buf_end
- s
->buf_ptr
;
433 len
= s
->buf_end
- s
->buf_ptr
;
437 memcpy(buf
, s
->buf_ptr
, len
);
440 if (url_ferror(s
)) return url_ferror(s
);
441 if (url_feof(s
)) return AVERROR_EOF
;
446 unsigned int get_le16(ByteIOContext
*s
)
450 val
|= get_byte(s
) << 8;
454 unsigned int get_le24(ByteIOContext
*s
)
458 val
|= get_byte(s
) << 16;
462 unsigned int get_le32(ByteIOContext
*s
)
466 val
|= get_le16(s
) << 16;
470 uint64_t get_le64(ByteIOContext
*s
)
473 val
= (uint64_t)get_le32(s
);
474 val
|= (uint64_t)get_le32(s
) << 32;
478 unsigned int get_be16(ByteIOContext
*s
)
481 val
= get_byte(s
) << 8;
486 unsigned int get_be24(ByteIOContext
*s
)
489 val
= get_be16(s
) << 8;
493 unsigned int get_be32(ByteIOContext
*s
)
496 val
= get_be16(s
) << 16;
501 char *get_strz(ByteIOContext
*s
, char *buf
, int maxlen
)
506 while ((c
= get_byte(s
))) {
511 buf
[i
] = 0; /* Ensure null terminated, but may be truncated */
516 uint64_t get_be64(ByteIOContext
*s
)
519 val
= (uint64_t)get_be32(s
) << 32;
520 val
|= (uint64_t)get_be32(s
);
524 uint64_t ff_get_v(ByteIOContext
*bc
){
530 val
= (val
<<7) + (tmp
&127);
535 int url_fdopen(ByteIOContext
**s
, URLContext
*h
)
538 int buffer_size
, max_packet_size
;
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 */
545 buffer_size
= IO_BUFFER_SIZE
;
547 buffer
= av_malloc(buffer_size
);
549 return AVERROR(ENOMEM
);
551 *s
= av_mallocz(sizeof(ByteIOContext
));
554 return AVERROR(ENOMEM
);
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) {
564 (*s
)->is_streamed
= h
->is_streamed
;
565 (*s
)->max_packet_size
= max_packet_size
;
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
;
573 int url_setbufsize(ByteIOContext
*s
, int buf_size
)
576 buffer
= av_malloc(buf_size
);
578 return AVERROR(ENOMEM
);
582 s
->buffer_size
= buf_size
;
584 url_resetbuf(s
, s
->write_flag
? URL_WRONLY
: URL_RDONLY
);
588 int url_resetbuf(ByteIOContext
*s
, int flags
)
590 URLContext
*h
= s
->opaque
;
591 if ((flags
& URL_RDWR
) || (h
&& h
->flags
!= flags
&& !h
->flags
& URL_RDWR
))
592 return AVERROR(EINVAL
);
594 if (flags
& URL_WRONLY
) {
595 s
->buf_end
= s
->buffer
+ s
->buffer_size
;
598 s
->buf_end
= s
->buffer
;
604 int url_fopen(ByteIOContext
**s
, const char *filename
, int flags
)
609 err
= url_open(&h
, filename
, flags
);
612 err
= url_fdopen(s
, h
);
620 int url_fclose(ByteIOContext
*s
)
622 URLContext
*h
= s
->opaque
;
629 URLContext
*url_fileno(ByteIOContext
*s
)
635 int url_fprintf(ByteIOContext
*s
, const char *fmt
, ...)
642 ret
= vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
644 put_buffer(s
, buf
, strlen(buf
));
647 #endif //CONFIG_MUXERS
649 char *url_fgets(ByteIOContext
*s
, char *buf
, int buf_size
)
659 if (c
== EOF
|| c
== '\n')
661 if ((q
- buf
) < buf_size
- 1)
670 int url_fget_max_packet_size(ByteIOContext
*s
)
672 return s
->max_packet_size
;
675 int av_url_read_fpause(ByteIOContext
*s
, int pause
)
678 return AVERROR(ENOSYS
);
679 return s
->read_pause(s
->opaque
, pause
);
682 int64_t av_url_read_fseek(ByteIOContext
*s
, int stream_index
,
683 int64_t timestamp
, int flags
)
685 URLContext
*h
= s
->opaque
;
688 return AVERROR(ENOSYS
);
689 ret
= s
->read_seek(h
, stream_index
, timestamp
, flags
);
691 s
->buf_ptr
= s
->buf_end
; // Flush buffer
692 s
->pos
= s
->seek(h
, 0, SEEK_CUR
);
697 /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
698 * back to the server even if CONFIG_MUXERS is false. */
699 #if CONFIG_MUXERS || CONFIG_NETWORK
700 /* buffer handling */
701 int url_open_buf(ByteIOContext
**s
, uint8_t *buf
, int buf_size
, int flags
)
704 *s
= av_mallocz(sizeof(ByteIOContext
));
706 return AVERROR(ENOMEM
);
707 ret
= init_put_byte(*s
, buf
, buf_size
,
708 (flags
& URL_WRONLY
|| flags
& URL_RDWR
),
709 NULL
, NULL
, NULL
, NULL
);
715 int url_close_buf(ByteIOContext
*s
)
718 return s
->buf_ptr
- s
->buffer
;
721 /* output in a dynamic buffer */
723 typedef struct DynBuffer
{
724 int pos
, size
, allocated_size
;
727 uint8_t io_buffer
[1];
730 static int dyn_buf_write(void *opaque
, uint8_t *buf
, int buf_size
)
732 DynBuffer
*d
= opaque
;
733 unsigned new_size
, new_allocated_size
;
735 /* reallocate buffer if needed */
736 new_size
= d
->pos
+ buf_size
;
737 new_allocated_size
= d
->allocated_size
;
738 if(new_size
< d
->pos
|| new_size
> INT_MAX
/2)
740 while (new_size
> new_allocated_size
) {
741 if (!new_allocated_size
)
742 new_allocated_size
= new_size
;
744 new_allocated_size
+= new_allocated_size
/ 2 + 1;
747 if (new_allocated_size
> d
->allocated_size
) {
748 d
->buffer
= av_realloc(d
->buffer
, new_allocated_size
);
749 if(d
->buffer
== NULL
)
750 return AVERROR(ENOMEM
);
751 d
->allocated_size
= new_allocated_size
;
753 memcpy(d
->buffer
+ d
->pos
, buf
, buf_size
);
755 if (d
->pos
> d
->size
)
760 static int dyn_packet_buf_write(void *opaque
, uint8_t *buf
, int buf_size
)
762 unsigned char buf1
[4];
765 /* packetized write: output the header */
766 AV_WB32(buf1
, buf_size
);
767 ret
= dyn_buf_write(opaque
, buf1
, 4);
772 return dyn_buf_write(opaque
, buf
, buf_size
);
775 static int64_t dyn_buf_seek(void *opaque
, int64_t offset
, int whence
)
777 DynBuffer
*d
= opaque
;
779 if (whence
== SEEK_CUR
)
781 else if (whence
== SEEK_END
)
783 if (offset
< 0 || offset
> 0x7fffffffLL
)
789 static int url_open_dyn_buf_internal(ByteIOContext
**s
, int max_packet_size
)
793 unsigned io_buffer_size
= max_packet_size
? max_packet_size
: 1024;
795 if(sizeof(DynBuffer
) + io_buffer_size
< io_buffer_size
)
797 d
= av_mallocz(sizeof(DynBuffer
) + io_buffer_size
);
799 return AVERROR(ENOMEM
);
800 *s
= av_mallocz(sizeof(ByteIOContext
));
803 return AVERROR(ENOMEM
);
805 d
->io_buffer_size
= io_buffer_size
;
806 ret
= init_put_byte(*s
, d
->io_buffer
, io_buffer_size
,
808 max_packet_size
? dyn_packet_buf_write
: dyn_buf_write
,
809 max_packet_size
? NULL
: dyn_buf_seek
);
811 (*s
)->max_packet_size
= max_packet_size
;
819 int url_open_dyn_buf(ByteIOContext
**s
)
821 return url_open_dyn_buf_internal(s
, 0);
824 int url_open_dyn_packet_buf(ByteIOContext
**s
, int max_packet_size
)
826 if (max_packet_size
<= 0)
828 return url_open_dyn_buf_internal(s
, max_packet_size
);
831 int url_close_dyn_buf(ByteIOContext
*s
, uint8_t **pbuffer
)
833 DynBuffer
*d
= s
->opaque
;
838 *pbuffer
= d
->buffer
;
844 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */