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 **************************************************************************
985 * \if Function name : ih264d_fix_error_in_dpb \endif
986 *
987 * \brief
988 * fix error in DPB
989 *
990 * \return
991 * Number of node(s) deleted
992 **************************************************************************
993 */
994
ih264d_fix_error_in_dpb(dec_struct_t * ps_dec)995 WORD32 ih264d_fix_error_in_dpb(dec_struct_t *ps_dec)
996 {
997 /*--------------------------------------------------------------------*/
998 /* If there is common node in lt_list and st_list then delete it from */
999 /* st_list */
1000 /*--------------------------------------------------------------------*/
1001 UWORD8 no_of_nodes_deleted = 0;
1002 UWORD8 lt_ref_num = ps_dec->ps_dpb_mgr->u1_num_lt_ref_bufs;
1003 struct dpb_info_t *ps_lt_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_ht_head;
1004 while(lt_ref_num && ps_lt_curr_dpb)
1005 {
1006 if(ps_dec->ps_dpb_mgr->ps_dpb_st_head
1007 && ((ps_lt_curr_dpb->s_bot_field.u1_reference_info
1008 | ps_lt_curr_dpb->s_top_field.u1_reference_info)
1009 == (IS_SHORT_TERM | IS_LONG_TERM)))
1010 {
1011 struct dpb_info_t *ps_st_next_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head;
1012 struct dpb_info_t *ps_st_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head;
1013 UWORD8 st_ref_num = ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs;
1014 while(st_ref_num && ps_st_curr_dpb)
1015 {
1016 if(ps_st_curr_dpb == ps_lt_curr_dpb)
1017 {
1018 if(st_ref_num == ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs)
1019 {
1020 ps_dec->ps_dpb_mgr->ps_dpb_st_head =
1021 ps_dec->ps_dpb_mgr->ps_dpb_st_head->ps_prev_short;
1022 ps_st_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head;
1023 }
1024 else
1025 {
1026 ps_st_next_dpb->ps_prev_short = ps_st_curr_dpb->ps_prev_short;
1027 }
1028 ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs--;
1029 ps_dec->ps_dpb_mgr->u1_num_lt_ref_bufs++;
1030 no_of_nodes_deleted++;
1031 break;
1032 }
1033 ps_st_next_dpb = ps_st_curr_dpb;
1034 ps_st_curr_dpb = ps_st_curr_dpb->ps_prev_short;
1035 st_ref_num--;
1036 }
1037 }
1038 ps_lt_curr_dpb = ps_lt_curr_dpb->ps_prev_long;
1039 lt_ref_num--;
1040 }
1041 return no_of_nodes_deleted;
1042 }
1043
1044
1045 /*!
1046 **************************************************************************
1047 * \if Function name : DecodeSlice \endif
1048 *
1049 * \brief
1050 * Parses a slice
1051 *
1052 * \return
1053 * 0 on Success and Error code otherwise
1054 **************************************************************************
1055 */
1056
ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,dec_struct_t * ps_dec)1057 WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
1058 UWORD8 u1_nal_ref_idc,
1059 dec_struct_t *ps_dec /* Decoder parameters */
1060 )
1061 {
1062 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
1063 dec_pic_params_t *ps_pps;
1064 dec_seq_params_t *ps_seq;
1065 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
1066 pocstruct_t s_tmp_poc;
1067 WORD32 i_delta_poc[2];
1068 WORD32 i4_poc = 0;
1069 UWORD16 u2_first_mb_in_slice, u2_frame_num;
1070 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
1071 UWORD32 u4_idr_pic_id = 0;
1072 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
1073
1074 UWORD8 u1_nal_unit_type;
1075 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1076 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1077 WORD8 i1_is_end_of_poc;
1078
1079 WORD32 ret, end_of_frame;
1080 WORD32 prev_slice_err, num_mb_skipped;
1081 UWORD8 u1_mbaff;
1082 pocstruct_t *ps_cur_poc;
1083
1084 UWORD32 u4_temp;
1085 WORD32 i_temp;
1086 UWORD32 u4_call_end_of_pic = 0;
1087
1088 /* read FirstMbInSlice and slice type*/
1089 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1090 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst,
1091 pu4_bitstrm_buf);
1092 if(u2_first_mb_in_slice
1093 > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
1094 {
1095
1096 return ERROR_CORRUPTED_SLICE;
1097 }
1098
1099 /*we currently don not support ASO*/
1100 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag)
1101 <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
1102 {
1103 return ERROR_CORRUPTED_SLICE;
1104 }
1105
1106 COPYTHECONTEXT("SH: first_mb_in_slice",u2_first_mb_in_slice);
1107
1108 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1109
1110 if(u4_temp > 9)
1111 return ERROR_INV_SLC_TYPE_T;
1112
1113 u1_slice_type = u4_temp;
1114 COPYTHECONTEXT("SH: slice_type",(u1_slice_type));
1115 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
1116 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
1117 /* will be of same type of current */
1118 if(u1_slice_type > 4)
1119 {
1120 u1_slice_type -= 5;
1121 }
1122
1123 {
1124 UWORD32 skip;
1125
1126 if((ps_dec->i4_app_skip_mode == IVD_SKIP_PB)
1127 || (ps_dec->i4_dec_skip_mode == IVD_SKIP_PB))
1128 {
1129 UWORD32 u4_bit_stream_offset = 0;
1130
1131 if(ps_dec->u1_nal_unit_type == IDR_SLICE_NAL)
1132 {
1133 skip = 0;
1134
1135 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1136 }
1137 else if((I_SLICE == u1_slice_type)
1138 && (1 >= ps_dec->ps_cur_sps->u1_num_ref_frames))
1139 {
1140 skip = 0;
1141
1142 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1143 }
1144 else
1145 {
1146 skip = 1;
1147 }
1148
1149 /* If one frame worth of data is already skipped, do not skip the next one */
1150 if((0 == u2_first_mb_in_slice) && (1 == ps_dec->u4_prev_nal_skipped))
1151 {
1152 skip = 0;
1153 }
1154
1155 if(skip)
1156 {
1157 ps_dec->u4_prev_nal_skipped = 1;
1158 ps_dec->i4_dec_skip_mode = IVD_SKIP_PB;
1159 return 0;
1160 }
1161 else
1162 {
1163 /* If the previous NAL was skipped, then
1164 do not process that buffer in this call.
1165 Return to app and process it in the next call.
1166 This is necessary to handle cases where I/IDR is not complete in
1167 the current buffer and application intends to fill the remaining part of the bitstream
1168 later. This ensures we process only frame worth of data in every call */
1169 if(1 == ps_dec->u4_prev_nal_skipped)
1170 {
1171 ps_dec->u4_return_to_app = 1;
1172 return 0;
1173 }
1174 }
1175 }
1176
1177 }
1178
1179 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1180 if(u4_temp & MASK_ERR_PIC_SET_ID)
1181 return ERROR_INV_SLICE_HDR_T;
1182 /* discard slice if pic param is invalid */
1183 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp);
1184 ps_pps = &ps_dec->ps_pps[u4_temp];
1185 if(FALSE == ps_pps->u1_is_valid)
1186 {
1187 return ERROR_INV_SLICE_HDR_T;
1188 }
1189 ps_seq = ps_pps->ps_sps;
1190 if(!ps_seq)
1191 return ERROR_INV_SLICE_HDR_T;
1192 if(FALSE == ps_seq->u1_is_valid)
1193 return ERROR_INV_SLICE_HDR_T;
1194
1195 /* Get the frame num */
1196 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm,
1197 ps_seq->u1_bits_in_frm_num);
1198 // H264_DEC_DEBUG_PRINT("FRAME %d First MB in slice: %d\n", u2_frame_num, u2_first_mb_in_slice);
1199
1200 COPYTHECONTEXT("SH: frame_num", u2_frame_num);
1201 // 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);
1202 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
1203 {
1204 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
1205 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
1206
1207 ps_dec->u2_mbx = 0xffff;
1208 ps_dec->u2_mby = 0;
1209
1210 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
1211 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
1212
1213 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5)
1214 ps_dec->u2_prev_ref_frame_num = 0;
1215
1216 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
1217 {
1218 ih264d_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
1219 }
1220
1221 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
1222 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
1223 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
1224 if(ps_cur_slice->u1_nal_ref_idc)
1225 {
1226 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
1227 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
1228 ps_prev_poc->i4_delta_pic_order_cnt_bottom =
1229 ps_cur_poc->i4_delta_pic_order_cnt_bottom;
1230 ps_prev_poc->i4_delta_pic_order_cnt[0] =
1231 ps_cur_poc->i4_delta_pic_order_cnt[0];
1232 ps_prev_poc->i4_delta_pic_order_cnt[1] =
1233 ps_cur_poc->i4_delta_pic_order_cnt[1];
1234 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
1235 }
1236
1237 ps_dec->u2_total_mbs_coded = 0;
1238 }
1239 /* Get the field related flags */
1240 if(!ps_seq->u1_frame_mbs_only_flag)
1241 {
1242
1243 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
1244 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag);
1245 u1_bottom_field_flag = 0;
1246
1247 if(u1_field_pic_flag)
1248 {
1249 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld;
1250 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
1251 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag);
1252
1253 }
1254 else
1255 {
1256 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1257 }
1258 }
1259 else
1260 {
1261 u1_field_pic_flag = 0;
1262 u1_bottom_field_flag = 0;
1263
1264 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1265 }
1266
1267 u1_nal_unit_type = SLICE_NAL;
1268 if(u1_is_idr_slice)
1269 {
1270 u1_nal_unit_type = IDR_SLICE_NAL;
1271 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst,
1272 pu4_bitstrm_buf);
1273 if(u4_idr_pic_id > 65535)
1274 return ERROR_INV_SLICE_HDR_T;
1275 COPYTHECONTEXT("SH: ", u4_idr_pic_id);
1276 }
1277
1278 /* read delta pic order count information*/
1279 i_delta_poc[0] = i_delta_poc[1] = 0;
1280 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
1281 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
1282 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
1283 if(u1_pic_order_cnt_type == 0)
1284 {
1285 i_temp = ih264d_get_bits_h264(
1286 ps_bitstrm,
1287 ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
1288 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb)
1289 return ERROR_INV_SLICE_HDR_T;
1290 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
1291 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
1292
1293 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
1294 {
1295 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(
1296 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1297 //if(s_tmp_poc.i4_delta_pic_order_cnt_bottom > ps_seq->i4_max_pic_order_cntLsb)
1298 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom",
1299 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
1300 }
1301 }
1302
1303 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
1304 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
1305 if(u1_pic_order_cnt_type == 1
1306 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
1307 {
1308 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst,
1309 pu4_bitstrm_buf);
1310 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]",
1311 s_tmp_poc.i4_delta_pic_order_cnt[0]);
1312
1313 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
1314 {
1315 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(
1316 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1317 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]",
1318 s_tmp_poc.i4_delta_pic_order_cnt[1]);
1319 }
1320 }
1321
1322 if(ps_pps->u1_redundant_pic_cnt_present_flag)
1323 {
1324 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1325 if(u4_temp > MAX_REDUNDANT_PIC_CNT)
1326 return ERROR_INV_SLICE_HDR_T;
1327 u1_redundant_pic_cnt = u4_temp;
1328 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt);
1329 }
1330
1331 /*--------------------------------------------------------------------*/
1332 /* Check if the slice is part of new picture */
1333 /*--------------------------------------------------------------------*/
1334 /* First slice of a picture is always considered as part of new picture */
1335 i1_is_end_of_poc = 1;
1336 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
1337
1338 if(ps_dec->u4_first_slice_in_pic == 0)
1339 {
1340 i1_is_end_of_poc = ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc,
1341 &s_tmp_poc, &ps_dec->s_cur_pic_poc,
1342 ps_cur_slice, u1_pic_order_cnt_type,
1343 u1_nal_unit_type, u4_idr_pic_id,
1344 u1_field_pic_flag,
1345 u1_bottom_field_flag);
1346 if(i1_is_end_of_poc)
1347 {
1348 ps_dec->u1_first_slice_in_stream = 0;
1349 return ERROR_INCOMPLETE_FRAME;
1350 }
1351
1352 }
1353
1354 /*--------------------------------------------------------------------*/
1355 /* Check for error in slice and parse the missing/corrupted MB's */
1356 /* as skip-MB's in an inserted P-slice */
1357 /*--------------------------------------------------------------------*/
1358 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
1359 prev_slice_err = 0;
1360
1361 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
1362 {
1363 if(u2_frame_num != ps_dec->u2_prv_frame_num
1364 && ps_dec->u1_top_bottom_decoded != 0
1365 && ps_dec->u1_top_bottom_decoded
1366 != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
1367 {
1368 ps_dec->u1_dangling_field = 1;
1369 if(ps_dec->u4_first_slice_in_pic)
1370 {
1371 // first slice - dangling field
1372 prev_slice_err = 1;
1373 }
1374 else
1375 {
1376 // last slice - dangling field
1377 prev_slice_err = 2;
1378 }
1379
1380 if(ps_dec->u1_top_bottom_decoded ==TOP_FIELD_ONLY)
1381 ps_cur_slice->u1_bottom_field_flag = 1;
1382 else
1383 ps_cur_slice->u1_bottom_field_flag = 0;
1384
1385 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1386 - ps_dec->u2_total_mbs_coded;
1387 ps_cur_poc = &ps_dec->s_cur_pic_poc;
1388
1389 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
1390 }
1391 else if(ps_dec->u4_first_slice_in_pic)
1392 {
1393 if(u2_first_mb_in_slice > 0)
1394 {
1395 // first slice - missing/header corruption
1396 prev_slice_err = 1;
1397 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
1398 ps_cur_poc = &s_tmp_poc;
1399
1400 // initializing slice parameters
1401 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1402 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1403 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1404 ps_cur_slice->i4_pic_order_cnt_lsb =
1405 s_tmp_poc.i4_pic_order_cnt_lsb;
1406 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1407 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1408 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1409 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1410 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag
1411 && (!u1_field_pic_flag);
1412 }
1413 }
1414 else
1415 {
1416 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so conceal the current frame
1417 * completely */
1418 prev_slice_err = 2;
1419 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs
1420 * ps_dec->u2_frm_wd_in_mbs)
1421 - ps_dec->u2_total_mbs_coded;
1422 ps_cur_poc = &s_tmp_poc;
1423 }
1424 }
1425 else
1426 {
1427 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
1428 {
1429 // previous slice - missing/corruption
1430 prev_slice_err = 2;
1431 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff)
1432 - ps_dec->u2_total_mbs_coded;
1433 ps_cur_poc = &s_tmp_poc;
1434 }
1435 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
1436 {
1437 return ERROR_CORRUPTED_SLICE;
1438 }
1439 }
1440
1441 if(prev_slice_err)
1442 {
1443 ret = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
1444
1445 if(ps_dec->u1_dangling_field == 1)
1446 {
1447 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
1448 ps_dec->u1_first_slice_in_stream = 0;
1449 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY;
1450 return ERROR_DANGLING_FIELD_IN_PIC;
1451 }
1452
1453 if(prev_slice_err == 2)
1454 {
1455 ps_dec->u1_first_slice_in_stream = 0;
1456 return ERROR_INCOMPLETE_FRAME;
1457 }
1458
1459 if(ps_dec->u2_total_mbs_coded
1460 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1461 {
1462 /* return if all MBs in frame are parsed*/
1463 ps_dec->u1_first_slice_in_stream = 0;
1464 return ERROR_IN_LAST_SLICE_OF_PIC;
1465 }
1466
1467 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1468 {
1469 ih264d_err_pic_dispbuf_mgr(ps_dec);
1470 return ERROR_NEW_FRAME_EXPECTED;
1471 }
1472
1473 if(ret != OK)
1474 return ret;
1475
1476 i1_is_end_of_poc = 0;
1477 }
1478
1479 if (ps_dec->u4_first_slice_in_pic == 0)
1480 {
1481 ps_dec->ps_parse_cur_slice++;
1482 ps_dec->u2_cur_slice_num++;
1483 }
1484
1485 // in the case of single core increment ps_decode_cur_slice
1486 if((ps_dec->u1_separate_parse == 0) && (ps_dec->u4_first_slice_in_pic == 0))
1487 {
1488 ps_dec->ps_decode_cur_slice++;
1489 }
1490 ps_dec->u1_slice_header_done = 0;
1491
1492
1493 if(u1_field_pic_flag)
1494 {
1495 ps_dec->u2_prv_frame_num = u2_frame_num;
1496 }
1497
1498 if(ps_cur_slice->u1_mmco_equalto5)
1499 {
1500 WORD32 i4_temp_poc;
1501 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
1502
1503 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair
1504 {
1505 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1506 i4_bot_field_order_poc =
1507 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1508 i4_temp_poc = MIN(i4_top_field_order_poc,
1509 i4_bot_field_order_poc);
1510 }
1511 else if(!ps_cur_slice->u1_bottom_field_flag)
1512 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1513 else
1514 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1515
1516 ps_dec->ps_cur_pic->i4_top_field_order_cnt = i4_temp_poc
1517 - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1518 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = i4_temp_poc
1519 - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1520 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
1521 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
1522 }
1523 if(ps_dec->u4_first_slice_in_pic)
1524 {
1525 ret = ih264d_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num,
1526 &ps_dec->s_prev_pic_poc,
1527 &s_tmp_poc, ps_cur_slice, ps_pps,
1528 u1_nal_ref_idc,
1529 u1_bottom_field_flag,
1530 u1_field_pic_flag, &i4_poc);
1531 if(ret != OK)
1532 return ret;
1533 /* Display seq no calculations */
1534 if(i4_poc >= ps_dec->i4_max_poc)
1535 ps_dec->i4_max_poc = i4_poc;
1536 /* IDR Picture or POC wrap around */
1537 if(i4_poc == 0)
1538 {
1539 ps_dec->i4_prev_max_display_seq = ps_dec->i4_prev_max_display_seq
1540 + ps_dec->i4_max_poc
1541 + ps_dec->u1_max_dec_frame_buffering + 1;
1542 ps_dec->i4_max_poc = 0;
1543 }
1544 }
1545
1546 /*--------------------------------------------------------------------*/
1547 /* Copy the values read from the bitstream to the slice header and then*/
1548 /* If the slice is first slice in picture, then do Start of Picture */
1549 /* processing. */
1550 /*--------------------------------------------------------------------*/
1551 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
1552 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
1553 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1554 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
1555 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1556 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1557 ps_cur_slice->u1_slice_type = u1_slice_type;
1558 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1559
1560 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1561 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1562 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1563 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1564
1565 if(ps_seq->u1_frame_mbs_only_flag)
1566 ps_cur_slice->u1_direct_8x8_inference_flag =
1567 ps_seq->u1_direct_8x8_inference_flag;
1568 else
1569 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
1570
1571 if(u1_slice_type == B_SLICE)
1572 {
1573 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(
1574 ps_bitstrm);
1575 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag",
1576 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
1577
1578 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
1579 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
1580 else
1581 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
1582 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1583 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
1584 }
1585 else
1586 {
1587 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1588 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1589 }
1590
1591 if(ps_dec->u4_first_slice_in_pic)
1592 {
1593 if(u2_first_mb_in_slice == 0)
1594 {
1595 ret = ih264d_start_of_pic(ps_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
1596 if(ret != OK)
1597 return ret;
1598 }
1599
1600 ps_dec->u4_output_present = 0;
1601
1602 {
1603 ih264d_get_next_display_field(ps_dec,
1604 ps_dec->ps_out_buffer,
1605 &(ps_dec->s_disp_op));
1606 /* If error code is non-zero then there is no buffer available for display,
1607 hence avoid format conversion */
1608
1609 if(0 != ps_dec->s_disp_op.u4_error_code)
1610 {
1611 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1612 }
1613 else
1614 ps_dec->u4_output_present = 1;
1615 }
1616 if(ps_dec->u1_separate_parse == 1)
1617 {
1618 if(ps_dec->u4_dec_thread_created == 0)
1619 {
1620 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1621 (void *)ih264d_decode_picture_thread,
1622 (void *)ps_dec);
1623
1624 ps_dec->u4_dec_thread_created = 1;
1625 }
1626
1627 if((ps_dec->u4_num_cores == 3) &&
1628 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1629 && (ps_dec->u4_bs_deblk_thread_created == 0))
1630 {
1631 ps_dec->u4_start_recon_deblk = 0;
1632 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1633 (void *)ih264d_recon_deblk_thread,
1634 (void *)ps_dec);
1635 ps_dec->u4_bs_deblk_thread_created = 1;
1636 }
1637 }
1638
1639 }
1640
1641 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
1642 {
1643 UWORD8 uc_nofield_nombaff;
1644
1645
1646
1647 uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0)
1648 && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0)
1649 && (u1_slice_type != B_SLICE)
1650 && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
1651
1652 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
1653
1654 if(uc_nofield_nombaff)
1655 {
1656 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1657 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1658 }
1659 else
1660 {
1661 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
1662 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
1663 }
1664
1665
1666 }
1667
1668 /*
1669 * Decide whether to decode the current picture or not
1670 */
1671 {
1672 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1673 if(ps_err->u4_frm_sei_sync == u2_frame_num)
1674 {
1675 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1676 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
1677 }
1678 ps_err->u4_cur_frm = u2_frame_num;
1679 }
1680
1681 /* Decision for decoding if the picture is to be skipped */
1682 {
1683 WORD32 i4_skip_b_pic, i4_skip_p_pic;
1684
1685 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT)
1686 && (B_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1687
1688 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT)
1689 && (P_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1690
1691 /**************************************************************/
1692 /* Skip the B picture if skip mask is set for B picture and */
1693 /* Current B picture is a non reference B picture or there is */
1694 /* no user for reference B picture */
1695 /**************************************************************/
1696 if(i4_skip_b_pic)
1697 {
1698 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1699 /* Don't decode the picture in SKIP-B mode if that picture is B */
1700 /* and also it is not to be used as a reference picture */
1701 ps_dec->u1_last_pic_not_decoded = 1;
1702
1703 return OK;
1704 }
1705 /**************************************************************/
1706 /* Skip the P picture if skip mask is set for P picture and */
1707 /* Current P picture is a non reference P picture or there is */
1708 /* no user for reference P picture */
1709 /**************************************************************/
1710 if(i4_skip_p_pic)
1711 {
1712 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1713 /* Don't decode the picture in SKIP-P mode if that picture is P */
1714 /* and also it is not to be used as a reference picture */
1715 ps_dec->u1_last_pic_not_decoded = 1;
1716
1717 return OK;
1718 }
1719 }
1720
1721 {
1722 UWORD16 u2_mb_x, u2_mb_y;
1723
1724 ps_dec->i4_submb_ofst = ((u2_first_mb_in_slice
1725 << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE)
1726 - SUB_BLK_SIZE;
1727 if(u2_first_mb_in_slice)
1728 {
1729 UWORD8 u1_mb_aff;
1730 UWORD8 u1_field_pic;
1731 UWORD16 u2_frm_wd_in_mbs;
1732 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
1733 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
1734 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
1735
1736 {
1737 UWORD32 x_offset;
1738 UWORD32 y_offset;
1739 UWORD32 u4_frame_stride;
1740 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse;
1741
1742 if(ps_dec->u1_separate_parse)
1743 {
1744 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1745 }
1746 else
1747 {
1748 ps_trns_addr = &ps_dec->s_tran_addrecon;
1749 }
1750 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1751 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1752
1753 u2_mb_y <<= u1_mb_aff;
1754
1755 if((u2_mb_x > u2_frm_wd_in_mbs - 1)
1756 || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
1757 {
1758 return ERROR_CORRUPTED_SLICE;
1759 }
1760
1761 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
1762 x_offset = u2_mb_x << 4;
1763 y_offset = (u2_mb_y * u4_frame_stride) << 4;
1764
1765 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset
1766 + y_offset;
1767
1768 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
1769 x_offset >>= 1;
1770 y_offset = (u2_mb_y * u4_frame_stride) << 3;
1771
1772 x_offset *= YUV420SP_FACTOR;
1773
1774 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset
1775 + y_offset;
1776 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset
1777 + y_offset;
1778
1779 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1780 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1781 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1782
1783
1784 // assign the deblock structure pointers to start of slice
1785 if(ps_dec->u1_separate_parse == 1)
1786 {
1787 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1788 + (u2_first_mb_in_slice << u1_mb_aff);
1789 }
1790 else
1791 {
1792 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1793 + (u2_first_mb_in_slice << u1_mb_aff);
1794 }
1795
1796 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
1797
1798 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv
1799 + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
1800 }
1801 }
1802 else
1803 {
1804 tfr_ctxt_t *ps_trns_addr;
1805
1806 if(ps_dec->u1_separate_parse)
1807 {
1808 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1809 }
1810 else
1811 {
1812 ps_trns_addr = &ps_dec->s_tran_addrecon;
1813 }
1814
1815 u2_mb_x = 0xffff;
1816 u2_mb_y = 0;
1817 // assign the deblock structure pointers to start of slice
1818 ps_dec->u2_cur_mb_addr = 0;
1819 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
1820 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
1821 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
1822 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
1823 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
1824
1825 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1826 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1827 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1828
1829 }
1830
1831 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1832
1833 ps_dec->u2_mbx =
1834 (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1835 ps_dec->u2_mby =
1836 (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1837 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
1838 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1839 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1840 }
1841
1842 /* RBSP stop bit is used for CABAC decoding*/
1843 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
1844
1845 ps_dec->u1_B = (u1_slice_type == B_SLICE);
1846 ps_dec->u4_next_mb_skip = 0;
1847
1848 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice =
1849 ps_dec->ps_cur_slice->u2_first_mb_in_slice;
1850 ps_dec->ps_parse_cur_slice->slice_type =
1851 ps_dec->ps_cur_slice->u1_slice_type;
1852
1853
1854 ps_dec->u4_start_recon_deblk = 1;
1855 {
1856 WORD32 num_entries;
1857 WORD32 size;
1858 UWORD8 *pu1_buf;
1859
1860 num_entries = MAX_FRAMES;
1861 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1862 (0 == ps_dec->i4_display_delay))
1863 {
1864 num_entries = 1;
1865 }
1866 num_entries = ((2 * num_entries) + 1);
1867 num_entries *= 2;
1868
1869
1870 size = num_entries * sizeof(void *);
1871 size += PAD_MAP_IDX_POC * sizeof(void *);
1872
1873 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1874 pu1_buf += size * ps_dec->u2_cur_slice_num;
1875 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = ( void *)pu1_buf;
1876 }
1877
1878 if(ps_dec->u1_separate_parse)
1879 {
1880 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1881 }
1882 else
1883 {
1884 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1885 }
1886
1887 ret = ih264d_fix_error_in_dpb(ps_dec);
1888 if(ret < 0)
1889 return ERROR_DBP_MANAGER_T;
1890
1891 if(u1_slice_type == I_SLICE)
1892 {
1893 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
1894
1895 ret = ih264d_parse_islice(ps_dec, u2_first_mb_in_slice);
1896 ps_dec->u1_pr_sl_type = u1_slice_type;
1897 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
1898 ps_dec->i4_pic_type = I_SLICE;
1899
1900 }
1901 else if(u1_slice_type == P_SLICE)
1902 {
1903 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1904 ret = ih264d_parse_pslice(ps_dec, u2_first_mb_in_slice);
1905 ps_dec->u1_pr_sl_type = u1_slice_type;
1906 if(ps_dec->i4_pic_type != B_SLICE)
1907 ps_dec->i4_pic_type = P_SLICE;
1908 }
1909 else if(u1_slice_type == B_SLICE)
1910 {
1911 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1912 ret = ih264d_parse_bslice(ps_dec, u2_first_mb_in_slice);
1913 ps_dec->u1_pr_sl_type = u1_slice_type;
1914 ps_dec->i4_pic_type = B_SLICE;
1915 }
1916 else
1917 return ERROR_INV_SLC_TYPE_T;
1918
1919 if(ps_dec->u1_slice_header_done)
1920 {
1921 /* set to zero to indicate a valid slice has been decoded */
1922 ps_dec->u1_first_slice_in_stream = 0;
1923 }
1924
1925 if(ret != OK)
1926 return ret;
1927
1928 if(u1_nal_ref_idc != 0)
1929 {
1930 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read)
1931 {
1932 memcpy((void *)ps_dec->ps_dpb_cmds, (void *)(&(ps_dec->s_dpb_cmds_scratch)),
1933 sizeof(dpb_commands_t));
1934 }
1935 }
1936
1937 /* storing last Mb X and MbY of the slice */
1938 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1939 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1940
1941 /* End of Picture detection */
1942
1943 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
1944 {
1945 ps_dec->u1_pic_decode_done = 1;
1946
1947 }
1948
1949 {
1950 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1951 if((ps_err->u1_err_flag & REJECT_PB_PICS)
1952 && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1953 {
1954 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1955 }
1956 }
1957
1958 PRINT_BIN_BIT_RATIO(ps_dec)
1959
1960 return ret;
1961 }
1962
1963