← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libav/oneiric

« back to all changes in this revision

Viewing changes to libavformat/aviobuf.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-30 14:27:42 UTC
  • mfrom: (1.1.2 experimental)
  • Revision ID: james.westby@ubuntu.com-20110430142742-quvblxk1tj6adlh5
Tags: 4:0.7~b1-1ubuntu1
http://bugs.debian.org/623682
* Merge from debian. Remaining changes:
  - don't build against libfaad, libdirac, librtmp and libopenjpeg
    (all in universe)
  - explicitly --enable-pic on powerpc, cf. LP #654666
  - different arm configure bits that should probably better be
    merged into debian
* Cherry-picked from git: 
  - install doc/APIChanges and refer to them in NEWS.Debian (Closes: #623682)
  - don't try to install non-existing documentation, fixes FTBFS on powerpc

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavformat/aviobuf.c
2
2
 * Buffered I/O for ffmpeg system
3
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
4
 *
5
 
 * This file is part of FFmpeg.
 
5
 * This file is part of Libav.
6
6
 *
7
 
 * FFmpeg is free software; you can redistribute it and/or
 
7
 * Libav is free software; you can redistribute it and/or
8
8
 * modify it under the terms of the GNU Lesser General Public
9
9
 * License as published by the Free Software Foundation; either
10
10
 * version 2.1 of the License, or (at your option) any later version.
11
11
 *
12
 
 * FFmpeg is distributed in the hope that it will be useful,
 
12
 * Libav is distributed in the hope that it will be useful,
13
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
15
 * Lesser General Public License for more details.
16
16
 *
17
17
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with FFmpeg; if not, write to the Free Software
 
18
 * License along with Libav; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
21
 
23
23
#include "libavutil/intreadwrite.h"
24
24
#include "avformat.h"
25
25
#include "avio.h"
 
26
#include "avio_internal.h"
 
27
#include "internal.h"
 
28
#include "url.h"
26
29
#include <stdarg.h>
27
30
 
28
31
#define IO_BUFFER_SIZE 32768
34
37
 */
35
38
#define SHORT_SEEK_THRESHOLD 4096
36
39
 
37
 
static void fill_buffer(ByteIOContext *s);
38
 
#if LIBAVFORMAT_VERSION_MAJOR >= 53
39
 
static int url_resetbuf(ByteIOContext *s, int flags);
 
40
static void fill_buffer(AVIOContext *s);
 
41
#if !FF_API_URL_RESETBUF
 
42
static int url_resetbuf(AVIOContext *s, int flags);
40
43
#endif
41
44
 
42
 
int init_put_byte(ByteIOContext *s,
 
45
int ffio_init_context(AVIOContext *s,
43
46
                  unsigned char *buffer,
44
47
                  int buffer_size,
45
48
                  int write_flag,
52
55
    s->buffer_size = buffer_size;
53
56
    s->buf_ptr = buffer;
54
57
    s->opaque = opaque;
55
 
    url_resetbuf(s, write_flag ? URL_WRONLY : URL_RDONLY);
 
58
    url_resetbuf(s, write_flag ? AVIO_WRONLY : AVIO_RDONLY);
56
59
    s->write_packet = write_packet;
57
60
    s->read_packet = read_packet;
58
61
    s->seek = seek;
60
63
    s->must_flush = 0;
61
64
    s->eof_reached = 0;
62
65
    s->error = 0;
 
66
#if FF_API_OLD_AVIO
63
67
    s->is_streamed = 0;
 
68
#endif
 
69
    s->seekable = AVIO_SEEKABLE_NORMAL;
64
70
    s->max_packet_size = 0;
65
71
    s->update_checksum= NULL;
66
72
    if(!read_packet && !write_flag){
72
78
    return 0;
73
79
}
74
80
 
75
 
ByteIOContext *av_alloc_put_byte(
76
 
                  unsigned char *buffer,
77
 
                  int buffer_size,
78
 
                  int write_flag,
79
 
                  void *opaque,
80
 
                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
81
 
                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
82
 
                  int64_t (*seek)(void *opaque, int64_t offset, int whence))
83
 
{
84
 
    ByteIOContext *s = av_mallocz(sizeof(ByteIOContext));
85
 
    init_put_byte(s, buffer, buffer_size, write_flag, opaque,
 
81
#if FF_API_OLD_AVIO
 
82
int init_put_byte(AVIOContext *s,
 
83
                  unsigned char *buffer,
 
84
                  int buffer_size,
 
85
                  int write_flag,
 
86
                  void *opaque,
 
87
                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 
88
                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 
89
                  int64_t (*seek)(void *opaque, int64_t offset, int whence))
 
90
{
 
91
    return ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
 
92
                                read_packet, write_packet, seek);
 
93
}
 
94
AVIOContext *av_alloc_put_byte(
 
95
                  unsigned char *buffer,
 
96
                  int buffer_size,
 
97
                  int write_flag,
 
98
                  void *opaque,
 
99
                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 
100
                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 
101
                  int64_t (*seek)(void *opaque, int64_t offset, int whence))
 
102
{
 
103
    return avio_alloc_context(buffer, buffer_size, write_flag, opaque,
 
104
                              read_packet, write_packet, seek);
 
105
}
 
106
#endif
 
107
 
 
108
AVIOContext *avio_alloc_context(
 
109
                  unsigned char *buffer,
 
110
                  int buffer_size,
 
111
                  int write_flag,
 
112
                  void *opaque,
 
113
                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
 
114
                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
 
115
                  int64_t (*seek)(void *opaque, int64_t offset, int whence))
 
116
{
 
117
    AVIOContext *s = av_mallocz(sizeof(AVIOContext));
 
118
    ffio_init_context(s, buffer, buffer_size, write_flag, opaque,
86
119
                  read_packet, write_packet, seek);
87
120
    return s;
88
121
}
89
122
 
90
 
static void flush_buffer(ByteIOContext *s)
 
123
static void flush_buffer(AVIOContext *s)
91
124
{
92
125
    if (s->buf_ptr > s->buffer) {
93
126
        if (s->write_packet && !s->error){
105
138
    s->buf_ptr = s->buffer;
106
139
}
107
140
 
108
 
void put_byte(ByteIOContext *s, int b)
 
141
void avio_w8(AVIOContext *s, int b)
109
142
{
110
143
    *(s->buf_ptr)++ = b;
111
144
    if (s->buf_ptr >= s->buf_end)
112
145
        flush_buffer(s);
113
146
}
114
147
 
115
 
void put_buffer(ByteIOContext *s, const unsigned char *buf, int size)
 
148
void ffio_fill(AVIOContext *s, int b, int count)
 
149
{
 
150
    while (count > 0) {
 
151
        int len = FFMIN(s->buf_end - s->buf_ptr, count);
 
152
        memset(s->buf_ptr, b, len);
 
153
        s->buf_ptr += len;
 
154
 
 
155
        if (s->buf_ptr >= s->buf_end)
 
156
            flush_buffer(s);
 
157
 
 
158
        count -= len;
 
159
    }
 
160
}
 
161
 
 
162
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
116
163
{
117
164
    while (size > 0) {
118
165
        int len = FFMIN(s->buf_end - s->buf_ptr, size);
127
174
    }
128
175
}
129
176
 
130
 
void put_flush_packet(ByteIOContext *s)
 
177
void avio_flush(AVIOContext *s)
131
178
{
132
179
    flush_buffer(s);
133
180
    s->must_flush = 0;
134
181
}
135
182
 
136
 
int64_t url_fseek(ByteIOContext *s, int64_t offset, int whence)
 
183
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
137
184
{
138
185
    int64_t offset1;
139
186
    int64_t pos;
159
206
        offset1 >= 0 && offset1 <= (s->buf_end - s->buffer)) {
160
207
        /* can do the seek inside the buffer */
161
208
        s->buf_ptr = s->buffer + offset1;
162
 
    } else if ((s->is_streamed ||
 
209
    } else if ((!s->seekable ||
163
210
               offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
164
211
               !s->write_flag && offset1 >= 0 &&
165
212
              (whence != SEEK_END || force)) {
190
237
    return offset;
191
238
}
192
239
 
193
 
void url_fskip(ByteIOContext *s, int64_t offset)
194
 
{
195
 
    url_fseek(s, offset, SEEK_CUR);
196
 
}
197
 
 
198
 
int64_t url_ftell(ByteIOContext *s)
199
 
{
200
 
    return url_fseek(s, 0, SEEK_CUR);
201
 
}
202
 
 
203
 
int64_t url_fsize(ByteIOContext *s)
 
240
#if FF_API_OLD_AVIO
 
241
int url_fskip(AVIOContext *s, int64_t offset)
 
242
{
 
243
    int64_t ret = avio_seek(s, offset, SEEK_CUR);
 
244
    return ret < 0 ? ret : 0;
 
245
}
 
246
 
 
247
int64_t url_ftell(AVIOContext *s)
 
248
{
 
249
    return avio_seek(s, 0, SEEK_CUR);
 
250
}
 
251
#endif
 
252
 
 
253
int64_t avio_size(AVIOContext *s)
204
254
{
205
255
    int64_t size;
206
256
 
219
269
    return size;
220
270
}
221
271
 
222
 
int url_feof(ByteIOContext *s)
 
272
#if FF_API_OLD_AVIO
 
273
int url_feof(AVIOContext *s)
223
274
{
224
275
    if(!s)
225
276
        return 0;
226
277
    return s->eof_reached;
227
278
}
228
279
 
229
 
int url_ferror(ByteIOContext *s)
 
280
int url_ferror(AVIOContext *s)
230
281
{
231
282
    if(!s)
232
283
        return 0;
233
284
    return s->error;
234
285
}
235
 
 
236
 
void put_le32(ByteIOContext *s, unsigned int val)
237
 
{
238
 
    put_byte(s, val);
239
 
    put_byte(s, val >> 8);
240
 
    put_byte(s, val >> 16);
241
 
    put_byte(s, val >> 24);
242
 
}
243
 
 
244
 
void put_be32(ByteIOContext *s, unsigned int val)
245
 
{
246
 
    put_byte(s, val >> 24);
247
 
    put_byte(s, val >> 16);
248
 
    put_byte(s, val >> 8);
249
 
    put_byte(s, val);
250
 
}
251
 
 
252
 
void put_strz(ByteIOContext *s, const char *str)
253
 
{
254
 
    if (str)
255
 
        put_buffer(s, (const unsigned char *) str, strlen(str) + 1);
256
 
    else
257
 
        put_byte(s, 0);
258
 
}
259
 
 
260
 
void put_le64(ByteIOContext *s, uint64_t val)
261
 
{
262
 
    put_le32(s, (uint32_t)(val & 0xffffffff));
263
 
    put_le32(s, (uint32_t)(val >> 32));
264
 
}
265
 
 
266
 
void put_be64(ByteIOContext *s, uint64_t val)
267
 
{
268
 
    put_be32(s, (uint32_t)(val >> 32));
269
 
    put_be32(s, (uint32_t)(val & 0xffffffff));
270
 
}
271
 
 
272
 
void put_le16(ByteIOContext *s, unsigned int val)
273
 
{
274
 
    put_byte(s, val);
275
 
    put_byte(s, val >> 8);
276
 
}
277
 
 
278
 
void put_be16(ByteIOContext *s, unsigned int val)
279
 
{
280
 
    put_byte(s, val >> 8);
281
 
    put_byte(s, val);
282
 
}
283
 
 
284
 
void put_le24(ByteIOContext *s, unsigned int val)
285
 
{
286
 
    put_le16(s, val & 0xffff);
287
 
    put_byte(s, val >> 16);
288
 
}
289
 
 
290
 
void put_be24(ByteIOContext *s, unsigned int val)
291
 
{
292
 
    put_be16(s, val >> 8);
293
 
    put_byte(s, val);
294
 
}
295
 
 
296
 
void put_tag(ByteIOContext *s, const char *tag)
 
286
#endif
 
287
 
 
288
void avio_wl32(AVIOContext *s, unsigned int val)
 
289
{
 
290
    avio_w8(s, val);
 
291
    avio_w8(s, val >> 8);
 
292
    avio_w8(s, val >> 16);
 
293
    avio_w8(s, val >> 24);
 
294
}
 
295
 
 
296
void avio_wb32(AVIOContext *s, unsigned int val)
 
297
{
 
298
    avio_w8(s, val >> 24);
 
299
    avio_w8(s, val >> 16);
 
300
    avio_w8(s, val >> 8);
 
301
    avio_w8(s, val);
 
302
}
 
303
 
 
304
#if FF_API_OLD_AVIO
 
305
void put_strz(AVIOContext *s, const char *str)
 
306
{
 
307
    avio_put_str(s, str);
 
308
}
 
309
 
 
310
#define GET(name, type) \
 
311
    type get_be ##name(AVIOContext *s) \
 
312
{\
 
313
    return avio_rb ##name(s);\
 
314
}\
 
315
    type get_le ##name(AVIOContext *s) \
 
316
{\
 
317
    return avio_rl ##name(s);\
 
318
}
 
319
 
 
320
GET(16, unsigned int)
 
321
GET(24, unsigned int)
 
322
GET(32, unsigned int)
 
323
GET(64, uint64_t)
 
324
 
 
325
#undef GET
 
326
 
 
327
#define PUT(name, type ) \
 
328
    void put_le ##name(AVIOContext *s, type val)\
 
329
{\
 
330
        avio_wl ##name(s, val);\
 
331
}\
 
332
    void put_be ##name(AVIOContext *s, type val)\
 
333
{\
 
334
        avio_wb ##name(s, val);\
 
335
}
 
336
 
 
337
PUT(16, unsigned int)
 
338
PUT(24, unsigned int)
 
339
PUT(32, unsigned int)
 
340
PUT(64, uint64_t)
 
341
#undef PUT
 
342
 
 
343
int get_byte(AVIOContext *s)
 
344
{
 
345
   return avio_r8(s);
 
346
}
 
347
int get_buffer(AVIOContext *s, unsigned char *buf, int size)
 
348
{
 
349
    return avio_read(s, buf, size);
 
350
}
 
351
int get_partial_buffer(AVIOContext *s, unsigned char *buf, int size)
 
352
{
 
353
    return ffio_read_partial(s, buf, size);
 
354
}
 
355
void put_byte(AVIOContext *s, int val)
 
356
{
 
357
    avio_w8(s, val);
 
358
}
 
359
void put_buffer(AVIOContext *s, const unsigned char *buf, int size)
 
360
{
 
361
    avio_write(s, buf, size);
 
362
}
 
363
void put_nbyte(AVIOContext *s, int b, int count)
 
364
{
 
365
    ffio_fill(s, b, count);
 
366
}
 
367
 
 
368
int url_fopen(AVIOContext **s, const char *filename, int flags)
 
369
{
 
370
    return avio_open(s, filename, flags);
 
371
}
 
372
int url_fclose(AVIOContext *s)
 
373
{
 
374
    return avio_close(s);
 
375
}
 
376
int64_t url_fseek(AVIOContext *s, int64_t offset, int whence)
 
377
{
 
378
    return avio_seek(s, offset, whence);
 
379
}
 
380
int64_t url_fsize(AVIOContext *s)
 
381
{
 
382
    return avio_size(s);
 
383
}
 
384
int url_setbufsize(AVIOContext *s, int buf_size)
 
385
{
 
386
    return ffio_set_buf_size(s, buf_size);
 
387
}
 
388
int url_fprintf(AVIOContext *s, const char *fmt, ...)
 
389
{
 
390
    va_list ap;
 
391
    char buf[4096];
 
392
    int ret;
 
393
 
 
394
    va_start(ap, fmt);
 
395
    ret = vsnprintf(buf, sizeof(buf), fmt, ap);
 
396
    va_end(ap);
 
397
    avio_write(s, buf, strlen(buf));
 
398
    return ret;
 
399
}
 
400
void put_flush_packet(AVIOContext *s)
 
401
{
 
402
    avio_flush(s);
 
403
}
 
404
int av_url_read_fpause(AVIOContext *s, int pause)
 
405
{
 
406
    return avio_pause(s, pause);
 
407
}
 
408
int64_t av_url_read_fseek(AVIOContext *s, int stream_index,
 
409
                         int64_t timestamp, int flags)
 
410
{
 
411
    return avio_seek_time(s, stream_index, timestamp, flags);
 
412
}
 
413
void init_checksum(AVIOContext *s,
 
414
                   unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
 
415
                   unsigned long checksum)
 
416
{
 
417
    ffio_init_checksum(s, update_checksum, checksum);
 
418
}
 
419
unsigned long get_checksum(AVIOContext *s)
 
420
{
 
421
    return ffio_get_checksum(s);
 
422
}
 
423
int url_open_dyn_buf(AVIOContext **s)
 
424
{
 
425
    return avio_open_dyn_buf(s);
 
426
}
 
427
int url_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
 
428
{
 
429
    return ffio_open_dyn_packet_buf(s, max_packet_size);
 
430
}
 
431
int url_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
 
432
{
 
433
    return avio_close_dyn_buf(s, pbuffer);
 
434
}
 
435
int url_fdopen(AVIOContext **s, URLContext *h)
 
436
{
 
437
    return ffio_fdopen(s, h);
 
438
}
 
439
#endif
 
440
 
 
441
int avio_put_str(AVIOContext *s, const char *str)
 
442
{
 
443
    int len = 1;
 
444
    if (str) {
 
445
        len += strlen(str);
 
446
        avio_write(s, (const unsigned char *) str, len);
 
447
    } else
 
448
        avio_w8(s, 0);
 
449
    return len;
 
450
}
 
451
 
 
452
int avio_put_str16le(AVIOContext *s, const char *str)
 
453
{
 
454
    const uint8_t *q = str;
 
455
    int ret = 0;
 
456
 
 
457
    while (*q) {
 
458
        uint32_t ch;
 
459
        uint16_t tmp;
 
460
 
 
461
        GET_UTF8(ch, *q++, break;)
 
462
        PUT_UTF16(ch, tmp, avio_wl16(s, tmp);ret += 2;)
 
463
    }
 
464
    avio_wl16(s, 0);
 
465
    ret += 2;
 
466
    return ret;
 
467
}
 
468
 
 
469
int ff_get_v_length(uint64_t val){
 
470
    int i=1;
 
471
 
 
472
    while(val>>=7)
 
473
        i++;
 
474
 
 
475
    return i;
 
476
}
 
477
 
 
478
void ff_put_v(AVIOContext *bc, uint64_t val){
 
479
    int i= ff_get_v_length(val);
 
480
 
 
481
    while(--i>0)
 
482
        avio_w8(bc, 128 | (val>>(7*i)));
 
483
 
 
484
    avio_w8(bc, val&127);
 
485
}
 
486
 
 
487
void avio_wl64(AVIOContext *s, uint64_t val)
 
488
{
 
489
    avio_wl32(s, (uint32_t)(val & 0xffffffff));
 
490
    avio_wl32(s, (uint32_t)(val >> 32));
 
491
}
 
492
 
 
493
void avio_wb64(AVIOContext *s, uint64_t val)
 
494
{
 
495
    avio_wb32(s, (uint32_t)(val >> 32));
 
496
    avio_wb32(s, (uint32_t)(val & 0xffffffff));
 
497
}
 
498
 
 
499
void avio_wl16(AVIOContext *s, unsigned int val)
 
500
{
 
501
    avio_w8(s, val);
 
502
    avio_w8(s, val >> 8);
 
503
}
 
504
 
 
505
void avio_wb16(AVIOContext *s, unsigned int val)
 
506
{
 
507
    avio_w8(s, val >> 8);
 
508
    avio_w8(s, val);
 
509
}
 
510
 
 
511
void avio_wl24(AVIOContext *s, unsigned int val)
 
512
{
 
513
    avio_wl16(s, val & 0xffff);
 
514
    avio_w8(s, val >> 16);
 
515
}
 
516
 
 
517
void avio_wb24(AVIOContext *s, unsigned int val)
 
518
{
 
519
    avio_wb16(s, val >> 8);
 
520
    avio_w8(s, val);
 
521
}
 
522
 
 
523
#if FF_API_OLD_AVIO
 
524
void put_tag(AVIOContext *s, const char *tag)
297
525
{
298
526
    while (*tag) {
299
 
        put_byte(s, *tag++);
 
527
        avio_w8(s, *tag++);
300
528
    }
301
529
}
 
530
#endif
302
531
 
303
532
/* Input stream */
304
533
 
305
 
static void fill_buffer(ByteIOContext *s)
 
534
static void fill_buffer(AVIOContext *s)
306
535
{
307
 
    uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_ptr : s->buffer;
 
536
    uint8_t *dst= !s->max_packet_size && s->buf_end - s->buffer < s->buffer_size ? s->buf_end : s->buffer;
308
537
    int len= s->buffer_size - (dst - s->buffer);
309
538
    int max_buffer_size = s->max_packet_size ? s->max_packet_size : IO_BUFFER_SIZE;
310
539
 
311
 
    assert(s->buf_ptr == s->buf_end);
312
 
 
313
540
    /* no need to do anything if EOF already reached */
314
541
    if (s->eof_reached)
315
542
        return;
322
549
 
323
550
    /* make buffer smaller in case it ended up large after probing */
324
551
    if (s->buffer_size > max_buffer_size) {
325
 
        url_setbufsize(s, max_buffer_size);
 
552
        ffio_set_buf_size(s, max_buffer_size);
326
553
 
327
554
        s->checksum_ptr = dst = s->buffer;
328
555
        len = s->buffer_size;
351
578
    return av_crc(av_crc_get_table(AV_CRC_32_IEEE), checksum, buf, len);
352
579
}
353
580
 
354
 
unsigned long get_checksum(ByteIOContext *s)
 
581
unsigned long ffio_get_checksum(AVIOContext *s)
355
582
{
356
583
    s->checksum= s->update_checksum(s->checksum, s->checksum_ptr, s->buf_ptr - s->checksum_ptr);
357
584
    s->update_checksum= NULL;
358
585
    return s->checksum;
359
586
}
360
587
 
361
 
void init_checksum(ByteIOContext *s,
 
588
void ffio_init_checksum(AVIOContext *s,
362
589
                   unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len),
363
590
                   unsigned long checksum)
364
591
{
370
597
}
371
598
 
372
599
/* XXX: put an inline version */
373
 
int get_byte(ByteIOContext *s)
374
 
{
375
 
    if (s->buf_ptr < s->buf_end) {
376
 
        return *s->buf_ptr++;
377
 
    } else {
378
 
        fill_buffer(s);
379
 
        if (s->buf_ptr < s->buf_end)
380
 
            return *s->buf_ptr++;
381
 
        else
382
 
            return 0;
383
 
    }
384
 
}
385
 
 
386
 
int url_fgetc(ByteIOContext *s)
387
 
{
388
 
    if (s->buf_ptr < s->buf_end) {
389
 
        return *s->buf_ptr++;
390
 
    } else {
391
 
        fill_buffer(s);
392
 
        if (s->buf_ptr < s->buf_end)
393
 
            return *s->buf_ptr++;
394
 
        else
395
 
            return URL_EOF;
396
 
    }
397
 
}
398
 
 
399
 
int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
 
600
int avio_r8(AVIOContext *s)
 
601
{
 
602
    if (s->buf_ptr >= s->buf_end)
 
603
        fill_buffer(s);
 
604
    if (s->buf_ptr < s->buf_end)
 
605
        return *s->buf_ptr++;
 
606
    return 0;
 
607
}
 
608
 
 
609
#if FF_API_OLD_AVIO
 
610
int url_fgetc(AVIOContext *s)
 
611
{
 
612
    if (s->buf_ptr >= s->buf_end)
 
613
        fill_buffer(s);
 
614
    if (s->buf_ptr < s->buf_end)
 
615
        return *s->buf_ptr++;
 
616
    return URL_EOF;
 
617
}
 
618
#endif
 
619
 
 
620
int avio_read(AVIOContext *s, unsigned char *buf, int size)
400
621
{
401
622
    int len, size1;
402
623
 
437
658
        }
438
659
    }
439
660
    if (size1 == size) {
440
 
        if (url_ferror(s)) return url_ferror(s);
441
 
        if (url_feof(s))   return AVERROR_EOF;
 
661
        if (s->error)         return s->error;
 
662
        if (s->eof_reached)   return AVERROR_EOF;
442
663
    }
443
664
    return size1 - size;
444
665
}
445
666
 
446
 
int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size)
 
667
int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
447
668
{
448
669
    int len;
449
670
 
460
681
    memcpy(buf, s->buf_ptr, len);
461
682
    s->buf_ptr += len;
462
683
    if (!len) {
463
 
        if (url_ferror(s)) return url_ferror(s);
464
 
        if (url_feof(s))   return AVERROR_EOF;
 
684
        if (s->error)         return s->error;
 
685
        if (s->eof_reached)   return AVERROR_EOF;
465
686
    }
466
687
    return len;
467
688
}
468
689
 
469
 
unsigned int get_le16(ByteIOContext *s)
470
 
{
471
 
    unsigned int val;
472
 
    val = get_byte(s);
473
 
    val |= get_byte(s) << 8;
474
 
    return val;
475
 
}
476
 
 
477
 
unsigned int get_le24(ByteIOContext *s)
478
 
{
479
 
    unsigned int val;
480
 
    val = get_le16(s);
481
 
    val |= get_byte(s) << 16;
482
 
    return val;
483
 
}
484
 
 
485
 
unsigned int get_le32(ByteIOContext *s)
486
 
{
487
 
    unsigned int val;
488
 
    val = get_le16(s);
489
 
    val |= get_le16(s) << 16;
490
 
    return val;
491
 
}
492
 
 
493
 
uint64_t get_le64(ByteIOContext *s)
 
690
unsigned int avio_rl16(AVIOContext *s)
 
691
{
 
692
    unsigned int val;
 
693
    val = avio_r8(s);
 
694
    val |= avio_r8(s) << 8;
 
695
    return val;
 
696
}
 
697
 
 
698
unsigned int avio_rl24(AVIOContext *s)
 
699
{
 
700
    unsigned int val;
 
701
    val = avio_rl16(s);
 
702
    val |= avio_r8(s) << 16;
 
703
    return val;
 
704
}
 
705
 
 
706
unsigned int avio_rl32(AVIOContext *s)
 
707
{
 
708
    unsigned int val;
 
709
    val = avio_rl16(s);
 
710
    val |= avio_rl16(s) << 16;
 
711
    return val;
 
712
}
 
713
 
 
714
uint64_t avio_rl64(AVIOContext *s)
494
715
{
495
716
    uint64_t val;
496
 
    val = (uint64_t)get_le32(s);
497
 
    val |= (uint64_t)get_le32(s) << 32;
498
 
    return val;
499
 
}
500
 
 
501
 
unsigned int get_be16(ByteIOContext *s)
502
 
{
503
 
    unsigned int val;
504
 
    val = get_byte(s) << 8;
505
 
    val |= get_byte(s);
506
 
    return val;
507
 
}
508
 
 
509
 
unsigned int get_be24(ByteIOContext *s)
510
 
{
511
 
    unsigned int val;
512
 
    val = get_be16(s) << 8;
513
 
    val |= get_byte(s);
514
 
    return val;
515
 
}
516
 
unsigned int get_be32(ByteIOContext *s)
517
 
{
518
 
    unsigned int val;
519
 
    val = get_be16(s) << 16;
520
 
    val |= get_be16(s);
521
 
    return val;
522
 
}
523
 
 
524
 
char *get_strz(ByteIOContext *s, char *buf, int maxlen)
 
717
    val = (uint64_t)avio_rl32(s);
 
718
    val |= (uint64_t)avio_rl32(s) << 32;
 
719
    return val;
 
720
}
 
721
 
 
722
unsigned int avio_rb16(AVIOContext *s)
 
723
{
 
724
    unsigned int val;
 
725
    val = avio_r8(s) << 8;
 
726
    val |= avio_r8(s);
 
727
    return val;
 
728
}
 
729
 
 
730
unsigned int avio_rb24(AVIOContext *s)
 
731
{
 
732
    unsigned int val;
 
733
    val = avio_rb16(s) << 8;
 
734
    val |= avio_r8(s);
 
735
    return val;
 
736
}
 
737
unsigned int avio_rb32(AVIOContext *s)
 
738
{
 
739
    unsigned int val;
 
740
    val = avio_rb16(s) << 16;
 
741
    val |= avio_rb16(s);
 
742
    return val;
 
743
}
 
744
 
 
745
#if FF_API_OLD_AVIO
 
746
char *get_strz(AVIOContext *s, char *buf, int maxlen)
 
747
{
 
748
    avio_get_str(s, INT_MAX, buf, maxlen);
 
749
    return buf;
 
750
}
 
751
#endif
 
752
 
 
753
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
525
754
{
526
755
    int i = 0;
527
756
    char c;
528
757
 
529
 
    while ((c = get_byte(s))) {
530
 
        if (i < maxlen-1)
 
758
    do {
 
759
        c = avio_r8(s);
 
760
        if (c && i < maxlen-1)
531
761
            buf[i++] = c;
532
 
    }
533
 
 
534
 
    buf[i] = 0; /* Ensure null terminated, but may be truncated */
535
 
 
536
 
    return buf;
537
 
}
538
 
 
539
 
uint64_t get_be64(ByteIOContext *s)
 
762
    } while (c != '\n' && c);
 
763
 
 
764
    buf[i] = 0;
 
765
    return i;
 
766
}
 
767
 
 
768
int avio_get_str(AVIOContext *s, int maxlen, char *buf, int buflen)
 
769
{
 
770
    int i;
 
771
 
 
772
    // reserve 1 byte for terminating 0
 
773
    buflen = FFMIN(buflen - 1, maxlen);
 
774
    for (i = 0; i < buflen; i++)
 
775
        if (!(buf[i] = avio_r8(s)))
 
776
            return i + 1;
 
777
    if (buflen)
 
778
        buf[i] = 0;
 
779
    for (; i < maxlen; i++)
 
780
        if (!avio_r8(s))
 
781
            return i + 1;
 
782
    return maxlen;
 
783
}
 
784
 
 
785
#define GET_STR16(type, read) \
 
786
    int avio_get_str16 ##type(AVIOContext *pb, int maxlen, char *buf, int buflen)\
 
787
{\
 
788
    char* q = buf;\
 
789
    int ret = 0;\
 
790
    while (ret + 1 < maxlen) {\
 
791
        uint8_t tmp;\
 
792
        uint32_t ch;\
 
793
        GET_UTF16(ch, (ret += 2) <= maxlen ? read(pb) : 0, break;)\
 
794
        if (!ch)\
 
795
            break;\
 
796
        PUT_UTF8(ch, tmp, if (q - buf < buflen - 1) *q++ = tmp;)\
 
797
    }\
 
798
    *q = 0;\
 
799
    return ret;\
 
800
}\
 
801
 
 
802
GET_STR16(le, avio_rl16)
 
803
GET_STR16(be, avio_rb16)
 
804
 
 
805
#undef GET_STR16
 
806
 
 
807
uint64_t avio_rb64(AVIOContext *s)
540
808
{
541
809
    uint64_t val;
542
 
    val = (uint64_t)get_be32(s) << 32;
543
 
    val |= (uint64_t)get_be32(s);
 
810
    val = (uint64_t)avio_rb32(s) << 32;
 
811
    val |= (uint64_t)avio_rb32(s);
544
812
    return val;
545
813
}
546
814
 
547
 
uint64_t ff_get_v(ByteIOContext *bc){
 
815
uint64_t ffio_read_varlen(AVIOContext *bc){
548
816
    uint64_t val = 0;
549
817
    int tmp;
550
818
 
551
819
    do{
552
 
        tmp = get_byte(bc);
 
820
        tmp = avio_r8(bc);
553
821
        val= (val<<7) + (tmp&127);
554
822
    }while(tmp&128);
555
823
    return val;
556
824
}
557
825
 
558
 
int url_fdopen(ByteIOContext **s, URLContext *h)
 
826
int ffio_fdopen(AVIOContext **s, URLContext *h)
559
827
{
560
828
    uint8_t *buffer;
561
829
    int buffer_size, max_packet_size;
562
830
 
563
 
    max_packet_size = url_get_max_packet_size(h);
 
831
    max_packet_size = h->max_packet_size;
564
832
    if (max_packet_size) {
565
833
        buffer_size = max_packet_size; /* no need to bufferize more than one packet */
566
834
    } else {
570
838
    if (!buffer)
571
839
        return AVERROR(ENOMEM);
572
840
 
573
 
    *s = av_mallocz(sizeof(ByteIOContext));
 
841
    *s = av_mallocz(sizeof(AVIOContext));
574
842
    if(!*s) {
575
843
        av_free(buffer);
576
844
        return AVERROR(ENOMEM);
577
845
    }
578
846
 
579
 
    if (init_put_byte(*s, buffer, buffer_size,
580
 
                      (h->flags & URL_WRONLY || h->flags & URL_RDWR), h,
581
 
                      url_read, url_write, url_seek) < 0) {
 
847
    if (ffio_init_context(*s, buffer, buffer_size,
 
848
                      (h->flags & AVIO_WRONLY || h->flags & AVIO_RDWR), h,
 
849
                      ffurl_read, ffurl_write, ffurl_seek) < 0) {
582
850
        av_free(buffer);
583
851
        av_freep(s);
584
852
        return AVERROR(EIO);
585
853
    }
 
854
#if FF_API_OLD_AVIO
586
855
    (*s)->is_streamed = h->is_streamed;
 
856
#endif
 
857
    (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
587
858
    (*s)->max_packet_size = max_packet_size;
588
859
    if(h->prot) {
589
860
        (*s)->read_pause = (int (*)(void *, int))h->prot->url_read_pause;
592
863
    return 0;
593
864
}
594
865
 
595
 
int url_setbufsize(ByteIOContext *s, int buf_size)
 
866
int ffio_set_buf_size(AVIOContext *s, int buf_size)
596
867
{
597
868
    uint8_t *buffer;
598
869
    buffer = av_malloc(buf_size);
603
874
    s->buffer = buffer;
604
875
    s->buffer_size = buf_size;
605
876
    s->buf_ptr = buffer;
606
 
    url_resetbuf(s, s->write_flag ? URL_WRONLY : URL_RDONLY);
 
877
    url_resetbuf(s, s->write_flag ? AVIO_WRONLY : AVIO_RDONLY);
607
878
    return 0;
608
879
}
609
880
 
610
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
611
 
int url_resetbuf(ByteIOContext *s, int flags)
 
881
#if FF_API_URL_RESETBUF
 
882
int url_resetbuf(AVIOContext *s, int flags)
612
883
#else
613
 
static int url_resetbuf(ByteIOContext *s, int flags)
 
884
static int url_resetbuf(AVIOContext *s, int flags)
614
885
#endif
615
886
{
616
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
617
 
    URLContext *h = s->opaque;
618
 
    if ((flags & URL_RDWR) || (h && h->flags != flags && !h->flags & URL_RDWR))
 
887
#if FF_API_URL_RESETBUF
 
888
    if (flags & AVIO_RDWR)
619
889
        return AVERROR(EINVAL);
620
890
#else
621
 
    assert(flags == URL_WRONLY || flags == URL_RDONLY);
 
891
    assert(flags == AVIO_WRONLY || flags == AVIO_RDONLY);
622
892
#endif
623
893
 
624
 
    if (flags & URL_WRONLY) {
 
894
    if (flags & AVIO_WRONLY) {
625
895
        s->buf_end = s->buffer + s->buffer_size;
626
896
        s->write_flag = 1;
627
897
    } else {
631
901
    return 0;
632
902
}
633
903
 
634
 
int ff_rewind_with_probe_data(ByteIOContext *s, unsigned char *buf, int buf_size)
 
904
int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char *buf, int buf_size)
635
905
{
636
906
    int64_t buffer_start;
637
907
    int buffer_size;
638
 
    int overlap, new_size;
 
908
    int overlap, new_size, alloc_size;
639
909
 
640
910
    if (s->write_flag)
641
911
        return AVERROR(EINVAL);
649
919
    overlap = buf_size - buffer_start;
650
920
    new_size = buf_size + buffer_size - overlap;
651
921
 
 
922
    alloc_size = FFMAX(s->buffer_size, new_size);
 
923
    if (alloc_size > buf_size)
 
924
        if (!(buf = av_realloc(buf, alloc_size)))
 
925
            return AVERROR(ENOMEM);
 
926
 
652
927
    if (new_size > buf_size) {
653
 
        if (!(buf = av_realloc(buf, new_size)))
654
 
            return AVERROR(ENOMEM);
655
 
 
656
928
        memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
657
929
        buf_size = new_size;
658
930
    }
659
931
 
660
932
    av_free(s->buffer);
661
933
    s->buf_ptr = s->buffer = buf;
662
 
    s->pos = s->buffer_size = buf_size;
 
934
    s->buffer_size = alloc_size;
 
935
    s->pos = buf_size;
663
936
    s->buf_end = s->buf_ptr + buf_size;
664
937
    s->eof_reached = 0;
665
938
    s->must_flush = 0;
667
940
    return 0;
668
941
}
669
942
 
670
 
int url_fopen(ByteIOContext **s, const char *filename, int flags)
 
943
int avio_open(AVIOContext **s, const char *filename, int flags)
671
944
{
672
945
    URLContext *h;
673
946
    int err;
674
947
 
675
 
    err = url_open(&h, filename, flags);
 
948
    err = ffurl_open(&h, filename, flags);
676
949
    if (err < 0)
677
950
        return err;
678
 
    err = url_fdopen(s, h);
 
951
    err = ffio_fdopen(s, h);
679
952
    if (err < 0) {
680
 
        url_close(h);
 
953
        ffurl_close(h);
681
954
        return err;
682
955
    }
683
956
    return 0;
684
957
}
685
958
 
686
 
int url_fclose(ByteIOContext *s)
 
959
int avio_close(AVIOContext *s)
687
960
{
688
961
    URLContext *h = s->opaque;
689
962
 
690
963
    av_free(s->buffer);
691
964
    av_free(s);
692
 
    return url_close(h);
 
965
    return ffurl_close(h);
693
966
}
694
967
 
695
 
URLContext *url_fileno(ByteIOContext *s)
 
968
#if FF_API_OLD_AVIO
 
969
URLContext *url_fileno(AVIOContext *s)
696
970
{
697
971
    return s->opaque;
698
972
}
 
973
#endif
699
974
 
700
 
#if CONFIG_MUXERS
701
 
int url_fprintf(ByteIOContext *s, const char *fmt, ...)
 
975
int avio_printf(AVIOContext *s, const char *fmt, ...)
702
976
{
703
977
    va_list ap;
704
978
    char buf[4096];
707
981
    va_start(ap, fmt);
708
982
    ret = vsnprintf(buf, sizeof(buf), fmt, ap);
709
983
    va_end(ap);
710
 
    put_buffer(s, buf, strlen(buf));
 
984
    avio_write(s, buf, strlen(buf));
711
985
    return ret;
712
986
}
713
 
#endif //CONFIG_MUXERS
714
987
 
715
 
char *url_fgets(ByteIOContext *s, char *buf, int buf_size)
 
988
#if FF_API_OLD_AVIO
 
989
char *url_fgets(AVIOContext *s, char *buf, int buf_size)
716
990
{
717
991
    int c;
718
992
    char *q;
719
993
 
720
 
    c = url_fgetc(s);
721
 
    if (c == EOF)
 
994
    c = avio_r8(s);
 
995
    if (s->eof_reached)
722
996
        return NULL;
723
997
    q = buf;
724
998
    for(;;) {
725
 
        if (c == EOF || c == '\n')
 
999
        if (s->eof_reached || c == '\n')
726
1000
            break;
727
1001
        if ((q - buf) < buf_size - 1)
728
1002
            *q++ = c;
729
 
        c = url_fgetc(s);
 
1003
        c = avio_r8(s);
730
1004
    }
731
1005
    if (buf_size > 0)
732
1006
        *q = '\0';
733
1007
    return buf;
734
1008
}
735
1009
 
736
 
int url_fget_max_packet_size(ByteIOContext *s)
 
1010
int url_fget_max_packet_size(AVIOContext *s)
737
1011
{
738
1012
    return s->max_packet_size;
739
1013
}
 
1014
#endif
740
1015
 
741
 
int av_url_read_fpause(ByteIOContext *s, int pause)
 
1016
int avio_pause(AVIOContext *s, int pause)
742
1017
{
743
1018
    if (!s->read_pause)
744
1019
        return AVERROR(ENOSYS);
745
1020
    return s->read_pause(s->opaque, pause);
746
1021
}
747
1022
 
748
 
int64_t av_url_read_fseek(ByteIOContext *s, int stream_index,
749
 
                          int64_t timestamp, int flags)
 
1023
int64_t avio_seek_time(AVIOContext *s, int stream_index,
 
1024
                       int64_t timestamp, int flags)
750
1025
{
751
1026
    URLContext *h = s->opaque;
752
1027
    int64_t ret;
765
1040
    return ret;
766
1041
}
767
1042
 
768
 
/* url_open_dyn_buf and url_close_dyn_buf are used in rtp.c to send a response
769
 
 * back to the server even if CONFIG_MUXERS is false. */
770
 
#if CONFIG_MUXERS || CONFIG_NETWORK
771
1043
/* buffer handling */
772
 
int url_open_buf(ByteIOContext **s, uint8_t *buf, int buf_size, int flags)
 
1044
#if FF_API_OLD_AVIO
 
1045
int url_open_buf(AVIOContext **s, uint8_t *buf, int buf_size, int flags)
773
1046
{
774
1047
    int ret;
775
 
    *s = av_mallocz(sizeof(ByteIOContext));
 
1048
    *s = av_mallocz(sizeof(AVIOContext));
776
1049
    if(!*s)
777
1050
        return AVERROR(ENOMEM);
778
 
    ret = init_put_byte(*s, buf, buf_size,
779
 
                        (flags & URL_WRONLY || flags & URL_RDWR),
 
1051
    ret = ffio_init_context(*s, buf, buf_size,
 
1052
                        (flags & AVIO_WRONLY || flags & AVIO_RDWR),
780
1053
                        NULL, NULL, NULL, NULL);
781
1054
    if(ret != 0)
782
1055
        av_freep(s);
783
1056
    return ret;
784
1057
}
785
1058
 
786
 
int url_close_buf(ByteIOContext *s)
 
1059
int url_close_buf(AVIOContext *s)
787
1060
{
788
 
    put_flush_packet(s);
 
1061
    avio_flush(s);
789
1062
    return s->buf_ptr - s->buffer;
790
1063
}
 
1064
#endif
791
1065
 
792
1066
/* output in a dynamic buffer */
793
1067
 
857
1131
    return 0;
858
1132
}
859
1133
 
860
 
static int url_open_dyn_buf_internal(ByteIOContext **s, int max_packet_size)
 
1134
static int url_open_dyn_buf_internal(AVIOContext **s, int max_packet_size)
861
1135
{
862
1136
    DynBuffer *d;
863
 
    int ret;
864
1137
    unsigned io_buffer_size = max_packet_size ? max_packet_size : 1024;
865
1138
 
866
1139
    if(sizeof(DynBuffer) + io_buffer_size < io_buffer_size)
868
1141
    d = av_mallocz(sizeof(DynBuffer) + io_buffer_size);
869
1142
    if (!d)
870
1143
        return AVERROR(ENOMEM);
871
 
    *s = av_mallocz(sizeof(ByteIOContext));
872
 
    if(!*s) {
873
 
        av_free(d);
874
 
        return AVERROR(ENOMEM);
875
 
    }
876
1144
    d->io_buffer_size = io_buffer_size;
877
 
    ret = init_put_byte(*s, d->io_buffer, io_buffer_size,
878
 
                        1, d, NULL,
879
 
                        max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
880
 
                        max_packet_size ? NULL : dyn_buf_seek);
881
 
    if (ret == 0) {
882
 
        (*s)->max_packet_size = max_packet_size;
883
 
    } else {
 
1145
    *s = avio_alloc_context(d->io_buffer, d->io_buffer_size, 1, d, NULL,
 
1146
                            max_packet_size ? dyn_packet_buf_write : dyn_buf_write,
 
1147
                            max_packet_size ? NULL : dyn_buf_seek);
 
1148
    if(!*s) {
884
1149
        av_free(d);
885
 
        av_freep(s);
 
1150
        return AVERROR(ENOMEM);
886
1151
    }
887
 
    return ret;
 
1152
    (*s)->max_packet_size = max_packet_size;
 
1153
    return 0;
888
1154
}
889
1155
 
890
 
int url_open_dyn_buf(ByteIOContext **s)
 
1156
int avio_open_dyn_buf(AVIOContext **s)
891
1157
{
892
1158
    return url_open_dyn_buf_internal(s, 0);
893
1159
}
894
1160
 
895
 
int url_open_dyn_packet_buf(ByteIOContext **s, int max_packet_size)
 
1161
int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
896
1162
{
897
1163
    if (max_packet_size <= 0)
898
1164
        return -1;
899
1165
    return url_open_dyn_buf_internal(s, max_packet_size);
900
1166
}
901
1167
 
902
 
int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer)
 
1168
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
903
1169
{
904
1170
    DynBuffer *d = s->opaque;
905
1171
    int size;
906
 
 
907
 
    put_flush_packet(s);
 
1172
    static const char padbuf[FF_INPUT_BUFFER_PADDING_SIZE] = {0};
 
1173
    int padding = 0;
 
1174
 
 
1175
    /* don't attempt to pad fixed-size packet buffers */
 
1176
    if (!s->max_packet_size) {
 
1177
        avio_write(s, padbuf, sizeof(padbuf));
 
1178
        padding = FF_INPUT_BUFFER_PADDING_SIZE;
 
1179
    }
 
1180
 
 
1181
    avio_flush(s);
908
1182
 
909
1183
    *pbuffer = d->buffer;
910
1184
    size = d->size;
911
1185
    av_free(d);
912
1186
    av_free(s);
913
 
    return size;
 
1187
    return size - padding;
914
1188
}
915
 
#endif /* CONFIG_MUXERS || CONFIG_NETWORK */