00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00030 #ifndef AVCODEC_GOLOMB_H
00031 #define AVCODEC_GOLOMB_H
00032
00033 #include <stdint.h>
00034 #include "get_bits.h"
00035 #include "put_bits.h"
00036
00037 #define INVALID_VLC 0x80000000
00038
00039 extern const uint8_t ff_golomb_vlc_len[512];
00040 extern const uint8_t ff_ue_golomb_vlc_code[512];
00041 extern const int8_t ff_se_golomb_vlc_code[512];
00042 extern const uint8_t ff_ue_golomb_len[256];
00043
00044 extern const uint8_t ff_interleaved_golomb_vlc_len[256];
00045 extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
00046 extern const int8_t ff_interleaved_se_golomb_vlc_code[256];
00047 extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
00048
00049
00053 static inline int get_ue_golomb(GetBitContext *gb){
00054 unsigned int buf;
00055 int log;
00056
00057 OPEN_READER(re, gb);
00058 UPDATE_CACHE(re, gb);
00059 buf=GET_CACHE(re, gb);
00060
00061 if(buf >= (1<<27)){
00062 buf >>= 32 - 9;
00063 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00064 CLOSE_READER(re, gb);
00065
00066 return ff_ue_golomb_vlc_code[buf];
00067 }else{
00068 log= 2*av_log2(buf) - 31;
00069 buf>>= log;
00070 buf--;
00071 LAST_SKIP_BITS(re, gb, 32 - log);
00072 CLOSE_READER(re, gb);
00073
00074 return buf;
00075 }
00076 }
00077
00081 static inline unsigned get_ue_golomb_long(GetBitContext *gb)
00082 {
00083 unsigned buf, log;
00084
00085 buf = show_bits_long(gb, 32);
00086 log = 31 - av_log2(buf);
00087 skip_bits_long(gb, log);
00088
00089 return get_bits_long(gb, log + 1) - 1;
00090 }
00091
00096 static inline int get_ue_golomb_31(GetBitContext *gb){
00097 unsigned int buf;
00098
00099 OPEN_READER(re, gb);
00100 UPDATE_CACHE(re, gb);
00101 buf=GET_CACHE(re, gb);
00102
00103 buf >>= 32 - 9;
00104 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00105 CLOSE_READER(re, gb);
00106
00107 return ff_ue_golomb_vlc_code[buf];
00108 }
00109
00110 static inline unsigned svq3_get_ue_golomb(GetBitContext *gb)
00111 {
00112 uint32_t buf;
00113
00114 OPEN_READER(re, gb);
00115 UPDATE_CACHE(re, gb);
00116 buf=GET_CACHE(re, gb);
00117
00118 if(buf&0xAA800000){
00119 buf >>= 32 - 8;
00120 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00121 CLOSE_READER(re, gb);
00122
00123 return ff_interleaved_ue_golomb_vlc_code[buf];
00124 }else{
00125 unsigned ret = 1;
00126
00127 do {
00128 buf >>= 32 - 8;
00129 LAST_SKIP_BITS(re, gb, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
00130
00131 if (ff_interleaved_golomb_vlc_len[buf] != 9){
00132 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
00133 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
00134 break;
00135 }
00136 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
00137 UPDATE_CACHE(re, gb);
00138 buf = GET_CACHE(re, gb);
00139 } while (ret<0x8000000U && HAVE_BITS_REMAINING(re, gb));
00140
00141 CLOSE_READER(re, gb);
00142 return ret - 1;
00143 }
00144 }
00145
00149 static inline int get_te0_golomb(GetBitContext *gb, int range){
00150 av_assert2(range >= 1);
00151
00152 if(range==1) return 0;
00153 else if(range==2) return get_bits1(gb)^1;
00154 else return get_ue_golomb(gb);
00155 }
00156
00160 static inline int get_te_golomb(GetBitContext *gb, int range){
00161 av_assert2(range >= 1);
00162
00163 if(range==2) return get_bits1(gb)^1;
00164 else return get_ue_golomb(gb);
00165 }
00166
00167
00171 static inline int get_se_golomb(GetBitContext *gb){
00172 unsigned int buf;
00173 int log;
00174
00175 OPEN_READER(re, gb);
00176 UPDATE_CACHE(re, gb);
00177 buf=GET_CACHE(re, gb);
00178
00179 if(buf >= (1<<27)){
00180 buf >>= 32 - 9;
00181 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00182 CLOSE_READER(re, gb);
00183
00184 return ff_se_golomb_vlc_code[buf];
00185 }else{
00186 log= 2*av_log2(buf) - 31;
00187 buf>>= log;
00188
00189 LAST_SKIP_BITS(re, gb, 32 - log);
00190 CLOSE_READER(re, gb);
00191
00192 if(buf&1) buf= -(buf>>1);
00193 else buf= (buf>>1);
00194
00195 return buf;
00196 }
00197 }
00198
00199 static inline int svq3_get_se_golomb(GetBitContext *gb){
00200 unsigned int buf;
00201 int log;
00202
00203 OPEN_READER(re, gb);
00204 UPDATE_CACHE(re, gb);
00205 buf=GET_CACHE(re, gb);
00206
00207 if(buf&0xAA800000){
00208 buf >>= 32 - 8;
00209 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00210 CLOSE_READER(re, gb);
00211
00212 return ff_interleaved_se_golomb_vlc_code[buf];
00213 }else{
00214 LAST_SKIP_BITS(re, gb, 8);
00215 UPDATE_CACHE(re, gb);
00216 buf |= 1 | (GET_CACHE(re, gb) >> 8);
00217
00218 if((buf & 0xAAAAAAAA) == 0)
00219 return INVALID_VLC;
00220
00221 for(log=31; (buf & 0x80000000) == 0; log--){
00222 buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
00223 }
00224
00225 LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
00226 CLOSE_READER(re, gb);
00227
00228 return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
00229 }
00230 }
00231
00232 static inline int dirac_get_se_golomb(GetBitContext *gb){
00233 uint32_t buf;
00234 uint32_t ret;
00235
00236 ret = svq3_get_ue_golomb(gb);
00237
00238 if (ret) {
00239 OPEN_READER(re, gb);
00240 UPDATE_CACHE(re, gb);
00241 buf = SHOW_SBITS(re, gb, 1);
00242 LAST_SKIP_BITS(re, gb, 1);
00243 ret = (ret ^ buf) - buf;
00244 CLOSE_READER(re, gb);
00245 }
00246
00247 return ret;
00248 }
00249
00253 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00254 unsigned int buf;
00255 int log;
00256
00257 OPEN_READER(re, gb);
00258 UPDATE_CACHE(re, gb);
00259 buf=GET_CACHE(re, gb);
00260
00261 log= av_log2(buf);
00262
00263 if(log > 31-limit){
00264 buf >>= log - k;
00265 buf += (30-log)<<k;
00266 LAST_SKIP_BITS(re, gb, 32 + k - log);
00267 CLOSE_READER(re, gb);
00268
00269 return buf;
00270 }else{
00271 LAST_SKIP_BITS(re, gb, limit);
00272 UPDATE_CACHE(re, gb);
00273
00274 buf = SHOW_UBITS(re, gb, esc_len);
00275
00276 LAST_SKIP_BITS(re, gb, esc_len);
00277 CLOSE_READER(re, gb);
00278
00279 return buf + limit - 1;
00280 }
00281 }
00282
00286 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){
00287 unsigned int buf;
00288 int log;
00289
00290 OPEN_READER(re, gb);
00291 UPDATE_CACHE(re, gb);
00292 buf=GET_CACHE(re, gb);
00293
00294 log= av_log2(buf);
00295
00296 if(log - k >= 32-MIN_CACHE_BITS+(MIN_CACHE_BITS==32) && 32-log < limit){
00297 buf >>= log - k;
00298 buf += (30-log)<<k;
00299 LAST_SKIP_BITS(re, gb, 32 + k - log);
00300 CLOSE_READER(re, gb);
00301
00302 return buf;
00303 }else{
00304 int i;
00305 for (i = 0; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) {
00306 if (gb->size_in_bits <= re_index)
00307 return -1;
00308 LAST_SKIP_BITS(re, gb, 1);
00309 UPDATE_CACHE(re, gb);
00310 }
00311 SKIP_BITS(re, gb, 1);
00312
00313 if(i < limit - 1){
00314 if(k){
00315 buf = SHOW_UBITS(re, gb, k);
00316 LAST_SKIP_BITS(re, gb, k);
00317 }else{
00318 buf=0;
00319 }
00320
00321 CLOSE_READER(re, gb);
00322 return buf + (i<<k);
00323 }else if(i == limit - 1){
00324 buf = SHOW_UBITS(re, gb, esc_len);
00325 LAST_SKIP_BITS(re, gb, esc_len);
00326 CLOSE_READER(re, gb);
00327
00328 return buf + 1;
00329 }else
00330 return -1;
00331 }
00332 }
00333
00337 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00338 int v= get_ur_golomb(gb, k, limit, esc_len);
00339
00340 v++;
00341 if (v&1) return v>>1;
00342 else return -(v>>1);
00343
00344
00345 }
00346
00350 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){
00351 int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);
00352 return (v>>1) ^ -(v&1);
00353 }
00354
00358 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){
00359 return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
00360 }
00361
00365 static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
00366 {
00367 int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
00368 if (uvar & 1)
00369 return ~(uvar >> 1);
00370 else
00371 return uvar >> 1;
00372 }
00373
00374
00375
00376 #ifdef TRACE
00377
00378 static inline int get_ue(GetBitContext *s, const char *file, const char *func,
00379 int line)
00380 {
00381 int show= show_bits(s, 24);
00382 int pos= get_bits_count(s);
00383 int i= get_ue_golomb(s);
00384 int len= get_bits_count(s) - pos;
00385 int bits= show>>(24-len);
00386
00387 print_bin(bits, len);
00388
00389 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00390
00391 return i;
00392 }
00393
00394 static inline int get_se(GetBitContext *s, const char *file, const char *func,
00395 int line)
00396 {
00397 int show= show_bits(s, 24);
00398 int pos= get_bits_count(s);
00399 int i= get_se_golomb(s);
00400 int len= get_bits_count(s) - pos;
00401 int bits= show>>(24-len);
00402
00403 print_bin(bits, len);
00404
00405 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00406
00407 return i;
00408 }
00409
00410 static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line){
00411 int show= show_bits(s, 24);
00412 int pos= get_bits_count(s);
00413 int i= get_te0_golomb(s, r);
00414 int len= get_bits_count(s) - pos;
00415 int bits= show>>(24-len);
00416
00417 print_bin(bits, len);
00418
00419 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00420
00421 return i;
00422 }
00423
00424 #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00425 #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00426 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00427 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00428
00429 #endif
00430
00434 static inline void set_ue_golomb(PutBitContext *pb, int i){
00435 int e;
00436
00437 av_assert2(i>=0);
00438
00439 #if 0
00440 if(i=0){
00441 put_bits(pb, 1, 1);
00442 return;
00443 }
00444 #endif
00445 if(i<256)
00446 put_bits(pb, ff_ue_golomb_len[i], i+1);
00447 else{
00448 e= av_log2(i+1);
00449
00450 put_bits(pb, 2*e+1, i+1);
00451 }
00452 }
00453
00457 static inline void set_te_golomb(PutBitContext *pb, int i, int range){
00458 av_assert2(range >= 1);
00459 av_assert2(i<=range);
00460
00461 if(range==2) put_bits(pb, 1, i^1);
00462 else set_ue_golomb(pb, i);
00463 }
00464
00468 static inline void set_se_golomb(PutBitContext *pb, int i){
00469 #if 0
00470 if(i<=0) i= -2*i;
00471 else i= 2*i-1;
00472 #elif 1
00473 i= 2*i-1;
00474 if(i<0) i^= -1;
00475 #else
00476 i= 2*i-1;
00477 i^= (i>>31);
00478 #endif
00479 set_ue_golomb(pb, i);
00480 }
00481
00485 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00486 int e;
00487
00488 av_assert2(i>=0);
00489
00490 e= i>>k;
00491 if(e<limit){
00492 put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));
00493 }else{
00494 put_bits(pb, limit + esc_len, i - limit + 1);
00495 }
00496 }
00497
00501 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){
00502 int e;
00503
00504 av_assert2(i>=0);
00505
00506 e= (i>>k) + 1;
00507 if(e<limit){
00508 while(e > 31) {
00509 put_bits(pb, 31, 0);
00510 e -= 31;
00511 }
00512 put_bits(pb, e, 1);
00513 if(k)
00514 put_sbits(pb, k, i);
00515 }else{
00516 while(limit > 31) {
00517 put_bits(pb, 31, 0);
00518 limit -= 31;
00519 }
00520 put_bits(pb, limit , 1);
00521 put_bits(pb, esc_len, i - 1);
00522 }
00523 }
00524
00528 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00529 int v;
00530
00531 v = -2*i-1;
00532 v ^= (v>>31);
00533
00534 set_ur_golomb(pb, v, k, limit, esc_len);
00535 }
00536
00540 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){
00541 int v;
00542
00543 v = -2*i-1;
00544 v ^= (v>>31);
00545
00546 set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
00547 }
00548
00549 #endif