hc
2024-05-14 bedbef8ad3e75a304af6361af235302bcc61d06b
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
/*
 *  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 "rk_aiq_user_api2_sysctl.h"
 
XCamReturn
rk_aiq_uapi2_sysctl_preInit(const char* sns_ent_name,
                           rk_aiq_working_mode_t mode,
                           const char* force_iq_file)
{
    return rk_aiq_uapi_sysctl_preInit(sns_ent_name, mode, force_iq_file);
}
 
rk_aiq_sys_ctx_t*
rk_aiq_uapi2_sysctl_init(const char* sns_ent_name,
                        const char* config_file_dir,
                        rk_aiq_error_cb err_cb,
                        rk_aiq_metas_cb metas_cb)
{
    return rk_aiq_uapi_sysctl_init(sns_ent_name, config_file_dir, err_cb, metas_cb);
}
 
void rk_aiq_uapi2_sysctl_deinit(rk_aiq_sys_ctx_t* ctx)
{
    rk_aiq_uapi_sysctl_deinit(ctx);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_prepare(const rk_aiq_sys_ctx_t* ctx,
                           uint32_t  width, uint32_t  height,
                           rk_aiq_working_mode_t mode)
{
    return rk_aiq_uapi_sysctl_prepare(ctx, width, height, mode);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_start(const rk_aiq_sys_ctx_t* ctx)
{
    return rk_aiq_uapi_sysctl_start(ctx);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_stop(const rk_aiq_sys_ctx_t* ctx, bool keep_ext_hw_st)
{
    return rk_aiq_uapi_sysctl_stop(ctx, keep_ext_hw_st);
}
 
void rk_aiq_uapi2_get_version_info(rk_aiq_ver_info_t* vers)
{
    rk_aiq_uapi_get_version_info(vers);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_updateIq(rk_aiq_sys_ctx_t* sys_ctx, char* iqfile)
{
    return rk_aiq_uapi_sysctl_updateIq(sys_ctx, iqfile);
}
 
int32_t
rk_aiq_uapi2_sysctl_getModuleCtl(const rk_aiq_sys_ctx_t* ctx,
                                rk_aiq_module_id_t mId, bool *mod_en)
{
    return rk_aiq_uapi_sysctl_getModuleCtl(ctx, mId, mod_en);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_setModuleCtl(const rk_aiq_sys_ctx_t* ctx, rk_aiq_module_id_t mId, bool mod_en)
{
    return rk_aiq_uapi_sysctl_setModuleCtl(ctx, mId, mod_en);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_enableAxlib(const rk_aiq_sys_ctx_t* ctx,
                               const int algo_type,
                               const int lib_id,
                               bool enable)
{
    return rk_aiq_uapi_sysctl_enableAxlib(ctx, algo_type, lib_id, enable);
}
 
bool
rk_aiq_uapi2_sysctl_getAxlibStatus(const rk_aiq_sys_ctx_t* ctx,
                                  const int algo_type,
                                  const int lib_id)
{
    return rk_aiq_uapi_sysctl_getAxlibStatus(ctx, algo_type, lib_id);
}
 
const RkAiqAlgoContext*
rk_aiq_uapi2_sysctl_getEnabledAxlibCtx(const rk_aiq_sys_ctx_t* ctx, const int algo_type)
{
    return rk_aiq_uapi_sysctl_getEnabledAxlibCtx(ctx, algo_type);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_getStaticMetas(const char* sns_ent_name, rk_aiq_static_info_t* static_info)
{
    return rk_aiq_uapi_sysctl_getStaticMetas(sns_ent_name, static_info);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_enumStaticMetas(int index, rk_aiq_static_info_t* static_info)
{
    return rk_aiq_uapi_sysctl_enumStaticMetas(index, static_info);
}
 
const char*
rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd(const char* vd)
{
    return rk_aiq_uapi_sysctl_getBindedSnsEntNmByVd(vd);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_getCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t *rect)
{
    return rk_aiq_uapi_sysctl_getCrop(sys_ctx, rect);
}
 
#if 0
XCamReturn
rk_aiq_uapi2_sysctl_setCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t rect)
{
    return rk_aiq_uapi_sysctl_setCrop(sys_ctx, rect);
}
#endif
 
XCamReturn
rk_aiq_uapi2_sysctl_setCpsLtCfg(const rk_aiq_sys_ctx_t* ctx, rk_aiq_cpsl_cfg_t* cfg)
{
    return rk_aiq_uapi_sysctl_setCpsLtCfg(ctx, cfg);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_getCpsLtInfo(const rk_aiq_sys_ctx_t* ctx, rk_aiq_cpsl_info_t* info)
{
    return rk_aiq_uapi_sysctl_getCpsLtInfo(ctx, info);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_queryCpsLtCap(const rk_aiq_sys_ctx_t* ctx, rk_aiq_cpsl_cap_t* cap)
{
    return rk_aiq_uapi_sysctl_queryCpsLtCap(ctx, cap);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_setSharpFbcRotation(const rk_aiq_sys_ctx_t* ctx, rk_aiq_rotation_t rot)
{
    return rk_aiq_uapi_sysctl_setSharpFbcRotation(ctx, rot);
}
 
void
rk_aiq_uapi2_sysctl_setMulCamConc(const rk_aiq_sys_ctx_t* ctx, bool cc)
{
    rk_aiq_uapi_sysctl_setMulCamConc(ctx, cc);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_regMemsSensorIntf(const rk_aiq_sys_ctx_t* sys_ctx,
                                     const rk_aiq_mems_sensor_intf_t* intf)
{
    return rk_aiq_uapi_sysctl_regMemsSensorIntf(sys_ctx, intf);
}
 
int
rk_aiq_uapi2_sysctl_switch_scene(const rk_aiq_sys_ctx_t* sys_ctx,
                                const char* main_scene, const char* sub_scene)
{
    return rk_aiq_uapi_sysctl_switch_scene(sys_ctx, main_scene, sub_scene);
}
 
XCamReturn
rk_aiq_uapi2_sysctl_tuning(const rk_aiq_sys_ctx_t* sys_ctx, char* param)
{
    return rk_aiq_uapi_sysctl_tuning(sys_ctx, param);
}
 
char* rk_aiq_uapi2_sysctl_readiq(const rk_aiq_sys_ctx_t* sys_ctx, char* param)
{
    return rk_aiq_uapi_sysctl_readiq(sys_ctx, param);
}