blob: 9d341aeaf300d022adb987294b1469b79f004d4e [file] [log] [blame]
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -08001/*
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_NDEBUG 0
18#define LOG_TAG "ACameraMetadata"
19
20#include "ACameraMetadata.h"
21#include <utils/Vector.h>
Yin-Chia Yehc3603822016-01-18 22:11:19 -080022#include <system/graphics.h>
Colin Cross7e8d4ba2017-05-04 16:17:42 -070023#include <media/NdkImage.h>
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -080024
25using namespace android;
26
27/**
28 * ACameraMetadata Implementation
29 */
30ACameraMetadata::ACameraMetadata(camera_metadata_t* buffer, ACAMERA_METADATA_TYPE type) :
31 mData(buffer), mType(type) {
Yin-Chia Yehead91462016-01-06 16:45:08 -080032 if (mType == ACM_CHARACTERISTICS) {
33 filterUnsupportedFeatures();
Yin-Chia Yehc3603822016-01-18 22:11:19 -080034 filterStreamConfigurations();
Yin-Chia Yehad636932018-08-23 15:36:41 -070035 filterDurations(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
36 filterDurations(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS);
37 filterDurations(ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS);
38 filterDurations(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS);
Yin-Chia Yehead91462016-01-06 16:45:08 -080039 }
40 // TODO: filter request/result keys
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -080041}
42
43bool
44ACameraMetadata::isNdkSupportedCapability(int32_t capability) {
45 switch (capability) {
46 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE:
47 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR:
48 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING:
49 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW:
50 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS:
51 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE:
52 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT:
53 return true;
54 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING:
55 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING:
56 case ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO:
57 return false;
58 default:
59 // Newly defined capabilities will be unsupported by default (blacklist)
60 // TODO: Should we do whitelist or blacklist here?
61 ALOGE("%s: Unknonwn capability %d", __FUNCTION__, capability);
62 return false;
63 }
64}
65
66void
67ACameraMetadata::filterUnsupportedFeatures() {
68 // Hide unsupported capabilities (reprocessing)
69 camera_metadata_entry entry = mData.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);
Yin-Chia Yehc3603822016-01-18 22:11:19 -080070 if (entry.count == 0 || entry.type != TYPE_BYTE) {
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -080071 ALOGE("%s: malformed available capability key! count %zu, type %d",
72 __FUNCTION__, entry.count, entry.type);
73 return;
74 }
75
76 Vector<uint8_t> capabilities;
77 capabilities.setCapacity(entry.count);
78 for (size_t i = 0; i < entry.count; i++) {
79 uint8_t capability = entry.data.u8[i];
80 if (isNdkSupportedCapability(capability)) {
81 capabilities.push(capability);
82 }
83 }
84 mData.update(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, capabilities);
Yin-Chia Yehc3603822016-01-18 22:11:19 -080085}
86
87
88void
Yin-Chia Yehad636932018-08-23 15:36:41 -070089ACameraMetadata::filterDurations(uint32_t tag) {
90 const int STREAM_CONFIGURATION_SIZE = 4;
91 const int STREAM_FORMAT_OFFSET = 0;
92 const int STREAM_WIDTH_OFFSET = 1;
93 const int STREAM_HEIGHT_OFFSET = 2;
94 const int STREAM_DURATION_OFFSET = 3;
95 camera_metadata_entry entry = mData.find(tag);
96 if (entry.count == 0 || entry.count % 4 || entry.type != TYPE_INT64) {
97 ALOGE("%s: malformed duration key %d! count %zu, type %d",
98 __FUNCTION__, tag, entry.count, entry.type);
99 return;
100 }
101 Vector<int64_t> filteredDurations;
102 filteredDurations.setCapacity(entry.count * 2);
103
104 for (size_t i=0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
105 int64_t format = entry.data.i64[i + STREAM_FORMAT_OFFSET];
106 int64_t width = entry.data.i64[i + STREAM_WIDTH_OFFSET];
107 int64_t height = entry.data.i64[i + STREAM_HEIGHT_OFFSET];
108 int64_t duration = entry.data.i32[i + STREAM_DURATION_OFFSET];
109
110 // Leave the unfiltered format in so apps depending on previous wrong
111 // filter behavior continue to work
112 filteredDurations.push_back(format);
113 filteredDurations.push_back(width);
114 filteredDurations.push_back(height);
115 filteredDurations.push_back(duration);
116
117 // Translate HAL formats to NDK format
118 switch (tag) {
119 case ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS:
120 case ANDROID_SCALER_AVAILABLE_STALL_DURATIONS:
121 if (format == HAL_PIXEL_FORMAT_BLOB) {
122 format = AIMAGE_FORMAT_JPEG;
123 filteredDurations.push_back(format);
124 filteredDurations.push_back(width);
125 filteredDurations.push_back(height);
126 filteredDurations.push_back(duration);
127 }
128 break;
129 case ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS:
130 case ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS:
131 if (format == HAL_PIXEL_FORMAT_BLOB) {
132 format = AIMAGE_FORMAT_DEPTH_POINT_CLOUD;
133 filteredDurations.push_back(format);
134 filteredDurations.push_back(width);
135 filteredDurations.push_back(height);
136 filteredDurations.push_back(duration);
137 } else if (format == HAL_PIXEL_FORMAT_Y16) {
138 format = AIMAGE_FORMAT_DEPTH16;
139 filteredDurations.push_back(format);
140 filteredDurations.push_back(width);
141 filteredDurations.push_back(height);
142 filteredDurations.push_back(duration);
143 }
144 break;
145 default:
146 // Should not reach here
147 ALOGE("%s: Unkown tag 0x%x", __FUNCTION__, tag);
148 }
149 }
150
151 mData.update(tag, filteredDurations);
152}
153
154void
Yin-Chia Yehc3603822016-01-18 22:11:19 -0800155ACameraMetadata::filterStreamConfigurations() {
156 const int STREAM_CONFIGURATION_SIZE = 4;
157 const int STREAM_FORMAT_OFFSET = 0;
158 const int STREAM_WIDTH_OFFSET = 1;
159 const int STREAM_HEIGHT_OFFSET = 2;
160 const int STREAM_IS_INPUT_OFFSET = 3;
161 camera_metadata_entry entry = mData.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
Yin-Chia Yehf0906252019-02-26 14:02:15 -0800162 if (entry.count > 0 && (entry.count % 4 || entry.type != TYPE_INT32)) {
Yin-Chia Yehc3603822016-01-18 22:11:19 -0800163 ALOGE("%s: malformed available stream configuration key! count %zu, type %d",
164 __FUNCTION__, entry.count, entry.type);
165 return;
166 }
167
168 Vector<int32_t> filteredStreamConfigs;
169 filteredStreamConfigs.setCapacity(entry.count);
170
171 for (size_t i=0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
172 int32_t format = entry.data.i32[i + STREAM_FORMAT_OFFSET];
173 int32_t width = entry.data.i32[i + STREAM_WIDTH_OFFSET];
174 int32_t height = entry.data.i32[i + STREAM_HEIGHT_OFFSET];
175 int32_t isInput = entry.data.i32[i + STREAM_IS_INPUT_OFFSET];
176 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
177 // Hide input streams
178 continue;
179 }
180 // Translate HAL formats to NDK format
181 if (format == HAL_PIXEL_FORMAT_BLOB) {
182 format = AIMAGE_FORMAT_JPEG;
183 }
184 filteredStreamConfigs.push_back(format);
185 filteredStreamConfigs.push_back(width);
186 filteredStreamConfigs.push_back(height);
187 filteredStreamConfigs.push_back(isInput);
188 }
189
Yin-Chia Yehf0906252019-02-26 14:02:15 -0800190 if (filteredStreamConfigs.size() > 0) {
191 mData.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, filteredStreamConfigs);
192 }
Yin-Chia Yehc3603822016-01-18 22:11:19 -0800193
194 entry = mData.find(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS);
Yin-Chia Yehf0906252019-02-26 14:02:15 -0800195 if (entry.count > 0 && (entry.count % 4 || entry.type != TYPE_INT32)) {
196 ALOGE("%s: malformed available depth stream configuration key! count %zu, type %d",
197 __FUNCTION__, entry.count, entry.type);
198 return;
199 }
200
Yin-Chia Yehc3603822016-01-18 22:11:19 -0800201 Vector<int32_t> filteredDepthStreamConfigs;
202 filteredDepthStreamConfigs.setCapacity(entry.count);
203
204 for (size_t i=0; i < entry.count; i += STREAM_CONFIGURATION_SIZE) {
205 int32_t format = entry.data.i32[i + STREAM_FORMAT_OFFSET];
206 int32_t width = entry.data.i32[i + STREAM_WIDTH_OFFSET];
207 int32_t height = entry.data.i32[i + STREAM_HEIGHT_OFFSET];
208 int32_t isInput = entry.data.i32[i + STREAM_IS_INPUT_OFFSET];
209 if (isInput == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
210 // Hide input streams
211 continue;
212 }
213 // Translate HAL formats to NDK format
214 if (format == HAL_PIXEL_FORMAT_BLOB) {
215 format = AIMAGE_FORMAT_DEPTH_POINT_CLOUD;
216 } else if (format == HAL_PIXEL_FORMAT_Y16) {
217 format = AIMAGE_FORMAT_DEPTH16;
218 }
219
220 filteredDepthStreamConfigs.push_back(format);
221 filteredDepthStreamConfigs.push_back(width);
222 filteredDepthStreamConfigs.push_back(height);
223 filteredDepthStreamConfigs.push_back(isInput);
224 }
Yin-Chia Yehf0906252019-02-26 14:02:15 -0800225
226 if (filteredDepthStreamConfigs.size() > 0) {
227 mData.update(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS,
228 filteredDepthStreamConfigs);
229 }
230
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800231}
232
233bool
234ACameraMetadata::isVendorTag(const uint32_t tag) {
235 uint32_t tag_section = tag >> 16;
236 if (tag_section >= VENDOR_SECTION) {
237 return true;
238 }
239 return false;
240}
241
242camera_status_t
243ACameraMetadata::getConstEntry(uint32_t tag, ACameraMetadata_const_entry* entry) const {
244 if (entry == nullptr) {
245 return ACAMERA_ERROR_INVALID_PARAMETER;
246 }
247
Yin-Chia Yeh8aac03f2016-03-03 15:45:23 -0800248 Mutex::Autolock _l(mLock);
249
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800250 camera_metadata_ro_entry rawEntry = mData.find(tag);
251 if (rawEntry.count == 0) {
252 ALOGE("%s: cannot find metadata tag %d", __FUNCTION__, tag);
253 return ACAMERA_ERROR_METADATA_NOT_FOUND;
254 }
255 entry->tag = tag;
256 entry->type = rawEntry.type;
257 entry->count = rawEntry.count;
258 entry->data.u8 = rawEntry.data.u8;
259 return ACAMERA_OK;
260}
261
262camera_status_t
263ACameraMetadata::update(uint32_t tag, uint32_t count, const uint8_t* data) {
264 return updateImpl<uint8_t>(tag, count, data);
265}
266
267camera_status_t
268ACameraMetadata::update(uint32_t tag, uint32_t count, const int32_t* data) {
269 return updateImpl<int32_t>(tag, count, data);
270}
271
272camera_status_t
273ACameraMetadata::update(uint32_t tag, uint32_t count, const float* data) {
274 return updateImpl<float>(tag, count, data);
275}
276
277camera_status_t
278ACameraMetadata::update(uint32_t tag, uint32_t count, const double* data) {
279 return updateImpl<double>(tag, count, data);
280}
281
282camera_status_t
283ACameraMetadata::update(uint32_t tag, uint32_t count, const int64_t* data) {
284 return updateImpl<int64_t>(tag, count, data);
285}
286
287camera_status_t
288ACameraMetadata::update(uint32_t tag, uint32_t count, const ACameraMetadata_rational* data) {
289 return updateImpl<camera_metadata_rational_t>(tag, count, data);
290}
291
Yin-Chia Yeh8aac03f2016-03-03 15:45:23 -0800292camera_status_t
293ACameraMetadata::getTags(/*out*/int32_t* numTags,
294 /*out*/const uint32_t** tags) const {
295 Mutex::Autolock _l(mLock);
296 if (mTags.size() == 0) {
297 size_t entry_count = mData.entryCount();
298 mTags.setCapacity(entry_count);
299 const camera_metadata_t* rawMetadata = mData.getAndLock();
300 for (size_t i = 0; i < entry_count; i++) {
301 camera_metadata_ro_entry_t entry;
302 int ret = get_camera_metadata_ro_entry(rawMetadata, i, &entry);
303 if (ret != 0) {
304 ALOGE("%s: error reading metadata index %zu", __FUNCTION__, i);
305 return ACAMERA_ERROR_UNKNOWN;
306 }
307 // Hide system key from users
308 if (sSystemTags.count(entry.tag) == 0) {
309 mTags.push_back(entry.tag);
310 }
311 }
312 mData.unlock(rawMetadata);
313 }
314
315 *numTags = mTags.size();
316 *tags = mTags.array();
317 return ACAMERA_OK;
318}
319
320const CameraMetadata&
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100321ACameraMetadata::getInternalData() const {
Yin-Chia Yeh8aac03f2016-03-03 15:45:23 -0800322 return mData;
323}
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800324
325// TODO: some of key below should be hidden from user
326// ex: ACAMERA_REQUEST_ID and ACAMERA_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR
327/*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
328 * The key entries below this point are generated from metadata
329 * definitions in /system/media/camera/docs. Do not modify by hand or
330 * modify the comment blocks at the start or end.
331 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/
332
333bool
334ACameraMetadata::isCaptureRequestTag(const uint32_t tag) {
335 // Skip check for vendor keys
336 if (isVendorTag(tag)) {
337 return true;
338 }
339
340 switch (tag) {
341 case ACAMERA_COLOR_CORRECTION_MODE:
342 case ACAMERA_COLOR_CORRECTION_TRANSFORM:
343 case ACAMERA_COLOR_CORRECTION_GAINS:
344 case ACAMERA_COLOR_CORRECTION_ABERRATION_MODE:
345 case ACAMERA_CONTROL_AE_ANTIBANDING_MODE:
346 case ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION:
347 case ACAMERA_CONTROL_AE_LOCK:
348 case ACAMERA_CONTROL_AE_MODE:
349 case ACAMERA_CONTROL_AE_REGIONS:
350 case ACAMERA_CONTROL_AE_TARGET_FPS_RANGE:
351 case ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER:
352 case ACAMERA_CONTROL_AF_MODE:
353 case ACAMERA_CONTROL_AF_REGIONS:
354 case ACAMERA_CONTROL_AF_TRIGGER:
355 case ACAMERA_CONTROL_AWB_LOCK:
356 case ACAMERA_CONTROL_AWB_MODE:
357 case ACAMERA_CONTROL_AWB_REGIONS:
358 case ACAMERA_CONTROL_CAPTURE_INTENT:
359 case ACAMERA_CONTROL_EFFECT_MODE:
360 case ACAMERA_CONTROL_MODE:
361 case ACAMERA_CONTROL_SCENE_MODE:
362 case ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE:
363 case ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST:
Chien-Yu Chenc0dede92017-01-11 11:10:28 -0800364 case ACAMERA_CONTROL_ENABLE_ZSL:
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800365 case ACAMERA_EDGE_MODE:
366 case ACAMERA_FLASH_MODE:
367 case ACAMERA_HOT_PIXEL_MODE:
368 case ACAMERA_JPEG_GPS_COORDINATES:
369 case ACAMERA_JPEG_GPS_PROCESSING_METHOD:
370 case ACAMERA_JPEG_GPS_TIMESTAMP:
371 case ACAMERA_JPEG_ORIENTATION:
372 case ACAMERA_JPEG_QUALITY:
373 case ACAMERA_JPEG_THUMBNAIL_QUALITY:
374 case ACAMERA_JPEG_THUMBNAIL_SIZE:
375 case ACAMERA_LENS_APERTURE:
376 case ACAMERA_LENS_FILTER_DENSITY:
377 case ACAMERA_LENS_FOCAL_LENGTH:
378 case ACAMERA_LENS_FOCUS_DISTANCE:
379 case ACAMERA_LENS_OPTICAL_STABILIZATION_MODE:
380 case ACAMERA_NOISE_REDUCTION_MODE:
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800381 case ACAMERA_SCALER_CROP_REGION:
382 case ACAMERA_SENSOR_EXPOSURE_TIME:
383 case ACAMERA_SENSOR_FRAME_DURATION:
384 case ACAMERA_SENSOR_SENSITIVITY:
385 case ACAMERA_SENSOR_TEST_PATTERN_DATA:
386 case ACAMERA_SENSOR_TEST_PATTERN_MODE:
387 case ACAMERA_SHADING_MODE:
388 case ACAMERA_STATISTICS_FACE_DETECT_MODE:
389 case ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE:
390 case ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE:
Chien-Yu Chen5ca4a9b2018-01-18 12:23:50 -0800391 case ACAMERA_STATISTICS_OIS_DATA_MODE:
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800392 case ACAMERA_TONEMAP_CURVE_BLUE:
393 case ACAMERA_TONEMAP_CURVE_GREEN:
394 case ACAMERA_TONEMAP_CURVE_RED:
395 case ACAMERA_TONEMAP_MODE:
396 case ACAMERA_TONEMAP_GAMMA:
397 case ACAMERA_TONEMAP_PRESET_CURVE:
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800398 case ACAMERA_BLACK_LEVEL_LOCK:
Eino-Ville Talvala2d960922018-03-13 19:46:23 -0700399 case ACAMERA_DISTORTION_CORRECTION_MODE:
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800400 return true;
401 default:
402 return false;
403 }
404}
405
Yin-Chia Yeh8aac03f2016-03-03 15:45:23 -0800406// System tags that should be hidden from users
407std::unordered_set<uint32_t> ACameraMetadata::sSystemTags ({
408 ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
409 ANDROID_CONTROL_AE_PRECAPTURE_ID,
410 ANDROID_CONTROL_AF_TRIGGER_ID,
411 ANDROID_DEMOSAIC_MODE,
412 ANDROID_EDGE_STRENGTH,
413 ANDROID_FLASH_FIRING_POWER,
414 ANDROID_FLASH_FIRING_TIME,
415 ANDROID_FLASH_COLOR_TEMPERATURE,
416 ANDROID_FLASH_MAX_ENERGY,
417 ANDROID_FLASH_INFO_CHARGE_DURATION,
418 ANDROID_JPEG_MAX_SIZE,
419 ANDROID_JPEG_SIZE,
420 ANDROID_NOISE_REDUCTION_STRENGTH,
421 ANDROID_QUIRKS_METERING_CROP_REGION,
422 ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
423 ANDROID_QUIRKS_USE_ZSL_FORMAT,
424 ANDROID_REQUEST_INPUT_STREAMS,
425 ANDROID_REQUEST_METADATA_MODE,
426 ANDROID_REQUEST_OUTPUT_STREAMS,
427 ANDROID_REQUEST_TYPE,
428 ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS,
429 ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
430 ANDROID_SCALER_AVAILABLE_RAW_SIZES,
431 ANDROID_SENSOR_BASE_GAIN_FACTOR,
432 ANDROID_SENSOR_PROFILE_HUE_SAT_MAP_DIMENSIONS,
433 ANDROID_SENSOR_TEMPERATURE,
434 ANDROID_SENSOR_PROFILE_HUE_SAT_MAP,
435 ANDROID_SENSOR_PROFILE_TONE_CURVE,
436 ANDROID_SENSOR_OPAQUE_RAW_SIZE,
437 ANDROID_SHADING_STRENGTH,
438 ANDROID_STATISTICS_HISTOGRAM_MODE,
439 ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
440 ANDROID_STATISTICS_HISTOGRAM,
441 ANDROID_STATISTICS_SHARPNESS_MAP,
442 ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
443 ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
444 ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
445 ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
446 ANDROID_DEPTH_MAX_DEPTH_SAMPLES,
447});
448
Yin-Chia Yeh0dea57f2015-12-09 16:46:07 -0800449/*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~
450 * End generated code
451 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/