| /****************************************************************************** | |
| * | |
| * Copyright (C) 2015 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at: | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| ***************************************************************************** | |
| * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore | |
| */ | |
| /*! | |
| ************************************************************************** | |
| * \file ih264d_thread_parse_decode.c | |
| * | |
| * \brief | |
| * Contains routines that for multi-thread decoder | |
| * | |
| * Detailed_description | |
| * | |
| * \date | |
| * 20/02/2012 | |
| * | |
| * \author ZR | |
| ************************************************************************** | |
| */ | |
| #include "ih264d_error_handler.h" | |
| #include "ih264d_debug.h" | |
| #include "ithread.h" | |
| #include <string.h> | |
| #include "ih264d_defs.h" | |
| #include "ih264d_debug.h" | |
| #include "ih264d_tables.h" | |
| #include "ih264d_structs.h" | |
| #include "ih264d_defs.h" | |
| #include "ih264d_mb_utils.h" | |
| #include "ih264d_thread_parse_decode.h" | |
| #include "ih264d_inter_pred.h" | |
| #include "ih264d_process_pslice.h" | |
| #include "ih264d_process_intra_mb.h" | |
| #include "ih264d_deblocking.h" | |
| #include "ih264d_format_conv.h" | |
| void ih264d_deblock_mb_level(dec_struct_t *ps_dec, | |
| dec_mb_info_t *ps_cur_mb_info, | |
| UWORD32 nmb_index); | |
| void ih264d_copy_intra_pred_line(dec_struct_t *ps_dec, | |
| dec_mb_info_t *ps_cur_mb_info, | |
| UWORD32 nmb_index); | |
| void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec, | |
| UWORD32 u4_mb_idx, | |
| UWORD32 u4_num_mbs, | |
| UWORD32 u4_num_mbs_next, | |
| UWORD32 u4_tfr_n_mb, | |
| UWORD32 u4_end_of_row) | |
| { | |
| WORD32 i, u4_mb_num; | |
| const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; | |
| UWORD32 u4_n_mb_start; | |
| UNUSED(u4_mb_idx); | |
| UNUSED(u4_num_mbs_next); | |
| if(u4_tfr_n_mb) | |
| { | |
| u4_n_mb_start = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs; | |
| // copy into s_frmMbInfo | |
| u4_mb_num = u4_n_mb_start; | |
| u4_mb_num = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs; | |
| for(i = 0; i < u4_num_mbs; i++) | |
| { | |
| UPDATE_SLICE_NUM_MAP(ps_dec->pu2_slice_num_map, u4_mb_num, | |
| ps_dec->u2_cur_slice_num); | |
| DATA_SYNC(); | |
| UPDATE_MB_MAP_MBNUM_BYTE(ps_dec->pu1_dec_mb_map, u4_mb_num); | |
| u4_mb_num++; | |
| } | |
| /****************************************************************/ | |
| /* Check for End Of Row in Next iteration */ | |
| /****************************************************************/ | |
| /****************************************************************/ | |
| /* Transfer the Following things */ | |
| /* N-Mb DeblkParams Data ( To Ext DeblkParams Buffer ) */ | |
| /* N-Mb Recon Data ( To Ext Frame Buffer ) */ | |
| /* N-Mb Intrapredline Data ( Updated Internally) */ | |
| /* N-Mb MV Data ( To Ext MV Buffer ) */ | |
| /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers) */ | |
| /****************************************************************/ | |
| /* Swap top and current pointers */ | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_y += | |
| ps_dec->s_tran_addrecon_parse.u4_inc_y[u4_end_of_row]; | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_u += | |
| ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row]; | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_v += | |
| ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row]; | |
| if(u4_end_of_row) | |
| { | |
| UWORD16 u2_mb_y; | |
| UWORD32 u4_frame_stride, y_offset; | |
| ps_dec->ps_top_mb_row = ps_dec->ps_cur_mb_row; | |
| ps_dec->ps_cur_mb_row += ((ps_dec->u2_frm_wd_in_mbs) << u1_mbaff); | |
| u2_mb_y = ps_dec->u2_mby + (1 + u1_mbaff); | |
| u4_frame_stride = ps_dec->u2_frm_wd_y | |
| << ps_dec->ps_cur_slice->u1_field_pic_flag; | |
| y_offset = (u2_mb_y * u4_frame_stride) << 4; | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_y = | |
| ps_dec->s_cur_pic.pu1_buf1 + y_offset; | |
| u4_frame_stride = ps_dec->u2_frm_wd_uv | |
| << ps_dec->ps_cur_slice->u1_field_pic_flag; | |
| y_offset = (u2_mb_y * u4_frame_stride) << 3; | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_u = | |
| ps_dec->s_cur_pic.pu1_buf2 + y_offset; | |
| ps_dec->s_tran_addrecon_parse.pu1_dest_v = | |
| ps_dec->s_cur_pic.pu1_buf3 + y_offset; | |
| } | |
| ps_dec->ps_deblk_mbn += u4_num_mbs; | |
| /* | |
| * The Slice boundary is also a valid condition to transfer. So recalculate | |
| * the Left increment, in case the number of MBs is lesser than the | |
| * N MB value. c_numMbs will be equal to N of N MB if the entire N Mb is | |
| * decoded. | |
| */ | |
| ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u4_num_mbs >> u1_mbaff) - 1) | |
| << (4 + u1_mbaff); | |
| ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u4_num_mbs << 2) - 1 | |
| - (u1_mbaff << 2); | |
| /* reassign left MV and cur MV pointers */ | |
| ps_dec->ps_mv_left = ps_dec->ps_mv_cur | |
| + ps_dec->s_tran_addrecon.u2_mv_left_inc; | |
| ps_dec->ps_mv_cur += (u4_num_mbs << 4); | |
| ps_dec->u4_num_mbs_prev_nmb = u4_num_mbs; | |
| } | |
| } | |
| void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec, | |
| UWORD32 u4_num_mbs, | |
| UWORD32 u4_num_mbs_next, | |
| UWORD32 u4_end_of_row) | |
| { | |
| UWORD32 u1_end_of_row_next; | |
| const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; | |
| /****************************************************************/ | |
| /* Check for End Of Row in Next iteration */ | |
| /****************************************************************/ | |
| u1_end_of_row_next = u4_num_mbs_next && | |
| ((u4_num_mbs_next) <= (ps_dec->u4_recon_mb_grp >> u1_mbaff)); | |
| /****************************************************************/ | |
| /* Transfer the Following things */ | |
| /* N-Mb DeblkParams Data ( To Ext DeblkParams Buffer ) */ | |
| /* N-Mb Recon Data ( To Ext Frame Buffer ) */ | |
| /* N-Mb Intrapredline Data ( Updated Internally) */ | |
| /* N-Mb MV Data ( To Ext MV Buffer ) */ | |
| /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers) */ | |
| /****************************************************************/ | |
| if(u4_end_of_row) | |
| { | |
| ps_dec->i2_dec_thread_mb_y += (1 << u1_mbaff); | |
| } | |
| ih264d_transfer_mb_group_data(ps_dec, u4_num_mbs, u4_end_of_row, | |
| u1_end_of_row_next); | |
| } | |
| WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec, | |
| UWORD32 u4_num_mbs, | |
| UWORD32 u4_num_mbs_next, | |
| UWORD32 u4_end_of_row) | |
| { | |
| WORD32 i,j; | |
| dec_mb_info_t * ps_cur_mb_info; | |
| UWORD32 u4_update_mbaff = 0; | |
| const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; | |
| UWORD32 u1_slice_type, u1_B; | |
| WORD32 u1_skip_th; | |
| UWORD32 u1_ipcm_th; | |
| UWORD32 u4_cond; | |
| UWORD16 u2_slice_num,u2_cur_dec_mb_num; | |
| WORD32 ret; | |
| UWORD32 u4_mb_num; | |
| WORD32 nop_cnt = 8*128; | |
| u1_slice_type = ps_dec->ps_decode_cur_slice->slice_type; | |
| u1_B = (u1_slice_type == B_SLICE); | |
| u1_skip_th = ((u1_slice_type != I_SLICE) ? | |
| (u1_B ? B_8x8 : PRED_8x8R0) : -1); | |
| u1_ipcm_th = ((u1_slice_type != I_SLICE) ? (u1_B ? 23 : 5) : 0); | |
| u2_cur_dec_mb_num = ps_dec->cur_dec_mb_num; | |
| while(1) | |
| { | |
| UWORD32 u4_max_mb = (UWORD32)(ps_dec->i2_dec_thread_mb_y + (1 << u1_mbaff)) * ps_dec->u2_frm_wd_in_mbs - 1; | |
| u4_mb_num = u2_cur_dec_mb_num; | |
| /*introducing 1 MB delay*/ | |
| u4_mb_num = MIN(u4_mb_num + u4_num_mbs + 1, u4_max_mb); | |
| CHECK_MB_MAP_BYTE(u4_mb_num, ps_dec->pu1_dec_mb_map, u4_cond); | |
| if(u4_cond) | |
| { | |
| break; | |
| } | |
| else | |
| { | |
| if(nop_cnt > 0) | |
| { | |
| nop_cnt -= 128; | |
| NOP(128); | |
| } | |
| else | |
| { | |
| if(ps_dec->u4_output_present && (2 == ps_dec->u4_num_cores) && | |
| (ps_dec->u4_fmt_conv_cur_row < ps_dec->s_disp_frame_info.u4_y_ht)) | |
| { | |
| ps_dec->u4_fmt_conv_num_rows = | |
| MIN(FMT_CONV_NUM_ROWS, | |
| (ps_dec->s_disp_frame_info.u4_y_ht | |
| - ps_dec->u4_fmt_conv_cur_row)); | |
| ih264d_format_convert(ps_dec, &(ps_dec->s_disp_op), | |
| ps_dec->u4_fmt_conv_cur_row, | |
| ps_dec->u4_fmt_conv_num_rows); | |
| ps_dec->u4_fmt_conv_cur_row += ps_dec->u4_fmt_conv_num_rows; | |
| } | |
| else | |
| { | |
| nop_cnt = 8*128; | |
| ithread_yield(); | |
| } | |
| } | |
| } | |
| } | |
| /* N Mb MC Loop */ | |
| for(i = 0; i < u4_num_mbs; i++) | |
| { | |
| u4_mb_num = u2_cur_dec_mb_num; | |
| GET_SLICE_NUM_MAP(ps_dec->pu2_slice_num_map, u2_cur_dec_mb_num, | |
| u2_slice_num); | |
| if(u2_slice_num != ps_dec->u2_cur_slice_num_dec_thread) | |
| { | |
| ps_dec->u4_cur_slice_decode_done = 1; | |
| break; | |
| } | |
| ps_cur_mb_info = &ps_dec->ps_frm_mb_info[u2_cur_dec_mb_num]; | |
| ps_dec->u4_dma_buf_idx = 0; | |
| ps_dec->u4_pred_info_idx = 0; | |
| if(ps_cur_mb_info->u1_mb_type <= u1_skip_th) | |
| { | |
| WORD32 pred_cnt = 0; | |
| pred_info_pkd_t *ps_pred_pkd; | |
| UWORD32 u4_pred_info_pkd_idx; | |
| WORD8 i1_pred; | |
| u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx; | |
| while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts) | |
| { | |
| ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx; | |
| ps_dec->p_form_mb_part_info_thread(ps_pred_pkd,ps_dec, | |
| ps_cur_mb_info->u2_mbx, | |
| ps_cur_mb_info->u2_mby, | |
| (i >> u1_mbaff), | |
| ps_cur_mb_info); | |
| u4_pred_info_pkd_idx++; | |
| pred_cnt++; | |
| } | |
| ps_dec->p_mc_dec_thread(ps_dec, ps_cur_mb_info); | |
| } | |
| else if(ps_cur_mb_info->u1_mb_type == MB_SKIP) | |
| { | |
| WORD32 pred_cnt = 0; | |
| pred_info_pkd_t *ps_pred_pkd; | |
| UWORD32 u4_pred_info_pkd_idx; | |
| WORD8 i1_pred; | |
| u4_pred_info_pkd_idx = ps_cur_mb_info->u4_pred_info_pkd_idx; | |
| while(pred_cnt < ps_cur_mb_info->u1_num_pred_parts) | |
| { | |
| ps_pred_pkd = ps_dec->ps_pred_pkd + u4_pred_info_pkd_idx; | |
| ps_dec->p_form_mb_part_info_thread(ps_pred_pkd,ps_dec, | |
| ps_cur_mb_info->u2_mbx, | |
| ps_cur_mb_info->u2_mby, | |
| (i >> u1_mbaff), | |
| ps_cur_mb_info); | |
| u4_pred_info_pkd_idx++; | |
| pred_cnt++; | |
| } | |
| /* Decode MB skip */ | |
| ps_dec->p_mc_dec_thread(ps_dec, ps_cur_mb_info); | |
| } | |
| u2_cur_dec_mb_num++; | |
| } | |
| /* N Mb IQ IT RECON Loop */ | |
| for(j = 0; j < i; j++) | |
| { | |
| ps_cur_mb_info = &ps_dec->ps_frm_mb_info[ps_dec->cur_dec_mb_num]; | |
| if((ps_dec->u4_num_cores == 2) || !ps_dec->i1_recon_in_thread3_flag) | |
| { | |
| if(ps_cur_mb_info->u1_mb_type <= u1_skip_th) | |
| { | |
| ih264d_process_inter_mb(ps_dec, ps_cur_mb_info, j); | |
| } | |
| else if(ps_cur_mb_info->u1_mb_type != MB_SKIP) | |
| { | |
| if((u1_ipcm_th + 25) != ps_cur_mb_info->u1_mb_type) | |
| { | |
| ps_cur_mb_info->u1_mb_type -= (u1_skip_th + 1); | |
| ih264d_process_intra_mb(ps_dec, ps_cur_mb_info, j); | |
| } | |
| } | |
| if(ps_dec->u4_use_intrapred_line_copy == 1) | |
| ih264d_copy_intra_pred_line(ps_dec, ps_cur_mb_info, j); | |
| } | |
| DATA_SYNC(); | |
| if(u1_mbaff) | |
| { | |
| if(u4_update_mbaff) | |
| { | |
| UWORD32 u4_mb_num = ps_cur_mb_info->u2_mbx | |
| + ps_dec->u2_frm_wd_in_mbs | |
| * (ps_cur_mb_info->u2_mby >> 1); | |
| UPDATE_MB_MAP_MBNUM_BYTE(ps_dec->pu1_recon_mb_map, u4_mb_num); | |
| u4_update_mbaff = 0; | |
| } | |
| else | |
| { | |
| u4_update_mbaff = 1; | |
| } | |
| } | |
| else | |
| { | |
| UWORD32 u4_mb_num = ps_cur_mb_info->u2_mbx | |
| + ps_dec->u2_frm_wd_in_mbs * ps_cur_mb_info->u2_mby; | |
| UPDATE_MB_MAP_MBNUM_BYTE(ps_dec->pu1_recon_mb_map, u4_mb_num); | |
| } | |
| ps_dec->cur_dec_mb_num++; | |
| } | |
| /*N MB deblocking*/ | |
| if(ps_dec->u4_nmb_deblk == 1) | |
| { | |
| UWORD32 u4_wd_y, u4_wd_uv; | |
| tfr_ctxt_t *ps_tfr_cxt = &(ps_dec->s_tran_addrecon); | |
| UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag; | |
| const WORD32 i4_cb_qp_idx_ofst = | |
| ps_dec->ps_cur_pps->i1_chroma_qp_index_offset; | |
| const WORD32 i4_cr_qp_idx_ofst = | |
| ps_dec->ps_cur_pps->i1_second_chroma_qp_index_offset; | |
| u4_wd_y = ps_dec->u2_frm_wd_y << u1_field_pic_flag; | |
| u4_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag; | |
| ps_cur_mb_info = &ps_dec->ps_frm_mb_info[ps_dec->u4_cur_deblk_mb_num]; | |
| ps_dec->u4_deblk_mb_x = ps_cur_mb_info->u2_mbx; | |
| ps_dec->u4_deblk_mb_y = ps_cur_mb_info->u2_mby; | |
| for(j = 0; j < i; j++) | |
| { | |
| ih264d_deblock_mb_nonmbaff(ps_dec, ps_tfr_cxt, | |
| i4_cb_qp_idx_ofst, i4_cr_qp_idx_ofst, | |
| u4_wd_y, u4_wd_uv); | |
| } | |
| } | |
| /*handle the last mb in picture case*/ | |
| if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr) | |
| ps_dec->u4_cur_slice_decode_done = 1; | |
| if(i != u4_num_mbs) | |
| { | |
| u4_end_of_row = 0; | |
| /*Number of MB's left in row*/ | |
| u4_num_mbs_next = u4_num_mbs_next + ((u4_num_mbs - i) >> u1_mbaff); | |
| } | |
| ih264d_decode_tfr_nmb(ps_dec, (i), u4_num_mbs_next, u4_end_of_row); | |
| return OK; | |
| } | |
| WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec) | |
| { | |
| UWORD32 u4_num_mbs_next, u4_num_mbsleft, u4_end_of_row = 0; | |
| const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; | |
| UWORD32 u4_mbaff, u4_num_mbs; | |
| UWORD16 u2_first_mb_in_slice; | |
| UWORD16 i16_mb_x, i16_mb_y; | |
| UWORD8 u1_field_pic; | |
| UWORD32 u4_frame_stride, x_offset, y_offset; | |
| WORD32 ret; | |
| tfr_ctxt_t *ps_trns_addr; | |
| /*check for mb map of first mb in slice to ensure slice header is parsed*/ | |
| while(1) | |
| { | |
| UWORD32 u4_mb_num = ps_dec->cur_dec_mb_num; | |
| UWORD32 u4_cond = 0; | |
| WORD32 nop_cnt = 8 * 128; | |
| CHECK_MB_MAP_BYTE(u4_mb_num, ps_dec->pu1_dec_mb_map, u4_cond); | |
| if(u4_cond) | |
| { | |
| break; | |
| } | |
| else | |
| { | |
| if(nop_cnt > 0) | |
| { | |
| nop_cnt -= 128; | |
| NOP(128); | |
| } | |
| else if(ps_dec->u4_output_present && (2 == ps_dec->u4_num_cores) && | |
| (ps_dec->u4_fmt_conv_cur_row < ps_dec->s_disp_frame_info.u4_y_ht)) | |
| { | |
| ps_dec->u4_fmt_conv_num_rows = | |
| MIN(FMT_CONV_NUM_ROWS, | |
| (ps_dec->s_disp_frame_info.u4_y_ht | |
| - ps_dec->u4_fmt_conv_cur_row)); | |
| ih264d_format_convert(ps_dec, &(ps_dec->s_disp_op), | |
| ps_dec->u4_fmt_conv_cur_row, | |
| ps_dec->u4_fmt_conv_num_rows); | |
| ps_dec->u4_fmt_conv_cur_row += ps_dec->u4_fmt_conv_num_rows; | |
| } | |
| else | |
| { | |
| nop_cnt = 8*128; | |
| ithread_yield(); | |
| } | |
| DEBUG_THREADS_PRINTF("waiting for mb mapcur_dec_mb_num = %d,ps_dec->u4_cur_mb_addr = %d\n",u2_cur_dec_mb_num, | |
| ps_dec->u4_cur_mb_addr); | |
| } | |
| } | |
| u4_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; | |
| u2_first_mb_in_slice = ps_dec->ps_decode_cur_slice->u4_first_mb_in_slice; | |
| i16_mb_x = MOD(u2_first_mb_in_slice, i2_pic_wdin_mbs); | |
| i16_mb_y = DIV(u2_first_mb_in_slice, i2_pic_wdin_mbs); | |
| i16_mb_y <<= u4_mbaff; | |
| ps_dec->i2_dec_thread_mb_y = i16_mb_y; | |
| ps_dec->cur_dec_mb_num = u2_first_mb_in_slice << u4_mbaff; | |
| if((ps_dec->u4_num_cores == 2) || !ps_dec->i1_recon_in_thread3_flag) | |
| { | |
| ps_dec->pv_proc_tu_coeff_data = | |
| (void *) ps_dec->ps_decode_cur_slice->pv_tu_coeff_data_start; | |
| } | |
| // recalculate recon pointers | |
| u1_field_pic = ps_dec->ps_cur_slice->u1_field_pic_flag; | |
| u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic; | |
| x_offset = i16_mb_x << 4; | |
| y_offset = (i16_mb_y * u4_frame_stride) << 4; | |
| ps_trns_addr = &(ps_dec->s_tran_addrecon); | |
| ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset + y_offset; | |
| u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic; | |
| x_offset >>= 1; | |
| y_offset = (i16_mb_y * u4_frame_stride) << 3; | |
| x_offset *= YUV420SP_FACTOR; | |
| ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset + y_offset; | |
| ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset + y_offset; | |
| ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y; | |
| ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u; | |
| ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v; | |
| /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */ | |
| { | |
| ps_dec->p_mc_dec_thread = ih264d_motion_compensate_bp; | |
| ps_dec->p_form_mb_part_info_thread = ih264d_form_mb_part_info_bp; | |
| } | |
| { | |
| UWORD8 uc_nofield_nombaff; | |
| uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) | |
| && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) | |
| && (ps_dec->ps_decode_cur_slice->slice_type != B_SLICE) | |
| && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0)); | |
| if(uc_nofield_nombaff == 0) | |
| { | |
| ps_dec->p_mc_dec_thread = ih264d_motion_compensate_mp; | |
| ps_dec->p_form_mb_part_info_thread = ih264d_form_mb_part_info_mp; | |
| } | |
| } | |
| ps_dec->u4_cur_slice_decode_done = 0; | |
| while(ps_dec->u4_cur_slice_decode_done != 1) | |
| { | |
| u4_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u4_mbaff); | |
| if(u4_num_mbsleft <= ps_dec->u4_recon_mb_grp) | |
| { | |
| u4_num_mbs = u4_num_mbsleft; | |
| /*Indicate number of mb's left in a row*/ | |
| u4_num_mbs_next = 0; | |
| u4_end_of_row = 1; | |
| i16_mb_x = 0; | |
| } | |
| else | |
| { | |
| u4_num_mbs = ps_dec->u4_recon_mb_grp; | |
| /*Indicate number of mb's left in a row*/ | |
| u4_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x | |
| - (ps_dec->u4_recon_mb_grp >> u4_mbaff); | |
| i16_mb_x += (u4_num_mbs >> u4_mbaff); | |
| u4_end_of_row = 0; | |
| } | |
| ret = ih264d_decode_recon_tfr_nmb_thread(ps_dec, u4_num_mbs, u4_num_mbs_next, | |
| u4_end_of_row); | |
| if(ret != OK) | |
| return ret; | |
| } | |
| return OK; | |
| } | |
| void ih264d_decode_picture_thread(dec_struct_t *ps_dec ) | |
| { | |
| ithread_set_name("ih264d_decode_picture_thread"); | |
| while(1) | |
| { | |
| WORD32 ret; | |
| if(ps_dec->i4_threads_active) | |
| { | |
| ret = ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]); | |
| if(OK != ret) | |
| break; | |
| while(ps_dec->ai4_process_start[0] != PROC_START) | |
| { | |
| ithread_cond_wait(ps_dec->apv_proc_start_condition[0], | |
| ps_dec->apv_proc_start_mutex[0]); | |
| } | |
| ps_dec->ai4_process_start[0] = PROC_IN_PROGRESS; | |
| ret = ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]); | |
| if(OK != ret || ps_dec->i4_break_threads == 1) | |
| break; | |
| } | |
| while(1) | |
| { | |
| /*Complete all writes before processing next slice*/ | |
| DEBUG_THREADS_PRINTF(" Entering decode slice\n"); | |
| ih264d_decode_slice_thread(ps_dec); | |
| DEBUG_THREADS_PRINTF(" Exit ih264d_decode_slice_thread \n"); | |
| if(ps_dec->cur_dec_mb_num | |
| > ps_dec->ps_cur_sps->u4_max_mb_addr) | |
| { | |
| /*Last slice in frame*/ | |
| break; | |
| } | |
| else | |
| { | |
| ps_dec->ps_decode_cur_slice++; | |
| ps_dec->u2_cur_slice_num_dec_thread++; | |
| } | |
| } | |
| if(ps_dec->u4_output_present && (2 == ps_dec->u4_num_cores) && | |
| (ps_dec->u4_fmt_conv_cur_row < ps_dec->s_disp_frame_info.u4_y_ht)) | |
| { | |
| ps_dec->u4_fmt_conv_num_rows = | |
| (ps_dec->s_disp_frame_info.u4_y_ht | |
| - ps_dec->u4_fmt_conv_cur_row); | |
| ih264d_format_convert(ps_dec, &(ps_dec->s_disp_op), | |
| ps_dec->u4_fmt_conv_cur_row, | |
| ps_dec->u4_fmt_conv_num_rows); | |
| ps_dec->u4_fmt_conv_cur_row += ps_dec->u4_fmt_conv_num_rows; | |
| } | |
| if(ps_dec->i4_threads_active) | |
| { | |
| ret = ithread_mutex_lock(ps_dec->apv_proc_done_mutex[0]); | |
| if(OK != ret) | |
| break; | |
| ps_dec->ai4_process_done[0] = PROC_DONE; | |
| ithread_cond_signal(ps_dec->apv_proc_done_condition[0]); | |
| ret = ithread_mutex_unlock(ps_dec->apv_proc_done_mutex[0]); | |
| if(OK != ret) | |
| break; | |
| } | |
| else | |
| { | |
| break; | |
| } | |
| } | |
| } | |
| void ih264d_signal_decode_thread(dec_struct_t *ps_dec) | |
| { | |
| if(ps_dec->u4_dec_thread_created == 1) | |
| { | |
| if(ps_dec->i4_threads_active) | |
| { | |
| proc_state_t i4_process_state; | |
| ithread_mutex_lock(ps_dec->apv_proc_start_mutex[0]); | |
| i4_process_state = ps_dec->ai4_process_start[0]; | |
| ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[0]); | |
| // only wait if the thread has started decoding | |
| if(i4_process_state != PROC_INIT) | |
| { | |
| ithread_mutex_lock(ps_dec->apv_proc_done_mutex[0]); | |
| while(ps_dec->ai4_process_done[0] != PROC_DONE) | |
| { | |
| ithread_cond_wait(ps_dec->apv_proc_done_condition[0], | |
| ps_dec->apv_proc_done_mutex[0]); | |
| } | |
| ps_dec->ai4_process_done[0] = PROC_INIT; | |
| ithread_mutex_unlock(ps_dec->apv_proc_done_mutex[0]); | |
| } | |
| } | |
| else | |
| { | |
| ithread_join(ps_dec->pv_dec_thread_handle, NULL); | |
| ps_dec->u4_dec_thread_created = 0; | |
| } | |
| } | |
| } | |
| void ih264d_signal_bs_deblk_thread(dec_struct_t *ps_dec) | |
| { | |
| if(ps_dec->u4_bs_deblk_thread_created) | |
| { | |
| if(ps_dec->i4_threads_active) | |
| { | |
| proc_state_t i4_process_state; | |
| ithread_mutex_lock(ps_dec->apv_proc_start_mutex[1]); | |
| i4_process_state = ps_dec->ai4_process_start[1]; | |
| ithread_mutex_unlock(ps_dec->apv_proc_start_mutex[1]); | |
| // only wait if the thread has started deblking | |
| if(i4_process_state != PROC_INIT) | |
| { | |
| ithread_mutex_lock(ps_dec->apv_proc_done_mutex[1]); | |
| while(ps_dec->ai4_process_done[1] != PROC_DONE) | |
| { | |
| ithread_cond_wait(ps_dec->apv_proc_done_condition[1], | |
| ps_dec->apv_proc_done_mutex[1]); | |
| } | |
| ps_dec->ai4_process_done[1] = PROC_INIT; | |
| ithread_mutex_unlock(ps_dec->apv_proc_done_mutex[1]); | |
| } | |
| } | |
| else | |
| { | |
| ithread_join(ps_dec->pv_bs_deblk_thread_handle, NULL); | |
| ps_dec->u4_bs_deblk_thread_created = 0; | |
| } | |
| } | |
| } |