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