1 /*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "ConfigManagerUtil.h"
18
19 #include <android-base/logging.h>
20 #include <android-base/parsedouble.h>
21 #include <android-base/parseint.h>
22 #include <linux/videodev2.h>
23
24 #include <sstream>
25 #include <string>
26
27 #include <system/graphics-base-v1.0.h>
28
29 using ::aidl::android::hardware::automotive::evs::CameraParam;
30 using ::aidl::android::hardware::graphics::common::PixelFormat;
31
convertToEvsCameraParam(const std::string & id,CameraParam & camParam)32 bool ConfigManagerUtil::convertToEvsCameraParam(const std::string& id, CameraParam& camParam) {
33 std::string trimmed = ConfigManagerUtil::trimString(id);
34 bool success = true;
35
36 if (!trimmed.compare("BRIGHTNESS")) {
37 camParam = CameraParam::BRIGHTNESS;
38 } else if (!trimmed.compare("CONTRAST")) {
39 camParam = CameraParam::CONTRAST;
40 } else if (!trimmed.compare("AUTOGAIN")) {
41 camParam = CameraParam::AUTOGAIN;
42 } else if (!trimmed.compare("GAIN")) {
43 camParam = CameraParam::GAIN;
44 } else if (!trimmed.compare("AUTO_WHITE_BALANCE")) {
45 camParam = CameraParam::AUTO_WHITE_BALANCE;
46 } else if (!trimmed.compare("WHITE_BALANCE_TEMPERATURE")) {
47 camParam = CameraParam::WHITE_BALANCE_TEMPERATURE;
48 } else if (!trimmed.compare("SHARPNESS")) {
49 camParam = CameraParam::SHARPNESS;
50 } else if (!trimmed.compare("AUTO_EXPOSURE")) {
51 camParam = CameraParam::AUTO_EXPOSURE;
52 } else if (!trimmed.compare("ABSOLUTE_EXPOSURE")) {
53 camParam = CameraParam::ABSOLUTE_EXPOSURE;
54 } else if (!trimmed.compare("ABSOLUTE_FOCUS")) {
55 camParam = CameraParam::ABSOLUTE_FOCUS;
56 } else if (!trimmed.compare("AUTO_FOCUS")) {
57 camParam = CameraParam::AUTO_FOCUS;
58 } else if (!trimmed.compare("ABSOLUTE_ZOOM")) {
59 camParam = CameraParam::ABSOLUTE_ZOOM;
60 } else {
61 success = false;
62 }
63
64 return success;
65 }
66
convertToPixelFormat(const std::string & in,PixelFormat & out)67 bool ConfigManagerUtil::convertToPixelFormat(const std::string& in, PixelFormat& out) {
68 std::string trimmed = ConfigManagerUtil::trimString(in);
69 bool success = true;
70
71 if (!trimmed.compare("RGBA_8888")) {
72 out = PixelFormat::RGBA_8888;
73 } else if (!trimmed.compare("YCRCB_420_SP")) {
74 out = PixelFormat::YCRCB_420_SP;
75 } else if (!trimmed.compare("YCBCR_422_I")) {
76 out = PixelFormat::YCBCR_422_I;
77 } else {
78 out = PixelFormat::UNSPECIFIED;
79 success = false;
80 }
81
82 return success;
83 }
84
convertToMetadataTag(const char * name,camera_metadata_tag & aTag)85 bool ConfigManagerUtil::convertToMetadataTag(const char* name, camera_metadata_tag& aTag) {
86 if (!std::strcmp(name, "LENS_DISTORTION")) {
87 aTag = ANDROID_LENS_DISTORTION;
88 } else if (!std::strcmp(name, "LENS_INTRINSIC_CALIBRATION")) {
89 aTag = ANDROID_LENS_INTRINSIC_CALIBRATION;
90 } else if (!std::strcmp(name, "LENS_POSE_ROTATION")) {
91 aTag = ANDROID_LENS_POSE_ROTATION;
92 } else if (!std::strcmp(name, "LENS_POSE_TRANSLATION")) {
93 aTag = ANDROID_LENS_POSE_TRANSLATION;
94 } else if (!std::strcmp(name, "REQUEST_AVAILABLE_CAPABILITIES")) {
95 aTag = ANDROID_REQUEST_AVAILABLE_CAPABILITIES;
96 } else if (!std::strcmp(name, "LOGICAL_MULTI_CAMERA_PHYSICAL_IDS")) {
97 aTag = ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS;
98 } else {
99 return false;
100 }
101
102 return true;
103 }
104
convertToCameraCapability(const char * name,camera_metadata_enum_android_request_available_capabilities_t & cap)105 bool ConfigManagerUtil::convertToCameraCapability(
106 const char* name, camera_metadata_enum_android_request_available_capabilities_t& cap) {
107 if (!std::strcmp(name, "DEPTH_OUTPUT")) {
108 cap = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT;
109 } else if (!std::strcmp(name, "LOGICAL_MULTI_CAMERA")) {
110 cap = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA;
111 } else if (!std::strcmp(name, "MONOCHROME")) {
112 cap = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME;
113 } else if (!std::strcmp(name, "SECURE_IMAGE_DATA")) {
114 cap = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA;
115 } else {
116 return false;
117 }
118
119 return true;
120 }
121
convertFloatArray(const char * sz,const char * vals,size_t & count,const char delimiter)122 float* ConfigManagerUtil::convertFloatArray(const char* sz, const char* vals, size_t& count,
123 const char delimiter) {
124 std::string size_string(sz);
125 std::string value_string(vals);
126
127 if (!android::base::ParseUint(size_string, &count)) {
128 LOG(ERROR) << "Failed to parse " << size_string;
129 return nullptr;
130 }
131 float* result = new float[count];
132 std::stringstream values(value_string);
133
134 int32_t idx = 0;
135 std::string token;
136 while (getline(values, token, delimiter)) {
137 if (!android::base::ParseFloat(token, &result[idx++])) {
138 LOG(WARNING) << "Failed to parse " << token;
139 }
140 }
141
142 return result;
143 }
144
trimString(const std::string & src,const std::string & ws)145 std::string ConfigManagerUtil::trimString(const std::string& src, const std::string& ws) {
146 const auto s = src.find_first_not_of(ws);
147 if (s == std::string::npos) {
148 return "";
149 }
150
151 const auto e = src.find_last_not_of(ws);
152 const auto r = e - s + 1;
153
154 return src.substr(s, r);
155 }
156