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(*(uint32_t *)(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     *(uint32_t*)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
  96 static inline void bs_write( bs_t *s, int i_count, uint32_t i_bits )
  97 {
  98     if( WORD_SIZE == 8 )
  99     {
 100         s->cur_bits = (s->cur_bits << i_count) | i_bits;
 101         s->i_left -= i_count;
 102         if( s->i_left <= 32 )
 103         {
 104 #ifdef WORDS_BIGENDIAN
 105             *(uint32_t*)s->p = s->cur_bits >> (32 - s->i_left);
 106 #else
 107             *(uint32_t*)s->p = endian_fix( s->cur_bits << s->i_left );
 108 #endif
 109             s->i_left += 32;
 110             s->p += 4;
 111         }
 112     }
 113     else
 114     {
 115         if( i_count < s->i_left )
 116         {
 117             s->cur_bits = (s->cur_bits << i_count) | i_bits;
 118             s->i_left -= i_count;
 119         }
 120         else
 121         {
 122             i_count -= s->i_left;
 123             s->cur_bits = (s->cur_bits << s->i_left) | (i_bits >> i_count);
 124             *(uint32_t*)s->p = endian_fix( s->cur_bits );
 125             s->p += 4;
 126             s->cur_bits = i_bits;
 127             s->i_left = 32 - i_count;
 128         }
 129     }
 130 }
 131
 132 /* Special case to eliminate branch in normal bs_write. */
 133 /* Golomb never writes an even-size code, so this is only used in slice headers. */
 134 static inline void bs_write32( bs_t *s, uint32_t i_bits )
 135 {
 136     bs_write( s, 16, i_bits >> 16 );
 137     bs_write( s, 16, i_bits );
 138 }
 139
 140 static inline void bs_write1( bs_t *s, uint32_t i_bit )
 141 {
 142     s->cur_bits <<= 1;
 143     s->cur_bits |= i_bit;
 144     s->i_left--;
 145     if( s->i_left == WORD_SIZE*8-32 )
 146     {
 147         *(uint32_t*)s->p = endian_fix32( s->cur_bits );
 148         s->p += 4;
 149         s->i_left = WORD_SIZE*8;
 150     }
 151 }
 152
 153 static inline void bs_align_0( bs_t *s )
 154 {
 155     bs_write( s, s->i_left&7, 0 );
 156     bs_flush( s );
 157 }
 158 static inline void bs_align_1( bs_t *s )
 159 {
 160     bs_write( s, s->i_left&7, (1 << (s->i_left&7)) - 1 );
 161     bs_flush( s );
 162 }
 163
 164 /* golomb functions */
 165
 166 static const uint8_t x264_ue_size_tab[256] =
 167 {
 168      1, 1, 3, 3, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7,
 169      9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
 170     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
 171     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
 172     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 173     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 174     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 175     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
 176     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 177     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 178     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 179     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 180     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 181     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 182     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 183     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
 184 };
 185
 186 static inline void bs_write_ue_big( bs_t *s, unsigned int val )
 187 {
 188     int size = 0;
 189     int tmp = ++val;
 190     if( tmp >= 0x10000 )
 191     {
 192         size = 32;
 193         tmp >>= 16;
 194     }
 195     if( tmp >= 0x100 )
 196     {
 197         size += 16;
 198         tmp >>= 8;
 199     }
 200     size += x264_ue_size_tab[tmp];
 201     bs_write( s, size>>1, 0 );
 202     bs_write( s, (size>>1)+1, val );
 203 }
 204
 205 /* Only works on values under 255. */
 206 static inline void bs_write_ue( bs_t *s, int val )
 207 {
 208     bs_write( s, x264_ue_size_tab[val+1], val+1 );
 209 }
 210
 211 static inline void bs_write_se( bs_t *s, int val )
 212 {
 213     int size = 0;
 214     /* Faster than (val <= 0 ? -val*2+1 : val*2) */
 215     /* 4 instructions on x86, 3 on ARM */
 216     int tmp = 1 - val*2;
 217     if( tmp < 0 ) tmp = val*2;
 218     val = tmp;
 219
 220     if( tmp >= 0x100 )
 221     {
 222         size = 16;
 223         tmp >>= 8;
 224     }
 225     size += x264_ue_size_tab[tmp];
 226     bs_write( s, size, val );
 227 }
 228
 229 static inline void bs_write_te( bs_t *s, int x, int val )
 230 {
 231     if( x == 1 )
 232         bs_write1( s, 1^val );
 233     else //if( x > 1 )
 234         bs_write_ue( s, val );
 235 }
 236
 237 static inline void bs_rbsp_trailing( bs_t *s )
 238 {
 239     bs_write1( s, 1 );
 240     bs_write( s, s->i_left&7, 0  );
 241 }
 242
 243 static inline int bs_size_ue( unsigned int val )
 244 {
 245     return x264_ue_size_tab[val+1];
 246 }
 247
 248 static inline int bs_size_ue_big( unsigned int val )
 249 {
 250     if( val < 255 )
 251         return x264_ue_size_tab[val+1];
 252     else
 253         return x264_ue_size_tab[(val+1)>>8] + 16;
 254 }
 255
 256 static inline int bs_size_se( int val )
 257 {
 258     int tmp = 1 - val*2;
 259     if( tmp < 0 ) tmp = val*2;
 260     if( tmp < 256 )
 261         return x264_ue_size_tab[tmp];
 262     else
 263         return x264_ue_size_tab[tmp>>8]+16;
 264 }
 265
 266 static inline int bs_size_te( int x, int val )
 267 {
 268     if( x == 1 )
 269         return 1;
 270     else //if( x > 1 )
 271         return x264_ue_size_tab[val+1];
 272 }
 273
 274 #endif