blob: d66c18215ad1dc8102c5283e3c36fa039c95fd4f
1 | #ifndef AVCODEC_GOLOMB_H |
2 | #define AVCODEC_GOLOMB_H |
3 | |
4 | #include <linux/kernel.h> |
5 | #include <linux/types.h> |
6 | |
7 | #include "get_bits.h" |
8 | #include "put_bits.h" |
9 | #include "common.h" |
10 | |
11 | #define INVALID_VLC 0x80000000 |
12 | |
13 | extern const u8 ff_golomb_vlc_len[512]; |
14 | extern const u8 ff_ue_golomb_vlc_code[512]; |
15 | extern const char ff_se_golomb_vlc_code[512]; |
16 | extern const u8 ff_ue_golomb_len[256]; |
17 | |
18 | extern const u8 ff_interleaved_golomb_vlc_len[256]; |
19 | extern const u8 ff_interleaved_ue_golomb_vlc_code[256]; |
20 | extern const char ff_interleaved_se_golomb_vlc_code[256]; |
21 | extern const u8 ff_interleaved_dirac_golomb_vlc_code[256]; |
22 | |
23 | /** |
24 | * Read an u32 Exp-Golomb code in the range 0 to 8190. |
25 | * |
26 | * @returns the read value or a negative error code. |
27 | */ |
28 | static inline int get_ue_golomb(struct get_bits_context *gb) |
29 | { |
30 | u32 buf; |
31 | |
32 | OPEN_READER(re, gb); |
33 | UPDATE_CACHE(re, gb); |
34 | buf = GET_CACHE(re, gb); |
35 | |
36 | if (buf >= (1 << 27)) { |
37 | buf >>= 32 - 9; |
38 | LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]); |
39 | CLOSE_READER(re, gb); |
40 | |
41 | return ff_ue_golomb_vlc_code[buf]; |
42 | } else { |
43 | int log = 2 * av_log2(buf) - 31; |
44 | LAST_SKIP_BITS(re, gb, 32 - log); |
45 | CLOSE_READER(re, gb); |
46 | if (log < 7) { |
47 | pr_err("Invalid UE golomb code\n"); |
48 | return -1; |
49 | } |
50 | buf >>= log; |
51 | buf--; |
52 | |
53 | return buf; |
54 | } |
55 | } |
56 | |
57 | /** |
58 | * Read an u32 Exp-Golomb code in the range 0 to UINT_MAX-1. |
59 | */ |
60 | static inline u32 get_ue_golomb_long(struct get_bits_context *gb) |
61 | { |
62 | u32 buf, log; |
63 | |
64 | buf = show_bits_long(gb, 32); |
65 | log = 31 - av_log2(buf); |
66 | skip_bits_long(gb, log); |
67 | |
68 | return get_bits_long(gb, log + 1) - 1; |
69 | } |
70 | |
71 | /** |
72 | * read u32 exp golomb code, constraint to a max of 31. |
73 | * the return value is undefined if the stored value exceeds 31. |
74 | */ |
75 | static inline int get_ue_golomb_31(struct get_bits_context *gb) |
76 | { |
77 | u32 buf; |
78 | |
79 | OPEN_READER(re, gb); |
80 | UPDATE_CACHE(re, gb); |
81 | buf = GET_CACHE(re, gb); |
82 | |
83 | buf >>= 32 - 9; |
84 | LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]); |
85 | CLOSE_READER(re, gb); |
86 | |
87 | return ff_ue_golomb_vlc_code[buf]; |
88 | } |
89 | |
90 | static inline u32 get_interleaved_ue_golomb(struct get_bits_context *gb) |
91 | { |
92 | u32 buf; |
93 | |
94 | OPEN_READER(re, gb); |
95 | UPDATE_CACHE(re, gb); |
96 | buf = GET_CACHE(re, gb); |
97 | |
98 | if (buf & 0xAA800000) { |
99 | buf >>= 32 - 8; |
100 | LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]); |
101 | CLOSE_READER(re, gb); |
102 | |
103 | return ff_interleaved_ue_golomb_vlc_code[buf]; |
104 | } else { |
105 | u32 ret = 1; |
106 | |
107 | do { |
108 | buf >>= 32 - 8; |
109 | LAST_SKIP_BITS(re, gb, |
110 | FFMIN(ff_interleaved_golomb_vlc_len[buf], 8)); |
111 | |
112 | if (ff_interleaved_golomb_vlc_len[buf] != 9) { |
113 | ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1; |
114 | ret |= ff_interleaved_dirac_golomb_vlc_code[buf]; |
115 | break; |
116 | } |
117 | ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf]; |
118 | UPDATE_CACHE(re, gb); |
119 | buf = GET_CACHE(re, gb); |
120 | } while (ret<0x8000000U && BITS_AVAILABLE(re, gb)); |
121 | |
122 | CLOSE_READER(re, gb); |
123 | return ret - 1; |
124 | } |
125 | } |
126 | |
127 | /** |
128 | * read u32 truncated exp golomb code. |
129 | */ |
130 | static inline int get_te0_golomb(struct get_bits_context *gb, int range) |
131 | { |
132 | if (range == 1) |
133 | return 0; |
134 | else if (range == 2) |
135 | return get_bits1(gb) ^ 1; |
136 | else |
137 | return get_ue_golomb(gb); |
138 | } |
139 | |
140 | /** |
141 | * read u32 truncated exp golomb code. |
142 | */ |
143 | static inline int get_te_golomb(struct get_bits_context *gb, int range) |
144 | { |
145 | if (range == 2) |
146 | return get_bits1(gb) ^ 1; |
147 | else |
148 | return get_ue_golomb(gb); |
149 | } |
150 | |
151 | /** |
152 | * read signed exp golomb code. |
153 | */ |
154 | static inline int get_se_golomb(struct get_bits_context *gb) |
155 | { |
156 | u32 buf; |
157 | |
158 | OPEN_READER(re, gb); |
159 | UPDATE_CACHE(re, gb); |
160 | buf = GET_CACHE(re, gb); |
161 | |
162 | if (buf >= (1 << 27)) { |
163 | buf >>= 32 - 9; |
164 | LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]); |
165 | CLOSE_READER(re, gb); |
166 | |
167 | return ff_se_golomb_vlc_code[buf]; |
168 | } else { |
169 | int log = av_log2(buf), sign; |
170 | LAST_SKIP_BITS(re, gb, 31 - log); |
171 | UPDATE_CACHE(re, gb); |
172 | buf = GET_CACHE(re, gb); |
173 | |
174 | buf >>= log; |
175 | |
176 | LAST_SKIP_BITS(re, gb, 32 - log); |
177 | CLOSE_READER(re, gb); |
178 | |
179 | sign = -(buf & 1); |
180 | buf = ((buf >> 1) ^ sign) - sign; |
181 | |
182 | return buf; |
183 | } |
184 | } |
185 | |
186 | static inline int get_se_golomb_long(struct get_bits_context *gb) |
187 | { |
188 | u32 buf = get_ue_golomb_long(gb); |
189 | int sign = (buf & 1) - 1; |
190 | |
191 | return ((buf >> 1) ^ sign) + 1; |
192 | } |
193 | |
194 | static inline int get_interleaved_se_golomb(struct get_bits_context *gb) |
195 | { |
196 | u32 buf; |
197 | |
198 | OPEN_READER(re, gb); |
199 | UPDATE_CACHE(re, gb); |
200 | buf = GET_CACHE(re, gb); |
201 | |
202 | if (buf & 0xAA800000) { |
203 | buf >>= 32 - 8; |
204 | LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]); |
205 | CLOSE_READER(re, gb); |
206 | |
207 | return ff_interleaved_se_golomb_vlc_code[buf]; |
208 | } else { |
209 | int log; |
210 | LAST_SKIP_BITS(re, gb, 8); |
211 | UPDATE_CACHE(re, gb); |
212 | buf |= 1 | (GET_CACHE(re, gb) >> 8); |
213 | |
214 | if ((buf & 0xAAAAAAAA) == 0) |
215 | return INVALID_VLC; |
216 | |
217 | for (log = 31; (buf & 0x80000000) == 0; log--) |
218 | buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30); |
219 | |
220 | LAST_SKIP_BITS(re, gb, 63 - 2 * log - 8); |
221 | CLOSE_READER(re, gb); |
222 | return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1; |
223 | } |
224 | } |
225 | |
226 | static inline int dirac_get_se_golomb(struct get_bits_context *gb) |
227 | { |
228 | u32 ret = get_interleaved_ue_golomb(gb); |
229 | |
230 | if (ret) { |
231 | int sign = -get_bits1(gb); |
232 | ret = (ret ^ sign) - sign; |
233 | } |
234 | |
235 | return ret; |
236 | } |
237 | |
238 | /** |
239 | * read u32 golomb rice code (ffv1). |
240 | */ |
241 | static inline int get_ur_golomb(struct get_bits_context *gb, |
242 | int k, int limit, int esc_len) |
243 | { |
244 | u32 buf; |
245 | int log; |
246 | |
247 | OPEN_READER(re, gb); |
248 | UPDATE_CACHE(re, gb); |
249 | buf = GET_CACHE(re, gb); |
250 | |
251 | log = av_log2(buf); |
252 | |
253 | if (log > 31 - limit) { |
254 | buf >>= log - k; |
255 | buf += (30U - log) << k; |
256 | LAST_SKIP_BITS(re, gb, 32 + k - log); |
257 | CLOSE_READER(re, gb); |
258 | |
259 | return buf; |
260 | } else { |
261 | LAST_SKIP_BITS(re, gb, limit); |
262 | UPDATE_CACHE(re, gb); |
263 | |
264 | buf = SHOW_UBITS(re, gb, esc_len); |
265 | |
266 | LAST_SKIP_BITS(re, gb, esc_len); |
267 | CLOSE_READER(re, gb); |
268 | |
269 | return buf + limit - 1; |
270 | } |
271 | } |
272 | |
273 | /** |
274 | * read u32 golomb rice code (jpegls). |
275 | */ |
276 | static inline int get_ur_golomb_jpegls(struct get_bits_context *gb, |
277 | int k, int limit, int esc_len) |
278 | { |
279 | u32 buf; |
280 | int log; |
281 | |
282 | OPEN_READER(re, gb); |
283 | UPDATE_CACHE(re, gb); |
284 | buf = GET_CACHE(re, gb); |
285 | |
286 | log = av_log2(buf); |
287 | |
288 | if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) && |
289 | 32 - log < limit) { |
290 | buf >>= log - k; |
291 | buf += (30U - log) << k; |
292 | LAST_SKIP_BITS(re, gb, 32 + k - log); |
293 | CLOSE_READER(re, gb); |
294 | |
295 | return buf; |
296 | } else { |
297 | int i; |
298 | for (i = 0; i + MIN_CACHE_BITS <= limit && SHOW_UBITS(re, gb, MIN_CACHE_BITS) == 0; i += MIN_CACHE_BITS) { |
299 | if (gb->size_in_bits <= re_index) { |
300 | CLOSE_READER(re, gb); |
301 | return -1; |
302 | } |
303 | LAST_SKIP_BITS(re, gb, MIN_CACHE_BITS); |
304 | UPDATE_CACHE(re, gb); |
305 | } |
306 | for (; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) { |
307 | SKIP_BITS(re, gb, 1); |
308 | } |
309 | LAST_SKIP_BITS(re, gb, 1); |
310 | UPDATE_CACHE(re, gb); |
311 | |
312 | if (i < limit - 1) { |
313 | if (k) { |
314 | if (k > MIN_CACHE_BITS - 1) { |
315 | buf = SHOW_UBITS(re, gb, 16) << (k-16); |
316 | LAST_SKIP_BITS(re, gb, 16); |
317 | UPDATE_CACHE(re, gb); |
318 | buf |= SHOW_UBITS(re, gb, k-16); |
319 | LAST_SKIP_BITS(re, gb, k-16); |
320 | } else { |
321 | buf = SHOW_UBITS(re, gb, k); |
322 | LAST_SKIP_BITS(re, gb, k); |
323 | } |
324 | } else { |
325 | buf = 0; |
326 | } |
327 | buf += ((u32)i << k); |
328 | } else if (i == limit - 1) { |
329 | buf = SHOW_UBITS(re, gb, esc_len); |
330 | LAST_SKIP_BITS(re, gb, esc_len); |
331 | |
332 | buf ++; |
333 | } else { |
334 | buf = -1; |
335 | } |
336 | CLOSE_READER(re, gb); |
337 | return buf; |
338 | } |
339 | } |
340 | |
341 | /** |
342 | * read signed golomb rice code (ffv1). |
343 | */ |
344 | static inline int get_sr_golomb(struct get_bits_context *gb, |
345 | int k, int limit, int esc_len) |
346 | { |
347 | u32 v = get_ur_golomb(gb, k, limit, esc_len); |
348 | |
349 | return (v >> 1) ^ -(v & 1); |
350 | } |
351 | |
352 | /** |
353 | * read signed golomb rice code (flac). |
354 | */ |
355 | static inline int get_sr_golomb_flac(struct get_bits_context *gb, |
356 | int k, int limit, int esc_len) |
357 | { |
358 | u32 v = get_ur_golomb_jpegls(gb, k, limit, esc_len); |
359 | |
360 | return (v >> 1) ^ -(v & 1); |
361 | } |
362 | |
363 | /** |
364 | * read u32 golomb rice code (shorten). |
365 | */ |
366 | static inline u32 get_ur_golomb_shorten(struct get_bits_context *gb, int k) |
367 | { |
368 | return get_ur_golomb_jpegls(gb, k, INT_MAX, 0); |
369 | } |
370 | |
371 | /** |
372 | * read signed golomb rice code (shorten). |
373 | */ |
374 | static inline int get_sr_golomb_shorten(struct get_bits_context *gb, int k) |
375 | { |
376 | int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0); |
377 | |
378 | return (uvar >> 1) ^ -(uvar & 1); |
379 | } |
380 | |
381 | /** |
382 | * write u32 exp golomb code. 2^16 - 2 at most |
383 | */ |
384 | static inline void set_ue_golomb(struct put_bits_context *pb, int i) |
385 | { |
386 | if (i < 256) |
387 | put_bits(pb, ff_ue_golomb_len[i], i + 1); |
388 | else { |
389 | int e = av_log2(i + 1); |
390 | put_bits(pb, 2 * e + 1, i + 1); |
391 | } |
392 | } |
393 | |
394 | /** |
395 | * write u32 exp golomb code. 2^32-2 at most. |
396 | */ |
397 | static inline void set_ue_golomb_long(struct put_bits_context *pb, u32 i) |
398 | { |
399 | if (i < 256) |
400 | put_bits(pb, ff_ue_golomb_len[i], i + 1); |
401 | else { |
402 | int e = av_log2(i + 1); |
403 | put_bits64(pb, 2 * e + 1, i + 1); |
404 | } |
405 | } |
406 | |
407 | /** |
408 | * write truncated u32 exp golomb code. |
409 | */ |
410 | static inline void set_te_golomb(struct put_bits_context *pb, int i, int range) |
411 | { |
412 | if (range == 2) |
413 | put_bits(pb, 1, i ^ 1); |
414 | else |
415 | set_ue_golomb(pb, i); |
416 | } |
417 | |
418 | /** |
419 | * write signed exp golomb code. 16 bits at most. |
420 | */ |
421 | static inline void set_se_golomb(struct put_bits_context *pb, int i) |
422 | { |
423 | i = 2 * i - 1; |
424 | |
425 | if (i < 0) |
426 | i ^= -1; //FIXME check if gcc does the right thing |
427 | set_ue_golomb(pb, i); |
428 | } |
429 | |
430 | /** |
431 | * write u32 golomb rice code (ffv1). |
432 | */ |
433 | static inline void set_ur_golomb(struct put_bits_context *pb, int i, int k, int limit, |
434 | int esc_len) |
435 | { |
436 | int e; |
437 | |
438 | e = i >> k; |
439 | if (e < limit) |
440 | put_bits(pb, e + k + 1, (1 << k) + av_mod_uintp2(i, k)); |
441 | else |
442 | put_bits(pb, limit + esc_len, i - limit + 1); |
443 | } |
444 | |
445 | /** |
446 | * write u32 golomb rice code (jpegls). |
447 | */ |
448 | static inline void set_ur_golomb_jpegls(struct put_bits_context *pb, |
449 | int i, int k, int limit, int esc_len) |
450 | { |
451 | int e; |
452 | |
453 | e = (i >> k) + 1; |
454 | if (e < limit) { |
455 | while (e > 31) { |
456 | put_bits(pb, 31, 0); |
457 | e -= 31; |
458 | } |
459 | put_bits(pb, e, 1); |
460 | if (k) |
461 | put_sbits(pb, k, i); |
462 | } else { |
463 | while (limit > 31) { |
464 | put_bits(pb, 31, 0); |
465 | limit -= 31; |
466 | } |
467 | put_bits(pb, limit, 1); |
468 | put_bits(pb, esc_len, i - 1); |
469 | } |
470 | } |
471 | |
472 | /** |
473 | * write signed golomb rice code (ffv1). |
474 | */ |
475 | static inline void set_sr_golomb(struct put_bits_context *pb, |
476 | int i, int k, int limit, int esc_len) |
477 | { |
478 | int v; |
479 | |
480 | v = -2 * i - 1; |
481 | v ^= (v >> 31); |
482 | |
483 | set_ur_golomb(pb, v, k, limit, esc_len); |
484 | } |
485 | |
486 | /** |
487 | * write signed golomb rice code (flac). |
488 | */ |
489 | static inline void set_sr_golomb_flac(struct put_bits_context *pb, |
490 | int i, int k, int limit, int esc_len) |
491 | { |
492 | int v; |
493 | |
494 | v = -2 * i - 1; |
495 | v ^= (v >> 31); |
496 | |
497 | set_ur_golomb_jpegls(pb, v, k, limit, esc_len); |
498 | } |
499 | |
500 | #endif /* AVCODEC_GOLOMB_H */ |
501 |