1 /******************************************************************************
2 *
3 * Copyright (C) 2015 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 /*!
21 ***************************************************************************
22 * \file ih264d_cabac.c
23 *
24 * \brief
25 * This file contains Binary decoding routines.
26 *
27 * \date
28 * 04/02/2003
29 *
30 * \author NS
31 ***************************************************************************
32 */
33 #include <string.h>
34 #include "ih264_typedefs.h"
35 #include "ih264_macros.h"
36 #include "ih264_platform_macros.h"
37 #include "ih264d_structs.h"
38 #include "ih264d_cabac.h"
39 #include "ih264d_bitstrm.h"
40 #include "ih264d_error_handler.h"
41 #include "ih264d_defs.h"
42 #include "ih264d_debug.h"
43 #include "ih264d_tables.h"
44 #include "ih264d_parse_cabac.h"
45 #include "ih264d_tables.h"
46
47
48
49 /*!
50 **************************************************************************
51 * \if Function name : ih264d_init_cabac_dec_envirnoment \endif
52 *
53 * \brief
54 * This function initializes CABAC decoding envirnoment. This function
55 * implements 9.3.3.2.3.1 of ISO/IEC14496-10.
56 *
57 * \return
58 * None
59 *
60 **************************************************************************
61 */
ih264d_init_cabac_dec_envirnoment(decoding_envirnoment_t * ps_cab_env,dec_bit_stream_t * ps_bitstrm)62 WORD32 ih264d_init_cabac_dec_envirnoment(decoding_envirnoment_t * ps_cab_env,
63 dec_bit_stream_t *ps_bitstrm)
64 {
65 UWORD32 u4_code_int_val_ofst;
66
67 ps_cab_env->u4_code_int_range = (HALF - 2) << 23;
68 NEXTBITS(u4_code_int_val_ofst, ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer,
69 32);
70 FLUSHBITS(ps_bitstrm->u4_ofst, 9)
71
72 if(EXCEED_OFFSET(ps_bitstrm))
73 return ERROR_EOB_FLUSHBITS_T;
74
75 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
76
77 /*brief description of the design adopted for CABAC*/
78 /*according to the standard the u4_code_int_range needs to be initialized 0x 1FE(10 bits) and
79 9 bits from the bit stream need to be read and into the u4_code_int_val_ofst.As and when the
80 u4_code_int_range becomes less than 10 bits we need to renormalize and read from the bitstream*
81
82 In the implemented design
83 initially
84
85 range_new = range <<23
86 valOffset_new = valOffset << 23 + 23 bits(read from the bit stream)
87
88 Thus we have read 23 more bits ahead of time.
89
90 It can be mathematical proved that even with the modified range and u4_ofst the operations
91 like comparison and subtraction needed for a bin decode are still valid(both in the regular case and the bypass case)
92
93 As bins are decoded..we consume the bits that we have already read into the valOffset.The clz of Range
94 gives us the number of bits we consumed of the 23 bits that we have read ahead of time.
95
96 when the number bits we have consumed exceeds 23 ,we renormalize..and we read from the bitstream again*/
97
98 RESET_BIN_COUNTS(ps_cab_env)
99
100 return OK;
101 }
102
103 /*****************************************************************************/
104 /* */
105 /* Function Name : ih264d_init_cabac_contexts */
106 /* */
107 /* Description : This function initializes the cabac contexts */
108 /* depending upon slice type and Init_Idc value. */
109 /* Inputs : ps_dec, slice type */
110 /* Globals : <Does it use any global variables?> */
111 /* Outputs : */
112 /* Returns : void */
113 /* */
114 /* Issues : none */
115 /* */
116 /* Revision History: */
117 /* */
118 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
119 /* 03 05 2005 100153) Draft */
120 /* */
121 /*****************************************************************************/
122
ih264d_init_cabac_contexts(UWORD8 u1_slice_type,dec_struct_t * ps_dec)123 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec)
124 {
125
126 bin_ctxt_model_t *p_cabac_ctxt_table_t = ps_dec->p_cabac_ctxt_table_t;
127 UWORD8 u1_qp_y = ps_dec->ps_cur_slice->u1_slice_qp;
128 UWORD8 u1_cabac_init_Idc = 0;
129
130 if(I_SLICE != u1_slice_type)
131 {
132 u1_cabac_init_Idc = ps_dec->ps_cur_slice->u1_cabac_init_idc;
133 }
134
135 {
136 /* MAKING ps_dec->p_ctxt_inc_mb_map a scratch buffer */
137 /* 0th entry of CtxtIncMbMap will be always be containing default values
138 for CABAC context representing MB not available */
139 ctxt_inc_mb_info_t *p_DefCtxt = ps_dec->p_ctxt_inc_mb_map - 1;
140 UWORD8 *pu1_temp;
141 WORD8 i;
142 p_DefCtxt->u1_mb_type = CAB_SKIP;
143
144 p_DefCtxt->u1_cbp = 0x0f;
145 p_DefCtxt->u1_intra_chroma_pred_mode = 0;
146
147 p_DefCtxt->u1_yuv_dc_csbp = 0x7;
148
149 p_DefCtxt->u1_transform8x8_ctxt = 0;
150
151 pu1_temp = (UWORD8*)p_DefCtxt->i1_ref_idx;
152 for(i = 0; i < 4; i++, pu1_temp++)
153 (*pu1_temp) = 0;
154 pu1_temp = (UWORD8*)p_DefCtxt->u1_mv;
155 for(i = 0; i < 16; i++, pu1_temp++)
156 (*pu1_temp) = 0;
157 ps_dec->ps_def_ctxt_mb_info = p_DefCtxt;
158 }
159
160 if(u1_slice_type == I_SLICE)
161 {
162 u1_cabac_init_Idc = 3;
163 ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_I_SLICE;
164 }
165 else if(u1_slice_type == P_SLICE)
166 {
167 ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_P_SLICE;
168 ps_dec->p_mb_skip_flag_t = p_cabac_ctxt_table_t + MB_SKIP_FLAG_P_SLICE;
169 ps_dec->p_sub_mb_type_t = p_cabac_ctxt_table_t + SUB_MB_TYPE_P_SLICE;
170 }
171 else if(u1_slice_type == B_SLICE)
172 {
173 ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_B_SLICE;
174 ps_dec->p_mb_skip_flag_t = p_cabac_ctxt_table_t + MB_SKIP_FLAG_B_SLICE;
175 ps_dec->p_sub_mb_type_t = p_cabac_ctxt_table_t + SUB_MB_TYPE_B_SLICE;
176 }
177 {
178 bin_ctxt_model_t *p_cabac_ctxt_table_t_tmp = p_cabac_ctxt_table_t;
179 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
180 {
181 p_cabac_ctxt_table_t_tmp += SIGNIFICANT_COEFF_FLAG_FLD;
182
183 }
184 else
185 {
186 p_cabac_ctxt_table_t_tmp += SIGNIFICANT_COEFF_FLAG_FRAME;
187 }
188 {
189 bin_ctxt_model_t * * p_significant_coeff_flag_t =
190 ps_dec->p_significant_coeff_flag_t;
191 p_significant_coeff_flag_t[0] = p_cabac_ctxt_table_t_tmp
192 + SIG_COEFF_CTXT_CAT_0_OFFSET;
193 p_significant_coeff_flag_t[1] = p_cabac_ctxt_table_t_tmp
194 + SIG_COEFF_CTXT_CAT_1_OFFSET;
195 p_significant_coeff_flag_t[2] = p_cabac_ctxt_table_t_tmp
196 + SIG_COEFF_CTXT_CAT_2_OFFSET;
197 p_significant_coeff_flag_t[3] = p_cabac_ctxt_table_t_tmp
198 + SIG_COEFF_CTXT_CAT_3_OFFSET;
199 p_significant_coeff_flag_t[4] = p_cabac_ctxt_table_t_tmp
200 + SIG_COEFF_CTXT_CAT_4_OFFSET;
201
202 p_significant_coeff_flag_t[5] = p_cabac_ctxt_table_t_tmp
203 + SIG_COEFF_CTXT_CAT_5_OFFSET;
204
205 }
206 }
207
208 memcpy(p_cabac_ctxt_table_t,
209 gau1_ih264d_cabac_ctxt_init_table[u1_cabac_init_Idc][u1_qp_y],
210 NUM_CABAC_CTXTS * sizeof(bin_ctxt_model_t));
211 }
212 /*!
213 **************************************************************************
214 * \if Function name : ih264d_decode_bin \endif
215 *
216 * \brief
217 * This function implements decoding process of a decision as defined
218 * in 9.3.3.2.2.
219 *
220 * \return
221 * Returns symbol decoded.
222 *
223 * \note
224 * It is specified in 9.3.3.2.3.2 that, one of the input to this function
225 * is CtxIdx. CtxIdx is used to identify state and MPS of that context
226 * (Refer Fig 9.11 - Flowchart for encoding a decision). To suffice that
227 * here we pass a pointer bin_ctxt_model_t which contains these values.
228 *
229 **************************************************************************
230 */
231
ih264d_decode_bin(UWORD32 u4_ctx_inc,bin_ctxt_model_t * ps_src_bin_ctxt,dec_bit_stream_t * ps_bitstrm,decoding_envirnoment_t * ps_cab_env)232 UWORD32 ih264d_decode_bin(UWORD32 u4_ctx_inc,
233 bin_ctxt_model_t *ps_src_bin_ctxt,
234 dec_bit_stream_t *ps_bitstrm,
235 decoding_envirnoment_t *ps_cab_env)
236
237 {
238
239 UWORD32 u4_qnt_int_range, u4_code_int_range, u4_code_int_val_ofst,
240 u4_int_range_lps;
241
242 UWORD32 u4_symbol, u4_mps_state;
243
244 bin_ctxt_model_t *ps_bin_ctxt;
245
246 UWORD32 table_lookup;
247 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
248 UWORD32 u4_clz;
249
250 ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_inc;
251
252 u4_code_int_range = ps_cab_env->u4_code_int_range;
253 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
254
255 u4_mps_state = (ps_bin_ctxt->u1_mps_state);
256 u4_clz = CLZ(u4_code_int_range);
257
258 u4_qnt_int_range = u4_code_int_range << u4_clz;
259 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
260
261 table_lookup = pu4_table[(u4_mps_state << 2) + u4_qnt_int_range];
262 u4_int_range_lps = table_lookup & 0xff;
263
264 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
265 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
266
267 u4_symbol = ((u4_mps_state >> 6) & 0x1);
268
269 u4_mps_state = (table_lookup >> 8) & 0x7F;
270
271 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
272 u4_int_range_lps, u4_mps_state, table_lookup)
273
274 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
275 {
276 UWORD32 *pu4_buffer, u4_offset;
277
278 pu4_buffer = ps_bitstrm->pu4_buffer;
279 u4_offset = ps_bitstrm->u4_ofst;
280
281 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
282 pu4_buffer)
283
284 ps_bitstrm->u4_ofst = u4_offset;
285 }
286
287 INC_BIN_COUNT(ps_cab_env)
288
289 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
290 ps_cab_env->u4_code_int_range = u4_code_int_range;
291 ps_bin_ctxt->u1_mps_state = u4_mps_state;
292
293 return (u4_symbol);
294 }
295
296 /*!
297 **************************************************************************
298 * \if Function name : ih264d_decode_terminate \endif
299 *
300 * \brief
301 * This function implements decoding process of a termination as defined
302 * 9.3.3.2.2.3 of ISO/IEC14496-10.
303 *
304 * \return
305 * Returns symbol decoded.
306 *
307 * \note
308 * This routine is called while decoding "end_of_skice_flag" and of the
309 * bin indicating PCM mode in MBType.
310 *
311 **************************************************************************
312 */
ih264d_decode_terminate(decoding_envirnoment_t * ps_cab_env,dec_bit_stream_t * ps_stream)313 UWORD8 ih264d_decode_terminate(decoding_envirnoment_t * ps_cab_env,
314 dec_bit_stream_t * ps_stream)
315 {
316 UWORD32 u4_symbol;
317 UWORD32 u4_code_int_val_ofst, u4_code_int_range;
318 UWORD32 u4_clz;
319
320 u4_code_int_range = ps_cab_env->u4_code_int_range;
321 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
322
323 u4_clz = CLZ(u4_code_int_range);
324 u4_code_int_range -= (2 << (23 - u4_clz));
325
326 if(u4_code_int_val_ofst >= u4_code_int_range)
327 {
328 /* S=1 */
329 u4_symbol = 1;
330
331 {
332
333 /*the u4_ofst needs to be updated before termination*/
334 ps_stream->u4_ofst += u4_clz;
335
336 }
337
338 }
339 else
340 {
341 /* S=0 */
342 u4_symbol = 0;
343
344 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
345 {
346 UWORD32 *pu4_buffer, u4_offset;
347
348 pu4_buffer = ps_stream->pu4_buffer;
349 u4_offset = ps_stream->u4_ofst;
350
351 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
352 pu4_buffer)
353 ps_stream->u4_ofst = u4_offset;
354 }
355 }
356
357 ps_cab_env->u4_code_int_range = u4_code_int_range;
358 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
359
360 INC_BIN_COUNT(ps_cab_env)
361
362 return (u4_symbol);
363 }
364
365 /*****************************************************************************/
366 /* */
367 /* Function Name : ih264d_decode_bins_tunary */
368 /* */
369 /* Description : This function decodes bins in the case of TUNARY */
370 /* binarization technique.valid_length is assumed equal to 3 */
371 /* and u1_max_bins <= 4 in this functon. */
372 /* Inputs : <What inputs does the function take?> */
373 /* Globals : <Does it use any global variables?> */
374 /* Processing : <Describe how the function operates - include algorithm */
375 /* description> */
376 /* Outputs : <What does the function produce?> */
377 /* Returns : <What does the function return?> */
378 /* */
379 /* Issues : */
380 /* */
381 /* Revision History: */
382 /* */
383 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
384 /* 20 11 2008 SH Draft */
385 /* */
386 /*****************************************************************************/
387
ih264d_decode_bins_tunary(UWORD8 u1_max_bins,UWORD32 u4_ctx_inc,bin_ctxt_model_t * ps_src_bin_ctxt,dec_bit_stream_t * ps_bitstrm,decoding_envirnoment_t * ps_cab_env)388 UWORD32 ih264d_decode_bins_tunary(UWORD8 u1_max_bins,
389 UWORD32 u4_ctx_inc,
390 bin_ctxt_model_t *ps_src_bin_ctxt,
391 dec_bit_stream_t *ps_bitstrm,
392 decoding_envirnoment_t *ps_cab_env)
393
394 {
395 UWORD32 u4_value;
396 UWORD32 u4_symbol;
397 UWORD8 u4_ctx_Inc;
398 bin_ctxt_model_t *ps_bin_ctxt;
399 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
400 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
401
402 u4_value = 0;
403
404 /*u1_max_bins has to be less than or equal to 4, u1_max_bins <= 4 for this function*/
405
406 /*here the valid length is assumed to be equal to 3 ,so the calling function is expected
407 to duplicate CtxInc if valid lenth is 2 and cmaxbin is greater than2*/
408 u4_code_int_range = ps_cab_env->u4_code_int_range;
409 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
410
411 do
412 {
413 u4_ctx_Inc = u4_ctx_inc & 0xF;
414 u4_ctx_inc = u4_ctx_inc >> 4;
415
416 ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;
417
418 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
419 pu4_table, ps_bitstrm, u4_symbol)
420
421 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
422
423 u4_value++;
424 }
425 while((u4_value < u1_max_bins) & (u4_symbol));
426
427 u4_value = u4_value - 1 + u4_symbol;
428
429 ps_cab_env->u4_code_int_range = u4_code_int_range;
430 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
431
432 return (u4_value);
433
434 }
435
436 /*****************************************************************************/
437 /* */
438 /* Function Name : ih264d_decode_bins */
439 /* */
440 /* Description : This function decodes bins in the case of MSB_FIRST_FLC */
441 /* binarization technique.valid_length is always equal max_bins */
442 /* for MSB_FIRST_FLC. assumes u1_max_bins <= 4 */
443 /* Inputs : <What inputs does the function take?> */
444 /* Globals : <Does it use any global variables?> */
445 /* Processing : <Describe how the function operates - include algorithm */
446 /* description> */
447 /* Outputs : <What does the function produce?> */
448 /* Returns : <What does the function return?> */
449 /* */
450 /* Issues : <List any issues or problems with this function> */
451 /* */
452 /* Revision History: */
453 /* */
454 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
455 /* 20 11 2008 SH Draft */
456 /* */
457 /*****************************************************************************/
458
ih264d_decode_bins(UWORD8 u1_max_bins,UWORD32 u4_ctx_inc,bin_ctxt_model_t * ps_src_bin_ctxt,dec_bit_stream_t * ps_bitstrm,decoding_envirnoment_t * ps_cab_env)459 UWORD32 ih264d_decode_bins(UWORD8 u1_max_bins,
460 UWORD32 u4_ctx_inc,
461 bin_ctxt_model_t *ps_src_bin_ctxt,
462 dec_bit_stream_t *ps_bitstrm,
463 decoding_envirnoment_t *ps_cab_env)
464
465 {
466 UWORD32 u4_value;
467 UWORD32 u4_symbol, i;
468 UWORD32 u4_ctxt_inc;
469 bin_ctxt_model_t *ps_bin_ctxt;
470 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
471 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
472
473 i = 0;
474
475 u4_value = 0;
476
477 /*u1_max_bins has to be less than or equal to 4, u1_max_bins <= 4 for this fucntion*/
478 u4_code_int_range = ps_cab_env->u4_code_int_range;
479 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
480
481 do
482 {
483 u4_ctxt_inc = u4_ctx_inc & 0xf;
484 u4_ctx_inc = u4_ctx_inc >> 4;
485
486 ps_bin_ctxt = ps_src_bin_ctxt + u4_ctxt_inc;
487
488 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
489 pu4_table, ps_bitstrm, u4_symbol)
490
491 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
492
493 u4_value = (u4_value << 1) | (u4_symbol);
494
495 i++;
496 }
497 while(i < u1_max_bins);
498
499 ps_cab_env->u4_code_int_range = u4_code_int_range;
500 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
501
502 return (u4_value);
503
504 }
505
506 /*****************************************************************************/
507 /* */
508 /* Function Name : ih264d_decode_bins_unary */
509 /* */
510 /* Description : This function decodes bins in the case of UNARY */
511 /* binarization technique.here the valid length is taken to 5*/
512 /* and cmax is always greater than 9 */
513 /* Inputs : <What inputs does the function take?> */
514 /* Globals : <Does it use any global variables?> */
515 /* Processing : <Describe how the function operates - include algorithm */
516 /* description> */
517 /* Outputs : <What does the function produce?> */
518 /* Returns : <What does the function return?> */
519 /* */
520 /* Issues : <List any issues or problems with this function> */
521 /* */
522 /* Revision History: */
523 /* */
524 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
525 /* 20 11 2008 SH Draft */
526 /* */
527 /*****************************************************************************/
ih264d_decode_bins_unary(UWORD8 u1_max_bins,UWORD32 u4_ctx_inc,bin_ctxt_model_t * ps_src_bin_ctxt,dec_bit_stream_t * ps_bitstrm,decoding_envirnoment_t * ps_cab_env)528 UWORD32 ih264d_decode_bins_unary(UWORD8 u1_max_bins,
529 UWORD32 u4_ctx_inc,
530 bin_ctxt_model_t *ps_src_bin_ctxt,
531 dec_bit_stream_t *ps_bitstrm,
532 decoding_envirnoment_t *ps_cab_env)
533 {
534 UWORD32 u4_value;
535 UWORD32 u4_symbol;
536 bin_ctxt_model_t *ps_bin_ctxt;
537 UWORD32 u4_ctx_Inc;
538 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
539 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
540
541 /* in this function the valid length for u4_ctx_inc is always taken to be,so if the
542 the valid length is lessthan 5 the caller need to duplicate accordingly*/
543
544 /*u1_max_bins is always greater or equal to 9 we have the check for u1_max_bins only after the 2 loop*/
545 u4_value = 0;
546 u4_code_int_range = ps_cab_env->u4_code_int_range;
547 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
548
549 do
550 {
551 u4_ctx_Inc = u4_ctx_inc & 0xf;
552 u4_ctx_inc = u4_ctx_inc >> 4;
553
554 ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;
555
556 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
557 pu4_table, ps_bitstrm, u4_symbol)
558
559 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
560
561 u4_value++;
562
563 }
564 while(u4_symbol && u4_value < 4);
565
566 if(u4_symbol && (u4_value < u1_max_bins))
567 {
568
569 u4_ctx_Inc = u4_ctx_inc & 0xf;
570
571 ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;
572
573 do
574 {
575
576 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
577 pu4_table, ps_bitstrm, u4_symbol)
578
579 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
580
581 u4_value++;
582
583 }
584 while(u4_symbol && (u4_value < u1_max_bins));
585
586 }
587
588 ps_cab_env->u4_code_int_range = u4_code_int_range;
589 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
590
591 u4_value = u4_value - 1 + u4_symbol;
592
593 return (u4_value);
594
595 }
596
597 /*****************************************************************************/
598 /* */
599 /* Function Name : ih264d_decode_bypass_bins_unary */
600 /* */
601 /* Description : This function is used in the case of UNARY coding */
602 /* */
603 /* */
604 /* Inputs : <What inputs does the function take?> */
605 /* Globals : <Does it use any global variables?> */
606 /* Processing : <Describe how the function operates - include algorithm */
607 /* description> */
608 /* Outputs : <What does the function produce?> */
609 /* Returns : <What does the function return?> */
610 /* */
611 /* Issues : <List any issues or problems with this function> */
612 /* */
613 /* Revision History: */
614 /* */
615 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
616 /* 13 10 2005 Ittiam Draft */
617 /* */
618 /*****************************************************************************/
619
ih264d_decode_bypass_bins_unary(decoding_envirnoment_t * ps_cab_env,dec_bit_stream_t * ps_bitstrm)620 UWORD32 ih264d_decode_bypass_bins_unary(decoding_envirnoment_t *ps_cab_env,
621 dec_bit_stream_t *ps_bitstrm)
622 {
623 UWORD32 u4_value;
624 UWORD32 u4_bin;
625 UWORD32 u4_code_int_val_ofst, u4_code_int_range;
626
627 UWORD32 u1_max_bins;
628
629 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
630 u4_code_int_range = ps_cab_env->u4_code_int_range;
631
632 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
633 {
634 UWORD32 *pu4_buffer, u4_offset;
635
636 pu4_buffer = ps_bitstrm->pu4_buffer;
637 u4_offset = ps_bitstrm->u4_ofst;
638
639 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
640 pu4_buffer)
641 ps_bitstrm->u4_ofst = u4_offset;
642 }
643
644 /*as it is called only form mvd*/
645 u1_max_bins = 32;
646 u4_value = 0;
647
648 do
649 {
650 u4_value++;
651
652 u4_code_int_range = u4_code_int_range >> 1;
653 if(u4_code_int_val_ofst >= u4_code_int_range)
654 {
655 /* S=1 */
656 u4_bin = 1;
657 u4_code_int_val_ofst -= u4_code_int_range;
658 }
659 else
660 {
661 /* S=0 */
662 u4_bin = 0;
663 }
664
665 INC_BIN_COUNT(ps_cab_env);INC_BYPASS_BINS(ps_cab_env);
666
667 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
668 {
669 UWORD32 *pu4_buffer, u4_offset;
670
671 pu4_buffer = ps_bitstrm->pu4_buffer;
672 u4_offset = ps_bitstrm->u4_ofst;
673
674 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
675 pu4_buffer)
676
677 ps_bitstrm->u4_ofst = u4_offset;
678 }
679
680 }
681 while(u4_bin && (u4_value < u1_max_bins));
682
683 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
684 ps_cab_env->u4_code_int_range = u4_code_int_range;
685 u4_value = (u4_value - 1 + u4_bin);
686
687 return (u4_value);
688 }
689
690 /*****************************************************************************/
691 /* */
692 /* Function Name : ih264d_decode_bypass_bins */
693 /* */
694 /* Description : This function is used in the case of FLC coding */
695 /* */
696 /* */
697 /* Inputs : <What inputs does the function take?> */
698 /* Globals : <Does it use any global variables?> */
699 /* Processing : <Describe how the function operates - include algorithm */
700 /* description> */
701 /* Outputs : <What does the function produce?> */
702 /* Returns : <What does the function return?> */
703 /* */
704 /* Issues : <List any issues or problems with this function> */
705 /* */
706 /* Revision History: */
707 /* */
708 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
709 /* 13 10 2005 Ittiam Draft */
710 /* */
711 /*****************************************************************************/
712
ih264d_decode_bypass_bins(decoding_envirnoment_t * ps_cab_env,UWORD8 u1_max_bins,dec_bit_stream_t * ps_bitstrm)713 UWORD32 ih264d_decode_bypass_bins(decoding_envirnoment_t *ps_cab_env,
714 UWORD8 u1_max_bins,
715 dec_bit_stream_t *ps_bitstrm)
716 {
717 UWORD32 u4_bins;
718 UWORD32 u4_bin;
719 UWORD32 u4_code_int_val_ofst, u4_code_int_range;
720
721 u4_bins = 0;
722 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
723 u4_code_int_range = ps_cab_env->u4_code_int_range;
724
725 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
726 {
727 UWORD32 *pu4_buffer, u4_offset;
728
729 pu4_buffer = ps_bitstrm->pu4_buffer;
730 u4_offset = ps_bitstrm->u4_ofst;
731
732 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
733 pu4_buffer)
734 ps_bitstrm->u4_ofst = u4_offset;
735 }
736
737 do
738 {
739
740 u4_code_int_range = u4_code_int_range >> 1;
741
742 if(u4_code_int_val_ofst >= u4_code_int_range)
743 {
744 /* S=1 */
745 u4_bin = 1;
746 u4_code_int_val_ofst -= u4_code_int_range;
747 }
748 else
749 {
750 /* S=0 */
751 u4_bin = 0;
752 }
753
754 INC_BIN_COUNT(ps_cab_env);INC_BYPASS_BINS(ps_cab_env);
755
756 u4_bins = ((u4_bins << 1) | u4_bin);
757 u1_max_bins--;
758
759 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
760 {
761 UWORD32 *pu4_buffer, u4_offset;
762
763 pu4_buffer = ps_bitstrm->pu4_buffer;
764 u4_offset = ps_bitstrm->u4_ofst;
765
766 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
767 pu4_buffer)
768 ps_bitstrm->u4_ofst = u4_offset;
769 }
770
771 }
772 while(u1_max_bins);
773
774 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
775 ps_cab_env->u4_code_int_range = u4_code_int_range;
776
777 return (u4_bins);
778 }
779
780