| /* |
| * Copyright (C) 2019-2020 Intel Corporation. |
| * |
| * 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. |
| */ |
| |
| #define LOG_TAG "IntelIspParamAdaptor" |
| |
| #include "modules/algowrapper/IntelIspParamAdaptor.h" |
| |
| #include "iutils/CameraLog.h" |
| |
| namespace icamera { |
| |
| IntelIspParamAdaptor::IntelIspParamAdaptor() { |
| LOG2("@%s", __func__); |
| } |
| |
| IntelIspParamAdaptor::~IntelIspParamAdaptor() { |
| LOG2("@%s", __func__); |
| } |
| |
| ia_isp_bxt* IntelIspParamAdaptor::init(const ia_binary_data* ispData, const ia_cmc_t* iaCmc, |
| unsigned int maxStatsWidth, unsigned int maxStatsHeight, |
| unsigned int maxNumStatsIn, ia_mkn* iaMkn) { |
| LOG2("@%s", __func__); |
| CheckError(!ispData || !iaCmc, nullptr, "%s, No CPF or CMC data", __func__); |
| LOG1("%s, ispData size: %d, pointer: %p, max width: %u, max height: %u", __func__, |
| ispData->size, ispData->data, maxStatsWidth, maxStatsHeight); |
| |
| return ia_isp_bxt_init(ispData, iaCmc, maxStatsWidth, maxStatsHeight, maxNumStatsIn, iaMkn); |
| } |
| |
| void IntelIspParamAdaptor::deInit(ia_isp_bxt* ispBxtHandle) { |
| LOG2("@%s", __func__); |
| CheckError(!ispBxtHandle, VOID_VALUE, "%s, ispBxtHandle is nullptr", __func__); |
| |
| ia_isp_bxt_deinit(ispBxtHandle); |
| } |
| |
| int IntelIspParamAdaptor::getPalDataSize(ia_isp_bxt_program_group* programGroup) { |
| LOG2("@%s", __func__); |
| CheckError(!programGroup, -1, "%s programGroup is nullptr", __func__); |
| |
| return ia_isp_bxt_get_output_size(programGroup); |
| } |
| |
| void IntelIspParamAdaptor::freePalBuffer(void* addr) { |
| LOG2("@%s addr: %p", __func__, addr); |
| free(addr); |
| } |
| |
| void* IntelIspParamAdaptor::allocatePalBuffer(int streamId, int index, int palDataSize) { |
| LOG2("@%s index: %d, streamId: %d, size: %d", __func__, index, streamId, palDataSize); |
| |
| return calloc(1, palDataSize); |
| } |
| |
| status_t IntelIspParamAdaptor::runPal(ia_isp_bxt* ispBxtHandle, |
| const ia_isp_bxt_input_params_v2* inputParams, |
| ia_binary_data* outputData) { |
| LOG2("@%s", __func__); |
| CheckError((!ispBxtHandle || !inputParams), UNKNOWN_ERROR, |
| "%s, ispBxtHandle or inputParams is nullptr", __func__); |
| CheckError((!outputData || !outputData->data || outputData->size <= 0), UNKNOWN_ERROR, |
| "%s, Wrong pal data buffer", __func__); |
| |
| ia_err ret = ia_isp_bxt_run_v2(ispBxtHandle, inputParams, outputData); |
| CheckError(ret != ia_err_none && ret != ia_err_not_run, UNKNOWN_ERROR, "%s, run PAL failed %d", |
| __func__, ret); |
| |
| // if PAL doesn't run, set output size to 0 |
| if (ret == ia_err_not_run) outputData->size = 0; |
| |
| LOG1("%s, The pal result size: %d", __func__, outputData->size); |
| |
| return OK; |
| } |
| |
| status_t IntelIspParamAdaptor::queryAndConvertStats(ia_isp_bxt* ispBxtHandle, |
| ConvertInputParam* inputParams, |
| ConvertResult* result) { |
| LOG2("@%s", __func__); |
| CheckError(!ispBxtHandle, UNKNOWN_ERROR, "%s, ispBxtHandle is nullptr", __func__); |
| CheckError(!inputParams || !result, UNKNOWN_ERROR, "%s, inputParams or result nullptr", |
| __func__); |
| CheckError(!inputParams->dvsReso || !inputParams->aeResults, UNKNOWN_ERROR, |
| "%s, inputParams or result nullptr", __func__); |
| CheckError((!inputParams->statsBuffer || !inputParams->statsBuffer->data || |
| inputParams->statsBuffer->size <= 0), |
| UNKNOWN_ERROR, "%s, Wrong statistics buffer", __func__); |
| CheckError(!result->queryResults, UNKNOWN_ERROR, "%s, queryResults is nullptr", __func__); |
| |
| ia_err ret = |
| ia_isp_bxt_statistics_query(ispBxtHandle, inputParams->statsBuffer, result->queryResults); |
| CheckError(ret != ia_err_none, UNKNOWN_ERROR, "%s, Query statistice failed %d", __func__, ret); |
| |
| // Decode DVS statistics |
| if (result->queryResults->dvs_stats) { |
| if (inputParams->dvsReso->width == 0 || inputParams->dvsReso->height == 0) { |
| LOGW("%s, The gdc resolution for DVS isn't correct", __func__); |
| } else { |
| ret = ia_isp_bxt_statistics_convert_dvs_from_binary( |
| ispBxtHandle, inputParams->statsBuffer, inputParams->dvsReso->width, |
| inputParams->dvsReso->height, &(result->dvsStats)); |
| CheckWarning((ret != ia_err_none || !result->dvsStats), UNKNOWN_ERROR, |
| "%s, Failed to convert DVS statistics %d", __func__, ret); |
| LOG3A("%s, DVS stat vector_count: %u", __func__, result->dvsStats->vector_count); |
| } |
| } |
| |
| // Decode psa rgbs and af statistics |
| if (result->queryResults->rgbs_grid && result->queryResults->af_grid && |
| !inputParams->multiExpo) { |
| ret = ia_isp_bxt_statistics_convert_awb_from_binary_v3( |
| ispBxtHandle, inputParams->statsBuffer, nullptr, inputParams->aeResults, |
| inputParams->bcompResult, result->rgbsGrid, nullptr); |
| |
| ia_aiq_rgbs_grid* rgbs = *(result->rgbsGrid); |
| CheckWarning((ret != ia_err_none || !rgbs), UNKNOWN_ERROR, |
| "%s, Failed to convert psa RGBS statistics %d", __func__, ret); |
| LOG3A("%s, RGBS stat grid %dx%d", __func__, rgbs->grid_width, rgbs->grid_height); |
| |
| ret = ia_isp_bxt_statistics_convert_af_from_binary(ispBxtHandle, inputParams->statsBuffer, |
| &(result->afGrid)); |
| CheckWarning((ret != ia_err_none || !result->afGrid), UNKNOWN_ERROR, |
| "%s, Failed to convert psa AF statistics %d", __func__, ret); |
| LOG3A("%s, AF stat grid %dx%d", __func__, result->afGrid->grid_width, |
| result->afGrid->grid_height); |
| } |
| |
| return OK; |
| } |
| } // namespace icamera |