FFmpeg coverage

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 %


/*
 * Bytestream functions
 * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
 * Copyright (c) 2012 Aneesh Dogra (lionaneesh) <lionaneesh@gmail.com>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * 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.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVCODEC_BYTESTREAM_H
#define AVCODEC_BYTESTREAM_H

#include <stdint.h>
#include <string.h>

#include "libavutil/avassert.h"
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"

typedef struct GetByteContext {
    const uint8_t *buffer, *buffer_end, *buffer_start;
} GetByteContext;

typedef struct PutByteContext {
    uint8_t *buffer, *buffer_end, *buffer_start;
    int eof;
} PutByteContext;

#define DEF(type, name, bytes, read, write)                                  \
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) {                                   \
        g->buffer = g->buffer_end;                                             \
        return 0;                                                              \
    }                                                                          \
    return bytestream2_get_ ## name ## u(g);                                   \
}                                                                              \
static av_always_inline type bytestream2_peek_ ## name ## u(GetByteContext *g) \
{                                                                              \
    return read(g->buffer);                                                    \
}                                                                              \
static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g)      \
{                                                                              \
    if (g->buffer_end - g->buffer < bytes)                                     \
        return 0;                                                              \
    return bytestream2_peek_ ## name ## u(g);                                  \
}

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)

#if AV_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

static av_always_inline void bytestream2_init(GetByteContext *g,
                                              const uint8_t *buf,
                                              int buf_size)
{
    av_assert0(buf_size >= 0);
    g->buffer       = buf;
    g->buffer_start = buf;
    g->buffer_end   = buf + buf_size;
}

static av_always_inline void bytestream2_init_writer(PutByteContext *p,
                                                     uint8_t *buf,
                                                     int buf_size)
{
    av_assert0(buf_size >= 0);
    p->buffer       = buf;
    p->buffer_start = buf;
    p->buffer_end   = buf + buf_size;
    p->eof          = 0;
}

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
{
    return g->buffer_end - g->buffer;
}

static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
{
    return p->buffer_end - p->buffer;
}

static av_always_inline void bytestream2_skip(GetByteContext *g,
                                              unsigned int size)
{
    g->buffer += FFMIN(g->buffer_end - g->buffer, size);
}

static av_always_inline void bytestream2_skipu(GetByteContext *g,
                                               unsigned int size)
{
    g->buffer += size;
}

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;
}

static av_always_inline int bytestream2_tell(GetByteContext *g)
{
    return (int)(g->buffer - g->buffer_start);
}

static av_always_inline int bytestream2_tell_p(PutByteContext *p)
{
    return (int)(p->buffer - p->buffer_start);
}

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);
}

static av_always_inline int bytestream2_seek(GetByteContext *g,
                                             int offset,
                                             int whence)
{
    switch (whence) {
    case SEEK_CUR:
        offset     = av_clip(offset, -(g->buffer - g->buffer_start),
                             g->buffer_end - g->buffer);
        g->buffer += offset;
        break;
    case SEEK_END:
        offset    = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
        g->buffer = g->buffer_end + offset;
        break;
    case SEEK_SET:
        offset    = av_clip(offset, 0, g->buffer_end - g->buffer_start);
        g->buffer = g->buffer_start + offset;
        break;
    default:
        return AVERROR(EINVAL);
    }
    return bytestream2_tell(g);
}

static av_always_inline int bytestream2_seek_p(PutByteContext *p,
                                               int offset,
                                               int whence)
{
    p->eof = 0;
    switch (whence) {
    case SEEK_CUR:
        if (p->buffer_end - p->buffer < offset)
            p->eof = 1;
        offset     = av_clip(offset, -(p->buffer - p->buffer_start),
                             p->buffer_end - p->buffer);
        p->buffer += offset;
        break;
    case SEEK_END:
        if (offset > 0)
            p->eof = 1;
        offset    = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
        p->buffer = p->buffer_end + offset;
        break;
    case SEEK_SET:
        if (p->buffer_end - p->buffer_start < offset)
            p->eof = 1;
        offset    = av_clip(offset, 0, p->buffer_end - p->buffer_start);
        p->buffer = p->buffer_start + offset;
        break;
    default:
        return AVERROR(EINVAL);
    }
    return bytestream2_tell_p(p);
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
{
    return p->eof;
}

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);
}

static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b,
                                                           uint8_t *dst,
                                                           unsigned int size)
{
    memcpy(dst, *b, size);
    (*b) += size;
    return size;
}

static av_always_inline void bytestream_put_buffer(uint8_t **b,
                                                   const uint8_t *src,
                                                   unsigned int size)
{
    memcpy(*b, src, size);
    (*b) += size;
}

#endif /* AVCODEC_BYTESTREAM_H */


Generated by: GCOVR (Version 4.2)

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 */