Merge "Move sensor hal service to class 'hal' from main." into oc-dev
diff --git a/camera/common/1.0/default/Android.bp b/camera/common/1.0/default/Android.bp
index 10f9fdb..03a71fa 100644
--- a/camera/common/1.0/default/Android.bp
+++ b/camera/common/1.0/default/Android.bp
@@ -15,7 +15,8 @@
shared_libs: [
"liblog",
"libhardware",
- "libcamera_metadata"],
+ "libcamera_metadata",
+ "android.hardware.graphics.mapper@2.0"],
include_dirs: ["system/media/private/camera/include"],
export_include_dirs : ["include"]
}
diff --git a/camera/common/1.0/default/HandleImporter.cpp b/camera/common/1.0/default/HandleImporter.cpp
index e22f26f..fd8b943 100644
--- a/camera/common/1.0/default/HandleImporter.cpp
+++ b/camera/common/1.0/default/HandleImporter.cpp
@@ -25,33 +25,27 @@
namespace V1_0 {
namespace helper {
-HandleImporter HandleImporter::sHandleImporter;
+using MapperError = android::hardware::graphics::mapper::V2_0::Error;
-HandleImporter& HandleImporter::getInstance() {
- sHandleImporter.initialize();
- return sHandleImporter;
-}
+HandleImporter::HandleImporter() : mInitialized(false) {}
-bool HandleImporter::initialize() {
- // allow only one client
+void HandleImporter::initializeLocked() {
if (mInitialized) {
- return false;
- }
-
- if (!openGralloc()) {
- return false;
- }
-
- mInitialized = true;
- return true;
-}
-
-void HandleImporter::cleanup() {
- if (!mInitialized) {
return;
}
- closeGralloc();
+ mMapper = IMapper::getService();
+ if (mMapper == nullptr) {
+ ALOGE("%s: cannnot acccess graphics mapper HAL!", __FUNCTION__);
+ return;
+ }
+
+ mInitialized = true;
+ return;
+}
+
+void HandleImporter::cleanup() {
+ mMapper.clear();
mInitialized = false;
}
@@ -64,12 +58,37 @@
return true;
}
- buffer_handle_t clone = cloneBuffer(handle);
- if (!clone) {
+ Mutex::Autolock lock(mLock);
+ if (!mInitialized) {
+ initializeLocked();
+ }
+
+ if (mMapper == nullptr) {
+ ALOGE("%s: mMapper is null!", __FUNCTION__);
return false;
}
- handle = clone;
+ MapperError error;
+ buffer_handle_t importedHandle;
+ auto ret = mMapper->importBuffer(
+ hidl_handle(handle),
+ [&](const auto& tmpError, const auto& tmpBufferHandle) {
+ error = tmpError;
+ importedHandle = static_cast<buffer_handle_t>(tmpBufferHandle);
+ });
+
+ if (!ret.isOk()) {
+ ALOGE("%s: mapper importBuffer failed: %s",
+ __FUNCTION__, ret.description().c_str());
+ return false;
+ }
+
+ if (error != MapperError::NONE) {
+ return false;
+ }
+
+ handle = importedHandle;
+
return true;
}
@@ -78,10 +97,20 @@
return;
}
- releaseBuffer(handle);
+ Mutex::Autolock lock(mLock);
+ if (mMapper == nullptr) {
+ ALOGE("%s: mMapper is null!", __FUNCTION__);
+ return;
+ }
+
+ auto ret = mMapper->freeBuffer(const_cast<native_handle_t*>(handle));
+ if (!ret.isOk()) {
+ ALOGE("%s: mapper freeBuffer failed: %s",
+ __FUNCTION__, ret.description().c_str());
+ }
}
-bool HandleImporter::importFence(const native_handle_t* handle, int& fd) {
+bool HandleImporter::importFence(const native_handle_t* handle, int& fd) const {
if (handle == nullptr || handle->numFds == 0) {
fd = -1;
} else if (handle->numFds == 1) {
@@ -99,89 +128,12 @@
return true;
}
-void HandleImporter::closeFence(int fd) {
+void HandleImporter::closeFence(int fd) const {
if (fd >= 0) {
close(fd);
}
}
-bool HandleImporter::openGralloc() {
- const hw_module_t* module;
- int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
- if (err) {
- ALOGE("failed to get gralloc module");
- return false;
- }
-
- uint8_t major = (module->module_api_version >> 8) & 0xff;
- if (major > 1) {
- ALOGE("unknown gralloc module major version %d", major);
- return false;
- }
-
- if (major == 1) {
- err = gralloc1_open(module, &mDevice);
- if (err) {
- ALOGE("failed to open gralloc1 device");
- return false;
- }
-
- mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN));
- mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
- mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE));
- if (!mRetain || !mRelease) {
- ALOGE("invalid gralloc1 device");
- gralloc1_close(mDevice);
- return false;
- }
- } else {
- mModule = reinterpret_cast<const gralloc_module_t*>(module);
- }
-
- return true;
-}
-
-void HandleImporter::closeGralloc() {
- if (mDevice) {
- gralloc1_close(mDevice);
- }
-}
-
-buffer_handle_t HandleImporter::cloneBuffer(buffer_handle_t handle) {
- native_handle_t* clone = native_handle_clone(handle);
- if (!clone) {
- ALOGE("failed to clone buffer %p", handle);
- return nullptr;
- }
-
- bool err;
- if (mDevice) {
- err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE);
- } else {
- err = (mModule->registerBuffer(mModule, clone) != 0);
- }
-
- if (err) {
- ALOGE("failed to retain/register buffer %p", clone);
- native_handle_close(clone);
- native_handle_delete(clone);
- return nullptr;
- }
-
- return clone;
-}
-
-void HandleImporter::releaseBuffer(buffer_handle_t handle) {
- if (mDevice) {
- mRelease(mDevice, handle);
- } else {
- mModule->unregisterBuffer(mModule, handle);
- }
- native_handle_close(handle);
- native_handle_delete(const_cast<native_handle_t*>(handle));
-}
-
} // namespace helper
} // namespace V1_0
} // namespace common
diff --git a/camera/common/1.0/default/include/HandleImporter.h b/camera/common/1.0/default/include/HandleImporter.h
index def8982..c68cfc0 100644
--- a/camera/common/1.0/default/include/HandleImporter.h
+++ b/camera/common/1.0/default/include/HandleImporter.h
@@ -17,9 +17,11 @@
#ifndef CAMERA_COMMON_1_0_HANDLEIMPORTED_H
#define CAMERA_COMMON_1_0_HANDLEIMPORTED_H
-#include <hardware/gralloc.h>
-#include <hardware/gralloc1.h>
#include <system/window.h>
+#include <utils/Mutex.h>
+#include <android/hardware/graphics/mapper/2.0/IMapper.h>
+
+using android::hardware::graphics::mapper::V2_0::IMapper;
namespace android {
namespace hardware {
@@ -31,36 +33,24 @@
// Borrowed from graphics HAL. Use this until gralloc mapper HAL is working
class HandleImporter {
public:
- static HandleImporter& getInstance();
+ HandleImporter();
// In IComposer, any buffer_handle_t is owned by the caller and we need to
// make a clone for hwcomposer2. We also need to translate empty handle
// to nullptr. This function does that, in-place.
bool importBuffer(buffer_handle_t& handle);
void freeBuffer(buffer_handle_t handle);
- bool importFence(const native_handle_t* handle, int& fd);
- void closeFence(int fd);
+ bool importFence(const native_handle_t* handle, int& fd) const;
+ void closeFence(int fd) const;
private:
-
- HandleImporter() : mInitialized(false) {}
- bool initialize();
+ void initializeLocked();
void cleanup();
- bool openGralloc();
- void closeGralloc();
- buffer_handle_t cloneBuffer(buffer_handle_t handle);
- void releaseBuffer(buffer_handle_t handle);
- static HandleImporter sHandleImporter;
+ Mutex mLock;
bool mInitialized;
+ sp<IMapper> mMapper;
- // gralloc1
- gralloc1_device_t* mDevice;
- GRALLOC1_PFN_RETAIN mRetain;
- GRALLOC1_PFN_RELEASE mRelease;
-
- // gralloc0
- const gralloc_module_t* mModule;
};
} // namespace helper
diff --git a/camera/device/1.0/default/Android.bp b/camera/device/1.0/default/Android.bp
index af94b0f..c2f0c46 100644
--- a/camera/device/1.0/default/Android.bp
+++ b/camera/device/1.0/default/Android.bp
@@ -14,6 +14,7 @@
"android.hardware.camera.device@1.0",
"android.hardware.camera.common@1.0",
"android.hardware.graphics.allocator@2.0",
+ "android.hardware.graphics.mapper@2.0",
"android.hardware.graphics.common@1.0",
"android.hidl.allocator@1.0",
"android.hidl.base@1.0",
diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index cb20fec..cdc9de2 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -33,7 +33,7 @@
using ::android::hardware::graphics::common::V1_0::BufferUsage;
using ::android::hardware::graphics::common::V1_0::PixelFormat;
-HandleImporter& CameraDevice::sHandleImporter = HandleImporter::getInstance();
+HandleImporter CameraDevice::sHandleImporter;
Status CameraDevice::getHidlStatus(const int& status) {
switch (status) {
diff --git a/camera/device/1.0/default/CameraDevice_1_0.h b/camera/device/1.0/default/CameraDevice_1_0.h
index a9f55c2..4240d57 100644
--- a/camera/device/1.0/default/CameraDevice_1_0.h
+++ b/camera/device/1.0/default/CameraDevice_1_0.h
@@ -170,7 +170,7 @@
// Set by provider (when external camera is connected/disconnected)
bool mDisconnected;
- static HandleImporter& sHandleImporter;
+ static HandleImporter sHandleImporter;
const SortedVector<std::pair<std::string, std::string>>& mCameraDeviceNames;
diff --git a/camera/device/3.2/default/Android.bp b/camera/device/3.2/default/Android.bp
index d95f8f4..325c008 100644
--- a/camera/device/3.2/default/Android.bp
+++ b/camera/device/3.2/default/Android.bp
@@ -12,6 +12,7 @@
"libcutils",
"android.hardware.camera.device@3.2",
"android.hardware.camera.provider@2.4",
+ "android.hardware.graphics.mapper@2.0",
"liblog",
"libhardware",
"libcamera_metadata",
diff --git a/camera/device/3.2/default/CameraDeviceSession.cpp b/camera/device/3.2/default/CameraDeviceSession.cpp
index 2499b1a..61be82d 100644
--- a/camera/device/3.2/default/CameraDeviceSession.cpp
+++ b/camera/device/3.2/default/CameraDeviceSession.cpp
@@ -35,7 +35,7 @@
// Size of result metadata fast message queue. Change to 0 to always use hwbinder buffer.
static constexpr size_t CAMERA_RESULT_METADATA_QUEUE_SIZE = 1 << 20 /* 1MB */;
-HandleImporter& CameraDeviceSession::sHandleImporter = HandleImporter::getInstance();
+HandleImporter CameraDeviceSession::sHandleImporter;
const int CameraDeviceSession::ResultBatcher::NOT_BATCHED;
CameraDeviceSession::CameraDeviceSession(
@@ -44,16 +44,33 @@
const sp<ICameraDeviceCallback>& callback) :
camera3_callback_ops({&sProcessCaptureResult, &sNotify}),
mDevice(device),
+ mDeviceVersion(device->common.version),
+ mIsAELockAvailable(false),
+ mDerivePostRawSensKey(false),
+ mNumPartialResults(1),
mResultBatcher(callback) {
mDeviceInfo = deviceInfo;
- uint32_t numPartialResults = 1;
camera_metadata_entry partialResultsCount =
mDeviceInfo.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT);
if (partialResultsCount.count > 0) {
- numPartialResults = partialResultsCount.data.i32[0];
+ mNumPartialResults = partialResultsCount.data.i32[0];
}
- mResultBatcher.setNumPartialResults(numPartialResults);
+ mResultBatcher.setNumPartialResults(mNumPartialResults);
+
+ camera_metadata_entry aeLockAvailableEntry = mDeviceInfo.find(
+ ANDROID_CONTROL_AE_LOCK_AVAILABLE);
+ if (aeLockAvailableEntry.count > 0) {
+ mIsAELockAvailable = (aeLockAvailableEntry.data.u8[0] ==
+ ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE);
+ }
+
+ // Determine whether we need to derive sensitivity boost values for older devices.
+ // If post-RAW sensitivity boost range is listed, so should post-raw sensitivity control
+ // be listed (as the default value 100)
+ if (mDeviceInfo.exists(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE)) {
+ mDerivePostRawSensKey = true;
+ }
mInitFail = initialize();
}
@@ -130,6 +147,77 @@
}
}
+/**
+ * For devices <= CAMERA_DEVICE_API_VERSION_3_2, AE_PRECAPTURE_TRIGGER_CANCEL is not supported so
+ * we need to override AE_PRECAPTURE_TRIGGER_CANCEL to AE_PRECAPTURE_TRIGGER_IDLE and AE_LOCK_OFF
+ * to AE_LOCK_ON to start cancelling AE precapture. If AE lock is not available, it still overrides
+ * AE_PRECAPTURE_TRIGGER_CANCEL to AE_PRECAPTURE_TRIGGER_IDLE but doesn't add AE_LOCK_ON to the
+ * request.
+ */
+bool CameraDeviceSession::handleAePrecaptureCancelRequestLocked(
+ const camera3_capture_request_t &halRequest,
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata *settings /*out*/,
+ AETriggerCancelOverride *override /*out*/) {
+ if ((mDeviceVersion > CAMERA_DEVICE_API_VERSION_3_2) ||
+ (nullptr == halRequest.settings) || (nullptr == settings) ||
+ (0 == get_camera_metadata_entry_count(halRequest.settings))) {
+ return false;
+ }
+
+ settings->clear();
+ settings->append(halRequest.settings);
+ camera_metadata_entry_t aePrecaptureTrigger =
+ settings->find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER);
+ if (aePrecaptureTrigger.count > 0 &&
+ aePrecaptureTrigger.data.u8[0] ==
+ ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL) {
+ // Always override CANCEL to IDLE
+ uint8_t aePrecaptureTrigger =
+ ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
+ settings->update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
+ &aePrecaptureTrigger, 1);
+ *override = { false, ANDROID_CONTROL_AE_LOCK_OFF,
+ true, ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL };
+
+ if (mIsAELockAvailable == true) {
+ camera_metadata_entry_t aeLock = settings->find(
+ ANDROID_CONTROL_AE_LOCK);
+ if (aeLock.count == 0 || aeLock.data.u8[0] ==
+ ANDROID_CONTROL_AE_LOCK_OFF) {
+ uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_ON;
+ settings->update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
+ override->applyAeLock = true;
+ override->aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Override result metadata for cancelling AE precapture trigger applied in
+ * handleAePrecaptureCancelRequestLocked().
+ */
+void CameraDeviceSession::overrideResultForPrecaptureCancelLocked(
+ const AETriggerCancelOverride &aeTriggerCancelOverride,
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata *settings /*out*/) {
+ if (aeTriggerCancelOverride.applyAeLock) {
+ // Only devices <= v3.2 should have this override
+ assert(mDeviceVersion <= CAMERA_DEVICE_API_VERSION_3_2);
+ settings->update(ANDROID_CONTROL_AE_LOCK, &aeTriggerCancelOverride.aeLock, 1);
+ }
+
+ if (aeTriggerCancelOverride.applyAePrecaptureTrigger) {
+ // Only devices <= v3.2 should have this override
+ assert(mDeviceVersion <= CAMERA_DEVICE_API_VERSION_3_2);
+ settings->update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
+ &aeTriggerCancelOverride.aePrecaptureTrigger, 1);
+ }
+}
+
Status CameraDeviceSession::importRequest(
const CaptureRequest& request,
hidl_vec<buffer_handle_t*>& allBufPtrs,
@@ -612,13 +700,58 @@
__FUNCTION__, type);
status = Status::ILLEGAL_ARGUMENT;
} else {
- convertToHidl(rawRequest, &outMetadata);
+ mOverridenRequest.clear();
+ mOverridenRequest.append(rawRequest);
+ // Derive some new keys for backward compatibility
+ if (mDerivePostRawSensKey && !mOverridenRequest.exists(
+ ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST)) {
+ int32_t defaultBoost[1] = {100};
+ mOverridenRequest.update(
+ ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
+ defaultBoost, 1);
+ const camera_metadata_t *metaBuffer =
+ mOverridenRequest.getAndLock();
+ convertToHidl(metaBuffer, &outMetadata);
+ mOverridenRequest.unlock(metaBuffer);
+ } else {
+ convertToHidl(rawRequest, &outMetadata);
+ }
}
}
_hidl_cb(status, outMetadata);
return Void();
}
+/**
+ * Map Android N dataspace definitions back to Android M definitions, for
+ * use with HALv3.3 or older.
+ *
+ * Only map where correspondences exist, and otherwise preserve the value.
+ */
+android_dataspace CameraDeviceSession::mapToLegacyDataspace(
+ android_dataspace dataSpace) const {
+ if (mDeviceVersion <= CAMERA_DEVICE_API_VERSION_3_3) {
+ switch (dataSpace) {
+ case HAL_DATASPACE_V0_SRGB_LINEAR:
+ return HAL_DATASPACE_SRGB_LINEAR;
+ case HAL_DATASPACE_V0_SRGB:
+ return HAL_DATASPACE_SRGB;
+ case HAL_DATASPACE_V0_JFIF:
+ return HAL_DATASPACE_JFIF;
+ case HAL_DATASPACE_V0_BT601_625:
+ return HAL_DATASPACE_BT601_625;
+ case HAL_DATASPACE_V0_BT601_525:
+ return HAL_DATASPACE_BT601_525;
+ case HAL_DATASPACE_V0_BT709:
+ return HAL_DATASPACE_BT709;
+ default:
+ return dataSpace;
+ }
+ }
+
+ return dataSpace;
+}
+
Return<void> CameraDeviceSession::configureStreams(
const StreamConfiguration& requestedConfiguration, configureStreams_cb _hidl_cb) {
Status status = initStatus();
@@ -634,6 +767,22 @@
return Void();
}
+ if (!mInflightAETriggerOverrides.empty()) {
+ ALOGE("%s: trying to configureStreams while there are still %zu inflight"
+ " trigger overrides!", __FUNCTION__,
+ mInflightAETriggerOverrides.size());
+ _hidl_cb(Status::INTERNAL_ERROR, outStreams);
+ return Void();
+ }
+
+ if (!mInflightRawBoostPresent.empty()) {
+ ALOGE("%s: trying to configureStreams while there are still %zu inflight"
+ " boost overrides!", __FUNCTION__,
+ mInflightRawBoostPresent.size());
+ _hidl_cb(Status::INTERNAL_ERROR, outStreams);
+ return Void();
+ }
+
if (status != Status::OK) {
_hidl_cb(status, outStreams);
return Void();
@@ -654,6 +803,8 @@
Camera3Stream stream;
convertFromHidl(requestedConfiguration.streams[i], &stream);
mStreamMap[id] = stream;
+ mStreamMap[id].data_space = mapToLegacyDataspace(
+ mStreamMap[id].data_space);
mCirculatingBuffers.emplace(stream.mId, CirculatingBuffers{});
} else {
// width/height/format must not change, but usage/rotation might need to change
@@ -662,8 +813,9 @@
mStreamMap[id].width != requestedConfiguration.streams[i].width ||
mStreamMap[id].height != requestedConfiguration.streams[i].height ||
mStreamMap[id].format != (int) requestedConfiguration.streams[i].format ||
- mStreamMap[id].data_space != (android_dataspace_t)
- requestedConfiguration.streams[i].dataSpace) {
+ mStreamMap[id].data_space !=
+ mapToLegacyDataspace( static_cast<android_dataspace_t> (
+ requestedConfiguration.streams[i].dataSpace))) {
ALOGE("%s: stream %d configuration changed!", __FUNCTION__, id);
_hidl_cb(Status::INTERNAL_ERROR, outStreams);
return Void();
@@ -837,6 +989,8 @@
hidl_vec<camera3_stream_buffer_t> outHalBufs;
outHalBufs.resize(numOutputBufs);
+ bool aeCancelTriggerNeeded = false;
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata settingsOverride;
{
Mutex::Autolock _l(mInflightLock);
if (hasInputBuf) {
@@ -862,12 +1016,24 @@
outHalBufs[i] = bufCache;
}
halRequest.output_buffers = outHalBufs.data();
+
+ AETriggerCancelOverride triggerOverride;
+ aeCancelTriggerNeeded = handleAePrecaptureCancelRequestLocked(
+ halRequest, &settingsOverride /*out*/, &triggerOverride/*out*/);
+ if (aeCancelTriggerNeeded) {
+ mInflightAETriggerOverrides[halRequest.frame_number] =
+ triggerOverride;
+ halRequest.settings = settingsOverride.getAndLock();
+ }
}
ATRACE_ASYNC_BEGIN("frame capture", request.frameNumber);
ATRACE_BEGIN("camera3->process_capture_request");
status_t ret = mDevice->ops->process_capture_request(mDevice, &halRequest);
ATRACE_END();
+ if (aeCancelTriggerNeeded) {
+ settingsOverride.unlock(halRequest.settings);
+ }
if (ret != OK) {
Mutex::Autolock _l(mInflightLock);
ALOGE("%s: HAL process_capture_request call failed!", __FUNCTION__);
@@ -881,6 +1047,9 @@
auto key = std::make_pair(request.outputBuffers[i].streamId, request.frameNumber);
mInflightBuffers.erase(key);
}
+ if (aeCancelTriggerNeeded) {
+ mInflightAETriggerOverrides.erase(request.frameNumber);
+ }
return Status::INTERNAL_ERROR;
}
@@ -908,6 +1077,17 @@
ALOGE("%s: trying to close while there are still %zu inflight buffers!",
__FUNCTION__, mInflightBuffers.size());
}
+ if (!mInflightAETriggerOverrides.empty()) {
+ ALOGE("%s: trying to close while there are still %zu inflight "
+ "trigger overrides!", __FUNCTION__,
+ mInflightAETriggerOverrides.size());
+ }
+ if (!mInflightRawBoostPresent.empty()) {
+ ALOGE("%s: trying to close while there are still %zu inflight "
+ " RAW boost overrides!", __FUNCTION__,
+ mInflightRawBoostPresent.size());
+ }
+
}
ATRACE_BEGIN("camera3->close");
@@ -971,6 +1151,61 @@
result.fmqResultSize = 0;
result.partialResult = hal_result->partial_result;
convertToHidl(hal_result->result, &result.result);
+ if (nullptr != hal_result->result) {
+ bool resultOverriden = false;
+ Mutex::Autolock _l(d->mInflightLock);
+
+ // Derive some new keys for backward compatibility
+ if (d->mDerivePostRawSensKey) {
+ camera_metadata_ro_entry entry;
+ if (find_camera_metadata_ro_entry(hal_result->result,
+ ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST, &entry) == 0) {
+ d->mInflightRawBoostPresent[frameNumber] = true;
+ } else {
+ auto entry = d->mInflightRawBoostPresent.find(frameNumber);
+ if (d->mInflightRawBoostPresent.end() == entry) {
+ d->mInflightRawBoostPresent[frameNumber] = false;
+ }
+ }
+
+ if ((hal_result->partial_result == d->mNumPartialResults)) {
+ if (!d->mInflightRawBoostPresent[frameNumber]) {
+ if (!resultOverriden) {
+ d->mOverridenResult.clear();
+ d->mOverridenResult.append(hal_result->result);
+ resultOverriden = true;
+ }
+ int32_t defaultBoost[1] = {100};
+ d->mOverridenResult.update(
+ ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST,
+ defaultBoost, 1);
+ }
+
+ d->mInflightRawBoostPresent.erase(frameNumber);
+ }
+ }
+
+ auto entry = d->mInflightAETriggerOverrides.find(frameNumber);
+ if (d->mInflightAETriggerOverrides.end() != entry) {
+ if (!resultOverriden) {
+ d->mOverridenResult.clear();
+ d->mOverridenResult.append(hal_result->result);
+ resultOverriden = true;
+ }
+ d->overrideResultForPrecaptureCancelLocked(entry->second,
+ &d->mOverridenResult);
+ if (hal_result->partial_result == d->mNumPartialResults) {
+ d->mInflightAETriggerOverrides.erase(frameNumber);
+ }
+ }
+
+ if (resultOverriden) {
+ const camera_metadata_t *metaBuffer =
+ d->mOverridenResult.getAndLock();
+ convertToHidl(metaBuffer, &result.result);
+ d->mOverridenResult.unlock(metaBuffer);
+ }
+ }
if (hasInputBuf) {
result.inputBuffer.streamId =
static_cast<Camera3Stream*>(hal_result->input_buffer->stream)->mId;
@@ -1046,6 +1281,36 @@
return;
}
}
+
+ if (static_cast<camera3_msg_type_t>(hidlMsg.type) == CAMERA3_MSG_ERROR) {
+ switch (hidlMsg.msg.error.errorCode) {
+ case ErrorCode::ERROR_DEVICE:
+ case ErrorCode::ERROR_REQUEST:
+ case ErrorCode::ERROR_RESULT: {
+ Mutex::Autolock _l(d->mInflightLock);
+ auto entry = d->mInflightAETriggerOverrides.find(
+ hidlMsg.msg.error.frameNumber);
+ if (d->mInflightAETriggerOverrides.end() != entry) {
+ d->mInflightAETriggerOverrides.erase(
+ hidlMsg.msg.error.frameNumber);
+ }
+
+ auto boostEntry = d->mInflightRawBoostPresent.find(
+ hidlMsg.msg.error.frameNumber);
+ if (d->mInflightRawBoostPresent.end() != boostEntry) {
+ d->mInflightRawBoostPresent.erase(
+ hidlMsg.msg.error.frameNumber);
+ }
+
+ }
+ break;
+ case ErrorCode::ERROR_BUFFER:
+ default:
+ break;
+ }
+
+ }
+
d->mResultBatcher.notify(hidlMsg);
}
diff --git a/camera/device/3.2/default/CameraDeviceSession.h b/camera/device/3.2/default/CameraDeviceSession.h
index 7682165..d559c48 100644
--- a/camera/device/3.2/default/CameraDeviceSession.h
+++ b/camera/device/3.2/default/CameraDeviceSession.h
@@ -111,7 +111,18 @@
// Set by CameraDevice (when external camera is disconnected)
bool mDisconnected = false;
+ struct AETriggerCancelOverride {
+ bool applyAeLock;
+ uint8_t aeLock;
+ bool applyAePrecaptureTrigger;
+ uint8_t aePrecaptureTrigger;
+ };
+
camera3_device_t* mDevice;
+ uint32_t mDeviceVersion;
+ bool mIsAELockAvailable;
+ bool mDerivePostRawSensKey;
+ uint32_t mNumPartialResults;
// Stream ID -> Camera3Stream cache
std::map<int, Camera3Stream> mStreamMap;
@@ -119,6 +130,12 @@
// (streamID, frameNumber) -> inflight buffer cache
std::map<std::pair<int, uint32_t>, camera3_stream_buffer_t> mInflightBuffers;
+ // (frameNumber, AETriggerOverride) -> inflight request AETriggerOverrides
+ std::map<uint32_t, AETriggerCancelOverride> mInflightAETriggerOverrides;
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata mOverridenResult;
+ std::map<uint32_t, bool> mInflightRawBoostPresent;
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata mOverridenRequest;
+
// buffers currently ciculating between HAL and camera service
// key: bufferId sent via HIDL interface
// value: imported buffer_handle_t
@@ -128,7 +145,7 @@
// Stream ID -> circulating buffers map
std::map<int, CirculatingBuffers> mCirculatingBuffers;
- static HandleImporter& sHandleImporter;
+ static HandleImporter sHandleImporter;
bool mInitFail;
@@ -258,6 +275,18 @@
void updateBufferCaches(const hidl_vec<BufferCache>& cachesToRemove);
+ android_dataspace mapToLegacyDataspace(
+ android_dataspace dataSpace) const;
+
+ bool handleAePrecaptureCancelRequestLocked(
+ const camera3_capture_request_t &halRequest,
+ android::hardware::camera::common::V1_0::helper::CameraMetadata *settings /*out*/,
+ AETriggerCancelOverride *override /*out*/);
+
+ void overrideResultForPrecaptureCancelLocked(
+ const AETriggerCancelOverride &aeTriggerCancelOverride,
+ ::android::hardware::camera::common::V1_0::helper::CameraMetadata *settings /*out*/);
+
Status processOneCaptureRequest(const CaptureRequest& request);
/**
* Static callback forwarding methods from HAL to instance
diff --git a/camera/provider/2.4/default/Android.bp b/camera/provider/2.4/default/Android.bp
index 8e8df62..d897fc7 100644
--- a/camera/provider/2.4/default/Android.bp
+++ b/camera/provider/2.4/default/Android.bp
@@ -15,6 +15,7 @@
"camera.device@3.2-impl",
"android.hardware.camera.provider@2.4",
"android.hardware.camera.common@1.0",
+ "android.hardware.graphics.mapper@2.0",
"android.hidl.allocator@1.0",
"android.hidl.memory@1.0",
"liblog",
diff --git a/camera/provider/2.4/default/CameraProvider.cpp b/camera/provider/2.4/default/CameraProvider.cpp
index 9f4d188..791b93c 100644
--- a/camera/provider/2.4/default/CameraProvider.cpp
+++ b/camera/provider/2.4/default/CameraProvider.cpp
@@ -207,6 +207,20 @@
mNumberOfLegacyCameras = mModule->getNumberOfCameras();
for (int i = 0; i < mNumberOfLegacyCameras; i++) {
+ struct camera_info info;
+ auto rc = mModule->getCameraInfo(i, &info);
+ if (rc != NO_ERROR) {
+ ALOGE("%s: Camera info query failed!", __func__);
+ mModule.clear();
+ return true;
+ }
+
+ if (checkCameraVersion(i, info) != OK) {
+ ALOGE("%s: Camera version check failed!", __func__);
+ mModule.clear();
+ return true;
+ }
+
char cameraId[kMaxCameraIdLen];
snprintf(cameraId, sizeof(cameraId), "%d", i);
std::string cameraIdStr(cameraId);
@@ -242,6 +256,40 @@
return false; // mInitFailed
}
+/**
+ * Check that the device HAL version is still in supported.
+ */
+int CameraProvider::checkCameraVersion(int id, camera_info info) {
+ if (mModule == nullptr) {
+ return NO_INIT;
+ }
+
+ // device_version undefined in CAMERA_MODULE_API_VERSION_1_0,
+ // All CAMERA_MODULE_API_VERSION_1_0 devices are backward-compatible
+ if (mModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
+ // Verify the device version is in the supported range
+ switch (info.device_version) {
+ case CAMERA_DEVICE_API_VERSION_1_0:
+ case CAMERA_DEVICE_API_VERSION_3_2:
+ case CAMERA_DEVICE_API_VERSION_3_3:
+ case CAMERA_DEVICE_API_VERSION_3_4:
+ // in support
+ break;
+ case CAMERA_DEVICE_API_VERSION_2_0:
+ case CAMERA_DEVICE_API_VERSION_2_1:
+ case CAMERA_DEVICE_API_VERSION_3_0:
+ case CAMERA_DEVICE_API_VERSION_3_1:
+ // no longer supported
+ default:
+ ALOGE("%s: Device %d has HAL version %x, which is not supported",
+ __FUNCTION__, id, info.device_version);
+ return NO_INIT;
+ }
+ }
+
+ return OK;
+}
+
bool CameraProvider::setUpVendorTags() {
ATRACE_CALL();
vendor_tag_ops_t vOps = vendor_tag_ops_t();
diff --git a/camera/provider/2.4/default/CameraProvider.h b/camera/provider/2.4/default/CameraProvider.h
index d7b0ea6..75971fa 100644
--- a/camera/provider/2.4/default/CameraProvider.h
+++ b/camera/provider/2.4/default/CameraProvider.h
@@ -89,6 +89,7 @@
hidl_vec<VendorTagSection> mVendorTagSections;
bool setUpVendorTags();
+ int checkCameraVersion(int id, camera_info info);
// extract legacy camera ID/device version from a HIDL device name
static std::string getLegacyCameraId(const hidl_string& deviceName);
diff --git a/keymaster/3.0/default/KeymasterDevice.cpp b/keymaster/3.0/default/KeymasterDevice.cpp
index 9c7c860..219f419 100644
--- a/keymaster/3.0/default/KeymasterDevice.cpp
+++ b/keymaster/3.0/default/KeymasterDevice.cpp
@@ -603,7 +603,13 @@
return ErrorCode::UNIMPLEMENTED;
}
auto kmKeyBlob = hidlVec2KmKeyBlob(keyBlob);
- return legacy_enum_conversion(keymaster_device_->delete_key(keymaster_device_, &kmKeyBlob));
+ auto rc = legacy_enum_conversion(
+ keymaster_device_->delete_key(keymaster_device_, &kmKeyBlob));
+ // Keymaster 3.0 requires deleteKey to return ErrorCode::OK if the key
+ // blob is unusable after the call. This is equally true if the key blob was
+ // unusable before.
+ if (rc == ErrorCode::INVALID_KEY_BLOB) return ErrorCode::OK;
+ return rc;
}
Return<ErrorCode> KeymasterDevice::deleteAllKeys() {