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