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 point to cur pic,so that if first Islice is in error, ref pic struct will have valid entries*/
445 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0];
446 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][0]) = *ps_cur_pic;
447 /* Initialize for field reference as well */
448 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic;
449 }
450
451 if(!ps_dec->ps_cur_pic)
452 {
453 WORD32 j;
454 H264_DEC_DEBUG_PRINT("------- Display Buffers Reset --------\n");
455 for(j = 0; j < MAX_DISP_BUFS_NEW; j++)
456 {
457
458 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
459 j,
460 BUF_MGR_REF);
461 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
462 ps_dec->au1_pic_buf_id_mv_buf_id_map[j],
463 BUF_MGR_REF);
464 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
465 j,
466 BUF_MGR_IO);
467 }
468
469 ps_dec->i4_cur_display_seq = 0;
470 ps_dec->i4_prev_max_display_seq = 0;
471 ps_dec->i4_max_poc = 0;
472
473 ps_cur_pic = (pic_buffer_t *)ih264_buf_mgr_get_next_free(
474 (buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
475 &cur_pic_buf_id);
476 if(ps_cur_pic == NULL)
477 {
478 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T;
479 return ERROR_UNAVAIL_PICBUF_T;
480 }
481
482 ps_col_mv = (col_mv_buf_t *)ih264_buf_mgr_get_next_free((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
483 &cur_mv_buf_id);
484 if(ps_col_mv == NULL)
485 {
486 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T;
487 return ERROR_UNAVAIL_MVBUF_T;
488 }
489
490 ps_dec->ps_cur_pic = ps_cur_pic;
491 ps_dec->u1_pic_buf_id = cur_pic_buf_id;
492 ps_cur_pic->u4_ts = ps_dec->u4_ts;
493 ps_dec->apv_buf_id_pic_buf_map[cur_pic_buf_id] = (void *)ps_cur_pic;
494
495 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id;
496 ps_dec->au1_pic_buf_id_mv_buf_id_map[cur_pic_buf_id] = cur_mv_buf_id;
497
498 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *)ps_col_mv->pv_col_zero_flag;
499 ps_cur_pic->ps_mv = (mv_pred_t *)ps_col_mv->pv_mv;
500 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0;
501
502 }
503
504 ps_dec->ps_cur_pic->u1_picturetype = u1_field_pic_flag;
505 ps_dec->ps_cur_pic->u4_pack_slc_typ = SKIP_NONE;
506 H264_DEC_DEBUG_PRINT("got a buffer\n");
507 }
508 else
509 {
510 H264_DEC_DEBUG_PRINT("did not get a buffer\n");
511 }
512
513 ps_dec->u4_pic_buf_got = 1;
514
515 ps_dec->ps_cur_pic->i4_poc = i4_poc;
516 ps_dec->ps_cur_pic->i4_frame_num = u2_frame_num;
517 ps_dec->ps_cur_pic->i4_pic_num = u2_frame_num;
518 ps_dec->ps_cur_pic->i4_top_field_order_cnt = ps_pps->i4_top_field_order_cnt;
519 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt =
520 ps_pps->i4_bottom_field_order_cnt;
521 ps_dec->ps_cur_pic->i4_avg_poc = ps_pps->i4_avg_poc;
522 ps_dec->ps_cur_pic->u4_time_stamp = ps_dec->u4_pts;
523
524 ps_dec->s_cur_pic = *(ps_dec->ps_cur_pic);
525 if(u1_field_pic_flag && u1_bottom_field_flag)
526 {
527 WORD32 i4_temp_poc;
528 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
529 /* Point to odd lines, since it's bottom field */
530 ps_dec->s_cur_pic.pu1_buf1 += ps_dec->s_cur_pic.u2_frm_wd_y;
531 ps_dec->s_cur_pic.pu1_buf2 += ps_dec->s_cur_pic.u2_frm_wd_uv;
532 ps_dec->s_cur_pic.pu1_buf3 += ps_dec->s_cur_pic.u2_frm_wd_uv;
533 ps_dec->s_cur_pic.ps_mv +=
534 ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5);
535 ps_dec->s_cur_pic.pu1_col_zero_flag += ((ps_dec->u2_pic_ht
536 * ps_dec->u2_pic_wd) >> 5);
537 ps_dec->ps_cur_pic->u1_picturetype |= BOT_FLD;
538 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
539 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
540 i4_temp_poc = MIN(i4_top_field_order_poc,
541 i4_bot_field_order_poc);
542 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
543 }
544
545 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag
546 && (!u1_field_pic_flag);
547
548 ps_dec->ps_cur_pic->u1_picturetype |= (ps_cur_slice->u1_mbaff_frame_flag
549 << 2);
550
551 ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row; //[0];
552 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
553 ps_dec->ps_cur_mb_row += 2;
554 ps_dec->ps_top_mb_row = ps_dec->ps_nbr_mb_row;
555 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));
556 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid
557 ps_dec->ps_top_mb_row += 2;
558
559 /* CHANGED CODE */
560 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
561 ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
562 /* CHANGED CODE */
563 ps_dec->u1_mv_top_p = 0;
564 ps_dec->u1_mb_idx = 0;
565 /* CHANGED CODE */
566 ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
567 ps_dec->u2_total_mbs_coded = 0;
568 ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
569 ps_dec->u4_pred_info_idx = 0;
570 ps_dec->u4_pred_info_pkd_idx = 0;
571 ps_dec->u4_dma_buf_idx = 0;
572 ps_dec->ps_mv = ps_dec->s_cur_pic.ps_mv;
573 ps_dec->ps_mv_bank_cur = ps_dec->s_cur_pic.ps_mv;
574 ps_dec->pu1_col_zero_flag = ps_dec->s_cur_pic.pu1_col_zero_flag;
575 ps_dec->ps_part = ps_dec->ps_parse_part_params;
576 ps_dec->i2_prev_slice_mbx = -1;
577 ps_dec->i2_prev_slice_mby = 0;
578 ps_dec->u2_mv_2mb[0] = 0;
579 ps_dec->u2_mv_2mb[1] = 0;
580 ps_dec->u1_last_pic_not_decoded = 0;
581
582 ps_dec->u2_cur_slice_num_dec_thread = 0;
583 ps_dec->u2_cur_slice_num_bs = 0;
584 ps_dec->u4_intra_pred_line_ofst = 0;
585 ps_dec->pu1_cur_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line;
586 ps_dec->pu1_cur_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line;
587 ps_dec->pu1_cur_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line;
588
589 ps_dec->pu1_cur_y_intra_pred_line_base = ps_dec->pu1_y_intra_pred_line;
590 ps_dec->pu1_cur_u_intra_pred_line_base = ps_dec->pu1_u_intra_pred_line;
591 ps_dec->pu1_cur_v_intra_pred_line_base = ps_dec->pu1_v_intra_pred_line;
592
593
594
595
596
597 ps_dec->pu1_prev_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line
598 + (ps_dec->u2_frm_wd_in_mbs * MB_SIZE);
599
600 ps_dec->pu1_prev_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line
601 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE * YUV420SP_FACTOR;
602 ps_dec->pu1_prev_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line
603 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE;
604
605 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
606 /* Initialize The Function Pointer Depending Upon the Entropy and MbAff Flag */
607 {
608 if(ps_cur_slice->u1_mbaff_frame_flag)
609 {
610 ps_dec->pf_compute_bs = ih264d_compute_bs_mbaff;
611 ps_dec->pf_mvpred = ih264d_mvpred_mbaff;
612 }
613 else
614 {
615 ps_dec->pf_compute_bs = ih264d_compute_bs_non_mbaff;
616 ps_dec->u1_cur_mb_fld_dec_flag = ps_cur_slice->u1_field_pic_flag;
617 }
618 }
619 /* Set up the Parameter for DMA transfer */
620 {
621 UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
622
623 UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
624
625 UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
626 % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
627 UWORD16 ui16_lastmbs_widthY =
628 (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp
629 >> u1_mbaff) << 4));
630 UWORD16 ui16_lastmbs_widthUV =
631 uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp
632 >> u1_mbaff) << 3);
633
634 ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
635 ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
636 ps_dec->s_tran_addrecon.pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
637
638 ps_dec->s_tran_addrecon.u2_frm_wd_y = ps_dec->u2_frm_wd_y
639 << u1_field_pic_flag;
640 ps_dec->s_tran_addrecon.u2_frm_wd_uv = ps_dec->u2_frm_wd_uv
641 << u1_field_pic_flag;
642
643 if(u1_field_pic_flag)
644 {
645 ui16_lastmbs_widthY += ps_dec->u2_frm_wd_y;
646 ui16_lastmbs_widthUV += ps_dec->u2_frm_wd_uv;
647 }
648
649 /* Normal Increment of Pointer */
650 ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4)
651 >> u1_mbaff);
652 ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4)
653 >> u1_mbaff);
654
655 /* End of Row Increment */
656 ps_dec->s_tran_addrecon.u4_inc_y[1] = (ui16_lastmbs_widthY
657 + (PAD_LEN_Y_H << 1)
658 + ps_dec->s_tran_addrecon.u2_frm_wd_y
659 * ((15 << u1_mbaff) + u1_mbaff));
660 ps_dec->s_tran_addrecon.u4_inc_uv[1] = (ui16_lastmbs_widthUV
661 + (PAD_LEN_UV_H << 2)
662 + ps_dec->s_tran_addrecon.u2_frm_wd_uv
663 * ((15 << u1_mbaff) + u1_mbaff));
664
665 /* Assign picture numbers to each frame/field */
666 /* only once per picture. */
667 ih264d_assign_pic_num(ps_dec);
668 ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u1_recon_mb_grp
669 << 2) - 1 - (u1_mbaff << 2);
670 ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp
671 >> u1_mbaff) - 1) << (4 + u1_mbaff);
672 }
673 /**********************************************************************/
674 /* High profile related initialization at pictrue level */
675 /**********************************************************************/
676 if(ps_seq->u1_profile_idc == HIGH_PROFILE_IDC)
677 {
678 if((ps_seq->i4_seq_scaling_matrix_present_flag)
679 || (ps_pps->i4_pic_scaling_matrix_present_flag))
680 {
681 ih264d_form_scaling_matrix_picture(ps_seq, ps_pps, ps_dec);
682 ps_dec->s_high_profile.u1_scaling_present = 1;
683 }
684 else
685 {
686 ih264d_form_default_scaling_matrix(ps_dec);
687 }
688
689 if(ps_pps->i4_transform_8x8_mode_flag)
690 {
691 ps_dec->s_high_profile.u1_transform8x8_present = 1;
692 }
693 }
694 else
695 {
696 ih264d_form_default_scaling_matrix(ps_dec);
697 }
698
699 /* required while reading the transform_size_8x8 u4_flag */
700 ps_dec->s_high_profile.u1_direct_8x8_inference_flag =
701 ps_seq->u1_direct_8x8_inference_flag;
702 ps_dec->s_high_profile.s_cavlc_ctxt = ps_dec->s_cavlc_ctxt;
703
704 ps_dec->i1_recon_in_thread3_flag = 1;
705 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_addrecon;
706 if(ps_dec->u1_separate_parse)
707 {
708 memcpy(&ps_dec->s_tran_addrecon_parse, &ps_dec->s_tran_addrecon,
709 sizeof(tfr_ctxt_t));
710 if(ps_dec->u4_num_cores >= 3 && ps_dec->i1_recon_in_thread3_flag)
711 {
712 memcpy(&ps_dec->s_tran_iprecon, &ps_dec->s_tran_addrecon,
713 sizeof(tfr_ctxt_t));
714 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_iprecon;
715 }
716 }
717
718
719 ih264d_init_deblk_tfr_ctxt(ps_dec,&(ps_dec->s_pad_mgr), &(ps_dec->s_tran_addrecon),
720 ps_dec->u2_frm_wd_in_mbs, 0);
721
722 ps_dec->ps_cur_deblk_mb = ps_dec->ps_deblk_pic;
723 ps_dec->u4_cur_deblk_mb_num = 0;
724
725 ps_dec->u4_deblk_mb_x = 0;
726 ps_dec->u4_deblk_mb_y = 0;
727 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat;
728
729 ps_dec->u4_first_slice_in_pic = 0;
730 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
731 return OK;
732 }
733
734 /*!
735 **************************************************************************
736 * \if Function name : ih264d_deblock_display \endif
737 *
738 * \brief : The function callls the deblocking routine and manages
739 : the Recon buffers and displays .
740 * \return : Nothing
741 *
742 **************************************************************************
743 */
ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)744 WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)
745 {
746 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
747 UWORD8 u1_num_of_users = 0;
748 WORD32 ret;
749
750 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
751 if(1)
752 {
753
754 {
755 ih264d_delete_nonref_nondisplay_pics(ps_dec->ps_dpb_mgr);
756 if(ps_cur_slice->u1_mmco_equalto5
757 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
758 {
759 ps_dec->ps_cur_pic->i4_poc = 0;
760 if(ps_dec->u2_total_mbs_coded
761 == (ps_dec->ps_cur_sps->u2_max_mb_addr + 1))
762 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
763 ih264d_release_display_bufs(ps_dec);
764 }
765 if(IVD_DECODE_FRAME_OUT != ps_dec->e_frm_out_mode)
766 {
767 ret = ih264d_assign_display_seq(ps_dec);
768 if(ret != OK)
769 return ret;
770 }
771 }
772
773 if(ps_cur_slice->u1_nal_ref_idc)
774 {
775 /* Mark pic buf as needed for reference */
776 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
777 ps_dec->u1_pic_buf_id,
778 BUF_MGR_REF);
779 /* Mark mv buf as needed for reference */
780 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
781 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
782 BUF_MGR_REF);
783 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 1;
784 }
785
786 /* 420 consumer */
787 /* Increment the number of users by 1 for display based upon */
788 /*the SEEK KEY FRAME control sent to decoder */
789 if(((0 == ps_dec->u1_last_pic_not_decoded)
790 && (0
791 == (ps_dec->ps_cur_pic->u4_pack_slc_typ
792 & ps_dec->u4_skip_frm_mask)))
793 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
794 {
795 /* Mark pic buf as needed for display */
796 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
797 ps_dec->u1_pic_buf_id,
798 BUF_MGR_IO);
799
800 }
801
802 if(!ps_cur_slice->u1_field_pic_flag
803 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY)
804 != ps_dec->u1_top_bottom_decoded))
805 {
806 pic_buffer_t *ps_cur_pic = ps_dec->ps_cur_pic;
807 ps_cur_pic->u2_disp_width = ps_dec->u2_disp_width;
808 ps_cur_pic->u2_disp_height = ps_dec->u2_disp_height >> 1;
809
810 ps_cur_pic->u2_crop_offset_y = ps_dec->u2_crop_offset_y;
811 ps_cur_pic->u2_crop_offset_uv = ps_dec->u2_crop_offset_uv;
812 ps_cur_pic->u1_pic_type = 0;
813
814 ret = ih264d_insert_pic_in_display_list(
815 ps_dec->ps_dpb_mgr,
816 ps_dec->u1_pic_buf_id,
817 ps_dec->i4_prev_max_display_seq
818 + ps_dec->ps_cur_pic->i4_poc,
819 ps_dec->ps_cur_pic->i4_frame_num);
820 if(ret != OK)
821 return ret;
822
823 {
824 ivd_video_decode_op_t * ps_dec_output =
825 (ivd_video_decode_op_t *)ps_dec->pv_dec_out;
826
827 ps_dec_output->u4_frame_decoded_flag = 1;
828 }
829 if(ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] == 0)
830 {
831 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
832 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
833 BUF_MGR_REF);
834 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 0;
835
836 }
837 }
838 else
839 {
840 H264_DEC_DEBUG_PRINT("pic not inserted display %d %d\n",
841 ps_cur_slice->u1_field_pic_flag,
842 ps_dec->u1_second_field);
843 }
844
845 if(!ps_cur_slice->u1_field_pic_flag
846 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY)
847 == ps_dec->u1_top_bottom_decoded))
848 {
849 if(IVD_DECODE_FRAME_OUT == ps_dec->e_frm_out_mode)
850 {
851 ret = ih264d_assign_display_seq(ps_dec);
852 if(ret != OK)
853 return ret;
854 }
855 }
856 }
857
858 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
859
860 return OK;
861 }
862
ih264d_err_pic_dispbuf_mgr(dec_struct_t * ps_dec)863 void ih264d_err_pic_dispbuf_mgr(dec_struct_t *ps_dec)
864 {
865 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
866 ivd_video_decode_op_t * ps_dec_output =
867 (ivd_video_decode_op_t *)ps_dec->pv_dec_out;
868
869 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
870 ps_dec->u1_pic_buf_id,
871 BUF_MGR_REF);
872 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr,
873 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id],
874 BUF_MGR_REF);
875 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr,
876 ps_dec->u1_pic_buf_id,
877 BUF_MGR_IO);
878 }
879
ih264d_deblock_picture(void * ptr)880 void ih264d_deblock_picture(void *ptr)
881 {
882 dec_struct_t *ps_dec = (dec_struct_t *)ptr;
883
884 {
885 /*Deblock picture only if all the mb's in the frame have been decoded*/
886 if(ps_dec->u1_pic_decode_done == 1)
887 {
888 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag
889 || ps_dec->ps_cur_slice->u1_field_pic_flag)
890 {
891 ps_dec->p_DeblockPicture[ps_dec->ps_cur_slice->u1_mbaff_frame_flag](
892 ps_dec);
893 }
894 else
895
896 {
897
898 ih264d_deblock_picture_progressive(ps_dec);
899 }
900
901 }
902 }
903
904 }
905
906 /*!
907 **************************************************************************
908 * \if Function name : ih264d_deblock_display \endif
909 *
910 * \brief : The function callls the deblocking routine and manages
911 : the Recon buffers and displays .
912 * \return : Nothing
913 *
914 **************************************************************************
915 */
ih264d_deblock_display(dec_struct_t * ps_dec)916 WORD32 ih264d_deblock_display(dec_struct_t *ps_dec)
917 {
918 WORD32 ret;
919 /* Call deblocking */
920 ih264d_deblock_picture(ps_dec);
921
922 ret = ih264d_end_of_pic_dispbuf_mgr(ps_dec);
923 if(ret != OK)
924 return ret;
925
926 return OK;
927 }
928
929 /*
930 *!
931 **************************************************************************
932 * \if Function name : EndofPoc \endif
933 *
934 * \brief
935 * EndofPoc Processing
936 *
937 * \return
938 * 0 on Success and Error code otherwise
939 **************************************************************************
940 */
941
ih264d_end_of_pic(dec_struct_t * ps_dec)942 WORD32 ih264d_end_of_pic(dec_struct_t *ps_dec)
943 {
944 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
945 WORD32 ret;
946
947 {
948 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
949 if(ps_err->u1_err_flag & REJECT_CUR_PIC)
950 {
951 ih264d_err_pic_dispbuf_mgr(ps_dec);
952 return ERROR_NEW_FRAME_EXPECTED;
953 }
954 }
955
956 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex);
957 ret = ih264d_end_of_pic_processing(ps_dec);
958 if(ret != OK)
959 return ret;
960 /*--------------------------------------------------------------------*/
961 /* ih264d_decode_pic_order_cnt - calculate the Pic Order Cnt */
962 /* Needed to detect end of picture */
963 /*--------------------------------------------------------------------*/
964
965 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex);
966
967 return OK;
968 }
969
970 /*!
971 **************************************************************************
972 * \if Function name : DecodeSlice \endif
973 *
974 * \brief
975 * Parses a slice
976 *
977 * \return
978 * 0 on Success and Error code otherwise
979 **************************************************************************
980 */
981
ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,UWORD8 u1_nal_ref_idc,dec_struct_t * ps_dec)982 WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
983 UWORD8 u1_nal_ref_idc,
984 dec_struct_t *ps_dec /* Decoder parameters */
985 )
986 {
987 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
988 dec_pic_params_t *ps_pps;
989 dec_seq_params_t *ps_seq;
990 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice;
991 pocstruct_t s_tmp_poc;
992 WORD32 i_delta_poc[2];
993 WORD32 i4_poc = 0;
994 UWORD16 u2_first_mb_in_slice, u2_frame_num;
995 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type;
996 UWORD32 u4_idr_pic_id = 0;
997 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type;
998
999 UWORD8 u1_nal_unit_type;
1000 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
1001 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
1002 WORD8 i1_is_end_of_poc;
1003
1004 WORD32 ret, end_of_frame;
1005 WORD32 prev_slice_err, num_mb_skipped;
1006 UWORD8 u1_mbaff;
1007 pocstruct_t *ps_cur_poc;
1008
1009 UWORD32 u4_temp;
1010 WORD32 i_temp;
1011 UWORD32 u4_call_end_of_pic = 0;
1012
1013 /* read FirstMbInSlice and slice type*/
1014 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0;
1015 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst,
1016 pu4_bitstrm_buf);
1017 if(u2_first_mb_in_slice
1018 > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs))
1019 {
1020
1021 return ERROR_CORRUPTED_SLICE;
1022 }
1023
1024 /*we currently don not support ASO*/
1025 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag)
1026 <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
1027 {
1028 return ERROR_CORRUPTED_SLICE;
1029 }
1030
1031 COPYTHECONTEXT("SH: first_mb_in_slice",u2_first_mb_in_slice);
1032
1033 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1034
1035 if(u4_temp > 9)
1036 return ERROR_INV_SLC_TYPE_T;
1037
1038 u1_slice_type = u4_temp;
1039 COPYTHECONTEXT("SH: slice_type",(u1_slice_type));
1040 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */
1041 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/
1042 /* will be of same type of current */
1043 if(u1_slice_type > 4)
1044 {
1045 u1_slice_type -= 5;
1046 }
1047
1048 {
1049 UWORD32 skip;
1050
1051 if((ps_dec->i4_app_skip_mode == IVD_SKIP_PB)
1052 || (ps_dec->i4_dec_skip_mode == IVD_SKIP_PB))
1053 {
1054 UWORD32 u4_bit_stream_offset = 0;
1055
1056 if(ps_dec->u1_nal_unit_type == IDR_SLICE_NAL)
1057 {
1058 skip = 0;
1059
1060 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1061 }
1062 else if((I_SLICE == u1_slice_type)
1063 && (1 >= ps_dec->ps_cur_sps->u1_num_ref_frames))
1064 {
1065 skip = 0;
1066
1067 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE;
1068 }
1069 else
1070 {
1071 skip = 1;
1072 }
1073
1074 /* If one frame worth of data is already skipped, do not skip the next one */
1075 if((0 == u2_first_mb_in_slice) && (1 == ps_dec->u4_prev_nal_skipped))
1076 {
1077 skip = 0;
1078 }
1079
1080 if(skip)
1081 {
1082 ps_dec->u4_prev_nal_skipped = 1;
1083 ps_dec->i4_dec_skip_mode = IVD_SKIP_PB;
1084 return 0;
1085 }
1086 else
1087 {
1088 /* If the previous NAL was skipped, then
1089 do not process that buffer in this call.
1090 Return to app and process it in the next call.
1091 This is necessary to handle cases where I/IDR is not complete in
1092 the current buffer and application intends to fill the remaining part of the bitstream
1093 later. This ensures we process only frame worth of data in every call */
1094 if(1 == ps_dec->u4_prev_nal_skipped)
1095 {
1096 ps_dec->u4_return_to_app = 1;
1097 return 0;
1098 }
1099 }
1100 }
1101
1102 }
1103
1104 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1105 if(u4_temp & MASK_ERR_PIC_SET_ID)
1106 return ERROR_INV_SLICE_HDR_T;
1107 /* discard slice if pic param is invalid */
1108 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp);
1109 ps_pps = &ps_dec->ps_pps[u4_temp];
1110 if(FALSE == ps_pps->u1_is_valid)
1111 {
1112 return ERROR_INV_SLICE_HDR_T;
1113 }
1114 ps_seq = ps_pps->ps_sps;
1115 if(!ps_seq)
1116 return ERROR_INV_SLICE_HDR_T;
1117 if(FALSE == ps_seq->u1_is_valid)
1118 return ERROR_INV_SLICE_HDR_T;
1119
1120 /* Get the frame num */
1121 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm,
1122 ps_seq->u1_bits_in_frm_num);
1123 // H264_DEC_DEBUG_PRINT("FRAME %d First MB in slice: %d\n", u2_frame_num, u2_first_mb_in_slice);
1124
1125 COPYTHECONTEXT("SH: frame_num", u2_frame_num);
1126 // 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);
1127 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic)
1128 {
1129 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc;
1130 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc;
1131
1132 ps_dec->u2_mbx = 0xffff;
1133 ps_dec->u2_mby = 0;
1134
1135 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc)
1136 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num;
1137
1138 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5)
1139 ps_dec->u2_prev_ref_frame_num = 0;
1140
1141 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag)
1142 {
1143 ih264d_decode_gaps_in_frame_num(ps_dec, u2_frame_num);
1144 }
1145
1146 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst;
1147 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num;
1148 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5;
1149 if(ps_cur_slice->u1_nal_ref_idc)
1150 {
1151 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb;
1152 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb;
1153 ps_prev_poc->i4_delta_pic_order_cnt_bottom =
1154 ps_cur_poc->i4_delta_pic_order_cnt_bottom;
1155 ps_prev_poc->i4_delta_pic_order_cnt[0] =
1156 ps_cur_poc->i4_delta_pic_order_cnt[0];
1157 ps_prev_poc->i4_delta_pic_order_cnt[1] =
1158 ps_cur_poc->i4_delta_pic_order_cnt[1];
1159 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
1160 }
1161
1162 ps_dec->u2_total_mbs_coded = 0;
1163 }
1164 /* Get the field related flags */
1165 if(!ps_seq->u1_frame_mbs_only_flag)
1166 {
1167
1168 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm);
1169 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag);
1170 u1_bottom_field_flag = 0;
1171
1172 if(u1_field_pic_flag)
1173 {
1174 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld;
1175 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm);
1176 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag);
1177
1178 }
1179 else
1180 {
1181 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1182 }
1183 }
1184 else
1185 {
1186 u1_field_pic_flag = 0;
1187 u1_bottom_field_flag = 0;
1188
1189 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan;
1190 }
1191
1192 u1_nal_unit_type = SLICE_NAL;
1193 if(u1_is_idr_slice)
1194 {
1195 u1_nal_unit_type = IDR_SLICE_NAL;
1196 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst,
1197 pu4_bitstrm_buf);
1198 if(u4_idr_pic_id > 65535)
1199 return ERROR_INV_SLICE_HDR_T;
1200 COPYTHECONTEXT("SH: ", u4_idr_pic_id);
1201 }
1202
1203 /* read delta pic order count information*/
1204 i_delta_poc[0] = i_delta_poc[1] = 0;
1205 s_tmp_poc.i4_pic_order_cnt_lsb = 0;
1206 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0;
1207 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type;
1208 if(u1_pic_order_cnt_type == 0)
1209 {
1210 i_temp = ih264d_get_bits_h264(
1211 ps_bitstrm,
1212 ps_seq->u1_log2_max_pic_order_cnt_lsb_minus);
1213 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb)
1214 return ERROR_INV_SLICE_HDR_T;
1215 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp;
1216 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb);
1217
1218 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag))
1219 {
1220 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev(
1221 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1222 //if(s_tmp_poc.i4_delta_pic_order_cnt_bottom > ps_seq->i4_max_pic_order_cntLsb)
1223 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom",
1224 s_tmp_poc.i4_delta_pic_order_cnt_bottom);
1225 }
1226 }
1227
1228 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0;
1229 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0;
1230 if(u1_pic_order_cnt_type == 1
1231 && (!ps_seq->u1_delta_pic_order_always_zero_flag))
1232 {
1233 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst,
1234 pu4_bitstrm_buf);
1235 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]",
1236 s_tmp_poc.i4_delta_pic_order_cnt[0]);
1237
1238 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag)
1239 {
1240 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev(
1241 pu4_bitstrm_ofst, pu4_bitstrm_buf);
1242 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]",
1243 s_tmp_poc.i4_delta_pic_order_cnt[1]);
1244 }
1245 }
1246
1247 if(ps_pps->u1_redundant_pic_cnt_present_flag)
1248 {
1249 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
1250 if(u4_temp > MAX_REDUNDANT_PIC_CNT)
1251 return ERROR_INV_SLICE_HDR_T;
1252 u1_redundant_pic_cnt = u4_temp;
1253 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt);
1254 }
1255
1256 /*--------------------------------------------------------------------*/
1257 /* Check if the slice is part of new picture */
1258 /*--------------------------------------------------------------------*/
1259 /* First slice of a picture is always considered as part of new picture */
1260 i1_is_end_of_poc = 1;
1261 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC;
1262
1263 if(ps_dec->u4_first_slice_in_pic == 0)
1264 {
1265 i1_is_end_of_poc = ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc,
1266 &s_tmp_poc, &ps_dec->s_cur_pic_poc,
1267 ps_cur_slice, u1_pic_order_cnt_type,
1268 u1_nal_unit_type, u4_idr_pic_id,
1269 u1_field_pic_flag,
1270 u1_bottom_field_flag);
1271 if(i1_is_end_of_poc)
1272 {
1273 ps_dec->u1_first_slice_in_stream = 0;
1274 return ERROR_INCOMPLETE_FRAME;
1275 }
1276
1277 }
1278
1279 /*--------------------------------------------------------------------*/
1280 /* Check for error in slice and parse the missing/corrupted MB's */
1281 /* as skip-MB's in an inserted P-slice */
1282 /*--------------------------------------------------------------------*/
1283 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
1284 prev_slice_err = 0;
1285
1286 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
1287 {
1288 if(u2_frame_num != ps_dec->u2_prv_frame_num
1289 && ps_dec->u1_top_bottom_decoded != 0
1290 && ps_dec->u1_top_bottom_decoded
1291 != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
1292 {
1293 ps_dec->u1_dangling_field = 1;
1294 if(ps_dec->u4_first_slice_in_pic)
1295 {
1296 // first slice - dangling field
1297 prev_slice_err = 1;
1298 }
1299 else
1300 {
1301 // last slice - dangling field
1302 prev_slice_err = 2;
1303 }
1304
1305 if(ps_dec->u1_top_bottom_decoded ==TOP_FIELD_ONLY)
1306 ps_cur_slice->u1_bottom_field_flag = 1;
1307 else
1308 ps_cur_slice->u1_bottom_field_flag = 0;
1309
1310 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1311 - ps_dec->u2_total_mbs_coded;
1312 ps_cur_poc = &ps_dec->s_cur_pic_poc;
1313
1314 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
1315 }
1316 else if(ps_dec->u4_first_slice_in_pic)
1317 {
1318 if(u2_first_mb_in_slice > 0)
1319 {
1320 // first slice - missing/header corruption
1321 prev_slice_err = 1;
1322 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
1323 ps_cur_poc = &s_tmp_poc;
1324
1325 // initializing slice parameters
1326 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1327 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1328 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1329 ps_cur_slice->i4_pic_order_cnt_lsb =
1330 s_tmp_poc.i4_pic_order_cnt_lsb;
1331 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1332 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1333 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1334 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1335 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag
1336 && (!u1_field_pic_flag);
1337 }
1338 }
1339 else
1340 {
1341 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so conceal the current frame
1342 * completely */
1343 prev_slice_err = 2;
1344 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs
1345 * ps_dec->u2_frm_wd_in_mbs)
1346 - ps_dec->u2_total_mbs_coded;
1347 ps_cur_poc = &s_tmp_poc;
1348 }
1349 }
1350 else
1351 {
1352 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
1353 {
1354 // previous slice - missing/corruption
1355 prev_slice_err = 2;
1356 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff)
1357 - ps_dec->u2_total_mbs_coded;
1358 ps_cur_poc = &s_tmp_poc;
1359 }
1360 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
1361 {
1362 return ERROR_CORRUPTED_SLICE;
1363 }
1364 }
1365
1366 if(prev_slice_err)
1367 {
1368 ret = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err);
1369
1370 if(ps_dec->u1_dangling_field == 1)
1371 {
1372 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field;
1373 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1374 ps_dec->u2_prv_frame_num = u2_frame_num;
1375 ps_dec->u1_first_slice_in_stream = 0;
1376 return ERROR_DANGLING_FIELD_IN_PIC;
1377 }
1378
1379 if(prev_slice_err == 2)
1380 {
1381 ps_dec->u1_first_slice_in_stream = 0;
1382 return ERROR_INCOMPLETE_FRAME;
1383 }
1384
1385 if(ps_dec->u2_total_mbs_coded
1386 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
1387 {
1388 /* return if all MBs in frame are parsed*/
1389 ps_dec->u1_first_slice_in_stream = 0;
1390 return ERROR_IN_LAST_SLICE_OF_PIC;
1391 }
1392
1393 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
1394 {
1395 ih264d_err_pic_dispbuf_mgr(ps_dec);
1396 return ERROR_NEW_FRAME_EXPECTED;
1397 }
1398
1399 if(ret != OK)
1400 return ret;
1401
1402 i1_is_end_of_poc = 0;
1403 }
1404
1405 if (ps_dec->u4_first_slice_in_pic == 0)
1406 {
1407 ps_dec->ps_parse_cur_slice++;
1408 ps_dec->u2_cur_slice_num++;
1409 }
1410
1411 // in the case of single core increment ps_decode_cur_slice
1412 if((ps_dec->u1_separate_parse == 0) && (ps_dec->u4_first_slice_in_pic == 0))
1413 {
1414 ps_dec->ps_decode_cur_slice++;
1415 }
1416 ps_dec->u1_slice_header_done = 0;
1417
1418
1419 if(u1_field_pic_flag)
1420 {
1421 ps_dec->u2_prv_frame_num = u2_frame_num;
1422 }
1423
1424 if(ps_cur_slice->u1_mmco_equalto5)
1425 {
1426 WORD32 i4_temp_poc;
1427 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc;
1428
1429 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair
1430 {
1431 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1432 i4_bot_field_order_poc =
1433 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1434 i4_temp_poc = MIN(i4_top_field_order_poc,
1435 i4_bot_field_order_poc);
1436 }
1437 else if(!ps_cur_slice->u1_bottom_field_flag)
1438 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1439 else
1440 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1441
1442 ps_dec->ps_cur_pic->i4_top_field_order_cnt = i4_temp_poc
1443 - ps_dec->ps_cur_pic->i4_top_field_order_cnt;
1444 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = i4_temp_poc
1445 - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt;
1446 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc;
1447 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc;
1448 }
1449 if(ps_dec->u4_first_slice_in_pic)
1450 {
1451 ret = ih264d_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num,
1452 &ps_dec->s_prev_pic_poc,
1453 &s_tmp_poc, ps_cur_slice, ps_pps,
1454 u1_nal_ref_idc,
1455 u1_bottom_field_flag,
1456 u1_field_pic_flag, &i4_poc);
1457 if(ret != OK)
1458 return ret;
1459 /* Display seq no calculations */
1460 if(i4_poc >= ps_dec->i4_max_poc)
1461 ps_dec->i4_max_poc = i4_poc;
1462 /* IDR Picture or POC wrap around */
1463 if(i4_poc == 0)
1464 {
1465 ps_dec->i4_prev_max_display_seq = ps_dec->i4_prev_max_display_seq
1466 + ps_dec->i4_max_poc
1467 + ps_dec->u1_max_dec_frame_buffering + 1;
1468 ps_dec->i4_max_poc = 0;
1469 }
1470 }
1471
1472 /*--------------------------------------------------------------------*/
1473 /* Copy the values read from the bitstream to the slice header and then*/
1474 /* If the slice is first slice in picture, then do Start of Picture */
1475 /* processing. */
1476 /*--------------------------------------------------------------------*/
1477 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0];
1478 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1];
1479 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id;
1480 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice;
1481 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag;
1482 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag;
1483 ps_cur_slice->u1_slice_type = u1_slice_type;
1484 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb;
1485
1486 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type;
1487 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt;
1488 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc;
1489 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type;
1490
1491 if(ps_seq->u1_frame_mbs_only_flag)
1492 ps_cur_slice->u1_direct_8x8_inference_flag =
1493 ps_seq->u1_direct_8x8_inference_flag;
1494 else
1495 ps_cur_slice->u1_direct_8x8_inference_flag = 1;
1496
1497 if(u1_slice_type == B_SLICE)
1498 {
1499 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264(
1500 ps_bitstrm);
1501 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag",
1502 ps_cur_slice->u1_direct_spatial_mv_pred_flag);
1503
1504 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag)
1505 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct;
1506 else
1507 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct;
1508 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1509 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB;
1510 }
1511 else
1512 {
1513 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag)))
1514 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff;
1515 }
1516
1517 if(ps_dec->u4_first_slice_in_pic)
1518 {
1519 if(u2_first_mb_in_slice == 0)
1520 {
1521 ret = ih264d_start_of_pic(ps_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps);
1522 if(ret != OK)
1523 return ret;
1524 }
1525
1526 ps_dec->u4_output_present = 0;
1527
1528 {
1529 ih264d_get_next_display_field(ps_dec,
1530 ps_dec->ps_out_buffer,
1531 &(ps_dec->s_disp_op));
1532 /* If error code is non-zero then there is no buffer available for display,
1533 hence avoid format conversion */
1534
1535 if(0 != ps_dec->s_disp_op.u4_error_code)
1536 {
1537 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht;
1538 }
1539 else
1540 ps_dec->u4_output_present = 1;
1541 }
1542 if(ps_dec->u1_separate_parse == 1)
1543 {
1544 if(ps_dec->u4_dec_thread_created == 0)
1545 {
1546 ithread_create(ps_dec->pv_dec_thread_handle, NULL,
1547 (void *)ih264d_decode_picture_thread,
1548 (void *)ps_dec);
1549
1550 ps_dec->u4_dec_thread_created = 1;
1551 }
1552
1553 if((ps_dec->u4_num_cores == 3) &&
1554 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag)
1555 && (ps_dec->u4_bs_deblk_thread_created == 0))
1556 {
1557 ps_dec->u4_start_recon_deblk = 0;
1558 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL,
1559 (void *)ih264d_recon_deblk_thread,
1560 (void *)ps_dec);
1561 ps_dec->u4_bs_deblk_thread_created = 1;
1562 }
1563 }
1564
1565 }
1566
1567 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */
1568 {
1569 UWORD8 uc_nofield_nombaff;
1570
1571
1572
1573 uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0)
1574 && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0)
1575 && (u1_slice_type != B_SLICE)
1576 && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0));
1577
1578 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */
1579
1580 if(uc_nofield_nombaff)
1581 {
1582 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp;
1583 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp;
1584 }
1585 else
1586 {
1587 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp;
1588 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp;
1589 }
1590
1591
1592 }
1593
1594 /*
1595 * Decide whether to decode the current picture or not
1596 */
1597 {
1598 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1599 if(ps_err->u4_frm_sei_sync == u2_frame_num)
1600 {
1601 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1602 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT;
1603 }
1604 ps_err->u4_cur_frm = u2_frame_num;
1605 }
1606
1607 /* Decision for decoding if the picture is to be skipped */
1608 {
1609 WORD32 i4_skip_b_pic, i4_skip_p_pic;
1610
1611 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT)
1612 && (B_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1613
1614 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT)
1615 && (P_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc);
1616
1617 /**************************************************************/
1618 /* Skip the B picture if skip mask is set for B picture and */
1619 /* Current B picture is a non reference B picture or there is */
1620 /* no user for reference B picture */
1621 /**************************************************************/
1622 if(i4_skip_b_pic)
1623 {
1624 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1625 /* Don't decode the picture in SKIP-B mode if that picture is B */
1626 /* and also it is not to be used as a reference picture */
1627 ps_dec->u1_last_pic_not_decoded = 1;
1628
1629 return OK;
1630 }
1631 /**************************************************************/
1632 /* Skip the P picture if skip mask is set for P picture and */
1633 /* Current P picture is a non reference P picture or there is */
1634 /* no user for reference P picture */
1635 /**************************************************************/
1636 if(i4_skip_p_pic)
1637 {
1638 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1639 /* Don't decode the picture in SKIP-P mode if that picture is P */
1640 /* and also it is not to be used as a reference picture */
1641 ps_dec->u1_last_pic_not_decoded = 1;
1642
1643 return OK;
1644 }
1645 }
1646
1647 {
1648 UWORD16 u2_mb_x, u2_mb_y;
1649
1650 ps_dec->i4_submb_ofst = ((u2_first_mb_in_slice
1651 << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE)
1652 - SUB_BLK_SIZE;
1653 if(u2_first_mb_in_slice)
1654 {
1655 UWORD8 u1_mb_aff;
1656 UWORD8 u1_field_pic;
1657 UWORD16 u2_frm_wd_in_mbs;
1658 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs;
1659 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag;
1660 u1_field_pic = ps_cur_slice->u1_field_pic_flag;
1661
1662 {
1663 UWORD32 x_offset;
1664 UWORD32 y_offset;
1665 UWORD32 u4_frame_stride;
1666 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse;
1667
1668 if(ps_dec->u1_separate_parse)
1669 {
1670 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1671 }
1672 else
1673 {
1674 ps_trns_addr = &ps_dec->s_tran_addrecon;
1675 }
1676 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1677 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs);
1678
1679 u2_mb_y <<= u1_mb_aff;
1680
1681 if((u2_mb_x > u2_frm_wd_in_mbs - 1)
1682 || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1))
1683 {
1684 return ERROR_CORRUPTED_SLICE;
1685 }
1686
1687 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic;
1688 x_offset = u2_mb_x << 4;
1689 y_offset = (u2_mb_y * u4_frame_stride) << 4;
1690
1691 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset
1692 + y_offset;
1693
1694 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic;
1695 x_offset >>= 1;
1696 y_offset = (u2_mb_y * u4_frame_stride) << 3;
1697
1698 x_offset *= YUV420SP_FACTOR;
1699
1700 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset
1701 + y_offset;
1702 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset
1703 + y_offset;
1704
1705 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1706 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1707 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1708
1709
1710 // assign the deblock structure pointers to start of slice
1711 if(ps_dec->u1_separate_parse == 1)
1712 {
1713 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1714 + (u2_first_mb_in_slice << u1_mb_aff);
1715 }
1716 else
1717 {
1718 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic
1719 + (u2_first_mb_in_slice << u1_mb_aff);
1720 }
1721
1722 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
1723
1724 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv
1725 + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
1726 }
1727 }
1728 else
1729 {
1730 tfr_ctxt_t *ps_trns_addr;
1731
1732 if(ps_dec->u1_separate_parse)
1733 {
1734 ps_trns_addr = &ps_dec->s_tran_addrecon_parse;
1735 }
1736 else
1737 {
1738 ps_trns_addr = &ps_dec->s_tran_addrecon;
1739 }
1740
1741 u2_mb_x = 0xffff;
1742 u2_mb_y = 0;
1743 // assign the deblock structure pointers to start of slice
1744 ps_dec->u2_cur_mb_addr = 0;
1745 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
1746 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
1747 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
1748 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
1749 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3;
1750
1751 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y;
1752 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u;
1753 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v;
1754
1755 }
1756
1757 ps_dec->ps_part = ps_dec->ps_parse_part_params;
1758
1759 ps_dec->u2_mbx =
1760 (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1761 ps_dec->u2_mby =
1762 (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs));
1763 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag;
1764 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1765 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1766 }
1767
1768 /* RBSP stop bit is used for CABAC decoding*/
1769 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode;
1770
1771 ps_dec->u1_B = (u1_slice_type == B_SLICE);
1772 ps_dec->u4_next_mb_skip = 0;
1773
1774 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice =
1775 ps_dec->ps_cur_slice->u2_first_mb_in_slice;
1776 ps_dec->ps_parse_cur_slice->slice_type =
1777 ps_dec->ps_cur_slice->u1_slice_type;
1778
1779
1780 ps_dec->u4_start_recon_deblk = 1;
1781 {
1782 WORD32 num_entries;
1783 WORD32 size;
1784 UWORD8 *pu1_buf;
1785
1786 num_entries = MAX_FRAMES;
1787 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) &&
1788 (0 == ps_dec->i4_display_delay))
1789 {
1790 num_entries = 1;
1791 }
1792 num_entries = ((2 * num_entries) + 1);
1793 if(BASE_PROFILE_IDC != ps_dec->ps_cur_sps->u1_profile_idc)
1794 {
1795 num_entries *= 2;
1796 }
1797
1798 size = num_entries * sizeof(void *);
1799 size += PAD_MAP_IDX_POC * sizeof(void *);
1800
1801 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf;
1802 pu1_buf += size * ps_dec->u2_cur_slice_num;
1803 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = ( void *)pu1_buf;
1804 }
1805
1806 if(ps_dec->u1_separate_parse)
1807 {
1808 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data;
1809 }
1810 else
1811 {
1812 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
1813 }
1814
1815 if(u1_slice_type == I_SLICE)
1816 {
1817 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT;
1818
1819 ret = ih264d_parse_islice(ps_dec, u2_first_mb_in_slice);
1820
1821 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE)
1822 ps_dec->i4_pic_type = I_SLICE;
1823
1824 }
1825 else if(u1_slice_type == P_SLICE)
1826 {
1827 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT;
1828 ret = ih264d_parse_pslice(ps_dec, u2_first_mb_in_slice);
1829 ps_dec->u1_pr_sl_type = u1_slice_type;
1830 if(ps_dec->i4_pic_type != B_SLICE)
1831 ps_dec->i4_pic_type = P_SLICE;
1832 }
1833 else if(u1_slice_type == B_SLICE)
1834 {
1835 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT;
1836 ret = ih264d_parse_bslice(ps_dec, u2_first_mb_in_slice);
1837 ps_dec->u1_pr_sl_type = u1_slice_type;
1838 ps_dec->i4_pic_type = B_SLICE;
1839 }
1840 else
1841 return ERROR_INV_SLC_TYPE_T;
1842
1843 if(ps_dec->u1_slice_header_done)
1844 {
1845 /* set to zero to indicate a valid slice has been decoded */
1846 ps_dec->u1_first_slice_in_stream = 0;
1847 }
1848
1849 if(ret != OK)
1850 return ret;
1851
1852 /* storing last Mb X and MbY of the slice */
1853 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
1854 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
1855
1856 /* End of Picture detection */
1857
1858 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
1859 {
1860 ps_dec->u1_pic_decode_done = 1;
1861
1862 }
1863
1864 {
1865 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status;
1866 if((ps_err->u1_err_flag & REJECT_PB_PICS)
1867 && (ps_err->u1_cur_pic_type == PIC_TYPE_I))
1868 {
1869 ps_err->u1_err_flag = ACCEPT_ALL_PICS;
1870 }
1871 }
1872
1873 PRINT_BIN_BIT_RATIO(ps_dec)
1874
1875 return ret;
1876 }
1877
1878