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