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_slice.c
24 *
25 * @brief
26 * Contains routines that decodes a slice NAL unit
27 *
28 * @author
29 * Kishore
30 *
31 * @remarks
32 * None
33 *
34 *******************************************************************************
35 */
36
37 #include <string.h>
38 #include <assert.h>
39 #include "ih264_typedefs.h"
40 #include "ih264_macros.h"
41 #include "ih264_platform_macros.h"
42 #include "ithread.h"
43 #include "isvcd_structs.h"
44 #include "ih264d_debug.h"
45 #include "ih264d_bitstrm.h"
46 #include "ih264d_parse_mb_header.h"
47 #include "ih264d_process_bslice.h"
48 #include "ih264d_process_pslice.h"
49 #include "ih264d_parse_cavlc.h"
50 #include "ih264d_utils.h"
51 #include "isvcd_utils.h"
52 #include "ih264d_deblocking.h"
53 #include "ih264d_defs.h"
54 #include "ih264d_error_handler.h"
55 #include "ih264d_tables.h"
56 #include "ih264d_defs.h"
57 #include "ih264d_mem_request.h"
58 #include "ih264d_parse_islice.h"
59 #include "ih264d_parse_slice.h"
60 #include "ih264d_mvpred.h"
61 #include "ih264d_mb_utils.h"
62 #include "ih264d_defs.h"
63 #include "ih264d_quant_scaling.h"
64 #include "ih264d_inter_pred.h"
65 #include "ih264d_sei.h"
66 #include "ih264_error.h"
67 #include "ih264_disp_mgr.h"
68 #include "ih264_buf_mgr.h"
69 #include "ih264d_thread_parse_decode.h"
70 #include "ih264d_thread_compute_bs.h"
71 #include "ih264d_dpb_manager.h"
72 #include "ih264d_parse_islice.h"
73 #include "isvcd_parse_slice.h"
74 #include "isvcd_process_epslice.h"
75 #include "isvcd_process_ebslice.h"
76 #include "isvcd_thread_compute_bs.h"
77 #include "isvcd_thread_parse_decode.h"
78 #include "isvcd_deblocking.h"
79
80 #define RET_LAST_SKIP 0x80000000
81
82 WORD32 check_app_out_buf_size(dec_struct_t *ps_dec);
83 /*!
84 **************************************************************************
85 * \if Function name : isvcd_verify_level \endif
86 *
87 * \brief
88 * Initialize the Parameter required for all the slices for a picture
89 *
90 * \return : Nothing
91 *
92 **************************************************************************
93 */
isvcd_verify_level(UWORD8 u1_level_idc)94 WORD32 isvcd_verify_level(UWORD8 u1_level_idc)
95 {
96 switch(u1_level_idc)
97 {
98 case H264_LEVEL_1_0:
99 case H264_LEVEL_1_1:
100 case H264_LEVEL_1_2:
101 case H264_LEVEL_1_3:
102 case H264_LEVEL_2_0:
103 case H264_LEVEL_2_1:
104 case H264_LEVEL_2_2:
105 case H264_LEVEL_3_0:
106 case H264_LEVEL_3_1:
107 case H264_LEVEL_3_2:
108 case H264_LEVEL_4_0:
109 case H264_LEVEL_4_1:
110 case H264_LEVEL_4_2:
111 case H264_LEVEL_5_0:
112 case H264_LEVEL_5_1:
113 return OK;
114 default:
115 return NOT_OK;
116 }
117 }
118
119 /*!
120 **************************************************************************
121 * \if Function name : isvcd_start_of_pic \endif
122 *
123 * \brief
124 * Initialize the Parameter required for all the slices for a picture
125 *
126 * \return : Nothing
127 *
128 **************************************************************************
129 */
130
isvcd_start_of_pic(svc_dec_lyr_struct_t * ps_svc_lyr_dec,WORD32 i4_poc,pocstruct_t * ps_temp_poc,UWORD16 u2_frame_num,dec_pic_params_t * ps_pps)131 WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
132 pocstruct_t *ps_temp_poc, UWORD16 u2_frame_num, dec_pic_params_t *ps_pps)
133 {
134 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
135 pocstruct_t *ps_prev_poc = &ps_dec->s_cur_pic_poc;
136 pocstruct_t *ps_cur_poc = ps_temp_poc;
137
138 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
139 dec_seq_params_t *ps_seq = ps_dec->ps_cur_sps;
140 UWORD8 u1_bottom_field_flag = ps_cur_slice->u1_bottom_field_flag;
141 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
142 /* high profile related declarations */
143 WORD32 ret;
144
145 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
146
147 if(u1_field_pic_flag == 1)
148 {
149 ps_dec->i4_error_code = ERROR_SVC_FIELD_PIC_UNSUPPORTED;
150 return ERROR_SVC_FIELD_PIC_UNSUPPORTED;
151 }
152
153 /* check output buffer size given by the application */
154 if(check_app_out_buf_size(ps_dec) != IV_SUCCESS) return IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
155
156 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
157 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
158 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
159 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
160 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
161 ps_prev_poc->u1_bot_field = ps_dec->ps_cur_slice->u1_bottom_field_flag;
162 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
163 ps_prev_poc->u2_frame_num = u2_frame_num;
164 ps_dec->i1_prev_mb_qp_delta = 0;
165 ps_dec->i1_next_ctxt_idx = 0;
166
167 ps_dec->u4_nmb_deblk = 0;
168 if(ps_dec->u4_num_cores == 1) ps_dec->u4_nmb_deblk = 1;
169
170 if(ps_seq->u1_mb_aff_flag == 1)
171 {
172 ps_dec->u4_nmb_deblk = 0;
173 if(ps_dec->u4_num_cores > 2) ps_dec->u4_num_cores = 2;
174 }
175
176 ps_dec->u4_use_intrapred_line_copy = 0;
177
178 if(ps_seq->u1_mb_aff_flag == 0)
179 {
180 ps_dec->u4_use_intrapred_line_copy = 1;
181 }
182
183 ps_dec->u4_app_disable_deblk_frm = 0;
184 /* If degrade is enabled, set the degrade flags appropriately */
185 if(ps_dec->i4_degrade_type && ps_dec->i4_degrade_pics)
186 {
187 WORD32 degrade_pic;
188 ps_dec->i4_degrade_pic_cnt++;
189 degrade_pic = 0;
190
191 /* If degrade is to be done in all frames, then do not check further */
192 switch(ps_dec->i4_degrade_pics)
193 {
194 case 4:
195 {
196 degrade_pic = 1;
197 break;
198 }
199 case 3:
200 {
201 if(ps_cur_slice->u1_slice_type != I_SLICE) degrade_pic = 1;
202
203 break;
204 }
205 case 2:
206 {
207 /* If pic count hits non-degrade interval or it is an islice, then do not
208 * degrade */
209 if((ps_cur_slice->u1_slice_type != I_SLICE) &&
210 (ps_dec->i4_degrade_pic_cnt != ps_dec->i4_nondegrade_interval))
211 degrade_pic = 1;
212
213 break;
214 }
215 case 1:
216 {
217 /* Check if the current picture is non-ref */
218 if(0 == ps_cur_slice->u1_nal_ref_idc)
219 {
220 degrade_pic = 1;
221 }
222 break;
223 }
224 }
225 if(degrade_pic)
226 {
227 if(ps_dec->i4_degrade_type & 0x2) ps_dec->u4_app_disable_deblk_frm = 1;
228
229 /* MC degrading is done only for non-ref pictures */
230 if(0 == ps_cur_slice->u1_nal_ref_idc)
231 {
232 if(ps_dec->i4_degrade_type & 0x4) ps_dec->i4_mv_frac_mask = 0;
233
234 if(ps_dec->i4_degrade_type & 0x8) ps_dec->i4_mv_frac_mask = 0;
235 }
236 }
237 else
238 ps_dec->i4_degrade_pic_cnt = 0;
239 }
240
241 {
242 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
243 if((ps_cur_slice->u1_slice_type == I_SLICE) || (ps_cur_slice->u1_slice_type == SI_SLICE))
244 ps_err->u1_cur_pic_type = PIC_TYPE_I;
245 else
246 ps_err->u1_cur_pic_type = PIC_TYPE_UNKNOWN;
247
248 if(ps_err->u1_pic_aud_i == PIC_TYPE_I)
249 {
250 ps_err->u1_cur_pic_type = PIC_TYPE_I;
251 ps_err->u1_pic_aud_i = PIC_TYPE_UNKNOWN;
252 }
253
254 if(ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)
255 {
256 if(ps_err->u1_err_flag) ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
257 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
258 }
259 }
260
261 if(ps_dec->u1_init_dec_flag && ps_dec->s_prev_seq_params.u1_eoseq_pending)
262 {
263 /* Reset the decoder picture buffers */
264 WORD32 j;
265 for(j = 0; j < MAX_DISP_BUFS_NEW; j++)
266 {
267 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, j, BUF_MGR_REF);
268 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_mv_buf_mgr,
269 ps_dec->as_buf_id_info_map[j].mv_buf_id, BUF_MGR_REF);
270 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, j, BUF_MGR_IO);
271 }
272
273 /* reset the decoder structure parameters related to buffer handling */
274 ps_dec->u1_second_field = 0;
275 ps_dec->i4_cur_display_seq = 0;
276
277 /********************************************************************/
278 /* indicate in the decoder output i4_status that some frames are being */
279 /* dropped, so that it resets timestamp and wait for a new sequence */
280 /********************************************************************/
281 ps_dec->s_prev_seq_params.u1_eoseq_pending = 0;
282 }
283 ret = isvcd_init_pic(ps_svc_lyr_dec, u2_frame_num, i4_poc, ps_pps);
284 if(ret != OK) return ret;
285
286 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data;
287 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data;
288 ps_dec->ps_nmb_info = ps_dec->ps_frm_mb_info;
289 ps_svc_lyr_dec->ps_svc_nmb_info = ps_svc_lyr_dec->ps_svc_frm_mb_info;
290 if(ps_dec->u1_separate_parse)
291 {
292 UWORD32 num_mbs;
293 num_mbs = ps_dec->ps_cur_sps->u2_total_num_of_mbs
294 << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag);
295
296 if(ps_dec->pu1_dec_mb_map)
297 {
298 memset((void *) ps_dec->pu1_dec_mb_map, 0, num_mbs);
299 }
300
301 if(ps_dec->pu1_recon_mb_map)
302 {
303 memset((void *) ps_dec->pu1_recon_mb_map, 0, num_mbs);
304 }
305
306 if(ps_dec->pu2_slice_num_map)
307 {
308 memset((void *) ps_dec->pu2_slice_num_map, 0, (num_mbs * sizeof(UWORD16)));
309 }
310 }
311
312 ps_dec->ps_parse_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
313 ps_dec->ps_decode_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
314 ps_dec->ps_computebs_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
315 ps_dec->u2_cur_slice_num = 0;
316
317 /* Initialize all the HP toolsets to zero */
318 ps_dec->s_high_profile.u1_scaling_present = 0;
319 ps_dec->s_high_profile.u1_transform8x8_present = 0;
320
321 /* Get Next Free Picture */
322 if(1 == ps_dec->u4_share_disp_buf)
323 {
324 UWORD32 i;
325 /* Free any buffer that is in the queue to be freed */
326 for(i = 0; i < MAX_DISP_BUFS_NEW; i++)
327 {
328 if(0 == ps_dec->u4_disp_buf_to_be_freed[i]) continue;
329 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, i, BUF_MGR_IO);
330 ps_dec->u4_disp_buf_to_be_freed[i] = 0;
331 ps_dec->u4_disp_buf_mapping[i] = 0;
332 }
333 }
334 if(!(u1_field_pic_flag && 0 != ps_dec->u1_top_bottom_decoded))
335 {
336 pic_buffer_t *ps_cur_pic;
337 WORD32 cur_pic_buf_id, cur_mv_buf_id;
338 col_mv_buf_t *ps_col_mv;
339 while(1)
340 {
341 ps_cur_pic = (pic_buffer_t *) ih264_buf_mgr_get_next_free(
342 (buf_mgr_t *) ps_dec->pv_pic_buf_mgr, &cur_pic_buf_id);
343
344 /* In case of IDR slices, if there is no free picture buffer, then release
345 * all buffers from display and reference
346 */
347 if((ps_cur_pic == NULL) && (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
348 {
349 WORD32 j;
350
351 for(j = 0; j < MAX_DISP_BUFS_NEW; j++)
352 {
353 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, j, BUF_MGR_REF);
354 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_mv_buf_mgr,
355 ps_dec->as_buf_id_info_map[j].mv_buf_id, BUF_MGR_REF);
356
357 ih264_buf_mgr_release((buf_mgr_t *) ps_dec->pv_pic_buf_mgr, j, BUF_MGR_IO);
358 }
359 ps_cur_pic = (pic_buffer_t *) ih264_buf_mgr_get_next_free(
360 (buf_mgr_t *) ps_dec->pv_pic_buf_mgr, &cur_pic_buf_id);
361 }
362 if(ps_cur_pic == NULL)
363 {
364 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T;
365 ps_dec->ps_dec_err_status->u1_err_flag |= REJECT_CUR_PIC;
366 return ERROR_UNAVAIL_PICBUF_T;
367 }
368 if(0 == ps_dec->u4_disp_buf_mapping[cur_pic_buf_id])
369 {
370 break;
371 }
372 }
373 ps_col_mv = (col_mv_buf_t *) ih264_buf_mgr_get_next_free(
374 (buf_mgr_t *) ps_dec->pv_mv_buf_mgr, &cur_mv_buf_id);
375 if(ps_col_mv == NULL)
376 {
377 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T;
378 ps_dec->ps_dec_err_status->u1_err_flag |= REJECT_CUR_PIC;
379 return ERROR_UNAVAIL_MVBUF_T;
380 }
381
382 ps_dec->ps_cur_pic = ps_cur_pic;
383 ps_dec->u1_pic_buf_id = cur_pic_buf_id;
384 ps_cur_pic->u4_ts = ps_dec->u4_ts;
385 memcpy(&ps_cur_pic->s_sei_pic, ps_dec->ps_sei, sizeof(sei));
386
387 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id;
388 ps_dec->as_buf_id_info_map[cur_pic_buf_id].mv_buf_id = cur_mv_buf_id;
389
390 if(ps_dec->u1_enable_mb_info)
391 {
392 UWORD32 mb_info_map_size = ps_dec->u4_total_mbs << 2;
393 ps_dec->as_buf_id_info_map[cur_pic_buf_id].pu1_qp_map =
394 ps_dec->pu1_qp_map_base + cur_pic_buf_id * mb_info_map_size;
395 ps_dec->as_buf_id_info_map[cur_pic_buf_id].pu1_mb_type_map =
396 ps_dec->pu1_mb_type_map_base + cur_pic_buf_id * mb_info_map_size;
397 memset(ps_dec->as_buf_id_info_map[cur_pic_buf_id].pu1_qp_map, 0, mb_info_map_size);
398 memset(ps_dec->as_buf_id_info_map[cur_pic_buf_id].pu1_mb_type_map, 0, mb_info_map_size);
399 }
400 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *) ps_col_mv->pv_col_zero_flag;
401 ps_cur_pic->ps_mv = (mv_pred_t *) ps_col_mv->pv_mv;
402 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0;
403
404 {
405 /*make first entry of list0 and list1 point to cur pic,
406 *so that if first slice is in error, ref pic struct will have valid
407 *entries*/
408 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0];
409 ps_dec->ps_ref_pic_buf_lx[1] = ps_dec->ps_dpb_mgr->ps_init_dpb[1];
410 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][0]) = *ps_cur_pic;
411 /* Initialize for field reference as well */
412 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic;
413
414 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][0]) = *ps_cur_pic;
415 /* Initialize for field reference as well */
416 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic;
417 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][0]) = *ps_cur_pic;
418 /* Initialize for field reference as well */
419 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic;
420 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][0]) = *ps_cur_pic;
421 /* Initialize for field reference as well */
422 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic;
423 }
424
425 ps_dec->ps_cur_pic->u1_picturetype = u1_field_pic_flag;
426 ps_dec->ps_cur_pic->u4_pack_slc_typ = SKIP_NONE;
427 H264_DEC_DEBUG_PRINT("got a buffer\n");
428 }
429 else
430 {
431 H264_DEC_DEBUG_PRINT("did not get a buffer\n");
432 }
433
434 ps_dec->u4_pic_buf_got = 1;
435
436 ps_dec->ps_cur_pic->i4_poc = i4_poc;
437 ps_dec->ps_cur_pic->i4_frame_num = u2_frame_num;
438 ps_dec->ps_cur_pic->i4_pic_num = u2_frame_num;
439 ps_dec->ps_cur_pic->i4_top_field_order_cnt = ps_pps->i4_top_field_order_cnt;
440 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = ps_pps->i4_bottom_field_order_cnt;
441 ps_dec->ps_cur_pic->i4_avg_poc = ps_pps->i4_avg_poc;
442 ps_dec->ps_cur_pic->u4_time_stamp = ps_dec->u4_pts;
443
444 ps_dec->s_cur_pic = *(ps_dec->ps_cur_pic);
445 if(u1_field_pic_flag && u1_bottom_field_flag)
446 {
447 WORD32 i4_temp_poc;
448 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
449 /* Point to odd lines, since it's bottom field */
450 ps_dec->s_cur_pic.pu1_buf1 += ps_dec->s_cur_pic.u2_frm_wd_y;
451 ps_dec->s_cur_pic.pu1_buf2 += ps_dec->s_cur_pic.u2_frm_wd_uv;
452 ps_dec->s_cur_pic.pu1_buf3 += ps_dec->s_cur_pic.u2_frm_wd_uv;
453 ps_dec->s_cur_pic.ps_mv += ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
454 ps_dec->s_cur_pic.pu1_col_zero_flag += ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
455 ps_dec->ps_cur_pic->u1_picturetype |= BOT_FLD;
456 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
457 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
458 i4_temp_poc = MIN(i4_top_field_order_poc, i4_bot_field_order_poc);
459 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
460 }
461
462 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
463 ps_dec->ps_cur_pic->u1_picturetype |= (ps_cur_slice->u1_mbaff_frame_flag << 2);
464
465 ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row;
466 ps_dec->ps_cur_mb_row += 2;
467 ps_dec->ps_top_mb_row = ps_dec->ps_nbr_mb_row;
468 ps_dec->ps_top_mb_row +=
469 ((ps_dec->u2_frm_wd_in_mbs + 2) << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag));
470 // Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
471 ps_dec->ps_top_mb_row += 2;
472 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
473 ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
474 ps_dec->u1_mv_top_p = 0;
475 ps_dec->u1_mb_idx = 0;
476 ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
477 ps_dec->u2_total_mbs_coded = 0;
478 ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
479 ps_dec->u4_pred_info_idx = 0;
480 ps_dec->u4_pred_info_pkd_idx = 0;
481 ps_dec->u4_dma_buf_idx = 0;
482 ps_dec->ps_mv = ps_dec->s_cur_pic.ps_mv;
483 ps_dec->ps_mv_bank_cur = ps_dec->s_cur_pic.ps_mv;
484 ps_dec->pu1_col_zero_flag = ps_dec->s_cur_pic.pu1_col_zero_flag;
485 ps_dec->ps_part = ps_dec->ps_parse_part_params;
486 ps_dec->i2_prev_slice_mbx = -1;
487 ps_dec->i2_prev_slice_mby = 0;
488 ps_dec->u2_mv_2mb[0] = 0;
489 ps_dec->u2_mv_2mb[1] = 0;
490 ps_dec->u1_last_pic_not_decoded = 0;
491
492 ps_dec->u2_cur_slice_num_dec_thread = 0;
493 ps_dec->u2_cur_slice_num_bs = 0;
494 ps_dec->u4_intra_pred_line_ofst = 0;
495 ps_dec->pu1_cur_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line;
496 ps_dec->pu1_cur_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line;
497 ps_dec->pu1_cur_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line;
498
499 ps_dec->pu1_cur_y_intra_pred_line_base = ps_dec->pu1_y_intra_pred_line;
500 ps_dec->pu1_cur_u_intra_pred_line_base = ps_dec->pu1_u_intra_pred_line;
501 ps_dec->pu1_cur_v_intra_pred_line_base = ps_dec->pu1_v_intra_pred_line;
502
503 ps_dec->pu1_prev_y_intra_pred_line =
504 ps_dec->pu1_y_intra_pred_line + (ps_dec->u2_frm_wd_in_mbs * MB_SIZE);
505
506 ps_dec->pu1_prev_u_intra_pred_line =
507 ps_dec->pu1_u_intra_pred_line + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE * YUV420SP_FACTOR;
508 ps_dec->pu1_prev_v_intra_pred_line =
509 ps_dec->pu1_v_intra_pred_line + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE;
510
511 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
512 /* Initialize The Function Pointer Depending Upon the Entropy and MbAff Flag
513 */
514 {
515 if(ps_cur_slice->u1_mbaff_frame_flag)
516 {
517 ps_dec->pf_compute_bs = ih264d_compute_bs_mbaff;
518 ps_dec->pf_mvpred = ih264d_mvpred_mbaff;
519 ps_svc_lyr_dec->pf_svc_compute_bs = isvcd_compute_bs_non_mbaff;
520 }
521 else
522 {
523 ps_dec->pf_compute_bs = ih264d_compute_bs_non_mbaff;
524 ps_svc_lyr_dec->pf_svc_compute_bs = isvcd_compute_bs_non_mbaff;
525 ps_dec->u1_cur_mb_fld_dec_flag = ps_cur_slice->u1_field_pic_flag;
526
527 if((ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER) &&
528 (0 == ps_svc_lyr_dec->u1_base_res_flag))
529 {
530 ps_svc_lyr_dec->pf_svc_compute_bs = isvcd_compute_bs_non_mbaff_target_lyr;
531 }
532
533 if((ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER) &&
534 (1 == ps_svc_lyr_dec->u1_base_res_flag))
535 {
536 ps_svc_lyr_dec->pf_svc_compute_bs =
537 isvcd_compute_bs_non_mbaff_target_lyr_no_inter_layer;
538 }
539
540 if((ps_svc_lyr_dec->u1_layer_identifier == MEDIAL_ENHANCEMENT_LAYER) &&
541 (0 == ps_svc_lyr_dec->u1_base_res_flag))
542 {
543 ps_svc_lyr_dec->pf_svc_compute_bs = isvcd_compute_bs_non_mbaff_medial_lyr;
544 }
545 }
546 }
547 /* Set up the Parameter for DMA transfer */
548 {
549 UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
550 UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
551 UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
552 UWORD16 ui16_lastmbs_widthY =
553 (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 4));
554 UWORD16 ui16_lastmbs_widthUV =
555 uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 3);
556
557 ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
558 ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
559 ps_dec->s_tran_addrecon.pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
560
561 ps_dec->s_tran_addrecon.u2_frm_wd_y = ps_dec->u2_frm_wd_y << u1_field_pic_flag;
562 ps_dec->s_tran_addrecon.u2_frm_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag;
563
564 if(u1_field_pic_flag)
565 {
566 ui16_lastmbs_widthY += ps_dec->u2_frm_wd_y;
567 ui16_lastmbs_widthUV += ps_dec->u2_frm_wd_uv;
568 }
569
570 /* Normal Increment of Pointer */
571 ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
572 ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
573
574 /* End of Row Increment */
575 ps_dec->s_tran_addrecon.u4_inc_y[1] =
576 (ui16_lastmbs_widthY + (PAD_LEN_Y_H << 1) +
577 ps_dec->s_tran_addrecon.u2_frm_wd_y * ((15 << u1_mbaff) + u1_mbaff));
578 ps_dec->s_tran_addrecon.u4_inc_uv[1] =
579 (ui16_lastmbs_widthUV + (PAD_LEN_UV_H << 2) +
580 ps_dec->s_tran_addrecon.u2_frm_wd_uv * ((15 << u1_mbaff) + u1_mbaff));
581
582 /* Assign picture numbers to each frame/field */
583 /* only once per picture. */
584 ih264d_assign_pic_num(ps_dec);
585 ps_dec->s_tran_addrecon.u2_mv_top_left_inc =
586 (ps_dec->u1_recon_mb_grp << 2) - 1 - (u1_mbaff << 2);
587 ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp >> u1_mbaff) - 1)
588 << (4 + u1_mbaff);
589 }
590 /**********************************************************************/
591 /* High profile related initialization at pictrue level */
592 /**********************************************************************/
593 if((ps_seq->u1_profile_idc == HIGH_PROFILE_IDC) ||
594 (ps_seq->u1_profile_idc == SCALABLE_HIGH_PROFILE_IDC) ||
595 (ps_seq->u1_profile_idc == SCALABLE_BASELINE_PROFILE_IDC))
596 {
597 if((ps_seq->i4_seq_scaling_matrix_present_flag) ||
598 (ps_pps->i4_pic_scaling_matrix_present_flag))
599 {
600 ret = ih264d_form_scaling_matrix_picture(ps_seq, ps_pps, ps_dec);
601 ps_dec->s_high_profile.u1_scaling_present = 1;
602 }
603 else
604 {
605 ret = ih264d_form_default_scaling_matrix(ps_dec);
606 }
607
608 if(ps_pps->i4_transform_8x8_mode_flag)
609 {
610 ps_dec->s_high_profile.u1_transform8x8_present = 1;
611 }
612 }
613 else
614 {
615 ret = ih264d_form_default_scaling_matrix(ps_dec);
616 }
617
618 if(ret != OK) return ret;
619
620 /* required while reading the transform_size_8x8 u4_flag */
621 ps_dec->s_high_profile.u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
622 ps_dec->s_high_profile.s_cavlc_ctxt = ps_dec->s_cavlc_ctxt;
623
624 ps_dec->i1_recon_in_thread3_flag = 1;
625 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_addrecon;
626 if(ps_dec->u1_separate_parse)
627 {
628 memcpy(&ps_dec->s_tran_addrecon_parse, &ps_dec->s_tran_addrecon, sizeof(tfr_ctxt_t));
629 }
630
631 ih264d_init_deblk_tfr_ctxt(ps_dec, &(ps_dec->s_pad_mgr), &(ps_dec->s_tran_addrecon),
632 ps_dec->u2_frm_wd_in_mbs, 0);
633
634 ps_dec->ps_cur_deblk_mb = ps_dec->ps_deblk_pic;
635 ps_dec->u4_cur_deblk_mb_num = 0;
636 ps_dec->u4_deblk_mb_x = 0;
637 ps_dec->u4_deblk_mb_y = 0;
638 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
639
640 ps_dec->u4_first_slice_in_pic = 0;
641 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
642 return OK;
643 }
644 /*!
645 **************************************************************************
646 * \if Function name : isvcd_parse_decode_slice_ext_nal \endif
647 *
648 * \brief
649 * Parses a slice extension NAL
650 *
651 * \return
652 * 0 on Success and Error code otherwise
653 **************************************************************************
654 */
isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,svc_dec_lyr_struct_t * ps_svc_lyr_dec)655 WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
656 svc_dec_lyr_struct_t *ps_svc_lyr_dec)
657 {
658 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
659 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
660 dec_pic_params_t *ps_pps;
661 dec_seq_params_t *ps_seq;
662 dec_svc_seq_params_t *ps_subset_seq;
663 dec_slice_params_t *ps_cur_slice = NULL;
664 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
665
666 pocstruct_t s_tmp_poc = {0};
667 WORD32 i_delta_poc[2] = {0};
668 WORD32 i4_poc = 0;
669 UWORD16 u2_first_mb_in_slice, u2_frame_num;
670 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
671 UWORD32 u4_idr_pic_id = 0;
672 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
673
674 UWORD8 u1_nal_unit_type;
675 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
676 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
677 WORD8 i1_is_end_of_poc;
678 WORD32 ret;
679 WORD32 prev_slice_err, num_mb_skipped;
680 UWORD8 u1_mbaff;
681 pocstruct_t *ps_cur_poc;
682 UWORD32 u4_temp;
683 WORD32 i_temp;
684 svc_dec_ctxt_t *psvcd_dec_ctxt;
685 dec_struct_t *ps_dec_cur_lyr_minus_1;
686 svc_dec_lyr_struct_t *ps_svc_cur_lyr_dec_minus_1;
687
688 ps_cur_slice = ps_dec->ps_cur_slice;
689 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
690
691 /* read FirstMbInSlice and slice type*/
692 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
693 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
694 if(u2_first_mb_in_slice > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
695 {
696 return ERROR_CORRUPTED_SLICE;
697 }
698
699 /*we currently don not support ASO*/
700 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
701 (ps_dec->u4_first_slice_in_pic == 0))
702 {
703 return ERROR_CORRUPTED_SLICE;
704 }
705
706 if(ps_dec->u4_first_slice_in_pic == 1)
707 {
708 if(u2_first_mb_in_slice != 0)
709 {
710 return ERROR_CORRUPTED_SLICE;
711 }
712 }
713
714 COPYTHECONTEXT("Slice Header SVC ext: first_mb_in_slice", u2_first_mb_in_slice);
715
716 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
717
718 if(u4_temp > 9) return ERROR_INV_SLC_TYPE_T;
719
720 u1_slice_type = u4_temp;
721 COPYTHECONTEXT("Slice Header SVC ext: slice_type", (u1_slice_type));
722 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
723 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
724 /* will be of same type of current */
725 if(u1_slice_type > 4)
726 {
727 u1_slice_type -= 5;
728 }
729
730 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
731 if(u4_temp & MASK_ERR_PIC_SET_ID) return ERROR_INV_SLICE_HDR_T;
732 /* discard slice if pic param is invalid */
733 COPYTHECONTEXT("Slice Header SVC ext: pic_parameter_set_id", u4_temp);
734 ps_pps = &ps_dec->ps_pps[u4_temp];
735 if(FALSE == ps_pps->u1_is_valid)
736 {
737 return ERROR_INV_SLICE_HDR_T;
738 }
739 /* slices in a layer should have same PPS id*/
740 if(UINT32_MAX == ps_svc_lyr_dec->u4_pps_id_for_layer)
741 {
742 ps_svc_lyr_dec->u4_pps_id_for_layer = u4_temp;
743 }
744 else if(u4_temp != ps_svc_lyr_dec->u4_pps_id_for_layer)
745 {
746 return ERROR_INV_SLICE_HDR_T;
747 }
748 ps_seq = ps_pps->ps_sps;
749 ps_seq += MAX_NUM_SEQ_PARAMS;
750 ps_subset_seq =
751 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
752
753 ps_dec->ps_cur_sps = ps_seq;
754 ps_svc_lyr_dec->ps_cur_subset_sps = ps_subset_seq;
755
756 if(!ps_seq) return ERROR_INV_SLICE_HDR_T;
757 if(FALSE == ps_seq->u1_is_valid) return ERROR_INV_SLICE_HDR_T;
758 if(ps_seq->u1_mb_aff_flag) return ERROR_INV_SLICE_HDR_T;
759 if(ps_seq->u1_level_idc > H264_LEVEL_4_2) return ERROR_INV_SLICE_HDR_T;
760 if(!ps_seq->u1_frame_mbs_only_flag) return ERROR_INV_SLICE_HDR_T;
761 if(OK != isvcd_verify_level(ps_seq->u1_level_idc)) return ERROR_INV_SLICE_HDR_T;
762
763 if(ps_dec->u1_init_dec_flag == 1)
764 {
765 if(ps_dec->u2_frm_wd_in_mbs != ps_seq->u2_frm_wd_in_mbs) return ERROR_INV_SLICE_HDR_T;
766 if(ps_dec->u2_frm_ht_in_mbs != ps_seq->u2_frm_ht_in_mbs) return ERROR_INV_SLICE_HDR_T;
767 }
768
769 if(ps_dec->u1_init_dec_flag == 1)
770 {
771 if(ps_dec->u2_disp_height != ps_subset_seq->u2_disp_height) return ERROR_INV_SLICE_HDR_T;
772 if(ps_dec->u2_disp_width != ps_subset_seq->u2_disp_width) return ERROR_INV_SLICE_HDR_T;
773 }
774
775 ps_dec->i4_reorder_depth = ps_subset_seq->i4_reorder_depth;
776
777 ps_dec->u2_disp_height = ps_subset_seq->u2_disp_height;
778 ps_dec->u2_disp_width = ps_subset_seq->u2_disp_width;
779
780 if(ps_svc_lyr_dec->u1_layer_id > 0)
781 {
782 psvcd_dec_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
783 ps_svc_cur_lyr_dec_minus_1 =
784 &psvcd_dec_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_layer_id - 1];
785
786 ps_dec_cur_lyr_minus_1 = &ps_svc_cur_lyr_dec_minus_1->s_dec;
787
788 if((ps_dec_cur_lyr_minus_1->u2_pic_wd > ps_subset_seq->u2_pic_wd) ||
789 (ps_dec_cur_lyr_minus_1->u2_pic_ht > ps_subset_seq->u2_pic_ht))
790 {
791 return ERROR_CORRUPTED_SLICE;
792 }
793 }
794
795 ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
796 ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
797 ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
798
799 /* Determining the Width and Height of Frame from that of Picture */
800 ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
801 ps_dec->u2_frm_ht_y = ps_subset_seq->u2_frm_ht_y;
802
803 ps_dec->u2_frm_wd_uv = ps_subset_seq->u2_frm_wd_uv;
804 ps_dec->u2_frm_ht_uv = ps_subset_seq->u2_frm_ht_uv;
805
806 ps_dec->s_pad_mgr.u1_pad_len_y_v = ps_subset_seq->u1_pad_len_y_v;
807 ps_dec->s_pad_mgr.u1_pad_len_cr_v = ps_subset_seq->u1_pad_len_cr_v;
808
809 ps_dec->u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
810 ps_dec->u2_frm_ht_in_mbs = ps_seq->u2_frm_ht_in_mbs;
811
812 ps_dec->u2_crop_offset_y = ps_subset_seq->u2_crop_offset_y;
813 ps_dec->u2_crop_offset_uv = ps_subset_seq->u2_crop_offset_uv;
814
815 /* Get the frame num */
816 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_bits_in_frm_num);
817
818 COPYTHECONTEXT("Slice Header SVC ext: frame_num", u2_frame_num);
819 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
820 {
821 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
822 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
823
824 ps_dec->u2_mbx = 0xffff;
825 ps_dec->u2_mby = 0;
826
827 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
828 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
829
830 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) ps_dec->u2_prev_ref_frame_num = 0;
831
832 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
833 {
834 isvcd_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
835 }
836
837 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
838 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
839 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
840 if(ps_cur_slice->u1_nal_ref_idc)
841 {
842 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
843 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
844 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
845 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
846 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
847 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
848 }
849
850 ps_dec->u2_total_mbs_coded = 0;
851 }
852 /* Get the field related flags */
853 if(!ps_seq->u1_frame_mbs_only_flag)
854 {
855 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
856 COPYTHECONTEXT("Slice Header SVC ext: field_pic_flag", u1_field_pic_flag);
857 u1_bottom_field_flag = 0;
858
859 if(u1_field_pic_flag)
860 {
861 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan_fld;
862 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
863 COPYTHECONTEXT("Slice Header SVC ext: bottom_field_flag", u1_bottom_field_flag);
864 }
865 else
866 {
867 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
868 }
869 }
870 else
871 {
872 u1_field_pic_flag = 0;
873 u1_bottom_field_flag = 0;
874 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
875 }
876
877 u1_nal_unit_type = SLICE_NAL;
878 if(u1_is_idr_slice)
879 {
880 u1_nal_unit_type = IDR_SLICE_NAL;
881 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
882 if(u4_idr_pic_id > 65535) return ERROR_INV_SLICE_HDR_T;
883 COPYTHECONTEXT("Slice Header SVC ext: ", u4_idr_pic_id);
884 }
885
886 /* read delta pic order count information*/
887 i_delta_poc[0] = i_delta_poc[1] = 0;
888 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
889 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
890 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
891 if(u1_pic_order_cnt_type == 0)
892 {
893 i_temp = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
894 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) return ERROR_INV_SLICE_HDR_T;
895 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
896 COPYTHECONTEXT("Slice Header SVC ext: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
897
898 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
899 {
900 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
901 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt_bottom",
902 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
903 }
904 }
905
906 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
907 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
908 if(u1_pic_order_cnt_type == 1 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
909 {
910 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
911 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt[0]",
912 s_tmp_poc.i4_delta_pic_order_cnt[0]);
913
914 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
915 {
916 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
917 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt[1]",
918 s_tmp_poc.i4_delta_pic_order_cnt[1]);
919 }
920 }
921
922 if(ps_pps->u1_redundant_pic_cnt_present_flag)
923 {
924 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
925 if(u4_temp > MAX_REDUNDANT_PIC_CNT) return ERROR_INV_SLICE_HDR_T;
926 u1_redundant_pic_cnt = u4_temp;
927 COPYTHECONTEXT("Slice Header SVC ext: redundant_pic_cnt", u1_redundant_pic_cnt);
928 }
929
930 /*--------------------------------------------------------------------*/
931 /* Check if the slice is part of new picture */
932 /*--------------------------------------------------------------------*/
933 /* First slice of a picture is always considered as part of new picture */
934 i1_is_end_of_poc = 1;
935 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
936
937 if(ps_dec->u4_first_slice_in_pic == 0)
938 {
939 i1_is_end_of_poc =
940 ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, &s_tmp_poc, &ps_dec->s_cur_pic_poc,
941 ps_cur_slice, u1_pic_order_cnt_type, u1_nal_unit_type,
942 u4_idr_pic_id, u1_field_pic_flag, u1_bottom_field_flag);
943 if(i1_is_end_of_poc)
944 {
945 ps_dec->u1_first_slice_in_stream = 0;
946 return ERROR_INCOMPLETE_FRAME;
947 }
948 }
949
950 /*--------------------------------------------------------------------*/
951 /* Check for error in slice and parse the missing/corrupted MB's */
952 /* as skip-MB's in an inserted P-slice */
953 /*--------------------------------------------------------------------*/
954 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
955 prev_slice_err = 0;
956
957 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
958 {
959 /* If the current slice is not a field or frame number of the current
960 * slice doesn't match with previous slice, and decoder is expecting
961 * to decode a field i.e. ps_dec->u1_top_bottom_decoded is not 0 and
962 * is not (TOP_FIELD_ONLY | BOT_FIELD_ONLY), treat it as a dangling
963 * field */
964 if((u1_field_pic_flag == 0 || u2_frame_num != ps_dec->u2_prv_frame_num) &&
965 ps_dec->u1_top_bottom_decoded != 0 &&
966 ps_dec->u1_top_bottom_decoded != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
967 {
968 ps_dec->u1_dangling_field = 1;
969 if(ps_dec->u4_first_slice_in_pic)
970 {
971 // first slice - dangling field
972 prev_slice_err = 1;
973 }
974 else
975 {
976 // last slice - dangling field
977 prev_slice_err = 2;
978 }
979
980 if(ps_dec->u1_top_bottom_decoded == TOP_FIELD_ONLY)
981 ps_cur_slice->u1_bottom_field_flag = 1;
982 else
983 ps_cur_slice->u1_bottom_field_flag = 0;
984
985 num_mb_skipped =
986 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
987 ps_cur_poc = &ps_dec->s_cur_pic_poc;
988
989 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
990 }
991 else if(ps_dec->u4_first_slice_in_pic)
992 {
993 if(u2_first_mb_in_slice > 0)
994 {
995 // first slice - missing/header corruption
996 prev_slice_err = 1;
997 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
998 ps_cur_poc = &s_tmp_poc;
999
1000 // initializing slice parameters
1001 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1002 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1003 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1004 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1005 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1006 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1007 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1008 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1009 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
1010 }
1011 }
1012 else
1013 {
1014 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so
1015 * conceal the current frame completely */
1016 prev_slice_err = 2;
1017 num_mb_skipped =
1018 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
1019 ps_cur_poc = &s_tmp_poc;
1020 }
1021 }
1022 else
1023 {
1024 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
1025 {
1026 // previous slice - missing/corruption
1027 prev_slice_err = 2;
1028 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
1029 ps_cur_poc = &s_tmp_poc;
1030 }
1031 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
1032 {
1033 return ERROR_CORRUPTED_SLICE;
1034 }
1035 }
1036 if(prev_slice_err)
1037 {
1038 ret = isvcd_mark_err_slice_skip((svc_dec_lyr_struct_t *) ps_dec, num_mb_skipped,
1039 u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
1040
1041 if(ps_dec->u1_dangling_field == 1)
1042 {
1043 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
1044 ps_dec->u1_first_slice_in_stream = 0;
1045 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;
1046 return ERROR_DANGLING_FIELD_IN_PIC;
1047 }
1048
1049 if(prev_slice_err == 2)
1050 {
1051 ps_dec->u1_first_slice_in_stream = 0;
1052 return ERROR_INCOMPLETE_FRAME;
1053 }
1054
1055 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1056 {
1057 /* return if all MBs in frame are parsed*/
1058 ps_dec->u1_first_slice_in_stream = 0;
1059 return ERROR_IN_LAST_SLICE_OF_PIC;
1060 }
1061
1062 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1063 {
1064 ih264d_err_pic_dispbuf_mgr(ps_dec);
1065 return ERROR_NEW_FRAME_EXPECTED;
1066 }
1067
1068 if(ret != OK) return ret;
1069
1070 i1_is_end_of_poc = 0;
1071 }
1072
1073 if(u1_field_pic_flag)
1074 {
1075 ps_dec->u2_prv_frame_num = u2_frame_num;
1076 }
1077
1078 if(ps_cur_slice->u1_mmco_equalto5)
1079 {
1080 WORD32 i4_temp_poc;
1081 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
1082 WORD64 i8_result;
1083 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair
1084 {
1085 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1086 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1087 i4_temp_poc = MIN(i4_top_field_order_poc, i4_bot_field_order_poc);
1088 }
1089 else if(!ps_cur_slice->u1_bottom_field_flag)
1090 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1091 else
1092 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1093
1094 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1095 if(IS_OUT_OF_RANGE_S32(i8_result))
1096 {
1097 return ERROR_INV_POC;
1098 }
1099 ps_dec->ps_cur_pic->i4_top_field_order_cnt = (WORD32) i8_result;
1100 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1101 if(IS_OUT_OF_RANGE_S32(i8_result))
1102 {
1103 return ERROR_INV_POC;
1104 }
1105 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = (WORD32) i8_result;
1106 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
1107 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
1108 }
1109 if(ps_dec->u4_first_slice_in_pic)
1110 {
1111 ret = isvcd_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, &ps_dec->s_prev_pic_poc,
1112 &s_tmp_poc, ps_cur_slice, ps_pps, u1_nal_ref_idc,
1113 u1_bottom_field_flag, u1_field_pic_flag, &i4_poc, ps_dec);
1114 if(ret != OK) return ret;
1115 /* Display seq no calculations */
1116 if(i4_poc >= ps_dec->i4_max_poc) ps_dec->i4_max_poc = i4_poc;
1117 /* IDR Picture or POC wrap around */
1118 if(i4_poc == 0)
1119 {
1120 WORD64 i8_temp;
1121 i8_temp = (WORD64) ps_dec->i4_prev_max_display_seq + ps_dec->i4_max_poc +
1122 ps_dec->u1_max_dec_frame_buffering + 1;
1123 /*If i4_prev_max_display_seq overflows integer range, reset it */
1124 ps_dec->i4_prev_max_display_seq = IS_OUT_OF_RANGE_S32(i8_temp) ? 0 : i8_temp;
1125 ps_dec->i4_max_poc = 0;
1126 }
1127 }
1128
1129 /* Increment only if the current slice has atleast 1 more MB */
1130 if(ps_dec->u4_first_slice_in_pic == 0 &&
1131 (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
1132 (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
1133 {
1134 ps_dec->ps_parse_cur_slice++;
1135 ps_dec->u2_cur_slice_num++;
1136 // in the case of single core increment ps_decode_cur_slice
1137 if(ps_dec->u1_separate_parse == 0)
1138 {
1139 ps_dec->ps_decode_cur_slice++;
1140 }
1141 }
1142
1143 ps_dec->u1_slice_header_done = 0;
1144
1145 /*--------------------------------------------------------------------*/
1146 /* Copy the values read from the bitstream to the slice header and then*/
1147 /* If the slice is first slice in picture, then do Start of Picture */
1148 /* processing. */
1149 /*--------------------------------------------------------------------*/
1150 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
1151 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
1152 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1153 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
1154 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1155 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1156 ps_cur_slice->u1_slice_type = u1_slice_type;
1157 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1158
1159 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1160 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1161 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1162 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1163
1164 if(ps_seq->u1_frame_mbs_only_flag)
1165 ps_cur_slice->u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
1166 else
1167 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
1168
1169 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1170 {
1171 if(B_SLICE == u1_slice_type)
1172 {
1173 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(ps_bitstrm);
1174 COPYTHECONTEXT("Slice Header SVC ext: direct_spatial_mv_pred_flag",
1175 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
1176
1177 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
1178 ps_cur_slice->pf_decodeDirect = isvcd_decode_spatial_direct;
1179 else
1180 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
1181 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1182 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
1183 }
1184 else
1185 {
1186 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag))) /*check if this is valid here */
1187 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1188 }
1189 }
1190
1191 if(ps_dec->u4_first_slice_in_pic)
1192 {
1193 if(u2_first_mb_in_slice == 0)
1194 {
1195 ret = isvcd_start_of_pic(ps_svc_lyr_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
1196 if(ret != OK) return ret;
1197 /*inter layer buffer intialization */
1198 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
1199 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start;
1200 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_cur_mb =
1201 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base;
1202 }
1203
1204 ps_dec->u4_output_present = 0;
1205
1206 {
1207 ih264d_get_next_display_field(ps_dec, ps_dec->ps_out_buffer, &(ps_dec->s_disp_op));
1208 /* If error code is non-zero then there is no buffer available for
1209 display, hence avoid format conversion */
1210
1211 if(0 != ps_dec->s_disp_op.u4_error_code)
1212 {
1213 ps_dec->u4_output_present = 0;
1214 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1215 }
1216 else
1217 ps_dec->u4_output_present = 1;
1218 }
1219 ret = isvcd_parse_interlayer_resamp_func_init(ps_svc_lyr_dec, u2_first_mb_in_slice);
1220 if(ret != OK)
1221 {
1222 return ERROR_CORRUPTED_SLICE;
1223 }
1224 if((ps_dec->u1_separate_parse == 1) &&
1225 (ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER) && (ps_svc_lyr_dec->u1_res_init_done == 1))
1226 {
1227 if(ps_dec->u4_dec_thread_created == 0)
1228 {
1229 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1230 (void *) isvcd_decode_picture_thread, (void *) ps_dec);
1231
1232 ps_dec->u4_dec_thread_created = 1;
1233 }
1234 #ifdef KEEP_THREADS_ACTIVE
1235 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
1236 RETURN_IF((ret != IV_SUCCESS), ret);
1237
1238 ps_dec->ai4_process_start[0] = PROC_START;
1239 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
1240 RETURN_IF((ret != IV_SUCCESS), ret);
1241
1242 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
1243 RETURN_IF((ret != IV_SUCCESS), ret);
1244 #endif
1245 #ifdef KEEP_THREADS_ACTIVE
1246 if(ps_dec->u4_bs_deblk_thread_created)
1247 {
1248 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
1249 RETURN_IF((ret != IV_SUCCESS), ret);
1250
1251 ps_dec->ai4_process_start[1] = PROC_START;
1252 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
1253 RETURN_IF((ret != IV_SUCCESS), ret);
1254
1255 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
1256 RETURN_IF((ret != IV_SUCCESS), ret);
1257 }
1258 #endif
1259 }
1260 }
1261
1262 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
1263 {
1264 UWORD8 uc_nofield_nombaff;
1265
1266 uc_nofield_nombaff =
1267 ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) &&
1268 (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) && (u1_slice_type != B_SLICE) &&
1269 (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
1270
1271 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
1272
1273 if(uc_nofield_nombaff)
1274 {
1275 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1276 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1277 }
1278 else
1279 {
1280 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
1281 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
1282 }
1283 }
1284
1285 /*
1286 * Decide whether to decode the current picture or not
1287 */
1288 {
1289 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
1290 if(ps_err->u4_frm_sei_sync == u2_frame_num)
1291 {
1292 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1293 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
1294 }
1295 ps_err->u4_cur_frm = u2_frame_num;
1296 }
1297
1298 /* Decision for decoding if the picture is to be skipped */
1299 {
1300 WORD32 i4_skip_b_pic, i4_skip_p_pic;
1301
1302 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) && (B_SLICE == u1_slice_type) &&
1303 (0 == u1_nal_ref_idc);
1304
1305 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) && (P_SLICE == u1_slice_type) &&
1306 (0 == u1_nal_ref_idc);
1307
1308 /**************************************************************/
1309 /* Skip the B picture if skip mask is set for B picture and */
1310 /* Current B picture is a non reference B picture or there is */
1311 /* no user for reference B picture */
1312 /**************************************************************/
1313 if(i4_skip_b_pic)
1314 {
1315 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1316 /* Don't decode the picture in SKIP-B mode if that picture is B */
1317 /* and also it is not to be used as a reference picture */
1318 ps_dec->u1_last_pic_not_decoded = 1;
1319
1320 return OK;
1321 }
1322 /**************************************************************/
1323 /* Skip the P picture if skip mask is set for P picture and */
1324 /* Current P picture is a non reference P picture or there is */
1325 /* no user for reference P picture */
1326 /**************************************************************/
1327 if(i4_skip_p_pic)
1328 {
1329 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1330 /* Don't decode the picture in SKIP-P mode if that picture is P */
1331 /* and also it is not to be used as a reference picture */
1332 ps_dec->u1_last_pic_not_decoded = 1;
1333
1334 return OK;
1335 }
1336 }
1337
1338 {
1339 UWORD16 u2_mb_x, u2_mb_y;
1340
1341 ps_dec->i4_submb_ofst =
1342 ((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) -
1343 SUB_BLK_SIZE;
1344 if(u2_first_mb_in_slice)
1345 {
1346 UWORD8 u1_mb_aff;
1347 UWORD8 u1_field_pic;
1348 UWORD16 u2_frm_wd_in_mbs;
1349 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
1350 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
1351 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
1352
1353 {
1354 UWORD32 x_offset;
1355 UWORD32 y_offset;
1356 UWORD32 u4_frame_stride;
1357 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse;
1358
1359 if(ps_dec->u1_separate_parse)
1360 {
1361 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1362 }
1363 else
1364 {
1365 ps_trns_addr = &ps_dec->s_tran_addrecon;
1366 }
1367 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1368 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1369
1370 u2_mb_y <<= u1_mb_aff;
1371
1372 if((u2_mb_x > u2_frm_wd_in_mbs - 1) || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
1373 {
1374 return ERROR_CORRUPTED_SLICE;
1375 }
1376
1377 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
1378 x_offset = u2_mb_x << 4;
1379 y_offset = (u2_mb_y * u4_frame_stride) << 4;
1380
1381 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset + y_offset;
1382
1383 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
1384 x_offset >>= 1;
1385 y_offset = (u2_mb_y * u4_frame_stride) << 3;
1386
1387 x_offset *= YUV420SP_FACTOR;
1388
1389 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset + y_offset;
1390 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset + y_offset;
1391
1392 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1393 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1394 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1395
1396 // assign the deblock structure pointers to start of slice
1397 if(ps_dec->u1_separate_parse == 1)
1398 {
1399 ps_dec->ps_deblk_mbn =
1400 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
1401 }
1402 else
1403 {
1404 ps_dec->ps_deblk_mbn =
1405 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
1406 }
1407
1408 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
1409
1410 ps_dec->ps_mv_cur =
1411 ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
1412 }
1413 }
1414 else
1415 {
1416 tfr_ctxt_t *ps_trns_addr;
1417
1418 if(ps_dec->u1_separate_parse)
1419 {
1420 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1421 }
1422 else
1423 {
1424 ps_trns_addr = &ps_dec->s_tran_addrecon;
1425 }
1426
1427 u2_mb_x = 0xffff;
1428 u2_mb_y = 0;
1429 // assign the deblock structure pointers to start of slice
1430 ps_dec->u2_cur_mb_addr = 0;
1431 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
1432 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
1433 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
1434 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
1435 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
1436
1437 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1438 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1439 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1440 }
1441
1442 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1443
1444 ps_dec->u2_mbx = (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1445 ps_dec->u2_mby = (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1446 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
1447 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1448 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1449 }
1450
1451 /* RBSP stop bit is used for CABAC decoding*/
1452 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
1453
1454 ps_dec->u1_B = (u1_slice_type == B_SLICE);
1455 ps_dec->u4_next_mb_skip = 0;
1456
1457 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->ps_cur_slice->u2_first_mb_in_slice;
1458 ps_dec->ps_parse_cur_slice->slice_type = ps_dec->ps_cur_slice->u1_slice_type;
1459
1460 ps_dec->u4_start_recon_deblk = 1;
1461 {
1462 WORD32 num_entries;
1463 WORD32 size;
1464 UWORD8 *pu1_buf;
1465
1466 num_entries = MAX_FRAMES;
1467 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
1468 {
1469 num_entries = 1;
1470 }
1471 num_entries = ((2 * num_entries) + 1);
1472 num_entries *= 2;
1473
1474 size = num_entries * sizeof(void *);
1475 size += PAD_MAP_IDX_POC * sizeof(void *);
1476
1477 pu1_buf = (UWORD8 *) ps_dec->pv_map_ref_idx_to_poc_buf;
1478 pu1_buf += size * ps_dec->u2_cur_slice_num;
1479 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (void *) pu1_buf;
1480 }
1481
1482 if(ps_dec->u1_separate_parse)
1483 {
1484 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1485 }
1486 else
1487 {
1488 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1489 }
1490
1491 ret = ih264d_fix_error_in_dpb(ps_dec);
1492 if(ret < 0) return ERROR_DBP_MANAGER_T;
1493
1494 /*Default initializing default values for some parameters*/
1495 ps_svc_slice_params->u1_slice_skip_flag = 0;
1496 ps_svc_slice_params->u1_adaptive_base_mode_flag = 0;
1497 ps_svc_slice_params->u1_default_base_mode_flag = 0;
1498 ps_svc_slice_params->u1_adaptive_motion_prediction_flag = 0;
1499 ps_svc_slice_params->u1_default_motion_prediction_flag = 0;
1500 ps_svc_slice_params->u1_adaptive_residual_prediction_flag = 0;
1501 ps_svc_slice_params->u1_default_residual_prediction_flag = 0;
1502
1503 if(u1_slice_type == I_SLICE)
1504 {
1505 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
1506
1507 ret = isvcd_parse_eislice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1508 ps_dec->u1_pr_sl_type = u1_slice_type;
1509 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
1510 ps_dec->i4_pic_type = I_SLICE;
1511 }
1512 else if(u1_slice_type == P_SLICE)
1513 {
1514 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1515 ret = isvcd_parse_epslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1516 ps_dec->u1_pr_sl_type = u1_slice_type;
1517 if(ps_dec->i4_pic_type != B_SLICE) ps_dec->i4_pic_type = P_SLICE;
1518 }
1519 else if(u1_slice_type == B_SLICE)
1520 {
1521 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1522 ret = isvcd_parse_ebslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1523 ps_dec->u1_pr_sl_type = u1_slice_type;
1524 ps_dec->i4_pic_type = B_SLICE;
1525 }
1526 else
1527 return ERROR_INV_SLC_TYPE_T;
1528
1529 if(ps_dec->u1_slice_header_done)
1530 {
1531 /* set to zero to indicate a valid slice has been decoded */
1532 ps_dec->u1_first_slice_in_stream = 0;
1533 }
1534
1535 if(ret != OK) return ret;
1536
1537 if(u1_nal_ref_idc != 0)
1538 {
1539 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
1540 {
1541 memcpy((void *) ps_dec->ps_dpb_cmds, (void *) (&(ps_dec->s_dpb_cmds_scratch)),
1542 sizeof(dpb_commands_t));
1543 }
1544 }
1545
1546 /* storing last Mb X and MbY of the slice */
1547 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1548 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1549
1550 /* End of Picture detection */
1551 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
1552 {
1553 ps_dec->u1_pic_decode_done = 1;
1554 }
1555
1556 {
1557 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
1558 if((ps_err->u1_err_flag & REJECT_PB_PICS) && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1559 {
1560 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1561 }
1562 }
1563
1564 PRINT_BIN_BIT_RATIO(ps_dec)
1565
1566 return ret;
1567 }
1568
1569 /*!
1570 **************************************************************************
1571 * \if Function name : isvcd_set_default_slice_header_ext \endif
1572 *
1573 * \brief
1574 * sets the default values for the svc slice header attr
1575 *
1576 * \return
1577 * 0 on Success and Error code otherwise
1578 **************************************************************************
1579 */
isvcd_set_default_slice_header_ext(svc_dec_lyr_struct_t * ps_svc_lyr_dec)1580 WORD32 isvcd_set_default_slice_header_ext(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
1581 {
1582 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1583 WORD32 i_status = OK;
1584 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
1585 dec_seq_params_t *ps_seq;
1586 dec_svc_seq_params_t *ps_subset_seq;
1587 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1588 dec_subset_seq_params_t *ps_sps_svc_ext = NULL;
1589 ps_seq = ps_pps->ps_sps;
1590 ps_seq += MAX_NUM_SEQ_PARAMS;
1591 ps_subset_seq =
1592 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
1593 ps_sps_svc_ext = &ps_subset_seq->s_sps_svc_ext;
1594 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1595
1596 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1597 {
1598 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1599 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_y_plus1;
1600
1601 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag =
1602 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_x_plus1_flag;
1603 }
1604
1605 ps_svc_slice_params->u4_ref_layer_dq_id = UINT32_MAX;
1606 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc = 0;
1607 ps_svc_slice_params->u1_scan_idx_start = 0;
1608 ps_svc_slice_params->u1_scan_idx_end = 15;
1609 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 = 0;
1610 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 = 0;
1611 ps_svc_slice_params->u1_constrained_intra_resampling_flag = 0;
1612
1613 return i_status;
1614 }
1615
1616 /*!
1617 **************************************************************************
1618 * \if Function name : isvcd_parse_slice_header \endif
1619 *
1620 * \brief
1621 * parses the svc slice header attr
1622 *
1623 * \return
1624 * 0 on Success and Error code otherwise
1625 **************************************************************************
1626 */
isvcd_parse_slice_header(svc_dec_lyr_struct_t * ps_svc_lyr_dec)1627 WORD32 isvcd_parse_slice_header(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
1628 {
1629 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1630 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
1631 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1632 dec_seq_params_t *ps_seq;
1633 dec_svc_seq_params_t *ps_subset_seq;
1634 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1635 dec_subset_seq_params_t *ps_sps_svc_ext = NULL;
1636 svc_dec_ctxt_t *ps_svcd_ctxt;
1637 UWORD32 *pu4_bitstrm_buf = ps_dec->ps_bitstrm->pu4_buffer;
1638 UWORD32 *pu4_bitstrm_ofst = &ps_dec->ps_bitstrm->u4_ofst;
1639 ps_svcd_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
1640 ps_seq = ps_pps->ps_sps;
1641 ps_seq += MAX_NUM_SEQ_PARAMS;
1642 ps_subset_seq =
1643 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
1644 ps_sps_svc_ext = &ps_subset_seq->s_sps_svc_ext;
1645 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1646
1647 if(!ps_svc_lyr_dec->ps_nal_svc_ext->u1_no_inter_layer_pred_flag &&
1648 (0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id))
1649 {
1650 ps_svc_slice_params->u4_ref_layer_dq_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1651 COPYTHECONTEXT("Slice Header SVC ext: u4_ref_layer_dq_id",
1652 ps_svc_slice_params->u4_ref_layer_dq_id);
1653 if(ps_svc_slice_params->u4_ref_layer_dq_id > MAX_REF_DEP_ID)
1654 {
1655 return ERROR_INV_SLICE_HDR_T;
1656 }
1657 /* Reference layer id update is taken care during resolution init */
1658 /*
1659 ps_svc_lyr_dec->u1_ref_layer_id = ps_svc_slice_params->u4_ref_layer_dq_id >> 4;
1660 if(ps_svc_lyr_dec->u1_ref_layer_id >= ps_svc_lyr_dec->u1_layer_id)
1661 {
1662 return ERROR_INV_SLICE_HDR_T;
1663 }
1664 */
1665 ps_svc_lyr_dec->ps_dec_svc_ref_layer =
1666 &ps_svcd_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_ref_layer_id];
1667
1668 if(ps_sps_svc_ext->u1_inter_layer_deblocking_filter_control_present_flag)
1669 {
1670 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc =
1671 ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1672 COPYTHECONTEXT("Slice Header SVC ext: u4_disable_inter_layer_deblk_filter_idc",
1673 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc);
1674
1675 if(ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc > 6)
1676 {
1677 return ERROR_INV_SLICE_HDR_T;
1678 }
1679
1680 if(1 != ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc)
1681 {
1682 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 =
1683 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1684 COPYTHECONTEXT("Slice Header SVC ext: i4_inter_layer_slice_alpha_c0_offset_div2",
1685 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2);
1686
1687 if(ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 > 6 ||
1688 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 < -6)
1689 {
1690 return ERROR_INV_SLICE_HDR_T;
1691 }
1692
1693 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 =
1694 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1695 COPYTHECONTEXT("Slice Header SVC ext: i4_inter_layer_slice_beta_offset_div2",
1696 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2);
1697
1698 if(ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 > 6 ||
1699 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 < -6)
1700 {
1701 return ERROR_INV_SLICE_HDR_T;
1702 }
1703 }
1704 }
1705
1706 ps_svc_slice_params->u1_constrained_intra_resampling_flag = ih264d_get_bit_h264(ps_bitstrm);
1707 COPYTHECONTEXT("Slice Header SVC ext: u1_constrained_intra_resampling_flag",
1708 ps_svc_slice_params->u1_constrained_intra_resampling_flag);
1709
1710 ps_svc_lyr_dec->s_res_prms.i1_constrained_intra_rsmpl_flag =
1711 ps_svc_lyr_dec->s_svc_slice_params.u1_constrained_intra_resampling_flag;
1712 isvcd_intra_resamp_res_init_update_flags(ps_svc_lyr_dec);
1713
1714 if(2 == ps_sps_svc_ext->u1_extended_spatial_scalability_idc)
1715 {
1716 /* ChromaArrayType = i4_chroma_format_idc if separate_colour_plane_flag
1717 * = 0 for all chroma format except 4:4:4 */
1718 if(ps_dec->ps_cur_sps->i4_chroma_format_idc >= 0)
1719 {
1720 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag =
1721 ih264d_get_bit_h264(ps_bitstrm);
1722 COPYTHECONTEXT("Slice Header SVC ext: u1_ref_layer_chroma_phase_x_plus1_flag",
1723 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag);
1724
1725 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1726 ih264d_get_bits_h264(ps_bitstrm, 2);
1727 COPYTHECONTEXT("Slice Header SVC ext: u1_ref_layer_chroma_phase_y_plus1",
1728 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1);
1729
1730 if(ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 > 2)
1731 {
1732 return ERROR_INV_SLICE_HDR_T;
1733 }
1734 }
1735 else
1736 {
1737 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1738 {
1739 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1740 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_y_plus1;
1741 }
1742 }
1743
1744 ps_svc_slice_params->i4_scaled_ref_layer_left_offset =
1745 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1746 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_left_offset",
1747 ps_svc_slice_params->i4_scaled_ref_layer_left_offset);
1748
1749 if(ps_svc_slice_params->i4_scaled_ref_layer_left_offset != 0)
1750 {
1751 return ERROR_INV_SLICE_HDR_T;
1752 }
1753
1754 if(ps_svc_slice_params->i4_scaled_ref_layer_left_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1755 ps_svc_slice_params->i4_scaled_ref_layer_left_offset < MIN_SCLD_REF_LAYER_OFFSET)
1756 {
1757 return ERROR_INV_SLICE_HDR_T;
1758 }
1759
1760 ps_svc_slice_params->i4_scaled_ref_layer_top_offset =
1761 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1762 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_top_offset",
1763 ps_svc_slice_params->i4_scaled_ref_layer_top_offset);
1764
1765 if(ps_svc_slice_params->i4_scaled_ref_layer_top_offset != 0)
1766 {
1767 return ERROR_INV_SLICE_HDR_T;
1768 }
1769
1770 if(ps_svc_slice_params->i4_scaled_ref_layer_top_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1771 ps_svc_slice_params->i4_scaled_ref_layer_top_offset < MIN_SCLD_REF_LAYER_OFFSET)
1772 {
1773 return ERROR_INV_SLICE_HDR_T;
1774 }
1775
1776 ps_svc_slice_params->i4_scaled_ref_layer_right_offset =
1777 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1778 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_right_offset",
1779 ps_svc_slice_params->i4_scaled_ref_layer_right_offset);
1780
1781 if(ps_svc_slice_params->i4_scaled_ref_layer_right_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1782 ps_svc_slice_params->i4_scaled_ref_layer_right_offset < MIN_SCLD_REF_LAYER_OFFSET)
1783 {
1784 return ERROR_INV_SLICE_HDR_T;
1785 }
1786
1787 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset =
1788 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1789 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_bottom_offset",
1790 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset);
1791
1792 if(ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset >=
1793 MAX_SCLD_REF_LAYER_OFFSET ||
1794 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset < MIN_SCLD_REF_LAYER_OFFSET)
1795 {
1796 return ERROR_INV_SLICE_HDR_T;
1797 }
1798 }
1799 else
1800 {
1801 ps_svc_slice_params->i4_scaled_ref_layer_left_offset =
1802 ps_sps_svc_ext->i4_seq_scaled_ref_layer_left_offset;
1803 ps_svc_slice_params->i4_scaled_ref_layer_top_offset =
1804 ps_sps_svc_ext->i4_seq_scaled_ref_layer_top_offset;
1805 ps_svc_slice_params->i4_scaled_ref_layer_right_offset =
1806 ps_sps_svc_ext->i4_seq_scaled_ref_layer_right_offset;
1807 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset =
1808 ps_sps_svc_ext->i4_seq_scaled_ref_layer_bottom_offset;
1809 }
1810 }
1811
1812 if(!ps_svc_lyr_dec->ps_nal_svc_ext->u1_no_inter_layer_pred_flag)
1813 {
1814 ps_svc_slice_params->u1_slice_skip_flag = ih264d_get_bit_h264(ps_bitstrm);
1815 COPYTHECONTEXT("Slice Header SVC ext: u1_slice_skip_flag",
1816 ps_svc_slice_params->u1_slice_skip_flag);
1817
1818 if(ps_svc_slice_params->u1_slice_skip_flag)
1819 {
1820 ps_svc_slice_params->u4_num_mbs_in_slice_minus1 =
1821 ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1822 COPYTHECONTEXT("Slice Header SVC ext: u4_num_mbs_in_slice_minus1",
1823 ps_svc_slice_params->u4_num_mbs_in_slice_minus1);
1824 }
1825 else
1826 {
1827 ps_svc_slice_params->u1_adaptive_base_mode_flag = ih264d_get_bit_h264(ps_bitstrm);
1828 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_base_mode_flag",
1829 ps_svc_slice_params->u1_adaptive_base_mode_flag);
1830
1831 if(!ps_svc_slice_params->u1_adaptive_base_mode_flag)
1832 {
1833 ps_svc_slice_params->u1_default_base_mode_flag = ih264d_get_bit_h264(ps_bitstrm);
1834 COPYTHECONTEXT("Slice Header SVC ext: u1_default_base_mode_flag",
1835 ps_svc_slice_params->u1_default_base_mode_flag);
1836 }
1837 if(!ps_svc_slice_params->u1_default_base_mode_flag)
1838 {
1839 ps_svc_slice_params->u1_adaptive_motion_prediction_flag =
1840 ih264d_get_bit_h264(ps_bitstrm);
1841 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_motion_prediction_flag",
1842 ps_svc_slice_params->u1_adaptive_motion_prediction_flag);
1843
1844 if(!ps_svc_slice_params->u1_adaptive_motion_prediction_flag)
1845 {
1846 ps_svc_slice_params->u1_default_motion_prediction_flag =
1847 ih264d_get_bit_h264(ps_bitstrm);
1848 COPYTHECONTEXT("Slice Header SVC ext: u1_default_motion_prediction_flag",
1849 ps_svc_slice_params->u1_default_motion_prediction_flag);
1850 }
1851 }
1852 ps_svc_slice_params->u1_adaptive_residual_prediction_flag =
1853 ih264d_get_bit_h264(ps_bitstrm);
1854 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_residual_prediction_flag",
1855 ps_svc_slice_params->u1_adaptive_residual_prediction_flag);
1856
1857 if(!ps_svc_slice_params->u1_adaptive_residual_prediction_flag)
1858 {
1859 ps_svc_slice_params->u1_default_residual_prediction_flag =
1860 ih264d_get_bit_h264(ps_bitstrm);
1861 COPYTHECONTEXT("Slice Header SVC ext: u1_default_residual_prediction_flag",
1862 ps_svc_slice_params->u1_default_residual_prediction_flag);
1863 }
1864 }
1865
1866 if(ps_sps_svc_ext->u1_adaptive_tcoeff_level_prediction_flag)
1867 {
1868 ps_svc_slice_params->u1_tcoeff_level_prediction_flag = ih264d_get_bit_h264(ps_bitstrm);
1869 COPYTHECONTEXT("Slice Header SVC ext: u1_tcoeff_level_prediction_flag",
1870 ps_svc_slice_params->u1_tcoeff_level_prediction_flag);
1871
1872 if(ps_svc_slice_params->u1_tcoeff_level_prediction_flag != 0)
1873 {
1874 return ERROR_INV_SPS_PPS_T;
1875 }
1876 }
1877 }
1878
1879 if(!ps_sps_svc_ext->u1_slice_header_restriction_flag &&
1880 !ps_svc_slice_params->u1_slice_skip_flag)
1881 {
1882 ps_svc_slice_params->u1_scan_idx_start = ih264d_get_bits_h264(ps_bitstrm, 4);
1883 COPYTHECONTEXT("Slice Header SVC ext: u1_scan_idx_start",
1884 ps_svc_slice_params->u1_scan_idx_start);
1885 ps_svc_slice_params->u1_scan_idx_end = ih264d_get_bits_h264(ps_bitstrm, 4);
1886 COPYTHECONTEXT("Slice Header SVC ext: u1_scan_idx_end",
1887 ps_svc_slice_params->u1_scan_idx_end);
1888
1889 if(0 != ps_svc_slice_params->u1_scan_idx_start &&
1890 15 != ps_svc_slice_params->u1_scan_idx_end)
1891 return ERROR_SVC_INV_SCAN_IDX;
1892 }
1893 return OK;
1894 }
1895
1896 /*!
1897 **************************************************************************
1898 * \if Function name : DecodeSlice \endif
1899 *
1900 * \brief
1901 * Parses a slice
1902 *
1903 * \return
1904 * 0 on Success and Error code otherwise
1905 **************************************************************************
1906 */
1907
isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,svc_dec_lyr_struct_t * ps_svc_lyr_dec)1908 WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
1909 svc_dec_lyr_struct_t *ps_svc_lyr_dec /* SVC Decoder parameters */
1910 )
1911 {
1912 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1913 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1914 dec_pic_params_t *ps_pps;
1915 dec_seq_params_t *ps_seq;
1916 dec_svc_seq_params_t *ps_subset_seq;
1917 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
1918 pocstruct_t s_tmp_poc = {0};
1919 WORD32 i_delta_poc[2] = {0};
1920 WORD32 i4_poc = 0;
1921 UWORD16 u2_first_mb_in_slice, u2_frame_num;
1922 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
1923 UWORD32 u4_idr_pic_id = 0;
1924 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
1925 UWORD8 u1_nal_unit_type;
1926 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1927 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1928 WORD8 i1_is_end_of_poc;
1929
1930 WORD32 ret;
1931 WORD32 prev_slice_err, num_mb_skipped;
1932 UWORD8 u1_mbaff;
1933 pocstruct_t *ps_cur_poc;
1934
1935 UWORD32 u4_temp;
1936 WORD32 i_temp;
1937 svc_dec_ctxt_t *psvcd_dec_ctxt;
1938 dec_struct_t *ps_dec_cur_lyr_minus_1;
1939 svc_dec_lyr_struct_t *ps_svc_cur_lyr_dec_minus_1;
1940
1941 /* read FirstMbInSlice and slice type*/
1942 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1943 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1944 if(u2_first_mb_in_slice > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
1945 {
1946 return ERROR_CORRUPTED_SLICE;
1947 }
1948
1949 /*we currently don not support ASO*/
1950 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
1951 (ps_dec->u4_first_slice_in_pic == 0))
1952 {
1953 return ERROR_CORRUPTED_SLICE;
1954 }
1955
1956 if(ps_dec->u4_first_slice_in_pic == 1)
1957 {
1958 if(u2_first_mb_in_slice != 0)
1959 {
1960 return ERROR_CORRUPTED_SLICE;
1961 }
1962 }
1963
1964 COPYTHECONTEXT("SH: first_mb_in_slice", u2_first_mb_in_slice);
1965
1966 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1967 if(u4_temp > 9) return ERROR_INV_SLC_TYPE_T;
1968
1969 u1_slice_type = u4_temp;
1970 COPYTHECONTEXT("SH: slice_type", (u1_slice_type));
1971 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
1972 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
1973 /* will be of same type of current */
1974 if(u1_slice_type > 4)
1975 {
1976 u1_slice_type -= 5;
1977 }
1978
1979 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1980 if(u4_temp & MASK_ERR_PIC_SET_ID) return ERROR_INV_SLICE_HDR_T;
1981 /* discard slice if pic param is invalid */
1982 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp);
1983 ps_pps = &ps_dec->ps_pps[u4_temp];
1984 if(FALSE == ps_pps->u1_is_valid)
1985 {
1986 return ERROR_INV_SLICE_HDR_T;
1987 }
1988 /* slices in a layer should have same PPS id*/
1989 if(UINT32_MAX == ps_svc_lyr_dec->u4_pps_id_for_layer)
1990 {
1991 ps_svc_lyr_dec->u4_pps_id_for_layer = u4_temp;
1992 }
1993 else if(u4_temp != ps_svc_lyr_dec->u4_pps_id_for_layer)
1994 {
1995 return ERROR_INV_SLICE_HDR_T;
1996 }
1997 ps_seq = ps_pps->ps_sps;
1998 ps_dec->ps_cur_sps = ps_seq;
1999 ps_subset_seq = &ps_svc_lyr_dec->ps_subset_sps[ps_seq->u1_seq_parameter_set_id];
2000 ps_svc_lyr_dec->ps_cur_subset_sps = ps_subset_seq;
2001 if(!ps_seq) return ERROR_INV_SLICE_HDR_T;
2002 if(FALSE == ps_seq->u1_is_valid) return ERROR_INV_SLICE_HDR_T;
2003 if(ps_seq->u1_mb_aff_flag) return ERROR_INV_SLICE_HDR_T;
2004 if(ps_seq->u1_level_idc > H264_LEVEL_4_2) return ERROR_INV_SLICE_HDR_T;
2005 if(!ps_seq->u1_frame_mbs_only_flag) return ERROR_INV_SLICE_HDR_T;
2006 if(OK != isvcd_verify_level(ps_seq->u1_level_idc)) return ERROR_INV_SLICE_HDR_T;
2007 if(ps_dec->u1_init_dec_flag == 1)
2008 {
2009 if(ps_dec->u2_frm_wd_in_mbs != ps_seq->u2_frm_wd_in_mbs) return ERROR_INV_SLICE_HDR_T;
2010 if(ps_dec->u2_frm_ht_in_mbs != ps_seq->u2_frm_ht_in_mbs) return ERROR_INV_SLICE_HDR_T;
2011 }
2012
2013 if(ps_dec->u1_init_dec_flag == 1)
2014 {
2015 if(ps_dec->u2_disp_height != ps_subset_seq->u2_disp_height) return ERROR_INV_SLICE_HDR_T;
2016 if(ps_dec->u2_disp_width != ps_subset_seq->u2_disp_width) return ERROR_INV_SLICE_HDR_T;
2017 }
2018
2019 if(ps_seq->u1_profile_idc == BASE_PROFILE_IDC)
2020 {
2021 if(ps_pps->u1_entropy_coding_mode != 0)
2022 {
2023 return ERROR_INV_SPS_PPS_T;
2024 }
2025 }
2026
2027 ps_dec->i4_reorder_depth = ps_subset_seq->i4_reorder_depth;
2028 ps_dec->u2_disp_height = ps_subset_seq->u2_disp_height;
2029 ps_dec->u2_disp_width = ps_subset_seq->u2_disp_width;
2030
2031 if(ps_svc_lyr_dec->u1_layer_id > 0)
2032 {
2033 psvcd_dec_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
2034 ps_svc_cur_lyr_dec_minus_1 =
2035 &psvcd_dec_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_layer_id - 1];
2036
2037 ps_dec_cur_lyr_minus_1 = &ps_svc_cur_lyr_dec_minus_1->s_dec;
2038
2039 if((ps_dec_cur_lyr_minus_1->u2_pic_wd > ps_subset_seq->u2_pic_wd) ||
2040 (ps_dec_cur_lyr_minus_1->u2_pic_ht > ps_subset_seq->u2_pic_ht))
2041 {
2042 return ERROR_CORRUPTED_SLICE;
2043 }
2044 }
2045
2046 ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
2047 ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
2048 ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
2049
2050 /* Determining the Width and Height of Frame from that of Picture */
2051 ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
2052 ps_dec->u2_frm_ht_y = ps_subset_seq->u2_frm_ht_y;
2053
2054 ps_dec->u2_frm_wd_uv = ps_subset_seq->u2_frm_wd_uv;
2055 ps_dec->u2_frm_ht_uv = ps_subset_seq->u2_frm_ht_uv;
2056
2057 ps_dec->s_pad_mgr.u1_pad_len_y_v = ps_subset_seq->u1_pad_len_y_v;
2058 ps_dec->s_pad_mgr.u1_pad_len_cr_v = ps_subset_seq->u1_pad_len_cr_v;
2059 ps_dec->u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
2060 ps_dec->u2_frm_ht_in_mbs = ps_seq->u2_frm_ht_in_mbs;
2061
2062 ps_dec->u2_crop_offset_y = ps_subset_seq->u2_crop_offset_y;
2063 ps_dec->u2_crop_offset_uv = ps_subset_seq->u2_crop_offset_uv;
2064
2065 /* Get the frame num */
2066 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_bits_in_frm_num);
2067 COPYTHECONTEXT("SH: frame_num", u2_frame_num);
2068
2069 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
2070 {
2071 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
2072 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
2073
2074 ps_dec->u2_mbx = 0xffff;
2075 ps_dec->u2_mby = 0;
2076
2077 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
2078 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
2079
2080 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) ps_dec->u2_prev_ref_frame_num = 0;
2081
2082 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
2083 {
2084 isvcd_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
2085 }
2086
2087 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
2088 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
2089 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
2090 if(ps_cur_slice->u1_nal_ref_idc)
2091 {
2092 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
2093 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
2094 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
2095 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
2096 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
2097 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
2098 }
2099
2100 ps_dec->u2_total_mbs_coded = 0;
2101 }
2102 /* Get the field related flags */
2103 if(!ps_seq->u1_frame_mbs_only_flag)
2104 {
2105 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
2106 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag);
2107 u1_bottom_field_flag = 0;
2108
2109 if(u1_field_pic_flag)
2110 {
2111 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan_fld;
2112 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
2113 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag);
2114 }
2115 else
2116 {
2117 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
2118 }
2119 }
2120 else
2121 {
2122 u1_field_pic_flag = 0;
2123 u1_bottom_field_flag = 0;
2124
2125 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
2126 }
2127
2128 u1_nal_unit_type = SLICE_NAL;
2129 if(u1_is_idr_slice)
2130 {
2131 u1_nal_unit_type = IDR_SLICE_NAL;
2132 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2133 if(u4_idr_pic_id > 65535) return ERROR_INV_SLICE_HDR_T;
2134 COPYTHECONTEXT("SH: ", u4_idr_pic_id);
2135 }
2136
2137 /* read delta pic order count information*/
2138 i_delta_poc[0] = i_delta_poc[1] = 0;
2139 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
2140 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
2141 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
2142 if(u1_pic_order_cnt_type == 0)
2143 {
2144 i_temp = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
2145 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) return ERROR_INV_SLICE_HDR_T;
2146 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
2147 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
2148
2149 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
2150 {
2151 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2152 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom",
2153 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
2154 }
2155 }
2156
2157 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
2158 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
2159 if(u1_pic_order_cnt_type == 1 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
2160 {
2161 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2162 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]", s_tmp_poc.i4_delta_pic_order_cnt[0]);
2163
2164 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
2165 {
2166 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2167 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]", s_tmp_poc.i4_delta_pic_order_cnt[1]);
2168 }
2169 }
2170
2171 if(ps_pps->u1_redundant_pic_cnt_present_flag)
2172 {
2173 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2174 if(u4_temp > MAX_REDUNDANT_PIC_CNT) return ERROR_INV_SLICE_HDR_T;
2175 u1_redundant_pic_cnt = u4_temp;
2176 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt);
2177 }
2178
2179 /*--------------------------------------------------------------------*/
2180 /* Check if the slice is part of new picture */
2181 /*--------------------------------------------------------------------*/
2182 /* First slice of a picture is always considered as part of new picture */
2183 i1_is_end_of_poc = 1;
2184 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
2185
2186 if(ps_dec->u4_first_slice_in_pic == 0)
2187 {
2188 i1_is_end_of_poc =
2189 ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, &s_tmp_poc, &ps_dec->s_cur_pic_poc,
2190 ps_cur_slice, u1_pic_order_cnt_type, u1_nal_unit_type,
2191 u4_idr_pic_id, u1_field_pic_flag, u1_bottom_field_flag);
2192 if(i1_is_end_of_poc)
2193 {
2194 ps_dec->u1_first_slice_in_stream = 0;
2195 return ERROR_INCOMPLETE_FRAME;
2196 }
2197 }
2198
2199 /*--------------------------------------------------------------------*/
2200 /* Check for error in slice and parse the missing/corrupted MB's */
2201 /* as skip-MB's in an inserted P-slice */
2202 /*--------------------------------------------------------------------*/
2203 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
2204 prev_slice_err = 0;
2205
2206 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
2207 {
2208 /* If the current slice is not a field or frame number of the current
2209 * slice doesn't match with previous slice, and decoder is expecting
2210 * to decode a field i.e. ps_dec->u1_top_bottom_decoded is not 0 and
2211 * is not (TOP_FIELD_ONLY | BOT_FIELD_ONLY), treat it as a dangling
2212 * field */
2213 if((u1_field_pic_flag == 0 || u2_frame_num != ps_dec->u2_prv_frame_num) &&
2214 ps_dec->u1_top_bottom_decoded != 0 &&
2215 ps_dec->u1_top_bottom_decoded != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
2216 {
2217 ps_dec->u1_dangling_field = 1;
2218 if(ps_dec->u4_first_slice_in_pic)
2219 {
2220 // first slice - dangling field
2221 prev_slice_err = 1;
2222 }
2223 else
2224 {
2225 // last slice - dangling field
2226 prev_slice_err = 2;
2227 }
2228
2229 if(ps_dec->u1_top_bottom_decoded == TOP_FIELD_ONLY)
2230 ps_cur_slice->u1_bottom_field_flag = 1;
2231 else
2232 ps_cur_slice->u1_bottom_field_flag = 0;
2233
2234 num_mb_skipped =
2235 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
2236 ps_cur_poc = &ps_dec->s_cur_pic_poc;
2237
2238 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
2239 }
2240 else if(ps_dec->u4_first_slice_in_pic)
2241 {
2242 if(u2_first_mb_in_slice > 0)
2243 {
2244 /* first slice - missing/header corruption */
2245 prev_slice_err = 1;
2246 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
2247 ps_cur_poc = &s_tmp_poc;
2248
2249 /* initializing slice parameters */
2250 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
2251 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
2252 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
2253 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
2254 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
2255 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
2256 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
2257 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
2258 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
2259 }
2260 }
2261 else
2262 {
2263 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so
2264 * conceal the current frame completely */
2265 prev_slice_err = 2;
2266 num_mb_skipped =
2267 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
2268 ps_cur_poc = &s_tmp_poc;
2269 }
2270 }
2271 else
2272 {
2273 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
2274 {
2275 // previous slice - missing/corruption
2276 prev_slice_err = 2;
2277 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
2278 ps_cur_poc = &s_tmp_poc;
2279 }
2280 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
2281 {
2282 return ERROR_CORRUPTED_SLICE;
2283 }
2284 }
2285 if(prev_slice_err)
2286 {
2287 ret = isvcd_mark_err_slice_skip((svc_dec_lyr_struct_t *) ps_dec, num_mb_skipped,
2288 u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
2289
2290 if(ps_dec->u1_dangling_field == 1)
2291 {
2292 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
2293 ps_dec->u1_first_slice_in_stream = 0;
2294 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;
2295 return ERROR_DANGLING_FIELD_IN_PIC;
2296 }
2297
2298 if(prev_slice_err == 2)
2299 {
2300 ps_dec->u1_first_slice_in_stream = 0;
2301 return ERROR_INCOMPLETE_FRAME;
2302 }
2303
2304 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
2305 {
2306 /* return if all MBs in frame are parsed*/
2307 ps_dec->u1_first_slice_in_stream = 0;
2308 return ERROR_IN_LAST_SLICE_OF_PIC;
2309 }
2310
2311 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
2312 {
2313 ih264d_err_pic_dispbuf_mgr(ps_dec);
2314 return ERROR_NEW_FRAME_EXPECTED;
2315 }
2316
2317 if(ret != OK) return ret;
2318
2319 i1_is_end_of_poc = 0;
2320 }
2321
2322 if(u1_field_pic_flag)
2323 {
2324 ps_dec->u2_prv_frame_num = u2_frame_num;
2325 }
2326
2327 if(ps_cur_slice->u1_mmco_equalto5 && NULL != ps_dec->ps_cur_pic)
2328 {
2329 WORD32 i4_temp_poc;
2330 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
2331 WORD64 i8_result;
2332 if(!ps_cur_slice->u1_field_pic_flag)
2333 {
2334 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2335 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2336 i4_temp_poc = MIN(i4_top_field_order_poc, i4_bot_field_order_poc);
2337 }
2338 else if(!ps_cur_slice->u1_bottom_field_flag)
2339 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2340 else
2341 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2342
2343 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2344 if(IS_OUT_OF_RANGE_S32(i8_result))
2345 {
2346 return ERROR_INV_POC;
2347 }
2348 ps_dec->ps_cur_pic->i4_top_field_order_cnt = (WORD32) i8_result;
2349 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2350 if(IS_OUT_OF_RANGE_S32(i8_result))
2351 {
2352 return ERROR_INV_POC;
2353 }
2354 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = (WORD32) i8_result;
2355 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
2356 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
2357 }
2358 if(ps_dec->u4_first_slice_in_pic)
2359 {
2360 ret = isvcd_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, &ps_dec->s_prev_pic_poc,
2361 &s_tmp_poc, ps_cur_slice, ps_pps, u1_nal_ref_idc,
2362 u1_bottom_field_flag, u1_field_pic_flag, &i4_poc, ps_dec);
2363 if(ret != OK) return ret;
2364 /* Display seq no calculations */
2365 if(i4_poc >= ps_dec->i4_max_poc) ps_dec->i4_max_poc = i4_poc;
2366 /* IDR Picture or POC wrap around */
2367 if(i4_poc == 0)
2368 {
2369 WORD64 i8_temp;
2370 i8_temp = (WORD64) ps_dec->i4_prev_max_display_seq + ps_dec->i4_max_poc +
2371 ps_dec->u1_max_dec_frame_buffering + 1;
2372 /*If i4_prev_max_display_seq overflows integer range, reset it */
2373 ps_dec->i4_prev_max_display_seq = IS_OUT_OF_RANGE_S32(i8_temp) ? 0 : i8_temp;
2374 ps_dec->i4_max_poc = 0;
2375 }
2376 }
2377
2378 /* Increment only if the current slice has atleast 1 more MB */
2379 if(ps_dec->u4_first_slice_in_pic == 0 &&
2380 (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
2381 (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
2382 {
2383 ps_dec->ps_parse_cur_slice++;
2384 ps_dec->u2_cur_slice_num++;
2385 // in the case of single core increment ps_decode_cur_slice
2386 if(ps_dec->u1_separate_parse == 0)
2387 {
2388 ps_dec->ps_decode_cur_slice++;
2389 }
2390 }
2391
2392 ps_dec->u1_slice_header_done = 0;
2393
2394 /*--------------------------------------------------------------------*/
2395 /* Copy the values read from the bitstream to the slice header and then*/
2396 /* If the slice is first slice in picture, then do Start of Picture */
2397 /* processing. */
2398 /*--------------------------------------------------------------------*/
2399 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
2400 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
2401 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
2402 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
2403 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
2404 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
2405 ps_cur_slice->u1_slice_type = u1_slice_type;
2406 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
2407
2408 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
2409 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
2410 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
2411 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
2412
2413 if(ps_seq->u1_frame_mbs_only_flag)
2414 ps_cur_slice->u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
2415 else
2416 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
2417
2418 if(u1_slice_type == B_SLICE)
2419 {
2420 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(ps_bitstrm);
2421 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag",
2422 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
2423
2424 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
2425 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
2426 else
2427 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
2428 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
2429 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
2430 }
2431 else
2432 {
2433 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
2434 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
2435 }
2436
2437 if(ps_dec->u4_first_slice_in_pic)
2438 {
2439 if(u2_first_mb_in_slice == 0)
2440 {
2441 ret = isvcd_start_of_pic(ps_svc_lyr_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
2442 if(ret != OK) return ret;
2443 /*inter layer buffer intialization */
2444 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
2445 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start;
2446 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_cur_mb =
2447 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base;
2448 }
2449
2450 ps_dec->u4_output_present = 0;
2451
2452 {
2453 ih264d_get_next_display_field(ps_dec, ps_dec->ps_out_buffer, &(ps_dec->s_disp_op));
2454 /* If error code is non-zero then there is no buffer available for
2455 display, hence avoid format conversion */
2456
2457 if(0 != ps_dec->s_disp_op.u4_error_code)
2458 {
2459 ps_dec->u4_output_present = 0;
2460 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
2461 }
2462 else
2463 ps_dec->u4_output_present = 1;
2464 }
2465 ret = isvcd_parse_interlayer_resamp_func_init(ps_svc_lyr_dec, u2_first_mb_in_slice);
2466 if(ret != OK)
2467 {
2468 return ERROR_CORRUPTED_SLICE;
2469 }
2470 if((ps_dec->u1_separate_parse == 1) && (ps_svc_lyr_dec->u1_res_init_done == 1))
2471 {
2472 if(ps_dec->u4_dec_thread_created == 0)
2473 {
2474 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
2475 {
2476 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
2477 (void *) isvcd_decode_picture_thread, (void *) ps_dec);
2478
2479 ps_dec->u4_dec_thread_created = 1;
2480 }
2481 else
2482 {
2483 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
2484 (void *) ih264d_decode_picture_thread, (void *) ps_dec);
2485
2486 ps_dec->u4_dec_thread_created = 1;
2487 }
2488 }
2489 #ifdef KEEP_THREADS_ACTIVE
2490 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
2491 RETURN_IF((ret != IV_SUCCESS), ret);
2492
2493 ps_dec->ai4_process_start[0] = PROC_START;
2494 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
2495 RETURN_IF((ret != IV_SUCCESS), ret);
2496
2497 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
2498 RETURN_IF((ret != IV_SUCCESS), ret);
2499 #endif
2500 #ifdef KEEP_THREADS_ACTIVE
2501 if(ps_dec->u4_bs_deblk_thread_created)
2502 {
2503 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
2504 RETURN_IF((ret != IV_SUCCESS), ret);
2505
2506 ps_dec->ai4_process_start[1] = PROC_START;
2507 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
2508 RETURN_IF((ret != IV_SUCCESS), ret);
2509
2510 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
2511 RETURN_IF((ret != IV_SUCCESS), ret);
2512 }
2513 #endif
2514 }
2515 }
2516
2517 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
2518 {
2519 UWORD8 uc_nofield_nombaff;
2520
2521 uc_nofield_nombaff =
2522 ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) &&
2523 (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) && (u1_slice_type != B_SLICE) &&
2524 (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
2525
2526 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
2527
2528 if(uc_nofield_nombaff)
2529 {
2530 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
2531 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
2532 }
2533 else
2534 {
2535 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
2536 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
2537 }
2538 }
2539
2540 /*
2541 * Decide whether to decode the current picture or not
2542 */
2543 {
2544 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
2545 if(ps_err->u4_frm_sei_sync == u2_frame_num)
2546 {
2547 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
2548 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
2549 }
2550 ps_err->u4_cur_frm = u2_frame_num;
2551 }
2552
2553 /* Decision for decoding if the picture is to be skipped */
2554 {
2555 WORD32 i4_skip_b_pic, i4_skip_p_pic;
2556
2557 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) && (B_SLICE == u1_slice_type) &&
2558 (0 == u1_nal_ref_idc);
2559
2560 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) && (P_SLICE == u1_slice_type) &&
2561 (0 == u1_nal_ref_idc);
2562
2563 /**************************************************************/
2564 /* Skip the B picture if skip mask is set for B picture and */
2565 /* Current B picture is a non reference B picture or there is */
2566 /* no user for reference B picture */
2567 /**************************************************************/
2568 if(i4_skip_b_pic)
2569 {
2570 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
2571 /* Don't decode the picture in SKIP-B mode if that picture is B */
2572 /* and also it is not to be used as a reference picture */
2573 ps_dec->u1_last_pic_not_decoded = 1;
2574
2575 return OK;
2576 }
2577 /**************************************************************/
2578 /* Skip the P picture if skip mask is set for P picture and */
2579 /* Current P picture is a non reference P picture or there is */
2580 /* no user for reference P picture */
2581 /**************************************************************/
2582 if(i4_skip_p_pic)
2583 {
2584 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
2585 /* Don't decode the picture in SKIP-P mode if that picture is P */
2586 /* and also it is not to be used as a reference picture */
2587 ps_dec->u1_last_pic_not_decoded = 1;
2588
2589 return OK;
2590 }
2591 }
2592
2593 {
2594 UWORD16 u2_mb_x, u2_mb_y;
2595
2596 ps_dec->i4_submb_ofst =
2597 ((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) -
2598 SUB_BLK_SIZE;
2599 if(u2_first_mb_in_slice)
2600 {
2601 UWORD8 u1_mb_aff;
2602 UWORD8 u1_field_pic;
2603 UWORD16 u2_frm_wd_in_mbs;
2604 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
2605 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
2606 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
2607
2608 {
2609 UWORD32 x_offset;
2610 UWORD32 y_offset;
2611 UWORD32 u4_frame_stride;
2612 tfr_ctxt_t *ps_trns_addr;
2613
2614 if(ps_dec->u1_separate_parse)
2615 {
2616 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
2617 }
2618 else
2619 {
2620 ps_trns_addr = &ps_dec->s_tran_addrecon;
2621 }
2622 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
2623 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
2624
2625 u2_mb_y <<= u1_mb_aff;
2626
2627 if((u2_mb_x > u2_frm_wd_in_mbs - 1) || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
2628 {
2629 return ERROR_CORRUPTED_SLICE;
2630 }
2631
2632 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
2633 x_offset = u2_mb_x << 4;
2634 y_offset = (u2_mb_y * u4_frame_stride) << 4;
2635
2636 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset + y_offset;
2637
2638 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
2639 x_offset >>= 1;
2640 y_offset = (u2_mb_y * u4_frame_stride) << 3;
2641
2642 x_offset *= YUV420SP_FACTOR;
2643
2644 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset + y_offset;
2645 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset + y_offset;
2646
2647 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
2648 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
2649 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
2650
2651 /* assign the deblock structure pointers to start of slice */
2652 if(ps_dec->u1_separate_parse == 1)
2653 {
2654 ps_dec->ps_deblk_mbn =
2655 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
2656 }
2657 else
2658 {
2659 ps_dec->ps_deblk_mbn =
2660 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
2661 }
2662
2663 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
2664
2665 ps_dec->ps_mv_cur =
2666 ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
2667 }
2668 }
2669 else
2670 {
2671 tfr_ctxt_t *ps_trns_addr;
2672
2673 if(ps_dec->u1_separate_parse)
2674 {
2675 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
2676 }
2677 else
2678 {
2679 ps_trns_addr = &ps_dec->s_tran_addrecon;
2680 }
2681
2682 u2_mb_x = 0xffff;
2683 u2_mb_y = 0;
2684 // assign the deblock structure pointers to start of slice
2685 ps_dec->u2_cur_mb_addr = 0;
2686 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
2687 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
2688 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
2689 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
2690 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
2691
2692 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
2693 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
2694 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
2695 }
2696
2697 ps_dec->ps_part = ps_dec->ps_parse_part_params;
2698
2699 ps_dec->u2_mbx = (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
2700 ps_dec->u2_mby = (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
2701 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
2702 ps_dec->i2_prev_slice_mbx = (WORD16) ps_dec->u2_mbx;
2703 ps_dec->i2_prev_slice_mby = (WORD16) ps_dec->u2_mby;
2704 }
2705
2706 /* RBSP stop bit is used for CABAC decoding*/
2707 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
2708
2709 ps_dec->u1_B = (u1_slice_type == B_SLICE);
2710 ps_dec->u4_next_mb_skip = 0;
2711
2712 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->ps_cur_slice->u2_first_mb_in_slice;
2713 ps_dec->ps_parse_cur_slice->slice_type = ps_dec->ps_cur_slice->u1_slice_type;
2714
2715 ps_dec->u4_start_recon_deblk = 1;
2716 {
2717 WORD32 num_entries;
2718 WORD32 size;
2719 UWORD8 *pu1_buf;
2720
2721 num_entries = MAX_FRAMES;
2722 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
2723 {
2724 num_entries = 1;
2725 }
2726 num_entries = ((2 * num_entries) + 1);
2727 num_entries *= 2;
2728
2729 size = num_entries * sizeof(void *);
2730 size += PAD_MAP_IDX_POC * sizeof(void *);
2731
2732 pu1_buf = (UWORD8 *) ps_dec->pv_map_ref_idx_to_poc_buf;
2733 pu1_buf += size * ps_dec->u2_cur_slice_num;
2734 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (void *) pu1_buf;
2735 }
2736
2737 if(ps_dec->u1_separate_parse)
2738 {
2739 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
2740 }
2741 else
2742 {
2743 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
2744 }
2745
2746 ret = ih264d_fix_error_in_dpb(ps_dec);
2747 if(ret < 0) return ERROR_DBP_MANAGER_T;
2748
2749 if(u1_slice_type == I_SLICE)
2750 {
2751 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
2752
2753 ret = isvcd_parse_islice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2754 ps_dec->u1_pr_sl_type = u1_slice_type;
2755 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
2756 ps_dec->i4_pic_type = I_SLICE;
2757 }
2758 else if(u1_slice_type == P_SLICE)
2759 {
2760 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
2761 ret = isvcd_parse_pslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2762 ps_dec->u1_pr_sl_type = u1_slice_type;
2763 if(ps_dec->i4_pic_type != B_SLICE) ps_dec->i4_pic_type = P_SLICE;
2764 }
2765 else if(u1_slice_type == B_SLICE)
2766 {
2767 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
2768 ret = isvcd_parse_bslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2769 ps_dec->u1_pr_sl_type = u1_slice_type;
2770 ps_dec->i4_pic_type = B_SLICE;
2771 }
2772 else
2773 return ERROR_INV_SLC_TYPE_T;
2774
2775 if(ps_dec->u1_slice_header_done)
2776 {
2777 /* set to zero to indicate a valid slice has been decoded */
2778 ps_dec->u1_first_slice_in_stream = 0;
2779 }
2780
2781 if(ret != OK) return ret;
2782
2783 if(u1_nal_ref_idc != 0)
2784 {
2785 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2786 {
2787 memcpy((void *) ps_dec->ps_dpb_cmds, (void *) (&(ps_dec->s_dpb_cmds_scratch)),
2788 sizeof(dpb_commands_t));
2789 }
2790 }
2791
2792 /* storing last Mb X and MbY of the slice */
2793 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
2794 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
2795
2796 /* End of Picture detection */
2797
2798 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
2799 {
2800 ps_dec->u1_pic_decode_done = 1;
2801 }
2802
2803 {
2804 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
2805 if((ps_err->u1_err_flag & REJECT_PB_PICS) && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
2806 {
2807 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
2808 }
2809 }
2810
2811 PRINT_BIN_BIT_RATIO(ps_dec)
2812
2813 return ret;
2814 }