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