diff --git a/vendor/mediatek/proprietary/hardware/mtkcam/aaa/include/private/aaa_hal_private.h b/vendor/mediatek/proprietary/hardware/mtkcam/aaa/include/private/aaa_hal_private.h new file mode 100644 index 0000000..8663db3 --- /dev/null +++ b/vendor/mediatek/proprietary/hardware/mtkcam/aaa/include/private/aaa_hal_private.h @@ -0,0 +1,1103 @@ +/* Copyright Statement: +* +* This software/firmware and related documentation ("MediaTek Software") are +* protected under relevant copyright laws. The information contained herein is +* confidential and proprietary to MediaTek Inc. and/or its licensors. Without +* the prior written permission of MediaTek inc. and/or its licensors, any +* reproduction, modification, use or disclosure of MediaTek Software, and +* information contained herein, in whole or in part, shall be strictly +* prohibited. +* +* MediaTek Inc. (C) 2010. All rights reserved. +* +* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES +* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") +* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER +* ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL +* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR +* NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH +* RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, +* INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES +* TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. +* RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO +* OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK +* SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE +* RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR +* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S +* ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE +* RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE +* MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE +* CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. +* +* The following software/firmware and/or related documentation ("MediaTek +* Software") have been modified by MediaTek Inc. All revisions are subject to +* any receiver's applicable license agreements with MediaTek Inc. +*/ + +#ifndef _MTK_HARDWARE_MTKCAM_AAA_INCLUDE_PRIVATE_AAA_HAL_PRIVATE_H_ +#define _MTK_HARDWARE_MTKCAM_AAA_INCLUDE_PRIVATE_AAA_HAL_PRIVATE_H_ + +#include +#include + +#include +#include +#include "../../../common/hal/inc/camera_custom_ae.h" +//#include "mtkcam3/feature/3dnr/3dnr_isp_defs.h" +#include "../../../../mtkcam3/include/mtkcam3/feature/3dnr/3dnr_isp_defs.h" + +using namespace NSIspTuning; + +/****************************************************************************** + * + ******************************************************************************/ +#define HAL3A_SETBIT(a, mask, value) (a) = (((a) & ~(mask)) | ((value) & (mask))) + +#define HAL_FLG_DUMMY (1<<0) +#define HAL_FLG_DUMMY2 (1<<2) + +/****************************************************************************** + * + ******************************************************************************/ +namespace NS3Av3 +{ +typedef enum +{ + ESensorDevId_Main = 0x01, + ESensorDevId_Sub = 0x02, + ESensorDevId_MainSecond = 0x04, + ESensorDevId_Main3D = 0x05, + ESensorDevId_Atv = 0x08, +} ESensorDevId_T; + +#define SENSOR_IDX_MAX (20) +template +struct INST_T{ + std::once_flag onceFlag; + std::unique_ptr instance; +}; + +enum ESensorType_T { + ESensorType_RAW = 0, + ESensorType_YUV = 1 +}; + + +/** + * @brief 3A commands + */ +enum ECmd_T { + ECmd_CameraPreviewStart, + ECmd_CameraPreviewEnd, + ECmd_PrecaptureStart, + ECmd_PrecaptureEnd, + ECmd_CaptureStart, + ECmd_CaptureEnd, + ECmd_RecordingStart, + ECmd_RecordingEnd, + ECmd_Update, + ECmd_IntDummy, + ECmd_VideoDownSampling, + // internal command + ECmd_Init, + ECmd_Uninit, + ECmd_AFUpdate, // sync with AF done + ECmd_TouchAEStart, + ECmd_TouchAEEnd, + ECmd_AFStart, + ECmd_AFEnd, + ECmd_AFTrigger, + ECmd_Sync3AStart, + ECmd_Sync3AEnd + +}; + + +enum EQueryType_T{ + EQueryType_Init, + EQueryType_Effect, + EQueryType_AWB, + EQueryType_AF, + EQueryType_Ev, + EQueryType_Sat, + EQueryType_Bright, + EQueryType_Contrast +}; + + +enum E3ACaptureMode_T +{ + ECapMode_P2_Cal = (1<<0), + ECapMode_P2_Set = (1<<1) +}; + + +enum E3APreviewMode_T +{ + EPv_Normal = 0, + EPv_Video +}; + + +enum ECaptureType_T +{ + ECapType_SingleCapture = 0, + ECapType_MultiCapture +}; + + +enum ESubFrameCount_T +{ + ESubFrameCnt_Normal = 1, + ESubFrameCnt_SMVRx4_fps = 4, + ESubFrameCnt_SMVRx8_fps = 8, +}; + + +typedef struct +{ + MINT64 iYvalue; + MINT32 i4ISO; + MINT32 i4IsAEStable; + MINT32 i4SceneLV; + MINT32 ishutterValue; + MINT32 i4DeltaBV; + MUINT8 aeBlockV[25]; + MINT32 i4IsFlashFrm; + MINT32 i4AEBlockAreaYCnt; + MUINT8 *pAEBlockAreaYvalue; + MINT32 i4IsAELocked; +} AE2AFInfo_T; + +typedef struct +{ + MUINT64 TS_AFDone; // Time stamp of AFDone of the current frame +} AdptCompTimeData_T; +struct CameraArea_T +{ + MINT32 i4Left; + MINT32 i4Top; + MINT32 i4Right; + MINT32 i4Bottom; + MINT32 i4Weight; + CameraArea_T() + : i4Left(0) + , i4Top(0) + , i4Right(0) + , i4Bottom(0) + , i4Weight(0) + {} +}; + +#define MAX_FOCUS_AREAS 9 + +struct CameraFocusArea_T +{ + CameraArea_T rAreas[MAX_FOCUS_AREAS]; + MUINT32 u4Count; + CameraFocusArea_T() + : u4Count(0) + {} +}; + + +struct ISP_SENSOR_INFO_T +{ + MBOOL bHLREnable; + MBOOL bAEStable; + MBOOL bAELock; + MBOOL bAEScenarioChange; + MINT32 i4FrameId; + MINT32 i4deltaIndex; + MUINT32 u4AfeGain; + MUINT32 u4IspGain; + MUINT32 u4Eposuretime; //!<: Exposure time in ms + MUINT32 u4RealISOValue; + MUINT32 u4MaxISO; + MUINT32 u4OrgExposuretime; //!<: Exposure time in ms + MUINT32 u4OrgRealISOValue; + MUINT32 u4AEStableCnt; + MUINT32 u4AEFinerEVIdxBase; + MUINT32 u4AEidxCurrentF; + MINT32 i4LightValue_x10; // sceneLV + MUINT32 u4MgrCWValue; // central weighting Y value + MINT32 i4AeBlockV[25]; + ISP_SENSOR_INFO_T() + : bHLREnable(0) + , bAEStable(0) + , bAELock(0) + , bAEScenarioChange(0) + , i4FrameId(0) + , i4deltaIndex(0) + , u4AfeGain(0) + , u4IspGain(0) + , u4Eposuretime(0) + , u4RealISOValue(0) + , u4MaxISO(0) + , u4OrgExposuretime(0) + , u4OrgRealISOValue(0) + , u4AEStableCnt(0) + , u4AEFinerEVIdxBase(0) + , u4AEidxCurrentF(0) + , i4LightValue_x10(0) + , u4MgrCWValue(0) + { + memset(i4AeBlockV, 0, sizeof(MINT32)*25); + } +}; + +struct AF2AEInfo_T +{ + MINT32 i4MagicNum; + MINT32 i4IsAFDone; + MINT32 i4AfDac; + MINT32 i4IsSceneStable; + AF2AEInfo_T() + : i4MagicNum(0) + , i4IsAFDone(0) + , i4AfDac(0) + , i4IsSceneStable(0) + {} +}; + + +struct Hal3A_HDROutputParam_T +{ + MUINT32 u4OutputFrameNum; // Output frame number (2 or 3) + MUINT32 u4FinalGainDiff[2]; // 1x=1024; [0]: Between short exposure and 0EV; [1]: Between 0EV and long exposure + MUINT32 u4TargetTone; //Decide the curve to decide target tone +}; + +struct ScaleCropedArea_T { + MINT32 i4Xoffset; + MINT32 i4Yoffset; + MINT32 i4Xwidth; + MINT32 i4Yheight; + ScaleCropedArea_T() + : i4Xoffset(0) + , i4Yoffset(0) + , i4Xwidth(0) + , i4Yheight(0) + {} +}; + +#define MAX_METERING_AREAS 9 + +struct CameraMeteringArea_T { + CameraArea_T rAreas[MAX_METERING_AREAS]; + MUINT32 u4Count; + CameraMeteringArea_T() + : u4Count(0) + {} +}; + + +// LCE Info +struct LCEInfo_T { + MINT32 i4NormalAEidx; // gain >= 4x AE Pline table index at 30fps + MINT32 i4LowlightAEidx; // gain max AE Pline table index at 30fps + MINT32 i4AEidxCur; // AE current frame Pline table index + MINT32 i4AEidxNext; // AE next frame Pline table index + MINT32 i4AEidxNextF; // AE next frame Pline table indexF +}; + + +typedef enum +{ + E_AE_PRECAPTURE_IDLE, + E_AE_PRECAPTURE_START +} EAePreCapture_T; + + +struct SMVR_GAIN_DELAY_T { + MUINT32 u4SensorGain_Delay; + MUINT32 u4SutterGain_Delay; + MUINT32 u4ISPGain_Delay; + + SMVR_GAIN_DELAY_T() + : u4SensorGain_Delay(0) + , u4SutterGain_Delay(0) + , u4ISPGain_Delay(0) + {} +}; + +/** + * @brief ISP parameters + */ +// ISP P1 parameters +struct P1Param_T { + // config part + MUINT32 u4ISPRawWidth; + MUINT32 u4ISPRawHeight; + MUINT32 ERawPath; + MUINT32 u4P1DirectYUV_Port; + MBOOL bYUVafterRRZ; + // set P1 isp part + MUINT8 u1CapIntent; + MUINT8 u1ColorCorrectMode; + MUINT8 u1IspProfile; + MINT32 i4Stage; + MINT8 i1ControlMode; + MINT8 i1EffectMode; + MINT8 i1SceneMode; + MINT8 i1EdgeMode; + MINT8 i1NRMode; + MINT8 i1ColorCorrectMode; + MBOOL fgColorCorrectModeIsSet; + MFLOAT fColorCorrectMat[9]; + MBOOL bIMGO_RawType; + MINT32 i4RequestNumber; + const MVOID *pAEResultInfo; + const MVOID *pAWBResultInfo; + const MVOID *pHALResult; + MBOOL fgFdEnable; + MINT32 i4ZoomRatio; + MBOOL bSync2AMode; + MBOOL bSlave_P1; + // tonemap + MUINT8 u1TonemapMode; + MBOOL fgIsThisFrameSkip; + MINT32 i4LatestUnSkippedMagic; + MINT32 i4FUS_Effective_Num; + MINT32 i4HWHDRMode; + MINT32 i4HDR10Mode; + MBOOL bEnableDownSampling; + + P1Param_T() + : u4ISPRawWidth(1000) + , u4ISPRawHeight(1000) + , ERawPath(0) + , u4P1DirectYUV_Port(0) + , bYUVafterRRZ(MFALSE) + , u1CapIntent(MTK_CONTROL_CAPTURE_INTENT_PREVIEW) + , u1ColorCorrectMode(MTK_COLOR_CORRECTION_MODE_FAST) + , u1IspProfile(0xFF) + , i4Stage(0) + , i1ControlMode(-1) + , i1EffectMode(-1) + , i1SceneMode(-1) + , i1EdgeMode(-1) + , i1NRMode(-1) + , i1ColorCorrectMode(-1) + , fgColorCorrectModeIsSet(MFALSE) + , bIMGO_RawType(MTRUE) + , i4RequestNumber(0) + , pAEResultInfo(NULL) + , pAWBResultInfo(NULL) + , pHALResult(NULL) + , fgFdEnable(MFALSE) + , i4ZoomRatio(1) + , bSync2AMode(MFALSE) + , bSlave_P1(MFALSE) + , u1TonemapMode(MTK_TONEMAP_MODE_FAST) + , fgIsThisFrameSkip(MFALSE) + , i4LatestUnSkippedMagic(-1) + , i4FUS_Effective_Num(0) + , i4HWHDRMode(0) + , i4HDR10Mode(0) + , bEnableDownSampling(MFALSE) + { + memset(fColorCorrectMat, 0, sizeof(MFLOAT)*9); + } +}; +/** + * @brief ISP parameters + */ +// ISP P1 Get parameters +struct P1GetParam_T { + MUINT32 frmId; + const MVOID *pISPResult; + const MVOID *pLCSOResult; + const MVOID *pCCUResult; + //AAA_DEBUG_INFO2_T& rDbg3AInfo2; + MVOID *pDbg3AInfo2; + P1GetParam_T() + : frmId(0) + , pISPResult(NULL) + , pLCSOResult(NULL) + , pCCUResult(NULL) + , pDbg3AInfo2(NULL) + { + } +}; + +/** + * @brief 3A parameters + */ +// 3A parameters +struct Param_T { + // DEFAULT DEFINITION CATEGORY ( ordered by SDK ) + MINT32 i4MagicNum; + MINT32 i4MagicNumCur; + MINT32 i4PresetKey; + MINT32 i4FrameNum; + MUINT32 u4HalFlag; + MUINT8 u1ControlMode; + MUINT8 u1PrecapTrig; + MUINT8 u1AfTrig; + MINT32 i4MinFps; + MINT32 i4MaxFps; + MUINT32 u4AeMode; + MUINT8 u1HdrMode; + MUINT8 u1AppHdrMode; + MUINT32 u4AwbMode; + MINT32 i4MWBColorTemperature; //ex. 3000, 3200, 4000, 6500... 5000 means 5000k. + MUINT32 u4EffectMode; + MUINT32 u4AntiBandingMode; + MUINT32 u4SceneMode; + MUINT32 u4StrobeMode; + MINT32 i4ExpIndex; + MFLOAT fExpCompStep; + + // NEWLY-ADDED CATEGORY + MUINT32 u4CamMode; //Factory, ENG, normal + MUINT32 u4ShotMode; + MUINT32 u4CapType; //refer to ECaptureType_T + + // MTK DEFINITION CATEGORY + MINT32 i4IsoSpeedMode; + MINT32 i4BrightnessMode; + MINT32 i4HueMode; + MINT32 i4SaturationMode; + MINT32 i4ContrastMode; + MINT32 i4EdgeMode; + MUINT32 u4AeMeterMode; + MINT32 i4RotateDegree; + + //EAePreCapture_T eAePreCapture; + //MBOOL bHistogramMode; + MBOOL bIsAELock; + MBOOL bIsAWBLock; + + // flash for engineer mode + MINT32 i4PreFlashDuty; + MINT32 i4PreFlashStep; + MINT32 i4MainFlashDuty; + MINT32 i4MainFlashStep; + + // shading + MUINT8 u1ShadingMode; + MUINT8 u1ShadingMapMode; + MUINT8 u1ShadingMapXGrid; + MUINT8 u1ShadingMapYGrid; + + // manual sensor + MINT64 i8FrameDuration; // naro sec + MINT64 i8ExposureTime; // naro sec + MINT32 i4Sensitivity; // ISO value + MUINT8 u1BlackLvlLock; + MUINT8 u1RollingShutterSkew; + + // color correction + MUINT8 u1ColorCorrectMode; + MFLOAT fColorCorrectGain[4]; + MFLOAT fColorCorrectMat[9]; + + // edge & NR + MUINT8 u1EdgeMode; + MUINT8 u1NRMode; + + // tonemap + MUINT8 u1TonemapMode; + std::vector vecTonemapCurveBlue; + std::vector vecTonemapCurveGreen; + std::vector vecTonemapCurveRed; + + MINT32 i4RawType; + MUINT8 u1CaptureIntent; + MINT32 i4Cshot; + MUINT8 u1ZSDCaptureIntent; + MUINT8 u1IsGetExif; + MBOOL u1HQCapEnable; + MBOOL i4DisableP1; // Store Request.fgDisableP1 + MUINT8 u1IsSingleFrameHDR; + MUINT8 u1IsStartCapture; + MBOOL u1AeFakePreCap; + NSIspTuning::EIspProfile_T eIspProfile; + MINT32 i4DenoiseMode; + NSCam::IMetadata::Memory rcapParams; + CameraMeteringArea_T rMeteringAreas; + ScaleCropedArea_T rScaleCropRect; + MINT32 i4ZoomRatio; + MINT32 i4ForceFace3A; + MUINT8 u1FaceDetectMode; + MBOOL bDummyBeforeCapture; + MBOOL bDummyAfterCapture; + MUINT8 u1PreCapStart; + MUINT32 u4AFNVRAMIndex; + MINT32 i4AwbValue; + MUINT8 u1RemosaicEn; + MBOOL bIsDualCamWithCamSv; + MINT32 i4FlashCalEn; // flash calibration enable + MINT32 i4DynamicSubsampleCount; + AE_Cust_Param_T rAeCustParam; + Custom_AE_Setting_Param_T rAeCustSettingParam; + MINT64 i8ExposureTimeDummy; + MINT64 i8FrameDurationDummy; + MINT32 i4SensitivityDummy; + MBOOL bIsDummyFrame; + MBOOL bIsFDReady; + NSCam::MSize targetSize; + MBOOL u1SubFlashCustomization; + MUINT8 u1TorchDuty; + MBOOL bByPassStt; + MUINT8 u1Dummy; + MINT32 i4MultiExpHDRMode; + MINT32 i4AEExpLevel; + NSCam::MSize sResolution; + MINT32 i4Streamingfps; + MINT32 i4AETargetMode; + MINT32 i4APPMode; + MINT32 i4ManualPlineIdx; + MINT32 i4CustomPlineMode; + MBOOL bIsAIShutterNeeded; + MINT32 i4InSensorZoomMode; + MINT32 i4AEValidExp; + MINT32 i4HDR10Mode; + MBOOL bIsUseAEThread; + + Param_T() + : i4MagicNum(0) + , i4MagicNumCur(0) + , i4PresetKey(0) + , i4FrameNum(0) + , u4HalFlag(0) + , u1ControlMode(MTK_CONTROL_MODE_AUTO) + , u1PrecapTrig(MTK_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE) + , u1AfTrig(MTK_CONTROL_AF_TRIGGER_IDLE) + , i4MinFps(5000) + , i4MaxFps(30000) + , u4AeMode(1) + , u1HdrMode(0) + , u1AppHdrMode(0) + , u4AwbMode(1) + , i4MWBColorTemperature(0) + , u4EffectMode(0) + , u4AntiBandingMode(0) + , u4SceneMode(0) + , u4StrobeMode(0) + , i4ExpIndex(0) + , fExpCompStep(5) + // + , u4CamMode(5) //eAppMode_PhotoMode + , u4ShotMode(0) + , u4CapType(ECapType_SingleCapture) + // + , i4IsoSpeedMode(0) + , i4BrightnessMode(1) + , i4HueMode(1) + , i4SaturationMode(1) + , i4ContrastMode(1) + , i4EdgeMode(1) + , u4AeMeterMode (0) + , i4RotateDegree(0) + // + , bIsAELock(MFALSE) + , bIsAWBLock(MFALSE) + // + , i4PreFlashDuty(-1) + , i4PreFlashStep(-1) + , i4MainFlashDuty(-1) + , i4MainFlashStep(-1) + // + , u1ShadingMode(MTK_SHADING_MODE_FAST) + , u1ShadingMapMode(MTK_STATISTICS_LENS_SHADING_MAP_MODE_OFF) + , u1ShadingMapXGrid(1) + , u1ShadingMapYGrid(1) + // + , i8FrameDuration(0) + , i8ExposureTime(0) + , i4Sensitivity(0) + , u1BlackLvlLock(MTK_BLACK_LEVEL_LOCK_OFF) + , u1RollingShutterSkew(0) + , u1ColorCorrectMode(MTK_COLOR_CORRECTION_MODE_FAST) + // + , u1EdgeMode(MTK_EDGE_MODE_FAST) + , u1NRMode(MTK_NOISE_REDUCTION_MODE_FAST) + , u1TonemapMode(MTK_TONEMAP_MODE_FAST) + // + , i4RawType(NSIspTuning::ERawType_Proc) + , u1CaptureIntent(MTK_CONTROL_CAPTURE_INTENT_PREVIEW) + , i4Cshot(MTK_CSHOT_FEATURE_CAPTURE_OFF) + , u1ZSDCaptureIntent(MTK_CONTROL_CAPTURE_INTENT_PREVIEW) + , u1IsGetExif(0) + , u1HQCapEnable(MFALSE) + , i4DisableP1(MFALSE) + , u1IsSingleFrameHDR(0) + , u1IsStartCapture(MFALSE) + , u1AeFakePreCap(MFALSE) + , eIspProfile(NSIspTuning::EIspProfile_Preview) + , i4DenoiseMode(0) + , i4ZoomRatio(100) + , i4ForceFace3A(0) + , u1FaceDetectMode(0) + , bDummyBeforeCapture(MFALSE) + , bDummyAfterCapture(MFALSE) + , u1PreCapStart(0) + , u4AFNVRAMIndex(0) + , i4AwbValue(0) + , u1RemosaicEn(0) + , bIsDualCamWithCamSv(0) + , i4FlashCalEn(0) + , i4DynamicSubsampleCount(1) + , rAeCustSettingParam() + , i8ExposureTimeDummy(0) + , i8FrameDurationDummy(0) + , i4SensitivityDummy(0) + , bIsDummyFrame(0) + , bIsFDReady(MTRUE) + , targetSize(0,0) + , u1SubFlashCustomization(0) + , u1TorchDuty(1) // Torch default level + , bByPassStt(0) + , u1Dummy(0) + , i4MultiExpHDRMode(0) + , i4AEExpLevel(MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_NONE) + , sResolution() + , i4Streamingfps(0) + , i4AETargetMode(0) + , i4APPMode(0) + , i4ManualPlineIdx(0) + , i4CustomPlineMode(0) + , bIsAIShutterNeeded(MFALSE) + , i4InSensorZoomMode(MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE_OFF) + , i4AEValidExp(MTK_STAGGER_VALID_EXPOSURE_NON) + , i4HDR10Mode(MTK_STREAMING_FEATURE_HDR10_OFF) + , bIsUseAEThread(1) + {} +}; + + +/** + * @brief 3A parameters + */ +// 3A P2 parameters +struct P2Param_T { + MUINT8 u1PGN; + MUINT8 u1Exif; + MUINT8 u1DumpExif; + MUINT8 u1RepeatResult; + MUINT8 u1IspProfile; + MINT32 i4Stage; + MUINT8 u1CapIntent; + MUINT8 u1appEdgeMode; //Android ISP Spec + MUINT8 u1NrMode; + MBOOL bBypassLCE; + const NSCam::NR3D::NR3DIspParam *pNR3DBuf; + MBOOL bBypassNR; + MBOOL bEnableNDD; + MINT32 i4HLR_P2_FakeRatio; + MINT32 i4P2InImgFmt; + MUINT8 u1P2TuningUpdate; + MINT32 i4UniqueKey; + MINT32 i4RawType; + MINT32 i4FrmNo; + MINT32 i4ReqNo; + MINT32 i4ISO; + MINT32 NR3D_Data[14]; + MINT32 ResizeYUV; + const NSCam::MRect *rpSclCropRect; + const NSCam::MRect *rpP1Crop; + const NSCam::MRect *rpP2Crop; + const NSCam::MSize *rpRzInSize; + const NSCam::MSize *rpRzSize; + const NSCam::MSize *rpP2OriginSize; + const NSCam::MSize *rpP2RzSize; + NSCam::IMetadata rexifMeta; // Need to update & write back to ResultP2, cannot be declared as pointer to indicate constanct control Metadata + const NSCam::IMetadata::Memory *rpdbgIsp; + const NSCam::IMetadata::Memory *rpLscData; + const NSCam::IMetadata::Memory *rpTsfData; + const NSCam::IMetadata::Memory *rpTsfDumpNo; + + MINT32 i4MagicNum; + MINT32 i4EdgeMode; + MINT32 i4halEdgeMode; //MTK Internal APP User Select Level before ISP 6.0 + MUINT8 u1TonemapMode; + const MFLOAT * pTonemapCurveRed; + const MFLOAT * pTonemapCurveBlue; + const MFLOAT * pTonemapCurveGreen; + MUINT32 u4TonemapCurveRedSize; + MUINT32 u4TonemapCurveGreenSize; + MUINT32 u4TonemapCurveBlueSize; + + MINT32 i4BrightnessMode; + MINT32 i4ContrastMode; + MINT32 i4HueMode; + MINT32 i4SaturationMode; + MINT32 i4DenoiseMode; + ScaleCropedArea_T rScaleCropRect; + MUINT8 u1ControlMode; + NSCam::MSize targetSize; + MINT32 i4ScaleIndex; + MINT32 i4ScaleFrmNo; + MINT32 i4TotalMulitiFrmNum; + MINT32 i4TotalMulitiFrmNumCaptured; + MINT32 i4P2ProcessedRaw; + MINT32 i4DsdnVersion; + MINT32 i4AinrMdlaMode; + MINT32 i4LtmBitMode; + + P2Param_T() + : u1PGN(0) + , u1Exif(0) + , u1DumpExif(0) + , u1RepeatResult(0) + , u1IspProfile(255) + , i4Stage(0) + , u1CapIntent(MTK_CONTROL_CAPTURE_INTENT_PREVIEW) + , u1appEdgeMode(1) + , u1NrMode(0) + , bBypassLCE(0) + , pNR3DBuf(NULL) + , bBypassNR(0) + , bEnableNDD(0) + , i4HLR_P2_FakeRatio(0) + , i4P2InImgFmt(0) + , u1P2TuningUpdate(0) + , i4UniqueKey(0) + , i4RawType(NSIspTuning::ERawType_Proc) + , i4FrmNo(0) + , i4ReqNo(0) + , i4ISO(0) + , NR3D_Data() + , ResizeYUV(0) + , rpSclCropRect(NULL) + , rpP1Crop(NULL) + , rpP2Crop(NULL) + , rpRzInSize(NULL) + , rpRzSize(NULL) + , rpP2OriginSize(NULL) + , rpP2RzSize(NULL) + , rexifMeta() + , rpdbgIsp(NULL) + , rpLscData(NULL) + , rpTsfData(NULL) + , rpTsfDumpNo(NULL) + , i4MagicNum(0) + , i4EdgeMode(1) + , i4halEdgeMode(0) + , u1TonemapMode(MTK_TONEMAP_MODE_FAST) + , pTonemapCurveRed(NULL) + , pTonemapCurveBlue(NULL) + , pTonemapCurveGreen(NULL) + , u4TonemapCurveRedSize(1) + , u4TonemapCurveGreenSize(1) + , u4TonemapCurveBlueSize(1) + , i4BrightnessMode(1) + , i4ContrastMode(1) + , i4HueMode(1) + , i4SaturationMode(1) + , i4DenoiseMode(0) + , u1ControlMode(MTK_CONTROL_MODE_AUTO) + , targetSize(0,0) + , i4ScaleIndex(-1) + , i4ScaleFrmNo(-1) + , i4TotalMulitiFrmNum(1) + , i4TotalMulitiFrmNumCaptured(-1) + , i4P2ProcessedRaw(0) + , i4DsdnVersion(0) + , i4AinrMdlaMode(0) + , i4LtmBitMode(12) + {} +}; + + +/** + * @brief AF parameters + */ +// AF parameters +struct AF_Param_T { + + MINT32 i4MagicNum; /* request magic number */ + MINT32 i4MagicNumCur; /* statistic magic number */ + MUINT32 u4AfMode; + MFLOAT fFocusDistance; + MBOOL bEnable3ASetParams; + MUINT8 u1PrecapTrig; + MUINT8 u1AfTrig; + MUINT8 u1AfPause; + MUINT8 u1MZOn; + MUINT8 u1CaptureIntent; + MUINT8 u1ZSDCaptureIntent; + MUINT8 u1isTouched; + CameraFocusArea_T rFocusAreas; + CameraArea_T rScaleCropArea; + MUINT8 u1AfTrigStart; + MUINT8 u1MTKCaptureHint; + MINT32 i4MultiExpHDRMode; + MINT32 i4AEExpLevel; + MINT32 i4MaxFps; + MINT32 i4SubsampleCount; + MINT32 i4AEValidExp; + + AF_Param_T() + : i4MagicNum(0) + , i4MagicNumCur(0) + , u4AfMode(5) + , fFocusDistance(-1) + , bEnable3ASetParams(MTRUE) + , u1PrecapTrig(MTK_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE) + , u1AfTrig(0) + , u1AfPause(0) + , u1MZOn(255) + , u1CaptureIntent(0) + , u1ZSDCaptureIntent(0) + , u1isTouched(MFALSE) + , rFocusAreas() + , rScaleCropArea() + , u1AfTrigStart(0) + , u1MTKCaptureHint(0) + , i4MultiExpHDRMode(0) + , i4AEExpLevel(MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_NONE) + , i4MaxFps(30000) + , i4SubsampleCount(1) + , i4AEValidExp(MTK_STAGGER_VALID_EXPOSURE_NON) + {} +}; + + +struct ParamIspProfile_T +{ + EIspProfile_T eIspProfile; + MINT32 i4MagicNum; + MINT32 i4MagicNumCur; + MINT32 iEnableRPG; + MINT32 iValidateOpt; + MBOOL bMainFlash; + RequestSet_T rRequestSet; + enum + { + EParamValidate_None = 0, + EParamValidate_All = 1, + EParamValidate_P2Only = 2 + }; + + ParamIspProfile_T() + : eIspProfile(EIspProfile_Preview) + , i4MagicNum(0) + , i4MagicNumCur(0) + , iEnableRPG(0) + , iValidateOpt(1) + , bMainFlash(MFALSE) + , rRequestSet() + {} + + ParamIspProfile_T( + EIspProfile_T eIspProfile_, + MINT32 i4MagicNum_, + MINT32 i4MagicNumCur_, + MINT32 iEnableRPG_, + MINT32 iValidateOpt_, + RequestSet_T rRequestSet_) + : eIspProfile(eIspProfile_) + , i4MagicNum(i4MagicNum_) + , i4MagicNumCur(i4MagicNumCur_) + , iEnableRPG(iEnableRPG_) + , iValidateOpt(iValidateOpt_) + , bMainFlash(MFALSE) + , rRequestSet(rRequestSet_) + {} +}; + + +enum E_Repeat_Result { + E_Repeat_OFF = 0, + E_Repeat_ON = 1 +}; + + +struct E3ACtrl_ConvertToIspGamma_ARG_T +{ + MUINT32 u4NumPts; + const MFLOAT* pPtPairs; + MINT32* pOutGMA; + + E3ACtrl_ConvertToIspGamma_ARG_T() + : u4NumPts(0) + , pPtPairs(NULL) + , pOutGMA(NULL) + {} + + E3ACtrl_ConvertToIspGamma_ARG_T(const MFLOAT* _pPtPairs, MUINT32 _u4NumPts, MINT32* _pOutGMA) + : u4NumPts(_u4NumPts) + , pPtPairs(_pPtPairs) + , pOutGMA(_pOutGMA) + {} +}; + +struct GyroSensor_Param_T { + MINT32 i4AcceInfo[3]; + MINT32 i4GyroInfo[3]; + MUINT64 u8AcceTS; + MUINT64 u8GyroTS; + + GyroSensor_Param_T() + : u8AcceTS(0) + , u8GyroTS(0) + { + i4AcceInfo[0] = i4AcceInfo[1] = i4AcceInfo[2] = 0; + i4GyroInfo[0] = i4GyroInfo[1] = i4GyroInfo[2] = 0; + } +}; + +struct AWB_AAO_CONFIG_Param_T +{ + MUINT32 width; + MUINT32 height; + MUINT32 offset_x; + MUINT32 offset_y; + MUINT32 size_x; + MUINT32 size_y; + MUINT32 num_x; + MUINT32 num_y; + + AWB_AAO_CONFIG_Param_T() + : width(0) + , height(0) + , offset_x(0) + , offset_y(0) + , size_x(0) + , size_y(0) + , num_x(0) + , num_y(0) + {} +}; + +struct Query_3A_Index_T +{ + MUINT32 u4AENVRAMIndex; + MUINT32 u4AWBNVRAMIndex; + MUINT32 u4AFNVRAMIndex; + MUINT32 u4FlashAENVRAMIndex; + MUINT32 u4FlashAWBNVRAMIndex; + MUINT32 u4FlashCaliNVRAMIndex; + MUINT32 u4OBCNVRAMIndex; + MUINT32 u4LTMNVRAMIndex; + + Query_3A_Index_T() + : u4AENVRAMIndex(0) + , u4AWBNVRAMIndex(0) + , u4AFNVRAMIndex(0) + , u4FlashAENVRAMIndex(0) + , u4FlashAWBNVRAMIndex(0) + , u4FlashCaliNVRAMIndex(0) + , u4OBCNVRAMIndex(0) + , u4LTMNVRAMIndex(0) + {} +}; + +struct STT_CFG_INFO_T +{ + MINT32 i4TgInfo; + std::vector vecCAMSVIndexOf3EXPO; //This is for 3EXPO flow + + STT_CFG_INFO_T() + : i4TgInfo(0) + { + vecCAMSVIndexOf3EXPO.clear(); + } +}; + +struct AE_PARAM_SET_INFO { + MINT32 i4NDDTimeStamp; + MINT32 i4NDDFrameNum; + MINT32 i4NDDRequestNum; + MBOOL bIsAELock; + MBOOL bBlackLvlLock; + MINT32 i4MinFps; + MINT32 i4MaxFps; + MUINT32 u4AeMeterMode; + MINT32 i4RotateDegree; + MINT32 i4IsoSpeedMode; + MINT32 i4ExpIndex; + MFLOAT fExpCompStep; + MUINT32 u4AeMode; + MINT32 i4DenoiseMode; + MUINT32 u4AntiBandingMode; + MUINT32 u4CamMode; + MUINT32 u4ShotMode; + MUINT32 u4SceneMode; + MUINT8 u1HdrMode; + MUINT8 u1AppHdrMode; + MINT32 i4ZoomRatio; + CameraMeteringArea_T rMeteringAreas; + MUINT32 u4ZoomXOffset; + MUINT32 u4ZoomYOffset; + MUINT32 u4ZoomWidth; + MUINT32 u4ZoomHeight; + MUINT8 u1IsDummyFrame; + MINT32 i4MStreamHDRMode; + MINT32 i4AEExpLevel; + MBOOL bDummyAfterCapture; + MINT32 i4AETargetMode; + MINT32 i4APPMode; + MINT32 i4ManualPlineIdx; + MINT32 i4CustomPlineMode; + MUINT32 u4AEAutoFLKMode; + MBOOL bFlickerFPSActive; + MINT32 i4Flicker50Score; + MINT32 i4Flicker60Score; + MBOOL bFlickerScoreActive; + MINT32 i4InSensorZoomMode; + MINT32 i4AEValidExp; + + AE_PARAM_SET_INFO() + : i4NDDTimeStamp(0) + ,i4NDDFrameNum(0) + ,i4NDDRequestNum(0) + ,bIsAELock(MFALSE) + , bBlackLvlLock(MTK_BLACK_LEVEL_LOCK_OFF) + , i4MinFps(5000) + , i4MaxFps(30000) + , u4AeMeterMode (0) + , i4RotateDegree(0) + , i4IsoSpeedMode(0) + , i4ExpIndex(0) + , fExpCompStep(5) + , u4AeMode(1) + , i4DenoiseMode(0) + , u4AntiBandingMode(0) + , u4CamMode(5) //eAppMode_PhotoMode + , u4ShotMode(0) + , u4SceneMode(0) + , u1HdrMode(0) + , u1AppHdrMode(0) + , i4ZoomRatio(100) + , u4ZoomXOffset(0) + , u4ZoomYOffset(0) + , u4ZoomWidth(0) + , u4ZoomHeight(0) + , u1IsDummyFrame(0) + , i4MStreamHDRMode(0) + , i4AEExpLevel(MTK_3A_FEATURE_AE_EXPOSURE_LEVEL_NONE) + , bDummyAfterCapture(MFALSE) + , i4AETargetMode(0) + , i4APPMode(0) + , i4ManualPlineIdx(0) + , i4CustomPlineMode(0) + , u4AEAutoFLKMode(0) + , bFlickerFPSActive(MFALSE) + , i4Flicker50Score(0) + , i4Flicker60Score(0) + , bFlickerScoreActive(0) + , i4InSensorZoomMode(MTK_CONTROL_CAPTURE_INSENSORZOOM_MODE_OFF) + , i4AEValidExp(MTK_STAGGER_VALID_EXPOSURE_NON) + {} +}; + +struct AE_STATIC_PARAM { + MFLOAT fFNum; + MFLOAT fFocalLength; + + AE_STATIC_PARAM() + : fFNum(0.0) + , fFocalLength(0.0) + {} +}; + +} //namespace NS3Av3 +/****************************************************************************** + * + ******************************************************************************/ +#endif //_MTK_HARDWARE_MTKCAM_AAA_INCLUDE_PRIVATE_AAA_HAL_PRIVATE_H_ diff --git a/vendor/mediatek/proprietary/hardware/mtkcam/legacy/include/mtkcam/hal/aaa_hal_base.h b/vendor/mediatek/proprietary/hardware/mtkcam/legacy/include/mtkcam/hal/aaa_hal_base.h new file mode 100644 index 0000000..26a3898 --- /dev/null +++ b/vendor/mediatek/proprietary/hardware/mtkcam/legacy/include/mtkcam/hal/aaa_hal_base.h @@ -0,0 +1,766 @@ +/* Copyright Statement: + * + * This software/firmware and related documentation ("MediaTek Software") are + * protected under relevant copyright laws. The information contained herein + * is confidential and proprietary to MediaTek Inc. and/or its licensors. + * Without the prior written permission of MediaTek inc. and/or its licensors, + * any reproduction, modification, use or disclosure of MediaTek Software, + * and information contained herein, in whole or in part, shall be strictly prohibited. + */ +/* MediaTek Inc. (C) 2010. All rights reserved. + * + * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") + * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON + * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. + * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE + * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR + * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH + * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES + * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES + * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK + * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR + * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND + * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, + * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, + * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO + * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. + * + * The following software/firmware and/or related documentation ("MediaTek Software") + * have been modified by MediaTek Inc. All revisions are subject to any receiver's + * applicable license agreements with MediaTek Inc. + */ + +/******************************************************************************************** + * LEGAL DISCLAIMER + * + * (Header of MediaTek Software/Firmware Release or Documentation) + * + * BY OPENING OR USING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES + * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") RECEIVED + * FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON AN "AS-IS" BASIS + * ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR + * A PARTICULAR PURPOSE OR NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY + * WHATSOEVER WITH RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, + * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK + * ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO + * NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S SPECIFICATION + * OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM. + * + * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE LIABILITY WITH + * RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, +TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE + * FEES OR SERVICE CHARGE PAID BY BUYER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. + * + * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE WITH THE LAWS + * OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF LAWS PRINCIPLES. + ************************************************************************************************/ +/** +* @file aaa_hal_base.h +* @brief Declarations of 3A Hal Base Class and Top Data Structures +*/ +#ifdef MTK_LOG_ENABLE +#undef MTK_LOG_ENABLE +#endif +#define MTK_LOG_ENABLE 1 + +#include +#include +#include + +#ifndef _AAA_HAL_BASE_H_ +#define _AAA_HAL_BASE_H_ + +typedef intptr_t MINTPTR; +typedef uintptr_t MUINTPTR; + +class IBaseCamExif; + +namespace NS3A +{ + +enum E3ACtrl_T +{ + E3ACtrl_Begin = 0, + //shading + E3ACtrl_SetShadingOnOff = 0x0001, + E3ACtrl_SetShadingStrength = 0x0002, + E3ACtrl_SetShadingSdblkCfg = 0x0003, + E3ACtrl_SetShadingTSFOnOff = 0x0004, + E3ACtrl_SetShadingDynamic = 0x0005, + E3ACtrl_SetShadingColorTemp = 0x0006, + E3ACtrl_SetShadingByp123 = 0x0007, + E3ACtrl_SetShadingTSFCapByp = 0x0008, + //AWB + E3ACtrl_SetAwbBypCalibration = 0x0100, + //AE + E3ACtrl_SetExposureParam = 0x0200, + E3ACtrl_GetExposureParam = 0x0201, + E3ACtrl_GetAEPLineTable = 0x0202, + E3ACtrl_EnableDisableAE = 0x0203, + E3ACtrl_SetIsAEMultiCapture = 0x0204, + E3ACtrl_GetAECapDelay = 0x0205, + E3ACtrl_GetSensorDelayFrame = 0x0206, + E3ACtrl_SetSensorDirectly = 0x0207, + E3ACtrl_SetAEContinueShot = 0x0208, + E3ACtrl_GetEvCapture = 0x0209, + //ISP + E3ACtrl_GetIspGamma = 0x0300, + //AF + E3ACtrl_PostPDAFtask = 0x0400, + E3ACtrl_QueryAFStatus = 0x0401, + //Flow control set + E3ACtrl_Enable3ASetParams = 0x1000, + E3ACtrl_SetOperMode = 0x1001, + E3ACtrl_KeepOnLastStatus = 0x1002, + //Flow control get + E3ACtrl_GetOperMode = 0x2001, + //Stereo + E3ACtrl_GetStereo3DWarning = 0x8000, + E3ACtrl_GetDAFTBL = 0x8001, + // For engineer collect module info file + ECmd_Set3ACollectInfoFile = 0x9000, + // + E3ACtrl_Num +}; + +typedef enum +{ + ESensorDevId_Main = 0x01, + ESensorDevId_Sub = 0x02, + ESensorDevId_MainSecond = 0x04, + ESensorDevId_Main3D = 0x05, + ESensorDevId_Atv = 0x08, +} ESensorDevId_T; + +enum ESensorType_T { + ESensorType_RAW = 0, + ESensorType_YUV = 1 +}; +/** + * @brief 3A commands + */ +enum ECmd_T { + ECmd_CameraPreviewStart, + ECmd_CameraPreviewEnd, + ECmd_CamcorderPreviewStart, + ECmd_CamcorderPreviewEnd, + ECmd_PrecaptureStart, + ECmd_PrecaptureEnd, + ECmd_CaptureStart, + ECmd_CaptureEnd, + ECmd_RecordingStart, + ECmd_RecordingEnd, + ECmd_Update, + // internal command + ECmd_Init, + ECmd_Uninit, + ECmd_AFUpdate, // sync with AF done + ECmd_AFStart, + ECmd_AFEnd + +}; + +enum EQueryType_T{ + EQueryType_Init, + EQueryType_Effect, + EQueryType_AWB, + EQueryType_AF, + EQueryType_Ev, + EQueryType_Sat, + EQueryType_Bright, + EQueryType_Contrast +}; +/** + * @brief ISP tuning profile + */ +enum EIspProfile_T +{ + // NORMAL + EIspProfile_NormalPreview = 0, + EIspProfile_ZsdPreview_CC, + EIspProfile_ZsdPreview_NCC, + EIspProfile_NormalCapture, + EIspProfile_VideoPreview, + EIspProfile_VideoCapture, + EIspProfile_NormalCapture_CC, + EIspProfile_NormalCapture_16M, + // MF + EIspProfile_MFCapPass1, + EIspProfile_MFCapPass2, + EIspProfile_NUM +}; + +enum E3ACaptureMode_T +{ + ECapMode_P2_Cal = (1<<0), + ECapMode_P2_Set = (1<<1) +}; + +enum E3APreviewMode_T +{ + EPv_Normal = 0, + EPv_Video +}; + +enum ECaptureType_T +{ + ECapType_SingleCapture = 0, + ECapType_MultiCapture +}; + +struct FrameOutputParam_T +{ + MUINT32 u4FRameRate_x10; // 10 base frame rate + MINT32 i4BrightValue_x10; // 10 base brightness value + MINT32 i4ExposureValue_x10; // 10 base exposure value + MINT32 i4LightValue_x10; // 10 base lumince value + MUINT32 u4AEIndex; + + MUINT32 u4ShutterSpeed_us; // micro second + MUINT32 u4SensorGain_x1024; // 1024 base + MUINT32 u4ISPGain_x1024; // 1024 base + + MUINT32 u4PreviewShutterSpeed_us; // micro secondMUINT32 u4ShutterSpeed_us; // micro second + MUINT32 u4PreviewSensorGain_x1024; // 1024 base + MUINT32 u4PreviewISPGain_x1024; // 1024 base + MUINT32 u4RealISOValue; + MUINT32 u4CapShutterSpeed_us; // micro second + MUINT32 u4CapSensorGain_x1024; // 1024 base + MUINT32 u4CapISPGain_x1024; // 1024 base + MINT16 i2FlareOffset; // 12 bit domain + MINT16 i2FlareGain; // 9 base gain +}; + + +struct Hal3A_HDROutputParam_T +{ + MUINT32 u4OutputFrameNum; // Output frame number (2 or 3) + MUINT32 u4FinalGainDiff[2]; // 1x=1024; [0]: Between short exposure and 0EV; [1]: Between 0EV and long exposure + MUINT32 u4TargetTone; //Decide the curve to decide target tone +}; +/** + * @brief 3A parameters for capture + */ +struct CaptureParam_T +{ + MUINT32 u4ExposureMode; //0: exp. time, 1: exp. line + MUINT32 u4Eposuretime; //!<: Exposure time in us + MUINT32 u4AfeGain; //!<: sensor gain + MUINT32 u4IspGain; //!<: raw gain + MUINT32 u4RealISO; //!<: Real ISO speed + MUINT32 u4FlareOffset; + MUINT32 u4FlareGain; // 512 is 1x + MINT32 i4LightValue_x10; // 10 base LV value + MUINT32 u4YuvShading; //0: off, 1,on + MUINT32 u4YuvGamma; //0: off, 1,on + MUINT32 u4YuvAE; //0: off, 1,on + MUINT32 u4YuvShutter; + MUINT32 u4YuvGain; + MUINT32 u4YuvShutterRange; +}; + +struct FeatureParam_T { + MBOOL bExposureLockSupported; + MBOOL bAutoWhiteBalanceLockSupported; + MUINT32 u4MaxFocusAreaNum; + MINT32 i4MaxLensPos; + MINT32 i4MinLensPos; + MINT32 i4AFBestPos; + MINT64 i8BSSVlu; + MUINT32 u4MaxMeterAreaNum; + MUINT32 u4FocusLength_100x; +}; + +struct CameraArea_T { + MINT32 i4Left; + MINT32 i4Top; + MINT32 i4Right; + MINT32 i4Bottom; + MINT32 i4Weight; +}; + +struct ExpSettingParam_T { + MINT32 u4AOEMode; + MUINT32 u4MaxSensorAnalogGain; // 1x=1024 + MUINT32 u4MaxAEExpTimeInUS; // unit: us + MUINT32 u4MinAEExpTimeInUS; // unit: us + MUINT32 u4ShutterLineTime; // unit: 1/1000 us + MUINT32 u4MaxAESensorGain; // 1x=1024 + MUINT32 u4MinAESensorGain; // 1x=1024 + MUINT32 u4ExpTimeInUS0EV; // unit: us + MUINT32 u4SensorGain0EV; // 1x=1024 + MUINT8 u1FlareOffset0EV; + MINT32 i4GainBase0EV; // AOE application for LE calculation + MINT32 i4LE_LowAvg; // AOE application for LE calculation, def: 0 ~ 39 avg + MINT32 i4SEDeltaEVx100; // AOE application for SE calculation + MUINT32 u4Histogram[128]; +}; + +#define MAX_FOCUS_AREAS 9 + +struct CameraFocusArea_T { + CameraArea_T rAreas[MAX_FOCUS_AREAS]; + MUINT32 u4Count; +}; + +#define MAX_METERING_AREAS 9 + +struct CameraMeteringArea_T { + CameraArea_T rAreas[MAX_METERING_AREAS]; + MUINT32 u4Count; +}; + +// 3A ASD info +struct ASDInfo_T { + MINT32 i4AELv_x10; // AE Lv + MBOOL bAEBacklit; // AE backlit condition + MBOOL bAEStable; // AE stable + MINT16 i2AEFaceDiffIndex; // Face AE difference index with central weighting + MINT32 i4AWBRgain_X128; // AWB Rgain + MINT32 i4AWBBgain_X128; // AWB Bgain + MINT32 i4AWBRgain_D65_X128; // AWB Rgain (D65; golden sample) + MINT32 i4AWBBgain_D65_X128; // AWB Bgain (D65; golden sample) + MINT32 i4AWBRgain_CWF_X128; // AWB Rgain (CWF; golden sample) + MINT32 i4AWBBgain_CWF_X128; // AWB Bgain (CWF; golden sample) + MBOOL bAWBStable; // AWB stable + MINT32 i4AFPos; // AF position + MVOID *pAFTable; // Pointer to AF table + MINT32 i4AFTableOffset; // AF table offset + MINT32 i4AFTableMacroIdx; // AF table macro index + MINT32 i4AFTableIdxNum; // AF table total index number + MBOOL bAFStable; // AF stable +}; + +// LCE Info +struct LCEInfo_T { + MINT32 i4NormalAEidx; // gain >= 4x AE Pline table index at 30fps + MINT32 i4LowlightAEidx; // gain max AE Pline table index at 30fps + MINT32 i4AEidxCur; // AE current frame Pline table index + MINT32 i4AEidxNext; // AE next frame Pline table index +}; + +typedef enum +{ + E_AE_PRECAPTURE_IDLE, + E_AE_PRECAPTURE_START +} EAePreCapture_T; +/** + * @brief 3A parameters + */ +// 3A parameters +struct Param_T { + + // DEFAULT DEFINITION CATEGORY ( ordered by SDK ) + MINT32 i4MinFps; + MINT32 i4MaxFps; + MUINT32 u4AfMode; + MUINT32 u4AeMode; + MUINT32 u4AwbMode; + MUINT32 u4EffectMode; + MUINT32 u4AntiBandingMode; + MUINT32 u4SceneMode; + MUINT32 u4StrobeMode; + MINT32 i4ExpIndex; + MFLOAT fExpCompStep; + MBOOL bIsAELock; + MBOOL bIsAWBLock; + + MINT32 i4FullScanStep; + MINT32 i4MFPos; + CameraFocusArea_T rFocusAreas; + CameraMeteringArea_T rMeteringAreas; + + // MTK DEFINITION CATEGORY + + MUINT32 u4IsoSpeedMode; + MUINT32 u4AfLampMode; + // + MUINT32 u4BrightnessMode; + MUINT32 u4HueMode; + MUINT32 u4SaturationMode; + MUINT32 u4EdgeMode; + MUINT32 u4ContrastMode; + MINT32 i4RotateDegree; + MUINT32 u4AeMeterMode; + + // NEWLY-ADDED CATEGORY + MUINT32 u4CamMode; //Photo, Video, ZSD, ENG mode + MUINT32 u4ShotMode; + + //flash for engineer mode + MINT32 i4PreFlashDuty; + MINT32 i4PreFlashStep; + MINT32 i4MainFlashDuty; + MINT32 i4MainFlashStep; + + MBOOL bIsSupportAndroidService; + MBOOL bVideoStabilization; + + Param_T() + : i4MinFps(5000) + , i4MaxFps(30000) + , u4AfMode(5) + , u4AeMode(0) + , u4AwbMode(1) + , u4EffectMode(0) + , u4AntiBandingMode(0) + , u4SceneMode(0) + , u4StrobeMode(0) + , i4ExpIndex(0) + , fExpCompStep(0) + , bIsAELock(MFALSE) + , bIsAWBLock(MFALSE) + , i4FullScanStep(1) + , i4MFPos(0) + , rFocusAreas() + , rMeteringAreas() + , u4IsoSpeedMode(0) + , u4AfLampMode(0) + , u4BrightnessMode(0) + , u4HueMode(0) + , u4SaturationMode(0) + , u4EdgeMode(0) + , u4ContrastMode(0) + , i4RotateDegree(0) + , u4AeMeterMode (0) + , u4CamMode(0) + , u4ShotMode(0) + , i4PreFlashDuty(-1) + , i4PreFlashStep(-1) + , i4MainFlashDuty(-1) + , i4MainFlashStep(-1) + , bIsSupportAndroidService(MTRUE) + , bVideoStabilization(0) + {} +}; + + +/* +#if 0 +typedef enum +{ + E_AF_INACTIVE, + E_AF_PASSIVE_SCAN, + E_AF_PASSIVE_FOCUSED, + E_AF_ACTIVE_SCAN, + E_AF_FOCUSED_LOCKED, + E_AF_NOT_FOCUSED_LOCKED, + E_AF_PASSIVE_UNFOCUSED, +} EAfState_T; + +typedef enum +{ + E_AE_INACTIVE, + E_AE_SEARCHING, + E_AE_CONVERGED, + E_AE_LOCKED, + E_AE_FLASH_REQUIRED, + E_AE_PRECAPTURE +} EAeState_T; + +typedef enum +{ + E_AWB_INACTIVE, + E_AWB_SEARCHING, + E_AWB_CONVERGED, + E_AWB_LOCKED +} EAwbState_T; +#endif +// max frames to queue DAF information +#define DAF_TBL_QLEN 32 +#define DIST_TBL_QLEN 16 +typedef struct +{ + MUINT32 frm_mun; + MUINT8 is_learning; + MUINT8 is_querying; + MUINT8 af_valid; + MUINT16 af_dac_index; + MUINT16 af_confidence; + MUINT16 af_win_start_x; + MUINT16 af_win_start_y; + MUINT16 af_win_end_x; + MUINT16 af_win_end_y; + MUINT16 daf_dac_index; + MUINT16 daf_confidence; + MUINT16 daf_distance; +} DAF_VEC_STRUCT; + +typedef struct +{ + MUINT8 is_daf_run; + MUINT32 is_query_happen; + MUINT32 curr_p1_frm_num; + MUINT32 curr_p2_frm_num; + MUINT16 af_dac_min; + MUINT16 af_dac_max; + MUINT16 af_dac_start; + MUINT32 dac[DIST_TBL_QLEN]; + MUINT32 dist[DIST_TBL_QLEN]; + + DAF_VEC_STRUCT daf_vec[DAF_TBL_QLEN]; +}DAF_TBL_STRUCT; +*/ +struct Result_T +{ + MINT32 i4FrmId; + MINT32 i4PrecaptureId; // android.control.aePrecaptureId + //EAfState_T eAfState; + //EAeState_T eAeState; + //EAwbState_T eAwbState; +}; + + + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +class I3ACallBack { + +public: + + virtual ~I3ACallBack() {} + +public: + + virtual void doNotifyCb ( + int32_t _msgType, + int32_t _ext1, + int32_t _ext2, + int32_t _ext3 + ) = 0; + + virtual void doDataCb ( + int32_t _msgType, + void* _data, + uint32_t _size + ) = 0; +public: + +enum ECallBack_T +{ + eID_NOTIFY_AF_FOCUSED, + eID_NOTIFY_AF_MOVING, + eID_DATA_AF_FOCUSED, +}; + +}; +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +/** + * @brief 3A Hal Base Class + */ +class Hal3ABase { + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +protected: // Ctor/Dtor. + Hal3ABase() {} + virtual ~Hal3ABase() {} + +private: // disable copy constructor and copy assignment operator + Hal3ABase(const Hal3ABase&); + Hal3ABase& operator=(const Hal3ABase&); + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Interfaces. +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +public: + // + /** + * @brief Create instance of Hal3ABase + * @param [in] i4SensorDevId sensor device; please refer to halSensorDev_e in sensor_hal.h + */ + static Hal3ABase* createInstance(MINT32 const i4SensorDevId); + /** + * @brief destroy instance of Hal3ABase + */ + virtual MVOID destroyInstance() {} + /** + * @brief send commands to 3A hal + * @param [in] eCmd 3A commands; please refer to ECmd_T + */ + virtual MBOOL sendCommand(ECmd_T const /*eCmd*/, MINTPTR const i4Arg = 0) {(void)i4Arg; return MTRUE;} + /** + * @brief get 3A error code + */ + virtual MINT32 getErrorCode() const {return 0;} + /** + * @brief get 3A parameters + * @param [out] rParam 3A parameter struct; please refer to Param_T + */ + virtual MBOOL getParams(Param_T &/*rParam*/) const {return MTRUE;} + /** + * @brief set 3A parameters + * @param [in] rNewParam 3A parameter struct; please refer to Param_T + */ + virtual MBOOL setParams(Param_T const &/*rNewParam*/) {return MTRUE;} + /** + * @brief get 3A feature parameters + * @param [out] rFeatureParam feature parameter struct; please refer to FeatureParam_T + */ + virtual MBOOL getSupportedParams(FeatureParam_T &/*rFeatureParam*/) {return MTRUE;} + /** + * @brief to return whether ready to capture or not + */ + virtual MBOOL isReadyToCapture() const {return MTRUE;} + /** + * @brief execute auto focus process + */ + virtual MBOOL autoFocus() {return MTRUE;} + /** + * @brief cancel auto focus process + */ + virtual MBOOL cancelAutoFocus() {return MTRUE;} + /** + * @brief set zoom parameters of auto focus + */ + virtual MBOOL setZoom(MUINT32 /*u4ZoomRatio_x100*/, MUINT32 /*u4XOffset*/, MUINT32 /*u4YOffset*/, MUINT32 /*u4Width*/, MUINT32 /*u4Height*/) {return MTRUE;} + /** + * @brief set 3A photo EXIF information + * @param [in] pIBaseCamExif pointer of Exif base object; please refer to IBaseCamExif in IBaseCamExif.h + */ + virtual MBOOL set3AEXIFInfo(IBaseCamExif */*pIBaseCamExif*/) const {return MTRUE;} + /** + * @brief set debug information of MTK photo debug parsor + * @param [in] pIBaseCamExif pointer of Exif base object; please refer to IBaseCamExif in IBaseCamExif.h + */ + virtual MBOOL setDebugInfo(IBaseCamExif */*pIBaseCamExif*/) const {return MTRUE;} + /** + * @brief provide number of delay frames required by 3A mechanism + * @param [in] eQueryType query type; please refer to EQueryType_T + */ + virtual MINT32 getDelayFrame(EQueryType_T const /*eQueryType*/) const {return 0;} + /** + * @brief set callbacks of AF Manager + */ + virtual MBOOL setCallbacks(I3ACallBack* /*cb*/) {return MTRUE;} + /** + * @brief set ISP tuning profile + * @param [in] IspProfile ISP profile; please refer to EIspProfile + */ + virtual MBOOL setIspProfile(EIspProfile_T const /*IspProfile*/) {return MTRUE;} + /** + * @brief get capture AE parameters information + * @param [in] index capture index information, the value is 0~2 + * @param [in] i4EVidx increase or decrease capture AE parameters information + * @param [out] a_rCaptureInfo AE information structure; please refer to Ae_param.h + */ + virtual MINT32 getCaptureParams(MINT8 /*index*/, MINT32 /*i4EVidx*/, CaptureParam_T &/*a_rCaptureInfo*/) {return 0;} + /** + * @brief update capture AE parameters + * @param [in] a_rCaptureInfo capture AE parameters information + */ + virtual MINT32 updateCaptureParams(CaptureParam_T &/*a_rCaptureInfo*/) {return 0;} + + virtual MINT32 getExposureInfo(ExpSettingParam_T &/*strHDRInputSetting*/) {return 0;} + /** + * @brief get High dynamic range capture information + * @param [out] a_strHDROutputInfo capture information; + */ + virtual MINT32 getHDRCapInfo(Hal3A_HDROutputParam_T &/*a_strHDROutputInfo*/) {return 0;} + /** + * @brief set AE face detection area and weight information + * @param [in] a_sFaces face detection information; please refer to Faces.h + */ + virtual MVOID setFDEnable(MBOOL /*bEnable*/) {} + virtual MBOOL setFDInfo(MVOID* /*a_sFaces*/) {return MTRUE;} + virtual MBOOL setOTInfo(MVOID* /*a_sOT*/) {return MTRUE;} + /** + * @brief get real time AE parameters information + * @param [out] a_strFrameOutputInfo previiew AE information; + */ + virtual MINT32 getRTParams(FrameOutputParam_T &/*a_strFrameOutputInfo*/) {return 0;} + /** + * @brief to return whether need to fire flash + */ + virtual MINT32 isNeedFiringFlash() {return 0;} + /** + * @brief get ASD info + * @param [out] a_rASDInfo ASD info; + */ + virtual MBOOL getASDInfo(ASDInfo_T &/*a_rASDInfo*/) {return MTRUE;} + /** + * @brief get LCE info from AE + * @param [out] a_rLCEInfo LCE info; + */ + virtual MBOOL getLCEInfo(LCEInfo_T &/*a_rLCEInfo*/) {return MTRUE;} + /** + * @brief End continuous shot, EX: turn off flash device + */ + virtual MVOID endContinuousShotJobs() {} + /** + * @brief enable AE limiter control + */ + virtual MINT32 enableAELimiterControl(MBOOL /*bIsAELimiter*/) {return 0;} + virtual MINT32 getFlashFrameNumBeforeCapFrame() {return 1;} + virtual MVOID onFireCapFlashIfNeeded() {} + virtual MVOID setSensorMode(MINT32 /*i4SensorMode*/) {} + virtual MINT32 send3ACtrl(E3ACtrl_T /*e3ACtrl*/, MINTPTR /*iArg1*/, MINTPTR /*iArg2*/) {return 0;} + virtual MBOOL setAELock(MBOOL /*bIsAELock*/){return MTRUE;}; + virtual MBOOL setAWBLock(MBOOL /*bIsAELock*/){return MTRUE;}; + + virtual MINT32 enableFlashQuickCalibration(MINT32 /*bEn*/) {return 0;} + virtual MINT32 getFlashQuickCalibrationResult() {return 0;} + +#if 0 + virtual MBOOL getFocusData (vector &rData) const = 0; + // FD + // EXIF (T.B.D) + +#endif +}; + +class aaaTimer { +public: + inline MINT32 getUsTime() + { + struct timeval tv; + gettimeofday(&tv, NULL); + + return tv.tv_sec * 1000000 + tv.tv_usec; + } + + aaaTimer(const char* info, MINT32 sensorDevId, MBOOL enable) + : mInfo(info), mIdx(sensorDevId), mEnable(enable) + { + if (mEnable) mStartTime = getUsTime(); + } + + MVOID start(const char* info, MINT32 sensorDevId, MBOOL enable) //used by global/static variables + { + mInfo = info; + mIdx = sensorDevId; + mEnable = enable; + if (mEnable) mStartTime = getUsTime(); + } + + MVOID printTime() + { + if (!mEnable) return; + MINT32 endTime = getUsTime(); + ALOGD("[Function: %s, SensorDevId: %d] =====> time(ms): %f\n", mInfo, mIdx, ((double)(endTime - mStartTime)) / 1000); + } + + ~aaaTimer() + { + } + +protected: + const char* mInfo; + MINT32 mStartTime; + MINT32 mIdx; + MBOOL mEnable; +}; + + +}; // namespace NS3A + +#endif +