Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libavc / refs/heads/int/p/fp2 / . / decoder / ih264d_parse_cavlc.c
blob: b6a0125bd0916998b8c085383eaf5b89888ece42 [file] [log] [blame]
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]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_parse_cavlc.c
23 *
24 * \brief
25 * This file contains UVLC related functions.
26 *
27 * \date
28 * 20/11/2002
29 *
30 * \author NS
31 ***************************************************************************
32 */
33
34#include <string.h>
35#include <stdio.h>
36
37#include "ih264d_bitstrm.h"
38#include "ih264d_parse_cavlc.h"
39#include "ih264d_error_handler.h"
40#include "ih264d_defs.h"
41#include "ih264d_debug.h"
42#include "ih264d_cabac.h"
43#include "ih264d_structs.h"
44#include "ih264d_tables.h"
45#include "ih264d_tables.h"
46#include "ih264d_mb_utils.h"
47
48void ih264d_unpack_coeff4x4_dc_4x4blk(tu_sblk4x4_coeff_data_t *ps_tu_4x4,
49 WORD16 *pi2_out_coeff_data,
50 UWORD8 *pu1_inv_scan);
51
52/*****************************************************************************/
53/* */
54/* Function Name : ih264d_uev */
55/* */
56/* Description : Reads the unsigned Exp Golomb codec syntax from the */
57/* ps_bitstrm as specified in section 9.1 of H264 standard */
58/* It also increases bitstream u4_ofst by the number of bits */
59/* parsed for UEV decode operation */
60/* */
61/* Inputs : bitstream base pointer and bitsream u4_ofst in bits */
62/* Globals : None */
63/* Processing : */
64/* Outputs : UEV decoded syntax element and incremented ps_bitstrm u4_ofst */
65/* Returns : UEV decoded syntax element */
66/* */
67/* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */
68/* for performamce. Caller might have to do error resilence */
69/* check for bitstream overflow */
70/* */
71/* Revision History: */
72/* */
73/* DD MM YYYY Author(s) Changes (Describe the changes made) */
74/* 19 09 2008 Jay Draft */
75/* */
76/*****************************************************************************/
77UWORD32 ih264d_uev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
78{
79 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
80 UWORD32 u4_word, u4_ldz;
81
82 /***************************************************************/
83 /* Find leading zeros in next 32 bits */
84 /***************************************************************/
85 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
86 u4_ldz = CLZ(u4_word);
87 /* Flush the ps_bitstrm */
88 u4_bitstream_offset += (u4_ldz + 1);
89 /* Read the suffix from the ps_bitstrm */
90 u4_word = 0;
91 if(u4_ldz)
92 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
93 *pu4_bitstrm_ofst = u4_bitstream_offset;
94 return ((1 << u4_ldz) + u4_word - 1);
95}
96
97/*****************************************************************************/
98/* */
99/* Function Name : ih264d_sev */
100/* */
101/* Description : Reads the signed Exp Golomb codec syntax from the ps_bitstrm */
102/* as specified in section 9.1 of H264 standard. */
103/* It also increases bitstream u4_ofst by the number of bits */
104/* parsed for SEV decode operation */
105/* */
106/* Inputs : bitstream base pointer and bitsream u4_ofst in bits */
107/* Globals : None */
108/* Processing : */
109/* Outputs : SEV decoded syntax element and incremented ps_bitstrm u4_ofst */
110/* Returns : SEV decoded syntax element */
111/* */
112/* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */
113/* for performamce. Caller might have to do error resilence */
114/* check for bitstream overflow */
115/* */
116/* Revision History: */
117/* */
118/* DD MM YYYY Author(s) Changes (Describe the changes made) */
119/* 19 09 2008 Jay Draft */
120/* */
121/*****************************************************************************/
122WORD32 ih264d_sev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
123{
124 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
125 UWORD32 u4_word, u4_ldz, u4_abs_val;
126
127 /***************************************************************/
128 /* Find leading zeros in next 32 bits */
129 /***************************************************************/
130 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
131 u4_ldz = CLZ(u4_word);
132
133 /* Flush the ps_bitstrm */
134 u4_bitstream_offset += (u4_ldz + 1);
135
136 /* Read the suffix from the ps_bitstrm */
137 u4_word = 0;
138 if(u4_ldz)
139 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
140
141 *pu4_bitstrm_ofst = u4_bitstream_offset;
142 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
143
144 if(u4_word & 0x1)
145 return (-(WORD32)u4_abs_val);
146 else
147 return (u4_abs_val);
148}
149
150/*****************************************************************************/
151/* */
152/* Function Name : get_tev_range_1 */
153/* */
154/* Description : Reads the TEV Exp Golomb codec syntax from the ps_bitstrm */
155/* as specified in section 9.1 of H264 standard. This will */
156/* called only when the input range is 1 for TEV decode. */
157/* If range is more than 1, then UEV decode is done */
158/* */
159/* Inputs : bitstream base pointer and bitsream u4_ofst in bits */
160/* Globals : None */
161/* Processing : */
162/* Outputs : TEV decoded syntax element and incremented ps_bitstrm u4_ofst */
163/* Returns : TEV decoded syntax element */
164/* */
165/* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */
166/* for performamce. Caller might have to do error resilence */
167/* check for bitstream overflow */
168/* */
169/* Revision History: */
170/* */
171/* DD MM YYYY Author(s) Changes (Describe the changes made) */
172/* 19 09 2008 Jay Draft */
173/* */
174/*****************************************************************************/
175UWORD32 ih264d_tev_range1(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
176{
177 UWORD32 u4_code;
178 GETBIT(u4_code, *pu4_bitstrm_ofst, pu4_bitstrm_buf);
179 return (!u4_code);
180}
181
182/*!
183 **************************************************************************
184 * \if Function name : ih264d_uvlc \endif
185 *
186 * \brief
187 *
188 * Reads the unsigned/signed/truncated integer Exp-Golomb-coded syntax element
189 * with the left bit first. The parsing process for this descriptor is specified
190 * in subclause 9.1.
191 *
192 * \param ps_bitstrm : Pointer to Bitstream Structure .
193 * \param u4_range : Range value in case of Truncated Exp-Golomb-code
194 * \param pi_bitstrm_ofst : Pointer to the local copy of Bitstream u4_ofst
195 * \param u1_flag : Flag indicating the case of UEV,SEV or TEV
196 * \param u4_bitstrm_ofst : Local copy of Bitstream u4_ofst
197 * \param pu4_bitstrm_buf : Pointer to the Bitstream buffer
198 *
199 * \return
200 * Returns Code Value.
201 *
202 **************************************************************************
203 */
204
205WORD32 ih264d_uvlc(dec_bit_stream_t *ps_bitstrm,
206 UWORD32 u4_range,
207 UWORD32 *pi_bitstrm_ofst,
208 UWORD8 u1_flag,
209 UWORD32 u4_bitstrm_ofst,
210 UWORD32 *pu4_bitstrm_buf)
211{
212 UWORD32 word, word2, cur_bit, cur_word, code_val, code_num, clz;
213
214 SWITCHOFFTRACE;
215 cur_bit = u4_bitstrm_ofst & 0x1F;
216 cur_word = u4_bitstrm_ofst >> 5;
217 word = pu4_bitstrm_buf[cur_word];
218 word2 = pu4_bitstrm_buf[cur_word + 1];
219
220 if(cur_bit != 0)
221 {
222 word <<= cur_bit;
223 word2 >>= (32 - cur_bit);
224 word |= word2;
225 }
226
227 if(u1_flag == TEV && u4_range == 1)
228 {
229 word >>= 31;
230 word = 1 - word;
231 (*pi_bitstrm_ofst)++;
232 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;
233 return (WORD32)word;
234 }
235
236 //finding clz
237 {
238 UWORD32 ui32_code, ui32_mask;
239
240 ui32_code = word;
241 ui32_mask = 0x80000000;
242 clz = 0;
243
244 /* DSP implements this with LMBD instruction */
245 /* so there we don't need to break the loop */
246 while(!(ui32_code & ui32_mask))
247 {
248 clz++;
249 ui32_mask >>= 1;
250 if(0 == ui32_mask)
251 break;
252 }
253 }
254
255 if(clz == 0)
256 {
257 *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1;
258 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;
259 return 0;
260 }
261
262 word <<= (clz + 1);
263 word >>= (32 - clz);
264 code_num = (1 << clz) + word - 1;
265 *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1;
266 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;
267
268 if(u1_flag == TEV || u1_flag == UEV)
269 return (WORD32)code_num;
270
271 code_val = (code_num + 1) >> 1;
272 if(!(code_num & 0x01))
273 return -((WORD32)code_val);
274 return (WORD32)code_val;
275
276}
277
278/*****************************************************************************/
279/* */
280/* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_1 */
281/* */
282/* Description : This function does cavlc decoding of 4x4 block residual */
283/* coefficient when total coeff is equal to 1. The parsing */
284/* is done as defined in section 9.2.2 and 9.2.3 of the */
285/* H264 standard. */
286/* */
287/* Inputs : <What inputs does the function take?> */
288/* Globals : <Does it use any global variables?> */
289/* Processing : <Describe how the function operates - include algorithm */
290/* description> */
291/* Outputs : <What does the function produce?> */
292/* Returns : <What does the function return?> */
293/* */
294/* Issues : <List any issues or problems with this function> */
295/* */
296/* Revision History: */
297/* */
298/* DD MM YYYY Author(s) Changes (Describe the changes made) */
299/* 25 09 2008 Jay Draft */
300/* */
301/*****************************************************************************/
302WORD32 ih264d_cavlc_4x4res_block_totalcoeff_1(UWORD32 u4_isdc,
303 UWORD32 u4_total_coeff_trail_one,
304 dec_bit_stream_t *ps_bitstrm)
305{
306
307 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
308 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
309 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
310 WORD32 i2_level;
311 UWORD32 u4_tot_zero, u4_ldz, u4_scan_pos;
312
313 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
314 WORD16 *pi2_coeff_data;
315 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
316
317 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
318 ps_tu_4x4->u2_sig_coeff_map = 0;
319 pi2_coeff_data = &ps_tu_4x4->ai2_level[0];
320
321
322 if(u4_trailing_ones)
323 {
324 UWORD32 u4_sign;
325 /****************************************************************/
326 /* Decode Trailing One as in section 9.2.2 */
327 /****************************************************************/
328 GETBIT(u4_sign, u4_bitstream_offset, pu4_bitstrm_buf);
329 i2_level = u4_sign ? -1 : 1;
330 }
331 else
332 {
333 /****************************************************************/
334 /* Decoding Level based on prefix and suffix as in 9.2.2 */
335 /****************************************************************/
336 UWORD32 u4_lev_suffix, u4_lev_suffix_size;
337 WORD32 u2_lev_code, u2_abs_value;
338 UWORD32 u4_lev_prefix;
339 /***************************************************************/
340 /* Find leading zeros in next 32 bits */
341 /***************************************************************/
342 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
343 pu4_bitstrm_buf);
344 u2_lev_code = (2 + MIN(u4_lev_prefix, 15));
345
346 if(14 == u4_lev_prefix)
347 u4_lev_suffix_size = 4;
348 else if(15 <= u4_lev_prefix)
349 {
350 u2_lev_code += 15;
351 u4_lev_suffix_size = u4_lev_prefix - 3;
352 }
353 else
354 u4_lev_suffix_size = 0;
355
356 //HP_LEVEL_PREFIX
357 if(16 <= u4_lev_prefix)
358 {
359 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
360 }
361 if(u4_lev_suffix_size)
362 {
363 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
364 u4_lev_suffix_size);
365 u2_lev_code += u4_lev_suffix;
366 }
367
368 u2_abs_value = (u2_lev_code + 2) >> 1;
369 /*********************************************************/
370 /* If Level code is odd, level is negative else positive */
371 /*********************************************************/
372 i2_level = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
373
374 }
375
376 /****************************************************************/
377 /* Decoding total zeros as in section 9.2.3, table 9.7 */
378 /****************************************************************/
379 FIND_ONE_IN_STREAM_LEN(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf, 8);
380
381 if(u4_ldz)
382 {
383 GETBIT(u4_tot_zero, u4_bitstream_offset, pu4_bitstrm_buf);
384 u4_tot_zero = (u4_ldz << 1) - u4_tot_zero;
385 }
386 else
387 u4_tot_zero = 0;
388
389 /***********************************************************************/
390 /* Inverse scan and store residual coeff. Update the bitstream u4_ofst */
391 /***********************************************************************/
392 u4_scan_pos = u4_tot_zero + u4_isdc;
393 if(u4_scan_pos > 15)
394 return -1;
395
396 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
397 *pi2_coeff_data++ = i2_level;
398
399
400 {
401 WORD32 offset;
402 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
403 offset = ALIGN4(offset);
404 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
405 }
406
407 ps_bitstrm->u4_ofst = u4_bitstream_offset;
408 return 0;
409}
410
411/*****************************************************************************/
412/* */
413/* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_2to10 */
414/* */
415/* Description : This function does cavlc decoding of 4x4 block residual */
416/* coefficient when total coeffs are between two and ten */
417/* inclusive. Parsing is done as defined in section 9.2.2 */
418/* and 9.2.3 the H264 standard. */
419/* */
420/* Inputs : <What inputs does the function take?> */
421/* Globals : <Does it use any global variables?> */
422/* Processing : <Describe how the function operates - include algorithm */
423/* description> */
424/* Outputs : <What does the function produce?> */
425/* Returns : <What does the function return?> */
426/* */
427/* Issues : <List any issues or problems with this function> */
428/* */
429/* Revision History: */
430/* */
431/* DD MM YYYY Author(s) Changes (Describe the changes made) */
432/* 25 09 2008 Jay Draft */
433/* */
434/*****************************************************************************/
435
436WORD32 ih264d_cavlc_4x4res_block_totalcoeff_2to10(UWORD32 u4_isdc,
437 UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/
438 dec_bit_stream_t *ps_bitstrm)
439{
440 UWORD32 u4_total_zeroes;
441 WORD32 i;
442 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
443 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
444 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
445 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
Harish Mahendrakaref3da4e2016-02-17 18:06:36 +0530[diff] [blame]446 // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3)
447 // since u4_trailing_ones can at the max be 3. This will be required when
448 // u4_total_coeff is less than u4_trailing_ones
449 WORD16 ai2_level_arr[19];
450 WORD16 *i2_level_arr = &ai2_level_arr[3];
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]451
452 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
453 WORD16 *pi2_coeff_data;
454 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
455
456 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
457 ps_tu_4x4->u2_sig_coeff_map = 0;
458 pi2_coeff_data = &ps_tu_4x4->ai2_level[0];
459
460 i = u4_total_coeff - 1;
461
462 if(u4_trailing_ones)
463 {
464 /*********************************************************************/
465 /* Decode Trailing Ones */
466 /* read the sign of T1's and put them in level array */
467 /*********************************************************************/
468 UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
469 WORD16 (*ppi2_trlone_lkup)[3] =
470 (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
471 WORD16 *pi2_trlone_lkup;
472
473 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);
474
475 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];
476
477 while(u4_cnt--)
478 i2_level_arr[i--] = *pi2_trlone_lkup++;
479 }
480
481 /****************************************************************/
482 /* Decoding Levels Begins */
483 /****************************************************************/
484 if(i >= 0)
485 {
486 /****************************************************************/
487 /* First level is decoded outside the loop as it has lot of */
488 /* special cases. */
489 /****************************************************************/
490 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
491 WORD32 u2_lev_code, u2_abs_value;
492 UWORD32 u4_lev_prefix;
493
494 /***************************************************************/
495 /* u4_suffix_len = 0, Find leading zeros in next 32 bits */
496 /***************************************************************/
497 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
498 pu4_bitstrm_buf);
499
500 /*********************************************************/
501 /* Special decoding case when trailing ones are 3 */
502 /*********************************************************/
503 u2_lev_code = MIN(15, u4_lev_prefix);
504
505 u2_lev_code += (3 == u4_trailing_ones) ? 0 : 2;
506
507 if(14 == u4_lev_prefix)
508 u4_lev_suffix_size = 4;
509 else if(15 <= u4_lev_prefix)
510 {
511 u2_lev_code += 15;
512 u4_lev_suffix_size = u4_lev_prefix - 3;
513 }
514 else
515 u4_lev_suffix_size = 0;
516
517 //HP_LEVEL_PREFIX
518 if(16 <= u4_lev_prefix)
519 {
520 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
521 }
522 if(u4_lev_suffix_size)
523 {
524 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
525 u4_lev_suffix_size);
526 u2_lev_code += u4_lev_suffix;
527 }
528
529 u2_abs_value = (u2_lev_code + 2) >> 1;
530 /*********************************************************/
531 /* If Level code is odd, level is negative else positive */
532 /*********************************************************/
533 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
534
535 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;
536
537 /*********************************************************/
538 /* Now loop over the remaining levels */
539 /*********************************************************/
540 while(i >= 0)
541 {
542
543 /***************************************************************/
544 /* Find leading zeros in next 32 bits */
545 /***************************************************************/
546 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
547 pu4_bitstrm_buf);
548
549 u4_lev_suffix_size =
550 (15 <= u4_lev_prefix) ?
551 (u4_lev_prefix - 3) : u4_suffix_len;
552
553 /*********************************************************/
554 /* Compute level code using prefix and suffix */
555 /*********************************************************/
556 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
557 u4_lev_suffix_size);
558 u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len)
559 + u4_lev_suffix;
560
561 //HP_LEVEL_PREFIX
562 if(16 <= u4_lev_prefix)
563 {
564 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
565 }
566 u2_abs_value = (u2_lev_code + 2) >> 1;
567
568 /*********************************************************/
569 /* If Level code is odd, level is negative else positive */
570 /*********************************************************/
571 i2_level_arr[i--] =
572 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
573
574 /*********************************************************/
575 /* Increment suffix length if required */
576 /*********************************************************/
577 u4_suffix_len +=
578 (u4_suffix_len < 6) ?
579 (u2_abs_value
580 > (3
581 << (u4_suffix_len
582 - 1))) :
583 0;
584 }
585
586 /****************************************************************/
587 /* Decoding Levels Ends */
588 /****************************************************************/
589 }
590
591 /****************************************************************/
592 /* Decoding total zeros as in section 9.2.3, table 9.7 */
593 /****************************************************************/
594 {
595 UWORD32 u4_index;
596 const UWORD8 (*ppu1_total_zero_lkup)[64] =
597 (const UWORD8 (*)[64])gau1_ih264d_table_total_zero_2to10;
598
599 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 6);
600 u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 2][u4_index];
601
602 FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4));
603 u4_total_zeroes &= 0xf;
604 }
605
606 /**************************************************************/
607 /* Decode the runs and form the coefficient buffer */
608 /**************************************************************/
609 {
610 const UWORD8 *pu1_table_runbefore;
611 UWORD32 u4_run;
612 WORD32 k;
613 UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc;
614 WORD32 u4_zeroes_left = u4_total_zeroes;
615 k = u4_total_coeff - 1;
616
617 /**************************************************************/
618 /* Decoding Runs Begin for zeros left > 6 */
619 /**************************************************************/
620 while((u4_zeroes_left > 6) && k)
621 {
622 UWORD32 u4_code;
623
624 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);
625
626 if(u4_code != 0)
627 {
628 FLUSHBITS(u4_bitstream_offset, 3);
629 u4_run = (7 - u4_code);
630 }
631 else
632 {
633
634 FIND_ONE_IN_STREAM_LEN(u4_code, u4_bitstream_offset,
635 pu4_bitstrm_buf, 11);
636 u4_run = (4 + u4_code);
637 }
638
639 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
640 *pi2_coeff_data++ = i2_level_arr[k--];
641 u4_zeroes_left -= u4_run;
642 u4_scan_pos -= (u4_run + 1);
643 }
644
645 /**************************************************************/
646 /* Decoding Runs for 0 < zeros left <=6 */
647 /**************************************************************/
648 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
649 while((u4_zeroes_left > 0) && k)
650 {
651 UWORD32 u4_code;
652 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);
653
654 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
655 u4_run = u4_code >> 2;
656
657 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
658
659 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
660 *pi2_coeff_data++ = i2_level_arr[k--];
661 u4_zeroes_left -= u4_run;
662 u4_scan_pos -= (u4_run + 1);
663 }
664 /**************************************************************/
665 /* Decoding Runs End */
666 /**************************************************************/
667
668 /**************************************************************/
669 /* Copy the remaining coefficients */
670 /**************************************************************/
671 if(u4_zeroes_left < 0)
672 return -1;
673 while(k >= 0)
674 {
675
676 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
677 *pi2_coeff_data++ = i2_level_arr[k--];
678 u4_scan_pos--;
679 }
680 }
681
682 {
683 WORD32 offset;
684 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
685 offset = ALIGN4(offset);
686 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
687 }
688
689 ps_bitstrm->u4_ofst = u4_bitstream_offset;
690 return 0;
691}
692
693/*****************************************************************************/
694/* */
695/* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_11to16 */
696/* */
697/* Description : This function does cavlc decoding of 4x4 block residual */
698/* coefficient when total coeffs are greater than ten. */
699/* Parsing is done as defined in section 9.2.2 and 9.2.3 of */
700/* the H264 standard. */
701/* */
702/* Inputs : <What inputs does the function take?> */
703/* Globals : <Does it use any global variables?> */
704/* Processing : <Describe how the function operates - include algorithm */
705/* description> */
706/* Outputs : <What does the function produce?> */
707/* Returns : <What does the function return?> */
708/* */
709/* Issues : <List any issues or problems with this function> */
710/* */
711/* Revision History: */
712/* */
713/* DD MM YYYY Author(s) Changes (Describe the changes made) */
714/* 25 09 2008 Jay Draft */
715/* */
716/*****************************************************************************/
717
718WORD32 ih264d_cavlc_4x4res_block_totalcoeff_11to16(UWORD32 u4_isdc,
719 UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/
720 dec_bit_stream_t *ps_bitstrm )
721{
722 UWORD32 u4_total_zeroes;
723 WORD32 i;
724 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
725 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
726 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
727 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
Harish Mahendrakaref3da4e2016-02-17 18:06:36 +0530[diff] [blame]728 // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3)
729 // since u4_trailing_ones can at the max be 3. This will be required when
730 // u4_total_coeff is less than u4_trailing_ones
731 WORD16 ai2_level_arr[19];//
732 WORD16 *i2_level_arr = &ai2_level_arr[3];
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]733
734 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
735 WORD16 *pi2_coeff_data;
736 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
737
738 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
739 ps_tu_4x4->u2_sig_coeff_map = 0;
740 pi2_coeff_data = &ps_tu_4x4->ai2_level[0];
741
742 i = u4_total_coeff - 1;
743 if(u4_trailing_ones)
744 {
745 /*********************************************************************/
746 /* Decode Trailing Ones */
747 /* read the sign of T1's and put them in level array */
748 /*********************************************************************/
749 UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
750 WORD16 (*ppi2_trlone_lkup)[3] =
751 (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
752 WORD16 *pi2_trlone_lkup;
753
754 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);
755
756 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];
757
758 while(u4_cnt--)
759 i2_level_arr[i--] = *pi2_trlone_lkup++;
760 }
761
762 /****************************************************************/
763 /* Decoding Levels Begins */
764 /****************************************************************/
765 if(i >= 0)
766 {
767 /****************************************************************/
768 /* First level is decoded outside the loop as it has lot of */
769 /* special cases. */
770 /****************************************************************/
771 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
772 UWORD16 u2_lev_code, u2_abs_value;
773 UWORD32 u4_lev_prefix;
774
775 if(u4_trailing_ones < 3)
776 {
777 /*********************************************************/
778 /* u4_suffix_len = 1 */
779 /*********************************************************/
780 /***************************************************************/
781 /* Find leading zeros in next 32 bits */
782 /***************************************************************/
783 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
784 pu4_bitstrm_buf);
785
786 u4_lev_suffix_size =
787 (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : 1;
788
789 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
790 u4_lev_suffix_size);
791 u2_lev_code = 2 + (MIN(u4_lev_prefix,15) << 1) + u4_lev_suffix;
792
793 //HP_LEVEL_PREFIX
794 if(16 <= u4_lev_prefix)
795 {
796 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
797 }
798 }
799 else
800 {
801 /*********************************************************/
802 /*u4_suffix_len = 0 */
803 /*********************************************************/
804 /***************************************************************/
805 /* Find leading zeros in next 32 bits */
806 /***************************************************************/
807 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
808 pu4_bitstrm_buf);
809
810 /*********************************************************/
811 /* Special decoding case when trailing ones are 3 */
812 /*********************************************************/
813 u2_lev_code = MIN(15, u4_lev_prefix);
814
815 u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2);
816
817 if(14 == u4_lev_prefix)
818 u4_lev_suffix_size = 4;
819 else if(15 <= u4_lev_prefix)
820 {
821 u2_lev_code += 15;
822 u4_lev_suffix_size = (u4_lev_prefix - 3);
823 }
824 else
825 u4_lev_suffix_size = 0;
826
827 //HP_LEVEL_PREFIX
828 if(16 <= u4_lev_prefix)
829 {
830 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
831 }
832 if(u4_lev_suffix_size)
833 {
834 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
835 u4_lev_suffix_size);
836 u2_lev_code += u4_lev_suffix;
837 }
838 }
839
840 u2_abs_value = (u2_lev_code + 2) >> 1;
841 /*********************************************************/
842 /* If Level code is odd, level is negative else positive */
843 /*********************************************************/
844 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
845
846 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;
847
848 /*********************************************************/
849 /* Now loop over the remaining levels */
850 /*********************************************************/
851 while(i >= 0)
852 {
853
854 /***************************************************************/
855 /* Find leading zeros in next 32 bits */
856 /***************************************************************/
857 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
858 pu4_bitstrm_buf);
859
860 u4_lev_suffix_size =
861 (15 <= u4_lev_prefix) ?
862 (u4_lev_prefix - 3) : u4_suffix_len;
863
864 /*********************************************************/
865 /* Compute level code using prefix and suffix */
866 /*********************************************************/
867 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
868 u4_lev_suffix_size);
869 u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len)
870 + u4_lev_suffix;
871
872 //HP_LEVEL_PREFIX
873 if(16 <= u4_lev_prefix)
874 {
875 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
876 }
877 u2_abs_value = (u2_lev_code + 2) >> 1;
878
879 /*********************************************************/
880 /* If Level code is odd, level is negative else positive */
881 /*********************************************************/
882 i2_level_arr[i--] =
883 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
884
885 /*********************************************************/
886 /* Increment suffix length if required */
887 /*********************************************************/
888 u4_suffix_len +=
889 (u4_suffix_len < 6) ?
890 (u2_abs_value
891 > (3
892 << (u4_suffix_len
893 - 1))) :
894 0;
895 }
896
897 /****************************************************************/
898 /* Decoding Levels Ends */
899 /****************************************************************/
900 }
901
902 if(u4_total_coeff < (16 - u4_isdc))
903 {
904 UWORD32 u4_index;
905 const UWORD8 (*ppu1_total_zero_lkup)[16] =
906 (const UWORD8 (*)[16])gau1_ih264d_table_total_zero_11to15;
907
908 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 4);
909 u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 11][u4_index];
910
911 FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4));
912 u4_total_zeroes &= 0xf;
913 }
914 else
915 u4_total_zeroes = 0;
916
917 /**************************************************************/
918 /* Decode the runs and form the coefficient buffer */
919 /**************************************************************/
920 {
921 const UWORD8 *pu1_table_runbefore;
922 UWORD32 u4_run;
923 WORD32 k;
924 UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc;
925 WORD32 u4_zeroes_left = u4_total_zeroes;
926 k = u4_total_coeff - 1;
927
928 /**************************************************************/
929 /* Decoding Runs for 0 < zeros left <=6 */
930 /**************************************************************/
931 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
932 while((u4_zeroes_left > 0) && k)
933 {
934 UWORD32 u4_code;
935 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);
936
937 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
938 u4_run = u4_code >> 2;
939
940 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
941 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
942 *pi2_coeff_data++ = i2_level_arr[k--];
943 u4_zeroes_left -= u4_run;
944 u4_scan_pos -= (u4_run + 1);
945 }
946 /**************************************************************/
947 /* Decoding Runs End */
948 /**************************************************************/
949
950 /**************************************************************/
951 /* Copy the remaining coefficients */
952 /**************************************************************/
953 if(u4_zeroes_left < 0)
954 return -1;
955 while(k >= 0)
956 {
957 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
958 *pi2_coeff_data++ = i2_level_arr[k--];
959 u4_scan_pos--;
960 }
961 }
962
963 {
964 WORD32 offset;
965 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
966 offset = ALIGN4(offset);
967 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
968 }
969
970 ps_bitstrm->u4_ofst = u4_bitstream_offset;
971 return 0;
972}
973
974/*****************************************************************************/
975/* */
976/* Function Name : ih264d_rest_of_residual_cav_chroma_dc_block */
977/* */
978/* Description : This function does the Cavlc parsing of the bitstream */
979/* for chroma dc coefficients */
980/* Inputs : <What inputs does the function take?> */
981/* Globals : <Does it use any global variables?> */
982/* Processing : <Describe how the function operates - include algorithm */
983/* description> */
984/* Outputs : <What does the function produce?> */
985/* Returns : <What does the function return?> */
986/* */
987/* Issues : <List any issues or problems with this function> */
988/* */
989/* Revision History: */
990/* */
991/* DD MM YYYY Author(s) Changes (Describe the changes made) */
992/* 15 09 2008 Jay Draft */
993/* */
994/*****************************************************************************/
995void ih264d_rest_of_residual_cav_chroma_dc_block(UWORD32 u4_total_coeff_trail_one,
996 dec_bit_stream_t *ps_bitstrm)
997{
998 UWORD32 u4_total_zeroes;
999 WORD16 i;
1000 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1001 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
1002 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
1003 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
Harish Mahendrakaref3da4e2016-02-17 18:06:36 +0530[diff] [blame]1004 // To avoid error check at 4x4 level, allocating for 3 extra levels(4+3)
1005 // since u4_trailing_ones can at the max be 3. This will be required when
1006 // u4_total_coeff is less than u4_trailing_ones
1007 WORD16 ai2_level_arr[7];//
1008 WORD16 *i2_level_arr = &ai2_level_arr[3];
Hamsalekha S8d3d3032015-03-13 21:24:58 +0530[diff] [blame]1009
1010 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
1011 WORD16 *pi2_coeff_data;
1012 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
1013
1014 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
1015 ps_tu_4x4->u2_sig_coeff_map = 0;
1016 pi2_coeff_data = &ps_tu_4x4->ai2_level[0];
1017
1018 i = u4_total_coeff - 1;
1019 if(u4_trailing_ones)
1020 {
1021 /*********************************************************************/
1022 /* Decode Trailing Ones */
1023 /* read the sign of T1's and put them in level array */
1024 /*********************************************************************/
1025 UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
1026 WORD16 (*ppi2_trlone_lkup)[3] =
1027 (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
1028 WORD16 *pi2_trlone_lkup;
1029
1030 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);
1031
1032 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];
1033
1034 while(u4_cnt--)
1035 i2_level_arr[i--] = *pi2_trlone_lkup++;
1036 }
1037
1038 /****************************************************************/
1039 /* Decoding Levels Begins */
1040 /****************************************************************/
1041 if(i >= 0)
1042 {
1043 /****************************************************************/
1044 /* First level is decoded outside the loop as it has lot of */
1045 /* special cases. */
1046 /****************************************************************/
1047 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
1048 UWORD16 u2_lev_code, u2_abs_value;
1049 UWORD32 u4_lev_prefix;
1050
1051 /***************************************************************/
1052 /* u4_suffix_len = 0, Find leading zeros in next 32 bits */
1053 /***************************************************************/
1054 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
1055 pu4_bitstrm_buf);
1056
1057 /*********************************************************/
1058 /* Special decoding case when trailing ones are 3 */
1059 /*********************************************************/
1060 u2_lev_code = MIN(15, u4_lev_prefix);
1061
1062 u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2);
1063
1064 if(14 == u4_lev_prefix)
1065 u4_lev_suffix_size = 4;
1066 else if(15 <= u4_lev_prefix)
1067 {
1068 u2_lev_code += 15;
1069 u4_lev_suffix_size = u4_lev_prefix - 3;
1070 }
1071 else
1072 u4_lev_suffix_size = 0;
1073
1074 //HP_LEVEL_PREFIX
1075 if(16 <= u4_lev_prefix)
1076 {
1077 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
1078 }
1079 if(u4_lev_suffix_size)
1080 {
1081 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
1082 u4_lev_suffix_size);
1083 u2_lev_code += u4_lev_suffix;
1084 }
1085
1086 u2_abs_value = (u2_lev_code + 2) >> 1;
1087 /*********************************************************/
1088 /* If Level code is odd, level is negative else positive */
1089 /*********************************************************/
1090 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
1091
1092 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;
1093
1094 /*********************************************************/
1095 /* Now loop over the remaining levels */
1096 /*********************************************************/
1097 while(i >= 0)
1098 {
1099
1100 /***************************************************************/
1101 /* Find leading zeros in next 32 bits */
1102 /***************************************************************/
1103 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
1104 pu4_bitstrm_buf);
1105
1106 u4_lev_suffix_size =
1107 (15 <= u4_lev_prefix) ?
1108 (u4_lev_prefix - 3) : u4_suffix_len;
1109
1110 /*********************************************************/
1111 /* Compute level code using prefix and suffix */
1112 /*********************************************************/
1113 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
1114 u4_lev_suffix_size);
1115 u2_lev_code = (MIN(u4_lev_prefix,15) << u4_suffix_len)
1116 + u4_lev_suffix;
1117
1118 //HP_LEVEL_PREFIX
1119 if(16 <= u4_lev_prefix)
1120 {
1121 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
1122 }
1123 u2_abs_value = (u2_lev_code + 2) >> 1;
1124
1125 /*********************************************************/
1126 /* If Level code is odd, level is negative else positive */
1127 /*********************************************************/
1128 i2_level_arr[i--] =
1129 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;
1130
1131 /*********************************************************/
1132 /* Increment suffix length if required */
1133 /*********************************************************/
1134 u4_suffix_len += (u2_abs_value > (3 << (u4_suffix_len - 1)));
1135 }
1136
1137 /****************************************************************/
1138 /* Decoding Levels Ends */
1139 /****************************************************************/
1140 }
1141
1142 if(u4_total_coeff < 4)
1143 {
1144 UWORD32 u4_max_ldz = (4 - u4_total_coeff);
1145 FIND_ONE_IN_STREAM_LEN(u4_total_zeroes, u4_bitstream_offset,
1146 pu4_bitstrm_buf, u4_max_ldz);
1147 }
1148 else
1149 u4_total_zeroes = 0;
1150
1151 /**************************************************************/
1152 /* Decode the runs and form the coefficient buffer */
1153 /**************************************************************/
1154 {
1155 const UWORD8 *pu1_table_runbefore;
1156 UWORD32 u4_run;
1157 UWORD32 u4_scan_pos = (u4_total_coeff + u4_total_zeroes - 1);
1158 UWORD32 u4_zeroes_left = u4_total_zeroes;
1159 i = u4_total_coeff - 1;
1160
1161 /**************************************************************/
1162 /* Decoding Runs for 0 < zeros left <=6 */
1163 /**************************************************************/
1164 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
1165 while(u4_zeroes_left && i)
1166 {
1167 UWORD32 u4_code;
1168 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);
1169
1170 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
1171 u4_run = u4_code >> 2;
1172
1173 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
1174 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
1175 *pi2_coeff_data++ = i2_level_arr[i--];
1176 u4_zeroes_left -= u4_run;
1177 u4_scan_pos -= (u4_run + 1);
1178 }
1179 /**************************************************************/
1180 /* Decoding Runs End */
1181 /**************************************************************/
1182
1183 /**************************************************************/
1184 /* Copy the remaining coefficients */
1185 /**************************************************************/
1186 while(i >= 0)
1187 {
1188 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
1189 *pi2_coeff_data++ = i2_level_arr[i--];
1190 u4_scan_pos--;
1191 }
1192 }
1193
1194 {
1195 WORD32 offset;
1196 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
1197 offset = ALIGN4(offset);
1198 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
1199 }
1200
1201 ps_bitstrm->u4_ofst = u4_bitstream_offset;
1202}
1203
1204/*!
1205 **************************************************************************
1206 * \if Function name : CavlcParsingInvScanInvQuant \endif
1207 *
1208 * \brief
1209 * This function do cavlc parsing of coefficient tokens for any block
1210 * type except chromDc and depending
1211 * on whenther any coefficients to be parsed calls module
1212 * RestOfResidualBlockCavlc.
1213 *
1214 * \return
1215 * Returns total number of non-zero coefficients.
1216 *
1217 **************************************************************************
1218 */
1219
1220WORD32 ih264d_cavlc_parse4x4coeff_n0to7(WORD16 *pi2_coeff_block,
1221 UWORD32 u4_isdc, /* is it a DC block */
1222 WORD32 u4_n,
1223 dec_struct_t *ps_dec,
1224 UWORD32 *pu4_total_coeff)
1225{
1226 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1227 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1228 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
1229 UWORD32 u4_code, u4_index, u4_ldz;
1230 const UWORD16 *pu2_code = (const UWORD16*)gau2_ih264d_code_gx;
1231 const UWORD16 *pu2_offset_num_vlc =
1232 (const UWORD16 *)gau2_ih264d_offset_num_vlc_tab;
1233 UWORD32 u4_offset_num_vlc = pu2_offset_num_vlc[u4_n];
1234
1235
1236 UNUSED(pi2_coeff_block);
1237 *pu4_total_coeff = 0;
1238 FIND_ONE_IN_STREAM_32(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf);
1239 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 3);
1240 u4_index += (u4_ldz << 3);
1241 u4_index += u4_offset_num_vlc;
1242
1243 u4_index = MIN(u4_index, 303);
1244 u4_code = pu2_code[u4_index];
1245
1246 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
1247 ps_bitstrm->u4_ofst = u4_bitstream_offset;
1248 *pu4_total_coeff = (u4_code >> 4);
1249
1250 if(*pu4_total_coeff)
1251 {
1252 UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone;
1253 const UWORD8 *pu1_offset =
1254 (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset;
1255 WORD32 ret;
1256 u4_trailing_ones = ((u4_code >> 2) & 0x03);
1257 u4_offset = pu1_offset[*pu4_total_coeff - 1];
1258 u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones;
1259
1260 ret = ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc,
1261 u4_total_coeff_tone,
1262 ps_bitstrm);
1263 if(ret != 0)
1264 return ERROR_CAVLC_NUM_COEFF_T;
1265 }
1266
1267 return OK;
1268}
1269
1270WORD32 ih264d_cavlc_parse4x4coeff_n8(WORD16 *pi2_coeff_block,
1271 UWORD32 u4_isdc, /* is it a DC block */
1272 WORD32 u4_n,
1273 dec_struct_t *ps_dec,
1274 UWORD32 *pu4_total_coeff)
1275{
1276
1277 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1278 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1279 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
1280 UWORD32 u4_code;
1281 UNUSED(u4_n);
1282 UNUSED(pi2_coeff_block);
1283 GETBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 6);
1284 ps_bitstrm->u4_ofst = u4_bitstream_offset;
1285 *pu4_total_coeff = 0;
1286
1287 if(u4_code != 3)
1288 {
1289 UWORD8 *pu1_offset = (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset;
1290 UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone;
1291
1292 *pu4_total_coeff = (u4_code >> 2) + 1;
1293 u4_trailing_ones = u4_code & 0x03;
1294 u4_offset = pu1_offset[*pu4_total_coeff - 1];
1295 u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones;
1296
1297 ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc,
1298 u4_total_coeff_tone,
1299 ps_bitstrm);
1300 }
1301
1302 return OK;
1303}
1304
1305/*!
1306 **************************************************************************
1307 * \if Function name : ih264d_cavlc_parse_chroma_dc \endif
1308 *
1309 * \brief
1310 * This function do cavlc parsing of coefficient tokens chromDc block
1311 * and depending on whenther any coefficients to be parsed calls module
1312 * ih264d_rest_of_residual_cav_chroma_dc_block.
1313 *
1314 * \return
1315 * Returns total number of non-zero coefficients.
1316 *
1317 **************************************************************************
1318 */
1319
1320void ih264d_cavlc_parse_chroma_dc(dec_mb_info_t *ps_cur_mb_info,
1321 WORD16 *pi2_coeff_block,
1322 dec_bit_stream_t *ps_bitstrm,
1323 UWORD32 u4_scale_u,
1324 UWORD32 u4_scale_v,
1325 WORD32 i4_mb_inter_inc)
1326{
1327 UWORD32 u4_total_coeff, u4_trailing_ones, u4_total_coeff_tone, u4_code;
1328 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1329 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
1330 const UWORD8 *pu1_cav_chromdc = (const UWORD8*)gau1_ih264d_cav_chromdc_vld;
1331 UNUSED(i4_mb_inter_inc);
1332 /******************************************************************/
1333 /* Chroma DC Block for U component */
1334 /******************************************************************/
1335 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8);
1336
1337 u4_code = pu1_cav_chromdc[u4_code];
1338
1339 FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1));
1340 ps_bitstrm->u4_ofst = u4_bitstream_offset;
1341
1342 u4_total_coeff = (u4_code >> 5);
1343
1344 if(u4_total_coeff)
1345 {
1346 WORD32 i_z0, i_z1, i_z2, i_z3;
1347 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
1348 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
1349 WORD16 ai2_dc_coef[4];
1350 UWORD8 pu1_inv_scan[4] =
1351 { 0, 1, 2, 3 };
1352 WORD16 *pi2_coeff_data =
1353 (WORD16 *)ps_dec->pv_parse_tu_coeff_data;
1354
1355 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
1356
1357 u4_trailing_ones = ((u4_code >> 3) & 0x3);
1358 u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones;
1359 ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone,
1360 ps_bitstrm);
1361
1362 ai2_dc_coef[0] = 0;
1363 ai2_dc_coef[1] = 0;
1364 ai2_dc_coef[2] = 0;
1365 ai2_dc_coef[3] = 0;
1366
1367 ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4,
1368 ai2_dc_coef,
1369 pu1_inv_scan);
1370 /*-------------------------------------------------------------------*/
1371 /* Inverse 2x2 transform and scaling of chroma DC */
1372 /*-------------------------------------------------------------------*/
1373 i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]);
1374 i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]);
1375 i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]);
1376 i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]);
1377
1378 /*-----------------------------------------------------------*/
1379 /* Scaling and storing the values back */
1380 /*-----------------------------------------------------------*/
1381 *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_u) >> 5;
1382 *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_u) >> 5;
1383 *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_u) >> 5;
1384 *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_u) >> 5;
1385
1386 ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data;
1387
1388 SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,1);
1389 }
1390
1391 /******************************************************************/
1392 /* Chroma DC Block for V component */
1393 /******************************************************************/
1394 pi2_coeff_block += 64;
1395 u4_bitstream_offset = ps_bitstrm->u4_ofst;
1396
1397 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8);
1398
1399 u4_code = pu1_cav_chromdc[u4_code];
1400
1401 FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1));
1402 ps_bitstrm->u4_ofst = u4_bitstream_offset;
1403
1404 u4_total_coeff = (u4_code >> 5);
1405
1406 if(u4_total_coeff)
1407 {
1408 WORD32 i_z0, i_z1, i_z2, i_z3;
1409 tu_sblk4x4_coeff_data_t *ps_tu_4x4;
1410 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
1411 WORD16 ai2_dc_coef[4];
1412 UWORD8 pu1_inv_scan[4] =
1413 { 0, 1, 2, 3 };
1414 WORD16 *pi2_coeff_data =
1415 (WORD16 *)ps_dec->pv_parse_tu_coeff_data;
1416
1417 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
1418
1419 u4_trailing_ones = ((u4_code >> 3) & 0x3);
1420 u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones;
1421 ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone,
1422 ps_bitstrm);
1423
1424 ai2_dc_coef[0] = 0;
1425 ai2_dc_coef[1] = 0;
1426 ai2_dc_coef[2] = 0;
1427 ai2_dc_coef[3] = 0;
1428
1429 ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4,
1430 ai2_dc_coef,
1431 pu1_inv_scan);
1432
1433 /*-------------------------------------------------------------------*/
1434 /* Inverse 2x2 transform and scaling of chroma DC */
1435 /*-------------------------------------------------------------------*/
1436 i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]);
1437 i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]);
1438 i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]);
1439 i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]);
1440
1441 /*-----------------------------------------------------------*/
1442 /* Scaling and storing the values back */
1443 /*-----------------------------------------------------------*/
1444 *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_v) >> 5;
1445 *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_v) >> 5;
1446 *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_v) >> 5;
1447 *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_v) >> 5;
1448
1449 ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data;
1450
1451 SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,2);
1452 }
1453}
1454
1455/*****************************************************************************/
1456/* */
1457/* Function Name : ih264d_parse_pmb_ref_index_cavlc_range1 */
1458/* */
1459/* Description : This function does the Cavlc TEV range =1 parsing of */
1460/* reference index for a P MB. Range is 1 when */
1461/* num_ref_idx_active_minus1 is 0 */
1462/* */
1463/* Inputs : <What inputs does the function take?> */
1464/* Globals : <Does it use any global variables?> */
1465/* Processing : <Describe how the function operates - include algorithm */
1466/* description> */
1467/* Outputs : <What does the function produce?> */
1468/* Returns : <What does the function return?> */
1469/* */
1470/* Issues : <List any issues or problems with this function> */
1471/* */
1472/* Revision History: */
1473/* */
1474/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1475/* 19 09 2008 Jay Draft */
1476/* */
1477/*****************************************************************************/
1478void ih264d_parse_pmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */
1479 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
1480 WORD8 *pi1_ref_idx, /* pointer to reference index array */
1481 UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */
1482 )
1483{
1484 UWORD32 u4_i;
1485 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1486 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
1487 UNUSED(u4_num_ref_idx_active_minus1);
1488 for(u4_i = 0; u4_i < u4_num_part; u4_i++)
1489 {
1490 UWORD32 u4_ref_idx;
1491 u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf);
1492
1493 /* Storing Reference Idx Information */
1494 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
1495 }
1496}
1497
1498/*****************************************************************************/
1499/* */
1500/* Function Name : ih264d_parse_pmb_ref_index_cavlc */
1501/* */
1502/* Description : This function does the Cavlc TEV range > 1 parsing of */
1503/* reference index for a P MB. */
1504/* Range > 1 when num_ref_idx_active_minus1 > 0 */
1505/* */
1506/* Inputs : <What inputs does the function take?> */
1507/* Globals : <Does it use any global variables?> */
1508/* Processing : <Describe how the function operates - include algorithm */
1509/* description> */
1510/* Outputs : <What does the function produce?> */
1511/* Returns : <What does the function return?> */
1512/* */
1513/* Issues : <List any issues or problems with this function> */
1514/* */
1515/* Revision History: */
1516/* */
1517/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1518/* 19 09 2008 Jay Draft */
1519/* */
1520/*****************************************************************************/
1521
1522WORD32 ih264d_parse_pmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */
1523 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
1524 WORD8 *pi1_ref_idx, /* pointer to reference index array */
1525 UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */
1526 )
1527{
1528 UWORD32 u4_i;
1529 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1530 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
1531
1532 for(u4_i = 0; u4_i < u4_num_part; u4_i++)
1533 {
1534 UWORD32 u4_ref_idx;
1535//Inlined ih264d_uev
1536 UWORD32 u4_bitstream_offset = *pu4_bitstream_off;
1537 UWORD32 u4_word, u4_ldz;
1538
1539 /***************************************************************/
1540 /* Find leading zeros in next 32 bits */
1541 /***************************************************************/
1542 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1543 u4_ldz = CLZ(u4_word);
1544 /* Flush the ps_bitstrm */
1545 u4_bitstream_offset += (u4_ldz + 1);
1546 /* Read the suffix from the ps_bitstrm */
1547 u4_word = 0;
1548 if(u4_ldz)
1549 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
1550 *pu4_bitstream_off = u4_bitstream_offset;
1551 u4_ref_idx = ((1 << u4_ldz) + u4_word - 1);
1552//Inlined ih264d_uev
1553
1554 if(u4_ref_idx > u4_num_ref_idx_active_minus1)
1555 return ERROR_REF_IDX;
1556
1557 /* Storing Reference Idx Information */
1558 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
1559 }
1560 return OK;
1561}
1562
1563/*****************************************************************************/
1564/* */
1565/* Function Name : ih264d_parse_bmb_ref_index_cavlc_range1 */
1566/* */
1567/* Description : This function does the Cavlc TEV range =1 parsing of */
1568/* reference index for a B MB. Range is 1 when */
1569/* num_ref_idx_active_minus1 is 0 */
1570/* */
1571/* Inputs : <What inputs does the function take?> */
1572/* Globals : <Does it use any global variables?> */
1573/* Processing : <Describe how the function operates - include algorithm */
1574/* description> */
1575/* Outputs : <What does the function produce?> */
1576/* Returns : <What does the function return?> */
1577/* */
1578/* Issues : <List any issues or problems with this function> */
1579/* */
1580/* Revision History: */
1581/* */
1582/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1583/* 19 09 2008 Jay Draft */
1584/* */
1585/*****************************************************************************/
1586void ih264d_parse_bmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */
1587 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
1588 WORD8 *pi1_ref_idx, /* pointer to reference index array */
1589 UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */
1590 )
1591{
1592 UWORD32 u4_i;
1593 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1594 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
1595 UNUSED(u4_num_ref_idx_active_minus1);
1596 for(u4_i = 0; u4_i < u4_num_part; u4_i++)
1597 {
1598 if(pi1_ref_idx[u4_i] > -1)
1599 {
1600 UWORD32 u4_ref_idx;
1601
1602 u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf);
1603
1604 /* Storing Reference Idx Information */
1605 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
1606 }
1607 }
1608}
1609
1610/*****************************************************************************/
1611/* */
1612/* Function Name : ih264d_parse_bmb_ref_index_cavlc */
1613/* */
1614/* Description : This function does the Cavlc TEV range > 1 parsing of */
1615/* reference index for a B MB. */
1616/* Range > 1 when num_ref_idx_active_minus1 > 0 */
1617/* */
1618/* Inputs : <What inputs does the function take?> */
1619/* Globals : <Does it use any global variables?> */
1620/* Processing : <Describe how the function operates - include algorithm */
1621/* description> */
1622/* Outputs : <What does the function produce?> */
1623/* Returns : <What does the function return?> */
1624/* */
1625/* Issues : <List any issues or problems with this function> */
1626/* */
1627/* Revision History: */
1628/* */
1629/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1630/* 19 09 2008 Jay Draft */
1631/* */
1632/*****************************************************************************/
1633WORD32 ih264d_parse_bmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */
1634 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
1635 WORD8 *pi1_ref_idx, /* pointer to reference index array */
1636 UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */
1637 )
1638{
1639 UWORD32 u4_i;
1640 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1641 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
1642
1643 for(u4_i = 0; u4_i < u4_num_part; u4_i++)
1644 {
1645 if(pi1_ref_idx[u4_i] > -1)
1646 {
1647 UWORD32 u4_ref_idx;
1648//inlining ih264d_uev
1649 UWORD32 u4_bitstream_offset = *pu4_bitstream_off;
1650 UWORD32 u4_word, u4_ldz;
1651
1652 /***************************************************************/
1653 /* Find leading zeros in next 32 bits */
1654 /***************************************************************/
1655 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1656 u4_ldz = CLZ(u4_word);
1657 /* Flush the ps_bitstrm */
1658 u4_bitstream_offset += (u4_ldz + 1);
1659 /* Read the suffix from the ps_bitstrm */
1660 u4_word = 0;
1661 if(u4_ldz)
1662 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
1663 *pu4_bitstream_off = u4_bitstream_offset;
1664 u4_ref_idx = ((1 << u4_ldz) + u4_word - 1);
1665//inlining ih264d_uev
1666 if(u4_ref_idx > u4_num_ref_idx_active_minus1)
1667 return ERROR_REF_IDX;
1668
1669 /* Storing Reference Idx Information */
1670 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
1671 }
1672 }
1673 return OK;
1674}
1675/*****************************************************************************/
1676/* */
1677/* Function Name : ih264d_cavlc_parse_8x8block_both_available */
1678/* */
1679/* Description : This function does the residual parsing of 4 subblocks */
1680/* in a 8x8 block when both top and left are available */
1681/* */
1682/* Inputs : pi2_coeff_block : pointer to residual block where */
1683/* decoded and inverse scan coefficients are updated */
1684/* */
1685/* u4_sub_block_strd : indicates the number of sublocks */
1686/* in a row. It is 4 for luma and 2 for chroma. */
1687/* */
1688/* u4_isdc : required to indicate 4x4 parse modules if the */
1689/* current Mb is I_16x16/chroma DC coded. */
1690/* */
1691/* ps_dec : pointer to Decstruct (decoder context) */
1692/* */
1693/* pu1_top_nnz : top nnz pointer */
1694/* */
1695/* pu1_left_nnz : left nnz pointer */
1696/* */
1697/* Globals : No */
1698/* Processing : Parsing for four subblocks in unrolled, top and left nnz */
1699/* are updated on the fly. csbp is set in accordance to */
1700/* decoded numcoeff for the subblock index in raster order */
1701/* */
1702/* Outputs : The updated residue buffer, nnzs and csbp current block */
1703/* */
1704/* Returns : Returns the coded sub block pattern csbp for the block */
1705/* */
1706/* Issues : <List any issues or problems with this function> */
1707/* */
1708/* Revision History: */
1709/* */
1710/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1711/* 09 10 2008 Jay Draft */
1712/* */
1713/*****************************************************************************/
1714WORD32 ih264d_cavlc_parse_8x8block_both_available(WORD16 *pi2_coeff_block,
1715 UWORD32 u4_sub_block_strd,
1716 UWORD32 u4_isdc,
1717 dec_struct_t * ps_dec,
1718 UWORD8 *pu1_top_nnz,
1719 UWORD8 *pu1_left_nnz,
1720 UWORD8 u1_tran_form8x8,
1721 UWORD8 u1_mb_field_decodingflag,
1722 UWORD32 *pu4_csbp)
1723{
1724 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
1725 UWORD32 u4_top0, u4_top1;
1726 UWORD32 *pu4_dummy;
1727 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
1728 UWORD32 u4_isdc,
1729 WORD32 u4_n,
1730 struct _DecStruct *ps_dec,
1731 UWORD32 *pu4_dummy) =
1732 ps_dec->pf_cavlc_parse4x4coeff;
1733 UWORD32 u4_idx = 0;
1734 UWORD8 *puc_temp;
1735 WORD32 ret;
1736
1737 *pu4_csbp = 0;
1738 /* need to change the inverse scan matrices here */
1739 puc_temp = ps_dec->pu1_inv_scan;
1740
1741 /*------------------------------------------------------*/
1742 /* Residual 4x4 decoding: SubBlock 0 */
1743 /*------------------------------------------------------*/
1744 if(u1_tran_form8x8)
1745 {
1746 if(!u1_mb_field_decodingflag)
1747 {
1748 ps_dec->pu1_inv_scan =
1749 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
1750 }
1751 else
1752 {
1753 ps_dec->pu1_inv_scan =
1754 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
1755 }
1756 }
1757 u4_n = (pu1_top_nnz[0] + pu1_left_nnz[0] + 1) >> 1;
1758 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1759 u4_n, ps_dec, &u4_num_coeff);
1760 if(ret != OK)
1761 return ret;
1762
1763 u4_top0 = u4_num_coeff;
1764 u4_subblock_coded = (u4_num_coeff != 0);
1765 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1766
1767 /*------------------------------------------------------*/
1768 /* Residual 4x4 decoding: SubBlock 1 */
1769 /*------------------------------------------------------*/
1770 u4_idx++;
1771 if(u1_tran_form8x8)
1772 {
1773 if(!u1_mb_field_decodingflag)
1774 {
1775 ps_dec->pu1_inv_scan =
1776 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
1777 }
1778 else
1779 {
1780 ps_dec->pu1_inv_scan =
1781 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
1782 }
1783 }
1784 else
1785 {
1786 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
1787 }
1788 u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1;
1789 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1790 u4_n, ps_dec, &u4_num_coeff);
1791 if(ret != OK)
1792 return ret;
1793
1794 u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
1795 u4_subblock_coded = (u4_num_coeff != 0);
1796 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1797
1798 /*------------------------------------------------------*/
1799 /* Residual 4x4 decoding: SubBlock 2 */
1800 /*------------------------------------------------------*/
1801 u4_idx += (u4_sub_block_strd - 1);
1802 if(u1_tran_form8x8)
1803 {
1804 if(!u1_mb_field_decodingflag)
1805 {
1806 ps_dec->pu1_inv_scan =
1807 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
1808 }
1809 else
1810 {
1811 ps_dec->pu1_inv_scan =
1812 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
1813 }
1814 }
1815 else
1816 {
1817 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
1818 }
1819 u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1;
1820 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1821 u4_n, ps_dec, &u4_num_coeff);
1822 if(ret != OK)
1823 return ret;
1824
1825 pu1_top_nnz[0] = u4_num_coeff;
1826 u4_subblock_coded = (u4_num_coeff != 0);
1827 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1828
1829 /*------------------------------------------------------*/
1830 /* Residual 4x4 decoding: SubBlock 3 */
1831 /*------------------------------------------------------*/
1832 u4_idx++;
1833 if(u1_tran_form8x8)
1834 {
1835 if(!u1_mb_field_decodingflag)
1836 {
1837 ps_dec->pu1_inv_scan =
1838 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
1839 }
1840 else
1841 {
1842 ps_dec->pu1_inv_scan =
1843 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
1844 }
1845 }
1846 else
1847 {
1848 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
1849 }
1850 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
1851 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1852 u4_n, ps_dec, &u4_num_coeff);
1853 if(ret != OK)
1854 return ret;
1855
1856 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
1857 u4_subblock_coded = (u4_num_coeff != 0);
1858 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1859
1860 ps_dec->pu1_inv_scan = puc_temp;
1861
1862 return OK;
1863}
1864
1865/*****************************************************************************/
1866/* */
1867/* Function Name : ih264d_cavlc_parse_8x8block_left_available */
1868/* */
1869/* Description : This function does the residual parsing of 4 subblocks */
1870/* in a 8x8 block when only left is available for block */
1871/* */
1872/* Inputs : pi2_coeff_block : pointer to residual block where */
1873/* decoded and inverse scan coefficients are updated */
1874/* */
1875/* u4_sub_block_strd : indicates the number of sublocks */
1876/* in a row. It is 4 for luma and 2 for chroma. */
1877/* */
1878/* u4_isdc : required to indicate 4x4 parse modules if the */
1879/* current Mb is I_16x16/chroma DC coded. */
1880/* */
1881/* ps_dec : pointer to Decstruct (decoder context) */
1882/* */
1883/* pu1_top_nnz : top nnz pointer */
1884/* */
1885/* pu1_left_nnz : left nnz pointer */
1886/* */
1887/* Globals : No */
1888/* Processing : Parsing for four subblocks in unrolled, top and left nnz */
1889/* are updated on the fly. csbp is set in accordance to */
1890/* decoded numcoeff for the subblock index in raster order */
1891/* */
1892/* Outputs : The updated residue buffer, nnzs and csbp current block */
1893/* */
1894/* Returns : Returns the coded sub block pattern csbp for the block */
1895/* */
1896/* Issues : <List any issues or problems with this function> */
1897/* */
1898/* Revision History: */
1899/* */
1900/* DD MM YYYY Author(s) Changes (Describe the changes made) */
1901/* 09 10 2008 Jay Draft */
1902/* */
1903/*****************************************************************************/
1904WORD32 ih264d_cavlc_parse_8x8block_left_available(WORD16 *pi2_coeff_block,
1905 UWORD32 u4_sub_block_strd,
1906 UWORD32 u4_isdc,
1907 dec_struct_t * ps_dec,
1908 UWORD8 *pu1_top_nnz,
1909 UWORD8 *pu1_left_nnz,
1910 UWORD8 u1_tran_form8x8,
1911 UWORD8 u1_mb_field_decodingflag,
1912 UWORD32 *pu4_csbp)
1913{
1914 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
1915 UWORD32 u4_top0, u4_top1;
1916 UWORD32 *pu4_dummy;
1917 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
1918 UWORD32 u4_isdc,
1919 WORD32 u4_n,
1920 struct _DecStruct *ps_dec,
1921 UWORD32 *pu4_dummy) =
1922 ps_dec->pf_cavlc_parse4x4coeff;
1923 UWORD32 u4_idx = 0;
1924 UWORD8 *puc_temp;
1925 WORD32 ret;
1926
1927 *pu4_csbp = 0;
1928 puc_temp = ps_dec->pu1_inv_scan;
1929
1930 /*------------------------------------------------------*/
1931 /* Residual 4x4 decoding: SubBlock 0 */
1932 /*------------------------------------------------------*/
1933 if(u1_tran_form8x8)
1934 {
1935 if(!u1_mb_field_decodingflag)
1936 {
1937 ps_dec->pu1_inv_scan =
1938 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
1939 }
1940 else
1941 {
1942 ps_dec->pu1_inv_scan =
1943 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
1944 }
1945 }
1946 u4_n = pu1_left_nnz[0];
1947 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1948 u4_n, ps_dec, &u4_num_coeff);
1949 if(ret != OK)
1950 return ret;
1951
1952 u4_top0 = u4_num_coeff;
1953 u4_subblock_coded = (u4_num_coeff != 0);
1954 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1955
1956 /*------------------------------------------------------*/
1957 /* Residual 4x4 decoding: SubBlock 1 */
1958 /*------------------------------------------------------*/
1959 u4_idx++;
1960 if(u1_tran_form8x8)
1961 {
1962 if(!u1_mb_field_decodingflag)
1963 {
1964 ps_dec->pu1_inv_scan =
1965 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
1966 }
1967 else
1968 {
1969 ps_dec->pu1_inv_scan =
1970 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
1971 }
1972 }
1973 else
1974 {
1975 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
1976 }
1977 u4_n = u4_num_coeff;
1978 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
1979 u4_n, ps_dec, &u4_num_coeff);
1980 if(ret != OK)
1981 return ret;
1982
1983 u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
1984 u4_subblock_coded = (u4_num_coeff != 0);
1985 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
1986
1987 /*------------------------------------------------------*/
1988 /* Residual 4x4 decoding: SubBlock 2 */
1989 /*------------------------------------------------------*/
1990 u4_idx += (u4_sub_block_strd - 1);
1991 if(u1_tran_form8x8)
1992 {
1993 if(!u1_mb_field_decodingflag)
1994 {
1995 ps_dec->pu1_inv_scan =
1996 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
1997 }
1998 else
1999 {
2000 ps_dec->pu1_inv_scan =
2001 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
2002 }
2003 }
2004 else
2005 {
2006 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
2007 }
2008 u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1;
2009 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2010 u4_n, ps_dec, &u4_num_coeff);
2011 if(ret != OK)
2012 return ret;
2013
2014 pu1_top_nnz[0] = u4_num_coeff;
2015 u4_subblock_coded = (u4_num_coeff != 0);
2016 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2017
2018 /*------------------------------------------------------*/
2019 /* Residual 4x4 decoding: SubBlock 3 */
2020 /*------------------------------------------------------*/
2021 u4_idx++;
2022 if(u1_tran_form8x8)
2023 {
2024 if(!u1_mb_field_decodingflag)
2025 {
2026 ps_dec->pu1_inv_scan =
2027 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
2028 }
2029 else
2030 {
2031 ps_dec->pu1_inv_scan =
2032 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
2033 }
2034 }
2035 else
2036 {
2037 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
2038 }
2039 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
2040 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2041 u4_n, ps_dec, &u4_num_coeff);
2042 if(ret != OK)
2043 return ret;
2044
2045 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
2046 u4_subblock_coded = (u4_num_coeff != 0);
2047 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2048
2049 ps_dec->pu1_inv_scan = puc_temp;
2050
2051 return OK;
2052}
2053
2054/*****************************************************************************/
2055/* */
2056/* Function Name : ih264d_cavlc_parse_8x8block_top_available */
2057/* */
2058/* Description : This function does the residual parsing of 4 subblocks */
2059/* in a 8x8 block when only top is available for block */
2060/* */
2061/* Inputs : pi2_coeff_block : pointer to residual block where */
2062/* decoded and inverse scan coefficients are updated */
2063/* */
2064/* u4_sub_block_strd : indicates the number of sublocks */
2065/* in a row. It is 4 for luma and 2 for chroma. */
2066/* */
2067/* u4_isdc : required to indicate 4x4 parse modules if the */
2068/* current Mb is I_16x16/chroma DC coded. */
2069/* */
2070/* ps_dec : pointer to Decstruct (decoder context) */
2071/* */
2072/* pu1_top_nnz : top nnz pointer */
2073/* */
2074/* pu1_left_nnz : left nnz pointer */
2075/* */
2076/* Globals : No */
2077/* Processing : Parsing for four subblocks in unrolled, top and left nnz */
2078/* are updated on the fly. csbp is set in accordance to */
2079/* decoded numcoeff for the subblock index in raster order */
2080/* */
2081/* Outputs : The updated residue buffer, nnzs and csbp current block */
2082/* */
2083/* Returns : Returns the coded sub block pattern csbp for the block */
2084/* */
2085/* Issues : <List any issues or problems with this function> */
2086/* */
2087/* Revision History: */
2088/* */
2089/* DD MM YYYY Author(s) Changes (Describe the changes made) */
2090/* 09 10 2008 Jay Draft */
2091/* */
2092/*****************************************************************************/
2093WORD32 ih264d_cavlc_parse_8x8block_top_available(WORD16 *pi2_coeff_block,
2094 UWORD32 u4_sub_block_strd,
2095 UWORD32 u4_isdc,
2096 dec_struct_t * ps_dec,
2097 UWORD8 *pu1_top_nnz,
2098 UWORD8 *pu1_left_nnz,
2099 UWORD8 u1_tran_form8x8,
2100 UWORD8 u1_mb_field_decodingflag,
2101 UWORD32 *pu4_csbp)
2102{
2103 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
2104 UWORD32 u4_top0, u4_top1;
2105 UWORD32 *pu4_dummy;
2106 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
2107 UWORD32 u4_isdc,
2108 WORD32 u4_n,
2109 struct _DecStruct *ps_dec,
2110 UWORD32 *pu4_dummy) =
2111 ps_dec->pf_cavlc_parse4x4coeff;
2112 UWORD32 u4_idx = 0;
2113 UWORD8 *puc_temp;
2114 WORD32 ret;
2115
2116 *pu4_csbp = 0;
2117 puc_temp = ps_dec->pu1_inv_scan;
2118
2119 /*------------------------------------------------------*/
2120 /* Residual 4x4 decoding: SubBlock 0 */
2121 /*------------------------------------------------------*/
2122 if(u1_tran_form8x8)
2123 {
2124 if(!u1_mb_field_decodingflag)
2125 {
2126 ps_dec->pu1_inv_scan =
2127 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
2128 }
2129 else
2130 {
2131 ps_dec->pu1_inv_scan =
2132 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
2133 }
2134 }
2135 u4_n = pu1_top_nnz[0];
2136 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2137 u4_n, ps_dec, &u4_num_coeff);
2138 if(ret != OK)
2139 return ret;
2140
2141 u4_top0 = u4_num_coeff;
2142 u4_subblock_coded = (u4_num_coeff != 0);
2143 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2144
2145 /*------------------------------------------------------*/
2146 /* Residual 4x4 decoding: SubBlock 1 */
2147 /*------------------------------------------------------*/
2148 u4_idx++;
2149 if(u1_tran_form8x8)
2150 {
2151 if(!u1_mb_field_decodingflag)
2152 {
2153 ps_dec->pu1_inv_scan =
2154 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
2155 }
2156 else
2157 {
2158 ps_dec->pu1_inv_scan =
2159 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
2160 }
2161 }
2162 else
2163 {
2164 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
2165 }
2166 u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1;
2167 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2168 u4_n, ps_dec, &u4_num_coeff);
2169 if(ret != OK)
2170 return ret;
2171
2172 u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
2173 u4_subblock_coded = (u4_num_coeff != 0);
2174 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2175
2176 /*------------------------------------------------------*/
2177 /* Residual 4x4 decoding: SubBlock 2 */
2178 /*------------------------------------------------------*/
2179 u4_idx += (u4_sub_block_strd - 1);
2180 if(u1_tran_form8x8)
2181 {
2182 if(!u1_mb_field_decodingflag)
2183 {
2184 ps_dec->pu1_inv_scan =
2185 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
2186 }
2187 else
2188 {
2189 ps_dec->pu1_inv_scan =
2190 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
2191 }
2192 }
2193 else
2194 {
2195 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
2196 }
2197 u4_n = u4_top0;
2198 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2199 u4_n, ps_dec, &u4_num_coeff);
2200 if(ret != OK)
2201 return ret;
2202
2203 pu1_top_nnz[0] = u4_num_coeff;
2204 u4_subblock_coded = (u4_num_coeff != 0);
2205 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2206
2207 /*------------------------------------------------------*/
2208 /* Residual 4x4 decoding: SubBlock 3 */
2209 /*------------------------------------------------------*/
2210 u4_idx++;
2211 if(u1_tran_form8x8)
2212 {
2213 if(!u1_mb_field_decodingflag)
2214 {
2215 ps_dec->pu1_inv_scan =
2216 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
2217 }
2218 else
2219 {
2220 ps_dec->pu1_inv_scan =
2221 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
2222 }
2223 }
2224 else
2225 {
2226 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
2227 }
2228 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
2229 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2230 u4_n, ps_dec, &u4_num_coeff);
2231 if(ret != OK)
2232 return ret;
2233
2234 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
2235 u4_subblock_coded = (u4_num_coeff != 0);
2236 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2237
2238 ps_dec->pu1_inv_scan = puc_temp;
2239
2240 return OK;
2241}
2242
2243/*****************************************************************************/
2244/* */
2245/* Function Name : ih264d_cavlc_parse_8x8block_none_available */
2246/* */
2247/* Description : This function does the residual parsing of 4 subblocks */
2248/* in a 8x8 block when none of the neigbours are available */
2249/* */
2250/* Inputs : pi2_coeff_block : pointer to residual block where */
2251/* decoded and inverse scan coefficients are updated */
2252/* */
2253/* u4_sub_block_strd : indicates the number of sublocks */
2254/* in a row. It is 4 for luma and 2 for chroma. */
2255/* */
2256/* u4_isdc : required to indicate 4x4 parse modules if the */
2257/* current Mb is I_16x16/chroma DC coded. */
2258/* */
2259/* ps_dec : pointer to Decstruct (decoder context) */
2260/* */
2261/* pu1_top_nnz : top nnz pointer */
2262/* */
2263/* pu1_left_nnz : left nnz pointer */
2264/* */
2265/* Globals : No */
2266/* Processing : Parsing for four subblocks in unrolled, top and left nnz */
2267/* are updated on the fly. csbp is set in accordance to */
2268/* decoded numcoeff for the subblock index in raster order */
2269/* */
2270/* Outputs : The updated residue buffer, nnzs and csbp current block */
2271/* */
2272/* Returns : Returns the coded sub block pattern csbp for the block */
2273/* */
2274/* Issues : <List any issues or problems with this function> */
2275/* */
2276/* Revision History: */
2277/* */
2278/* DD MM YYYY Author(s) Changes (Describe the changes made) */
2279/* 09 10 2008 Jay Draft */
2280/* */
2281/*****************************************************************************/
2282WORD32 ih264d_cavlc_parse_8x8block_none_available(WORD16 *pi2_coeff_block,
2283 UWORD32 u4_sub_block_strd,
2284 UWORD32 u4_isdc,
2285 dec_struct_t * ps_dec,
2286 UWORD8 *pu1_top_nnz,
2287 UWORD8 *pu1_left_nnz,
2288 UWORD8 u1_tran_form8x8,
2289 UWORD8 u1_mb_field_decodingflag,
2290 UWORD32 *pu4_csbp)
2291{
2292 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
2293 UWORD32 u4_top0, u4_top1;
2294 UWORD32 *pu4_dummy;
2295 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
2296 UWORD32 u4_isdc,
2297 WORD32 u4_n,
2298 struct _DecStruct *ps_dec,
2299 UWORD32 *pu4_dummy) =
2300 ps_dec->pf_cavlc_parse4x4coeff;
2301 UWORD32 u4_idx = 0;
2302 UWORD8 *puc_temp;
2303 WORD32 ret;
2304
2305 *pu4_csbp = 0;
2306 puc_temp = ps_dec->pu1_inv_scan;
2307
2308 /*------------------------------------------------------*/
2309 /* Residual 4x4 decoding: SubBlock 0 */
2310 /*------------------------------------------------------*/
2311 if(u1_tran_form8x8)
2312 {
2313 if(!u1_mb_field_decodingflag)
2314 {
2315 ps_dec->pu1_inv_scan =
2316 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
2317 }
2318 else
2319 {
2320 ps_dec->pu1_inv_scan =
2321 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
2322 }
2323 }
2324 ret = pf_cavlc_parse4x4coeff[0](pi2_coeff_block, u4_isdc, 0,
2325 ps_dec, &u4_num_coeff);
2326 if(ret != OK)
2327 return ret;
2328
2329 u4_top0 = u4_num_coeff;
2330 u4_subblock_coded = (u4_num_coeff != 0);
2331 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2332
2333 /*------------------------------------------------------*/
2334 /* Residual 4x4 decoding: SubBlock 1 */
2335 /*------------------------------------------------------*/
2336 u4_idx++;
2337 if(u1_tran_form8x8)
2338 {
2339 if(!u1_mb_field_decodingflag)
2340 {
2341 ps_dec->pu1_inv_scan =
2342 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
2343 }
2344 else
2345 {
2346 ps_dec->pu1_inv_scan =
2347 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
2348 }
2349 }
2350 else
2351 {
2352 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
2353 }
2354 u4_n = u4_num_coeff;
2355 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2356 u4_n, ps_dec, &u4_num_coeff);
2357 if(ret != OK)
2358 return ret;
2359
2360 u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
2361 u4_subblock_coded = (u4_num_coeff != 0);
2362 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2363
2364 /*------------------------------------------------------*/
2365 /* Residual 4x4 decoding: SubBlock 2 */
2366 /*------------------------------------------------------*/
2367 u4_idx += (u4_sub_block_strd - 1);
2368 if(u1_tran_form8x8)
2369 {
2370 if(!u1_mb_field_decodingflag)
2371 {
2372 ps_dec->pu1_inv_scan =
2373 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
2374 }
2375 else
2376 {
2377 ps_dec->pu1_inv_scan =
2378 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
2379 }
2380 }
2381 else
2382 {
2383 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
2384 }
2385 u4_n = u4_top0;
2386 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2387 u4_n, ps_dec, &u4_num_coeff);
2388 if(ret != OK)
2389 return ret;
2390
2391 pu1_top_nnz[0] = u4_num_coeff;
2392 u4_subblock_coded = (u4_num_coeff != 0);
2393 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2394
2395 /*------------------------------------------------------*/
2396 /* Residual 4x4 decoding: SubBlock 3 */
2397 /*------------------------------------------------------*/
2398 u4_idx++;
2399 if(u1_tran_form8x8)
2400 {
2401 if(!u1_mb_field_decodingflag)
2402 {
2403 ps_dec->pu1_inv_scan =
2404 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
2405 }
2406 else
2407 {
2408 ps_dec->pu1_inv_scan =
2409 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
2410 }
2411 }
2412 else
2413 {
2414 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
2415 }
2416 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
2417 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
2418 u4_n, ps_dec, &u4_num_coeff);
2419 if(ret != OK)
2420 return ret;
2421
2422 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
2423 u4_subblock_coded = (u4_num_coeff != 0);
2424 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);
2425
2426 ps_dec->pu1_inv_scan = puc_temp;
2427
2428 return OK;
2429}
2430
2431/*!
2432 **************************************************************************
2433 * \if Function name : ih264d_parse_residual4x4_cavlc \endif
2434 *
2435 * \brief
2436 * This function parses CAVLC syntax of a Luma and Chroma AC Residuals.
2437 *
2438 * \return
2439 * 0 on Success and Error code otherwise
2440 **************************************************************************
2441 */
2442
2443WORD32 ih264d_parse_residual4x4_cavlc(dec_struct_t * ps_dec,
2444 dec_mb_info_t *ps_cur_mb_info,
2445 UWORD8 u1_offset)
2446{
2447 UWORD8 u1_cbp = ps_cur_mb_info->u1_cbp;
2448 UWORD16 ui16_csbp = 0;
2449 UWORD32 u4_nbr_avl;
2450 WORD16 *pi2_residual_buf;
2451
2452 UWORD8 u1_is_top_mb_avail;
2453 UWORD8 u1_is_left_mb_avail;
2454
2455 UWORD8 *pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_y;
2456 UWORD8 *pu1_left_nnz = ps_dec->pu1_left_nnz_y;
2457 WORD16 *pi2_coeff_block = NULL;
2458 UWORD32 *pu4_dummy;
2459 WORD32 ret;
2460
2461 WORD32 (**pf_cavlc_parse_8x8block)(WORD16 *pi2_coeff_block,
2462 UWORD32 u4_sub_block_strd,
2463 UWORD32 u4_isdc,
2464 struct _DecStruct *ps_dec,
2465 UWORD8 *pu1_top_nnz,
2466 UWORD8 *pu1_left_nnz,
2467 UWORD8 u1_tran_form8x8,
2468 UWORD8 u1_mb_field_decodingflag,
2469 UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse_8x8block;
2470
2471
2472 {
2473 UWORD8 uc_temp = ps_dec->u1_mb_ngbr_availablity;
2474 u1_is_top_mb_avail = BOOLEAN(uc_temp & TOP_MB_AVAILABLE_MASK);
2475 u1_is_left_mb_avail = BOOLEAN(uc_temp & LEFT_MB_AVAILABLE_MASK);
2476 u4_nbr_avl = (u1_is_top_mb_avail << 1) | u1_is_left_mb_avail;
2477 }
2478
2479 ps_cur_mb_info->u1_qp_div6 = ps_dec->u1_qp_y_div6;
2480 ps_cur_mb_info->u1_qp_rem6 = ps_dec->u1_qp_y_rem6;
2481 ps_cur_mb_info->u1_qpc_div6 = ps_dec->u1_qp_u_div6;
2482 ps_cur_mb_info->u1_qpc_rem6 = ps_dec->u1_qp_u_rem6;
2483 ps_cur_mb_info->u1_qpcr_div6 = ps_dec->u1_qp_v_div6;
2484 ps_cur_mb_info->u1_qpcr_rem6 = ps_dec->u1_qp_v_rem6;
2485
2486 if(u1_cbp & 0xf)
2487 {
2488 pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[0];
2489 pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[1];
2490 pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[2];
2491 pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[3];
2492
2493 /*******************************************************************/
2494 /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */
2495 /*******************************************************************/
2496 if(!(u1_cbp & 0x1))
2497 {
2498 *(UWORD16 *)(pu1_top_nnz) = 0;
2499 *(UWORD16 *)(pu1_left_nnz) = 0;
2500
2501 }
2502 else
2503 {
2504 UWORD32 u4_temp;
2505 ret = pf_cavlc_parse_8x8block[u4_nbr_avl](
2506 pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz,
2507 pu1_left_nnz, ps_cur_mb_info->u1_tran_form8x8,
2508 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
2509 if(ret != OK)
2510 return ret;
2511 ui16_csbp = u4_temp;
2512 }
2513
2514 /*******************************************************************/
2515 /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */
2516 /*******************************************************************/
2517 if(ps_cur_mb_info->u1_tran_form8x8)
2518 {
2519 pi2_coeff_block += 64;
2520 }
2521 else
2522 {
2523 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK);
2524 }
2525
2526 if(!(u1_cbp & 0x2))
2527 {
2528 *(UWORD16 *)(pu1_top_nnz + 2) = 0;
2529 *(UWORD16 *)(pu1_left_nnz) = 0;
2530 }
2531 else
2532 {
2533 UWORD32 u4_temp = (u4_nbr_avl | 0x1);
2534 ret = pf_cavlc_parse_8x8block[u4_temp](
2535 pi2_coeff_block, 4, u1_offset, ps_dec,
2536 (pu1_top_nnz + 2), pu1_left_nnz,
2537 ps_cur_mb_info->u1_tran_form8x8,
2538 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
2539 if(ret != OK)
2540 return ret;
2541 ui16_csbp |= (u4_temp << 2);
2542 }
2543
2544 /*******************************************************************/
2545 /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */
2546 /*******************************************************************/
2547 if(ps_cur_mb_info->u1_tran_form8x8)
2548 {
2549 pi2_coeff_block += 64;
2550 }
2551 else
2552 {
2553 pi2_coeff_block += (6 * NUM_COEFFS_IN_4x4BLK);
2554 }
2555
2556 if(!(u1_cbp & 0x4))
2557 {
2558 *(UWORD16 *)(pu1_top_nnz) = 0;
2559 *(UWORD16 *)(pu1_left_nnz + 2) = 0;
2560 }
2561 else
2562 {
2563 UWORD32 u4_temp = (u4_nbr_avl | 0x2);
2564 ret = pf_cavlc_parse_8x8block[u4_temp](
2565 pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz,
2566 (pu1_left_nnz + 2), ps_cur_mb_info->u1_tran_form8x8,
2567 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
2568 if(ret != OK)
2569 return ret;
2570 ui16_csbp |= (u4_temp << 8);
2571 }
2572
2573 /*******************************************************************/
2574 /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/
2575 /*******************************************************************/
2576 if(ps_cur_mb_info->u1_tran_form8x8)
2577 {
2578 pi2_coeff_block += 64;
2579 }
2580 else
2581 {
2582 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK);
2583 }
2584
2585 if(!(u1_cbp & 0x8))
2586 {
2587 *(UWORD16 *)(pu1_top_nnz + 2) = 0;
2588 *(UWORD16 *)(pu1_left_nnz + 2) = 0;
2589 }
2590 else
2591 {
2592 UWORD32 u4_temp;
2593 ret = pf_cavlc_parse_8x8block[0x3](
2594 pi2_coeff_block, 4, u1_offset, ps_dec,
2595 (pu1_top_nnz + 2), (pu1_left_nnz + 2),
2596 ps_cur_mb_info->u1_tran_form8x8,
2597 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
2598 if(ret != OK)
2599 return ret;
2600 ui16_csbp |= (u4_temp << 10);
2601 }
2602 }
2603 else
2604 {
2605 *(UWORD32 *)(pu1_top_nnz) = 0;
2606 *(UWORD32 *)(pu1_left_nnz) = 0;
2607 }
2608
2609 ps_cur_mb_info->u2_luma_csbp = ui16_csbp;
2610 ps_cur_mb_info->ps_curmb->u2_luma_csbp = ui16_csbp;
2611
2612 {
2613 UWORD16 u2_chroma_csbp = 0;
2614 ps_cur_mb_info->u2_chroma_csbp = 0;
2615 pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_uv;
2616 pu1_left_nnz = ps_dec->pu1_left_nnz_uv;
2617
2618 u1_cbp >>= 4;
2619 /*--------------------------------------------------------------------*/
2620 /* if Chroma Component not present OR no ac values present */
2621 /* Set the values of N to zero */
2622 /*--------------------------------------------------------------------*/
2623 if(u1_cbp == CBPC_ALLZERO || u1_cbp == CBPC_ACZERO)
2624 {
2625 *(UWORD32 *)(pu1_top_nnz) = 0;
2626 *(UWORD32 *)(pu1_left_nnz) = 0;
2627 }
2628
2629 if(u1_cbp == CBPC_ALLZERO)
2630 {
2631 return (0);
2632 }
2633 /*--------------------------------------------------------------------*/
2634 /* Decode Chroma DC values */
2635 /*--------------------------------------------------------------------*/
2636 {
2637 WORD32 u4_scale_u;
2638 WORD32 u4_scale_v;
2639 WORD32 i4_mb_inter_inc;
2640 u4_scale_u = ps_dec->pu2_quant_scale_u[0] << ps_dec->u1_qp_u_div6;
2641 u4_scale_v = ps_dec->pu2_quant_scale_v[0] << ps_dec->u1_qp_v_div6;
2642 i4_mb_inter_inc = (!((ps_cur_mb_info->ps_curmb->u1_mb_type == I_4x4_MB)
2643 || (ps_cur_mb_info->ps_curmb->u1_mb_type == I_16x16_MB)))
2644 * 3;
2645
2646 if(ps_dec->s_high_profile.u1_scaling_present)
2647 {
2648 u4_scale_u *=
2649 ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc
2650 + 1][0];
2651 u4_scale_v *=
2652 ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc
2653 + 2][0];
2654
2655 }
2656 else
2657 {
2658 u4_scale_u <<= 4;
2659 u4_scale_v <<= 4;
2660 }
2661
2662 ih264d_cavlc_parse_chroma_dc(ps_cur_mb_info,pi2_coeff_block, ps_dec->ps_bitstrm,
2663 u4_scale_u, u4_scale_v,
2664 i4_mb_inter_inc);
2665 }
2666
2667 if(u1_cbp == CBPC_ACZERO)
2668 return (0);
2669
2670 pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[0];
2671 pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[1];
2672 pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[2];
2673 pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[3];
2674 /*--------------------------------------------------------------------*/
2675 /* Decode Chroma AC values */
2676 /*--------------------------------------------------------------------*/
2677 {
2678 UWORD32 u4_temp;
2679 /*****************************************************************/
2680 /* U Block residual decoding, check cbp and proceed (subblock=0)*/
2681 /*****************************************************************/
2682 ret = pf_cavlc_parse_8x8block[u4_nbr_avl](
2683 pi2_coeff_block, 2, 1, ps_dec, pu1_top_nnz,
2684 pu1_left_nnz, 0, 0, &u4_temp);
2685 if(ret != OK)
2686 return ret;
2687 u2_chroma_csbp = u4_temp;
2688
2689 pi2_coeff_block += MB_CHROM_SIZE;
2690 /*****************************************************************/
2691 /* V Block residual decoding, check cbp and proceed (subblock=1)*/
2692 /*****************************************************************/
2693 ret = pf_cavlc_parse_8x8block[u4_nbr_avl](pi2_coeff_block, 2, 1,
2694 ps_dec,
2695 (pu1_top_nnz + 2),
2696 (pu1_left_nnz + 2), 0,
2697 0, &u4_temp);
2698 if(ret != OK)
2699 return ret;
2700 u2_chroma_csbp |= (u4_temp << 4);
2701 }
2702
2703 ps_cur_mb_info->u2_chroma_csbp = u2_chroma_csbp;
2704 }
2705 return OK;
2706}