| /* |
| * 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. |
| */ |
| |
| #define LOG_TAG "IntelAEStateMachine" |
| |
| #include "IntelAEStateMachine.h" |
| |
| #include "Errors.h" |
| #include "HALv3Utils.h" |
| #include "Utils.h" |
| |
| namespace camera3 { |
| |
| IntelAEStateMachine::IntelAEStateMachine(int cameraId) |
| : mCameraId(cameraId), |
| mLastControlMode(0), |
| mLastSceneMode(0), |
| mCurrentAeMode(NULL) { |
| LOG1("%s mCameraId %d", __func__, mCameraId); |
| mCurrentAeMode = &mAutoMode; |
| CLEAR(mLastAeControls); |
| mLastAeControls.aeMode = ANDROID_CONTROL_AE_MODE_ON; |
| } |
| |
| IntelAEStateMachine::~IntelAEStateMachine() { |
| LOG1("%s mCameraId %d", __func__, mCameraId); |
| } |
| |
| /** |
| * Process states in input stage before the AE is run. |
| * It is initializing the current state if input |
| * parameters have an influence. |
| * |
| * \param[IN] controlMode: control.controlMode |
| * \param[IN] sceneMode: control.sceneMode |
| * \param[IN] aeControls: set of control.<ae> |
| */ |
| int IntelAEStateMachine::processState(uint8_t controlMode, uint8_t sceneMode, |
| const AeControls& aeControls) { |
| if (controlMode == ANDROID_CONTROL_MODE_OFF) { |
| LOG2("%s: Set AE offMode: controlMode = %d, aeMode = %d", __func__, controlMode, |
| aeControls.aeMode); |
| mCurrentAeMode = &mOffMode; |
| } else { |
| if (aeControls.aeMode == ANDROID_CONTROL_AE_MODE_OFF) { |
| mCurrentAeMode = &mOffMode; |
| LOG2("%s: Set AE offMode: controlMode = %d, aeMode = %d", __func__, controlMode, |
| aeControls.aeMode); |
| } else { |
| LOG2("%s: Set AE AutoMode: controlMode = %d, aeMode = %d", __func__, controlMode, |
| aeControls.aeMode); |
| mCurrentAeMode = &mAutoMode; |
| } |
| } |
| |
| mLastAeControls = aeControls; |
| mLastSceneMode = sceneMode; |
| mLastControlMode = controlMode; |
| |
| return mCurrentAeMode->processState(controlMode, sceneMode, aeControls); |
| } |
| |
| /** |
| * Process results and define output state after the AE is run |
| * |
| * \param[IN] aeConverged: from the ae result |
| * \param[IN] results: cameraMetadata to write dynamic tags. |
| */ |
| int IntelAEStateMachine::processResult(bool aeConverged, android::CameraMetadata* result) { |
| CheckError(!mCurrentAeMode, icamera::UNKNOWN_ERROR, "Invalid AE mode"); |
| CheckError(!result, icamera::UNKNOWN_ERROR, "%s, result is nullptr", __func__); |
| |
| return mCurrentAeMode->processResult(aeConverged, result); |
| } |
| |
| /****************************************************************************** |
| * AE MODE - BASE |
| ******************************************************************************/ |
| IntelAEModeBase::IntelAEModeBase() |
| : mLastControlMode(0), |
| mLastSceneMode(0), |
| mEvChanged(false), |
| mLastAeConvergedFlag(false), |
| mAeRunCount(0), |
| mAeConvergedCount(0), |
| mCurrentAeState(ANDROID_CONTROL_AE_STATE_INACTIVE) { |
| LOG1("%s", __func__); |
| CLEAR(mLastAeControls); |
| } |
| |
| void IntelAEModeBase::updateResult(android::CameraMetadata* results) { |
| CheckError(!results, VOID_VALUE, "%s, result is nullptr", __func__); |
| LOG2("%s: current AE state is: %d", __func__, mCurrentAeState); |
| |
| //# METADATA_Dynamic control.aeMode done |
| results->update(ANDROID_CONTROL_AE_MODE, &mLastAeControls.aeMode, 1); |
| //# METADATA_Dynamic control.aeLock done |
| results->update(ANDROID_CONTROL_AE_LOCK, &mLastAeControls.aeLock, 1); |
| //# METADATA_Dynamic control.aePrecaptureTrigger done |
| results->update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &mLastAeControls.aePreCaptureTrigger, 1); |
| //# METADATA_Dynamic control.aeState done |
| results->update(ANDROID_CONTROL_AE_STATE, &mCurrentAeState, 1); |
| } |
| |
| void IntelAEModeBase::resetState() { |
| LOG2("%s", __func__); |
| |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| mLastAeConvergedFlag = false; |
| mAeRunCount = 0; |
| mAeConvergedCount = 0; |
| } |
| |
| /****************************************************************************** |
| * AE MODE - OFF |
| ******************************************************************************/ |
| |
| IntelAEModeOff::IntelAEModeOff() : IntelAEModeBase() { |
| LOG1("%s", __func__); |
| } |
| |
| int IntelAEModeOff::processState(uint8_t controlMode, uint8_t sceneMode, |
| const AeControls& aeControls) { |
| LOG2("%s", __func__); |
| |
| mLastAeControls = aeControls; |
| mLastSceneMode = sceneMode; |
| mLastControlMode = controlMode; |
| |
| if (controlMode == ANDROID_CONTROL_MODE_OFF || |
| aeControls.aeMode == ANDROID_CONTROL_AE_MODE_OFF) { |
| resetState(); |
| } else { |
| LOGE("AE State machine should not be OFF! - Fix bug"); |
| return icamera::UNKNOWN_ERROR; |
| } |
| |
| return icamera::OK; |
| } |
| |
| int IntelAEModeOff::processResult(bool aeConverged, android::CameraMetadata* result) { |
| UNUSED(aeConverged); |
| CheckError(!result, icamera::UNKNOWN_ERROR, "%s, result is nullptr", __func__); |
| LOG2("%s", __func__); |
| |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| updateResult(result); |
| |
| return icamera::OK; |
| } |
| |
| /****************************************************************************** |
| * AE MODE - AUTO |
| ******************************************************************************/ |
| |
| IntelAEModeAuto::IntelAEModeAuto() : IntelAEModeBase() { |
| LOG1("%s", __func__); |
| } |
| |
| int IntelAEModeAuto::processState(uint8_t controlMode, uint8_t sceneMode, |
| const AeControls& aeControls) { |
| if (controlMode != mLastControlMode) { |
| LOG1("%s: control mode has changed %d -> %d, reset AE State", __func__, controlMode, |
| mLastControlMode); |
| resetState(); |
| } |
| |
| if (aeControls.aeLock == ANDROID_CONTROL_AE_LOCK_ON) { |
| // If ev compensation changes, we have to let the AE run until |
| // convergence. Thus we need to figure out changes in compensation and |
| // only change the state immediately to locked, |
| // IF the EV did not change. |
| mEvChanged = (mLastAeControls.evCompensation != aeControls.evCompensation) ? true : false; |
| |
| if (!mEvChanged) mCurrentAeState = ANDROID_CONTROL_AE_STATE_LOCKED; |
| } else if (aeControls.aeMode != mLastAeControls.aeMode || |
| (controlMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE && |
| sceneMode != mLastSceneMode)) { |
| resetState(); |
| } else { |
| switch (mCurrentAeState) { |
| case ANDROID_CONTROL_AE_STATE_LOCKED: |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| break; |
| case ANDROID_CONTROL_AE_STATE_SEARCHING: |
| case ANDROID_CONTROL_AE_STATE_INACTIVE: |
| case ANDROID_CONTROL_AE_STATE_CONVERGED: |
| case ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED: |
| case ANDROID_CONTROL_AE_STATE_PRECAPTURE: |
| if (aeControls.aePreCaptureTrigger == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START) |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; |
| |
| if (aeControls.aePreCaptureTrigger == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL) |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| break; |
| default: |
| LOGE("Invalid AE state!, State set to INACTIVE"); |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| |
| break; |
| } |
| } |
| mLastAeControls = aeControls; |
| mLastSceneMode = sceneMode; |
| mLastControlMode = controlMode; |
| return icamera::OK; |
| } |
| |
| int IntelAEModeAuto::processResult(bool aeConverged, android::CameraMetadata* result) { |
| CheckError(!result, icamera::UNKNOWN_ERROR, "%s, result is nullptr", __func__); |
| switch (mCurrentAeState) { |
| case ANDROID_CONTROL_AE_STATE_LOCKED: |
| // do nothing |
| break; |
| case ANDROID_CONTROL_AE_STATE_INACTIVE: |
| case ANDROID_CONTROL_AE_STATE_SEARCHING: |
| case ANDROID_CONTROL_AE_STATE_CONVERGED: |
| case ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED: |
| if (aeConverged) { |
| mEvChanged = false; // converged -> reset |
| if (mLastAeControls.aeLock) { |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_LOCKED; |
| } else { |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| } |
| } else { |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_SEARCHING; |
| } |
| break; |
| case ANDROID_CONTROL_AE_STATE_PRECAPTURE: |
| if (aeConverged) { |
| mEvChanged = false; // converged -> reset |
| if (mLastAeControls.aeLock) { |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_LOCKED; |
| } else { |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; |
| } |
| } // here the else is staying at the same state. |
| break; |
| default: |
| LOGE("Invalid AE state!, State set to INACTIVE"); |
| mCurrentAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; |
| break; |
| } |
| |
| if (aeConverged) { |
| if (mLastAeConvergedFlag == true) { |
| mAeConvergedCount++; |
| LOG2("%s: AE converged for %d frames", __func__, mAeConvergedCount); |
| } else { |
| mAeConvergedCount = 1; |
| LOG1("%s: AE converging -> converged, after running AE for %d times", __func__, |
| mAeRunCount); |
| } |
| } else { |
| if (mLastAeConvergedFlag == true) { |
| LOG1("%s: AE Converged -> converging", __func__); |
| mAeRunCount = 1; |
| mAeConvergedCount = 0; |
| } else { |
| mAeRunCount++; |
| LOG2("%s: AE converging for %d frames", __func__, mAeRunCount); |
| } |
| } |
| mLastAeConvergedFlag = aeConverged; |
| |
| updateResult(result); |
| |
| return icamera::OK; |
| } |
| |
| } // namespace camera3 |
