blob: 5308dc40119eec3e652dae5ae94cca45c86b90af
1 | /* |
2 | * Copyright (C) 2014 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 | /* |
18 | * Contains implementation of a class EmulatedFakeCamera3 that encapsulates |
19 | * functionality of an advanced fake camera. |
20 | */ |
21 | |
22 | #define LOG_TAG "EmulatedCamera_FakeCamera3Info" |
23 | #include <camera/CameraMetadata.h> |
24 | #include "EmulatedFakeCamera3.h" |
25 | #include "inc/DebugUtils.h" |
26 | |
27 | namespace android { |
28 | |
29 | //level: legacy:0-4, limited:1-5, full:2-6 |
30 | const struct EmulatedFakeCamera3::KeyInfo_s EmulatedFakeCamera3::sKeyInfo[] = { |
31 | {ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES , LEGACY , BC }, |
32 | {ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES , LEGACY , BC }, |
33 | {ANDROID_CONTROL_AE_AVAILABLE_MODES , LEGACY , BC }, |
34 | {ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES , LEGACY , BC }, |
35 | {ANDROID_CONTROL_AE_COMPENSATION_RANGE , LEGACY , BC }, |
36 | {ANDROID_CONTROL_AE_COMPENSATION_STEP , LEGACY , BC }, |
37 | #if 1 |
38 | {ANDROID_CONTROL_AF_AVAILABLE_MODES , LEGACY , BC }, |
39 | #endif |
40 | {ANDROID_CONTROL_AVAILABLE_EFFECTS , LEGACY , BC }, |
41 | {ANDROID_CONTROL_AVAILABLE_SCENE_MODES , LEGACY , BC }, |
42 | {ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES , LEGACY , BC }, |
43 | {ANDROID_CONTROL_AWB_AVAILABLE_MODES , LEGACY , BC }, |
44 | // {ANDROID_CONTROL_MAX_REGIONS_AE , LEGACY , BC }, |
45 | // {ANDROID_CONTROL_MAX_REGIONS_AF , LEGACY , BC }, |
46 | // {ANDROID_CONTROL_MAX_REGIONS_AWB , LEGACY , BC }, |
47 | {ANDROID_EDGE_AVAILABLE_EDGE_MODES , FULL , NONE }, |
48 | {ANDROID_FLASH_INFO_AVAILABLE , LEGACY , BC }, |
49 | {ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES , OPT , RAW }, |
50 | {ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL , LEGACY , BC }, |
51 | {ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES , LEGACY , BC }, |
52 | {ANDROID_LENS_FACING , LEGACY , BC }, |
53 | {ANDROID_LENS_INFO_AVAILABLE_APERTURES , FULL , MANUAL_SENSOR }, |
54 | {ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES , FULL , MANUAL_SENSOR }, |
55 | {ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS , LEGACY , BC }, |
56 | {ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION , LIMITED , MANUAL_SENSOR }, |
57 | {ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION , LIMITED , MANUAL_SENSOR }, |
58 | {ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE , LIMITED , MANUAL_SENSOR }, |
59 | {ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE , LIMITED , NONE }, |
60 | {ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES , LEGACY , BC }, |
61 | {ANDROID_REQUEST_AVAILABLE_CAPABILITIES , LEGACY , BC }, |
62 | // {ANDROID_REQUEST_MAX_NUM_OUTPUT_PROC , LEGACY , BC }, |
63 | // {ANDROID_REQUEST_MAX_NUM_OUTPUT_PROC_STALLING , LEGACY , BC }, |
64 | // {ANDROID_REQUEST_MAX_NUM_OUTPUT_RAW , LEGACY , BC }, |
65 | {ANDROID_REQUEST_PARTIAL_RESULT_COUNT , LEGACY , BC }, |
66 | {ANDROID_REQUEST_PIPELINE_MAX_DEPTH , LEGACY , BC }, |
67 | {ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM , LEGACY , BC }, |
68 | // {ANDROID_SCALER_STREAM_CONFIGURATION_MAP , LEGACY , BC }, |
69 | {ANDROID_SCALER_CROPPING_TYPE , LEGACY , BC }, |
70 | {ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES , LEGACY , NONE }, |
71 | {ANDROID_SENSOR_BLACK_LEVEL_PATTERN , FULL , MANUAL_SENSOR | RAW }, |
72 | {ANDROID_SENSOR_CALIBRATION_TRANSFORM1 , OPT , RAW }, |
73 | {ANDROID_SENSOR_CALIBRATION_TRANSFORM2 , OPT , RAW }, |
74 | {ANDROID_SENSOR_COLOR_TRANSFORM1 , OPT , RAW }, |
75 | {ANDROID_SENSOR_COLOR_TRANSFORM2 , OPT , RAW }, |
76 | {ANDROID_SENSOR_FORWARD_MATRIX1 , OPT , RAW }, |
77 | {ANDROID_SENSOR_FORWARD_MATRIX2 , OPT , RAW }, |
78 | {ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE , LEGACY , BC | RAW }, |
79 | {ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT , FULL , RAW }, |
80 | {ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE , FULL , MANUAL_SENSOR }, |
81 | {ANDROID_SENSOR_INFO_MAX_FRAME_DURATION , FULL , MANUAL_SENSOR }, |
82 | {ANDROID_SENSOR_INFO_PHYSICAL_SIZE , LEGACY , BC }, |
83 | {ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE , LEGACY , BC }, |
84 | {ANDROID_SENSOR_INFO_SENSITIVITY_RANGE , FULL , MANUAL_SENSOR }, |
85 | {ANDROID_SENSOR_INFO_WHITE_LEVEL , OPT , RAW }, |
86 | {ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE , LEGACY , BC }, |
87 | {ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY , FULL , MANUAL_SENSOR }, |
88 | {ANDROID_SENSOR_ORIENTATION , LEGACY , BC }, |
89 | {ANDROID_SENSOR_REFERENCE_ILLUMINANT1 , OPT , RAW }, |
90 | {ANDROID_SENSOR_REFERENCE_ILLUMINANT2 , OPT , RAW }, |
91 | {ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES , LEGACY , BC }, |
92 | {ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES , OPT , RAW }, |
93 | {ANDROID_STATISTICS_INFO_MAX_FACE_COUNT , LEGACY , BC }, |
94 | {ANDROID_SYNC_MAX_LATENCY , LEGACY , BC }, |
95 | {ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES , FULL , MANUAL_SENSOR }, |
96 | {ANDROID_TONEMAP_MAX_CURVE_POINTS , FULL , MANUAL_SENSOR }, |
97 | /////////////////////split///////////////////////// |
98 | }; |
99 | |
100 | const struct EmulatedFakeCamera3::KeyInfo_s EmulatedFakeCamera3::sKeyInfoReq[] = { |
101 | // {ANDROID_CONTROL_AE_ANTIBANDING_MODE, LIMITED , BC }, |
102 | // {ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, LIMITED , BC }, |
103 | // {ANDROID_CONTROL_AE_LOCK, LIMITED , BC }, |
104 | {ANDROID_CONTROL_AE_MODE, LIMITED , BC }, |
105 | // {ANDROID_CONTROL_AE_TARGET_FPS_RANGE, LIMITED , BC }, |
106 | {ANDROID_CONTROL_AF_MODE, LIMITED , BC }, |
107 | // {ANDROID_CONTROL_AF_TRIGGER, LIMITED , BC }, |
108 | // {ANDROID_CONTROL_AWB_LOCK, LIMITED , BC }, |
109 | {ANDROID_CONTROL_AWB_MODE, LIMITED , BC }, |
110 | // {ANDROID_CONTROL_CAPTURE_INTENT, LIMITED , BC }, |
111 | // {ANDROID_CONTROL_EFFECT_MODE, LIMITED , BC }, |
112 | {ANDROID_CONTROL_MODE, LIMITED , BC }, |
113 | // {ANDROID_CONTROL_SCENE_MODE, LIMITED , BC }, |
114 | {ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, LIMITED , BC }, |
115 | // {ANDROID_FLASH_MODE, LIMITED , BC }, |
116 | // {ANDROID_JPEG_GPS_LOCATION, LIMITED , BC }, |
117 | // {ANDROID_JPEG_ORIENTATION, LIMITED , BC }, |
118 | // {ANDROID_JPEG_QUALITY, LIMITED , BC }, |
119 | // {ANDROID_JPEG_THUMBNAIL_QUALITY, LIMITED , BC }, |
120 | // {ANDROID_JPEG_THUMBNAIL_SIZE, LIMITED , BC }, |
121 | // {ANDROID_SCALER_CROP_REGION, LIMITED , BC }, |
122 | {ANDROID_STATISTICS_FACE_DETECT_MODE, LIMITED , BC }, |
123 | |
124 | // {ANDROID_TONEMAP_MODE, LIMITED , MANUAL_POST_PROCESSING }, |
125 | // {ANDROID_COLOR_CORRECTION_GAINS, LIMITED , MANUAL_POST_PROCESSING }, |
126 | // {ANDROID_COLOR_CORRECTION_TRANSFORM, LIMITED , MANUAL_POST_PROCESSING }, |
127 | // {ANDROID_SHADING_MODE, LIMITED , MANUAL_POST_PROCESSING }, |
128 | // {ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, LIMITED , MANUAL_POST_PROCESSING }, |
129 | // {ANDROID_TONEMAP_CURVE, FULL , MANUAL_POST_PROCESSING }, |
130 | // {ANDROID_COLOR_CORRECTION_ABERRATION_MODE, FULL , MANUAL_POST_PROCESSING }, |
131 | {ANDROID_COLOR_CORRECTION_ABERRATION_MODE, LEGACY , BC}, |
132 | |
133 | // {ANDROID_SENSOR_FRAME_DURATION, LIMITED , MANUAL_SENSOR }, |
134 | // {ANDROID_SENSOR_EXPOSURE_TIME, LIMITED , MANUAL_SENSOR }, |
135 | // {ANDROID_SENSOR_SENSITIVITY, LIMITED , MANUAL_SENSOR }, |
136 | // {ANDROID_LENS_APERTURE, LIMITED , MANUAL_SENSOR }, |
137 | // {ANDROID_LENS_FILTER_DENSITY, LIMITED , MANUAL_SENSOR }, |
138 | {ANDROID_LENS_OPTICAL_STABILIZATION_MODE, LIMITED , MANUAL_SENSOR }, |
139 | // {ANDROID_BLACK_LEVEL_LOCK, LIMITED , MANUAL_SENSOR }, |
140 | {ANDROID_NOISE_REDUCTION_MODE, LEGACY , BC }, |
141 | }; |
142 | const struct EmulatedFakeCamera3::KeyInfo_s EmulatedFakeCamera3::sKeyInfoResult[] = { |
143 | }; |
144 | |
145 | const struct EmulatedFakeCamera3::KeyInfo_s EmulatedFakeCamera3::sKeyBackwardCompat[] = { |
146 | {ANDROID_CONTROL_AE_ANTIBANDING_MODE, 0,}, |
147 | {ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, 0,}, |
148 | {ANDROID_CONTROL_AE_LOCK, 0,}, |
149 | {ANDROID_CONTROL_AE_MODE, 0,}, |
150 | {ANDROID_CONTROL_AE_TARGET_FPS_RANGE, 0,}, |
151 | {ANDROID_CONTROL_AF_MODE, 0,}, |
152 | {ANDROID_CONTROL_AF_TRIGGER, 0,}, |
153 | {ANDROID_CONTROL_AWB_LOCK, 0,}, |
154 | {ANDROID_CONTROL_AWB_MODE, 0,}, |
155 | {ANDROID_CONTROL_CAPTURE_INTENT, 0,}, |
156 | {ANDROID_CONTROL_EFFECT_MODE, 0,}, |
157 | {ANDROID_CONTROL_MODE, 0,}, |
158 | {ANDROID_CONTROL_SCENE_MODE, 0,}, |
159 | {ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, 0,}, |
160 | {ANDROID_FLASH_MODE, 0,}, |
161 | //{ANDROID_JPEG_GPS_LOCATION, 0}, |
162 | {ANDROID_JPEG_ORIENTATION, 0,}, |
163 | {ANDROID_JPEG_QUALITY, 0,}, |
164 | {ANDROID_JPEG_THUMBNAIL_QUALITY, 0,}, |
165 | {ANDROID_JPEG_THUMBNAIL_SIZE, 0,}, |
166 | {ANDROID_SCALER_CROP_REGION, 0,}, |
167 | {ANDROID_STATISTICS_FACE_DETECT_MODE, 0,}, |
168 | }; |
169 | |
170 | int EmulatedFakeCamera3::getAvailableChKeys(CameraMetadata *info, uint8_t level){ |
171 | //actualHwLevel: legacy:0, limited:1, full:2 |
172 | enum hardware_level_e actualHwLevel; |
173 | uint8_t availCapMask = NONE; |
174 | int size, sizeReq ,sizeofbckComp; |
175 | int availCount = 0; |
176 | camera_metadata_entry e; |
177 | const struct KeyInfo_s *keyInfo = &EmulatedFakeCamera3::sKeyInfo[0]; |
178 | |
179 | size = sizeof(sKeyInfo)/sizeof(struct KeyInfo_s); |
180 | sizeReq = sizeof(sKeyInfoReq)/sizeof(sKeyInfoReq[0]); |
181 | sizeofbckComp = sizeof(sKeyBackwardCompat)/sizeof(sKeyBackwardCompat[0]); |
182 | int32_t available_keys[size+sizeReq+sizeofbckComp]; |
183 | |
184 | e = info->find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES); |
185 | if (e.count <= 0) { |
186 | CAMHAL_LOGDA("uncertained capabilities!!!\n"); |
187 | availCapMask = BC; |
188 | } |
189 | for (size_t i=0; i < e.count; i++) { |
190 | availCapMask |= (1 << e.data.u8[i]); |
191 | } |
192 | CAMHAL_LOGDB("availCapMask=%x\n", availCapMask); |
193 | |
194 | switch (level) { |
195 | case ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED: |
196 | actualHwLevel = LIMITED; |
197 | break; |
198 | |
199 | case ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL: |
200 | actualHwLevel = FULL; |
201 | break; |
202 | |
203 | default: |
204 | CAMHAL_LOGDA("!!!!uncertain hardware level\n"); |
205 | case ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY: |
206 | actualHwLevel = LEGACY; |
207 | break; |
208 | } |
209 | |
210 | for(int i = 0; i < size ; i++){ |
211 | |
212 | if (actualHwLevel >= keyInfo->level) { |
213 | available_keys[availCount] = keyInfo->key; |
214 | availCount ++; |
215 | } else if ( availCapMask & keyInfo->capmask) { |
216 | available_keys[availCount] = keyInfo->key; |
217 | availCount ++; |
218 | #if 0 |
219 | } else if ((actualHwLevel != LEGACY) || (keyInfo->level == OPT)) { |
220 | available_keys[availCount] = keyInfo->key; |
221 | availCount ++; |
222 | #endif |
223 | } |
224 | |
225 | keyInfo ++; |
226 | } |
227 | |
228 | info->update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, |
229 | (int32_t *)available_keys, availCount); |
230 | |
231 | CAMHAL_LOGVB("availableKeySize=%d\n", availCount); |
232 | |
233 | keyInfo = &EmulatedFakeCamera3::sKeyInfoReq[0]; |
234 | for (int i = 0; i < sizeReq; i ++) { |
235 | if (actualHwLevel >= keyInfo->level) { |
236 | available_keys[availCount] = keyInfo->key; |
237 | availCount ++; |
238 | } else if ( availCapMask & keyInfo->capmask) { |
239 | available_keys[availCount] = keyInfo->key; |
240 | availCount ++; |
241 | #if 0 |
242 | } else if ((actualHwLevel != LEGACY) || (keyInfo->level == OPT)) { |
243 | available_keys[availCount] = keyInfo->key; |
244 | availCount ++; |
245 | #endif |
246 | } |
247 | keyInfo ++; |
248 | } |
249 | keyInfo = &EmulatedFakeCamera3::sKeyBackwardCompat[0]; |
250 | for (int i = 0; i < sizeofbckComp; i ++){ |
251 | |
252 | if (actualHwLevel >= keyInfo->level) { |
253 | available_keys[availCount] = keyInfo->key; |
254 | availCount ++; |
255 | } else if ( availCapMask & keyInfo->capmask) { |
256 | available_keys[availCount] = keyInfo->key; |
257 | availCount ++; |
258 | #if 0 |
259 | } else if ((actualHwLevel != LEGACY) || (keyInfo->level == OPT)) { |
260 | available_keys[availCount] = keyInfo->key; |
261 | availCount ++; |
262 | #endif |
263 | } |
264 | |
265 | keyInfo ++; |
266 | |
267 | //////////////// |
268 | |
269 | } |
270 | |
271 | info->update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, |
272 | (int32_t *)available_keys, availCount); |
273 | |
274 | info->update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, |
275 | (int32_t *)available_keys, availCount); |
276 | CAMHAL_LOGVB("availableKeySize=%d\n", availCount); |
277 | return 0; |
278 | } |
279 | |
280 | } //namespace android |
281 |