00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00030 #ifndef FFMPEG_GOLOMB_H
00031 #define FFMPEG_GOLOMB_H
00032
00033 #include <stdint.h>
00034 #include "bitstream.h"
00035
00036 #define INVALID_VLC 0x80000000
00037
00038 extern const uint8_t ff_golomb_vlc_len[512];
00039 extern const uint8_t ff_ue_golomb_vlc_code[512];
00040 extern const int8_t ff_se_golomb_vlc_code[512];
00041 extern const uint8_t ff_ue_golomb_len[256];
00042
00043 extern const uint8_t ff_interleaved_golomb_vlc_len[256];
00044 extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
00045 extern const int8_t ff_interleaved_se_golomb_vlc_code[256];
00046 extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
00047
00048
00052 static inline int get_ue_golomb(GetBitContext *gb){
00053 unsigned int buf;
00054 int log;
00055
00056 OPEN_READER(re, gb);
00057 UPDATE_CACHE(re, gb);
00058 buf=GET_CACHE(re, gb);
00059
00060 if(buf >= (1<<27)){
00061 buf >>= 32 - 9;
00062 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00063 CLOSE_READER(re, gb);
00064
00065 return ff_ue_golomb_vlc_code[buf];
00066 }else{
00067 log= 2*av_log2(buf) - 31;
00068 buf>>= log;
00069 buf--;
00070 LAST_SKIP_BITS(re, gb, 32 - log);
00071 CLOSE_READER(re, gb);
00072
00073 return buf;
00074 }
00075 }
00076
00077 static inline int svq3_get_ue_golomb(GetBitContext *gb){
00078 uint32_t buf;
00079
00080 OPEN_READER(re, gb);
00081 UPDATE_CACHE(re, gb);
00082 buf=GET_CACHE(re, gb);
00083
00084 if(buf&0xAA800000){
00085 buf >>= 32 - 8;
00086 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00087 CLOSE_READER(re, gb);
00088
00089 return ff_interleaved_ue_golomb_vlc_code[buf];
00090 }else{
00091 int ret = 1;
00092
00093 while (1) {
00094 buf >>= 32 - 8;
00095 LAST_SKIP_BITS(re, gb, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
00096
00097 if (ff_interleaved_golomb_vlc_len[buf] != 9){
00098 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
00099 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
00100 break;
00101 }
00102 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
00103 UPDATE_CACHE(re, gb);
00104 buf = GET_CACHE(re, gb);
00105 }
00106
00107 CLOSE_READER(re, gb);
00108 return ret - 1;
00109 }
00110 }
00111
00115 static inline int get_te0_golomb(GetBitContext *gb, int range){
00116 assert(range >= 1);
00117
00118 if(range==1) return 0;
00119 else if(range==2) return get_bits1(gb)^1;
00120 else return get_ue_golomb(gb);
00121 }
00122
00126 static inline int get_te_golomb(GetBitContext *gb, int range){
00127 assert(range >= 1);
00128
00129 if(range==2) return get_bits1(gb)^1;
00130 else return get_ue_golomb(gb);
00131 }
00132
00133
00137 static inline int get_se_golomb(GetBitContext *gb){
00138 unsigned int buf;
00139 int log;
00140
00141 OPEN_READER(re, gb);
00142 UPDATE_CACHE(re, gb);
00143 buf=GET_CACHE(re, gb);
00144
00145 if(buf >= (1<<27)){
00146 buf >>= 32 - 9;
00147 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00148 CLOSE_READER(re, gb);
00149
00150 return ff_se_golomb_vlc_code[buf];
00151 }else{
00152 log= 2*av_log2(buf) - 31;
00153 buf>>= log;
00154
00155 LAST_SKIP_BITS(re, gb, 32 - log);
00156 CLOSE_READER(re, gb);
00157
00158 if(buf&1) buf= -(buf>>1);
00159 else buf= (buf>>1);
00160
00161 return buf;
00162 }
00163 }
00164
00165 static inline int svq3_get_se_golomb(GetBitContext *gb){
00166 unsigned int buf;
00167 int log;
00168
00169 OPEN_READER(re, gb);
00170 UPDATE_CACHE(re, gb);
00171 buf=GET_CACHE(re, gb);
00172
00173 if(buf&0xAA800000){
00174 buf >>= 32 - 8;
00175 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00176 CLOSE_READER(re, gb);
00177
00178 return ff_interleaved_se_golomb_vlc_code[buf];
00179 }else{
00180 LAST_SKIP_BITS(re, gb, 8);
00181 UPDATE_CACHE(re, gb);
00182 buf |= 1 | (GET_CACHE(re, gb) >> 8);
00183
00184 if((buf & 0xAAAAAAAA) == 0)
00185 return INVALID_VLC;
00186
00187 for(log=31; (buf & 0x80000000) == 0; log--){
00188 buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
00189 }
00190
00191 LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
00192 CLOSE_READER(re, gb);
00193
00194 return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
00195 }
00196 }
00197
00198 static inline int dirac_get_se_golomb(GetBitContext *gb){
00199 uint32_t buf;
00200 uint32_t ret;
00201
00202 ret = svq3_get_ue_golomb(gb);
00203
00204 if (ret) {
00205 OPEN_READER(re, gb);
00206 UPDATE_CACHE(re, gb);
00207 buf = SHOW_SBITS(re, gb, 1);
00208 LAST_SKIP_BITS(re, gb, 1);
00209 ret = (ret ^ buf) - buf;
00210 CLOSE_READER(re, gb);
00211 }
00212
00213 return ret;
00214 }
00215
00219 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00220 unsigned int buf;
00221 int log;
00222
00223 OPEN_READER(re, gb);
00224 UPDATE_CACHE(re, gb);
00225 buf=GET_CACHE(re, gb);
00226
00227 log= av_log2(buf);
00228
00229 if(log > 31-limit){
00230 buf >>= log - k;
00231 buf += (30-log)<<k;
00232 LAST_SKIP_BITS(re, gb, 32 + k - log);
00233 CLOSE_READER(re, gb);
00234
00235 return buf;
00236 }else{
00237 buf >>= 32 - limit - esc_len;
00238 LAST_SKIP_BITS(re, gb, esc_len + limit);
00239 CLOSE_READER(re, gb);
00240
00241 return buf + limit - 1;
00242 }
00243 }
00244
00248 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){
00249 unsigned int buf;
00250 int log;
00251
00252 OPEN_READER(re, gb);
00253 UPDATE_CACHE(re, gb);
00254 buf=GET_CACHE(re, gb);
00255
00256 log= av_log2(buf);
00257
00258 if(log > 31-11){
00259 buf >>= log - k;
00260 buf += (30-log)<<k;
00261 LAST_SKIP_BITS(re, gb, 32 + k - log);
00262 CLOSE_READER(re, gb);
00263
00264 return buf;
00265 }else{
00266 int i;
00267 for(i=0; SHOW_UBITS(re, gb, 1) == 0; i++){
00268 LAST_SKIP_BITS(re, gb, 1);
00269 UPDATE_CACHE(re, gb);
00270 }
00271 SKIP_BITS(re, gb, 1);
00272
00273 if(i < limit - 1){
00274 if(k){
00275 buf = SHOW_UBITS(re, gb, k);
00276 LAST_SKIP_BITS(re, gb, k);
00277 }else{
00278 buf=0;
00279 }
00280
00281 CLOSE_READER(re, gb);
00282 return buf + (i<<k);
00283 }else if(i == limit - 1){
00284 buf = SHOW_UBITS(re, gb, esc_len);
00285 LAST_SKIP_BITS(re, gb, esc_len);
00286 CLOSE_READER(re, gb);
00287
00288 return buf + 1;
00289 }else
00290 return -1;
00291 }
00292 }
00293
00297 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00298 int v= get_ur_golomb(gb, k, limit, esc_len);
00299
00300 v++;
00301 if (v&1) return v>>1;
00302 else return -(v>>1);
00303
00304
00305 }
00306
00310 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){
00311 int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);
00312 return (v>>1) ^ -(v&1);
00313 }
00314
00318 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){
00319 return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
00320 }
00321
00325 static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
00326 {
00327 int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
00328 if (uvar & 1)
00329 return ~(uvar >> 1);
00330 else
00331 return uvar >> 1;
00332 }
00333
00334
00335
00336 #ifdef TRACE
00337
00338 static inline int get_ue(GetBitContext *s, char *file, const char *func, int line){
00339 int show= show_bits(s, 24);
00340 int pos= get_bits_count(s);
00341 int i= get_ue_golomb(s);
00342 int len= get_bits_count(s) - pos;
00343 int bits= show>>(24-len);
00344
00345 print_bin(bits, len);
00346
00347 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00348
00349 return i;
00350 }
00351
00352 static inline int get_se(GetBitContext *s, char *file, const char *func, int line){
00353 int show= show_bits(s, 24);
00354 int pos= get_bits_count(s);
00355 int i= get_se_golomb(s);
00356 int len= get_bits_count(s) - pos;
00357 int bits= show>>(24-len);
00358
00359 print_bin(bits, len);
00360
00361 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00362
00363 return i;
00364 }
00365
00366 static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line){
00367 int show= show_bits(s, 24);
00368 int pos= get_bits_count(s);
00369 int i= get_te0_golomb(s, r);
00370 int len= get_bits_count(s) - pos;
00371 int bits= show>>(24-len);
00372
00373 print_bin(bits, len);
00374
00375 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00376
00377 return i;
00378 }
00379
00380 #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00381 #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00382 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00383 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00384
00385 #endif
00386
00390 static inline void set_ue_golomb(PutBitContext *pb, int i){
00391 int e;
00392
00393 assert(i>=0);
00394
00395 #if 0
00396 if(i=0){
00397 put_bits(pb, 1, 1);
00398 return;
00399 }
00400 #endif
00401 if(i<256)
00402 put_bits(pb, ff_ue_golomb_len[i], i+1);
00403 else{
00404 e= av_log2(i+1);
00405
00406 put_bits(pb, 2*e+1, i+1);
00407 }
00408 }
00409
00413 static inline void set_te_golomb(PutBitContext *pb, int i, int range){
00414 assert(range >= 1);
00415 assert(i<=range);
00416
00417 if(range==2) put_bits(pb, 1, i^1);
00418 else set_ue_golomb(pb, i);
00419 }
00420
00424 static inline void set_se_golomb(PutBitContext *pb, int i){
00425
00426
00427 #if 0
00428 if(i<=0) i= -2*i;
00429 else i= 2*i-1;
00430 #elif 1
00431 i= 2*i-1;
00432 if(i<0) i^= -1;
00433 #else
00434 i= 2*i-1;
00435 i^= (i>>31);
00436 #endif
00437 set_ue_golomb(pb, i);
00438 }
00439
00443 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00444 int e;
00445
00446 assert(i>=0);
00447
00448 e= i>>k;
00449 if(e<limit){
00450 put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));
00451 }else{
00452 put_bits(pb, limit + esc_len, i - limit + 1);
00453 }
00454 }
00455
00459 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){
00460 int e;
00461
00462 assert(i>=0);
00463
00464 e= (i>>k) + 1;
00465 if(e<limit){
00466 while(e > 31) {
00467 put_bits(pb, 31, 0);
00468 e -= 31;
00469 }
00470 put_bits(pb, e, 1);
00471 if(k)
00472 put_bits(pb, k, i&((1<<k)-1));
00473 }else{
00474 while(limit > 31) {
00475 put_bits(pb, 31, 0);
00476 limit -= 31;
00477 }
00478 put_bits(pb, limit , 1);
00479 put_bits(pb, esc_len, i - 1);
00480 }
00481 }
00482
00486 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00487 int v;
00488
00489 v = -2*i-1;
00490 v ^= (v>>31);
00491
00492 set_ur_golomb(pb, v, k, limit, esc_len);
00493 }
00494
00498 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){
00499 int v;
00500
00501 v = -2*i-1;
00502 v ^= (v>>31);
00503
00504 set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
00505 }
00506
00507 #endif