void SoftAVC::initEncParams() {
mCodecCtx = NULL;
mMemRecords = NULL;
mNumMemRecords = DEFAULT_MEM_REC_CNT;
mHeaderGenerated = 0;
mNumCores = GetCPUCoreCount();
mArch = DEFAULT_ARCH;
mSliceMode = DEFAULT_SLICE_MODE;
mSliceParam = DEFAULT_SLICE_PARAM;
mHalfPelEnable = DEFAULT_HPEL;
mIInterval = DEFAULT_I_INTERVAL;
mIDRInterval = DEFAULT_IDR_INTERVAL;
mDisableDeblkLevel = DEFAULT_DISABLE_DEBLK_LEVEL;
mEnableFastSad = DEFAULT_ENABLE_FAST_SAD;
mEnableAltRef = DEFAULT_ENABLE_ALT_REF;
mEncSpeed = DEFAULT_ENC_SPEED;
mIntra4x4 = DEFAULT_INTRA4x4;
mConstrainedIntraFlag = DEFAULT_CONSTRAINED_INTRA;
mAIRMode = DEFAULT_AIR;
mAIRRefreshPeriod = DEFAULT_AIR_REFRESH_PERIOD;
mPSNREnable = DEFAULT_PSNR_ENABLE;
mReconEnable = DEFAULT_RECON_ENABLE;
mEntropyMode = DEFAULT_ENTROPY_MODE;
mBframes = DEFAULT_B_FRAMES;
gettimeofday(&mTimeStart, NULL);
gettimeofday(&mTimeEnd, NULL);
}
OMX_ERRORTYPE OMXVideoDecoderVP9HWR::initDecoder()
{
mCtx = new vpx_codec_ctx_t;
vpx_codec_err_t vpx_err;
vpx_codec_dec_cfg_t cfg;
memset(&cfg, 0, sizeof(vpx_codec_dec_cfg_t));
cfg.threads = GetCPUCoreCount();
if ((vpx_err = vpx_codec_dec_init(
(vpx_codec_ctx_t *)mCtx,
&vpx_codec_vp9_dx_algo,
&cfg, 0))) {
LOGE("on2 decoder failed to initialize. (%d)", vpx_err);
return OMX_ErrorNotReady;
}
mNumFrameBuffer = OUTPORT_NATIVE_BUFFER_COUNT;
if (vpx_codec_set_frame_buffer_functions((vpx_codec_ctx_t *)mCtx,
getVP9FrameBuffer,
releaseVP9FrameBuffer,
this)) {
LOGE("Failed to configure external frame buffers");
return OMX_ErrorNotReady;
}
return OMX_ErrorNone;
}
status_t SoftHEVC::initDecoder() {
IV_API_CALL_STATUS_T status;
mNumCores = GetCPUCoreCount();
mCodecCtx = NULL;
mStride = outputBufferWidth();
/* Initialize the decoder */
{
ivdext_create_ip_t s_create_ip;
ivdext_create_op_t s_create_op;
void *dec_fxns = (void *)ivdec_api_function;
s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ivdext_create_ip_t);
s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
s_create_op.s_ivd_create_op_t.u4_size = sizeof(ivdext_create_op_t);
s_create_ip.s_ivd_create_ip_t.e_output_format = mIvColorFormat;
s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
status = ivdec_api_function(mCodecCtx, (void *)&s_create_ip, (void *)&s_create_op);
mCodecCtx = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
mCodecCtx->pv_fxns = dec_fxns;
mCodecCtx->u4_size = sizeof(iv_obj_t);
if (status != IV_SUCCESS) {
ALOGE("Error in create: 0x%x",
s_create_op.s_ivd_create_op_t.u4_error_code);
deInitDecoder();
mCodecCtx = NULL;
return UNKNOWN_ERROR;
}
}
/* Reset the plugin state */
resetPlugin();
/* Set the run time (dynamic) parameters */
setParams(mStride);
/* Set number of cores/threads to be used by the codec */
setNumCores();
/* Get codec version */
logVersion();
mFlushNeeded = false;
return OK;
}
status_t SoftVPX::initDecoder() {
mCtx = new vpx_codec_ctx_t;
vpx_codec_err_t vpx_err;
vpx_codec_dec_cfg_t cfg;
memset(&cfg, 0, sizeof(vpx_codec_dec_cfg_t));
cfg.threads = GetCPUCoreCount();
if ((vpx_err = vpx_codec_dec_init(
(vpx_codec_ctx_t *)mCtx,
mMode == MODE_VP8 ? &vpx_codec_vp8_dx_algo : &vpx_codec_vp9_dx_algo,
&cfg, 0))) {
ALOGE("on2 decoder failed to initialize. (%d)", vpx_err);
return UNKNOWN_ERROR;
}
return OK;
}
status_t SoftAVC::initDecoder(uint32_t width, uint32_t height) {
IV_API_CALL_STATUS_T status;
UWORD32 u4_num_reorder_frames;
UWORD32 u4_num_ref_frames;
UWORD32 u4_share_disp_buf;
WORD32 i4_level;
mNumCores = GetCPUCoreCount();
mCodecCtx = NULL;
/* Initialize number of ref and reorder modes (for H264) */
u4_num_reorder_frames = 16;
u4_num_ref_frames = 16;
u4_share_disp_buf = 0;
uint32_t displayStride = mIsAdaptive ? mAdaptiveMaxWidth : width;
uint32_t displayHeight = mIsAdaptive ? mAdaptiveMaxHeight : height;
uint32_t displaySizeY = displayStride * displayHeight;
if(mNewLevel == 0){
if (displaySizeY > (1920 * 1088)) {
i4_level = 50;
} else if (displaySizeY > (1280 * 720)) {
i4_level = 40;
} else if (displaySizeY > (720 * 576)) {
i4_level = 31;
} else if (displaySizeY > (624 * 320)) {
i4_level = 30;
} else if (displaySizeY > (352 * 288)) {
i4_level = 21;
} else {
i4_level = 20;
}
} else {
i4_level = mNewLevel;
}
{
iv_num_mem_rec_ip_t s_num_mem_rec_ip;
iv_num_mem_rec_op_t s_num_mem_rec_op;
s_num_mem_rec_ip.u4_size = sizeof(s_num_mem_rec_ip);
s_num_mem_rec_op.u4_size = sizeof(s_num_mem_rec_op);
s_num_mem_rec_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
ALOGV("Get number of mem records");
status = ivdec_api_function(
mCodecCtx, (void *)&s_num_mem_rec_ip, (void *)&s_num_mem_rec_op);
if (IV_SUCCESS != status) {
ALOGE("Error in getting mem records: 0x%x",
s_num_mem_rec_op.u4_error_code);
return UNKNOWN_ERROR;
}
mNumMemRecords = s_num_mem_rec_op.u4_num_mem_rec;
}
mMemRecords = (iv_mem_rec_t *)ivd_aligned_malloc(
128, mNumMemRecords * sizeof(iv_mem_rec_t));
if (mMemRecords == NULL) {
ALOGE("Allocation failure");
return NO_MEMORY;
}
memset(mMemRecords, 0, mNumMemRecords * sizeof(iv_mem_rec_t));
{
size_t i;
ivdext_fill_mem_rec_ip_t s_fill_mem_ip;
ivdext_fill_mem_rec_op_t s_fill_mem_op;
iv_mem_rec_t *ps_mem_rec;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_size =
sizeof(ivdext_fill_mem_rec_ip_t);
s_fill_mem_ip.i4_level = i4_level;
s_fill_mem_ip.u4_num_reorder_frames = u4_num_reorder_frames;
s_fill_mem_ip.u4_num_ref_frames = u4_num_ref_frames;
s_fill_mem_ip.u4_share_disp_buf = u4_share_disp_buf;
s_fill_mem_ip.u4_num_extra_disp_buf = 0;
s_fill_mem_ip.e_output_format = mIvColorFormat;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.pv_mem_rec_location = mMemRecords;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_wd = displayStride;
s_fill_mem_ip.s_ivd_fill_mem_rec_ip_t.u4_max_frm_ht = displayHeight;
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_size =
sizeof(ivdext_fill_mem_rec_op_t);
ps_mem_rec = mMemRecords;
for (i = 0; i < mNumMemRecords; i++) {
ps_mem_rec[i].u4_size = sizeof(iv_mem_rec_t);
}
status = ivdec_api_function(
mCodecCtx, (void *)&s_fill_mem_ip, (void *)&s_fill_mem_op);
if (IV_SUCCESS != status) {
ALOGE("Error in filling mem records: 0x%x",
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_error_code);
return UNKNOWN_ERROR;
}
mNumMemRecords =
s_fill_mem_op.s_ivd_fill_mem_rec_op_t.u4_num_mem_rec_filled;
ps_mem_rec = mMemRecords;
for (i = 0; i < mNumMemRecords; i++) {
ps_mem_rec->pv_base = ivd_aligned_malloc(
ps_mem_rec->u4_mem_alignment, ps_mem_rec->u4_mem_size);
if (ps_mem_rec->pv_base == NULL) {
ALOGE("Allocation failure for memory record #%zu of size %u",
i, ps_mem_rec->u4_mem_size);
status = IV_FAIL;
return NO_MEMORY;
}
ps_mem_rec++;
}
}
/* Initialize the decoder */
{
ivdext_init_ip_t s_init_ip;
ivdext_init_op_t s_init_op;
void *dec_fxns = (void *)ivdec_api_function;
s_init_ip.s_ivd_init_ip_t.u4_size = sizeof(ivdext_init_ip_t);
s_init_ip.s_ivd_init_ip_t.e_cmd = (IVD_API_COMMAND_TYPE_T)IV_CMD_INIT;
s_init_ip.s_ivd_init_ip_t.pv_mem_rec_location = mMemRecords;
s_init_ip.s_ivd_init_ip_t.u4_frm_max_wd = displayStride;
s_init_ip.s_ivd_init_ip_t.u4_frm_max_ht = displayHeight;
s_init_ip.i4_level = i4_level;
s_init_ip.u4_num_reorder_frames = u4_num_reorder_frames;
s_init_ip.u4_num_ref_frames = u4_num_ref_frames;
s_init_ip.u4_share_disp_buf = u4_share_disp_buf;
s_init_ip.u4_num_extra_disp_buf = 0;
s_init_op.s_ivd_init_op_t.u4_size = sizeof(s_init_op);
s_init_ip.s_ivd_init_ip_t.u4_num_mem_rec = mNumMemRecords;
s_init_ip.s_ivd_init_ip_t.e_output_format = mIvColorFormat;
mCodecCtx = (iv_obj_t *)mMemRecords[0].pv_base;
mCodecCtx->pv_fxns = dec_fxns;
mCodecCtx->u4_size = sizeof(iv_obj_t);
status = ivdec_api_function(mCodecCtx, (void *)&s_init_ip, (void *)&s_init_op);
if (status != IV_SUCCESS) {
mCodecCtx = NULL;
ALOGE("Error in init: 0x%x",
s_init_op.s_ivd_init_op_t.u4_error_code);
return UNKNOWN_ERROR;
}
}
/* Reset the plugin state */
resetPlugin();
/* Set the run time (dynamic) parameters */
setParams(displayStride);
/* Set number of cores/threads to be used by the codec */
setNumCores();
/* Get codec version */
logVersion();
/* Allocate internal picture buffer */
uint32_t bufferSize = displaySizeY * 3 / 2;
mFlushOutBuffer = (uint8_t *)ivd_aligned_malloc(128, bufferSize);
if (NULL == mFlushOutBuffer) {
ALOGE("Could not allocate flushOutputBuffer of size %u", bufferSize);
return NO_MEMORY;
}
mInitNeeded = false;
mFlushNeeded = false;
return OK;
}
