rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/camera_engine_rkaiq/hwi/fakecamera/FakeCamHwIsp20.cpp

1100 lines
42 KiB
C++
Raw Blame History

/*
* 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 "FakeCamHwIsp20.h"
#include "Isp20Evts.h"
#include "FakeSensorHw.h"
#include "rk_isp20_hw.h"
#include "Isp20_module_dbg.h"
#include "mediactl/mediactl-priv.h"
#include <linux/v4l2-subdev.h>
#include <sys/mman.h>
#include <sys/stat.h>
namespace RkCam {
FakeCamHwIsp20::FakeCamHwIsp20() : isp_index(0)
{
ENTER_CAMHW_FUNCTION();
_rx_memory_type = V4L2_MEMORY_DMABUF;
_tx_memory_type = V4L2_MEMORY_DMABUF;
mNoReadBack = false;
EXIT_CAMHW_FUNCTION();
}
FakeCamHwIsp20::~FakeCamHwIsp20()
{
ENTER_CAMHW_FUNCTION();
setupOffLineLink(isp_index, false);
EXIT_CAMHW_FUNCTION();
}
XCamReturn
FakeCamHwIsp20::init(const char* sns_ent_name)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
ret = CamHwIsp20::init(sns_ent_name);
if (ret)
return ret;
// special for fake sensor
SmartPtr<BaseSensorHw> sensorHw;
mSensorDev->close();
sensorHw = new FakeSensorHw();
mSensorDev = sensorHw;
mSensorDev->open();
mIspStatsStream->set_event_handle_dev(sensorHw);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
FakeCamHwIsp20::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<BaseSensorHw> sensorHw;
ENTER_CAMHW_FUNCTION();
SmartPtr<FakeSensorHw> fakeSensorHw = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>>::iterator it;
if ((it = mSensorHwInfos.find(sns_name)) == mSensorHwInfos.end()) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "can't find sensor %s", sns_name);
return XCAM_RETURN_ERROR_SENSOR;
}
rk_sensor_full_info_t *s_info = it->second.ptr();
isp_index = s_info->isp_info->logic_id;
#ifndef USE_RAWSTREAM_LIB
setupOffLineLink(isp_index, true);
#endif
init_mipi_devices(s_info);
fakeSensorHw->set_mipi_tx_devs(_mipi_tx_devs);
#ifndef USE_RAWSTREAM_LIB
mRawCapUnit->set_tx_devices(_mipi_tx_devs);
mRawProcUnit->set_rx_devices(_mipi_rx_devs);
mRawProcUnit->setPollCallback(this);
#endif
ret = CamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
if (ret)
return ret;
if (mIspSofStream.ptr())
mIspSofStream->setPollCallback (NULL);
EXIT_CAMHW_FUNCTION();
return ret;
}
XCamReturn
FakeCamHwIsp20::poll_buffer_ready (SmartPtr<V4l2BufferProxy> &buf, int dev_index)
{
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
// notify fakesensor one frame has been processed by ISP
return fakeSensor->on_dqueue(dev_index, buf);
}
XCamReturn
FakeCamHwIsp20::init_mipi_devices(rk_sensor_full_info_t *s_info)
{
/*
* for _mipi_tx_devs, index 0 refer to short frame always, inedex 1 refer
* to middle frame always, index 2 refert to long frame always.
* for CIF usecase, because mipi_id0 refert to long frame always, so we
* should know the HDR mode firstly befor building the relationship between
* _mipi_tx_devs array and mipi_idx. here we just set the mipi_idx to
* _mipi_tx_devs, we will build the real relation in start.
* for CIF usecase, rawwr2_path is always connected to _mipi_tx_devs[0],
* rawwr0_path is always connected to _mipi_tx_devs[1], and rawwr1_path is always
* connected to _mipi_tx_devs[0]
*/
//short frame
_mipi_tx_devs[0] = new FakeV4l2Device ();
_mipi_tx_devs[0]->open();
_mipi_tx_devs[0]->set_mem_type(_tx_memory_type);
_mipi_tx_devs[0]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
_mipi_rx_devs[0] = new V4l2Device (s_info->isp_info->rawrd2_s_path);//rkisp_rawrd2_s
_mipi_rx_devs[0]->open();
_mipi_rx_devs[0]->set_mem_type(_rx_memory_type);
//mid frame
_mipi_tx_devs[1] = new FakeV4l2Device ();
_mipi_tx_devs[1]->open();
_mipi_tx_devs[1]->set_mem_type(_tx_memory_type);
_mipi_tx_devs[1]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
_mipi_rx_devs[1] = new V4l2Device (s_info->isp_info->rawrd0_m_path);//rkisp_rawrd0_m
_mipi_rx_devs[1]->open();
_mipi_rx_devs[1]->set_mem_type(_rx_memory_type);
//long frame
_mipi_tx_devs[2] = new FakeV4l2Device ();
_mipi_tx_devs[2]->open();
_mipi_tx_devs[2]->set_mem_type(_tx_memory_type);
_mipi_tx_devs[2]->set_buf_type(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
_mipi_rx_devs[2] = new V4l2Device (s_info->isp_info->rawrd1_l_path);//rkisp_rawrd1_l
_mipi_rx_devs[2]->open();
_mipi_rx_devs[2]->set_mem_type(_rx_memory_type);
for (int i = 0; i < 3; i++) {
if (_linked_to_isp) {
if (_rawbuf_type == RK_AIQ_RAW_FILE) {
_mipi_tx_devs[0]->set_use_type(2);
_mipi_tx_devs[i]->set_buffer_count(1);
_mipi_rx_devs[i]->set_buffer_count(1);
} else if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
_mipi_tx_devs[0]->set_use_type(1);
_mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
_mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
} else {
_mipi_tx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
_mipi_rx_devs[i]->set_buffer_count(ISP_TX_BUF_NUM);
}
} else {
_mipi_tx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
_mipi_rx_devs[i]->set_buffer_count(VIPCAP_TX_BUF_NUM);
}
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
rk_aiq_exposure_sensor_descriptor sns_des;
fakeSensor->get_sensor_desc(&sns_des);
_mipi_tx_devs[i]->set_format(sns_des.sensor_output_width,
sns_des.sensor_output_height,
sns_des.sensor_pixelformat);
_mipi_rx_devs[i]->set_format(sns_des.sensor_output_width,
sns_des.sensor_output_height,
sns_des.sensor_pixelformat);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
FakeCamHwIsp20::poll_event_ready (uint32_t sequence, int type)
{
struct v4l2_event event;
event.u.frame_sync.frame_sequence = sequence;
mIspSofStream->stop();
SmartPtr<VideoBuffer> buf =
mIspSofStream->new_video_buffer(event, NULL);
CamHwBase::poll_buffer_ready(buf);
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
FakeCamHwIsp20::enqueueRawBuffer(void *rawdata, bool sync)
{
ENTER_XCORE_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct rk_aiq_vbuf vbuf;
memset(&vbuf, 0, sizeof(vbuf));
parse_rk_rawdata(rawdata, &vbuf);
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
fakeSensor->enqueue_rawbuffer(&vbuf, sync);
poll_event_ready(vbuf.buf_info[0].frame_id, V4L2_EVENT_FRAME_SYNC);
EXIT_XCORE_FUNCTION();
return ret;
}
XCamReturn
FakeCamHwIsp20::enqueueRawFile(const char *path)
{
ENTER_XCORE_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
struct rk_aiq_vbuf vbuf;
memset(&vbuf, 0, sizeof(vbuf));
if (0 != access(path, F_OK)) {
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "file: %s is not exist!", path);
return XCAM_RETURN_ERROR_PARAM;
}
FILE *fp = fopen(path, "rb");
if (!fp) {
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "open file: %s failed", path);
return XCAM_RETURN_ERROR_FAILED;
}
ret = parse_rk_rawfile(fp, &vbuf);
if (ret != XCAM_RETURN_NO_ERROR) {
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Failed to parse rk rawfile!");
fclose(fp);
return ret;
}
fclose(fp);
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
fakeSensor->enqueue_rawbuffer(&vbuf, true);
poll_event_ready(vbuf.buf_info[0].frame_id, V4L2_EVENT_FRAME_SYNC);
EXIT_XCORE_FUNCTION();
return ret;
}
void
FakeCamHwIsp20::parse_rk_rawdata(void *rawdata, struct rk_aiq_vbuf *vbuf)
{
unsigned short tag = 0;
struct _block_header header;
uint8_t *p = (uint8_t *)rawdata;
uint8_t *actual_raw[3] = {NULL, NULL, NULL};
int actual_raw_len[3] = {0, 0, 0};
bool is_actual_rawdata = false;
bool bExit = false;
while(!bExit){
tag = *((unsigned short*)p);
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
switch (tag)
{
case START_TAG:
p = p+TAG_BYTE_LEN;
memset(_st_addr, 0, sizeof(_st_addr));
memset(&_rawfmt, 0, sizeof(_rawfmt));
memset(&_finfo, 0, sizeof(_finfo));
break;
case NORMAL_RAW_TAG:
{
header = *((struct _block_header *)p);
p = p + sizeof(struct _block_header);
if (header.block_length == sizeof(struct _st_addrinfo)) {
_st_addr[0] = *((struct _st_addrinfo*)p);
}else{
//actual raw data
is_actual_rawdata = true;
actual_raw[0] = p;
actual_raw_len[0] = header.block_length;
}
p = p + header.block_length;
break;
}
case HDR_S_RAW_TAG:
{
header = *((struct _block_header *)p);
p = p + sizeof(struct _block_header);
if (header.block_length == sizeof(struct _st_addrinfo)) {
_st_addr[0] = *((struct _st_addrinfo*)p);
}else{
//actual raw data
is_actual_rawdata = true;
actual_raw[0] = p;
actual_raw_len[0] = header.block_length;
}
p = p + header.block_length;
break;
}
case HDR_M_RAW_TAG:
{
header = *((struct _block_header *)p);
p = p + sizeof(struct _block_header);
if (header.block_length == sizeof(struct _st_addrinfo)) {
_st_addr[1] = *((struct _st_addrinfo*)p);
}else{
//actual raw data
is_actual_rawdata = true;
actual_raw[1] = p;
actual_raw_len[1] = header.block_length;
}
p = p + header.block_length;
break;
}
case HDR_L_RAW_TAG:
{
header = *((struct _block_header *)p);
p = p + sizeof(struct _block_header);
if (header.block_length == sizeof(struct _st_addrinfo)) {
_st_addr[2] = *((struct _st_addrinfo*)p);
}else{
//actual raw data
is_actual_rawdata = true;
actual_raw[2] = p;
actual_raw_len[2] = header.block_length;
}
p = p + header.block_length;
break;
}
case FORMAT_TAG:
{
_rawfmt = *((struct _raw_format *)p);
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
p = p + sizeof(struct _block_header) + _rawfmt.size;
break;
}
case STATS_TAG:
{
_finfo = *((rk_aiq_frame_info_t *)p);
p = p + sizeof(struct _block_header) + _finfo.size;
break;
}
case ISP_REG_FMT_TAG:
{
header = *((struct _block_header *)p);
p += sizeof(struct _block_header);
p = p + header.block_length;
break;
}
case ISP_REG_TAG:
{
header = *((struct _block_header *)p);
p += sizeof(struct _block_header);
p = p + header.block_length;
break;
}
case ISPP_REG_FMT_TAG:
{
header = *((struct _block_header *)p);
p += sizeof(struct _block_header);
p = p + header.block_length;
break;
}
case ISPP_REG_TAG:
{
header = *((struct _block_header *)p);
p += sizeof(struct _block_header);
p = p + header.block_length;
break;
}
case PLATFORM_TAG:
{
header = *((struct _block_header *)p);
p += sizeof(struct _block_header);
p = p + header.block_length;
break;
}
case END_TAG:
{
bExit = true;
break;
}
default:
{
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
bExit = true;
break;
}
}
}
vbuf->frame_width = _rawfmt.width;
vbuf->frame_height = _rawfmt.height;
vbuf->base_addr = rawdata;
if (_rawfmt.hdr_mode == 1) {
if (is_actual_rawdata) {
vbuf->buf_info[0].data_addr = actual_raw[0];
vbuf->buf_info[0].data_fd = 0;
vbuf->buf_info[0].data_length = actual_raw_len[0];
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[0].data_addr =
(uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
}
vbuf->buf_info[0].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[0].data_fd = _st_addr[0].fd;
vbuf->buf_info[0].data_addr = NULL;
}
vbuf->buf_info[0].data_length = _st_addr[0].size;
}
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
} else if (_rawfmt.hdr_mode == 2) {
if (is_actual_rawdata) {
vbuf->buf_info[0].data_addr = actual_raw[0];
vbuf->buf_info[0].data_fd = 0;
vbuf->buf_info[0].data_length = actual_raw_len[0];
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[0].data_addr =
(uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
}
vbuf->buf_info[0].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[0].data_addr = NULL;
vbuf->buf_info[0].data_fd = _st_addr[0].fd;
}
vbuf->buf_info[0].data_length = _st_addr[0].size;
}
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.hdr_gain_s;
vbuf->buf_info[0].exp_time = (float)_finfo.hdr_exp_s;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.hdr_gain_s_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.hdr_exp_s_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
if (is_actual_rawdata) {
vbuf->buf_info[1].data_addr = actual_raw[1];//actual_raw[1]
vbuf->buf_info[1].data_fd = 0;
vbuf->buf_info[1].data_length = actual_raw_len[1];//actual_raw_len[1]
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[1].data_addr = (uint8_t*)(long)(_st_addr[1].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[1].data_addr =
(uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
}
vbuf->buf_info[1].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[1].data_addr = NULL;
vbuf->buf_info[1].data_fd = _st_addr[1].fd;
}
vbuf->buf_info[1].data_length = _st_addr[1].size;
}
vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
vbuf->buf_info[1].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[1].data_addr,
vbuf->buf_info[1].data_fd,
vbuf->buf_info[1].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[1].exp_gain,
vbuf->buf_info[1].exp_time,
vbuf->buf_info[1].exp_gain_reg,
vbuf->buf_info[1].exp_time_reg);
} else if (_rawfmt.hdr_mode == 3) {
if (is_actual_rawdata) {
vbuf->buf_info[0].data_addr = actual_raw[0];
vbuf->buf_info[0].data_fd = 0;
vbuf->buf_info[0].data_length = actual_raw_len[0];
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[0].data_addr = (uint8_t*)(long)(_st_addr[0].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[0].data_addr =
(uint8_t*)(((uint64_t)_st_addr[0].haddr << 32) + _st_addr[0].laddr);
}
vbuf->buf_info[0].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[0].data_addr = NULL;
vbuf->buf_info[0].data_fd = _st_addr[0].fd;
}
vbuf->buf_info[0].data_length = _st_addr[0].size;
}
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.hdr_gain_s;
vbuf->buf_info[0].exp_time = (float)_finfo.hdr_exp_s;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.hdr_gain_s_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.hdr_exp_s_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
if (is_actual_rawdata) {
vbuf->buf_info[1].data_addr = actual_raw[1];
vbuf->buf_info[1].data_fd = 0;
vbuf->buf_info[1].data_length = actual_raw_len[1];
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[1].data_addr = (uint8_t*)(long)(_st_addr[1].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[1].data_addr =
(uint8_t*)(((uint64_t)_st_addr[1].haddr << 32) + _st_addr[1].laddr);
}
vbuf->buf_info[1].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[1].data_addr = NULL;
vbuf->buf_info[1].data_fd = _st_addr[1].fd;
}
vbuf->buf_info[1].data_length = _st_addr[1].size;
}
vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
vbuf->buf_info[1].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[1].data_addr,
vbuf->buf_info[1].data_fd,
vbuf->buf_info[1].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[1].exp_gain,
vbuf->buf_info[1].exp_time,
vbuf->buf_info[1].exp_gain_reg,
vbuf->buf_info[1].exp_time_reg);
if (is_actual_rawdata) {
vbuf->buf_info[2].data_addr = actual_raw[2];
vbuf->buf_info[2].data_fd = 0;
vbuf->buf_info[2].data_length = actual_raw_len[2];
} else {
if (_rawbuf_type == RK_AIQ_RAW_ADDR) {
if (sizeof(uint8_t*) == 4) {
vbuf->buf_info[2].data_addr = (uint8_t*)(long)(_st_addr[2].laddr);
} else if (sizeof(uint8_t*) == 8) {
vbuf->buf_info[2].data_addr =
(uint8_t*)(((uint64_t)_st_addr[2].haddr << 32) + _st_addr[2].laddr);
}
vbuf->buf_info[2].data_fd = 0;
} else if (_rawbuf_type == RK_AIQ_RAW_FD) {
vbuf->buf_info[2].data_addr = NULL;
vbuf->buf_info[2].data_fd = _st_addr[2].fd;
}
vbuf->buf_info[2].data_length = _st_addr[2].size;
}
vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
vbuf->buf_info[2].exp_gain = (float)_finfo.hdr_gain_l;
vbuf->buf_info[2].exp_time = (float)_finfo.hdr_exp_l;
vbuf->buf_info[2].exp_gain_reg = (uint32_t)_finfo.hdr_gain_l_reg;
vbuf->buf_info[2].exp_time_reg = (uint32_t)_finfo.hdr_exp_l_reg;
vbuf->buf_info[2].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[2].data_addr,
vbuf->buf_info[2].data_fd,
vbuf->buf_info[2].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[2].exp_gain,
vbuf->buf_info[2].exp_time,
vbuf->buf_info[2].exp_gain_reg,
vbuf->buf_info[2].exp_time_reg);
}
}
XCamReturn
FakeCamHwIsp20::parse_rk_rawfile(FILE *fp, struct rk_aiq_vbuf *vbuf)
{
unsigned short tag = 0;
struct _block_header header;
bool bExit = false;
if (!_mipi_rx_devs[0]->is_activated()) {
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "device(%s) hasn't activated(%d) yet!!!\n",
XCAM_STR (_mipi_rx_devs[0]->get_device_name()),
_mipi_rx_devs[0]->is_activated());
return XCAM_RETURN_ERROR_FAILED;
}
while(!bExit){
int ret = fread(&tag, sizeof(tag), 1, fp);
if (ret == 0)
break;
fseek(fp, TAG_BYTE_LEN*(-1), SEEK_CUR);//backforwad to tag start
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "tag=0x%04x\n",tag);
switch (tag)
{
case START_TAG:
fseek(fp, TAG_BYTE_LEN, SEEK_CUR);
memset(_st_addr, 0, sizeof(_st_addr));
memset(&_rawfmt, 0, sizeof(_rawfmt));
memset(&_finfo, 0, sizeof(_finfo));
break;
case NORMAL_RAW_TAG:
{
fread(&header, sizeof(header), 1, fp);
if (header.block_length > 0) {
vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
vbuf->buf_info[0].data_length = header.block_length;
}
break;
}
case HDR_S_RAW_TAG:
{
fread(&header, sizeof(header), 1, fp);
if (header.block_length > 0) {
vbuf->buf_info[0].data_addr = (uint8_t*)_mipi_rx_devs[0]->get_buffer_by_index(0)->get_expbuf_usrptr();
fread(vbuf->buf_info[0].data_addr, header.block_length, 1, fp);
vbuf->buf_info[0].data_length = header.block_length;
}
break;
}
case HDR_M_RAW_TAG:
{
fread(&header, sizeof(header), 1, fp);
if (header.block_length > 0) {
vbuf->buf_info[1].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
fread(vbuf->buf_info[1].data_addr, header.block_length, 1, fp);
vbuf->buf_info[1].data_length = header.block_length;
}
break;
}
case HDR_L_RAW_TAG:
{
fread(&header, sizeof(header), 1, fp);
if (header.block_length > 0) {
vbuf->buf_info[2].data_addr = (uint8_t*)_mipi_rx_devs[1]->get_buffer_by_index(0)->get_expbuf_usrptr();
fread(vbuf->buf_info[2].data_addr, header.block_length, 1, fp);
vbuf->buf_info[2].data_length = header.block_length;
}
break;
}
case FORMAT_TAG:
{
fread(&_rawfmt, sizeof(_rawfmt), 1, fp);
LOGD_CAMHW_SUBM(FAKECAM_SUBM, "hdr_mode=%d,bayer_fmt=%d\n",_rawfmt.hdr_mode,_rawfmt.bayer_fmt);
break;
}
case STATS_TAG:
{
fread(&_finfo, sizeof(_finfo), 1, fp);
break;
}
case ISP_REG_FMT_TAG:
{
fread(&header, sizeof(header), 1, fp);
fseek(fp, header.block_length, SEEK_CUR);
break;
}
case ISP_REG_TAG:
{
fread(&header, sizeof(header), 1, fp);
fseek(fp, header.block_length, SEEK_CUR);
break;
}
case ISPP_REG_FMT_TAG:
{
fread(&header, sizeof(header), 1, fp);
fseek(fp, header.block_length, SEEK_CUR);
break;
}
case ISPP_REG_TAG:
{
fread(&header, sizeof(header), 1, fp);
fseek(fp, header.block_length, SEEK_CUR);
break;
}
case PLATFORM_TAG:
{
fread(&header, sizeof(header), 1, fp);
fseek(fp, header.block_length, SEEK_CUR);
break;
}
case END_TAG:
{
bExit = true;
break;
}
default:
{
LOGE_CAMHW_SUBM(FAKECAM_SUBM, "Not support TAG(0x%04x)\n", tag);
bExit = true;
break;
}
}
}
vbuf->frame_width = _rawfmt.width;
vbuf->frame_height = _rawfmt.height;
if (_rawfmt.hdr_mode == 1) {
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"data_addr=%p,fd=%d,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
}else if (_rawfmt.hdr_mode == 2) {
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
vbuf->buf_info[1].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[1].data_addr,
vbuf->buf_info[1].data_fd,
vbuf->buf_info[1].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[1].exp_gain,
vbuf->buf_info[1].exp_time,
vbuf->buf_info[1].exp_gain_reg,
vbuf->buf_info[1].exp_time_reg);
}else if (_rawfmt.hdr_mode == 3) {
vbuf->buf_info[0].frame_id = _rawfmt.frame_id;
vbuf->buf_info[0].exp_gain = (float)_finfo.normal_gain;
vbuf->buf_info[0].exp_time = (float)_finfo.normal_exp;
vbuf->buf_info[0].exp_gain_reg = (uint32_t)_finfo.normal_gain_reg;
vbuf->buf_info[0].exp_time_reg = (uint32_t)_finfo.normal_exp_reg;
vbuf->buf_info[0].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[0].data_addr,
vbuf->buf_info[0].data_fd,
vbuf->buf_info[0].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[0]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[0].exp_gain,
vbuf->buf_info[0].exp_time,
vbuf->buf_info[0].exp_gain_reg,
vbuf->buf_info[0].exp_time_reg);
vbuf->buf_info[1].frame_id = _rawfmt.frame_id;
vbuf->buf_info[1].exp_gain = (float)_finfo.hdr_gain_m;
vbuf->buf_info[1].exp_time = (float)_finfo.hdr_exp_m;
vbuf->buf_info[1].exp_gain_reg = (uint32_t)_finfo.hdr_gain_m_reg;
vbuf->buf_info[1].exp_time_reg = (uint32_t)_finfo.hdr_exp_m_reg;
vbuf->buf_info[1].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[1].data_addr,
vbuf->buf_info[1].data_fd,
vbuf->buf_info[1].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[1]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[1].exp_gain,
vbuf->buf_info[1].exp_time,
vbuf->buf_info[1].exp_gain_reg,
vbuf->buf_info[1].exp_time_reg);
vbuf->buf_info[2].frame_id = _rawfmt.frame_id;
vbuf->buf_info[2].exp_gain = (float)_finfo.hdr_gain_l;
vbuf->buf_info[2].exp_time = (float)_finfo.hdr_exp_l;
vbuf->buf_info[2].exp_gain_reg = (uint32_t)_finfo.hdr_gain_l_reg;
vbuf->buf_info[2].exp_time_reg = (uint32_t)_finfo.hdr_exp_l_reg;
vbuf->buf_info[2].valid = true;
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: data_addr=%p,fd=%d,,length=%d\n",
vbuf->buf_info[2].data_addr,
vbuf->buf_info[2].data_fd,
vbuf->buf_info[2].data_length);
LOGD_CAMHW_SUBM(FAKECAM_SUBM,"buf_info[2]: gain:%f,time:%f,gain_reg:0x%x,time_reg:0x%x\n",
vbuf->buf_info[2].exp_gain,
vbuf->buf_info[2].exp_time,
vbuf->buf_info[2].exp_gain_reg,
vbuf->buf_info[2].exp_time_reg);
}
return XCAM_RETURN_NO_ERROR;
}
XCamReturn
FakeCamHwIsp20::registRawdataCb(void (*callback)(void *))
{
ENTER_XCORE_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
ret = fakeSensor->register_rawdata_callback(callback);
EXIT_XCORE_FUNCTION();
return ret;
}
XCamReturn
FakeCamHwIsp20::rawdataPrepare(rk_aiq_raw_prop_t prop)
{
ENTER_XCORE_FUNCTION();
XCamReturn ret = XCAM_RETURN_NO_ERROR;
_rawbuf_type = prop.rawbuf_type;
if (_rawbuf_type == RK_AIQ_RAW_ADDR)
{
_rx_memory_type = V4L2_MEMORY_USERPTR;
_tx_memory_type = V4L2_MEMORY_USERPTR;
}
else if (_rawbuf_type == RK_AIQ_RAW_FD)
{
_rx_memory_type = V4L2_MEMORY_DMABUF;
_tx_memory_type = V4L2_MEMORY_DMABUF;
}
else if(_rawbuf_type == RK_AIQ_RAW_DATA)
{
_rx_memory_type = V4L2_MEMORY_MMAP;
_tx_memory_type = V4L2_MEMORY_USERPTR;
}
else if(_rawbuf_type == RK_AIQ_RAW_FILE)
{
_rx_memory_type = V4L2_MEMORY_MMAP;
_tx_memory_type = V4L2_MEMORY_USERPTR;
}
else {
LOGE_CAMHW_SUBM(FAKECAM_SUBM,"Not support raw data type:%d", _rawbuf_type);
return XCAM_RETURN_ERROR_PARAM;
}
SmartPtr<FakeSensorHw> fakeSensor = mSensorDev.dynamic_cast_ptr<FakeSensorHw>();
ret = fakeSensor->prepare(prop);
EXIT_XCORE_FUNCTION();
return ret;
}
XCamReturn FakeCamHwIsp20::setupOffLineLink(int isp_index, bool enable)
{
media_device* device = NULL;
media_entity* entity = NULL;
media_pad* src_pad = NULL;
media_pad* sink_pad = NULL;
int lvds_max_entities = 6;
int lvds_entity = 0;
device = media_device_new(mIspHwInfos.isp_info[isp_index].media_dev_path);
if (!device) return XCAM_RETURN_ERROR_FAILED;
/* Enumerate entities, pads and links. */
media_device_enumerate(device);
entity = media_get_entity_by_name(device, "rkisp-isp-subdev", strlen("rkisp-isp-subdev"));
if (!entity) {
goto FAIL;
}
sink_pad = (media_pad*)media_entity_get_pad(entity, 0);
if (!sink_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkisp-isp-subdev sink pad failed!\n");
goto FAIL;
}
for (lvds_entity = 0; lvds_entity < lvds_max_entities; lvds_entity++) {
char entity_name[128] = {0};
src_pad = NULL;
if (!lvds_entity) {
snprintf(entity_name, 128, "rkcif-mipi-lvds");
} else {
snprintf(entity_name, 128, "rkcif-mipi-lvds%d", lvds_entity);
}
entity = media_get_entity_by_name(device, entity_name, strlen(entity_name));
if (entity) {
src_pad = (media_pad*)media_entity_get_pad(entity, 0);
if (!src_pad) {
LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get rkcif-mipi-lvds%d source pad s failed!\n",
lvds_entity);
goto FAIL;
}
}
if (src_pad && sink_pad) {
if (enable) {
media_setup_link(device, src_pad, sink_pad, 0);
} else
media_setup_link(device, src_pad, sink_pad, MEDIA_LNK_FL_ENABLED);
}
}
media_device_unref(device);
return XCAM_RETURN_NO_ERROR;
FAIL:
media_device_unref(device);
return XCAM_RETURN_ERROR_FAILED;
}
FakeCamHwIsp21::FakeCamHwIsp21()
: FakeCamHwIsp20() {
}
FakeCamHwIsp21::~FakeCamHwIsp21()
{
ENTER_CAMHW_FUNCTION();
EXIT_CAMHW_FUNCTION();
}
XCamReturn
FakeCamHwIsp21::init(const char* sns_ent_name)
{
return FakeCamHwIsp20::init(sns_ent_name);
}
XCamReturn
FakeCamHwIsp21::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
}
XCamReturn
FakeCamHwIsp21::enqueueRawBuffer(void *rawdata, bool sync)
{
return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
}
XCamReturn
FakeCamHwIsp21::enqueueRawFile(const char *path)
{
return FakeCamHwIsp20::enqueueRawFile(path);
}
XCamReturn
FakeCamHwIsp21::registRawdataCb(void (*callback)(void *))
{
return FakeCamHwIsp20::registRawdataCb(callback);
}
XCamReturn
FakeCamHwIsp21::rawdataPrepare(rk_aiq_raw_prop_t prop)
{
return FakeCamHwIsp20::rawdataPrepare(prop);
}
XCamReturn
FakeCamHwIsp21::poll_event_ready (uint32_t sequence, int type)
{
return FakeCamHwIsp20::poll_event_ready (sequence, type);
}
FakeCamHwIsp3x::FakeCamHwIsp3x()
: FakeCamHwIsp20() {
}
FakeCamHwIsp3x::~FakeCamHwIsp3x()
{
ENTER_CAMHW_FUNCTION();
EXIT_CAMHW_FUNCTION();
}
XCamReturn
FakeCamHwIsp3x::init(const char* sns_ent_name)
{
return FakeCamHwIsp20::init(sns_ent_name);
}
XCamReturn
FakeCamHwIsp3x::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
}
XCamReturn
FakeCamHwIsp3x::enqueueRawBuffer(void *rawdata, bool sync)
{
return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
}
XCamReturn
FakeCamHwIsp3x::enqueueRawFile(const char *path)
{
return FakeCamHwIsp20::enqueueRawFile(path);
}
XCamReturn
FakeCamHwIsp3x::registRawdataCb(void (*callback)(void *))
{
return FakeCamHwIsp20::registRawdataCb(callback);
}
XCamReturn
FakeCamHwIsp3x::rawdataPrepare(rk_aiq_raw_prop_t prop)
{
return FakeCamHwIsp20::rawdataPrepare(prop);
}
XCamReturn
FakeCamHwIsp3x::poll_event_ready (uint32_t sequence, int type)
{
return FakeCamHwIsp20::poll_event_ready (sequence, type);
}
FakeCamHwIsp32::FakeCamHwIsp32()
: FakeCamHwIsp20() {
}
FakeCamHwIsp32::~FakeCamHwIsp32()
{
ENTER_CAMHW_FUNCTION();
EXIT_CAMHW_FUNCTION();
}
XCamReturn
FakeCamHwIsp32::init(const char* sns_ent_name)
{
return FakeCamHwIsp20::init(sns_ent_name);
}
XCamReturn
FakeCamHwIsp32::prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay)
{
return FakeCamHwIsp20::prepare(width, height, mode, t_delay, g_delay);
}
XCamReturn
FakeCamHwIsp32::enqueueRawBuffer(void *rawdata, bool sync)
{
return FakeCamHwIsp20::enqueueRawBuffer(rawdata, sync);
}
XCamReturn
FakeCamHwIsp32::enqueueRawFile(const char *path)
{
return FakeCamHwIsp20::enqueueRawFile(path);
}
XCamReturn
FakeCamHwIsp32::registRawdataCb(void (*callback)(void *))
{
return FakeCamHwIsp20::registRawdataCb(callback);
}
XCamReturn
FakeCamHwIsp32::rawdataPrepare(rk_aiq_raw_prop_t prop)
{
return FakeCamHwIsp20::rawdataPrepare(prop);
}
XCamReturn
FakeCamHwIsp32::poll_event_ready (uint32_t sequence, int type)
{
return FakeCamHwIsp20::poll_event_ready (sequence, type);
}
} //namspace RkCam
Reference in New Issue View Git Blame Copy Permalink