1/*
2 * Copyright (C) 2015 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 "CameraModule"
18//#define LOG_NDEBUG 0
19
20#include "CameraModule.h"
21
22namespace android {
23
24void CameraModule::deriveCameraCharacteristicsKeys(
25        uint32_t deviceVersion, CameraMetadata &chars) {
26    // HAL1 devices should not reach here
27    if (deviceVersion < CAMERA_DEVICE_API_VERSION_2_0) {
28        ALOGV("%s: Cannot derive keys for HAL version < 2.0");
29        return;
30    }
31
32    // Keys added in HAL3.3
33    if (deviceVersion < CAMERA_DEVICE_API_VERSION_3_3) {
34        const size_t NUM_DERIVED_KEYS_HAL3_3 = 5;
35        Vector<uint8_t> controlModes;
36        uint8_t data = ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE;
37        chars.update(ANDROID_CONTROL_AE_LOCK_AVAILABLE, &data, /*count*/1);
38        data = ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE;
39        chars.update(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, &data, /*count*/1);
40        controlModes.push(ANDROID_CONTROL_MODE_AUTO);
41        camera_metadata_entry entry = chars.find(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
42        if (entry.count > 1 || entry.data.u8[0] != ANDROID_CONTROL_SCENE_MODE_DISABLED) {
43            controlModes.push(ANDROID_CONTROL_MODE_USE_SCENE_MODE);
44        }
45
46        // Only advertise CONTROL_OFF mode if 3A manual controls are supported.
47        bool isManualAeSupported = false;
48        bool isManualAfSupported = false;
49        bool isManualAwbSupported = false;
50        entry = chars.find(ANDROID_CONTROL_AE_AVAILABLE_MODES);
51        if (entry.count > 0) {
52            for (size_t i = 0; i < entry.count; i++) {
53                if (entry.data.u8[i] == ANDROID_CONTROL_AE_MODE_OFF) {
54                    isManualAeSupported = true;
55                    break;
56                }
57            }
58        }
59        entry = chars.find(ANDROID_CONTROL_AF_AVAILABLE_MODES);
60        if (entry.count > 0) {
61            for (size_t i = 0; i < entry.count; i++) {
62                if (entry.data.u8[i] == ANDROID_CONTROL_AF_MODE_OFF) {
63                    isManualAfSupported = true;
64                    break;
65                }
66            }
67        }
68        entry = chars.find(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
69        if (entry.count > 0) {
70            for (size_t i = 0; i < entry.count; i++) {
71                if (entry.data.u8[i] == ANDROID_CONTROL_AWB_MODE_OFF) {
72                    isManualAwbSupported = true;
73                    break;
74                }
75            }
76        }
77        if (isManualAeSupported && isManualAfSupported && isManualAwbSupported) {
78            controlModes.push(ANDROID_CONTROL_MODE_OFF);
79        }
80
81        chars.update(ANDROID_CONTROL_AVAILABLE_MODES, controlModes);
82
83        entry = chars.find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
84        // HAL3.2 devices passing existing CTS test should all support all LSC modes and LSC map
85        bool lensShadingModeSupported = false;
86        if (entry.count > 0) {
87            for (size_t i = 0; i < entry.count; i++) {
88                if (entry.data.i32[i] == ANDROID_SHADING_MODE) {
89                    lensShadingModeSupported = true;
90                    break;
91                }
92            }
93        }
94        Vector<uint8_t> lscModes;
95        Vector<uint8_t> lscMapModes;
96        lscModes.push(ANDROID_SHADING_MODE_FAST);
97        lscModes.push(ANDROID_SHADING_MODE_HIGH_QUALITY);
98        lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF);
99        if (lensShadingModeSupported) {
100            lscModes.push(ANDROID_SHADING_MODE_OFF);
101            lscMapModes.push(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON);
102        }
103        chars.update(ANDROID_SHADING_AVAILABLE_MODES, lscModes);
104        chars.update(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, lscMapModes);
105
106        entry = chars.find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
107        Vector<int32_t> availableCharsKeys;
108        availableCharsKeys.setCapacity(entry.count + NUM_DERIVED_KEYS_HAL3_3);
109        for (size_t i = 0; i < entry.count; i++) {
110            availableCharsKeys.push(entry.data.i32[i]);
111        }
112        availableCharsKeys.push(ANDROID_CONTROL_AE_LOCK_AVAILABLE);
113        availableCharsKeys.push(ANDROID_CONTROL_AWB_LOCK_AVAILABLE);
114        availableCharsKeys.push(ANDROID_CONTROL_AVAILABLE_MODES);
115        availableCharsKeys.push(ANDROID_SHADING_AVAILABLE_MODES);
116        availableCharsKeys.push(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES);
117        chars.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, availableCharsKeys);
118
119        // Need update android.control.availableHighSpeedVideoConfigurations since HAL3.3
120        // adds batch size to this array.
121        entry = chars.find(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS);
122        if (entry.count > 0) {
123            Vector<int32_t> highSpeedConfig;
124            for (size_t i = 0; i < entry.count; i += 4) {
125                highSpeedConfig.add(entry.data.i32[i]); // width
126                highSpeedConfig.add(entry.data.i32[i + 1]); // height
127                highSpeedConfig.add(entry.data.i32[i + 2]); // fps_min
128                highSpeedConfig.add(entry.data.i32[i + 3]); // fps_max
129                highSpeedConfig.add(1); // batchSize_max. default to 1 for HAL3.2
130            }
131            chars.update(ANDROID_CONTROL_AVAILABLE_HIGH_SPEED_VIDEO_CONFIGURATIONS,
132                    highSpeedConfig);
133        }
134    }
135
136    // Always add a default for the pre-correction active array if the vendor chooses to omit this
137    camera_metadata_entry entry = chars.find(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
138    if (entry.count == 0) {
139        Vector<int32_t> preCorrectionArray;
140        entry = chars.find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
141        preCorrectionArray.appendArray(entry.data.i32, entry.count);
142        chars.update(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE, preCorrectionArray);
143    }
144
145    return;
146}
147
148CameraModule::CameraModule(camera_module_t *module) {
149    if (module == NULL) {
150        ALOGE("%s: camera hardware module must not be null", __FUNCTION__);
151        assert(0);
152    }
153
154    mModule = module;
155    mCameraInfoMap.setCapacity(getNumberOfCameras());
156}
157
158CameraModule::~CameraModule()
159{
160    while (mCameraInfoMap.size() > 0) {
161        camera_info cameraInfo = mCameraInfoMap.editValueAt(0);
162        if (cameraInfo.static_camera_characteristics != NULL) {
163            free_camera_metadata(
164                    const_cast<camera_metadata_t*>(cameraInfo.static_camera_characteristics));
165        }
166        mCameraInfoMap.removeItemsAt(0);
167    }
168}
169
170int CameraModule::init() {
171    if (getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4 &&
172            mModule->init != NULL) {
173        return mModule->init();
174    }
175    return OK;
176}
177
178int CameraModule::getCameraInfo(int cameraId, struct camera_info *info) {
179    Mutex::Autolock lock(mCameraInfoLock);
180    if (cameraId < 0) {
181        ALOGE("%s: Invalid camera ID %d", __FUNCTION__, cameraId);
182        return -EINVAL;
183    }
184
185    // Only override static_camera_characteristics for API2 devices
186    int apiVersion = mModule->common.module_api_version;
187    if (apiVersion < CAMERA_MODULE_API_VERSION_2_0) {
188        return mModule->get_camera_info(cameraId, info);
189    }
190
191    ssize_t index = mCameraInfoMap.indexOfKey(cameraId);
192    if (index == NAME_NOT_FOUND) {
193        // Get camera info from raw module and cache it
194        camera_info rawInfo, cameraInfo;
195        int ret = mModule->get_camera_info(cameraId, &rawInfo);
196        if (ret != 0) {
197            return ret;
198        }
199        int deviceVersion = rawInfo.device_version;
200        if (deviceVersion < CAMERA_DEVICE_API_VERSION_2_0) {
201            // static_camera_characteristics is invalid
202            *info = rawInfo;
203            return ret;
204        }
205        CameraMetadata m;
206        m = rawInfo.static_camera_characteristics;
207        deriveCameraCharacteristicsKeys(rawInfo.device_version, m);
208        cameraInfo = rawInfo;
209        cameraInfo.static_camera_characteristics = m.release();
210        index = mCameraInfoMap.add(cameraId, cameraInfo);
211    }
212
213    assert(index != NAME_NOT_FOUND);
214    // return the cached camera info
215    *info = mCameraInfoMap[index];
216    return OK;
217}
218
219int CameraModule::open(const char* id, struct hw_device_t** device) {
220    return filterOpenErrorCode(mModule->common.methods->open(&mModule->common, id, device));
221}
222
223int CameraModule::openLegacy(
224        const char* id, uint32_t halVersion, struct hw_device_t** device) {
225    return mModule->open_legacy(&mModule->common, id, halVersion, device);
226}
227
228int CameraModule::getNumberOfCameras() {
229    return mModule->get_number_of_cameras();
230}
231
232int CameraModule::setCallbacks(const camera_module_callbacks_t *callbacks) {
233    return mModule->set_callbacks(callbacks);
234}
235
236bool CameraModule::isVendorTagDefined() {
237    return mModule->get_vendor_tag_ops != NULL;
238}
239
240void CameraModule::getVendorTagOps(vendor_tag_ops_t* ops) {
241    if (mModule->get_vendor_tag_ops) {
242        mModule->get_vendor_tag_ops(ops);
243    }
244}
245
246int CameraModule::setTorchMode(const char* camera_id, bool enable) {
247    return mModule->set_torch_mode(camera_id, enable);
248}
249
250status_t CameraModule::filterOpenErrorCode(status_t err) {
251    switch(err) {
252        case NO_ERROR:
253        case -EBUSY:
254        case -EINVAL:
255        case -EUSERS:
256            return err;
257        default:
258            break;
259    }
260    return -ENODEV;
261}
262
263uint16_t CameraModule::getModuleApiVersion() {
264    return mModule->common.module_api_version;
265}
266
267const char* CameraModule::getModuleName() {
268    return mModule->common.name;
269}
270
271uint16_t CameraModule::getHalApiVersion() {
272    return mModule->common.hal_api_version;
273}
274
275const char* CameraModule::getModuleAuthor() {
276    return mModule->common.author;
277}
278
279void* CameraModule::getDso() {
280    return mModule->common.dso;
281}
282
283}; // namespace android
284