bool CommonHandler::set_temporal_noise_reduction_level (double level) { XCAM_FAIL_RETURN ( ERROR, level >= -1.0 && level < 1.0, false, "set TNR levlel(%.03f) out of range[-1.0, 1.0]", level); AnalyzerHandler::HanlderLock lock(this); _params.tnr_level = level; XCAM_LOG_DEBUG ("common 3A set TNR level:%.03f", level); return true; }
bool AwbHandler::set_speed (double speed) { XCAM_FAIL_RETURN ( ERROR, (0.0 < speed) && (speed <= 1.0), false, "awb speed(%f) is out of range, suggest (0.0, 1.0]", speed); AnalyzerHandler::HanlderLock lock(this); _params.speed = speed; XCAM_LOG_DEBUG ("awb set speed [%f]", speed); return true; }
void CLContext::context_pfn_notify ( const char* erro_info, const void *private_info, size_t cb, void *user_data ) { CLContext *context = (CLContext*) user_data; XCAM_UNUSED (context); XCAM_UNUSED (erro_info); XCAM_UNUSED (private_info); XCAM_UNUSED (cb); XCAM_LOG_DEBUG ("cl context pfn error:%s", XCAM_STR (erro_info)); }
bool CommonHandler::set_manual_brightness (double level) { XCAM_FAIL_RETURN ( ERROR, level >= -1.0 && level < 1.0, false, "set brightness levlel(%.03f) out of range[-1.0, 1.0]", level); AnalyzerHandler::HanlderLock lock(this); _params.brightness = level; XCAM_LOG_DEBUG ("common 3A set brightness level:%.03f", level); return true; }
XCamReturn PollThread::poll_buffer_loop () { XCamReturn ret = XCAM_RETURN_NO_ERROR; int poll_ret = 0; SmartPtr<V4l2Buffer> buf; poll_ret = _capture_dev->poll_event (PollThread::default_capture_event_timeout); if (poll_ret < 0) { XCAM_LOG_DEBUG ("poll buffer event got error but continue"); ::usleep (100000); // 100ms return XCAM_RETURN_ERROR_TIMEOUT; } /* timeout */ if (poll_ret == 0) { XCAM_LOG_DEBUG ("poll buffer timeout and continue"); return XCAM_RETURN_ERROR_TIMEOUT; } ret = _capture_dev->dequeue_buffer (buf); if (ret != XCAM_RETURN_NO_ERROR) { XCAM_LOG_WARNING ("capture buffer failed"); return ret; } XCAM_ASSERT (buf.ptr()); XCAM_ASSERT (_poll_callback); SmartPtr<V4l2BufferProxy> buf_proxy = new V4l2BufferProxy (buf, _capture_dev); if (_poll_callback) return _poll_callback->poll_buffer_ready (buf_proxy); return ret; }
CL3aImageProcessor::CL3aImageProcessor () : CLImageProcessor ("CL3aImageProcessor") , _output_fourcc (V4L2_PIX_FMT_NV12) , _out_smaple_type (OutSampleYuv) , _pipeline_profile (BasicPipelineProfile) , _capture_stage (TonemappingStage) , _hdr_mode (0) , _tnr_mode (0) , _enable_gamma (true) , _enable_tonemapping (false) , _enable_macc (true) , _enable_dpc (false) , _snr_mode (0) { XCAM_LOG_DEBUG ("CL3aImageProcessor constructed"); }
bool AwbHandler::set_color_temperature_range (uint32_t cct_min, uint32_t cct_max) { XCAM_FAIL_RETURN ( ERROR, (cct_min <= cct_max), false, "awb set wrong cct(%u, %u) parameters", cct_min, cct_max); AnalyzerHandler::HanlderLock lock(this); _params.cct_min = cct_min; _params.cct_max = cct_max; XCAM_LOG_DEBUG ("awb set cct range [%u, %u]", cct_min, cct_max); return true; }
XCamReturn V4l2Device::queue_buffer (SmartPtr<V4l2Buffer> &buf) { XCAM_ASSERT (buf.ptr()); buf->reset (); struct v4l2_buffer v4l2_buf = buf->get_buf (); XCAM_ASSERT (v4l2_buf.index < _buf_count); XCAM_LOG_DEBUG ("device(%s) queue buffer index:%d", XCAM_STR (_name), v4l2_buf.index); if (io_control (VIDIOC_QBUF, &v4l2_buf) < 0) { XCAM_LOG_ERROR("fail to enqueue buffer index:%d.", v4l2_buf.index); return XCAM_RETURN_ERROR_IOCTL; } return XCAM_RETURN_NO_ERROR; }
XCamReturn PipeManager::stop () { _is_running = false; if (_smart_analyzer.ptr ()) { _smart_analyzer->stop (); _smart_analyzer->deinit (); } if (_processor_center.ptr ()) _processor_center->stop (); XCAM_LOG_DEBUG ("pipe manager stopped"); return XCAM_RETURN_NO_ERROR; }
XCamReturn VKDevice::wait_for_fence (VkFence fence, uint64_t timeout) { XCAM_ASSERT (XCAM_IS_VALID_VK_ID (_dev_id)); XCAM_ASSERT (XCAM_IS_VALID_VK_ID (fence)); VkResult ret = vkWaitForFences (_dev_id, 1, &fence, VK_TRUE, timeout); if (ret == VK_TIMEOUT) { XCAM_LOG_DEBUG ("VKDevice wait for fence timeout"); return XCAM_RETURN_ERROR_TIMEOUT; } XCAM_FAIL_RETURN ( ERROR, ret == VK_SUCCESS, XCAM_RETURN_ERROR_VULKAN, "VKDevice wait for fence failed."); return XCAM_RETURN_NO_ERROR; }
bool AwbHandler::set_manual_gain (double gr, double r, double b, double gb) { XCAM_FAIL_RETURN ( ERROR, gr >= 0.0 && r >= 0.0 && b >= 0.0 && gb >= 0.0, false, "awb manual gain value must >= 0.0"); AnalyzerHandler::HanlderLock lock(this); _params.gr_gain = gr; _params.r_gain = r; _params.b_gain = b; _params.gb_gain = gb; XCAM_LOG_DEBUG ("awb set manual gain value(gr:%.03f, r:%.03f, b:%.03f, gb:%.03f)", gr, r, b, gb); return true; }
bool CLContext::insert_kernel (SmartPtr<CLKernel> &kernel) { std::string kernel_name = kernel->get_kernel_name (); CLKernelMap::iterator i_pos = _kernel_map.lower_bound (kernel_name); XCAM_ASSERT (!kernel_name.empty()); if (i_pos != _kernel_map.end () && !_kernel_map.key_comp ()(kernel_name, i_pos->first)) { // need update i_pos->second = kernel; XCAM_LOG_DEBUG ("kernel:%s already exist in context, now update to new one", kernel_name.c_str()); return true; } _kernel_map.insert (i_pos, std::make_pair (kernel_name, kernel)); return true; }
bool CLDevice::init () { cl_platform_id platform_id = NULL; cl_device_id device_id = NULL; cl_uint num_platform = 0; cl_uint num_device = 0; CLDevieInfo device_info; if (clGetPlatformIDs (1, &platform_id, &num_platform) != CL_SUCCESS) { XCAM_LOG_WARNING ("get cl platform ID failed"); return false; } XCAM_ASSERT (num_platform >= 1); if (clGetDeviceIDs (platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, &num_device) != CL_SUCCESS) { XCAM_LOG_WARNING ("get cl device ID failed"); return false; } XCAM_ASSERT (num_device >= 1); // only query first device info if (!query_device_info (device_id, device_info)) { //continue XCAM_LOG_WARNING ("cl get device info failed but continue"); } else { XCAM_LOG_DEBUG ( "cl get device info,\n" "\tmax_compute_unit:%d" "\tmax_work_item_dims:%d" "\tmax_work_item_sizes:{%d, %d, %d}" "\tmax_work_group_size:%d", device_info.max_compute_unit, device_info.max_work_item_dims, device_info.max_work_item_sizes[0], device_info.max_work_item_sizes[1], device_info.max_work_item_sizes[2], device_info.max_work_group_size); } _platform_id = platform_id; _device_id = device_id; _device_info = device_info; _inited = true; return true; }
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; }
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; }
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; }
CL3aImageProcessor::CL3aImageProcessor () : CLImageProcessor ("CL3aImageProcessor") , _output_fourcc (V4L2_PIX_FMT_NV12) , _3a_stats_bits (8) , _scaler_factor (1.0) , _pipeline_profile (BasicPipelineProfile) , _capture_stage (TonemappingStage) , _wdr_mode (WDRdisabled) , _hdr_mode (0) , _tnr_mode (0) , _enable_gamma (true) , _enable_macc (true) , _enable_dpc (false) , _enable_scaler (false) , _enable_wireframe (false) , _wavelet_basis (CL_WAVELET_DISABLED) , _wavelet_channel (CL_IMAGE_CHANNEL_UV) , _wavelet_bayes_shrink (false) , _snr_mode (0) { keep_attached_buf (true); XCAM_LOG_DEBUG ("CL3aImageProcessor constructed"); }
void AiqCompositor::close () { _adaptor.release (); if (_ia_handle) { ia_aiq_deinit (_ia_handle); _ia_handle = NULL; } if (_ia_mkn) { ia_mkn_uninit (_ia_mkn); _ia_mkn = NULL; } _ae_handler.release (); _awb_handler.release (); _af_handler.release (); _common_handler.release (); _pa_result = NULL; XCAM_LOG_DEBUG ("Aiq compositor closed"); }
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; }
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; }
CLContext::~CLContext () { destroy_context (); XCAM_LOG_DEBUG ("CLContext destructed"); }
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; }
X3aAnalyzerManager::X3aAnalyzerManager () { XCAM_LOG_DEBUG ("X3aAnalyzerManager construction"); }
X3aAnalyzerManager::~X3aAnalyzerManager () { XCAM_LOG_DEBUG ("X3aAnalyzerManager destruction"); }
XCamReturn CL3aImageProcessor::create_handlers () { SmartPtr<CLImageHandler> image_handler; SmartPtr<CLContext> context = get_cl_context (); XCAM_ASSERT (context.ptr ()); /* bayer pipeline */ image_handler = create_cl_bayer_basic_image_handler (context, _enable_gamma, _3a_stats_bits); _bayer_basic_pipe = image_handler.dynamic_cast_ptr<CLBayerBasicImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _bayer_basic_pipe.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create bayer basic pipe handler failed"); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); _bayer_basic_pipe->set_stats_callback (_stats_callback); add_handler (image_handler); /* tone mapping */ switch(_wdr_mode) { case Gaussian: { image_handler = create_cl_tonemapping_image_handler (context); _tonemapping = image_handler.dynamic_cast_ptr<CLTonemappingImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _tonemapping.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create tonemapping handler failed"); _tonemapping->set_kernels_enable (true); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); break; } case Haleq: { image_handler = create_cl_newtonemapping_image_handler (context); _newtonemapping = image_handler.dynamic_cast_ptr<CLNewTonemappingImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _newtonemapping.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create tonemapping handler failed"); _newtonemapping->set_kernels_enable (true); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); break; } default: XCAM_LOG_DEBUG ("WDR disabled"); break; } /* bayer pipe */ image_handler = create_cl_bayer_pipe_image_handler (context); _bayer_pipe = image_handler.dynamic_cast_ptr<CLBayerPipeImageHandler> (); XCAM_FAIL_RETURN ( WARNING, image_handler.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create bayer pipe handler failed"); _bayer_pipe->enable_denoise (XCAM_DENOISE_TYPE_BNR & _snr_mode); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE * 2); //image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); add_handler (image_handler); if(_capture_stage == BasicbayerStage) return XCAM_RETURN_NO_ERROR; image_handler = create_cl_yuv_pipe_image_handler (context); _yuv_pipe = image_handler.dynamic_cast_ptr<CLYuvPipeImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _yuv_pipe.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create yuv pipe handler failed"); _yuv_pipe->set_tnr_enable (_tnr_mode & CL_TNR_TYPE_YUV); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE * 2); add_handler (image_handler); #if ENABLE_YEENR_HANDLER /* ee */ image_handler = create_cl_ee_image_handler (context); _ee = image_handler.dynamic_cast_ptr<CLEeImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _ee.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create ee handler failed"); _ee->set_kernels_enable (XCAM_DENOISE_TYPE_EE & _snr_mode); image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); #endif /* wavelet denoise */ switch (_wavelet_basis) { case CL_WAVELET_HAT: { image_handler = create_cl_wavelet_denoise_image_handler (context, _wavelet_channel); _wavelet = image_handler.dynamic_cast_ptr<CLWaveletDenoiseImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _wavelet.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create wavelet denoise handler failed"); _wavelet->set_kernels_enable (true); image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); break; } case CL_WAVELET_HAAR: { image_handler = create_cl_newwavelet_denoise_image_handler (context, _wavelet_channel, _wavelet_bayes_shrink); _newwavelet = image_handler.dynamic_cast_ptr<CLNewWaveletDenoiseImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _newwavelet.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create new wavelet denoise handler failed"); _newwavelet->set_kernels_enable (true); image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); break; } case CL_WAVELET_DISABLED: default : XCAM_LOG_DEBUG ("unknown or disable wavelet (%d)", _wavelet_basis); break; } /* image scaler */ image_handler = create_cl_image_scaler_handler (context, V4L2_PIX_FMT_NV12); _scaler = image_handler.dynamic_cast_ptr<CLImageScaler> (); XCAM_FAIL_RETURN ( WARNING, _scaler.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create scaler handler failed"); _scaler->set_scaler_factor (_scaler_factor); _scaler->set_buffer_callback (_stats_callback); image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); image_handler->set_kernels_enable (_enable_scaler); add_handler (image_handler); /* wire frame */ image_handler = create_cl_wire_frame_image_handler (context); _wire_frame = image_handler.dynamic_cast_ptr<CLWireFrameImageHandler> (); XCAM_FAIL_RETURN ( WARNING, _wire_frame.ptr (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor create wire frame handler failed"); _wire_frame->set_kernels_enable (_enable_wireframe); image_handler->set_pool_type (CLImageHandler::DrmBoPoolType); image_handler->set_pool_size (XCAM_CL_3A_IMAGE_MAX_POOL_SIZE); add_handler (image_handler); XCAM_FAIL_RETURN ( WARNING, post_config (), XCAM_RETURN_ERROR_CL, "CL3aImageProcessor post_config failed"); return XCAM_RETURN_NO_ERROR; }
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; }
CL3aImageProcessor::~CL3aImageProcessor () { XCAM_LOG_DEBUG ("CL3aImageProcessor destructed"); }
XCamReturn DeviceManager::start () { XCamReturn ret = XCAM_RETURN_NO_ERROR; // start device XCAM_ASSERT (_device->is_opened()); if (!_device.ptr() || !_device->is_opened()) { XCAM_FAILED_STOP (ret = XCAM_RETURN_ERROR_FILE, "capture device not ready"); } XCAM_FAILED_STOP (ret = _device->start(), "capture device start failed"); //start subdevice //XCAM_ASSERT (_subdevice->is_opened()); if (_subdevice.ptr()) { if (!_subdevice->is_opened()) XCAM_FAILED_STOP (ret = XCAM_RETURN_ERROR_FILE, "event device not ready"); XCAM_FAILED_STOP (ret = _subdevice->start(), "start event device failed"); } //suppose _device and _subdevice already started if (!_isp_controller.ptr ()) _isp_controller = new IspController (_device); XCAM_ASSERT (_isp_controller.ptr()); if (_has_3a) { // Initialize and start analyzer uint32_t width = 0, height = 0; uint32_t fps_n = 0, fps_d = 0; double framerate = 30.0; if (!_3a_analyzer.ptr()) { _3a_analyzer = X3aAnalyzerManager::instance()->create_analyzer(); if (!_3a_analyzer.ptr()) { XCAM_FAILED_STOP (ret = XCAM_RETURN_ERROR_PARAM, "create analyzer failed"); } } if (_3a_analyzer->prepare_handlers () != XCAM_RETURN_NO_ERROR) { XCAM_FAILED_STOP (ret = XCAM_RETURN_ERROR_PARAM, "prepare analyzer handler failed"); } _3a_analyzer->set_results_callback (this); _device->get_size (width, height); _device->get_framerate (fps_n, fps_d); if (fps_d) framerate = (double)fps_n / (double)fps_d; XCAM_FAILED_STOP ( ret = _3a_analyzer->init (width, height, framerate), "initialize analyzer failed"); XCAM_FAILED_STOP (ret = _3a_analyzer->start (), "start analyzer failed"); if (_smart_analyzer.ptr()) { if (_smart_analyzer->prepare_handlers () != XCAM_RETURN_NO_ERROR) { XCAM_LOG_INFO ("prepare smart analyzer handler failed"); } //_smart_analyzer->set_results_callback (this); if (_smart_analyzer->init (width, height, framerate) != XCAM_RETURN_NO_ERROR) { XCAM_LOG_INFO ("initialize smart analyzer failed"); } if (_smart_analyzer->start () != XCAM_RETURN_NO_ERROR) { XCAM_LOG_INFO ("start smart analyzer failed"); } } // Initialize and start image processors if (!_3a_process_center->has_processors()) { // default processor SmartPtr<ImageProcessor> default_processor = new IspImageProcessor (_isp_controller); XCAM_ASSERT (default_processor.ptr ()); _3a_process_center->insert_processor (default_processor); } _3a_process_center->set_image_callback(this); XCAM_FAILED_STOP (ret = _3a_process_center->start (), "3A process center start failed"); } //Initialize and start poll thread _poll_thread = new PollThread; _poll_thread->set_capture_device (_device); if (_subdevice.ptr ()) _poll_thread->set_event_device (_subdevice); _poll_thread->set_isp_controller (_isp_controller); _poll_thread->set_poll_callback (this); _poll_thread->set_stats_callback (this); XCAM_FAILED_STOP (ret = _poll_thread->start(), "start poll failed"); _is_running = true; XCAM_LOG_DEBUG ("Device manager started"); return XCAM_RETURN_NO_ERROR; }
DnnSemanticSegmentation::DnnSemanticSegmentation (DnnInferConfig& config) : DnnInferenceEngine (config) { XCAM_LOG_DEBUG ("DnnSemanticSegmentation::DnnSemanticSegmentation"); set_output_layer_type ("ArgMax"); }
DeviceManager::~DeviceManager() { XCAM_LOG_DEBUG ("~DeviceManager destruction"); }