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