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
21 * ihevcd_parse_residual.c
22 *
23 * @brief
24 * Contains functions for parsing residual data at TU level
25 *
26 * @author
27 * Harish
28 *
29 * @par List of Functions:
30 *
31 * @remarks
32 * None
33 *
34 *******************************************************************************
35 */
36 /*****************************************************************************/
37 /* File Includes */
38 /*****************************************************************************/
39 #include <stdio.h>
40 #include <stddef.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <assert.h>
44
45 #include "ihevc_typedefs.h"
46 #include "iv.h"
47 #include "ivd.h"
48 #include "ihevcd_cxa.h"
49
50 #include "ihevc_defs.h"
51 #include "ihevc_debug.h"
52 #include "ihevc_structs.h"
53 #include "ihevc_macros.h"
54 #include "ihevc_platform_macros.h"
55
56 #include "ihevc_common_tables.h"
57 #include "ihevc_error.h"
58 #include "ihevc_cabac_tables.h"
59
60 #include "ihevcd_trace.h"
61 #include "ihevcd_defs.h"
62 #include "ihevcd_function_selector.h"
63 #include "ihevcd_structs.h"
64 #include "ihevcd_error.h"
65 #include "ihevcd_nal.h"
66 #include "ihevcd_bitstream.h"
67 #include "ihevcd_utils.h"
68 #include "ihevcd_parse_residual.h"
69 #include "ihevcd_cabac.h"
70
71 /**
72 *****************************************************************************
73 * @brief returns context increment for sig coeff based on csbf neigbour
74 * flags (bottom and right) and current coeff postion in 4x4 block
75 * See section 9.3.3.1.4 for details on this context increment
76 *
77 * input : neigbour csbf flags(bit0:rightcsbf, bit1:bottom csbf)
78 * coeff idx in raster order (0-15)
79 *
80 * output : context increment for sig coeff flag
81 *
82 *****************************************************************************
83 */
84 const UWORD8 gau1_ihevcd_sigcoeff_ctxtinc[3][4][16] =
85 {
86
87 {
88 /* nbr csbf = 0: sigCtx = (xP+yP == 0) ? 2 : (xP+yP < 3) ? 1: 0 */
89 { 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
90 /* nbr csbf = 1: sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1: 0 */
91 { 2, 1, 2, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 0, 0, 0 },
92 /* nbr csbf = 2: sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0 */
93 { 2, 2, 1, 2, 1, 0, 2, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
94 /* nbr csbf = 3: sigCtx = 2 */
95 { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
96 },
97 {
98 /* nbr csbf = 0: sigCtx = (xP+yP == 0) ? 2 : (xP+yP < 3) ? 1: 0 */
99 { 2, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
100 /* nbr csbf = 1: sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1: 0 */
101 { 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
102 /* nbr csbf = 2: sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0 */
103 { 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0 },
104 /* nbr csbf = 3: sigCtx = 2 */
105 { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
106 },
107 {
108 /* nbr csbf = 0: sigCtx = (xP+yP == 0) ? 2 : (xP+yP < 3) ? 1: 0 */
109 { 2, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
110 /* nbr csbf = 1: sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1: 0 */
111 { 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0 },
112 /* nbr csbf = 2: sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0 */
113 { 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
114 /* nbr csbf = 3: sigCtx = 2 */
115 { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
116 },
117
118
119 };
120
121
122
123 /**
124 *****************************************************************************
125 * @brief returns context increment for sig coeff for 4x4 tranform size as
126 * per Table 9-39 in section 9.3.3.1.4
127 *
128 * input : coeff idx in raster order (0-15)
129 *
130 * output : context increment for sig coeff flag
131 *
132 *****************************************************************************
133 */
134 const UWORD8 gau1_ihevcd_sigcoeff_ctxtinc_tr4[3][16] =
135 {
136 /* Upright diagonal scan */
137 {
138 0, 2, 1, 6,
139 3, 4, 7, 6,
140 4, 5, 7, 8,
141 5, 8, 8, 8,
142 },
143 /* Horizontal scan */
144 {
145 0, 1, 4, 5,
146 2, 3, 4, 5,
147 6, 6, 8, 8,
148 7, 7, 8, 8,
149 },
150 /* Vertical scan */
151 {
152 0, 2, 6, 7,
153 1, 3, 6, 7,
154 4, 4, 8, 8,
155 5, 5, 8, 8,
156 },
157 };
158
159
160 /**
161 *******************************************************************************
162 *
163 * @brief
164 * Parses Residual coding
165 *
166 * @par Description:
167 * Parses Residual coding as per Section:7.3.13
168 *
169 * @param[in] ps_codec
170 * Pointer to codec context
171 *
172 * @returns error code from IHEVCD_ERROR_T
173 *
174 * @remarks
175 *
176 *
177 *******************************************************************************
178 */
179
ihevcd_parse_residual_coding(codec_t * ps_codec,WORD32 x0,WORD32 y0,WORD32 log2_trafo_size,WORD32 c_idx,WORD32 intra_pred_mode)180 WORD32 ihevcd_parse_residual_coding(codec_t *ps_codec,
181 WORD32 x0, WORD32 y0,
182 WORD32 log2_trafo_size,
183 WORD32 c_idx,
184 WORD32 intra_pred_mode)
185 {
186 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
187 WORD32 transform_skip_flag;
188 WORD32 value;
189 pps_t *ps_pps;
190 WORD32 last_scan_pos, last_sub_blk;
191 bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;
192 WORD32 last_significant_coeff_x_prefix, last_significant_coeff_y_prefix;
193 WORD32 last_significant_coeff_x, last_significant_coeff_y;
194 const UWORD8 *pu1_scan_blk = NULL, *pu1_scan_coeff;
195 WORD32 scan_idx;
196 WORD32 i;
197 WORD32 sign_data_hiding_flag;
198 cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;
199 WORD32 gt1_ctxt = 1;
200 WORD32 c_max;
201 UWORD16 au2_csbf[9];
202 tu_sblk_coeff_data_t *ps_tu_sblk_coeff_data;
203 WORD8 *pi1_num_coded_subblks;
204 WORD32 num_subblks;
205 WORD32 sig_coeff_base_ctxt, abs_gt1_base_ctxt;
206 UNUSED(x0);
207 UNUSED(y0);
208 ps_pps = ps_codec->s_parse.ps_pps;
209
210 sign_data_hiding_flag = ps_pps->i1_sign_data_hiding_flag;
211 transform_skip_flag = 0;
212 if(ps_pps->i1_transform_skip_enabled_flag &&
213 !ps_codec->s_parse.s_cu.i4_cu_transquant_bypass &&
214 (log2_trafo_size == 2))
215 {
216 WORD32 ctxt_idx;
217
218 if(!c_idx)
219 {
220 ctxt_idx = IHEVC_CAB_TFM_SKIP0;
221 }
222 else
223 {
224 ctxt_idx = IHEVC_CAB_TFM_SKIP12;
225 }
226 TRACE_CABAC_CTXT("transform_skip_flag", ps_cabac->u4_range, ctxt_idx);
227 value = ihevcd_cabac_decode_bin(ps_cabac,
228 ps_bitstrm,
229 ctxt_idx);
230 AEV_TRACE("transform_skip_flag", value, ps_cabac->u4_range);
231 transform_skip_flag = value;
232 }
233
234 /* code the last_coeff_x_prefix as tunary binarized code */
235 {
236 WORD32 ctxt_idx_x, ctxt_idx_y, ctx_shift;
237 WORD32 ctx_offset;
238 c_max = (log2_trafo_size << 1) - 1;
239
240 if(!c_idx)
241 {
242 ctx_offset = (3 * (log2_trafo_size - 2)) + ((log2_trafo_size - 1) >> 2);
243 ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + ctx_offset;
244 ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + ctx_offset;
245 ctx_shift = (log2_trafo_size + 1) >> 2;
246 }
247 else
248 {
249 ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + 15;
250 ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + 15;
251 ctx_shift = log2_trafo_size - 2;
252 }
253
254 TRACE_CABAC_CTXT("last_coeff_x_prefix", ps_cabac->u4_range, ctxt_idx_x);
255 last_significant_coeff_x_prefix = ihevcd_cabac_decode_bins_tunary(ps_cabac,
256 ps_bitstrm,
257 c_max,
258 ctxt_idx_x,
259 ctx_shift,
260 c_max);
261
262 AEV_TRACE("last_coeff_x_prefix", last_significant_coeff_x_prefix, ps_cabac->u4_range);
263
264 TRACE_CABAC_CTXT("last_coeff_y_prefix", ps_cabac->u4_range, ctxt_idx_y);
265 last_significant_coeff_y_prefix = ihevcd_cabac_decode_bins_tunary(ps_cabac,
266 ps_bitstrm,
267 c_max,
268 ctxt_idx_y,
269 ctx_shift,
270 c_max);
271
272 AEV_TRACE("last_coeff_y_prefix", last_significant_coeff_y_prefix, ps_cabac->u4_range);
273
274
275 last_significant_coeff_x = last_significant_coeff_x_prefix;
276 if(last_significant_coeff_x_prefix > 3)
277 {
278 WORD32 suf_length = ((last_significant_coeff_x_prefix - 2) >> 1);
279
280 value = ihevcd_cabac_decode_bypass_bins(ps_cabac,
281 ps_bitstrm,
282 suf_length);
283
284 AEV_TRACE("last_coeff_x_suffix", value, ps_cabac->u4_range);
285
286
287 last_significant_coeff_x =
288 (1 << ((last_significant_coeff_x_prefix >> 1) - 1)) *
289 (2 + (last_significant_coeff_x_prefix & 1)) + value;
290 }
291
292
293 last_significant_coeff_y = last_significant_coeff_y_prefix;
294 if(last_significant_coeff_y_prefix > 3)
295 {
296 WORD32 suf_length = ((last_significant_coeff_y_prefix - 2) >> 1);
297 value = ihevcd_cabac_decode_bypass_bins(ps_cabac,
298 ps_bitstrm,
299 suf_length);
300
301 AEV_TRACE("last_coeff_y_suffix", value, ps_cabac->u4_range);
302 last_significant_coeff_y =
303 (1 << ((last_significant_coeff_y_prefix >> 1) - 1)) *
304 (2 + (last_significant_coeff_y_prefix & 1)) + value;
305 }
306
307 }
308
309 /* Choose a scan matrix based on intra flag, intra pred mode, transform size
310 and luma/chroma */
311 scan_idx = SCAN_DIAG_UPRIGHT;
312 if(PRED_MODE_INTRA == ps_codec->s_parse.s_cu.i4_pred_mode)
313 {
314 if((2 == log2_trafo_size) || ((3 == log2_trafo_size) && (0 == c_idx)))
315 {
316 if((6 <= intra_pred_mode) &&
317 (14 >= intra_pred_mode))
318 {
319 scan_idx = SCAN_VERT;
320 }
321 else if((22 <= intra_pred_mode) &&
322 (30 >= intra_pred_mode))
323 {
324 scan_idx = SCAN_HORZ;
325 }
326 }
327 }
328
329 /* In case the scan is vertical, then swap X and Y positions */
330 if(SCAN_VERT == scan_idx)
331 {
332 SWAP(last_significant_coeff_x, last_significant_coeff_y);
333 }
334
335 {
336 WORD8 *pi1_scan_idx;
337 WORD8 *pi1_buf = (WORD8 *)ps_codec->s_parse.pv_tu_coeff_data;
338
339 /* First WORD8 gives number of coded subblocks */
340 pi1_num_coded_subblks = pi1_buf++;
341
342 /* Set number of coded subblocks in the current TU to zero */
343 /* This will be updated later */
344 *pi1_num_coded_subblks = 0;
345
346 /* Second WORD8 gives (scan idx << 1) | trans_skip */
347 pi1_scan_idx = pi1_buf++;
348 *pi1_scan_idx = (scan_idx << 1) | transform_skip_flag;
349
350 /* Store the incremented pointer in pv_tu_coeff_data */
351 ps_codec->s_parse.pv_tu_coeff_data = pi1_buf;
352
353 }
354 /**
355 * Given last_significant_coeff_y and last_significant_coeff_x find last sub block
356 * This is done by ignoring lower two bits of last_significant_coeff_y and last_significant_coeff_x
357 * and using scan matrix for lookup
358 */
359
360 /* If transform is 4x4, last_sub_blk is zero */
361 last_sub_blk = 0;
362
363 /* If transform is larger than 4x4, then based on scan_idx and transform size, choose a scan table */
364
365 if(log2_trafo_size > 2)
366 {
367 WORD32 scan_pos;
368 WORD32 scan_mat_size;
369 pu1_scan_blk = (UWORD8 *)gapv_ihevc_scan[scan_idx * 3 + (log2_trafo_size - 2 - 1)];
370
371
372 /* Divide the current transform to 4x4 subblocks and count number of 4x4 in the first row */
373 /* This will be size of scan matrix to be used for subblock scanning */
374 scan_mat_size = 1 << (log2_trafo_size - 2);
375 scan_pos = ((last_significant_coeff_y >> 2) * scan_mat_size) +
376 (last_significant_coeff_x >> 2);
377
378 last_sub_blk = pu1_scan_blk[scan_pos];
379 }
380 pu1_scan_coeff = &gau1_ihevc_scan4x4[scan_idx][0];
381
382 {
383 WORD32 scan_pos;
384
385 scan_pos = ((last_significant_coeff_y & 3) << 2) +
386 (last_significant_coeff_x & 3);
387
388 last_scan_pos = pu1_scan_coeff[scan_pos];
389 }
390 if(log2_trafo_size > 2)
391 pu1_scan_blk = (UWORD8 *)gapv_ihevc_invscan[scan_idx * 3 + (log2_trafo_size - 2 - 1)];
392 pu1_scan_coeff = &gau1_ihevc_invscan4x4[scan_idx][0];
393
394 /* Set CSBF array to zero */
395 {
396 UWORD32 *pu4_csbf;
397 pu4_csbf = (void *)au2_csbf;
398 *pu4_csbf++ = 0;
399 *pu4_csbf++ = 0;
400 *pu4_csbf++ = 0;
401 *pu4_csbf = 0;
402 /* To avoid a check for y pos, 9th WORD16 in the array is set to zero */
403 au2_csbf[8] = 0;
404 }
405
406 /*************************************************************************/
407 /* derive base context index for sig coeff as per section 9.3.3.1.4 */
408 /* TODO; convert to look up based on luma/chroma, scan type and tfr size */
409 /*************************************************************************/
410 if(!c_idx)
411 {
412 sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;
413 abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG;
414
415 if(3 == log2_trafo_size)
416 {
417 /* 8x8 transform size */
418 sig_coeff_base_ctxt += (scan_idx == SCAN_DIAG_UPRIGHT) ? 9 : 15;
419 }
420 else if(3 < log2_trafo_size)
421 {
422 /* larger transform sizes */
423 sig_coeff_base_ctxt += 21;
424 }
425 }
426 else
427 {
428 /* chroma context initializations */
429 sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG + 27;
430 abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG + 16;
431
432 if(3 == log2_trafo_size)
433 {
434 /* 8x8 transform size */
435 sig_coeff_base_ctxt += 9;
436 }
437 else if(3 < log2_trafo_size)
438 {
439 /* larger transform sizes */
440 sig_coeff_base_ctxt += 12;
441 }
442 }
443 num_subblks = 0;
444 /* Parse each 4x4 subblocks */
445 for(i = last_sub_blk; i >= 0; i--)
446 {
447 WORD32 sub_blk_pos;
448 WORD32 infer_sig_coeff_flag;
449 WORD32 cur_csbf;
450
451 WORD32 n;
452 WORD32 num_coeff;
453 /* Sig coeff map for 16 entries in raster scan order. Upper 16 bits are used.
454 * MSB gives sig coeff flag for 0th coeff and so on
455 * UWORD16 would have been enough but kept as UWORD32 for code optimizations
456 * In arm unnecessary masking operations are saved
457 */
458 UWORD32 u4_sig_coeff_map_raster;
459 WORD32 sign_hidden;
460
461 /* Sig coeff map in scan order */
462 UWORD32 u4_sig_coeff_map;
463 WORD32 coeff_abs_level_greater2_flag;
464 UWORD32 u4_coeff_abs_level_greater1_map;
465 UWORD32 u4_coeff_abs_level_greater2_map;
466 UWORD32 u4_coeff_sign_map;
467 WORD32 first_sig_scan_pos, last_sig_scan_pos, num_greater1_flag, first_greater1_scan_pos;
468 WORD32 num_sig_coeff, sum_abs_level;
469 WORD32 nbr_csbf;
470
471
472 WORD32 ctxt_set;
473 WORD32 rice_param;
474 WORD32 xs, ys;
475
476
477 sub_blk_pos = 0;
478 if(i && (log2_trafo_size > 2))
479 sub_blk_pos = pu1_scan_blk[i];
480
481 /* Get xs and ys from scan position */
482 /* This is needed for context modelling of significant coeff flag */
483 xs = sub_blk_pos & ((1 << (log2_trafo_size - 2)) - 1);
484 ys = sub_blk_pos >> (log2_trafo_size - 2);
485
486
487 /* Check if neighbor subblocks are coded */
488 {
489
490 nbr_csbf = 0;
491
492 /* Get Bottom sub blocks CSBF */
493 nbr_csbf |= (au2_csbf[ys + 1] >> xs) & 1;
494 nbr_csbf <<= 1;
495
496 /* Get Right sub blocks CSBF */
497 /* Even if xs is equal to (1 << (log2_trafo_size - 2 )) - 1,
498 since au2_csbf is set to zero at the beginning, csbf for
499 neighbor will be read as 0 */
500
501 nbr_csbf |= (au2_csbf[ys] >> (xs + 1)) & 1;
502
503
504 }
505 cur_csbf = 0;
506
507 /* DC coeff is inferred, only if coded_sub_block is explicitly parsed as 1 */
508 /* i.e. it is not inferred for first and last subblock */
509 infer_sig_coeff_flag = 0;
510 if((i < last_sub_blk) && (i > 0))
511 {
512 WORD32 ctxt_idx = IHEVC_CAB_CODED_SUBLK_IDX;
513
514 /* ctxt based on right / bottom avail csbf, section 9.3.3.1.3 */
515 ctxt_idx += (nbr_csbf) ? 1 : 0;
516
517 /* Ctxt based on luma or chroma */
518 ctxt_idx += c_idx ? 2 : 0;
519 TRACE_CABAC_CTXT("coded_sub_block_flag", ps_cabac->u4_range, ctxt_idx);
520 IHEVCD_CABAC_DECODE_BIN(cur_csbf, ps_cabac, ps_bitstrm, ctxt_idx);
521 AEV_TRACE("coded_sub_block_flag", cur_csbf, ps_cabac->u4_range);
522
523 infer_sig_coeff_flag = 1;
524 }
525 else /* if((i == last_sub_blk) || (sub_blk_pos == 0)) */
526 {
527 /* CSBF is set to 1 for first and last subblock */
528 /* Note for these subblocks sig_coeff_map is not inferred but instead parsed */
529 cur_csbf = 1;
530 }
531
532 /* Set current sub blocks CSBF */
533 {
534 UWORD32 u4_mask = 1 << xs;
535 if(cur_csbf)
536 au2_csbf[ys] |= u4_mask;
537 else
538 au2_csbf[ys] &= ~u4_mask;
539
540 }
541
542 /* If current subblock is not coded, proceed to the next subblock */
543 if(0 == cur_csbf)
544 continue;
545
546 n = 15;
547 u4_sig_coeff_map_raster = 0;
548 u4_sig_coeff_map = 0;
549 num_coeff = 0;
550 if(i == last_sub_blk)
551 {
552 WORD32 pos = ((last_significant_coeff_y & 3) << 2) +
553 (last_significant_coeff_x & 3);
554 n = (last_scan_pos - 1);
555 /* Set Significant coeff map for last significant coeff flag as 1 */
556 u4_sig_coeff_map_raster = 1 << pos;
557 u4_sig_coeff_map = 1 << last_scan_pos;
558 num_coeff = 1;
559 }
560
561 for(; n >= 0; n--)
562 {
563 WORD32 significant_coeff_flag;
564
565 if((n > 0 || !infer_sig_coeff_flag))
566 {
567 //WORD32 coeff_pos;
568 WORD32 sig_ctxinc;
569 WORD32 ctxt_idx;
570
571 /* Coefficient position is needed for deriving context index for significant_coeff_flag */
572 //coeff_pos = pu1_scan_coeff[n];
573 /* derive the context inc as per section 9.3.3.1.4 */
574 sig_ctxinc = 0;
575 if(2 == log2_trafo_size)
576 {
577
578 /* 4x4 transform size increment uses lookup */
579 sig_ctxinc = gau1_ihevcd_sigcoeff_ctxtinc_tr4[scan_idx][n];
580 }
581 else if(n || i)
582 {
583 /* ctxt for AC coeff depends on curpos and neigbour csbf */
584 sig_ctxinc = gau1_ihevcd_sigcoeff_ctxtinc[scan_idx][nbr_csbf][n];
585
586 /* based on luma subblock pos */
587 sig_ctxinc += (i && (!c_idx)) ? 3 : 0;
588
589 }
590 else
591 {
592 /* DC coeff has fixed context for luma and chroma */
593 sig_coeff_base_ctxt = (0 == c_idx) ? IHEVC_CAB_COEFF_FLAG :
594 (IHEVC_CAB_COEFF_FLAG + 27);
595 }
596
597 ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;
598 TRACE_CABAC_CTXT("significant_coeff_flag", ps_cabac->u4_range, ctxt_idx);
599 IHEVCD_CABAC_DECODE_BIN(significant_coeff_flag, ps_cabac,
600 ps_bitstrm,
601 ctxt_idx);
602 AEV_TRACE("significant_coeff_flag", significant_coeff_flag, ps_cabac->u4_range);
603
604
605 /* If at least one non-zero coeff is signalled then do not infer sig coeff map */
606 /* for (0,0) coeff in the current sub block */
607 if(significant_coeff_flag)
608 infer_sig_coeff_flag = 0;
609
610 // u4_sig_coeff_map_raster |= significant_coeff_flag
611 // << coeff_pos;
612 u4_sig_coeff_map |= significant_coeff_flag << n;
613 num_coeff += significant_coeff_flag;
614 }
615
616
617 }
618 /*********************************************************************/
619 /* If infer_sig_coeff_flag is 1 then treat the 0th coeff as non zero */
620 /* If infer_sig_coeff_flag is zero, then last significant_coeff_flag */
621 /* is parsed in the above loop */
622 /*********************************************************************/
623 if(infer_sig_coeff_flag)
624 {
625 u4_sig_coeff_map_raster |= 1;
626 u4_sig_coeff_map |= 1;
627 num_coeff++;
628 }
629
630 /*********************************************************************/
631 /* First subblock does not get an explicit csbf. It is assumed to */
632 /* be 1. For this subblock there is chance of getting all */
633 /* sig_coeff_flags to be zero. In such a case proceed to the next */
634 /* subblock(which is end of parsing for the current transform block) */
635 /*********************************************************************/
636
637 if(0 == num_coeff)
638 continue;
639
640 /* Increment number of coded subblocks for the current TU */
641 num_subblks++;
642
643 /* Set sig coeff map and subblock position */
644 ps_tu_sblk_coeff_data = (tu_sblk_coeff_data_t *)ps_codec->s_parse.pv_tu_coeff_data;
645 ps_tu_sblk_coeff_data->u2_sig_coeff_map = u4_sig_coeff_map;
646 ps_tu_sblk_coeff_data->u2_subblk_pos = (ys << 8) | xs;
647
648 first_sig_scan_pos = 16;
649 last_sig_scan_pos = -1;
650 num_greater1_flag = 0;
651 first_greater1_scan_pos = -1;
652 u4_coeff_abs_level_greater1_map = 0;
653
654
655 /* context set based on luma subblock pos */
656 ctxt_set = (i && (!c_idx)) ? 2 : 0;
657
658 /* See section 9.3.3.1.5 */
659 ctxt_set += (0 == gt1_ctxt) ? 1 : 0;
660
661 gt1_ctxt = 1;
662 /* Instead of initializing n to 15, set it to 31-CLZ(sig coeff map) */
663 {
664 UWORD32 u4_sig_coeff_map_shift;
665 UWORD32 clz;
666 clz = CLZ(u4_sig_coeff_map);
667 n = 31 - clz;
668 u4_sig_coeff_map_shift = u4_sig_coeff_map << clz;
669 /* For loop for n changed to do while to break early if sig_coeff_map_shift becomes zero */
670 do
671 {
672 //WORD32 coeff_pos;
673 WORD32 ctxt_idx;
674
675 //TODO: Scan lookup will be removed later and instead u4_sig_coeff_map will be used
676 //coeff_pos = pu1_scan_coeff[n];
677
678 if((u4_sig_coeff_map_shift >> 31) & 1)
679 {
680
681 /* abs_level_greater1_flag is sent for only first 8 non-zero levels in a subblock */
682 if(num_greater1_flag < 8)
683 {
684 WORD32 coeff_abs_level_greater1_flag;
685
686 ctxt_idx = (ctxt_set * 4) + abs_gt1_base_ctxt + gt1_ctxt;
687
688 TRACE_CABAC_CTXT("coeff_abs_level_greater1_flag", ps_cabac->u4_range, ctxt_idx);
689 IHEVCD_CABAC_DECODE_BIN(coeff_abs_level_greater1_flag, ps_cabac, ps_bitstrm, ctxt_idx);
690 AEV_TRACE("coeff_abs_level_greater1_flag", coeff_abs_level_greater1_flag, ps_cabac->u4_range);
691
692 u4_coeff_abs_level_greater1_map |= coeff_abs_level_greater1_flag << n;
693 num_greater1_flag++;
694
695 /* first_greater1_scan_pos is obtained using CLZ on u4_coeff_abs_level_greater1_map*/
696 /* outside the loop instead of the following check inside the loop */
697 /* if( coeff_abs_level_greater1_flag && first_greater1_scan_pos == -1) */
698 /* first_greater1_scan_pos = n; */
699
700 if(coeff_abs_level_greater1_flag)
701 {
702 gt1_ctxt = 0;
703 }
704 else if(gt1_ctxt && (gt1_ctxt < 3))
705 {
706 gt1_ctxt++;
707 }
708
709 }
710 else
711 break;
712
713 /* instead of computing last and first significan scan position using checks below */
714 /* They are computed outside the loop using CLZ and CTZ on sig_coeff_map */
715 /* if(last_sig_scan_pos == -1) */
716 /* last_sig_scan_pos = n; */
717 /* first_sig_scan_pos = n; */
718 }
719 u4_sig_coeff_map_shift <<= 1;
720 n--;
721 /* If there are zero coeffs, then shift by as many zero coeffs and decrement n */
722 clz = CLZ(u4_sig_coeff_map_shift);
723 u4_sig_coeff_map_shift <<= clz;
724 n -= clz;
725 }while(u4_sig_coeff_map_shift);
726 }
727 /* At this level u4_sig_coeff_map is non-zero i.e. has atleast one non-zero coeff */
728 last_sig_scan_pos = (31 - CLZ(u4_sig_coeff_map));
729 first_sig_scan_pos = CTZ(u4_sig_coeff_map);
730 sign_hidden = (((last_sig_scan_pos - first_sig_scan_pos) > 3) && !ps_codec->s_parse.s_cu.i4_cu_transquant_bypass);
731
732 u4_coeff_abs_level_greater2_map = 0;
733
734 if(u4_coeff_abs_level_greater1_map)
735 {
736 /* Check if the first level > 1 is greater than 2 */
737 WORD32 ctxt_idx;
738 first_greater1_scan_pos = (31 - CLZ(u4_coeff_abs_level_greater1_map));
739
740
741 ctxt_idx = IHEVC_CAB_COEFABS_GRTR2_FLAG;
742
743 ctxt_idx += (!c_idx) ? ctxt_set : (ctxt_set + 4);
744 TRACE_CABAC_CTXT("coeff_abs_level_greater2_flag", ps_cabac->u4_range, ctxt_idx);
745 IHEVCD_CABAC_DECODE_BIN(coeff_abs_level_greater2_flag, ps_cabac, ps_bitstrm, ctxt_idx);
746 AEV_TRACE("coeff_abs_level_greater2_flag", coeff_abs_level_greater2_flag, ps_cabac->u4_range);
747 u4_coeff_abs_level_greater2_map = coeff_abs_level_greater2_flag << first_greater1_scan_pos;
748 }
749
750
751 u4_coeff_sign_map = 0;
752
753 /* Parse sign flags */
754 if(!sign_data_hiding_flag || !sign_hidden)
755 {
756 IHEVCD_CABAC_DECODE_BYPASS_BINS(value, ps_cabac, ps_bitstrm, num_coeff);
757 AEV_TRACE("sign_flags", value, ps_cabac->u4_range);
758 u4_coeff_sign_map = value << (32 - num_coeff);
759 }
760 else
761 {
762 IHEVCD_CABAC_DECODE_BYPASS_BINS(value, ps_cabac, ps_bitstrm, (num_coeff - 1));
763 AEV_TRACE("sign_flags", value, ps_cabac->u4_range);
764 u4_coeff_sign_map = value << (32 - (num_coeff - 1));
765 }
766
767 num_sig_coeff = 0;
768 sum_abs_level = 0;
769 rice_param = 0;
770 {
771 UWORD32 clz;
772 UWORD32 u4_sig_coeff_map_shift;
773 clz = CLZ(u4_sig_coeff_map);
774 n = 31 - clz;
775 u4_sig_coeff_map_shift = u4_sig_coeff_map << clz;
776 /* For loop for n changed to do while to break early if sig_coeff_map_shift becomes zero */
777 do
778 {
779
780 if((u4_sig_coeff_map_shift >> 31) & 1)
781 {
782 WORD32 base_lvl;
783 WORD32 coeff_abs_level_remaining;
784 WORD32 level;
785 base_lvl = 1;
786
787 /* Update base_lvl if it is greater than 1 */
788 if((u4_coeff_abs_level_greater1_map >> n) & 1)
789 base_lvl++;
790
791 /* Update base_lvl if it is greater than 2 */
792 if((u4_coeff_abs_level_greater2_map >> n) & 1)
793 base_lvl++;
794
795 /* If level is greater than 3/2/1 based on the greater1 and greater2 maps,
796 * decode remaining level (level - base_lvl) will be signalled as bypass bins
797 */
798 coeff_abs_level_remaining = 0;
799 if(base_lvl == ((num_sig_coeff < 8) ? ((n == first_greater1_scan_pos) ? 3 : 2) : 1))
800 {
801 UWORD32 u4_prefix;
802 WORD32 bin;
803
804 u4_prefix = 0;
805
806 do
807 {
808 IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);
809 u4_prefix++;
810
811 if((WORD32)u4_prefix == 19 - rice_param)
812 {
813 bin = 1;
814 break;
815 }
816
817 }while(bin);
818
819 u4_prefix = u4_prefix - 1;
820 if(u4_prefix < 3)
821 {
822 UWORD32 u4_suffix;
823
824 coeff_abs_level_remaining = (u4_prefix << rice_param);
825 if(rice_param)
826 {
827 IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, rice_param);
828
829 coeff_abs_level_remaining |= u4_suffix;
830 }
831 }
832 else
833 {
834 UWORD32 u4_suffix;
835 UWORD32 u4_numbins;
836
837 //u4_prefix = CLIP3(u4_prefix, 0, 19 - rice_param);
838
839 u4_numbins = (u4_prefix - 3 + rice_param);
840 coeff_abs_level_remaining = (((1 << (u4_prefix - 3)) + 3 - 1) << rice_param);
841 if(u4_numbins)
842 {
843 IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, u4_numbins);
844 coeff_abs_level_remaining += u4_suffix;
845 }
846 }
847
848
849 AEV_TRACE("coeff_abs_level_remaining", coeff_abs_level_remaining, ps_cabac->u4_range);
850 base_lvl += coeff_abs_level_remaining;
851
852 }
853
854 /* update the rice param based on coeff level */
855 if((base_lvl > (3 << rice_param)) && (rice_param < 4))
856 {
857 rice_param++;
858 }
859
860 /* Compute absolute level */
861 level = base_lvl;
862
863 /* Update level with the sign */
864 if((u4_coeff_sign_map >> 31) & 1)
865 level = -level;
866
867 u4_coeff_sign_map <<= 1;
868 /* Update sign in case sign is hidden */
869 if(sign_data_hiding_flag && sign_hidden)
870 {
871 sum_abs_level += base_lvl;
872
873 if(n == first_sig_scan_pos && ((sum_abs_level % 2) == 1))
874 level = -level;
875 }
876
877 /* Store the resulting level in non-zero level array */
878 ps_tu_sblk_coeff_data->ai2_level[num_sig_coeff++] = level;
879 //AEV_TRACE("level", level, 0);
880 }
881 u4_sig_coeff_map_shift <<= 1;
882 n--;
883 /* If there are zero coeffs, then shift by as many zero coeffs and decrement n */
884 clz = CLZ(u4_sig_coeff_map_shift);
885 u4_sig_coeff_map_shift <<= clz;
886 n -= clz;
887
888
889 }while(u4_sig_coeff_map_shift);
890 }
891
892 /* Increment the pv_tu_sblk_coeff_data */
893 {
894 UWORD8 *pu1_buf = (UWORD8 *)ps_codec->s_parse.pv_tu_coeff_data;
895 pu1_buf += sizeof(tu_sblk_coeff_data_t) - SUBBLK_COEFF_CNT * sizeof(WORD16);
896 pu1_buf += num_coeff * sizeof(WORD16);
897 ps_codec->s_parse.pv_tu_coeff_data = pu1_buf;
898
899 }
900
901 }
902 /* Set number of coded sub blocks in the current TU */
903 *pi1_num_coded_subblks = num_subblks;
904
905 return ret;
906 }
907