1 /******************************************************************************
2 *
3 * Copyright (C) 2022 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
23 * isvcd_parse_epslice.c
24 *
25 * @brief
26 * Contains routines that decode a EP slice type
27 *
28 * @author
29 * Kishore
30 *
31 * @par List of Functions:
32 * - isvcd_parse_epslice()
33 * - isvcd_parse_inter_slice_data_cabac()
34 * - isvcd_parse_inter_slice_data_cabac_enh_lyr()
35 * - isvcd_parse_inter_slice_data_cavlc_enh_lyr()
36 * - isvcd_parse_pmb_cabac()
37 * - isvcd_parse_pmb_cavlc()
38 * - isvcd_mark_err_slice_skip()
39 * - isvcd_parse_interlayer_resamp_func_init()
40 * - isvcd_parse_pslice()
41 *
42 * @remarks
43 * None
44 *
45 *******************************************************************************
46 */
47
48 #include <string.h>
49 #include "ih264_defs.h"
50 #include "ih264d_bitstrm.h"
51 #include "ih264d_defs.h"
52 #include "ih264d_debug.h"
53 #include "ih264d_tables.h"
54 #include "isvcd_structs.h"
55 #include "ih264d_parse_cavlc.h"
56 #include "ih264d_mb_utils.h"
57 #include "ih264d_parse_slice.h"
58 #include "ih264d_mvpred.h"
59 #include "ih264d_parse_islice.h"
60 #include "ih264d_process_intra_mb.h"
61 #include "ih264d_inter_pred.h"
62 #include "ih264d_process_pslice.h"
63 #include "ih264d_deblocking.h"
64 #include "ih264d_cabac.h"
65 #include "ih264d_parse_mb_header.h"
66 #include "ih264d_error_handler.h"
67 #include "ih264d_format_conv.h"
68 #include "ih264d_quant_scaling.h"
69 #include "ih264d_thread_parse_decode.h"
70 #include "ih264d_thread_compute_bs.h"
71 #include "ih264d_process_bslice.h"
72 #include "ithread.h"
73 #include "ih264d_utils.h"
74 #include "ih264d_format_conv.h"
75 #include "ih264d_parse_headers.h"
76 #include "isvcd_parse_headers.h"
77 #include "isvcd_process_epslice.h"
78 #include "isvcd_mode_mv_resamp.h"
79 #include "isvcd_parse_slice.h"
80 #include "isvcd_parse_cavlc.h"
81 #include "isvcd_mb_utils.h"
82
83 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t *ps_dec);
84 void isvcd_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t *ps_dec);
85
86 /*!
87 **************************************************************************
88 * \if Function name : isvcd_parse_epslice \endif
89 *
90 * \brief
91 * Decodes a EP Slice
92 *
93 *
94 * \return
95 * 0 on Success and Error code otherwise
96 **************************************************************************
97 */
isvcd_parse_epslice(svc_dec_lyr_struct_t * ps_svc_lyr_dec,UWORD16 u2_first_mb_in_slice)98 WORD32 isvcd_parse_epslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_first_mb_in_slice)
99 {
100 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
101 WORD32 i_status = OK;
102 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
103 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
104 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
105 dec_seq_params_t *ps_seq;
106 dec_svc_seq_params_t *ps_subset_seq;
107 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
108 dec_subset_seq_params_t *ps_sps_svc_ext = NULL;
109 dec_nal_unit_svc_ext_params_t *ps_nal_svc_ext = NULL;
110
111 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
112 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
113 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
114 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
115
116 UWORD64 u8_ref_idx_l0;
117 UWORD32 u4_temp;
118 WORD32 i_temp;
119 WORD32 ret;
120 WORD64 i8_temp;
121
122 ps_nal_svc_ext = ps_svc_lyr_dec->ps_nal_svc_ext;
123 ps_seq = ps_pps->ps_sps;
124 ps_seq += MAX_NUM_SEQ_PARAMS;
125 ps_subset_seq =
126 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
127 ps_sps_svc_ext = &ps_subset_seq->s_sps_svc_ext;
128 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
129
130 /*--------------------------------------------------------------------*/
131 /* Read remaining contents of the slice header */
132 /*--------------------------------------------------------------------*/
133 {
134 WORD8 *pi1_buf;
135 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
136 WORD32 *pi4_mv = (WORD32 *) pi2_mv;
137 WORD16 *pi16_refFrame;
138
139 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
140 pi16_refFrame = (WORD16 *) pi1_buf;
141 *pi4_mv = 0;
142 *(pi4_mv + 1) = 0;
143 *pi16_refFrame = OUT_OF_RANGE_REF;
144 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8) -1;
145 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8) -1;
146 }
147
148 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
149 {
150 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(ps_bitstrm);
151
152 COPYTHECONTEXT("Slice Header SVC ext: num_ref_idx_override_flag",
153 ps_cur_slice->u1_num_ref_idx_active_override_flag);
154
155 u8_ref_idx_l0 = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
156 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
157 {
158 u8_ref_idx_l0 = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + (UWORD64) 1;
159 }
160
161 {
162 UWORD8 u1_max_ref_idx = H264_MAX_REF_PICS << u1_field_pic_flag;
163 if(u8_ref_idx_l0 > u1_max_ref_idx)
164 {
165 return ERROR_NUM_REF;
166 }
167 ps_cur_slice->u1_num_ref_idx_lx_active[0] = (UWORD8) u8_ref_idx_l0;
168 COPYTHECONTEXT("Slice Header SVC ext: num_ref_idx_l0_active_minus1",
169 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
170 }
171
172 {
173 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
174 COPYTHECONTEXT("Slice Header SVC ext: ref_pic_list_reordering_flag_l0",
175 uc_refIdxReFlagL0);
176
177 ih264d_init_ref_idx_lx_p(ps_dec);
178 /* Store the value for future slices in the same picture */
179 ps_dec->u1_num_ref_idx_lx_active_prev = ps_cur_slice->u1_num_ref_idx_lx_active[0];
180
181 /* Modified temporarily */
182 if(uc_refIdxReFlagL0)
183 {
184 WORD8 ret;
185 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
186 ret = ih264d_ref_idx_reordering(ps_dec, 0);
187 if(ret == -1) return ERROR_REFIDX_ORDER_T;
188 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
189 }
190 else
191 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0];
192 }
193 /* Create refIdx to POC mapping */
194 {
195 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
196 WORD8 idx;
197 struct pic_buffer_t *ps_pic;
198
199 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
200 pui_map_ref_idx_to_poc_lx0[0] = 0;
201 pui_map_ref_idx_to_poc_lx0++;
202 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
203 {
204 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
205 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
206 }
207
208 /* Bug Fix Deblocking */
209 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
210 pui_map_ref_idx_to_poc_lx1[0] = 0;
211
212 if(u1_mbaff)
213 {
214 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
215 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
216 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc + TOP_LIST_FLD_L0;
217 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc + BOT_LIST_FLD_L0;
218
219 ppv_map_ref_idx_to_poc_lx_t[0] = 0;
220 ppv_map_ref_idx_to_poc_lx_t++;
221 ppv_map_ref_idx_to_poc_lx_b[0] = 0;
222 ppv_map_ref_idx_to_poc_lx_b++;
223
224 idx = 0;
225 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
226 {
227 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
228 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
229 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
230
231 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
232 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
233
234 ppv_map_ref_idx_to_poc_lx_t += 2;
235 ppv_map_ref_idx_to_poc_lx_b += 2;
236 }
237 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc + TOP_LIST_FLD_L1;
238 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
239 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc + BOT_LIST_FLD_L1;
240 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
241 }
242 /* BS is moved post recon gen in libsvc*/
243 if(ps_dec->u4_num_cores >= 2)
244 {
245 WORD32 num_entries;
246 WORD32 size;
247
248 num_entries = MAX_FRAMES;
249 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
250 {
251 num_entries = 1;
252 }
253 num_entries = ((2 * num_entries) + 1);
254 num_entries *= 2;
255
256 size = num_entries * sizeof(void *);
257 size += PAD_MAP_IDX_POC * sizeof(void *);
258
259 memcpy((void *) ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc,
260 ps_dec->ppv_map_ref_idx_to_poc, size);
261 }
262 }
263 if(ps_pps->u1_wted_pred_flag)
264 {
265 if(!ps_nal_svc_ext->u1_no_inter_layer_pred_flag)
266 {
267 ps_svc_slice_params->u1_base_pred_weight_table_flag =
268 ih264d_get_bit_h264(ps_bitstrm);
269 COPYTHECONTEXT("Slice Header SVC ext: u1_base_pred_weight_table_flag",
270 ps_svc_slice_params->u1_base_pred_weight_table_flag);
271 }
272
273 if(ps_nal_svc_ext->u1_no_inter_layer_pred_flag ||
274 !ps_svc_slice_params->u1_base_pred_weight_table_flag)
275 {
276 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
277 if(ret != OK) return ret;
278
279 ih264d_form_pred_weight_matrix(ps_dec);
280 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
281 }
282 }
283 else
284 {
285 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
286 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
287 }
288
289 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
290
291 if(u1_mbaff && (u1_field_pic_flag == 0))
292 {
293 ih264d_convert_frm_mbaff_list(ps_dec);
294 }
295
296 /* G050 */
297 if(ps_cur_slice->u1_nal_ref_idc != 0)
298 {
299 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
300 {
301 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
302 dec_seq_params_t *ps_sps_tmp = ps_pps->ps_sps;
303 UWORD8 u1_nal_unit_type_tmp = ps_dec->u1_nal_unit_type;
304
305 ps_pps->ps_sps = ps_dec->ps_cur_sps;
306
307 if(ps_svc_lyr_dec->ps_nal_svc_ext->u1_idr_flag)
308 ps_dec->u1_nal_unit_type = IDR_SLICE_NAL;
309
310 i_temp = ih264d_read_mmco_commands(ps_dec);
311
312 ps_pps->ps_sps = ps_sps_tmp;
313 ps_dec->u1_nal_unit_type = u1_nal_unit_type_tmp;
314
315 if(i_temp < 0)
316 {
317 return ERROR_DBP_MANAGER_T;
318 }
319 ps_dec->u4_bitoffset = i_temp;
320 }
321 else
322 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
323
324 if(!ps_sps_svc_ext->u1_slice_header_restriction_flag)
325 {
326 ps_svc_slice_params->u1_store_ref_base_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
327 COPYTHECONTEXT("SPS_SVC_EXT: u1_store_ref_base_pic_flag",
328 ps_svc_slice_params->u1_store_ref_base_pic_flag);
329
330 if(0 != ps_svc_slice_params->u1_store_ref_base_pic_flag)
331 {
332 return NOT_OK;
333 }
334 if(((1 == ps_nal_svc_ext->u1_use_ref_base_pic_flag) ||
335 (1 == ps_svc_slice_params->u1_store_ref_base_pic_flag)) &&
336 (!ps_nal_svc_ext->u1_idr_flag))
337 {
338 i_status = isvcd_dec_ref_base_pic_marking(
339 &ps_svc_slice_params->s_ref_base_pic_marking_svc_ext, ps_bitstrm);
340 if(i_status != OK)
341 {
342 return i_status;
343 }
344 }
345 }
346 }
347 }
348 /* G050 */
349
350 if(ps_pps->u1_entropy_coding_mode == CABAC)
351 {
352 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
353
354 if(u4_temp > MAX_CABAC_INIT_IDC)
355 {
356 return ERROR_INV_SLICE_HDR_T;
357 }
358 ps_cur_slice->u1_cabac_init_idc = u4_temp;
359 COPYTHECONTEXT("Slice Header SVC ext: cabac_init_idc", ps_cur_slice->u1_cabac_init_idc);
360 }
361
362 /* Read slice_qp_delta */
363 i8_temp = (WORD64) ps_pps->u1_pic_init_qp + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
364 if((i8_temp < MIN_H264_QP) || (i8_temp > MAX_H264_QP))
365 {
366 return ERROR_INV_RANGE_QP_T;
367 }
368 ps_cur_slice->u1_slice_qp = (UWORD8) i8_temp;
369 COPYTHECONTEXT("Slice Header SVC ext: slice_qp_delta",
370 (WORD8) (ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
371
372 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
373 {
374 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
375 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
376 {
377 return ERROR_INV_SLICE_HDR_T;
378 }
379
380 COPYTHECONTEXT("Slice Header SVC ext: disable_deblocking_filter_idc", u4_temp);
381 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
382 if(u4_temp != 1)
383 {
384 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) << 1;
385 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
386 {
387 return ERROR_INV_SLICE_HDR_T;
388 }
389 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
390 COPYTHECONTEXT("Slice Header SVC ext: slice_alpha_c0_offset_div2",
391 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
392
393 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) << 1;
394 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
395 {
396 return ERROR_INV_SLICE_HDR_T;
397 }
398 ps_cur_slice->i1_slice_beta_offset = i_temp;
399 COPYTHECONTEXT("Slice Header SVC ext: slice_beta_offset_div2",
400 ps_cur_slice->i1_slice_beta_offset >> 1);
401 }
402 else
403 {
404 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
405 ps_cur_slice->i1_slice_beta_offset = 0;
406 }
407 }
408 else
409 {
410 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
411 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
412 ps_cur_slice->i1_slice_beta_offset = 0;
413 }
414
415 /* add the remaining part of the code for svc extension from reference */
416 ret = isvcd_set_default_slice_header_ext(ps_svc_lyr_dec);
417 if(ret != OK)
418 {
419 return ERROR_INV_SLICE_HDR_T;
420 }
421
422 ret = isvcd_parse_slice_header(ps_svc_lyr_dec);
423 if(ret != OK)
424 {
425 return ERROR_INV_SLICE_HDR_T;
426 }
427
428 ps_dec->u1_slice_header_done = 2;
429
430 if(!ps_svc_slice_params->u1_slice_skip_flag)
431 {
432 if(ps_pps->u1_entropy_coding_mode)
433 {
434 SWITCHOFFTRACE;
435 SWITCHONTRACECABAC;
436 ps_svc_lyr_dec->pf_parse_inter_slice_svc_ext =
437 isvcd_parse_inter_slice_data_cabac_enh_lyr;
438 ps_svc_lyr_dec->pf_parse_inter_mb_svc_ext = isvcd_parse_pmb_cabac;
439
440 isvcd_init_cabac_contexts(P_SLICE, ps_dec);
441
442 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
443 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
444 else
445 ps_dec->pf_get_mb_info = isvcd_get_mb_info_cabac_nonmbaff;
446 }
447 else
448 {
449 SWITCHONTRACE;
450 SWITCHOFFTRACECABAC;
451 ps_svc_lyr_dec->pf_parse_inter_slice_svc_ext =
452 isvcd_parse_inter_slice_data_cavlc_enh_lyr;
453 ps_svc_lyr_dec->pf_parse_inter_mb_svc_ext = isvcd_parse_pmb_cavlc;
454
455 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
456 {
457 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
458 }
459 else
460 ps_dec->pf_get_mb_info = isvcd_get_mb_info_cavlc_nonmbaff;
461 }
462 }
463 else
464 {
465 return ERROR_FEATURE_UNAVAIL;
466 }
467
468 ps_dec->u1_B = 0;
469 ps_dec->pf_mvpred_ref_tfr_nby2mb = isvcd_mv_pred_ref_tfr_nby2_epmb;
470 ret = ps_svc_lyr_dec->pf_parse_inter_slice_svc_ext(ps_svc_lyr_dec, ps_cur_slice,
471 u2_first_mb_in_slice);
472 if(ret != OK) return ret;
473
474 return OK;
475 }
476
477 /*****************************************************************************/
478 /* */
479 /* Function Name : isvcd_parse_inter_slice_data_cabac */
480 /* */
481 /* Description : This function parses cabac syntax of a inter slice on */
482 /* N MB basis. */
483 /* */
484 /* Inputs : ps_dec */
485 /* sliceparams */
486 /* firstMbInSlice */
487 /* */
488 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
489 /* decoded till the end of slice. */
490 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
491 /* */
492 /* Returns : 0 */
493 /* */
494 /* Issues : <List any issues or problems with this function> */
495 /* */
496 /* Revision History: */
497 /* */
498 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
499 /* 13 07 2002 Jay Draft */
500 /* */
501 /*****************************************************************************/
isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)502 WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
503 dec_slice_params_t *ps_slice,
504 UWORD16 u2_first_mb_in_slice)
505 {
506 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
507
508 UWORD32 uc_more_data_flag;
509 WORD32 i2_cur_mb_addr;
510 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
511 UWORD32 u1_mbaff;
512 UWORD32 u1_num_mbs_next, u1_end_of_row;
513 const UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
514 UWORD32 u1_slice_end = 0;
515 UWORD32 u1_tfr_n_mb = 0;
516 UWORD32 u1_decode_nmb = 0;
517
518 deblk_mb_t *ps_cur_deblk_mb;
519 dec_mb_info_t *ps_cur_mb_info;
520 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
521 UWORD32 u1_inter_mb_skip_type;
522 UWORD32 u1_inter_mb_type;
523 UWORD32 u1_deblk_mb_type;
524 UWORD32 u1_mb_threshold;
525 dec_bit_stream_t *const ps_bitstrm = ps_dec->ps_bitstrm;
526 WORD32 ret = OK;
527
528 /******************************************************/
529 /* Initialisations specific to B or P slice */
530 /******************************************************/
531 if(ps_slice->u1_slice_type == P_SLICE)
532 {
533 u1_inter_mb_skip_type = CAB_P_SKIP;
534 u1_inter_mb_type = P_MB;
535 u1_deblk_mb_type = D_INTER_MB;
536 u1_mb_threshold = 5;
537 }
538 else // B_SLICE
539 {
540 u1_inter_mb_skip_type = CAB_B_SKIP;
541 u1_inter_mb_type = B_MB;
542 u1_deblk_mb_type = D_B_SLICE;
543 u1_mb_threshold = 23;
544 }
545
546 /******************************************************/
547 /* Slice Level Initialisations */
548 /******************************************************/
549 i2_cur_mb_addr = u2_first_mb_in_slice;
550 ps_dec->u1_qp = ps_slice->u1_slice_qp;
551 ih264d_update_qp(ps_dec, 0);
552 u1_mb_idx = ps_dec->u1_mb_idx;
553 u1_num_mbs = u1_mb_idx;
554 u1_num_mbsNby2 = 0;
555 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
556 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
557 uc_more_data_flag = 1;
558
559 /* Initialisations specific to cabac */
560 if(ps_bitstrm->u4_ofst & 0x07)
561 {
562 ps_bitstrm->u4_ofst += 8;
563 ps_bitstrm->u4_ofst &= 0xFFFFFFF8;
564 }
565
566 ret = ih264d_init_cabac_dec_envirnoment(&(ps_dec->s_cab_dec_env), ps_bitstrm);
567 if(ret != OK) return ret;
568
569 ps_dec->i1_prev_mb_qp_delta = 0;
570
571 while(!u1_slice_end)
572 {
573 UWORD8 u1_mb_type;
574 UWORD32 u4_mb_skip;
575
576 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
577
578 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
579 {
580 break;
581 }
582
583 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
584 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
585
586 ps_cur_mb_info->u1_Mux = 0;
587 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
588 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
589 ps_cur_mb_info->u1_end_of_slice = 0;
590
591 /* Storing Default partition info */
592 ps_parse_mb_data->u1_num_part = 1;
593 ps_parse_mb_data->u1_isI_mb = 0;
594
595 /***************************************************************/
596 /* Get the required information for decoding of MB */
597 /* mb_x, mb_y , neighbour availablity, */
598 /***************************************************************/
599 u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1);
600
601 /*********************************************************************/
602 /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */
603 /*********************************************************************/
604 ps_cur_mb_info->u1_tran_form8x8 = 0;
605 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
606
607 /***************************************************************/
608 /* Set the deblocking parameters for this MB */
609 /***************************************************************/
610 if(ps_dec->u4_app_disable_deblk_frm == 0)
611 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
612 ps_dec->u1_mb_ngbr_availablity,
613 ps_dec->u1_cur_mb_fld_dec_flag);
614
615 if(u4_mb_skip)
616 {
617 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
618 memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t));
619 ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type;
620
621 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
622
623 *((UWORD32 *) ps_dec->pi1_left_ref_idx_ctxt_inc) = 0;
624 *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
625 ps_dec->i1_prev_mb_qp_delta = 0;
626 ps_cur_mb_info->u1_mb_type = MB_SKIP;
627 ps_cur_mb_info->u1_cbp = 0;
628
629 {
630 /* Storing Skip partition info */
631 parse_part_params_t *ps_part_info = ps_dec->ps_part;
632 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
633 ps_part_info->u1_sub_mb_num = 0;
634 ps_dec->ps_part++;
635 }
636
637 /* Update Nnzs */
638 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC);
639 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
640 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
641 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
642 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
643 {
644 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
645 }
646 }
647 else
648 {
649 /* Macroblock Layer Begins */
650 /* Decode the u1_mb_type */
651 u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec);
652 ps_cur_mb_info->u1_mb_type = u1_mb_type;
653 if(u1_mb_type > (25 + u1_mb_threshold)) return ERROR_MB_TYPE;
654
655 /* Parse Macroblock Data */
656 if(u1_mb_type < u1_mb_threshold)
657 {
658 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
659 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6;
660
661 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, u1_num_mbsNby2);
662 if(ret != OK) return ret;
663 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
664 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
665 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
666 {
667 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
668 }
669 }
670 else
671 {
672 /* Storing Intra partition info */
673 ps_parse_mb_data->u1_num_part = 0;
674 ps_parse_mb_data->u1_isI_mb = 1;
675
676 if((25 + u1_mb_threshold) == u1_mb_type)
677 {
678 /* I_PCM_MB */
679 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
680 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
681 if(ret != OK) return ret;
682 ps_cur_deblk_mb->u1_mb_qp = 0;
683 }
684 else
685 {
686 if(u1_mb_type == u1_mb_threshold)
687 ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB;
688 else
689 ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB;
690
691 ret = ih264d_parse_imb_cabac(ps_dec, ps_cur_mb_info,
692 (UWORD8) (u1_mb_type - u1_mb_threshold));
693 if(ret != OK) return ret;
694 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
695 }
696 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
697 }
698 }
699
700 if(ps_dec->u1_enable_mb_info)
701 {
702 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
703 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
704 }
705 if(u1_mbaff)
706 {
707 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
708 }
709
710 if(ps_cur_mb_info->u1_topmb && u1_mbaff)
711 uc_more_data_flag = 1;
712 else
713 {
714 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env, ps_bitstrm);
715 uc_more_data_flag = !uc_more_data_flag;
716 COPYTHECONTEXT("Decode Sliceterm", !uc_more_data_flag);
717 }
718
719 if(u1_mbaff)
720 {
721 if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
722 {
723 return ERROR_EOB_FLUSHBITS_T;
724 }
725 }
726 /* Next macroblock information */
727 i2_cur_mb_addr++;
728 u1_num_mbs++;
729 u1_num_mbsNby2++;
730 ps_parse_mb_data++;
731
732 /****************************************************************/
733 /* Check for End Of Row and other flags that determine when to */
734 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
735 /* N-Mb */
736 /****************************************************************/
737 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
738 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
739 u1_slice_end = !uc_more_data_flag;
740 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
741 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
742 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
743
744 if(u1_decode_nmb)
745 {
746 ret = ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
747 u1_num_mbsNby2 = 0;
748 {
749 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
750 ps_dec->ps_part = ps_dec->ps_parse_part_params;
751 }
752 if(ret != OK) return ret;
753 }
754
755 if(u1_decode_nmb)
756 {
757 if(ps_dec->u1_separate_parse)
758 {
759 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, u1_tfr_n_mb,
760 u1_end_of_row);
761 ps_dec->ps_nmb_info += u1_num_mbs;
762 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
763 }
764 else
765 {
766 if(ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER)
767 {
768 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
769 u1_tfr_n_mb, u1_end_of_row);
770 }
771 else
772 {
773 isvcd_decode_recon_tfr_nmb_base_lyr(ps_svc_lyr_dec, u1_mb_idx, u1_num_mbs,
774 u1_num_mbs_next, u1_tfr_n_mb,
775 u1_end_of_row);
776 }
777 }
778 ps_dec->u2_total_mbs_coded += u1_num_mbs;
779 if(u1_tfr_n_mb) u1_num_mbs = 0;
780 u1_mb_idx = u1_num_mbs;
781 ps_dec->u1_mb_idx = u1_num_mbs;
782 }
783 }
784
785 ps_dec->u4_num_mbs_cur_nmb = 0;
786 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr - (u2_first_mb_in_slice << u1_mbaff);
787
788 return ret;
789 }
790
791 /*****************************************************************************/
792 /* */
793 /* Function Name : isvcd_parse_inter_slice_data_cavlc */
794 /* */
795 /* Description : This function parses cavlc syntax of a inter slice on */
796 /* N MB basis. */
797 /* */
798 /* Inputs : ps_dec */
799 /* sliceparams */
800 /* firstMbInSlice */
801 /* */
802 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
803 /* decoded till the end of slice. */
804 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
805 /* */
806 /* Returns : 0 */
807 /* */
808 /* Issues : <List any issues or problems with this function> */
809 /* */
810 /* Revision History: */
811 /* */
812 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
813 /* 13 07 2002 Jay Draft */
814 /* */
815 /*****************************************************************************/
816
isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)817 WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
818 dec_slice_params_t *ps_slice,
819 UWORD16 u2_first_mb_in_slice)
820 {
821 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
822 UWORD32 uc_more_data_flag;
823 WORD32 i2_cur_mb_addr;
824 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
825 UWORD32 i2_mb_skip_run;
826 UWORD32 u1_read_mb_type;
827
828 UWORD32 u1_mbaff;
829 UWORD32 u1_num_mbs_next, u1_end_of_row;
830 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
831 UWORD32 u1_slice_end = 0;
832 UWORD32 u1_tfr_n_mb = 0;
833 UWORD32 u1_decode_nmb = 0;
834
835 dec_bit_stream_t *const ps_bitstrm = ps_dec->ps_bitstrm;
836 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
837 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
838 deblk_mb_t *ps_cur_deblk_mb;
839 dec_mb_info_t *ps_cur_mb_info;
840 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
841 UWORD32 u1_inter_mb_type;
842 UWORD32 u1_deblk_mb_type;
843 UWORD32 u1_mb_threshold;
844 WORD32 ret = OK;
845
846 /******************************************************/
847 /* Initialisations specific to B or P slice */
848 /******************************************************/
849 if(ps_slice->u1_slice_type == P_SLICE)
850 {
851 u1_inter_mb_type = P_MB;
852 u1_deblk_mb_type = D_INTER_MB;
853 u1_mb_threshold = 5;
854 }
855 else // B_SLICE
856 {
857 u1_inter_mb_type = B_MB;
858 u1_deblk_mb_type = D_B_SLICE;
859 u1_mb_threshold = 23;
860 }
861
862 /******************************************************/
863 /* Slice Level Initialisations */
864 /******************************************************/
865 ps_dec->u1_qp = ps_slice->u1_slice_qp;
866 ih264d_update_qp(ps_dec, 0);
867 u1_mb_idx = ps_dec->u1_mb_idx;
868 u1_num_mbs = u1_mb_idx;
869
870 u1_num_mbsNby2 = 0;
871 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
872 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
873 i2_mb_skip_run = 0;
874 uc_more_data_flag = 1;
875 u1_read_mb_type = 0;
876
877 while(!u1_slice_end)
878 {
879 UWORD8 u1_mb_type;
880
881 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
882 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
883 {
884 break;
885 }
886
887 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
888 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
889 ps_cur_mb_info->u1_Mux = 0;
890 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
891 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
892
893 ps_cur_mb_info->u1_end_of_slice = 0;
894
895 /* Storing Default partition info */
896 ps_parse_mb_data->u1_num_part = 1;
897 ps_parse_mb_data->u1_isI_mb = 0;
898
899 if((!i2_mb_skip_run) && (!u1_read_mb_type))
900 {
901 // Inlined ih264d_uev
902 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
903 UWORD32 u4_word, u4_ldz;
904
905 /***************************************************************/
906 /* Find leading zeros in next 32 bits */
907 /***************************************************************/
908 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
909
910 u4_ldz = CLZ(u4_word);
911
912 /* Flush the ps_bitstrm */
913 u4_bitstream_offset += (u4_ldz + 1);
914 /* Read the suffix from the ps_bitstrm */
915 u4_word = 0;
916 if(u4_ldz)
917 {
918 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
919 }
920 *pu4_bitstrm_ofst = u4_bitstream_offset;
921 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1);
922 // Inlined ih264d_uev
923 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run);
924 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
925 u1_read_mb_type = uc_more_data_flag;
926 }
927
928 /***************************************************************/
929 /* Get the required information for decoding of MB */
930 /* mb_x, mb_y , neighbour availablity, */
931 /***************************************************************/
932 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
933
934 /***************************************************************/
935 /* Set the deblocking parameters for this MB */
936 /***************************************************************/
937 if(ps_dec->u4_app_disable_deblk_frm == 0)
938 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
939 ps_dec->u1_mb_ngbr_availablity,
940 ps_dec->u1_cur_mb_fld_dec_flag);
941
942 if(i2_mb_skip_run)
943 {
944 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
945 ps_dec->i1_prev_mb_qp_delta = 0;
946 ps_dec->u1_sub_mb_num = 0;
947 ps_cur_mb_info->u1_mb_type = MB_SKIP;
948 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
949 ps_cur_mb_info->u1_cbp = 0;
950
951 {
952 /* Storing Skip partition info */
953 parse_part_params_t *ps_part_info = ps_dec->ps_part;
954 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
955 ps_part_info->u1_sub_mb_num = 0;
956 ps_dec->ps_part++;
957 }
958
959 /* Update Nnzs */
960 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
961
962 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
963 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
964
965 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
966 {
967 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
968 }
969
970 i2_mb_skip_run--;
971 }
972 else
973 {
974 u1_read_mb_type = 0;
975 /**************************************************************/
976 /* Macroblock Layer Begins, Decode the u1_mb_type */
977 /**************************************************************/
978 {
979 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
980 UWORD32 u4_word, u4_ldz, u4_temp;
981
982 // Inlined ih264d_uev
983 /***************************************************************/
984 /* Find leading zeros in next 32 bits */
985 /***************************************************************/
986 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
987 u4_ldz = CLZ(u4_word);
988 /* Flush the ps_bitstrm */
989 u4_bitstream_offset += (u4_ldz + 1);
990 /* Read the suffix from the ps_bitstrm */
991 u4_word = 0;
992 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
993 *pu4_bitstrm_ofst = u4_bitstream_offset;
994 u4_temp = ((1 << u4_ldz) + u4_word - 1);
995 // Inlined ih264d_uev
996 if(u4_temp > (UWORD32) (25 + u1_mb_threshold)) return ERROR_MB_TYPE;
997 u1_mb_type = u4_temp;
998 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
999 }
1000 ps_cur_mb_info->u1_mb_type = u1_mb_type;
1001
1002 /**************************************************************/
1003 /* Parse Macroblock data */
1004 /**************************************************************/
1005 if(u1_mb_type < u1_mb_threshold)
1006 {
1007 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1008
1009 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, u1_num_mbsNby2);
1010 if(ret != OK) return ret;
1011 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1012
1013 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1014 {
1015 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1016 }
1017 }
1018 else
1019 {
1020 /* Storing Intra partition info */
1021 ps_parse_mb_data->u1_num_part = 0;
1022 ps_parse_mb_data->u1_isI_mb = 1;
1023
1024 if((25 + u1_mb_threshold) == u1_mb_type)
1025 {
1026 /* I_PCM_MB */
1027 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
1028 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
1029 if(ret != OK) return ret;
1030 ps_dec->u1_qp = 0;
1031 }
1032 else
1033 {
1034 ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u1_num_mbs,
1035 (UWORD8) (u1_mb_type - u1_mb_threshold));
1036 if(ret != OK) return ret;
1037 }
1038
1039 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1040 }
1041 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1042 }
1043 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1044
1045 if(ps_dec->u1_enable_mb_info)
1046 {
1047 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
1048 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
1049 }
1050 if(u1_mbaff)
1051 {
1052 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1053 if(!uc_more_data_flag && !i2_mb_skip_run && (0 == (i2_cur_mb_addr & 1)))
1054 {
1055 return ERROR_EOB_FLUSHBITS_T;
1056 }
1057 }
1058
1059 /**************************************************************/
1060 /* Get next Macroblock address */
1061 /**************************************************************/
1062 i2_cur_mb_addr++;
1063
1064 u1_num_mbs++;
1065 u1_num_mbsNby2++;
1066 ps_parse_mb_data++;
1067
1068 /****************************************************************/
1069 /* Check for End Of Row and other flags that determine when to */
1070 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1071 /* N-Mb */
1072 /****************************************************************/
1073 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1074 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1075 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
1076 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
1077 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1078 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1079
1080 if(u1_decode_nmb)
1081 {
1082 ret = ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1083 u1_num_mbsNby2 = 0;
1084 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1085 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1086 if(ret != OK) return ret;
1087 }
1088
1089 if(u1_decode_nmb)
1090 {
1091 if(ps_dec->u1_separate_parse)
1092 {
1093 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, u1_tfr_n_mb,
1094 u1_end_of_row);
1095 ps_dec->ps_nmb_info += u1_num_mbs;
1096 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
1097 }
1098 else
1099 {
1100 if(ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER)
1101 {
1102 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
1103 u1_tfr_n_mb, u1_end_of_row);
1104 }
1105 else
1106 {
1107 isvcd_decode_recon_tfr_nmb_base_lyr(ps_svc_lyr_dec, u1_mb_idx, u1_num_mbs,
1108 u1_num_mbs_next, u1_tfr_n_mb,
1109 u1_end_of_row);
1110 }
1111 }
1112 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1113 if(u1_tfr_n_mb) u1_num_mbs = 0;
1114 u1_mb_idx = u1_num_mbs;
1115 ps_dec->u1_mb_idx = u1_num_mbs;
1116 }
1117 }
1118
1119 ps_dec->u4_num_mbs_cur_nmb = 0;
1120 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr - (u2_first_mb_in_slice << u1_mbaff);
1121
1122 return ret;
1123 }
1124
1125 /*****************************************************************************/
1126 /* */
1127 /* Function Name : isvcd_parse_inter_slice_data_cabac_enh_lyr */
1128 /* */
1129 /* Description : This function parses cabac syntax of a inter slice on */
1130 /* N MB basis for svc ext */
1131 /* */
1132 /* Inputs : ps_dec */
1133 /* sliceparams */
1134 /* firstMbInSlice */
1135 /* */
1136 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
1137 /* decoded till the end of slice. */
1138 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
1139 /* */
1140 /* Returns : 0 */
1141 /* */
1142 /* Issues : <List any issues or problems with this function> */
1143 /* */
1144 /* Revision History: */
1145 /* */
1146 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1147 /* 09 06 2021 Jay Draft */
1148 /* */
1149 /*****************************************************************************/
1150 WORD32
isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)1151 isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
1152 dec_slice_params_t *ps_slice,
1153 UWORD16 u2_first_mb_in_slice)
1154 {
1155 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1156 UWORD32 uc_more_data_flag;
1157 WORD32 i2_cur_mb_addr;
1158 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
1159 UWORD32 u1_mbaff;
1160 UWORD32 u1_num_mbs_next, u1_end_of_row;
1161 const UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1162 UWORD32 u1_slice_end = 0;
1163 UWORD32 u1_tfr_n_mb = 0;
1164 UWORD32 u1_decode_nmb = 0;
1165
1166 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1167 deblk_mb_t *ps_cur_deblk_mb;
1168 dec_mb_info_t *ps_cur_mb_info;
1169 dec_svc_mb_info_t *ps_svc_cur_mb_info;
1170
1171 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1172 UWORD32 u1_inter_mb_skip_type;
1173 UWORD32 u1_inter_mb_type;
1174 UWORD32 u1_deblk_mb_type;
1175 UWORD32 u1_mb_threshold;
1176 dec_bit_stream_t *const ps_bitstrm = ps_dec->ps_bitstrm;
1177 decoding_envirnoment_t *ps_cab_env = NULL;
1178 WORD32 ret = OK;
1179
1180 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1181
1182 /******************************************************/
1183 /* Initialisations specific to B or P slice */
1184 /******************************************************/
1185 if(ps_slice->u1_slice_type == P_SLICE)
1186 {
1187 u1_inter_mb_skip_type = CAB_P_SKIP;
1188 u1_inter_mb_type = P_MB;
1189 u1_deblk_mb_type = D_INTER_MB;
1190 u1_mb_threshold = 5;
1191 }
1192 else // EB_SLICE
1193 {
1194 u1_inter_mb_skip_type = CAB_B_SKIP;
1195 u1_inter_mb_type = B_MB;
1196 u1_deblk_mb_type = D_B_SLICE;
1197 u1_mb_threshold = 23;
1198 }
1199
1200 /******************************************************/
1201 /* Slice Level Initialisations */
1202 /******************************************************/
1203 i2_cur_mb_addr = u2_first_mb_in_slice;
1204 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1205 ih264d_update_qp(ps_dec, 0);
1206 u1_mb_idx = ps_dec->u1_mb_idx;
1207 u1_num_mbs = u1_mb_idx;
1208 u1_num_mbsNby2 = 0;
1209 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1210 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
1211 uc_more_data_flag = 1;
1212
1213 /* Initialisations specific to cabac */
1214 if(ps_bitstrm->u4_ofst & 0x07)
1215 {
1216 ps_bitstrm->u4_ofst += 8;
1217 ps_bitstrm->u4_ofst &= 0xFFFFFFF8;
1218 }
1219
1220 ret = ih264d_init_cabac_dec_envirnoment(&(ps_dec->s_cab_dec_env), ps_bitstrm);
1221 if(ret != OK) return ret;
1222
1223 ps_cab_env = &ps_dec->s_cab_dec_env;
1224 ps_dec->i1_prev_mb_qp_delta = 0;
1225
1226 while(!u1_slice_end)
1227 {
1228 UWORD8 u1_mb_type;
1229 UWORD32 u4_mb_skip;
1230 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1231 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1232 {
1233 break;
1234 }
1235
1236 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1237 ps_svc_cur_mb_info = ps_svc_lyr_dec->ps_svc_nmb_info + u1_num_mbs;
1238 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1239 ps_cur_mb_info->u1_Mux = 0;
1240 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1241 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1242 ps_cur_mb_info->u1_end_of_slice = 0;
1243
1244 /* Storing Default partition info */
1245 ps_parse_mb_data->u1_num_part = 1;
1246 ps_parse_mb_data->u1_isI_mb = 0;
1247
1248 /***************************************************************/
1249 /* Get the required information for decoding of MB */
1250 /* mb_x, mb_y , neighbour availablity, */
1251 /***************************************************************/
1252 u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1);
1253 ps_svc_cur_mb_info->u1_crop_window_flag =
1254 *(ps_svc_lyr_dec->pu1_crop_wnd_flag + ps_cur_mb_info->u2_mbx +
1255 (ps_cur_mb_info->u2_mby * ps_dec->u2_frm_wd_in_mbs));
1256 /*********************************************************************/
1257 /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */
1258 /*********************************************************************/
1259 ps_cur_mb_info->u1_tran_form8x8 = 0;
1260 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
1261
1262 /***************************************************************/
1263 /* Set the deblocking parameters for this MB */
1264 /***************************************************************/
1265 if(ps_dec->u4_app_disable_deblk_frm == 0)
1266 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1267 ps_dec->u1_mb_ngbr_availablity,
1268 ps_dec->u1_cur_mb_fld_dec_flag);
1269
1270 if(u4_mb_skip)
1271 {
1272 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1273 memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t));
1274 ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type;
1275
1276 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0);
1277
1278 *((UWORD32 *) ps_dec->pi1_left_ref_idx_ctxt_inc) = 0;
1279 *(ps_dec->pu1_left_yuv_dc_csbp) = 0;
1280
1281 ps_dec->i1_prev_mb_qp_delta = 0;
1282 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1283 ps_cur_mb_info->u1_cbp = 0;
1284 ps_svc_cur_mb_info->u1_base_mode_flag = 0;
1285 ps_svc_cur_mb_info->au1_motion_pred_flag[0] = 0;
1286 ps_svc_cur_mb_info->au1_motion_pred_flag[1] = 0;
1287 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
1288
1289 {
1290 /* Storing Skip partition info */
1291 parse_part_params_t *ps_part_info = ps_dec->ps_part;
1292 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1293 ps_part_info->u1_sub_mb_num = 0;
1294 ps_dec->ps_part++;
1295 }
1296
1297 /* Update Nnzs */
1298 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC);
1299 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1300 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1301 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1302 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1303 {
1304 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1305 }
1306 }
1307 else
1308 {
1309 /* Variables for handling Cabac contexts */
1310 UWORD8 *pu1_cur_svc_base_mode_flag;
1311 UWORD8 u1_left_svc_base_mode_flag;
1312 UWORD8 u1_top_svc_base_mode_flag;
1313
1314 UWORD32 u4_a, u4_b, u4_ctxt_inc;
1315 ps_svc_cur_mb_info->u1_base_mode_flag = 0;
1316 /* Macroblock Layer Begins */
1317 if(ps_svc_cur_mb_info->u1_crop_window_flag &&
1318 ps_svc_slice_params->u1_adaptive_base_mode_flag)
1319 {
1320 pu1_cur_svc_base_mode_flag =
1321 ps_svc_lyr_dec->pu1_svc_base_mode_flag + ps_cur_mb_info->u2_mbx;
1322 pu1_cur_svc_base_mode_flag +=
1323 ps_cur_mb_info->u2_mby * ps_svc_lyr_dec->i4_frm_svc_base_mode_cabac_stride;
1324
1325 u1_left_svc_base_mode_flag = 0;
1326 if(ps_dec->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK)
1327 u1_left_svc_base_mode_flag = *(pu1_cur_svc_base_mode_flag - 1);
1328
1329 u1_top_svc_base_mode_flag = 0;
1330 if(ps_dec->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK)
1331 u1_top_svc_base_mode_flag =
1332 *(pu1_cur_svc_base_mode_flag -
1333 ps_svc_lyr_dec->i4_frm_svc_base_mode_cabac_stride);
1334
1335 u4_a = 1;
1336 u4_b = 1;
1337
1338 if(u1_top_svc_base_mode_flag)
1339 {
1340 u4_a = 0;
1341 }
1342
1343 if(u1_left_svc_base_mode_flag)
1344 {
1345 u4_b = 0;
1346 }
1347
1348 u4_ctxt_inc = u4_a + u4_b;
1349 ps_svc_cur_mb_info->u1_base_mode_flag = ih264d_decode_bin(
1350 u4_ctxt_inc, ps_svc_lyr_dec->ps_base_mode_flag, ps_bitstrm, ps_cab_env);
1351 COPYTHECONTEXT("SVC ext: u1_base_mode_flag", ps_svc_cur_mb_info->u1_base_mode_flag);
1352 *pu1_cur_svc_base_mode_flag = ps_svc_cur_mb_info->u1_base_mode_flag;
1353 }
1354 else if(ps_svc_cur_mb_info->u1_crop_window_flag)
1355 {
1356 ps_svc_cur_mb_info->u1_base_mode_flag =
1357 ps_svc_slice_params->u1_default_base_mode_flag;
1358 }
1359
1360 if(!ps_svc_cur_mb_info->u1_base_mode_flag)
1361 {
1362 /* Decode the u1_mb_type */
1363 u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec);
1364 ps_cur_mb_info->u1_mb_type = u1_mb_type;
1365 if(u1_mb_type > (25 + u1_mb_threshold)) return ERROR_MB_TYPE;
1366 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
1367 }
1368 else
1369 {
1370 // default intialization for Base mode flag : reserved
1371 ps_dec->ps_part += MAX_NUM_MB_PART;
1372
1373 ps_svc_cur_mb_info->au1_motion_pred_flag[0] = 0;
1374 ps_svc_cur_mb_info->au1_motion_pred_flag[1] = 0;
1375 ps_cur_mb_info->u1_mb_type = MB_INFER;
1376 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1377 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1378 {
1379 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1380 }
1381
1382 /*SVC EXT needs to update incropwindow*/
1383 if(ps_svc_slice_params->u1_adaptive_residual_prediction_flag &&
1384 ps_svc_cur_mb_info->u1_crop_window_flag)
1385 {
1386 ps_svc_cur_mb_info->u1_residual_prediction_flag = ih264d_decode_bin(
1387 0, ps_svc_lyr_dec->ps_residual_prediction_flag, ps_bitstrm, ps_cab_env);
1388 COPYTHECONTEXT("SVC ext: u1_residual_prediction_flag",
1389 ps_svc_cur_mb_info->u1_residual_prediction_flag);
1390 }
1391 else
1392 {
1393 /*residual flag inference code */
1394 if(1 == ps_svc_cur_mb_info->u1_crop_window_flag)
1395 {
1396 ps_svc_cur_mb_info->u1_residual_prediction_flag =
1397 ps_svc_slice_params->u1_default_residual_prediction_flag;
1398 }
1399 else
1400 {
1401 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
1402 }
1403 }
1404 }
1405
1406 /* Parse Macroblock Data */
1407 u1_mb_type = ps_cur_mb_info->u1_mb_type;
1408 if(u1_mb_type < u1_mb_threshold)
1409 {
1410 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1411 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6;
1412
1413 ret = ps_svc_lyr_dec->pf_parse_inter_mb_svc_ext(
1414 ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info, u1_num_mbs, u1_num_mbsNby2);
1415 if(ret != OK) return ret;
1416 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1417 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1418 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1419 {
1420 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1421 }
1422 }
1423 else
1424 {
1425 /* Storing Intra partition info */
1426 ps_parse_mb_data->u1_num_part = 0;
1427 ps_parse_mb_data->u1_isI_mb = 1;
1428
1429 if((25 + u1_mb_threshold) == u1_mb_type)
1430 {
1431 /* I_PCM_MB */
1432 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
1433 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
1434 if(ret != OK) return ret;
1435 ps_cur_deblk_mb->u1_mb_qp = 0;
1436 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1437 }
1438 else
1439 {
1440 if(u1_mb_type == u1_mb_threshold)
1441 ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB;
1442 else
1443 ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB;
1444
1445 ret = isvcd_parse_imb_cabac(ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info,
1446 (UWORD8) (u1_mb_type - u1_mb_threshold));
1447 if(ret != OK) return ret;
1448 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1449 if(0 == ps_svc_cur_mb_info->u1_base_mode_flag)
1450 {
1451 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1452 }
1453 }
1454 ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
1455 }
1456 }
1457
1458 if(ps_dec->u1_enable_mb_info)
1459 {
1460 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
1461 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
1462 }
1463 if(u1_mbaff)
1464 {
1465 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1466 }
1467
1468 if(ps_cur_mb_info->u1_topmb && u1_mbaff)
1469 uc_more_data_flag = 1;
1470 else
1471 {
1472 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env, ps_bitstrm);
1473 uc_more_data_flag = !uc_more_data_flag;
1474 COPYTHECONTEXT("Decode Sliceterm", !uc_more_data_flag);
1475 }
1476
1477 if(u1_mbaff)
1478 {
1479 if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
1480 {
1481 return ERROR_EOB_FLUSHBITS_T;
1482 }
1483 }
1484 /* Next macroblock information */
1485 i2_cur_mb_addr++;
1486 u1_num_mbs++;
1487 u1_num_mbsNby2++;
1488 ps_parse_mb_data++;
1489
1490 /****************************************************************/
1491 /* Check for End Of Row and other flags that determine when to */
1492 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1493 /* N-Mb */
1494 /****************************************************************/
1495 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1496 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1497 u1_slice_end = !uc_more_data_flag;
1498 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
1499 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1500 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1501
1502 if(u1_decode_nmb)
1503 {
1504 ret = ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1505 u1_num_mbsNby2 = 0;
1506 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1507 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1508 if(ret != OK) return ret;
1509 }
1510
1511 if(u1_decode_nmb)
1512 {
1513 if(ps_dec->u1_separate_parse)
1514 {
1515 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, u1_tfr_n_mb,
1516 u1_end_of_row);
1517 ps_dec->ps_nmb_info += u1_num_mbs;
1518 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
1519 }
1520 else
1521 {
1522 ret = isvcd_decode_recon_tfr_nmb_non_base_lyr(ps_svc_lyr_dec, u1_mb_idx, u1_num_mbs,
1523 u1_num_mbs_next, u1_tfr_n_mb,
1524 u1_end_of_row);
1525 if(ret != OK) return ret;
1526 }
1527 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1528 if(u1_tfr_n_mb) u1_num_mbs = 0;
1529 u1_mb_idx = u1_num_mbs;
1530 ps_dec->u1_mb_idx = u1_num_mbs;
1531 }
1532 }
1533
1534 ps_dec->u4_num_mbs_cur_nmb = 0;
1535 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr - (u2_first_mb_in_slice << u1_mbaff);
1536
1537 return ret;
1538 }
1539
1540 /*****************************************************************************/
1541 /* */
1542 /* Function Name : isvcd_parse_inter_slice_data_cavlc_enh_lyr */
1543 /* */
1544 /* Description : This function parses cavlc syntax of a inter slice on */
1545 /* N MB basis. */
1546 /* */
1547 /* Inputs : ps_dec */
1548 /* sliceparams */
1549 /* firstMbInSlice */
1550 /* */
1551 /* Processing : 1. After parsing syntax for N MBs those N MBs are */
1552 /* decoded till the end of slice. */
1553 /* 2. MV prediction and DMA happens on a N/2 MB basis. */
1554 /* */
1555 /* Returns : 0 */
1556 /* */
1557 /* Issues : <List any issues or problems with this function> */
1558 /* */
1559 /* Revision History: */
1560 /* */
1561 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1562 /* 09 06 2021 Kishore Draft */
1563 /* */
1564 /*****************************************************************************/
1565
isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_slice_params_t * ps_slice,UWORD16 u2_first_mb_in_slice)1566 WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
1567 dec_slice_params_t *ps_slice,
1568 UWORD16 u2_first_mb_in_slice)
1569 {
1570 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1571 UWORD32 uc_more_data_flag;
1572 WORD32 i2_cur_mb_addr;
1573 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx;
1574 UWORD32 i2_mb_skip_run;
1575 UWORD32 u1_read_mb_type;
1576
1577 UWORD32 u1_mbaff;
1578 UWORD32 u1_num_mbs_next, u1_end_of_row;
1579 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
1580 UWORD32 u1_slice_end = 0;
1581 UWORD32 u1_tfr_n_mb = 0;
1582 UWORD32 u1_decode_nmb = 0;
1583
1584 dec_bit_stream_t *const ps_bitstrm = ps_dec->ps_bitstrm;
1585 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1586 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1587
1588 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1589
1590 deblk_mb_t *ps_cur_deblk_mb;
1591 dec_mb_info_t *ps_cur_mb_info;
1592 dec_svc_mb_info_t *ps_svc_cur_mb_info;
1593
1594 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1595 UWORD32 u1_inter_mb_type;
1596 UWORD32 u1_deblk_mb_type;
1597 UWORD32 u1_mb_threshold;
1598 WORD32 ret = OK;
1599
1600 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1601
1602 /******************************************************/
1603 /* Initialisations specific to EB or EP slice */
1604 /******************************************************/
1605
1606 if(ps_slice->u1_slice_type == P_SLICE)
1607 {
1608 u1_inter_mb_type = P_MB;
1609 u1_deblk_mb_type = D_INTER_MB;
1610 u1_mb_threshold = 5;
1611 }
1612 else
1613 {
1614 u1_inter_mb_type = B_MB;
1615 u1_deblk_mb_type = D_B_SLICE;
1616 u1_mb_threshold = 23;
1617 }
1618
1619 /******************************************************/
1620 /* Slice Level Initialisations */
1621 /******************************************************/
1622 ps_dec->u1_qp = ps_slice->u1_slice_qp;
1623 ih264d_update_qp(ps_dec, 0);
1624 u1_mb_idx = ps_dec->u1_mb_idx;
1625 u1_num_mbs = u1_mb_idx;
1626 u1_num_mbsNby2 = 0;
1627 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
1628 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
1629 i2_mb_skip_run = 0;
1630 uc_more_data_flag = 1;
1631 u1_read_mb_type = 0;
1632
1633 while(!u1_slice_end)
1634 {
1635 UWORD8 u1_mb_type;
1636
1637 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1638
1639 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
1640 {
1641 break;
1642 }
1643
1644 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
1645 ps_svc_cur_mb_info = ps_svc_lyr_dec->ps_svc_nmb_info + u1_num_mbs;
1646 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
1647
1648 ps_cur_mb_info->u1_Mux = 0;
1649 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
1650 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
1651
1652 ps_cur_mb_info->u1_end_of_slice = 0;
1653
1654 /* Storing Default partition info */
1655 ps_parse_mb_data->u1_num_part = 1;
1656 ps_parse_mb_data->u1_isI_mb = 0;
1657
1658 if((!i2_mb_skip_run) && (!u1_read_mb_type))
1659 {
1660 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1661 UWORD32 u4_word, u4_ldz;
1662
1663 /***************************************************************/
1664 /* Find leading zeros in next 32 bits */
1665 /***************************************************************/
1666 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1667
1668 u4_ldz = CLZ(u4_word);
1669
1670 /* Flush the ps_bitstrm */
1671 u4_bitstream_offset += (u4_ldz + 1);
1672 /* Read the suffix from the ps_bitstrm */
1673 u4_word = 0;
1674 if(u4_ldz)
1675 {
1676 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
1677 }
1678 *pu4_bitstrm_ofst = u4_bitstream_offset;
1679 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1);
1680
1681 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run);
1682 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1683 u1_read_mb_type = uc_more_data_flag;
1684 }
1685
1686 /***************************************************************/
1687 /* Get the required information for decoding of MB */
1688 /* mb_x, mb_y , neighbour availablity, */
1689 /***************************************************************/
1690 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
1691 ps_svc_cur_mb_info->u1_crop_window_flag =
1692 *(ps_svc_lyr_dec->pu1_crop_wnd_flag + ps_cur_mb_info->u2_mbx +
1693 (ps_cur_mb_info->u2_mby * ps_dec->u2_frm_wd_in_mbs));
1694 /***************************************************************/
1695 /* Set the deblocking parameters for this MB */
1696 /***************************************************************/
1697 if(ps_dec->u4_app_disable_deblk_frm == 0)
1698 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
1699 ps_dec->u1_mb_ngbr_availablity,
1700 ps_dec->u1_cur_mb_fld_dec_flag);
1701
1702 if(i2_mb_skip_run)
1703 {
1704 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
1705 ps_dec->i1_prev_mb_qp_delta = 0;
1706 ps_dec->u1_sub_mb_num = 0;
1707 ps_cur_mb_info->u1_mb_type = MB_SKIP;
1708 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
1709 ps_cur_mb_info->u1_cbp = 0;
1710 ps_svc_cur_mb_info->u1_base_mode_flag = 0;
1711 ps_svc_cur_mb_info->au1_motion_pred_flag[0] = 0;
1712 ps_svc_cur_mb_info->au1_motion_pred_flag[1] = 0;
1713 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
1714
1715 {
1716 /* Storing Skip partition info */
1717 parse_part_params_t *ps_part_info = ps_dec->ps_part;
1718 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
1719 ps_part_info->u1_sub_mb_num = 0;
1720 ps_dec->ps_part++;
1721 }
1722
1723 /* Update Nnzs */
1724 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
1725
1726 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1727 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1728
1729 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1730 {
1731 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1732 }
1733 i2_mb_skip_run--;
1734 }
1735 else
1736 {
1737 UWORD32 u4_word, u4_ldz, u4_temp;
1738
1739 ps_svc_cur_mb_info->u1_base_mode_flag = 0;
1740 if(ps_svc_cur_mb_info->u1_crop_window_flag &&
1741 ps_svc_slice_params->u1_adaptive_base_mode_flag)
1742 {
1743 ps_svc_cur_mb_info->u1_base_mode_flag = ih264d_get_bit_h264(ps_bitstrm);
1744 COPYTHECONTEXT("SVC :u1_base_mode_flag", ps_cur_mb_info->u1_base_mode_flag);
1745 }
1746 else if(ps_svc_cur_mb_info->u1_crop_window_flag)
1747 {
1748 ps_svc_cur_mb_info->u1_base_mode_flag =
1749 ps_svc_slice_params->u1_default_base_mode_flag;
1750 }
1751
1752 if(!ps_svc_cur_mb_info->u1_base_mode_flag)
1753 {
1754 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
1755
1756 u1_read_mb_type = 0;
1757 /**************************************************************/
1758 /* Macroblock Layer Begins, Decode the u1_mb_type */
1759 /**************************************************************/
1760 {
1761 /***************************************************************/
1762 /* Find leading zeros in next 32 bits */
1763 /***************************************************************/
1764 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
1765 u4_ldz = CLZ(u4_word);
1766 /* Flush the ps_bitstrm */
1767 u4_bitstream_offset += (u4_ldz + 1);
1768 /* Read the suffix from the ps_bitstrm */
1769 u4_word = 0;
1770 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
1771 *pu4_bitstrm_ofst = u4_bitstream_offset;
1772 u4_temp = ((1 << u4_ldz) + u4_word - 1);
1773
1774 if(u4_temp > (UWORD32) (25 + u1_mb_threshold)) return ERROR_MB_TYPE;
1775 u1_mb_type = u4_temp;
1776 COPYTHECONTEXT("u1_mb_type", u1_mb_type);
1777 }
1778 ps_cur_mb_info->u1_mb_type = u1_mb_type;
1779 }
1780 else
1781 {
1782 /* default intialization for Base mode flag : reserved */
1783 ps_dec->ps_part += MAX_NUM_MB_PART;
1784 u1_read_mb_type = 0;
1785 ps_svc_cur_mb_info->au1_motion_pred_flag[0] = 0;
1786 ps_svc_cur_mb_info->au1_motion_pred_flag[1] = 0;
1787 ps_cur_mb_info->u1_mb_type = MB_INFER;
1788 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1789 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1790 {
1791 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1792 }
1793
1794 /*SVC EXT needs to update incropwindow*/
1795 if(ps_svc_slice_params->u1_adaptive_residual_prediction_flag &&
1796 ps_svc_cur_mb_info->u1_crop_window_flag)
1797 {
1798 ps_svc_cur_mb_info->u1_residual_prediction_flag =
1799 ih264d_get_bit_h264(ps_bitstrm);
1800 COPYTHECONTEXT("SVC ext: u1_residual_prediction_flag",
1801 ps_cur_mb_info->u1_residual_prediction_flag);
1802 }
1803 else
1804 {
1805 /*residual flag inference code */
1806 if(1 == ps_svc_cur_mb_info->u1_crop_window_flag)
1807 {
1808 ps_svc_cur_mb_info->u1_residual_prediction_flag =
1809 ps_svc_slice_params->u1_default_residual_prediction_flag;
1810 }
1811 else
1812 {
1813 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
1814 }
1815 }
1816 }
1817
1818 /**************************************************************/
1819 /* Parse Macroblock data */
1820 /**************************************************************/
1821 u1_mb_type = ps_cur_mb_info->u1_mb_type;
1822 if(u1_mb_type < u1_mb_threshold)
1823 {
1824 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
1825
1826 ret = ps_svc_lyr_dec->pf_parse_inter_mb_svc_ext(
1827 ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info, u1_num_mbs, u1_num_mbsNby2);
1828 if(ret != OK) return ret;
1829 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
1830
1831 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
1832 {
1833 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
1834 }
1835 }
1836 else
1837 {
1838 /* Storing Intra partition info */
1839 ps_parse_mb_data->u1_num_part = 0;
1840
1841 if((25 + u1_mb_threshold) == u1_mb_type)
1842 {
1843 /* I_PCM_MB */
1844 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
1845 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
1846 if(ret != OK) return ret;
1847 ps_dec->u1_qp = 0;
1848 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1849 }
1850 else
1851 {
1852 ret =
1853 isvcd_parse_imb_cavlc(ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info,
1854 u1_num_mbs, (UWORD8) (u1_mb_type - u1_mb_threshold));
1855 if(ret != OK) return ret;
1856
1857 if(0 == ps_svc_cur_mb_info->u1_base_mode_flag)
1858 {
1859 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
1860 }
1861 }
1862 ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
1863 }
1864 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
1865 }
1866 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
1867
1868 if(ps_dec->u1_enable_mb_info)
1869 {
1870 ih264d_populate_mb_info_map(ps_dec, ps_cur_mb_info, ps_cur_mb_info->u2_mbx << 1,
1871 ps_cur_mb_info->u2_mby << 1, ps_cur_deblk_mb->u1_mb_qp);
1872 }
1873 if(u1_mbaff)
1874 {
1875 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
1876 if(!uc_more_data_flag && !i2_mb_skip_run && (0 == (i2_cur_mb_addr & 1)))
1877 {
1878 return ERROR_EOB_FLUSHBITS_T;
1879 }
1880 }
1881 /**************************************************************/
1882 /* Get next Macroblock address */
1883 /**************************************************************/
1884 i2_cur_mb_addr++;
1885 u1_num_mbs++;
1886 u1_num_mbsNby2++;
1887 ps_parse_mb_data++;
1888
1889 /****************************************************************/
1890 /* Check for End Of Row and other flags that determine when to */
1891 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
1892 /* N-Mb */
1893 /****************************************************************/
1894 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
1895 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
1896 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
1897 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
1898 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
1899 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
1900
1901 if(u1_decode_nmb)
1902 {
1903 ret = ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
1904 u1_num_mbsNby2 = 0;
1905 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
1906 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1907 if(ret != OK) return ret;
1908 }
1909
1910 if(u1_decode_nmb)
1911 {
1912 if(ps_dec->u1_separate_parse)
1913 {
1914 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, u1_tfr_n_mb,
1915 u1_end_of_row);
1916 ps_dec->ps_nmb_info += u1_num_mbs;
1917 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
1918 }
1919 else
1920 {
1921 ret = isvcd_decode_recon_tfr_nmb_non_base_lyr(ps_svc_lyr_dec, u1_mb_idx, u1_num_mbs,
1922 u1_num_mbs_next, u1_tfr_n_mb,
1923 u1_end_of_row);
1924 if(ret != OK) return ret;
1925 }
1926 ps_dec->u2_total_mbs_coded += u1_num_mbs;
1927 if(u1_tfr_n_mb) u1_num_mbs = 0;
1928 u1_mb_idx = u1_num_mbs;
1929 ps_dec->u1_mb_idx = u1_num_mbs;
1930 }
1931 }
1932
1933 ps_dec->u4_num_mbs_cur_nmb = 0;
1934 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr - (u2_first_mb_in_slice << u1_mbaff);
1935
1936 return ret;
1937 }
1938
1939 /*!
1940 **************************************************************************
1941 * \if Function name : ih264d_parse_pmb_cabac_svc \endif
1942 *
1943 * \brief
1944 * This function parses CABAC syntax of a P MB.
1945 *
1946 * \return
1947 * 0 on Success and Error code otherwise
1948 **************************************************************************
1949 */
isvcd_parse_pmb_cabac(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_mb_info_t * ps_cur_mb_info,dec_svc_mb_info_t * ps_svc_cur_mb_info,UWORD8 u1_mb_num,UWORD8 u1_num_mbsNby2)1950 WORD32 isvcd_parse_pmb_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_mb_info_t *ps_cur_mb_info,
1951 dec_svc_mb_info_t *ps_svc_cur_mb_info, UWORD8 u1_mb_num,
1952 UWORD8 u1_num_mbsNby2)
1953 {
1954 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1955 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1956
1957 UWORD32 u1_num_mb_part;
1958 UWORD32 uc_sub_mb;
1959 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data + u1_num_mbsNby2;
1960 WORD8 *pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
1961 const UWORD8 *pu1_num_mb_part = (const UWORD8 *) gau1_ih264d_num_mb_part;
1962 const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
1963 UWORD8 *pu1_col_info = ps_parse_mb_data->u1_col_info;
1964 UWORD32 u1_mb_mc_mode = u1_mb_type;
1965 ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
1966 decoding_envirnoment_t *ps_cab_env = &ps_dec->s_cab_dec_env;
1967 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1968 UWORD32 u4_sub_mb_pack = 0;
1969 WORD32 ret;
1970
1971 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
1972 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1973
1974 ps_cur_mb_info->u1_tran_form8x8 = 0;
1975 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
1976 ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
1977 p_curr_ctxt->u1_mb_type = CAB_P;
1978 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
1979 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
1980
1981 /* Reading the subMB type */
1982 if(uc_sub_mb)
1983 {
1984 UWORD8 u1_colz = (PRED_8x8 << 6);
1985 u1_mb_mc_mode = 0;
1986 {
1987 UWORD8 u1_sub_mb_mode;
1988 u1_sub_mb_mode =
1989 ih264d_parse_submb_type_cabac(0, ps_cab_env, ps_bitstrm, ps_dec->p_sub_mb_type_t);
1990 if(u1_sub_mb_mode > 3) return ERROR_SUB_MB_TYPE;
1991
1992 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
1993 /* Storing collocated information */
1994 *pu1_col_info++ = u1_colz | ((UWORD8) (u1_sub_mb_mode << 4));
1995 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
1996 /* check if Motion compensation is done below 8x8 */
1997 if(u1_sub_mb_mode != P_L0_8x8)
1998 {
1999 u1_no_submb_part_size_lt8x8_flag = 0;
2000 }
2001 }
2002 {
2003 UWORD8 u1_sub_mb_mode;
2004 u1_sub_mb_mode =
2005 ih264d_parse_submb_type_cabac(0, ps_cab_env, ps_bitstrm, ps_dec->p_sub_mb_type_t);
2006 if(u1_sub_mb_mode > 3) return ERROR_SUB_MB_TYPE;
2007
2008 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
2009 /* Storing collocated information */
2010 *pu1_col_info++ = u1_colz | ((UWORD8) (u1_sub_mb_mode << 4));
2011 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
2012 /* check if Motion compensation is done below 8x8 */
2013 if(u1_sub_mb_mode != P_L0_8x8)
2014 {
2015 u1_no_submb_part_size_lt8x8_flag = 0;
2016 }
2017 }
2018 {
2019 UWORD8 u1_sub_mb_mode;
2020 u1_sub_mb_mode =
2021 ih264d_parse_submb_type_cabac(0, ps_cab_env, ps_bitstrm, ps_dec->p_sub_mb_type_t);
2022 if(u1_sub_mb_mode > 3) return ERROR_SUB_MB_TYPE;
2023
2024 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
2025 /* Storing collocated information */
2026 *pu1_col_info++ = u1_colz | ((UWORD8) (u1_sub_mb_mode << 4));
2027 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
2028 /* check if Motion compensation is done below 8x8 */
2029 if(u1_sub_mb_mode != P_L0_8x8)
2030 {
2031 u1_no_submb_part_size_lt8x8_flag = 0;
2032 }
2033 }
2034 {
2035 UWORD8 u1_sub_mb_mode;
2036 u1_sub_mb_mode =
2037 ih264d_parse_submb_type_cabac(0, ps_cab_env, ps_bitstrm, ps_dec->p_sub_mb_type_t);
2038 if(u1_sub_mb_mode > 3) return ERROR_SUB_MB_TYPE;
2039
2040 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode;
2041 /* Storing collocated information */
2042 *pu1_col_info++ = u1_colz | ((UWORD8) (u1_sub_mb_mode << 4));
2043 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode);
2044 /* check if Motion compensation is done below 8x8 */
2045 if(u1_sub_mb_mode != P_L0_8x8)
2046 {
2047 u1_no_submb_part_size_lt8x8_flag = 0;
2048 }
2049 }
2050 u1_num_mb_part = 4;
2051 }
2052 else
2053 {
2054 u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
2055 /* Storing collocated Mb and SubMb mode information */
2056 *pu1_col_info++ = (u1_mb_type << 6);
2057 if(u1_mb_type) *pu1_col_info++ = (u1_mb_type << 6);
2058 }
2059
2060 /*Adding code to get Motion Prediction Flags*/
2061 {
2062 UWORD8 uc_i;
2063 UWORD8 *pu1_motion_pred_flag_l0;
2064 UWORD8 u1_mvp_flag;
2065 WORD8 *pi1_top_ref_idx_ctx_inc_arr = p_curr_ctxt->i1_ref_idx;
2066 WORD8 *pi1_left_ref_idx_ctxt_inc = ps_dec->pi1_left_ref_idx_ctxt_inc;
2067 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
2068 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
2069 UWORD8 uc_num_ref_idx_l0_active_minus1 =
2070 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] << (u1_mbaff & uc_field)) - 1;
2071 pu1_motion_pred_flag_l0 = &ps_svc_cur_mb_info->au1_motion_pred_flag[0];
2072 *pu1_motion_pred_flag_l0 = 0;
2073
2074 if(ps_svc_cur_mb_info->u1_crop_window_flag &&
2075 ps_svc_slice_params->u1_adaptive_motion_prediction_flag)
2076 {
2077 for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
2078 {
2079 /*usage of bins and ctxt check*/
2080 u1_mvp_flag = ih264d_decode_bin(0, ps_svc_lyr_dec->ps_motion_prediction_flag_l0,
2081 ps_bitstrm, ps_cab_env);
2082 COPYTHECONTEXT("SVC ext: ps_motion_prediction_flag_l0", u1_mvp_flag);
2083
2084 *pu1_motion_pred_flag_l0 |= (u1_mvp_flag << uc_i);
2085 if(u1_mvp_flag)
2086 {
2087 pi1_ref_idx[uc_i] = -1;
2088 }
2089 }
2090 }
2091 else if(ps_svc_cur_mb_info->u1_crop_window_flag)
2092 {
2093 *pu1_motion_pred_flag_l0 = ps_svc_slice_params->u1_default_motion_prediction_flag
2094 ? ((1 << u1_num_mb_part) - 1)
2095 : 0;
2096 if(ps_svc_slice_params->u1_default_motion_prediction_flag)
2097 {
2098 pi1_ref_idx[0] = -1;
2099 pi1_ref_idx[1] = -1;
2100 pi1_ref_idx[2] = -1;
2101 pi1_ref_idx[3] = -1;
2102 }
2103 }
2104
2105 /* Decoding reference index 0: For simple profile the following */
2106 /* conditions are always true (mb_field_decoding_flag == 0); */
2107 /* (MbPartPredMode != PredL1) */
2108 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
2109 {
2110 /* force the routine to decode ref idx for each partition */
2111 /*SVC added motion_prediction_flag to force it to take it only for
2112 * !motion_pred_flag_l0*/
2113
2114 ret = ih264d_parse_ref_idx_cabac(u1_num_mb_part, 0, uc_num_ref_idx_l0_active_minus1,
2115 u1_mb_mc_mode, pi1_ref_idx, pi1_left_ref_idx_ctxt_inc,
2116 pi1_top_ref_idx_ctx_inc_arr, ps_cab_env, ps_bitstrm,
2117 ps_dec->p_ref_idx_t);
2118 if(ret != OK)
2119 {
2120 return ret;
2121 }
2122 }
2123 else
2124 {
2125 /* When there exists only a single frame to predict from */
2126 pi1_left_ref_idx_ctxt_inc[0] = 0;
2127 pi1_left_ref_idx_ctxt_inc[1] = 0;
2128 pi1_top_ref_idx_ctx_inc_arr[0] = 0;
2129 pi1_top_ref_idx_ctx_inc_arr[1] = 0;
2130 *((UWORD32 *) pi1_ref_idx) = 0;
2131 }
2132 }
2133
2134 {
2135 UWORD8 u1_p_idx, uc_i;
2136 parse_part_params_t *ps_part = ps_dec->ps_part;
2137 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
2138 UWORD8 u1_sub_mb_num;
2139 const UWORD8 *pu1_top_left_sub_mb_indx;
2140 mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
2141 UWORD16 u2_sub_mb_num_pack = 0x028A;
2142
2143 /* Loading the table pointers */
2144 const UWORD8 *pu1_mb_partw = (const UWORD8 *) gau1_ih264d_mb_partw;
2145 const UWORD8 *pu1_mb_parth = (const UWORD8 *) gau1_ih264d_mb_parth;
2146 const UWORD8 *pu1_sub_mb_indx_mod =
2147 (const UWORD8 *) (gau1_ih264d_submb_indx_mod) + (uc_sub_mb * 6);
2148 const UWORD8 *pu1_sub_mb_partw = (const UWORD8 *) gau1_ih264d_submb_partw;
2149 const UWORD8 *pu1_sub_mb_parth = (const UWORD8 *) gau1_ih264d_submb_parth;
2150 const UWORD8 *pu1_num_sub_mb_part = (const UWORD8 *) gau1_ih264d_num_submb_part;
2151
2152 /*********************************************************/
2153 /* default initialisations for condition (uc_sub_mb == 0) */
2154 /* i.e. all are subpartitions of 8x8 */
2155 /*********************************************************/
2156 u1_sub_mb_mode = 0;
2157 u1_num_subpart = 1;
2158 u1_mb_part_width = pu1_mb_partw[u1_mb_type];
2159 u1_mb_part_height = pu1_mb_parth[u1_mb_type];
2160 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
2161 u1_sub_mb_num = 0;
2162
2163 /* Loop on number of partitions */
2164 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
2165 {
2166 UWORD8 uc_j;
2167 if(uc_sub_mb)
2168 {
2169 u1_sub_mb_mode = u4_sub_mb_pack >> 24;
2170 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
2171 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
2172 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
2173 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
2174 u1_sub_mb_num = u2_sub_mb_num_pack >> 12;
2175 u4_sub_mb_pack <<= 8;
2176 u2_sub_mb_num_pack <<= 4;
2177 }
2178 /* Loop on Number of sub-partitions */
2179 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
2180 {
2181 mv_pred_t *ps_mv;
2182 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
2183 ps_mv = ps_mv_start + u1_sub_mb_num;
2184
2185 /* Storing Info for partitions */
2186 ps_part->u1_is_direct = PART_NOT_DIRECT;
2187 ps_part->u1_sub_mb_num = u1_sub_mb_num;
2188 ps_part->u1_partheight = u1_mb_part_height;
2189 ps_part->u1_partwidth = u1_mb_part_width;
2190
2191 /* Increment partition Index */
2192 u1_p_idx++;
2193 ps_part++;
2194
2195 ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width, u1_mb_part_height, 1,
2196 ps_dec, ps_mv);
2197 }
2198 }
2199 ps_parse_mb_data->u1_num_part = u1_p_idx;
2200 ps_dec->ps_part = ps_part;
2201 }
2202
2203 /* update incropwindow*/
2204 if(ps_svc_slice_params->u1_adaptive_residual_prediction_flag &&
2205 ps_svc_cur_mb_info->u1_crop_window_flag)
2206 {
2207 ps_svc_cur_mb_info->u1_residual_prediction_flag = ih264d_decode_bin(
2208 1, ps_svc_lyr_dec->ps_residual_prediction_flag, ps_bitstrm, ps_cab_env);
2209 COPYTHECONTEXT("SVC ext: u1_residual_prediction_flag",
2210 ps_cur_mb_info->u1_residual_prediction_flag);
2211 }
2212 else
2213 {
2214 /*residual flag inference code */
2215 if(1 == ps_svc_cur_mb_info->u1_crop_window_flag)
2216 {
2217 ps_svc_cur_mb_info->u1_residual_prediction_flag =
2218 ps_svc_slice_params->u1_default_residual_prediction_flag;
2219 }
2220 else
2221 {
2222 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
2223 }
2224 }
2225
2226 if(ps_svc_slice_params->u1_scan_idx_end >= ps_svc_slice_params->u1_scan_idx_start)
2227 {
2228 UWORD8 u1_cbp;
2229 /* Read the Coded block pattern */
2230 u1_cbp = (WORD8) ih264d_parse_ctx_cbp_cabac(ps_dec);
2231 COPYTHECONTEXT("coded_block_pattern", u1_cbp);
2232 ps_cur_mb_info->u1_cbp = u1_cbp;
2233 p_curr_ctxt->u1_cbp = u1_cbp;
2234 p_curr_ctxt->u1_intra_chroma_pred_mode = 0;
2235 p_curr_ctxt->u1_yuv_dc_csbp &= 0xFE;
2236 ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x6;
2237
2238 if(u1_cbp > 47) return ERROR_CBP;
2239
2240 ps_cur_mb_info->u1_tran_form8x8 = 0;
2241 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
2242
2243 /* Read the transform8x8 u4_flag if present */
2244 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u1_cbp & 0xf) &&
2245 u1_no_submb_part_size_lt8x8_flag)
2246 {
2247 ps_cur_mb_info->u1_tran_form8x8 =
2248 ih264d_parse_transform8x8flag_cabac(ps_dec, ps_cur_mb_info);
2249 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
2250 p_curr_ctxt->u1_transform8x8_ctxt = ps_cur_mb_info->u1_tran_form8x8;
2251 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
2252 }
2253 else
2254 {
2255 p_curr_ctxt->u1_transform8x8_ctxt = 0;
2256 }
2257
2258 /* Read mb_qp_delta */
2259 if(u1_cbp)
2260 {
2261 WORD8 c_temp;
2262 ret = ih264d_parse_mb_qp_delta_cabac(ps_dec, &c_temp);
2263 if(ret != OK) return ret;
2264 COPYTHECONTEXT("mb_qp_delta", c_temp);
2265 if(c_temp != 0)
2266 {
2267 ret = ih264d_update_qp(ps_dec, c_temp);
2268 if(ret != OK) return ret;
2269 }
2270 }
2271 else
2272 ps_dec->i1_prev_mb_qp_delta = 0;
2273
2274 /*residual from start to end idx */
2275 ih264d_parse_residual4x4_cabac(ps_dec, ps_cur_mb_info, 0);
2276 if(EXCEED_OFFSET(ps_dec->ps_bitstrm)) return ERROR_EOB_TERMINATE_T;
2277 }
2278 return OK;
2279 }
2280
2281 /*!
2282 **************************************************************************
2283 * \if Function name : isvcd_parse_pmb_cavlc \endif
2284 *
2285 * \brief
2286 * This function parses CAVLC syntax of a P MB.
2287 *
2288 * \return
2289 * 0 on Success and Error code otherwise
2290 **************************************************************************
2291 */
isvcd_parse_pmb_cavlc(svc_dec_lyr_struct_t * ps_svc_lyr_dec,dec_mb_info_t * ps_cur_mb_info,dec_svc_mb_info_t * ps_svc_cur_mb_info,UWORD8 u1_mb_num,UWORD8 u1_num_mbsNby2)2292 WORD32 isvcd_parse_pmb_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_mb_info_t *ps_cur_mb_info,
2293 dec_svc_mb_info_t *ps_svc_cur_mb_info, UWORD8 u1_mb_num,
2294 UWORD8 u1_num_mbsNby2)
2295 {
2296 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
2297 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
2298 UWORD32 u1_num_mb_part;
2299 UWORD32 uc_sub_mb;
2300 dec_bit_stream_t *const ps_bitstrm = ps_dec->ps_bitstrm;
2301 UWORD32 *const pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
2302 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
2303 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data + u1_num_mbsNby2;
2304 WORD8 *pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
2305 const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
2306 const UWORD8 *pu1_num_mb_part = (const UWORD8 *) gau1_ih264d_num_mb_part;
2307 UWORD8 *pu1_col_info = ps_parse_mb_data->u1_col_info;
2308 UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
2309 UWORD32 u4_sum_mb_mode_pack = 0;
2310 WORD32 ret;
2311 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1;
2312
2313 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
2314 ps_cur_mb_info->u1_tran_form8x8 = 0;
2315 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
2316 ps_cur_mb_info->u1_yuv_dc_block_flag = 0;
2317 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type;
2318 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0));
2319
2320 /* Reading the subMB type */
2321 if(uc_sub_mb)
2322 {
2323 WORD32 i;
2324 UWORD8 u1_colz = (PRED_8x8 << 6);
2325
2326 for(i = 0; i < 4; i++)
2327 {
2328 UWORD32 ui_sub_mb_mode;
2329
2330 // Inlined ih264d_uev
2331 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
2332 UWORD32 u4_word, u4_ldz;
2333
2334 /***************************************************************/
2335 /* Find leading zeros in next 32 bits */
2336 /***************************************************************/
2337 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
2338 u4_ldz = CLZ(u4_word);
2339 /* Flush the ps_bitstrm */
2340 u4_bitstream_offset += (u4_ldz + 1);
2341 /* Read the suffix from the ps_bitstrm */
2342 u4_word = 0;
2343 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
2344 *pu4_bitstrm_ofst = u4_bitstream_offset;
2345 ui_sub_mb_mode = ((1 << u4_ldz) + u4_word - 1);
2346 // Inlined ih264d_uev
2347
2348 if(ui_sub_mb_mode > 3)
2349 {
2350 return ERROR_SUB_MB_TYPE;
2351 }
2352 else
2353 {
2354 u4_sum_mb_mode_pack = (u4_sum_mb_mode_pack << 8) | ui_sub_mb_mode;
2355 /* Storing collocated information */
2356 *pu1_col_info++ = u1_colz | (UWORD8) (ui_sub_mb_mode << 4);
2357
2358 COPYTHECONTEXT("sub_mb_type", ui_sub_mb_mode);
2359 }
2360
2361 /* check if Motion compensation is done below 8x8 */
2362 if(ui_sub_mb_mode != P_L0_8x8)
2363 {
2364 u1_no_submb_part_size_lt8x8_flag = 0;
2365 }
2366 }
2367 u1_num_mb_part = 4;
2368 }
2369 else
2370 {
2371 *pu1_col_info++ = (u1_mb_type << 6);
2372 if(u1_mb_type) *pu1_col_info++ = (u1_mb_type << 6);
2373 u1_num_mb_part = pu1_num_mb_part[u1_mb_type];
2374 }
2375
2376 /*Adding code to get Motion Prediction Flags*/
2377 {
2378 /*free the scratch buffer once used*/
2379 UWORD8 uc_i;
2380 UWORD8 *pu1_motion_pred_flag_l0;
2381 UWORD8 u1_mvp_flag;
2382 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag;
2383 UWORD8 uc_num_ref_idx_l0_active_minus1 =
2384 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] << (u1_mbaff & uc_field)) - 1;
2385
2386 pu1_motion_pred_flag_l0 = &ps_svc_cur_mb_info->au1_motion_pred_flag[0];
2387 *pu1_motion_pred_flag_l0 = 0;
2388 if(ps_svc_cur_mb_info->u1_crop_window_flag &&
2389 ps_svc_slice_params->u1_adaptive_motion_prediction_flag)
2390 {
2391 for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
2392 {
2393 /*usage of bins and ctxt check*/
2394 u1_mvp_flag = ih264d_get_bit_h264(ps_bitstrm);
2395 COPYTHECONTEXT("SVC ext: ps_motion_prediction_flag_l0", u1_mvp_flag);
2396
2397 *pu1_motion_pred_flag_l0 |= (u1_mvp_flag << uc_i);
2398 }
2399 }
2400 else if(ps_svc_cur_mb_info->u1_crop_window_flag)
2401 {
2402 *pu1_motion_pred_flag_l0 = ps_svc_slice_params->u1_default_motion_prediction_flag
2403 ? ((1 << u1_num_mb_part) - 1)
2404 : 0;
2405 }
2406
2407 /* Decoding reference index 0: For simple profile the following */
2408 /* conditions are always true (mb_field_decoding_flag == 0); */
2409 /* (MbPartPredMode != PredL1) */
2410 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0))
2411 {
2412 if(1 == uc_num_ref_idx_l0_active_minus1)
2413 isvcd_parse_pmb_ref_index_cavlc_range1(u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
2414 uc_num_ref_idx_l0_active_minus1,
2415 pu1_motion_pred_flag_l0);
2416 else
2417 {
2418 ret = isvcd_parse_pmb_ref_index_cavlc(u1_num_mb_part, ps_bitstrm, pi1_ref_idx,
2419 uc_num_ref_idx_l0_active_minus1,
2420 pu1_motion_pred_flag_l0);
2421 if(ret != OK) return ret;
2422 }
2423 }
2424 else
2425 {
2426 /* When there exists only a single frame to predict from */
2427 UWORD8 uc_i;
2428 for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++) /* Storing Reference Idx Information */
2429 pi1_ref_idx[uc_i] = 0;
2430 }
2431 }
2432
2433 {
2434 UWORD8 u1_p_idx, uc_i;
2435 parse_part_params_t *ps_part = ps_dec->ps_part;
2436 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
2437 UWORD8 u1_sub_mb_num;
2438 const UWORD8 *pu1_top_left_sub_mb_indx;
2439 mv_pred_t *ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
2440 /* Loading the table pointers */
2441 const UWORD8 *pu1_mb_partw = (const UWORD8 *) gau1_ih264d_mb_partw;
2442 const UWORD8 *pu1_mb_parth = (const UWORD8 *) gau1_ih264d_mb_parth;
2443 const UWORD8 *pu1_sub_mb_indx_mod =
2444 (const UWORD8 *) (gau1_ih264d_submb_indx_mod) + (uc_sub_mb * 6);
2445 const UWORD8 *pu1_sub_mb_partw = (const UWORD8 *) gau1_ih264d_submb_partw;
2446 const UWORD8 *pu1_sub_mb_parth = (const UWORD8 *) gau1_ih264d_submb_parth;
2447 const UWORD8 *pu1_num_sub_mb_part = (const UWORD8 *) gau1_ih264d_num_submb_part;
2448 UWORD16 u2_sub_mb_num = 0x028A;
2449
2450 /*********************************************************/
2451 /* default initialisations for condition (uc_sub_mb == 0) */
2452 /* i.e. all are subpartitions of 8x8 */
2453 /*********************************************************/
2454 u1_sub_mb_mode = 0;
2455 u1_num_subpart = 1;
2456 u1_mb_part_width = pu1_mb_partw[u1_mb_type];
2457 u1_mb_part_height = pu1_mb_parth[u1_mb_type];
2458 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
2459 u1_sub_mb_num = 0;
2460
2461 /* Loop on number of partitions */
2462 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
2463 {
2464 UWORD8 uc_j;
2465 if(uc_sub_mb)
2466 {
2467 u1_sub_mb_mode = u4_sum_mb_mode_pack >> 24;
2468 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode];
2469 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
2470 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
2471 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
2472 u1_sub_mb_num = u2_sub_mb_num >> 12;
2473 u4_sum_mb_mode_pack <<= 8;
2474 u2_sub_mb_num <<= 4;
2475 }
2476 /* Loop on Number of sub-partitions */
2477 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
2478 {
2479 WORD16 i2_mvx, i2_mvy;
2480 u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
2481 ps_mv = ps_mv_start + u1_sub_mb_num;
2482
2483 /* Reading the differential Mv from the bitstream */
2484 // inlining ih264d_sev
2485 {
2486 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
2487 UWORD32 u4_word, u4_ldz, u4_abs_val;
2488
2489 /***************************************************************/
2490 /* Find leading zeros in next 32 bits */
2491 /***************************************************************/
2492 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
2493 u4_ldz = CLZ(u4_word);
2494
2495 /* Flush the ps_bitstrm */
2496 u4_bitstream_offset += (u4_ldz + 1);
2497
2498 /* Read the suffix from the ps_bitstrm */
2499 u4_word = 0;
2500 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
2501
2502 *pu4_bitstrm_ofst = u4_bitstream_offset;
2503 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
2504
2505 if(u4_word & 0x1)
2506 i2_mvx = (-(WORD32) u4_abs_val);
2507 else
2508 i2_mvx = (u4_abs_val);
2509 }
2510 // inlinined ih264d_sev
2511 COPYTHECONTEXT("MVD", i2_mvx);
2512 i2_mvy = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2513 COPYTHECONTEXT("MVD", i2_mvy);
2514
2515 /* Storing Info for partitions */
2516 ps_part->u1_is_direct = PART_NOT_DIRECT;
2517 ps_part->u1_sub_mb_num = u1_sub_mb_num;
2518 ps_part->u1_partheight = u1_mb_part_height;
2519 ps_part->u1_partwidth = u1_mb_part_width;
2520
2521 /* Storing Mv residuals */
2522 ps_mv->i2_mv[0] = i2_mvx;
2523 ps_mv->i2_mv[1] = i2_mvy;
2524
2525 /* Increment partition Index */
2526 u1_p_idx++;
2527 ps_part++;
2528 }
2529 }
2530 ps_parse_mb_data->u1_num_part = u1_p_idx;
2531 ps_dec->ps_part = ps_part;
2532 }
2533
2534 if(ps_svc_slice_params->u1_adaptive_residual_prediction_flag &&
2535 ps_svc_cur_mb_info->u1_crop_window_flag)
2536 {
2537 ps_svc_cur_mb_info->u1_residual_prediction_flag = ih264d_get_bit_h264(ps_bitstrm);
2538 COPYTHECONTEXT("SVC ext: u1_residual_prediction_flag",
2539 ps_svc_cur_mb_info->u1_residual_prediction_flag);
2540 }
2541 else
2542 {
2543 /*residual flag inference code */
2544 if(1 == ps_svc_cur_mb_info->u1_crop_window_flag)
2545 {
2546 ps_svc_cur_mb_info->u1_residual_prediction_flag =
2547 ps_svc_slice_params->u1_default_residual_prediction_flag;
2548 }
2549 else
2550 {
2551 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
2552 }
2553 }
2554
2555 if(ps_svc_slice_params->u1_scan_idx_end >= ps_svc_slice_params->u1_scan_idx_start)
2556 {
2557 UWORD32 u4_cbp;
2558 /* Read the Coded block pattern */
2559 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
2560 UWORD32 u4_word, u4_ldz;
2561
2562 /***************************************************************/
2563 /* Find leading zeros in next 32 bits */
2564 /***************************************************************/
2565 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
2566 u4_ldz = CLZ(u4_word);
2567 /* Flush the ps_bitstrm */
2568 u4_bitstream_offset += (u4_ldz + 1);
2569 /* Read the suffix from the ps_bitstrm */
2570 u4_word = 0;
2571 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
2572 *pu4_bitstrm_ofst = u4_bitstream_offset;
2573 u4_cbp = ((1 << u4_ldz) + u4_word - 1);
2574
2575 if(u4_cbp > 47) return ERROR_CBP;
2576
2577 u4_cbp = *((UWORD8 *) gau1_ih264d_cbp_inter + u4_cbp);
2578 COPYTHECONTEXT("coded_block_pattern", u4_cbp);
2579 ps_cur_mb_info->u1_cbp = u4_cbp;
2580
2581 /* Read the transform8x8 u4_flag if present */
2582 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u4_cbp & 0xf) &&
2583 u1_no_submb_part_size_lt8x8_flag)
2584 {
2585 ps_cur_mb_info->u1_tran_form8x8 = ih264d_get_bit_h264(ps_bitstrm);
2586 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8);
2587 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8;
2588 }
2589
2590 /* Read mb_qp_delta */
2591 if(u4_cbp)
2592 {
2593 WORD32 i_temp;
2594 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
2595 UWORD32 u4_word, u4_ldz, u4_abs_val;
2596
2597 /***************************************************************/
2598 /* Find leading zeros in next 32 bits */
2599 /***************************************************************/
2600 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
2601 u4_ldz = CLZ(u4_word);
2602
2603 /* Flush the ps_bitstrm */
2604 u4_bitstream_offset += (u4_ldz + 1);
2605
2606 /* Read the suffix from the ps_bitstrm */
2607 u4_word = 0;
2608 if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
2609
2610 *pu4_bitstrm_ofst = u4_bitstream_offset;
2611 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;
2612
2613 if(u4_word & 0x1)
2614 i_temp = (-(WORD32) u4_abs_val);
2615 else
2616 i_temp = (u4_abs_val);
2617
2618 if((i_temp < -26) || (i_temp > 25)) return ERROR_INV_RANGE_QP_T;
2619 // inlinined ih264d_sev
2620
2621 COPYTHECONTEXT("mb_qp_delta", i_temp);
2622 if(i_temp)
2623 {
2624 ret = ih264d_update_qp(ps_dec, (WORD8) i_temp);
2625 if(ret != OK) return ret;
2626 }
2627
2628 /*change to support start to end idx*/
2629 ret = ih264d_parse_residual4x4_cavlc(ps_dec, ps_cur_mb_info, 0);
2630 if(ret != OK) return ret;
2631 if(EXCEED_OFFSET(ps_bitstrm)) return ERROR_EOB_TERMINATE_T;
2632 }
2633 else
2634 {
2635 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
2636 }
2637 }
2638
2639 return OK;
2640 }
2641 /*!
2642 **************************************************************************
2643 * \if Function name : isvcd_mark_err_slice_skip \endif
2644 *
2645 * \brief
2646 *
2647 *
2648 * \return
2649 * 0 on Success and Error code otherwise
2650 **************************************************************************
2651 */
isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t * ps_svc_lyr_dec,WORD32 num_mb_skip,UWORD8 u1_is_idr_slice,UWORD16 u2_frame_num,pocstruct_t * ps_cur_poc,WORD32 prev_slice_err)2652 WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 num_mb_skip,
2653 UWORD8 u1_is_idr_slice, UWORD16 u2_frame_num,
2654 pocstruct_t *ps_cur_poc, WORD32 prev_slice_err)
2655 {
2656 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
2657 WORD32 i2_cur_mb_addr;
2658 UWORD32 u1_num_mbs;
2659 UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
2660 UWORD32 i2_mb_skip_run;
2661 UWORD32 u1_num_mbs_next, u1_end_of_row;
2662 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
2663 UWORD32 u1_slice_end;
2664 UWORD32 u1_tfr_n_mb;
2665 UWORD32 u1_decode_nmb;
2666 dec_slice_params_t *ps_slice = ps_dec->ps_cur_slice;
2667 deblk_mb_t *ps_cur_deblk_mb;
2668 dec_mb_info_t *ps_cur_mb_info;
2669 dec_svc_mb_info_t *ps_svc_cur_mb_info;
2670 parse_pmbarams_t *ps_parse_mb_data;
2671 UWORD32 u1_inter_mb_type;
2672 UWORD32 u1_deblk_mb_type;
2673 UWORD32 u1_mbaff;
2674 parse_part_params_t *ps_part_info;
2675 WORD32 ret;
2676 UNUSED(u1_is_idr_slice);
2677
2678 ps_svc_lyr_dec->u1_error_in_cur_frame = 1;
2679 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
2680 {
2681 ih264d_err_pic_dispbuf_mgr(ps_dec);
2682 return 0;
2683 }
2684
2685 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (num_mb_skip & 1))
2686 {
2687 num_mb_skip++;
2688 }
2689 ps_dec->ps_dpb_cmds->u1_long_term_reference_flag = 0;
2690 if(prev_slice_err == 1)
2691 {
2692 /* first slice - missing/header corruption */
2693 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num;
2694 {
2695 WORD32 i, j, poc = 0;
2696 ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0;
2697 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
2698 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
2699 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
2700
2701 if(ps_dec->ps_cur_pic != NULL)
2702 {
2703 poc = ps_dec->ps_cur_pic->i4_poc;
2704 if(poc <= INT32_MAX - 2) poc += 2;
2705 }
2706
2707 j = -1;
2708 for(i = 0; i < MAX_NUM_PIC_PARAMS; i++)
2709 {
2710 if(ps_dec->ps_pps[i].u1_is_valid == TRUE)
2711 {
2712 if(ps_dec->ps_pps[i].ps_sps->u1_is_valid == TRUE)
2713 {
2714 j = i;
2715 break;
2716 }
2717 }
2718 }
2719
2720 // if valid SPS PPS is not found return error
2721 if(j == -1)
2722 {
2723 return ERROR_INV_SLICE_HDR_T;
2724 }
2725
2726 /* call ih264d_start_of_pic only if it was not called earlier*/
2727 if(ps_dec->u4_pic_buf_got == 0)
2728 {
2729 // initialize slice params required by isvcd_start_of_pic to valid values
2730 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
2731 ps_dec->ps_cur_slice->u1_nal_ref_idc = 1;
2732 ps_dec->ps_cur_slice->u1_nal_unit_type = 1;
2733 ret = isvcd_start_of_pic(ps_svc_lyr_dec, poc, ps_cur_poc,
2734 ps_dec->ps_cur_slice->u2_frame_num, &ps_dec->ps_pps[j]);
2735
2736 if(ret != OK)
2737 {
2738 return ret;
2739 }
2740 /*inter layer buffer intialization */
2741 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
2742 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start;
2743 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_cur_mb =
2744 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base;
2745 }
2746
2747 ps_dec->ps_ref_pic_buf_lx[0][0]->u1_pic_buf_id = 0;
2748 ps_dec->u4_output_present = 0;
2749
2750 {
2751 ih264d_get_next_display_field(ps_dec, ps_dec->ps_out_buffer, &(ps_dec->s_disp_op));
2752 /* If error code is non-zero then there is no buffer available for
2753 display, hence avoid format conversion */
2754
2755 if(0 != ps_dec->s_disp_op.u4_error_code)
2756 {
2757 ps_dec->u4_output_present = 0;
2758 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
2759 }
2760 else
2761 ps_dec->u4_output_present = 1;
2762 }
2763
2764 if(ps_dec->u1_separate_parse == 1)
2765 {
2766 #ifdef KEEP_THREADS_ACTIVE
2767 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
2768 RETURN_IF((ret != IV_SUCCESS), ret);
2769
2770 ps_dec->ai4_process_start[0] = PROC_START;
2771 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
2772 RETURN_IF((ret != IV_SUCCESS), ret);
2773
2774 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
2775 RETURN_IF((ret != IV_SUCCESS), ret);
2776 #endif
2777 #ifdef KEEP_THREADS_ACTIVE
2778 if(ps_dec->u4_bs_deblk_thread_created)
2779 {
2780 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
2781 RETURN_IF((ret != IV_SUCCESS), ret);
2782
2783 ps_dec->ai4_process_start[1] = PROC_START;
2784 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
2785 RETURN_IF((ret != IV_SUCCESS), ret);
2786
2787 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
2788 RETURN_IF((ret != IV_SUCCESS), ret);
2789 }
2790 #endif
2791 }
2792 }
2793 }
2794 else
2795 {
2796 // Middle / last slice
2797 dec_slice_struct_t *ps_parse_cur_slice;
2798 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
2799
2800 if(ps_dec->u1_slice_header_done && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice)
2801 {
2802 // Slice data corrupted
2803 // in the case of mbaff, conceal from the even mb.
2804 if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
2805 {
2806 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
2807 ps_dec->u2_cur_mb_addr--;
2808 }
2809
2810 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
2811 if(u1_num_mbs)
2812 {
2813 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1;
2814 }
2815 else
2816 {
2817 if(ps_dec->u1_separate_parse)
2818 {
2819 ps_cur_mb_info = ps_dec->ps_nmb_info;
2820 }
2821 else
2822 {
2823 ps_cur_mb_info = ps_dec->ps_nmb_info + ps_dec->u4_num_mbs_prev_nmb - 1;
2824 }
2825 }
2826
2827 ps_dec->u2_mby = ps_cur_mb_info->u2_mby;
2828 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx;
2829 ps_dec->u1_mb_ngbr_availablity = ps_cur_mb_info->u1_mb_ngbr_availablity;
2830
2831 if(u1_num_mbs)
2832 {
2833 // Going back 1 mb
2834 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
2835 ps_dec->u2_cur_mb_addr--;
2836 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
2837
2838 // Parse/decode N-MB left unparsed
2839 if(ps_dec->u1_pr_sl_type == P_SLICE || ps_dec->u1_pr_sl_type == B_SLICE)
2840 {
2841 if((ps_dec->i4_submb_ofst - ((WORD32) ((u1_num_mbs - u1_mb_idx) << 4))) < 0)
2842 {
2843 ps_dec->i4_submb_ofst = ((u1_num_mbs - u1_mb_idx) << 4);
2844 }
2845
2846 ret = ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
2847 ps_dec->ps_part = ps_dec->ps_parse_part_params;
2848 if(ret != OK) return ret;
2849 }
2850
2851 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
2852 u1_end_of_row =
2853 (!u1_num_mbs_next) &&
2854 (!(ps_dec->ps_cur_slice->u1_mbaff_frame_flag && (u1_num_mbs & 0x01)));
2855 u1_slice_end = 1;
2856 u1_tfr_n_mb = 1;
2857 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
2858
2859 if(ps_dec->u1_separate_parse)
2860 {
2861 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
2862 u1_tfr_n_mb, u1_end_of_row);
2863 ps_dec->ps_nmb_info += u1_num_mbs;
2864 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
2865 }
2866 else
2867 {
2868 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
2869 u1_tfr_n_mb, u1_end_of_row);
2870 }
2871 ps_dec->u2_total_mbs_coded += u1_num_mbs;
2872 ps_dec->u1_mb_idx = 0;
2873 ps_dec->u4_num_mbs_cur_nmb = 0;
2874 }
2875
2876 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
2877 {
2878 ps_dec->u1_pic_decode_done = 1;
2879 return 0;
2880 }
2881
2882 /* Inserting new slice only if the current slice has atleast 1 MB*/
2883 if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
2884 (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
2885 {
2886 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
2887 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
2888 ps_dec->u2_cur_slice_num++;
2889 ps_dec->ps_parse_cur_slice++;
2890 }
2891 }
2892 else
2893 {
2894 // Slice missing / header corrupted
2895 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num;
2896 }
2897 }
2898
2899 /******************************************************/
2900 /* Initializations to new slice */
2901 /******************************************************/
2902 {
2903 WORD32 num_entries;
2904 WORD32 size;
2905 UWORD8 *pu1_buf;
2906
2907 num_entries = MAX_FRAMES;
2908 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
2909 {
2910 num_entries = 1;
2911 }
2912 num_entries = ((2 * num_entries) + 1);
2913 num_entries *= 2;
2914
2915 size = num_entries * sizeof(void *);
2916 size += PAD_MAP_IDX_POC * sizeof(void *);
2917
2918 pu1_buf = (UWORD8 *) ps_dec->pv_map_ref_idx_to_poc_buf;
2919 pu1_buf += size * ps_dec->u2_cur_slice_num;
2920 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **) pu1_buf;
2921 }
2922 u1_mbaff = ps_slice->u1_mbaff_frame_flag;
2923 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
2924 ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
2925 ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
2926
2927 if(ps_dec->ps_cur_slice->u1_field_pic_flag)
2928 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
2929
2930 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
2931 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
2932
2933 if(ps_dec->u1_separate_parse)
2934 {
2935 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
2936 }
2937 else
2938 {
2939 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
2940 }
2941
2942 /******************************************************/
2943 /* Initializations specific to P slice */
2944 /******************************************************/
2945 u1_inter_mb_type = P_MB;
2946 u1_deblk_mb_type = D_INTER_MB;
2947
2948 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE;
2949 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE;
2950 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
2951 ps_dec->ps_part = ps_dec->ps_parse_part_params;
2952 ps_dec->u2_mbx =
2953 (MOD(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
2954 ps_dec->u2_mby =
2955 (DIV(ps_dec->ps_cur_slice->u2_first_mb_in_slice - 1, ps_dec->u2_frm_wd_in_mbs));
2956 ps_dec->u2_mby <<= u1_mbaff;
2957
2958 /******************************************************/
2959 /* Parsing / decoding the slice */
2960 /******************************************************/
2961 ret = isvcd_parse_interlayer_resamp_func_init(ps_svc_lyr_dec,
2962 ps_dec->ps_cur_slice->u2_first_mb_in_slice);
2963 ps_dec->u1_slice_header_done = 2;
2964
2965 ps_dec->u1_qp = ps_slice->u1_slice_qp;
2966 ih264d_update_qp(ps_dec, 0);
2967 u1_mb_idx = ps_dec->u1_mb_idx;
2968 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
2969 u1_num_mbs = u1_mb_idx;
2970 u1_slice_end = 0;
2971 u1_tfr_n_mb = 0;
2972 u1_decode_nmb = 0;
2973 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
2974 i2_mb_skip_run = num_mb_skip;
2975 if(0 == ps_dec->u2_total_mbs_coded)
2976 {
2977 ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row; //[0];
2978 // Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
2979 ps_dec->ps_cur_mb_row += 2;
2980 ps_dec->ps_top_mb_row = ps_dec->ps_nbr_mb_row;
2981 ps_dec->ps_top_mb_row +=
2982 ((ps_dec->u2_frm_wd_in_mbs + 2) << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag));
2983 // Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
2984 ps_dec->ps_top_mb_row += 2;
2985
2986 /* CHANGED CODE */
2987 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
2988 ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
2989 ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
2990 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
2991 ps_dec->ps_mv = ps_dec->s_cur_pic.ps_mv;
2992 ps_dec->ps_mv_bank_cur = ps_dec->s_cur_pic.ps_mv;
2993 ps_dec->pu1_col_zero_flag = ps_dec->s_cur_pic.pu1_col_zero_flag;
2994 ps_dec->ps_part = ps_dec->ps_parse_part_params;
2995 ps_dec->pf_mvpred_ref_tfr_nby2mb = isvcd_mv_pred_ref_tfr_nby2_epmb;
2996 }
2997 while(!u1_slice_end)
2998 {
2999 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) break;
3000
3001 ps_svc_cur_mb_info = ps_svc_lyr_dec->ps_svc_nmb_info + u1_num_mbs;
3002 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
3003 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
3004 ps_cur_mb_info->u1_Mux = 0;
3005 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
3006 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
3007 ps_cur_mb_info->u1_end_of_slice = 0;
3008
3009 /* Storing Default partition info */
3010 ps_parse_mb_data->u1_num_part = 1;
3011 ps_parse_mb_data->u1_isI_mb = 0;
3012
3013 /**************************************************************/
3014 /* Get the required information for decoding of MB */
3015 /**************************************************************/
3016 /* mb_x, mb_y, neighbor availablity, */
3017 if(u1_mbaff)
3018 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run);
3019 else
3020 isvcd_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info,
3021 i2_mb_skip_run);
3022
3023 {
3024 UWORD16 *pu2_res_luma_csbp;
3025
3026 /*Pointer assignment for Residual NNZ */
3027 pu2_res_luma_csbp = ps_svc_lyr_dec->pu2_frm_res_luma_csbp + ps_cur_mb_info->u2_mbx;
3028 pu2_res_luma_csbp +=
3029 ps_cur_mb_info->u2_mby * ps_svc_lyr_dec->i4_frm_res_luma_csbp_stride;
3030 *pu2_res_luma_csbp = 0;
3031 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
3032 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start + ps_cur_mb_info->u2_mbx +
3033 (ps_svc_lyr_dec->u2_inter_lyr_mb_prms_stride * (ps_cur_mb_info->u2_mby));
3034 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb->i1_mb_mode = SVC_INTER_MB;
3035 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb->i1_tx_size =
3036 ps_cur_mb_info->u1_tran_form8x8;
3037 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb->u2_luma_nnz = 0;
3038 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb->u1_chroma_nnz = 0;
3039 }
3040
3041 /* Set the deblocking parameters for this MB */
3042 if(ps_dec->u4_app_disable_deblk_frm == 0)
3043 {
3044 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
3045 ps_dec->u1_mb_ngbr_availablity,
3046 ps_dec->u1_cur_mb_fld_dec_flag);
3047 }
3048
3049 /* Set appropriate flags in ps_cur_mb_info and ps_dec */
3050 ps_dec->i1_prev_mb_qp_delta = 0;
3051 ps_dec->u1_sub_mb_num = 0;
3052 ps_cur_mb_info->u1_mb_type = MB_SKIP;
3053 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16;
3054 ps_cur_mb_info->u1_cbp = 0;
3055
3056 /* set appropriat flags in svc cur MB info */
3057 ps_svc_cur_mb_info->u1_base_mode_flag = 0;
3058 ps_svc_cur_mb_info->u1_residual_prediction_flag = 0;
3059 ps_svc_cur_mb_info->u1_crop_window_flag = 0;
3060 ps_svc_cur_mb_info->au1_motion_pred_flag[0] = 0;
3061 ps_svc_cur_mb_info->au1_motion_pred_flag[1] = 0;
3062
3063 /* Storing Skip partition info */
3064 ps_part_info = ps_dec->ps_part;
3065 ps_part_info->u1_is_direct = PART_DIRECT_16x16;
3066 ps_part_info->u1_sub_mb_num = 0;
3067 ps_dec->ps_part++;
3068
3069 /* Update Nnzs */
3070 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC);
3071
3072 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type;
3073 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type;
3074
3075 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
3076 {
3077 ps_cur_deblk_mb->u1_deblocking_mode = MB_DISABLE_FILTERING;
3078 }
3079
3080 i2_mb_skip_run--;
3081 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
3082
3083 if(u1_mbaff)
3084 {
3085 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
3086 }
3087
3088 /**************************************************************/
3089 /* Get next Macroblock address */
3090 /**************************************************************/
3091 i2_cur_mb_addr++;
3092 u1_num_mbs++;
3093 ps_parse_mb_data++;
3094
3095 /****************************************************************/
3096 /* Check for End Of Row and other flags that determine when to */
3097 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */
3098 /* N-Mb */
3099 /****************************************************************/
3100 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
3101 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
3102 u1_slice_end = !i2_mb_skip_run;
3103 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
3104 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
3105 ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
3106
3107 if(u1_decode_nmb)
3108 {
3109 if((ps_dec->i4_submb_ofst - ((WORD32) ((u1_num_mbs - u1_mb_idx) << 4))) < 0)
3110 {
3111 ps_dec->i4_submb_ofst = ((u1_num_mbs - u1_mb_idx) << 4);
3112 }
3113
3114 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs);
3115 ps_parse_mb_data = ps_dec->ps_parse_mb_data;
3116 ps_dec->ps_part = ps_dec->ps_parse_part_params;
3117
3118 if(ps_dec->u1_separate_parse)
3119 {
3120 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, u1_tfr_n_mb,
3121 u1_end_of_row);
3122 ps_dec->ps_nmb_info += u1_num_mbs;
3123 ps_svc_lyr_dec->ps_svc_nmb_info += u1_num_mbs;
3124 }
3125 else
3126 {
3127 if(ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER)
3128 {
3129 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
3130 u1_tfr_n_mb, u1_end_of_row);
3131 }
3132 else
3133 {
3134 isvcd_decode_recon_tfr_nmb_base_lyr(ps_svc_lyr_dec, u1_mb_idx, u1_num_mbs,
3135 u1_num_mbs_next, u1_tfr_n_mb,
3136 u1_end_of_row);
3137 }
3138 }
3139 ps_dec->u2_total_mbs_coded += u1_num_mbs;
3140 if(u1_tfr_n_mb) u1_num_mbs = 0;
3141 u1_mb_idx = u1_num_mbs;
3142 ps_dec->u1_mb_idx = u1_num_mbs;
3143 }
3144 }
3145
3146 ps_dec->u4_num_mbs_cur_nmb = 0;
3147 ps_dec->ps_cur_slice->u4_mbs_in_slice =
3148 i2_cur_mb_addr - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice;
3149
3150 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice);
3151
3152 /* incremented here only if first slice is inserted */
3153 if(ps_dec->u4_first_slice_in_pic != 0)
3154 {
3155 ps_dec->ps_parse_cur_slice++;
3156 ps_dec->u2_cur_slice_num++;
3157 }
3158
3159 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
3160 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
3161
3162 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
3163 {
3164 ps_dec->u1_pic_decode_done = 1;
3165 }
3166
3167 return 0;
3168 }
3169 /*!
3170 **************************************************************************
3171 * \if Function name : isvcd_parse_interlayer_resamp_func_init \endif
3172
3173 * \brief
3174 * This function initilizes default values for svcd inter layer func.
3175 *
3176 * \return
3177 * 0 on Success and Error code otherwise
3178 **************************************************************************
3179 */
isvcd_parse_interlayer_resamp_func_init(svc_dec_lyr_struct_t * ps_svc_lyr_dec,UWORD16 u2_first_mb_in_slice)3180 WORD32 isvcd_parse_interlayer_resamp_func_init(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
3181 UWORD16 u2_first_mb_in_slice)
3182 {
3183 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
3184 dec_slice_params_t *ps_slice = ps_dec->ps_cur_slice;
3185 WORD32 ret = OK;
3186 if(ps_svc_lyr_dec->u1_res_init_done == 1)
3187 return ret;
3188
3189 if(TARGET_LAYER != ps_svc_lyr_dec->u1_layer_identifier)
3190 {
3191 ps_slice->u1_disable_dblk_filter_idc = ps_svc_lyr_dec->u1_inter_lyr_disable_dblk_filter_idc;
3192 ps_slice->i1_slice_alpha_c0_offset = ps_svc_lyr_dec->i1_inter_lyr_slice_alpha_c0_offset;
3193 ps_slice->i1_slice_beta_offset = ps_svc_lyr_dec->i1_inter_lyr_slice_beta_offset;
3194 }
3195
3196 if(0 == u2_first_mb_in_slice)
3197 {
3198 ret = isvcd_populate_res_prms(ps_svc_lyr_dec);
3199 if(ret != OK) return NOT_OK;
3200 isvcd_crop_wnd_flag_res_int(ps_svc_lyr_dec);
3201 ret = isvcd_comp_mode_mv_res_init(ps_svc_lyr_dec);
3202 if(ret != OK) return NOT_OK;
3203 ret = isvcd_ii_pred_res_init(ps_svc_lyr_dec);
3204 if(ret != OK) return NOT_OK;
3205 ret = isvcd_intra_resamp_res_init(ps_svc_lyr_dec);
3206 if(ret != OK) return NOT_OK;
3207 ret = isvcd_residual_samp_res_init(ps_svc_lyr_dec);
3208 if(ret != OK) return NOT_OK;
3209
3210 ps_svc_lyr_dec->u1_res_init_done = 1;
3211 }
3212
3213 return ret;
3214 }
3215
3216 /*!
3217 **************************************************************************
3218 * \if Function name : isvcd_decode_pslice \endif
3219 *
3220 * \brief
3221 * Decodes a P Slice
3222 *
3223 *
3224 * \return
3225 * 0 on Success and Error code otherwise
3226 **************************************************************************
3227 */
isvcd_parse_pslice(svc_dec_lyr_struct_t * ps_svc_lyr_dec,UWORD16 u2_first_mb_in_slice)3228 WORD32 isvcd_parse_pslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_first_mb_in_slice)
3229 {
3230 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
3231 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
3232 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
3233 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
3234 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
3235 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
3236 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
3237 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
3238 UWORD64 u8_ref_idx_l0;
3239 UWORD32 u4_temp;
3240 WORD32 i_temp;
3241 WORD32 ret;
3242 WORD64 i8_temp;
3243
3244 /*--------------------------------------------------------------------*/
3245 /* Read remaining contents of the slice header */
3246 /*--------------------------------------------------------------------*/
3247 {
3248 WORD8 *pi1_buf;
3249 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv;
3250 WORD32 *pi4_mv = (WORD32 *) pi2_mv;
3251 WORD16 *pi16_refFrame;
3252
3253 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame;
3254 pi16_refFrame = (WORD16 *) pi1_buf;
3255 *pi4_mv = 0;
3256 *(pi4_mv + 1) = 0;
3257 *pi16_refFrame = OUT_OF_RANGE_REF;
3258 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8) -1;
3259 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8) -1;
3260 }
3261
3262 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264(ps_bitstrm);
3263 COPYTHECONTEXT("SH: num_ref_idx_override_flag",
3264 ps_cur_slice->u1_num_ref_idx_active_override_flag);
3265
3266 u8_ref_idx_l0 = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0];
3267 if(ps_cur_slice->u1_num_ref_idx_active_override_flag)
3268 {
3269 u8_ref_idx_l0 = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + (UWORD64) 1;
3270 }
3271
3272 {
3273 UWORD8 u1_max_ref_idx = H264_MAX_REF_PICS << u1_field_pic_flag;
3274 if(u8_ref_idx_l0 >= u1_max_ref_idx)
3275 {
3276 return ERROR_NUM_REF;
3277 }
3278 ps_cur_slice->u1_num_ref_idx_lx_active[0] = (UWORD8) u8_ref_idx_l0;
3279 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1",
3280 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1);
3281 }
3282
3283 {
3284 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm);
3285 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0", uc_refIdxReFlagL0);
3286
3287 ih264d_init_ref_idx_lx_p(ps_dec);
3288 /* Store the value for future slices in the same picture */
3289 ps_dec->u1_num_ref_idx_lx_active_prev = ps_cur_slice->u1_num_ref_idx_lx_active[0];
3290
3291 /* Modified temporarily */
3292 if(uc_refIdxReFlagL0)
3293 {
3294 WORD8 ret;
3295 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
3296 ret = ih264d_ref_idx_reordering(ps_dec, 0);
3297 if(ret == -1) return ERROR_REFIDX_ORDER_T;
3298 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0];
3299 }
3300 else
3301 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0];
3302 }
3303 /* Create refIdx to POC mapping */
3304 {
3305 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1;
3306 WORD8 idx;
3307 struct pic_buffer_t *ps_pic;
3308
3309 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0;
3310 pui_map_ref_idx_to_poc_lx0[0] = 0;
3311 pui_map_ref_idx_to_poc_lx0++;
3312 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
3313 {
3314 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
3315 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1);
3316 }
3317
3318 /* Bug Fix Deblocking */
3319 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1;
3320 pui_map_ref_idx_to_poc_lx1[0] = 0;
3321
3322 if(u1_mbaff)
3323 {
3324 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b;
3325 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1;
3326 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc + TOP_LIST_FLD_L0;
3327 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc + BOT_LIST_FLD_L0;
3328 ppv_map_ref_idx_to_poc_lx_t[0] = 0;
3329 ppv_map_ref_idx_to_poc_lx_t++;
3330 ppv_map_ref_idx_to_poc_lx_b[0] = 0;
3331 ppv_map_ref_idx_to_poc_lx_b++;
3332 idx = 0;
3333 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++)
3334 {
3335 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx];
3336 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1);
3337 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1);
3338 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1;
3339 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1;
3340 ppv_map_ref_idx_to_poc_lx_t += 2;
3341 ppv_map_ref_idx_to_poc_lx_b += 2;
3342 }
3343 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc + TOP_LIST_FLD_L1;
3344 ppv_map_ref_idx_to_poc_lx_t1[0] = 0;
3345 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc + BOT_LIST_FLD_L1;
3346 ppv_map_ref_idx_to_poc_lx_b1[0] = 0;
3347 }
3348 }
3349 if(ps_pps->u1_wted_pred_flag)
3350 {
3351 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm);
3352 if(ret != OK) return ret;
3353
3354 ih264d_form_pred_weight_matrix(ps_dec);
3355 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
3356 }
3357 else
3358 {
3359 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0;
3360 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
3361 }
3362
3363 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
3364
3365 if(u1_mbaff && (u1_field_pic_flag == 0))
3366 {
3367 ih264d_convert_frm_mbaff_list(ps_dec);
3368 }
3369
3370 /* G050 */
3371 if(ps_cur_slice->u1_nal_ref_idc != 0)
3372 {
3373 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
3374 {
3375 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
3376 dec_seq_params_t *ps_sps_tmp = ps_pps->ps_sps;
3377 UWORD8 u1_nal_unit_type_tmp = ps_dec->u1_nal_unit_type;
3378
3379 ps_pps->ps_sps = ps_dec->ps_cur_sps;
3380 if(ps_svc_lyr_dec->ps_nal_svc_ext->u1_idr_flag)
3381 ps_dec->u1_nal_unit_type = IDR_SLICE_NAL;
3382
3383 i_temp = ih264d_read_mmco_commands(ps_dec);
3384
3385 ps_pps->ps_sps = ps_sps_tmp;
3386 ps_dec->u1_nal_unit_type = u1_nal_unit_type_tmp;
3387
3388 if(i_temp < 0)
3389 {
3390 return ERROR_DBP_MANAGER_T;
3391 }
3392 ps_dec->u4_bitoffset = i_temp;
3393 }
3394 else
3395 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset;
3396 }
3397 /* G050 */
3398
3399 if(ps_pps->u1_entropy_coding_mode == CABAC)
3400 {
3401 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
3402
3403 if(u4_temp > MAX_CABAC_INIT_IDC)
3404 {
3405 return ERROR_INV_SLICE_HDR_T;
3406 }
3407 ps_cur_slice->u1_cabac_init_idc = u4_temp;
3408 COPYTHECONTEXT("SH: cabac_init_idc", ps_cur_slice->u1_cabac_init_idc);
3409 }
3410
3411 /* Read slice_qp_delta */
3412 i8_temp = (WORD64) ps_pps->u1_pic_init_qp + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
3413 if((i8_temp < MIN_H264_QP) || (i8_temp > MAX_H264_QP))
3414 {
3415 return ERROR_INV_RANGE_QP_T;
3416 }
3417 ps_cur_slice->u1_slice_qp = (UWORD8) i8_temp;
3418 COPYTHECONTEXT("SH: slice_qp_delta",
3419 (WORD8) (ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp));
3420
3421 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1)
3422 {
3423 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
3424 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED)
3425 {
3426 return ERROR_INV_SLICE_HDR_T;
3427 }
3428
3429 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp);
3430 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp;
3431 if(u4_temp != 1)
3432 {
3433 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) << 1;
3434 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
3435 {
3436 return ERROR_INV_SLICE_HDR_T;
3437 }
3438 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp;
3439 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2",
3440 ps_cur_slice->i1_slice_alpha_c0_offset >> 1);
3441
3442 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) << 1;
3443 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF))
3444 {
3445 return ERROR_INV_SLICE_HDR_T;
3446 }
3447 ps_cur_slice->i1_slice_beta_offset = i_temp;
3448 COPYTHECONTEXT("SH: slice_beta_offset_div2", ps_cur_slice->i1_slice_beta_offset >> 1);
3449 }
3450 else
3451 {
3452 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
3453 ps_cur_slice->i1_slice_beta_offset = 0;
3454 }
3455 }
3456 else
3457 {
3458 ps_cur_slice->u1_disable_dblk_filter_idc = 0;
3459 ps_cur_slice->i1_slice_alpha_c0_offset = 0;
3460 ps_cur_slice->i1_slice_beta_offset = 0;
3461 }
3462
3463 ps_dec->u1_slice_header_done = 2;
3464 if(ps_pps->u1_entropy_coding_mode)
3465 {
3466 SWITCHOFFTRACE;
3467 SWITCHONTRACECABAC;
3468 ps_svc_lyr_dec->pf_parse_svc_inter_slice = isvcd_parse_inter_slice_data_cabac;
3469 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac;
3470 ih264d_init_cabac_contexts(P_SLICE, ps_dec);
3471
3472 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
3473 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff;
3474 else
3475 ps_dec->pf_get_mb_info = isvcd_get_mb_info_cabac_nonmbaff;
3476 }
3477 else
3478 {
3479 SWITCHONTRACE;
3480 SWITCHOFFTRACECABAC;
3481 ps_svc_lyr_dec->pf_parse_svc_inter_slice = isvcd_parse_inter_slice_data_cavlc;
3482 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc;
3483 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag)
3484 {
3485 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff;
3486 }
3487 else
3488 ps_dec->pf_get_mb_info = isvcd_get_mb_info_cavlc_nonmbaff;
3489 }
3490
3491 ps_dec->u1_B = 0;
3492 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
3493 ret = ps_svc_lyr_dec->pf_parse_svc_inter_slice(ps_svc_lyr_dec, ps_cur_slice,
3494 u2_first_mb_in_slice);
3495 if(ret != OK) return ret;
3496
3497 return OK;
3498 }
3499