You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
584 lines
21 KiB
584 lines
21 KiB
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* 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 "CamComm1.0-CamModule"
|
|
#define ATRACE_TAG ATRACE_TAG_CAMERA
|
|
//#define LOG_NDEBUG 0
|
|
|
|
#include <utils/Trace.h>
|
|
|
|
#include "CameraModule.h"
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace camera {
|
|
namespace common {
|
|
namespace V1_0 {
|
|
namespace helper {
|
|
|
|
void CameraModule::deriveCameraCharacteristicsKeys(
|
|
uint32_t deviceVersion, CameraMetadata &chars) {
|
|
ATRACE_CALL();
|
|
|
|
Vector<int32_t> derivedCharKeys;
|
|
Vector<int32_t> derivedRequestKeys;
|
|
Vector<int32_t> derivedResultKeys;
|
|
// Keys added in HAL3.3
|
|
if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_3) {
|
|
Vector<uint8_t> controlModes;
|
|
uint8_t data = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
|
|
chars.update(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &data, /*count*/1);
|
|
data = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
|
|
chars.update(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &data, /*count*/1);
|
|
controlModes.push(ANDROID_CONTROL_MODE_AUTO);
|
|
camera_metadata_entry entry = chars.find(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
|
|
if (entry.count > 1 || entry.data.u8[0] != ANDROID_CONTROL_SCENE_MODE_DISABLED) {
|
|
controlModes.push(ANDROID_CONTROL_MODE_USE_SCENE_MODE);
|
|
}
|
|
|
|
// Only advertise CONTROL_OFF mode if 3A manual controls are supported.
|
|
bool isManualAeSupported = false;
|
|
bool isManualAfSupported = false;
|
|
bool isManualAwbSupported = false;
|
|
entry = chars.find(ANDROID_CONTROL_AE_AVAILABLE_MODES);
|
|
if (entry.count > 0) {
|
|
for (size_t i = 0; i < entry.count; i++) {
|
|
if (entry.data.u8[i] == ANDROID_CONTROL_AE_MODE_OFF) {
|
|
isManualAeSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
entry = chars.find(ANDROID_CONTROL_AF_AVAILABLE_MODES);
|
|
if (entry.count > 0) {
|
|
for (size_t i = 0; i < entry.count; i++) {
|
|
if (entry.data.u8[i] == ANDROID_CONTROL_AF_MODE_OFF) {
|
|
isManualAfSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
entry = chars.find(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
|
|
if (entry.count > 0) {
|
|
for (size_t i = 0; i < entry.count; i++) {
|
|
if (entry.data.u8[i] == ANDROID_CONTROL_AWB_MODE_OFF) {
|
|
isManualAwbSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (isManualAeSupported && isManualAfSupported && isManualAwbSupported) {
|
|
controlModes.push(ANDROID_CONTROL_MODE_OFF);
|
|
}
|
|
|
|
chars.update(ANDROID_CONTROL_AVAILABLE_MODES, controlModes);
|
|
|
|
entry = chars.find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
|
|
// HAL3.2 devices passing existing CTS test should all support all LSC modes and LSC map
|
|
bool lensShadingModeSupported = false;
|
|
if (entry.count > 0) {
|
|
for (size_t i = 0; i < entry.count; i++) {
|
|
if (entry.data.i32[i] == ANDROID_SHADING_MODE) {
|
|
lensShadingModeSupported = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Vector<uint8_t> lscModes;
|
|
Vector<uint8_t> lscMapModes;
|
|
lscModes.push(ANDROID_SHADING_MODE_FAST);
|
|
lscModes.push(ANDROID_SHADING_MODE_HIGH_QUALITY);
|
|
lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
|
|
if (lensShadingModeSupported) {
|
|
lscModes.push(ANDROID_SHADING_MODE_OFF);
|
|
lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON);
|
|
}
|
|
chars.update(ANDROID_SHADING_AVAILABLE_MODES, lscModes);
|
|
chars.update(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, lscMapModes);
|
|
|
|
derivedCharKeys.push(ANDROID_CONTROL_AE_LOCK_AVAILABLE);
|
|
derivedCharKeys.push(ANDROID_CONTROL_AWB_LOCK_AVAILABLE);
|
|
derivedCharKeys.push(ANDROID_CONTROL_AVAILABLE_MODES);
|
|
derivedCharKeys.push(ANDROID_SHADING_AVAILABLE_MODES);
|
|
derivedCharKeys.push(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES);
|
|
|
|
// Need update android.control.availableHighSpeedVideoConfigurations since HAL3.3
|
|
// adds batch size to this array.
|
|
entry = chars.find(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS);
|
|
if (entry.count > 0) {
|
|
Vector<int32_t> highSpeedConfig;
|
|
for (size_t i = 0; i < entry.count; i += 4) {
|
|
highSpeedConfig.add(entry.data.i32[i]); // width
|
|
highSpeedConfig.add(entry.data.i32[i + 1]); // height
|
|
highSpeedConfig.add(entry.data.i32[i + 2]); // fps_min
|
|
highSpeedConfig.add(entry.data.i32[i + 3]); // fps_max
|
|
highSpeedConfig.add(1); // batchSize_max. default to 1 for HAL3.2
|
|
}
|
|
chars.update(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS,
|
|
highSpeedConfig);
|
|
}
|
|
}
|
|
|
|
// Keys added in HAL3.4
|
|
if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_4) {
|
|
// Check if HAL supports RAW_OPAQUE output
|
|
camera_metadata_entry entry = chars.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
|
|
bool supportRawOpaque = false;
|
|
bool supportAnyRaw = false;
|
|
const int STREAM_CONFIGURATION_SIZE = 4;
|
|
const int STREAM_FORMAT_OFFSET = 0;
|
|
const int STREAM_WIDTH_OFFSET = 1;
|
|
const int STREAM_HEIGHT_OFFSET = 2;
|
|
const int STREAM_IS_INPUT_OFFSET = 3;
|
|
Vector<int32_t> rawOpaqueSizes;
|
|
|
|
for (size_t i=0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
|
|
int32_t format = entry.data.i32[i + STREAM_FORMAT_OFFSET];
|
|
int32_t width = entry.data.i32[i + STREAM_WIDTH_OFFSET];
|
|
int32_t height = entry.data.i32[i + STREAM_HEIGHT_OFFSET];
|
|
int32_t isInput = entry.data.i32[i + STREAM_IS_INPUT_OFFSET];
|
|
if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
|
|
format == HAL_PIXEL_FORMAT_RAW_OPAQUE) {
|
|
supportRawOpaque = true;
|
|
rawOpaqueSizes.push(width);
|
|
rawOpaqueSizes.push(height);
|
|
// 2 bytes per pixel. This rough estimation is only used when
|
|
// HAL does not fill in the opaque raw size
|
|
rawOpaqueSizes.push(width * height *2);
|
|
}
|
|
if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
|
|
(format == HAL_PIXEL_FORMAT_RAW16 ||
|
|
format == HAL_PIXEL_FORMAT_RAW10 ||
|
|
format == HAL_PIXEL_FORMAT_RAW12 ||
|
|
format == HAL_PIXEL_FORMAT_RAW_OPAQUE)) {
|
|
supportAnyRaw = true;
|
|
}
|
|
}
|
|
|
|
if (supportRawOpaque) {
|
|
entry = chars.find(ANDROID_SENSOR_OPAQUE_RAW_SIZE);
|
|
if (entry.count == 0) {
|
|
// Fill in estimated value if HAL does not list it
|
|
chars.update(ANDROID_SENSOR_OPAQUE_RAW_SIZE, rawOpaqueSizes);
|
|
derivedCharKeys.push(ANDROID_SENSOR_OPAQUE_RAW_SIZE);
|
|
}
|
|
}
|
|
|
|
// Check if HAL supports any RAW output, if so, fill in postRawSensitivityBoost range
|
|
if (supportAnyRaw) {
|
|
int32_t defaultRange[2] = {100, 100};
|
|
entry = chars.find(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE);
|
|
if (entry.count == 0) {
|
|
// Fill in default value (100, 100)
|
|
chars.update(
|
|
ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE,
|
|
defaultRange, 2);
|
|
derivedCharKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE);
|
|
// Actual request/results will be derived by camera device.
|
|
derivedRequestKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST);
|
|
derivedResultKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add those newly added keys to AVAILABLE_CHARACTERISTICS_KEYS
|
|
// This has to be done at this end of this function.
|
|
if (derivedCharKeys.size() > 0) {
|
|
appendAvailableKeys(
|
|
chars, ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, derivedCharKeys);
|
|
}
|
|
if (derivedRequestKeys.size() > 0) {
|
|
appendAvailableKeys(
|
|
chars, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, derivedRequestKeys);
|
|
}
|
|
if (derivedResultKeys.size() > 0) {
|
|
appendAvailableKeys(
|
|
chars, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, derivedResultKeys);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void CameraModule::appendAvailableKeys(CameraMetadata &chars,
|
|
int32_t keyTag, const Vector<int32_t>& appendKeys) {
|
|
camera_metadata_entry entry = chars.find(keyTag);
|
|
Vector<int32_t> availableKeys;
|
|
availableKeys.setCapacity(entry.count + appendKeys.size());
|
|
for (size_t i = 0; i < entry.count; i++) {
|
|
availableKeys.push(entry.data.i32[i]);
|
|
}
|
|
for (size_t i = 0; i < appendKeys.size(); i++) {
|
|
availableKeys.push(appendKeys[i]);
|
|
}
|
|
chars.update(keyTag, availableKeys);
|
|
}
|
|
|
|
CameraModule::CameraModule(camera_module_t *module) : mNumberOfCameras(0) {
|
|
if (module == NULL) {
|
|
ALOGE("%s: camera hardware module must not be null", __FUNCTION__);
|
|
assert(0);
|
|
}
|
|
mModule = module;
|
|
}
|
|
|
|
CameraModule::~CameraModule()
|
|
{
|
|
while (mCameraInfoMap.size() > 0) {
|
|
camera_info cameraInfo = mCameraInfoMap.editValueAt(0);
|
|
if (cameraInfo.static_camera_characteristics != NULL) {
|
|
free_camera_metadata(
|
|
const_cast<camera_metadata_t*>(cameraInfo.static_camera_characteristics));
|
|
}
|
|
mCameraInfoMap.removeItemsAt(0);
|
|
}
|
|
|
|
while (mPhysicalCameraInfoMap.size() > 0) {
|
|
camera_metadata_t* metadata = mPhysicalCameraInfoMap.editValueAt(0);
|
|
if (metadata != NULL) {
|
|
free_camera_metadata(metadata);
|
|
}
|
|
mPhysicalCameraInfoMap.removeItemsAt(0);
|
|
}
|
|
}
|
|
|
|
int CameraModule::init() {
|
|
ATRACE_CALL();
|
|
int res = OK;
|
|
if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 &&
|
|
mModule->init != NULL) {
|
|
ATRACE_BEGIN("camera_module->init");
|
|
res = mModule->init();
|
|
ATRACE_END();
|
|
}
|
|
mNumberOfCameras = getNumberOfCameras();
|
|
mCameraInfoMap.setCapacity(mNumberOfCameras);
|
|
return res;
|
|
}
|
|
|
|
int CameraModule::getCameraInfo(int cameraId, struct camera_info *info) {
|
|
ATRACE_CALL();
|
|
Mutex::Autolock lock(mCameraInfoLock);
|
|
if (cameraId < 0) {
|
|
ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
|
|
return -EINVAL;
|
|
}
|
|
|
|
// Only override static_camera_characteristics for API2 devices
|
|
int apiVersion = mModule->common.module_api_version;
|
|
if (apiVersion < CAMERA_MODULE_API_VERSION_2_0) {
|
|
int ret;
|
|
ATRACE_BEGIN("camera_module->get_camera_info");
|
|
ret = mModule->get_camera_info(cameraId, info);
|
|
// Fill in this so CameraService won't be confused by
|
|
// possibly 0 device_version
|
|
info->device_version = CAMERA_DEVICE_API_VERSION_1_0;
|
|
ATRACE_END();
|
|
return ret;
|
|
}
|
|
|
|
ssize_t index = mCameraInfoMap.indexOfKey(cameraId);
|
|
if (index == NAME_NOT_FOUND) {
|
|
// Get camera info from raw module and cache it
|
|
camera_info rawInfo, cameraInfo;
|
|
ATRACE_BEGIN("camera_module->get_camera_info");
|
|
int ret = mModule->get_camera_info(cameraId, &rawInfo);
|
|
ATRACE_END();
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
int deviceVersion = rawInfo.device_version;
|
|
if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_0) {
|
|
// static_camera_characteristics is invalid
|
|
*info = rawInfo;
|
|
return ret;
|
|
}
|
|
CameraMetadata m;
|
|
m.append(rawInfo.static_camera_characteristics);
|
|
deriveCameraCharacteristicsKeys(rawInfo.device_version, m);
|
|
cameraInfo = rawInfo;
|
|
cameraInfo.static_camera_characteristics = m.release();
|
|
index = mCameraInfoMap.add(cameraId, cameraInfo);
|
|
}
|
|
|
|
assert(index != NAME_NOT_FOUND);
|
|
// return the cached camera info
|
|
*info = mCameraInfoMap[index];
|
|
return OK;
|
|
}
|
|
|
|
int CameraModule::getPhysicalCameraInfo(int physicalCameraId, camera_metadata_t **physicalInfo) {
|
|
ATRACE_CALL();
|
|
Mutex::Autolock lock(mCameraInfoLock);
|
|
if (physicalCameraId < mNumberOfCameras) {
|
|
ALOGE("%s: Invalid physical camera ID %d", __FUNCTION__, physicalCameraId);
|
|
return -EINVAL;
|
|
}
|
|
|
|
// Only query physical camera info for 2.5 version for newer
|
|
int apiVersion = mModule->common.module_api_version;
|
|
if (apiVersion < CAMERA_MODULE_API_VERSION_2_5) {
|
|
ALOGE("%s: Module version must be at least 2.5 to handle getPhysicalCameraInfo",
|
|
__FUNCTION__);
|
|
return -ENODEV;
|
|
}
|
|
if (mModule->get_physical_camera_info == nullptr) {
|
|
ALOGE("%s: get_physical_camera is NULL for module version 2.5", __FUNCTION__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ssize_t index = mPhysicalCameraInfoMap.indexOfKey(physicalCameraId);
|
|
if (index == NAME_NOT_FOUND) {
|
|
// Get physical camera characteristics, and cache it
|
|
camera_metadata_t *info = nullptr;
|
|
ATRACE_BEGIN("camera_module->get_physical_camera_info");
|
|
int ret = mModule->get_physical_camera_info(physicalCameraId, &info);
|
|
ATRACE_END();
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
|
|
// The camera_metadata_t returned by get_physical_camera_info could be using
|
|
// more memory than necessary due to unused reserved space. Reduce the
|
|
// size by appending it to a new CameraMetadata object, which internally
|
|
// calls resizeIfNeeded.
|
|
CameraMetadata m;
|
|
m.append(info);
|
|
camera_metadata_t* derivedMetadata = m.release();
|
|
index = mPhysicalCameraInfoMap.add(physicalCameraId, derivedMetadata);
|
|
}
|
|
|
|
assert(index != NAME_NOT_FOUND);
|
|
*physicalInfo = mPhysicalCameraInfoMap[index];
|
|
return OK;
|
|
}
|
|
|
|
int CameraModule::getDeviceVersion(int cameraId) {
|
|
ssize_t index = mDeviceVersionMap.indexOfKey(cameraId);
|
|
if (index == NAME_NOT_FOUND) {
|
|
int deviceVersion;
|
|
if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
|
|
struct camera_info info;
|
|
getCameraInfo(cameraId, &info);
|
|
deviceVersion = info.device_version;
|
|
} else {
|
|
deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
|
|
}
|
|
index = mDeviceVersionMap.add(cameraId, deviceVersion);
|
|
}
|
|
assert(index != NAME_NOT_FOUND);
|
|
return mDeviceVersionMap[index];
|
|
}
|
|
|
|
int CameraModule::open(const char* id, struct hw_device_t** device) {
|
|
int res;
|
|
ATRACE_BEGIN("camera_module->open");
|
|
res = filterOpenErrorCode(mModule->common.methods->open(&mModule->common, id, device));
|
|
ATRACE_END();
|
|
return res;
|
|
}
|
|
|
|
bool CameraModule::isOpenLegacyDefined() const {
|
|
if (getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_3) {
|
|
return false;
|
|
}
|
|
return mModule->open_legacy != NULL;
|
|
}
|
|
|
|
int CameraModule::openLegacy(
|
|
const char* id, uint32_t halVersion, struct hw_device_t** device) {
|
|
int res;
|
|
ATRACE_BEGIN("camera_module->open_legacy");
|
|
res = mModule->open_legacy(&mModule->common, id, halVersion, device);
|
|
ATRACE_END();
|
|
return res;
|
|
}
|
|
|
|
int CameraModule::getNumberOfCameras() {
|
|
int numCameras;
|
|
ATRACE_BEGIN("camera_module->get_number_of_cameras");
|
|
numCameras = mModule->get_number_of_cameras();
|
|
ATRACE_END();
|
|
return numCameras;
|
|
}
|
|
|
|
int CameraModule::setCallbacks(const camera_module_callbacks_t *callbacks) {
|
|
int res = OK;
|
|
ATRACE_BEGIN("camera_module->set_callbacks");
|
|
if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_1) {
|
|
res = mModule->set_callbacks(callbacks);
|
|
}
|
|
ATRACE_END();
|
|
return res;
|
|
}
|
|
|
|
bool CameraModule::isVendorTagDefined() const {
|
|
return mModule->get_vendor_tag_ops != NULL;
|
|
}
|
|
|
|
void CameraModule::getVendorTagOps(vendor_tag_ops_t* ops) {
|
|
if (mModule->get_vendor_tag_ops) {
|
|
ATRACE_BEGIN("camera_module->get_vendor_tag_ops");
|
|
mModule->get_vendor_tag_ops(ops);
|
|
ATRACE_END();
|
|
}
|
|
}
|
|
|
|
bool CameraModule::isSetTorchModeSupported() const {
|
|
if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
|
|
if (mModule->set_torch_mode == NULL) {
|
|
ALOGE("%s: Module 2.4 device must support set torch API!",
|
|
__FUNCTION__);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int CameraModule::setTorchMode(const char* camera_id, bool enable) {
|
|
int res = INVALID_OPERATION;
|
|
if (mModule->set_torch_mode != NULL) {
|
|
ATRACE_BEGIN("camera_module->set_torch_mode");
|
|
res = mModule->set_torch_mode(camera_id, enable);
|
|
ATRACE_END();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int CameraModule::isStreamCombinationSupported(int cameraId, camera_stream_combination_t *streams) {
|
|
int res = INVALID_OPERATION;
|
|
if (mModule->is_stream_combination_supported != NULL) {
|
|
ATRACE_BEGIN("camera_module->is_stream_combination_supported");
|
|
res = mModule->is_stream_combination_supported(cameraId, streams);
|
|
ATRACE_END();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void CameraModule::notifyDeviceStateChange(uint64_t deviceState) {
|
|
if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_5 &&
|
|
mModule->notify_device_state_change != NULL) {
|
|
ATRACE_BEGIN("camera_module->notify_device_state_change");
|
|
ALOGI("%s: calling notify_device_state_change with state %" PRId64, __FUNCTION__,
|
|
deviceState);
|
|
mModule->notify_device_state_change(deviceState);
|
|
ATRACE_END();
|
|
}
|
|
}
|
|
|
|
bool CameraModule::isLogicalMultiCamera(
|
|
const common::V1_0::helper::CameraMetadata& metadata,
|
|
std::unordered_set<std::string>* physicalCameraIds) {
|
|
if (physicalCameraIds == nullptr) {
|
|
ALOGE("%s: physicalCameraIds must not be null", __FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
bool isLogicalMultiCamera = false;
|
|
camera_metadata_ro_entry_t capabilities =
|
|
metadata.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
|
|
for (size_t i = 0; i < capabilities.count; i++) {
|
|
if (capabilities.data.u8[i] ==
|
|
ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA) {
|
|
isLogicalMultiCamera = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isLogicalMultiCamera) {
|
|
camera_metadata_ro_entry_t entry =
|
|
metadata.find(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS);
|
|
const uint8_t* ids = entry.data.u8;
|
|
size_t start = 0;
|
|
for (size_t i = 0; i < entry.count; ++i) {
|
|
if (ids[i] == '\0') {
|
|
if (start != i) {
|
|
const char* physicalId = reinterpret_cast<const char*>(ids+start);
|
|
physicalCameraIds->emplace(physicalId);
|
|
}
|
|
start = i + 1;
|
|
}
|
|
}
|
|
}
|
|
return isLogicalMultiCamera;
|
|
}
|
|
|
|
status_t CameraModule::filterOpenErrorCode(status_t err) {
|
|
switch(err) {
|
|
case NO_ERROR:
|
|
case -EBUSY:
|
|
case -EINVAL:
|
|
case -EUSERS:
|
|
return err;
|
|
default:
|
|
break;
|
|
}
|
|
return -ENODEV;
|
|
}
|
|
|
|
void CameraModule::removeCamera(int cameraId) {
|
|
// Skip HAL1 devices which isn't cached in mCameraInfoMap and don't advertise
|
|
// static_camera_characteristics
|
|
if (getDeviceVersion(cameraId) >= CAMERA_DEVICE_API_VERSION_3_0) {
|
|
std::unordered_set<std::string> physicalIds;
|
|
camera_metadata_t *metadata = const_cast<camera_metadata_t*>(
|
|
mCameraInfoMap.valueFor(cameraId).static_camera_characteristics);
|
|
common::V1_0::helper::CameraMetadata hidlMetadata(metadata);
|
|
|
|
if (isLogicalMultiCamera(hidlMetadata, &physicalIds)) {
|
|
for (const auto& id : physicalIds) {
|
|
int idInt = std::stoi(id);
|
|
if (mPhysicalCameraInfoMap.indexOfKey(idInt) >= 0) {
|
|
free_camera_metadata(mPhysicalCameraInfoMap[idInt]);
|
|
mPhysicalCameraInfoMap.removeItem(idInt);
|
|
} else {
|
|
ALOGE("%s: Cannot find corresponding static metadata for physical id %s",
|
|
__FUNCTION__, id.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mCameraInfoMap.removeItem(cameraId);
|
|
mDeviceVersionMap.removeItem(cameraId);
|
|
}
|
|
|
|
uint16_t CameraModule::getModuleApiVersion() const {
|
|
return mModule->common.module_api_version;
|
|
}
|
|
|
|
const char* CameraModule::getModuleName() const {
|
|
return mModule->common.name;
|
|
}
|
|
|
|
uint16_t CameraModule::getHalApiVersion() const {
|
|
return mModule->common.hal_api_version;
|
|
}
|
|
|
|
const char* CameraModule::getModuleAuthor() const {
|
|
return mModule->common.author;
|
|
}
|
|
|
|
void* CameraModule::getDso() {
|
|
return mModule->common.dso;
|
|
}
|
|
|
|
} // namespace helper
|
|
} // namespace V1_0
|
|
} // namespace common
|
|
} // namespace camera
|
|
} // namespace hardware
|
|
} // namespace android
|