| /* |
| * Copyright (C) 2015-2020 Intel 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. |
| */ |
| |
| #pragma once |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| #include <unordered_map> |
| |
| #include "iutils/Errors.h" |
| #include "iutils/Utils.h" |
| #include "CameraMetadata.h" |
| |
| #include "MakerNote.h" |
| #ifdef ENABLE_SANDBOXING |
| #include "modules/sandboxing/client/IntelLard.h" |
| #include "modules/sandboxing/client/IntelCmc.h" |
| #else |
| #include "modules/algowrapper/IntelLard.h" |
| #include "modules/algowrapper/IntelCmc.h" |
| #endif |
| |
| namespace icamera { |
| |
| #define NVM_DATA_PATH "/sys/bus/i2c/devices/" |
| |
| /** |
| * This class is intended to save/load AIQD data. |
| */ |
| class AiqdData |
| { |
| public: |
| AiqdData(TuningMode tuningMode, const std::string& sensorName); |
| ~AiqdData(); |
| |
| ia_binary_data* getAiqd(); |
| void saveAiqd(const ia_binary_data& data); |
| |
| private: |
| void loadAiqdFromFile(); |
| void saveAiqdToFile(); |
| |
| private: |
| std::string mAiqdFileName; |
| ia_binary_data mBinaryData; |
| std::unique_ptr<char[]> mDataPtr; |
| }; |
| |
| /** |
| * The IA data stored |
| */ |
| class CpfConf |
| { |
| public: |
| explicit CpfConf(ia_binary_data* nvmData); |
| virtual ~CpfConf(); |
| |
| /** |
| * \brief get CMC pointer |
| * |
| */ |
| ia_cmc_t* getCmc() const; |
| |
| /** |
| * \brief get CMC uintptr_t |
| * |
| */ |
| uintptr_t getCmcHandle() const; |
| |
| /** |
| * \brief get ISP data from CPF file |
| * |
| * \param[out] ia_binary_data* IspData: ISP data |
| */ |
| void getIspData(ia_binary_data* IspData); |
| |
| /** |
| * \brief get AIQ data from CPF file |
| * |
| * \param[out] ia_binary_data* AiqData: AIQ data |
| */ |
| void getAiqData(ia_binary_data* AiqData); |
| |
| /** |
| * \brief get others data from CPF file, including LTM data |
| * |
| * \param[out] ia_binary_data* otherData: others data |
| */ |
| void getOtherData(ia_binary_data* otherData); |
| |
| /** |
| * \brief parse CMC/ISP/AIQ/Others from the CPF data |
| * |
| * Parse the CMC/ISP/AIQ/Others data according to the tuning mode, and init |
| * the CMC handler. |
| * |
| * \param[in] ia_binary_data: CPF data loaded from the AIQB file |
| * \param[in] LardTagConfig: lard tag cfg |
| * |
| * \return OK if init successfully; otherwise non-0 value is returned. |
| */ |
| int init(const ia_binary_data& cpfData, const LardTagConfig* lardTagCfg); |
| |
| /** |
| * \brief deinit CMC handler. |
| */ |
| void deinit(); |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(CpfConf); |
| |
| void initLardInputParam(const ia_lard& iaLard, |
| const LardTagConfig* lardTagCfg, |
| ia_lard_input_params* lardInputParam); |
| bool isTagValid(unsigned int tag, unsigned int count, const unsigned int* tags); |
| |
| private: |
| IntelLard* mLard; |
| ia_binary_data* mNvmData; |
| std::unique_ptr<IntelCmc> mCmc; |
| ia_binary_data mAiq; |
| ia_binary_data mIsp; |
| ia_binary_data mOthers; |
| };//end CpfConf |
| |
| /** |
| * Camera Module Information |
| * |
| * Camera Module Information is gotten from the EEPROM, which needs to be programmed with |
| * an identification block located in the last 32 bytes of the EEPROM. |
| */ |
| struct CameraModuleInfo |
| { |
| char mOsInfo[4]; |
| uint16_t mCRC; |
| uint8_t mVersion; |
| uint8_t mLengthOfFields; |
| uint16_t mDataFormat; |
| uint16_t mModuleProduct; |
| char mModuleVendor[2]; |
| char mSensorVendor[2]; |
| uint16_t mSensorModel; |
| uint8_t mI2cAddress; |
| uint8_t mReserved[13]; |
| }; |
| #define CAMERA_MODULE_INFO_OFFSET 32 |
| #define CAMERA_MODULE_INFO_SIZE 32 |
| |
| /** |
| * CPF file operation class |
| */ |
| class CpfStore |
| { |
| public: |
| CpfStore(const std::string& sensorName, const std::string& camCfgDir, |
| const std::vector<TuningConfig>& tuningCfg, |
| const std::vector<LardTagConfig>& lardTagCfg, |
| const std::string& nvmPath, |
| std::unordered_map<std::string, std::string> camModuleToAiqbMap, |
| ia_binary_data* nvmData); |
| virtual ~CpfStore(); |
| |
| /** |
| * get Isp and Aiq data info |
| * |
| * \param ispData: return isp data of struct ia_binary_data |
| * \param aiqData: return aiq data of struct ia_binary_data |
| * \param otherData: return other data of struct ia_binary_data, such as tuning data for LTM |
| * \param cmcHandle: return cmc uintptr_t |
| * \param mode: Camera Mode |
| * \param cmcData: return cmc pointer |
| * \return NO_INIT if data not found, return OK if success. |
| */ |
| int getCpfAndCmc(ia_binary_data* ispData, |
| ia_binary_data* aiqData, |
| ia_binary_data* otherData, |
| uintptr_t* cmcHandle, |
| TuningMode mode = TUNING_MODE_VIDEO, |
| ia_cmc_t** cmcData = nullptr); |
| private: |
| DISALLOW_COPY_AND_ASSIGN(CpfStore); |
| |
| int getCameraModuleFromEEPROM(const std::string& nvmPath, std::string* cameraModule); |
| int findConfigFile(const std::string& camCfgDir, std::string* cpfPathName); |
| int loadConf(const std::string& camCfgDir, const std::string& aiqbName); |
| |
| public: |
| CpfConf* mCpfConfig[TUNING_MODE_MAX]; |
| std::map<std::string, ia_binary_data> mCpfData; |
| |
| };//end CpfStore |
| |
| /** |
| * This class ia a wrapper class which includes CPF data, AIQD data and NVM data. |
| */ |
| class AiqInitData { |
| public: |
| AiqInitData(const std::string& sensorName, |
| const std::string& camCfgDir, |
| const std::vector<TuningConfig>& tuningCfg, |
| const std::vector<LardTagConfig>& lardTagCfg, |
| const std::string& nvmDir, |
| int maxNvmSize, |
| const std::unordered_map<std::string, std::string>& camModuleToAiqbMap); |
| ~AiqInitData(); |
| |
| // cpf and cmc |
| int getCpfAndCmc(ia_binary_data* ispData, |
| ia_binary_data* aiqData, |
| ia_binary_data* otherData, |
| uintptr_t* cmcHandle, |
| TuningMode mode = TUNING_MODE_VIDEO, |
| ia_cmc_t** cmcData = nullptr); |
| |
| // aiqd |
| ia_binary_data* getAiqd(TuningMode mode); |
| void saveAiqd(TuningMode mode, const ia_binary_data& data); |
| |
| // nvm |
| ia_binary_data* getNvm(); |
| |
| // maker note |
| void* getMknHandle(void); |
| int saveMakernoteData(camera_makernote_mode_t makernoteMode, int64_t sequence); |
| void updateMakernoteTimeStamp(int64_t sequence, uint64_t timestamp); |
| void acquireMakernoteData(uint64_t timestamp, Parameters *param); |
| |
| private: |
| status_t loadNvm(); |
| |
| private: |
| std::string mSensorName; |
| std::string mCamCfgDir; |
| std::string mNvmPath; |
| int mMaxNvmSize; |
| std::vector<TuningConfig> mTuningCfg; |
| std::vector<LardTagConfig> mLardTagCfg; |
| CpfStore* mCpfStore; |
| |
| /* key: camera module info, value: aiqb name */ |
| std::unordered_map<std::string, std::string> mCameraModuleToAiqbMap; |
| |
| // NVM data |
| std::unique_ptr <char[]> mNvmDataBuf; |
| ia_binary_data mNvmData; |
| |
| std::unique_ptr<MakerNote> mMakerNote; |
| |
| std::map<TuningMode, AiqdData*> mAiqdDataMap; |
| }; |
| |
| } |