bytestream.h 14 KB
Newer Older
1 2 3
/*
 * Bytestream functions
 * 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 Libav.
7
 *
8
 * Libav is free software; you can redistribute it and/or
9 10 11 12
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
13
 * Libav is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with Libav; if not, write to the Free Software
20 21 22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

23 24
#ifndef AVCODEC_BYTESTREAM_H
#define AVCODEC_BYTESTREAM_H
25

26
#include <stdint.h>
27
#include <string.h>
28

29
#include "libavutil/common.h"
30
#include "libavutil/intreadwrite.h"
31

32
typedef struct GetByteContext {
33
    const uint8_t *buffer, *buffer_end, *buffer_start;
34 35
} GetByteContext;

36
typedef struct PutByteContext {
37 38 39 40
    uint8_t *buffer, *buffer_end, *buffer_start;
    int eof;
} PutByteContext;

41
#define DEF(type, name, bytes, read, write)                                  \
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
static av_always_inline type bytestream_get_ ## name(const uint8_t **b)        \
{                                                                              \
    (*b) += bytes;                                                             \
    return read(*b - bytes);                                                   \
}                                                                              \
static av_always_inline void bytestream_put_ ## name(uint8_t **b,              \
                                                     const type value)         \
{                                                                              \
    write(*b, value);                                                          \
    (*b) += bytes;                                                             \
}                                                                              \
static av_always_inline void bytestream2_put_ ## name ## u(PutByteContext *p,  \
                                                           const type value)   \
{                                                                              \
    bytestream_put_ ## name(&p->buffer, value);                                \
}                                                                              \
static av_always_inline void bytestream2_put_ ## name(PutByteContext *p,       \
                                                      const type value)        \
{                                                                              \
    if (!p->eof && (p->buffer_end - p->buffer >= bytes)) {                     \
        write(p->buffer, value);                                               \
        p->buffer += bytes;                                                    \
    } else                                                                     \
        p->eof = 1;                                                            \
}                                                                              \
static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g)  \
{                                                                              \
    return bytestream_get_ ## name(&g->buffer);                                \
}                                                                              \
static av_always_inline type bytestream2_get_ ## name(GetByteContext *g)       \
{                                                                              \
    if (g->buffer_end - g->buffer < bytes)                                     \
        return 0;                                                              \
    return bytestream2_get_ ## name ## u(g);                                   \
}                                                                              \
static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g)      \
{                                                                              \
    if (g->buffer_end - g->buffer < bytes)                                     \
        return 0;                                                              \
    return read(g->buffer);                                                    \
82
}
83

84 85 86 87 88 89 90 91 92
DEF(uint64_t,     le64, 8, AV_RL64, AV_WL64)
DEF(unsigned int, le32, 4, AV_RL32, AV_WL32)
DEF(unsigned int, le24, 3, AV_RL24, AV_WL24)
DEF(unsigned int, le16, 2, AV_RL16, AV_WL16)
DEF(uint64_t,     be64, 8, AV_RB64, AV_WB64)
DEF(unsigned int, be32, 4, AV_RB32, AV_WB32)
DEF(unsigned int, be24, 3, AV_RB24, AV_WB24)
DEF(unsigned int, be16, 2, AV_RB16, AV_WB16)
DEF(unsigned int, byte, 1, AV_RB8 , AV_WB8)
93

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
#if HAVE_BIGENDIAN
#   define bytestream2_get_ne16  bytestream2_get_be16
#   define bytestream2_get_ne24  bytestream2_get_be24
#   define bytestream2_get_ne32  bytestream2_get_be32
#   define bytestream2_get_ne64  bytestream2_get_be64
#   define bytestream2_get_ne16u bytestream2_get_be16u
#   define bytestream2_get_ne24u bytestream2_get_be24u
#   define bytestream2_get_ne32u bytestream2_get_be32u
#   define bytestream2_get_ne64u bytestream2_get_be64u
#   define bytestream2_put_ne16  bytestream2_put_be16
#   define bytestream2_put_ne24  bytestream2_put_be24
#   define bytestream2_put_ne32  bytestream2_put_be32
#   define bytestream2_put_ne64  bytestream2_put_be64
#   define bytestream2_peek_ne16 bytestream2_peek_be16
#   define bytestream2_peek_ne24 bytestream2_peek_be24
#   define bytestream2_peek_ne32 bytestream2_peek_be32
#   define bytestream2_peek_ne64 bytestream2_peek_be64
#else
#   define bytestream2_get_ne16  bytestream2_get_le16
#   define bytestream2_get_ne24  bytestream2_get_le24
#   define bytestream2_get_ne32  bytestream2_get_le32
#   define bytestream2_get_ne64  bytestream2_get_le64
#   define bytestream2_get_ne16u bytestream2_get_le16u
#   define bytestream2_get_ne24u bytestream2_get_le24u
#   define bytestream2_get_ne32u bytestream2_get_le32u
#   define bytestream2_get_ne64u bytestream2_get_le64u
#   define bytestream2_put_ne16  bytestream2_put_le16
#   define bytestream2_put_ne24  bytestream2_put_le24
#   define bytestream2_put_ne32  bytestream2_put_le32
#   define bytestream2_put_ne64  bytestream2_put_le64
#   define bytestream2_peek_ne16 bytestream2_peek_le16
#   define bytestream2_peek_ne24 bytestream2_peek_le24
#   define bytestream2_peek_ne32 bytestream2_peek_le32
#   define bytestream2_peek_ne64 bytestream2_peek_le64
#endif

130
static av_always_inline void bytestream2_init(GetByteContext *g,
131 132
                                              const uint8_t *buf,
                                              int buf_size)
133
{
134
    g->buffer       = buf;
135
    g->buffer_start = buf;
136
    g->buffer_end   = buf + buf_size;
137 138
}

139
static av_always_inline void bytestream2_init_writer(PutByteContext *p,
140 141
                                                     uint8_t *buf,
                                                     int buf_size)
142 143 144 145 146 147 148
{
    p->buffer       = buf;
    p->buffer_start = buf;
    p->buffer_end   = buf + buf_size;
    p->eof          = 0;
}

149 150 151 152 153
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
{
    return g->buffer_end - g->buffer;
}

154 155 156 157 158
static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
{
    return p->buffer_end - p->buffer;
}

159 160 161 162 163 164
static av_always_inline void bytestream2_skip(GetByteContext *g,
                                              unsigned int size)
{
    g->buffer += FFMIN(g->buffer_end - g->buffer, size);
}

165 166 167 168 169 170
static av_always_inline void bytestream2_skipu(GetByteContext *g,
                                               unsigned int size)
{
    g->buffer += size;
}

171 172 173 174 175 176 177 178 179 180 181 182
static av_always_inline void bytestream2_skip_p(PutByteContext *p,
                                                unsigned int size)
{
    int size2;
    if (p->eof)
        return;
    size2 = FFMIN(p->buffer_end - p->buffer, size);
    if (size2 != size)
        p->eof = 1;
    p->buffer += size2;
}

183 184 185 186 187
static av_always_inline int bytestream2_tell(GetByteContext *g)
{
    return (int)(g->buffer - g->buffer_start);
}

188 189 190 191 192
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
{
    return (int)(p->buffer - p->buffer_start);
}

193 194 195 196 197 198 199 200 201 202
static av_always_inline int bytestream2_size(GetByteContext *g)
{
    return (int)(g->buffer_end - g->buffer_start);
}

static av_always_inline int bytestream2_size_p(PutByteContext *p)
{
    return (int)(p->buffer_end - p->buffer_start);
}

203 204
static av_always_inline int bytestream2_seek(GetByteContext *g,
                                             int offset,
205 206 207 208
                                             int whence)
{
    switch (whence) {
    case SEEK_CUR:
209 210
        offset     = av_clip(offset, -(g->buffer - g->buffer_start),
                             g->buffer_end - g->buffer);
211 212 213
        g->buffer += offset;
        break;
    case SEEK_END:
214
        offset    = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
215 216 217
        g->buffer = g->buffer_end + offset;
        break;
    case SEEK_SET:
218
        offset    = av_clip(offset, 0, g->buffer_end - g->buffer_start);
219 220 221 222 223 224 225 226
        g->buffer = g->buffer_start + offset;
        break;
    default:
        return AVERROR(EINVAL);
    }
    return bytestream2_tell(g);
}

227 228
static av_always_inline int bytestream2_seek_p(PutByteContext *p,
                                               int offset,
229 230 231 232 233 234 235
                                               int whence)
{
    p->eof = 0;
    switch (whence) {
    case SEEK_CUR:
        if (p->buffer_end - p->buffer < offset)
            p->eof = 1;
236 237
        offset     = av_clip(offset, -(p->buffer - p->buffer_start),
                             p->buffer_end - p->buffer);
238 239 240 241 242
        p->buffer += offset;
        break;
    case SEEK_END:
        if (offset > 0)
            p->eof = 1;
243
        offset    = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
244 245 246 247 248
        p->buffer = p->buffer_end + offset;
        break;
    case SEEK_SET:
        if (p->buffer_end - p->buffer_start < offset)
            p->eof = 1;
249
        offset    = av_clip(offset, 0, p->buffer_end - p->buffer_start);
250 251 252 253 254 255 256 257
        p->buffer = p->buffer_start + offset;
        break;
    default:
        return AVERROR(EINVAL);
    }
    return bytestream2_tell_p(p);
}

258 259 260 261 262 263 264 265 266 267
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
                                                            uint8_t *dst,
                                                            unsigned int size)
{
    int size2 = FFMIN(g->buffer_end - g->buffer, size);
    memcpy(dst, g->buffer, size2);
    g->buffer += size2;
    return size2;
}

268 269 270 271 272 273 274 275 276
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g,
                                                             uint8_t *dst,
                                                             unsigned int size)
{
    memcpy(dst, g->buffer, size);
    g->buffer += size;
    return size;
}

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p,
                                                            const uint8_t *src,
                                                            unsigned int size)
{
    int size2;
    if (p->eof)
        return 0;
    size2 = FFMIN(p->buffer_end - p->buffer, size);
    if (size2 != size)
        p->eof = 1;
    memcpy(p->buffer, src, size2);
    p->buffer += size2;
    return size2;
}

292 293 294 295 296 297 298 299 300
static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p,
                                                             const uint8_t *src,
                                                             unsigned int size)
{
    memcpy(p->buffer, src, size);
    p->buffer += size;
    return size;
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314
static av_always_inline void bytestream2_set_buffer(PutByteContext *p,
                                                    const uint8_t c,
                                                    unsigned int size)
{
    int size2;
    if (p->eof)
        return;
    size2 = FFMIN(p->buffer_end - p->buffer, size);
    if (size2 != size)
        p->eof = 1;
    memset(p->buffer, c, size2);
    p->buffer += size2;
}

315 316 317 318 319 320 321 322
static av_always_inline void bytestream2_set_bufferu(PutByteContext *p,
                                                     const uint8_t c,
                                                     unsigned int size)
{
    memset(p->buffer, c, size);
    p->buffer += size;
}

323 324 325 326 327
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
{
    return p->eof;
}

328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
static av_always_inline unsigned int bytestream2_copy_bufferu(PutByteContext *p,
                                                              GetByteContext *g,
                                                              unsigned int size)
{
    memcpy(p->buffer, g->buffer, size);
    p->buffer += size;
    g->buffer += size;
    return size;
}

static av_always_inline unsigned int bytestream2_copy_buffer(PutByteContext *p,
                                                             GetByteContext *g,
                                                             unsigned int size)
{
    int size2;

    if (p->eof)
        return 0;
    size  = FFMIN(g->buffer_end - g->buffer, size);
    size2 = FFMIN(p->buffer_end - p->buffer, size);
    if (size2 != size)
        p->eof = 1;

    return bytestream2_copy_bufferu(p, g, size2);
}

354 355 356
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b,
                                                           uint8_t *dst,
                                                           unsigned int size)
357 358 359 360 361 362
{
    memcpy(dst, *b, size);
    (*b) += size;
    return size;
}

363 364 365
static av_always_inline void bytestream_put_buffer(uint8_t **b,
                                                   const uint8_t *src,
                                                   unsigned int size)
366 367 368 369 370
{
    memcpy(*b, src, size);
    (*b) += size;
}

371
#endif /* AVCODEC_BYTESTREAM_H */