Mercurial > libavformat.hg
annotate aviobuf.c @ 3068:9cc9ff5aff9c libavformat
set bps to uncompressed original sound data for compressed audio
according to aiff specs, qt set it to 16 for mace and ima4,
fail if block align is not set.
author | bcoudurier |
---|---|
date | Mon, 25 Feb 2008 12:00:31 +0000 |
parents | c31c50af40c5 |
children | 6f61c3b36632 |
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 */ |
21 #include "avformat.h" | |
64 | 22 #include "avio.h" |
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
|
23 #include "crc.h" |
0 | 24 #include <stdarg.h> |
25 | |
26 #define IO_BUFFER_SIZE 32768 | |
27 | |
1326 | 28 static void fill_buffer(ByteIOContext *s); |
29 | |
0 | 30 int init_put_byte(ByteIOContext *s, |
31 unsigned char *buffer, | |
32 int buffer_size, | |
33 int write_flag, | |
34 void *opaque, | |
65 | 35 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), |
554 | 36 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), |
778
4fbe04f998bf
Fix url_fsize for large files patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents:
764
diff
changeset
|
37 offset_t (*seek)(void *opaque, offset_t offset, int whence)) |
0 | 38 { |
39 s->buffer = buffer; | |
40 s->buffer_size = buffer_size; | |
41 s->buf_ptr = buffer; | |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
42 url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY); |
0 | 43 s->opaque = opaque; |
44 s->write_packet = write_packet; | |
45 s->read_packet = read_packet; | |
46 s->seek = seek; | |
47 s->pos = 0; | |
48 s->must_flush = 0; | |
49 s->eof_reached = 0; | |
554 | 50 s->error = 0; |
0 | 51 s->is_streamed = 0; |
52 s->max_packet_size = 0; | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
53 s->update_checksum= NULL; |
1403
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
54 if(!read_packet && !write_flag){ |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
55 s->pos = buffer_size; |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
56 s->buf_end = s->buffer + buffer_size; |
1973528c6975
move memory reading ByteIOContext init from mov.c to avobuf.c
michael
parents:
1358
diff
changeset
|
57 } |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
58 s->read_pause = NULL; |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
59 s->read_seek = NULL; |
0 | 60 return 0; |
61 } | |
885 | 62 |
2853 | 63 ByteIOContext *av_alloc_put_byte( |
64 unsigned char *buffer, | |
65 int buffer_size, | |
66 int write_flag, | |
67 void *opaque, | |
68 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), | |
69 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), | |
70 offset_t (*seek)(void *opaque, offset_t offset, int whence)) { | |
71 ByteIOContext *s = av_mallocz(sizeof(ByteIOContext)); | |
72 init_put_byte(s, buffer, buffer_size, write_flag, opaque, | |
73 read_packet, write_packet, seek); | |
74 return s; | |
75 } | |
76 | |
0 | 77 static void flush_buffer(ByteIOContext *s) |
78 { | |
79 if (s->buf_ptr > s->buffer) { | |
554 | 80 if (s->write_packet && !s->error){ |
81 int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer); | |
82 if(ret < 0){ | |
83 s->error = ret; | |
84 } | |
85 } | |
421 | 86 if(s->update_checksum){ |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
87 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
|
88 s->checksum_ptr= s->buffer; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
89 } |
0 | 90 s->pos += s->buf_ptr - s->buffer; |
91 } | |
92 s->buf_ptr = s->buffer; | |
93 } | |
94 | |
95 void put_byte(ByteIOContext *s, int b) | |
96 { | |
97 *(s->buf_ptr)++ = b; | |
885 | 98 if (s->buf_ptr >= s->buf_end) |
0 | 99 flush_buffer(s); |
100 } | |
101 | |
102 void put_buffer(ByteIOContext *s, const unsigned char *buf, int size) | |
103 { | |
104 int len; | |
105 | |
106 while (size > 0) { | |
107 len = (s->buf_end - s->buf_ptr); | |
108 if (len > size) | |
109 len = size; | |
110 memcpy(s->buf_ptr, buf, len); | |
111 s->buf_ptr += len; | |
112 | |
885 | 113 if (s->buf_ptr >= s->buf_end) |
0 | 114 flush_buffer(s); |
115 | |
116 buf += len; | |
117 size -= len; | |
118 } | |
119 } | |
120 | |
121 void put_flush_packet(ByteIOContext *s) | |
122 { | |
123 flush_buffer(s); | |
124 s->must_flush = 0; | |
125 } | |
126 | |
127 offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence) | |
128 { | |
129 offset_t offset1; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
130 offset_t pos; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
131 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
132 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
133 return AVERROR(EINVAL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
134 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
135 pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer)); |
0 | 136 |
137 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
|
138 return AVERROR(EINVAL); |
885 | 139 |
1323 | 140 if (whence == SEEK_CUR) { |
141 offset1 = pos + (s->buf_ptr - s->buffer); | |
142 if (offset == 0) | |
143 return offset1; | |
144 offset += offset1; | |
145 } | |
146 offset1 = offset - pos; | |
147 if (!s->must_flush && | |
148 offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) { | |
149 /* can do the seek inside the buffer */ | |
150 s->buf_ptr = s->buffer + offset1; | |
1326 | 151 } else if(s->is_streamed && !s->write_flag && |
152 offset1 >= 0 && offset1 < (s->buf_end - s->buffer) + (1<<16)){ | |
153 while(s->pos < offset && !s->eof_reached) | |
154 fill_buffer(s); | |
2816
1523342b58b3
return error when url_fseek could not read until desired offset in streamed mode
bcoudurier
parents:
2783
diff
changeset
|
155 if (s->eof_reached) |
1523342b58b3
return error when url_fseek could not read until desired offset in streamed mode
bcoudurier
parents:
2783
diff
changeset
|
156 return AVERROR(EPIPE); |
1326 | 157 s->buf_ptr = s->buf_end + offset - s->pos; |
1323 | 158 } else { |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
159 offset_t res = AVERROR(EPIPE); |
1747
fa70e732d2db
Fix misbehaviour in url_fseek() when seeking fails.
gpoirier
parents:
1741
diff
changeset
|
160 |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
161 #if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) |
1323 | 162 if (s->write_flag) { |
0 | 163 flush_buffer(s); |
164 s->must_flush = 1; | |
1323 | 165 } else |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
166 #endif /* defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) */ |
1323 | 167 { |
168 s->buf_end = s->buffer; | |
0 | 169 } |
1323 | 170 s->buf_ptr = s->buffer; |
1747
fa70e732d2db
Fix misbehaviour in url_fseek() when seeking fails.
gpoirier
parents:
1741
diff
changeset
|
171 if (!s->seek || (res = s->seek(s->opaque, offset, SEEK_SET)) < 0) |
fa70e732d2db
Fix misbehaviour in url_fseek() when seeking fails.
gpoirier
parents:
1741
diff
changeset
|
172 return res; |
1323 | 173 s->pos = offset; |
0 | 174 } |
1323 | 175 s->eof_reached = 0; |
0 | 176 return offset; |
177 } | |
178 | |
179 void url_fskip(ByteIOContext *s, offset_t offset) | |
180 { | |
181 url_fseek(s, offset, SEEK_CUR); | |
182 } | |
183 | |
184 offset_t url_ftell(ByteIOContext *s) | |
185 { | |
186 return url_fseek(s, 0, SEEK_CUR); | |
187 } | |
188 | |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
189 offset_t url_fsize(ByteIOContext *s) |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
190 { |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
191 offset_t size; |
885 | 192 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
193 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
194 return AVERROR(EINVAL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
195 |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
196 if (!s->seek) |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
197 return AVERROR(EPIPE); |
1612
a6eaa0762191
seekless filesize retrieving support in 7 lines of code, also doesnt break compatibility
michael
parents:
1592
diff
changeset
|
198 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
|
199 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
|
200 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
|
201 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
|
202 size++; |
1613 | 203 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
|
204 } |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
205 return size; |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
206 } |
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
719
diff
changeset
|
207 |
0 | 208 int url_feof(ByteIOContext *s) |
209 { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
210 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
211 return 0; |
0 | 212 return s->eof_reached; |
213 } | |
214 | |
554 | 215 int url_ferror(ByteIOContext *s) |
216 { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
217 if(!s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
218 return 0; |
554 | 219 return s->error; |
220 } | |
221 | |
0 | 222 void put_le32(ByteIOContext *s, unsigned int val) |
223 { | |
224 put_byte(s, val); | |
225 put_byte(s, val >> 8); | |
226 put_byte(s, val >> 16); | |
227 put_byte(s, val >> 24); | |
228 } | |
229 | |
230 void put_be32(ByteIOContext *s, unsigned int val) | |
231 { | |
232 put_byte(s, val >> 24); | |
233 put_byte(s, val >> 16); | |
234 put_byte(s, val >> 8); | |
235 put_byte(s, val); | |
236 } | |
237 | |
238 void put_strz(ByteIOContext *s, const char *str) | |
239 { | |
240 if (str) | |
241 put_buffer(s, (const unsigned char *) str, strlen(str) + 1); | |
242 else | |
243 put_byte(s, 0); | |
244 } | |
245 | |
65 | 246 void put_le64(ByteIOContext *s, uint64_t val) |
0 | 247 { |
65 | 248 put_le32(s, (uint32_t)(val & 0xffffffff)); |
249 put_le32(s, (uint32_t)(val >> 32)); | |
0 | 250 } |
251 | |
65 | 252 void put_be64(ByteIOContext *s, uint64_t val) |
0 | 253 { |
65 | 254 put_be32(s, (uint32_t)(val >> 32)); |
255 put_be32(s, (uint32_t)(val & 0xffffffff)); | |
0 | 256 } |
257 | |
258 void put_le16(ByteIOContext *s, unsigned int val) | |
259 { | |
260 put_byte(s, val); | |
261 put_byte(s, val >> 8); | |
262 } | |
263 | |
264 void put_be16(ByteIOContext *s, unsigned int val) | |
265 { | |
266 put_byte(s, val >> 8); | |
267 put_byte(s, val); | |
268 } | |
269 | |
937 | 270 void put_le24(ByteIOContext *s, unsigned int val) |
271 { | |
272 put_le16(s, val & 0xffff); | |
273 put_byte(s, val >> 16); | |
274 } | |
275 | |
822 | 276 void put_be24(ByteIOContext *s, unsigned int val) |
277 { | |
278 put_be16(s, val >> 8); | |
279 put_byte(s, val); | |
280 } | |
281 | |
0 | 282 void put_tag(ByteIOContext *s, const char *tag) |
283 { | |
284 while (*tag) { | |
285 put_byte(s, *tag++); | |
286 } | |
287 } | |
288 | |
289 /* Input stream */ | |
290 | |
291 static void fill_buffer(ByteIOContext *s) | |
292 { | |
2576 | 293 int len=0; |
0 | 294 |
295 /* no need to do anything if EOF already reached */ | |
296 if (s->eof_reached) | |
297 return; | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
298 |
421 | 299 if(s->update_checksum){ |
780 | 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); | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
302 s->checksum_ptr= s->buffer; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
303 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
304 |
2576 | 305 if(s->read_packet) |
2577 | 306 len = s->read_packet(s->opaque, s->buffer, s->buffer_size); |
0 | 307 if (len <= 0) { |
308 /* do not modify buffer if EOF reached so that a seek back can | |
309 be done without rereading data */ | |
310 s->eof_reached = 1; | |
2082 | 311 if(len<0) |
312 s->error= len; | |
0 | 313 } else { |
314 s->pos += len; | |
315 s->buf_ptr = s->buffer; | |
316 s->buf_end = s->buffer + len; | |
317 } | |
318 } | |
319 | |
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
|
320 unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len){ |
2893 | 321 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
|
322 } |
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
|
323 |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
324 unsigned long get_checksum(ByteIOContext *s){ |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
325 s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr); |
421 | 326 s->update_checksum= NULL; |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
327 return s->checksum; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
328 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
329 |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
330 void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum){ |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
331 s->update_checksum= update_checksum; |
421 | 332 if(s->update_checksum){ |
1184 | 333 s->checksum= checksum; |
421 | 334 s->checksum_ptr= s->buf_ptr; |
335 } | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
336 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
389
diff
changeset
|
337 |
0 | 338 /* XXX: put an inline version */ |
339 int get_byte(ByteIOContext *s) | |
340 { | |
341 if (s->buf_ptr < s->buf_end) { | |
342 return *s->buf_ptr++; | |
343 } else { | |
344 fill_buffer(s); | |
345 if (s->buf_ptr < s->buf_end) | |
346 return *s->buf_ptr++; | |
347 else | |
348 return 0; | |
349 } | |
350 } | |
351 | |
352 int url_fgetc(ByteIOContext *s) | |
353 { | |
354 if (s->buf_ptr < s->buf_end) { | |
355 return *s->buf_ptr++; | |
356 } else { | |
357 fill_buffer(s); | |
358 if (s->buf_ptr < s->buf_end) | |
359 return *s->buf_ptr++; | |
360 else | |
361 return URL_EOF; | |
362 } | |
363 } | |
364 | |
365 int get_buffer(ByteIOContext *s, unsigned char *buf, int size) | |
366 { | |
367 int len, size1; | |
368 | |
369 size1 = size; | |
370 while (size > 0) { | |
371 len = s->buf_end - s->buf_ptr; | |
372 if (len > size) | |
373 len = size; | |
374 if (len == 0) { | |
719 | 375 if(size > s->buffer_size && !s->update_checksum){ |
2576 | 376 if(s->read_packet) |
2577 | 377 len = s->read_packet(s->opaque, buf, size); |
719 | 378 if (len <= 0) { |
379 /* do not modify buffer if EOF reached so that a seek back can | |
380 be done without rereading data */ | |
381 s->eof_reached = 1; | |
382 if(len<0) | |
383 s->error= len; | |
384 break; | |
385 } else { | |
386 s->pos += len; | |
387 size -= len; | |
388 buf += len; | |
389 s->buf_ptr = s->buffer; | |
390 s->buf_end = s->buffer/* + len*/; | |
391 } | |
392 }else{ | |
393 fill_buffer(s); | |
394 len = s->buf_end - s->buf_ptr; | |
395 if (len == 0) | |
396 break; | |
397 } | |
0 | 398 } else { |
399 memcpy(buf, s->buf_ptr, len); | |
400 buf += len; | |
401 s->buf_ptr += len; | |
402 size -= len; | |
403 } | |
404 } | |
405 return size1 - size; | |
406 } | |
407 | |
389
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
408 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
|
409 { |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
410 int len; |
885 | 411 |
643 | 412 if(size<0) |
413 return -1; | |
389
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
414 |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
415 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
|
416 if (len == 0) { |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
417 fill_buffer(s); |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
418 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
|
419 } |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
420 if (len > size) |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
421 len = size; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
422 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
|
423 s->buf_ptr += len; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
424 return len; |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
425 } |
e14fcd57ad2f
decode latency patch by (Leon van Stuivenberg <l dot vanstuivenberg at chello dot nl>)
michael
parents:
364
diff
changeset
|
426 |
0 | 427 unsigned int get_le16(ByteIOContext *s) |
428 { | |
429 unsigned int val; | |
430 val = get_byte(s); | |
431 val |= get_byte(s) << 8; | |
432 return val; | |
433 } | |
434 | |
937 | 435 unsigned int get_le24(ByteIOContext *s) |
436 { | |
437 unsigned int val; | |
438 val = get_le16(s); | |
439 val |= get_byte(s) << 16; | |
440 return val; | |
441 } | |
442 | |
0 | 443 unsigned int get_le32(ByteIOContext *s) |
444 { | |
445 unsigned int val; | |
822 | 446 val = get_le16(s); |
447 val |= get_le16(s) << 16; | |
0 | 448 return val; |
449 } | |
450 | |
65 | 451 uint64_t get_le64(ByteIOContext *s) |
0 | 452 { |
65 | 453 uint64_t val; |
454 val = (uint64_t)get_le32(s); | |
455 val |= (uint64_t)get_le32(s) << 32; | |
0 | 456 return val; |
457 } | |
458 | |
459 unsigned int get_be16(ByteIOContext *s) | |
460 { | |
461 unsigned int val; | |
462 val = get_byte(s) << 8; | |
463 val |= get_byte(s); | |
464 return val; | |
465 } | |
466 | |
822 | 467 unsigned int get_be24(ByteIOContext *s) |
468 { | |
469 unsigned int val; | |
470 val = get_be16(s) << 8; | |
471 val |= get_byte(s); | |
472 return val; | |
473 } | |
0 | 474 unsigned int get_be32(ByteIOContext *s) |
475 { | |
476 unsigned int val; | |
822 | 477 val = get_be16(s) << 16; |
478 val |= get_be16(s); | |
0 | 479 return val; |
480 } | |
481 | |
482 char *get_strz(ByteIOContext *s, char *buf, int maxlen) | |
483 { | |
484 int i = 0; | |
485 char c; | |
486 | |
487 while ((c = get_byte(s))) { | |
488 if (i < maxlen-1) | |
489 buf[i++] = c; | |
490 } | |
885 | 491 |
0 | 492 buf[i] = 0; /* Ensure null terminated, but may be truncated */ |
493 | |
494 return buf; | |
495 } | |
496 | |
65 | 497 uint64_t get_be64(ByteIOContext *s) |
0 | 498 { |
65 | 499 uint64_t val; |
500 val = (uint64_t)get_be32(s) << 32; | |
501 val |= (uint64_t)get_be32(s); | |
0 | 502 return val; |
503 } | |
504 | |
2700 | 505 uint64_t ff_get_v(ByteIOContext *bc){ |
2699 | 506 uint64_t val = 0; |
507 int tmp; | |
508 | |
509 do{ | |
510 tmp = get_byte(bc); | |
511 val= (val<<7) + (tmp&127); | |
512 }while(tmp&128); | |
513 return val; | |
514 } | |
515 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
516 int url_fdopen(ByteIOContext **s, URLContext *h) |
0 | 517 { |
65 | 518 uint8_t *buffer; |
0 | 519 int buffer_size, max_packet_size; |
520 | |
885 | 521 |
0 | 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 */ | |
525 } else { | |
526 buffer_size = IO_BUFFER_SIZE; | |
527 } | |
528 buffer = av_malloc(buffer_size); | |
529 if (!buffer) | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
530 return AVERROR(ENOMEM); |
0 | 531 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
532 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
533 if(!*s) { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
534 av_free(buffer); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
535 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
536 } |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
537 |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
538 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
|
539 (h->flags & URL_WRONLY || h->flags & URL_RDWR), h, |
2831 | 540 url_read, url_write, url_seek) < 0) { |
0 | 541 av_free(buffer); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
542 av_freep(s); |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2082
diff
changeset
|
543 return AVERROR(EIO); |
0 | 544 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
545 (*s)->is_streamed = h->is_streamed; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
546 (*s)->max_packet_size = max_packet_size; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
547 if(h->prot) { |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
548 (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause; |
2840
f51675f78402
Make recently added and still unused read_seek functions return offset_t.
michael
parents:
2839
diff
changeset
|
549 (*s)->read_seek = (offset_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
|
550 } |
0 | 551 return 0; |
552 } | |
553 | |
554 int url_setbufsize(ByteIOContext *s, int buf_size) | |
555 { | |
65 | 556 uint8_t *buffer; |
0 | 557 buffer = av_malloc(buf_size); |
558 if (!buffer) | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1747
diff
changeset
|
559 return AVERROR(ENOMEM); |
0 | 560 |
561 av_free(s->buffer); | |
562 s->buffer = buffer; | |
563 s->buffer_size = buf_size; | |
564 s->buf_ptr = buffer; | |
2598
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
565 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
|
566 return 0; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
567 } |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
568 |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
569 int url_resetbuf(ByteIOContext *s, int flags) |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
570 { |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
571 URLContext *h = s->opaque; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
572 if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR)) |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
573 return AVERROR(EINVAL); |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
574 |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
575 if (flags & URL_WRONLY) { |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
576 s->buf_end = s->buffer + s->buffer_size; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
577 s->write_flag = 1; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
578 } else { |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
579 s->buf_end = s->buffer; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
580 s->write_flag = 0; |
fc7f8ee4700b
Add functionality to set the direction of a ByteIOContext buffer.
benoit
parents:
2577
diff
changeset
|
581 } |
0 | 582 return 0; |
583 } | |
584 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
585 int url_fopen(ByteIOContext **s, const char *filename, int flags) |
0 | 586 { |
587 URLContext *h; | |
588 int err; | |
589 | |
590 err = url_open(&h, filename, flags); | |
591 if (err < 0) | |
592 return err; | |
593 err = url_fdopen(s, h); | |
594 if (err < 0) { | |
595 url_close(h); | |
596 return err; | |
597 } | |
598 return 0; | |
599 } | |
600 | |
601 int url_fclose(ByteIOContext *s) | |
602 { | |
603 URLContext *h = s->opaque; | |
885 | 604 |
0 | 605 av_free(s->buffer); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
606 av_free(s); |
0 | 607 return url_close(h); |
608 } | |
609 | |
610 URLContext *url_fileno(ByteIOContext *s) | |
611 { | |
612 return s->opaque; | |
613 } | |
614 | |
858
66cc656ea404
Replace CONFIG_ENCODERS/CONFIG_DECODERS with CONFIG_MUXERS/CONFIG_DEMUXERS
diego
parents:
823
diff
changeset
|
615 #ifdef CONFIG_MUXERS |
0 | 616 int url_fprintf(ByteIOContext *s, const char *fmt, ...) |
617 { | |
618 va_list ap; | |
619 char buf[4096]; | |
620 int ret; | |
621 | |
622 va_start(ap, fmt); | |
623 ret = vsnprintf(buf, sizeof(buf), fmt, ap); | |
624 va_end(ap); | |
625 put_buffer(s, buf, strlen(buf)); | |
626 return ret; | |
627 } | |
858
66cc656ea404
Replace CONFIG_ENCODERS/CONFIG_DECODERS with CONFIG_MUXERS/CONFIG_DEMUXERS
diego
parents:
823
diff
changeset
|
628 #endif //CONFIG_MUXERS |
0 | 629 |
630 char *url_fgets(ByteIOContext *s, char *buf, int buf_size) | |
631 { | |
632 int c; | |
633 char *q; | |
634 | |
635 c = url_fgetc(s); | |
636 if (c == EOF) | |
637 return NULL; | |
638 q = buf; | |
639 for(;;) { | |
640 if (c == EOF || c == '\n') | |
641 break; | |
642 if ((q - buf) < buf_size - 1) | |
643 *q++ = c; | |
644 c = url_fgetc(s); | |
645 } | |
646 if (buf_size > 0) | |
647 *q = '\0'; | |
648 return buf; | |
649 } | |
650 | |
651 int url_fget_max_packet_size(ByteIOContext *s) | |
652 { | |
653 return s->max_packet_size; | |
654 } | |
655 | |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
656 int av_url_read_fpause(ByteIOContext *s, int pause) |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
657 { |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
658 if (!s->read_pause) |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
659 return AVERROR(ENOSYS); |
2839
b51319dd86e5
Merge recently added and still unused play and pause functions.
michael
parents:
2831
diff
changeset
|
660 return s->read_pause(s->opaque, pause); |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
661 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
662 |
2840
f51675f78402
Make recently added and still unused read_seek functions return offset_t.
michael
parents:
2839
diff
changeset
|
663 offset_t av_url_read_fseek(ByteIOContext *s, |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
664 int stream_index, int64_t timestamp, int flags) |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
665 { |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
666 URLContext *h = s->opaque; |
2840
f51675f78402
Make recently added and still unused read_seek functions return offset_t.
michael
parents:
2839
diff
changeset
|
667 offset_t ret; |
2783
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
668 if (!s->read_seek) |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
669 return AVERROR(ENOSYS); |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
670 ret = s->read_seek(h, stream_index, timestamp, flags); |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
671 if(ret >= 0) { |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
672 s->buf_ptr = s->buf_end; // Flush buffer |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
673 s->pos = s->seek(h, 0, SEEK_CUR); |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
674 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
675 return ret; |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
676 } |
1a9db30c1d1c
Extend ByteIOContext and add the buffered IO functions:
andoma
parents:
2771
diff
changeset
|
677 |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
678 /* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response |
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
679 * back to the server even if CONFIG_MUXERS is not set. */ |
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
680 #if defined(CONFIG_MUXERS) || defined(CONFIG_NETWORK) |
0 | 681 /* buffer handling */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
682 int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags) |
0 | 683 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
684 int ret; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
685 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
686 if(!*s) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
687 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
688 ret = init_put_byte(*s, buf, buf_size, |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
689 (flags & URL_WRONLY || flags & URL_RDWR), |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
690 NULL, NULL, NULL, NULL); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
691 if(ret != 0) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
692 av_freep(s); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
693 return ret; |
0 | 694 } |
695 | |
696 int url_close_buf(ByteIOContext *s) | |
697 { | |
698 put_flush_packet(s); | |
699 return s->buf_ptr - s->buffer; | |
700 } | |
701 | |
702 /* output in a dynamic buffer */ | |
703 | |
704 typedef struct DynBuffer { | |
705 int pos, size, allocated_size; | |
65 | 706 uint8_t *buffer; |
0 | 707 int io_buffer_size; |
65 | 708 uint8_t io_buffer[1]; |
0 | 709 } DynBuffer; |
710 | |
554 | 711 static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size) |
0 | 712 { |
713 DynBuffer *d = opaque; | |
714 int new_size, new_allocated_size; | |
885 | 715 |
0 | 716 /* reallocate buffer if needed */ |
717 new_size = d->pos + buf_size; | |
718 new_allocated_size = d->allocated_size; | |
639 | 719 if(new_size < d->pos || new_size > INT_MAX/2) |
720 return -1; | |
0 | 721 while (new_size > new_allocated_size) { |
722 if (!new_allocated_size) | |
723 new_allocated_size = new_size; | |
724 else | |
885 | 725 new_allocated_size += new_allocated_size / 2 + 1; |
0 | 726 } |
885 | 727 |
0 | 728 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
|
729 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
|
730 if(d->buffer == NULL) |
554 | 731 return -1234; |
0 | 732 d->allocated_size = new_allocated_size; |
733 } | |
734 memcpy(d->buffer + d->pos, buf, buf_size); | |
735 d->pos = new_size; | |
736 if (d->pos > d->size) | |
737 d->size = d->pos; | |
554 | 738 return buf_size; |
0 | 739 } |
740 | |
554 | 741 static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size) |
0 | 742 { |
743 unsigned char buf1[4]; | |
554 | 744 int ret; |
0 | 745 |
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); | |
554 | 751 ret= dyn_buf_write(opaque, buf1, 4); |
752 if(ret < 0) | |
753 return ret; | |
0 | 754 |
755 /* then the data */ | |
554 | 756 return dyn_buf_write(opaque, buf, buf_size); |
0 | 757 } |
758 | |
778
4fbe04f998bf
Fix url_fsize for large files patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents:
764
diff
changeset
|
759 static offset_t dyn_buf_seek(void *opaque, offset_t offset, int whence) |
0 | 760 { |
761 DynBuffer *d = opaque; | |
762 | |
763 if (whence == SEEK_CUR) | |
764 offset += d->pos; | |
765 else if (whence == SEEK_END) | |
766 offset += d->size; | |
767 if (offset < 0 || offset > 0x7fffffffLL) | |
768 return -1; | |
769 d->pos = offset; | |
770 return 0; | |
771 } | |
772 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
773 static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size) |
0 | 774 { |
775 DynBuffer *d; | |
776 int io_buffer_size, ret; | |
885 | 777 |
778 if (max_packet_size) | |
0 | 779 io_buffer_size = max_packet_size; |
780 else | |
781 io_buffer_size = 1024; | |
885 | 782 |
639 | 783 if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size) |
784 return -1; | |
0 | 785 d = av_malloc(sizeof(DynBuffer) + io_buffer_size); |
786 if (!d) | |
787 return -1; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
788 *s = av_mallocz(sizeof(ByteIOContext)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
789 if(!*s) { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
790 av_free(d); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
791 return AVERROR(ENOMEM); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
792 } |
0 | 793 d->io_buffer_size = io_buffer_size; |
794 d->buffer = NULL; | |
795 d->pos = 0; | |
796 d->size = 0; | |
797 d->allocated_size = 0; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
798 ret = init_put_byte(*s, d->io_buffer, io_buffer_size, |
885 | 799 1, d, NULL, |
800 max_packet_size ? dyn_packet_buf_write : dyn_buf_write, | |
0 | 801 max_packet_size ? NULL : dyn_buf_seek); |
802 if (ret == 0) { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
803 (*s)->max_packet_size = max_packet_size; |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
804 } else { |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
805 av_free(d); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
806 av_freep(s); |
0 | 807 } |
808 return ret; | |
809 } | |
810 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
811 int url_open_dyn_buf(ByteIOContext **s) |
0 | 812 { |
813 return url_open_dyn_buf_internal(s, 0); | |
814 } | |
815 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
816 int url_open_dyn_packet_buf(ByteIOContext **s, int max_packet_size) |
0 | 817 { |
818 if (max_packet_size <= 0) | |
819 return -1; | |
820 return url_open_dyn_buf_internal(s, max_packet_size); | |
821 } | |
822 | |
65 | 823 int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer) |
0 | 824 { |
825 DynBuffer *d = s->opaque; | |
826 int size; | |
827 | |
828 put_flush_packet(s); | |
829 | |
830 *pbuffer = d->buffer; | |
831 size = d->size; | |
832 av_free(d); | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2700
diff
changeset
|
833 av_free(s); |
0 | 834 return size; |
835 } | |
1546
41356096b2d0
Fix compile with --disable-muxers, patch by Lo«Ác Le Loarer, lll+ffmpeg m4x org.
diego
parents:
1403
diff
changeset
|
836 #endif /* CONFIG_MUXERS || CONFIG_NETWORK */ |