Mercurial > libavcodec.hg
comparison cabac.h @ 1290:dae280b939ca libavcodec
(truncated) unary binerization
unary k-th order exp golomb binarization
author | michaelni |
---|---|
date | Fri, 30 May 2003 01:05:48 +0000 |
parents | 9211fbd31353 |
children | 5bc3184810dc |
comparison
equal
deleted
inserted
replaced
1289:57172377849a | 1290:dae280b939ca |
---|---|
111 #ifdef STRICT_LIMITS | 111 #ifdef STRICT_LIMITS |
112 c->symCount++; | 112 c->symCount++; |
113 #endif | 113 #endif |
114 } | 114 } |
115 | 115 |
116 /** | |
117 * @param bit 0 -> write zero bit, !=0 write one bit | |
118 */ | |
116 static inline void put_cabac_bypass(CABACContext *c, int bit){ | 119 static inline void put_cabac_bypass(CABACContext *c, int bit){ |
117 c->low += c->low; | 120 c->low += c->low; |
118 | 121 |
119 if(bit){ | 122 if(bit){ |
120 c->low += c->range; | 123 c->low += c->range; |
154 } | 157 } |
155 | 158 |
156 #ifdef STRICT_LIMITS | 159 #ifdef STRICT_LIMITS |
157 c->symCount++; | 160 c->symCount++; |
158 #endif | 161 #endif |
162 } | |
163 | |
164 /** | |
165 * put (truncated) unary binarization. | |
166 */ | |
167 static inline void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){ | |
168 int i; | |
169 | |
170 assert(v <= max); | |
171 | |
172 #if 1 | |
173 for(i=0; i<v; i++){ | |
174 put_cabac(c, state, 1); | |
175 if(i < max_index) state++; | |
176 } | |
177 if(truncated==0 || v<max) | |
178 put_cabac(c, state, 0); | |
179 #else | |
180 if(v <= max_index){ | |
181 for(i=0; i<v; i++){ | |
182 put_cabac(c, state+i, 1); | |
183 } | |
184 if(truncated==0 || v<max) | |
185 put_cabac(c, state+i, 0); | |
186 }else{ | |
187 for(i=0; i<=max_index; i++){ | |
188 put_cabac(c, state+i, 1); | |
189 } | |
190 for(; i<v; i++){ | |
191 put_cabac(c, state+max_index, 1); | |
192 } | |
193 if(truncated==0 || v<max) | |
194 put_cabac(c, state+max_index, 0); | |
195 } | |
196 #endif | |
197 } | |
198 | |
199 /** | |
200 * put unary exp golomb k-th order binarization. | |
201 */ | |
202 static inline void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int sign, int max, int is_signed, int k, int max_index){ | |
203 int i; | |
204 | |
205 if(v==0) | |
206 put_cabac(c, state, 0); | |
207 else{ | |
208 if(v<max){ | |
209 for(i=0; i<v; i++){ | |
210 put_cabac(c, state, 1); | |
211 if(i < max_index) state++; | |
212 } | |
213 | |
214 put_cabac(c, state, 0); | |
215 }else{ | |
216 int m= 1<<k; | |
217 | |
218 for(i=0; i<max; i++){ | |
219 put_cabac(c, state, 1); | |
220 if(i < max_index) state++; | |
221 } | |
222 | |
223 v -= max; | |
224 while(v >= m){ //FIXME optimize | |
225 put_cabac_bypass(c, 1); | |
226 v-= m; | |
227 m+= m; | |
228 } | |
229 put_cabac_bypass(c, 0); | |
230 while(m>>=1){ | |
231 put_cabac_bypass(c, v&m); | |
232 } | |
233 } | |
234 | |
235 if(is_signed) | |
236 put_cabac_bypass(c, sign); | |
237 } | |
159 } | 238 } |
160 | 239 |
161 static inline void renorm_cabac_decoder(CABACContext *c){ | 240 static inline void renorm_cabac_decoder(CABACContext *c){ |
162 while(c->range < 0x10000){ | 241 while(c->range < 0x10000){ |
163 c->range+= c->range; | 242 c->range+= c->range; |
228 }else{ | 307 }else{ |
229 return 1; | 308 return 1; |
230 } | 309 } |
231 } | 310 } |
232 | 311 |
312 /** | |
313 * get (truncated) unnary binarization. | |
314 */ | |
315 static inline int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){ | |
316 int i; | |
317 | |
318 for(i=0; i<max; i++){ | |
319 if(get_cabac(c, state)==0) | |
320 return i; | |
321 | |
322 if(i< max_index) state++; | |
323 } | |
324 | |
325 return truncated ? max : -1; | |
326 } | |
327 | |
328 /** | |
329 * get unary exp golomb k-th order binarization. | |
330 */ | |
331 static inline int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){ | |
332 int i, v; | |
333 int m= 1<<k; | |
334 | |
335 if(get_cabac(c, state)==0) | |
336 return 0; | |
337 | |
338 if(0 < max_index) state++; | |
339 | |
340 for(i=1; i<max; i++){ | |
341 if(get_cabac(c, state)==0){ | |
342 if(is_signed && get_cabac_bypass(c)){ | |
343 return -i; | |
344 }else | |
345 return i; | |
346 } | |
347 | |
348 if(i < max_index) state++; | |
349 } | |
350 | |
351 while(get_cabac_bypass(c)){ | |
352 i+= m; | |
353 m+= m; | |
354 } | |
355 | |
356 v=0; | |
357 while(m>>=1){ | |
358 v+= v + get_cabac_bypass(c); | |
359 } | |
360 i += v; | |
361 | |
362 if(is_signed && get_cabac_bypass(c)){ | |
363 return -i; | |
364 }else | |
365 return i; | |
366 } |