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