1 /*
2 * Copyright (C) 2016 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 #define LOG_TAG "CamComm1.0-CamModule"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include <utils/Trace.h>
22
23 #include "CameraModule.h"
24
25 namespace android {
26 namespace hardware {
27 namespace camera {
28 namespace common {
29 namespace V1_0 {
30 namespace helper {
31
deriveCameraCharacteristicsKeys(uint32_t deviceVersion,CameraMetadata & chars)32 void CameraModule::deriveCameraCharacteristicsKeys(
33 uint32_t deviceVersion, CameraMetadata &chars) {
34 ATRACE_CALL();
35
36 Vector<int32_t> derivedCharKeys;
37 Vector<int32_t> derivedRequestKeys;
38 Vector<int32_t> derivedResultKeys;
39 // Keys added in HAL3.3
40 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_3) {
41 Vector<uint8_t> controlModes;
42 uint8_t data = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
43 chars.update(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &data, /*count*/1);
44 data = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
45 chars.update(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &data, /*count*/1);
46 controlModes.push(ANDROID_CONTROL_MODE_AUTO);
47 camera_metadata_entry entry = chars.find(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
48 if (entry.count > 1 || entry.data.u8[0] != ANDROID_CONTROL_SCENE_MODE_DISABLED) {
49 controlModes.push(ANDROID_CONTROL_MODE_USE_SCENE_MODE);
50 }
51
52 // Only advertise CONTROL_OFF mode if 3A manual controls are supported.
53 bool isManualAeSupported = false;
54 bool isManualAfSupported = false;
55 bool isManualAwbSupported = false;
56 entry = chars.find(ANDROID_CONTROL_AE_AVAILABLE_MODES);
57 if (entry.count > 0) {
58 for (size_t i = 0; i < entry.count; i++) {
59 if (entry.data.u8[i] == ANDROID_CONTROL_AE_MODE_OFF) {
60 isManualAeSupported = true;
61 break;
62 }
63 }
64 }
65 entry = chars.find(ANDROID_CONTROL_AF_AVAILABLE_MODES);
66 if (entry.count > 0) {
67 for (size_t i = 0; i < entry.count; i++) {
68 if (entry.data.u8[i] == ANDROID_CONTROL_AF_MODE_OFF) {
69 isManualAfSupported = true;
70 break;
71 }
72 }
73 }
74 entry = chars.find(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
75 if (entry.count > 0) {
76 for (size_t i = 0; i < entry.count; i++) {
77 if (entry.data.u8[i] == ANDROID_CONTROL_AWB_MODE_OFF) {
78 isManualAwbSupported = true;
79 break;
80 }
81 }
82 }
83 if (isManualAeSupported && isManualAfSupported && isManualAwbSupported) {
84 controlModes.push(ANDROID_CONTROL_MODE_OFF);
85 }
86
87 chars.update(ANDROID_CONTROL_AVAILABLE_MODES, controlModes);
88
89 entry = chars.find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
90 // HAL3.2 devices passing existing CTS test should all support all LSC modes and LSC map
91 bool lensShadingModeSupported = false;
92 if (entry.count > 0) {
93 for (size_t i = 0; i < entry.count; i++) {
94 if (entry.data.i32[i] == ANDROID_SHADING_MODE) {
95 lensShadingModeSupported = true;
96 break;
97 }
98 }
99 }
100 Vector<uint8_t> lscModes;
101 Vector<uint8_t> lscMapModes;
102 lscModes.push(ANDROID_SHADING_MODE_FAST);
103 lscModes.push(ANDROID_SHADING_MODE_HIGH_QUALITY);
104 lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
105 if (lensShadingModeSupported) {
106 lscModes.push(ANDROID_SHADING_MODE_OFF);
107 lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON);
108 }
109 chars.update(ANDROID_SHADING_AVAILABLE_MODES, lscModes);
110 chars.update(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, lscMapModes);
111
112 derivedCharKeys.push(ANDROID_CONTROL_AE_LOCK_AVAILABLE);
113 derivedCharKeys.push(ANDROID_CONTROL_AWB_LOCK_AVAILABLE);
114 derivedCharKeys.push(ANDROID_CONTROL_AVAILABLE_MODES);
115 derivedCharKeys.push(ANDROID_SHADING_AVAILABLE_MODES);
116 derivedCharKeys.push(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES);
117
118 // Need update android.control.availableHighSpeedVideoConfigurations since HAL3.3
119 // adds batch size to this array.
120 entry = chars.find(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS);
121 if (entry.count > 0) {
122 Vector<int32_t> highSpeedConfig;
123 for (size_t i = 0; i < entry.count; i += 4) {
124 highSpeedConfig.add(entry.data.i32[i]); // width
125 highSpeedConfig.add(entry.data.i32[i + 1]); // height
126 highSpeedConfig.add(entry.data.i32[i + 2]); // fps_min
127 highSpeedConfig.add(entry.data.i32[i + 3]); // fps_max
128 highSpeedConfig.add(1); // batchSize_max. default to 1 for HAL3.2
129 }
130 chars.update(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS,
131 highSpeedConfig);
132 }
133 }
134
135 // Keys added in HAL3.4
136 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_4) {
137 // Check if HAL supports RAW_OPAQUE output
138 camera_metadata_entry entry = chars.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
139 bool supportRawOpaque = false;
140 bool supportAnyRaw = false;
141 const int STREAM_CONFIGURATION_SIZE = 4;
142 const int STREAM_FORMAT_OFFSET = 0;
143 const int STREAM_WIDTH_OFFSET = 1;
144 const int STREAM_HEIGHT_OFFSET = 2;
145 const int STREAM_IS_INPUT_OFFSET = 3;
146 Vector<int32_t> rawOpaqueSizes;
147
148 for (size_t i=0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
149 int32_t format = entry.data.i32[i + STREAM_FORMAT_OFFSET];
150 int32_t width = entry.data.i32[i + STREAM_WIDTH_OFFSET];
151 int32_t height = entry.data.i32[i + STREAM_HEIGHT_OFFSET];
152 int32_t isInput = entry.data.i32[i + STREAM_IS_INPUT_OFFSET];
153 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
154 format == HAL_PIXEL_FORMAT_RAW_OPAQUE) {
155 supportRawOpaque = true;
156 rawOpaqueSizes.push(width);
157 rawOpaqueSizes.push(height);
158 // 2 bytes per pixel. This rough estimation is only used when
159 // HAL does not fill in the opaque raw size
160 rawOpaqueSizes.push(width * height *2);
161 }
162 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
163 (format == HAL_PIXEL_FORMAT_RAW16 ||
164 format == HAL_PIXEL_FORMAT_RAW10 ||
165 format == HAL_PIXEL_FORMAT_RAW12 ||
166 format == HAL_PIXEL_FORMAT_RAW_OPAQUE)) {
167 supportAnyRaw = true;
168 }
169 }
170
171 if (supportRawOpaque) {
172 entry = chars.find(ANDROID_SENSOR_OPAQUE_RAW_SIZE);
173 if (entry.count == 0) {
174 // Fill in estimated value if HAL does not list it
175 chars.update(ANDROID_SENSOR_OPAQUE_RAW_SIZE, rawOpaqueSizes);
176 derivedCharKeys.push(ANDROID_SENSOR_OPAQUE_RAW_SIZE);
177 }
178 }
179
180 // Check if HAL supports any RAW output, if so, fill in postRawSensitivityBoost range
181 if (supportAnyRaw) {
182 int32_t defaultRange[2] = {100, 100};
183 entry = chars.find(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE);
184 if (entry.count == 0) {
185 // Fill in default value (100, 100)
186 chars.update(
187 ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE,
188 defaultRange, 2);
189 derivedCharKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE);
190 // Actual request/results will be derived by camera device.
191 derivedRequestKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST);
192 derivedResultKeys.push(ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST);
193 }
194 }
195 }
196
197 // Always add a default for the pre-correction active array if the vendor chooses to omit this
198 camera_metadata_entry entry = chars.find(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
199 if (entry.count == 0) {
200 Vector<int32_t> preCorrectionArray;
201 entry = chars.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
202 preCorrectionArray.appendArray(entry.data.i32, entry.count);
203 chars.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE, preCorrectionArray);
204 derivedCharKeys.push(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
205 }
206
207 // Add those newly added keys to AVAILABLE_CHARACTERISTICS_KEYS
208 // This has to be done at this end of this function.
209 if (derivedCharKeys.size() > 0) {
210 appendAvailableKeys(
211 chars, ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, derivedCharKeys);
212 }
213 if (derivedRequestKeys.size() > 0) {
214 appendAvailableKeys(
215 chars, ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, derivedRequestKeys);
216 }
217 if (derivedResultKeys.size() > 0) {
218 appendAvailableKeys(
219 chars, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, derivedResultKeys);
220 }
221 return;
222 }
223
appendAvailableKeys(CameraMetadata & chars,int32_t keyTag,const Vector<int32_t> & appendKeys)224 void CameraModule::appendAvailableKeys(CameraMetadata &chars,
225 int32_t keyTag, const Vector<int32_t>& appendKeys) {
226 camera_metadata_entry entry = chars.find(keyTag);
227 Vector<int32_t> availableKeys;
228 availableKeys.setCapacity(entry.count + appendKeys.size());
229 for (size_t i = 0; i < entry.count; i++) {
230 availableKeys.push(entry.data.i32[i]);
231 }
232 for (size_t i = 0; i < appendKeys.size(); i++) {
233 availableKeys.push(appendKeys[i]);
234 }
235 chars.update(keyTag, availableKeys);
236 }
237
CameraModule(camera_module_t * module)238 CameraModule::CameraModule(camera_module_t *module) {
239 if (module == NULL) {
240 ALOGE("%s: camera hardware module must not be null", __FUNCTION__);
241 assert(0);
242 }
243 mModule = module;
244 }
245
~CameraModule()246 CameraModule::~CameraModule()
247 {
248 while (mCameraInfoMap.size() > 0) {
249 camera_info cameraInfo = mCameraInfoMap.editValueAt(0);
250 if (cameraInfo.static_camera_characteristics != NULL) {
251 free_camera_metadata(
252 const_cast<camera_metadata_t*>(cameraInfo.static_camera_characteristics));
253 }
254 mCameraInfoMap.removeItemsAt(0);
255 }
256 }
257
init()258 int CameraModule::init() {
259 ATRACE_CALL();
260 int res = OK;
261 if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 &&
262 mModule->init != NULL) {
263 ATRACE_BEGIN("camera_module->init");
264 res = mModule->init();
265 ATRACE_END();
266 }
267 mCameraInfoMap.setCapacity(getNumberOfCameras());
268 return res;
269 }
270
getCameraInfo(int cameraId,struct camera_info * info)271 int CameraModule::getCameraInfo(int cameraId, struct camera_info *info) {
272 ATRACE_CALL();
273 Mutex::Autolock lock(mCameraInfoLock);
274 if (cameraId < 0) {
275 ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
276 return -EINVAL;
277 }
278
279 // Only override static_camera_characteristics for API2 devices
280 int apiVersion = mModule->common.module_api_version;
281 if (apiVersion < CAMERA_MODULE_API_VERSION_2_0) {
282 int ret;
283 ATRACE_BEGIN("camera_module->get_camera_info");
284 ret = mModule->get_camera_info(cameraId, info);
285 // Fill in this so CameraService won't be confused by
286 // possibly 0 device_version
287 info->device_version = CAMERA_DEVICE_API_VERSION_1_0;
288 ATRACE_END();
289 return ret;
290 }
291
292 ssize_t index = mCameraInfoMap.indexOfKey(cameraId);
293 if (index == NAME_NOT_FOUND) {
294 // Get camera info from raw module and cache it
295 camera_info rawInfo, cameraInfo;
296 ATRACE_BEGIN("camera_module->get_camera_info");
297 int ret = mModule->get_camera_info(cameraId, &rawInfo);
298 ATRACE_END();
299 if (ret != 0) {
300 return ret;
301 }
302 int deviceVersion = rawInfo.device_version;
303 if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_0) {
304 // static_camera_characteristics is invalid
305 *info = rawInfo;
306 return ret;
307 }
308 CameraMetadata m;
309 m = rawInfo.static_camera_characteristics;
310 deriveCameraCharacteristicsKeys(rawInfo.device_version, m);
311 cameraInfo = rawInfo;
312 cameraInfo.static_camera_characteristics = m.release();
313 index = mCameraInfoMap.add(cameraId, cameraInfo);
314 }
315
316 assert(index != NAME_NOT_FOUND);
317 // return the cached camera info
318 *info = mCameraInfoMap[index];
319 return OK;
320 }
321
getDeviceVersion(int cameraId)322 int CameraModule::getDeviceVersion(int cameraId) {
323 ssize_t index = mDeviceVersionMap.indexOfKey(cameraId);
324 if (index == NAME_NOT_FOUND) {
325 int deviceVersion;
326 if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_0) {
327 struct camera_info info;
328 getCameraInfo(cameraId, &info);
329 deviceVersion = info.device_version;
330 } else {
331 deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
332 }
333 index = mDeviceVersionMap.add(cameraId, deviceVersion);
334 }
335 assert(index != NAME_NOT_FOUND);
336 return mDeviceVersionMap[index];
337 }
338
open(const char * id,struct hw_device_t ** device)339 int CameraModule::open(const char* id, struct hw_device_t** device) {
340 int res;
341 ATRACE_BEGIN("camera_module->open");
342 res = filterOpenErrorCode(mModule->common.methods->open(&mModule->common, id, device));
343 ATRACE_END();
344 return res;
345 }
346
isOpenLegacyDefined() const347 bool CameraModule::isOpenLegacyDefined() const {
348 if (getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_3) {
349 return false;
350 }
351 return mModule->open_legacy != NULL;
352 }
353
openLegacy(const char * id,uint32_t halVersion,struct hw_device_t ** device)354 int CameraModule::openLegacy(
355 const char* id, uint32_t halVersion, struct hw_device_t** device) {
356 int res;
357 ATRACE_BEGIN("camera_module->open_legacy");
358 res = mModule->open_legacy(&mModule->common, id, halVersion, device);
359 ATRACE_END();
360 return res;
361 }
362
getNumberOfCameras()363 int CameraModule::getNumberOfCameras() {
364 int numCameras;
365 ATRACE_BEGIN("camera_module->get_number_of_cameras");
366 numCameras = mModule->get_number_of_cameras();
367 ATRACE_END();
368 return numCameras;
369 }
370
setCallbacks(const camera_module_callbacks_t * callbacks)371 int CameraModule::setCallbacks(const camera_module_callbacks_t *callbacks) {
372 int res = OK;
373 ATRACE_BEGIN("camera_module->set_callbacks");
374 if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_1) {
375 res = mModule->set_callbacks(callbacks);
376 }
377 ATRACE_END();
378 return res;
379 }
380
isVendorTagDefined() const381 bool CameraModule::isVendorTagDefined() const {
382 return mModule->get_vendor_tag_ops != NULL;
383 }
384
getVendorTagOps(vendor_tag_ops_t * ops)385 void CameraModule::getVendorTagOps(vendor_tag_ops_t* ops) {
386 if (mModule->get_vendor_tag_ops) {
387 ATRACE_BEGIN("camera_module->get_vendor_tag_ops");
388 mModule->get_vendor_tag_ops(ops);
389 ATRACE_END();
390 }
391 }
392
isSetTorchModeSupported() const393 bool CameraModule::isSetTorchModeSupported() const {
394 if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
395 if (mModule->set_torch_mode == NULL) {
396 ALOGE("%s: Module 2.4 device must support set torch API!",
397 __FUNCTION__);
398 return false;
399 }
400 return true;
401 }
402 return false;
403 }
404
setTorchMode(const char * camera_id,bool enable)405 int CameraModule::setTorchMode(const char* camera_id, bool enable) {
406 int res = INVALID_OPERATION;
407 if (mModule->set_torch_mode != NULL) {
408 ATRACE_BEGIN("camera_module->set_torch_mode");
409 res = mModule->set_torch_mode(camera_id, enable);
410 ATRACE_END();
411 }
412 return res;
413 }
414
filterOpenErrorCode(status_t err)415 status_t CameraModule::filterOpenErrorCode(status_t err) {
416 switch(err) {
417 case NO_ERROR:
418 case -EBUSY:
419 case -EINVAL:
420 case -EUSERS:
421 return err;
422 default:
423 break;
424 }
425 return -ENODEV;
426 }
427
getModuleApiVersion() const428 uint16_t CameraModule::getModuleApiVersion() const {
429 return mModule->common.module_api_version;
430 }
431
getModuleName() const432 const char* CameraModule::getModuleName() const {
433 return mModule->common.name;
434 }
435
getHalApiVersion() const436 uint16_t CameraModule::getHalApiVersion() const {
437 return mModule->common.hal_api_version;
438 }
439
getModuleAuthor() const440 const char* CameraModule::getModuleAuthor() const {
441 return mModule->common.author;
442 }
443
getDso()444 void* CameraModule::getDso() {
445 return mModule->common.dso;
446 }
447
448 } // namespace helper
449 } // namespace V1_0
450 } // namespace common
451 } // namespace camera
452 } // namespace hardware
453 } // namespace android
454