2025-05-10 21:58:58 +08:00

419 lines
17 KiB
C++

/*
* 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.
*
*/
#ifndef _CAM_HW_ISP20_H_
#define _CAM_HW_ISP20_H_
#include <linux/rk-video-format.h>
#include "CamHwBase.h"
#include "Isp20Params.h"
#include "SensorHw.h"
#include "LensHw.h"
#include "Isp20StatsBuffer.h"
#include "Stream.h"
#include "RawStreamCapUnit.h"
#include "RawStreamProcUnit.h"
#include "SPStreamProcUnit.h"
#include "PdafStreamProcUnit.h"
#ifdef ISP_HW_V20
#include "TnrStreamProcUnit.h"
#include "NrStreamProcUnit.h"
#include "FecParamStream.h"
#endif
#include "thumbnails.h"
#include "CifScaleStream.h"
#include <unordered_map>
struct media_device;
/*
* [sub modules]: use bits 4-11 to define the sub modules of each module, the
* specific meaning of each bit is decided by the module itself. These bits
* is designed to implement the sub module's log switch.
* ----------------------------
* | sub modules | bits |
* ----------------------------
* | ISP20HW_SUBM | 0x01 |
* ----------------------------
* | ISP20PARAM_SUBM | 0x02 |
* ----------------------------
* | SENSOR_SUBM | 0x04 |
* ----------------------------
* | FL_SUBM | 0x08 |
* ----------------------------
* | LENS_SUBM | 0x10 |
* ----------------------------
* | CAPTURERAW_SUBM | 0x80 |
* ----------------------------
*/
namespace RkCam {
class IspParamsSplitter;
#define ISP20HW_SUBM (0x1)
#define MAX_PARAMS_QUEUE_SIZE 5
#define ISP_PARAMS_EFFECT_DELAY_CNT 2
#define CAM_INDEX_FOR_1608 8
#define DISABLE_PARAMS_POLL_THREAD
// FIXME: share 1608 data ptr(aiq/rawdata)
typedef struct sensor_info_share_s {
RawStreamProcUnit* raw_proc_unit[CAM_INDEX_FOR_1608]; // bind rx by camId
SmartPtr<RawStreamCapUnit> raw_cap_unit; // save 1st tx obj addr
char reference_name[64]; // save vicap name(for 1608)
rk_aiq_cif_info_t* reference_mipi_cif; // vicap inf (for 1608)
// us: union_stream
int us_open_cnt; // for hwi open(1608)
int us_prepare_cnt; // for rawCap buffer manage(1608).
int us_stream_cnt; // mark cnt. on: ++, off: --
int us_stop_cnt; // last sensor stop
// tracking opened sensor num
int en_sns_num; // Record the number of open sensors
int first_en[CAM_INDEX_FOR_1608]; // set/get fmt for 1608 sensor
} sensor_info_share_t;
class CamHwIsp20
: public CamHwBase, virtual public Isp20Params, public V4l2Device
, public isp_drv_share_mem_ops_t {
public:
friend class RawStreamProcUnit;
explicit CamHwIsp20();
virtual ~CamHwIsp20();
// from ICamHw
virtual XCamReturn init(const char* sns_ent_name) override;
virtual XCamReturn deInit() override;
virtual XCamReturn prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay) override;
virtual XCamReturn start() override;
virtual XCamReturn stop() override;
virtual XCamReturn pause() override;
virtual XCamReturn resume() override;
virtual XCamReturn swWorkingModeDyn(int mode) override;
virtual XCamReturn getSensorModeData(const char* sns_ent_name,
rk_aiq_exposure_sensor_descriptor& sns_des) override;
virtual void setCalib(const CamCalibDbV2Context_t* calibv2) override;
virtual XCamReturn applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync) override;
virtual XCamReturn applyAnalyzerResult(cam3aResultList& list) override;
XCamReturn setModuleCtl(rk_aiq_module_id_t moduleId, bool en) override;
XCamReturn getModuleCtl(rk_aiq_module_id_t moduleId, bool& en) override;
XCamReturn notify_capture_raw() override;
XCamReturn capture_raw_ctl(capture_raw_t type, int count = 0, const char* capture_dir = nullptr, char* output_dir = nullptr) override;
XCamReturn getSensorCrop(rk_aiq_rect_t& rect) override;
XCamReturn setSensorCrop(rk_aiq_rect_t& rect) override;
XCamReturn setSensorFlip(bool mirror, bool flip, int skip_frm_cnt) override;
XCamReturn getSensorFlip(bool& mirror, bool& flip) override;
void setMulCamConc(bool cc);
XCamReturn getZoomPosition(int& position) override;
XCamReturn getIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType);
XCamReturn getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override;
XCamReturn setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override;
XCamReturn setLensVcmCfg(struct rkmodule_inf& mod_info);
XCamReturn FocusCorrection() override;
XCamReturn ZoomCorrection() override;
XCamReturn setAngleZ(float angleZ) override;
virtual void getShareMemOps(isp_drv_share_mem_ops_t** mem_ops) override;
uint64_t getIspModuleEnState() override;
static rk_aiq_static_info_t* getStaticCamHwInfo(const char* sns_ent_name, uint16_t index = 0);
static rk_aiq_static_info_t* getStaticCamHwInfoByPhyId(const char* sns_ent_name, uint16_t index = 0);
static XCamReturn clearStaticCamHwInfo();
static XCamReturn initCamHwInfos();
static XCamReturn selectIqFile(const char* sns_ent_name, char* iqfile_name);
static const char* getBindedSnsEntNmByVd(const char* vd);
// from PollCallback
virtual XCamReturn poll_event_ready (uint32_t sequence, int type) override;
virtual XCamReturn poll_event_failed (int64_t timestamp, const char *msg) override;
XCamReturn rawReproc_genIspParams (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo, int mode) override;
XCamReturn rawReProc_prepare (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo) override;
//fake sensor
static const char* rawReproc_preInit(const char* isp_driver, const char* offline_sns_ent_name);
XCamReturn rawReproc_deInit (const char* fakeSensor);
XCamReturn getEffectiveIspParams(rkisp_effect_params_v20& ispParams, uint32_t frame_id) override;
void setHdrGlobalTmoMode(uint32_t frame_id, bool mode);
XCamReturn setSharpFbcRotation(rk_aiq_rotation_t rot) {
_sharp_fbc_rotation = rot;
return XCAM_RETURN_NO_ERROR;
}
XCamReturn notify_sof(SmartPtr<VideoBuffer>& buf);
SmartPtr<ispHwEvt_t> make_ispHwEvt (uint32_t sequence, int type, int64_t timestamp);
int get_workingg_mode() {
return _hdr_mode;
}
//should be called after prepare
XCamReturn get_stream_format(rkaiq_stream_type_t type, struct v4l2_format &format);
XCamReturn get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h) override;
XCamReturn showOtpPdafData(struct rkmodule_pdaf_inf *otp_pdaf);
XCamReturn showOtpAfData(struct rkmodule_af_inf *otp_af);
#if RKAIQ_HAVE_PDAF
bool get_pdaf_support() override;
#endif
virtual XCamReturn setIspStreamMode(rk_isp_stream_mode_t mode) override {
if (mode == RK_ISP_STREAM_MODE_ONLNIE) {
mNoReadBack = true;
} else if (mode == RK_ISP_STREAM_MODE_OFFLNIE) {
mNoReadBack = false;
} else {
return XCAM_RETURN_ERROR_FAILED;
}
return XCAM_RETURN_NO_ERROR;
}
virtual rk_isp_stream_mode_t getIspStreamMode() override {
if (true == mNoReadBack)
return RK_ISP_STREAM_MODE_ONLNIE;
else
return RK_ISP_STREAM_MODE_OFFLNIE;
}
void notify_isp_stream_status(bool on);
bool getParamsForEffMap(uint32_t frameId);
XCamReturn reset_hardware() override;
// FIXME: Set struct to static.
static sensor_info_share_t rk1608_share_inf;
virtual void setUserSensorFormat(uint16_t width, uint16_t height, uint16_t code) override {
userSensorWidth = width;
userSensorHeight = height;
userSensorFmtCode = code;
}
// cif scale flag
XCamReturn setCifSclStartFlag(int ratio, bool mode);
private:
using V4l2Device::start;
#if defined(ISP_HW_V20)
XCamReturn handlePpReslut(SmartPtr<cam3aResult> &result);
XCamReturn setPpConfig(SmartPtr<cam3aResult> &result);
#endif
XCamReturn setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar);
XCamReturn setIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType);
XCamReturn setHdrProcessCount(rk_aiq_luma_params_t luma_params) override;
XCamReturn setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params);
XCamReturn setCpslParams(SmartPtr<RkAiqCpslParamsProxy>& cpsl_params);
XCamReturn setupHdrLink(int mode, int isp_index, bool enable);
static void findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info);
XCamReturn setExpDelayInfo(int mode);
void analyzePpInitEns(SmartPtr<cam3aResult> &result);
XCamReturn get_sensor_pdafinfo(rk_sensor_full_info_t *sensor_info, rk_sensor_pdaf_info_t *pdaf_info);
protected:
XCAM_DEAD_COPY(CamHwIsp20);
virtual XCamReturn setIspConfig(cam3aResultList* result_list = NULL);
virtual void updateEffParams(void* params, void* ori_params = NULL) { return; }
virtual bool processTb(void* params) { return false; }
virtual XCamReturn poll_buffer_ready (SmartPtr<VideoBuffer> &buf) override;
enum cam_hw_state_e {
CAM_HW_STATE_INVALID,
CAM_HW_STATE_INITED,
CAM_HW_STATE_PREPARED,
CAM_HW_STATE_STARTED,
CAM_HW_STATE_PAUSED,
CAM_HW_STATE_STOPPED,
};
enum ircut_state_e {
IRCUT_STATE_CLOSED, /* close ir-cut,meaning that infrared ray can be received */
IRCUT_STATE_CLOSING,
IRCUT_STATE_OPENING,
IRCUT_STATE_OPENED, /* open ir-cut,meaning that only visible light can be received */
};
typedef struct calib_infos_s {
struct {
bool enable;
bool motion_detect_en;
} mfnr;
struct {
CalibDb_IrisTypeV2_t IrisType;
} aec;
struct {
CalibDbV2_Af_VcmCfg_t vcmcfg;
CalibDbV2_Af_LdgParam_t ldg_param;
CalibDbV2_Af_HighLightParam_t highlight;
} af;
struct {
CalibDb_DcgSetV2_t CISDcgSet;
CalibDb_ExpUpdate_CombV2_t CISExpUpdate;
} sensor;
} calib_infos_t;
calib_infos_t _cur_calib_infos;
int _hdr_mode;
Mutex _isp_params_cfg_mutex;
int _state;
volatile bool _is_exit;
bool _linked_to_isp;
bool _linked_to_1608;
#if defined(ISP_HW_V20)
struct rkispp_params_cfg _full_active_ispp_params;
uint32_t _ispp_module_init_ens;
SmartPtr<V4l2SubDevice> _ispp_sd;
#endif
SmartPtr<V4l2SubDevice> _cif_csi2_sd;
char sns_name[32];
public:
static std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t>> mCamHwInfos;
static rk_aiq_isp_hw_info_t mIspHwInfos;
static rk_aiq_cif_hw_info_t mCifHwInfos;
static std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>> mSensorHwInfos;
static std::unordered_map<std::string, std::string> mFakeCameraName;
protected:
static bool mIsMultiIspMode;
static uint16_t mMultiIspExtendedPixel;
// TODO: Sync 1608 sensor start streaming
static XCam::Mutex _sync_1608_mutex;
static bool _sync_1608_done;
#if defined(ISP_HW_V20)
void gen_full_ispp_params(const struct rkispp_params_cfg* update_params,
struct rkispp_params_cfg* full_params);
#endif
#if 0
void dump_isp_config(struct isp2x_isp_params_cfg* isp_params,
SmartPtr<RkAiqIspParamsProxy> aiq_results,
SmartPtr<RkAiqIspParamsProxy> aiq_other_results);
void dumpRawnrFixValue(struct isp2x_rawnr_cfg * pRawnrCfg );
void dumpTnrFixValue(struct rkispp_tnr_config * pTnrCfg);
void dumpUvnrFixValue(struct rkispp_nr_config * pNrCfg);
void dumpYnrFixValue(struct rkispp_nr_config * pNrCfg);
void dumpSharpFixValue(struct rkispp_sharp_config * pSharpCfg);
#endif
XCamReturn setIrcutParams(bool on);
XCamReturn setIsppSharpFbcRot(struct rkispp_sharp_config* shp_cfg);
XCamReturn setupPipelineFmt();
XCamReturn setupPipelineFmtIsp(struct v4l2_subdev_selection& sns_sd_sel,
struct v4l2_subdev_format& sns_sd_fmt,
__u32 sns_v4l_pix_fmt);
XCamReturn setupPipelineFmtCif(struct v4l2_subdev_selection& sns_sd_sel,
struct v4l2_subdev_format& sns_sd_fmt,
__u32 sns_v4l_pix_fmt);
XCamReturn setupHdrLink_vidcap(int hdr_mode, int cif_index, bool enable);
#if defined(ISP_HW_V20)
XCamReturn init_pp(rk_sensor_full_info_t *s_info);
#endif
virtual bool isOnlineByWorkingMode();
enum mipi_stream_idx {
MIPI_STREAM_IDX_0 = 1,
MIPI_STREAM_IDX_1 = 2,
MIPI_STREAM_IDX_2 = 4,
MIPI_STREAM_IDX_ALL = 7,
};
XCamReturn hdr_mipi_start_mode(int mode);
XCamReturn hdr_mipi_stop();
XCamReturn hdr_mipi_prepare_mode(int mode);
static void allocMemResource(uint8_t id, void *ops_ctx, void *config, void **mem_ctx);
static void releaseMemResource(uint8_t id, void *mem_ctx);
static void* getFreeItem(uint8_t id, void *mem_ctx);
uint64_t _isp_module_ens{0};
bool mNoReadBack;
rk_aiq_rotation_t _sharp_fbc_rotation;
rk_aiq_ldch_share_mem_info_t ldch_mem_info_array[2 * ISP2X_MESH_BUF_NUM];
rk_aiq_fec_share_mem_info_t fec_mem_info_array[FEC_MESH_BUF_NUM];
rk_aiq_cac_share_mem_info_t cac_mem_info_array[2 * ISP3X_MESH_BUF_NUM];
rk_aiq_dbg_share_mem_info_t dbg_mem_info_array[2 * RKISP_INFO2DDR_BUF_MAX];
typedef struct drv_share_mem_ctx_s {
void* ops_ctx;
void* mem_info;
rk_aiq_drv_share_mem_type_t type;
} drv_share_mem_ctx_t;
drv_share_mem_ctx_t _ldch_drv_mem_ctx;
drv_share_mem_ctx_t _fec_drv_mem_ctx;
drv_share_mem_ctx_t _cac_drv_mem_ctx;
drv_share_mem_ctx_t _dbg_drv_mem_ctx;
Mutex _mem_mutex;
rk_aiq_rect_t _crop_rect;
uint32_t _ds_width;
uint32_t _ds_heigth;
uint32_t _ds_width_align;
uint32_t _ds_heigth_align;
uint32_t _exp_delay;
rk_aiq_lens_descriptor _lens_des;
//ispp
#if defined(ISP_HW_V20)
SmartPtr<FecParamStream> mFecParamStream;
SmartPtr<NrStreamProcUnit> mNrStreamProcUnit;
SmartPtr<TnrStreamProcUnit> mTnrStreamProcUnit;
#endif
//isp
SmartPtr<RKStream> mLumaStream;
SmartPtr<RKStatsStream> mIspStatsStream;
SmartPtr<RKStream> mIspParamStream;
SmartPtr<RKSofEventStream> mIspSofStream;
#if defined(RKAIQ_ENABLE_SPSTREAM)
SmartPtr<SPStreamProcUnit> mSpStreamUnit;
#endif
SmartPtr<RkStreamEventPollThread> mIspStremEvtTh;
SmartPtr<RawStreamCapUnit> mRawCapUnit;
SmartPtr<RawStreamProcUnit> mRawProcUnit;
SmartPtr<CifSclStream> mCifScaleStream;
SmartPtr<PdafStreamProcUnit> mPdafStreamUnit;
SmartPtr<cam3aResult> get_3a_module_result (cam3aResultList &results, int32_t type);
XCamReturn handleIsp3aReslut(SmartPtr<cam3aResult> &result);
XCamReturn handleIsp3aReslut(cam3aResultList& list);
virtual XCamReturn dispatchResult(SmartPtr<cam3aResult> cam3a_result);
virtual XCamReturn dispatchResult(cam3aResultList& list);
std::map<int, cam3aResultList> _camIsp3aResult;
std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>> _effecting_ispparam_map;
SmartPtr<RkAiqIspEffParamsPool> mEffectIspParamsPool;
#ifndef DISABLE_PARAMS_ASSEMBLER
SmartPtr<IspParamsAssembler> mParamsAssembler;
#endif
uint32_t mPpModuleInitEns;
bool mVicapIspPhyLinkSupported; // if phsical link between vicap and isp, only isp3x support now
SmartPtr<IspParamsSplitter> mParamsSplitter;
enum ISP_STREAM_STATUS_E {
ISP_STREAM_STATUS_INVALID,
ISP_STREAM_STATUS_STREAM_ON,
ISP_STREAM_STATUS_STREAM_OFF,
};
int _isp_stream_status;
rk_sensor_pdaf_info_t mPdafInfo;
Mutex _stop_cond_mutex;
// TODO: Sync(1608 sensor) sdk hwEvt cb
XCam::Cond _sync_done_cond;
XCamReturn waitLastSensorDone();
XCamReturn pixFmt2Bpp(uint32_t pixFmt, int8_t& bpp);
uint32_t _curIspParamsSeq;
uint16_t userSensorWidth;
uint16_t userSensorHeight;
uint16_t userSensorFmtCode;
bool _not_skip_first{true};
struct isp32_rawawb_meas_cfg _first_awb_cfg{};
};
}
#endif