/* 
 | 
 *  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); 
 | 
} 
 |