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 ps_dec->i4_reorder_depth = ps_subset_seq->i4_reorder_depth;
770
771 ps_dec->u2_disp_height = ps_subset_seq->u2_disp_height;
772 ps_dec->u2_disp_width = ps_subset_seq->u2_disp_width;
773
774 if(ps_svc_lyr_dec->u1_layer_id > 0)
775 {
776 psvcd_dec_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
777 ps_svc_cur_lyr_dec_minus_1 =
778 &psvcd_dec_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_layer_id - 1];
779
780 ps_dec_cur_lyr_minus_1 = &ps_svc_cur_lyr_dec_minus_1->s_dec;
781
782 if((ps_dec_cur_lyr_minus_1->u2_pic_wd > ps_subset_seq->u2_pic_wd) ||
783 (ps_dec_cur_lyr_minus_1->u2_pic_ht > ps_subset_seq->u2_pic_ht))
784 {
785 return ERROR_CORRUPTED_SLICE;
786 }
787 }
788
789 ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
790 ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
791 ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
792
793 /* Determining the Width and Height of Frame from that of Picture */
794 ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
795 ps_dec->u2_frm_ht_y = ps_subset_seq->u2_frm_ht_y;
796
797 ps_dec->u2_frm_wd_uv = ps_subset_seq->u2_frm_wd_uv;
798 ps_dec->u2_frm_ht_uv = ps_subset_seq->u2_frm_ht_uv;
799
800 ps_dec->s_pad_mgr.u1_pad_len_y_v = ps_subset_seq->u1_pad_len_y_v;
801 ps_dec->s_pad_mgr.u1_pad_len_cr_v = ps_subset_seq->u1_pad_len_cr_v;
802
803 ps_dec->u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
804 ps_dec->u2_frm_ht_in_mbs = ps_seq->u2_frm_ht_in_mbs;
805
806 ps_dec->u2_crop_offset_y = ps_subset_seq->u2_crop_offset_y;
807 ps_dec->u2_crop_offset_uv = ps_subset_seq->u2_crop_offset_uv;
808
809 /* Get the frame num */
810 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_bits_in_frm_num);
811
812 COPYTHECONTEXT("Slice Header SVC ext: frame_num", u2_frame_num);
813 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
814 {
815 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
816 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
817
818 ps_dec->u2_mbx = 0xffff;
819 ps_dec->u2_mby = 0;
820
821 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
822 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
823
824 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) ps_dec->u2_prev_ref_frame_num = 0;
825
826 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
827 {
828 isvcd_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
829 }
830
831 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
832 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
833 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
834 if(ps_cur_slice->u1_nal_ref_idc)
835 {
836 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
837 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
838 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
839 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
840 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
841 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
842 }
843
844 ps_dec->u2_total_mbs_coded = 0;
845 }
846 /* Get the field related flags */
847 if(!ps_seq->u1_frame_mbs_only_flag)
848 {
849 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
850 COPYTHECONTEXT("Slice Header SVC ext: field_pic_flag", u1_field_pic_flag);
851 u1_bottom_field_flag = 0;
852
853 if(u1_field_pic_flag)
854 {
855 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan_fld;
856 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
857 COPYTHECONTEXT("Slice Header SVC ext: bottom_field_flag", u1_bottom_field_flag);
858 }
859 else
860 {
861 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
862 }
863 }
864 else
865 {
866 u1_field_pic_flag = 0;
867 u1_bottom_field_flag = 0;
868 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
869 }
870
871 u1_nal_unit_type = SLICE_NAL;
872 if(u1_is_idr_slice)
873 {
874 u1_nal_unit_type = IDR_SLICE_NAL;
875 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
876 if(u4_idr_pic_id > 65535) return ERROR_INV_SLICE_HDR_T;
877 COPYTHECONTEXT("Slice Header SVC ext: ", u4_idr_pic_id);
878 }
879
880 /* read delta pic order count information*/
881 i_delta_poc[0] = i_delta_poc[1] = 0;
882 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
883 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
884 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
885 if(u1_pic_order_cnt_type == 0)
886 {
887 i_temp = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
888 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) return ERROR_INV_SLICE_HDR_T;
889 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
890 COPYTHECONTEXT("Slice Header SVC ext: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
891
892 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
893 {
894 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
895 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt_bottom",
896 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
897 }
898 }
899
900 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
901 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
902 if(u1_pic_order_cnt_type == 1 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
903 {
904 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
905 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt[0]",
906 s_tmp_poc.i4_delta_pic_order_cnt[0]);
907
908 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
909 {
910 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
911 COPYTHECONTEXT("Slice Header SVC ext: delta_pic_order_cnt[1]",
912 s_tmp_poc.i4_delta_pic_order_cnt[1]);
913 }
914 }
915
916 if(ps_pps->u1_redundant_pic_cnt_present_flag)
917 {
918 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
919 if(u4_temp > MAX_REDUNDANT_PIC_CNT) return ERROR_INV_SLICE_HDR_T;
920 u1_redundant_pic_cnt = u4_temp;
921 COPYTHECONTEXT("Slice Header SVC ext: redundant_pic_cnt", u1_redundant_pic_cnt);
922 }
923
924 /*--------------------------------------------------------------------*/
925 /* Check if the slice is part of new picture */
926 /*--------------------------------------------------------------------*/
927 /* First slice of a picture is always considered as part of new picture */
928 i1_is_end_of_poc = 1;
929 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
930
931 if(ps_dec->u4_first_slice_in_pic == 0)
932 {
933 i1_is_end_of_poc =
934 ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, &s_tmp_poc, &ps_dec->s_cur_pic_poc,
935 ps_cur_slice, u1_pic_order_cnt_type, u1_nal_unit_type,
936 u4_idr_pic_id, u1_field_pic_flag, u1_bottom_field_flag);
937 if(i1_is_end_of_poc)
938 {
939 ps_dec->u1_first_slice_in_stream = 0;
940 return ERROR_INCOMPLETE_FRAME;
941 }
942 }
943
944 /*--------------------------------------------------------------------*/
945 /* Check for error in slice and parse the missing/corrupted MB's */
946 /* as skip-MB's in an inserted P-slice */
947 /*--------------------------------------------------------------------*/
948 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
949 prev_slice_err = 0;
950
951 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
952 {
953 /* If the current slice is not a field or frame number of the current
954 * slice doesn't match with previous slice, and decoder is expecting
955 * to decode a field i.e. ps_dec->u1_top_bottom_decoded is not 0 and
956 * is not (TOP_FIELD_ONLY | BOT_FIELD_ONLY), treat it as a dangling
957 * field */
958 if((u1_field_pic_flag == 0 || u2_frame_num != ps_dec->u2_prv_frame_num) &&
959 ps_dec->u1_top_bottom_decoded != 0 &&
960 ps_dec->u1_top_bottom_decoded != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
961 {
962 ps_dec->u1_dangling_field = 1;
963 if(ps_dec->u4_first_slice_in_pic)
964 {
965 // first slice - dangling field
966 prev_slice_err = 1;
967 }
968 else
969 {
970 // last slice - dangling field
971 prev_slice_err = 2;
972 }
973
974 if(ps_dec->u1_top_bottom_decoded == TOP_FIELD_ONLY)
975 ps_cur_slice->u1_bottom_field_flag = 1;
976 else
977 ps_cur_slice->u1_bottom_field_flag = 0;
978
979 num_mb_skipped =
980 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
981 ps_cur_poc = &ps_dec->s_cur_pic_poc;
982
983 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
984 }
985 else if(ps_dec->u4_first_slice_in_pic)
986 {
987 if(u2_first_mb_in_slice > 0)
988 {
989 // first slice - missing/header corruption
990 prev_slice_err = 1;
991 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
992 ps_cur_poc = &s_tmp_poc;
993
994 // initializing slice parameters
995 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
996 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
997 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
998 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
999 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1000 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1001 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1002 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1003 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
1004 }
1005 }
1006 else
1007 {
1008 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so
1009 * conceal the current frame completely */
1010 prev_slice_err = 2;
1011 num_mb_skipped =
1012 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
1013 ps_cur_poc = &s_tmp_poc;
1014 }
1015 }
1016 else
1017 {
1018 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
1019 {
1020 // previous slice - missing/corruption
1021 prev_slice_err = 2;
1022 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
1023 ps_cur_poc = &s_tmp_poc;
1024 }
1025 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
1026 {
1027 return ERROR_CORRUPTED_SLICE;
1028 }
1029 }
1030 if(prev_slice_err)
1031 {
1032 ret = isvcd_mark_err_slice_skip((svc_dec_lyr_struct_t *) ps_dec, num_mb_skipped,
1033 u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
1034
1035 if(ps_dec->u1_dangling_field == 1)
1036 {
1037 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
1038 ps_dec->u1_first_slice_in_stream = 0;
1039 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;
1040 return ERROR_DANGLING_FIELD_IN_PIC;
1041 }
1042
1043 if(prev_slice_err == 2)
1044 {
1045 ps_dec->u1_first_slice_in_stream = 0;
1046 return ERROR_INCOMPLETE_FRAME;
1047 }
1048
1049 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1050 {
1051 /* return if all MBs in frame are parsed*/
1052 ps_dec->u1_first_slice_in_stream = 0;
1053 return ERROR_IN_LAST_SLICE_OF_PIC;
1054 }
1055
1056 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1057 {
1058 ih264d_err_pic_dispbuf_mgr(ps_dec);
1059 return ERROR_NEW_FRAME_EXPECTED;
1060 }
1061
1062 if(ret != OK) return ret;
1063
1064 i1_is_end_of_poc = 0;
1065 }
1066
1067 if(u1_field_pic_flag)
1068 {
1069 ps_dec->u2_prv_frame_num = u2_frame_num;
1070 }
1071
1072 if(ps_cur_slice->u1_mmco_equalto5)
1073 {
1074 WORD32 i4_temp_poc;
1075 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
1076 WORD64 i8_result;
1077 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair
1078 {
1079 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1080 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1081 i4_temp_poc = MIN(i4_top_field_order_poc, i4_bot_field_order_poc);
1082 }
1083 else if(!ps_cur_slice->u1_bottom_field_flag)
1084 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1085 else
1086 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1087
1088 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1089 if(IS_OUT_OF_RANGE_S32(i8_result))
1090 {
1091 return ERROR_INV_POC;
1092 }
1093 ps_dec->ps_cur_pic->i4_top_field_order_cnt = (WORD32) i8_result;
1094 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_bottom_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_bottom_field_order_cnt = (WORD32) i8_result;
1100 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
1101 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
1102 }
1103 if(ps_dec->u4_first_slice_in_pic)
1104 {
1105 ret = isvcd_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, &ps_dec->s_prev_pic_poc,
1106 &s_tmp_poc, ps_cur_slice, ps_pps, u1_nal_ref_idc,
1107 u1_bottom_field_flag, u1_field_pic_flag, &i4_poc, ps_dec);
1108 if(ret != OK) return ret;
1109 /* Display seq no calculations */
1110 if(i4_poc >= ps_dec->i4_max_poc) ps_dec->i4_max_poc = i4_poc;
1111 /* IDR Picture or POC wrap around */
1112 if(i4_poc == 0)
1113 {
1114 WORD64 i8_temp;
1115 i8_temp = (WORD64) ps_dec->i4_prev_max_display_seq + ps_dec->i4_max_poc +
1116 ps_dec->u1_max_dec_frame_buffering + 1;
1117 /*If i4_prev_max_display_seq overflows integer range, reset it */
1118 ps_dec->i4_prev_max_display_seq = IS_OUT_OF_RANGE_S32(i8_temp) ? 0 : i8_temp;
1119 ps_dec->i4_max_poc = 0;
1120 }
1121 }
1122
1123 /* Increment only if the current slice has atleast 1 more MB */
1124 if(ps_dec->u4_first_slice_in_pic == 0 &&
1125 (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
1126 (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
1127 {
1128 ps_dec->ps_parse_cur_slice++;
1129 ps_dec->u2_cur_slice_num++;
1130 // in the case of single core increment ps_decode_cur_slice
1131 if(ps_dec->u1_separate_parse == 0)
1132 {
1133 ps_dec->ps_decode_cur_slice++;
1134 }
1135 }
1136
1137 ps_dec->u1_slice_header_done = 0;
1138
1139 /*--------------------------------------------------------------------*/
1140 /* Copy the values read from the bitstream to the slice header and then*/
1141 /* If the slice is first slice in picture, then do Start of Picture */
1142 /* processing. */
1143 /*--------------------------------------------------------------------*/
1144 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
1145 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
1146 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1147 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
1148 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1149 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1150 ps_cur_slice->u1_slice_type = u1_slice_type;
1151 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1152
1153 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1154 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1155 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1156 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1157
1158 if(ps_seq->u1_frame_mbs_only_flag)
1159 ps_cur_slice->u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
1160 else
1161 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
1162
1163 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1164 {
1165 if(B_SLICE == u1_slice_type)
1166 {
1167 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(ps_bitstrm);
1168 COPYTHECONTEXT("Slice Header SVC ext: direct_spatial_mv_pred_flag",
1169 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
1170
1171 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
1172 ps_cur_slice->pf_decodeDirect = isvcd_decode_spatial_direct;
1173 else
1174 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
1175 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1176 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
1177 }
1178 else
1179 {
1180 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag))) /*check if this is valid here */
1181 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1182 }
1183 }
1184
1185 if(ps_dec->u4_first_slice_in_pic)
1186 {
1187 if(u2_first_mb_in_slice == 0)
1188 {
1189 ret = isvcd_start_of_pic(ps_svc_lyr_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
1190 if(ret != OK) return ret;
1191 /*inter layer buffer intialization */
1192 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
1193 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start;
1194 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_cur_mb =
1195 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base;
1196 }
1197
1198 ps_dec->u4_output_present = 0;
1199
1200 {
1201 ih264d_get_next_display_field(ps_dec, ps_dec->ps_out_buffer, &(ps_dec->s_disp_op));
1202 /* If error code is non-zero then there is no buffer available for
1203 display, hence avoid format conversion */
1204
1205 if(0 != ps_dec->s_disp_op.u4_error_code)
1206 {
1207 ps_dec->u4_output_present = 0;
1208 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1209 }
1210 else
1211 ps_dec->u4_output_present = 1;
1212 }
1213 ret = isvcd_parse_interlayer_resamp_func_init(ps_svc_lyr_dec, u2_first_mb_in_slice);
1214 if(ret != OK)
1215 {
1216 return ERROR_CORRUPTED_SLICE;
1217 }
1218 if((ps_dec->u1_separate_parse == 1) &&
1219 (ps_svc_lyr_dec->u1_layer_identifier == TARGET_LAYER) && (ps_svc_lyr_dec->u1_res_init_done == 1))
1220 {
1221 if(ps_dec->u4_dec_thread_created == 0)
1222 {
1223 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1224 (void *) isvcd_decode_picture_thread, (void *) ps_dec);
1225
1226 ps_dec->u4_dec_thread_created = 1;
1227 }
1228 #ifdef KEEP_THREADS_ACTIVE
1229 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
1230 RETURN_IF((ret != IV_SUCCESS), ret);
1231
1232 ps_dec->ai4_process_start[0] = PROC_START;
1233 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
1234 RETURN_IF((ret != IV_SUCCESS), ret);
1235
1236 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
1237 RETURN_IF((ret != IV_SUCCESS), ret);
1238 #endif
1239 #ifdef KEEP_THREADS_ACTIVE
1240 if(ps_dec->u4_bs_deblk_thread_created)
1241 {
1242 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
1243 RETURN_IF((ret != IV_SUCCESS), ret);
1244
1245 ps_dec->ai4_process_start[1] = PROC_START;
1246 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
1247 RETURN_IF((ret != IV_SUCCESS), ret);
1248
1249 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
1250 RETURN_IF((ret != IV_SUCCESS), ret);
1251 }
1252 #endif
1253 }
1254 }
1255
1256 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
1257 {
1258 UWORD8 uc_nofield_nombaff;
1259
1260 uc_nofield_nombaff =
1261 ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) &&
1262 (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) && (u1_slice_type != B_SLICE) &&
1263 (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
1264
1265 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
1266
1267 if(uc_nofield_nombaff)
1268 {
1269 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1270 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1271 }
1272 else
1273 {
1274 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
1275 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
1276 }
1277 }
1278
1279 /*
1280 * Decide whether to decode the current picture or not
1281 */
1282 {
1283 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
1284 if(ps_err->u4_frm_sei_sync == u2_frame_num)
1285 {
1286 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1287 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
1288 }
1289 ps_err->u4_cur_frm = u2_frame_num;
1290 }
1291
1292 /* Decision for decoding if the picture is to be skipped */
1293 {
1294 WORD32 i4_skip_b_pic, i4_skip_p_pic;
1295
1296 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) && (B_SLICE == u1_slice_type) &&
1297 (0 == u1_nal_ref_idc);
1298
1299 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) && (P_SLICE == u1_slice_type) &&
1300 (0 == u1_nal_ref_idc);
1301
1302 /**************************************************************/
1303 /* Skip the B picture if skip mask is set for B picture and */
1304 /* Current B picture is a non reference B picture or there is */
1305 /* no user for reference B picture */
1306 /**************************************************************/
1307 if(i4_skip_b_pic)
1308 {
1309 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1310 /* Don't decode the picture in SKIP-B mode if that picture is B */
1311 /* and also it is not to be used as a reference picture */
1312 ps_dec->u1_last_pic_not_decoded = 1;
1313
1314 return OK;
1315 }
1316 /**************************************************************/
1317 /* Skip the P picture if skip mask is set for P picture and */
1318 /* Current P picture is a non reference P picture or there is */
1319 /* no user for reference P picture */
1320 /**************************************************************/
1321 if(i4_skip_p_pic)
1322 {
1323 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1324 /* Don't decode the picture in SKIP-P mode if that picture is P */
1325 /* and also it is not to be used as a reference picture */
1326 ps_dec->u1_last_pic_not_decoded = 1;
1327
1328 return OK;
1329 }
1330 }
1331
1332 {
1333 UWORD16 u2_mb_x, u2_mb_y;
1334
1335 ps_dec->i4_submb_ofst =
1336 ((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) -
1337 SUB_BLK_SIZE;
1338 if(u2_first_mb_in_slice)
1339 {
1340 UWORD8 u1_mb_aff;
1341 UWORD8 u1_field_pic;
1342 UWORD16 u2_frm_wd_in_mbs;
1343 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
1344 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
1345 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
1346
1347 {
1348 UWORD32 x_offset;
1349 UWORD32 y_offset;
1350 UWORD32 u4_frame_stride;
1351 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse;
1352
1353 if(ps_dec->u1_separate_parse)
1354 {
1355 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1356 }
1357 else
1358 {
1359 ps_trns_addr = &ps_dec->s_tran_addrecon;
1360 }
1361 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1362 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1363
1364 u2_mb_y <<= u1_mb_aff;
1365
1366 if((u2_mb_x > u2_frm_wd_in_mbs - 1) || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
1367 {
1368 return ERROR_CORRUPTED_SLICE;
1369 }
1370
1371 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
1372 x_offset = u2_mb_x << 4;
1373 y_offset = (u2_mb_y * u4_frame_stride) << 4;
1374
1375 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset + y_offset;
1376
1377 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
1378 x_offset >>= 1;
1379 y_offset = (u2_mb_y * u4_frame_stride) << 3;
1380
1381 x_offset *= YUV420SP_FACTOR;
1382
1383 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset + y_offset;
1384 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset + y_offset;
1385
1386 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1387 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1388 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1389
1390 // assign the deblock structure pointers to start of slice
1391 if(ps_dec->u1_separate_parse == 1)
1392 {
1393 ps_dec->ps_deblk_mbn =
1394 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
1395 }
1396 else
1397 {
1398 ps_dec->ps_deblk_mbn =
1399 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
1400 }
1401
1402 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
1403
1404 ps_dec->ps_mv_cur =
1405 ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
1406 }
1407 }
1408 else
1409 {
1410 tfr_ctxt_t *ps_trns_addr;
1411
1412 if(ps_dec->u1_separate_parse)
1413 {
1414 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1415 }
1416 else
1417 {
1418 ps_trns_addr = &ps_dec->s_tran_addrecon;
1419 }
1420
1421 u2_mb_x = 0xffff;
1422 u2_mb_y = 0;
1423 // assign the deblock structure pointers to start of slice
1424 ps_dec->u2_cur_mb_addr = 0;
1425 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
1426 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
1427 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
1428 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
1429 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
1430
1431 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1432 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1433 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1434 }
1435
1436 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1437
1438 ps_dec->u2_mbx = (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1439 ps_dec->u2_mby = (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1440 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
1441 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1442 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1443 }
1444
1445 /* RBSP stop bit is used for CABAC decoding*/
1446 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
1447
1448 ps_dec->u1_B = (u1_slice_type == B_SLICE);
1449 ps_dec->u4_next_mb_skip = 0;
1450
1451 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->ps_cur_slice->u2_first_mb_in_slice;
1452 ps_dec->ps_parse_cur_slice->slice_type = ps_dec->ps_cur_slice->u1_slice_type;
1453
1454 ps_dec->u4_start_recon_deblk = 1;
1455 {
1456 WORD32 num_entries;
1457 WORD32 size;
1458 UWORD8 *pu1_buf;
1459
1460 num_entries = MAX_FRAMES;
1461 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
1462 {
1463 num_entries = 1;
1464 }
1465 num_entries = ((2 * num_entries) + 1);
1466 num_entries *= 2;
1467
1468 size = num_entries * sizeof(void *);
1469 size += PAD_MAP_IDX_POC * sizeof(void *);
1470
1471 pu1_buf = (UWORD8 *) ps_dec->pv_map_ref_idx_to_poc_buf;
1472 pu1_buf += size * ps_dec->u2_cur_slice_num;
1473 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (void *) pu1_buf;
1474 }
1475
1476 if(ps_dec->u1_separate_parse)
1477 {
1478 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1479 }
1480 else
1481 {
1482 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1483 }
1484
1485 ret = ih264d_fix_error_in_dpb(ps_dec);
1486 if(ret < 0) return ERROR_DBP_MANAGER_T;
1487
1488 /*Default initializing default values for some parameters*/
1489 ps_svc_slice_params->u1_slice_skip_flag = 0;
1490 ps_svc_slice_params->u1_adaptive_base_mode_flag = 0;
1491 ps_svc_slice_params->u1_default_base_mode_flag = 0;
1492 ps_svc_slice_params->u1_adaptive_motion_prediction_flag = 0;
1493 ps_svc_slice_params->u1_default_motion_prediction_flag = 0;
1494 ps_svc_slice_params->u1_adaptive_residual_prediction_flag = 0;
1495 ps_svc_slice_params->u1_default_residual_prediction_flag = 0;
1496
1497 if(u1_slice_type == I_SLICE)
1498 {
1499 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
1500
1501 ret = isvcd_parse_eislice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1502 ps_dec->u1_pr_sl_type = u1_slice_type;
1503 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
1504 ps_dec->i4_pic_type = I_SLICE;
1505 }
1506 else if(u1_slice_type == P_SLICE)
1507 {
1508 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1509 ret = isvcd_parse_epslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1510 ps_dec->u1_pr_sl_type = u1_slice_type;
1511 if(ps_dec->i4_pic_type != B_SLICE) ps_dec->i4_pic_type = P_SLICE;
1512 }
1513 else if(u1_slice_type == B_SLICE)
1514 {
1515 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1516 ret = isvcd_parse_ebslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
1517 ps_dec->u1_pr_sl_type = u1_slice_type;
1518 ps_dec->i4_pic_type = B_SLICE;
1519 }
1520 else
1521 return ERROR_INV_SLC_TYPE_T;
1522
1523 if(ps_dec->u1_slice_header_done)
1524 {
1525 /* set to zero to indicate a valid slice has been decoded */
1526 ps_dec->u1_first_slice_in_stream = 0;
1527 }
1528
1529 if(ret != OK) return ret;
1530
1531 if(u1_nal_ref_idc != 0)
1532 {
1533 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
1534 {
1535 memcpy((void *) ps_dec->ps_dpb_cmds, (void *) (&(ps_dec->s_dpb_cmds_scratch)),
1536 sizeof(dpb_commands_t));
1537 }
1538 }
1539
1540 /* storing last Mb X and MbY of the slice */
1541 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1542 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1543
1544 /* End of Picture detection */
1545 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
1546 {
1547 ps_dec->u1_pic_decode_done = 1;
1548 }
1549
1550 {
1551 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
1552 if((ps_err->u1_err_flag & REJECT_PB_PICS) && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1553 {
1554 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1555 }
1556 }
1557
1558 PRINT_BIN_BIT_RATIO(ps_dec)
1559
1560 return ret;
1561 }
1562
1563 /*!
1564 **************************************************************************
1565 * \if Function name : isvcd_set_default_slice_header_ext \endif
1566 *
1567 * \brief
1568 * sets the default values for the svc slice header attr
1569 *
1570 * \return
1571 * 0 on Success and Error code otherwise
1572 **************************************************************************
1573 */
isvcd_set_default_slice_header_ext(svc_dec_lyr_struct_t * ps_svc_lyr_dec)1574 WORD32 isvcd_set_default_slice_header_ext(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
1575 {
1576 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1577 WORD32 i_status = OK;
1578 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
1579 dec_seq_params_t *ps_seq;
1580 dec_svc_seq_params_t *ps_subset_seq;
1581 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1582 dec_subset_seq_params_t *ps_sps_svc_ext = NULL;
1583 ps_seq = ps_pps->ps_sps;
1584 ps_seq += MAX_NUM_SEQ_PARAMS;
1585 ps_subset_seq =
1586 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
1587 ps_sps_svc_ext = &ps_subset_seq->s_sps_svc_ext;
1588 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1589
1590 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1591 {
1592 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1593 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_y_plus1;
1594
1595 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag =
1596 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_x_plus1_flag;
1597 }
1598
1599 ps_svc_slice_params->u4_ref_layer_dq_id = UINT32_MAX;
1600 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc = 0;
1601 ps_svc_slice_params->u1_scan_idx_start = 0;
1602 ps_svc_slice_params->u1_scan_idx_end = 15;
1603 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 = 0;
1604 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 = 0;
1605 ps_svc_slice_params->u1_constrained_intra_resampling_flag = 0;
1606
1607 return i_status;
1608 }
1609
1610 /*!
1611 **************************************************************************
1612 * \if Function name : isvcd_parse_slice_header \endif
1613 *
1614 * \brief
1615 * parses the svc slice header attr
1616 *
1617 * \return
1618 * 0 on Success and Error code otherwise
1619 **************************************************************************
1620 */
isvcd_parse_slice_header(svc_dec_lyr_struct_t * ps_svc_lyr_dec)1621 WORD32 isvcd_parse_slice_header(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
1622 {
1623 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1624 dec_pic_params_t *ps_pps = ps_dec->ps_cur_pps;
1625 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1626 dec_seq_params_t *ps_seq;
1627 dec_svc_seq_params_t *ps_subset_seq;
1628 dec_slice_svc_ext_params_t *ps_svc_slice_params = NULL;
1629 dec_subset_seq_params_t *ps_sps_svc_ext = NULL;
1630 svc_dec_ctxt_t *ps_svcd_ctxt;
1631 UWORD32 *pu4_bitstrm_buf = ps_dec->ps_bitstrm->pu4_buffer;
1632 UWORD32 *pu4_bitstrm_ofst = &ps_dec->ps_bitstrm->u4_ofst;
1633 ps_svcd_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
1634 ps_seq = ps_pps->ps_sps;
1635 ps_seq += MAX_NUM_SEQ_PARAMS;
1636 ps_subset_seq =
1637 &ps_svc_lyr_dec->ps_subset_sps[MAX_NUM_SEQ_PARAMS + ps_seq->u1_seq_parameter_set_id];
1638 ps_sps_svc_ext = &ps_subset_seq->s_sps_svc_ext;
1639 ps_svc_slice_params = &ps_svc_lyr_dec->s_svc_slice_params;
1640
1641 if(!ps_svc_lyr_dec->ps_nal_svc_ext->u1_no_inter_layer_pred_flag &&
1642 (0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id))
1643 {
1644 ps_svc_slice_params->u4_ref_layer_dq_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1645 COPYTHECONTEXT("Slice Header SVC ext: u4_ref_layer_dq_id",
1646 ps_svc_slice_params->u4_ref_layer_dq_id);
1647 if(ps_svc_slice_params->u4_ref_layer_dq_id > MAX_REF_DEP_ID)
1648 {
1649 return ERROR_INV_SLICE_HDR_T;
1650 }
1651 /* Reference layer id update is taken care during resolution init */
1652 /*
1653 ps_svc_lyr_dec->u1_ref_layer_id = ps_svc_slice_params->u4_ref_layer_dq_id >> 4;
1654 if(ps_svc_lyr_dec->u1_ref_layer_id >= ps_svc_lyr_dec->u1_layer_id)
1655 {
1656 return ERROR_INV_SLICE_HDR_T;
1657 }
1658 */
1659 ps_svc_lyr_dec->ps_dec_svc_ref_layer =
1660 &ps_svcd_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_ref_layer_id];
1661
1662 if(ps_sps_svc_ext->u1_inter_layer_deblocking_filter_control_present_flag)
1663 {
1664 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc =
1665 ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1666 COPYTHECONTEXT("Slice Header SVC ext: u4_disable_inter_layer_deblk_filter_idc",
1667 ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc);
1668
1669 if(ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc > 6)
1670 {
1671 return ERROR_INV_SLICE_HDR_T;
1672 }
1673
1674 if(1 != ps_svc_slice_params->u4_disable_inter_layer_deblk_filter_idc)
1675 {
1676 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 =
1677 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1678 COPYTHECONTEXT("Slice Header SVC ext: i4_inter_layer_slice_alpha_c0_offset_div2",
1679 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2);
1680
1681 if(ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 > 6 ||
1682 ps_svc_slice_params->i4_inter_layer_slice_alpha_c0_offset_div2 < -6)
1683 {
1684 return ERROR_INV_SLICE_HDR_T;
1685 }
1686
1687 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 =
1688 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1689 COPYTHECONTEXT("Slice Header SVC ext: i4_inter_layer_slice_beta_offset_div2",
1690 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2);
1691
1692 if(ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 > 6 ||
1693 ps_svc_slice_params->i4_inter_layer_slice_beta_offset_div2 < -6)
1694 {
1695 return ERROR_INV_SLICE_HDR_T;
1696 }
1697 }
1698 }
1699
1700 ps_svc_slice_params->u1_constrained_intra_resampling_flag = ih264d_get_bit_h264(ps_bitstrm);
1701 COPYTHECONTEXT("Slice Header SVC ext: u1_constrained_intra_resampling_flag",
1702 ps_svc_slice_params->u1_constrained_intra_resampling_flag);
1703
1704 ps_svc_lyr_dec->s_res_prms.i1_constrained_intra_rsmpl_flag =
1705 ps_svc_lyr_dec->s_svc_slice_params.u1_constrained_intra_resampling_flag;
1706 isvcd_intra_resamp_res_init_update_flags(ps_svc_lyr_dec);
1707
1708 if(2 == ps_sps_svc_ext->u1_extended_spatial_scalability_idc)
1709 {
1710 /* ChromaArrayType = i4_chroma_format_idc if separate_colour_plane_flag
1711 * = 0 for all chroma format except 4:4:4 */
1712 if(ps_dec->ps_cur_sps->i4_chroma_format_idc >= 0)
1713 {
1714 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag =
1715 ih264d_get_bit_h264(ps_bitstrm);
1716 COPYTHECONTEXT("Slice Header SVC ext: u1_ref_layer_chroma_phase_x_plus1_flag",
1717 ps_svc_slice_params->u1_ref_layer_chroma_phase_x_plus1_flag);
1718
1719 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1720 ih264d_get_bits_h264(ps_bitstrm, 2);
1721 COPYTHECONTEXT("Slice Header SVC ext: u1_ref_layer_chroma_phase_y_plus1",
1722 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1);
1723
1724 if(ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 > 2)
1725 {
1726 return ERROR_INV_SLICE_HDR_T;
1727 }
1728 }
1729 else
1730 {
1731 if(0 == ps_svc_lyr_dec->ps_nal_svc_ext->u1_quality_id)
1732 {
1733 ps_svc_slice_params->u1_ref_layer_chroma_phase_y_plus1 =
1734 ps_sps_svc_ext->u1_seq_ref_layer_chroma_phase_y_plus1;
1735 }
1736 }
1737
1738 ps_svc_slice_params->i4_scaled_ref_layer_left_offset =
1739 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1740 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_left_offset",
1741 ps_svc_slice_params->i4_scaled_ref_layer_left_offset);
1742
1743 if(ps_svc_slice_params->i4_scaled_ref_layer_left_offset != 0)
1744 {
1745 return ERROR_INV_SLICE_HDR_T;
1746 }
1747
1748 if(ps_svc_slice_params->i4_scaled_ref_layer_left_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1749 ps_svc_slice_params->i4_scaled_ref_layer_left_offset < MIN_SCLD_REF_LAYER_OFFSET)
1750 {
1751 return ERROR_INV_SLICE_HDR_T;
1752 }
1753
1754 ps_svc_slice_params->i4_scaled_ref_layer_top_offset =
1755 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1756 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_top_offset",
1757 ps_svc_slice_params->i4_scaled_ref_layer_top_offset);
1758
1759 if(ps_svc_slice_params->i4_scaled_ref_layer_top_offset != 0)
1760 {
1761 return ERROR_INV_SLICE_HDR_T;
1762 }
1763
1764 if(ps_svc_slice_params->i4_scaled_ref_layer_top_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1765 ps_svc_slice_params->i4_scaled_ref_layer_top_offset < MIN_SCLD_REF_LAYER_OFFSET)
1766 {
1767 return ERROR_INV_SLICE_HDR_T;
1768 }
1769
1770 ps_svc_slice_params->i4_scaled_ref_layer_right_offset =
1771 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1772 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_right_offset",
1773 ps_svc_slice_params->i4_scaled_ref_layer_right_offset);
1774
1775 if(ps_svc_slice_params->i4_scaled_ref_layer_right_offset >= MAX_SCLD_REF_LAYER_OFFSET ||
1776 ps_svc_slice_params->i4_scaled_ref_layer_right_offset < MIN_SCLD_REF_LAYER_OFFSET)
1777 {
1778 return ERROR_INV_SLICE_HDR_T;
1779 }
1780
1781 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset =
1782 ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1783 COPYTHECONTEXT("Slice Header SVC ext: i4_scaled_ref_layer_bottom_offset",
1784 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset);
1785
1786 if(ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset >=
1787 MAX_SCLD_REF_LAYER_OFFSET ||
1788 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset < MIN_SCLD_REF_LAYER_OFFSET)
1789 {
1790 return ERROR_INV_SLICE_HDR_T;
1791 }
1792 }
1793 else
1794 {
1795 ps_svc_slice_params->i4_scaled_ref_layer_left_offset =
1796 ps_sps_svc_ext->i4_seq_scaled_ref_layer_left_offset;
1797 ps_svc_slice_params->i4_scaled_ref_layer_top_offset =
1798 ps_sps_svc_ext->i4_seq_scaled_ref_layer_top_offset;
1799 ps_svc_slice_params->i4_scaled_ref_layer_right_offset =
1800 ps_sps_svc_ext->i4_seq_scaled_ref_layer_right_offset;
1801 ps_svc_slice_params->i4_scaled_ref_layer_bottom_offset =
1802 ps_sps_svc_ext->i4_seq_scaled_ref_layer_bottom_offset;
1803 }
1804 }
1805
1806 if(!ps_svc_lyr_dec->ps_nal_svc_ext->u1_no_inter_layer_pred_flag)
1807 {
1808 ps_svc_slice_params->u1_slice_skip_flag = ih264d_get_bit_h264(ps_bitstrm);
1809 COPYTHECONTEXT("Slice Header SVC ext: u1_slice_skip_flag",
1810 ps_svc_slice_params->u1_slice_skip_flag);
1811
1812 if(ps_svc_slice_params->u1_slice_skip_flag)
1813 {
1814 ps_svc_slice_params->u4_num_mbs_in_slice_minus1 =
1815 ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1816 COPYTHECONTEXT("Slice Header SVC ext: u4_num_mbs_in_slice_minus1",
1817 ps_svc_slice_params->u4_num_mbs_in_slice_minus1);
1818 }
1819 else
1820 {
1821 ps_svc_slice_params->u1_adaptive_base_mode_flag = ih264d_get_bit_h264(ps_bitstrm);
1822 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_base_mode_flag",
1823 ps_svc_slice_params->u1_adaptive_base_mode_flag);
1824
1825 if(!ps_svc_slice_params->u1_adaptive_base_mode_flag)
1826 {
1827 ps_svc_slice_params->u1_default_base_mode_flag = ih264d_get_bit_h264(ps_bitstrm);
1828 COPYTHECONTEXT("Slice Header SVC ext: u1_default_base_mode_flag",
1829 ps_svc_slice_params->u1_default_base_mode_flag);
1830 }
1831 if(!ps_svc_slice_params->u1_default_base_mode_flag)
1832 {
1833 ps_svc_slice_params->u1_adaptive_motion_prediction_flag =
1834 ih264d_get_bit_h264(ps_bitstrm);
1835 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_motion_prediction_flag",
1836 ps_svc_slice_params->u1_adaptive_motion_prediction_flag);
1837
1838 if(!ps_svc_slice_params->u1_adaptive_motion_prediction_flag)
1839 {
1840 ps_svc_slice_params->u1_default_motion_prediction_flag =
1841 ih264d_get_bit_h264(ps_bitstrm);
1842 COPYTHECONTEXT("Slice Header SVC ext: u1_default_motion_prediction_flag",
1843 ps_svc_slice_params->u1_default_motion_prediction_flag);
1844 }
1845 }
1846 ps_svc_slice_params->u1_adaptive_residual_prediction_flag =
1847 ih264d_get_bit_h264(ps_bitstrm);
1848 COPYTHECONTEXT("Slice Header SVC ext: u1_adaptive_residual_prediction_flag",
1849 ps_svc_slice_params->u1_adaptive_residual_prediction_flag);
1850
1851 if(!ps_svc_slice_params->u1_adaptive_residual_prediction_flag)
1852 {
1853 ps_svc_slice_params->u1_default_residual_prediction_flag =
1854 ih264d_get_bit_h264(ps_bitstrm);
1855 COPYTHECONTEXT("Slice Header SVC ext: u1_default_residual_prediction_flag",
1856 ps_svc_slice_params->u1_default_residual_prediction_flag);
1857 }
1858 }
1859
1860 if(ps_sps_svc_ext->u1_adaptive_tcoeff_level_prediction_flag)
1861 {
1862 ps_svc_slice_params->u1_tcoeff_level_prediction_flag = ih264d_get_bit_h264(ps_bitstrm);
1863 COPYTHECONTEXT("Slice Header SVC ext: u1_tcoeff_level_prediction_flag",
1864 ps_svc_slice_params->u1_tcoeff_level_prediction_flag);
1865
1866 if(ps_svc_slice_params->u1_tcoeff_level_prediction_flag != 0)
1867 {
1868 return ERROR_INV_SPS_PPS_T;
1869 }
1870 }
1871 }
1872
1873 if(!ps_sps_svc_ext->u1_slice_header_restriction_flag &&
1874 !ps_svc_slice_params->u1_slice_skip_flag)
1875 {
1876 ps_svc_slice_params->u1_scan_idx_start = ih264d_get_bits_h264(ps_bitstrm, 4);
1877 COPYTHECONTEXT("Slice Header SVC ext: u1_scan_idx_start",
1878 ps_svc_slice_params->u1_scan_idx_start);
1879 ps_svc_slice_params->u1_scan_idx_end = ih264d_get_bits_h264(ps_bitstrm, 4);
1880 COPYTHECONTEXT("Slice Header SVC ext: u1_scan_idx_end",
1881 ps_svc_slice_params->u1_scan_idx_end);
1882
1883 if(0 != ps_svc_slice_params->u1_scan_idx_start &&
1884 15 != ps_svc_slice_params->u1_scan_idx_end)
1885 return ERROR_SVC_INV_SCAN_IDX;
1886 }
1887 return OK;
1888 }
1889
1890 /*!
1891 **************************************************************************
1892 * \if Function name : DecodeSlice \endif
1893 *
1894 * \brief
1895 * Parses a slice
1896 *
1897 * \return
1898 * 0 on Success and Error code otherwise
1899 **************************************************************************
1900 */
1901
isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,svc_dec_lyr_struct_t * ps_svc_lyr_dec)1902 WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
1903 svc_dec_lyr_struct_t *ps_svc_lyr_dec /* SVC Decoder parameters */
1904 )
1905 {
1906 dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
1907 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
1908 dec_pic_params_t *ps_pps;
1909 dec_seq_params_t *ps_seq;
1910 dec_svc_seq_params_t *ps_subset_seq;
1911 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
1912 pocstruct_t s_tmp_poc = {0};
1913 WORD32 i_delta_poc[2] = {0};
1914 WORD32 i4_poc = 0;
1915 UWORD16 u2_first_mb_in_slice, u2_frame_num;
1916 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
1917 UWORD32 u4_idr_pic_id = 0;
1918 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
1919 UWORD8 u1_nal_unit_type;
1920 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1921 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1922 WORD8 i1_is_end_of_poc;
1923
1924 WORD32 ret;
1925 WORD32 prev_slice_err, num_mb_skipped;
1926 UWORD8 u1_mbaff;
1927 pocstruct_t *ps_cur_poc;
1928
1929 UWORD32 u4_temp;
1930 WORD32 i_temp;
1931 svc_dec_ctxt_t *psvcd_dec_ctxt;
1932 dec_struct_t *ps_dec_cur_lyr_minus_1;
1933 svc_dec_lyr_struct_t *ps_svc_cur_lyr_dec_minus_1;
1934
1935 /* read FirstMbInSlice and slice type*/
1936 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1937 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1938 if(u2_first_mb_in_slice > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
1939 {
1940 return ERROR_CORRUPTED_SLICE;
1941 }
1942
1943 /*we currently don not support ASO*/
1944 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
1945 (ps_dec->u4_first_slice_in_pic == 0))
1946 {
1947 return ERROR_CORRUPTED_SLICE;
1948 }
1949
1950 if(ps_dec->u4_first_slice_in_pic == 1)
1951 {
1952 if(u2_first_mb_in_slice != 0)
1953 {
1954 return ERROR_CORRUPTED_SLICE;
1955 }
1956 }
1957
1958 COPYTHECONTEXT("SH: first_mb_in_slice", u2_first_mb_in_slice);
1959
1960 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1961 if(u4_temp > 9) return ERROR_INV_SLC_TYPE_T;
1962
1963 u1_slice_type = u4_temp;
1964 COPYTHECONTEXT("SH: slice_type", (u1_slice_type));
1965 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
1966 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
1967 /* will be of same type of current */
1968 if(u1_slice_type > 4)
1969 {
1970 u1_slice_type -= 5;
1971 }
1972
1973 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1974 if(u4_temp & MASK_ERR_PIC_SET_ID) return ERROR_INV_SLICE_HDR_T;
1975 /* discard slice if pic param is invalid */
1976 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp);
1977 ps_pps = &ps_dec->ps_pps[u4_temp];
1978 if(FALSE == ps_pps->u1_is_valid)
1979 {
1980 return ERROR_INV_SLICE_HDR_T;
1981 }
1982 /* slices in a layer should have same PPS id*/
1983 if(UINT32_MAX == ps_svc_lyr_dec->u4_pps_id_for_layer)
1984 {
1985 ps_svc_lyr_dec->u4_pps_id_for_layer = u4_temp;
1986 }
1987 else if(u4_temp != ps_svc_lyr_dec->u4_pps_id_for_layer)
1988 {
1989 return ERROR_INV_SLICE_HDR_T;
1990 }
1991 ps_seq = ps_pps->ps_sps;
1992 ps_dec->ps_cur_sps = ps_seq;
1993 ps_subset_seq = &ps_svc_lyr_dec->ps_subset_sps[ps_seq->u1_seq_parameter_set_id];
1994 ps_svc_lyr_dec->ps_cur_subset_sps = ps_subset_seq;
1995 if(!ps_seq) return ERROR_INV_SLICE_HDR_T;
1996 if(FALSE == ps_seq->u1_is_valid) return ERROR_INV_SLICE_HDR_T;
1997 if(ps_seq->u1_mb_aff_flag) return ERROR_INV_SLICE_HDR_T;
1998 if(ps_seq->u1_level_idc > H264_LEVEL_4_2) return ERROR_INV_SLICE_HDR_T;
1999 if(!ps_seq->u1_frame_mbs_only_flag) return ERROR_INV_SLICE_HDR_T;
2000 if(OK != isvcd_verify_level(ps_seq->u1_level_idc)) return ERROR_INV_SLICE_HDR_T;
2001 if(ps_dec->u1_init_dec_flag == 1)
2002 {
2003 if(ps_dec->u2_frm_wd_in_mbs != ps_seq->u2_frm_wd_in_mbs) return ERROR_INV_SLICE_HDR_T;
2004 if(ps_dec->u2_frm_ht_in_mbs != ps_seq->u2_frm_ht_in_mbs) return ERROR_INV_SLICE_HDR_T;
2005 }
2006
2007 if(ps_seq->u1_profile_idc == BASE_PROFILE_IDC)
2008 {
2009 if(ps_pps->u1_entropy_coding_mode != 0)
2010 {
2011 return ERROR_INV_SPS_PPS_T;
2012 }
2013 }
2014
2015 ps_dec->i4_reorder_depth = ps_subset_seq->i4_reorder_depth;
2016 ps_dec->u2_disp_height = ps_subset_seq->u2_disp_height;
2017 ps_dec->u2_disp_width = ps_subset_seq->u2_disp_width;
2018
2019 if(ps_svc_lyr_dec->u1_layer_id > 0)
2020 {
2021 psvcd_dec_ctxt = ps_svc_lyr_dec->ps_svcd_ctxt;
2022 ps_svc_cur_lyr_dec_minus_1 =
2023 &psvcd_dec_ctxt->ps_svc_dec_lyr[ps_svc_lyr_dec->u1_layer_id - 1];
2024
2025 ps_dec_cur_lyr_minus_1 = &ps_svc_cur_lyr_dec_minus_1->s_dec;
2026
2027 if((ps_dec_cur_lyr_minus_1->u2_pic_wd > ps_subset_seq->u2_pic_wd) ||
2028 (ps_dec_cur_lyr_minus_1->u2_pic_ht > ps_subset_seq->u2_pic_ht))
2029 {
2030 return ERROR_CORRUPTED_SLICE;
2031 }
2032 }
2033
2034 ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
2035 ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
2036 ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
2037
2038 /* Determining the Width and Height of Frame from that of Picture */
2039 ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
2040 ps_dec->u2_frm_ht_y = ps_subset_seq->u2_frm_ht_y;
2041
2042 ps_dec->u2_frm_wd_uv = ps_subset_seq->u2_frm_wd_uv;
2043 ps_dec->u2_frm_ht_uv = ps_subset_seq->u2_frm_ht_uv;
2044
2045 ps_dec->s_pad_mgr.u1_pad_len_y_v = ps_subset_seq->u1_pad_len_y_v;
2046 ps_dec->s_pad_mgr.u1_pad_len_cr_v = ps_subset_seq->u1_pad_len_cr_v;
2047 ps_dec->u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
2048 ps_dec->u2_frm_ht_in_mbs = ps_seq->u2_frm_ht_in_mbs;
2049
2050 ps_dec->u2_crop_offset_y = ps_subset_seq->u2_crop_offset_y;
2051 ps_dec->u2_crop_offset_uv = ps_subset_seq->u2_crop_offset_uv;
2052
2053 /* Get the frame num */
2054 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_bits_in_frm_num);
2055 COPYTHECONTEXT("SH: frame_num", u2_frame_num);
2056
2057 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
2058 {
2059 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
2060 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
2061
2062 ps_dec->u2_mbx = 0xffff;
2063 ps_dec->u2_mby = 0;
2064
2065 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
2066 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
2067
2068 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) ps_dec->u2_prev_ref_frame_num = 0;
2069
2070 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
2071 {
2072 isvcd_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
2073 }
2074
2075 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
2076 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
2077 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
2078 if(ps_cur_slice->u1_nal_ref_idc)
2079 {
2080 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
2081 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
2082 ps_prev_poc->i4_delta_pic_order_cnt_bottom = ps_cur_poc->i4_delta_pic_order_cnt_bottom;
2083 ps_prev_poc->i4_delta_pic_order_cnt[0] = ps_cur_poc->i4_delta_pic_order_cnt[0];
2084 ps_prev_poc->i4_delta_pic_order_cnt[1] = ps_cur_poc->i4_delta_pic_order_cnt[1];
2085 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
2086 }
2087
2088 ps_dec->u2_total_mbs_coded = 0;
2089 }
2090 /* Get the field related flags */
2091 if(!ps_seq->u1_frame_mbs_only_flag)
2092 {
2093 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
2094 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag);
2095 u1_bottom_field_flag = 0;
2096
2097 if(u1_field_pic_flag)
2098 {
2099 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan_fld;
2100 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
2101 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag);
2102 }
2103 else
2104 {
2105 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
2106 }
2107 }
2108 else
2109 {
2110 u1_field_pic_flag = 0;
2111 u1_bottom_field_flag = 0;
2112
2113 ps_dec->pu1_inv_scan = (UWORD8 *) gau1_ih264d_inv_scan;
2114 }
2115
2116 u1_nal_unit_type = SLICE_NAL;
2117 if(u1_is_idr_slice)
2118 {
2119 u1_nal_unit_type = IDR_SLICE_NAL;
2120 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2121 if(u4_idr_pic_id > 65535) return ERROR_INV_SLICE_HDR_T;
2122 COPYTHECONTEXT("SH: ", u4_idr_pic_id);
2123 }
2124
2125 /* read delta pic order count information*/
2126 i_delta_poc[0] = i_delta_poc[1] = 0;
2127 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
2128 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
2129 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
2130 if(u1_pic_order_cnt_type == 0)
2131 {
2132 i_temp = ih264d_get_bits_h264(ps_bitstrm, ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
2133 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) return ERROR_INV_SLICE_HDR_T;
2134 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
2135 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
2136
2137 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
2138 {
2139 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2140 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom",
2141 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
2142 }
2143 }
2144
2145 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
2146 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
2147 if(u1_pic_order_cnt_type == 1 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
2148 {
2149 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2150 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]", s_tmp_poc.i4_delta_pic_order_cnt[0]);
2151
2152 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
2153 {
2154 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2155 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]", s_tmp_poc.i4_delta_pic_order_cnt[1]);
2156 }
2157 }
2158
2159 if(ps_pps->u1_redundant_pic_cnt_present_flag)
2160 {
2161 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
2162 if(u4_temp > MAX_REDUNDANT_PIC_CNT) return ERROR_INV_SLICE_HDR_T;
2163 u1_redundant_pic_cnt = u4_temp;
2164 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt);
2165 }
2166
2167 /*--------------------------------------------------------------------*/
2168 /* Check if the slice is part of new picture */
2169 /*--------------------------------------------------------------------*/
2170 /* First slice of a picture is always considered as part of new picture */
2171 i1_is_end_of_poc = 1;
2172 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
2173
2174 if(ps_dec->u4_first_slice_in_pic == 0)
2175 {
2176 i1_is_end_of_poc =
2177 ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, &s_tmp_poc, &ps_dec->s_cur_pic_poc,
2178 ps_cur_slice, u1_pic_order_cnt_type, u1_nal_unit_type,
2179 u4_idr_pic_id, u1_field_pic_flag, u1_bottom_field_flag);
2180 if(i1_is_end_of_poc)
2181 {
2182 ps_dec->u1_first_slice_in_stream = 0;
2183 return ERROR_INCOMPLETE_FRAME;
2184 }
2185 }
2186
2187 /*--------------------------------------------------------------------*/
2188 /* Check for error in slice and parse the missing/corrupted MB's */
2189 /* as skip-MB's in an inserted P-slice */
2190 /*--------------------------------------------------------------------*/
2191 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
2192 prev_slice_err = 0;
2193
2194 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
2195 {
2196 /* If the current slice is not a field or frame number of the current
2197 * slice doesn't match with previous slice, and decoder is expecting
2198 * to decode a field i.e. ps_dec->u1_top_bottom_decoded is not 0 and
2199 * is not (TOP_FIELD_ONLY | BOT_FIELD_ONLY), treat it as a dangling
2200 * field */
2201 if((u1_field_pic_flag == 0 || u2_frame_num != ps_dec->u2_prv_frame_num) &&
2202 ps_dec->u1_top_bottom_decoded != 0 &&
2203 ps_dec->u1_top_bottom_decoded != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
2204 {
2205 ps_dec->u1_dangling_field = 1;
2206 if(ps_dec->u4_first_slice_in_pic)
2207 {
2208 // first slice - dangling field
2209 prev_slice_err = 1;
2210 }
2211 else
2212 {
2213 // last slice - dangling field
2214 prev_slice_err = 2;
2215 }
2216
2217 if(ps_dec->u1_top_bottom_decoded == TOP_FIELD_ONLY)
2218 ps_cur_slice->u1_bottom_field_flag = 1;
2219 else
2220 ps_cur_slice->u1_bottom_field_flag = 0;
2221
2222 num_mb_skipped =
2223 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
2224 ps_cur_poc = &ps_dec->s_cur_pic_poc;
2225
2226 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
2227 }
2228 else if(ps_dec->u4_first_slice_in_pic)
2229 {
2230 if(u2_first_mb_in_slice > 0)
2231 {
2232 /* first slice - missing/header corruption */
2233 prev_slice_err = 1;
2234 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
2235 ps_cur_poc = &s_tmp_poc;
2236
2237 /* initializing slice parameters */
2238 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
2239 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
2240 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
2241 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
2242 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
2243 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
2244 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
2245 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
2246 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
2247 }
2248 }
2249 else
2250 {
2251 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so
2252 * conceal the current frame completely */
2253 prev_slice_err = 2;
2254 num_mb_skipped =
2255 (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
2256 ps_cur_poc = &s_tmp_poc;
2257 }
2258 }
2259 else
2260 {
2261 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
2262 {
2263 // previous slice - missing/corruption
2264 prev_slice_err = 2;
2265 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
2266 ps_cur_poc = &s_tmp_poc;
2267 }
2268 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
2269 {
2270 return ERROR_CORRUPTED_SLICE;
2271 }
2272 }
2273 if(prev_slice_err)
2274 {
2275 ret = isvcd_mark_err_slice_skip((svc_dec_lyr_struct_t *) ps_dec, num_mb_skipped,
2276 u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
2277
2278 if(ps_dec->u1_dangling_field == 1)
2279 {
2280 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
2281 ps_dec->u1_first_slice_in_stream = 0;
2282 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;
2283 return ERROR_DANGLING_FIELD_IN_PIC;
2284 }
2285
2286 if(prev_slice_err == 2)
2287 {
2288 ps_dec->u1_first_slice_in_stream = 0;
2289 return ERROR_INCOMPLETE_FRAME;
2290 }
2291
2292 if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
2293 {
2294 /* return if all MBs in frame are parsed*/
2295 ps_dec->u1_first_slice_in_stream = 0;
2296 return ERROR_IN_LAST_SLICE_OF_PIC;
2297 }
2298
2299 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
2300 {
2301 ih264d_err_pic_dispbuf_mgr(ps_dec);
2302 return ERROR_NEW_FRAME_EXPECTED;
2303 }
2304
2305 if(ret != OK) return ret;
2306
2307 i1_is_end_of_poc = 0;
2308 }
2309
2310 if(u1_field_pic_flag)
2311 {
2312 ps_dec->u2_prv_frame_num = u2_frame_num;
2313 }
2314
2315 if(ps_cur_slice->u1_mmco_equalto5 && NULL != ps_dec->ps_cur_pic)
2316 {
2317 WORD32 i4_temp_poc;
2318 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
2319 WORD64 i8_result;
2320 if(!ps_cur_slice->u1_field_pic_flag)
2321 {
2322 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2323 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2324 i4_temp_poc = MIN(i4_top_field_order_poc, i4_bot_field_order_poc);
2325 }
2326 else if(!ps_cur_slice->u1_bottom_field_flag)
2327 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2328 else
2329 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2330
2331 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
2332 if(IS_OUT_OF_RANGE_S32(i8_result))
2333 {
2334 return ERROR_INV_POC;
2335 }
2336 ps_dec->ps_cur_pic->i4_top_field_order_cnt = (WORD32) i8_result;
2337 i8_result = (WORD64) i4_temp_poc - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
2338 if(IS_OUT_OF_RANGE_S32(i8_result))
2339 {
2340 return ERROR_INV_POC;
2341 }
2342 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = (WORD32) i8_result;
2343 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
2344 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
2345 }
2346 if(ps_dec->u4_first_slice_in_pic)
2347 {
2348 ret = isvcd_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, &ps_dec->s_prev_pic_poc,
2349 &s_tmp_poc, ps_cur_slice, ps_pps, u1_nal_ref_idc,
2350 u1_bottom_field_flag, u1_field_pic_flag, &i4_poc, ps_dec);
2351 if(ret != OK) return ret;
2352 /* Display seq no calculations */
2353 if(i4_poc >= ps_dec->i4_max_poc) ps_dec->i4_max_poc = i4_poc;
2354 /* IDR Picture or POC wrap around */
2355 if(i4_poc == 0)
2356 {
2357 WORD64 i8_temp;
2358 i8_temp = (WORD64) ps_dec->i4_prev_max_display_seq + ps_dec->i4_max_poc +
2359 ps_dec->u1_max_dec_frame_buffering + 1;
2360 /*If i4_prev_max_display_seq overflows integer range, reset it */
2361 ps_dec->i4_prev_max_display_seq = IS_OUT_OF_RANGE_S32(i8_temp) ? 0 : i8_temp;
2362 ps_dec->i4_max_poc = 0;
2363 }
2364 }
2365
2366 /* Increment only if the current slice has atleast 1 more MB */
2367 if(ps_dec->u4_first_slice_in_pic == 0 &&
2368 (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
2369 (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
2370 {
2371 ps_dec->ps_parse_cur_slice++;
2372 ps_dec->u2_cur_slice_num++;
2373 // in the case of single core increment ps_decode_cur_slice
2374 if(ps_dec->u1_separate_parse == 0)
2375 {
2376 ps_dec->ps_decode_cur_slice++;
2377 }
2378 }
2379
2380 ps_dec->u1_slice_header_done = 0;
2381
2382 /*--------------------------------------------------------------------*/
2383 /* Copy the values read from the bitstream to the slice header and then*/
2384 /* If the slice is first slice in picture, then do Start of Picture */
2385 /* processing. */
2386 /*--------------------------------------------------------------------*/
2387 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
2388 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
2389 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
2390 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
2391 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
2392 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
2393 ps_cur_slice->u1_slice_type = u1_slice_type;
2394 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
2395
2396 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
2397 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
2398 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
2399 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
2400
2401 if(ps_seq->u1_frame_mbs_only_flag)
2402 ps_cur_slice->u1_direct_8x8_inference_flag = ps_seq->u1_direct_8x8_inference_flag;
2403 else
2404 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
2405
2406 if(u1_slice_type == B_SLICE)
2407 {
2408 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(ps_bitstrm);
2409 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag",
2410 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
2411
2412 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
2413 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
2414 else
2415 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
2416 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
2417 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
2418 }
2419 else
2420 {
2421 if(!((ps_seq->u1_mb_aff_flag) && (!u1_field_pic_flag)))
2422 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
2423 }
2424
2425 if(ps_dec->u4_first_slice_in_pic)
2426 {
2427 if(u2_first_mb_in_slice == 0)
2428 {
2429 ret = isvcd_start_of_pic(ps_svc_lyr_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
2430 if(ret != OK) return ret;
2431 /*inter layer buffer intialization */
2432 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_cur_mb =
2433 ps_svc_lyr_dec->ps_inter_lyr_mb_prms_frm_start;
2434 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_cur_mb =
2435 ps_svc_lyr_dec->ps_il_pred_mv_bank_buf_base;
2436 }
2437
2438 ps_dec->u4_output_present = 0;
2439
2440 {
2441 ih264d_get_next_display_field(ps_dec, ps_dec->ps_out_buffer, &(ps_dec->s_disp_op));
2442 /* If error code is non-zero then there is no buffer available for
2443 display, hence avoid format conversion */
2444
2445 if(0 != ps_dec->s_disp_op.u4_error_code)
2446 {
2447 ps_dec->u4_output_present = 0;
2448 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
2449 }
2450 else
2451 ps_dec->u4_output_present = 1;
2452 }
2453 ret = isvcd_parse_interlayer_resamp_func_init(ps_svc_lyr_dec, u2_first_mb_in_slice);
2454 if(ret != OK)
2455 {
2456 return ERROR_CORRUPTED_SLICE;
2457 }
2458 if((ps_dec->u1_separate_parse == 1) && (ps_svc_lyr_dec->u1_res_init_done == 1))
2459 {
2460 if(ps_dec->u4_dec_thread_created == 0)
2461 {
2462 if(ps_svc_lyr_dec->u1_layer_identifier != TARGET_LAYER)
2463 {
2464 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
2465 (void *) isvcd_decode_picture_thread, (void *) ps_dec);
2466
2467 ps_dec->u4_dec_thread_created = 1;
2468 }
2469 else
2470 {
2471 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
2472 (void *) ih264d_decode_picture_thread, (void *) ps_dec);
2473
2474 ps_dec->u4_dec_thread_created = 1;
2475 }
2476 }
2477 #ifdef KEEP_THREADS_ACTIVE
2478 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]);
2479 RETURN_IF((ret != IV_SUCCESS), ret);
2480
2481 ps_dec->ai4_process_start[0] = PROC_START;
2482 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[0]);
2483 RETURN_IF((ret != IV_SUCCESS), ret);
2484
2485 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]);
2486 RETURN_IF((ret != IV_SUCCESS), ret);
2487 #endif
2488 #ifdef KEEP_THREADS_ACTIVE
2489 if(ps_dec->u4_bs_deblk_thread_created)
2490 {
2491 ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]);
2492 RETURN_IF((ret != IV_SUCCESS), ret);
2493
2494 ps_dec->ai4_process_start[1] = PROC_START;
2495 ret = ithread_cond_signal(ps_dec->apv_proc_start_condition[1]);
2496 RETURN_IF((ret != IV_SUCCESS), ret);
2497
2498 ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]);
2499 RETURN_IF((ret != IV_SUCCESS), ret);
2500 }
2501 #endif
2502 }
2503 }
2504
2505 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
2506 {
2507 UWORD8 uc_nofield_nombaff;
2508
2509 uc_nofield_nombaff =
2510 ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) &&
2511 (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) && (u1_slice_type != B_SLICE) &&
2512 (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
2513
2514 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
2515
2516 if(uc_nofield_nombaff)
2517 {
2518 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
2519 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
2520 }
2521 else
2522 {
2523 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
2524 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
2525 }
2526 }
2527
2528 /*
2529 * Decide whether to decode the current picture or not
2530 */
2531 {
2532 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
2533 if(ps_err->u4_frm_sei_sync == u2_frame_num)
2534 {
2535 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
2536 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
2537 }
2538 ps_err->u4_cur_frm = u2_frame_num;
2539 }
2540
2541 /* Decision for decoding if the picture is to be skipped */
2542 {
2543 WORD32 i4_skip_b_pic, i4_skip_p_pic;
2544
2545 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) && (B_SLICE == u1_slice_type) &&
2546 (0 == u1_nal_ref_idc);
2547
2548 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) && (P_SLICE == u1_slice_type) &&
2549 (0 == u1_nal_ref_idc);
2550
2551 /**************************************************************/
2552 /* Skip the B picture if skip mask is set for B picture and */
2553 /* Current B picture is a non reference B picture or there is */
2554 /* no user for reference B picture */
2555 /**************************************************************/
2556 if(i4_skip_b_pic)
2557 {
2558 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
2559 /* Don't decode the picture in SKIP-B mode if that picture is B */
2560 /* and also it is not to be used as a reference picture */
2561 ps_dec->u1_last_pic_not_decoded = 1;
2562
2563 return OK;
2564 }
2565 /**************************************************************/
2566 /* Skip the P picture if skip mask is set for P picture and */
2567 /* Current P picture is a non reference P picture or there is */
2568 /* no user for reference P picture */
2569 /**************************************************************/
2570 if(i4_skip_p_pic)
2571 {
2572 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
2573 /* Don't decode the picture in SKIP-P mode if that picture is P */
2574 /* and also it is not to be used as a reference picture */
2575 ps_dec->u1_last_pic_not_decoded = 1;
2576
2577 return OK;
2578 }
2579 }
2580
2581 {
2582 UWORD16 u2_mb_x, u2_mb_y;
2583
2584 ps_dec->i4_submb_ofst =
2585 ((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) -
2586 SUB_BLK_SIZE;
2587 if(u2_first_mb_in_slice)
2588 {
2589 UWORD8 u1_mb_aff;
2590 UWORD8 u1_field_pic;
2591 UWORD16 u2_frm_wd_in_mbs;
2592 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
2593 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
2594 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
2595
2596 {
2597 UWORD32 x_offset;
2598 UWORD32 y_offset;
2599 UWORD32 u4_frame_stride;
2600 tfr_ctxt_t *ps_trns_addr;
2601
2602 if(ps_dec->u1_separate_parse)
2603 {
2604 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
2605 }
2606 else
2607 {
2608 ps_trns_addr = &ps_dec->s_tran_addrecon;
2609 }
2610 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
2611 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
2612
2613 u2_mb_y <<= u1_mb_aff;
2614
2615 if((u2_mb_x > u2_frm_wd_in_mbs - 1) || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
2616 {
2617 return ERROR_CORRUPTED_SLICE;
2618 }
2619
2620 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
2621 x_offset = u2_mb_x << 4;
2622 y_offset = (u2_mb_y * u4_frame_stride) << 4;
2623
2624 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset + y_offset;
2625
2626 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
2627 x_offset >>= 1;
2628 y_offset = (u2_mb_y * u4_frame_stride) << 3;
2629
2630 x_offset *= YUV420SP_FACTOR;
2631
2632 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset + y_offset;
2633 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset + y_offset;
2634
2635 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
2636 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
2637 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
2638
2639 /* assign the deblock structure pointers to start of slice */
2640 if(ps_dec->u1_separate_parse == 1)
2641 {
2642 ps_dec->ps_deblk_mbn =
2643 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
2644 }
2645 else
2646 {
2647 ps_dec->ps_deblk_mbn =
2648 ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
2649 }
2650
2651 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
2652
2653 ps_dec->ps_mv_cur =
2654 ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
2655 }
2656 }
2657 else
2658 {
2659 tfr_ctxt_t *ps_trns_addr;
2660
2661 if(ps_dec->u1_separate_parse)
2662 {
2663 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
2664 }
2665 else
2666 {
2667 ps_trns_addr = &ps_dec->s_tran_addrecon;
2668 }
2669
2670 u2_mb_x = 0xffff;
2671 u2_mb_y = 0;
2672 // assign the deblock structure pointers to start of slice
2673 ps_dec->u2_cur_mb_addr = 0;
2674 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
2675 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
2676 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
2677 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
2678 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
2679
2680 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
2681 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
2682 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
2683 }
2684
2685 ps_dec->ps_part = ps_dec->ps_parse_part_params;
2686
2687 ps_dec->u2_mbx = (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
2688 ps_dec->u2_mby = (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
2689 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
2690 ps_dec->i2_prev_slice_mbx = (WORD16) ps_dec->u2_mbx;
2691 ps_dec->i2_prev_slice_mby = (WORD16) ps_dec->u2_mby;
2692 }
2693
2694 /* RBSP stop bit is used for CABAC decoding*/
2695 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
2696
2697 ps_dec->u1_B = (u1_slice_type == B_SLICE);
2698 ps_dec->u4_next_mb_skip = 0;
2699
2700 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->ps_cur_slice->u2_first_mb_in_slice;
2701 ps_dec->ps_parse_cur_slice->slice_type = ps_dec->ps_cur_slice->u1_slice_type;
2702
2703 ps_dec->u4_start_recon_deblk = 1;
2704 {
2705 WORD32 num_entries;
2706 WORD32 size;
2707 UWORD8 *pu1_buf;
2708
2709 num_entries = MAX_FRAMES;
2710 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && (0 == ps_dec->i4_display_delay))
2711 {
2712 num_entries = 1;
2713 }
2714 num_entries = ((2 * num_entries) + 1);
2715 num_entries *= 2;
2716
2717 size = num_entries * sizeof(void *);
2718 size += PAD_MAP_IDX_POC * sizeof(void *);
2719
2720 pu1_buf = (UWORD8 *) ps_dec->pv_map_ref_idx_to_poc_buf;
2721 pu1_buf += size * ps_dec->u2_cur_slice_num;
2722 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (void *) pu1_buf;
2723 }
2724
2725 if(ps_dec->u1_separate_parse)
2726 {
2727 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
2728 }
2729 else
2730 {
2731 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
2732 }
2733
2734 ret = ih264d_fix_error_in_dpb(ps_dec);
2735 if(ret < 0) return ERROR_DBP_MANAGER_T;
2736
2737 if(u1_slice_type == I_SLICE)
2738 {
2739 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
2740
2741 ret = isvcd_parse_islice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2742 ps_dec->u1_pr_sl_type = u1_slice_type;
2743 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
2744 ps_dec->i4_pic_type = I_SLICE;
2745 }
2746 else if(u1_slice_type == P_SLICE)
2747 {
2748 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
2749 ret = isvcd_parse_pslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2750 ps_dec->u1_pr_sl_type = u1_slice_type;
2751 if(ps_dec->i4_pic_type != B_SLICE) ps_dec->i4_pic_type = P_SLICE;
2752 }
2753 else if(u1_slice_type == B_SLICE)
2754 {
2755 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
2756 ret = isvcd_parse_bslice(ps_svc_lyr_dec, u2_first_mb_in_slice);
2757 ps_dec->u1_pr_sl_type = u1_slice_type;
2758 ps_dec->i4_pic_type = B_SLICE;
2759 }
2760 else
2761 return ERROR_INV_SLC_TYPE_T;
2762
2763 if(ps_dec->u1_slice_header_done)
2764 {
2765 /* set to zero to indicate a valid slice has been decoded */
2766 ps_dec->u1_first_slice_in_stream = 0;
2767 }
2768
2769 if(ret != OK) return ret;
2770
2771 if(u1_nal_ref_idc != 0)
2772 {
2773 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
2774 {
2775 memcpy((void *) ps_dec->ps_dpb_cmds, (void *) (&(ps_dec->s_dpb_cmds_scratch)),
2776 sizeof(dpb_commands_t));
2777 }
2778 }
2779
2780 /* storing last Mb X and MbY of the slice */
2781 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
2782 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
2783
2784 /* End of Picture detection */
2785
2786 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
2787 {
2788 ps_dec->u1_pic_decode_done = 1;
2789 }
2790
2791 {
2792 dec_err_status_t *ps_err = ps_dec->ps_dec_err_status;
2793 if((ps_err->u1_err_flag & REJECT_PB_PICS) && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
2794 {
2795 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
2796 }
2797 }
2798
2799 PRINT_BIN_BIT_RATIO(ps_dec)
2800
2801 return ret;
2802 }