1 /*
2 _* Copyright (C) 2013-2019 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 <unordered_set>
18 #define LOG_TAG "HWLUtils"
19 #include "HWLUtils.h"
20 #include <log/log.h>
21 #include "utils.h"
22
23 #include <map>
24
25 namespace android {
26
27 using google_camera_hal::utils::HasCapability;
28
GetSensorCharacteristics(const HalCameraMetadata * metadata,SensorCharacteristics * sensor_chars)29 status_t GetSensorCharacteristics(const HalCameraMetadata* metadata,
30 SensorCharacteristics* sensor_chars /*out*/) {
31 if ((metadata == nullptr) || (sensor_chars == nullptr)) {
32 return BAD_VALUE;
33 }
34
35 status_t ret = OK;
36 camera_metadata_ro_entry_t entry;
37 ret = metadata->Get(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, &entry);
38 if ((ret != OK) || (entry.count != 2)) {
39 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE!", __FUNCTION__);
40 return BAD_VALUE;
41 }
42 sensor_chars->width = entry.data.i32[0];
43 sensor_chars->height = entry.data.i32[1];
44 sensor_chars->full_res_width = sensor_chars->width;
45 sensor_chars->full_res_height = sensor_chars->height;
46
47 ret = metadata->Get(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE_MAXIMUM_RESOLUTION,
48 &entry);
49 if ((ret == OK) && (entry.count == 2)) {
50 sensor_chars->full_res_width = entry.data.i32[0];
51 sensor_chars->full_res_height = entry.data.i32[1];
52 sensor_chars->quad_bayer_sensor = true;
53 }
54
55 ret = metadata->Get(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, &entry);
56 if ((ret != OK) || (entry.count != 3)) {
57 ALOGE("%s: Invalid ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS!", __FUNCTION__);
58 return BAD_VALUE;
59 }
60
61 sensor_chars->max_raw_streams = entry.data.i32[0];
62 sensor_chars->max_processed_streams = entry.data.i32[1];
63 sensor_chars->max_stalling_streams = entry.data.i32[2];
64
65 if (HasCapability(
66 metadata,
67 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)) {
68 ret = metadata->Get(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP,
69 &entry);
70 if ((ret != OK) || ((entry.count % 3) != 0)) {
71 ALOGE("%s: Invalid ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP!",
72 __FUNCTION__);
73 return BAD_VALUE;
74 }
75
76 for (size_t i = 0; i < entry.count; i += 3) {
77 sensor_chars->dynamic_range_profiles.emplace(
78 static_cast<
79 camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
80 entry.data.i64[i]),
81 std::unordered_set<
82 camera_metadata_enum_android_request_available_dynamic_range_profiles_map>());
83 const auto profile_end =
84 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_DOLBY_VISION_8B_HDR_OEM_PO
85 << 1;
86 uint64_t current_profile =
87 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD;
88 for (; current_profile != profile_end; current_profile <<= 1) {
89 if (entry.data.i64[i + 1] & current_profile) {
90 sensor_chars->dynamic_range_profiles
91 .at(static_cast<
92 camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
93 entry.data.i64[i]))
94 .emplace(
95 static_cast<
96 camera_metadata_enum_android_request_available_dynamic_range_profiles_map>(
97 current_profile));
98 }
99 }
100 }
101
102 sensor_chars->is_10bit_dynamic_range_capable = true;
103 }
104
105 if (HasCapability(metadata,
106 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR)) {
107 ret = metadata->Get(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, &entry);
108 if ((ret != OK) ||
109 (entry.count != ARRAY_SIZE(sensor_chars->exposure_time_range))) {
110 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE!",
111 __FUNCTION__);
112 return BAD_VALUE;
113 }
114 memcpy(sensor_chars->exposure_time_range, entry.data.i64,
115 sizeof(sensor_chars->exposure_time_range));
116
117 ret = metadata->Get(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, &entry);
118 if ((ret != OK) || (entry.count != 1)) {
119 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_MAX_FRAME_DURATION!", __FUNCTION__);
120 return BAD_VALUE;
121 }
122 sensor_chars->frame_duration_range[1] = entry.data.i64[0];
123 sensor_chars->frame_duration_range[0] =
124 EmulatedSensor::kSupportedFrameDurationRange[0];
125
126 ret = metadata->Get(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, &entry);
127 if ((ret != OK) ||
128 (entry.count != ARRAY_SIZE(sensor_chars->sensitivity_range))) {
129 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_SENSITIVITY_RANGE!", __FUNCTION__);
130 return BAD_VALUE;
131 }
132 memcpy(sensor_chars->sensitivity_range, entry.data.i64,
133 sizeof(sensor_chars->sensitivity_range));
134 } else {
135 memcpy(sensor_chars->exposure_time_range,
136 EmulatedSensor::kSupportedExposureTimeRange,
137 sizeof(sensor_chars->exposure_time_range));
138 memcpy(sensor_chars->frame_duration_range,
139 EmulatedSensor::kSupportedFrameDurationRange,
140 sizeof(sensor_chars->frame_duration_range));
141 memcpy(sensor_chars->sensitivity_range,
142 EmulatedSensor::kSupportedSensitivityRange,
143 sizeof(sensor_chars->sensitivity_range));
144 }
145
146 if (HasCapability(metadata, ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW)) {
147 ret = metadata->Get(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, &entry);
148 if ((ret != OK) || (entry.count != 1)) {
149 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT!",
150 __FUNCTION__);
151 return BAD_VALUE;
152 }
153
154 sensor_chars->color_arangement = static_cast<
155 camera_metadata_enum_android_sensor_info_color_filter_arrangement>(
156 entry.data.u8[0]);
157
158 ret = metadata->Get(ANDROID_SENSOR_INFO_WHITE_LEVEL, &entry);
159 if ((ret != OK) || (entry.count != 1)) {
160 ALOGE("%s: Invalid ANDROID_SENSOR_INFO_WHITE_LEVEL!", __FUNCTION__);
161 return BAD_VALUE;
162 }
163 sensor_chars->max_raw_value = entry.data.i32[0];
164
165 ret = metadata->Get(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, &entry);
166 if ((ret != OK) ||
167 (entry.count != ARRAY_SIZE(sensor_chars->black_level_pattern))) {
168 ALOGE("%s: Invalid ANDROID_SENSOR_BLACK_LEVEL_PATTERN!", __FUNCTION__);
169 return BAD_VALUE;
170 }
171
172 memcpy(sensor_chars->black_level_pattern, entry.data.i32,
173 sizeof(sensor_chars->black_level_pattern));
174
175 ret = metadata->Get(ANDROID_LENS_INFO_SHADING_MAP_SIZE, &entry);
176 if ((ret == OK) && (entry.count == 2)) {
177 sensor_chars->lens_shading_map_size[0] = entry.data.i32[0];
178 sensor_chars->lens_shading_map_size[1] = entry.data.i32[1];
179 } else {
180 ALOGE("%s: No available shading map size!", __FUNCTION__);
181 return BAD_VALUE;
182 }
183
184 ret = metadata->Get(ANDROID_SENSOR_COLOR_TRANSFORM1, &entry);
185 if ((ret != OK) || (entry.count != (3 * 3))) { // 3x3 rational matrix
186 ALOGE("%s: Invalid ANDROID_SENSOR_COLOR_TRANSFORM1!", __FUNCTION__);
187 return BAD_VALUE;
188 }
189
190 sensor_chars->color_filter.rX = RAT_TO_FLOAT(entry.data.r[0]);
191 sensor_chars->color_filter.rY = RAT_TO_FLOAT(entry.data.r[1]);
192 sensor_chars->color_filter.rZ = RAT_TO_FLOAT(entry.data.r[2]);
193 sensor_chars->color_filter.grX = RAT_TO_FLOAT(entry.data.r[3]);
194 sensor_chars->color_filter.grY = RAT_TO_FLOAT(entry.data.r[4]);
195 sensor_chars->color_filter.grZ = RAT_TO_FLOAT(entry.data.r[5]);
196 sensor_chars->color_filter.gbX = RAT_TO_FLOAT(entry.data.r[3]);
197 sensor_chars->color_filter.gbY = RAT_TO_FLOAT(entry.data.r[4]);
198 sensor_chars->color_filter.gbZ = RAT_TO_FLOAT(entry.data.r[5]);
199 sensor_chars->color_filter.bX = RAT_TO_FLOAT(entry.data.r[6]);
200 sensor_chars->color_filter.bY = RAT_TO_FLOAT(entry.data.r[7]);
201 sensor_chars->color_filter.bZ = RAT_TO_FLOAT(entry.data.r[8]);
202 } else {
203 sensor_chars->color_arangement = static_cast<
204 camera_metadata_enum_android_sensor_info_color_filter_arrangement>(
205 EmulatedSensor::kSupportedColorFilterArrangement);
206 sensor_chars->max_raw_value = EmulatedSensor::kDefaultMaxRawValue;
207 memcpy(sensor_chars->black_level_pattern,
208 EmulatedSensor::kDefaultBlackLevelPattern,
209 sizeof(sensor_chars->black_level_pattern));
210 }
211
212 if (HasCapability(
213 metadata,
214 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING) ||
215 HasCapability(metadata,
216 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING)) {
217 ret = metadata->Get(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, &entry);
218 if ((ret != OK) || (entry.count != 1)) {
219 ALOGE("%s: Invalid ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS!", __FUNCTION__);
220 return BAD_VALUE;
221 }
222
223 sensor_chars->max_input_streams = entry.data.i32[0];
224 }
225
226 ret = metadata->Get(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &entry);
227 if ((ret == OK) && (entry.count == 1)) {
228 if (entry.data.u8[0] == 0) {
229 ALOGE("%s: Maximum request pipeline must have a non zero value!",
230 __FUNCTION__);
231 return BAD_VALUE;
232 }
233 sensor_chars->max_pipeline_depth = entry.data.u8[0];
234 } else {
235 ALOGE("%s: Maximum request pipeline depth absent!", __FUNCTION__);
236 return BAD_VALUE;
237 }
238
239 ret = metadata->Get(ANDROID_SENSOR_ORIENTATION, &entry);
240 if ((ret == OK) && (entry.count == 1)) {
241 sensor_chars->orientation = entry.data.i32[0];
242 } else {
243 ALOGE("%s: Sensor orientation absent!", __FUNCTION__);
244 return BAD_VALUE;
245 }
246
247 ret = metadata->Get(ANDROID_LENS_FACING, &entry);
248 if ((ret == OK) && (entry.count == 1)) {
249 sensor_chars->is_front_facing = false;
250 if (ANDROID_LENS_FACING_FRONT == entry.data.u8[0]) {
251 sensor_chars->is_front_facing = true;
252 }
253 } else {
254 ALOGE("%s: Lens facing absent!", __FUNCTION__);
255 return BAD_VALUE;
256 }
257
258 if (HasCapability(metadata,
259 ANDROID_REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE)) {
260 sensor_chars->support_stream_use_case = true;
261 } else {
262 sensor_chars->support_stream_use_case = false;
263 }
264
265 return ret;
266 }
267
ClonePhysicalDeviceMap(const PhysicalDeviceMapPtr & src)268 PhysicalDeviceMapPtr ClonePhysicalDeviceMap(const PhysicalDeviceMapPtr& src) {
269 auto ret = std::make_unique<PhysicalDeviceMap>();
270 for (const auto& it : *src) {
271 ret->emplace(it.first, std::make_pair(it.second.first,
272 HalCameraMetadata::Clone(it.second.second.get())));
273 }
274 return ret;
275 }
276
277 } // namespace android
278