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 (); }