254 lines
8.1 KiB
C++
254 lines
8.1 KiB
C++
/*
|
|
* AiqCameraHalAdapter.h - main rkaiq CameraHal Adapter
|
|
*
|
|
* Copyright (c) 2020 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 _AIQ_CAMERA_HAL_ADAPTER_H_
|
|
#define _AIQ_CAMERA_HAL_ADAPTER_H_
|
|
|
|
#include "RkAiqCore.h"
|
|
#include <RkAiqManager.h>
|
|
|
|
#include "rkisp_control_loop.h"
|
|
#include "rkaiq.h"
|
|
|
|
#ifdef ANDROID_VERSION_ABOVE_8_X
|
|
#include <CameraMetadata.h>
|
|
using ::android::hardware::camera::common::V1_0::helper::CameraMetadata;
|
|
#include <cutils/properties.h>
|
|
#define CAM_IQ_PROPERTY_KEY "vendor.cam.librkisp.iqfile.name"
|
|
#else
|
|
#include <camera/CameraMetadata.h>
|
|
#endif
|
|
#include <pthread.h>
|
|
|
|
#include "include/ae_state_machine.h"
|
|
#include "include/af_state_machine.h"
|
|
#include "include/awb_state_machine.h"
|
|
|
|
#include "settings_processor.h"
|
|
#include "MessageQueue.h"
|
|
#include "MessageThread.h"
|
|
|
|
/*
|
|
***************** AIQ ADAPTER LIB VERSION NOTE *****************
|
|
* v1.0.0 init
|
|
* - match rkaiq v1.3.0
|
|
* - add properties to show rkaiq & aiqAdapter lib version
|
|
* v1.0.1
|
|
* - remove unnecessary code
|
|
* v1.0.2
|
|
* - add Message Thread deal with parameter setting & resultcb
|
|
* v1.0.3
|
|
* - workaround awb state not converged issue.
|
|
* - fix some mismatched debug info
|
|
* v2.0.1
|
|
* - adapt to aiq_v5.0x1.3-rc1.
|
|
* - replace uAPI1 with uAPI2
|
|
*/
|
|
|
|
#define CONFIG_AIQ_ADAPTER_LIB_VERSION "v2.0.1"
|
|
|
|
using namespace RkCam;
|
|
using namespace XCam;
|
|
using namespace android::camera2;
|
|
|
|
typedef struct rk_aiq_sys_ctx_s rk_aiq_sys_ctx_t;
|
|
|
|
struct rkisp_cl_frame_rkaiq_s {
|
|
//frame id
|
|
int id;
|
|
// rkaiq input parameters
|
|
const void *rkaiq;
|
|
};
|
|
|
|
struct rkisp_cl_frame_rkaiq_result_s {
|
|
//frame id
|
|
int id;
|
|
rk_aiq_ae_results *ae_results;
|
|
rk_aiq_awb_results *awb_results;
|
|
rk_aiq_af_results *af_results;
|
|
};
|
|
|
|
enum USE_CASE {
|
|
UC_PREVIEW,
|
|
UC_PRE_CAPTRUE,
|
|
UC_CAPTURE,
|
|
UC_RECORDING,
|
|
UC_RAW
|
|
};
|
|
|
|
enum MessageId {
|
|
MESSAGE_ID_EXIT = 0, // call requestExitAndWait
|
|
MESSAGE_ID_ISP_STAT_DONE,
|
|
MESSAGE_ID_ISP_SOF_DONE,
|
|
MESSAGE_ID_RKAIQ_CAL_DONE, // partial metadata
|
|
MESSAGE_ID_FLUSH,
|
|
// max number of messages
|
|
MESSAGE_ID_MAX
|
|
};
|
|
|
|
struct MessageMetadataDone {
|
|
int resultIndex; /*!> Index from the partial result array that is
|
|
being returned */
|
|
};
|
|
|
|
struct MessageShutterDone {
|
|
int64_t time;
|
|
};
|
|
|
|
union MessageData {
|
|
MessageMetadataDone meta;
|
|
MessageShutterDone shutter;
|
|
};
|
|
|
|
/**
|
|
* \struct
|
|
* Result processor message structure
|
|
*/
|
|
struct Message {
|
|
MessageId id;
|
|
MessageData data;
|
|
};
|
|
|
|
typedef enum StillLockState {
|
|
STILL_CAP_3A_UNLOCK = 0,
|
|
STILL_CAP_3A_LOCK
|
|
} StillLockState_t ;
|
|
|
|
//namespace RkCam {
|
|
class AiqCameraHalAdapter:
|
|
public IMessageHandler
|
|
{
|
|
private:
|
|
|
|
const cl_result_callback_ops_t *mCallbackOps;
|
|
|
|
Mutex _settingsMutex;
|
|
// push_back when set_control_params, erase when calculationd done
|
|
std::vector<SmartPtr<AiqInputParams>> _settings;
|
|
std::vector<SmartPtr<AiqInputParams>> _fly_settings;
|
|
SmartPtr<AiqInputParams> _cur_settings;
|
|
SettingsProcessor* _settingsProcessor;
|
|
SmartPtr<AiqInputParams> _inputParams;
|
|
SmartPtr<RkAEStateMachine> mAeState; /**< AE state machine */
|
|
SmartPtr<RkAFStateMachine> mAfState; /**< AF state machine */
|
|
SmartPtr<RkAWBStateMachine> mAwbState; /**< AWB state machine */
|
|
rk_aiq_exposure_sensor_descriptor _sns_des;
|
|
|
|
/* MetaData*/
|
|
CameraMetadata *_metadata;
|
|
camera_metadata_t *_meta;
|
|
//TODO for Capture or Flash
|
|
bool _delay_still_capture;
|
|
rk_aiq_working_mode_t _work_mode;
|
|
int32_t _exposureCompensation;
|
|
StillLockState_t mAelockstate;
|
|
StillLockState_t mAflockstate;
|
|
StillLockState_t mAwblockstate;
|
|
XCamAeParam mLastAeParam;
|
|
XCamAwbParam mLastAwbParam;
|
|
XCamAfParam mLastAfParam;
|
|
|
|
private: /* Members */
|
|
/**
|
|
* Thread control members
|
|
*/
|
|
std::atomic<bool> mThreadRunning;
|
|
MessageQueue<Message, MessageId> mMessageQueue;
|
|
std::unique_ptr<android::camera2::MessageThread> mMessageThread;
|
|
float mMeanLuma = 1.0f;
|
|
enum aiq_state_e {
|
|
AIQ_ADAPTER_STATE_INVALID,
|
|
AIQ_ADAPTER_STATE_INITED,
|
|
AIQ_ADAPTER_STATE_PREPARED,
|
|
AIQ_ADAPTER_STATE_STARTED,
|
|
AIQ_ADAPTER_STATE_STOPED,
|
|
};
|
|
|
|
int _state;
|
|
private: /* Methods */
|
|
/* IMessageHandler overloads */
|
|
status_t requestExitAndWait();
|
|
virtual void messageThreadLoop();
|
|
status_t handleMessageExit(Message &msg);
|
|
status_t handleIspSofCb(Message &msg);
|
|
status_t handleMessageFlush(Message &msg);
|
|
|
|
public:
|
|
rk_aiq_sys_ctx_t* _aiq_ctx;
|
|
static CameraMetadata staticMeta;
|
|
pthread_mutex_t _aiq_ctx_mutex;
|
|
camera_metadata_rational_t _transformMatrix[9];
|
|
|
|
public:
|
|
explicit AiqCameraHalAdapter();
|
|
virtual ~AiqCameraHalAdapter();
|
|
void init(const cl_result_callback_ops_t* callbacks);
|
|
void start();
|
|
void stop();
|
|
void deInit();
|
|
void processResults();
|
|
void syncSofToHal(rk_aiq_metas_t* metas);
|
|
void processResultsDebug(SmartPtr<RkAiqFullParamsProxy> &results);
|
|
XCamReturn getAeResults(rk_aiq_ae_results &ae_results);
|
|
void getAeResultsDebug(rk_aiq_ae_results &ae_results, SmartPtr<rk_aiq_exposure_params_wrapper_t> exp_param);
|
|
XCamReturn getAfResults(rk_aiq_af_results &af_results);
|
|
void getAfResultsDebug(rk_aiq_af_results &af_results, SmartPtr<rk_aiq_focus_params_t> focus_param);
|
|
XCamReturn getAwbResults(rk_aiq_awb_results &awb_results);
|
|
void getAwbResultsDebug(rk_aiq_awb_results &awb_results, SmartPtr<rk_aiq_isp_stats_t> isp_param);
|
|
void updateParams(SmartPtr<VideoBuffer>& ispStats);
|
|
void updateAeParams(XCamAeParam *aeParams);
|
|
void updateAwbParams(XCamAwbParam *awbParams);
|
|
void updateAfParams(XCamAfParam *afParams);
|
|
void setFrameParams(const struct rkisp_cl_frame_rkaiq_s* frame_params);
|
|
|
|
virtual XCamReturn metaCallback(rk_aiq_metas_t* metas);
|
|
|
|
SmartPtr<AiqInputParams> getAiqInputParams();
|
|
void set_aiq_ctx(rk_aiq_sys_ctx_t* aiq_ctx) { _aiq_ctx = aiq_ctx; };
|
|
rk_aiq_sys_ctx_t* get_aiq_ctx() { return _aiq_ctx; };
|
|
void set_static_metadata(const camera_metadata_t *metas) { staticMeta = metas; };
|
|
static CameraMetadata& get_static_metadata() { return staticMeta; };
|
|
XCamReturn set_control_params(const int request_frame_id,
|
|
const camera_metadata_t *metas);
|
|
void setAiqInputParams(SmartPtr<AiqInputParams> inputParams) { _inputParams = inputParams; };
|
|
SmartPtr<AiqInputParams> getAiqInputParams_simple() { return _inputParams; };
|
|
|
|
void updateMetaParams(SmartPtr<AiqInputParams> inputParams);
|
|
void updateAeMetaParams(XCamAeParam *aeParams, int reqId);
|
|
void updateAfMetaParams(XCamAfParam *afParams, int reqId);
|
|
void updateAwbV21MetaParams(XCamAwbParam *awbParams, int reqId);
|
|
void updateAwbV30MetaParams(XCamAwbParam *awbParams, int reqId);
|
|
void updateAwbV32MetaParams(XCamAwbParam *awbParams, int reqId);
|
|
void updateAwbMetaParams(XCamAwbParam *awbParams, int reqId);
|
|
void updateOtherMetaParams();
|
|
|
|
void pre_process_3A_states(SmartPtr<AiqInputParams> inputParams);
|
|
bool set_sensor_mode_data (rk_aiq_exposure_sensor_descriptor *sensor_mode,
|
|
bool first);
|
|
XCamReturn processAeMetaResults(rk_aiq_ae_results &ae_result, CameraMetadata *metadata);
|
|
XCamReturn processAfMetaResults(rk_aiq_af_results &af_result, CameraMetadata *metadata);
|
|
XCamReturn processAwbMetaResults(rk_aiq_awb_results &awb_result, CameraMetadata *metadata);
|
|
XCamReturn processMiscMetaResults(CameraMetadata *metadata);
|
|
void set_working_mode(rk_aiq_working_mode_t work_mode) { _work_mode = work_mode; };
|
|
};
|
|
//}; //namespace RkCam
|
|
|
|
|
|
#endif //_AIQ_CAMERA_HAL_ADAPTER_H_
|