summaryrefslogtreecommitdiff
path: root/audio_codec/libflac/golomb.h (plain)
blob: 248bfc2b406c612d6cf3fb14ff1fcd00fabbec9c
1/*
2 * exp golomb vlc stuff
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 * Copyright (c) 2004 Alex Beregszaszi
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/**
24 * @file libavcodec/golomb.h
25 * @brief
26 * exp golomb vlc stuff
27 * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi
28 */
29
30#ifndef AVCODEC_GOLOMB_H
31#define AVCODEC_GOLOMB_H
32
33#ifndef __MW__
34#include <stdint.h>
35#endif
36#include "get_bits.h"
37//#include "put_bits.h"
38
39#include <assert.h>
40
41#define INVALID_VLC 0x80000000
42#ifndef __MW__
43extern const uint8_t ff_golomb_vlc_len[512];
44extern const uint8_t ff_ue_golomb_vlc_code[512];
45extern const int8_t ff_se_golomb_vlc_code[512];
46extern const uint8_t ff_ue_golomb_len[256];
47
48extern const uint8_t ff_interleaved_golomb_vlc_len[256];
49extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
50extern const int8_t ff_interleaved_se_golomb_vlc_code[256];
51extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
52
53
54/**
55* read unsigned exp golomb code.
56*/
57static inline int get_ue_golomb(GetBitContext *gb)
58{
59 unsigned int buf;
60 int log;
61
62 OPEN_READER(re, gb);
63 UPDATE_CACHE(re, gb);
64 buf = GET_CACHE(re, gb);
65
66 if (buf >= (1 << 27)) {
67 buf >>= 32 - 9;
68 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
69 CLOSE_READER(re, gb);
70
71 return ff_ue_golomb_vlc_code[buf];
72 } else {
73 log = 2 * av_log2(buf) - 31;
74 buf >>= log;
75 buf--;
76 LAST_SKIP_BITS(re, gb, 32 - log);
77 CLOSE_READER(re, gb);
78
79 return buf;
80 }
81}
82
83/**
84* read unsigned exp golomb code, constraint to a max of 31.
85* the return value is undefined if the stored value exceeds 31.
86*/
87static inline int get_ue_golomb_31(GetBitContext *gb)
88{
89 unsigned int buf;
90
91 OPEN_READER(re, gb);
92 UPDATE_CACHE(re, gb);
93 buf = GET_CACHE(re, gb);
94
95 buf >>= 32 - 9;
96 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
97 CLOSE_READER(re, gb);
98
99 return ff_ue_golomb_vlc_code[buf];
100}
101
102static inline int svq3_get_ue_golomb(GetBitContext *gb)
103{
104 uint32_t buf;
105
106 OPEN_READER(re, gb);
107 UPDATE_CACHE(re, gb);
108 buf = GET_CACHE(re, gb);
109
110 if (buf & 0xAA800000) {
111 buf >>= 32 - 8;
112 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
113 CLOSE_READER(re, gb);
114
115 return ff_interleaved_ue_golomb_vlc_code[buf];
116 } else {
117 int ret = 1;
118
119 while (1) {
120 buf >>= 32 - 8;
121 LAST_SKIP_BITS(re, gb, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
122
123 if (ff_interleaved_golomb_vlc_len[buf] != 9) {
124 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
125 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
126 break;
127 }
128 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
129 UPDATE_CACHE(re, gb);
130 buf = GET_CACHE(re, gb);
131 }
132
133 CLOSE_READER(re, gb);
134 return ret - 1;
135 }
136}
137
138/**
139 * read unsigned truncated exp golomb code.
140 */
141static inline int get_te0_golomb(GetBitContext *gb, int range)
142{
143 assert(range >= 1);
144
145 if (range == 1) {
146 return 0;
147 } else if (range == 2) {
148 return get_bits1(gb) ^ 1;
149 } else {
150 return get_ue_golomb(gb);
151 }
152}
153
154/**
155 * read unsigned truncated exp golomb code.
156 */
157static inline int get_te_golomb(GetBitContext *gb, int range)
158{
159 assert(range >= 1);
160
161 if (range == 2) {
162 return get_bits1(gb) ^ 1;
163 } else {
164 return get_ue_golomb(gb);
165 }
166}
167
168
169/**
170 * read signed exp golomb code.
171 */
172static inline int get_se_golomb(GetBitContext *gb)
173{
174 unsigned int buf;
175 int log;
176
177 OPEN_READER(re, gb);
178 UPDATE_CACHE(re, gb);
179 buf = GET_CACHE(re, gb);
180
181 if (buf >= (1 << 27)) {
182 buf >>= 32 - 9;
183 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
184 CLOSE_READER(re, gb);
185
186 return ff_se_golomb_vlc_code[buf];
187 } else {
188 log = 2 * av_log2(buf) - 31;
189 buf >>= log;
190
191 LAST_SKIP_BITS(re, gb, 32 - log);
192 CLOSE_READER(re, gb);
193
194 if (buf & 1) {
195 buf = -(buf >> 1);
196 } else {
197 buf = (buf >> 1);
198 }
199
200 return buf;
201 }
202}
203
204static inline int svq3_get_se_golomb(GetBitContext *gb)
205{
206 unsigned int buf;
207 int log;
208
209 OPEN_READER(re, gb);
210 UPDATE_CACHE(re, gb);
211 buf = GET_CACHE(re, gb);
212
213 if (buf & 0xAA800000) {
214 buf >>= 32 - 8;
215 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
216 CLOSE_READER(re, gb);
217
218 return ff_interleaved_se_golomb_vlc_code[buf];
219 } else {
220 LAST_SKIP_BITS(re, gb, 8);
221 UPDATE_CACHE(re, gb);
222 buf |= 1 | (GET_CACHE(re, gb) >> 8);
223
224 if ((buf & 0xAAAAAAAA) == 0) {
225 return INVALID_VLC;
226 }
227
228 for (log = 31; (buf & 0x80000000) == 0; log--) {
229 buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
230 }
231
232 LAST_SKIP_BITS(re, gb, 63 - 2 * log - 8);
233 CLOSE_READER(re, gb);
234
235 return (signed)(((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
236 }
237}
238
239static inline int dirac_get_se_golomb(GetBitContext *gb)
240{
241 uint32_t buf;
242 uint32_t ret;
243
244 ret = svq3_get_ue_golomb(gb);
245
246 if (ret) {
247 OPEN_READER(re, gb);
248 UPDATE_CACHE(re, gb);
249 buf = SHOW_SBITS(re, gb, 1);
250 LAST_SKIP_BITS(re, gb, 1);
251 ret = (ret ^ buf) - buf;
252 CLOSE_READER(re, gb);
253 }
254
255 return ret;
256}
257#endif
258
259/**
260 * read unsigned golomb rice code (ffv1).
261 */
262static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len)
263{
264 unsigned int buf;
265 int log;
266
267 OPEN_READER(re, gb);
268 UPDATE_CACHE(re, gb);
269 buf = GET_CACHE(re, gb);
270
271 log = av_log2(buf);
272
273 if (log > 31 - limit) {
274 buf >>= log - k;
275 buf += (30 - log) << k;
276 LAST_SKIP_BITS(re, gb, 32 + k - log);
277 CLOSE_READER(re, gb);
278
279 return buf;
280 } else {
281 LAST_SKIP_BITS(re, gb, limit);
282 UPDATE_CACHE(re, gb);
283
284 buf = SHOW_UBITS(re, gb, esc_len);
285
286 LAST_SKIP_BITS(re, gb, esc_len);
287 CLOSE_READER(re, gb);
288
289 return buf + limit - 1;
290 }
291}
292
293/**
294 * read unsigned golomb rice code (jpegls).
295 */
296static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
297{
298 unsigned int buf;
299 int log;
300
301 OPEN_READER(re, gb);
302 UPDATE_CACHE(re, gb);
303 buf = GET_CACHE(re, gb);
304
305 log = av_log2(buf);
306
307 if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) && 32 - log < limit) {
308 buf >>= log - k;
309 buf += (30 - log) << k;
310 LAST_SKIP_BITS(re, gb, 32 + k - log);
311 CLOSE_READER(re, gb);
312
313 return buf;
314 } else {
315 int i;
316 for (i = 0; SHOW_UBITS(re, gb, 1) == 0; i++) {
317 LAST_SKIP_BITS(re, gb, 1);
318 UPDATE_CACHE(re, gb);
319 }
320 SKIP_BITS(re, gb, 1);
321
322 if (i < limit - 1) {
323 if (k) {
324 buf = SHOW_UBITS(re, gb, k);
325 LAST_SKIP_BITS(re, gb, k);
326 } else {
327 buf = 0;
328 }
329
330 CLOSE_READER(re, gb);
331 return buf + (i << k);
332 } else if (i == limit - 1) {
333 buf = SHOW_UBITS(re, gb, esc_len);
334 LAST_SKIP_BITS(re, gb, esc_len);
335 CLOSE_READER(re, gb);
336
337 return buf + 1;
338 } else {
339 return -1;
340 }
341 }
342}
343
344/**
345 * read signed golomb rice code (ffv1).
346 */
347static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len)
348{
349 int v = get_ur_golomb(gb, k, limit, esc_len);
350
351 v++;
352 if (v & 1) {
353 return v >> 1;
354 } else {
355 return -(v >> 1);
356 }
357
358 // return (v>>1) ^ -(v&1);
359}
360
361/**
362 * read signed golomb rice code (flac).
363 */
364static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
365{
366 int v = get_ur_golomb_jpegls(gb, k, limit, esc_len);
367 return (v >> 1) ^ -(v & 1);
368}
369
370/**
371 * read unsigned golomb rice code (shorten).
372 */
373static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)
374{
375 return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
376}
377
378/**
379 * read signed golomb rice code (shorten).
380 */
381static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
382{
383 int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
384 if (uvar & 1) {
385 return ~(uvar >> 1);
386 } else {
387 return uvar >> 1;
388 }
389}
390
391
392
393#ifdef TRACE
394
395static inline int get_ue(GetBitContext *s, char *file, const char *func, int line)
396{
397 int show = show_bits(s, 24);
398 int pos = get_bits_count(s);
399 int i = get_ue_golomb(s);
400 int len = get_bits_count(s) - pos;
401 int bits = show >> (24 - len);
402
403 print_bin(bits, len);
404
405 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
406
407 return i;
408}
409
410static inline int get_se(GetBitContext *s, char *file, const char *func, int line)
411{
412 int show = show_bits(s, 24);
413 int pos = get_bits_count(s);
414 int i = get_se_golomb(s);
415 int len = get_bits_count(s) - pos;
416 int bits = show >> (24 - len);
417
418 print_bin(bits, len);
419
420 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
421
422 return i;
423}
424
425static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line)
426{
427 int show = show_bits(s, 24);
428 int pos = get_bits_count(s);
429 int i = get_te0_golomb(s, r);
430 int len = get_bits_count(s) - pos;
431 int bits = show >> (24 - len);
432
433 print_bin(bits, len);
434
435 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
436
437 return i;
438}
439
440#define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
441#define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
442#define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
443#define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
444
445#endif
446
447#if 0
448/**
449 * write unsigned exp golomb code.
450 */
451static inline void set_ue_golomb(PutBitContext *pb, int i)
452{
453 int e;
454
455 assert(i >= 0);
456
457#if 0
458 if (i = 0) {
459 put_bits(pb, 1, 1);
460 return;
461 }
462#endif
463 if (i < 256) {
464 put_bits(pb, ff_ue_golomb_len[i], i + 1);
465 } else {
466 e = av_log2(i + 1);
467
468 put_bits(pb, 2 * e + 1, i + 1);
469 }
470}
471
472/**
473 * write truncated unsigned exp golomb code.
474 */
475static inline void set_te_golomb(PutBitContext *pb, int i, int range)
476{
477 assert(range >= 1);
478 assert(i <= range);
479
480 if (range == 2) {
481 put_bits(pb, 1, i ^ 1);
482 } else {
483 set_ue_golomb(pb, i);
484 }
485}
486
487/**
488 * write signed exp golomb code. 16 bits at most.
489 */
490static inline void set_se_golomb(PutBitContext *pb, int i)
491{
492 // if (i>32767 || i<-32767)
493 // av_log(NULL,AV_LOG_ERROR,"value out of range %d\n", i);
494#if 0
495 if (i <= 0) {
496 i = -2 * i;
497 } else {
498 i = 2 * i - 1;
499 }
500#elif 1
501 i = 2 * i - 1;
502 if (i < 0) {
503 i ^= -1; //FIXME check if gcc does the right thing
504 }
505#else
506 i = 2 * i - 1;
507 i ^= (i >> 31);
508#endif
509 set_ue_golomb(pb, i);
510}
511
512/**
513 * write unsigned golomb rice code (ffv1).
514 */
515static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
516{
517 int e;
518
519 assert(i >= 0);
520
521 e = i >> k;
522 if (e < limit) {
523 put_bits(pb, e + k + 1, (1 << k) + (i & ((1 << k) - 1)));
524 } else {
525 put_bits(pb, limit + esc_len, i - limit + 1);
526 }
527}
528
529/**
530 * write unsigned golomb rice code (jpegls).
531 */
532static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len)
533{
534 int e;
535
536 assert(i >= 0);
537
538 e = (i >> k) + 1;
539 if (e < limit) {
540 while (e > 31) {
541 put_bits(pb, 31, 0);
542 e -= 31;
543 }
544 put_bits(pb, e, 1);
545 if (k) {
546 put_sbits(pb, k, i);
547 }
548 } else {
549 while (limit > 31) {
550 put_bits(pb, 31, 0);
551 limit -= 31;
552 }
553 put_bits(pb, limit , 1);
554 put_bits(pb, esc_len, i - 1);
555 }
556}
557
558/**
559 * write signed golomb rice code (ffv1).
560 */
561static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
562{
563 int v;
564
565 v = -2 * i - 1;
566 v ^= (v >> 31);
567
568 set_ur_golomb(pb, v, k, limit, esc_len);
569}
570
571/**
572 * write signed golomb rice code (flac).
573 */
574static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len)
575{
576 int v;
577
578 v = -2 * i - 1;
579 v ^= (v >> 31);
580
581 set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
582}
583#endif
584
585#endif /* AVCODEC_GOLOMB_H */
586
generated by cgit at 2024-05-18 21:01:15 (GMT)