Mercurial > libavformat.hg
annotate aviobuf.c @ 6306:175c5f6cb556 libavformat
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
If there is little unread data in the ByteIOContext buffer, this may lead
to reducing the size of the ByteIOContext buffer to little more the probe
data size. This can lead to suboptimal aviobuf behaviour, e.g. making some
demuxers fail to do short seeks backwards (if the input isn't seekable).
author | mstorsjo |
---|---|
date | Sat, 24 Jul 2010 09:04:44 +0000 |
parents | 1b2b5dbcf549 |
children | daed56aa74bc |
rev | line source |
---|---|
0 | 1 /* |
2 * Buffered I/O for ffmpeg system | |
3 * Copyright (c) 2000,2001 Fabrice Bellard | |
4 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 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 | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1326
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
887
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
3286 | 21 |
22 #include "libavutil/crc.h" | |
4233 | 23 #include "libavutil/intreadwrite.h" |
0 | 24 #include "avformat.h" |
64 | 25 #include "avio.h" |
6246
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
26 #include "internal.h" |
0 | 27 #include <stdarg.h> |
28 | |
29 #define IO_BUFFER_SIZE 32768 | |
30 | |
6268
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
31 /** |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
32 * Do seeks within this distance ahead of the current buffer by skipping |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
33 * data instead of calling the protocol seek function, for seekable |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
34 * protocols. |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
35 */ |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
36 #define SHORT_SEEK_THRESHOLD 4096 |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
37 |
1326 | 38 static void fill_buffer(ByteIOContext *s); |
5320
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
39 #if LIBAVFORMAT_VERSION_MAJOR >= 53 |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
40 static int url_resetbuf(ByteIOContext *s, int flags); |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
41 #endif |
1326 | 42 |
0 | 43 int init_put_byte(ByteIOContext *s, |
44 unsigned char *buffer, | |
45 int buffer_size, | |
46 int write_flag, | |
47 void *opaque, | |
65 | 48 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), |
554 | 49 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
50 int64_t (*seek)(void *opaque, int64_t offset, int whence)) |
0 | 51 { |
52 s->buffer = buffer; | |
53 s->buffer_size = buffer_size; | |
54 s->buf_ptr = buffer; | |
4127
6afa3d7c206e
Initialize s->opaque before calling url_resetbuf().
cehoyos
parents:
4091
diff
changeset
|
55 s->opaque = opaque; |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
56 url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY); |
0 | 57 s->write_packet = write_packet; |
58 s->read_packet = read_packet; | |
59 s->seek = seek; | |
60 s->pos = 0; | |
61 s->must_flush = 0; | |
62 s->eof_reached = 0; | |
554 | 63 s->error = 0; |
0 | 64 s->is_streamed = 0; |
65 s->max_packet_size = 0; | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
66 s->update_checksum= NULL; |
1403
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
67 if(!read_packet && !write_flag){ |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
68 s->pos = buffer_size; |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
69 s->buf_end = s->buffer + buffer_size; |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
70 } |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
71 s->read_pause = NULL; |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
72 s->read_seek = NULL; |
0 | 73 return 0; |
74 } | |
885 | 75 |
2853 | 76 ByteIOContext *av_alloc_put_byte( |
77 unsigned char *buffer, | |
78 int buffer_size, | |
79 int write_flag, | |
80 void *opaque, | |
81 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), | |
82 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), | |
4091 | 83 int64_t (*seek)(void *opaque, int64_t offset, int whence)) |
84 { | |
2853 | 85 ByteIOContext *s = av_mallocz(sizeof(ByteIOContext)); |
86 init_put_byte(s, buffer, buffer_size, write_flag, opaque, | |
87 read_packet, write_packet, seek); | |
88 return s; | |
89 } | |
90 | |
0 | 91 static void flush_buffer(ByteIOContext *s) |
92 { | |
93 if (s->buf_ptr > s->buffer) { | |
554 | 94 if (s->write_packet && !s->error){ |
95 int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer); | |
96 if(ret < 0){ | |
97 s->error = ret; | |
98 } | |
99 } | |
421 | 100 if(s->update_checksum){ |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
101 s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr); |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
102 s->checksum_ptr= s->buffer; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
103 } |
0 | 104 s->pos += s->buf_ptr - s->buffer; |
105 } | |
106 s->buf_ptr = s->buffer; | |
107 } | |
108 | |
109 void put_byte(ByteIOContext *s, int b) | |
110 { | |
111 *(s->buf_ptr)++ = b; | |
885 | 112 if (s->buf_ptr >= s->buf_end) |
0 | 113 flush_buffer(s); |
114 } | |
115 | |
116 void put_buffer(ByteIOContext *s, const unsigned char *buf, int size) | |
117 { | |
118 while (size > 0) { | |
5275 | 119 int len = FFMIN(s->buf_end - s->buf_ptr, size); |
0 | 120 memcpy(s->buf_ptr, buf, len); |
121 s->buf_ptr += len; | |
122 | |
885 | 123 if (s->buf_ptr >= s->buf_end) |
0 | 124 flush_buffer(s); |
125 | |
126 buf += len; | |
127 size -= len; | |
128 } | |
129 } | |
130 | |
131 void put_flush_packet(ByteIOContext *s) | |
132 { | |
133 flush_buffer(s); | |
134 s->must_flush = 0; | |
135 } | |
136 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
137 int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence) |
0 | 138 { |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
139 int64_t offset1; |
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
140 int64_t pos; |
5874
6a24c2ae6ee4
Mask away AVSEEK_FORCE properly in some checks in url_fseek()
benoit
parents:
5856
diff
changeset
|
141 int force = whence & AVSEEK_FORCE; |
6a24c2ae6ee4
Mask away AVSEEK_FORCE properly in some checks in url_fseek()
benoit
parents:
5856
diff
changeset
|
142 whence &= ~AVSEEK_FORCE; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
143 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
144 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
145 return AVERROR(EINVAL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
146 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
147 pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); |
0 | 148 |
149 if (whence != SEEK_CUR && whence != SEEK_SET) | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
150 return AVERROR(EINVAL); |
885 | 151 |
1323 | 152 if (whence == SEEK_CUR) { |
153 offset1 = pos + (s->buf_ptr - s->buffer); | |
154 if (offset == 0) | |
155 return offset1; | |
156 offset += offset1; | |
157 } | |
158 offset1 = offset - pos; | |
159 if (!s->must_flush && | |
4871
37da30baa62d
seek inside buffer when offset is exactly at the end, fix seeking with memory ByteIOContext
bcoudurier
parents:
4236
diff
changeset
|
160 offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) { |
1323 | 161 /* can do the seek inside the buffer */ |
162 s->buf_ptr = s->buffer + offset1; | |
6268
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
163 } else if ((s->is_streamed || |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
164 offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) && |
68c7733519ca
aviobuf: Do short seeks forward by reading and skipping data instead of a proper seek
mstorsjo
parents:
6265
diff
changeset
|
165 !s->write_flag && offset1 >= 0 && |
5942
b106b59bf663
Seeking forward in non-seekable media by discarding data, regardless of how far to seek. Won't SEEK_END unless forced though.
thardin
parents:
5941
diff
changeset
|
166 (whence != SEEK_END || force)) { |
1326 | 167 while(s->pos < offset && !s->eof_reached) |
168 fill_buffer(s); | |
2816
1523342b58b3
return error when url_fseek could not read until desired offset in streamed mode
bcoudurier
parents:
2783
diff
changeset
|
169 if (s->eof_reached) |
5856
a1121e5fa662
Make url_fseek() return AVERROR_EOF rather than AVERROR(EPIPE) if end
stefano
parents:
5850
diff
changeset
|
170 return AVERROR_EOF; |
1326 | 171 s->buf_ptr = s->buf_end + offset - s->pos; |
1323 | 172 } else { |
5977
6eada15742a7
Do not initialize res in url_fseek(), in the case !s->seek directly
stefano
parents:
5961
diff
changeset
|
173 int64_t res; |
1747
fa70e732d2db
Fix misbehaviour in url_fseek() when seeking fails.
gpoirier
parents:
1741
diff
changeset
|
174 |
4206 | 175 #if CONFIG_MUXERS || CONFIG_NETWORK |
1323 | 176 if (s->write_flag) { |
0 | 177 flush_buffer(s); |
178 s->must_flush = 1; | |
3614
71fdc3f7c771
Only reset buffer state if seeking is successful; update seek reg ref.
bcoudurier
parents:
3286
diff
changeset
|
179 } |
4206 | 180 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */ |
5977
6eada15742a7
Do not initialize res in url_fseek(), in the case !s->seek directly
stefano
parents:
5961
diff
changeset
|
181 if (!s->seek) |
6eada15742a7
Do not initialize res in url_fseek(), in the case !s->seek directly
stefano
parents:
5961
diff
changeset
|
182 return AVERROR(EPIPE); |
6eada15742a7
Do not initialize res in url_fseek(), in the case !s->seek directly
stefano
parents:
5961
diff
changeset
|
183 if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0) |
1747
fa70e732d2db
Fix misbehaviour in url_fseek() when seeking fails.
gpoirier
parents:
1741
diff
changeset
|
184 return res; |
3614
71fdc3f7c771
Only reset buffer state if seeking is successful; update seek reg ref.
bcoudurier
parents:
3286
diff
changeset
|
185 if (!s->write_flag) |
71fdc3f7c771
Only reset buffer state if seeking is successful; update seek reg ref.
bcoudurier
parents:
3286
diff
changeset
|
186 s->buf_end = s->buffer; |
71fdc3f7c771
Only reset buffer state if seeking is successful; update seek reg ref.
bcoudurier
parents:
3286
diff
changeset
|
187 s->buf_ptr = s->buffer; |
1323 | 188 s->pos = offset; |
0 | 189 } |
1323 | 190 s->eof_reached = 0; |
0 | 191 return offset; |
192 } | |
193 | |
6265
6eead40d46a7
url_fskip: Return an error code if the url_fseek failed
mstorsjo
parents:
6246
diff
changeset
|
194 int url_fskip(ByteIOContext *s, int64_t offset) |
0 | 195 { |
6265
6eead40d46a7
url_fskip: Return an error code if the url_fseek failed
mstorsjo
parents:
6246
diff
changeset
|
196 int64_t ret = url_fseek(s, offset, SEEK_CUR); |
6eead40d46a7
url_fskip: Return an error code if the url_fseek failed
mstorsjo
parents:
6246
diff
changeset
|
197 return ret < 0 ? ret : 0; |
0 | 198 } |
199 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
200 int64_t url_ftell(ByteIOContext *s) |
0 | 201 { |
202 return url_fseek(s, 0, SEEK_CUR); | |
203 } | |
204 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
205 int64_t url_fsize(ByteIOContext *s) |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
206 { |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
207 int64_t size; |
885 | 208 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
209 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
210 return AVERROR(EINVAL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
211 |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
212 if (!s->seek) |
5961
d9da72409ff9
Make url_fsize() return AVERROR(ENOSYS) rather than AVERROR(EPIPE) if
stefano
parents:
5948
diff
changeset
|
213 return AVERROR(ENOSYS); |
1612
a6eaa0762191
seekless filesize retrieving support in 7 lines of code, also doesnt break compatibility
michael
parents:
1592
diff
changeset
|
214 size = s->seek(s->opaque, 0, AVSEEK_SIZE); |
a6eaa0762191
seekless filesize retrieving support in 7 lines of code, also doesnt break compatibility
michael
parents:
1592
diff
changeset
|
215 if(size<0){ |
1741
e9c7714b1c34
proper error handling in file size retrieval, patch by Ronald S. Bultje rbultje at ronald bitfreak net
bcoudurier
parents:
1613
diff
changeset
|
216 if ((size = s->seek(s->opaque, -1, SEEK_END)) < 0) |
e9c7714b1c34
proper error handling in file size retrieval, patch by Ronald S. Bultje rbultje at ronald bitfreak net
bcoudurier
parents:
1613
diff
changeset
|
217 return size; |
e9c7714b1c34
proper error handling in file size retrieval, patch by Ronald S. Bultje rbultje at ronald bitfreak net
bcoudurier
parents:
1613
diff
changeset
|
218 size++; |
1613 | 219 s->seek(s->opaque, s->pos, SEEK_SET); |
1612
a6eaa0762191
seekless filesize retrieving support in 7 lines of code, also doesnt break compatibility
michael
parents:
1592
diff
changeset
|
220 } |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
221 return size; |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
222 } |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
223 |
0 | 224 int url_feof(ByteIOContext *s) |
225 { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
226 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
227 return 0; |
0 | 228 return s->eof_reached; |
229 } | |
230 | |
554 | 231 int url_ferror(ByteIOContext *s) |
232 { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
233 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
234 return 0; |
554 | 235 return s->error; |
236 } | |
237 | |
0 | 238 void put_le32(ByteIOContext *s, unsigned int val) |
239 { | |
240 put_byte(s, val); | |
241 put_byte(s, val >> 8); | |
242 put_byte(s, val >> 16); | |
243 put_byte(s, val >> 24); | |
244 } | |
245 | |
246 void put_be32(ByteIOContext *s, unsigned int val) | |
247 { | |
248 put_byte(s, val >> 24); | |
249 put_byte(s, val >> 16); | |
250 put_byte(s, val >> 8); | |
251 put_byte(s, val); | |
252 } | |
253 | |
254 void put_strz(ByteIOContext *s, const char *str) | |
255 { | |
256 if (str) | |
257 put_buffer(s, (const unsigned char *) str, strlen(str) + 1); | |
258 else | |
259 put_byte(s, 0); | |
260 } | |
261 | |
6246
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
262 int ff_get_v_length(uint64_t val){ |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
263 int i=1; |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
264 |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
265 while(val>>=7) |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
266 i++; |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
267 |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
268 return i; |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
269 } |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
270 |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
271 void ff_put_v(ByteIOContext *bc, uint64_t val){ |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
272 int i= ff_get_v_length(val); |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
273 |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
274 while(--i>0) |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
275 put_byte(bc, 128 | (val>>(7*i))); |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
276 |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
277 put_byte(bc, val&127); |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
278 } |
79fc252c65cd
move ff_get_v_length and ff_put_v from nutenc.c to internal.h/aviobuf.c
janne
parents:
6233
diff
changeset
|
279 |
65 | 280 void put_le64(ByteIOContext *s, uint64_t val) |
0 | 281 { |
65 | 282 put_le32(s, (uint32_t)(val & 0xffffffff)); |
283 put_le32(s, (uint32_t)(val >> 32)); | |
0 | 284 } |
285 | |
65 | 286 void put_be64(ByteIOContext *s, uint64_t val) |
0 | 287 { |
65 | 288 put_be32(s, (uint32_t)(val >> 32)); |
289 put_be32(s, (uint32_t)(val & 0xffffffff)); | |
0 | 290 } |
291 | |
292 void put_le16(ByteIOContext *s, unsigned int val) | |
293 { | |
294 put_byte(s, val); | |
295 put_byte(s, val >> 8); | |
296 } | |
297 | |
298 void put_be16(ByteIOContext *s, unsigned int val) | |
299 { | |
300 put_byte(s, val >> 8); | |
301 put_byte(s, val); | |
302 } | |
303 | |
937 | 304 void put_le24(ByteIOContext *s, unsigned int val) |
305 { | |
306 put_le16(s, val & 0xffff); | |
307 put_byte(s, val >> 16); | |
308 } | |
309 | |
822 | 310 void put_be24(ByteIOContext *s, unsigned int val) |
311 { | |
312 put_be16(s, val >> 8); | |
313 put_byte(s, val); | |
314 } | |
315 | |
0 | 316 void put_tag(ByteIOContext *s, const char *tag) |
317 { | |
318 while (*tag) { | |
319 put_byte(s, *tag++); | |
320 } | |
321 } | |
322 | |
323 /* Input stream */ | |
324 | |
325 static void fill_buffer(ByteIOContext *s) | |
326 { | |
4020
9d94163ca066
always use the whole buffer for reading w/ packetized sources to avoid packet truncation
henry
parents:
3998
diff
changeset
|
327 uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_ptr : s->buffer; |
3998
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
328 int len= s->buffer_size - (dst - s->buffer); |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
329 int max_buffer_size = s->max_packet_size ? s->max_packet_size : IO_BUFFER_SIZE; |
3998
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
330 |
0 | 331 /* no need to do anything if EOF already reached */ |
332 if (s->eof_reached) | |
333 return; | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
334 |
3998
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
335 if(s->update_checksum && dst == s->buffer){ |
780 | 336 if(s->buf_end > s->checksum_ptr) |
337 s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr); | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
338 s->checksum_ptr= s->buffer; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
339 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
340 |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
341 /* make buffer smaller in case it ended up large after probing */ |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
342 if (s->buffer_size > max_buffer_size) { |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
343 url_setbufsize(s, max_buffer_size); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
344 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
345 s->checksum_ptr = dst = s->buffer; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
346 len = s->buffer_size; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
347 } |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
348 |
2576 | 349 if(s->read_packet) |
3998
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
350 len = s->read_packet(s->opaque, dst, len); |
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
351 else |
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
352 len = 0; |
0 | 353 if (len <= 0) { |
354 /* do not modify buffer if EOF reached so that a seek back can | |
355 be done without rereading data */ | |
356 s->eof_reached = 1; | |
2082 | 357 if(len<0) |
358 s->error= len; | |
0 | 359 } else { |
360 s->pos += len; | |
3998
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
361 s->buf_ptr = dst; |
692e5298a27a
Append read data onto the buffer instead of overwriting, this ensures
michael
parents:
3982
diff
changeset
|
362 s->buf_end = dst + len; |
0 | 363 } |
364 } | |
365 | |
4091 | 366 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, |
367 unsigned int len) | |
368 { | |
2893 | 369 return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len); |
2683
153d6efc05b8
rename av_crc04C11DB7_update to ff_crc04C11DB7_update and move it to aviobuf.c so it can be reused by other (de)muxers
bcoudurier
parents:
2598
diff
changeset
|
370 } |
153d6efc05b8
rename av_crc04C11DB7_update to ff_crc04C11DB7_update and move it to aviobuf.c so it can be reused by other (de)muxers
bcoudurier
parents:
2598
diff
changeset
|
371 |
4091 | 372 unsigned long get_checksum(ByteIOContext *s) |
373 { | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
374 s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr); |
421 | 375 s->update_checksum= NULL; |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
376 return s->checksum; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
377 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
378 |
4091 | 379 void init_checksum(ByteIOContext *s, |
380 unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), | |
381 unsigned long checksum) | |
382 { | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
383 s->update_checksum= update_checksum; |
421 | 384 if(s->update_checksum){ |
1184 | 385 s->checksum= checksum; |
421 | 386 s->checksum_ptr= s->buf_ptr; |
387 } | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
388 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
389 |
0 | 390 /* XXX: put an inline version */ |
391 int get_byte(ByteIOContext *s) | |
392 { | |
393 if (s->buf_ptr < s->buf_end) { | |
394 return *s->buf_ptr++; | |
395 } else { | |
396 fill_buffer(s); | |
397 if (s->buf_ptr < s->buf_end) | |
398 return *s->buf_ptr++; | |
399 else | |
400 return 0; | |
401 } | |
402 } | |
403 | |
404 int url_fgetc(ByteIOContext *s) | |
405 { | |
406 if (s->buf_ptr < s->buf_end) { | |
407 return *s->buf_ptr++; | |
408 } else { | |
409 fill_buffer(s); | |
410 if (s->buf_ptr < s->buf_end) | |
411 return *s->buf_ptr++; | |
412 else | |
413 return URL_EOF; | |
414 } | |
415 } | |
416 | |
417 int get_buffer(ByteIOContext *s, unsigned char *buf, int size) | |
418 { | |
419 int len, size1; | |
420 | |
421 size1 = size; | |
422 while (size > 0) { | |
423 len = s->buf_end - s->buf_ptr; | |
424 if (len > size) | |
425 len = size; | |
426 if (len == 0) { | |
719 | 427 if(size > s->buffer_size && !s->update_checksum){ |
2576 | 428 if(s->read_packet) |
2577 | 429 len = s->read_packet(s->opaque, buf, size); |
719 | 430 if (len <= 0) { |
431 /* do not modify buffer if EOF reached so that a seek back can | |
432 be done without rereading data */ | |
433 s->eof_reached = 1; | |
434 if(len<0) | |
435 s->error= len; | |
436 break; | |
437 } else { | |
438 s->pos += len; | |
439 size -= len; | |
440 buf += len; | |
441 s->buf_ptr = s->buffer; | |
442 s->buf_end = s->buffer/* + len*/; | |
443 } | |
444 }else{ | |
445 fill_buffer(s); | |
446 len = s->buf_end - s->buf_ptr; | |
447 if (len == 0) | |
448 break; | |
449 } | |
0 | 450 } else { |
451 memcpy(buf, s->buf_ptr, len); | |
452 buf += len; | |
453 s->buf_ptr += len; | |
454 size -= len; | |
455 } | |
456 } | |
5253
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
457 if (size1 == size) { |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
458 if (url_ferror(s)) return url_ferror(s); |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
459 if (url_feof(s)) return AVERROR_EOF; |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
460 } |
0 | 461 return size1 - size; |
462 } | |
463 | |
389
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
464 int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size) |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
465 { |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
466 int len; |
885 | 467 |
643 | 468 if(size<0) |
469 return -1; | |
389
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
470 |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
471 len = s->buf_end - s->buf_ptr; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
472 if (len == 0) { |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
473 fill_buffer(s); |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
474 len = s->buf_end - s->buf_ptr; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
475 } |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
476 if (len > size) |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
477 len = size; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
478 memcpy(buf, s->buf_ptr, len); |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
479 s->buf_ptr += len; |
5253
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
480 if (!len) { |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
481 if (url_ferror(s)) return url_ferror(s); |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
482 if (url_feof(s)) return AVERROR_EOF; |
a2289b41a9f2
Make get_buffer and get_partial_buffer return url_ferror or AVERROR_EOF as
reimar
parents:
4871
diff
changeset
|
483 } |
389
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
484 return len; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
485 } |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
486 |
0 | 487 unsigned int get_le16(ByteIOContext *s) |
488 { | |
489 unsigned int val; | |
490 val = get_byte(s); | |
491 val |= get_byte(s) << 8; | |
492 return val; | |
493 } | |
494 | |
937 | 495 unsigned int get_le24(ByteIOContext *s) |
496 { | |
497 unsigned int val; | |
498 val = get_le16(s); | |
499 val |= get_byte(s) << 16; | |
500 return val; | |
501 } | |
502 | |
0 | 503 unsigned int get_le32(ByteIOContext *s) |
504 { | |
505 unsigned int val; | |
822 | 506 val = get_le16(s); |
507 val |= get_le16(s) << 16; | |
0 | 508 return val; |
509 } | |
510 | |
65 | 511 uint64_t get_le64(ByteIOContext *s) |
0 | 512 { |
65 | 513 uint64_t val; |
514 val = (uint64_t)get_le32(s); | |
515 val |= (uint64_t)get_le32(s) << 32; | |
0 | 516 return val; |
517 } | |
518 | |
519 unsigned int get_be16(ByteIOContext *s) | |
520 { | |
521 unsigned int val; | |
522 val = get_byte(s) << 8; | |
523 val |= get_byte(s); | |
524 return val; | |
525 } | |
526 | |
822 | 527 unsigned int get_be24(ByteIOContext *s) |
528 { | |
529 unsigned int val; | |
530 val = get_be16(s) << 8; | |
531 val |= get_byte(s); | |
532 return val; | |
533 } | |
0 | 534 unsigned int get_be32(ByteIOContext *s) |
535 { | |
536 unsigned int val; | |
822 | 537 val = get_be16(s) << 16; |
538 val |= get_be16(s); | |
0 | 539 return val; |
540 } | |
541 | |
542 char *get_strz(ByteIOContext *s, char *buf, int maxlen) | |
543 { | |
544 int i = 0; | |
545 char c; | |
546 | |
547 while ((c = get_byte(s))) { | |
548 if (i < maxlen-1) | |
549 buf[i++] = c; | |
550 } | |
885 | 551 |
0 | 552 buf[i] = 0; /* Ensure null terminated, but may be truncated */ |
553 | |
554 return buf; | |
555 } | |
556 | |
6301 | 557 int ff_get_line(ByteIOContext *s, char *buf, int maxlen) |
6300 | 558 { |
559 int i = 0; | |
560 char c; | |
561 | |
562 do { | |
563 c = get_byte(s); | |
6301 | 564 if (c && i < maxlen-1) |
6300 | 565 buf[i++] = c; |
566 } while (c != '\n' && c); | |
567 | |
568 buf[i] = 0; | |
6301 | 569 return i; |
6300 | 570 } |
571 | |
65 | 572 uint64_t get_be64(ByteIOContext *s) |
0 | 573 { |
65 | 574 uint64_t val; |
575 val = (uint64_t)get_be32(s) << 32; | |
576 val |= (uint64_t)get_be32(s); | |
0 | 577 return val; |
578 } | |
579 | |
2700 | 580 uint64_t ff_get_v(ByteIOContext *bc){ |
2699 | 581 uint64_t val = 0; |
582 int tmp; | |
583 | |
584 do{ | |
585 tmp = get_byte(bc); | |
586 val= (val<<7) + (tmp&127); | |
587 }while(tmp&128); | |
588 return val; | |
589 } | |
590 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
591 int url_fdopen(ByteIOContext **s, URLContext *h) |
0 | 592 { |
65 | 593 uint8_t *buffer; |
0 | 594 int buffer_size, max_packet_size; |
595 | |
596 max_packet_size = url_get_max_packet_size(h); | |
597 if (max_packet_size) { | |
598 buffer_size = max_packet_size; /* no need to bufferize more than one packet */ | |
599 } else { | |
600 buffer_size = IO_BUFFER_SIZE; | |
601 } | |
602 buffer = av_malloc(buffer_size); | |
603 if (!buffer) | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
604 return AVERROR(ENOMEM); |
0 | 605 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
606 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
607 if(!*s) { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
608 av_free(buffer); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
609 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
610 } |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
611 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
612 if (init_put_byte(*s, buffer, buffer_size, |
364
0d74e8abcb3d
avio patch by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
277
diff
changeset
|
613 (h->flags & URL_WRONLY || h->flags & URL_RDWR), h, |
2831 | 614 url_read, url_write, url_seek) < 0) { |
0 | 615 av_free(buffer); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
616 av_freep(s); |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2082
diff
changeset
|
617 return AVERROR(EIO); |
0 | 618 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
619 (*s)->is_streamed = h->is_streamed; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
620 (*s)->max_packet_size = max_packet_size; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
621 if(h->prot) { |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
622 (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
623 (*s)->read_seek = (int64_t (*)(void *, int, int64_t, int))h->prot->url_read_seek; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
624 } |
0 | 625 return 0; |
626 } | |
627 | |
628 int url_setbufsize(ByteIOContext *s, int buf_size) | |
629 { | |
65 | 630 uint8_t *buffer; |
0 | 631 buffer = av_malloc(buf_size); |
632 if (!buffer) | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
633 return AVERROR(ENOMEM); |
0 | 634 |
635 av_free(s->buffer); | |
636 s->buffer = buffer; | |
637 s->buffer_size = buf_size; | |
638 s->buf_ptr = buffer; | |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
639 url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY); |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
640 return 0; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
641 } |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
642 |
5320
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
643 #if LIBAVFORMAT_VERSION_MAJOR < 53 |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
644 int url_resetbuf(ByteIOContext *s, int flags) |
5320
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
645 #else |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
646 static int url_resetbuf(ByteIOContext *s, int flags) |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
647 #endif |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
648 { |
5320
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
649 #if LIBAVFORMAT_VERSION_MAJOR < 53 |
6233 | 650 if (flags & URL_RDWR) |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
651 return AVERROR(EINVAL); |
5320
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
652 #else |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
653 assert(flags == URL_WRONLY || flags == URL_RDONLY); |
db1e4c61789a
Make url_resetbuf() assert on wrong flags passed and make it static on next
benoit
parents:
5275
diff
changeset
|
654 #endif |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
655 |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
656 if (flags & URL_WRONLY) { |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
657 s->buf_end = s->buffer + s->buffer_size; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
658 s->write_flag = 1; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
659 } else { |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
660 s->buf_end = s->buffer; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
661 s->write_flag = 0; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
662 } |
0 | 663 return 0; |
664 } | |
665 | |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
666 int ff_rewind_with_probe_data(ByteIOContext *s, unsigned char *buf, int buf_size) |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
667 { |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
668 int64_t buffer_start; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
669 int buffer_size; |
6306
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
670 int overlap, new_size, alloc_size; |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
671 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
672 if (s->write_flag) |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
673 return AVERROR(EINVAL); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
674 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
675 buffer_size = s->buf_end - s->buffer; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
676 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
677 /* the buffers must touch or overlap */ |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
678 if ((buffer_start = s->pos - buffer_size) > buf_size) |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
679 return AVERROR(EINVAL); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
680 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
681 overlap = buf_size - buffer_start; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
682 new_size = buf_size + buffer_size - overlap; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
683 |
6306
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
684 alloc_size = FFMAX(s->buffer_size, new_size); |
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
685 if (alloc_size > buf_size) |
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
686 if (!(buf = av_realloc(buf, alloc_size))) |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
687 return AVERROR(ENOMEM); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
688 |
6306
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
689 if (new_size > buf_size) { |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
690 memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
691 buf_size = new_size; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
692 } |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
693 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
694 av_free(s->buffer); |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
695 s->buf_ptr = s->buffer = buf; |
6306
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
696 s->buffer_size = alloc_size; |
175c5f6cb556
Never shrink the ByteIOContext buffer in ff_rewind_with_probe_data
mstorsjo
parents:
6301
diff
changeset
|
697 s->pos = buf_size; |
5941
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
698 s->buf_end = s->buf_ptr + buf_size; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
699 s->eof_reached = 0; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
700 s->must_flush = 0; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
701 |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
702 return 0; |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
703 } |
bde9a4b67f86
Reusing the probe buffer to rewind the ByteIOContext in ff_probe_input_buffer() instead of seeking back to the start of the file. Once exhausted, the size of the buffer is reduced.
thardin
parents:
5874
diff
changeset
|
704 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
705 int url_fopen(ByteIOContext **s, const char *filename, int flags) |
0 | 706 { |
707 URLContext *h; | |
708 int err; | |
709 | |
710 err = url_open(&h, filename, flags); | |
711 if (err < 0) | |
712 return err; | |
713 err = url_fdopen(s, h); | |
714 if (err < 0) { | |
715 url_close(h); | |
716 return err; | |
717 } | |
718 return 0; | |
719 } | |
720 | |
721 int url_fclose(ByteIOContext *s) | |
722 { | |
723 URLContext *h = s->opaque; | |
885 | 724 |
0 | 725 av_free(s->buffer); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
726 av_free(s); |
0 | 727 return url_close(h); |
728 } | |
729 | |
730 URLContext *url_fileno(ByteIOContext *s) | |
731 { | |
732 return s->opaque; | |
733 } | |
734 | |
4206 | 735 #if CONFIG_MUXERS |
0 | 736 int url_fprintf(ByteIOContext *s, const char *fmt, ...) |
737 { | |
738 va_list ap; | |
739 char buf[4096]; | |
740 int ret; | |
741 | |
742 va_start(ap, fmt); | |
743 ret = vsnprintf(buf, sizeof(buf), fmt, ap); | |
744 va_end(ap); | |
745 put_buffer(s, buf, strlen(buf)); | |
746 return ret; | |
747 } | |
858
66cc656ea404
Replace CONFIG_ENCODERS/CONFIG_DECODERS with CONFIG_MUXERS/CONFIG_DEMUXERS
diego
parents:
823
diff
changeset
|
748 #endif //CONFIG_MUXERS |
0 | 749 |
750 char *url_fgets(ByteIOContext *s, char *buf, int buf_size) | |
751 { | |
752 int c; | |
753 char *q; | |
754 | |
755 c = url_fgetc(s); | |
756 if (c == EOF) | |
757 return NULL; | |
758 q = buf; | |
759 for(;;) { | |
760 if (c == EOF || c == '\n') | |
761 break; | |
762 if ((q - buf) < buf_size - 1) | |
763 *q++ = c; | |
764 c = url_fgetc(s); | |
765 } | |
766 if (buf_size > 0) | |
767 *q = '\0'; | |
768 return buf; | |
769 } | |
770 | |
771 int url_fget_max_packet_size(ByteIOContext *s) | |
772 { | |
773 return s->max_packet_size; | |
774 } | |
775 | |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
776 int av_url_read_fpause(ByteIOContext *s, int pause) |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
777 { |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
778 if (!s->read_pause) |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
779 return AVERROR(ENOSYS); |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
780 return s->read_pause(s->opaque, pause); |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
781 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
782 |
4091 | 783 int64_t av_url_read_fseek(ByteIOContext *s, int stream_index, |
784 int64_t timestamp, int flags) | |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
785 { |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
786 URLContext *h = s->opaque; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
787 int64_t ret; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
788 if (!s->read_seek) |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
789 return AVERROR(ENOSYS); |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
790 ret = s->read_seek(h, stream_index, timestamp, flags); |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
791 if(ret >= 0) { |
5948 | 792 int64_t pos; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
793 s->buf_ptr = s->buf_end; // Flush buffer |
5948 | 794 pos = s->seek(h, 0, SEEK_CUR); |
795 if (pos >= 0) | |
796 s->pos = pos; | |
797 else if (pos != AVERROR(ENOSYS)) | |
798 ret = pos; | |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
799 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
800 return ret; |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
801 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
802 |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
803 /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response |
4206 | 804 * back to the server even if CONFIG_MUXERS is false. */ |
805 #if CONFIG_MUXERS || CONFIG_NETWORK | |
0 | 806 /* buffer handling */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
807 int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags) |
0 | 808 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
809 int ret; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
810 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
811 if(!*s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
812 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
813 ret = init_put_byte(*s, buf, buf_size, |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
814 (flags & URL_WRONLY || flags & URL_RDWR), |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
815 NULL, NULL, NULL, NULL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
816 if(ret != 0) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
817 av_freep(s); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
818 return ret; |
0 | 819 } |
820 | |
821 int url_close_buf(ByteIOContext *s) | |
822 { | |
823 put_flush_packet(s); | |
824 return s->buf_ptr - s->buffer; | |
825 } | |
826 | |
827 /* output in a dynamic buffer */ | |
828 | |
829 typedef struct DynBuffer { | |
830 int pos, size, allocated_size; | |
65 | 831 uint8_t *buffer; |
0 | 832 int io_buffer_size; |
65 | 833 uint8_t io_buffer[1]; |
0 | 834 } DynBuffer; |
835 | |
554 | 836 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size) |
0 | 837 { |
838 DynBuffer *d = opaque; | |
3982
1505b1ddab11
Make size variables in dyn_buf_write unsigned so gcc will not optimize the
reimar
parents:
3973
diff
changeset
|
839 unsigned new_size, new_allocated_size; |
885 | 840 |
0 | 841 /* reallocate buffer if needed */ |
842 new_size = d->pos + buf_size; | |
843 new_allocated_size = d->allocated_size; | |
639 | 844 if(new_size < d->pos || new_size > INT_MAX/2) |
845 return -1; | |
0 | 846 while (new_size > new_allocated_size) { |
847 if (!new_allocated_size) | |
848 new_allocated_size = new_size; | |
849 else | |
885 | 850 new_allocated_size += new_allocated_size / 2 + 1; |
0 | 851 } |
885 | 852 |
0 | 853 if (new_allocated_size > d->allocated_size) { |
93
69ed49c151bf
ffserver deallocate ctx->streams on closing patch by (Mark Hills <mark at pogo dot org dot uk>)
michaelni
parents:
65
diff
changeset
|
854 d->buffer = av_realloc(d->buffer, new_allocated_size); |
69ed49c151bf
ffserver deallocate ctx->streams on closing patch by (Mark Hills <mark at pogo dot org dot uk>)
michaelni
parents:
65
diff
changeset
|
855 if(d->buffer == NULL) |
4231
07ea426be9a3
Replace nonsense -1234 return value in dyn_buf_write by proper AVERROR(ENOMEM)
reimar
parents:
4206
diff
changeset
|
856 return AVERROR(ENOMEM); |
0 | 857 d->allocated_size = new_allocated_size; |
858 } | |
859 memcpy(d->buffer + d->pos, buf, buf_size); | |
860 d->pos = new_size; | |
861 if (d->pos > d->size) | |
862 d->size = d->pos; | |
554 | 863 return buf_size; |
0 | 864 } |
865 | |
554 | 866 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size) |
0 | 867 { |
868 unsigned char buf1[4]; | |
554 | 869 int ret; |
0 | 870 |
871 /* packetized write: output the header */ | |
4233 | 872 AV_WB32(buf1, buf_size); |
554 | 873 ret= dyn_buf_write(opaque, buf1, 4); |
874 if(ret < 0) | |
875 return ret; | |
0 | 876 |
877 /* then the data */ | |
554 | 878 return dyn_buf_write(opaque, buf, buf_size); |
0 | 879 } |
880 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3614
diff
changeset
|
881 static int64_t dyn_buf_seek(void *opaque, int64_t offset, int whence) |
0 | 882 { |
883 DynBuffer *d = opaque; | |
884 | |
885 if (whence == SEEK_CUR) | |
886 offset += d->pos; | |
887 else if (whence == SEEK_END) | |
888 offset += d->size; | |
889 if (offset < 0 || offset > 0x7fffffffLL) | |
890 return -1; | |
891 d->pos = offset; | |
892 return 0; | |
893 } | |
894 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
895 static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size) |
0 | 896 { |
897 DynBuffer *d; | |
4235
ce71070e447d
Make io_buffer_size unsigned to avoid a warning about comparing
reimar
parents:
4234
diff
changeset
|
898 int ret; |
4236
63c721da20e5
Merge declaration and initialization of io_buffer_size
reimar
parents:
4235
diff
changeset
|
899 unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024; |
885 | 900 |
639 | 901 if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size) |
902 return -1; | |
4232
5defcf4194fb
Use av_mallocz instead of explicitly zeroing in url_open_dyn_buf_internal.
reimar
parents:
4231
diff
changeset
|
903 d = av_mallocz(sizeof(DynBuffer) + io_buffer_size); |
0 | 904 if (!d) |
4234
3d57729868a9
Return AVERROR(ENOMEM) instead of -1 when malloc fails in url_open_dyn_buf_internal
reimar
parents:
4233
diff
changeset
|
905 return AVERROR(ENOMEM); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
906 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
907 if(!*s) { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
908 av_free(d); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
909 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
910 } |
0 | 911 d->io_buffer_size = io_buffer_size; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
912 ret = init_put_byte(*s, d->io_buffer, io_buffer_size, |
885 | 913 1, d, NULL, |
914 max_packet_size ? dyn_packet_buf_write : dyn_buf_write, | |
0 | 915 max_packet_size ? NULL : dyn_buf_seek); |
916 if (ret == 0) { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
917 (*s)->max_packet_size = max_packet_size; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
918 } else { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
919 av_free(d); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
920 av_freep(s); |
0 | 921 } |
922 return ret; | |
923 } | |
924 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
925 int url_open_dyn_buf(ByteIOContext **s) |
0 | 926 { |
927 return url_open_dyn_buf_internal(s, 0); | |
928 } | |
929 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
930 int url_open_dyn_packet_buf(ByteIOContext **s, int max_packet_size) |
0 | 931 { |
932 if (max_packet_size <= 0) | |
933 return -1; | |
934 return url_open_dyn_buf_internal(s, max_packet_size); | |
935 } | |
936 | |
65 | 937 int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer) |
0 | 938 { |
939 DynBuffer *d = s->opaque; | |
940 int size; | |
6209
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
941 static const char padbuf[FF_INPUT_BUFFER_PADDING_SIZE] = {0}; |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
942 int padding = 0; |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
943 |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
944 /* don't attempt to pad fixed-size packet buffers */ |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
945 if (!s->max_packet_size) { |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
946 put_buffer(s, padbuf, sizeof(padbuf)); |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
947 padding = FF_INPUT_BUFFER_PADDING_SIZE; |
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
948 } |
0 | 949 |
950 put_flush_packet(s); | |
951 | |
952 *pbuffer = d->buffer; | |
953 size = d->size; | |
954 av_free(d); | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
955 av_free(s); |
6209
71862ed5b874
Pad the buffer in url_close_dyn_buf, for buffers opened with url_open_dyn_buf
mstorsjo
parents:
5977
diff
changeset
|
956 return size - padding; |
0 | 957 } |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
958 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */ |