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