Mercurial > libavcodec.hg
annotate cabac.h @ 1560:07dac732074a libavcodec
10l
author | alex |
---|---|
date | Wed, 22 Oct 2003 22:12:25 +0000 |
parents | 9d02a1859891 |
children | 752b51a3c8ed |
rev | line source |
---|---|
1287 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
5 * This library is free software; you can redistribute it and/or | |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
9 * | |
10 * This library is distributed in the hope that it will be useful, | |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 * Lesser General Public License for more details. | |
14 * | |
15 * You should have received a copy of the GNU Lesser General Public | |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 * | |
19 */ | |
20 | |
21 /** | |
22 * @file cabac.h | |
23 * Context Adaptive Binary Arithmetic Coder. | |
24 */ | |
25 | |
26 | |
27 #undef NDEBUG | |
28 #include <assert.h> | |
29 | |
30 typedef struct CABACContext{ | |
31 int low; | |
32 int range; | |
33 int outstanding_count; | |
34 #ifdef STRICT_LIMITS | |
35 int symCount; | |
36 #endif | |
37 uint8_t lps_range[2*64][4]; ///< rangeTabLPS | |
38 uint8_t lps_state[2*64]; ///< transIdxLPS | |
39 uint8_t mps_state[2*64]; ///< transIdxMPS | |
1300
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
40 uint8_t *bytestream_start; |
1287 | 41 uint8_t *bytestream; |
42 int bits_left; ///< | |
43 PutBitContext pb; | |
44 }CABACContext; | |
45 | |
1301 | 46 extern const uint8_t ff_h264_lps_range[64][4]; |
47 extern const uint8_t ff_h264_mps_state[64]; | |
48 extern const uint8_t ff_h264_lps_state[64]; | |
1287 | 49 |
50 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size); | |
51 void ff_init_cabac_decoder(CABACContext *c, uint8_t *buf, int buf_size); | |
52 void ff_init_cabac_states(CABACContext *c, uint8_t const (*lps_range)[4], | |
53 uint8_t const *mps_state, uint8_t const *lps_state, int state_count); | |
54 | |
55 | |
56 static inline void put_cabac_bit(CABACContext *c, int b){ | |
57 put_bits(&c->pb, 1, b); | |
58 for(;c->outstanding_count; c->outstanding_count--){ | |
59 put_bits(&c->pb, 1, 1-b); | |
60 } | |
61 } | |
62 | |
63 static inline void renorm_cabac_encoder(CABACContext *c){ | |
64 while(c->range < 0x100){ | |
65 //FIXME optimize | |
66 if(c->low<0x100){ | |
67 put_cabac_bit(c, 0); | |
68 }else if(c->low<0x200){ | |
69 c->outstanding_count++; | |
70 c->low -= 0x100; | |
71 }else{ | |
72 put_cabac_bit(c, 1); | |
73 c->low -= 0x200; | |
74 } | |
75 | |
76 c->range+= c->range; | |
77 c->low += c->low; | |
78 } | |
79 } | |
80 | |
81 static inline void put_cabac(CABACContext *c, uint8_t * const state, int bit){ | |
82 int RangeLPS= c->lps_range[*state][((c->range)>>6)&3]; | |
83 | |
84 if(bit == ((*state)&1)){ | |
85 c->range -= RangeLPS; | |
86 *state= c->mps_state[*state]; | |
87 }else{ | |
88 c->low += c->range - RangeLPS; | |
89 c->range = RangeLPS; | |
90 *state= c->lps_state[*state]; | |
91 } | |
92 | |
93 renorm_cabac_encoder(c); | |
94 | |
95 #ifdef STRICT_LIMITS | |
96 c->symCount++; | |
97 #endif | |
98 } | |
99 | |
100 static inline void put_cabac_static(CABACContext *c, int RangeLPS, int bit){ | |
101 assert(c->range > RangeLPS); | |
102 | |
103 if(!bit){ | |
104 c->range -= RangeLPS; | |
105 }else{ | |
106 c->low += c->range - RangeLPS; | |
107 c->range = RangeLPS; | |
108 } | |
109 | |
110 renorm_cabac_encoder(c); | |
111 | |
112 #ifdef STRICT_LIMITS | |
113 c->symCount++; | |
114 #endif | |
115 } | |
116 | |
1290 | 117 /** |
118 * @param bit 0 -> write zero bit, !=0 write one bit | |
119 */ | |
1287 | 120 static inline void put_cabac_bypass(CABACContext *c, int bit){ |
121 c->low += c->low; | |
122 | |
123 if(bit){ | |
124 c->low += c->range; | |
125 } | |
126 //FIXME optimize | |
127 if(c->low<0x200){ | |
128 put_cabac_bit(c, 0); | |
129 }else if(c->low<0x400){ | |
130 c->outstanding_count++; | |
131 c->low -= 0x200; | |
132 }else{ | |
133 put_cabac_bit(c, 1); | |
134 c->low -= 0x400; | |
135 } | |
136 | |
137 #ifdef STRICT_LIMITS | |
138 c->symCount++; | |
139 #endif | |
140 } | |
141 | |
1300
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
142 /** |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
143 * |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
144 * @return the number of bytes written |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
145 */ |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
146 static inline int put_cabac_terminate(CABACContext *c, int bit){ |
1287 | 147 c->range -= 2; |
148 | |
149 if(!bit){ | |
150 renorm_cabac_encoder(c); | |
151 }else{ | |
152 c->low += c->range; | |
153 c->range= 2; | |
154 | |
155 renorm_cabac_encoder(c); | |
156 | |
157 assert(c->low <= 0x1FF); | |
158 put_cabac_bit(c, c->low>>9); | |
159 put_bits(&c->pb, 2, ((c->low>>7)&3)|1); | |
160 | |
161 flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong | |
162 } | |
163 | |
164 #ifdef STRICT_LIMITS | |
165 c->symCount++; | |
166 #endif | |
1300
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
167 |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
168 return (get_bit_count(&c->pb)+7)>>3; |
1287 | 169 } |
170 | |
1290 | 171 /** |
172 * put (truncated) unary binarization. | |
173 */ | |
174 static inline void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){ | |
175 int i; | |
176 | |
177 assert(v <= max); | |
178 | |
179 #if 1 | |
180 for(i=0; i<v; i++){ | |
181 put_cabac(c, state, 1); | |
182 if(i < max_index) state++; | |
183 } | |
184 if(truncated==0 || v<max) | |
185 put_cabac(c, state, 0); | |
186 #else | |
187 if(v <= max_index){ | |
188 for(i=0; i<v; i++){ | |
189 put_cabac(c, state+i, 1); | |
190 } | |
191 if(truncated==0 || v<max) | |
192 put_cabac(c, state+i, 0); | |
193 }else{ | |
194 for(i=0; i<=max_index; i++){ | |
195 put_cabac(c, state+i, 1); | |
196 } | |
197 for(; i<v; i++){ | |
198 put_cabac(c, state+max_index, 1); | |
199 } | |
200 if(truncated==0 || v<max) | |
201 put_cabac(c, state+max_index, 0); | |
202 } | |
203 #endif | |
204 } | |
205 | |
206 /** | |
207 * put unary exp golomb k-th order binarization. | |
208 */ | |
1298 | 209 static inline void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){ |
1290 | 210 int i; |
211 | |
212 if(v==0) | |
213 put_cabac(c, state, 0); | |
214 else{ | |
1298 | 215 const int sign= v < 0; |
216 | |
217 if(is_signed) v= ABS(v); | |
218 | |
1290 | 219 if(v<max){ |
220 for(i=0; i<v; i++){ | |
221 put_cabac(c, state, 1); | |
222 if(i < max_index) state++; | |
223 } | |
224 | |
225 put_cabac(c, state, 0); | |
226 }else{ | |
227 int m= 1<<k; | |
228 | |
229 for(i=0; i<max; i++){ | |
230 put_cabac(c, state, 1); | |
231 if(i < max_index) state++; | |
232 } | |
233 | |
234 v -= max; | |
235 while(v >= m){ //FIXME optimize | |
236 put_cabac_bypass(c, 1); | |
237 v-= m; | |
238 m+= m; | |
239 } | |
240 put_cabac_bypass(c, 0); | |
241 while(m>>=1){ | |
242 put_cabac_bypass(c, v&m); | |
243 } | |
244 } | |
245 | |
246 if(is_signed) | |
247 put_cabac_bypass(c, sign); | |
248 } | |
249 } | |
250 | |
1287 | 251 static inline void renorm_cabac_decoder(CABACContext *c){ |
252 while(c->range < 0x10000){ | |
253 c->range+= c->range; | |
254 c->low+= c->low; | |
255 if(--c->bits_left == 0){ | |
256 c->low+= *c->bytestream++; | |
257 c->bits_left= 8; | |
258 } | |
259 } | |
260 } | |
261 | |
262 static inline int get_cabac(CABACContext *c, uint8_t * const state){ | |
263 int RangeLPS= c->lps_range[*state][((c->range)>>14)&3]<<8; | |
264 int bit; | |
265 | |
266 c->range -= RangeLPS; | |
267 if(c->low < c->range){ | |
268 bit= (*state)&1; | |
269 *state= c->mps_state[*state]; | |
270 }else{ | |
271 bit= ((*state)&1)^1; | |
272 c->low -= c->range; | |
273 c->range = RangeLPS; | |
274 *state= c->lps_state[*state]; | |
275 } | |
276 renorm_cabac_decoder(c); | |
277 | |
278 return bit; | |
279 } | |
280 | |
281 static inline int get_cabac_static(CABACContext *c, int RangeLPS){ | |
282 int bit; | |
283 | |
284 c->range -= RangeLPS; | |
285 if(c->low < c->range){ | |
286 bit= 0; | |
287 }else{ | |
288 bit= 1; | |
289 c->low -= c->range; | |
290 c->range = RangeLPS; | |
291 } | |
292 renorm_cabac_decoder(c); | |
293 | |
294 return bit; | |
295 } | |
296 | |
297 static inline int get_cabac_bypass(CABACContext *c){ | |
298 c->low += c->low; | |
299 | |
300 if(--c->bits_left == 0){ | |
301 c->low+= *c->bytestream++; | |
302 c->bits_left= 8; | |
303 } | |
304 | |
305 if(c->low < c->range){ | |
306 return 0; | |
307 }else{ | |
308 c->low -= c->range; | |
309 return 1; | |
310 } | |
311 } | |
312 | |
1300
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
313 /** |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
314 * |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
315 * @return the number of bytes read or 0 if no end |
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
316 */ |
1287 | 317 static inline int get_cabac_terminate(CABACContext *c){ |
318 c->range -= 2<<8; | |
319 if(c->low < c->range){ | |
320 renorm_cabac_decoder(c); | |
321 return 0; | |
322 }else{ | |
1300
e18667d1e94d
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents:
1298
diff
changeset
|
323 return c->bytestream - c->bytestream_start; |
1287 | 324 } |
325 } | |
326 | |
1290 | 327 /** |
328 * get (truncated) unnary binarization. | |
329 */ | |
330 static inline int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){ | |
331 int i; | |
332 | |
333 for(i=0; i<max; i++){ | |
334 if(get_cabac(c, state)==0) | |
335 return i; | |
336 | |
337 if(i< max_index) state++; | |
338 } | |
339 | |
340 return truncated ? max : -1; | |
341 } | |
342 | |
343 /** | |
344 * get unary exp golomb k-th order binarization. | |
345 */ | |
346 static inline int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){ | |
347 int i, v; | |
348 int m= 1<<k; | |
349 | |
350 if(get_cabac(c, state)==0) | |
351 return 0; | |
352 | |
353 if(0 < max_index) state++; | |
354 | |
355 for(i=1; i<max; i++){ | |
356 if(get_cabac(c, state)==0){ | |
357 if(is_signed && get_cabac_bypass(c)){ | |
358 return -i; | |
359 }else | |
360 return i; | |
361 } | |
362 | |
363 if(i < max_index) state++; | |
364 } | |
365 | |
366 while(get_cabac_bypass(c)){ | |
367 i+= m; | |
368 m+= m; | |
369 } | |
370 | |
371 v=0; | |
372 while(m>>=1){ | |
373 v+= v + get_cabac_bypass(c); | |
374 } | |
375 i += v; | |
376 | |
377 if(is_signed && get_cabac_bypass(c)){ | |
378 return -i; | |
379 }else | |
380 return i; | |
381 } |