1 /******************************************************************************
2 *
3 * Copyright (C) 2015 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 ih264d_parse_slice.c
23 *
24 * \brief
25 * Contains routines that decodes a slice NAL unit
26 *
27 * \date
28 * 19/12/2002
29 *
30 * \author AI
31 **************************************************************************
32 */
33 #include <string.h>
34 #include "ih264_typedefs.h"
35 #include "ih264_macros.h"
36 #include "ih264_platform_macros.h"
37 #include "ithread.h"
38 #include "ih264d_structs.h"
39 #include "ih264d_debug.h"
40 #include "ih264d_bitstrm.h"
41 #include "ih264d_parse_mb_header.h"
42 #include "ih264d_process_bslice.h"
43 #include "ih264d_process_pslice.h"
44 #include "ih264d_parse_cavlc.h"
45 #include "ih264d_utils.h"
46 #include "ih264d_deblocking.h"
47 #include "ih264d_defs.h"
48 #include "ih264d_error_handler.h"
49 #include "ih264d_tables.h"
50 #include "ih264d_defs.h"
51 #include "ih264d_mem_request.h"
52 #include "ih264d_parse_islice.h"
53 #include "ih264d_parse_slice.h"
54 #include "ih264d_mvpred.h"
55 #include "ih264d_mb_utils.h"
56
57 #include "ih264d_defs.h"
58 #include "ih264d_quant_scaling.h"
59
60 #include "ih264d_inter_pred.h"
61
62 #include "ih264d_sei.h"
63 #include "ih264d.h"
64 #include "ih264_error.h"
65 #include "ih264_disp_mgr.h"
66 #include "ih264_buf_mgr.h"
67
68 #include "ih264d_thread_parse_decode.h"
69 #include "ih264d_thread_compute_bs.h"
70 #include "ih264d_dpb_manager.h"
71 #include <assert.h>
72 #include "ih264d_parse_islice.h"
73 #define RET_LAST_SKIP 0x80000000
74
75 WORD32 check_app_out_buf_size(dec_struct_t *ps_dec);
76 /*!
77 **************************************************************************
78 * \if Function name : ih264d_form_pred_weight_matrix \endif
79 *
80 * \brief
81 * Forms pred weight matrix.
82 *
83 * \return
84 * None
85 *
86 **************************************************************************
87 */
88
ih264d_form_pred_weight_matrix(dec_struct_t * ps_dec)89 void ih264d_form_pred_weight_matrix(dec_struct_t *ps_dec)
90 {
91 dec_slice_params_t *ps_cur_slice;
92 UWORD8 uc_num_ref_idx_l0_active, uc_num_ref_idx_l1_active;
93 UWORD8 i, j;
94 UWORD32 *pu4_mat_iwt_ofst;
95 UWORD16 i2_idx;
96 UWORD32 *pui32_weight_offset_l0, *pui32_weight_offset_l1;
97 UWORD32 u4_temp;
98
99 ps_cur_slice = ps_dec->ps_cur_slice;
100 uc_num_ref_idx_l0_active = ps_cur_slice->u1_num_ref_idx_lx_active[0];
101 uc_num_ref_idx_l1_active = ps_cur_slice->u1_num_ref_idx_lx_active[1];
102
103 pu4_mat_iwt_ofst = ps_dec->pu4_wts_ofsts_mat;
104
105 if(ps_cur_slice->u1_slice_type == B_SLICE)
106 {
107 for(i = 0; i < uc_num_ref_idx_l0_active; i++)
108 {
109 pui32_weight_offset_l0 = ps_cur_slice->u4_wt_ofst_lx[0][i];
110 for(j = 0; j < uc_num_ref_idx_l1_active; j++)
111 {
112 pui32_weight_offset_l1 = ps_cur_slice->u4_wt_ofst_lx[1][j];
113 i2_idx = i * uc_num_ref_idx_l0_active + j;
114 i2_idx = X3(i2_idx);
115 /* u4_temp = (pui32_weight_offset_l0[0] | (pui32_weight_offset_l1[0] << 16));
116 pu4_mat_iwt_ofst[0] = u4_temp;
117 u4_temp = (pui32_weight_offset_l0[1] | (pui32_weight_offset_l1[1] << 16));
118 pu4_mat_iwt_ofst[1] = u4_temp;
119 u4_temp = (pui32_weight_offset_l0[2] | (pui32_weight_offset_l1[2] << 16));
120 pu4_mat_iwt_ofst[2] = u4_temp;
121 pu4_mat_iwt_ofst += 3;*/
122 pu4_mat_iwt_ofst[0] = pui32_weight_offset_l0[0];
123 pu4_mat_iwt_ofst[1] = pui32_weight_offset_l1[0];
124 pu4_mat_iwt_ofst[2] = pui32_weight_offset_l0[1];
125 pu4_mat_iwt_ofst[3] = pui32_weight_offset_l1[1];
126 pu4_mat_iwt_ofst[4] = pui32_weight_offset_l0[2];
127 pu4_mat_iwt_ofst[5] = pui32_weight_offset_l1[2];
128 pu4_mat_iwt_ofst += 6;
129 }
130 }
131 }
132 else
133 {
134 for(i = 0; i < uc_num_ref_idx_l0_active; i++)
135 {
136 pui32_weight_offset_l0 = ps_cur_slice->u4_wt_ofst_lx[0][i];
137 i2_idx = X3(i);
138 u4_temp = (UWORD32)pui32_weight_offset_l0[0];
139 pu4_mat_iwt_ofst[0] = u4_temp;
140 u4_temp = (UWORD32)pui32_weight_offset_l0[1];
141 pu4_mat_iwt_ofst[2] = u4_temp;
142 u4_temp = (UWORD32)pui32_weight_offset_l0[2];
143 pu4_mat_iwt_ofst[4] = u4_temp;
144 pu4_mat_iwt_ofst += 6;
145 }
146 }
147 }
148
149
150 /*!
151 **************************************************************************
152 * \if Function name : init_firstSliceParam \endif
153 *
154 * \brief
155 * Initialize the Parameter required for all the slices for a picture
156 *
157 * \return : Nothing
158 *
159 **************************************************************************
160 */
161
ih264d_start_of_pic(dec_struct_t * ps_dec,WORD32 i4_poc,pocstruct_t * ps_temp_poc,UWORD16 u2_frame_num,dec_pic_params_t * ps_pps)162 WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
163 WORD32 i4_poc,
164 pocstruct_t *ps_temp_poc,
165 UWORD16 u2_frame_num,
166 dec_pic_params_t *ps_pps)
167 {
168 pocstruct_t *ps_prev_poc = &ps_dec->s_cur_pic_poc;
169 pocstruct_t *ps_cur_poc = ps_temp_poc;
170
171 pic_buffer_t *pic_buf;
172
173 ivd_video_decode_op_t * ps_dec_output =
174 (ivd_video_decode_op_t *)ps_dec->pv_dec_out;
175 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
176 dec_seq_params_t *ps_seq = ps_pps->ps_sps;
177 UWORD8 u1_bottom_field_flag = ps_cur_slice->u1_bottom_field_flag;
178 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag;
179 /* high profile related declarations */
180 high_profile_tools_t s_high_profile;
181 WORD32 ret;
182
183 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
184
185 /* check output buffer size given by the application */
186 if(check_app_out_buf_size(ps_dec) != IV_SUCCESS)
187 return IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
188
189 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
190 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
191 ps_prev_poc->i4_delta_pic_order_cnt_bottom =
192 ps_cur_poc->i4_delta_pic_order_cnt_bottom;
193 ps_prev_poc->i4_delta_pic_order_cnt[0] =
194 ps_cur_poc->i4_delta_pic_order_cnt[0];
195 ps_prev_poc->i4_delta_pic_order_cnt[1] =
196 ps_cur_poc->i4_delta_pic_order_cnt[1];
197 ps_prev_poc->u1_bot_field = ps_dec->ps_cur_slice->u1_bottom_field_flag;
198 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
199 ps_prev_poc->u2_frame_num = u2_frame_num;
200 ps_dec->i1_prev_mb_qp_delta = 0;
201 ps_dec->i1_next_ctxt_idx = 0;
202
203
204 ps_dec->u4_nmb_deblk = 0;
205 if(ps_dec->u4_num_cores == 1)
206 ps_dec->u4_nmb_deblk = 1;
207
208
209
210 if(ps_seq->u1_mb_aff_flag == 1)
211 {
212 ps_dec->u4_nmb_deblk = 0;
213 if(ps_dec->u4_num_cores > 2)
214 ps_dec->u4_num_cores = 2;
215 }
216
217 ps_dec->u4_use_intrapred_line_copy = 0;
218
219
220
221 if (ps_seq->u1_mb_aff_flag == 0)
222 {
223 ps_dec->u4_use_intrapred_line_copy = 1;
224 }
225
226 ps_dec->u4_app_disable_deblk_frm = 0;
227 /* If degrade is enabled, set the degrade flags appropriately */
228 if(ps_dec->i4_degrade_type && ps_dec->i4_degrade_pics)
229 {
230 WORD32 degrade_pic;
231 ps_dec->i4_degrade_pic_cnt++;
232 degrade_pic = 0;
233
234 /* If degrade is to be done in all frames, then do not check further */
235 switch(ps_dec->i4_degrade_pics)
236 {
237 case 4:
238 {
239 degrade_pic = 1;
240 break;
241 }
242 case 3:
243 {
244 if(ps_cur_slice->u1_slice_type != I_SLICE)
245 degrade_pic = 1;
246
247 break;
248 }
249 case 2:
250 {
251
252 /* If pic count hits non-degrade interval or it is an islice, then do not degrade */
253 if((ps_cur_slice->u1_slice_type != I_SLICE)
254 && (ps_dec->i4_degrade_pic_cnt
255 != ps_dec->i4_nondegrade_interval))
256 degrade_pic = 1;
257
258 break;
259 }
260 case 1:
261 {
262 /* Check if the current picture is non-ref */
263 if(0 == ps_cur_slice->u1_nal_ref_idc)
264 {
265 degrade_pic = 1;
266 }
267 break;
268 }
269
270 }
271 if(degrade_pic)
272 {
273 if(ps_dec->i4_degrade_type & 0x2)
274 ps_dec->u4_app_disable_deblk_frm = 1;
275
276 /* MC degrading is done only for non-ref pictures */
277 if(0 == ps_cur_slice->u1_nal_ref_idc)
278 {
279 if(ps_dec->i4_degrade_type & 0x4)
280 ps_dec->i4_mv_frac_mask = 0;
281
282 if(ps_dec->i4_degrade_type & 0x8)
283 ps_dec->i4_mv_frac_mask = 0;
284 }
285 }
286 else
287 ps_dec->i4_degrade_pic_cnt = 0;
288 }
289
290 {
291 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
292 if((ps_cur_slice->u1_slice_type == I_SLICE)
293 || (ps_cur_slice->u1_slice_type == SI_SLICE))
294 ps_err->u1_cur_pic_type = PIC_TYPE_I;
295 else
296 ps_err->u1_cur_pic_type = PIC_TYPE_UNKNOWN;
297
298 if(ps_err->u1_pic_aud_i == PIC_TYPE_I)
299 {
300 ps_err->u1_cur_pic_type = PIC_TYPE_I;
301 ps_err->u1_pic_aud_i = PIC_TYPE_UNKNOWN;
302 }
303
304 if(ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)
305 {
306 if(ps_err->u1_err_flag)
307 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
308 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
309 }
310 }
311
312 if(ps_dec->u1_init_dec_flag && ps_dec->s_prev_seq_params.u1_eoseq_pending)
313 {
314 /* Reset the decoder picture buffers */
315 WORD32 j;
316 for(j = 0; j < MAX_DISP_BUFS_NEW; j++)
317 {
318
319 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
320 j,
321 BUF_MGR_REF);
322 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
323 ps_dec->au1_pic_buf_id_mv_buf_id_map[j],
324 BUF_MGR_REF);
325 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
326 j,
327 BUF_MGR_IO);
328 }
329
330 /* reset the decoder structure parameters related to buffer handling */
331 ps_dec->u1_second_field = 0;
332 ps_dec->i4_cur_display_seq = 0;
333
334 /********************************************************************/
335 /* indicate in the decoder output i4_status that some frames are being */
336 /* dropped, so that it resets timestamp and wait for a new sequence */
337 /********************************************************************/
338
339 ps_dec->s_prev_seq_params.u1_eoseq_pending = 0;
340 }
341 ret = ih264d_init_pic(ps_dec, u2_frame_num, i4_poc, ps_pps);
342 if(ret != OK)
343 return ret;
344
345 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data;
346 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data;
347 ps_dec->ps_nmb_info = ps_dec->ps_frm_mb_info;
348 if(ps_dec->u1_separate_parse)
349 {
350 UWORD16 pic_wd;
351 UWORD16 pic_ht;
352 UWORD32 num_mbs;
353
354 pic_wd = ps_dec->u2_pic_wd;
355 pic_ht = ps_dec->u2_pic_ht;
356 num_mbs = (pic_wd * pic_ht) >> 8;
357
358 if(ps_dec->pu1_dec_mb_map)
359 {
360 memset((void *)ps_dec->pu1_dec_mb_map, 0, num_mbs);
361 }
362
363 if(ps_dec->pu1_recon_mb_map)
364 {
365
366 memset((void *)ps_dec->pu1_recon_mb_map, 0, num_mbs);
367 }
368
369 if(ps_dec->pu2_slice_num_map)
370 {
371 memset((void *)ps_dec->pu2_slice_num_map, 0,
372 (num_mbs * sizeof(UWORD16)));
373 }
374
375 }
376
377 ps_dec->ps_parse_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
378 ps_dec->ps_decode_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
379 ps_dec->ps_computebs_cur_slice = &(ps_dec->ps_dec_slice_buf[0]);
380 ps_dec->u2_cur_slice_num = 0;
381
382 /* Initialize all the HP toolsets to zero */
383 ps_dec->s_high_profile.u1_scaling_present = 0;
384 ps_dec->s_high_profile.u1_transform8x8_present = 0;
385
386 /* Get Next Free Picture */
387 if(1 == ps_dec->u4_share_disp_buf)
388 {
389 UWORD32 i;
390 /* Free any buffer that is in the queue to be freed */
391 for(i = 0; i < MAX_DISP_BUFS_NEW; i++)
392 {
393 if(0 == ps_dec->u4_disp_buf_to_be_freed[i])
394 continue;
395 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, i,
396 BUF_MGR_IO);
397 ps_dec->u4_disp_buf_to_be_freed[i] = 0;
398 ps_dec->u4_disp_buf_mapping[i] = 0;
399
400 }
401 }
402 if(!(u1_field_pic_flag && 0 != ps_dec->u1_top_bottom_decoded)) //ps_dec->u1_second_field))
403 {
404 pic_buffer_t *ps_cur_pic;
405 WORD32 cur_pic_buf_id, cur_mv_buf_id;
406 col_mv_buf_t *ps_col_mv;
407 while(1)
408 {
409 ps_cur_pic = (pic_buffer_t *)ih264_buf_mgr_get_next_free(
410 (buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
411 &cur_pic_buf_id);
412 if(ps_cur_pic == NULL)
413 {
414 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T;
415 return ERROR_UNAVAIL_PICBUF_T;
416 }
417 if(0 == ps_dec->u4_disp_buf_mapping[cur_pic_buf_id])
418 {
419 break;
420 }
421
422 }
423 ps_col_mv = (col_mv_buf_t *)ih264_buf_mgr_get_next_free((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
424 &cur_mv_buf_id);
425 if(ps_col_mv == NULL)
426 {
427 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T;
428 return ERROR_UNAVAIL_MVBUF_T;
429 }
430
431 ps_dec->ps_cur_pic = ps_cur_pic;
432 ps_dec->u1_pic_buf_id = cur_pic_buf_id;
433 ps_cur_pic->u4_ts = ps_dec->u4_ts;
434
435
436 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id;
437 ps_dec->au1_pic_buf_id_mv_buf_id_map[cur_pic_buf_id] = cur_mv_buf_id;
438
439 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *)ps_col_mv->pv_col_zero_flag;
440 ps_cur_pic->ps_mv = (mv_pred_t *)ps_col_mv->pv_mv;
441 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0;
442
443 {
444 /*make first entry of list0 and list1 point to cur pic,
445 *so that if first slice is in error, ref pic struct will have valid entries*/
446 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0];
447 ps_dec->ps_ref_pic_buf_lx[1] = ps_dec->ps_dpb_mgr->ps_init_dpb[1];
448 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][0]) = *ps_cur_pic;
449 /* Initialize for field reference as well */
450 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic;
451
452 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][0]) = *ps_cur_pic;
453 /* Initialize for field reference as well */
454 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic;
455 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][0]) = *ps_cur_pic;
456 /* Initialize for field reference as well */
457 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic;
458 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][0]) = *ps_cur_pic;
459 /* Initialize for field reference as well */
460 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic;
461 }
462
463 if(!ps_dec->ps_cur_pic)
464 {
465 WORD32 j;
466 H264_DEC_DEBUG_PRINT("------- Display Buffers Reset --------\n");
467 for(j = 0; j < MAX_DISP_BUFS_NEW; j++)
468 {
469
470 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
471 j,
472 BUF_MGR_REF);
473 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
474 ps_dec->au1_pic_buf_id_mv_buf_id_map[j],
475 BUF_MGR_REF);
476 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
477 j,
478 BUF_MGR_IO);
479 }
480
481 ps_dec->i4_cur_display_seq = 0;
482 ps_dec->i4_prev_max_display_seq = 0;
483 ps_dec->i4_max_poc = 0;
484
485 ps_cur_pic = (pic_buffer_t *)ih264_buf_mgr_get_next_free(
486 (buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
487 &cur_pic_buf_id);
488 if(ps_cur_pic == NULL)
489 {
490 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T;
491 return ERROR_UNAVAIL_PICBUF_T;
492 }
493
494 ps_col_mv = (col_mv_buf_t *)ih264_buf_mgr_get_next_free((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
495 &cur_mv_buf_id);
496 if(ps_col_mv == NULL)
497 {
498 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T;
499 return ERROR_UNAVAIL_MVBUF_T;
500 }
501
502 ps_dec->ps_cur_pic = ps_cur_pic;
503 ps_dec->u1_pic_buf_id = cur_pic_buf_id;
504 ps_cur_pic->u4_ts = ps_dec->u4_ts;
505 ps_dec->apv_buf_id_pic_buf_map[cur_pic_buf_id] = (void *)ps_cur_pic;
506
507 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id;
508 ps_dec->au1_pic_buf_id_mv_buf_id_map[cur_pic_buf_id] = cur_mv_buf_id;
509
510 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *)ps_col_mv->pv_col_zero_flag;
511 ps_cur_pic->ps_mv = (mv_pred_t *)ps_col_mv->pv_mv;
512 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0;
513
514 }
515
516 ps_dec->ps_cur_pic->u1_picturetype = u1_field_pic_flag;
517 ps_dec->ps_cur_pic->u4_pack_slc_typ = SKIP_NONE;
518 H264_DEC_DEBUG_PRINT("got a buffer\n");
519 }
520 else
521 {
522 H264_DEC_DEBUG_PRINT("did not get a buffer\n");
523 }
524
525 ps_dec->u4_pic_buf_got = 1;
526
527 ps_dec->ps_cur_pic->i4_poc = i4_poc;
528 ps_dec->ps_cur_pic->i4_frame_num = u2_frame_num;
529 ps_dec->ps_cur_pic->i4_pic_num = u2_frame_num;
530 ps_dec->ps_cur_pic->i4_top_field_order_cnt = ps_pps->i4_top_field_order_cnt;
531 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt =
532 ps_pps->i4_bottom_field_order_cnt;
533 ps_dec->ps_cur_pic->i4_avg_poc = ps_pps->i4_avg_poc;
534 ps_dec->ps_cur_pic->u4_time_stamp = ps_dec->u4_pts;
535
536 ps_dec->s_cur_pic = *(ps_dec->ps_cur_pic);
537 if(u1_field_pic_flag && u1_bottom_field_flag)
538 {
539 WORD32 i4_temp_poc;
540 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
541 /* Point to odd lines, since it's bottom field */
542 ps_dec->s_cur_pic.pu1_buf1 += ps_dec->s_cur_pic.u2_frm_wd_y;
543 ps_dec->s_cur_pic.pu1_buf2 += ps_dec->s_cur_pic.u2_frm_wd_uv;
544 ps_dec->s_cur_pic.pu1_buf3 += ps_dec->s_cur_pic.u2_frm_wd_uv;
545 ps_dec->s_cur_pic.ps_mv +=
546 ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
547 ps_dec->s_cur_pic.pu1_col_zero_flag += ((ps_dec->u2_pic_ht
548 * ps_dec->u2_pic_wd) >> 5);
549 ps_dec->ps_cur_pic->u1_picturetype |= BOT_FLD;
550 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
551 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
552 i4_temp_poc = MIN(i4_top_field_order_poc,
553 i4_bot_field_order_poc);
554 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
555 }
556
557 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag
558 && (!u1_field_pic_flag);
559
560 ps_dec->ps_cur_pic->u1_picturetype |= (ps_cur_slice->u1_mbaff_frame_flag
561 << 2);
562
563 ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row; //[0];
564 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
565 ps_dec->ps_cur_mb_row += 2;
566 ps_dec->ps_top_mb_row = ps_dec->ps_nbr_mb_row;
567 ps_dec->ps_top_mb_row += ((ps_dec->u2_frm_wd_in_mbs + 2) << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag));
568 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
569 ps_dec->ps_top_mb_row += 2;
570
571 /* CHANGED CODE */
572 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
573 ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
574 /* CHANGED CODE */
575 ps_dec->u1_mv_top_p = 0;
576 ps_dec->u1_mb_idx = 0;
577 /* CHANGED CODE */
578 ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
579 ps_dec->u2_total_mbs_coded = 0;
580 ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
581 ps_dec->u4_pred_info_idx = 0;
582 ps_dec->u4_pred_info_pkd_idx = 0;
583 ps_dec->u4_dma_buf_idx = 0;
584 ps_dec->ps_mv = ps_dec->s_cur_pic.ps_mv;
585 ps_dec->ps_mv_bank_cur = ps_dec->s_cur_pic.ps_mv;
586 ps_dec->pu1_col_zero_flag = ps_dec->s_cur_pic.pu1_col_zero_flag;
587 ps_dec->ps_part = ps_dec->ps_parse_part_params;
588 ps_dec->i2_prev_slice_mbx = -1;
589 ps_dec->i2_prev_slice_mby = 0;
590 ps_dec->u2_mv_2mb[0] = 0;
591 ps_dec->u2_mv_2mb[1] = 0;
592 ps_dec->u1_last_pic_not_decoded = 0;
593
594 ps_dec->u2_cur_slice_num_dec_thread = 0;
595 ps_dec->u2_cur_slice_num_bs = 0;
596 ps_dec->u4_intra_pred_line_ofst = 0;
597 ps_dec->pu1_cur_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line;
598 ps_dec->pu1_cur_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line;
599 ps_dec->pu1_cur_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line;
600
601 ps_dec->pu1_cur_y_intra_pred_line_base = ps_dec->pu1_y_intra_pred_line;
602 ps_dec->pu1_cur_u_intra_pred_line_base = ps_dec->pu1_u_intra_pred_line;
603 ps_dec->pu1_cur_v_intra_pred_line_base = ps_dec->pu1_v_intra_pred_line;
604
605
606
607
608
609 ps_dec->pu1_prev_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line
610 + (ps_dec->u2_frm_wd_in_mbs * MB_SIZE);
611
612 ps_dec->pu1_prev_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line
613 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE * YUV420SP_FACTOR;
614 ps_dec->pu1_prev_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line
615 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE;
616
617 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
618 /* Initialize The Function Pointer Depending Upon the Entropy and MbAff Flag */
619 {
620 if(ps_cur_slice->u1_mbaff_frame_flag)
621 {
622 ps_dec->pf_compute_bs = ih264d_compute_bs_mbaff;
623 ps_dec->pf_mvpred = ih264d_mvpred_mbaff;
624 }
625 else
626 {
627 ps_dec->pf_compute_bs = ih264d_compute_bs_non_mbaff;
628 ps_dec->u1_cur_mb_fld_dec_flag = ps_cur_slice->u1_field_pic_flag;
629 }
630 }
631 /* Set up the Parameter for DMA transfer */
632 {
633 UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
634
635 UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
636
637 UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
638 % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
639 UWORD16 ui16_lastmbs_widthY =
640 (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp
641 >> u1_mbaff) << 4));
642 UWORD16 ui16_lastmbs_widthUV =
643 uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp
644 >> u1_mbaff) << 3);
645
646 ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
647 ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
648 ps_dec->s_tran_addrecon.pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
649
650 ps_dec->s_tran_addrecon.u2_frm_wd_y = ps_dec->u2_frm_wd_y
651 << u1_field_pic_flag;
652 ps_dec->s_tran_addrecon.u2_frm_wd_uv = ps_dec->u2_frm_wd_uv
653 << u1_field_pic_flag;
654
655 if(u1_field_pic_flag)
656 {
657 ui16_lastmbs_widthY += ps_dec->u2_frm_wd_y;
658 ui16_lastmbs_widthUV += ps_dec->u2_frm_wd_uv;
659 }
660
661 /* Normal Increment of Pointer */
662 ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4)
663 >> u1_mbaff);
664 ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4)
665 >> u1_mbaff);
666
667 /* End of Row Increment */
668 ps_dec->s_tran_addrecon.u4_inc_y[1] = (ui16_lastmbs_widthY
669 + (PAD_LEN_Y_H << 1)
670 + ps_dec->s_tran_addrecon.u2_frm_wd_y
671 * ((15 << u1_mbaff) + u1_mbaff));
672 ps_dec->s_tran_addrecon.u4_inc_uv[1] = (ui16_lastmbs_widthUV
673 + (PAD_LEN_UV_H << 2)
674 + ps_dec->s_tran_addrecon.u2_frm_wd_uv
675 * ((15 << u1_mbaff) + u1_mbaff));
676
677 /* Assign picture numbers to each frame/field */
678 /* only once per picture. */
679 ih264d_assign_pic_num(ps_dec);
680 ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u1_recon_mb_grp
681 << 2) - 1 - (u1_mbaff << 2);
682 ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp
683 >> u1_mbaff) - 1) << (4 + u1_mbaff);
684 }
685 /**********************************************************************/
686 /* High profile related initialization at pictrue level */
687 /**********************************************************************/
688 if(ps_seq->u1_profile_idc == HIGH_PROFILE_IDC)
689 {
690 if((ps_seq->i4_seq_scaling_matrix_present_flag)
691 || (ps_pps->i4_pic_scaling_matrix_present_flag))
692 {
693 ih264d_form_scaling_matrix_picture(ps_seq, ps_pps, ps_dec);
694 ps_dec->s_high_profile.u1_scaling_present = 1;
695 }
696 else
697 {
698 ih264d_form_default_scaling_matrix(ps_dec);
699 }
700
701 if(ps_pps->i4_transform_8x8_mode_flag)
702 {
703 ps_dec->s_high_profile.u1_transform8x8_present = 1;
704 }
705 }
706 else
707 {
708 ih264d_form_default_scaling_matrix(ps_dec);
709 }
710
711 /* required while reading the transform_size_8x8 u4_flag */
712 ps_dec->s_high_profile.u1_direct_8x8_inference_flag =
713 ps_seq->u1_direct_8x8_inference_flag;
714 ps_dec->s_high_profile.s_cavlc_ctxt = ps_dec->s_cavlc_ctxt;
715
716 ps_dec->i1_recon_in_thread3_flag = 1;
717 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_addrecon;
718 if(ps_dec->u1_separate_parse)
719 {
720 memcpy(&ps_dec->s_tran_addrecon_parse, &ps_dec->s_tran_addrecon,
721 sizeof(tfr_ctxt_t));
722 if(ps_dec->u4_num_cores >= 3 && ps_dec->i1_recon_in_thread3_flag)
723 {
724 memcpy(&ps_dec->s_tran_iprecon, &ps_dec->s_tran_addrecon,
725 sizeof(tfr_ctxt_t));
726 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_iprecon;
727 }
728 }
729
730
731 ih264d_init_deblk_tfr_ctxt(ps_dec,&(ps_dec->s_pad_mgr), &(ps_dec->s_tran_addrecon),
732 ps_dec->u2_frm_wd_in_mbs, 0);
733
734 ps_dec->ps_cur_deblk_mb = ps_dec->ps_deblk_pic;
735 ps_dec->u4_cur_deblk_mb_num = 0;
736
737 ps_dec->u4_deblk_mb_x = 0;
738 ps_dec->u4_deblk_mb_y = 0;
739 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
740
741 ps_dec->u4_first_slice_in_pic = 0;
742 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
743 return OK;
744 }
745
746 /*!
747 **************************************************************************
748 * \if Function name : ih264d_deblock_display \endif
749 *
750 * \brief : The function callls the deblocking routine and manages
751 : the Recon buffers and displays .
752 * \return : Nothing
753 *
754 **************************************************************************
755 */
ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)756 WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)
757 {
758 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
759 UWORD8 u1_num_of_users = 0;
760 WORD32 ret;
761
762 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
763 if(1)
764 {
765
766 {
767 ih264d_delete_nonref_nondisplay_pics(ps_dec->ps_dpb_mgr);
768 if(ps_cur_slice->u1_mmco_equalto5
769 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
770 {
771 ps_dec->ps_cur_pic->i4_poc = 0;
772 if(ps_dec->u2_total_mbs_coded
773 == (ps_dec->ps_cur_sps->u2_max_mb_addr + 1))
774 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
775 ih264d_release_display_bufs(ps_dec);
776 }
777 if(IVD_DECODE_FRAME_OUT != ps_dec->e_frm_out_mode)
778 {
779 ret = ih264d_assign_display_seq(ps_dec);
780 if(ret != OK)
781 return ret;
782 }
783 }
784
785 if(ps_cur_slice->u1_nal_ref_idc)
786 {
787 /* Mark pic buf as needed for reference */
788 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
789 ps_dec->u1_pic_buf_id,
790 BUF_MGR_REF);
791 /* Mark mv buf as needed for reference */
792 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
793 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
794 BUF_MGR_REF);
795 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 1;
796 }
797
798 /* 420 consumer */
799 /* Increment the number of users by 1 for display based upon */
800 /*the SEEK KEY FRAME control sent to decoder */
801 if(((0 == ps_dec->u1_last_pic_not_decoded)
802 && (0
803 == (ps_dec->ps_cur_pic->u4_pack_slc_typ
804 & ps_dec->u4_skip_frm_mask)))
805 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
806 {
807 /* Mark pic buf as needed for display */
808 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
809 ps_dec->u1_pic_buf_id,
810 BUF_MGR_IO);
811
812 }
813
814 if(!ps_cur_slice->u1_field_pic_flag
815 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY)
816 != ps_dec->u1_top_bottom_decoded))
817 {
818 pic_buffer_t *ps_cur_pic = ps_dec->ps_cur_pic;
819 ps_cur_pic->u2_disp_width = ps_dec->u2_disp_width;
820 ps_cur_pic->u2_disp_height = ps_dec->u2_disp_height >> 1;
821
822 ps_cur_pic->u2_crop_offset_y = ps_dec->u2_crop_offset_y;
823 ps_cur_pic->u2_crop_offset_uv = ps_dec->u2_crop_offset_uv;
824 ps_cur_pic->u1_pic_type = 0;
825
826 ret = ih264d_insert_pic_in_display_list(
827 ps_dec->ps_dpb_mgr,
828 ps_dec->u1_pic_buf_id,
829 ps_dec->i4_prev_max_display_seq
830 + ps_dec->ps_cur_pic->i4_poc,
831 ps_dec->ps_cur_pic->i4_frame_num);
832 if(ret != OK)
833 return ret;
834
835 {
836 ivd_video_decode_op_t * ps_dec_output =
837 (ivd_video_decode_op_t *)ps_dec->pv_dec_out;
838
839 ps_dec_output->u4_frame_decoded_flag = 1;
840 }
841 if(ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] == 0)
842 {
843 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
844 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
845 BUF_MGR_REF);
846 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 0;
847
848 }
849 }
850 else
851 {
852 H264_DEC_DEBUG_PRINT("pic not inserted display %d %d\n",
853 ps_cur_slice->u1_field_pic_flag,
854 ps_dec->u1_second_field);
855 }
856
857 if(!ps_cur_slice->u1_field_pic_flag
858 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY)
859 == ps_dec->u1_top_bottom_decoded))
860 {
861 if(IVD_DECODE_FRAME_OUT == ps_dec->e_frm_out_mode)
862 {
863 ret = ih264d_assign_display_seq(ps_dec);
864 if(ret != OK)
865 return ret;
866 }
867 }
868 }
869
870 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
871
872 return OK;
873 }
874
ih264d_err_pic_dispbuf_mgr(dec_struct_t * ps_dec)875 void ih264d_err_pic_dispbuf_mgr(dec_struct_t *ps_dec)
876 {
877 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
878 ivd_video_decode_op_t * ps_dec_output =
879 (ivd_video_decode_op_t *)ps_dec->pv_dec_out;
880
881 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
882 ps_dec->u1_pic_buf_id,
883 BUF_MGR_REF);
884 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
885 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
886 BUF_MGR_REF);
887 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
888 ps_dec->u1_pic_buf_id,
889 BUF_MGR_IO);
890 }
891
ih264d_deblock_picture(void * ptr)892 void ih264d_deblock_picture(void *ptr)
893 {
894 dec_struct_t *ps_dec = (dec_struct_t *)ptr;
895
896 {
897 /*Deblock picture only if all the mb's in the frame have been decoded*/
898 if(ps_dec->u1_pic_decode_done == 1)
899 {
900 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag
901 || ps_dec->ps_cur_slice->u1_field_pic_flag)
902 {
903 ps_dec->p_DeblockPicture[ps_dec->ps_cur_slice->u1_mbaff_frame_flag](
904 ps_dec);
905 }
906 else
907
908 {
909
910 ih264d_deblock_picture_progressive(ps_dec);
911 }
912
913 }
914 }
915
916 }
917
918 /*!
919 **************************************************************************
920 * \if Function name : ih264d_deblock_display \endif
921 *
922 * \brief : The function callls the deblocking routine and manages
923 : the Recon buffers and displays .
924 * \return : Nothing
925 *
926 **************************************************************************
927 */
ih264d_deblock_display(dec_struct_t * ps_dec)928 WORD32 ih264d_deblock_display(dec_struct_t *ps_dec)
929 {
930 WORD32 ret;
931 /* Call deblocking */
932 ih264d_deblock_picture(ps_dec);
933
934 ret = ih264d_end_of_pic_dispbuf_mgr(ps_dec);
935 if(ret != OK)
936 return ret;
937
938 return OK;
939 }
940
941 /*
942 *!
943 **************************************************************************
944 * \if Function name : EndofPoc \endif
945 *
946 * \brief
947 * EndofPoc Processing
948 *
949 * \return
950 * 0 on Success and Error code otherwise
951 **************************************************************************
952 */
953
ih264d_end_of_pic(dec_struct_t * ps_dec)954 WORD32 ih264d_end_of_pic(dec_struct_t *ps_dec)
955 {
956 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
957 WORD32 ret;
958
959 {
960 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
961 if(ps_err->u1_err_flag & REJECT_CUR_PIC)
962 {
963 ih264d_err_pic_dispbuf_mgr(ps_dec);
964 return ERROR_NEW_FRAME_EXPECTED;
965 }
966 }
967
968 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
969 ret = ih264d_end_of_pic_processing(ps_dec);
970 if(ret != OK)
971 return ret;
972 /*--------------------------------------------------------------------*/
973 /* ih264d_decode_pic_order_cnt - calculate the Pic Order Cnt */
974 /* Needed to detect end of picture */
975 /*--------------------------------------------------------------------*/
976
977 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
978
979 return OK;
980 }
981
982 /*!
983 **************************************************************************
984 * \if Function name : DecodeSlice \endif
985 *
986 * \brief
987 * Parses a slice
988 *
989 * \return
990 * 0 on Success and Error code otherwise
991 **************************************************************************
992 */
993
ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,dec_struct_t * ps_dec)994 WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
995 UWORD8 u1_nal_ref_idc,
996 dec_struct_t *ps_dec /* Decoder parameters */
997 )
998 {
999 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
1000 dec_pic_params_t *ps_pps;
1001 dec_seq_params_t *ps_seq;
1002 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
1003 pocstruct_t s_tmp_poc;
1004 WORD32 i_delta_poc[2];
1005 WORD32 i4_poc = 0;
1006 UWORD16 u2_first_mb_in_slice, u2_frame_num;
1007 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
1008 UWORD32 u4_idr_pic_id = 0;
1009 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
1010
1011 UWORD8 u1_nal_unit_type;
1012 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1013 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1014 WORD8 i1_is_end_of_poc;
1015
1016 WORD32 ret, end_of_frame;
1017 WORD32 prev_slice_err, num_mb_skipped;
1018 UWORD8 u1_mbaff;
1019 pocstruct_t *ps_cur_poc;
1020
1021 UWORD32 u4_temp;
1022 WORD32 i_temp;
1023 UWORD32 u4_call_end_of_pic = 0;
1024
1025 /* read FirstMbInSlice and slice type*/
1026 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1027 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst,
1028 pu4_bitstrm_buf);
1029 if(u2_first_mb_in_slice
1030 > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
1031 {
1032
1033 return ERROR_CORRUPTED_SLICE;
1034 }
1035
1036 /*we currently don not support ASO*/
1037 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag)
1038 <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
1039 {
1040 return ERROR_CORRUPTED_SLICE;
1041 }
1042
1043 COPYTHECONTEXT("SH: first_mb_in_slice",u2_first_mb_in_slice);
1044
1045 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1046
1047 if(u4_temp > 9)
1048 return ERROR_INV_SLC_TYPE_T;
1049
1050 u1_slice_type = u4_temp;
1051 COPYTHECONTEXT("SH: slice_type",(u1_slice_type));
1052 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
1053 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
1054 /* will be of same type of current */
1055 if(u1_slice_type > 4)
1056 {
1057 u1_slice_type -= 5;
1058 }
1059
1060 {
1061 UWORD32 skip;
1062
1063 if((ps_dec->i4_app_skip_mode == IVD_SKIP_PB)
1064 || (ps_dec->i4_dec_skip_mode == IVD_SKIP_PB))
1065 {
1066 UWORD32 u4_bit_stream_offset = 0;
1067
1068 if(ps_dec->u1_nal_unit_type == IDR_SLICE_NAL)
1069 {
1070 skip = 0;
1071
1072 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1073 }
1074 else if((I_SLICE == u1_slice_type)
1075 && (1 >= ps_dec->ps_cur_sps->u1_num_ref_frames))
1076 {
1077 skip = 0;
1078
1079 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1080 }
1081 else
1082 {
1083 skip = 1;
1084 }
1085
1086 /* If one frame worth of data is already skipped, do not skip the next one */
1087 if((0 == u2_first_mb_in_slice) && (1 == ps_dec->u4_prev_nal_skipped))
1088 {
1089 skip = 0;
1090 }
1091
1092 if(skip)
1093 {
1094 ps_dec->u4_prev_nal_skipped = 1;
1095 ps_dec->i4_dec_skip_mode = IVD_SKIP_PB;
1096 return 0;
1097 }
1098 else
1099 {
1100 /* If the previous NAL was skipped, then
1101 do not process that buffer in this call.
1102 Return to app and process it in the next call.
1103 This is necessary to handle cases where I/IDR is not complete in
1104 the current buffer and application intends to fill the remaining part of the bitstream
1105 later. This ensures we process only frame worth of data in every call */
1106 if(1 == ps_dec->u4_prev_nal_skipped)
1107 {
1108 ps_dec->u4_return_to_app = 1;
1109 return 0;
1110 }
1111 }
1112 }
1113
1114 }
1115
1116 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1117 if(u4_temp & MASK_ERR_PIC_SET_ID)
1118 return ERROR_INV_SLICE_HDR_T;
1119 /* discard slice if pic param is invalid */
1120 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp);
1121 ps_pps = &ps_dec->ps_pps[u4_temp];
1122 if(FALSE == ps_pps->u1_is_valid)
1123 {
1124 return ERROR_INV_SLICE_HDR_T;
1125 }
1126 ps_seq = ps_pps->ps_sps;
1127 if(!ps_seq)
1128 return ERROR_INV_SLICE_HDR_T;
1129 if(FALSE == ps_seq->u1_is_valid)
1130 return ERROR_INV_SLICE_HDR_T;
1131
1132 /* Get the frame num */
1133 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm,
1134 ps_seq->u1_bits_in_frm_num);
1135 // H264_DEC_DEBUG_PRINT("FRAME %d First MB in slice: %d\n", u2_frame_num, u2_first_mb_in_slice);
1136
1137 COPYTHECONTEXT("SH: frame_num", u2_frame_num);
1138 // H264_DEC_DEBUG_PRINT("Second field: %d frame num: %d prv_frame_num: %d \n", ps_dec->u1_second_field, u2_frame_num, ps_dec->u2_prv_frame_num);
1139 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
1140 {
1141 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
1142 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
1143
1144 ps_dec->u2_mbx = 0xffff;
1145 ps_dec->u2_mby = 0;
1146
1147 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
1148 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
1149
1150 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5)
1151 ps_dec->u2_prev_ref_frame_num = 0;
1152
1153 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
1154 {
1155 ih264d_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
1156 }
1157
1158 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
1159 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
1160 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
1161 if(ps_cur_slice->u1_nal_ref_idc)
1162 {
1163 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
1164 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
1165 ps_prev_poc->i4_delta_pic_order_cnt_bottom =
1166 ps_cur_poc->i4_delta_pic_order_cnt_bottom;
1167 ps_prev_poc->i4_delta_pic_order_cnt[0] =
1168 ps_cur_poc->i4_delta_pic_order_cnt[0];
1169 ps_prev_poc->i4_delta_pic_order_cnt[1] =
1170 ps_cur_poc->i4_delta_pic_order_cnt[1];
1171 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
1172 }
1173
1174 ps_dec->u2_total_mbs_coded = 0;
1175 }
1176 /* Get the field related flags */
1177 if(!ps_seq->u1_frame_mbs_only_flag)
1178 {
1179
1180 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
1181 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag);
1182 u1_bottom_field_flag = 0;
1183
1184 if(u1_field_pic_flag)
1185 {
1186 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld;
1187 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
1188 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag);
1189
1190 }
1191 else
1192 {
1193 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1194 }
1195 }
1196 else
1197 {
1198 u1_field_pic_flag = 0;
1199 u1_bottom_field_flag = 0;
1200
1201 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1202 }
1203
1204 u1_nal_unit_type = SLICE_NAL;
1205 if(u1_is_idr_slice)
1206 {
1207 u1_nal_unit_type = IDR_SLICE_NAL;
1208 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst,
1209 pu4_bitstrm_buf);
1210 if(u4_idr_pic_id > 65535)
1211 return ERROR_INV_SLICE_HDR_T;
1212 COPYTHECONTEXT("SH: ", u4_idr_pic_id);
1213 }
1214
1215 /* read delta pic order count information*/
1216 i_delta_poc[0] = i_delta_poc[1] = 0;
1217 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
1218 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
1219 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
1220 if(u1_pic_order_cnt_type == 0)
1221 {
1222 i_temp = ih264d_get_bits_h264(
1223 ps_bitstrm,
1224 ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
1225 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb)
1226 return ERROR_INV_SLICE_HDR_T;
1227 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
1228 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
1229
1230 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
1231 {
1232 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(
1233 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1234 //if(s_tmp_poc.i4_delta_pic_order_cnt_bottom > ps_seq->i4_max_pic_order_cntLsb)
1235 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom",
1236 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
1237 }
1238 }
1239
1240 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
1241 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
1242 if(u1_pic_order_cnt_type == 1
1243 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
1244 {
1245 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst,
1246 pu4_bitstrm_buf);
1247 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]",
1248 s_tmp_poc.i4_delta_pic_order_cnt[0]);
1249
1250 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
1251 {
1252 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(
1253 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1254 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]",
1255 s_tmp_poc.i4_delta_pic_order_cnt[1]);
1256 }
1257 }
1258
1259 if(ps_pps->u1_redundant_pic_cnt_present_flag)
1260 {
1261 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1262 if(u4_temp > MAX_REDUNDANT_PIC_CNT)
1263 return ERROR_INV_SLICE_HDR_T;
1264 u1_redundant_pic_cnt = u4_temp;
1265 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt);
1266 }
1267
1268 /*--------------------------------------------------------------------*/
1269 /* Check if the slice is part of new picture */
1270 /*--------------------------------------------------------------------*/
1271 /* First slice of a picture is always considered as part of new picture */
1272 i1_is_end_of_poc = 1;
1273 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
1274
1275 if(ps_dec->u4_first_slice_in_pic == 0)
1276 {
1277 i1_is_end_of_poc = ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc,
1278 &s_tmp_poc, &ps_dec->s_cur_pic_poc,
1279 ps_cur_slice, u1_pic_order_cnt_type,
1280 u1_nal_unit_type, u4_idr_pic_id,
1281 u1_field_pic_flag,
1282 u1_bottom_field_flag);
1283 if(i1_is_end_of_poc)
1284 {
1285 ps_dec->u1_first_slice_in_stream = 0;
1286 return ERROR_INCOMPLETE_FRAME;
1287 }
1288
1289 }
1290
1291 /*--------------------------------------------------------------------*/
1292 /* Check for error in slice and parse the missing/corrupted MB's */
1293 /* as skip-MB's in an inserted P-slice */
1294 /*--------------------------------------------------------------------*/
1295 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
1296 prev_slice_err = 0;
1297
1298 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
1299 {
1300 if(u2_frame_num != ps_dec->u2_prv_frame_num
1301 && ps_dec->u1_top_bottom_decoded != 0
1302 && ps_dec->u1_top_bottom_decoded
1303 != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
1304 {
1305 ps_dec->u1_dangling_field = 1;
1306 if(ps_dec->u4_first_slice_in_pic)
1307 {
1308 // first slice - dangling field
1309 prev_slice_err = 1;
1310 }
1311 else
1312 {
1313 // last slice - dangling field
1314 prev_slice_err = 2;
1315 }
1316
1317 if(ps_dec->u1_top_bottom_decoded ==TOP_FIELD_ONLY)
1318 ps_cur_slice->u1_bottom_field_flag = 1;
1319 else
1320 ps_cur_slice->u1_bottom_field_flag = 0;
1321
1322 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1323 - ps_dec->u2_total_mbs_coded;
1324 ps_cur_poc = &ps_dec->s_cur_pic_poc;
1325
1326 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
1327 }
1328 else if(ps_dec->u4_first_slice_in_pic)
1329 {
1330 if(u2_first_mb_in_slice > 0)
1331 {
1332 // first slice - missing/header corruption
1333 prev_slice_err = 1;
1334 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
1335 ps_cur_poc = &s_tmp_poc;
1336
1337 // initializing slice parameters
1338 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1339 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1340 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1341 ps_cur_slice->i4_pic_order_cnt_lsb =
1342 s_tmp_poc.i4_pic_order_cnt_lsb;
1343 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1344 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1345 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1346 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1347 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag
1348 && (!u1_field_pic_flag);
1349 }
1350 }
1351 else
1352 {
1353 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so conceal the current frame
1354 * completely */
1355 prev_slice_err = 2;
1356 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs
1357 * ps_dec->u2_frm_wd_in_mbs)
1358 - ps_dec->u2_total_mbs_coded;
1359 ps_cur_poc = &s_tmp_poc;
1360 }
1361 }
1362 else
1363 {
1364 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
1365 {
1366 // previous slice - missing/corruption
1367 prev_slice_err = 2;
1368 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff)
1369 - ps_dec->u2_total_mbs_coded;
1370 ps_cur_poc = &s_tmp_poc;
1371 }
1372 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
1373 {
1374 return ERROR_CORRUPTED_SLICE;
1375 }
1376 }
1377
1378 if(prev_slice_err)
1379 {
1380 ret = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
1381
1382 if(ps_dec->u1_dangling_field == 1)
1383 {
1384 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
1385 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1386 ps_dec->u2_prv_frame_num = u2_frame_num;
1387 ps_dec->u1_first_slice_in_stream = 0;
1388 return ERROR_DANGLING_FIELD_IN_PIC;
1389 }
1390
1391 if(prev_slice_err == 2)
1392 {
1393 ps_dec->u1_first_slice_in_stream = 0;
1394 return ERROR_INCOMPLETE_FRAME;
1395 }
1396
1397 if(ps_dec->u2_total_mbs_coded
1398 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1399 {
1400 /* return if all MBs in frame are parsed*/
1401 ps_dec->u1_first_slice_in_stream = 0;
1402 return ERROR_IN_LAST_SLICE_OF_PIC;
1403 }
1404
1405 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1406 {
1407 ih264d_err_pic_dispbuf_mgr(ps_dec);
1408 return ERROR_NEW_FRAME_EXPECTED;
1409 }
1410
1411 if(ret != OK)
1412 return ret;
1413
1414 i1_is_end_of_poc = 0;
1415 }
1416
1417 if (ps_dec->u4_first_slice_in_pic == 0)
1418 {
1419 ps_dec->ps_parse_cur_slice++;
1420 ps_dec->u2_cur_slice_num++;
1421 }
1422
1423 // in the case of single core increment ps_decode_cur_slice
1424 if((ps_dec->u1_separate_parse == 0) && (ps_dec->u4_first_slice_in_pic == 0))
1425 {
1426 ps_dec->ps_decode_cur_slice++;
1427 }
1428 ps_dec->u1_slice_header_done = 0;
1429
1430
1431 if(u1_field_pic_flag)
1432 {
1433 ps_dec->u2_prv_frame_num = u2_frame_num;
1434 }
1435
1436 if(ps_cur_slice->u1_mmco_equalto5)
1437 {
1438 WORD32 i4_temp_poc;
1439 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
1440
1441 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair
1442 {
1443 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1444 i4_bot_field_order_poc =
1445 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1446 i4_temp_poc = MIN(i4_top_field_order_poc,
1447 i4_bot_field_order_poc);
1448 }
1449 else if(!ps_cur_slice->u1_bottom_field_flag)
1450 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1451 else
1452 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1453
1454 ps_dec->ps_cur_pic->i4_top_field_order_cnt = i4_temp_poc
1455 - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1456 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = i4_temp_poc
1457 - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1458 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
1459 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
1460 }
1461 if(ps_dec->u4_first_slice_in_pic)
1462 {
1463 ret = ih264d_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num,
1464 &ps_dec->s_prev_pic_poc,
1465 &s_tmp_poc, ps_cur_slice, ps_pps,
1466 u1_nal_ref_idc,
1467 u1_bottom_field_flag,
1468 u1_field_pic_flag, &i4_poc);
1469 if(ret != OK)
1470 return ret;
1471 /* Display seq no calculations */
1472 if(i4_poc >= ps_dec->i4_max_poc)
1473 ps_dec->i4_max_poc = i4_poc;
1474 /* IDR Picture or POC wrap around */
1475 if(i4_poc == 0)
1476 {
1477 ps_dec->i4_prev_max_display_seq = ps_dec->i4_prev_max_display_seq
1478 + ps_dec->i4_max_poc
1479 + ps_dec->u1_max_dec_frame_buffering + 1;
1480 ps_dec->i4_max_poc = 0;
1481 }
1482 }
1483
1484 /*--------------------------------------------------------------------*/
1485 /* Copy the values read from the bitstream to the slice header and then*/
1486 /* If the slice is first slice in picture, then do Start of Picture */
1487 /* processing. */
1488 /*--------------------------------------------------------------------*/
1489 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
1490 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
1491 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1492 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
1493 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1494 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1495 ps_cur_slice->u1_slice_type = u1_slice_type;
1496 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1497
1498 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1499 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1500 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1501 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1502
1503 if(ps_seq->u1_frame_mbs_only_flag)
1504 ps_cur_slice->u1_direct_8x8_inference_flag =
1505 ps_seq->u1_direct_8x8_inference_flag;
1506 else
1507 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
1508
1509 if(u1_slice_type == B_SLICE)
1510 {
1511 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(
1512 ps_bitstrm);
1513 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag",
1514 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
1515
1516 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
1517 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
1518 else
1519 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
1520 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1521 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
1522 }
1523 else
1524 {
1525 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1526 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1527 }
1528
1529 if(ps_dec->u4_first_slice_in_pic)
1530 {
1531 if(u2_first_mb_in_slice == 0)
1532 {
1533 ret = ih264d_start_of_pic(ps_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
1534 if(ret != OK)
1535 return ret;
1536 }
1537
1538 ps_dec->u4_output_present = 0;
1539
1540 {
1541 ih264d_get_next_display_field(ps_dec,
1542 ps_dec->ps_out_buffer,
1543 &(ps_dec->s_disp_op));
1544 /* If error code is non-zero then there is no buffer available for display,
1545 hence avoid format conversion */
1546
1547 if(0 != ps_dec->s_disp_op.u4_error_code)
1548 {
1549 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1550 }
1551 else
1552 ps_dec->u4_output_present = 1;
1553 }
1554 if(ps_dec->u1_separate_parse == 1)
1555 {
1556 if(ps_dec->u4_dec_thread_created == 0)
1557 {
1558 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1559 (void *)ih264d_decode_picture_thread,
1560 (void *)ps_dec);
1561
1562 ps_dec->u4_dec_thread_created = 1;
1563 }
1564
1565 if((ps_dec->u4_num_cores == 3) &&
1566 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1567 && (ps_dec->u4_bs_deblk_thread_created == 0))
1568 {
1569 ps_dec->u4_start_recon_deblk = 0;
1570 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1571 (void *)ih264d_recon_deblk_thread,
1572 (void *)ps_dec);
1573 ps_dec->u4_bs_deblk_thread_created = 1;
1574 }
1575 }
1576
1577 }
1578
1579 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
1580 {
1581 UWORD8 uc_nofield_nombaff;
1582
1583
1584
1585 uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0)
1586 && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0)
1587 && (u1_slice_type != B_SLICE)
1588 && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
1589
1590 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
1591
1592 if(uc_nofield_nombaff)
1593 {
1594 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1595 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1596 }
1597 else
1598 {
1599 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
1600 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
1601 }
1602
1603
1604 }
1605
1606 /*
1607 * Decide whether to decode the current picture or not
1608 */
1609 {
1610 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1611 if(ps_err->u4_frm_sei_sync == u2_frame_num)
1612 {
1613 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1614 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
1615 }
1616 ps_err->u4_cur_frm = u2_frame_num;
1617 }
1618
1619 /* Decision for decoding if the picture is to be skipped */
1620 {
1621 WORD32 i4_skip_b_pic, i4_skip_p_pic;
1622
1623 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT)
1624 && (B_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1625
1626 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT)
1627 && (P_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1628
1629 /**************************************************************/
1630 /* Skip the B picture if skip mask is set for B picture and */
1631 /* Current B picture is a non reference B picture or there is */
1632 /* no user for reference B picture */
1633 /**************************************************************/
1634 if(i4_skip_b_pic)
1635 {
1636 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1637 /* Don't decode the picture in SKIP-B mode if that picture is B */
1638 /* and also it is not to be used as a reference picture */
1639 ps_dec->u1_last_pic_not_decoded = 1;
1640
1641 return OK;
1642 }
1643 /**************************************************************/
1644 /* Skip the P picture if skip mask is set for P picture and */
1645 /* Current P picture is a non reference P picture or there is */
1646 /* no user for reference P picture */
1647 /**************************************************************/
1648 if(i4_skip_p_pic)
1649 {
1650 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1651 /* Don't decode the picture in SKIP-P mode if that picture is P */
1652 /* and also it is not to be used as a reference picture */
1653 ps_dec->u1_last_pic_not_decoded = 1;
1654
1655 return OK;
1656 }
1657 }
1658
1659 {
1660 UWORD16 u2_mb_x, u2_mb_y;
1661
1662 ps_dec->i4_submb_ofst = ((u2_first_mb_in_slice
1663 << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE)
1664 - SUB_BLK_SIZE;
1665 if(u2_first_mb_in_slice)
1666 {
1667 UWORD8 u1_mb_aff;
1668 UWORD8 u1_field_pic;
1669 UWORD16 u2_frm_wd_in_mbs;
1670 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
1671 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
1672 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
1673
1674 {
1675 UWORD32 x_offset;
1676 UWORD32 y_offset;
1677 UWORD32 u4_frame_stride;
1678 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse;
1679
1680 if(ps_dec->u1_separate_parse)
1681 {
1682 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1683 }
1684 else
1685 {
1686 ps_trns_addr = &ps_dec->s_tran_addrecon;
1687 }
1688 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1689 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1690
1691 u2_mb_y <<= u1_mb_aff;
1692
1693 if((u2_mb_x > u2_frm_wd_in_mbs - 1)
1694 || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
1695 {
1696 return ERROR_CORRUPTED_SLICE;
1697 }
1698
1699 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
1700 x_offset = u2_mb_x << 4;
1701 y_offset = (u2_mb_y * u4_frame_stride) << 4;
1702
1703 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset
1704 + y_offset;
1705
1706 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
1707 x_offset >>= 1;
1708 y_offset = (u2_mb_y * u4_frame_stride) << 3;
1709
1710 x_offset *= YUV420SP_FACTOR;
1711
1712 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset
1713 + y_offset;
1714 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset
1715 + y_offset;
1716
1717 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1718 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1719 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1720
1721
1722 // assign the deblock structure pointers to start of slice
1723 if(ps_dec->u1_separate_parse == 1)
1724 {
1725 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1726 + (u2_first_mb_in_slice << u1_mb_aff);
1727 }
1728 else
1729 {
1730 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1731 + (u2_first_mb_in_slice << u1_mb_aff);
1732 }
1733
1734 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
1735
1736 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv
1737 + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
1738 }
1739 }
1740 else
1741 {
1742 tfr_ctxt_t *ps_trns_addr;
1743
1744 if(ps_dec->u1_separate_parse)
1745 {
1746 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1747 }
1748 else
1749 {
1750 ps_trns_addr = &ps_dec->s_tran_addrecon;
1751 }
1752
1753 u2_mb_x = 0xffff;
1754 u2_mb_y = 0;
1755 // assign the deblock structure pointers to start of slice
1756 ps_dec->u2_cur_mb_addr = 0;
1757 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
1758 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
1759 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
1760 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
1761 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
1762
1763 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1764 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1765 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1766
1767 }
1768
1769 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1770
1771 ps_dec->u2_mbx =
1772 (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1773 ps_dec->u2_mby =
1774 (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1775 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
1776 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1777 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1778 }
1779
1780 /* RBSP stop bit is used for CABAC decoding*/
1781 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
1782
1783 ps_dec->u1_B = (u1_slice_type == B_SLICE);
1784 ps_dec->u4_next_mb_skip = 0;
1785
1786 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice =
1787 ps_dec->ps_cur_slice->u2_first_mb_in_slice;
1788 ps_dec->ps_parse_cur_slice->slice_type =
1789 ps_dec->ps_cur_slice->u1_slice_type;
1790
1791
1792 ps_dec->u4_start_recon_deblk = 1;
1793 {
1794 WORD32 num_entries;
1795 WORD32 size;
1796 UWORD8 *pu1_buf;
1797
1798 num_entries = MAX_FRAMES;
1799 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1800 (0 == ps_dec->i4_display_delay))
1801 {
1802 num_entries = 1;
1803 }
1804 num_entries = ((2 * num_entries) + 1);
1805 num_entries *= 2;
1806
1807
1808 size = num_entries * sizeof(void *);
1809 size += PAD_MAP_IDX_POC * sizeof(void *);
1810
1811 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1812 pu1_buf += size * ps_dec->u2_cur_slice_num;
1813 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = ( void *)pu1_buf;
1814 }
1815
1816 if(ps_dec->u1_separate_parse)
1817 {
1818 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1819 }
1820 else
1821 {
1822 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1823 }
1824
1825 if(u1_slice_type == I_SLICE)
1826 {
1827 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
1828
1829 ret = ih264d_parse_islice(ps_dec, u2_first_mb_in_slice);
1830
1831 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
1832 ps_dec->i4_pic_type = I_SLICE;
1833
1834 }
1835 else if(u1_slice_type == P_SLICE)
1836 {
1837 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1838 ret = ih264d_parse_pslice(ps_dec, u2_first_mb_in_slice);
1839 ps_dec->u1_pr_sl_type = u1_slice_type;
1840 if(ps_dec->i4_pic_type != B_SLICE)
1841 ps_dec->i4_pic_type = P_SLICE;
1842 }
1843 else if(u1_slice_type == B_SLICE)
1844 {
1845 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1846 ret = ih264d_parse_bslice(ps_dec, u2_first_mb_in_slice);
1847 ps_dec->u1_pr_sl_type = u1_slice_type;
1848 ps_dec->i4_pic_type = B_SLICE;
1849 }
1850 else
1851 return ERROR_INV_SLC_TYPE_T;
1852
1853 if(ps_dec->u1_slice_header_done)
1854 {
1855 /* set to zero to indicate a valid slice has been decoded */
1856 ps_dec->u1_first_slice_in_stream = 0;
1857 }
1858
1859 if(ret != OK)
1860 return ret;
1861
1862 /* storing last Mb X and MbY of the slice */
1863 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1864 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1865
1866 /* End of Picture detection */
1867
1868 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
1869 {
1870 ps_dec->u1_pic_decode_done = 1;
1871
1872 }
1873
1874 {
1875 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1876 if((ps_err->u1_err_flag & REJECT_PB_PICS)
1877 && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1878 {
1879 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1880 }
1881 }
1882
1883 PRINT_BIN_BIT_RATIO(ps_dec)
1884
1885 return ret;
1886 }
1887
1888