repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.4.3~trusty1
[deb_ffmpeg.git] / ffmpeg / libavcodec / bytestream.h
CommitLineData
2ba45a60
DM		 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
33typedef struct GetByteContext {
34 const uint8_t *buffer, *buffer_end, *buffer_start;
35} GetByteContext;
36
37typedef struct PutByteContext {
38 uint8_t *buffer, *buffer_end, *buffer_start;
39 int eof;
40} PutByteContext;
41
42#define DEF(type, name, bytes, read, write) \
43static av_always_inline type bytestream_get_ ## name(const uint8_t **b) \
44{ \
45 (*b) += bytes; \
46 return read(*b - bytes); \
47} \
48static av_always_inline void bytestream_put_ ## name(uint8_t **b, \
49 const type value) \
50{ \
51 write(*b, value); \
52 (*b) += bytes; \
53} \
54static av_always_inline void bytestream2_put_ ## name ## u(PutByteContext *p, \
55 const type value) \
56{ \
57 bytestream_put_ ## name(&p->buffer, value); \
58} \
59static 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} \
68static av_always_inline type bytestream2_get_ ## name ## u(GetByteContext *g) \
69{ \
70 return bytestream_get_ ## name(&g->buffer); \
71} \
72static av_always_inline type bytestream2_get_ ## name(GetByteContext *g) \
73{ \
74 if (g->buffer_end - g->buffer < bytes) \
75 return 0; \
76 return bytestream2_get_ ## name ## u(g); \
77} \
78static av_always_inline type bytestream2_peek_ ## name(GetByteContext *g) \
79{ \
80 if (g->buffer_end - g->buffer < bytes) \
81 return 0; \
82 return read(g->buffer); \
83}
84
85DEF(uint64_t, le64, 8, AV_RL64, AV_WL64)
86DEF(unsigned int, le32, 4, AV_RL32, AV_WL32)
87DEF(unsigned int, le24, 3, AV_RL24, AV_WL24)
88DEF(unsigned int, le16, 2, AV_RL16, AV_WL16)
89DEF(uint64_t, be64, 8, AV_RB64, AV_WB64)
90DEF(unsigned int, be32, 4, AV_RB32, AV_WB32)
91DEF(unsigned int, be24, 3, AV_RB24, AV_WB24)
92DEF(unsigned int, be16, 2, AV_RB16, AV_WB16)
93DEF(unsigned int, byte, 1, AV_RB8 , AV_WB8)
94
95#if HAVE_BIGENDIAN
96# define bytestream2_get_ne16 bytestream2_get_be16
97# define bytestream2_get_ne24 bytestream2_get_be24
98# define bytestream2_get_ne32 bytestream2_get_be32
99# define bytestream2_get_ne64 bytestream2_get_be64
100# define bytestream2_get_ne16u bytestream2_get_be16u
101# define bytestream2_get_ne24u bytestream2_get_be24u
102# define bytestream2_get_ne32u bytestream2_get_be32u
103# define bytestream2_get_ne64u bytestream2_get_be64u
104# define bytestream2_put_ne16 bytestream2_put_be16
105# define bytestream2_put_ne24 bytestream2_put_be24
106# define bytestream2_put_ne32 bytestream2_put_be32
107# define bytestream2_put_ne64 bytestream2_put_be64
108# define bytestream2_peek_ne16 bytestream2_peek_be16
109# define bytestream2_peek_ne24 bytestream2_peek_be24
110# define bytestream2_peek_ne32 bytestream2_peek_be32
111# define bytestream2_peek_ne64 bytestream2_peek_be64
112#else
113# define bytestream2_get_ne16 bytestream2_get_le16
114# define bytestream2_get_ne24 bytestream2_get_le24
115# define bytestream2_get_ne32 bytestream2_get_le32
116# define bytestream2_get_ne64 bytestream2_get_le64
117# define bytestream2_get_ne16u bytestream2_get_le16u
118# define bytestream2_get_ne24u bytestream2_get_le24u
119# define bytestream2_get_ne32u bytestream2_get_le32u
120# define bytestream2_get_ne64u bytestream2_get_le64u
121# define bytestream2_put_ne16 bytestream2_put_le16
122# define bytestream2_put_ne24 bytestream2_put_le24
123# define bytestream2_put_ne32 bytestream2_put_le32
124# define bytestream2_put_ne64 bytestream2_put_le64
125# define bytestream2_peek_ne16 bytestream2_peek_le16
126# define bytestream2_peek_ne24 bytestream2_peek_le24
127# define bytestream2_peek_ne32 bytestream2_peek_le32
128# define bytestream2_peek_ne64 bytestream2_peek_le64
129#endif
130
131static av_always_inline void bytestream2_init(GetByteContext *g,
132 const uint8_t *buf,
133 int buf_size)
134{
135 av_assert0(buf_size >= 0);
136 g->buffer = buf;
137 g->buffer_start = buf;
138 g->buffer_end = buf + buf_size;
139}
140
141static av_always_inline void bytestream2_init_writer(PutByteContext *p,
142 uint8_t *buf,
143 int buf_size)
144{
145 av_assert0(buf_size >= 0);
146 p->buffer = buf;
147 p->buffer_start = buf;
148 p->buffer_end = buf + buf_size;
149 p->eof = 0;
150}
151
152static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
153{
154 return g->buffer_end - g->buffer;
155}
156
157static av_always_inline unsigned int bytestream2_get_bytes_left_p(PutByteContext *p)
158{
159 return p->buffer_end - p->buffer;
160}
161
162static av_always_inline void bytestream2_skip(GetByteContext *g,
163 unsigned int size)
164{
165 g->buffer += FFMIN(g->buffer_end - g->buffer, size);
166}
167
168static av_always_inline void bytestream2_skipu(GetByteContext *g,
169 unsigned int size)
170{
171 g->buffer += size;
172}
173
174static av_always_inline void bytestream2_skip_p(PutByteContext *p,
175 unsigned int size)
176{
177 int size2;
178 if (p->eof)
179 return;
180 size2 = FFMIN(p->buffer_end - p->buffer, size);
181 if (size2 != size)
182 p->eof = 1;
183 p->buffer += size2;
184}
185
186static av_always_inline int bytestream2_tell(GetByteContext *g)
187{
188 return (int)(g->buffer - g->buffer_start);
189}
190
191static av_always_inline int bytestream2_tell_p(PutByteContext *p)
192{
193 return (int)(p->buffer - p->buffer_start);
194}
195
196static av_always_inline int bytestream2_size(GetByteContext *g)
197{
198 return (int)(g->buffer_end - g->buffer_start);
199}
200
201static av_always_inline int bytestream2_size_p(PutByteContext *p)
202{
203 return (int)(p->buffer_end - p->buffer_start);
204}
205
206static av_always_inline int bytestream2_seek(GetByteContext *g,
207 int offset,
208 int whence)
209{
210 switch (whence) {
211 case SEEK_CUR:
212 offset = av_clip(offset, -(g->buffer - g->buffer_start),
213 g->buffer_end - g->buffer);
214 g->buffer += offset;
215 break;
216 case SEEK_END:
217 offset = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
218 g->buffer = g->buffer_end + offset;
219 break;
220 case SEEK_SET:
221 offset = av_clip(offset, 0, g->buffer_end - g->buffer_start);
222 g->buffer = g->buffer_start + offset;
223 break;
224 default:
225 return AVERROR(EINVAL);
226 }
227 return bytestream2_tell(g);
228}
229
230static av_always_inline int bytestream2_seek_p(PutByteContext *p,
231 int offset,
232 int whence)
233{
234 p->eof = 0;
235 switch (whence) {
236 case SEEK_CUR:
237 if (p->buffer_end - p->buffer < offset)
238 p->eof = 1;
239 offset = av_clip(offset, -(p->buffer - p->buffer_start),
240 p->buffer_end - p->buffer);
241 p->buffer += offset;
242 break;
243 case SEEK_END:
244 if (offset > 0)
245 p->eof = 1;
246 offset = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
247 p->buffer = p->buffer_end + offset;
248 break;
249 case SEEK_SET:
250 if (p->buffer_end - p->buffer_start < offset)
251 p->eof = 1;
252 offset = av_clip(offset, 0, p->buffer_end - p->buffer_start);
253 p->buffer = p->buffer_start + offset;
254 break;
255 default:
256 return AVERROR(EINVAL);
257 }
258 return bytestream2_tell_p(p);
259}
260
261static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
262 uint8_t *dst,
263 unsigned int size)
264{
265 int size2 = FFMIN(g->buffer_end - g->buffer, size);
266 memcpy(dst, g->buffer, size2);
267 g->buffer += size2;
268 return size2;
269}
270
271static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g,
272 uint8_t *dst,
273 unsigned int size)
274{
275 memcpy(dst, g->buffer, size);
276 g->buffer += size;
277 return size;
278}
279
280static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p,
281 const uint8_t *src,
282 unsigned int size)
283{
284 int size2;
285 if (p->eof)
286 return 0;
287 size2 = FFMIN(p->buffer_end - p->buffer, size);
288 if (size2 != size)
289 p->eof = 1;
290 memcpy(p->buffer, src, size2);
291 p->buffer += size2;
292 return size2;
293}
294
295static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p,
296 const uint8_t *src,
297 unsigned int size)
298{
299 memcpy(p->buffer, src, size);
300 p->buffer += size;
301 return size;
302}
303
304static av_always_inline void bytestream2_set_buffer(PutByteContext *p,
305 const uint8_t c,
306 unsigned int size)
307{
308 int size2;
309 if (p->eof)
310 return;
311 size2 = FFMIN(p->buffer_end - p->buffer, size);
312 if (size2 != size)
313 p->eof = 1;
314 memset(p->buffer, c, size2);
315 p->buffer += size2;
316}
317
318static av_always_inline void bytestream2_set_bufferu(PutByteContext *p,
319 const uint8_t c,
320 unsigned int size)
321{
322 memset(p->buffer, c, size);
323 p->buffer += size;
324}
325
326static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
327{
328 return p->eof;
329}
330
331static av_always_inline unsigned int bytestream2_copy_bufferu(PutByteContext *p,
332 GetByteContext *g,
333 unsigned int size)
334{
335 memcpy(p->buffer, g->buffer, size);
336 p->buffer += size;
337 g->buffer += size;
338 return size;
339}
340
341static av_always_inline unsigned int bytestream2_copy_buffer(PutByteContext *p,
342 GetByteContext *g,
343 unsigned int size)
344{
345 int size2;
346
347 if (p->eof)
348 return 0;
349 size = FFMIN(g->buffer_end - g->buffer, size);
350 size2 = FFMIN(p->buffer_end - p->buffer, size);
351 if (size2 != size)
352 p->eof = 1;
353
354 return bytestream2_copy_bufferu(p, g, size2);
355}
356
357static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b,
358 uint8_t *dst,
359 unsigned int size)
360{
361 memcpy(dst, *b, size);
362 (*b) += size;
363 return size;
364}
365
366static av_always_inline void bytestream_put_buffer(uint8_t **b,
367 const uint8_t *src,
368 unsigned int size)
369{
370 memcpy(*b, src, size);
371 (*b) += size;
372}
373
374#endif /* AVCODEC_BYTESTREAM_H */
ffmpeg Piment Noir Debian package repository