Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/golomb.h Source File

00001 /*
00002  * exp golomb vlc stuff
00003  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00004  * Copyright (c) 2004 Alex Beregszaszi
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2 of the License, or (at your option) any later version.
00010  *
00011  * This library is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with this library; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  *
00020  */
00021  
00029 #define INVALID_VLC           0x80000000
00030 
00031 extern const uint8_t ff_golomb_vlc_len[512];
00032 extern const uint8_t ff_ue_golomb_vlc_code[512];
00033 extern const  int8_t ff_se_golomb_vlc_code[512];
00034 extern const uint8_t ff_ue_golomb_len[256];
00035 
00036 extern const uint8_t ff_interleaved_golomb_vlc_len[256];
00037 extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
00038 extern const  int8_t ff_interleaved_se_golomb_vlc_code[256];
00039 
00040  
00044 static inline int get_ue_golomb(GetBitContext *gb){
00045     unsigned int buf;
00046     int log;
00047     
00048     OPEN_READER(re, gb);
00049     UPDATE_CACHE(re, gb);
00050     buf=GET_CACHE(re, gb);
00051     
00052     if(buf >= (1<<27)){
00053         buf >>= 32 - 9;
00054         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00055         CLOSE_READER(re, gb);
00056     
00057         return ff_ue_golomb_vlc_code[buf];
00058     }else{
00059         log= 2*av_log2(buf) - 31;
00060         buf>>= log;
00061         buf--;
00062         LAST_SKIP_BITS(re, gb, 32 - log);
00063         CLOSE_READER(re, gb);
00064     
00065         return buf;
00066     }
00067 }
00068 
00069 static inline int svq3_get_ue_golomb(GetBitContext *gb){
00070     uint32_t buf;
00071     int log;
00072 
00073     OPEN_READER(re, gb);
00074     UPDATE_CACHE(re, gb);
00075     buf=GET_CACHE(re, gb);
00076     
00077     if(buf&0xAA800000){
00078         buf >>= 32 - 8;
00079         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00080         CLOSE_READER(re, gb);
00081         
00082         return ff_interleaved_ue_golomb_vlc_code[buf];
00083     }else{
00084         LAST_SKIP_BITS(re, gb, 8);
00085         UPDATE_CACHE(re, gb);
00086         buf |= 1 | (GET_CACHE(re, gb) >> 8);
00087 
00088         if((buf & 0xAAAAAAAA) == 0)
00089             return INVALID_VLC;
00090 
00091         for(log=31; (buf & 0x80000000) == 0; log--){
00092             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
00093         }
00094 
00095         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
00096         CLOSE_READER(re, gb);
00097 
00098         return ((buf << log) >> log) - 1;
00099     }
00100 }
00101 
00105 static inline int get_te0_golomb(GetBitContext *gb, int range){
00106     assert(range >= 1);
00107     
00108     if(range==1)      return 0;
00109     else if(range==2) return get_bits1(gb)^1;
00110     else              return get_ue_golomb(gb);
00111 }
00112 
00116 static inline int get_te_golomb(GetBitContext *gb, int range){
00117     assert(range >= 1);
00118     
00119     if(range==2) return get_bits1(gb)^1;
00120     else         return get_ue_golomb(gb);
00121 }
00122 
00123 
00127 static inline int get_se_golomb(GetBitContext *gb){
00128     unsigned int buf;
00129     int log;
00130     
00131     OPEN_READER(re, gb);
00132     UPDATE_CACHE(re, gb);
00133     buf=GET_CACHE(re, gb);
00134     
00135     if(buf >= (1<<27)){
00136         buf >>= 32 - 9;
00137         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
00138         CLOSE_READER(re, gb);
00139     
00140         return ff_se_golomb_vlc_code[buf];
00141     }else{
00142         log= 2*av_log2(buf) - 31;
00143         buf>>= log;
00144         
00145         LAST_SKIP_BITS(re, gb, 32 - log);
00146         CLOSE_READER(re, gb);
00147     
00148         if(buf&1) buf= -(buf>>1);
00149         else      buf=  (buf>>1);
00150 
00151         return buf;
00152     }
00153 }
00154 
00155 static inline int svq3_get_se_golomb(GetBitContext *gb){
00156     unsigned int buf;
00157     int log;
00158 
00159     OPEN_READER(re, gb);
00160     UPDATE_CACHE(re, gb);
00161     buf=GET_CACHE(re, gb);
00162 
00163     if(buf&0xAA800000){
00164         buf >>= 32 - 8;
00165         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
00166         CLOSE_READER(re, gb);
00167         
00168         return ff_interleaved_se_golomb_vlc_code[buf];
00169     }else{
00170         LAST_SKIP_BITS(re, gb, 8);
00171         UPDATE_CACHE(re, gb);
00172         buf |= 1 | (GET_CACHE(re, gb) >> 8);
00173 
00174         if((buf & 0xAAAAAAAA) == 0)
00175             return INVALID_VLC;
00176 
00177         for(log=31; (buf & 0x80000000) == 0; log--){
00178             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
00179         }
00180 
00181         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
00182         CLOSE_READER(re, gb);
00183 
00184         return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
00185     }
00186 }
00187 
00191 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00192     unsigned int buf;
00193     int log;
00194     
00195     OPEN_READER(re, gb);
00196     UPDATE_CACHE(re, gb);
00197     buf=GET_CACHE(re, gb);
00198 
00199     log= av_log2(buf);
00200 
00201     if(log > 31-limit){
00202         buf >>= log - k;
00203         buf += (30-log)<<k;
00204         LAST_SKIP_BITS(re, gb, 32 + k - log);
00205         CLOSE_READER(re, gb);
00206     
00207         return buf;
00208     }else{
00209         buf >>= 32 - limit - esc_len;
00210         LAST_SKIP_BITS(re, gb, esc_len + limit);
00211         CLOSE_READER(re, gb);
00212     
00213         return buf + limit - 1;
00214     }
00215 }
00216 
00220 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){
00221     unsigned int buf;
00222     int log;
00223     
00224     OPEN_READER(re, gb);
00225     UPDATE_CACHE(re, gb);
00226     buf=GET_CACHE(re, gb);
00227 
00228     log= av_log2(buf);
00229     
00230     if(log > 31-11){
00231         buf >>= log - k;
00232         buf += (30-log)<<k;
00233         LAST_SKIP_BITS(re, gb, 32 + k - log);
00234         CLOSE_READER(re, gb);
00235     
00236         return buf;
00237     }else{
00238         int i;
00239         for(i=0; SHOW_UBITS(re, gb, 1) == 0; i++){
00240             LAST_SKIP_BITS(re, gb, 1);
00241             UPDATE_CACHE(re, gb);
00242         }
00243         SKIP_BITS(re, gb, 1);
00244 
00245         if(i < limit - 1){
00246             if(k){
00247                 buf = SHOW_UBITS(re, gb, k);
00248                 LAST_SKIP_BITS(re, gb, k);
00249             }else{
00250                 buf=0;
00251             }
00252 
00253             CLOSE_READER(re, gb);
00254             return buf + (i<<k);
00255         }else if(i == limit - 1){
00256             buf = SHOW_UBITS(re, gb, esc_len);
00257             LAST_SKIP_BITS(re, gb, esc_len);
00258             CLOSE_READER(re, gb);
00259     
00260             return buf + 1;
00261         }else
00262             return -1;
00263     }
00264 }
00265 
00269 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){
00270     int v= get_ur_golomb(gb, k, limit, esc_len);
00271     
00272     v++;
00273     if (v&1) return v>>1;
00274     else return -(v>>1);
00275     
00276 //    return (v>>1) ^ -(v&1);
00277 }
00278 
00282 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){
00283     int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);
00284     return (v>>1) ^ -(v&1);
00285 }
00286 
00290 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){
00291         return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
00292 }
00293 
00297 static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
00298 {
00299     int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
00300     if (uvar & 1)
00301         return ~(uvar >> 1);
00302     else
00303         return uvar >> 1;
00304 }
00305 
00306 
00307 
00308 #ifdef TRACE
00309 
00310 static inline int get_ue(GetBitContext *s, char *file, const char *func, int line){
00311     int show= show_bits(s, 24);
00312     int pos= get_bits_count(s);
00313     int i= get_ue_golomb(s);
00314     int len= get_bits_count(s) - pos;
00315     int bits= show>>(24-len);
00316     
00317     print_bin(bits, len);
00318     
00319     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00320     
00321     return i;
00322 }
00323 
00324 static inline int get_se(GetBitContext *s, char *file, const char *func, int line){
00325     int show= show_bits(s, 24);
00326     int pos= get_bits_count(s);
00327     int i= get_se_golomb(s);
00328     int len= get_bits_count(s) - pos;
00329     int bits= show>>(24-len);
00330     
00331     print_bin(bits, len);
00332     
00333     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00334     
00335     return i;
00336 }
00337 
00338 static inline int get_te(GetBitContext *s, int r, 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_te0_golomb(s, r);
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 te  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);
00348     
00349     return i;
00350 }
00351 
00352 #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00353 #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00354 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00355 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
00356 
00357 #endif
00358 
00362 static inline void set_ue_golomb(PutBitContext *pb, int i){
00363     int e;
00364     
00365     assert(i>=0);
00366 
00367 #if 0
00368     if(i=0){
00369         put_bits(pb, 1, 1);
00370         return;
00371     }
00372 #endif
00373     if(i<256)
00374         put_bits(pb, ff_ue_golomb_len[i], i+1);
00375     else{
00376         e= av_log2(i+1);
00377     
00378         put_bits(pb, 2*e+1, i+1);
00379     }
00380 }
00381 
00385 static inline void set_te_golomb(PutBitContext *pb, int i, int range){
00386     assert(range >= 1);
00387     assert(i<=range);
00388 
00389     if(range==2) put_bits(pb, 1, i^1);
00390     else         set_ue_golomb(pb, i);
00391 }
00392 
00396 static inline void set_se_golomb(PutBitContext *pb, int i){
00397 #if 0 
00398     if(i<=0) i= -2*i;
00399     else     i=  2*i-1;
00400 #elif 1
00401     i= 2*i-1;
00402     if(i<0) i^= -1; //FIXME check if gcc does the right thing
00403 #else
00404     i= 2*i-1;
00405     i^= (i>>31);
00406 #endif
00407     set_ue_golomb(pb, i);
00408 }
00409 
00413 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00414     int e;
00415     
00416     assert(i>=0);
00417     
00418     e= i>>k;
00419     if(e<limit){
00420         put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));
00421     }else{
00422         put_bits(pb, limit + esc_len, i - limit + 1);
00423     }
00424 }
00425 
00429 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){
00430     int e;
00431     
00432     assert(i>=0);
00433     
00434     e= (i>>k) + 1;
00435     if(e<limit){
00436         put_bits(pb, e, 1);
00437         if(k)
00438             put_bits(pb, k, i&((1<<k)-1));
00439     }else{
00440         put_bits(pb, limit  , 1);
00441         put_bits(pb, esc_len, i - 1);
00442     }
00443 }
00444 
00448 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
00449     int v;
00450 
00451     v = -2*i-1;
00452     v ^= (v>>31);
00453 
00454     set_ur_golomb(pb, v, k, limit, esc_len);
00455 }
00456 
00460 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){
00461     int v;
00462 
00463     v = -2*i-1;
00464     v ^= (v>>31);
00465 
00466     set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
00467 }