/*
|
* Copyright (c) 2019 Rockchip Corporation
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
*/
|
|
#include <sys/select.h>
|
#include <time.h>
|
#include "FakeSensorHw.h"
|
#include "fake_v4l2_device.h"
|
namespace RkCam {
|
using namespace std;
|
|
static uint32_t rk_format_to_media_format(rk_aiq_format_t format)
|
{
|
uint32_t pixelformat = -1;
|
switch (format) {
|
case RK_PIX_FMT_SBGGR10:
|
pixelformat = MEDIA_BUS_FMT_SBGGR10_1X10;
|
break;
|
case RK_PIX_FMT_SRGGB10:
|
pixelformat = MEDIA_BUS_FMT_SRGGB10_1X10;
|
break;
|
case RK_PIX_FMT_SGBRG10:
|
pixelformat = MEDIA_BUS_FMT_SGBRG10_1X10;
|
break;
|
case RK_PIX_FMT_SGRBG10:
|
pixelformat = MEDIA_BUS_FMT_SGRBG10_1X10;
|
break;
|
default:
|
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "%s no support format: %d\n",
|
__func__, format);
|
}
|
return pixelformat;
|
}
|
|
FakeSensorHw::FakeSensorHw()
|
: BaseSensorHw ("/dev/null")
|
, _first(true)
|
, _working_mode(RK_AIQ_WORKING_MODE_NORMAL)
|
,_sync_cond(false)
|
,_need_sync(false)
|
{
|
ENTER_CAMHW_FUNCTION();
|
_timer = new CTimer(this);
|
pFunc = NULL;
|
mAiqExpParamsPool = new RkAiqExpParamsPool("FakeSensorExpParams", 8);
|
EXIT_CAMHW_FUNCTION();
|
}
|
|
FakeSensorHw::~FakeSensorHw()
|
{
|
ENTER_CAMHW_FUNCTION();
|
delete _timer;
|
EXIT_CAMHW_FUNCTION();
|
}
|
|
int
|
FakeSensorHw::get_blank(rk_aiq_exposure_sensor_descriptor* sns_des)
|
{
|
sns_des->pixel_periods_per_line = sns_des->sensor_output_width;
|
sns_des->line_periods_per_field = sns_des->sensor_output_height;
|
return 0;
|
}
|
|
int
|
FakeSensorHw::get_pixel(rk_aiq_exposure_sensor_descriptor* sns_des)
|
{
|
sns_des->pixel_clock_freq_mhz = 600.0f;
|
return 0;
|
}
|
|
int
|
FakeSensorHw::get_sensor_fps(float& fps)
|
{
|
fps = 25.0f;
|
|
return 0;
|
}
|
|
int
|
FakeSensorHw::get_format(rk_aiq_exposure_sensor_descriptor* sns_des)
|
{
|
sns_des->sensor_output_width = _width;
|
sns_des->sensor_output_height = _height;
|
sns_des->sensor_pixelformat = get_v4l2_pixelformat(_fmt_code);
|
return 0;
|
}
|
|
int
|
FakeSensorHw::get_exposure_range(rk_aiq_exposure_sensor_descriptor* sns_des)
|
{
|
sns_des->coarse_integration_time_min = 1;
|
sns_des->coarse_integration_time_max_margin = 10;
|
return 0;
|
}
|
|
int
|
FakeSensorHw::get_nr_switch(rk_aiq_sensor_nr_switch_t* nr_switch)
|
{
|
|
nr_switch->valid = false;
|
nr_switch->direct = 0;
|
nr_switch->up_thres = 0;
|
nr_switch->down_thres = 0;
|
nr_switch->div_coeff = 0;
|
|
return 0;
|
}
|
|
XCamReturn
|
FakeSensorHw::get_sensor_descriptor(rk_aiq_exposure_sensor_descriptor *sns_des)
|
{
|
memset(sns_des, 0, sizeof(rk_aiq_exposure_sensor_descriptor));
|
|
if (get_format(sns_des))
|
return XCAM_RETURN_ERROR_IOCTL;
|
|
if (get_blank(sns_des))
|
return XCAM_RETURN_ERROR_IOCTL;
|
|
/*
|
* pixel rate is not equal to pclk sometimes
|
* prefer to use pclk = ppl * lpp * fps
|
*/
|
float fps = 0;
|
if (get_sensor_fps(fps) == 0)
|
sns_des->pixel_clock_freq_mhz =
|
(float)(sns_des->pixel_periods_per_line) *
|
sns_des->line_periods_per_field * fps / 1000000.0;
|
else if (get_pixel(sns_des))
|
return XCAM_RETURN_ERROR_IOCTL;
|
|
if (get_exposure_range(sns_des))
|
return XCAM_RETURN_ERROR_IOCTL;
|
|
if (get_nr_switch(&sns_des->nr_switch)) {
|
// do nothing;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar)
|
{
|
ENTER_CAMHW_FUNCTION();
|
|
if (_first) {
|
if (expPar->data()->exp_tbl_size > 0) {
|
int lastIdx = expPar->data()->exp_tbl_size - 1;
|
expPar->data()->aecExpInfo.LinearExp = expPar->data()->exp_tbl[lastIdx].LinearExp;
|
expPar->data()->aecExpInfo.HdrExp[0] = expPar->data()->exp_tbl[lastIdx].HdrExp[0];
|
expPar->data()->aecExpInfo.HdrExp[1] = expPar->data()->exp_tbl[lastIdx].HdrExp[1];
|
expPar->data()->aecExpInfo.HdrExp[2] = expPar->data()->exp_tbl[lastIdx].HdrExp[2];
|
expPar->data()->aecExpInfo.frame_length_lines = expPar->data()->exp_tbl[lastIdx].frame_length_lines;
|
expPar->data()->aecExpInfo.line_length_pixels = expPar->data()->exp_tbl[lastIdx].line_length_pixels;
|
expPar->data()->aecExpInfo.pixel_clock_freq_mhz = expPar->data()->exp_tbl[lastIdx].pixel_clock_freq_mhz;
|
}
|
SmartLock locker (_map_mutex);
|
_effecting_exp_map[0] = expPar;
|
_first = false;
|
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "exp-sync: first set exp, add id[0] to the effected exp map");
|
}
|
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::getEffectiveExpParams(SmartPtr<RkAiqExpParamsProxy>& expParams, int frame_id)
|
{
|
ENTER_CAMHW_FUNCTION();
|
|
std::map<int, SmartPtr<RkAiqExpParamsProxy>>::iterator it;
|
int search_id = frame_id < 0 ? 0 : frame_id;
|
SmartLock locker (_map_mutex);
|
it = _effecting_exp_map.find(search_id);
|
if (it == _effecting_exp_map.end()) {
|
LOGW_CAMHW_SUBM(FAKECAM_SUBM, "Can't find exp params of frameid(%d), use the last one\n",search_id);
|
expParams = _effecting_exp_map.rbegin()->second;
|
search_id = _effecting_exp_map.rbegin()->first;
|
} else {
|
expParams = _effecting_exp_map[search_id];
|
}
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "get id:%d, reg_gain:0x%x,reg_time:0x%x", search_id,
|
expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
|
expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);
|
EXIT_CAMHW_FUNCTION();
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::getSensorModeData(const char* sns_ent_name,
|
rk_aiq_exposure_sensor_descriptor& sns_des)
|
{
|
rk_aiq_exposure_sensor_descriptor sensor_desc;
|
get_sensor_descriptor (&sensor_desc);
|
|
_sns_entity_name = sns_ent_name;
|
sns_des.coarse_integration_time_min =
|
sensor_desc.coarse_integration_time_min;
|
sns_des.coarse_integration_time_max_margin =
|
sensor_desc.coarse_integration_time_max_margin;
|
sns_des.fine_integration_time_min =
|
sensor_desc.fine_integration_time_min;
|
sns_des.fine_integration_time_max_margin =
|
sensor_desc.fine_integration_time_max_margin;
|
|
sns_des.frame_length_lines = sensor_desc.line_periods_per_field;
|
sns_des.line_length_pck = sensor_desc.pixel_periods_per_line;
|
sns_des.vt_pix_clk_freq_hz = sensor_desc.pixel_clock_freq_mhz/* * 1000000 */;
|
sns_des.pixel_clock_freq_mhz = sensor_desc.pixel_clock_freq_mhz/* * 1000000 */;
|
|
//add nr_switch
|
sns_des.nr_switch = sensor_desc.nr_switch;
|
|
sns_des.sensor_output_width = sensor_desc.sensor_output_width;
|
sns_des.sensor_output_height = sensor_desc.sensor_output_height;
|
sns_des.sensor_pixelformat = sensor_desc.sensor_pixelformat;
|
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "vts-hts-pclk: %d-%d-%d-%f, rect: [%dx%d]\n",
|
sns_des.frame_length_lines,
|
sns_des.line_length_pck,
|
sns_des.vt_pix_clk_freq_hz,
|
sns_des.pixel_clock_freq_mhz,
|
sns_des.sensor_output_width,
|
sns_des.sensor_output_height);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::handle_sof(int64_t time, int frameid)
|
{
|
ENTER_CAMHW_FUNCTION();
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::set_working_mode(int mode)
|
{
|
__u32 hdr_mode = NO_HDR;
|
|
if (mode == RK_AIQ_WORKING_MODE_NORMAL) {
|
hdr_mode = NO_HDR;
|
} else if (mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
|
mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
|
hdr_mode = HDR_X2;
|
} else if (mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
|
mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
|
hdr_mode = HDR_X3;
|
} else {
|
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "failed to set hdr mode to %d", mode);
|
return XCAM_RETURN_ERROR_FAILED;
|
}
|
|
_working_mode = mode;
|
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "%s _working_mode: %d\n",
|
__func__, _working_mode);
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::set_mirror_flip(bool mirror, bool flip, int32_t& skip_frame_sequence)
|
{
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
|
XCamReturn
|
FakeSensorHw::get_mirror_flip(bool& mirror, bool& flip)
|
{
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::set_exp_delay_info(int time_delay, int gain_delay, int hcg_lcg_mode_delay)
|
{
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::start()
|
{
|
ENTER_CAMHW_FUNCTION();
|
|
V4l2SubDevice::start();
|
|
_timer->SetTimer(0, 10000);
|
_timer->StartTimer();
|
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::stop()
|
{
|
ENTER_CAMHW_FUNCTION();
|
_timer->StopTimer();
|
_effecting_exp_map.clear();
|
_vbuf_list.clear();
|
V4l2SubDevice::stop();
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::get_selection (int pad, uint32_t target, struct v4l2_subdev_selection &select)
|
{
|
XCAM_ASSERT (is_opened());
|
|
return XCAM_RETURN_ERROR_IOCTL;
|
}
|
|
XCamReturn
|
FakeSensorHw::getFormat(struct v4l2_subdev_format &aFormat)
|
{
|
int ret = 0;
|
ENTER_CAMHW_FUNCTION();
|
aFormat.format.width = _width;
|
aFormat.format.height = _height;
|
aFormat.format.code = _fmt_code;
|
aFormat.format.field = V4L2_FIELD_NONE;
|
aFormat.format.colorspace = V4L2_COLORSPACE_470_SYSTEM_M;
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "pad: %d, which: %d, width: %d, "
|
"height: %d, format: 0x%x, field: %d, color space: %d",
|
aFormat.pad,
|
aFormat.which,
|
aFormat.format.width,
|
aFormat.format.height,
|
aFormat.format.code,
|
aFormat.format.field,
|
aFormat.format.colorspace);
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::prepare(rk_aiq_raw_prop_t prop)
|
{
|
ENTER_CAMHW_FUNCTION();
|
_width = prop.frame_width;
|
_height = prop.frame_height;
|
_fmt_code = rk_format_to_media_format(prop.format);
|
_rawbuf_type = prop.rawbuf_type;
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::enqueue_rawbuffer(struct rk_aiq_vbuf *vbuf, bool sync)
|
{
|
int max_count = 0;
|
SmartPtr<FakeV4l2Device> fake_v4l2_dev;
|
ENTER_CAMHW_FUNCTION();
|
if (_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
|
max_count = 1;
|
} else if (_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
|
_working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
|
max_count = 2;
|
} else if (_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
|
_working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
|
max_count = 3;
|
}
|
for (int i=0; i<max_count; i++) {
|
fake_v4l2_dev = _mipi_tx_dev[i].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->enqueue_rawbuffer(&vbuf->buf_info[i]);
|
}
|
_mutex.lock();
|
_vbuf_list.push_back(*vbuf);
|
_mutex.unlock();
|
|
_map_mutex.lock();
|
while (_effecting_exp_map.size() > 4)
|
_effecting_exp_map.erase(_effecting_exp_map.begin());
|
|
int fid = vbuf->buf_info[0].frame_id;
|
SmartPtr<RkAiqExpParamsProxy> exp_param_prx = mAiqExpParamsPool->get_item();
|
|
exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global = vbuf->buf_info[0].exp_gain;
|
exp_param_prx->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time = vbuf->buf_info[0].exp_time;
|
exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[2].exp_gain;
|
exp_param_prx->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time = vbuf->buf_info[2].exp_time;
|
exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[1].exp_gain;
|
exp_param_prx->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time = vbuf->buf_info[1].exp_time;
|
exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global = vbuf->buf_info[0].exp_gain;
|
exp_param_prx->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time = vbuf->buf_info[0].exp_time;
|
_effecting_exp_map[fid] = exp_param_prx;
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "add id[%d] to the effected exp map", fid);
|
_map_mutex.unlock();
|
if (sync) {
|
_need_sync = sync;
|
if (_sync_cond.timedwait(_sync_mutex, 5000000) != 0) {
|
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "wait raw buffer process done timeout");
|
return XCAM_RETURN_ERROR_TIMEOUT;
|
}
|
}
|
EXIT_CAMHW_FUNCTION();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
FakeSensorHw::register_rawdata_callback(void (*callback)(void *))
|
{
|
ENTER_XCORE_FUNCTION();
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
pFunc = callback;
|
EXIT_XCORE_FUNCTION();
|
return ret;
|
}
|
|
XCamReturn
|
FakeSensorHw::on_dqueue(int dev_idx, SmartPtr<V4l2BufferProxy> buf_proxy)
|
{
|
ENTER_XCORE_FUNCTION();
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
std::list<struct rk_aiq_vbuf>::iterator it;
|
SmartLock locker (_mutex);
|
|
if (!_vbuf_list.empty()) {
|
for(it = _vbuf_list.begin(); it != _vbuf_list.end(); it++) {
|
if (_rawbuf_type == RK_AIQ_RAW_DATA) {
|
uintptr_t ptr = buf_proxy->get_reserved();
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(data): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
|
if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
|
it->buf_info[dev_idx].valid = false;
|
break;
|
}
|
} else if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
|
uintptr_t ptr = buf_proxy->get_v4l2_userptr();
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(addr): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
|
if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
|
it->buf_info[dev_idx].valid = false;
|
break;
|
}
|
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
|
uint32_t buf_fd = buf_proxy->get_expbuf_fd();
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(fd): %d vs %d",it->buf_info[dev_idx].data_fd,buf_fd);
|
if (it->buf_info[dev_idx].data_fd == buf_fd) {
|
it->buf_info[dev_idx].valid = false;
|
break;
|
}
|
} else if (_rawbuf_type == RK_AIQ_RAW_FILE) {
|
uintptr_t ptr = buf_proxy->get_v4l2_userptr();
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "rawbuf_type(file): %p vs 0x%x",it->buf_info[dev_idx].data_addr,ptr);
|
if (it->buf_info[dev_idx].data_addr == (uint8_t*)ptr) {
|
it->buf_info[dev_idx].valid = false;
|
break;
|
}
|
} else {
|
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "raw buf type is wrong:0x%x",_rawbuf_type);
|
return XCAM_RETURN_ERROR_FAILED;
|
}
|
|
}
|
if (it != _vbuf_list.end()) {
|
switch (_working_mode)
|
{
|
case RK_AIQ_WORKING_MODE_NORMAL:
|
if (!it->buf_info[0].valid) {
|
goto out;
|
}
|
break;
|
case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
|
case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
|
if (!it->buf_info[0].valid && !it->buf_info[1].valid) {
|
goto out;
|
}
|
break;
|
case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
|
case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
|
if (!it->buf_info[0].valid && !it->buf_info[1].valid && !it->buf_info[2].valid) {
|
goto out;
|
}
|
break;
|
}
|
}
|
}
|
EXIT_XCORE_FUNCTION();
|
return ret;
|
out:
|
_vbuf_list.erase(it);
|
|
if (_need_sync) {
|
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "give off signal");
|
_sync_cond.signal();
|
}else {
|
if (pFunc)
|
pFunc(it->base_addr);
|
}
|
EXIT_XCORE_FUNCTION();
|
return ret;
|
}
|
|
XCamReturn
|
FakeSensorHw::set_mipi_tx_devs(SmartPtr<V4l2Device> mipi_tx_devs[3])
|
{
|
_mipi_tx_dev[0] = mipi_tx_devs[0];
|
_mipi_tx_dev[1] = mipi_tx_devs[1];
|
_mipi_tx_dev[2] = mipi_tx_devs[2];
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
CTimer::CTimer(FakeSensorHw *dev):
|
m_second(0), m_microsecond(0)
|
{
|
_dev = dev;
|
}
|
|
CTimer::~CTimer()
|
{
|
}
|
|
void CTimer::SetTimer(long second, long microsecond)
|
{
|
m_second = second;
|
m_microsecond = microsecond;
|
}
|
|
void CTimer::StartTimer()
|
{
|
pthread_create(&thread_timer, NULL, OnTimer_stub, this);
|
}
|
|
void CTimer::StopTimer()
|
{
|
pthread_cancel(thread_timer);
|
pthread_join(thread_timer, NULL);
|
}
|
|
void CTimer::thread_proc()
|
{
|
while (true)
|
{
|
OnTimer();
|
pthread_testcancel();
|
struct timeval tempval;
|
tempval.tv_sec = m_second;
|
tempval.tv_usec = m_microsecond;
|
select(0, NULL, NULL, NULL, &tempval);
|
}
|
}
|
|
void CTimer::OnTimer()
|
{
|
SmartPtr<FakeV4l2Device> fake_v4l2_dev;
|
ENTER_CAMHW_FUNCTION();
|
if (_dev->_working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
|
fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
} else if (_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
|
_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
|
fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
fake_v4l2_dev = _dev->_mipi_tx_dev[1].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
} else if (_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
|
_dev->_working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
|
fake_v4l2_dev = _dev->_mipi_tx_dev[0].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
fake_v4l2_dev = _dev->_mipi_tx_dev[1].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
fake_v4l2_dev = _dev->_mipi_tx_dev[2].dynamic_cast_ptr<FakeV4l2Device>();
|
fake_v4l2_dev->on_timer_proc();
|
|
}
|
EXIT_XCORE_FUNCTION();
|
}
|
|
}; //namespace RkCam
|
