1 /*
2 * Copyright (C) 2018 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 <hidl/Utils.h>
18 #include <hidl/VndkVersionMetadataTags.h>
19 #include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
20 #include <cutils/native_handle.h>
21 #include <mediautils/AImageReaderUtils.h>
22
23 namespace android {
24 namespace hardware {
25 namespace cameraservice {
26 namespace utils {
27 namespace conversion {
28
29 using hardware::graphics::bufferqueue::V1_0::utils::H2BGraphicBufferProducer;
30 using aimg::AImageReader_getHGBPFromHandle;
31
32 // Note: existing data in dst will be gone. Caller still owns the memory of src
convertToHidl(const camera_metadata_t * src,HCameraMetadata * dst)33 void convertToHidl(const camera_metadata_t *src, HCameraMetadata* dst) {
34 if (src == nullptr) {
35 ALOGW("%s:attempt to convert empty metadata to Hidl", __FUNCTION__);
36 return;
37 }
38 size_t size = get_camera_metadata_size(src);
39 dst->setToExternal((uint8_t *) src, size);
40 return;
41 }
42
convertFromHidl(HStreamConfigurationMode streamConfigurationMode)43 int32_t convertFromHidl(HStreamConfigurationMode streamConfigurationMode) {
44 switch (streamConfigurationMode) {
45 case HStreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE:
46 return camera2::ICameraDeviceUser::CONSTRAINED_HIGH_SPEED_MODE;
47 case HStreamConfigurationMode::NORMAL_MODE:
48 return camera2::ICameraDeviceUser::NORMAL_MODE;
49 default:
50 // TODO: Fix this
51 return camera2::ICameraDeviceUser::VENDOR_MODE_START;
52 }
53 }
54
convertFromHidl(HTemplateId templateId)55 int32_t convertFromHidl(HTemplateId templateId) {
56 switch(templateId) {
57 case HTemplateId::PREVIEW:
58 return camera2::ICameraDeviceUser::TEMPLATE_PREVIEW;
59 case HTemplateId::STILL_CAPTURE:
60 return camera2::ICameraDeviceUser::TEMPLATE_STILL_CAPTURE;
61 case HTemplateId::RECORD:
62 return camera2::ICameraDeviceUser::TEMPLATE_RECORD;
63 case HTemplateId::VIDEO_SNAPSHOT:
64 return camera2::ICameraDeviceUser::TEMPLATE_VIDEO_SNAPSHOT;
65 case HTemplateId::ZERO_SHUTTER_LAG:
66 return camera2::ICameraDeviceUser::TEMPLATE_ZERO_SHUTTER_LAG;
67 case HTemplateId::MANUAL:
68 return camera2::ICameraDeviceUser::TEMPLATE_MANUAL;
69 }
70 }
71
convertFromHidl(HOutputConfiguration::Rotation rotation)72 int convertFromHidl(HOutputConfiguration::Rotation rotation) {
73 switch(rotation) {
74 case HOutputConfiguration::Rotation::R0:
75 return 0;
76 case HOutputConfiguration::Rotation::R90:
77 return 1;
78 case HOutputConfiguration::Rotation::R180:
79 return 2;
80 case HOutputConfiguration::Rotation::R270:
81 return 3;
82 }
83 }
84
convertFromHidl(const HOutputConfiguration & hOutputConfiguration)85 hardware::camera2::params::OutputConfiguration convertFromHidl(
86 const HOutputConfiguration &hOutputConfiguration) {
87 std::vector<sp<IGraphicBufferProducer>> iGBPs;
88 auto &windowHandles = hOutputConfiguration.windowHandles;
89 iGBPs.reserve(windowHandles.size());
90 for (auto &handle : windowHandles) {
91 iGBPs.push_back(new H2BGraphicBufferProducer(AImageReader_getHGBPFromHandle(handle)));
92 }
93 String16 physicalCameraId16(hOutputConfiguration.physicalCameraId.c_str());
94 hardware::camera2::params::OutputConfiguration outputConfiguration(
95 iGBPs, convertFromHidl(hOutputConfiguration.rotation), physicalCameraId16,
96 hOutputConfiguration.windowGroupId, OutputConfiguration::SURFACE_TYPE_UNKNOWN, 0, 0,
97 (windowHandles.size() > 1));
98 return outputConfiguration;
99 }
100
convertFromHidl(const HSessionConfiguration & hSessionConfiguration)101 hardware::camera2::params::SessionConfiguration convertFromHidl(
102 const HSessionConfiguration &hSessionConfiguration) {
103 hardware::camera2::params::SessionConfiguration sessionConfig(
104 hSessionConfiguration.inputWidth, hSessionConfiguration.inputHeight,
105 hSessionConfiguration.inputFormat,
106 static_cast<int>(hSessionConfiguration.operationMode));
107
108 for (const auto& hConfig : hSessionConfiguration.outputStreams) {
109 hardware::camera2::params::OutputConfiguration config = convertFromHidl(hConfig);
110 sessionConfig.addOutputConfiguration(config);
111 }
112
113 return sessionConfig;
114 }
115
116 // The camera metadata here is cloned. Since we're reading metadata over
117 // hwbinder we would need to clone it in order to avoid aligment issues.
convertFromHidl(const HCameraMetadata & src,CameraMetadata * dst)118 bool convertFromHidl(const HCameraMetadata &src, CameraMetadata *dst) {
119 const camera_metadata_t *buffer = reinterpret_cast<const camera_metadata_t*>(src.data());
120 size_t expectedSize = src.size();
121 if (buffer != nullptr) {
122 int res = validate_camera_metadata_structure(buffer, &expectedSize);
123 if (res == OK || res == CAMERA_METADATA_VALIDATION_SHIFTED) {
124 *dst = buffer;
125 } else {
126 ALOGE("%s: Malformed camera metadata received from HAL", __FUNCTION__);
127 return false;
128 }
129 }
130 return true;
131 }
132
convertToHidlCameraDeviceStatus(int32_t status)133 HCameraDeviceStatus convertToHidlCameraDeviceStatus(int32_t status) {
134 HCameraDeviceStatus deviceStatus = HCameraDeviceStatus::STATUS_UNKNOWN;
135 switch(status) {
136 case hardware::ICameraServiceListener::STATUS_NOT_PRESENT:
137 deviceStatus = HCameraDeviceStatus::STATUS_NOT_PRESENT;
138 break;
139 case hardware::ICameraServiceListener::STATUS_PRESENT:
140 deviceStatus = HCameraDeviceStatus::STATUS_PRESENT;
141 break;
142 case hardware::ICameraServiceListener::STATUS_ENUMERATING:
143 deviceStatus = HCameraDeviceStatus::STATUS_ENUMERATING;
144 break;
145 case hardware::ICameraServiceListener::STATUS_NOT_AVAILABLE:
146 deviceStatus = HCameraDeviceStatus::STATUS_NOT_AVAILABLE;
147 break;
148 default:
149 break;
150 }
151 return deviceStatus;
152 }
153
convertToHidl(const CaptureResultExtras & captureResultExtras)154 HCaptureResultExtras convertToHidl(const CaptureResultExtras &captureResultExtras) {
155 HCaptureResultExtras hCaptureResultExtras;
156 hCaptureResultExtras.requestId = captureResultExtras.requestId;
157 hCaptureResultExtras.burstId = captureResultExtras.burstId;
158 hCaptureResultExtras.frameNumber = captureResultExtras.frameNumber;
159 hCaptureResultExtras.partialResultCount = captureResultExtras.partialResultCount;
160 hCaptureResultExtras.errorStreamId = captureResultExtras.errorStreamId;
161 hCaptureResultExtras.errorPhysicalCameraId = hidl_string(String8(
162 captureResultExtras.errorPhysicalCameraId).string());
163 return hCaptureResultExtras;
164 }
165
convertToHidl(int32_t errorCode)166 HErrorCode convertToHidl(int32_t errorCode) {
167 switch(errorCode) {
168 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED:
169 return HErrorCode::CAMERA_DISCONNECTED;
170 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE :
171 return HErrorCode::CAMERA_DEVICE;
172 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE:
173 return HErrorCode::CAMERA_SERVICE;
174 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
175 return HErrorCode::CAMERA_REQUEST;
176 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
177 return HErrorCode::CAMERA_RESULT;
178 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
179 return HErrorCode::CAMERA_BUFFER;
180 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISABLED:
181 return HErrorCode::CAMERA_DISABLED;
182 case camera2::ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR:
183 return HErrorCode::CAMERA_INVALID_ERROR;
184 default:
185 return HErrorCode::CAMERA_UNKNOWN_ERROR;
186 }
187 }
188
convertToHidl(const std::vector<hardware::CameraStatus> & src,hidl_vec<HCameraStatusAndId> * dst)189 void convertToHidl(const std::vector<hardware::CameraStatus> &src,
190 hidl_vec<HCameraStatusAndId>* dst) {
191 dst->resize(src.size());
192 size_t i = 0;
193 for (auto &statusAndId : src) {
194 auto &a = (*dst)[i++];
195 a.cameraId = statusAndId.cameraId.c_str();
196 a.deviceStatus = convertToHidlCameraDeviceStatus(statusAndId.status);
197 }
198 return;
199 }
200
convertToHidl(const std::vector<hardware::CameraStatus> & src,hidl_vec<frameworks::cameraservice::service::V2_1::CameraStatusAndId> * dst)201 void convertToHidl(const std::vector<hardware::CameraStatus> &src,
202 hidl_vec<frameworks::cameraservice::service::V2_1::CameraStatusAndId>* dst) {
203 dst->resize(src.size());
204 size_t i = 0;
205 for (const auto &statusAndId : src) {
206 auto &a = (*dst)[i++];
207 a.v2_0.cameraId = statusAndId.cameraId.c_str();
208 a.v2_0.deviceStatus = convertToHidlCameraDeviceStatus(statusAndId.status);
209 size_t numUnvailPhysicalCameras = statusAndId.unavailablePhysicalIds.size();
210 a.unavailPhysicalCameraIds.resize(numUnvailPhysicalCameras);
211 for (size_t j = 0; j < numUnvailPhysicalCameras; j++) {
212 a.unavailPhysicalCameraIds[j] = statusAndId.unavailablePhysicalIds[j].c_str();
213 }
214 }
215 return;
216 }
217
convertToHidl(const hardware::camera2::utils::SubmitInfo & submitInfo,frameworks::cameraservice::device::V2_0::SubmitInfo * hSubmitInfo)218 void convertToHidl(
219 const hardware::camera2::utils::SubmitInfo &submitInfo,
220 frameworks::cameraservice::device::V2_0::SubmitInfo *hSubmitInfo) {
221 hSubmitInfo->requestId = submitInfo.mRequestId;
222 hSubmitInfo->lastFrameNumber = submitInfo.mLastFrameNumber;
223 }
224
B2HStatus(const binder::Status & bStatus)225 HStatus B2HStatus(const binder::Status &bStatus) {
226 HStatus status = HStatus::NO_ERROR;
227 if (bStatus.isOk()) {
228 // NO Error here
229 return status;
230 }
231 switch(bStatus.serviceSpecificErrorCode()) {
232 case hardware::ICameraService::ERROR_DISCONNECTED:
233 status = HStatus::DISCONNECTED;
234 break;
235 case hardware::ICameraService::ERROR_CAMERA_IN_USE:
236 status = HStatus::CAMERA_IN_USE;
237 break;
238 case hardware::ICameraService::ERROR_MAX_CAMERAS_IN_USE:
239 status = HStatus::MAX_CAMERAS_IN_USE;
240 break;
241 case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT:
242 status = HStatus::ILLEGAL_ARGUMENT;
243 break;
244 case hardware::ICameraService::ERROR_DEPRECATED_HAL:
245 // Should not reach here since we filtered legacy HALs earlier
246 status = HStatus::DEPRECATED_HAL;
247 break;
248 case hardware::ICameraService::ERROR_DISABLED:
249 status = HStatus::DISABLED;
250 break;
251 case hardware::ICameraService::ERROR_PERMISSION_DENIED:
252 status = HStatus::PERMISSION_DENIED;
253 break;
254 case hardware::ICameraService::ERROR_INVALID_OPERATION:
255 status = HStatus::INVALID_OPERATION;
256 break;
257 default:
258 status = HStatus::UNKNOWN_ERROR;
259 break;
260 }
261 return status;
262 }
263
convertToHidl(const PhysicalCaptureResultInfo & physicalCaptureResultInfo,std::shared_ptr<CaptureResultMetadataQueue> & captureResultMetadataQueue)264 HPhysicalCaptureResultInfo convertToHidl(
265 const PhysicalCaptureResultInfo &physicalCaptureResultInfo,
266 std::shared_ptr<CaptureResultMetadataQueue> &captureResultMetadataQueue) {
267 HPhysicalCaptureResultInfo hPhysicalCaptureResultInfo;
268 hPhysicalCaptureResultInfo.physicalCameraId =
269 String8(physicalCaptureResultInfo.mPhysicalCameraId).string();
270 const camera_metadata_t *rawMetadata =
271 physicalCaptureResultInfo.mPhysicalCameraMetadata.getAndLock();
272 // Try using fmq at first.
273 size_t metadata_size = get_camera_metadata_size(rawMetadata);
274 if ((metadata_size > 0) && (captureResultMetadataQueue->availableToWrite() > 0)) {
275 if (captureResultMetadataQueue->write((uint8_t *)rawMetadata, metadata_size)) {
276 hPhysicalCaptureResultInfo.physicalCameraMetadata.fmqMetadataSize(metadata_size);
277 } else {
278 ALOGW("%s Couldn't use fmq, falling back to hwbinder", __FUNCTION__);
279 HCameraMetadata metadata;
280 convertToHidl(rawMetadata, &metadata);
281 hPhysicalCaptureResultInfo.physicalCameraMetadata.metadata(std::move(metadata));
282 }
283 }
284 physicalCaptureResultInfo.mPhysicalCameraMetadata.unlock(rawMetadata);
285 return hPhysicalCaptureResultInfo;
286 }
287
convertToHidl(const std::vector<PhysicalCaptureResultInfo> & physicalCaptureResultInfos,std::shared_ptr<CaptureResultMetadataQueue> & captureResultMetadataQueue)288 hidl_vec<HPhysicalCaptureResultInfo> convertToHidl(
289 const std::vector<PhysicalCaptureResultInfo> &physicalCaptureResultInfos,
290 std::shared_ptr<CaptureResultMetadataQueue> &captureResultMetadataQueue) {
291 hidl_vec<HPhysicalCaptureResultInfo> hPhysicalCaptureResultInfos;
292 hPhysicalCaptureResultInfos.resize(physicalCaptureResultInfos.size());
293 size_t i = 0;
294 for (auto &physicalCaptureResultInfo : physicalCaptureResultInfos) {
295 hPhysicalCaptureResultInfos[i++] = convertToHidl(physicalCaptureResultInfo,
296 captureResultMetadataQueue);
297 }
298 return hPhysicalCaptureResultInfos;
299 }
300
filterVndkKeys(int vndkVersion,CameraMetadata & metadata,bool isStatic)301 status_t filterVndkKeys(int vndkVersion, CameraMetadata &metadata, bool isStatic) {
302 if (vndkVersion == __ANDROID_API_FUTURE__) {
303 // VNDK version in ro.vndk.version is a version code-name that
304 // corresponds to the current version.
305 return OK;
306 }
307 const auto &apiLevelToKeys =
308 isStatic ? static_api_level_to_keys : dynamic_api_level_to_keys;
309 // Find the vndk versions above the given vndk version. All the vndk
310 // versions above the given one, need to have their keys filtered from the
311 // metadata in order to avoid metadata invalidation.
312 auto it = apiLevelToKeys.upper_bound(vndkVersion);
313 while (it != apiLevelToKeys.end()) {
314 for (const auto &key : it->second) {
315 status_t res = metadata.erase(key);
316 if (res != OK) {
317 ALOGE("%s metadata key %d could not be erased", __FUNCTION__, key);
318 return res;
319 }
320 }
321 it++;
322 }
323 return OK;
324 }
325
326 } //conversion
327 } // utils
328 } //cameraservice
329 } // hardware
330 } // android
331