| /* |
| * Copyright (C) 2013-2017 Intel Corporation |
| * Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd |
| * |
| * 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 "Profiles" |
| |
| #include <expat.h> |
| #include <limits.h> |
| #include <system/camera_metadata.h> |
| |
| #include "LogHelper.h" |
| #include "CameraProfiles.h" |
| #include "Metadata.h" |
| #include "CameraMetadataHelper.h" |
| #include "IPSLConfParser.h" |
| #include "Utils.h" |
| |
| #include "PSLConfParser.h" |
| |
| /** |
| * Platform specific implementation |
| */ |
| #include "ChromeCameraProfiles.h" |
| |
| #define STATIC_ENTRY_CAP 256 |
| #define STATIC_DATA_CAP 6688 // TODO: we may need to increase it again if more metadata is added |
| #define MAX_METADATA_NAME_LENTGTH 128 |
| #define MAX_METADATA_ATTRIBUTE_NAME_LENTGTH 128 |
| #define MAX_METADATA_ATTRIBUTE_VALUE_LENTGTH 6144 |
| |
| NAMESPACE_DECLARATION { |
| CameraProfiles::CameraProfiles(CameraHWInfo *cameraHWInfo) : |
| mCurrentDataField(FIELD_INVALID), |
| mMetadataCache(nullptr), |
| mSensorIndex(-1), |
| mXmlSensorIndex(-1), |
| mItemsCount(-1), |
| mCameraCommon(cameraHWInfo), |
| mUseEntry(true) |
| { |
| CLEAR(mProfileEnd); |
| } |
| |
| status_t CameraProfiles::init() |
| { |
| LOG1("@%s", __FUNCTION__); |
| |
| if (!mCameraCommon) { |
| LOGE("CameraHWInfo is nullptr"); |
| return BAD_VALUE; |
| } |
| |
| mCameraCommon->init(PSLConfParser::getSensorMediaDevicePath()); |
| |
| // Assumption: Driver enumeration order will match the CameraId |
| // CameraId in camera_profiles.xml. Main camera is always at |
| // index 0, front camera at index 1. |
| if (mCameraCommon->mSensorInfo.empty()) { |
| LOGE("No sensor Info available, exit parsing"); |
| return UNKNOWN_ERROR; |
| } |
| |
| mSensorNames = mCameraCommon->mSensorInfo; |
| |
| mCameraInfoPool.init(MAX_CAMERAS); |
| for (int i = 0;i < MAX_CAMERAS; i++) |
| mCharacteristicsKeys[i].clear(); |
| |
| return OK; |
| } |
| |
| void CameraProfiles::createConfParser() |
| { |
| // Now parse PSL sections for found cameras |
| for (const auto &cameraIdToCameraInfo : mCameraIdToCameraInfo) { |
| // get psl parser |
| CameraInfo *info = cameraIdToCameraInfo.second; |
| info->parser = PSLConfParser::getInstance(mXmlConfigName, mSensorNames); |
| } |
| } |
| |
| void CameraProfiles::destroyConfParser() |
| { |
| PSLConfParser::deleteInstance(); |
| } |
| |
| int CameraProfiles::getXmlCameraId(int cameraId) const |
| { |
| LOG2("@%s", __FUNCTION__); |
| std::map<int, CameraInfo*>::const_iterator it = |
| mCameraIdToCameraInfo.find(cameraId); |
| if (it == mCameraIdToCameraInfo.end()) { |
| return NAME_NOT_FOUND; |
| } |
| return it->second->xmlCameraId; |
| } |
| |
| CameraProfiles::~CameraProfiles() |
| { |
| LOG2("@%s", __FUNCTION__); |
| for (unsigned int i = 0; i < mStaticMeta.size(); i++) { |
| if (mStaticMeta[i]) |
| free_camera_metadata(mStaticMeta[i]); |
| } |
| |
| mStaticMeta.clear(); |
| |
| for (const auto &cameraIdToCameraInfo : mCameraIdToCameraInfo) { |
| CameraInfo *info = cameraIdToCameraInfo.second; |
| mCameraInfoPool.releaseItem(info); |
| } |
| |
| mCameraIdToCameraInfo.clear(); |
| |
| mSensorNames.clear(); |
| } |
| |
| const CameraCapInfo *CameraProfiles::getCameraCapInfo(int cameraId) |
| { |
| // get the psl parser instance for cameraid |
| IPSLConfParser *parserInstance; |
| std::map<int, CameraInfo*>::iterator it = |
| mCameraIdToCameraInfo.find(cameraId); |
| if (it == mCameraIdToCameraInfo.end()) { |
| LOGE("Camera id: %d not found. Sensor might not be live", cameraId); |
| return nullptr; |
| } |
| CameraInfo *info = it->second; |
| parserInstance = info->parser; |
| |
| if (parserInstance == nullptr) { |
| LOGE("Failed to get PSL parser instance"); |
| return nullptr; |
| } |
| |
| return parserInstance->getCameraCapInfo(cameraId); |
| } |
| |
| const CameraCapInfo *CameraProfiles::getCameraCapInfoForXmlCameraId(int xmlCameraId) |
| { |
| // get the psl parser instance for cameraid |
| IPSLConfParser *parserInstance; |
| |
| int cameraId = -1; |
| for (const auto &cameraIdToCameraInfo : mCameraIdToCameraInfo) { |
| if (cameraIdToCameraInfo.second->xmlCameraId == xmlCameraId) { |
| cameraId = cameraIdToCameraInfo.first; |
| break; |
| } |
| } |
| if (cameraId == -1) |
| return nullptr; |
| |
| CameraInfo *info = mCameraIdToCameraInfo[cameraId]; |
| parserInstance = info->parser; |
| |
| if (parserInstance == nullptr) { |
| LOGE("Failed to get PSL parser instance"); |
| return nullptr; |
| } |
| |
| return parserInstance->getCameraCapInfo(cameraId); |
| } |
| |
| camera_metadata_t *CameraProfiles::constructDefaultMetadata(int cameraId, int requestTemplate) |
| { |
| // get the psl parser instance for cameraid |
| IPSLConfParser *parserInstance; |
| std::map<int, CameraInfo*>::iterator it = |
| mCameraIdToCameraInfo.find(cameraId); |
| if (it == mCameraIdToCameraInfo.end()) { |
| LOGE("Failed to get camera info for camera:%d", cameraId); |
| return nullptr; |
| } |
| |
| CameraInfo *info = it->second; |
| parserInstance = info->parser; |
| |
| if (parserInstance == nullptr) { |
| LOGE("Failed to get PSL parser instance"); |
| return nullptr; |
| } |
| |
| return parserInstance->constructDefaultMetadata(cameraId, requestTemplate); |
| |
| } |
| |
| status_t CameraProfiles::addCamera(int cameraId) |
| { |
| LOG1("%s: for camera %d", __FUNCTION__, cameraId); |
| |
| camera_metadata_t * meta = allocate_camera_metadata(STATIC_ENTRY_CAP, STATIC_DATA_CAP); |
| if (!meta) { |
| LOGE("No memory for camera metadata!"); |
| return NO_MEMORY; |
| } |
| LOG2("Add cameraId: %d to mStaticMeta", cameraId); |
| mStaticMeta.push_back(meta); |
| |
| return NO_ERROR; |
| } |
| |
| /** |
| * convertEnum |
| * Converts from the string provided as src to an enum value. |
| * It uses a table to convert from the string to an enum value (usually BYTE) |
| * \param [IN] dest: data buffer where to store the result |
| * \param [IN] src: pointer to the string to parse |
| * \param [IN] table: table to convert from string to value |
| * \param [IN] tableNum: size of the enum table |
| * \param [IN] type: data type to be parsed (byte, int32, int64 etc..) |
| * \param [OUT] newDest: pointer to the new write location |
| */ |
| int CameraProfiles::convertEnum(void *dest, const char *src, int type, |
| const metadata_value_t *table, int tableLen, |
| void **newDest) |
| { |
| int ret = 0; |
| union { |
| uint8_t * u8; |
| int32_t * i32; |
| int64_t * i64; |
| } data; |
| |
| *newDest = dest; |
| data.u8 = (uint8_t *)dest; |
| |
| /* ignore any spaces in front of the string */ |
| size_t blanks = strspn(src," "); |
| src = src + blanks; |
| |
| for (int i = 0; i < tableLen; i++ ) { |
| if (!strncasecmp(src, table[i].name, STRLEN_S(table[i].name)) |
| && (STRLEN_S(src) == STRLEN_S(table[i].name))) { |
| if (type == TYPE_BYTE) { |
| data.u8[0] = table[i].value; |
| LOG1("byte - %s: %d -", table[i].name, data.u8[0]); |
| *newDest = (void*) &data.u8[1]; |
| } else if (type == TYPE_INT32) { |
| data.i32[0] = table[i].value; |
| LOG1("int - %s: %d -", table[i].name, data.i32[0]); |
| *newDest = (void*) &data.i32[1]; |
| } else if (type == TYPE_INT64) { |
| data.i64[0] = table[i].value; |
| LOG1("int64 - %s: %" PRId64 " -", table[i].name, data.i64[0]); |
| *newDest = (void*) &data.i64[1]; |
| } |
| ret = 1; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| /** |
| * parseEnum |
| * parses an enumeration type or a list of enumeration types it stores the data |
| * in the member buffer mMetadataCache that is of size mMetadataCacheSize. |
| * |
| * \param src: string to be parsed |
| * \param tagInfo: structure with the description of the static metadata |
| * \param metadataCacheSize:the upper limited size of the dest buffer |
| * \param metadataCache: the dest buffer to store the medatada after persed |
| * \return number of elements parsed |
| */ |
| int CameraProfiles::parseEnum(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int count = 0; |
| int maxCount = metadataCacheSize / camera_metadata_type_size[tagInfo->type]; |
| char *endPtr = nullptr; |
| |
| /** |
| * pointer to the metadata cache buffer |
| */ |
| void *storeBuf = metadataCache; |
| void *next; |
| |
| do { |
| endPtr = (char*) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| |
| count += convertEnum(storeBuf, src,tagInfo->type, |
| tagInfo->enumTable, tagInfo->tableLength, &next); |
| if (endPtr) { |
| src = endPtr + 1; |
| storeBuf = next; |
| } |
| } while (count < maxCount && endPtr); |
| |
| return count; |
| } |
| |
| /** |
| * parseEnumAndNumbers |
| * parses an enumeration type or a list of enumeration types or tries to convert string to a number |
| * it stores the data in the member buffer mMetadataCache that is of size mMetadataCacheSize. |
| * |
| * \param src: string to be parsed |
| * \param tagInfo: structure with the description of the static metadata |
| * \param metadataCacheSize:the upper limited size of the dest buffer |
| * \param metadataCache: the dest buffer to store the medatada after persed |
| * \return number of elements parsed |
| */ |
| int CameraProfiles::parseEnumAndNumbers(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int count = 0; |
| int maxCount = metadataCacheSize / camera_metadata_type_size[tagInfo->type]; |
| char * endPtr = nullptr; |
| |
| /** |
| * pointer to the metadata cache buffer |
| */ |
| void *storeBuf = metadataCache; |
| void *next; |
| |
| do { |
| endPtr = (char *) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| |
| count += convertEnum(storeBuf, src,tagInfo->type, |
| tagInfo->enumTable, tagInfo->tableLength, &next); |
| /* Try to convert value to number */ |
| if (count == 0) { |
| long int *number = reinterpret_cast<long int*>(storeBuf); |
| *number = strtol(src, &endPtr, 10); |
| if (*number == LONG_MAX || *number == LONG_MIN) |
| LOGW("You might have invalid value in the camera profiles: %s", src); |
| count++; |
| } |
| |
| if (endPtr) { |
| src = endPtr + 1; |
| storeBuf = next; |
| } |
| } while (count < maxCount && endPtr); |
| |
| return count; |
| } |
| |
| /** |
| * parseData |
| * parses a generic array type. It stores the data in the member buffer |
| * mMetadataCache that is of size mMetadataCacheSize. |
| * |
| * \param src: string to be parsed |
| * \param tagInfo: structure with the description of the static metadata |
| * \param metadataCacheSize:the upper limited size of the dest buffer |
| * \param metadataCache: the dest buffer to store the medatada after persed |
| * \return number of elements parsed |
| */ |
| int CameraProfiles::parseData(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int index = 0; |
| int maxIndex = metadataCacheSize/sizeof(double); // worst case |
| |
| char * endPtr = nullptr; |
| union { |
| uint8_t * u8; |
| int32_t * i32; |
| int64_t * i64; |
| float * f; |
| double * d; |
| } data; |
| data.u8 = (uint8_t *)metadataCache; |
| |
| do { |
| switch (tagInfo->type) { |
| case TYPE_BYTE: |
| data.u8[index] = (char)strtol(src, &endPtr, 10); |
| LOG2(" - %d -", data.u8[index]); |
| break; |
| case TYPE_INT32: |
| case TYPE_RATIONAL: |
| data.i32[index] = strtol(src, &endPtr, 10); |
| LOG2(" - %d -", data.i32[index]); |
| break; |
| case TYPE_INT64: |
| data.i64[index] = strtol(src, &endPtr, 10); |
| LOG2(" - %" PRId64 " -", data.i64[index]); |
| break; |
| case TYPE_FLOAT: |
| data.f[index] = strtof(src, &endPtr); |
| LOG2(" - %8.3f -", data.f[index]); |
| break; |
| case TYPE_DOUBLE: |
| data.d[index] = strtof(src, &endPtr); |
| LOG2(" - %8.3f -", data.d[index]); |
| break; |
| } |
| index++; |
| if (endPtr != nullptr) { |
| if (*endPtr == ',' || *endPtr == 'x') |
| src = endPtr + 1; |
| else if (*endPtr == ')') |
| src = endPtr + 3; |
| else if (*endPtr == 0) |
| break; |
| } |
| } while (index < maxIndex); |
| |
| if (tagInfo->type == TYPE_RATIONAL) { |
| if (index % 2) { |
| LOGW("Invalid number of entries to define rational (%d) in tag %s." |
| " It should be even", index, tagInfo->name); |
| // lets make it even |
| index -= 1; |
| } |
| index = index / 2; |
| // we divide by 2 because one rational is made of 2 ints |
| } |
| |
| return index; |
| } |
| |
| |
| const char *CameraProfiles::skipWhiteSpace(const char *src) |
| { |
| /* Skip whitespace. (space, tab, newline, vertical tab, feed, carriage return) */ |
| while( *src == '\n' || *src == '\t' || *src == ' ' || *src == '\v' || *src == '\r' || *src == '\f' ) { |
| src++; |
| } |
| return src; |
| } |
| |
| /** |
| * Parses the string with the supported stream configurations |
| * a stream configuration is made of 3 elements |
| * - Format |
| * - Resolution |
| * - Direction (input or output) |
| * we parse the string in 3 steps |
| * example of valid stream configuration is: |
| * RAW16,4208x3120,INPUT |
| * \param src: string to be parsed |
| * \param tagInfo: descriptor of the static metadata. this is the entry from the |
| * table defined in the autogenerated code |
| * \param metadataCacheSize:the upper limited size of the dest buffer |
| * \param metadataCache: the dest buffer to store the medatada after persed |
| * |
| * \return number of int32 entries to be stored (i.e. 4 per configuration found) |
| */ |
| int CameraProfiles::parseStreamConfig(const char *src, |
| const metadata_tag_t *tagInfo, |
| std::vector<MetaValueRefTable> refTables, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| |
| int count = 0; // entry count |
| int maxCount = metadataCacheSize/sizeof(int32_t); |
| int ret; |
| char * endPtr = nullptr; |
| int parseStep = 1; |
| int32_t *i32; |
| |
| const metadata_value_t * activeTable; |
| int activeTableLen = 0; |
| |
| void *storeBuf = metadataCache; |
| void *next; |
| |
| if (refTables.size() < 2) { |
| LOGE("incomplete reference table :%zu", refTables.size()); |
| return count; |
| } |
| |
| do { |
| endPtr = (char *) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| |
| if (parseStep == 1) { |
| activeTable = refTables[0].table; |
| activeTableLen = refTables[0].tableSize; |
| } else if (parseStep == 3) { |
| activeTable = refTables[1].table; |
| activeTableLen = refTables[1].tableSize; |
| } |
| |
| if (parseStep == 1 || parseStep == 3) { |
| ret = convertEnum(storeBuf, src, tagInfo->type, activeTable, |
| activeTableLen, &next); |
| if (ret == 1) { |
| count++; |
| storeBuf = next; |
| } else { |
| LOGE("Malformed enum in stream configuration %s", src); |
| goto parseError; |
| } |
| |
| } else { // Step 2: Parse the resolution |
| i32 = reinterpret_cast<int32_t*>(storeBuf); |
| i32[0] = strtol(src, &endPtr, 10); |
| if (endPtr == nullptr || *endPtr != 'x') { |
| LOGE("Malformed resolution in stream configuration"); |
| goto parseError; |
| } |
| src = endPtr + 1; |
| i32[1] = strtol(src, &endPtr, 10); |
| storeBuf = reinterpret_cast<void*>(&i32[2]); |
| count += 2; |
| LOG1(" - %dx%d -", i32[0], i32[1]); |
| } |
| |
| if (endPtr) { |
| src = endPtr + 1; |
| src = skipWhiteSpace(src); |
| parseStep++; |
| /* parsing steps go from 1 to 3 */ |
| if (parseStep == 4) { |
| parseStep = 1; |
| LOG1("Stream Configuration found"); |
| } |
| } else { |
| break; |
| } |
| } while (count < maxCount); |
| |
| if (endPtr != nullptr) { |
| LOGW("Stream configuration stream too long for parser"); |
| } |
| /** |
| * Total number of entries per stream configuration is 4 |
| * - one for the format |
| * - two for the resolution |
| * - one for the direction |
| * The total entry count should be multiple of 4 |
| */ |
| if (count % 4) { |
| LOGE("Malformed string for stream configuration." |
| " ignoring last %d entries", count % 4); |
| count -= count % 4; |
| } |
| return count; |
| |
| parseError: |
| LOGE("Error parsing stream configuration "); |
| return 0; |
| } |
| /** |
| * parseAvailableKeys |
| * This method is used to parse the following two static metadata tags: |
| * android.request.availableRequestKeys |
| * android.request.availableResultKeys |
| * |
| * It uses the auto-generated table metadataNames to look for all the non |
| * static tags. |
| */ |
| int CameraProfiles::parseAvailableKeys(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int count = 0; // entry count |
| int maxCount = metadataCacheSize/camera_metadata_type_size[tagInfo->type]; |
| size_t tableSize = ELEMENT(metadataNames); |
| size_t blanks, tokenSize; |
| const char *token; |
| const char *cleanToken; |
| const char delim = ','; |
| int32_t* storeBuf = (int32_t*)metadataCache; |
| std::vector<std::string> tokens; |
| getTokens(src, delim, tokens); |
| |
| for (size_t i = 0; i < tokens.size(); i++) { |
| token = tokens.at(i).c_str(); |
| /* ignore any spaces in front of the string */ |
| blanks = strspn(token," "); |
| cleanToken = token + blanks; |
| /** |
| * Parse the token without blanks. |
| * TODO: Add support for simple wildcard to allow things like |
| * android.request.* |
| */ |
| tokenSize = STRLEN_S(cleanToken); |
| for (unsigned int i = 0; i< tableSize; i++) { |
| if (strncmp(cleanToken, metadataNames[i].name, tokenSize) == 0) { |
| storeBuf[count] = metadataNames[i].value; |
| count++; |
| } |
| } |
| if (count >= maxCount) { |
| LOGW("Too many keys found (%d)- ignoring the rest", count); |
| /* if this happens then we should increase the size of the |
| * mMetadataCache |
| */ |
| break; |
| } |
| } |
| return count; |
| } |
| |
| /** |
| * Parses the string with the avaialble input-output formats map |
| * a format map is made of 3 elements |
| * - Input Format |
| * - Number output formats it can be converted in to |
| * - List of the output formats. |
| * we parse the string in 3 steps |
| * example of valid input-output formats map is: |
| * RAW_OPAQUE,3,BLOB,IMPLEMENTATION_DEFINED,YCbCr_420_888 |
| * |
| * \param src: string to be parsed |
| * \param tagInfo: descriptor of the static metadata. this is the entry from the |
| * table defined in the autogenerated code |
| * \param metadataCacheSize:the upper limit size of the dest buffer |
| * \param metadataCache: the dest buffer to store the medatada after persed |
| * |
| * \return number of int32 entries to be stored |
| */ |
| int CameraProfiles::parseAvailableInputOutputFormatsMap(const char *src, |
| const metadata_tag_t *tagInfo, |
| std::vector<MetaValueRefTable> refTables, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| |
| int count = 0; // entry count |
| int maxCount = metadataCacheSize/camera_metadata_type_size[tagInfo->type]; |
| int ret; |
| char * endPtr = nullptr; |
| int parseStep = 1; |
| int32_t *i32; |
| int numOutputFormats = 0; |
| |
| const metadata_value_t * activeTable; |
| int activeTableLen = 0; |
| |
| void *storeBuf = metadataCache; |
| void *next; |
| |
| if (refTables.size() < 1) { |
| LOGE("incomplete reference table :%zu", refTables.size()); |
| return count; |
| } |
| |
| do { |
| endPtr = (char *) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| |
| if (parseStep == 1) { // Step 1 parse the input format |
| if (STRLEN_S(src) == 0) break; |
| // detect empty string. It means we are done, so get out of the loop |
| activeTable = refTables[0].table; |
| activeTableLen = refTables[0].tableSize; |
| ret = convertEnum(storeBuf, src, tagInfo->type, activeTable, |
| activeTableLen, &next); |
| if (ret == 1) { |
| count++; |
| storeBuf = next; |
| } else { |
| LOGE("Malformed enum in format map %s", src); |
| break; |
| } |
| } else if (parseStep == 2) { // Step 2: Parse the num of output formats |
| i32 = reinterpret_cast<int32_t*>(storeBuf); |
| i32[0] = strtol(src, &endPtr, 10); |
| numOutputFormats = i32[0]; |
| count += 1; |
| storeBuf = reinterpret_cast<void*>(&i32[1]); |
| LOGD("Num of output formats = %d", i32[0]); |
| |
| } else { // Step3 parse the output formats |
| activeTable = refTables[0].table; |
| activeTableLen = refTables[0].tableSize; |
| for (int i = 0; i < numOutputFormats; i++) { |
| ret = convertEnum(storeBuf, src, tagInfo->type, activeTable, |
| activeTableLen, &next); |
| if (ret == 1) { |
| count += 1; |
| if (endPtr == nullptr) return count; |
| src = endPtr + 1; |
| storeBuf = next; |
| } else { |
| LOGE("Malformed enum in format map %s", src); |
| break; |
| } |
| if (i < numOutputFormats - 1) { |
| endPtr = (char *) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| } |
| } |
| } |
| |
| if (endPtr) { |
| src = endPtr + 1; |
| src = skipWhiteSpace(src); |
| parseStep++; |
| /* parsing steps go from 1 to 3 */ |
| if (parseStep == 4) { |
| parseStep = 1; |
| } |
| } |
| } while (count < maxCount && endPtr); |
| |
| if (endPtr != nullptr) { |
| LOGW("Formats Map string too long for parser"); |
| } |
| |
| return count; |
| } |
| |
| |
| int CameraProfiles::parseSizes(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t* metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int entriesFound = 0; |
| |
| entriesFound = parseData(src, tagInfo, metadataCacheSize, metadataCache); |
| |
| if (entriesFound % 2) { |
| LOGE("Odd number of entries (%d), resolutions should have an even " |
| "number of entries", entriesFound); |
| entriesFound -= 1; //make it even Ignore the last one |
| } |
| return entriesFound; |
| } |
| |
| int CameraProfiles::parseImageFormats(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t *metadataCache) |
| { |
| /** |
| * DEPRECATED in V 3.2: TODO: add warning and extra checks |
| */ |
| HAL_TRACE_CALL(1); |
| int entriesFound = 0; |
| |
| entriesFound = parseEnum(src, tagInfo, metadataCacheSize, metadataCache); |
| |
| return entriesFound; |
| } |
| |
| int CameraProfiles::parseRectangle(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t *metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int entriesFound = 0; |
| entriesFound = parseData(src, tagInfo, metadataCacheSize, metadataCache); |
| |
| if (entriesFound % 4) { |
| LOGE("incorrect number of entries (%d), rectangles have 4 values", |
| entriesFound); |
| entriesFound -= entriesFound % 4; //round to multiple of 4 |
| } |
| |
| return entriesFound; |
| } |
| int CameraProfiles::parseBlackLevelPattern(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t *metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int entriesFound = 0; |
| entriesFound = parseData(src, tagInfo, metadataCacheSize, metadataCache); |
| if (entriesFound % 4) { |
| LOGE("incorrect number of entries (%d), black level pattern have 4 values", |
| entriesFound); |
| entriesFound -= entriesFound % 4; //round to multiple of 4 |
| } |
| return entriesFound; |
| } |
| |
| int CameraProfiles::parseStreamConfigDuration(const char *src, |
| const metadata_tag_t *tagInfo, |
| std::vector<MetaValueRefTable> refTables, |
| int metadataCacheSize, |
| int64_t *metadataCache) |
| { |
| HAL_TRACE_CALL(1); |
| int count = 0; // entry count |
| int maxCount = metadataCacheSize/camera_metadata_type_size[tagInfo->type]; |
| int ret; |
| char * endPtr = nullptr; |
| int parseStep = 1; |
| int64_t *i64; |
| |
| const metadata_value_t * activeTable; |
| int activeTableLen = 0; |
| |
| void *storeBuf = metadataCache; |
| void *next; |
| |
| if (refTables.size() < 1) { |
| LOGE("incomplete reference table :%zu", refTables.size()); |
| return count; |
| } |
| |
| do { |
| endPtr = (char *) strchr(src, ','); |
| if (endPtr) |
| *endPtr = 0; |
| |
| if (parseStep == 1) { // Step 1 parse the format |
| if (STRLEN_S(src) == 0) break; |
| // detect empty string. It means we are done, so get out of the loop |
| activeTable = refTables[0].table; |
| activeTableLen = refTables[0].tableSize; |
| ret = convertEnum(storeBuf, src, tagInfo->type, activeTable, |
| activeTableLen, &next); |
| if (ret == 1) { |
| count++; |
| storeBuf = next; |
| } else { |
| LOGE("Malformed enum in stream configuration duration %s", src); |
| break; |
| } |
| |
| } else if (parseStep == 2) { // Step 2: Parse the resolution |
| i64 = reinterpret_cast<int64_t*>(storeBuf); |
| i64[0] = strtol(src, &endPtr, 10); |
| if (endPtr == nullptr || *endPtr != 'x') { |
| LOGE("Malformed resolution in stream duration configuration"); |
| break; |
| } |
| src = endPtr + 1; |
| i64[1] = strtol(src, &endPtr, 10); |
| storeBuf = reinterpret_cast<void*>(&i64[2]); |
| count += 2; |
| LOG1(" - %" PRId64 "x%" PRId64 " -", i64[0], i64[1]); |
| |
| } else { // Step3 parse the duration |
| |
| i64 = reinterpret_cast<int64_t*>(storeBuf); |
| if (endPtr) |
| i64[0] = strtol(src, &endPtr, 10); |
| else |
| i64[0] = strtol(src, nullptr, 10); // Do not update endPtr |
| storeBuf = reinterpret_cast<void*>(&i64[1]); |
| count += 1; |
| LOG1(" - %" PRId64 " ns -", i64[0]); |
| } |
| |
| if (endPtr) { |
| src = endPtr + 1; |
| src = skipWhiteSpace(src); |
| parseStep++; |
| /* parsing steps go from 1 to 3 */ |
| if (parseStep == 4) { |
| parseStep = 1; |
| LOG1("Stream Configuration Duration found"); |
| } |
| } |
| } while (count < maxCount && endPtr); |
| |
| if (endPtr != nullptr) { |
| LOGW("Stream configuration duration string too long for parser"); |
| } |
| /** |
| * Total number of entries per stream configuration is 4 |
| * - one for the format |
| * - two for the resolution |
| * - one for the duration |
| * The total entry count should be multiple of 4 |
| */ |
| if (count % 4) { |
| LOGE("Malformed string for stream config duration." |
| " ignoring last %d entries", count % 4); |
| count -= count % 4; |
| } |
| return count; |
| } |
| /** |
| * |
| * Checks whether the sensor named in a profile is present in the list of |
| * runtime detected sensors. |
| * The result of this method helps to decide whether to use a particular profile |
| * from the XML file. |
| * |
| * \param[in] detectedSensors vector with the description of the runtime |
| * detected sensors. |
| * \param[in] profileName name of the sensor present in the XML config file. |
| * \param[in] cameraId camera Id for the sensor name in the XML. |
| * |
| * \return true if the sensor named in the profile is available in HW. |
| */ |
| bool CameraProfiles::isSensorPresent(std::vector<SensorDriverDescriptor> &detectedSensors, |
| const char *profileName, int cameraId) const |
| { |
| for (unsigned int i = 0; i < detectedSensors.size(); i++) { |
| /* |
| * Logic for legacy platforms with only 1-2 sensors. |
| */ |
| if ((detectedSensors[i].mIspPort == PRIMARY && cameraId == 0) || |
| (detectedSensors[i].mIspPort == SECONDARY && cameraId == 1) || |
| (detectedSensors[i].mIspPort == UNKNOWN_PORT)) { |
| if (detectedSensors[i].mSensorName == profileName) { |
| LOG1("@%s: mUseEntry is true, mSensorIndex = %d, name = %s", |
| __FUNCTION__, cameraId, profileName); |
| return true; |
| } |
| } |
| /* |
| * Logic for new platforms that support more than 2 sensors. |
| * To uniquely match an XML profile to a sensor present in HW we will |
| * use 2 pieces of information: |
| * - sensor name |
| * - CSI port |
| * Current implementation only uses sensor name. CSI port is needed in |
| * cases where we have same sensor name in different ports. |
| * TODO add this to XML part |
| */ |
| if (detectedSensors[i].mSensorDevType == SENSOR_DEVICE_MC) { |
| if (detectedSensors[i].mSensorName == profileName) { |
| LOG1("@%s: mUseEntry is true, mSensorIndex = %d, name = %s", |
| __FUNCTION__, cameraId, profileName); |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| /** |
| * This function will check which field that the parser parses to. |
| * |
| * The field is set to 5 types. |
| * FIELD_INVALID FIELD_SENSOR_COMMON FIELD_SENSOR_ANDROID_METADATA FIELD_SENSOR_VENDOR_METADATA and FIELD_COMMON |
| * |
| * \param name: the element's name. |
| * \param atts: the element's attribute. |
| */ |
| void CameraProfiles::checkField(CameraProfiles *profiles, |
| const char *name, |
| const char **atts) |
| { |
| if (!strcmp(name, "Profiles")) { |
| mXmlSensorIndex = atoi(atts[1]); |
| if (mXmlSensorIndex > MAX_CAMERAS) { |
| LOGE("ERROR: bad camera id %d!", mSensorIndex); |
| return; |
| } |
| |
| profiles->mUseEntry = false; |
| int attIndex = 2; |
| if (atts[attIndex]) { |
| if (strcmp(atts[attIndex], "name") == 0) { |
| mSensorIndex++; |
| LOG1("@%s: mSensorIndex = %d, name = %s, mSensorNames.size():%zu", |
| __FUNCTION__, mSensorIndex, |
| atts[attIndex + 1], profiles->mSensorNames.size()); |
| |
| profiles->mUseEntry = isSensorPresent(profiles->mSensorNames, |
| atts[attIndex + 1], |
| mSensorIndex); |
| |
| if (profiles->mUseEntry) { |
| mCameraIdToSensorName.insert(make_pair(mSensorIndex, std::string(atts[attIndex + 1]))); |
| } |
| } else { |
| LOGE("unknown attribute atts[%d] = %s", attIndex, atts[attIndex]); |
| } |
| } else { |
| // for platforms that don't have the name field in the camera profiles. |
| profiles->mUseEntry = true; |
| mSensorIndex++; |
| } |
| |
| if (profiles->mUseEntry |
| && mSensorIndex >= mStaticMeta.size() |
| && mStaticMeta.size() < profiles->mSensorNames.size()) |
| addCamera(mSensorIndex); |
| } else if (strcmp(name, "Supported_hardware") == 0) { |
| mCurrentDataField = FIELD_SUPPORTED_HARDWARE; |
| mItemsCount = -1; |
| } else if (strcmp(name, "Android_metadata") == 0) { |
| mCurrentDataField = FIELD_ANDROID_STATIC_METADATA; |
| mItemsCount = -1; |
| } else if (strcmp(name, "Common") == 0) { |
| mCurrentDataField = FIELD_COMMON; |
| mItemsCount = -1; |
| } |
| |
| LOG1("@%s: name:%s, field %d", __FUNCTION__, name, mCurrentDataField); |
| return; |
| } |
| |
| void CameraProfiles::handleSupportedHardware(const char *name, const char **atts) |
| { |
| LOG1("@%s, type:%s", __FUNCTION__, name); |
| if (strcmp(atts[0], "value") != 0) { |
| LOGE("name:%s, atts[0]:%s, xml format wrong", name, atts[0]); |
| return; |
| } |
| |
| if (strcmp(name, "hwType") == 0) { |
| CameraInfo *info = nullptr; |
| mCameraInfoPool.acquireItem(&info); |
| if (info != nullptr) { |
| info->parser = nullptr; |
| info->hwType = atts[1]; |
| info->xmlCameraId = mXmlSensorIndex; |
| mCameraIdToCameraInfo.insert(std::make_pair(mSensorIndex, info)); |
| LOG2("Add sensor: %s to mCameraIdToCameraInfo with key: %d", name, mSensorIndex); |
| } else { |
| LOGE("Failed to get camera info for sensor index %d", mSensorIndex); |
| } |
| } else { |
| LOGE("Unhandled xml attribute in Supported_hardware"); |
| } |
| } |
| |
| /** |
| * This function will handle all the common related elements. |
| * |
| * It will be called in the function startElement |
| * |
| * \param name: the element's name. |
| * \param atts: the element's attribute. |
| */ |
| void CameraProfiles::handleCommon(const char *name, const char **atts) |
| { |
| LOG1("@%s, name:%s, atts[0]:%s", __FUNCTION__, name, atts[0]); |
| |
| if (strcmp(atts[0], "value") != 0) { |
| LOGE("name:%s, atts[0]:%s, xml format wrong", name, atts[0]); |
| return; |
| } |
| } |
| |
| bool CameraProfiles::validateStaticMetadata(const char *name, const char **atts) |
| { |
| /** |
| * string validation |
| */ |
| size_t nameSize = strnlen(name, MAX_METADATA_NAME_LENTGTH); |
| size_t attrNameSize = strnlen(atts[0], MAX_METADATA_ATTRIBUTE_NAME_LENTGTH); |
| size_t attrValueSize = strnlen(atts[1], MAX_METADATA_ATTRIBUTE_VALUE_LENTGTH); |
| if ((attrValueSize == MAX_METADATA_ATTRIBUTE_VALUE_LENTGTH) || |
| (attrNameSize == MAX_METADATA_ATTRIBUTE_NAME_LENTGTH) || |
| (nameSize == MAX_METADATA_NAME_LENTGTH)) { |
| LOGW("Warning XML strings too long ignoring this tag %s", name); |
| return false; |
| } |
| |
| if ((strncmp(atts[0], "value", attrNameSize) != 0) || |
| (attrValueSize == 0)) { |
| LOGE("Check atts failed! name: %s, atts[0]: \"%s\", atts[1]: \"%s\", the format of xml is wrong!", name, atts[0], atts[1]); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| const metadata_tag_t *CameraProfiles::findTagInfo(const char *name, |
| const metadata_tag_t *tagsTable, |
| unsigned int size) |
| { |
| size_t nameSize = strnlen(name, MAX_METADATA_NAME_LENTGTH); |
| unsigned int index = 0; |
| const metadata_tag_t *tagInfo = nullptr; |
| |
| for (index = 0; index < size; index++) { |
| if (!strncmp(name, tagsTable[index].name, nameSize)) { |
| tagInfo = &tagsTable[index]; |
| break; |
| } |
| } |
| if (index >= size) { |
| LOGW("Parser does not support tag %s! - ignoring", name); |
| } |
| |
| return tagInfo; |
| } |
| |
| int CameraProfiles::parseGenericTypes(const char *src, |
| const metadata_tag_t *tagInfo, |
| int metadataCacheSize, |
| int64_t *metadataCache) |
| { |
| int count = 0; |
| switch (tagInfo->arrayTypedef) { |
| case BOOLEAN: |
| case ENUM_LIST: |
| count = parseEnum(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case RANGE_INT: |
| case RANGE_LONG: |
| count = parseData(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case SIZE_F: |
| case SIZE: |
| count = parseSizes(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case RECTANGLE: |
| count = parseRectangle(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case IMAGE_FORMAT: |
| count = parseImageFormats(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case BLACK_LEVEL_PATTERN: |
| count = parseBlackLevelPattern(src, tagInfo, metadataCacheSize, metadataCache); |
| break; |
| case TYPEDEF_NONE: /* Single values*/ |
| if (tagInfo->enumTable) { |
| count = parseEnum(src, tagInfo, metadataCacheSize, metadataCache); |
| } else { |
| count = parseData(src, tagInfo, metadataCacheSize, metadataCache); |
| } |
| break; |
| default: |
| LOGW("Unsupported typedef %s", tagInfo->name); |
| break; |
| } |
| |
| return count; |
| } |
| |
| /** |
| * the callback function of the libexpat for handling of one element start |
| * |
| * When it comes to the start of one element. This function will be called. |
| * |
| * \param userData: the pointer we set by the function XML_SetUserData. |
| * \param name: the element's name. |
| */ |
| void CameraProfiles::startElement(void *userData, const char *name, const char **atts) |
| { |
| CameraProfiles *profiles = (CameraProfiles *)userData; |
| |
| if (profiles->mCurrentDataField == FIELD_INVALID) { |
| profiles->checkField(profiles, name, atts); |
| return; |
| } |
| LOG2("@%s: name:%s, for sensor %d", __FUNCTION__, name, profiles->mSensorIndex); |
| |
| profiles->mItemsCount++; |
| |
| switch (profiles->mCurrentDataField) { |
| case FIELD_SUPPORTED_HARDWARE: |
| if (profiles->mUseEntry) |
| profiles->handleSupportedHardware(name, atts); |
| break; |
| case FIELD_ANDROID_STATIC_METADATA: |
| if (profiles->mUseEntry) |
| profiles->handleAndroidStaticMetadata(name, atts); |
| |
| break; |
| case FIELD_COMMON: |
| if (profiles->mStaticMeta.size() > 0) |
| profiles->handleCommon(name, atts); |
| |
| break; |
| default: |
| LOGE("line:%d, go to default handling", __LINE__); |
| break; |
| } |
| } |
| |
| /** |
| * the callback function of the libexpat for handling of one element end |
| * |
| * When it comes to the end of one element. This function will be called. |
| * |
| * \param userData: the pointer we set by the function XML_SetUserData. |
| * \param name: the element's name. |
| */ |
| void CameraProfiles::endElement(void *userData, const char *name) |
| { |
| CameraProfiles *profiles = (CameraProfiles *)userData; |
| if (!strcmp(name, "Profiles")) { |
| profiles->mCurrentDataField = FIELD_INVALID; |
| if (profiles->mUseEntry) |
| profiles->mProfileEnd[profiles->mSensorIndex] = true; |
| } else if (!strcmp(name, "Supported_hardware") |
| || !strcmp(name, "Android_metadata") |
| || !strcmp(name, "Common")) { |
| profiles->mCurrentDataField = FIELD_INVALID; |
| profiles->mItemsCount = -1; |
| } |
| return; |
| } |
| |
| /** |
| * Get camera configuration from xml file |
| * |
| * The function will read the xml configuration file firstly. |
| * Then it will parse out the camera settings. |
| * The camera setting is stored inside this CameraProfiles class. |
| * |
| */ |
| void CameraProfiles::getDataFromXmlFile(void) |
| { |
| int done; |
| void *pBuf = nullptr; |
| FILE *fp = nullptr; |
| LOG1("@%s", __FUNCTION__); |
| camera_metadata_t *currentMeta = nullptr; |
| status_t res; |
| int tag = ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS; |
| |
| fp = ::fopen(mXmlConfigName.c_str(), "r"); |
| if (nullptr == fp) { |
| LOGE("line:%d, fp is nullptr", __LINE__); |
| return; |
| } |
| |
| XML_Parser parser = ::XML_ParserCreate(nullptr); |
| if (nullptr == parser) { |
| LOGE("line:%d, parser is nullptr", __LINE__); |
| goto exit; |
| } |
| ::XML_SetUserData(parser, this); |
| ::XML_SetElementHandler(parser, startElement, endElement); |
| |
| pBuf = ::operator new(BUFFERSIZE); |
| mMetadataCache = new int64_t[METADATASIZE]; |
| |
| do { |
| int len = (int)::fread(pBuf, 1, BUFFERSIZE, fp); |
| if (!len) { |
| if (ferror(fp)) { |
| clearerr(fp); |
| goto exit; |
| } |
| } |
| done = len < BUFFERSIZE; |
| if (XML_Parse(parser, (const char *)pBuf, len, done) == XML_STATUS_ERROR) { |
| LOGE("line:%d, XML_Parse error", __LINE__); |
| goto exit; |
| } |
| } while (!done); |
| |
| if (mStaticMeta.size() > 0) { |
| for (unsigned int i = 0; i < mStaticMeta.size(); i++) { |
| currentMeta = mStaticMeta.at(i); |
| if (currentMeta == nullptr) { |
| LOGE("can't get the static metadata"); |
| goto exit; |
| } |
| // update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS |
| int *keys = mCharacteristicsKeys[i].data(); |
| res = MetadataHelper::updateMetadata(currentMeta, tag, keys, mCharacteristicsKeys[i].size()); |
| if (res != OK) |
| LOGE("call add/update_camera_metadata_entry fail for request.availableCharacteristicsKeys"); |
| } |
| } |
| exit: |
| if (parser) |
| ::XML_ParserFree(parser); |
| |
| ::operator delete(pBuf); |
| |
| if (mMetadataCache) { |
| delete [] mMetadataCache; |
| mMetadataCache = nullptr; |
| } |
| if (fp) |
| ::fclose(fp); |
| } |
| |
| CameraHwType CameraProfiles::getCameraHwforId(int cameraId) |
| { |
| LOG2("@%s cameraId: %d", __FUNCTION__, cameraId); |
| |
| std::map<int, CameraInfo*>::iterator it = |
| mCameraIdToCameraInfo.find(cameraId); |
| if (it == mCameraIdToCameraInfo.end()) { |
| LOGE("Camera id not found, BUG, this should not happen!!mSensorIndex = %d", cameraId); |
| return SUPPORTED_HW_UNKNOWN; |
| } |
| |
| CameraInfo *info = it->second; |
| std::string hwType = info->hwType; |
| |
| if (hwType == "SUPPORTED_HW_RKISP1") { |
| return SUPPORTED_HW_RKISP1; |
| } else |
| LOGE("ERROR: Camera HW type wrong in xml"); |
| return SUPPORTED_HW_UNKNOWN; |
| } |
| |
| void CameraProfiles::dumpSupportedHWSection(int cameraId) { |
| LOGD("@%s", __FUNCTION__); |
| std::map<int, CameraInfo*>::iterator it = |
| mCameraIdToCameraInfo.find(cameraId); |
| if (it == mCameraIdToCameraInfo.end()) { |
| LOGE("Camera id not found, BUG, this should not happen!!mSensorIndex = %d", cameraId); |
| return; |
| } |
| |
| CameraInfo *info = it->second; |
| LOGD("element name hwType element value = %s", info->hwType.c_str()); |
| } |
| |
| void CameraProfiles::dumpStaticMetadataSection(int cameraId) |
| { |
| LOGD("@%s", __FUNCTION__); |
| if (mStaticMeta.size() > 0) |
| MetadataHelper::dumpMetadata(mStaticMeta[cameraId]); |
| else { |
| LOGE("Camera isn't added, unable to get the static metadata"); |
| } |
| } |
| |
| void CameraProfiles::dumpCommonSection() |
| { |
| LOGD("@%s", __FUNCTION__); |
| LOGD("element name: boardName, element value = %s", mCameraCommon->mBoardName.c_str()); |
| LOGD("element name: productName, element value = %s", mCameraCommon->productName()); |
| LOGD("element name: manufacturerName, element value = %s", mCameraCommon->manufacturerName()); |
| LOGD("element name: mSupportDualVideo, element value = %d", mCameraCommon-> mSupportDualVideo); |
| LOGD("element name: supportExtendedMakernote, element value = %d", mCameraCommon->mSupportExtendedMakernote); |
| } |
| |
| // To be modified when new elements or sections are added |
| // Use LOGD for traces to be visible |
| void CameraProfiles::dump() |
| { |
| LOGD("===========================@%s======================", __FUNCTION__); |
| for (unsigned int i = 0; i <= mSensorIndex; i++) { |
| dumpSupportedHWSection(i); |
| dumpStaticMetadataSection(i); |
| } |
| dumpCommonSection(); |
| LOGD("===========================end======================"); |
| } |
| |
| } NAMESPACE_DECLARATION_END |
