ffmpeg / libavformat / aviobuf.c @ 576ae256
History | View | Annotate | Download (17.8 KB)
1 |
/*
|
---|---|
2 |
* Buffered I/O for ffmpeg system
|
3 |
* Copyright (c) 2000,2001 Fabrice Bellard
|
4 |
*
|
5 |
* This library is free software; you can redistribute it and/or
|
6 |
* modify it under the terms of the GNU Lesser General Public
|
7 |
* License as published by the Free Software Foundation; either
|
8 |
* version 2 of the License, or (at your option) any later version.
|
9 |
*
|
10 |
* This library is distributed in the hope that it will be useful,
|
11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
13 |
* Lesser General Public License for more details.
|
14 |
*
|
15 |
* You should have received a copy of the GNU Lesser General Public
|
16 |
* License along with this library; if not, write to the Free Software
|
17 |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
18 |
*/
|
19 |
#include "avformat.h" |
20 |
#include "avio.h" |
21 |
#include <stdarg.h> |
22 |
|
23 |
#define IO_BUFFER_SIZE 32768 |
24 |
|
25 |
int init_put_byte(ByteIOContext *s,
|
26 |
unsigned char *buffer, |
27 |
int buffer_size,
|
28 |
int write_flag,
|
29 |
void *opaque,
|
30 |
int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), |
31 |
int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), |
32 |
int (*seek)(void *opaque, offset_t offset, int whence)) |
33 |
{ |
34 |
s->buffer = buffer; |
35 |
s->buffer_size = buffer_size; |
36 |
s->buf_ptr = buffer; |
37 |
s->write_flag = write_flag; |
38 |
if (!s->write_flag)
|
39 |
s->buf_end = buffer; |
40 |
else
|
41 |
s->buf_end = buffer + buffer_size; |
42 |
s->opaque = opaque; |
43 |
s->write_packet = write_packet; |
44 |
s->read_packet = read_packet; |
45 |
s->seek = seek; |
46 |
s->pos = 0;
|
47 |
s->must_flush = 0;
|
48 |
s->eof_reached = 0;
|
49 |
s->error = 0;
|
50 |
s->is_streamed = 0;
|
51 |
s->max_packet_size = 0;
|
52 |
s->update_checksum= NULL;
|
53 |
return 0; |
54 |
} |
55 |
|
56 |
|
57 |
#ifdef CONFIG_ENCODERS
|
58 |
static void flush_buffer(ByteIOContext *s) |
59 |
{ |
60 |
if (s->buf_ptr > s->buffer) {
|
61 |
if (s->write_packet && !s->error){
|
62 |
int ret= s->write_packet(s->opaque, s->buffer, s->buf_ptr - s->buffer);
|
63 |
if(ret < 0){ |
64 |
s->error = ret; |
65 |
} |
66 |
} |
67 |
if(s->update_checksum){
|
68 |
s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr); |
69 |
s->checksum_ptr= s->buffer; |
70 |
} |
71 |
s->pos += s->buf_ptr - s->buffer; |
72 |
} |
73 |
s->buf_ptr = s->buffer; |
74 |
} |
75 |
|
76 |
void put_byte(ByteIOContext *s, int b) |
77 |
{ |
78 |
*(s->buf_ptr)++ = b; |
79 |
if (s->buf_ptr >= s->buf_end)
|
80 |
flush_buffer(s); |
81 |
} |
82 |
|
83 |
void put_buffer(ByteIOContext *s, const unsigned char *buf, int size) |
84 |
{ |
85 |
int len;
|
86 |
|
87 |
while (size > 0) { |
88 |
len = (s->buf_end - s->buf_ptr); |
89 |
if (len > size)
|
90 |
len = size; |
91 |
memcpy(s->buf_ptr, buf, len); |
92 |
s->buf_ptr += len; |
93 |
|
94 |
if (s->buf_ptr >= s->buf_end)
|
95 |
flush_buffer(s); |
96 |
|
97 |
buf += len; |
98 |
size -= len; |
99 |
} |
100 |
} |
101 |
|
102 |
void put_flush_packet(ByteIOContext *s)
|
103 |
{ |
104 |
flush_buffer(s); |
105 |
s->must_flush = 0;
|
106 |
} |
107 |
#endif //CONFIG_ENCODERS |
108 |
|
109 |
offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)
|
110 |
{ |
111 |
offset_t offset1; |
112 |
|
113 |
if (whence != SEEK_CUR && whence != SEEK_SET)
|
114 |
return -EINVAL;
|
115 |
|
116 |
#ifdef CONFIG_ENCODERS
|
117 |
if (s->write_flag) {
|
118 |
if (whence == SEEK_CUR) {
|
119 |
offset1 = s->pos + (s->buf_ptr - s->buffer); |
120 |
if (offset == 0) |
121 |
return offset1;
|
122 |
offset += offset1; |
123 |
} |
124 |
offset1 = offset - s->pos; |
125 |
if (!s->must_flush &&
|
126 |
offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
|
127 |
/* can do the seek inside the buffer */
|
128 |
s->buf_ptr = s->buffer + offset1; |
129 |
} else {
|
130 |
if (!s->seek)
|
131 |
return -EPIPE;
|
132 |
flush_buffer(s); |
133 |
s->must_flush = 1;
|
134 |
s->buf_ptr = s->buffer; |
135 |
s->seek(s->opaque, offset, SEEK_SET); |
136 |
s->pos = offset; |
137 |
} |
138 |
} else
|
139 |
#endif //CONFIG_ENCODERS |
140 |
{ |
141 |
if (whence == SEEK_CUR) {
|
142 |
offset1 = s->pos - (s->buf_end - s->buffer) + (s->buf_ptr - s->buffer); |
143 |
if (offset == 0) |
144 |
return offset1;
|
145 |
offset += offset1; |
146 |
} |
147 |
offset1 = offset - (s->pos - (s->buf_end - s->buffer)); |
148 |
if (offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) { |
149 |
/* can do the seek inside the buffer */
|
150 |
s->buf_ptr = s->buffer + offset1; |
151 |
} else {
|
152 |
if (!s->seek)
|
153 |
return -EPIPE;
|
154 |
s->buf_ptr = s->buffer; |
155 |
s->buf_end = s->buffer; |
156 |
if (s->seek(s->opaque, offset, SEEK_SET) == (offset_t)-EPIPE)
|
157 |
return -EPIPE;
|
158 |
s->pos = offset; |
159 |
} |
160 |
s->eof_reached = 0;
|
161 |
} |
162 |
return offset;
|
163 |
} |
164 |
|
165 |
void url_fskip(ByteIOContext *s, offset_t offset)
|
166 |
{ |
167 |
url_fseek(s, offset, SEEK_CUR); |
168 |
} |
169 |
|
170 |
offset_t url_ftell(ByteIOContext *s) |
171 |
{ |
172 |
return url_fseek(s, 0, SEEK_CUR); |
173 |
} |
174 |
|
175 |
int url_feof(ByteIOContext *s)
|
176 |
{ |
177 |
return s->eof_reached;
|
178 |
} |
179 |
|
180 |
int url_ferror(ByteIOContext *s)
|
181 |
{ |
182 |
return s->error;
|
183 |
} |
184 |
|
185 |
#ifdef CONFIG_ENCODERS
|
186 |
void put_le32(ByteIOContext *s, unsigned int val) |
187 |
{ |
188 |
put_byte(s, val); |
189 |
put_byte(s, val >> 8);
|
190 |
put_byte(s, val >> 16);
|
191 |
put_byte(s, val >> 24);
|
192 |
} |
193 |
|
194 |
void put_be32(ByteIOContext *s, unsigned int val) |
195 |
{ |
196 |
put_byte(s, val >> 24);
|
197 |
put_byte(s, val >> 16);
|
198 |
put_byte(s, val >> 8);
|
199 |
put_byte(s, val); |
200 |
} |
201 |
|
202 |
/* IEEE format is assumed */
|
203 |
void put_be64_double(ByteIOContext *s, double val) |
204 |
{ |
205 |
union {
|
206 |
double d;
|
207 |
uint64_t ull; |
208 |
} u; |
209 |
u.d = val; |
210 |
put_be64(s, u.ull); |
211 |
} |
212 |
|
213 |
void put_strz(ByteIOContext *s, const char *str) |
214 |
{ |
215 |
if (str)
|
216 |
put_buffer(s, (const unsigned char *) str, strlen(str) + 1); |
217 |
else
|
218 |
put_byte(s, 0);
|
219 |
} |
220 |
|
221 |
void put_le64(ByteIOContext *s, uint64_t val)
|
222 |
{ |
223 |
put_le32(s, (uint32_t)(val & 0xffffffff));
|
224 |
put_le32(s, (uint32_t)(val >> 32));
|
225 |
} |
226 |
|
227 |
void put_be64(ByteIOContext *s, uint64_t val)
|
228 |
{ |
229 |
put_be32(s, (uint32_t)(val >> 32));
|
230 |
put_be32(s, (uint32_t)(val & 0xffffffff));
|
231 |
} |
232 |
|
233 |
void put_le16(ByteIOContext *s, unsigned int val) |
234 |
{ |
235 |
put_byte(s, val); |
236 |
put_byte(s, val >> 8);
|
237 |
} |
238 |
|
239 |
void put_be16(ByteIOContext *s, unsigned int val) |
240 |
{ |
241 |
put_byte(s, val >> 8);
|
242 |
put_byte(s, val); |
243 |
} |
244 |
|
245 |
void put_tag(ByteIOContext *s, const char *tag) |
246 |
{ |
247 |
while (*tag) {
|
248 |
put_byte(s, *tag++); |
249 |
} |
250 |
} |
251 |
#endif //CONFIG_ENCODERS |
252 |
|
253 |
/* Input stream */
|
254 |
|
255 |
static void fill_buffer(ByteIOContext *s) |
256 |
{ |
257 |
int len;
|
258 |
|
259 |
/* no need to do anything if EOF already reached */
|
260 |
if (s->eof_reached)
|
261 |
return;
|
262 |
|
263 |
if(s->update_checksum){
|
264 |
s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_end - s->checksum_ptr); |
265 |
s->checksum_ptr= s->buffer; |
266 |
} |
267 |
|
268 |
len = s->read_packet(s->opaque, s->buffer, s->buffer_size); |
269 |
if (len <= 0) { |
270 |
/* do not modify buffer if EOF reached so that a seek back can
|
271 |
be done without rereading data */
|
272 |
s->eof_reached = 1;
|
273 |
if(len<0) |
274 |
s->error= len; |
275 |
} else {
|
276 |
s->pos += len; |
277 |
s->buf_ptr = s->buffer; |
278 |
s->buf_end = s->buffer + len; |
279 |
} |
280 |
} |
281 |
|
282 |
unsigned long get_checksum(ByteIOContext *s){ |
283 |
s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr); |
284 |
s->update_checksum= NULL;
|
285 |
return s->checksum;
|
286 |
} |
287 |
|
288 |
void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum){ |
289 |
s->update_checksum= update_checksum; |
290 |
if(s->update_checksum){
|
291 |
s->checksum= s->update_checksum(checksum, NULL, 0); |
292 |
s->checksum_ptr= s->buf_ptr; |
293 |
} |
294 |
} |
295 |
|
296 |
/* NOTE: return 0 if EOF, so you cannot use it if EOF handling is
|
297 |
necessary */
|
298 |
/* XXX: put an inline version */
|
299 |
int get_byte(ByteIOContext *s)
|
300 |
{ |
301 |
if (s->buf_ptr < s->buf_end) {
|
302 |
return *s->buf_ptr++;
|
303 |
} else {
|
304 |
fill_buffer(s); |
305 |
if (s->buf_ptr < s->buf_end)
|
306 |
return *s->buf_ptr++;
|
307 |
else
|
308 |
return 0; |
309 |
} |
310 |
} |
311 |
|
312 |
/* NOTE: return URL_EOF (-1) if EOF */
|
313 |
int url_fgetc(ByteIOContext *s)
|
314 |
{ |
315 |
if (s->buf_ptr < s->buf_end) {
|
316 |
return *s->buf_ptr++;
|
317 |
} else {
|
318 |
fill_buffer(s); |
319 |
if (s->buf_ptr < s->buf_end)
|
320 |
return *s->buf_ptr++;
|
321 |
else
|
322 |
return URL_EOF;
|
323 |
} |
324 |
} |
325 |
|
326 |
int get_buffer(ByteIOContext *s, unsigned char *buf, int size) |
327 |
{ |
328 |
int len, size1;
|
329 |
|
330 |
size1 = size; |
331 |
while (size > 0) { |
332 |
len = s->buf_end - s->buf_ptr; |
333 |
if (len > size)
|
334 |
len = size; |
335 |
if (len == 0) { |
336 |
fill_buffer(s); |
337 |
len = s->buf_end - s->buf_ptr; |
338 |
if (len == 0) |
339 |
break;
|
340 |
} else {
|
341 |
memcpy(buf, s->buf_ptr, len); |
342 |
buf += len; |
343 |
s->buf_ptr += len; |
344 |
size -= len; |
345 |
} |
346 |
} |
347 |
return size1 - size;
|
348 |
} |
349 |
|
350 |
int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size) |
351 |
{ |
352 |
int len;
|
353 |
|
354 |
len = s->buf_end - s->buf_ptr; |
355 |
if (len == 0) { |
356 |
fill_buffer(s); |
357 |
len = s->buf_end - s->buf_ptr; |
358 |
} |
359 |
if (len > size)
|
360 |
len = size; |
361 |
memcpy(buf, s->buf_ptr, len); |
362 |
s->buf_ptr += len; |
363 |
return len;
|
364 |
} |
365 |
|
366 |
unsigned int get_le16(ByteIOContext *s) |
367 |
{ |
368 |
unsigned int val; |
369 |
val = get_byte(s); |
370 |
val |= get_byte(s) << 8;
|
371 |
return val;
|
372 |
} |
373 |
|
374 |
unsigned int get_le32(ByteIOContext *s) |
375 |
{ |
376 |
unsigned int val; |
377 |
val = get_byte(s); |
378 |
val |= get_byte(s) << 8;
|
379 |
val |= get_byte(s) << 16;
|
380 |
val |= get_byte(s) << 24;
|
381 |
return val;
|
382 |
} |
383 |
|
384 |
uint64_t get_le64(ByteIOContext *s) |
385 |
{ |
386 |
uint64_t val; |
387 |
val = (uint64_t)get_le32(s); |
388 |
val |= (uint64_t)get_le32(s) << 32;
|
389 |
return val;
|
390 |
} |
391 |
|
392 |
unsigned int get_be16(ByteIOContext *s) |
393 |
{ |
394 |
unsigned int val; |
395 |
val = get_byte(s) << 8;
|
396 |
val |= get_byte(s); |
397 |
return val;
|
398 |
} |
399 |
|
400 |
unsigned int get_be32(ByteIOContext *s) |
401 |
{ |
402 |
unsigned int val; |
403 |
val = get_byte(s) << 24;
|
404 |
val |= get_byte(s) << 16;
|
405 |
val |= get_byte(s) << 8;
|
406 |
val |= get_byte(s); |
407 |
return val;
|
408 |
} |
409 |
|
410 |
double get_be64_double(ByteIOContext *s)
|
411 |
{ |
412 |
union {
|
413 |
double d;
|
414 |
uint64_t ull; |
415 |
} u; |
416 |
|
417 |
u.ull = get_be64(s); |
418 |
return u.d;
|
419 |
} |
420 |
|
421 |
char *get_strz(ByteIOContext *s, char *buf, int maxlen) |
422 |
{ |
423 |
int i = 0; |
424 |
char c;
|
425 |
|
426 |
while ((c = get_byte(s))) {
|
427 |
if (i < maxlen-1) |
428 |
buf[i++] = c; |
429 |
} |
430 |
|
431 |
buf[i] = 0; /* Ensure null terminated, but may be truncated */ |
432 |
|
433 |
return buf;
|
434 |
} |
435 |
|
436 |
uint64_t get_be64(ByteIOContext *s) |
437 |
{ |
438 |
uint64_t val; |
439 |
val = (uint64_t)get_be32(s) << 32;
|
440 |
val |= (uint64_t)get_be32(s); |
441 |
return val;
|
442 |
} |
443 |
|
444 |
/* link with avio functions */
|
445 |
|
446 |
#ifdef CONFIG_ENCODERS
|
447 |
static int url_write_packet(void *opaque, uint8_t *buf, int buf_size) |
448 |
{ |
449 |
URLContext *h = opaque; |
450 |
return url_write(h, buf, buf_size);
|
451 |
} |
452 |
#else
|
453 |
#define url_write_packet NULL |
454 |
#endif //CONFIG_ENCODERS |
455 |
|
456 |
static int url_read_packet(void *opaque, uint8_t *buf, int buf_size) |
457 |
{ |
458 |
URLContext *h = opaque; |
459 |
return url_read(h, buf, buf_size);
|
460 |
} |
461 |
|
462 |
static int url_seek_packet(void *opaque, int64_t offset, int whence) |
463 |
{ |
464 |
URLContext *h = opaque; |
465 |
return url_seek(h, offset, whence);
|
466 |
//return 0;
|
467 |
} |
468 |
|
469 |
int url_fdopen(ByteIOContext *s, URLContext *h)
|
470 |
{ |
471 |
uint8_t *buffer; |
472 |
int buffer_size, max_packet_size;
|
473 |
|
474 |
|
475 |
max_packet_size = url_get_max_packet_size(h); |
476 |
if (max_packet_size) {
|
477 |
buffer_size = max_packet_size; /* no need to bufferize more than one packet */
|
478 |
} else {
|
479 |
buffer_size = IO_BUFFER_SIZE; |
480 |
} |
481 |
buffer = av_malloc(buffer_size); |
482 |
if (!buffer)
|
483 |
return -ENOMEM;
|
484 |
|
485 |
if (init_put_byte(s, buffer, buffer_size,
|
486 |
(h->flags & URL_WRONLY || h->flags & URL_RDWR), h, |
487 |
url_read_packet, url_write_packet, url_seek_packet) < 0) {
|
488 |
av_free(buffer); |
489 |
return AVERROR_IO;
|
490 |
} |
491 |
s->is_streamed = h->is_streamed; |
492 |
s->max_packet_size = max_packet_size; |
493 |
return 0; |
494 |
} |
495 |
|
496 |
/* XXX: must be called before any I/O */
|
497 |
int url_setbufsize(ByteIOContext *s, int buf_size) |
498 |
{ |
499 |
uint8_t *buffer; |
500 |
buffer = av_malloc(buf_size); |
501 |
if (!buffer)
|
502 |
return -ENOMEM;
|
503 |
|
504 |
av_free(s->buffer); |
505 |
s->buffer = buffer; |
506 |
s->buffer_size = buf_size; |
507 |
s->buf_ptr = buffer; |
508 |
if (!s->write_flag)
|
509 |
s->buf_end = buffer; |
510 |
else
|
511 |
s->buf_end = buffer + buf_size; |
512 |
return 0; |
513 |
} |
514 |
|
515 |
/* NOTE: when opened as read/write, the buffers are only used for
|
516 |
reading */
|
517 |
int url_fopen(ByteIOContext *s, const char *filename, int flags) |
518 |
{ |
519 |
URLContext *h; |
520 |
int err;
|
521 |
|
522 |
err = url_open(&h, filename, flags); |
523 |
if (err < 0) |
524 |
return err;
|
525 |
err = url_fdopen(s, h); |
526 |
if (err < 0) { |
527 |
url_close(h); |
528 |
return err;
|
529 |
} |
530 |
return 0; |
531 |
} |
532 |
|
533 |
int url_fclose(ByteIOContext *s)
|
534 |
{ |
535 |
URLContext *h = s->opaque; |
536 |
|
537 |
av_free(s->buffer); |
538 |
memset(s, 0, sizeof(ByteIOContext)); |
539 |
return url_close(h);
|
540 |
} |
541 |
|
542 |
URLContext *url_fileno(ByteIOContext *s) |
543 |
{ |
544 |
return s->opaque;
|
545 |
} |
546 |
|
547 |
#ifdef CONFIG_ENCODERS
|
548 |
/* XXX: currently size is limited */
|
549 |
int url_fprintf(ByteIOContext *s, const char *fmt, ...) |
550 |
{ |
551 |
va_list ap; |
552 |
char buf[4096]; |
553 |
int ret;
|
554 |
|
555 |
va_start(ap, fmt); |
556 |
ret = vsnprintf(buf, sizeof(buf), fmt, ap);
|
557 |
va_end(ap); |
558 |
put_buffer(s, buf, strlen(buf)); |
559 |
return ret;
|
560 |
} |
561 |
#endif //CONFIG_ENCODERS |
562 |
|
563 |
/* note: unlike fgets, the EOL character is not returned and a whole
|
564 |
line is parsed. return NULL if first char read was EOF */
|
565 |
char *url_fgets(ByteIOContext *s, char *buf, int buf_size) |
566 |
{ |
567 |
int c;
|
568 |
char *q;
|
569 |
|
570 |
c = url_fgetc(s); |
571 |
if (c == EOF) |
572 |
return NULL; |
573 |
q = buf; |
574 |
for(;;) {
|
575 |
if (c == EOF || c == '\n') |
576 |
break;
|
577 |
if ((q - buf) < buf_size - 1) |
578 |
*q++ = c; |
579 |
c = url_fgetc(s); |
580 |
} |
581 |
if (buf_size > 0) |
582 |
*q = '\0';
|
583 |
return buf;
|
584 |
} |
585 |
|
586 |
/*
|
587 |
* Return the maximum packet size associated to packetized buffered file
|
588 |
* handle. If the file is not packetized (stream like http or file on
|
589 |
* disk), then 0 is returned.
|
590 |
*
|
591 |
* @param h buffered file handle
|
592 |
* @return maximum packet size in bytes
|
593 |
*/
|
594 |
int url_fget_max_packet_size(ByteIOContext *s)
|
595 |
{ |
596 |
return s->max_packet_size;
|
597 |
} |
598 |
|
599 |
#ifdef CONFIG_ENCODERS
|
600 |
/* buffer handling */
|
601 |
int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags) |
602 |
{ |
603 |
return init_put_byte(s, buf, buf_size,
|
604 |
(flags & URL_WRONLY || flags & URL_RDWR), |
605 |
NULL, NULL, NULL, NULL); |
606 |
} |
607 |
|
608 |
/* return the written or read size */
|
609 |
int url_close_buf(ByteIOContext *s)
|
610 |
{ |
611 |
put_flush_packet(s); |
612 |
return s->buf_ptr - s->buffer;
|
613 |
} |
614 |
|
615 |
/* output in a dynamic buffer */
|
616 |
|
617 |
typedef struct DynBuffer { |
618 |
int pos, size, allocated_size;
|
619 |
uint8_t *buffer; |
620 |
int io_buffer_size;
|
621 |
uint8_t io_buffer[1];
|
622 |
} DynBuffer; |
623 |
|
624 |
static int dyn_buf_write(void *opaque, uint8_t *buf, int buf_size) |
625 |
{ |
626 |
DynBuffer *d = opaque; |
627 |
int new_size, new_allocated_size;
|
628 |
|
629 |
/* reallocate buffer if needed */
|
630 |
new_size = d->pos + buf_size; |
631 |
new_allocated_size = d->allocated_size; |
632 |
while (new_size > new_allocated_size) {
|
633 |
if (!new_allocated_size)
|
634 |
new_allocated_size = new_size; |
635 |
else
|
636 |
new_allocated_size = (new_allocated_size * 3) / 2 + 1; |
637 |
} |
638 |
|
639 |
if (new_allocated_size > d->allocated_size) {
|
640 |
d->buffer = av_realloc(d->buffer, new_allocated_size); |
641 |
if(d->buffer == NULL) |
642 |
return -1234; |
643 |
d->allocated_size = new_allocated_size; |
644 |
} |
645 |
memcpy(d->buffer + d->pos, buf, buf_size); |
646 |
d->pos = new_size; |
647 |
if (d->pos > d->size)
|
648 |
d->size = d->pos; |
649 |
return buf_size;
|
650 |
} |
651 |
|
652 |
static int dyn_packet_buf_write(void *opaque, uint8_t *buf, int buf_size) |
653 |
{ |
654 |
unsigned char buf1[4]; |
655 |
int ret;
|
656 |
|
657 |
/* packetized write: output the header */
|
658 |
buf1[0] = (buf_size >> 24); |
659 |
buf1[1] = (buf_size >> 16); |
660 |
buf1[2] = (buf_size >> 8); |
661 |
buf1[3] = (buf_size);
|
662 |
ret= dyn_buf_write(opaque, buf1, 4);
|
663 |
if(ret < 0) |
664 |
return ret;
|
665 |
|
666 |
/* then the data */
|
667 |
return dyn_buf_write(opaque, buf, buf_size);
|
668 |
} |
669 |
|
670 |
static int dyn_buf_seek(void *opaque, offset_t offset, int whence) |
671 |
{ |
672 |
DynBuffer *d = opaque; |
673 |
|
674 |
if (whence == SEEK_CUR)
|
675 |
offset += d->pos; |
676 |
else if (whence == SEEK_END) |
677 |
offset += d->size; |
678 |
if (offset < 0 || offset > 0x7fffffffLL) |
679 |
return -1; |
680 |
d->pos = offset; |
681 |
return 0; |
682 |
} |
683 |
|
684 |
static int url_open_dyn_buf_internal(ByteIOContext *s, int max_packet_size) |
685 |
{ |
686 |
DynBuffer *d; |
687 |
int io_buffer_size, ret;
|
688 |
|
689 |
if (max_packet_size)
|
690 |
io_buffer_size = max_packet_size; |
691 |
else
|
692 |
io_buffer_size = 1024;
|
693 |
|
694 |
d = av_malloc(sizeof(DynBuffer) + io_buffer_size);
|
695 |
if (!d)
|
696 |
return -1; |
697 |
d->io_buffer_size = io_buffer_size; |
698 |
d->buffer = NULL;
|
699 |
d->pos = 0;
|
700 |
d->size = 0;
|
701 |
d->allocated_size = 0;
|
702 |
ret = init_put_byte(s, d->io_buffer, io_buffer_size, |
703 |
1, d, NULL, |
704 |
max_packet_size ? dyn_packet_buf_write : dyn_buf_write, |
705 |
max_packet_size ? NULL : dyn_buf_seek);
|
706 |
if (ret == 0) { |
707 |
s->max_packet_size = max_packet_size; |
708 |
} |
709 |
return ret;
|
710 |
} |
711 |
|
712 |
/*
|
713 |
* Open a write only memory stream.
|
714 |
*
|
715 |
* @param s new IO context
|
716 |
* @return zero if no error.
|
717 |
*/
|
718 |
int url_open_dyn_buf(ByteIOContext *s)
|
719 |
{ |
720 |
return url_open_dyn_buf_internal(s, 0); |
721 |
} |
722 |
|
723 |
/*
|
724 |
* Open a write only packetized memory stream with a maximum packet
|
725 |
* size of 'max_packet_size'. The stream is stored in a memory buffer
|
726 |
* with a big endian 4 byte header giving the packet size in bytes.
|
727 |
*
|
728 |
* @param s new IO context
|
729 |
* @param max_packet_size maximum packet size (must be > 0)
|
730 |
* @return zero if no error.
|
731 |
*/
|
732 |
int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size) |
733 |
{ |
734 |
if (max_packet_size <= 0) |
735 |
return -1; |
736 |
return url_open_dyn_buf_internal(s, max_packet_size);
|
737 |
} |
738 |
|
739 |
/*
|
740 |
* Return the written size and a pointer to the buffer. The buffer
|
741 |
* must be freed with av_free().
|
742 |
* @param s IO context
|
743 |
* @param pointer to a byte buffer
|
744 |
* @return the length of the byte buffer
|
745 |
*/
|
746 |
int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
|
747 |
{ |
748 |
DynBuffer *d = s->opaque; |
749 |
int size;
|
750 |
|
751 |
put_flush_packet(s); |
752 |
|
753 |
*pbuffer = d->buffer; |
754 |
size = d->size; |
755 |
av_free(d); |
756 |
return size;
|
757 |
} |
758 |
#endif //CONFIG_ENCODERS |