XCamReturn
VKComputePipeline::push_consts_by (
VKCmdBuf &cmd_buf, const SmartPtr<VKConstRange::VKPushConstArg> &push_const)
{
VkCommandBuffer cmd_buf_id = cmd_buf.get_cmd_buf_id ();
XCAM_FAIL_RETURN (
ERROR,
XCAM_IS_VALID_VK_ID (cmd_buf_id) && XCAM_IS_VALID_VK_ID (_pipe_layout),
XCAM_RETURN_ERROR_PARAM,
"vk compute pipeline push_consts by cmdbuf failed, please check pipe_layout and cmd_buf_id.");
XCAM_ASSERT (push_const.ptr ());
VkPushConstantRange const_range;
xcam_mem_clear (const_range);
void *ptr = NULL;
push_const->get_const_data (const_range, ptr);
XCAM_FAIL_RETURN (
ERROR,
const_range.stageFlags == VK_SHADER_STAGE_COMPUTE_BIT,
XCAM_RETURN_ERROR_PARAM,
"vk compute pipeline push_consts by cmdbuf failed, please check pipe_layout and cmd_buf_id.");
vkCmdPushConstants(
cmd_buf_id, _pipe_layout, VK_SHADER_STAGE_COMPUTE_BIT, const_range.offset, const_range.size, ptr);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
X3aAnalyzerAiq::internal_init (uint32_t width, uint32_t height, double framerate)
{
XCAM_ASSERT (_cpf_path);
CpfReader reader (_cpf_path);
ia_binary_data binary;
XCAM_ASSERT (_aiq_compositor.ptr ());
_aiq_compositor->set_framerate (framerate);
xcam_mem_clear (binary);
XCAM_FAIL_RETURN (
ERROR,
reader.read(binary),
XCAM_RETURN_ERROR_AIQ,
"read cpf file(%s) failed", _cpf_path);
_aiq_compositor->set_size (width, height);
XCAM_FAIL_RETURN (
ERROR,
_aiq_compositor->open (binary),
XCAM_RETURN_ERROR_AIQ,
"AIQ open failed");
return XCAM_RETURN_NO_ERROR;
}
bool
CLBayer3AStatsThread::loop ()
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<BayerPostData> data;
data = _stats_process_list.pop ();
if (!data.ptr ()) {
XCAM_LOG_INFO ("cl bayer 3a-stats thread is going to stop, processing data empty");
return false;
}
XCAM_ASSERT (data->image_buffer.ptr ());
XCAM_ASSERT (data->stats_cl_buf.ptr ());
XCAM_ASSERT (_handler);
ret = _handler->process_stats_buffer (data->image_buffer, data->stats_cl_buf);
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
false,
"cl bayer 3a-stats thread has error buffer on kernel post processing");
XCAM_FAIL_RETURN (
ERROR,
_buffer_done_list.push (data->image_buffer),
false,
"cl bayer 3a-stats thread failed to queue done-buffers");
return true;
}
/*
* Default kernel arguments
* arg0:
* input, __read_only image2d_t
* arg1:
* output, __write_only image2d_t
* suppose cl can get width/height pixels from
* get_image_width/get_image_height
*/
XCamReturn
CLImageKernel::pre_execute (SmartPtr<DrmBoBuffer> &input, SmartPtr<DrmBoBuffer> &output)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<CLContext> context = get_context ();
#define XCAM_CL_MAX_ARGS 256
CLArgument args[XCAM_CL_MAX_ARGS];
uint32_t arg_count = XCAM_CL_MAX_ARGS;
CLWorkSize work_size;
ret = prepare_arguments (input, output, args, arg_count, work_size);
XCAM_ASSERT (arg_count);
for (uint32_t i = 0; i < arg_count; ++i) {
ret = set_argument (i, args[i].arg_adress, args[i].arg_size);
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
ret,
"cl image kernel(%s) set argc(%d) failed", get_kernel_name (), i);
}
XCAM_ASSERT (work_size.global[0]);
ret = set_work_size (work_size.dim, work_size.global, work_size.local);
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
ret,
"cl image kernel(%s) set work size failed", get_kernel_name ());
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
VKComputePipeline::ensure_pipeline ()
{
XCAM_FAIL_RETURN (
ERROR, XCAM_IS_VALID_VK_ID (_desc_layout) && XCAM_IS_VALID_VK_ID (_pipe_layout),
XCAM_RETURN_ERROR_PARAM,
"vk compute ensure pipeline failed. need ensure desc_layout and pipe_layout first");
XCAM_FAIL_RETURN (
ERROR, !_shaders.empty (), XCAM_RETURN_ERROR_PARAM,
"vk compute ensure pipeline failed, shader was empty");
VkComputePipelineCreateInfo pipeline_create_info =
get_compute_create_info (_shaders[0], _pipe_layout);
VkPipeline pipe_id;
XCAM_VK_CHECK_RETURN (
ERROR, vkCreateComputePipelines (
_dev->get_dev_id (), 0, 1, &pipeline_create_info, 0, &pipe_id),
XCAM_RETURN_ERROR_VULKAN, "VK create compute pipeline failed.");
XCAM_ASSERT (XCAM_IS_VALID_VK_ID (pipe_id));
_pipe_id = pipe_id;
return XCAM_RETURN_NO_ERROR;
}
SmartPtr<VKShader>
VKDevice::create_shader (const std::vector<uint32_t> &binary)
{
XCAM_FAIL_RETURN (
ERROR, XCAM_IS_VALID_VK_ID (_dev_id), NULL,
"VKDevice load shader failed with error of null device ready.");
XCAM_FAIL_RETURN (
ERROR, binary.size () > 5, NULL,
"VKDevice load shader failed since binary is corrupt.");
VkShaderModule shader_id;
VkShaderModuleCreateInfo module_create_info = {};
module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
module_create_info.pNext = NULL;
module_create_info.codeSize = binary.size() * sizeof (binary[0]);
module_create_info.pCode = binary.data();
module_create_info.flags = 0;
XCAM_VK_CHECK_RETURN (
ERROR, vkCreateShaderModule (_dev_id, &module_create_info, NULL, &shader_id),
NULL, "VKDevice create shader module failed.");
XCAM_IS_VALID_VK_ID (shader_id);
return new VKShader (this, shader_id);
}
SmartPtr<CLImageHandler>
create_cl_image_scaler_handler (const SmartPtr<CLContext> &context, const uint32_t format)
{
SmartPtr<CLImageScaler> scaler_handler;
SmartPtr<CLImageKernel> scaler_kernel;
scaler_handler = new CLImageScaler (context);
XCAM_ASSERT (scaler_handler.ptr ());
if (V4L2_PIX_FMT_NV12 == format) {
//Y
scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_Y);
XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_Y kernel failed");
scaler_handler->add_kernel (scaler_kernel);
//UV
scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_NV12_UV);
XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_NV12_UV kernel failed");
scaler_handler->add_kernel (scaler_kernel);
} else if (XCAM_PIX_FMT_RGBA64 == format) {
scaler_kernel = create_scale_kernel (context, scaler_handler, CL_IMAGE_SCALER_RGBA);
XCAM_FAIL_RETURN (ERROR, scaler_kernel.ptr (), NULL, "build CL_IMAGE_SCALER_RGBA kernel failed");
scaler_handler->add_kernel (scaler_kernel);
} else {
XCAM_LOG_ERROR ("create cl image scaler failed, unknown format:0x%08x", format);
return NULL;
}
return scaler_handler;
}
SmartPtr<VKShader>
VKDevice::create_shader (const char *file_name)
{
FileHandle file (file_name, "rb");
XCAM_FAIL_RETURN (
ERROR, file.is_valid (), NULL,
"VKDevice load shader failed when opend shader file:%s.",
XCAM_STR (file_name));
size_t file_size;
XCAM_FAIL_RETURN (
ERROR, xcam_ret_is_ok (file.get_file_size (file_size)) || file_size == 0, NULL,
"VKDevice load shader failed when read shader file:%s.",
XCAM_STR (file_name));
std::vector<uint32_t> content (XCAM_ALIGN_UP (file_size, 4) / 4, 0);
XCAM_FAIL_RETURN (
ERROR, xcam_ret_is_ok (file.read_file ((void *)content.data (), file_size)), NULL,
"VKDevice load shader failed when read shader file:%s.",
XCAM_STR (file_name));
file.close ();
SmartPtr<VKShader> shader = create_shader (content);
if (shader.ptr ())
shader->set_name (file_name);
return shader;
}
XCamReturn
CL3aImageProcessor::create_handlers ()
{
SmartPtr<CLImageHandler> image_handler;
SmartPtr<CLContext> context = get_cl_context ();
XCAM_ASSERT (context.ptr ());
/* black leve as first */
image_handler = create_cl_blc_image_handler (context);
_black_level = image_handler;
XCAM_FAIL_RETURN (
WARNING,
image_handler.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create blc handler failed");
add_handler (image_handler);
/* hdr */
if (_enable_hdr) {
image_handler = create_cl_hdr_image_handler (context, CL_HDR_TYPE_RGB);
_hdr = image_handler;
XCAM_FAIL_RETURN (
WARNING,
_hdr.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create hdr handler failed");
add_handler (image_handler);
}
/* demosaic */
image_handler = create_cl_demosaic_image_handler (context);
_demosaic = image_handler.dynamic_cast_ptr<CLBayer2RGBImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_demosaic.ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create demosaic handler failed");
add_handler (image_handler);
/* color space conversion */
if (_out_smaple_type == OutSampleYuv) {
image_handler = create_cl_csc_image_handler (context, CL_CSC_TYPE_RGBATONV12);
_csc = image_handler.dynamic_cast_ptr<CLCscImageHandler> ();
XCAM_FAIL_RETURN (
WARNING,
_csc .ptr (),
XCAM_RETURN_ERROR_CL,
"CL3aImageProcessor create csc handler failed");
add_handler (image_handler);
} else if (_out_smaple_type == OutSampleRGB) {
_demosaic->set_output_format (_output_fourcc);
}
return XCAM_RETURN_NO_ERROR;
}
SmartPtr<CLImageHandler>
create_cl_gamma_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLGammaImageHandler> gamma_handler;
SmartPtr<CLGammaImageKernel> gamma_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
gamma_kernel = new CLGammaImageKernel (context);
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_gamma)
#include "kernel_gamma.clx"
XCAM_CL_KERNEL_FUNC_END;
ret = gamma_kernel->load_from_source (kernel_gamma_body, strlen (kernel_gamma_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", gamma_kernel->get_kernel_name());
}
XCAM_ASSERT (gamma_kernel->is_valid ());
gamma_handler = new CLGammaImageHandler ("cl_handler_gamma");
gamma_handler->set_gamma_kernel (gamma_kernel);
return gamma_handler;
}
SmartPtr<CLImageHandler>
create_cl_rgb_pipe_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLRgbPipeImageHandler> rgb_pipe_handler;
SmartPtr<CLRgbPipeImageKernel> rgb_pipe_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
rgb_pipe_kernel = new CLRgbPipeImageKernel (context);
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_rgb_pipe)
#include "kernel_rgb_pipe.clx"
XCAM_CL_KERNEL_FUNC_END;
ret = rgb_pipe_kernel->load_from_source (kernel_rgb_pipe_body, strlen (kernel_rgb_pipe_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", rgb_pipe_kernel->get_kernel_name());
}
XCAM_ASSERT (rgb_pipe_kernel->is_valid ());
rgb_pipe_handler = new CLRgbPipeImageHandler ("cl_handler_rgb_pipe");
rgb_pipe_handler->set_rgb_pipe_kernel (rgb_pipe_kernel);
return rgb_pipe_handler;
}
XCamReturn
CLBuffer::enqueue_map (
void *&ptr, uint32_t offset, uint32_t size,
cl_map_flags map_flags,
CLEventList &event_waits,
SmartPtr<CLEvent> &event_out)
{
SmartPtr<CLContext> context = get_context ();
cl_mem mem_id = get_mem_id ();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
XCAM_ASSERT (is_valid ());
if (!is_valid ())
return XCAM_RETURN_ERROR_PARAM;
ret = context->enqueue_map_buffer (mem_id, ptr, offset, size, true, map_flags, event_waits, event_out);
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
ret,
"enqueue_map failed ");
set_mapped_ptr (ptr);
return ret;
}
SmartPtr<CLImageHandler>
create_cl_wb_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLWbImageHandler> wb_handler;
SmartPtr<CLWbImageKernel> wb_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
wb_kernel = new CLWbImageKernel (context);
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wb)
#include "kernel_wb.cl"
XCAM_CL_KERNEL_FUNC_END;
ret = wb_kernel->load_from_source (kernel_wb_body, strlen (kernel_wb_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", wb_kernel->get_kernel_name());
}
XCAM_ASSERT (wb_kernel->is_valid ());
wb_handler = new CLWbImageHandler ("cl_handler_wb");
wb_handler->set_wb_kernel (wb_kernel);
return wb_handler;
}
SmartPtr<CLImageHandler>
create_cl_newtonemapping_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLNewTonemappingImageHandler> tonemapping_handler;
SmartPtr<CLNewTonemappingImageKernel> tonemapping_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
tonemapping_kernel = new CLNewTonemappingImageKernel (context, "kernel_newtonemapping");
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_newtonemapping)
#include "kernel_newtonemapping.clx"
XCAM_CL_KERNEL_FUNC_END;
ret = tonemapping_kernel->load_from_source (kernel_newtonemapping_body, strlen (kernel_newtonemapping_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", tonemapping_kernel->get_kernel_name());
}
XCAM_ASSERT (tonemapping_kernel->is_valid ());
tonemapping_handler = new CLNewTonemappingImageHandler("cl_handler_newtonemapping");
tonemapping_handler->set_tonemapping_kernel(tonemapping_kernel);
return tonemapping_handler;
}
SmartPtr<CLImageHandler>
create_cl_bayer_basic_image_handler (const SmartPtr<CLContext> &context, bool enable_gamma, uint32_t stats_bits)
{
SmartPtr<CLBayerBasicImageHandler> bayer_planar_handler;
SmartPtr<CLBayerBasicImageKernel> basic_kernel;
char build_options[1024];
bayer_planar_handler = new CLBayerBasicImageHandler (context, "cl_handler_bayer_basic");
bayer_planar_handler->set_stats_bits (stats_bits);
basic_kernel = new CLBayerBasicImageKernel (context);
XCAM_ASSERT (basic_kernel.ptr ());
xcam_mem_clear (build_options);
snprintf (build_options, sizeof (build_options),
" -DENABLE_GAMMA=%d "
" -DENABLE_IMAGE_2D_INPUT=%d "
" -DSTATS_BITS=%d ",
(enable_gamma ? 1 : 0),
ENABLE_IMAGE_2D_INPUT,
stats_bits);
XCAM_FAIL_RETURN (
ERROR, basic_kernel->build_kernel (kernel_bayer_basic_info, build_options) == XCAM_RETURN_NO_ERROR, NULL,
"build bayer-basic kernel(%s) failed", kernel_bayer_basic_info.kernel_name);
XCAM_ASSERT (basic_kernel->is_valid ());
bayer_planar_handler->set_bayer_kernel (basic_kernel);
return bayer_planar_handler;
}
SmartPtr<CLImageHandler>
create_cl_bnr_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLBnrImageHandler> bnr_handler;
SmartPtr<CLBnrImageKernel> bnr_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
bnr_kernel = new CLBnrImageKernel (context);
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_bnr)
#include "kernel_bnr.clx"
XCAM_CL_KERNEL_FUNC_END;
ret = bnr_kernel->load_from_source (kernel_bnr_body, strlen (kernel_bnr_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", bnr_kernel->get_kernel_name());
}
XCAM_ASSERT (bnr_kernel->is_valid ());
bnr_handler = new CLBnrImageHandler ("cl_handler_bnr");
bnr_handler->set_simple_kernel (bnr_kernel);
return bnr_handler;
}
XCamReturn
AiqCommonHandler::analyze (X3aResultList &output)
{
ia_aiq *ia_handle = NULL;
ia_aiq_gbce_results *gbce_result = NULL;
ia_err ia_error = ia_err_none;
XCAM_UNUSED (output);
AnalyzerHandler::HanlderLock lock(this);
if (has_gbce_unlock()) {
ia_aiq_gbce_input_params gbce_input;
xcam_mem_clear (&gbce_input);
gbce_input.gbce_level = ia_aiq_gbce_level_use_tuning;
gbce_input.frame_use = _aiq_compositor->get_frame_use ();
gbce_input.ev_shift = 0; // Todo
ia_handle = _aiq_compositor->get_handle ();
XCAM_ASSERT (ia_handle);
ia_error = ia_aiq_gbce_run (ia_handle, &gbce_input, &gbce_result);
XCAM_FAIL_RETURN (ERROR, ia_error == ia_err_none, XCAM_RETURN_ERROR_AIQ, "AIQ run GBCE failed");
//TODO, need copy GBCE result out, not just assign
_gbce_result = gbce_result;
} else {
_gbce_result = NULL;
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
AiqAwbHandler::analyze (X3aResultList &output)
{
ia_aiq *ia_handle = NULL;
ia_aiq_awb_results *awb_ret = NULL;
ia_err ia_error = ia_err_none;
XCAM_UNUSED (output);
AnalyzerHandler::HanlderLock lock(this);
if (!ensure_ia_parameters ()) {
XCAM_LOG_ERROR ("AIQ AE ensure ia parameters failed");
return XCAM_RETURN_ERROR_PARAM;
}
ia_handle = _aiq_compositor->get_handle ();
XCAM_ASSERT (ia_handle);
ia_error = ia_aiq_awb_run (ia_handle, &_input, &awb_ret);
XCAM_FAIL_RETURN (ERROR, ia_error == ia_err_none, XCAM_RETURN_ERROR_AIQ, "AIQ run AWB failed");
_result = *awb_ret;
if (!_started) {
_history_result = _result;
_started = true;
}
adjust_speed (_history_result);
_history_result = _result;
return XCAM_RETURN_NO_ERROR;
}
bool
IaIspAdaptor15::run (
const IspInputParameters *isp_input_params,
ia_binary_data *output_data)
{
ia_err err;
_input_params.frame_use = isp_input_params->frame_use;
_input_params.sensor_frame_params = isp_input_params->sensor_frame_params;
_input_params.exposure_results = isp_input_params->exposure_results;
_input_params.awb_results = isp_input_params->awb_results;
_input_params.gbce_results = isp_input_params->gbce_results;
_input_params.pa_results = isp_input_params->pa_results;
_input_params.manual_brightness = isp_input_params->manual_brightness;
_input_params.manual_contrast = isp_input_params->manual_contrast;
_input_params.manual_hue = isp_input_params->manual_hue;
_input_params.manual_saturation = isp_input_params->manual_saturation;
_input_params.nr_setting.feature_level = ia_isp_feature_level_high;
_input_params.nr_setting.strength = isp_input_params->manual_nr_level;
_input_params.ee_setting.feature_level = ia_isp_feature_level_high;
_input_params.ee_setting.strength = isp_input_params->manual_sharpness;
_input_params.effects = isp_input_params->effects;
err = ia_isp_1_5_run (_handle, &_input_params, output_data);
XCAM_FAIL_RETURN (ERROR, err == ia_err_none, false, "ia_isp 1.5 run failed");
return true;
}
SmartPtr<CLImageHandler>
create_cl_wavelet_denoise_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLWaveletDenoiseImageHandler> wavelet_handler;
SmartPtr<CLWaveletDenoiseImageKernel> wavelet_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_wavelet_denoise)
#include "kernel_wavelet_denoise.clx"
XCAM_CL_KERNEL_FUNC_END;
wavelet_handler = new CLWaveletDenoiseImageHandler ("cl_handler_wavelet_denoise");
XCAM_ASSERT (wavelet_handler.ptr ());
for (int layer = 1; layer <= WAVELET_DECOMPOSITION_LEVELS; layer++) {
wavelet_kernel = new CLWaveletDenoiseImageKernel (context, "kernel_wavelet_denoise", wavelet_handler, layer);
ret = wavelet_kernel->load_from_source (
kernel_wavelet_denoise_body, strlen (kernel_wavelet_denoise_body),
NULL, NULL,
WAVELET_DENOISE_UV ? "-DWAVELET_DENOISE_UV=1" : "-DWAVELET_DENOISE_UV=0");
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", wavelet_kernel->get_kernel_name());
XCAM_ASSERT (wavelet_kernel->is_valid ());
SmartPtr<CLImageKernel> image_kernel = wavelet_kernel;
wavelet_handler->add_kernel (image_kernel);
}
return wavelet_handler;
}
SmartPtr<CLImageHandler>
create_cl_tnr_image_handler (SmartPtr<CLContext> &context, CLTnrType type)
{
SmartPtr<CLTnrImageHandler> tnr_handler;
SmartPtr<CLTnrImageKernel> tnr_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_tnr_yuv)
#include "kernel_tnr_yuv.clx"
XCAM_CL_KERNEL_FUNC_END;
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_tnr_rgb)
#include "kernel_tnr_rgb.clx"
XCAM_CL_KERNEL_FUNC_END;
if (CL_TNR_TYPE_YUV == type) {
tnr_kernel = new CLTnrImageKernel (context, "kernel_tnr_yuv", CL_TNR_TYPE_YUV);
ret = tnr_kernel->load_from_source (kernel_tnr_yuv_body, strlen (kernel_tnr_yuv_body));
} else if (CL_TNR_TYPE_RGB == type) {
tnr_kernel = new CLTnrImageKernel (context, "kernel_tnr_rgb", CL_TNR_TYPE_RGB);
ret = tnr_kernel->load_from_source (kernel_tnr_rgb_body, strlen (kernel_tnr_rgb_body));
}
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", tnr_kernel->get_kernel_name());
tnr_handler = new CLTnrImageHandler ("cl_handler_tnr");
XCAM_ASSERT (tnr_kernel->is_valid ());
tnr_handler->set_tnr_kernel (tnr_kernel);
return tnr_handler;
}
SmartPtr<CLImageHandler>
create_cl_demosaic_image_handler (SmartPtr<CLContext> &context)
{
SmartPtr<CLImageHandler> demosaic_handler;
SmartPtr<CLImageKernel> demosaic_kernel;
XCamReturn ret = XCAM_RETURN_NO_ERROR;
demosaic_kernel = new CLDemosaicImageKernel (context);
{
XCAM_CL_KERNEL_FUNC_SOURCE_BEGIN(kernel_demosaic)
#include "kernel_demosaic.cl"
XCAM_CL_KERNEL_FUNC_END;
ret = demosaic_kernel->load_from_source (kernel_demosaic_body, strlen (kernel_demosaic_body));
XCAM_FAIL_RETURN (
WARNING,
ret == XCAM_RETURN_NO_ERROR,
NULL,
"CL image handler(%s) load source failed", demosaic_kernel->get_kernel_name());
}
XCAM_ASSERT (demosaic_kernel->is_valid ());
demosaic_handler = new CLBayer2RGBImageHandler ("cl_handler_demosaic");
demosaic_handler->add_kernel (demosaic_kernel);
return demosaic_handler;
}
XCamReturn
CLDemosaicImageKernel::prepare_arguments (
SmartPtr<DrmBoBuffer> &input, SmartPtr<DrmBoBuffer> &output,
CLArgument args[], uint32_t &arg_count,
CLWorkSize &work_size)
{
SmartPtr<CLContext> context = get_context ();
const VideoBufferInfo & video_info = output->get_video_info ();
_image_in = new CLVaImage (context, input);
_image_out = new CLVaImage (context, output);
XCAM_ASSERT (_image_in->is_valid () && _image_out->is_valid ());
XCAM_FAIL_RETURN (
WARNING,
_image_in->is_valid () && _image_out->is_valid (),
XCAM_RETURN_ERROR_MEM,
"cl image kernel(%s) in/out memory not available", get_kernel_name ());
//set args;
args[0].arg_adress = &_image_in->get_mem_id ();
args[0].arg_size = sizeof (cl_mem);
args[1].arg_adress = &_image_out->get_mem_id ();
args[1].arg_size = sizeof (cl_mem);
arg_count = 2;
work_size.dim = XCAM_DEFAULT_IMAGE_DIM;
work_size.global[0] = video_info.width / 2;
work_size.global[1] = video_info.height / 2;
work_size.local[0] = 4;
work_size.local[1] = 4;
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CLKernel::load_from_binary (const uint8_t *binary, size_t length)
{
cl_kernel new_kernel_id = NULL;
XCAM_ASSERT (binary);
if (!binary || !length) {
XCAM_LOG_WARNING ("kernel:%s binary empty", XCAM_STR (_name));
return XCAM_RETURN_ERROR_PARAM;
}
if (_kernel_id) {
XCAM_LOG_WARNING ("kernel:%s already build yet", XCAM_STR (_name));
return XCAM_RETURN_ERROR_PARAM;
}
XCAM_ASSERT (_context.ptr ());
new_kernel_id =
_context->generate_kernel_id (
this,
binary, length,
CLContext::KERNEL_BUILD_BINARY);
XCAM_FAIL_RETURN(
WARNING,
new_kernel_id != NULL,
XCAM_RETURN_ERROR_CL,
"cl kernel(%s) load from binary failed", XCAM_STR (_name));
_kernel_id = new_kernel_id;
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
CLKernel::load_from_source (const char *source, size_t length)
{
cl_kernel new_kernel_id = NULL;
XCAM_ASSERT (source);
if (!source) {
XCAM_LOG_WARNING ("kernel:%s source empty", XCAM_STR (_name));
return XCAM_RETURN_ERROR_PARAM;
}
if (_kernel_id) {
XCAM_LOG_WARNING ("kernel:%s already build yet", XCAM_STR (_name));
return XCAM_RETURN_ERROR_PARAM;
}
XCAM_ASSERT (_context.ptr ());
if (length == 0)
length = strlen (source);
new_kernel_id =
_context->generate_kernel_id (
this,
(const uint8_t *)source, length,
CLContext::KERNEL_BUILD_SOURCE);
XCAM_FAIL_RETURN(
WARNING,
new_kernel_id != NULL,
XCAM_RETURN_ERROR_CL,
"cl kernel(%s) load from source failed", XCAM_STR (_name));
_kernel_id = new_kernel_id;
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
cl_events_wait (CLEventList &event_list)
{
#define XCAM_MAX_CL_EVENT_COUNT 256
cl_event event_ids [XCAM_MAX_CL_EVENT_COUNT];
uint32_t event_count = 0;
cl_int error_code = CL_SUCCESS;
if (event_list.empty ())
return XCAM_RETURN_NO_ERROR;
xcam_mem_clear (&event_ids);
for (CLEventList::iterator iter = event_list.begin ();
iter != event_list.end (); ++iter) {
SmartPtr<CLEvent> &event = *iter;
XCAM_ASSERT (event->get_event_id ());
event_ids[event_count++] = event->get_event_id ();
if (event_count >= XCAM_MAX_CL_EVENT_COUNT)
break;
}
XCAM_ASSERT (event_count > 0);
error_code = clWaitForEvents (event_count, event_ids);
XCAM_FAIL_RETURN (
WARNING,
error_code == CL_SUCCESS,
XCAM_RETURN_ERROR_CL,
"cl events wait failed with error cod:%d", error_code);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn AiqCompositor::integrate (X3aResultList &results)
{
IspInputParameters isp_params;
ia_aiq_pa_input_params pa_input;
ia_aiq_pa_results *pa_result = NULL;
ia_err ia_error = ia_err_none;
ia_binary_data output;
AiqAeHandler *aiq_ae = _ae_handler.ptr();
AiqAwbHandler *aiq_awb = _awb_handler.ptr();
AiqAfHandler *aiq_af = _af_handler.ptr();
AiqCommonHandler *aiq_common = _common_handler.ptr();
struct atomisp_parameters *isp_3a_result = NULL;
SmartPtr<X3aResult> isp_results;
XCAM_FAIL_RETURN (
ERROR,
aiq_ae && aiq_awb && aiq_af && aiq_common,
XCAM_RETURN_ERROR_PARAM,
"handlers are not AIQ inherited");
xcam_mem_clear (&pa_input);
pa_input.frame_use = _frame_use;
pa_input.awb_results = aiq_awb->get_result ();
if (aiq_ae->is_started())
pa_input.exposure_params = (aiq_ae->get_result ())->exposures[0].exposure;
pa_input.sensor_frame_params = &_frame_params;
pa_input.color_gains = NULL;
ia_error = ia_aiq_pa_run (_ia_handle, &pa_input, &pa_result);
if (ia_error != ia_err_none) {
XCAM_LOG_WARNING ("AIQ pa run failed"); // but not return error
}
_pa_result = pa_result;
isp_params.frame_use = _frame_use;
isp_params.awb_results = aiq_awb->get_result ();
if (aiq_ae->is_started())
isp_params.exposure_results = (aiq_ae->get_result ())->exposures[0].exposure;
isp_params.gbce_results = aiq_common->get_gbce_result ();
isp_params.sensor_frame_params = &_frame_params;
isp_params.pa_results = pa_result;
isp_params.manual_brightness = (int8_t)(aiq_common->get_brightness_unlock() * 128.0);
isp_params.manual_contrast = (int8_t)(aiq_common->get_contrast_unlock() * 128.0);
isp_params.manual_saturation = (int8_t)(aiq_common->get_saturation_unlock() * 128.0);
isp_params.manual_hue = (int8_t)(aiq_common->get_hue_unlock() * 128.0);
isp_params.manual_sharpness = (int8_t)(aiq_common->get_sharpness_unlock() * 128.0);
isp_params.manual_nr_level = (int8_t)(aiq_common->get_nr_level_unlock() * 128.0);
xcam_mem_clear (&output);
if (!_adaptor->run (&isp_params, &output)) {
XCAM_LOG_ERROR("Aiq to isp adaptor running failed");
return XCAM_RETURN_ERROR_ISP;
}
isp_3a_result = ((struct atomisp_parameters *)output.data);
isp_results = generate_3a_configs (isp_3a_result);
results.push_back (isp_results);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
GLBuffer::bind_buffer_range (uint32_t index, uint32_t offset, uint32_t size)
{
XCamReturn ret = bind ();
XCAM_FAIL_RETURN (
ERROR, xcam_ret_is_ok (ret), ret,
"GL bind buffer failed, buf_id:%d", _buf_id);
glBindBufferRange (_target, index, _buf_id, offset, size);
GLenum error = gl_error ();
XCAM_FAIL_RETURN (
ERROR, error == GL_NO_ERROR, XCAM_RETURN_ERROR_GLES,
"GL bind buffer range failed. buf_id:%d failed, idx:%d, error flag: %s",
_buf_id, index, gl_error_string (error));
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
VKComputePipeline::update_bindings (const VKDescriptor::SetBindInfoArray &bind_array)
{
XCAM_FAIL_RETURN (
ERROR, _pool.ptr () && XCAM_IS_VALID_VK_ID (_desc_layout), XCAM_RETURN_ERROR_PARAM,
"vk compute pipeline update bindins failed, pool was not set or desc_layout not ensured");
if (_desc_set.ptr ())
_desc_set.release ();
_desc_set = _pool->allocate_set (bind_array, _desc_layout);
XCAM_FAIL_RETURN (
ERROR, _desc_set.ptr (), XCAM_RETURN_ERROR_UNKNOWN,
"vk compute pipeline update bindins failed to allocate desc_set or update bindings");
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
FakePollThread::start()
{
XCAM_FAIL_RETURN(
ERROR,
_raw_path,
XCAM_RETURN_ERROR_FILE,
"FakePollThread failed due to raw path NULL");
_raw = fopen (_raw_path, "rb");
XCAM_FAIL_RETURN(
ERROR,
_raw,
XCAM_RETURN_ERROR_FILE,
"FakePollThread failed to open file:%s", XCAM_STR (_raw_path));
return PollThread::start ();
}
