1 /******************************************************************************
2 *
3 * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
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 /**
19 ******************************************************************************
20 * @file ihevcd_cabac.c
21 *
22 * @brief
23 * This file contains function definitions related to CABAC parsing
24 *
25 * @author
26 * Ittiam
27 *
28 *
29 * List of Functions
30 *
31 * ihevcd_cabac_init()
32 * ihevcd_cabac_decode_bin()
33 * ihevcd_cabac_decode_bypass_bin()
34 * ihevcd_cabac_decode_bypass_bins_tunary()
35 * ihevcd_cabac_decode_terminate()
36 * ihevcd_cabac_decode_bin_tunary()
37 * ihevcd_cabac_decode_bypass_bins()
38 * ihevcd_cabac_decode_bypass_bins_egk()
39 * ihevcd_cabac_decode_trunc_rice()
40 * ihevcd_cabac_flush()
41 *
42 ******************************************************************************
43 */
44
45 /*****************************************************************************/
46 /* File Includes */
47 /*****************************************************************************/
48 #include <stdio.h>
49 #include <stddef.h>
50 #include <assert.h>
51 #include <stdlib.h>
52 #include <string.h>
53
54 #include "ihevc_typedefs.h"
55 #include "iv.h"
56 #include "ivd.h"
57 #include "ihevcd_cxa.h"
58
59
60 #include "ihevc_debug.h"
61 #include "ihevc_macros.h"
62 #include "ihevc_platform_macros.h"
63 #include "ihevc_cabac_tables.h"
64 #include "ihevc_defs.h"
65 #include "ihevc_structs.h"
66 #include "ihevc_cabac_tables.h"
67
68
69 #include "ihevcd_defs.h"
70 #include "ihevcd_function_selector.h"
71 #include "ihevcd_structs.h"
72 #include "ihevcd_error.h"
73 #include "ihevcd_bitstream.h"
74 #include "ihevcd_cabac.h"
75 #include "ihevcd_trace.h"
76
77 #ifdef TRACE
78 extern trace_t g_trace;
79 #endif
80 #if DEBUG_CABAC_RANGE_OFST
81 #if FULLRANGE
82 #define DEBUG_RANGE_OFST(str, m_range, m_ofst ) \
83 {\
84 UWORD32 m_clz, m_range_shift, m_ofst_shift; \
85 m_clz = CLZ(m_range); \
86 m_clz -= (32 - RANGE_NUMBITS); \
87 m_range_shift = m_range << m_clz; \
88 m_range_shift = m_range_shift >> RANGE_SHIFT; \
89 m_ofst_shift = m_ofst << m_clz; \
90 m_ofst_shift = m_ofst_shift >> RANGE_SHIFT; \
91 fprintf( g_trace.fp, "%-40s R: %3d O: %3d\n", str, m_range_shift, m_ofst_shift); \
92 }
93
94 #else
95 #define DEBUG_RANGE_OFST(str, m_range, m_ofst) \
96 fprintf( g_trace.fp, "%-40s R: %3d O: %3d\n", str, m_range, m_ofst);
97 #endif
98 #else
99 #define DEBUG_RANGE_OFST(str, m_range, m_ofst )
100 #endif
101 /*****************************************************************************/
102 /* Function Definitions */
103 /*****************************************************************************/
104
105 /**
106 ******************************************************************************
107 *
108 * @brief Initializes the decoder cabac engine
109 *
110 * @par Description
111 * This routine needs to be called at start of slice/frame decode
112 *
113 * @param[in,out] ps_cabac_ctxt
114 * pointer to cabac context (handle)
115 *
116 * @param[in] ps_bitstrm
117 * pointer to bitstream context (handle)
118 *
119 * @param[in] qp
120 * current slice Qp
121 *
122 * @param[in] cabac_init_idc
123 * current slice init idc (range [0 - 2])
124 *
125 * @param[in] pu1_init_ctxt
126 * Init cabac context to be used (range [0 - 2])
127 *
128 * @return success or failure error code
129 *
130 ******************************************************************************
131 */
ihevcd_cabac_init(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 qp,WORD32 cabac_init_idc,const UWORD8 * pu1_init_ctxt)132 IHEVCD_ERROR_T ihevcd_cabac_init(cab_ctxt_t *ps_cabac,
133 bitstrm_t *ps_bitstrm,
134 WORD32 qp,
135 WORD32 cabac_init_idc,
136 const UWORD8 *pu1_init_ctxt)
137 {
138 /* Sanity checks */
139 ASSERT(ps_cabac != NULL);
140 ASSERT(ps_bitstrm != NULL);
141 ASSERT((qp >= 0) && (qp < 52));
142 ASSERT((cabac_init_idc >= 0) && (cabac_init_idc < 3));
143 UNUSED(qp);
144 UNUSED(cabac_init_idc);
145 /* CABAC engine uses 32 bit range instead of 9 bits as specified by
146 * the spec. This is done to reduce number of renormalizations
147 */
148 /* cabac engine initialization */
149 #if FULLRANGE
150 ps_cabac->u4_range = (UWORD32)510 << RANGE_SHIFT;
151 BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
152 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (9 + RANGE_SHIFT));
153
154 #else
155 ps_cabac->u4_range = (UWORD32)510;
156 BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
157 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, 9);
158
159 #endif
160
161 /* cabac context initialization based on init idc and slice qp */
162 memcpy(ps_cabac->au1_ctxt_models,
163 pu1_init_ctxt,
164 IHEVC_CAB_CTXT_END);
165 DEBUG_RANGE_OFST("init", ps_cabac->u4_range, ps_cabac->u4_ofst);
166 return ((IHEVCD_ERROR_T)IHEVCD_SUCCESS);
167 }
168
ihevcd_cabac_reset(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm)169 IHEVCD_ERROR_T ihevcd_cabac_reset(cab_ctxt_t *ps_cabac,
170 bitstrm_t *ps_bitstrm)
171 {
172 /* Sanity checks */
173 ASSERT(ps_cabac != NULL);
174 ASSERT(ps_bitstrm != NULL);
175
176 /* CABAC engine uses 32 bit range instead of 9 bits as specified by
177 * the spec. This is done to reduce number of renormalizations
178 */
179 /* cabac engine initialization */
180 #if FULLRANGE
181 ps_cabac->u4_range = (UWORD32)510 << RANGE_SHIFT;
182 BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
183 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (9 + RANGE_SHIFT));
184
185 #else
186 ps_cabac->u4_range = (UWORD32)510;
187 BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
188 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, 9);
189
190 #endif
191
192 return ((IHEVCD_ERROR_T)IHEVCD_SUCCESS);
193 }
194
195 /**
196 ******************************************************************************
197 *
198 * @brief Decodes a bin based on probablilty and mps packed context model
199 *
200 * @par Description
201 * Decodes a bin as per Section : 9.3.3.2.1 and calls renormalization if required
202 * as per section 9.3.3.2.2
203 * 1. Apart from decoding bin, context model is updated as per state transition
204 * 2. Range and Low renormalization is done based on bin and original state
205 * 3. After renorm bistream is updated (if required)
206 *
207 * @param[in,out] ps_cabac
208 * pointer to cabac context (handle)
209 *
210 * @param[in] ctxt_index
211 * index of cabac context model containing pState[bits6-1] | MPS[bit0]
212 *
213 * @param[in] ps_bitstrm
214 * Bitstream context
215 *
216 * @return bin(boolean) to be decoded
217 *
218 ******************************************************************************
219 */
ihevcd_cabac_decode_bin(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 ctxt_index)220 UWORD32 ihevcd_cabac_decode_bin(cab_ctxt_t *ps_cabac,
221 bitstrm_t *ps_bitstrm,
222 WORD32 ctxt_index
223
224 )
225 {
226 UWORD32 u4_range = ps_cabac->u4_range;
227 UWORD32 u4_ofst = ps_cabac->u4_ofst;
228 UWORD32 u4_rlps;
229 UWORD32 u4_bin;
230 UWORD8 *pu1_ctxt_model = &ps_cabac->au1_ctxt_models[ctxt_index];
231 WORD32 state_mps = *pu1_ctxt_model;
232 #if FULLRANGE
233 WORD32 clz;
234 #endif
235 UWORD32 u4_qnt_range;
236
237 /* Sanity checks */
238 ASSERT(u4_range >= 256);
239 ASSERT((ctxt_index >= 0) && (ctxt_index < IHEVC_CAB_CTXT_END));
240 ASSERT(state_mps < 128);
241 #if FULLRANGE
242 clz = CLZ(u4_range);
243 clz -= (32 - RANGE_NUMBITS);
244 u4_qnt_range = u4_range << clz;
245 u4_qnt_range = (u4_qnt_range >> (RANGE_SHIFT + 6)) & 0x3;
246 #else
247 u4_qnt_range = (u4_range >> 6) & 0x3;
248 #endif
249 /* Get the lps range from LUT based on quantized range and state */
250 u4_rlps = gau1_ihevc_cabac_rlps[state_mps >> 1][u4_qnt_range];
251 #if FULLRANGE
252 u4_rlps = u4_rlps << (RANGE_SHIFT - clz);
253 #endif
254 u4_range -= u4_rlps;
255
256 u4_bin = state_mps & 1;
257
258 if(u4_ofst >= u4_range)
259 {
260 u4_bin = 1 - u4_bin;
261 u4_ofst -= u4_range;
262 u4_range = u4_rlps;
263 }
264
265 *pu1_ctxt_model = gau1_ihevc_next_state[(state_mps << 1) | u4_bin];
266
267 /*****************************************************************/
268 /* Re-normalization; calculate bits generated based on range(R) */
269 /*****************************************************************/
270 if(u4_range < (1 << 8))
271 {
272 UWORD32 u4_bits;
273 WORD32 numbits;
274 numbits = CLZ(u4_range);
275 numbits -= (32 - RANGE_NUMBITS);
276 #if !FULLRANGE
277 numbits -= RANGE_SHIFT;
278 #endif
279 BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
280 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbits);
281
282 u4_ofst <<= numbits;
283 u4_ofst |= u4_bits;
284 u4_range <<= numbits;
285
286 }
287 /* Update the cabac context */
288 ps_cabac->u4_range = u4_range;
289 ps_cabac->u4_ofst = u4_ofst;
290 DEBUG_RANGE_OFST("bin", ps_cabac->u4_range, ps_cabac->u4_ofst);
291
292 return (u4_bin);
293
294
295 }
296
297 /**
298 ******************************************************************************
299 *
300 * @brief Decodes a bypass bin (equi-probable 0 / 1)
301 *
302 * @par Description
303 * Decodes a bypss bin as per Section : 9.3.3.2.3
304 *
305 * @param[in,out] ps_cabac
306 * pointer to cabac context (handle)
307 *
308 * @param[in] ps_bitstrm
309 * Bitstream context
310 *
311 * @return Decoded bypass bin
312 *
313 ******************************************************************************
314 */
ihevcd_cabac_decode_bypass_bin(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm)315 UWORD32 ihevcd_cabac_decode_bypass_bin(cab_ctxt_t *ps_cabac,
316 bitstrm_t *ps_bitstrm)
317 {
318
319 UWORD32 u4_bin;
320 UWORD32 u4_range = ps_cabac->u4_range;
321 UWORD32 u4_ofst = ps_cabac->u4_ofst;
322 UWORD32 u4_bits;
323
324 /* Sanity checks */
325 ASSERT(u4_range >= 256);
326
327 BIT_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
328 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word);
329
330 u4_ofst <<= 1;
331 u4_ofst |= u4_bits;
332
333 u4_bin = 0;
334 if(u4_ofst >= u4_range)
335 {
336 u4_bin = 1;
337 u4_ofst -= u4_range;
338 }
339
340 /* Update the cabac context */
341 ps_cabac->u4_ofst = u4_ofst;
342 DEBUG_RANGE_OFST("bypass end", ps_cabac->u4_range, ps_cabac->u4_ofst);
343 return (u4_bin);
344 }
345
346 /**
347 ******************************************************************************
348 *
349 * @brief Decodes a terminate bin (1:terminate 0:do not terminate)
350 *
351 * @par Description
352 * Decodes a terminate bin to be called for end_of_slice_flag and pcm_flag
353 * as per Section : 9.3.3.2.4
354 *
355 * @param[in,out] ps_cabac
356 * pointer to cabac context (handle)
357 *
358 * @param[in] ps_bitstrm
359 * Bitstream context
360 *
361 * @return Decoded Bin to indicate whether to terminate or not
362 *
363 ******************************************************************************
364 */
ihevcd_cabac_decode_terminate(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm)365 UWORD32 ihevcd_cabac_decode_terminate(cab_ctxt_t *ps_cabac,
366 bitstrm_t *ps_bitstrm)
367 {
368 UWORD32 u4_range = ps_cabac->u4_range;
369 UWORD32 u4_ofst = ps_cabac->u4_ofst;
370 UWORD32 u4_bin;
371 #if FULLRANGE
372 WORD32 clz;
373 #endif
374 /* Sanity checks */
375 ASSERT(u4_range >= 256);
376 #if FULLRANGE
377 clz = CLZ(u4_range);
378 clz -= (32 - RANGE_NUMBITS);
379 u4_range -= 2 << (RANGE_SHIFT - clz);
380 #else
381 u4_range -= 2;
382 #endif
383
384 if(u4_ofst >= u4_range)
385 {
386 u4_bin = 1;
387
388 #if FULLRANGE
389 /* In case of FULLRANGE extra bits read earlier need to pushed back to the bitstream */
390 {
391 WORD32 clz;
392 WORD32 numbits;
393 clz = CLZ(ps_cabac->u4_range);
394
395 numbits = (32 - clz);
396 numbits -= 9;
397
398 ihevcd_bits_seek(ps_bitstrm, -numbits);
399 }
400 #endif
401
402 }
403 else
404 {
405 u4_bin = 0;
406 }
407 if(0 == u4_bin)
408 {
409 UWORD32 u4_bits;
410 WORD32 numbits;
411 numbits = CLZ(u4_range);
412 numbits -= (32 - RANGE_NUMBITS);
413 #if !FULLRANGE
414 numbits -= RANGE_SHIFT;
415 #endif
416 /* Renormalize if required */
417 if(numbits)
418 {
419 BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
420 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbits);
421
422 u4_ofst <<= numbits;
423 u4_ofst |= u4_bits;
424 u4_range <<= numbits;
425 }
426 }
427 /* bits to be inserted in the bitstream */
428 ps_cabac->u4_range = u4_range;
429 ps_cabac->u4_ofst = u4_ofst;
430 DEBUG_RANGE_OFST("term", ps_cabac->u4_range, ps_cabac->u4_ofst);
431
432 return (u4_bin);
433 }
434
435 /**
436 ******************************************************************************
437 *
438 * @brief Decodes a bypass bin (equi-probable 0 / 1)
439 *
440 * @par Description
441 * Decodes a bypss bin as per Section : 9.3.3.2.3
442 *
443 * @param[in,out] ps_cabac
444 * pointer to cabac context (handle)
445 *
446 * @param[in] ps_bitstrm
447 * Bitstream context
448 *
449 * @param[in] numbins
450 * Number of bins to decoded
451 *
452 * @return Decoded bypass bin
453 *
454 * @remarks Tested only for numbins less than 17
455 *
456 ******************************************************************************
457 */
458
ihevcd_cabac_decode_bypass_bins(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 numbins)459 UWORD32 ihevcd_cabac_decode_bypass_bins(cab_ctxt_t *ps_cabac,
460 bitstrm_t *ps_bitstrm,
461 WORD32 numbins)
462 {
463 UWORD32 u4_bins;
464
465
466 UWORD32 u4_range = ps_cabac->u4_range;
467 UWORD32 u4_ofst = ps_cabac->u4_ofst;
468 UWORD32 u4_bits;
469 ASSERT(u4_range >= 256);
470 ASSERT(numbins > 0);
471
472 /* Sanity checks */
473 ASSERT(numbins < 17);
474
475 u4_bins = 0;
476
477 BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
478 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbins);
479
480 do
481 {
482 UWORD32 u4_bit;
483 numbins--;
484 u4_bit = (u4_bits >> numbins) & 1;
485 u4_ofst <<= 1;
486 u4_ofst |= u4_bit;
487
488 u4_bins <<= 1;
489 if(u4_ofst >= u4_range)
490 {
491 u4_bins += 1;
492 u4_ofst -= u4_range;
493 }
494 }while(numbins);
495
496 /* Update the cabac context */
497 ps_cabac->u4_ofst = u4_ofst;
498 DEBUG_RANGE_OFST("bypass", ps_cabac->u4_range, ps_cabac->u4_ofst);
499 return (u4_bins);
500 }
501
502 /**
503 ******************************************************************************
504 *
505 * @brief Decodes a truncated unary symbol associated with context model(s)
506 *
507 * @par Description
508 * Decodes symbols coded with TUnary binarization as per sec 9.3.2.2
509 * This is used for computing symbols like qp_delta,
510 * last_sig_coeff_prefix_x, last_sig_coeff_prefix_y.
511 *
512 * The context models associated with each bin is computed as :
513 * current bin context = "base context idx" + (bin_idx >> shift)
514 * where
515 * 1. "base context idx" is the base index for the syntax element
516 * 2. "bin_idx" is the current bin index of the unary code
517 * 3. "shift" is the shift factor associated with this syntax element
518 *
519 * @param[in,out] ps_cabac
520 * pointer to cabac context (handle)
521 *
522 * @param[in] ps_bitstrm
523 * Bitstream context
524 *
525 * @param[in] c_max
526 * maximum value of sym (required for tunary binarization)
527 *
528 * @param[in] ctxt_index
529 * base context model index for this syntax element
530 *
531 * @param[in] ctxt_shift
532 * shift factor for context increments associated with this syntax element
533 *
534 * @param[in] ctxt_inc_max
535 * max value of context increment beyond which all bins will use same ctxt
536 *
537 * @return syntax element decoded
538 *
539 ******************************************************************************
540 */
ihevcd_cabac_decode_bins_tunary(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 c_max,WORD32 ctxt_index,WORD32 ctxt_shift,WORD32 ctxt_inc_max)541 UWORD32 ihevcd_cabac_decode_bins_tunary(cab_ctxt_t *ps_cabac,
542 bitstrm_t *ps_bitstrm,
543 WORD32 c_max,
544 WORD32 ctxt_index,
545 WORD32 ctxt_shift,
546 WORD32 ctxt_inc_max)
547 {
548 UWORD32 u4_sym;
549 WORD32 bin;
550
551 /* Sanity checks */
552 ASSERT(c_max > 0);
553 ASSERT((ctxt_index >= 0) && (ctxt_index < IHEVC_CAB_CTXT_END));
554 ASSERT((ctxt_index + (c_max >> ctxt_shift)) < IHEVC_CAB_CTXT_END);
555
556 u4_sym = 0;
557 do
558 {
559 WORD32 bin_index;
560 bin_index = ctxt_index + MIN((u4_sym >> ctxt_shift), (UWORD32)ctxt_inc_max);
561 IHEVCD_CABAC_DECODE_BIN(bin, ps_cabac, ps_bitstrm, bin_index);
562 u4_sym++;
563 }while(((WORD32)u4_sym < c_max) && bin);
564
565 u4_sym = u4_sym - 1 + bin;
566
567 return (u4_sym);
568 }
569
570 /**
571 ******************************************************************************
572 *
573 * @brief Decodes a syntax element as truncated unary bypass bins
574 *
575 * @par Description
576 * Decodes symbols coded with TUnary binarization as per sec 9.3.2.2
577 * These symbols are coded as bypass bins
578 * This is used for computing symbols like merge_idx,
579 * mpm_idx etc
580 *
581 * @param[in,out]ps_cabac
582 * pointer to cabac context (handle)
583 *
584 * @param[in] ps_bitstrm
585 * Bitstream context
586 *
587 * @param[in] c_max
588 * maximum value of sym (required for tunary binarization)
589 *
590 * @return syntax element decoded
591 *
592 ******************************************************************************
593 */
ihevcd_cabac_decode_bypass_bins_tunary(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 c_max)594 UWORD32 ihevcd_cabac_decode_bypass_bins_tunary(cab_ctxt_t *ps_cabac,
595 bitstrm_t *ps_bitstrm,
596 WORD32 c_max)
597 {
598
599 UWORD32 u4_sym;
600 WORD32 bin;
601 UWORD32 u4_ofst = ps_cabac->u4_ofst;
602 UWORD32 u4_range = ps_cabac->u4_range;
603 UWORD32 u4_bits;
604 /* Sanity checks */
605 ASSERT(c_max > 0);
606 ASSERT(u4_range >= 256);
607 u4_sym = 0;
608 BITS_NXT(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
609 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (UWORD32)c_max);
610 u4_bits <<= (32 - c_max);
611 do
612 {
613 u4_ofst <<= 1;
614 u4_ofst |= (u4_bits >> 31);
615 u4_bits <<= 1;
616
617 bin = 0;
618 if(u4_ofst >= u4_range)
619 {
620 bin = 1;
621 u4_ofst -= u4_range;
622 }
623 u4_sym++;
624 }while(((WORD32)u4_sym < c_max) && bin);
625 BITS_FLUSH(ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
626 ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, u4_sym);
627
628 u4_sym = u4_sym - 1 + bin;
629 /* Update the cabac context */
630 ps_cabac->u4_ofst = u4_ofst;
631
632 return (u4_sym);
633 }
634
635 /**
636 ******************************************************************************
637 *
638 * @brief Decodes a syntax element as kth order Exp-Golomb code (EGK)
639 *
640 * @par Description
641 * Decodes a syntax element binarized as kth order Exp-Golomb code (EGK)
642 * Elements are coded as bypass bins
643 *
644 * @param[in,out] ps_cabac
645 * pointer to cabac context (handle)
646 *
647 * @param[in] u4_sym
648 * syntax element to be coded as EGK
649 *
650 * @param[in] k
651 * order of EGk
652 *
653 * @return success or failure error code
654 *
655 ******************************************************************************
656 */
ihevcd_cabac_decode_bypass_bins_egk(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 k)657 UWORD32 ihevcd_cabac_decode_bypass_bins_egk(cab_ctxt_t *ps_cabac,
658 bitstrm_t *ps_bitstrm,
659 WORD32 k)
660 {
661
662 UWORD32 u4_sym;
663 WORD32 numones;
664 WORD32 bin;
665
666 /* Sanity checks */
667 ASSERT((k >= 0));
668
669 numones = k;
670 bin = 1;
671 u4_sym = 0;
672 while(bin)
673 {
674 IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);
675 u4_sym += bin << numones++;
676 }
677
678 numones -= 1;
679 numones = CLIP3(numones, 0, 16);
680
681 if(numones)
682 {
683 UWORD32 u4_suffix;
684
685 IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, numones);
686 u4_sym += u4_suffix;
687 }
688 return (u4_sym);
689 }
690
691 /**
692 ******************************************************************************
693 *
694 * @brief Decodes a syntax element as truncated rice code (TR)
695 *
696 * @par Description
697 * Decodes a syntax element as truncated rice code (TR)
698 * Elements are coded as bypass bins
699 * This function ise used for coeff_abs_level_remaining coding when
700 * level is less than c_rice_max
701 *
702 * @param[in,out] ps_cabac
703 * pointer to cabac context (handle)
704 *
705 * @param[in] u4_sym
706 * syntax element to be coded as truncated rice code
707 *
708 * @param[in] c_rice_param
709 * shift factor for truncated unary prefix coding of (u4_sym >> c_rice_param)
710 *
711 * @param[in] c_rice_max
712 * max symbol val below which a suffix is coded as (u4_sym%(1<<c_rice_param))
713 * This is currently (4 << c_rice_param) for coeff_abs_level_remaining
714 *
715 * @return success or failure error code
716 *
717 ******************************************************************************
718 */
ihevcd_cabac_decode_bypass_bins_trunc_rice(cab_ctxt_t * ps_cabac,bitstrm_t * ps_bitstrm,WORD32 c_rice_param,WORD32 c_rice_max)719 UWORD32 ihevcd_cabac_decode_bypass_bins_trunc_rice(cab_ctxt_t *ps_cabac,
720 bitstrm_t *ps_bitstrm,
721 WORD32 c_rice_param,
722 WORD32 c_rice_max)
723 {
724 UWORD32 u4_sym;
725 WORD32 bin;
726 WORD32 c_max;
727 UWORD32 u4_suffix;
728 /* Sanity checks */
729 ASSERT((c_rice_param >= 0));
730
731
732 /* Decode prefix coded as TUnary */
733 c_max = c_rice_max >> c_rice_param;
734 u4_sym = 0;
735 do
736 {
737 IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);
738 u4_sym++;
739
740 }while(((WORD32)u4_sym < c_max) && bin);
741 u4_sym = u4_sym - 1 + bin;
742
743 /* If suffix is present, then decode c_rice_param number of bins */
744 if(c_rice_param)
745 {
746 IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, c_rice_param);
747
748 u4_sym = (u4_sym << c_rice_param) | u4_suffix;
749 }
750 return (u4_sym);
751 }
752