blob: b027bbbee6e26199e6a79c58f74ec2886409a054 [file] [log] [blame]
/*
* 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 <sstream>
#include <fstream>
#include <thread>
#include <hardware/gralloc.h>
#include <utils/SystemClock.h>
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
#include "ConfigManager.h"
using ::android::hardware::camera::device::V3_2::StreamRotation;
ConfigManager::~ConfigManager() {
/* Nothing to do */
}
void ConfigManager::printElementNames(const XMLElement *rootElem,
string prefix) const {
const XMLElement *curElem = rootElem;
while (curElem != nullptr) {
LOG(VERBOSE) << "[ELEM] " << prefix << curElem->Name();
const XMLAttribute *curAttr = curElem->FirstAttribute();
while (curAttr) {
LOG(VERBOSE) << "[ATTR] " << prefix << curAttr->Name() << ": " << curAttr->Value();
curAttr = curAttr->Next();
}
/* recursively go down to descendants */
printElementNames(curElem->FirstChildElement(), prefix + "\t");
curElem = curElem->NextSiblingElement();
}
}
void ConfigManager::readCameraInfo(const XMLElement * const aCameraElem) {
if (aCameraElem == nullptr) {
LOG(WARNING) << "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)) {
LOG(WARNING) << "Failed to read a camera information of " << 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 */
mCameraGroups.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)) {
LOG(WARNING) << "Failed to read a camera information of " << 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 */
LOG(DEBUG) << "Unknown element " << curElem->Name() << " is ignored";
}
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)) {
LOG(WARNING) << "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(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)
) {
aCamera->cameraMetadata.insert_or_assign(
tag, make_pair((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((void *)data, len + 1)
);
++numEntries;
dataSize += calculate_camera_metadata_entry_data_size(
get_camera_metadata_tag_type(tag), len
);
break;
}
/* TODO(b/140416878): add vendor-defined/custom tag support */
default:
LOG(WARNING) << "Parameter "
<< curElem->FindAttribute("name")->Value()
<< " is not supported";
break;
}
} else {
LOG(WARNING) << "Unsupported metadata tag "
<< curElem->FindAttribute("name")->Value()
<< " is found.";
}
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)) {
LOG(ERROR) << "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) {
LOG(ERROR) << "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,
entry.second);
if (err) {
LOG(ERROR) << "Failed to add an entry with a tag, " << std::hex << tag;
/* may exceed preallocated capacity */
LOG(ERROR) << "Camera metadata has "
<< get_camera_metadata_entry_count(aCamera->characteristics)
<< " / "
<< get_camera_metadata_entry_capacity(aCamera->characteristics)
<< " entries and "
<< get_camera_metadata_data_count(aCamera->characteristics)
<< " / "
<< get_camera_metadata_data_capacity(aCamera->characteristics)
<< " bytes are filled.";
LOG(ERROR) << "\tCurrent metadata entry requires "
<< calculate_camera_metadata_entry_data_size(tag, entry.second)
<< " bytes.";
success = false;
}
}
LOG(VERBOSE) << "Camera metadata has "
<< get_camera_metadata_entry_count(aCamera->characteristics)
<< " / "
<< get_camera_metadata_entry_capacity(aCamera->characteristics)
<< " entries and "
<< get_camera_metadata_data_count(aCamera->characteristics)
<< " / "
<< get_camera_metadata_data_capacity(aCamera->characteristics)
<< " bytes are filled.";
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) {
LOG(WARNING) << "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) {
LOG(ERROR) << "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) {
LOG(ERROR) << "Failed to load and/or parse a configuration file, " << xmlDoc.ErrorStr();
return false;
}
/* retrieve the root element */
const XMLElement *rootElem = xmlDoc.RootElement();
if (strcmp(rootElem->Name(), "configuration")) {
LOG(ERROR) << "A configuration file is not in the required format. "
<< "See /etc/automotive/evs/evs_configuration.dtd";
return false;
}
unique_lock<mutex> lock(mConfigLock);
/*
* 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"));
/* configuration data is ready to be consumed */
mIsReady = true;
/* notify that configuration data is ready */
lock.unlock();
mConfigCond.notify_all();
const int64_t parsingEnd = android::elapsedRealtimeNano();
LOG(INFO) << "Parsing configuration file takes "
<< std::scientific << (double)(parsingEnd - parsingStart) / 1000000.0
<< " ms.";
return true;
}
bool ConfigManager::readConfigDataFromBinary() {
/* Temporary buffer to hold configuration data read from a binary file */
char mBuffer[1024];
fstream srcFile;
const int64_t readStart = android::elapsedRealtimeNano();
srcFile.open(mBinaryFilePath, fstream::in | fstream::binary);
if (!srcFile) {
LOG(ERROR) << "Failed to open a source binary file, " << mBinaryFilePath;
return false;
}
unique_lock<mutex> lock(mConfigLock);
mIsReady = false;
/* read configuration data into the internal buffer */
srcFile.read(mBuffer, sizeof(mBuffer));
LOG(VERBOSE) << __FUNCTION__ << ": " << srcFile.gcount() << " bytes are read.";
char *p = mBuffer;
size_t sz = 0;
/* read number of camera group information entries */
size_t ngrps = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
/* read each camera information entry */
for (auto cidx = 0; cidx < ngrps; ++cidx) {
/* read camera identifier */
string cameraId = *(reinterpret_cast<string *>(p)); p += sizeof(string);
/* size of camera_metadata_t */
size_t num_entry = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
size_t num_data = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
/* create CameraInfo and add it to hash map */
unique_ptr<ConfigManager::CameraGroupInfo> aCamera;
if (aCamera == nullptr ||
!aCamera->allocate(num_entry, num_data)) {
LOG(ERROR) << "Failed to create new CameraInfo object";
mCameraInfo.clear();
return false;
}
/* controls */
typedef struct {
CameraParam cid;
int32_t min;
int32_t max;
int32_t step;
} CameraCtrl;
sz = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
CameraCtrl *ptr = reinterpret_cast<CameraCtrl *>(p);
for (auto idx = 0; idx < sz; ++idx) {
CameraCtrl temp = *ptr++;
aCamera->controls.emplace(temp.cid,
make_tuple(temp.min, temp.max, temp.step));
}
p = reinterpret_cast<char *>(ptr);
/* stream configurations */
sz = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
int32_t *i32_ptr = reinterpret_cast<int32_t *>(p);
for (auto idx = 0; idx < sz; ++idx) {
const int32_t id = *i32_ptr++;
std::array<int32_t, kStreamCfgSz> temp;
for (auto i = 0; i < kStreamCfgSz; ++i) {
temp[i] = *i32_ptr++;
}
aCamera->streamConfigurations.insert_or_assign(id, temp);
}
p = reinterpret_cast<char *>(i32_ptr);
/* synchronization */
aCamera->synchronized =
*(reinterpret_cast<int32_t *>(p)); p += sizeof(int32_t);
for (auto idx = 0; idx < num_entry; ++idx) {
/* Read camera metadata entries */
camera_metadata_tag_t tag =
*reinterpret_cast<camera_metadata_tag_t *>(p);
p += sizeof(camera_metadata_tag_t);
size_t count = *reinterpret_cast<size_t *>(p); p += sizeof(size_t);
int32_t type = get_camera_metadata_tag_type(tag);
switch (type) {
case TYPE_BYTE: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(uint8_t);
break;
}
case TYPE_INT32: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(int32_t);
break;
}
case TYPE_FLOAT: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(float);
break;
}
case TYPE_INT64: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(int64_t);
break;
}
case TYPE_DOUBLE: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(double);
break;
}
case TYPE_RATIONAL:
p += count * sizeof(camera_metadata_rational_t);
break;
default:
LOG(WARNING) << "Type " << type << " is unknown; "
<< "data may be corrupted.";
break;
}
}
mCameraInfo.insert_or_assign(cameraId, std::move(aCamera));
}
/* read number of camera information entries */
size_t ncams = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
/* read each camera information entry */
for (auto cidx = 0; cidx < ncams; ++cidx) {
/* read camera identifier */
string cameraId = *(reinterpret_cast<string *>(p)); p += sizeof(string);
/* size of camera_metadata_t */
size_t num_entry = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
size_t num_data = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
/* create CameraInfo and add it to hash map */
unique_ptr<ConfigManager::CameraInfo> aCamera;
if (aCamera == nullptr ||
!aCamera->allocate(num_entry, num_data)) {
LOG(ERROR) << "Failed to create new CameraInfo object";
mCameraInfo.clear();
return false;
}
/* controls */
typedef struct {
CameraParam cid;
int32_t min;
int32_t max;
int32_t step;
} CameraCtrl;
sz = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
CameraCtrl *ptr = reinterpret_cast<CameraCtrl *>(p);
for (auto idx = 0; idx < sz; ++idx) {
CameraCtrl temp = *ptr++;
aCamera->controls.emplace(temp.cid,
make_tuple(temp.min, temp.max, temp.step));
}
p = reinterpret_cast<char *>(ptr);
/* stream configurations */
sz = *(reinterpret_cast<size_t *>(p)); p += sizeof(size_t);
int32_t *i32_ptr = reinterpret_cast<int32_t *>(p);
for (auto idx = 0; idx < sz; ++idx) {
const int32_t id = *i32_ptr++;
std::array<int32_t, kStreamCfgSz> temp;
for (auto i = 0; i < kStreamCfgSz; ++i) {
temp[i] = *i32_ptr++;
}
aCamera->streamConfigurations.insert_or_assign(id, temp);
}
p = reinterpret_cast<char *>(i32_ptr);
for (auto idx = 0; idx < num_entry; ++idx) {
/* Read camera metadata entries */
camera_metadata_tag_t tag =
*reinterpret_cast<camera_metadata_tag_t *>(p);
p += sizeof(camera_metadata_tag_t);
size_t count = *reinterpret_cast<size_t *>(p); p += sizeof(size_t);
int32_t type = get_camera_metadata_tag_type(tag);
switch (type) {
case TYPE_BYTE: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(uint8_t);
break;
}
case TYPE_INT32: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(int32_t);
break;
}
case TYPE_FLOAT: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(float);
break;
}
case TYPE_INT64: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(int64_t);
break;
}
case TYPE_DOUBLE: {
add_camera_metadata_entry(aCamera->characteristics,
tag,
p,
count);
p += count * sizeof(double);
break;
}
case TYPE_RATIONAL:
p += count * sizeof(camera_metadata_rational_t);
break;
default:
LOG(WARNING) << "Type " << type << " is unknown; "
<< "data may be corrupted.";
break;
}
}
mCameraInfo.insert_or_assign(cameraId, std::move(aCamera));
}
mIsReady = true;
/* notify that configuration data is ready */
lock.unlock();
mConfigCond.notify_all();
int64_t readEnd = android::elapsedRealtimeNano();
LOG(INFO) << __FUNCTION__ << " takes "
<< std::scientific << (double)(readEnd - readStart) / 1000000.0
<< " ms.";
return true;
}
bool ConfigManager::writeConfigDataToBinary() {
fstream outFile;
int64_t writeStart = android::elapsedRealtimeNano();
outFile.open(mBinaryFilePath, fstream::out | fstream::binary);
if (!outFile) {
LOG(ERROR) << "Failed to open a destination binary file, " << mBinaryFilePath;
return false;
}
/* lock a configuration data while it's being written to the filesystem */
lock_guard<mutex> lock(mConfigLock);
/* write camera group information */
size_t sz = mCameraGroups.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto&& [camId, camInfo] : mCameraGroups) {
LOG(INFO) << "Storing camera group " << camId;
/* write a camera identifier string */
outFile.write(reinterpret_cast<const char *>(&camId),
sizeof(string));
/* controls */
sz = camInfo->controls.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto&& [ctrl, range] : camInfo->controls) {
outFile.write(reinterpret_cast<const char *>(&ctrl),
sizeof(CameraParam));
outFile.write(reinterpret_cast<const char *>(&get<0>(range)),
sizeof(int32_t));
outFile.write(reinterpret_cast<const char *>(&get<1>(range)),
sizeof(int32_t));
outFile.write(reinterpret_cast<const char *>(&get<2>(range)),
sizeof(int32_t));
}
/* stream configurations */
sz = camInfo->streamConfigurations.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto&& [sid, cfg] : camInfo->streamConfigurations) {
outFile.write(reinterpret_cast<const char *>(sid),
sizeof(int32_t));
for (int idx = 0; idx < kStreamCfgSz; ++idx) {
outFile.write(reinterpret_cast<const char *>(&cfg[idx]),
sizeof(int32_t));
}
}
/* synchronization */
outFile.write(reinterpret_cast<const char *>(&camInfo->synchronized),
sizeof(int32_t));
/* size of camera_metadata_t */
size_t num_entry = 0;
size_t num_data = 0;
if (camInfo->characteristics != nullptr) {
num_entry = get_camera_metadata_entry_count(camInfo->characteristics);
num_data = get_camera_metadata_data_count(camInfo->characteristics);
}
outFile.write(reinterpret_cast<const char *>(&num_entry),
sizeof(size_t));
outFile.write(reinterpret_cast<const char *>(&num_data),
sizeof(size_t));
/* write each camera metadata entry */
if (num_entry > 0) {
camera_metadata_entry_t entry;
for (auto idx = 0; idx < num_entry; ++idx) {
if (get_camera_metadata_entry(camInfo->characteristics, idx, &entry)) {
LOG(ERROR) << "Failed to retrieve camera metadata entry " << idx;
outFile.close();
return false;
}
outFile.write(reinterpret_cast<const char *>(&entry.tag),
sizeof(entry.tag));
outFile.write(reinterpret_cast<const char *>(&entry.count),
sizeof(entry.count));
int32_t type = get_camera_metadata_tag_type(entry.tag);
switch (type) {
case TYPE_BYTE:
outFile.write(reinterpret_cast<const char *>(entry.data.u8),
sizeof(uint8_t) * entry.count);
break;
case TYPE_INT32:
outFile.write(reinterpret_cast<const char *>(entry.data.i32),
sizeof(int32_t) * entry.count);
break;
case TYPE_FLOAT:
outFile.write(reinterpret_cast<const char *>(entry.data.f),
sizeof(float) * entry.count);
break;
case TYPE_INT64:
outFile.write(reinterpret_cast<const char *>(entry.data.i64),
sizeof(int64_t) * entry.count);
break;
case TYPE_DOUBLE:
outFile.write(reinterpret_cast<const char *>(entry.data.d),
sizeof(double) * entry.count);
break;
case TYPE_RATIONAL:
[[fallthrough]];
default:
LOG(WARNING) << "Type " << type << " is not supported.";
break;
}
}
}
}
/* write camera device information */
sz = mCameraInfo.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto&& [camId, camInfo] : mCameraInfo) {
LOG(INFO) << "Storing camera " << camId;
/* write a camera identifier string */
outFile.write(reinterpret_cast<const char *>(&camId),
sizeof(string));
/* controls */
sz = camInfo->controls.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto& [ctrl, range] : camInfo->controls) {
outFile.write(reinterpret_cast<const char *>(&ctrl),
sizeof(CameraParam));
outFile.write(reinterpret_cast<const char *>(&get<0>(range)),
sizeof(int32_t));
outFile.write(reinterpret_cast<const char *>(&get<1>(range)),
sizeof(int32_t));
outFile.write(reinterpret_cast<const char *>(&get<2>(range)),
sizeof(int32_t));
}
/* stream configurations */
sz = camInfo->streamConfigurations.size();
outFile.write(reinterpret_cast<const char *>(&sz),
sizeof(size_t));
for (auto&& [sid, cfg] : camInfo->streamConfigurations) {
outFile.write(reinterpret_cast<const char *>(sid),
sizeof(int32_t));
for (int idx = 0; idx < kStreamCfgSz; ++idx) {
outFile.write(reinterpret_cast<const char *>(&cfg[idx]),
sizeof(int32_t));
}
}
/* size of camera_metadata_t */
size_t num_entry = 0;
size_t num_data = 0;
if (camInfo->characteristics != nullptr) {
num_entry = get_camera_metadata_entry_count(camInfo->characteristics);
num_data = get_camera_metadata_data_count(camInfo->characteristics);
}
outFile.write(reinterpret_cast<const char *>(&num_entry),
sizeof(size_t));
outFile.write(reinterpret_cast<const char *>(&num_data),
sizeof(size_t));
/* write each camera metadata entry */
if (num_entry > 0) {
camera_metadata_entry_t entry;
for (auto idx = 0; idx < num_entry; ++idx) {
if (get_camera_metadata_entry(camInfo->characteristics, idx, &entry)) {
LOG(ERROR) << "Failed to retrieve camera metadata entry " << idx;
outFile.close();
return false;
}
outFile.write(reinterpret_cast<const char *>(&entry.tag),
sizeof(entry.tag));
outFile.write(reinterpret_cast<const char *>(&entry.count),
sizeof(entry.count));
int32_t type = get_camera_metadata_tag_type(entry.tag);
switch (type) {
case TYPE_BYTE:
outFile.write(reinterpret_cast<const char *>(entry.data.u8),
sizeof(uint8_t) * entry.count);
break;
case TYPE_INT32:
outFile.write(reinterpret_cast<const char *>(entry.data.i32),
sizeof(int32_t) * entry.count);
break;
case TYPE_FLOAT:
outFile.write(reinterpret_cast<const char *>(entry.data.f),
sizeof(float) * entry.count);
break;
case TYPE_INT64:
outFile.write(reinterpret_cast<const char *>(entry.data.i64),
sizeof(int64_t) * entry.count);
break;
case TYPE_DOUBLE:
outFile.write(reinterpret_cast<const char *>(entry.data.d),
sizeof(double) * entry.count);
break;
case TYPE_RATIONAL:
[[fallthrough]];
default:
LOG(WARNING) << "Type " << type << " is not supported.";
break;
}
}
}
}
outFile.close();
int64_t writeEnd = android::elapsedRealtimeNano();
LOG(INFO) << __FUNCTION__ << " takes "
<< std::scientific << (double)(writeEnd - writeStart) / 1000000.0
<< " ms.";
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;
}
}
ConfigManager::CameraInfo::~CameraInfo() {
free_camera_metadata(characteristics);
for (auto&& [tag, val] : cameraMetadata) {
switch(tag) {
case ANDROID_LENS_DISTORTION:
case ANDROID_LENS_POSE_ROTATION:
case ANDROID_LENS_POSE_TRANSLATION:
case ANDROID_LENS_INTRINSIC_CALIBRATION: {
delete[] reinterpret_cast<float *>(val.first);
break;
}
case ANDROID_REQUEST_AVAILABLE_CAPABILITIES: {
delete[] \
reinterpret_cast<
camera_metadata_enum_android_request_available_capabilities_t *
>(val.first);
break;
}
case ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS: {
delete[] reinterpret_cast<char *>(val.first);
break;
}
default:
LOG(WARNING) << "Tag " << std::hex << tag << " is not supported. "
<< "Data may be corrupted?";
break;
}
}
}