git.sesse.net Git - x264/blob - common/bs.h

   1 /*****************************************************************************
   2  * bs.h :
   3  *****************************************************************************
   4  * Copyright (C) 2003-2008 x264 project
   5  *
   6  * Authors: Loren Merritt <lorenm@u.washington.edu>
   7  *          Fiona Glaser <fiona@x264.com>
   8  *          Laurent Aimar <fenrir@via.ecp.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #ifndef X264_BS_H
  26 #define X264_BS_H
  27
  28 typedef struct
  29 {
  30     uint8_t i_bits;
  31     uint8_t i_size;
  32 } vlc_t;
  33
  34 typedef struct
  35 {
  36     uint16_t i_bits;
  37     uint8_t  i_size;
  38     /* Next level table to use */
  39     uint8_t  i_next;
  40 } vlc_large_t;
  41
  42 typedef struct bs_s
  43 {
  44     uint8_t *p_start;
  45     uint8_t *p;
  46     uint8_t *p_end;
  47
  48     intptr_t cur_bits;
  49     int     i_left;    /* i_count number of available bits */
  50     int     i_bits_encoded; /* RD only */
  51 } bs_t;
  52
  53 typedef struct
  54 {
  55     int     last;
  56     int16_t level[16];
  57     uint8_t run[16];
  58 } x264_run_level_t;
  59
  60 extern const vlc_t x264_coeff0_token[5];
  61 extern const vlc_t x264_coeff_token[5][16][4];
  62 extern const vlc_t x264_total_zeros[15][16];
  63 extern const vlc_t x264_total_zeros_dc[3][4];
  64 extern const vlc_t x264_run_before[7][16];
  65
  66 /* A larger level table size theoretically could help a bit at extremely
  67  * high bitrates, but the cost in cache is usually too high for it to be
  68  * useful.
  69  * This size appears to be optimal for QP18 encoding on a Nehalem CPU.
  70  * FIXME: Do further testing? */
  71 #define LEVEL_TABLE_SIZE 128
  72 extern vlc_large_t x264_level_token[7][LEVEL_TABLE_SIZE];
  73
  74 static inline void bs_init( bs_t *s, void *p_data, int i_data )
  75 {
  76     int offset = ((intptr_t)p_data & 3);
  77     s->p       = s->p_start = (uint8_t*)p_data - offset;
  78     s->p_end   = (uint8_t*)p_data + i_data;
  79     s->i_left  = (WORD_SIZE - offset)*8;
  80     s->cur_bits = endian_fix32( M32(s->p) );
  81     s->cur_bits >>= (4-offset)*8;
  82 }
  83 static inline int bs_pos( bs_t *s )
  84 {
  85     return( 8 * (s->p - s->p_start) + (WORD_SIZE*8) - s->i_left );
  86 }
  87
  88 /* Write the rest of cur_bits to the bitstream; results in a bitstream no longer 32-bit aligned. */
  89 static inline void bs_flush( bs_t *s )
  90 {
  91     M32( s->p ) = endian_fix32( s->cur_bits << (s->i_left&31) );
  92     s->p += WORD_SIZE - s->i_left / 8;
  93     s->i_left = WORD_SIZE*8;
  94 }
  95 /* The inverse of bs_flush: prepare the bitstream to be written to again. */
  96 static inline void bs_realign( bs_t *s )
  97 {
  98     int offset = ((intptr_t)s->p & 3);
  99     if( offset )
 100     {
 101         s->p       = (uint8_t*)s->p - offset;
 102         s->i_left  = (WORD_SIZE - offset)*8;
 103         s->cur_bits = endian_fix32( M32(s->p) );
 104         s->cur_bits >>= (4-offset)*8;
 105     }
 106 }
 107
 108 static inline void bs_write( bs_t *s, int i_count, uint32_t i_bits )
 109 {
 110     if( WORD_SIZE == 8 )
 111     {
 112         s->cur_bits = (s->cur_bits << i_count) | i_bits;
 113         s->i_left -= i_count;
 114         if( s->i_left <= 32 )
 115         {
 116 #ifdef WORDS_BIGENDIAN
 117             M32( s->p ) = s->cur_bits >> (32 - s->i_left);
 118 #else
 119             M32( s->p ) = endian_fix( s->cur_bits << s->i_left );
 120 #endif
 121             s->i_left += 32;
 122             s->p += 4;
 123         }
 124     }
 125     else
 126     {
 127         if( i_count < s->i_left )
 128         {
 129             s->cur_bits = (s->cur_bits << i_count) | i_bits;
 130             s->i_left -= i_count;
 131         }
 132         else
 133         {
 134             i_count -= s->i_left;
 135             s->cur_bits = (s->cur_bits << s->i_left) | (i_bits >> i_count);
 136             M32( s->p ) = endian_fix( s->cur_bits );
 137             s->p += 4;
 138             s->cur_bits = i_bits;
 139             s->i_left = 32 - i_count;
 140         }
 141     }
 142 }
 143
 144 /* Special case to eliminate branch in normal bs_write. */
 145 /* Golomb never writes an even-size code, so this is only used in slice headers. */
 146 static inline void bs_write32( bs_t *s, uint32_t i_bits )
 147 {
 148     bs_write( s, 16, i_bits >> 16 );
 149     bs_write( s, 16, i_bits );
 150 }
 151
 152 static inline void bs_write1( bs_t *s, uint32_t i_bit )
 153 {
 154     s->cur_bits <<= 1;
 155     s->cur_bits |= i_bit;
 156     s->i_left--;
 157     if( s->i_left == WORD_SIZE*8-32 )
 158     {
 159         M32( s->p ) = endian_fix32( s->cur_bits );
 160         s->p += 4;
 161         s->i_left = WORD_SIZE*8;
 162     }
 163 }
 164
 165 static inline void bs_align_0( bs_t *s )
 166 {
 167     bs_write( s, s->i_left&7, 0 );
 168     bs_flush( s );
 169 }
 170 static inline void bs_align_1( bs_t *s )
 171 {
 172     bs_write( s, s->i_left&7, (1 << (s->i_left&7)) - 1 );
 173     bs_flush( s );
 174 }
 175 static inline void bs_align_10( bs_t *s )
 176 {
 177     if( s->i_left&7 )
 178         bs_write( s, s->i_left&7, 1 << ( (s->i_left&7) - 1 ) );
 179 }
 180
 181 /* golomb functions */
 182
 183 static const uint8_t x264_ue_size_tab[256] =
 184 {
 185      1, 1, 3, 3, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7,
 186      9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
 187     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
 188     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
 189     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 190     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 191     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 192     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 193     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 194     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 195     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 196     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 197     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 198     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 199     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 200     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 201 };
 202
 203 static inline void bs_write_ue_big( bs_t *s, unsigned int val )
 204 {
 205     int size = 0;
 206     int tmp = ++val;
 207     if( tmp >= 0x10000 )
 208     {
 209         size = 32;
 210         tmp >>= 16;
 211     }
 212     if( tmp >= 0x100 )
 213     {
 214         size += 16;
 215         tmp >>= 8;
 216     }
 217     size += x264_ue_size_tab[tmp];
 218     bs_write( s, size>>1, 0 );
 219     bs_write( s, (size>>1)+1, val );
 220 }
 221
 222 /* Only works on values under 255. */
 223 static inline void bs_write_ue( bs_t *s, int val )
 224 {
 225     bs_write( s, x264_ue_size_tab[val+1], val+1 );
 226 }
 227
 228 static inline void bs_write_se( bs_t *s, int val )
 229 {
 230     int size = 0;
 231     /* Faster than (val <= 0 ? -val*2+1 : val*2) */
 232     /* 4 instructions on x86, 3 on ARM */
 233     int tmp = 1 - val*2;
 234     if( tmp < 0 ) tmp = val*2;
 235     val = tmp;
 236
 237     if( tmp >= 0x100 )
 238     {
 239         size = 16;
 240         tmp >>= 8;
 241     }
 242     size += x264_ue_size_tab[tmp];
 243     bs_write( s, size, val );
 244 }
 245
 246 static inline void bs_write_te( bs_t *s, int x, int val )
 247 {
 248     if( x == 1 )
 249         bs_write1( s, 1^val );
 250     else //if( x > 1 )
 251         bs_write_ue( s, val );
 252 }
 253
 254 static inline void bs_rbsp_trailing( bs_t *s )
 255 {
 256     bs_write1( s, 1 );
 257     bs_write( s, s->i_left&7, 0  );
 258 }
 259
 260 static ALWAYS_INLINE int bs_size_ue( unsigned int val )
 261 {
 262     return x264_ue_size_tab[val+1];
 263 }
 264
 265 static ALWAYS_INLINE int bs_size_ue_big( unsigned int val )
 266 {
 267     if( val < 255 )
 268         return x264_ue_size_tab[val+1];
 269     else
 270         return x264_ue_size_tab[(val+1)>>8] + 16;
 271 }
 272
 273 static ALWAYS_INLINE int bs_size_se( int val )
 274 {
 275     int tmp = 1 - val*2;
 276     if( tmp < 0 ) tmp = val*2;
 277     if( tmp < 256 )
 278         return x264_ue_size_tab[tmp];
 279     else
 280         return x264_ue_size_tab[tmp>>8]+16;
 281 }
 282
 283 static ALWAYS_INLINE int bs_size_te( int x, int val )
 284 {
 285     if( x == 1 )
 286         return 1;
 287     else //if( x > 1 )
 288         return x264_ue_size_tab[val+1];
 289 }
 290
 291 #endif