bool
IaIspAdaptor15::init (
const ia_binary_data *cpf,
unsigned int max_width,
unsigned int max_height,
ia_cmc_t *cmc,
ia_mkn *mkn)
{
xcam_mem_clear (&_input_params);
_input_params.isp_vamem_type = 1;
_handle = ia_isp_1_5_init (cpf, max_width, max_height, cmc, mkn);
XCAM_FAIL_RETURN (ERROR, _handle, false, "ia_isp 1.5 init failed");
return true;
}
VKPipeline::VKPipeline (
const SmartPtr<VKDevice> dev,
const ShaderVec &shaders,
const VKDescriptor::BindingArray &bindings,
const VKConstRange::VKConstantArray &consts)
: _pipe_id (VK_NULL_HANDLE)
, _dev (dev)
, _shaders (shaders)
, _bindings (bindings)
, _push_consts (consts)
{
_allocator = _dev->get_allocation_cb ();
xcam_mem_clear (_name);
}
AiqAeHandler::AiqAeResult::AiqAeResult()
{
xcam_mem_clear (&ae_result);
xcam_mem_clear (&ae_exp_ret);
xcam_mem_clear (&aiq_exp_param);
xcam_mem_clear (&sensor_exp_param);
xcam_mem_clear (&weight_grid);
xcam_mem_clear (&flash_param);
}
X3aAnalyzerAiq::X3aAnalyzerAiq (SmartPtr<IspController> &isp, const char *cpf_path)
: X3aAnalyzer ("X3aAnalyzerAiq")
, _isp (isp)
, _sensor_data_ready (false)
, _cpf_path (NULL)
{
if (cpf_path)
_cpf_path = strdup (cpf_path);
_aiq_compositor = new AiqCompositor ();
XCAM_ASSERT (_aiq_compositor.ptr());
xcam_mem_clear (_sensor_mode_data);
XCAM_LOG_DEBUG ("X3aAnalyzerAiq constructed");
}
V4l2Device::V4l2Device (const char *name)
: _name (NULL)
, _fd (-1)
, _sensor_id (0)
, _capture_mode (0)
, _capture_buf_type (V4L2_BUF_TYPE_VIDEO_CAPTURE)
, _memory_type (V4L2_MEMORY_MMAP)
, _fps_n (0)
, _fps_d (0)
, _active (false)
, _buf_count (XCAM_V4L2_DEFAULT_BUFFER_COUNT)
{
if (name)
_name = strndup (name, XCAM_MAX_STR_SIZE);
xcam_mem_clear (_format);
}
XCamReturn
IspController::set_3a_focus (const XCam3aResultFocus &focus)
{
int position = focus.position;
struct v4l2_control control;
xcam_mem_clear (&control);
control.id = V4L2_CID_FOCUS_ABSOLUTE;
control.value = position;
if (_device->io_control (VIDIOC_S_CTRL, &control) < 0) {
XCAM_LOG_WARNING (" set focus result failed to device");
return XCAM_RETURN_ERROR_IOCTL;
}
return XCAM_RETURN_NO_ERROR;
}
bool
AiqCompositor::set_3a_stats (SmartPtr<X3aIspStatistics> &stats)
{
ia_aiq_statistics_input_params aiq_stats_input;
ia_aiq_rgbs_grid *rgbs_grids = NULL;
ia_aiq_af_grid *af_grids = NULL;
xcam_mem_clear (&aiq_stats_input);
aiq_stats_input.frame_timestamp = stats->get_timestamp();
aiq_stats_input.frame_id = stats->get_timestamp() + 1;
aiq_stats_input.rgbs_grids = (const ia_aiq_rgbs_grid **)&rgbs_grids;
aiq_stats_input.num_rgbs_grids = 1;
aiq_stats_input.af_grids = (const ia_aiq_af_grid **)(&af_grids);
aiq_stats_input.num_af_grids = 1;
aiq_stats_input.frame_af_parameters = NULL;
aiq_stats_input.external_histograms = NULL;
aiq_stats_input.num_external_histograms = 0;
aiq_stats_input.camera_orientation = ia_aiq_camera_orientation_unknown;
if (_pa_result)
aiq_stats_input.frame_pa_parameters = _pa_result;
if (_ae_handler->is_started())
aiq_stats_input.frame_ae_parameters = _ae_handler->get_result ();
//if (_awb_handler->is_started())
// aiq_stats_input.frame_awb_parameters = _awb_handler->get_result();
if (!_adaptor->convert_statistics (stats->get_3a_stats(), &rgbs_grids, &af_grids)) {
XCAM_LOG_WARNING ("ia isp adaptor convert 3a stats failed");
return false;
}
XCAM_LOG_DEBUG ("statistics grid info, width:%u, height:%u, blk_r:%u, blk_b:%u, blk_gr:%u, blk_gb:%u",
aiq_stats_input.rgbs_grids[0]->grid_width,
aiq_stats_input.rgbs_grids[0]->grid_height,
aiq_stats_input.rgbs_grids[0]->blocks_ptr->avg_r,
aiq_stats_input.rgbs_grids[0]->blocks_ptr->avg_b,
aiq_stats_input.rgbs_grids[0]->blocks_ptr->avg_gr,
aiq_stats_input.rgbs_grids[0]->blocks_ptr->avg_gb);
if (ia_aiq_statistics_set(get_handle (), &aiq_stats_input) != ia_err_none) {
XCAM_LOG_ERROR ("Aiq set statistic failed");
return false;
}
return true;
}
void
CommonHandler::reset_parameters ()
{
xcam_mem_clear (&_params);
_params.is_manual_gamma = false;
_params.nr_level = 0.0;
_params.tnr_level = 0.0;
_params.brightness = 0.0;
_params.contrast = 0.0;
_params.hue = 0.0;
_params.saturation = 0.0;
_params.sharpness = 0.0;
_params.enable_dvs = false;
_params.enable_gbce = false;
_params.enable_night_mode = false;
}
XCamReturn
V4l2SubDevice::unsubscribe_event (int event)
{
struct v4l2_event_subscription sub;
int ret = 0;
XCAM_ASSERT (is_opened());
xcam_mem_clear (sub);
sub.type = event;
ret = this->io_control (VIDIOC_UNSUBSCRIBE_EVENT, &sub);
if (ret < 0) {
XCAM_LOG_DEBUG ("subdev(%s) unsubscribe event(%d) failed", XCAM_STR(_name), event);
return XCAM_RETURN_ERROR_IOCTL;
}
return XCAM_RETURN_NO_ERROR;
}
void
HybridAnalyzer::x3a_calculation_done (XAnalyzer *analyzer, X3aResultList &results)
{
XCAM_UNUSED (analyzer);
static XCam3aResultHead *res_heads[XCAM_3A_MAX_RESULT_COUNT];
xcam_mem_clear (res_heads);
XCAM_ASSERT (results.size () < XCAM_3A_MAX_RESULT_COUNT);
uint32_t result_count = translate_3a_results_to_xcam (results,
res_heads, XCAM_3A_MAX_RESULT_COUNT);
convert_results (res_heads, result_count, results);
for (uint32_t i = 0; i < result_count; ++i) {
if (res_heads[i])
free_3a_result (res_heads[i]);
}
notify_calculation_done (results);
}
/*! \brief v4l2 set format
*
* \param[in] width format width
* \param[in] height format height
* \param[in] pixelformat fourcc
* \param[in] field V4L2_FIELD_INTERLACED or V4L2_FIELD_NONE
*/
XCamReturn
V4l2Device::set_format (
uint32_t width, uint32_t height,
uint32_t pixelformat, enum v4l2_field field, uint32_t bytes_perline)
{
struct v4l2_format format;
xcam_mem_clear (format);
format.type = _capture_buf_type;
format.fmt.pix.width = width;
format.fmt.pix.height = height;
format.fmt.pix.pixelformat = pixelformat;
format.fmt.pix.field = field;
if (bytes_perline != 0)
format.fmt.pix.bytesperline = bytes_perline;
return set_format (format);
}
void
AwbHandler::reset_parameters ()
{
xcam_mem_clear (&_params);
_params.mode = XCAM_AWB_MODE_AUTO;
_params.speed = 1.0;
_params.cct_min = 0;
_params.cct_max = 0;
_params.gr_gain = 0.0;
_params.r_gain = 0.0;
_params.b_gain = 0.0;
_params.gb_gain = 0.0;
_params.window.x_start = 0;
_params.window.y_start = 0;
_params.window.x_end = 0;
_params.window.y_end = 0;
_params.window.weight = 0;
}
int
V4l2Device::poll_event (int timeout_msec)
{
struct pollfd poll_fd;
int ret = 0;
XCAM_ASSERT (_fd > 0);
xcam_mem_clear (poll_fd);
poll_fd.fd = _fd;
poll_fd.events = (POLLPRI | POLLIN | POLLERR | POLLNVAL | POLLHUP);
ret = poll (&poll_fd, 1, timeout_msec);
if (ret > 0 && (poll_fd.revents & (POLLERR | POLLNVAL | POLLHUP))) {
XCAM_LOG_DEBUG ("v4l2 subdev(%s) polled error", XCAM_STR(_name));
return -1;
}
return ret;
}
XCamReturn
CLPostImageProcessor::apply_3a_result (SmartPtr<X3aResult> &result)
{
STREAM_LOCK;
if (!result.ptr ())
return XCAM_RETURN_BYPASS;
uint32_t res_type = result->get_type ();
switch (res_type) {
case XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV: {
SmartPtr<X3aTemporalNoiseReduction> tnr_res = result.dynamic_cast_ptr<X3aTemporalNoiseReduction> ();
XCAM_ASSERT (tnr_res.ptr ());
if (_tnr.ptr ()) {
if (_defog_mode != CLPostImageProcessor::DefogDisabled) {
XCam3aResultTemporalNoiseReduction config;
xcam_mem_clear (config);
// isp processor
// config.gain = 0.12;
// cl processor
config.gain = 0.22;
config.threshold [0] = 0.00081;
config.threshold [1] = 0.00072;
_tnr->set_yuv_config (config);
} else {
_tnr->set_yuv_config (tnr_res->get_standard_result ());
}
}
break;
}
default:
XCAM_LOG_WARNING ("CLPostImageProcessor unknow 3a result: %d", res_type);
break;
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
V4l2Device::get_format (struct v4l2_format &format)
{
if (is_activated ()) {
format = _format;
return XCAM_RETURN_NO_ERROR;
}
if (!is_opened ())
return XCAM_RETURN_ERROR_IOCTL;
xcam_mem_clear (format);
format.type = _capture_buf_type;
if (this->io_control (VIDIOC_G_FMT, &format) < 0) {
// FIXME: also log the device name?
XCAM_LOG_ERROR("Fail to get format via ioctl VIDVIO_G_FMT.");
return XCAM_RETURN_ERROR_IOCTL;
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
PollThread::init_3a_stats_pool ()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct atomisp_parm parameters;
xcam_mem_clear (parameters);
ret = _isp_controller->get_isp_parameter (parameters);
if (ret != XCAM_RETURN_NO_ERROR ) {
XCAM_LOG_WARNING ("get isp parameters failed");
return ret;
}
if (!parameters.info.width || !parameters.info.height) {
XCAM_LOG_WARNING ("get isp parameters width or height wrong");
return XCAM_RETURN_ERROR_ISP;
}
_3a_stats_pool.dynamic_cast_ptr<X3aStatisticsQueue>()->set_grid_info (parameters.info);
if (!_3a_stats_pool->reserve (6)) {
XCAM_LOG_WARNING ("init_3a_stats_pool failed to reserve stats buffer.");
return XCAM_RETURN_ERROR_MEM;
}
return XCAM_RETURN_NO_ERROR;
}
std::list<struct v4l2_fmtdesc>
V4l2Device::enum_formats ()
{
std::list<struct v4l2_fmtdesc> formats;
struct v4l2_fmtdesc format;
uint32_t i = 0;
while (1) {
xcam_mem_clear (format);
format.index = i++;
format.type = _capture_buf_type;
if (this->io_control (VIDIOC_ENUM_FMT, &format) < 0) {
if (errno == EINVAL)
break;
else { // error
XCAM_LOG_DEBUG ("enum formats failed");
return formats;
}
}
formats.push_back (format);
}
return formats;
}
void
AeHandler::reset_parameters ()
{
// in case missing any parameters
xcam_mem_clear (&_params);
_params.mode = XCAM_AE_MODE_AUTO;
_params.metering_mode = XCAM_AE_METERING_MODE_AUTO;
_params.flicker_mode = XCAM_AE_FLICKER_MODE_AUTO;
_params.speed = 1.0;
_params.exposure_time_min = UINT64_C(0);
_params.exposure_time_max = UINT64_C(0);
_params.max_analog_gain = 0.0;
_params.manual_exposure_time = UINT64_C (0);
_params.manual_analog_gain = 0.0;
_params.aperture_fn = 0.0;
_params.ev_shift = 0.0;
_params.window.x_start = 0;
_params.window.y_start = 0;
_params.window.x_end = 0;
_params.window.y_end = 0;
_params.window.weight = 0;
}
CLWorkSize::CLWorkSize ()
: dim (XCAM_DEFAULT_IMAGE_DIM)
{
xcam_mem_clear (global);
xcam_mem_clear (local);
}
XCamReturn
X3aAnalyzerAiq::configure_3a ()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
X3aResultList first_results;
if (!_sensor_data_ready) {
struct atomisp_sensor_mode_data sensor_mode_data;
xcam_mem_clear (sensor_mode_data);
XCAM_ASSERT (_isp.ptr());
ret = _isp->get_sensor_mode_data (sensor_mode_data);
XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, ret, "get sensor mode data failed");
_sensor_mode_data = sensor_mode_data;
_sensor_data_ready = true;
}
if (!_aiq_compositor->set_sensor_mode_data (&_sensor_mode_data)) {
XCAM_LOG_WARNING ("AIQ configure 3a failed");
return XCAM_RETURN_ERROR_AIQ;
}
XCAM_LOG_DEBUG ("X3aAnalyzerAiq got sensor mode data, coarse_time_min:%u, "
"coarse_time_max_margin:%u, "
"fine_time_min:%u, fine_time_max_margin:%u, "
"fine_time_def:%u, "
"frame_length_lines:%u, line_length_pck:%u, "
"vt_pix_clk_freq_mhz:%u, "
"crop_horizontal_start:%u, crop_vertical_start:%u, "
"crop_horizontal_end:%u, crop_vertical_end:%u, "
"output_width:%u, output_height:%u, "
"binning_factor_x:%u, binning_factor_y:%u",
_sensor_mode_data.coarse_integration_time_min,
_sensor_mode_data.coarse_integration_time_max_margin,
_sensor_mode_data.fine_integration_time_min,
_sensor_mode_data.fine_integration_time_max_margin,
_sensor_mode_data.fine_integration_time_def,
_sensor_mode_data.frame_length_lines,
_sensor_mode_data.line_length_pck,
_sensor_mode_data.vt_pix_clk_freq_mhz,
_sensor_mode_data.crop_horizontal_start,
_sensor_mode_data.crop_vertical_start,
_sensor_mode_data.crop_horizontal_end,
_sensor_mode_data.crop_vertical_end,
_sensor_mode_data.output_width,
_sensor_mode_data.output_height,
(uint32_t)_sensor_mode_data.binning_factor_x,
(uint32_t)_sensor_mode_data.binning_factor_y);
// initialize ae and awb
get_ae_handler ()->analyze (first_results);
get_awb_handler ()->analyze (first_results);
ret = _aiq_compositor->integrate (first_results);
XCAM_FAIL_RETURN (WARNING, ret == XCAM_RETURN_NO_ERROR, ret, "AIQ configure_3a failed on integrate results");
if (!first_results.empty()) {
notify_calculation_done (first_results);
}
return XCAM_RETURN_NO_ERROR;
}
IaIspAdaptor22 () {
xcam_mem_clear (&_input_params);
}
XCamReturn
V4l2Device::allocate_buffer (
SmartPtr<V4l2Buffer> &buf,
const struct v4l2_format &format,
const uint32_t index)
{
struct v4l2_buffer v4l2_buf;
xcam_mem_clear (v4l2_buf);
v4l2_buf.index = index;
v4l2_buf.type = _capture_buf_type;
v4l2_buf.memory = _memory_type;
switch (_memory_type) {
case V4L2_MEMORY_DMABUF:
{
struct v4l2_exportbuffer expbuf;
xcam_mem_clear (expbuf);
expbuf.type = _capture_buf_type;
expbuf.index = index;
expbuf.flags = O_CLOEXEC;
if (io_control (VIDIOC_EXPBUF, &expbuf) < 0) {
XCAM_LOG_WARNING ("device(%s) get dma buf(%d) failed", XCAM_STR (_name), index);
return XCAM_RETURN_ERROR_MEM;
}
v4l2_buf.m.fd = expbuf.fd;
v4l2_buf.length = format.fmt.pix.sizeimage;
}
break;
case V4L2_MEMORY_MMAP:
{
void *pointer;
int map_flags = MAP_SHARED;
#ifdef NEED_MAP_32BIT
map_flags |= MAP_32BIT;
#endif
if (io_control (VIDIOC_QUERYBUF, &v4l2_buf) < 0) {
XCAM_LOG_WARNING("device(%s) query MMAP buf(%d) failed", XCAM_STR(_name), index);
return XCAM_RETURN_ERROR_MEM;
}
pointer = mmap (0, v4l2_buf.length, PROT_READ | PROT_WRITE, map_flags, _fd, v4l2_buf.m.offset);
if (pointer == MAP_FAILED) {
XCAM_LOG_WARNING("device(%s) mmap buf(%d) failed", XCAM_STR(_name), index);
return XCAM_RETURN_ERROR_MEM;
}
v4l2_buf.m.userptr = (uintptr_t) pointer;
}
break;
case V4L2_MEMORY_USERPTR:
default:
XCAM_ASSERT (false);
XCAM_LOG_WARNING (
"device(%s) allocated buffer mem_type(%d) doesn't support",
XCAM_STR (_name), _memory_type);
return XCAM_RETURN_ERROR_MEM;
}
buf = new V4l2Buffer (v4l2_buf, _format);
return XCAM_RETURN_NO_ERROR;
}
cl_kernel
CLContext::generate_kernel_id (
CLKernel *kernel,
const uint8_t *source, size_t length,
CLContext::KernelBuildType type)
{
struct CLProgram {
cl_program id;
CLProgram ()
: id (NULL)
{}
~CLProgram () {
if (id)
clReleaseProgram (id);
}
};
CLProgram program;
cl_kernel kernel_id = NULL;
cl_int error_code = CL_SUCCESS;
cl_device_id device_id = _device->get_device_id ();
const char * name = kernel->get_kernel_name ();
XCAM_ASSERT (source && length);
XCAM_ASSERT (name);
switch (type) {
case KERNEL_BUILD_SOURCE:
program.id =
clCreateProgramWithSource (
_context_id, 1,
(const char**)(&source), (const size_t *)&length,
&error_code);
break;
case KERNEL_BUILD_BINARY:
program.id =
clCreateProgramWithBinary (
_context_id, 1, &device_id,
(const size_t *)&length, (const uint8_t**)(&source),
NULL, &error_code);
break;
}
XCAM_FAIL_RETURN (
WARNING,
error_code == CL_SUCCESS,
NULL,
"cl create program failed with error_cod:%d", error_code);
XCAM_ASSERT (program.id);
error_code = clBuildProgram (program.id, 1, &device_id, NULL, CLContext::program_pfn_notify, this);
if (error_code != CL_SUCCESS) {
char error_log [XCAM_CL_MAX_STR_SIZE];
xcam_mem_clear (error_log);
clGetProgramBuildInfo (program.id, device_id, CL_PROGRAM_BUILD_LOG, sizeof (error_log) - 1, error_log, NULL);
XCAM_LOG_WARNING ("CL build program failed on %s, build log:%s", name, error_log);
return NULL;
}
kernel_id = clCreateKernel (program.id, name, &error_code);
XCAM_FAIL_RETURN (
WARNING,
error_code == CL_SUCCESS,
NULL,
"cl create kernel(%s) failed with error_cod:%d", name, error_code);
return kernel_id;
}
XCamReturn
V4l2Device::set_format (struct v4l2_format &format)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
XCAM_FAIL_RETURN (ERROR, !is_activated (), XCAM_RETURN_ERROR_PARAM,
"Cannot set format to v4l2 device while it is active.");
XCAM_FAIL_RETURN (ERROR, is_opened (), XCAM_RETURN_ERROR_FILE,
"Cannot set format to v4l2 device while it is closed.");
struct v4l2_format tmp_format = format;
ret = pre_set_format (format);
if (ret != XCAM_RETURN_NO_ERROR) {
XCAM_LOG_WARNING ("device(%s) pre_set_format failed", XCAM_STR (_name));
return ret;
}
if (io_control (VIDIOC_S_FMT, &format) < 0) {
if (errno == EBUSY) {
// TODO log device name
XCAM_LOG_ERROR("Video device is busy, fail to set format.");
} else {
// TODO log format details and errno
XCAM_LOG_ERROR("Fail to set format: %s", strerror(errno));
}
return XCAM_RETURN_ERROR_IOCTL;
}
if (tmp_format.fmt.pix.width != format.fmt.pix.width || tmp_format.fmt.pix.height != format.fmt.pix.height) {
XCAM_LOG_ERROR (
"device(%s) set v4l2 format failed, supported format: width:%d, height:%d",
XCAM_STR (_name),
format.fmt.pix.width,
format.fmt.pix.height);
return XCAM_RETURN_ERROR_PARAM;
}
while (_fps_n && _fps_d) {
struct v4l2_streamparm param;
xcam_mem_clear (param);
param.type = _capture_buf_type;
if (io_control (VIDIOC_G_PARM, ¶m) < 0) {
XCAM_LOG_WARNING ("device(%s) set framerate failed on VIDIOC_G_PARM but continue", XCAM_STR (_name));
break;
}
if (!(param.parm.capture.capability & V4L2_CAP_TIMEPERFRAME))
break;
param.parm.capture.timeperframe.numerator = _fps_d;
param.parm.capture.timeperframe.denominator = _fps_n;
if (io_control (VIDIOC_S_PARM, ¶m) < 0) {
XCAM_LOG_WARNING ("device(%s) set framerate failed on VIDIOC_S_PARM but continue", XCAM_STR (_name));
break;
}
_fps_n = param.parm.capture.timeperframe.denominator;
_fps_d = param.parm.capture.timeperframe.numerator;
XCAM_LOG_INFO ("device(%s) set framerate(%d/%d)", XCAM_STR (_name), _fps_n, _fps_d);
// exit here, otherwise it is an infinite loop
break;
}
ret = post_set_format (format);
if (ret != XCAM_RETURN_NO_ERROR) {
XCAM_LOG_WARNING ("device(%s) post_set_format failed", XCAM_STR (_name));
return ret;
}
_format = format;
XCAM_LOG_INFO (
"device(%s) set format(w:%d, h:%d, pixelformat:%s, bytesperline:%d,image_size:%d)",
XCAM_STR (_name),
format.fmt.pix.width, format.fmt.pix.height,
xcam_fourcc_to_string (format.fmt.pix.pixelformat),
format.fmt.pix.bytesperline,
format.fmt.pix.sizeimage);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
X3aCiqTnrTuningHandler::analyze (X3aResultList &output)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
const X3aCiqTnrTuningStaticData* tuning = imx185_tuning;
if (NULL != _tuning_data) {
tuning = (X3aCiqTnrTuningStaticData*)_tuning_data;;
}
XCam3aResultTemporalNoiseReduction config;
SmartPtr<X3aTemporalNoiseReduction> rgb_result = new X3aTemporalNoiseReduction (XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_RGB);
SmartPtr<X3aTemporalNoiseReduction> yuv_result = new X3aTemporalNoiseReduction (XCAM_3A_RESULT_TEMPORAL_NOISE_REDUCTION_YUV);
double analog_gain = get_current_analog_gain ();
double max_analog_gain = get_max_analog_gain ();
XCAM_LOG_DEBUG ("get current AG = (%f), max AG = (%f)", analog_gain, max_analog_gain);
uint8_t i_curr = 0;
uint8_t i_prev = 0;
for (i_curr = 0; i_curr < X3A_CIQ_GAIN_STEPS; i_curr++) {
if (analog_gain <= tuning[i_curr].analog_gain) {
break;
}
i_prev = i_curr;
}
if (i_curr >= X3A_CIQ_GAIN_STEPS) {
i_curr = X3A_CIQ_GAIN_STEPS - 1;
}
//Calculate YUV config
xcam_mem_clear (config);
config.gain = linear_interpolate_p2 (tuning[i_prev].yuv_gain, tuning[i_curr].yuv_gain,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[0] = linear_interpolate_p2 (tuning[i_prev].y_threshold, tuning[i_curr].y_threshold,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[1] = linear_interpolate_p2 (tuning[i_prev].uv_threshold, tuning[i_curr].uv_threshold,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[2] = 0.0;
XCAM_LOG_DEBUG ("Calculate YUV temporal noise reduction config: yuv_gain(%f), y_threshold(%f), uv_threshold(%f)",
config.gain, config.threshold[0], config.threshold[1]);
yuv_result->set_standard_result (config);
output.push_back (yuv_result);
//Calculate RGB config
xcam_mem_clear (config);
config.gain = linear_interpolate_p2 (tuning[i_prev].rgb_gain, tuning[i_curr].rgb_gain,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[0] = linear_interpolate_p2 (tuning[i_prev].r_threshold, tuning[i_curr].r_threshold,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[1] = linear_interpolate_p2 (tuning[i_prev].g_threshold, tuning[i_curr].g_threshold,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
config.threshold[2] = linear_interpolate_p2 (tuning[i_prev].b_threshold, tuning[i_curr].b_threshold,
tuning[i_prev].analog_gain, tuning[i_curr].analog_gain, analog_gain);
XCAM_LOG_DEBUG ("Calculate RGB temporal noise reduction config: rgb_gain(%f), r_threshold(%f), g_threshold(%f), b_threshold(%f)",
config.gain, config.threshold[0], config.threshold[1], config.threshold[2]);
rgb_result->set_standard_result (config);
output.push_back (rgb_result);
return ret;
}
XCamReturn
CLKernel::build_kernel (const XCamKernelInfo& info, const char* options)
{
KernelMap::iterator i_kernel;
SmartPtr<CLKernel> single_kernel;
char key_str[1024];
uint8_t body_key[8];
std::string key;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
XCAM_FAIL_RETURN (ERROR, info.kernel_name, XCAM_RETURN_ERROR_PARAM, "build kernel failed since kernel name null");
xcam_mem_clear (body_key);
get_string_key_id (info.kernel_body, info.kernel_body_len, body_key);
snprintf (
key_str, sizeof(key_str),
"%s#%02x%02x%02x%02x%02x%02x%02x%02x#%s",
info.kernel_name,
body_key[0], body_key[1], body_key[2], body_key[3], body_key[4], body_key[5], body_key[6], body_key[7],
XCAM_STR(options));
key = key_str;
char temp_filename[XCAM_MAX_STR_SIZE] = {0};
char cache_filename[XCAM_MAX_STR_SIZE] = {0};
FileHandle temp_file;
FileHandle cache_file;
size_t read_cache_size = 0;
size_t write_cache_size = 0;
uint8_t *kernel_cache = NULL;
bool load_cache = false;
struct timeval ts;
std::string cache_path = _kernel_cache_path;
const char *env = std::getenv ("XCAM_CL_KERNEL_CACHE_PATH");
if (env)
cache_path.assign (env, strlen (env));
snprintf (
cache_filename, XCAM_MAX_STR_SIZE - 1,
"%s/%s",
cache_path.c_str (), key_str);
{
SmartLock locker (_kernel_map_mutex);
i_kernel = _kernel_map.find (key);
if (i_kernel == _kernel_map.end ()) {
SmartPtr<CLContext> context = get_context ();
single_kernel = new CLKernel (context, info.kernel_name);
XCAM_ASSERT (single_kernel.ptr ());
if (access (cache_path.c_str (), F_OK) == -1) {
mkdir (cache_path.c_str (), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
}
ret = cache_file.open (cache_filename, "r");
if (ret == XCAM_RETURN_NO_ERROR) {
cache_file.get_file_size (read_cache_size);
if (read_cache_size > 0) {
kernel_cache = (uint8_t*) xcam_malloc0 (sizeof (uint8_t) * (read_cache_size + 1));
if (NULL != kernel_cache) {
cache_file.read_file (kernel_cache, read_cache_size);
cache_file.close ();
ret = single_kernel->load_from_binary (kernel_cache, read_cache_size);
xcam_free (kernel_cache);
kernel_cache = NULL;
XCAM_FAIL_RETURN (
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
"build kernel(%s) from binary failed", key_str);
load_cache = true;
}
}
} else {
XCAM_LOG_DEBUG ("open kernel cache file to read failed ret(%d)", ret);
}
if (load_cache == false) {
ret = single_kernel->load_from_source (info.kernel_body, strlen (info.kernel_body), &kernel_cache, &write_cache_size, options);
XCAM_FAIL_RETURN (
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
"build kernel(%s) from source failed", key_str);
}
_kernel_map.insert (std::make_pair (key, single_kernel));
//_kernel_map[key] = single_kernel;
} else {
single_kernel = i_kernel->second;
}
}
if (load_cache == false && NULL != kernel_cache) {
gettimeofday (&ts, NULL);
snprintf (
temp_filename, XCAM_MAX_STR_SIZE - 1,
"%s." XCAM_TIMESTAMP_FORMAT,
cache_filename, XCAM_TIMESTAMP_ARGS (XCAM_TIMEVAL_2_USEC (ts)));
ret = temp_file.open (temp_filename, "wb");
if (ret == XCAM_RETURN_NO_ERROR) {
ret = temp_file.write_file (kernel_cache, write_cache_size);
temp_file.close ();
if (ret == XCAM_RETURN_NO_ERROR && write_cache_size > 0) {
rename (temp_filename, cache_filename);
} else {
remove (temp_filename);
}
} else {
XCAM_LOG_ERROR ("open kernel cache file to write failed ret(%d)", ret);
}
xcam_free (kernel_cache);
kernel_cache = NULL;
}
XCAM_FAIL_RETURN (
ERROR, (single_kernel.ptr () && single_kernel->is_valid ()), XCAM_RETURN_ERROR_UNKNOWN,
"build kernel(%s) failed, unknown error", key_str);
ret = this->clone (single_kernel);
XCAM_FAIL_RETURN (
ERROR, ret == XCAM_RETURN_NO_ERROR, ret,
"load kernel(%s) from kernel failed", key_str);
return ret;
}