467 lines
18 KiB
C++
467 lines
18 KiB
C++
/*
|
|
* Copyright (C) 2019 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.
|
|
*/
|
|
|
|
#include "ConfigManager.h"
|
|
|
|
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
|
|
#include <hardware/gralloc.h>
|
|
#include <utils/SystemClock.h>
|
|
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <thread>
|
|
|
|
namespace android::hardware::automotive::evs::V1_1::implementation {
|
|
|
|
using namespace std;
|
|
using namespace tinyxml2;
|
|
using hardware::camera::device::V3_2::StreamRotation;
|
|
|
|
ConfigManager::~ConfigManager() {
|
|
/* Nothing to do */
|
|
}
|
|
|
|
void ConfigManager::readCameraInfo(const XMLElement* const aCameraElem) {
|
|
if (aCameraElem == nullptr) {
|
|
ALOGW("XML file does not have required camera element");
|
|
return;
|
|
}
|
|
|
|
const XMLElement* curElem = aCameraElem->FirstChildElement();
|
|
while (curElem != nullptr) {
|
|
if (!strcmp(curElem->Name(), "group")) {
|
|
/* camera group identifier */
|
|
const char* id = curElem->FindAttribute("id")->Value();
|
|
|
|
/* create a camera group to be filled */
|
|
CameraGroupInfo* aCamera = new CameraGroupInfo();
|
|
|
|
/* read camera device information */
|
|
if (!readCameraDeviceInfo(aCamera, curElem)) {
|
|
ALOGW("Failed to read a camera information of %s", id);
|
|
delete aCamera;
|
|
continue;
|
|
}
|
|
|
|
/* camera group synchronization */
|
|
const char* sync = curElem->FindAttribute("synchronized")->Value();
|
|
if (!strcmp(sync, "CALIBRATED")) {
|
|
aCamera->synchronized = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED;
|
|
} else if (!strcmp(sync, "APPROXIMATE")) {
|
|
aCamera->synchronized = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE;
|
|
} else {
|
|
aCamera->synchronized = 0; // Not synchronized
|
|
}
|
|
|
|
/* add a group to hash map */
|
|
mCameraGroupInfos.insert_or_assign(id, unique_ptr<CameraGroupInfo>(aCamera));
|
|
} else if (!strcmp(curElem->Name(), "device")) {
|
|
/* camera unique identifier */
|
|
const char* id = curElem->FindAttribute("id")->Value();
|
|
|
|
/* camera mount location */
|
|
const char* pos = curElem->FindAttribute("position")->Value();
|
|
|
|
/* create a camera device to be filled */
|
|
CameraInfo* aCamera = new CameraInfo();
|
|
|
|
/* read camera device information */
|
|
if (!readCameraDeviceInfo(aCamera, curElem)) {
|
|
ALOGW("Failed to read a camera information of %s", id);
|
|
delete aCamera;
|
|
continue;
|
|
}
|
|
|
|
/* store read camera module information */
|
|
mCameraInfo.insert_or_assign(id, unique_ptr<CameraInfo>(aCamera));
|
|
|
|
/* assign a camera device to a position group */
|
|
mCameraPosition[pos].emplace(id);
|
|
} else {
|
|
/* ignore other device types */
|
|
ALOGD("Unknown element %s is ignored", curElem->Name());
|
|
}
|
|
|
|
curElem = curElem->NextSiblingElement();
|
|
}
|
|
}
|
|
|
|
bool ConfigManager::readCameraDeviceInfo(CameraInfo* aCamera, const XMLElement* aDeviceElem) {
|
|
if (aCamera == nullptr || aDeviceElem == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
/* size information to allocate camera_metadata_t */
|
|
size_t totalEntries = 0;
|
|
size_t totalDataSize = 0;
|
|
|
|
/* read device capabilities */
|
|
totalEntries +=
|
|
readCameraCapabilities(aDeviceElem->FirstChildElement("caps"), aCamera, totalDataSize);
|
|
|
|
/* read camera metadata */
|
|
totalEntries += readCameraMetadata(aDeviceElem->FirstChildElement("characteristics"), aCamera,
|
|
totalDataSize);
|
|
|
|
/* construct camera_metadata_t */
|
|
if (!constructCameraMetadata(aCamera, totalEntries, totalDataSize)) {
|
|
ALOGW("Either failed to allocate memory or "
|
|
"allocated memory was not large enough");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t ConfigManager::readCameraCapabilities(const XMLElement* const aCapElem, CameraInfo* aCamera,
|
|
size_t& dataSize) {
|
|
if (aCapElem == nullptr || aCamera == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
string token;
|
|
const XMLElement* curElem = nullptr;
|
|
|
|
/* a list of supported camera parameters/controls */
|
|
curElem = aCapElem->FirstChildElement("supported_controls");
|
|
if (curElem != nullptr) {
|
|
const XMLElement* ctrlElem = curElem->FirstChildElement("control");
|
|
while (ctrlElem != nullptr) {
|
|
const char* nameAttr = ctrlElem->FindAttribute("name")->Value();
|
|
;
|
|
const int32_t minVal = stoi(ctrlElem->FindAttribute("min")->Value());
|
|
const int32_t maxVal = stoi(ctrlElem->FindAttribute("max")->Value());
|
|
|
|
int32_t stepVal = 1;
|
|
const XMLAttribute* stepAttr = ctrlElem->FindAttribute("step");
|
|
if (stepAttr != nullptr) {
|
|
stepVal = stoi(stepAttr->Value());
|
|
}
|
|
|
|
CameraParam aParam;
|
|
if (ConfigManagerUtil::convertToEvsCameraParam(nameAttr, aParam)) {
|
|
aCamera->controls.emplace(aParam, make_tuple(minVal, maxVal, stepVal));
|
|
}
|
|
|
|
ctrlElem = ctrlElem->NextSiblingElement("control");
|
|
}
|
|
}
|
|
|
|
/* a list of camera stream configurations */
|
|
curElem = aCapElem->FirstChildElement("stream");
|
|
while (curElem != nullptr) {
|
|
/* read 5 attributes */
|
|
const XMLAttribute* idAttr = curElem->FindAttribute("id");
|
|
const XMLAttribute* widthAttr = curElem->FindAttribute("width");
|
|
const XMLAttribute* heightAttr = curElem->FindAttribute("height");
|
|
const XMLAttribute* fmtAttr = curElem->FindAttribute("format");
|
|
const XMLAttribute* fpsAttr = curElem->FindAttribute("framerate");
|
|
|
|
const int32_t id = stoi(idAttr->Value());
|
|
int32_t framerate = 0;
|
|
if (fpsAttr != nullptr) {
|
|
framerate = stoi(fpsAttr->Value());
|
|
}
|
|
|
|
int32_t pixFormat;
|
|
if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(), pixFormat)) {
|
|
RawStreamConfiguration cfg = {id,
|
|
stoi(widthAttr->Value()),
|
|
stoi(heightAttr->Value()),
|
|
pixFormat,
|
|
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
|
|
framerate};
|
|
aCamera->streamConfigurations.insert_or_assign(id, cfg);
|
|
}
|
|
|
|
curElem = curElem->NextSiblingElement("stream");
|
|
}
|
|
|
|
dataSize = calculate_camera_metadata_entry_data_size(
|
|
get_camera_metadata_tag_type(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS),
|
|
aCamera->streamConfigurations.size() * kStreamCfgSz);
|
|
|
|
/* a single camera metadata entry contains multiple stream configurations */
|
|
return dataSize > 0 ? 1 : 0;
|
|
}
|
|
|
|
size_t ConfigManager::readCameraMetadata(const XMLElement* const aParamElem, CameraInfo* aCamera,
|
|
size_t& dataSize) {
|
|
if (aParamElem == nullptr || aCamera == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
const XMLElement* curElem = aParamElem->FirstChildElement("parameter");
|
|
size_t numEntries = 0;
|
|
camera_metadata_tag_t tag;
|
|
while (curElem != nullptr) {
|
|
if (!ConfigManagerUtil::convertToMetadataTag(curElem->FindAttribute("name")->Value(),
|
|
tag)) {
|
|
switch (tag) {
|
|
case ANDROID_LENS_DISTORTION:
|
|
case ANDROID_LENS_POSE_ROTATION:
|
|
case ANDROID_LENS_POSE_TRANSLATION:
|
|
case ANDROID_LENS_INTRINSIC_CALIBRATION: {
|
|
/* float[] */
|
|
size_t count = 0;
|
|
void* data = ConfigManagerUtil::convertFloatArray(
|
|
curElem->FindAttribute("size")->Value(),
|
|
curElem->FindAttribute("value")->Value(), count);
|
|
|
|
aCamera->cameraMetadata.insert_or_assign(
|
|
tag, make_pair(make_unique<void*>(data), count));
|
|
|
|
++numEntries;
|
|
dataSize += calculate_camera_metadata_entry_data_size(
|
|
get_camera_metadata_tag_type(tag), count);
|
|
|
|
break;
|
|
}
|
|
|
|
case ANDROID_REQUEST_AVAILABLE_CAPABILITIES: {
|
|
camera_metadata_enum_android_request_available_capabilities_t* data =
|
|
new camera_metadata_enum_android_request_available_capabilities_t[1];
|
|
if (ConfigManagerUtil::convertToCameraCapability(
|
|
curElem->FindAttribute("value")->Value(), *data)) {
|
|
curElem->FindAttribute("value")->Value(),
|
|
aCamera->cameraMetadata.insert_or_assign(
|
|
tag, make_pair(make_unique<void*>(data), 1));
|
|
|
|
++numEntries;
|
|
dataSize += calculate_camera_metadata_entry_data_size(
|
|
get_camera_metadata_tag_type(tag), 1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {
|
|
/* a comma-separated list of physical camera devices */
|
|
size_t len = strlen(curElem->FindAttribute("value")->Value());
|
|
char* data = new char[len + 1];
|
|
memcpy(data, curElem->FindAttribute("value")->Value(), len * sizeof(char));
|
|
|
|
/* replace commas with null char */
|
|
char* p = data;
|
|
while (*p != '\0') {
|
|
if (*p == ',') {
|
|
*p = '\0';
|
|
}
|
|
++p;
|
|
}
|
|
|
|
aCamera->cameraMetadata.insert_or_assign(
|
|
tag, make_pair(make_unique<void*>(data), len));
|
|
|
|
++numEntries;
|
|
dataSize += calculate_camera_metadata_entry_data_size(
|
|
get_camera_metadata_tag_type(tag), len);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
ALOGW("Parameter %s is not supported", curElem->FindAttribute("name")->Value());
|
|
break;
|
|
}
|
|
}
|
|
|
|
curElem = curElem->NextSiblingElement("parameter");
|
|
}
|
|
|
|
return numEntries;
|
|
}
|
|
|
|
bool ConfigManager::constructCameraMetadata(CameraInfo* aCamera, const size_t totalEntries,
|
|
const size_t totalDataSize) {
|
|
if (aCamera == nullptr || !aCamera->allocate(totalEntries, totalDataSize)) {
|
|
ALOGE("Failed to allocate memory for camera metadata");
|
|
return false;
|
|
}
|
|
|
|
const size_t numStreamConfigs = aCamera->streamConfigurations.size();
|
|
unique_ptr<int32_t[]> data(new int32_t[kStreamCfgSz * numStreamConfigs]);
|
|
int32_t* ptr = data.get();
|
|
for (auto& cfg : aCamera->streamConfigurations) {
|
|
for (auto i = 0; i < kStreamCfgSz; ++i) {
|
|
*ptr++ = cfg.second[i];
|
|
}
|
|
}
|
|
int32_t err = add_camera_metadata_entry(aCamera->characteristics,
|
|
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
|
|
data.get(), numStreamConfigs * kStreamCfgSz);
|
|
|
|
if (err) {
|
|
ALOGE("Failed to add stream configurations to metadata, ignored");
|
|
return false;
|
|
}
|
|
|
|
bool success = true;
|
|
for (auto& [tag, entry] : aCamera->cameraMetadata) {
|
|
/* try to add new camera metadata entry */
|
|
int32_t err = add_camera_metadata_entry(aCamera->characteristics, tag, entry.first.get(),
|
|
entry.second);
|
|
if (err) {
|
|
ALOGE("Failed to add an entry with a tag 0x%X", tag);
|
|
|
|
/* may exceed preallocated capacity */
|
|
ALOGE("Camera metadata has %ld / %ld entries and %ld / %ld bytes are filled",
|
|
(long)get_camera_metadata_entry_count(aCamera->characteristics),
|
|
(long)get_camera_metadata_entry_capacity(aCamera->characteristics),
|
|
(long)get_camera_metadata_data_count(aCamera->characteristics),
|
|
(long)get_camera_metadata_data_capacity(aCamera->characteristics));
|
|
ALOGE("\tCurrent metadata entry requires %ld bytes",
|
|
(long)calculate_camera_metadata_entry_data_size(tag, entry.second));
|
|
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
ALOGV("Camera metadata has %ld / %ld entries and %ld / %ld bytes are filled",
|
|
(long)get_camera_metadata_entry_count(aCamera->characteristics),
|
|
(long)get_camera_metadata_entry_capacity(aCamera->characteristics),
|
|
(long)get_camera_metadata_data_count(aCamera->characteristics),
|
|
(long)get_camera_metadata_data_capacity(aCamera->characteristics));
|
|
|
|
return success;
|
|
}
|
|
|
|
void ConfigManager::readSystemInfo(const XMLElement* const aSysElem) {
|
|
if (aSysElem == nullptr) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Please note that this function assumes that a given system XML element
|
|
* and its child elements follow DTD. If it does not, it will cause a
|
|
* segmentation fault due to the failure of finding expected attributes.
|
|
*/
|
|
|
|
/* read number of cameras available in the system */
|
|
const XMLElement* xmlElem = aSysElem->FirstChildElement("num_cameras");
|
|
if (xmlElem != nullptr) {
|
|
mSystemInfo.numCameras = stoi(xmlElem->FindAttribute("value")->Value());
|
|
}
|
|
}
|
|
|
|
void ConfigManager::readDisplayInfo(const XMLElement* const aDisplayElem) {
|
|
if (aDisplayElem == nullptr) {
|
|
ALOGW("XML file does not have required camera element");
|
|
return;
|
|
}
|
|
|
|
const XMLElement* curDev = aDisplayElem->FirstChildElement("device");
|
|
while (curDev != nullptr) {
|
|
const char* id = curDev->FindAttribute("id")->Value();
|
|
// const char *pos = curDev->FirstAttribute("position")->Value();
|
|
|
|
unique_ptr<DisplayInfo> dpy(new DisplayInfo());
|
|
if (dpy == nullptr) {
|
|
ALOGE("Failed to allocate memory for DisplayInfo");
|
|
return;
|
|
}
|
|
|
|
const XMLElement* cap = curDev->FirstChildElement("caps");
|
|
if (cap != nullptr) {
|
|
const XMLElement* curStream = cap->FirstChildElement("stream");
|
|
while (curStream != nullptr) {
|
|
/* read 4 attributes */
|
|
const XMLAttribute* idAttr = curStream->FindAttribute("id");
|
|
const XMLAttribute* widthAttr = curStream->FindAttribute("width");
|
|
const XMLAttribute* heightAttr = curStream->FindAttribute("height");
|
|
const XMLAttribute* fmtAttr = curStream->FindAttribute("format");
|
|
|
|
const int32_t id = stoi(idAttr->Value());
|
|
int32_t pixFormat;
|
|
if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(), pixFormat)) {
|
|
RawStreamConfiguration cfg = {
|
|
id,
|
|
stoi(widthAttr->Value()),
|
|
stoi(heightAttr->Value()),
|
|
pixFormat,
|
|
ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT,
|
|
0 // unused
|
|
};
|
|
dpy->streamConfigurations.insert_or_assign(id, cfg);
|
|
}
|
|
|
|
curStream = curStream->NextSiblingElement("stream");
|
|
}
|
|
}
|
|
|
|
mDisplayInfo.insert_or_assign(id, std::move(dpy));
|
|
curDev = curDev->NextSiblingElement("device");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
bool ConfigManager::readConfigDataFromXML() noexcept {
|
|
XMLDocument xmlDoc;
|
|
|
|
const int64_t parsingStart = android::elapsedRealtimeNano();
|
|
|
|
/* load and parse a configuration file */
|
|
xmlDoc.LoadFile(mConfigFilePath);
|
|
if (xmlDoc.ErrorID() != XML_SUCCESS) {
|
|
ALOGE("Failed to load and/or parse a configuration file, %s", xmlDoc.ErrorStr());
|
|
return false;
|
|
}
|
|
|
|
/* retrieve the root element */
|
|
const XMLElement* rootElem = xmlDoc.RootElement();
|
|
if (strcmp(rootElem->Name(), "configuration")) {
|
|
ALOGE("A configuration file is not in the required format. "
|
|
"See /etc/automotive/evs/evs_configuration.dtd");
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* parse camera information; this needs to be done before reading system
|
|
* information
|
|
*/
|
|
readCameraInfo(rootElem->FirstChildElement("camera"));
|
|
|
|
/* parse system information */
|
|
readSystemInfo(rootElem->FirstChildElement("system"));
|
|
|
|
/* parse display information */
|
|
readDisplayInfo(rootElem->FirstChildElement("display"));
|
|
|
|
const int64_t parsingEnd = android::elapsedRealtimeNano();
|
|
ALOGI("Parsing configuration file takes %lf (ms)",
|
|
(double)(parsingEnd - parsingStart) / 1000000.0);
|
|
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<ConfigManager> ConfigManager::Create(const char* path) {
|
|
unique_ptr<ConfigManager> cfgMgr(new ConfigManager(path));
|
|
|
|
/*
|
|
* Read a configuration from XML file
|
|
*
|
|
* If this is too slow, ConfigManager::readConfigDataFromBinary() and
|
|
* ConfigManager::writeConfigDataToBinary()can serialize CameraInfo object
|
|
* to the filesystem and construct CameraInfo instead; this was
|
|
* evaluated as 10x faster.
|
|
*/
|
|
if (!cfgMgr->readConfigDataFromXML()) {
|
|
return nullptr;
|
|
} else {
|
|
return cfgMgr;
|
|
}
|
|
}
|
|
|
|
} // namespace android::hardware::automotive::evs::V1_1::implementation
|