GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/bytestream.h Lines: 104 122 85.2 %
Date: 2020-11-28 20:53:16 Branches: 38 62 61.3 %

Line Branch Exec Source
1
/*
2
 * Bytestream functions
3
 * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
4
 * Copyright (c) 2012 Aneesh Dogra (lionaneesh) <lionaneesh@gmail.com>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
#ifndef AVCODEC_BYTESTREAM_H
24
#define AVCODEC_BYTESTREAM_H
25
26
#include <stdint.h>
27
#include <string.h>
28
29
#include "libavutil/avassert.h"
30
#include "libavutil/common.h"
31
#include "libavutil/intreadwrite.h"
32
33
typedef struct GetByteContext {
34
    const uint8_t *buffer, *buffer_end, *buffer_start;
35
} GetByteContext;
36
37
typedef struct PutByteContext {
38
    uint8_t *buffer, *buffer_end, *buffer_start;
39
    int eof;
40
} PutByteContext;
41
42
#define DEF(type, name, bytes, read, write)                                  \
43
static av_always_inline type bytestream_get_ ## name(const uint8_t **b)        \
44
{                                                                              \
45
    (*b) += bytes;                                                             \
46
    return read(*b - bytes);                                                   \
47
}                                                                              \
48
static av_always_inline void bytestream_put_ ## name(uint8_t **b,              \
49
                                                     const type value)         \
50
{                                                                              \
51
    write(*b, value);                                                          \
52
    (*b) += bytes;                                                             \
53
}                                                                              \
54
static av_always_inline void bytestream2_put_ ## name ## u(PutByteContext *p,  \
55
                                                           const type value)   \
56
{                                                                              \
57
    bytestream_put_ ## name(&p->buffer, value);                                \
58
}                                                                              \
59
static av_always_inline void bytestream2_put_ ## name(PutByteContext *p,       \
60
                                                      const type value)        \
61
{                                                                              \
62
    if (!p->eof && (p->buffer_end - p->buffer >= bytes)) {                     \
63
        write(p->buffer, value);                                               \
64
        p->buffer += bytes;                                                    \
65
    } else                                                                     \
66
        p->eof = 1;                                                            \
67
}                                                                              \
68
static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)  \
69
{                                                                              \
70
    return bytestream_get_ ## name(&g->buffer);                                \
71
}                                                                              \
72
static av_always_inline type bytestream2_get_ ## name(GetByteContext *g)       \
73
{                                                                              \
74
    if (g->buffer_end - g->buffer < bytes) {                                   \
75
        g->buffer = g->buffer_end;                                             \
76
        return 0;                                                              \
77
    }                                                                          \
78
    return bytestream2_get_ ## name ## u(g);                                   \
79
}                                                                              \
80
static av_always_inline type bytestream2_peek_ ## name ## u(GetByteContext *g) \
81
{                                                                              \
82
    return read(g->buffer);                                                    \
83
}                                                                              \
84
static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g)      \
85
{                                                                              \
86
    if (g->buffer_end - g->buffer < bytes)                                     \
87
        return 0;                                                              \
88
    return bytestream2_peek_ ## name ## u(g);                                  \
89
}
90
91

3049755
DEF(uint64_t,     le64, 8, AV_RL64, AV_WL64)
92

32501911
DEF(unsigned int, le32, 4, AV_RL32, AV_WL32)
93

64446784
DEF(unsigned int, le24, 3, AV_RL24, AV_WL24)
94

230251888
DEF(unsigned int, le16, 2, AV_RL16, AV_WL16)
95
1098211
DEF(uint64_t,     be64, 8, AV_RB64, AV_WB64)
96

19490264
DEF(unsigned int, be32, 4, AV_RB32, AV_WB32)
97

3751654
DEF(unsigned int, be24, 3, AV_RB24, AV_WB24)
98

93938479
DEF(unsigned int, be16, 2, AV_RB16, AV_WB16)
99

328323218
DEF(unsigned int, byte, 1, AV_RB8 , AV_WB8)
100
101
#if AV_HAVE_BIGENDIAN
102
#   define bytestream2_get_ne16  bytestream2_get_be16
103
#   define bytestream2_get_ne24  bytestream2_get_be24
104
#   define bytestream2_get_ne32  bytestream2_get_be32
105
#   define bytestream2_get_ne64  bytestream2_get_be64
106
#   define bytestream2_get_ne16u bytestream2_get_be16u
107
#   define bytestream2_get_ne24u bytestream2_get_be24u
108
#   define bytestream2_get_ne32u bytestream2_get_be32u
109
#   define bytestream2_get_ne64u bytestream2_get_be64u
110
#   define bytestream2_put_ne16  bytestream2_put_be16
111
#   define bytestream2_put_ne24  bytestream2_put_be24
112
#   define bytestream2_put_ne32  bytestream2_put_be32
113
#   define bytestream2_put_ne64  bytestream2_put_be64
114
#   define bytestream2_peek_ne16 bytestream2_peek_be16
115
#   define bytestream2_peek_ne24 bytestream2_peek_be24
116
#   define bytestream2_peek_ne32 bytestream2_peek_be32
117
#   define bytestream2_peek_ne64 bytestream2_peek_be64
118
#else
119
#   define bytestream2_get_ne16  bytestream2_get_le16
120
#   define bytestream2_get_ne24  bytestream2_get_le24
121
#   define bytestream2_get_ne32  bytestream2_get_le32
122
#   define bytestream2_get_ne64  bytestream2_get_le64
123
#   define bytestream2_get_ne16u bytestream2_get_le16u
124
#   define bytestream2_get_ne24u bytestream2_get_le24u
125
#   define bytestream2_get_ne32u bytestream2_get_le32u
126
#   define bytestream2_get_ne64u bytestream2_get_le64u
127
#   define bytestream2_put_ne16  bytestream2_put_le16
128
#   define bytestream2_put_ne24  bytestream2_put_le24
129
#   define bytestream2_put_ne32  bytestream2_put_le32
130
#   define bytestream2_put_ne64  bytestream2_put_le64
131
#   define bytestream2_peek_ne16 bytestream2_peek_le16
132
#   define bytestream2_peek_ne24 bytestream2_peek_le24
133
#   define bytestream2_peek_ne32 bytestream2_peek_le32
134
#   define bytestream2_peek_ne64 bytestream2_peek_le64
135
#endif
136
137
182701
static av_always_inline void bytestream2_init(GetByteContext *g,
138
                                              const uint8_t *buf,
139
                                              int buf_size)
140
{
141
182701
    av_assert0(buf_size >= 0);
142
182701
    g->buffer       = buf;
143
182701
    g->buffer_start = buf;
144
182701
    g->buffer_end   = buf + buf_size;
145
182701
}
146
147
1927
static av_always_inline void bytestream2_init_writer(PutByteContext *p,
148
                                                     uint8_t *buf,
149
                                                     int buf_size)
150
{
151
1927
    av_assert0(buf_size >= 0);
152
1927
    p->buffer       = buf;
153
1927
    p->buffer_start = buf;
154
1927
    p->buffer_end   = buf + buf_size;
155
1927
    p->eof          = 0;
156
1927
}
157
158
21597306
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
159
{
160
21597306
    return g->buffer_end - g->buffer;
161
}
162
163
86094
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
164
{
165
86094
    return p->buffer_end - p->buffer;
166
}
167
168
781175
static av_always_inline void bytestream2_skip(GetByteContext *g,
169
                                              unsigned int size)
170
{
171
781175
    g->buffer += FFMIN(g->buffer_end - g->buffer, size);
172
781175
}
173
174
70262
static av_always_inline void bytestream2_skipu(GetByteContext *g,
175
                                               unsigned int size)
176
{
177
70262
    g->buffer += size;
178
70262
}
179
180
39
static av_always_inline void bytestream2_skip_p(PutByteContext *p,
181
                                                unsigned int size)
182
{
183
    int size2;
184
39
    if (p->eof)
185
        return;
186
39
    size2 = FFMIN(p->buffer_end - p->buffer, size);
187
39
    if (size2 != size)
188
        p->eof = 1;
189
39
    p->buffer += size2;
190
}
191
192
4274676
static av_always_inline int bytestream2_tell(GetByteContext *g)
193
{
194
4274676
    return (int)(g->buffer - g->buffer_start);
195
}
196
197
148638
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
198
{
199
148638
    return (int)(p->buffer - p->buffer_start);
200
}
201
202
537
static av_always_inline int bytestream2_size(GetByteContext *g)
203
{
204
537
    return (int)(g->buffer_end - g->buffer_start);
205
}
206
207
static av_always_inline int bytestream2_size_p(PutByteContext *p)
208
{
209
    return (int)(p->buffer_end - p->buffer_start);
210
}
211
212
776494
static av_always_inline int bytestream2_seek(GetByteContext *g,
213
                                             int offset,
214
                                             int whence)
215
{
216

776494
    switch (whence) {
217
1155
    case SEEK_CUR:
218
1155
        offset     = av_clip(offset, -(g->buffer - g->buffer_start),
219
1155
                             g->buffer_end - g->buffer);
220
1155
        g->buffer += offset;
221
1155
        break;
222
727
    case SEEK_END:
223
727
        offset    = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
224
727
        g->buffer = g->buffer_end + offset;
225
727
        break;
226
774612
    case SEEK_SET:
227
774612
        offset    = av_clip(offset, 0, g->buffer_end - g->buffer_start);
228
774612
        g->buffer = g->buffer_start + offset;
229
774612
        break;
230
    default:
231
        return AVERROR(EINVAL);
232
    }
233
776494
    return bytestream2_tell(g);
234
}
235
236
11594
static av_always_inline int bytestream2_seek_p(PutByteContext *p,
237
                                               int offset,
238
                                               int whence)
239
{
240
11594
    p->eof = 0;
241

11594
    switch (whence) {
242
7050
    case SEEK_CUR:
243
7050
        if (p->buffer_end - p->buffer < offset)
244
            p->eof = 1;
245
7050
        offset     = av_clip(offset, -(p->buffer - p->buffer_start),
246
7050
                             p->buffer_end - p->buffer);
247
7050
        p->buffer += offset;
248
7050
        break;
249
    case SEEK_END:
250
        if (offset > 0)
251
            p->eof = 1;
252
        offset    = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
253
        p->buffer = p->buffer_end + offset;
254
        break;
255
4544
    case SEEK_SET:
256
4544
        if (p->buffer_end - p->buffer_start < offset)
257
            p->eof = 1;
258
4544
        offset    = av_clip(offset, 0, p->buffer_end - p->buffer_start);
259
4544
        p->buffer = p->buffer_start + offset;
260
4544
        break;
261
    default:
262
        return AVERROR(EINVAL);
263
    }
264
11594
    return bytestream2_tell_p(p);
265
}
266
267
800792
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
268
                                                            uint8_t *dst,
269
                                                            unsigned int size)
270
{
271
800792
    int size2 = FFMIN(g->buffer_end - g->buffer, size);
272
800792
    memcpy(dst, g->buffer, size2);
273
800792
    g->buffer += size2;
274
800792
    return size2;
275
}
276
277
511664
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g,
278
                                                             uint8_t *dst,
279
                                                             unsigned int size)
280
{
281
511664
    memcpy(dst, g->buffer, size);
282
511664
    g->buffer += size;
283
511664
    return size;
284
}
285
286
2350
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p,
287
                                                            const uint8_t *src,
288
                                                            unsigned int size)
289
{
290
    int size2;
291
2350
    if (p->eof)
292
        return 0;
293
2350
    size2 = FFMIN(p->buffer_end - p->buffer, size);
294
2350
    if (size2 != size)
295
        p->eof = 1;
296
2350
    memcpy(p->buffer, src, size2);
297
2350
    p->buffer += size2;
298
2350
    return size2;
299
}
300
301
1129
static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p,
302
                                                             const uint8_t *src,
303
                                                             unsigned int size)
304
{
305
1129
    memcpy(p->buffer, src, size);
306
1129
    p->buffer += size;
307
1129
    return size;
308
}
309
310
static av_always_inline void bytestream2_set_buffer(PutByteContext *p,
311
                                                    const uint8_t c,
312
                                                    unsigned int size)
313
{
314
    int size2;
315
    if (p->eof)
316
        return;
317
    size2 = FFMIN(p->buffer_end - p->buffer, size);
318
    if (size2 != size)
319
        p->eof = 1;
320
    memset(p->buffer, c, size2);
321
    p->buffer += size2;
322
}
323
324
static av_always_inline void bytestream2_set_bufferu(PutByteContext *p,
325
                                                     const uint8_t c,
326
                                                     unsigned int size)
327
{
328
    memset(p->buffer, c, size);
329
    p->buffer += size;
330
}
331
332
4557
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
333
{
334
4557
    return p->eof;
335
}
336
337
static av_always_inline unsigned int bytestream2_copy_bufferu(PutByteContext *p,
338
                                                              GetByteContext *g,
339
                                                              unsigned int size)
340
{
341
    memcpy(p->buffer, g->buffer, size);
342
    p->buffer += size;
343
    g->buffer += size;
344
    return size;
345
}
346
347
static av_always_inline unsigned int bytestream2_copy_buffer(PutByteContext *p,
348
                                                             GetByteContext *g,
349
                                                             unsigned int size)
350
{
351
    int size2;
352
353
    if (p->eof)
354
        return 0;
355
    size  = FFMIN(g->buffer_end - g->buffer, size);
356
    size2 = FFMIN(p->buffer_end - p->buffer, size);
357
    if (size2 != size)
358
        p->eof = 1;
359
360
    return bytestream2_copy_bufferu(p, g, size2);
361
}
362
363
1326
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b,
364
                                                           uint8_t *dst,
365
                                                           unsigned int size)
366
{
367
1326
    memcpy(dst, *b, size);
368
1326
    (*b) += size;
369
1326
    return size;
370
}
371
372
2214797
static av_always_inline void bytestream_put_buffer(uint8_t **b,
373
                                                   const uint8_t *src,
374
                                                   unsigned int size)
375
{
376
2214797
    memcpy(*b, src, size);
377
2214797
    (*b) += size;
378
2214797
}
379
380
#endif /* AVCODEC_BYTESTREAM_H */