dd8118d6a265ff1204c2884fe5790d35f7d033fb
[x262.git] / common / bitstream.h
1 /*****************************************************************************
2  * bitstream.h: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003-2008 x264 project
5  *
6  * Authors: Loren Merritt <lorenm@u.washington.edu>
7  *          Jason Garrett-Glaser <darkshikari@gmail.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 typedef struct
67 {
68     uint8_t *(*nal_escape) ( uint8_t *dst, uint8_t *src, uint8_t *end );
69 } x264_bitstream_function_t;
70
71 void x264_bitstream_init( int cpu, x264_bitstream_function_t *pf );
72
73 /* A larger level table size theoretically could help a bit at extremely
74  * high bitrates, but the cost in cache is usually too high for it to be
75  * useful.
76  * This size appears to be optimal for QP18 encoding on a Nehalem CPU.
77  * FIXME: Do further testing? */
78 #define LEVEL_TABLE_SIZE 128
79 extern vlc_large_t x264_level_token[7][LEVEL_TABLE_SIZE];
80
81 static inline void bs_init( bs_t *s, void *p_data, int i_data )
82 {
83     int offset = ((intptr_t)p_data & 3);
84     s->p       = s->p_start = (uint8_t*)p_data - offset;
85     s->p_end   = (uint8_t*)p_data + i_data;
86     s->i_left  = (WORD_SIZE - offset)*8;
87     s->cur_bits = endian_fix32( M32(s->p) );
88     s->cur_bits >>= (4-offset)*8;
89 }
90 static inline int bs_pos( bs_t *s )
91 {
92     return( 8 * (s->p - s->p_start) + (WORD_SIZE*8) - s->i_left );
93 }
94
95 /* Write the rest of cur_bits to the bitstream; results in a bitstream no longer 32-bit aligned. */
96 static inline void bs_flush( bs_t *s )
97 {
98     M32( s->p ) = endian_fix32( s->cur_bits << (s->i_left&31) );
99     s->p += WORD_SIZE - (s->i_left >> 3);
100     s->i_left = WORD_SIZE*8;
101 }
102 /* The inverse of bs_flush: prepare the bitstream to be written to again. */
103 static inline void bs_realign( bs_t *s )
104 {
105     int offset = ((intptr_t)s->p & 3);
106     if( offset )
107     {
108         s->p       = (uint8_t*)s->p - offset;
109         s->i_left  = (WORD_SIZE - offset)*8;
110         s->cur_bits = endian_fix32( M32(s->p) );
111         s->cur_bits >>= (4-offset)*8;
112     }
113 }
114
115 static inline void bs_write( bs_t *s, int i_count, uint32_t i_bits )
116 {
117     if( WORD_SIZE == 8 )
118     {
119         s->cur_bits = (s->cur_bits << i_count) | i_bits;
120         s->i_left -= i_count;
121         if( s->i_left <= 32 )
122         {
123 #if WORDS_BIGENDIAN
124             M32( s->p ) = s->cur_bits >> (32 - s->i_left);
125 #else
126             M32( s->p ) = endian_fix( s->cur_bits << s->i_left );
127 #endif
128             s->i_left += 32;
129             s->p += 4;
130         }
131     }
132     else
133     {
134         if( i_count < s->i_left )
135         {
136             s->cur_bits = (s->cur_bits << i_count) | i_bits;
137             s->i_left -= i_count;
138         }
139         else
140         {
141             i_count -= s->i_left;
142             s->cur_bits = (s->cur_bits << s->i_left) | (i_bits >> i_count);
143             M32( s->p ) = endian_fix( s->cur_bits );
144             s->p += 4;
145             s->cur_bits = i_bits;
146             s->i_left = 32 - i_count;
147         }
148     }
149 }
150
151 /* Special case to eliminate branch in normal bs_write. */
152 /* Golomb never writes an even-size code, so this is only used in slice headers. */
153 static inline void bs_write32( bs_t *s, uint32_t i_bits )
154 {
155     bs_write( s, 16, i_bits >> 16 );
156     bs_write( s, 16, i_bits );
157 }
158
159 static inline void bs_write1( bs_t *s, uint32_t i_bit )
160 {
161     s->cur_bits <<= 1;
162     s->cur_bits |= i_bit;
163     s->i_left--;
164     if( s->i_left == WORD_SIZE*8-32 )
165     {
166         M32( s->p ) = endian_fix32( s->cur_bits );
167         s->p += 4;
168         s->i_left = WORD_SIZE*8;
169     }
170 }
171
172 static inline void bs_align_0( bs_t *s )
173 {
174     bs_write( s, s->i_left&7, 0 );
175     bs_flush( s );
176 }
177 static inline void bs_align_1( bs_t *s )
178 {
179     bs_write( s, s->i_left&7, (1 << (s->i_left&7)) - 1 );
180     bs_flush( s );
181 }
182 static inline void bs_align_10( bs_t *s )
183 {
184     if( s->i_left&7 )
185         bs_write( s, s->i_left&7, 1 << ( (s->i_left&7) - 1 ) );
186 }
187
188 /* golomb functions */
189
190 static const uint8_t x264_ue_size_tab[256] =
191 {
192      1, 1, 3, 3, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7,
193      9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
194     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
195     11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
196     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
197     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
198     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
199     13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
200     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
201     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
202     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
203     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
204     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
205     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
206     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
207     15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
208 };
209
210 static inline void bs_write_ue_big( bs_t *s, unsigned int val )
211 {
212     int size = 0;
213     int tmp = ++val;
214     if( tmp >= 0x10000 )
215     {
216         size = 32;
217         tmp >>= 16;
218     }
219     if( tmp >= 0x100 )
220     {
221         size += 16;
222         tmp >>= 8;
223     }
224     size += x264_ue_size_tab[tmp];
225     bs_write( s, size>>1, 0 );
226     bs_write( s, (size>>1)+1, val );
227 }
228
229 /* Only works on values under 255. */
230 static inline void bs_write_ue( bs_t *s, int val )
231 {
232     bs_write( s, x264_ue_size_tab[val+1], val+1 );
233 }
234
235 static inline void bs_write_se( bs_t *s, int val )
236 {
237     int size = 0;
238     /* Faster than (val <= 0 ? -val*2+1 : val*2) */
239     /* 4 instructions on x86, 3 on ARM */
240     int tmp = 1 - val*2;
241     if( tmp < 0 ) tmp = val*2;
242     val = tmp;
243
244     if( tmp >= 0x100 )
245     {
246         size = 16;
247         tmp >>= 8;
248     }
249     size += x264_ue_size_tab[tmp];
250     bs_write( s, size, val );
251 }
252
253 static inline void bs_write_te( bs_t *s, int x, int val )
254 {
255     if( x == 1 )
256         bs_write1( s, 1^val );
257     else //if( x > 1 )
258         bs_write_ue( s, val );
259 }
260
261 static inline void bs_rbsp_trailing( bs_t *s )
262 {
263     bs_write1( s, 1 );
264     bs_write( s, s->i_left&7, 0  );
265 }
266
267 static ALWAYS_INLINE int bs_size_ue( unsigned int val )
268 {
269     return x264_ue_size_tab[val+1];
270 }
271
272 static ALWAYS_INLINE int bs_size_ue_big( unsigned int val )
273 {
274     if( val < 255 )
275         return x264_ue_size_tab[val+1];
276     else
277         return x264_ue_size_tab[(val+1)>>8] + 16;
278 }
279
280 static ALWAYS_INLINE int bs_size_se( int val )
281 {
282     int tmp = 1 - val*2;
283     if( tmp < 0 ) tmp = val*2;
284     if( tmp < 256 )
285         return x264_ue_size_tab[tmp];
286     else
287         return x264_ue_size_tab[tmp>>8]+16;
288 }
289
290 static ALWAYS_INLINE int bs_size_te( int x, int val )
291 {
292     if( x == 1 )
293         return 1;
294     else //if( x > 1 )
295         return x264_ue_size_tab[val+1];
296 }
297
298 #endif