kernel_5.10 no rt

hc

2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/*
 *  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 _ICAMHW_H_
#define _ICAMHW_H_
 
#include "video_buffer.h"
#include "smartptr.h"
#include "rk_aiq_types.h"
#include "rk_aiq_pool.h"
#include "RkAiqCalibDbV2Helper.h"
 
namespace RkCam {
 
using namespace XCam;
 
typedef struct ispHwEvt_s {
    virtual ~ispHwEvt_s() {};
    int evt_code;
    union {
        uint32_t frame_id;
    } msg;
} ispHwEvt_t;
 
class IsppStatsListener {
public:
    IsppStatsListener() {};
    virtual ~IsppStatsListener() {};
    virtual XCamReturn isppStatsCb(SmartPtr<VideoBuffer>& isppStats) = 0;
private:
    XCAM_DEAD_COPY (IsppStatsListener);
};
 
class IspLumaListener {
public:
    IspLumaListener() {};
    virtual ~IspLumaListener() {};
    virtual XCamReturn ispLumaCb(SmartPtr<VideoBuffer>& ispLuma) = 0;
private:
    XCAM_DEAD_COPY (IspLumaListener);
};
 
class IspStatsListener {
public:
    IspStatsListener() {};
    virtual ~IspStatsListener() {};
    virtual XCamReturn ispStatsCb(SmartPtr<VideoBuffer>& ispStats) = 0;
private:
    XCAM_DEAD_COPY (IspStatsListener);
};
 
class IspEvtsListener {
public:
    IspEvtsListener() {};
    virtual ~IspEvtsListener() {};
    virtual XCamReturn ispEvtsCb(SmartPtr<ispHwEvt_t> evt) = 0;
private:
    XCAM_DEAD_COPY (IspEvtsListener);
};
 
class HwResListener {
public:
    HwResListener() {};
    virtual ~HwResListener() {};
    virtual XCamReturn hwResCb(SmartPtr<VideoBuffer>& resources) = 0;
private:
    XCAM_DEAD_COPY (HwResListener);
};
 
class ICamHw {
public:
    ICamHw() {};
    virtual ~ICamHw() {};
    virtual XCamReturn init(const char* sns_ent_name) = 0;
    virtual XCamReturn deInit() = 0;
    virtual void setCalib(const CamCalibDbContext_t* calib) = 0;
    virtual void setCalib(const CamCalibDbV2Context_t* calibv2) = 0;
    virtual XCamReturn prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay) = 0;
    virtual XCamReturn start() = 0;
    virtual XCamReturn stop() = 0;
    virtual XCamReturn pause() = 0;
    virtual XCamReturn resume() = 0;
    virtual void keepHwStAtStop(bool ks) = 0;
    virtual XCamReturn swWorkingModeDyn(int mode) = 0;
    virtual XCamReturn setIspStreamMode(rk_isp_stream_mode_t mode) = 0;
    virtual rk_isp_stream_mode_t getIspStreamMode() = 0;
    virtual XCamReturn getSensorModeData(const char* sns_ent_name,
                                         rk_aiq_exposure_sensor_descriptor& sns_des) = 0;
    virtual XCamReturn setHdrProcessCount(rk_aiq_luma_params_t luma_params) = 0;
    virtual XCamReturn applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync) = 0;
    virtual XCamReturn applyAnalyzerResult(cam3aResultList& list) = 0;
    virtual XCamReturn setHwResListener(HwResListener* resListener) = 0;
    virtual XCamReturn setModuleCtl(rk_aiq_module_id_t mId, bool mod_en) = 0;
    virtual XCamReturn getModuleCtl(rk_aiq_module_id_t mId, bool& mod_en) = 0;
    virtual XCamReturn notify_capture_raw() = 0;
    virtual XCamReturn capture_raw_ctl(capture_raw_t type, int count = 0,
                                       const char* capture_dir = nullptr,
                                       char* output_dir = nullptr) = 0;
    virtual XCamReturn enqueueRawBuffer(void *vbuf, bool sync) = 0;
    virtual XCamReturn enqueueRawFile(const char *path) = 0;
    virtual XCamReturn registRawdataCb(void (*callback)(void *)) = 0;
    virtual XCamReturn rawdataPrepare(rk_aiq_raw_prop_t prop) = 0;
    virtual XCamReturn setSensorFlip(bool mirror, bool flip, int skip_frm_cnt) = 0;
    virtual XCamReturn getSensorFlip(bool& mirror, bool& flip) = 0;
    virtual XCamReturn getSensorCrop(rk_aiq_rect_t& rect) = 0;
    virtual XCamReturn setSensorCrop(rk_aiq_rect_t& rect) = 0;
    virtual XCamReturn getZoomPosition(int& position) = 0;
    virtual XCamReturn getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) = 0;
    virtual XCamReturn setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) = 0;
    virtual XCamReturn FocusCorrection() = 0;
    virtual XCamReturn ZoomCorrection() = 0;
    virtual void getShareMemOps(isp_drv_share_mem_ops_t** mem_ops) = 0;
    virtual XCamReturn getEffectiveIspParams(rkisp_effect_params_v20& ispParams, int frame_id) = 0;
    virtual uint64_t getIspModuleEnState() = 0;
    virtual XCamReturn get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h) = 0;
private:
    XCAM_DEAD_COPY (ICamHw);
};
 
}; //namespace RkCam
 
#endif