• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 /**
18  * @addtogroup Camera
19  * @{
20  */
21 
22 /**
23  * @file NdkCameraMetadataTags.h
24  */
25 
26 /*
27  * This file defines an NDK API.
28  * Do not remove methods.
29  * Do not change method signatures.
30  * Do not change the value of constants.
31  * Do not change the size of any of the classes defined in here.
32  * Do not reference types that are not part of the NDK.
33  * Do not #include files that aren't part of the NDK.
34  */
35 
36 #ifndef _NDK_CAMERA_METADATA_TAGS_H
37 #define _NDK_CAMERA_METADATA_TAGS_H
38 
39 #include <sys/cdefs.h>
40 
41 __BEGIN_DECLS
42 
43 #if __ANDROID_API__ >= 24
44 
45 typedef enum acamera_metadata_section {
46     ACAMERA_COLOR_CORRECTION,
47     ACAMERA_CONTROL,
48     ACAMERA_DEMOSAIC,
49     ACAMERA_EDGE,
50     ACAMERA_FLASH,
51     ACAMERA_FLASH_INFO,
52     ACAMERA_HOT_PIXEL,
53     ACAMERA_JPEG,
54     ACAMERA_LENS,
55     ACAMERA_LENS_INFO,
56     ACAMERA_NOISE_REDUCTION,
57     ACAMERA_QUIRKS,
58     ACAMERA_REQUEST,
59     ACAMERA_SCALER,
60     ACAMERA_SENSOR,
61     ACAMERA_SENSOR_INFO,
62     ACAMERA_SHADING,
63     ACAMERA_STATISTICS,
64     ACAMERA_STATISTICS_INFO,
65     ACAMERA_TONEMAP,
66     ACAMERA_LED,
67     ACAMERA_INFO,
68     ACAMERA_BLACK_LEVEL,
69     ACAMERA_SYNC,
70     ACAMERA_REPROCESS,
71     ACAMERA_DEPTH,
72     ACAMERA_SECTION_COUNT,
73 
74     ACAMERA_VENDOR = 0x8000
75 } acamera_metadata_section_t;
76 
77 /**
78  * Hierarchy positions in enum space.
79  */
80 typedef enum acamera_metadata_section_start {
81     ACAMERA_COLOR_CORRECTION_START = ACAMERA_COLOR_CORRECTION  << 16,
82     ACAMERA_CONTROL_START          = ACAMERA_CONTROL           << 16,
83     ACAMERA_DEMOSAIC_START         = ACAMERA_DEMOSAIC          << 16,
84     ACAMERA_EDGE_START             = ACAMERA_EDGE              << 16,
85     ACAMERA_FLASH_START            = ACAMERA_FLASH             << 16,
86     ACAMERA_FLASH_INFO_START       = ACAMERA_FLASH_INFO        << 16,
87     ACAMERA_HOT_PIXEL_START        = ACAMERA_HOT_PIXEL         << 16,
88     ACAMERA_JPEG_START             = ACAMERA_JPEG              << 16,
89     ACAMERA_LENS_START             = ACAMERA_LENS              << 16,
90     ACAMERA_LENS_INFO_START        = ACAMERA_LENS_INFO         << 16,
91     ACAMERA_NOISE_REDUCTION_START  = ACAMERA_NOISE_REDUCTION   << 16,
92     ACAMERA_QUIRKS_START           = ACAMERA_QUIRKS            << 16,
93     ACAMERA_REQUEST_START          = ACAMERA_REQUEST           << 16,
94     ACAMERA_SCALER_START           = ACAMERA_SCALER            << 16,
95     ACAMERA_SENSOR_START           = ACAMERA_SENSOR            << 16,
96     ACAMERA_SENSOR_INFO_START      = ACAMERA_SENSOR_INFO       << 16,
97     ACAMERA_SHADING_START          = ACAMERA_SHADING           << 16,
98     ACAMERA_STATISTICS_START       = ACAMERA_STATISTICS        << 16,
99     ACAMERA_STATISTICS_INFO_START  = ACAMERA_STATISTICS_INFO   << 16,
100     ACAMERA_TONEMAP_START          = ACAMERA_TONEMAP           << 16,
101     ACAMERA_LED_START              = ACAMERA_LED               << 16,
102     ACAMERA_INFO_START             = ACAMERA_INFO              << 16,
103     ACAMERA_BLACK_LEVEL_START      = ACAMERA_BLACK_LEVEL       << 16,
104     ACAMERA_SYNC_START             = ACAMERA_SYNC              << 16,
105     ACAMERA_REPROCESS_START        = ACAMERA_REPROCESS         << 16,
106     ACAMERA_DEPTH_START            = ACAMERA_DEPTH             << 16,
107     ACAMERA_VENDOR_START           = ACAMERA_VENDOR            << 16
108 } acamera_metadata_section_start_t;
109 
110 /**
111  * Main enum for camera metadata tags.
112  */
113 typedef enum acamera_metadata_tag {
114     /**
115      * <p>The mode control selects how the image data is converted from the
116      * sensor's native color into linear sRGB color.</p>
117      *
118      * <p>Type: byte (acamera_metadata_enum_android_color_correction_mode_t)</p>
119      *
120      * <p>This tag may appear in:
121      * <ul>
122      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
123      *   <li>ACaptureRequest</li>
124      * </ul></p>
125      *
126      * <p>When auto-white balance (AWB) is enabled with ACAMERA_CONTROL_AWB_MODE, this
127      * control is overridden by the AWB routine. When AWB is disabled, the
128      * application controls how the color mapping is performed.</p>
129      * <p>We define the expected processing pipeline below. For consistency
130      * across devices, this is always the case with TRANSFORM_MATRIX.</p>
131      * <p>When either FULL or HIGH_QUALITY is used, the camera device may
132      * do additional processing but ACAMERA_COLOR_CORRECTION_GAINS and
133      * ACAMERA_COLOR_CORRECTION_TRANSFORM will still be provided by the
134      * camera device (in the results) and be roughly correct.</p>
135      * <p>Switching to TRANSFORM_MATRIX and using the data provided from
136      * FAST or HIGH_QUALITY will yield a picture with the same white point
137      * as what was produced by the camera device in the earlier frame.</p>
138      * <p>The expected processing pipeline is as follows:</p>
139      * <p><img alt="White balance processing pipeline" src="../images/camera2/metadata/android.colorCorrection.mode/processing_pipeline.png" /></p>
140      * <p>The white balance is encoded by two values, a 4-channel white-balance
141      * gain vector (applied in the Bayer domain), and a 3x3 color transform
142      * matrix (applied after demosaic).</p>
143      * <p>The 4-channel white-balance gains are defined as:</p>
144      * <pre><code>ACAMERA_COLOR_CORRECTION_GAINS = [ R G_even G_odd B ]
145      * </code></pre>
146      * <p>where <code>G_even</code> is the gain for green pixels on even rows of the
147      * output, and <code>G_odd</code> is the gain for green pixels on the odd rows.
148      * These may be identical for a given camera device implementation; if
149      * the camera device does not support a separate gain for even/odd green
150      * channels, it will use the <code>G_even</code> value, and write <code>G_odd</code> equal to
151      * <code>G_even</code> in the output result metadata.</p>
152      * <p>The matrices for color transforms are defined as a 9-entry vector:</p>
153      * <pre><code>ACAMERA_COLOR_CORRECTION_TRANSFORM = [ I0 I1 I2 I3 I4 I5 I6 I7 I8 ]
154      * </code></pre>
155      * <p>which define a transform from input sensor colors, <code>P_in = [ r g b ]</code>,
156      * to output linear sRGB, <code>P_out = [ r' g' b' ]</code>,</p>
157      * <p>with colors as follows:</p>
158      * <pre><code>r' = I0r + I1g + I2b
159      * g' = I3r + I4g + I5b
160      * b' = I6r + I7g + I8b
161      * </code></pre>
162      * <p>Both the input and output value ranges must match. Overflow/underflow
163      * values are clipped to fit within the range.</p>
164      *
165      * @see ACAMERA_COLOR_CORRECTION_GAINS
166      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
167      * @see ACAMERA_CONTROL_AWB_MODE
168      */
169     ACAMERA_COLOR_CORRECTION_MODE =                             // byte (acamera_metadata_enum_android_color_correction_mode_t)
170             ACAMERA_COLOR_CORRECTION_START,
171     /**
172      * <p>A color transform matrix to use to transform
173      * from sensor RGB color space to output linear sRGB color space.</p>
174      *
175      * <p>Type: rational[3*3]</p>
176      *
177      * <p>This tag may appear in:
178      * <ul>
179      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
180      *   <li>ACaptureRequest</li>
181      * </ul></p>
182      *
183      * <p>This matrix is either set by the camera device when the request
184      * ACAMERA_COLOR_CORRECTION_MODE is not TRANSFORM_MATRIX, or
185      * directly by the application in the request when the
186      * ACAMERA_COLOR_CORRECTION_MODE is TRANSFORM_MATRIX.</p>
187      * <p>In the latter case, the camera device may round the matrix to account
188      * for precision issues; the final rounded matrix should be reported back
189      * in this matrix result metadata. The transform should keep the magnitude
190      * of the output color values within <code>[0, 1.0]</code> (assuming input color
191      * values is within the normalized range <code>[0, 1.0]</code>), or clipping may occur.</p>
192      * <p>The valid range of each matrix element varies on different devices, but
193      * values within [-1.5, 3.0] are guaranteed not to be clipped.</p>
194      *
195      * @see ACAMERA_COLOR_CORRECTION_MODE
196      */
197     ACAMERA_COLOR_CORRECTION_TRANSFORM =                        // rational[3*3]
198             ACAMERA_COLOR_CORRECTION_START + 1,
199     /**
200      * <p>Gains applying to Bayer raw color channels for
201      * white-balance.</p>
202      *
203      * <p>Type: float[4]</p>
204      *
205      * <p>This tag may appear in:
206      * <ul>
207      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
208      *   <li>ACaptureRequest</li>
209      * </ul></p>
210      *
211      * <p>These per-channel gains are either set by the camera device
212      * when the request ACAMERA_COLOR_CORRECTION_MODE is not
213      * TRANSFORM_MATRIX, or directly by the application in the
214      * request when the ACAMERA_COLOR_CORRECTION_MODE is
215      * TRANSFORM_MATRIX.</p>
216      * <p>The gains in the result metadata are the gains actually
217      * applied by the camera device to the current frame.</p>
218      * <p>The valid range of gains varies on different devices, but gains
219      * between [1.0, 3.0] are guaranteed not to be clipped. Even if a given
220      * device allows gains below 1.0, this is usually not recommended because
221      * this can create color artifacts.</p>
222      *
223      * @see ACAMERA_COLOR_CORRECTION_MODE
224      */
225     ACAMERA_COLOR_CORRECTION_GAINS =                            // float[4]
226             ACAMERA_COLOR_CORRECTION_START + 2,
227     /**
228      * <p>Mode of operation for the chromatic aberration correction algorithm.</p>
229      *
230      * <p>Type: byte (acamera_metadata_enum_android_color_correction_aberration_mode_t)</p>
231      *
232      * <p>This tag may appear in:
233      * <ul>
234      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
235      *   <li>ACaptureRequest</li>
236      * </ul></p>
237      *
238      * <p>Chromatic (color) aberration is caused by the fact that different wavelengths of light
239      * can not focus on the same point after exiting from the lens. This metadata defines
240      * the high level control of chromatic aberration correction algorithm, which aims to
241      * minimize the chromatic artifacts that may occur along the object boundaries in an
242      * image.</p>
243      * <p>FAST/HIGH_QUALITY both mean that camera device determined aberration
244      * correction will be applied. HIGH_QUALITY mode indicates that the camera device will
245      * use the highest-quality aberration correction algorithms, even if it slows down
246      * capture rate. FAST means the camera device will not slow down capture rate when
247      * applying aberration correction.</p>
248      * <p>LEGACY devices will always be in FAST mode.</p>
249      */
250     ACAMERA_COLOR_CORRECTION_ABERRATION_MODE =                  // byte (acamera_metadata_enum_android_color_correction_aberration_mode_t)
251             ACAMERA_COLOR_CORRECTION_START + 3,
252     /**
253      * <p>List of aberration correction modes for ACAMERA_COLOR_CORRECTION_ABERRATION_MODE that are
254      * supported by this camera device.</p>
255      *
256      * @see ACAMERA_COLOR_CORRECTION_ABERRATION_MODE
257      *
258      * <p>Type: byte[n]</p>
259      *
260      * <p>This tag may appear in:
261      * <ul>
262      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
263      * </ul></p>
264      *
265      * <p>This key lists the valid modes for ACAMERA_COLOR_CORRECTION_ABERRATION_MODE.  If no
266      * aberration correction modes are available for a device, this list will solely include
267      * OFF mode. All camera devices will support either OFF or FAST mode.</p>
268      * <p>Camera devices that support the MANUAL_POST_PROCESSING capability will always list
269      * OFF mode. This includes all FULL level devices.</p>
270      * <p>LEGACY devices will always only support FAST mode.</p>
271      *
272      * @see ACAMERA_COLOR_CORRECTION_ABERRATION_MODE
273      */
274     ACAMERA_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES =       // byte[n]
275             ACAMERA_COLOR_CORRECTION_START + 4,
276     ACAMERA_COLOR_CORRECTION_END,
277 
278     /**
279      * <p>The desired setting for the camera device's auto-exposure
280      * algorithm's antibanding compensation.</p>
281      *
282      * <p>Type: byte (acamera_metadata_enum_android_control_ae_antibanding_mode_t)</p>
283      *
284      * <p>This tag may appear in:
285      * <ul>
286      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
287      *   <li>ACaptureRequest</li>
288      * </ul></p>
289      *
290      * <p>Some kinds of lighting fixtures, such as some fluorescent
291      * lights, flicker at the rate of the power supply frequency
292      * (60Hz or 50Hz, depending on country). While this is
293      * typically not noticeable to a person, it can be visible to
294      * a camera device. If a camera sets its exposure time to the
295      * wrong value, the flicker may become visible in the
296      * viewfinder as flicker or in a final captured image, as a
297      * set of variable-brightness bands across the image.</p>
298      * <p>Therefore, the auto-exposure routines of camera devices
299      * include antibanding routines that ensure that the chosen
300      * exposure value will not cause such banding. The choice of
301      * exposure time depends on the rate of flicker, which the
302      * camera device can detect automatically, or the expected
303      * rate can be selected by the application using this
304      * control.</p>
305      * <p>A given camera device may not support all of the possible
306      * options for the antibanding mode. The
307      * ACAMERA_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES key contains
308      * the available modes for a given camera device.</p>
309      * <p>AUTO mode is the default if it is available on given
310      * camera device. When AUTO mode is not available, the
311      * default will be either 50HZ or 60HZ, and both 50HZ
312      * and 60HZ will be available.</p>
313      * <p>If manual exposure control is enabled (by setting
314      * ACAMERA_CONTROL_AE_MODE or ACAMERA_CONTROL_MODE to OFF),
315      * then this setting has no effect, and the application must
316      * ensure it selects exposure times that do not cause banding
317      * issues. The ACAMERA_STATISTICS_SCENE_FLICKER key can assist
318      * the application in this.</p>
319      *
320      * @see ACAMERA_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES
321      * @see ACAMERA_CONTROL_AE_MODE
322      * @see ACAMERA_CONTROL_MODE
323      * @see ACAMERA_STATISTICS_SCENE_FLICKER
324      */
325     ACAMERA_CONTROL_AE_ANTIBANDING_MODE =                       // byte (acamera_metadata_enum_android_control_ae_antibanding_mode_t)
326             ACAMERA_CONTROL_START,
327     /**
328      * <p>Adjustment to auto-exposure (AE) target image
329      * brightness.</p>
330      *
331      * <p>Type: int32</p>
332      *
333      * <p>This tag may appear in:
334      * <ul>
335      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
336      *   <li>ACaptureRequest</li>
337      * </ul></p>
338      *
339      * <p>The adjustment is measured as a count of steps, with the
340      * step size defined by ACAMERA_CONTROL_AE_COMPENSATION_STEP and the
341      * allowed range by ACAMERA_CONTROL_AE_COMPENSATION_RANGE.</p>
342      * <p>For example, if the exposure value (EV) step is 0.333, '6'
343      * will mean an exposure compensation of +2 EV; -3 will mean an
344      * exposure compensation of -1 EV. One EV represents a doubling
345      * of image brightness. Note that this control will only be
346      * effective if ACAMERA_CONTROL_AE_MODE <code>!=</code> OFF. This control
347      * will take effect even when ACAMERA_CONTROL_AE_LOCK <code>== true</code>.</p>
348      * <p>In the event of exposure compensation value being changed, camera device
349      * may take several frames to reach the newly requested exposure target.
350      * During that time, ACAMERA_CONTROL_AE_STATE field will be in the SEARCHING
351      * state. Once the new exposure target is reached, ACAMERA_CONTROL_AE_STATE will
352      * change from SEARCHING to either CONVERGED, LOCKED (if AE lock is enabled), or
353      * FLASH_REQUIRED (if the scene is too dark for still capture).</p>
354      *
355      * @see ACAMERA_CONTROL_AE_COMPENSATION_RANGE
356      * @see ACAMERA_CONTROL_AE_COMPENSATION_STEP
357      * @see ACAMERA_CONTROL_AE_LOCK
358      * @see ACAMERA_CONTROL_AE_MODE
359      * @see ACAMERA_CONTROL_AE_STATE
360      */
361     ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION =                  // int32
362             ACAMERA_CONTROL_START + 1,
363     /**
364      * <p>Whether auto-exposure (AE) is currently locked to its latest
365      * calculated values.</p>
366      *
367      * <p>Type: byte (acamera_metadata_enum_android_control_ae_lock_t)</p>
368      *
369      * <p>This tag may appear in:
370      * <ul>
371      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
372      *   <li>ACaptureRequest</li>
373      * </ul></p>
374      *
375      * <p>When set to <code>true</code> (ON), the AE algorithm is locked to its latest parameters,
376      * and will not change exposure settings until the lock is set to <code>false</code> (OFF).</p>
377      * <p>Note that even when AE is locked, the flash may be fired if
378      * the ACAMERA_CONTROL_AE_MODE is ON_AUTO_FLASH /
379      * ON_ALWAYS_FLASH / ON_AUTO_FLASH_REDEYE.</p>
380      * <p>When ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION is changed, even if the AE lock
381      * is ON, the camera device will still adjust its exposure value.</p>
382      * <p>If AE precapture is triggered (see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER)
383      * when AE is already locked, the camera device will not change the exposure time
384      * (ACAMERA_SENSOR_EXPOSURE_TIME) and sensitivity (ACAMERA_SENSOR_SENSITIVITY)
385      * parameters. The flash may be fired if the ACAMERA_CONTROL_AE_MODE
386      * is ON_AUTO_FLASH/ON_AUTO_FLASH_REDEYE and the scene is too dark. If the
387      * ACAMERA_CONTROL_AE_MODE is ON_ALWAYS_FLASH, the scene may become overexposed.
388      * Similarly, AE precapture trigger CANCEL has no effect when AE is already locked.</p>
389      * <p>When an AE precapture sequence is triggered, AE unlock will not be able to unlock
390      * the AE if AE is locked by the camera device internally during precapture metering
391      * sequence In other words, submitting requests with AE unlock has no effect for an
392      * ongoing precapture metering sequence. Otherwise, the precapture metering sequence
393      * will never succeed in a sequence of preview requests where AE lock is always set
394      * to <code>false</code>.</p>
395      * <p>Since the camera device has a pipeline of in-flight requests, the settings that
396      * get locked do not necessarily correspond to the settings that were present in the
397      * latest capture result received from the camera device, since additional captures
398      * and AE updates may have occurred even before the result was sent out. If an
399      * application is switching between automatic and manual control and wishes to eliminate
400      * any flicker during the switch, the following procedure is recommended:</p>
401      * <ol>
402      * <li>Starting in auto-AE mode:</li>
403      * <li>Lock AE</li>
404      * <li>Wait for the first result to be output that has the AE locked</li>
405      * <li>Copy exposure settings from that result into a request, set the request to manual AE</li>
406      * <li>Submit the capture request, proceed to run manual AE as desired.</li>
407      * </ol>
408      * <p>See ACAMERA_CONTROL_AE_STATE for AE lock related state transition details.</p>
409      *
410      * @see ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION
411      * @see ACAMERA_CONTROL_AE_MODE
412      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
413      * @see ACAMERA_CONTROL_AE_STATE
414      * @see ACAMERA_SENSOR_EXPOSURE_TIME
415      * @see ACAMERA_SENSOR_SENSITIVITY
416      */
417     ACAMERA_CONTROL_AE_LOCK =                                   // byte (acamera_metadata_enum_android_control_ae_lock_t)
418             ACAMERA_CONTROL_START + 2,
419     /**
420      * <p>The desired mode for the camera device's
421      * auto-exposure routine.</p>
422      *
423      * <p>Type: byte (acamera_metadata_enum_android_control_ae_mode_t)</p>
424      *
425      * <p>This tag may appear in:
426      * <ul>
427      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
428      *   <li>ACaptureRequest</li>
429      * </ul></p>
430      *
431      * <p>This control is only effective if ACAMERA_CONTROL_MODE is
432      * AUTO.</p>
433      * <p>When set to any of the ON modes, the camera device's
434      * auto-exposure routine is enabled, overriding the
435      * application's selected exposure time, sensor sensitivity,
436      * and frame duration (ACAMERA_SENSOR_EXPOSURE_TIME,
437      * ACAMERA_SENSOR_SENSITIVITY, and
438      * ACAMERA_SENSOR_FRAME_DURATION). If one of the FLASH modes
439      * is selected, the camera device's flash unit controls are
440      * also overridden.</p>
441      * <p>The FLASH modes are only available if the camera device
442      * has a flash unit (ACAMERA_FLASH_INFO_AVAILABLE is <code>true</code>).</p>
443      * <p>If flash TORCH mode is desired, this field must be set to
444      * ON or OFF, and ACAMERA_FLASH_MODE set to TORCH.</p>
445      * <p>When set to any of the ON modes, the values chosen by the
446      * camera device auto-exposure routine for the overridden
447      * fields for a given capture will be available in its
448      * CaptureResult.</p>
449      *
450      * @see ACAMERA_CONTROL_MODE
451      * @see ACAMERA_FLASH_INFO_AVAILABLE
452      * @see ACAMERA_FLASH_MODE
453      * @see ACAMERA_SENSOR_EXPOSURE_TIME
454      * @see ACAMERA_SENSOR_FRAME_DURATION
455      * @see ACAMERA_SENSOR_SENSITIVITY
456      */
457     ACAMERA_CONTROL_AE_MODE =                                   // byte (acamera_metadata_enum_android_control_ae_mode_t)
458             ACAMERA_CONTROL_START + 3,
459     /**
460      * <p>List of metering areas to use for auto-exposure adjustment.</p>
461      *
462      * <p>Type: int32[5*area_count]</p>
463      *
464      * <p>This tag may appear in:
465      * <ul>
466      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
467      *   <li>ACaptureRequest</li>
468      * </ul></p>
469      *
470      * <p>Not available if android.control.maxRegionsAe is 0.
471      * Otherwise will always be present.</p>
472      * <p>The maximum number of regions supported by the device is determined by the value
473      * of android.control.maxRegionsAe.</p>
474      * <p>The data representation is int[5 * area_count].
475      * Every five elements represent a metering region of (xmin, ymin, xmax, ymax, weight).
476      * The rectangle is defined to be inclusive on xmin and ymin, but exclusive on xmax and
477      * ymax.</p>
478      * <p>The coordinate system is based on the active pixel array,
479      * with (0,0) being the top-left pixel in the active pixel array, and
480      * (ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.width - 1,
481      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.height - 1) being the
482      * bottom-right pixel in the active pixel array.</p>
483      * <p>The weight must be within <code>[0, 1000]</code>, and represents a weight
484      * for every pixel in the area. This means that a large metering area
485      * with the same weight as a smaller area will have more effect in
486      * the metering result. Metering areas can partially overlap and the
487      * camera device will add the weights in the overlap region.</p>
488      * <p>The weights are relative to weights of other exposure metering regions, so if only one
489      * region is used, all non-zero weights will have the same effect. A region with 0
490      * weight is ignored.</p>
491      * <p>If all regions have 0 weight, then no specific metering area needs to be used by the
492      * camera device.</p>
493      * <p>If the metering region is outside the used ACAMERA_SCALER_CROP_REGION returned in
494      * capture result metadata, the camera device will ignore the sections outside the crop
495      * region and output only the intersection rectangle as the metering region in the result
496      * metadata.  If the region is entirely outside the crop region, it will be ignored and
497      * not reported in the result metadata.</p>
498      *
499      * @see ACAMERA_SCALER_CROP_REGION
500      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
501      */
502     ACAMERA_CONTROL_AE_REGIONS =                                // int32[5*area_count]
503             ACAMERA_CONTROL_START + 4,
504     /**
505      * <p>Range over which the auto-exposure routine can
506      * adjust the capture frame rate to maintain good
507      * exposure.</p>
508      *
509      * <p>Type: int32[2]</p>
510      *
511      * <p>This tag may appear in:
512      * <ul>
513      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
514      *   <li>ACaptureRequest</li>
515      * </ul></p>
516      *
517      * <p>Only constrains auto-exposure (AE) algorithm, not
518      * manual control of ACAMERA_SENSOR_EXPOSURE_TIME and
519      * ACAMERA_SENSOR_FRAME_DURATION.</p>
520      *
521      * @see ACAMERA_SENSOR_EXPOSURE_TIME
522      * @see ACAMERA_SENSOR_FRAME_DURATION
523      */
524     ACAMERA_CONTROL_AE_TARGET_FPS_RANGE =                       // int32[2]
525             ACAMERA_CONTROL_START + 5,
526     /**
527      * <p>Whether the camera device will trigger a precapture
528      * metering sequence when it processes this request.</p>
529      *
530      * <p>Type: byte (acamera_metadata_enum_android_control_ae_precapture_trigger_t)</p>
531      *
532      * <p>This tag may appear in:
533      * <ul>
534      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
535      *   <li>ACaptureRequest</li>
536      * </ul></p>
537      *
538      * <p>This entry is normally set to IDLE, or is not
539      * included at all in the request settings. When included and
540      * set to START, the camera device will trigger the auto-exposure (AE)
541      * precapture metering sequence.</p>
542      * <p>When set to CANCEL, the camera device will cancel any active
543      * precapture metering trigger, and return to its initial AE state.
544      * If a precapture metering sequence is already completed, and the camera
545      * device has implicitly locked the AE for subsequent still capture, the
546      * CANCEL trigger will unlock the AE and return to its initial AE state.</p>
547      * <p>The precapture sequence should be triggered before starting a
548      * high-quality still capture for final metering decisions to
549      * be made, and for firing pre-capture flash pulses to estimate
550      * scene brightness and required final capture flash power, when
551      * the flash is enabled.</p>
552      * <p>Normally, this entry should be set to START for only a
553      * single request, and the application should wait until the
554      * sequence completes before starting a new one.</p>
555      * <p>When a precapture metering sequence is finished, the camera device
556      * may lock the auto-exposure routine internally to be able to accurately expose the
557      * subsequent still capture image (<code>ACAMERA_CONTROL_CAPTURE_INTENT == STILL_CAPTURE</code>).
558      * For this case, the AE may not resume normal scan if no subsequent still capture is
559      * submitted. To ensure that the AE routine restarts normal scan, the application should
560      * submit a request with <code>ACAMERA_CONTROL_AE_LOCK == true</code>, followed by a request
561      * with <code>ACAMERA_CONTROL_AE_LOCK == false</code>, if the application decides not to submit a
562      * still capture request after the precapture sequence completes. Alternatively, for
563      * API level 23 or newer devices, the CANCEL can be used to unlock the camera device
564      * internally locked AE if the application doesn't submit a still capture request after
565      * the AE precapture trigger. Note that, the CANCEL was added in API level 23, and must not
566      * be used in devices that have earlier API levels.</p>
567      * <p>The exact effect of auto-exposure (AE) precapture trigger
568      * depends on the current AE mode and state; see
569      * ACAMERA_CONTROL_AE_STATE for AE precapture state transition
570      * details.</p>
571      * <p>On LEGACY-level devices, the precapture trigger is not supported;
572      * capturing a high-resolution JPEG image will automatically trigger a
573      * precapture sequence before the high-resolution capture, including
574      * potentially firing a pre-capture flash.</p>
575      * <p>Using the precapture trigger and the auto-focus trigger ACAMERA_CONTROL_AF_TRIGGER
576      * simultaneously is allowed. However, since these triggers often require cooperation between
577      * the auto-focus and auto-exposure routines (for example, the may need to be enabled for a
578      * focus sweep), the camera device may delay acting on a later trigger until the previous
579      * trigger has been fully handled. This may lead to longer intervals between the trigger and
580      * changes to ACAMERA_CONTROL_AE_STATE indicating the start of the precapture sequence, for
581      * example.</p>
582      * <p>If both the precapture and the auto-focus trigger are activated on the same request, then
583      * the camera device will complete them in the optimal order for that device.</p>
584      *
585      * @see ACAMERA_CONTROL_AE_LOCK
586      * @see ACAMERA_CONTROL_AE_STATE
587      * @see ACAMERA_CONTROL_AF_TRIGGER
588      * @see ACAMERA_CONTROL_CAPTURE_INTENT
589      */
590     ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER =                     // byte (acamera_metadata_enum_android_control_ae_precapture_trigger_t)
591             ACAMERA_CONTROL_START + 6,
592     /**
593      * <p>Whether auto-focus (AF) is currently enabled, and what
594      * mode it is set to.</p>
595      *
596      * <p>Type: byte (acamera_metadata_enum_android_control_af_mode_t)</p>
597      *
598      * <p>This tag may appear in:
599      * <ul>
600      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
601      *   <li>ACaptureRequest</li>
602      * </ul></p>
603      *
604      * <p>Only effective if ACAMERA_CONTROL_MODE = AUTO and the lens is not fixed focus
605      * (i.e. <code>ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE &gt; 0</code>). Also note that
606      * when ACAMERA_CONTROL_AE_MODE is OFF, the behavior of AF is device
607      * dependent. It is recommended to lock AF by using ACAMERA_CONTROL_AF_TRIGGER before
608      * setting ACAMERA_CONTROL_AE_MODE to OFF, or set AF mode to OFF when AE is OFF.</p>
609      * <p>If the lens is controlled by the camera device auto-focus algorithm,
610      * the camera device will report the current AF status in ACAMERA_CONTROL_AF_STATE
611      * in result metadata.</p>
612      *
613      * @see ACAMERA_CONTROL_AE_MODE
614      * @see ACAMERA_CONTROL_AF_STATE
615      * @see ACAMERA_CONTROL_AF_TRIGGER
616      * @see ACAMERA_CONTROL_MODE
617      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
618      */
619     ACAMERA_CONTROL_AF_MODE =                                   // byte (acamera_metadata_enum_android_control_af_mode_t)
620             ACAMERA_CONTROL_START + 7,
621     /**
622      * <p>List of metering areas to use for auto-focus.</p>
623      *
624      * <p>Type: int32[5*area_count]</p>
625      *
626      * <p>This tag may appear in:
627      * <ul>
628      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
629      *   <li>ACaptureRequest</li>
630      * </ul></p>
631      *
632      * <p>Not available if android.control.maxRegionsAf is 0.
633      * Otherwise will always be present.</p>
634      * <p>The maximum number of focus areas supported by the device is determined by the value
635      * of android.control.maxRegionsAf.</p>
636      * <p>The data representation is int[5 * area_count].
637      * Every five elements represent a metering region of (xmin, ymin, xmax, ymax, weight).
638      * The rectangle is defined to be inclusive on xmin and ymin, but exclusive on xmax and
639      * ymax.</p>
640      * <p>The coordinate system is based on the active pixel array,
641      * with (0,0) being the top-left pixel in the active pixel array, and
642      * (ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.width - 1,
643      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.height - 1) being the
644      * bottom-right pixel in the active pixel array.</p>
645      * <p>The weight must be within <code>[0, 1000]</code>, and represents a weight
646      * for every pixel in the area. This means that a large metering area
647      * with the same weight as a smaller area will have more effect in
648      * the metering result. Metering areas can partially overlap and the
649      * camera device will add the weights in the overlap region.</p>
650      * <p>The weights are relative to weights of other metering regions, so if only one region
651      * is used, all non-zero weights will have the same effect. A region with 0 weight is
652      * ignored.</p>
653      * <p>If all regions have 0 weight, then no specific metering area needs to be used by the
654      * camera device.</p>
655      * <p>If the metering region is outside the used ACAMERA_SCALER_CROP_REGION returned in
656      * capture result metadata, the camera device will ignore the sections outside the crop
657      * region and output only the intersection rectangle as the metering region in the result
658      * metadata. If the region is entirely outside the crop region, it will be ignored and
659      * not reported in the result metadata.</p>
660      *
661      * @see ACAMERA_SCALER_CROP_REGION
662      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
663      */
664     ACAMERA_CONTROL_AF_REGIONS =                                // int32[5*area_count]
665             ACAMERA_CONTROL_START + 8,
666     /**
667      * <p>Whether the camera device will trigger autofocus for this request.</p>
668      *
669      * <p>Type: byte (acamera_metadata_enum_android_control_af_trigger_t)</p>
670      *
671      * <p>This tag may appear in:
672      * <ul>
673      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
674      *   <li>ACaptureRequest</li>
675      * </ul></p>
676      *
677      * <p>This entry is normally set to IDLE, or is not
678      * included at all in the request settings.</p>
679      * <p>When included and set to START, the camera device will trigger the
680      * autofocus algorithm. If autofocus is disabled, this trigger has no effect.</p>
681      * <p>When set to CANCEL, the camera device will cancel any active trigger,
682      * and return to its initial AF state.</p>
683      * <p>Generally, applications should set this entry to START or CANCEL for only a
684      * single capture, and then return it to IDLE (or not set at all). Specifying
685      * START for multiple captures in a row means restarting the AF operation over
686      * and over again.</p>
687      * <p>See ACAMERA_CONTROL_AF_STATE for what the trigger means for each AF mode.</p>
688      * <p>Using the autofocus trigger and the precapture trigger ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
689      * simultaneously is allowed. However, since these triggers often require cooperation between
690      * the auto-focus and auto-exposure routines (for example, the may need to be enabled for a
691      * focus sweep), the camera device may delay acting on a later trigger until the previous
692      * trigger has been fully handled. This may lead to longer intervals between the trigger and
693      * changes to ACAMERA_CONTROL_AF_STATE, for example.</p>
694      *
695      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
696      * @see ACAMERA_CONTROL_AF_STATE
697      */
698     ACAMERA_CONTROL_AF_TRIGGER =                                // byte (acamera_metadata_enum_android_control_af_trigger_t)
699             ACAMERA_CONTROL_START + 9,
700     /**
701      * <p>Whether auto-white balance (AWB) is currently locked to its
702      * latest calculated values.</p>
703      *
704      * <p>Type: byte (acamera_metadata_enum_android_control_awb_lock_t)</p>
705      *
706      * <p>This tag may appear in:
707      * <ul>
708      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
709      *   <li>ACaptureRequest</li>
710      * </ul></p>
711      *
712      * <p>When set to <code>true</code> (ON), the AWB algorithm is locked to its latest parameters,
713      * and will not change color balance settings until the lock is set to <code>false</code> (OFF).</p>
714      * <p>Since the camera device has a pipeline of in-flight requests, the settings that
715      * get locked do not necessarily correspond to the settings that were present in the
716      * latest capture result received from the camera device, since additional captures
717      * and AWB updates may have occurred even before the result was sent out. If an
718      * application is switching between automatic and manual control and wishes to eliminate
719      * any flicker during the switch, the following procedure is recommended:</p>
720      * <ol>
721      * <li>Starting in auto-AWB mode:</li>
722      * <li>Lock AWB</li>
723      * <li>Wait for the first result to be output that has the AWB locked</li>
724      * <li>Copy AWB settings from that result into a request, set the request to manual AWB</li>
725      * <li>Submit the capture request, proceed to run manual AWB as desired.</li>
726      * </ol>
727      * <p>Note that AWB lock is only meaningful when
728      * ACAMERA_CONTROL_AWB_MODE is in the AUTO mode; in other modes,
729      * AWB is already fixed to a specific setting.</p>
730      * <p>Some LEGACY devices may not support ON; the value is then overridden to OFF.</p>
731      *
732      * @see ACAMERA_CONTROL_AWB_MODE
733      */
734     ACAMERA_CONTROL_AWB_LOCK =                                  // byte (acamera_metadata_enum_android_control_awb_lock_t)
735             ACAMERA_CONTROL_START + 10,
736     /**
737      * <p>Whether auto-white balance (AWB) is currently setting the color
738      * transform fields, and what its illumination target
739      * is.</p>
740      *
741      * <p>Type: byte (acamera_metadata_enum_android_control_awb_mode_t)</p>
742      *
743      * <p>This tag may appear in:
744      * <ul>
745      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
746      *   <li>ACaptureRequest</li>
747      * </ul></p>
748      *
749      * <p>This control is only effective if ACAMERA_CONTROL_MODE is AUTO.</p>
750      * <p>When set to the ON mode, the camera device's auto-white balance
751      * routine is enabled, overriding the application's selected
752      * ACAMERA_COLOR_CORRECTION_TRANSFORM, ACAMERA_COLOR_CORRECTION_GAINS and
753      * ACAMERA_COLOR_CORRECTION_MODE. Note that when ACAMERA_CONTROL_AE_MODE
754      * is OFF, the behavior of AWB is device dependent. It is recommened to
755      * also set AWB mode to OFF or lock AWB by using ACAMERA_CONTROL_AWB_LOCK before
756      * setting AE mode to OFF.</p>
757      * <p>When set to the OFF mode, the camera device's auto-white balance
758      * routine is disabled. The application manually controls the white
759      * balance by ACAMERA_COLOR_CORRECTION_TRANSFORM, ACAMERA_COLOR_CORRECTION_GAINS
760      * and ACAMERA_COLOR_CORRECTION_MODE.</p>
761      * <p>When set to any other modes, the camera device's auto-white
762      * balance routine is disabled. The camera device uses each
763      * particular illumination target for white balance
764      * adjustment. The application's values for
765      * ACAMERA_COLOR_CORRECTION_TRANSFORM,
766      * ACAMERA_COLOR_CORRECTION_GAINS and
767      * ACAMERA_COLOR_CORRECTION_MODE are ignored.</p>
768      *
769      * @see ACAMERA_COLOR_CORRECTION_GAINS
770      * @see ACAMERA_COLOR_CORRECTION_MODE
771      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
772      * @see ACAMERA_CONTROL_AE_MODE
773      * @see ACAMERA_CONTROL_AWB_LOCK
774      * @see ACAMERA_CONTROL_MODE
775      */
776     ACAMERA_CONTROL_AWB_MODE =                                  // byte (acamera_metadata_enum_android_control_awb_mode_t)
777             ACAMERA_CONTROL_START + 11,
778     /**
779      * <p>List of metering areas to use for auto-white-balance illuminant
780      * estimation.</p>
781      *
782      * <p>Type: int32[5*area_count]</p>
783      *
784      * <p>This tag may appear in:
785      * <ul>
786      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
787      *   <li>ACaptureRequest</li>
788      * </ul></p>
789      *
790      * <p>Not available if android.control.maxRegionsAwb is 0.
791      * Otherwise will always be present.</p>
792      * <p>The maximum number of regions supported by the device is determined by the value
793      * of android.control.maxRegionsAwb.</p>
794      * <p>The data representation is int[5 * area_count].
795      * Every five elements represent a metering region of (xmin, ymin, xmax, ymax, weight).
796      * The rectangle is defined to be inclusive on xmin and ymin, but exclusive on xmax and
797      * ymax.</p>
798      * <p>The coordinate system is based on the active pixel array,
799      * with (0,0) being the top-left pixel in the active pixel array, and
800      * (ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.width - 1,
801      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.height - 1) being the
802      * bottom-right pixel in the active pixel array.</p>
803      * <p>The weight must range from 0 to 1000, and represents a weight
804      * for every pixel in the area. This means that a large metering area
805      * with the same weight as a smaller area will have more effect in
806      * the metering result. Metering areas can partially overlap and the
807      * camera device will add the weights in the overlap region.</p>
808      * <p>The weights are relative to weights of other white balance metering regions, so if
809      * only one region is used, all non-zero weights will have the same effect. A region with
810      * 0 weight is ignored.</p>
811      * <p>If all regions have 0 weight, then no specific metering area needs to be used by the
812      * camera device.</p>
813      * <p>If the metering region is outside the used ACAMERA_SCALER_CROP_REGION returned in
814      * capture result metadata, the camera device will ignore the sections outside the crop
815      * region and output only the intersection rectangle as the metering region in the result
816      * metadata.  If the region is entirely outside the crop region, it will be ignored and
817      * not reported in the result metadata.</p>
818      *
819      * @see ACAMERA_SCALER_CROP_REGION
820      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
821      */
822     ACAMERA_CONTROL_AWB_REGIONS =                               // int32[5*area_count]
823             ACAMERA_CONTROL_START + 12,
824     /**
825      * <p>Information to the camera device 3A (auto-exposure,
826      * auto-focus, auto-white balance) routines about the purpose
827      * of this capture, to help the camera device to decide optimal 3A
828      * strategy.</p>
829      *
830      * <p>Type: byte (acamera_metadata_enum_android_control_capture_intent_t)</p>
831      *
832      * <p>This tag may appear in:
833      * <ul>
834      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
835      *   <li>ACaptureRequest</li>
836      * </ul></p>
837      *
838      * <p>This control (except for MANUAL) is only effective if
839      * <code>ACAMERA_CONTROL_MODE != OFF</code> and any 3A routine is active.</p>
840      * <p>ZERO_SHUTTER_LAG will be supported if ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
841      * contains PRIVATE_REPROCESSING or YUV_REPROCESSING. MANUAL will be supported if
842      * ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains MANUAL_SENSOR. Other intent values are
843      * always supported.</p>
844      *
845      * @see ACAMERA_CONTROL_MODE
846      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
847      */
848     ACAMERA_CONTROL_CAPTURE_INTENT =                            // byte (acamera_metadata_enum_android_control_capture_intent_t)
849             ACAMERA_CONTROL_START + 13,
850     /**
851      * <p>A special color effect to apply.</p>
852      *
853      * <p>Type: byte (acamera_metadata_enum_android_control_effect_mode_t)</p>
854      *
855      * <p>This tag may appear in:
856      * <ul>
857      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
858      *   <li>ACaptureRequest</li>
859      * </ul></p>
860      *
861      * <p>When this mode is set, a color effect will be applied
862      * to images produced by the camera device. The interpretation
863      * and implementation of these color effects is left to the
864      * implementor of the camera device, and should not be
865      * depended on to be consistent (or present) across all
866      * devices.</p>
867      */
868     ACAMERA_CONTROL_EFFECT_MODE =                               // byte (acamera_metadata_enum_android_control_effect_mode_t)
869             ACAMERA_CONTROL_START + 14,
870     /**
871      * <p>Overall mode of 3A (auto-exposure, auto-white-balance, auto-focus) control
872      * routines.</p>
873      *
874      * <p>Type: byte (acamera_metadata_enum_android_control_mode_t)</p>
875      *
876      * <p>This tag may appear in:
877      * <ul>
878      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
879      *   <li>ACaptureRequest</li>
880      * </ul></p>
881      *
882      * <p>This is a top-level 3A control switch. When set to OFF, all 3A control
883      * by the camera device is disabled. The application must set the fields for
884      * capture parameters itself.</p>
885      * <p>When set to AUTO, the individual algorithm controls in
886      * ACAMERA_CONTROL_* are in effect, such as ACAMERA_CONTROL_AF_MODE.</p>
887      * <p>When set to USE_SCENE_MODE, the individual controls in
888      * ACAMERA_CONTROL_* are mostly disabled, and the camera device implements
889      * one of the scene mode settings (such as ACTION, SUNSET, or PARTY)
890      * as it wishes. The camera device scene mode 3A settings are provided by
891      * capture results {@link ACameraMetadata} from
892      * {@link ACameraCaptureSession_captureCallback_result}.</p>
893      * <p>When set to OFF_KEEP_STATE, it is similar to OFF mode, the only difference
894      * is that this frame will not be used by camera device background 3A statistics
895      * update, as if this frame is never captured. This mode can be used in the scenario
896      * where the application doesn't want a 3A manual control capture to affect
897      * the subsequent auto 3A capture results.</p>
898      *
899      * @see ACAMERA_CONTROL_AF_MODE
900      */
901     ACAMERA_CONTROL_MODE =                                      // byte (acamera_metadata_enum_android_control_mode_t)
902             ACAMERA_CONTROL_START + 15,
903     /**
904      * <p>Control for which scene mode is currently active.</p>
905      *
906      * <p>Type: byte (acamera_metadata_enum_android_control_scene_mode_t)</p>
907      *
908      * <p>This tag may appear in:
909      * <ul>
910      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
911      *   <li>ACaptureRequest</li>
912      * </ul></p>
913      *
914      * <p>Scene modes are custom camera modes optimized for a certain set of conditions and
915      * capture settings.</p>
916      * <p>This is the mode that that is active when
917      * <code>ACAMERA_CONTROL_MODE == USE_SCENE_MODE</code>. Aside from FACE_PRIORITY, these modes will
918      * disable ACAMERA_CONTROL_AE_MODE, ACAMERA_CONTROL_AWB_MODE, and ACAMERA_CONTROL_AF_MODE
919      * while in use.</p>
920      * <p>The interpretation and implementation of these scene modes is left
921      * to the implementor of the camera device. Their behavior will not be
922      * consistent across all devices, and any given device may only implement
923      * a subset of these modes.</p>
924      *
925      * @see ACAMERA_CONTROL_AE_MODE
926      * @see ACAMERA_CONTROL_AF_MODE
927      * @see ACAMERA_CONTROL_AWB_MODE
928      * @see ACAMERA_CONTROL_MODE
929      */
930     ACAMERA_CONTROL_SCENE_MODE =                                // byte (acamera_metadata_enum_android_control_scene_mode_t)
931             ACAMERA_CONTROL_START + 16,
932     /**
933      * <p>Whether video stabilization is
934      * active.</p>
935      *
936      * <p>Type: byte (acamera_metadata_enum_android_control_video_stabilization_mode_t)</p>
937      *
938      * <p>This tag may appear in:
939      * <ul>
940      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
941      *   <li>ACaptureRequest</li>
942      * </ul></p>
943      *
944      * <p>Video stabilization automatically warps images from
945      * the camera in order to stabilize motion between consecutive frames.</p>
946      * <p>If enabled, video stabilization can modify the
947      * ACAMERA_SCALER_CROP_REGION to keep the video stream stabilized.</p>
948      * <p>Switching between different video stabilization modes may take several
949      * frames to initialize, the camera device will report the current mode
950      * in capture result metadata. For example, When "ON" mode is requested,
951      * the video stabilization modes in the first several capture results may
952      * still be "OFF", and it will become "ON" when the initialization is
953      * done.</p>
954      * <p>In addition, not all recording sizes or frame rates may be supported for
955      * stabilization by a device that reports stabilization support. It is guaranteed
956      * that an output targeting a MediaRecorder or MediaCodec will be stabilized if
957      * the recording resolution is less than or equal to 1920 x 1080 (width less than
958      * or equal to 1920, height less than or equal to 1080), and the recording
959      * frame rate is less than or equal to 30fps.  At other sizes, the CaptureResult
960      * ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE field will return
961      * OFF if the recording output is not stabilized, or if there are no output
962      * Surface types that can be stabilized.</p>
963      * <p>If a camera device supports both this mode and OIS
964      * (ACAMERA_LENS_OPTICAL_STABILIZATION_MODE), turning both modes on may
965      * produce undesirable interaction, so it is recommended not to enable
966      * both at the same time.</p>
967      *
968      * @see ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
969      * @see ACAMERA_LENS_OPTICAL_STABILIZATION_MODE
970      * @see ACAMERA_SCALER_CROP_REGION
971      */
972     ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE =                  // byte (acamera_metadata_enum_android_control_video_stabilization_mode_t)
973             ACAMERA_CONTROL_START + 17,
974     /**
975      * <p>List of auto-exposure antibanding modes for ACAMERA_CONTROL_AE_ANTIBANDING_MODE that are
976      * supported by this camera device.</p>
977      *
978      * @see ACAMERA_CONTROL_AE_ANTIBANDING_MODE
979      *
980      * <p>Type: byte[n]</p>
981      *
982      * <p>This tag may appear in:
983      * <ul>
984      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
985      * </ul></p>
986      *
987      * <p>Not all of the auto-exposure anti-banding modes may be
988      * supported by a given camera device. This field lists the
989      * valid anti-banding modes that the application may request
990      * for this camera device with the
991      * ACAMERA_CONTROL_AE_ANTIBANDING_MODE control.</p>
992      *
993      * @see ACAMERA_CONTROL_AE_ANTIBANDING_MODE
994      */
995     ACAMERA_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES =            // byte[n]
996             ACAMERA_CONTROL_START + 18,
997     /**
998      * <p>List of auto-exposure modes for ACAMERA_CONTROL_AE_MODE that are supported by this camera
999      * device.</p>
1000      *
1001      * @see ACAMERA_CONTROL_AE_MODE
1002      *
1003      * <p>Type: byte[n]</p>
1004      *
1005      * <p>This tag may appear in:
1006      * <ul>
1007      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1008      * </ul></p>
1009      *
1010      * <p>Not all the auto-exposure modes may be supported by a
1011      * given camera device, especially if no flash unit is
1012      * available. This entry lists the valid modes for
1013      * ACAMERA_CONTROL_AE_MODE for this camera device.</p>
1014      * <p>All camera devices support ON, and all camera devices with flash
1015      * units support ON_AUTO_FLASH and ON_ALWAYS_FLASH.</p>
1016      * <p>FULL mode camera devices always support OFF mode,
1017      * which enables application control of camera exposure time,
1018      * sensitivity, and frame duration.</p>
1019      * <p>LEGACY mode camera devices never support OFF mode.
1020      * LIMITED mode devices support OFF if they support the MANUAL_SENSOR
1021      * capability.</p>
1022      *
1023      * @see ACAMERA_CONTROL_AE_MODE
1024      */
1025     ACAMERA_CONTROL_AE_AVAILABLE_MODES =                        // byte[n]
1026             ACAMERA_CONTROL_START + 19,
1027     /**
1028      * <p>List of frame rate ranges for ACAMERA_CONTROL_AE_TARGET_FPS_RANGE supported by
1029      * this camera device.</p>
1030      *
1031      * @see ACAMERA_CONTROL_AE_TARGET_FPS_RANGE
1032      *
1033      * <p>Type: int32[2*n]</p>
1034      *
1035      * <p>This tag may appear in:
1036      * <ul>
1037      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1038      * </ul></p>
1039      *
1040      * <p>For devices at the LEGACY level or above:</p>
1041      * <ul>
1042      * <li>
1043      * <p>For constant-framerate recording, for each normal
1044      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html">CamcorderProfile</a>, that is, a
1045      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html">CamcorderProfile</a> that has
1046      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html#quality">quality</a>
1047      * in the range [
1048      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html#QUALITY_LOW">QUALITY_LOW</a>,
1049      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html#QUALITY_2160P">QUALITY_2160P</a>],
1050      * if the profile is supported by the device and has
1051      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html#videoFrameRate">videoFrameRate</a>
1052      * <code>x</code>, this list will always include (<code>x</code>,<code>x</code>).</p>
1053      * </li>
1054      * <li>
1055      * <p>Also, a camera device must either not support any
1056      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html">CamcorderProfile</a>,
1057      * or support at least one
1058      * normal <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html">CamcorderProfile</a>
1059      * that has
1060      * <a href="https://developer.android.com/reference/android/media/CamcorderProfile.html#videoFrameRate">videoFrameRate</a> <code>x</code> &gt;= 24.</p>
1061      * </li>
1062      * </ul>
1063      * <p>For devices at the LIMITED level or above:</p>
1064      * <ul>
1065      * <li>For YUV_420_888 burst capture use case, this list will always include (<code>min</code>, <code>max</code>)
1066      * and (<code>max</code>, <code>max</code>) where <code>min</code> &lt;= 15 and <code>max</code> = the maximum output frame rate of the
1067      * maximum YUV_420_888 output size.</li>
1068      * </ul>
1069      */
1070     ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES =            // int32[2*n]
1071             ACAMERA_CONTROL_START + 20,
1072     /**
1073      * <p>Maximum and minimum exposure compensation values for
1074      * ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION, in counts of ACAMERA_CONTROL_AE_COMPENSATION_STEP,
1075      * that are supported by this camera device.</p>
1076      *
1077      * @see ACAMERA_CONTROL_AE_COMPENSATION_STEP
1078      * @see ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION
1079      *
1080      * <p>Type: int32[2]</p>
1081      *
1082      * <p>This tag may appear in:
1083      * <ul>
1084      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1085      * </ul></p>
1086      *
1087      */
1088     ACAMERA_CONTROL_AE_COMPENSATION_RANGE =                     // int32[2]
1089             ACAMERA_CONTROL_START + 21,
1090     /**
1091      * <p>Smallest step by which the exposure compensation
1092      * can be changed.</p>
1093      *
1094      * <p>Type: rational</p>
1095      *
1096      * <p>This tag may appear in:
1097      * <ul>
1098      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1099      * </ul></p>
1100      *
1101      * <p>This is the unit for ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION. For example, if this key has
1102      * a value of <code>1/2</code>, then a setting of <code>-2</code> for ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION means
1103      * that the target EV offset for the auto-exposure routine is -1 EV.</p>
1104      * <p>One unit of EV compensation changes the brightness of the captured image by a factor
1105      * of two. +1 EV doubles the image brightness, while -1 EV halves the image brightness.</p>
1106      *
1107      * @see ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION
1108      */
1109     ACAMERA_CONTROL_AE_COMPENSATION_STEP =                      // rational
1110             ACAMERA_CONTROL_START + 22,
1111     /**
1112      * <p>List of auto-focus (AF) modes for ACAMERA_CONTROL_AF_MODE that are
1113      * supported by this camera device.</p>
1114      *
1115      * @see ACAMERA_CONTROL_AF_MODE
1116      *
1117      * <p>Type: byte[n]</p>
1118      *
1119      * <p>This tag may appear in:
1120      * <ul>
1121      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1122      * </ul></p>
1123      *
1124      * <p>Not all the auto-focus modes may be supported by a
1125      * given camera device. This entry lists the valid modes for
1126      * ACAMERA_CONTROL_AF_MODE for this camera device.</p>
1127      * <p>All LIMITED and FULL mode camera devices will support OFF mode, and all
1128      * camera devices with adjustable focuser units
1129      * (<code>ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE &gt; 0</code>) will support AUTO mode.</p>
1130      * <p>LEGACY devices will support OFF mode only if they support
1131      * focusing to infinity (by also setting ACAMERA_LENS_FOCUS_DISTANCE to
1132      * <code>0.0f</code>).</p>
1133      *
1134      * @see ACAMERA_CONTROL_AF_MODE
1135      * @see ACAMERA_LENS_FOCUS_DISTANCE
1136      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
1137      */
1138     ACAMERA_CONTROL_AF_AVAILABLE_MODES =                        // byte[n]
1139             ACAMERA_CONTROL_START + 23,
1140     /**
1141      * <p>List of color effects for ACAMERA_CONTROL_EFFECT_MODE that are supported by this camera
1142      * device.</p>
1143      *
1144      * @see ACAMERA_CONTROL_EFFECT_MODE
1145      *
1146      * <p>Type: byte[n]</p>
1147      *
1148      * <p>This tag may appear in:
1149      * <ul>
1150      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1151      * </ul></p>
1152      *
1153      * <p>This list contains the color effect modes that can be applied to
1154      * images produced by the camera device.
1155      * Implementations are not expected to be consistent across all devices.
1156      * If no color effect modes are available for a device, this will only list
1157      * OFF.</p>
1158      * <p>A color effect will only be applied if
1159      * ACAMERA_CONTROL_MODE != OFF.  OFF is always included in this list.</p>
1160      * <p>This control has no effect on the operation of other control routines such
1161      * as auto-exposure, white balance, or focus.</p>
1162      *
1163      * @see ACAMERA_CONTROL_MODE
1164      */
1165     ACAMERA_CONTROL_AVAILABLE_EFFECTS =                         // byte[n]
1166             ACAMERA_CONTROL_START + 24,
1167     /**
1168      * <p>List of scene modes for ACAMERA_CONTROL_SCENE_MODE that are supported by this camera
1169      * device.</p>
1170      *
1171      * @see ACAMERA_CONTROL_SCENE_MODE
1172      *
1173      * <p>Type: byte[n]</p>
1174      *
1175      * <p>This tag may appear in:
1176      * <ul>
1177      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1178      * </ul></p>
1179      *
1180      * <p>This list contains scene modes that can be set for the camera device.
1181      * Only scene modes that have been fully implemented for the
1182      * camera device may be included here. Implementations are not expected
1183      * to be consistent across all devices.</p>
1184      * <p>If no scene modes are supported by the camera device, this
1185      * will be set to DISABLED. Otherwise DISABLED will not be listed.</p>
1186      * <p>FACE_PRIORITY is always listed if face detection is
1187      * supported (i.e.<code>ACAMERA_STATISTICS_INFO_MAX_FACE_COUNT &gt;
1188      * 0</code>).</p>
1189      *
1190      * @see ACAMERA_STATISTICS_INFO_MAX_FACE_COUNT
1191      */
1192     ACAMERA_CONTROL_AVAILABLE_SCENE_MODES =                     // byte[n]
1193             ACAMERA_CONTROL_START + 25,
1194     /**
1195      * <p>List of video stabilization modes for ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
1196      * that are supported by this camera device.</p>
1197      *
1198      * @see ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
1199      *
1200      * <p>Type: byte[n]</p>
1201      *
1202      * <p>This tag may appear in:
1203      * <ul>
1204      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1205      * </ul></p>
1206      *
1207      * <p>OFF will always be listed.</p>
1208      */
1209     ACAMERA_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES =       // byte[n]
1210             ACAMERA_CONTROL_START + 26,
1211     /**
1212      * <p>List of auto-white-balance modes for ACAMERA_CONTROL_AWB_MODE that are supported by this
1213      * camera device.</p>
1214      *
1215      * @see ACAMERA_CONTROL_AWB_MODE
1216      *
1217      * <p>Type: byte[n]</p>
1218      *
1219      * <p>This tag may appear in:
1220      * <ul>
1221      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1222      * </ul></p>
1223      *
1224      * <p>Not all the auto-white-balance modes may be supported by a
1225      * given camera device. This entry lists the valid modes for
1226      * ACAMERA_CONTROL_AWB_MODE for this camera device.</p>
1227      * <p>All camera devices will support ON mode.</p>
1228      * <p>Camera devices that support the MANUAL_POST_PROCESSING capability will always support OFF
1229      * mode, which enables application control of white balance, by using
1230      * ACAMERA_COLOR_CORRECTION_TRANSFORM and ACAMERA_COLOR_CORRECTION_GAINS(ACAMERA_COLOR_CORRECTION_MODE must be set to TRANSFORM_MATRIX). This includes all FULL
1231      * mode camera devices.</p>
1232      *
1233      * @see ACAMERA_COLOR_CORRECTION_GAINS
1234      * @see ACAMERA_COLOR_CORRECTION_MODE
1235      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
1236      * @see ACAMERA_CONTROL_AWB_MODE
1237      */
1238     ACAMERA_CONTROL_AWB_AVAILABLE_MODES =                       // byte[n]
1239             ACAMERA_CONTROL_START + 27,
1240     /**
1241      * <p>List of the maximum number of regions that can be used for metering in
1242      * auto-exposure (AE), auto-white balance (AWB), and auto-focus (AF);
1243      * this corresponds to the the maximum number of elements in
1244      * ACAMERA_CONTROL_AE_REGIONS, ACAMERA_CONTROL_AWB_REGIONS,
1245      * and ACAMERA_CONTROL_AF_REGIONS.</p>
1246      *
1247      * @see ACAMERA_CONTROL_AE_REGIONS
1248      * @see ACAMERA_CONTROL_AF_REGIONS
1249      * @see ACAMERA_CONTROL_AWB_REGIONS
1250      *
1251      * <p>Type: int32[3]</p>
1252      *
1253      * <p>This tag may appear in:
1254      * <ul>
1255      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1256      * </ul></p>
1257      *
1258      */
1259     ACAMERA_CONTROL_MAX_REGIONS =                               // int32[3]
1260             ACAMERA_CONTROL_START + 28,
1261     /**
1262      * <p>Current state of the auto-exposure (AE) algorithm.</p>
1263      *
1264      * <p>Type: byte (acamera_metadata_enum_android_control_ae_state_t)</p>
1265      *
1266      * <p>This tag may appear in:
1267      * <ul>
1268      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1269      * </ul></p>
1270      *
1271      * <p>Switching between or enabling AE modes (ACAMERA_CONTROL_AE_MODE) always
1272      * resets the AE state to INACTIVE. Similarly, switching between ACAMERA_CONTROL_MODE,
1273      * or ACAMERA_CONTROL_SCENE_MODE if <code>ACAMERA_CONTROL_MODE == USE_SCENE_MODE</code> resets all
1274      * the algorithm states to INACTIVE.</p>
1275      * <p>The camera device can do several state transitions between two results, if it is
1276      * allowed by the state transition table. For example: INACTIVE may never actually be
1277      * seen in a result.</p>
1278      * <p>The state in the result is the state for this image (in sync with this image): if
1279      * AE state becomes CONVERGED, then the image data associated with this result should
1280      * be good to use.</p>
1281      * <p>Below are state transition tables for different AE modes.</p>
1282      * <p>State       | Transition Cause | New State | Notes
1283      * :------------:|:----------------:|:---------:|:-----------------------:
1284      * INACTIVE      |                  | INACTIVE  | Camera device auto exposure algorithm is disabled</p>
1285      * <p>When ACAMERA_CONTROL_AE_MODE is AE_MODE_ON_*:</p>
1286      * <p>State        | Transition Cause                             | New State      | Notes
1287      * :-------------:|:--------------------------------------------:|:--------------:|:-----------------:
1288      * INACTIVE       | Camera device initiates AE scan              | SEARCHING      | Values changing
1289      * INACTIVE       | ACAMERA_CONTROL_AE_LOCK is ON                 | LOCKED         | Values locked
1290      * SEARCHING      | Camera device finishes AE scan               | CONVERGED      | Good values, not changing
1291      * SEARCHING      | Camera device finishes AE scan               | FLASH_REQUIRED | Converged but too dark w/o flash
1292      * SEARCHING      | ACAMERA_CONTROL_AE_LOCK is ON                 | LOCKED         | Values locked
1293      * CONVERGED      | Camera device initiates AE scan              | SEARCHING      | Values changing
1294      * CONVERGED      | ACAMERA_CONTROL_AE_LOCK is ON                 | LOCKED         | Values locked
1295      * FLASH_REQUIRED | Camera device initiates AE scan              | SEARCHING      | Values changing
1296      * FLASH_REQUIRED | ACAMERA_CONTROL_AE_LOCK is ON                 | LOCKED         | Values locked
1297      * LOCKED         | ACAMERA_CONTROL_AE_LOCK is OFF                | SEARCHING      | Values not good after unlock
1298      * LOCKED         | ACAMERA_CONTROL_AE_LOCK is OFF                | CONVERGED      | Values good after unlock
1299      * LOCKED         | ACAMERA_CONTROL_AE_LOCK is OFF                | FLASH_REQUIRED | Exposure good, but too dark
1300      * PRECAPTURE     | Sequence done. ACAMERA_CONTROL_AE_LOCK is OFF | CONVERGED      | Ready for high-quality capture
1301      * PRECAPTURE     | Sequence done. ACAMERA_CONTROL_AE_LOCK is ON  | LOCKED         | Ready for high-quality capture
1302      * LOCKED         | aeLock is ON and aePrecaptureTrigger is START | LOCKED        | Precapture trigger is ignored when AE is already locked
1303      * LOCKED         | aeLock is ON and aePrecaptureTrigger is CANCEL| LOCKED        | Precapture trigger is ignored when AE is already locked
1304      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is START | PRECAPTURE     | Start AE precapture metering sequence
1305      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is CANCEL| INACTIVE       | Currently active precapture metering sequence is canceled</p>
1306      * <p>For the above table, the camera device may skip reporting any state changes that happen
1307      * without application intervention (i.e. mode switch, trigger, locking). Any state that
1308      * can be skipped in that manner is called a transient state.</p>
1309      * <p>For example, for above AE modes (AE_MODE_ON_*), in addition to the state transitions
1310      * listed in above table, it is also legal for the camera device to skip one or more
1311      * transient states between two results. See below table for examples:</p>
1312      * <p>State        | Transition Cause                                            | New State      | Notes
1313      * :-------------:|:-----------------------------------------------------------:|:--------------:|:-----------------:
1314      * INACTIVE       | Camera device finished AE scan                              | CONVERGED      | Values are already good, transient states are skipped by camera device.
1315      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is START, sequence done | FLASH_REQUIRED | Converged but too dark w/o flash after a precapture sequence, transient states are skipped by camera device.
1316      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is START, sequence done | CONVERGED      | Converged after a precapture sequence, transient states are skipped by camera device.
1317      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is CANCEL, converged    | FLASH_REQUIRED | Converged but too dark w/o flash after a precapture sequence is canceled, transient states are skipped by camera device.
1318      * Any state (excluding LOCKED) | ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is CANCEL, converged    | CONVERGED      | Converged after a precapture sequenceis canceled, transient states are skipped by camera device.
1319      * CONVERGED      | Camera device finished AE scan                              | FLASH_REQUIRED | Converged but too dark w/o flash after a new scan, transient states are skipped by camera device.
1320      * FLASH_REQUIRED | Camera device finished AE scan                              | CONVERGED      | Converged after a new scan, transient states are skipped by camera device.</p>
1321      *
1322      * @see ACAMERA_CONTROL_AE_LOCK
1323      * @see ACAMERA_CONTROL_AE_MODE
1324      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
1325      * @see ACAMERA_CONTROL_MODE
1326      * @see ACAMERA_CONTROL_SCENE_MODE
1327      */
1328     ACAMERA_CONTROL_AE_STATE =                                  // byte (acamera_metadata_enum_android_control_ae_state_t)
1329             ACAMERA_CONTROL_START + 31,
1330     /**
1331      * <p>Current state of auto-focus (AF) algorithm.</p>
1332      *
1333      * <p>Type: byte (acamera_metadata_enum_android_control_af_state_t)</p>
1334      *
1335      * <p>This tag may appear in:
1336      * <ul>
1337      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1338      * </ul></p>
1339      *
1340      * <p>Switching between or enabling AF modes (ACAMERA_CONTROL_AF_MODE) always
1341      * resets the AF state to INACTIVE. Similarly, switching between ACAMERA_CONTROL_MODE,
1342      * or ACAMERA_CONTROL_SCENE_MODE if <code>ACAMERA_CONTROL_MODE == USE_SCENE_MODE</code> resets all
1343      * the algorithm states to INACTIVE.</p>
1344      * <p>The camera device can do several state transitions between two results, if it is
1345      * allowed by the state transition table. For example: INACTIVE may never actually be
1346      * seen in a result.</p>
1347      * <p>The state in the result is the state for this image (in sync with this image): if
1348      * AF state becomes FOCUSED, then the image data associated with this result should
1349      * be sharp.</p>
1350      * <p>Below are state transition tables for different AF modes.</p>
1351      * <p>When ACAMERA_CONTROL_AF_MODE is AF_MODE_OFF or AF_MODE_EDOF:</p>
1352      * <p>State       | Transition Cause | New State | Notes
1353      * :------------:|:----------------:|:---------:|:-----------:
1354      * INACTIVE      |                  | INACTIVE  | Never changes</p>
1355      * <p>When ACAMERA_CONTROL_AF_MODE is AF_MODE_AUTO or AF_MODE_MACRO:</p>
1356      * <p>State            | Transition Cause | New State          | Notes
1357      * :-----------------:|:----------------:|:------------------:|:--------------:
1358      * INACTIVE           | AF_TRIGGER       | ACTIVE_SCAN        | Start AF sweep, Lens now moving
1359      * ACTIVE_SCAN        | AF sweep done    | FOCUSED_LOCKED     | Focused, Lens now locked
1360      * ACTIVE_SCAN        | AF sweep done    | NOT_FOCUSED_LOCKED | Not focused, Lens now locked
1361      * ACTIVE_SCAN        | AF_CANCEL        | INACTIVE           | Cancel/reset AF, Lens now locked
1362      * FOCUSED_LOCKED     | AF_CANCEL        | INACTIVE           | Cancel/reset AF
1363      * FOCUSED_LOCKED     | AF_TRIGGER       | ACTIVE_SCAN        | Start new sweep, Lens now moving
1364      * NOT_FOCUSED_LOCKED | AF_CANCEL        | INACTIVE           | Cancel/reset AF
1365      * NOT_FOCUSED_LOCKED | AF_TRIGGER       | ACTIVE_SCAN        | Start new sweep, Lens now moving
1366      * Any state          | Mode change      | INACTIVE           |</p>
1367      * <p>For the above table, the camera device may skip reporting any state changes that happen
1368      * without application intervention (i.e. mode switch, trigger, locking). Any state that
1369      * can be skipped in that manner is called a transient state.</p>
1370      * <p>For example, for these AF modes (AF_MODE_AUTO and AF_MODE_MACRO), in addition to the
1371      * state transitions listed in above table, it is also legal for the camera device to skip
1372      * one or more transient states between two results. See below table for examples:</p>
1373      * <p>State            | Transition Cause | New State          | Notes
1374      * :-----------------:|:----------------:|:------------------:|:--------------:
1375      * INACTIVE           | AF_TRIGGER       | FOCUSED_LOCKED     | Focus is already good or good after a scan, lens is now locked.
1376      * INACTIVE           | AF_TRIGGER       | NOT_FOCUSED_LOCKED | Focus failed after a scan, lens is now locked.
1377      * FOCUSED_LOCKED     | AF_TRIGGER       | FOCUSED_LOCKED     | Focus is already good or good after a scan, lens is now locked.
1378      * NOT_FOCUSED_LOCKED | AF_TRIGGER       | FOCUSED_LOCKED     | Focus is good after a scan, lens is not locked.</p>
1379      * <p>When ACAMERA_CONTROL_AF_MODE is AF_MODE_CONTINUOUS_VIDEO:</p>
1380      * <p>State            | Transition Cause                    | New State          | Notes
1381      * :-----------------:|:-----------------------------------:|:------------------:|:--------------:
1382      * INACTIVE           | Camera device initiates new scan    | PASSIVE_SCAN       | Start AF scan, Lens now moving
1383      * INACTIVE           | AF_TRIGGER                          | NOT_FOCUSED_LOCKED | AF state query, Lens now locked
1384      * PASSIVE_SCAN       | Camera device completes current scan| PASSIVE_FOCUSED    | End AF scan, Lens now locked
1385      * PASSIVE_SCAN       | Camera device fails current scan    | PASSIVE_UNFOCUSED  | End AF scan, Lens now locked
1386      * PASSIVE_SCAN       | AF_TRIGGER                          | FOCUSED_LOCKED     | Immediate transition, if focus is good. Lens now locked
1387      * PASSIVE_SCAN       | AF_TRIGGER                          | NOT_FOCUSED_LOCKED | Immediate transition, if focus is bad. Lens now locked
1388      * PASSIVE_SCAN       | AF_CANCEL                           | INACTIVE           | Reset lens position, Lens now locked
1389      * PASSIVE_FOCUSED    | Camera device initiates new scan    | PASSIVE_SCAN       | Start AF scan, Lens now moving
1390      * PASSIVE_UNFOCUSED  | Camera device initiates new scan    | PASSIVE_SCAN       | Start AF scan, Lens now moving
1391      * PASSIVE_FOCUSED    | AF_TRIGGER                          | FOCUSED_LOCKED     | Immediate transition, lens now locked
1392      * PASSIVE_UNFOCUSED  | AF_TRIGGER                          | NOT_FOCUSED_LOCKED | Immediate transition, lens now locked
1393      * FOCUSED_LOCKED     | AF_TRIGGER                          | FOCUSED_LOCKED     | No effect
1394      * FOCUSED_LOCKED     | AF_CANCEL                           | INACTIVE           | Restart AF scan
1395      * NOT_FOCUSED_LOCKED | AF_TRIGGER                          | NOT_FOCUSED_LOCKED | No effect
1396      * NOT_FOCUSED_LOCKED | AF_CANCEL                           | INACTIVE           | Restart AF scan</p>
1397      * <p>When ACAMERA_CONTROL_AF_MODE is AF_MODE_CONTINUOUS_PICTURE:</p>
1398      * <p>State            | Transition Cause                     | New State          | Notes
1399      * :-----------------:|:------------------------------------:|:------------------:|:--------------:
1400      * INACTIVE           | Camera device initiates new scan     | PASSIVE_SCAN       | Start AF scan, Lens now moving
1401      * INACTIVE           | AF_TRIGGER                           | NOT_FOCUSED_LOCKED | AF state query, Lens now locked
1402      * PASSIVE_SCAN       | Camera device completes current scan | PASSIVE_FOCUSED    | End AF scan, Lens now locked
1403      * PASSIVE_SCAN       | Camera device fails current scan     | PASSIVE_UNFOCUSED  | End AF scan, Lens now locked
1404      * PASSIVE_SCAN       | AF_TRIGGER                           | FOCUSED_LOCKED     | Eventual transition once the focus is good. Lens now locked
1405      * PASSIVE_SCAN       | AF_TRIGGER                           | NOT_FOCUSED_LOCKED | Eventual transition if cannot find focus. Lens now locked
1406      * PASSIVE_SCAN       | AF_CANCEL                            | INACTIVE           | Reset lens position, Lens now locked
1407      * PASSIVE_FOCUSED    | Camera device initiates new scan     | PASSIVE_SCAN       | Start AF scan, Lens now moving
1408      * PASSIVE_UNFOCUSED  | Camera device initiates new scan     | PASSIVE_SCAN       | Start AF scan, Lens now moving
1409      * PASSIVE_FOCUSED    | AF_TRIGGER                           | FOCUSED_LOCKED     | Immediate trans. Lens now locked
1410      * PASSIVE_UNFOCUSED  | AF_TRIGGER                           | NOT_FOCUSED_LOCKED | Immediate trans. Lens now locked
1411      * FOCUSED_LOCKED     | AF_TRIGGER                           | FOCUSED_LOCKED     | No effect
1412      * FOCUSED_LOCKED     | AF_CANCEL                            | INACTIVE           | Restart AF scan
1413      * NOT_FOCUSED_LOCKED | AF_TRIGGER                           | NOT_FOCUSED_LOCKED | No effect
1414      * NOT_FOCUSED_LOCKED | AF_CANCEL                            | INACTIVE           | Restart AF scan</p>
1415      * <p>When switch between AF_MODE_CONTINUOUS_* (CAF modes) and AF_MODE_AUTO/AF_MODE_MACRO
1416      * (AUTO modes), the initial INACTIVE or PASSIVE_SCAN states may be skipped by the
1417      * camera device. When a trigger is included in a mode switch request, the trigger
1418      * will be evaluated in the context of the new mode in the request.
1419      * See below table for examples:</p>
1420      * <p>State      | Transition Cause                       | New State                                | Notes
1421      * :-----------:|:--------------------------------------:|:----------------------------------------:|:--------------:
1422      * any state    | CAF--&gt;AUTO mode switch                 | INACTIVE                                 | Mode switch without trigger, initial state must be INACTIVE
1423      * any state    | CAF--&gt;AUTO mode switch with AF_TRIGGER | trigger-reachable states from INACTIVE   | Mode switch with trigger, INACTIVE is skipped
1424      * any state    | AUTO--&gt;CAF mode switch                 | passively reachable states from INACTIVE | Mode switch without trigger, passive transient state is skipped</p>
1425      *
1426      * @see ACAMERA_CONTROL_AF_MODE
1427      * @see ACAMERA_CONTROL_MODE
1428      * @see ACAMERA_CONTROL_SCENE_MODE
1429      */
1430     ACAMERA_CONTROL_AF_STATE =                                  // byte (acamera_metadata_enum_android_control_af_state_t)
1431             ACAMERA_CONTROL_START + 32,
1432     /**
1433      * <p>Current state of auto-white balance (AWB) algorithm.</p>
1434      *
1435      * <p>Type: byte (acamera_metadata_enum_android_control_awb_state_t)</p>
1436      *
1437      * <p>This tag may appear in:
1438      * <ul>
1439      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1440      * </ul></p>
1441      *
1442      * <p>Switching between or enabling AWB modes (ACAMERA_CONTROL_AWB_MODE) always
1443      * resets the AWB state to INACTIVE. Similarly, switching between ACAMERA_CONTROL_MODE,
1444      * or ACAMERA_CONTROL_SCENE_MODE if <code>ACAMERA_CONTROL_MODE == USE_SCENE_MODE</code> resets all
1445      * the algorithm states to INACTIVE.</p>
1446      * <p>The camera device can do several state transitions between two results, if it is
1447      * allowed by the state transition table. So INACTIVE may never actually be seen in
1448      * a result.</p>
1449      * <p>The state in the result is the state for this image (in sync with this image): if
1450      * AWB state becomes CONVERGED, then the image data associated with this result should
1451      * be good to use.</p>
1452      * <p>Below are state transition tables for different AWB modes.</p>
1453      * <p>When <code>ACAMERA_CONTROL_AWB_MODE != AWB_MODE_AUTO</code>:</p>
1454      * <p>State       | Transition Cause | New State | Notes
1455      * :------------:|:----------------:|:---------:|:-----------------------:
1456      * INACTIVE      |                  |INACTIVE   |Camera device auto white balance algorithm is disabled</p>
1457      * <p>When ACAMERA_CONTROL_AWB_MODE is AWB_MODE_AUTO:</p>
1458      * <p>State        | Transition Cause                 | New State     | Notes
1459      * :-------------:|:--------------------------------:|:-------------:|:-----------------:
1460      * INACTIVE       | Camera device initiates AWB scan | SEARCHING     | Values changing
1461      * INACTIVE       | ACAMERA_CONTROL_AWB_LOCK is ON    | LOCKED        | Values locked
1462      * SEARCHING      | Camera device finishes AWB scan  | CONVERGED     | Good values, not changing
1463      * SEARCHING      | ACAMERA_CONTROL_AWB_LOCK is ON    | LOCKED        | Values locked
1464      * CONVERGED      | Camera device initiates AWB scan | SEARCHING     | Values changing
1465      * CONVERGED      | ACAMERA_CONTROL_AWB_LOCK is ON    | LOCKED        | Values locked
1466      * LOCKED         | ACAMERA_CONTROL_AWB_LOCK is OFF   | SEARCHING     | Values not good after unlock</p>
1467      * <p>For the above table, the camera device may skip reporting any state changes that happen
1468      * without application intervention (i.e. mode switch, trigger, locking). Any state that
1469      * can be skipped in that manner is called a transient state.</p>
1470      * <p>For example, for this AWB mode (AWB_MODE_AUTO), in addition to the state transitions
1471      * listed in above table, it is also legal for the camera device to skip one or more
1472      * transient states between two results. See below table for examples:</p>
1473      * <p>State        | Transition Cause                 | New State     | Notes
1474      * :-------------:|:--------------------------------:|:-------------:|:-----------------:
1475      * INACTIVE       | Camera device finished AWB scan  | CONVERGED     | Values are already good, transient states are skipped by camera device.
1476      * LOCKED         | ACAMERA_CONTROL_AWB_LOCK is OFF   | CONVERGED     | Values good after unlock, transient states are skipped by camera device.</p>
1477      *
1478      * @see ACAMERA_CONTROL_AWB_LOCK
1479      * @see ACAMERA_CONTROL_AWB_MODE
1480      * @see ACAMERA_CONTROL_MODE
1481      * @see ACAMERA_CONTROL_SCENE_MODE
1482      */
1483     ACAMERA_CONTROL_AWB_STATE =                                 // byte (acamera_metadata_enum_android_control_awb_state_t)
1484             ACAMERA_CONTROL_START + 34,
1485     /**
1486      * <p>Whether the camera device supports ACAMERA_CONTROL_AE_LOCK</p>
1487      *
1488      * @see ACAMERA_CONTROL_AE_LOCK
1489      *
1490      * <p>Type: byte (acamera_metadata_enum_android_control_ae_lock_available_t)</p>
1491      *
1492      * <p>This tag may appear in:
1493      * <ul>
1494      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1495      * </ul></p>
1496      *
1497      * <p>Devices with MANUAL_SENSOR capability or BURST_CAPTURE capability will always
1498      * list <code>true</code>. This includes FULL devices.</p>
1499      */
1500     ACAMERA_CONTROL_AE_LOCK_AVAILABLE =                         // byte (acamera_metadata_enum_android_control_ae_lock_available_t)
1501             ACAMERA_CONTROL_START + 36,
1502     /**
1503      * <p>Whether the camera device supports ACAMERA_CONTROL_AWB_LOCK</p>
1504      *
1505      * @see ACAMERA_CONTROL_AWB_LOCK
1506      *
1507      * <p>Type: byte (acamera_metadata_enum_android_control_awb_lock_available_t)</p>
1508      *
1509      * <p>This tag may appear in:
1510      * <ul>
1511      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1512      * </ul></p>
1513      *
1514      * <p>Devices with MANUAL_POST_PROCESSING capability or BURST_CAPTURE capability will
1515      * always list <code>true</code>. This includes FULL devices.</p>
1516      */
1517     ACAMERA_CONTROL_AWB_LOCK_AVAILABLE =                        // byte (acamera_metadata_enum_android_control_awb_lock_available_t)
1518             ACAMERA_CONTROL_START + 37,
1519     /**
1520      * <p>List of control modes for ACAMERA_CONTROL_MODE that are supported by this camera
1521      * device.</p>
1522      *
1523      * @see ACAMERA_CONTROL_MODE
1524      *
1525      * <p>Type: byte[n]</p>
1526      *
1527      * <p>This tag may appear in:
1528      * <ul>
1529      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1530      * </ul></p>
1531      *
1532      * <p>This list contains control modes that can be set for the camera device.
1533      * LEGACY mode devices will always support AUTO mode. LIMITED and FULL
1534      * devices will always support OFF, AUTO modes.</p>
1535      */
1536     ACAMERA_CONTROL_AVAILABLE_MODES =                           // byte[n]
1537             ACAMERA_CONTROL_START + 38,
1538     /**
1539      * <p>Range of boosts for ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST supported
1540      * by this camera device.</p>
1541      *
1542      * @see ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST
1543      *
1544      * <p>Type: int32[2]</p>
1545      *
1546      * <p>This tag may appear in:
1547      * <ul>
1548      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1549      * </ul></p>
1550      *
1551      * <p>Devices support post RAW sensitivity boost  will advertise
1552      * ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST key for controling
1553      * post RAW sensitivity boost.</p>
1554      * <p>This key will be <code>null</code> for devices that do not support any RAW format
1555      * outputs. For devices that do support RAW format outputs, this key will always
1556      * present, and if a device does not support post RAW sensitivity boost, it will
1557      * list <code>(100, 100)</code> in this key.</p>
1558      *
1559      * @see ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST
1560      */
1561     ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE =          // int32[2]
1562             ACAMERA_CONTROL_START + 39,
1563     /**
1564      * <p>The amount of additional sensitivity boost applied to output images
1565      * after RAW sensor data is captured.</p>
1566      *
1567      * <p>Type: int32</p>
1568      *
1569      * <p>This tag may appear in:
1570      * <ul>
1571      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1572      *   <li>ACaptureRequest</li>
1573      * </ul></p>
1574      *
1575      * <p>Some camera devices support additional digital sensitivity boosting in the
1576      * camera processing pipeline after sensor RAW image is captured.
1577      * Such a boost will be applied to YUV/JPEG format output images but will not
1578      * have effect on RAW output formats like RAW_SENSOR, RAW10, RAW12 or RAW_OPAQUE.</p>
1579      * <p>This key will be <code>null</code> for devices that do not support any RAW format
1580      * outputs. For devices that do support RAW format outputs, this key will always
1581      * present, and if a device does not support post RAW sensitivity boost, it will
1582      * list <code>100</code> in this key.</p>
1583      * <p>If the camera device cannot apply the exact boost requested, it will reduce the
1584      * boost to the nearest supported value.
1585      * The final boost value used will be available in the output capture result.</p>
1586      * <p>For devices that support post RAW sensitivity boost, the YUV/JPEG output images
1587      * of such device will have the total sensitivity of
1588      * <code>ACAMERA_SENSOR_SENSITIVITY * ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST / 100</code>
1589      * The sensitivity of RAW format images will always be <code>ACAMERA_SENSOR_SENSITIVITY</code></p>
1590      * <p>This control is only effective if ACAMERA_CONTROL_AE_MODE or ACAMERA_CONTROL_MODE is set to
1591      * OFF; otherwise the auto-exposure algorithm will override this value.</p>
1592      *
1593      * @see ACAMERA_CONTROL_AE_MODE
1594      * @see ACAMERA_CONTROL_MODE
1595      * @see ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST
1596      * @see ACAMERA_SENSOR_SENSITIVITY
1597      */
1598     ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST =                // int32
1599             ACAMERA_CONTROL_START + 40,
1600     /**
1601      * <p>Allow camera device to enable zero-shutter-lag mode for requests with
1602      * ACAMERA_CONTROL_CAPTURE_INTENT == STILL_CAPTURE.</p>
1603      *
1604      * @see ACAMERA_CONTROL_CAPTURE_INTENT
1605      *
1606      * <p>Type: byte (acamera_metadata_enum_android_control_enable_zsl_t)</p>
1607      *
1608      * <p>This tag may appear in:
1609      * <ul>
1610      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1611      *   <li>ACaptureRequest</li>
1612      * </ul></p>
1613      *
1614      * <p>If enableZsl is <code>true</code>, the camera device may enable zero-shutter-lag mode for requests with
1615      * STILL_CAPTURE capture intent. The camera device may use images captured in the past to
1616      * produce output images for a zero-shutter-lag request. The result metadata including the
1617      * ACAMERA_SENSOR_TIMESTAMP reflects the source frames used to produce output images.
1618      * Therefore, the contents of the output images and the result metadata may be out of order
1619      * compared to previous regular requests. enableZsl does not affect requests with other
1620      * capture intents.</p>
1621      * <p>For example, when requests are submitted in the following order:
1622      *   Request A: enableZsl is <code>true</code>, ACAMERA_CONTROL_CAPTURE_INTENT is PREVIEW
1623      *   Request B: enableZsl is <code>true</code>, ACAMERA_CONTROL_CAPTURE_INTENT is STILL_CAPTURE</p>
1624      * <p>The output images for request B may have contents captured before the output images for
1625      * request A, and the result metadata for request B may be older than the result metadata for
1626      * request A.</p>
1627      * <p>Note that when enableZsl is <code>true</code>, it is not guaranteed to get output images captured in the
1628      * past for requests with STILL_CAPTURE capture intent.</p>
1629      * <p>For applications targeting SDK versions O and newer, the value of enableZsl in
1630      * TEMPLATE_STILL_CAPTURE template may be <code>true</code>. The value in other templates is always
1631      * <code>false</code> if present.</p>
1632      * <p>For applications targeting SDK versions older than O, the value of enableZsl in all
1633      * capture templates is always <code>false</code> if present.</p>
1634      * <p>For application-operated ZSL, use CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG template.</p>
1635      *
1636      * @see ACAMERA_CONTROL_CAPTURE_INTENT
1637      * @see ACAMERA_SENSOR_TIMESTAMP
1638      */
1639     ACAMERA_CONTROL_ENABLE_ZSL =                                // byte (acamera_metadata_enum_android_control_enable_zsl_t)
1640             ACAMERA_CONTROL_START + 41,
1641     ACAMERA_CONTROL_END,
1642 
1643     /**
1644      * <p>Operation mode for edge
1645      * enhancement.</p>
1646      *
1647      * <p>Type: byte (acamera_metadata_enum_android_edge_mode_t)</p>
1648      *
1649      * <p>This tag may appear in:
1650      * <ul>
1651      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1652      *   <li>ACaptureRequest</li>
1653      * </ul></p>
1654      *
1655      * <p>Edge enhancement improves sharpness and details in the captured image. OFF means
1656      * no enhancement will be applied by the camera device.</p>
1657      * <p>FAST/HIGH_QUALITY both mean camera device determined enhancement
1658      * will be applied. HIGH_QUALITY mode indicates that the
1659      * camera device will use the highest-quality enhancement algorithms,
1660      * even if it slows down capture rate. FAST means the camera device will
1661      * not slow down capture rate when applying edge enhancement. FAST may be the same as OFF if
1662      * edge enhancement will slow down capture rate. Every output stream will have a similar
1663      * amount of enhancement applied.</p>
1664      * <p>ZERO_SHUTTER_LAG is meant to be used by applications that maintain a continuous circular
1665      * buffer of high-resolution images during preview and reprocess image(s) from that buffer
1666      * into a final capture when triggered by the user. In this mode, the camera device applies
1667      * edge enhancement to low-resolution streams (below maximum recording resolution) to
1668      * maximize preview quality, but does not apply edge enhancement to high-resolution streams,
1669      * since those will be reprocessed later if necessary.</p>
1670      * <p>For YUV_REPROCESSING, these FAST/HIGH_QUALITY modes both mean that the camera
1671      * device will apply FAST/HIGH_QUALITY YUV-domain edge enhancement, respectively.
1672      * The camera device may adjust its internal edge enhancement parameters for best
1673      * image quality based on the android.reprocess.effectiveExposureFactor, if it is set.</p>
1674      */
1675     ACAMERA_EDGE_MODE =                                         // byte (acamera_metadata_enum_android_edge_mode_t)
1676             ACAMERA_EDGE_START,
1677     /**
1678      * <p>List of edge enhancement modes for ACAMERA_EDGE_MODE that are supported by this camera
1679      * device.</p>
1680      *
1681      * @see ACAMERA_EDGE_MODE
1682      *
1683      * <p>Type: byte[n]</p>
1684      *
1685      * <p>This tag may appear in:
1686      * <ul>
1687      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1688      * </ul></p>
1689      *
1690      * <p>Full-capability camera devices must always support OFF; camera devices that support
1691      * YUV_REPROCESSING or PRIVATE_REPROCESSING will list ZERO_SHUTTER_LAG; all devices will
1692      * list FAST.</p>
1693      */
1694     ACAMERA_EDGE_AVAILABLE_EDGE_MODES =                         // byte[n]
1695             ACAMERA_EDGE_START + 2,
1696     ACAMERA_EDGE_END,
1697 
1698     /**
1699      * <p>The desired mode for for the camera device's flash control.</p>
1700      *
1701      * <p>Type: byte (acamera_metadata_enum_android_flash_mode_t)</p>
1702      *
1703      * <p>This tag may appear in:
1704      * <ul>
1705      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1706      *   <li>ACaptureRequest</li>
1707      * </ul></p>
1708      *
1709      * <p>This control is only effective when flash unit is available
1710      * (<code>ACAMERA_FLASH_INFO_AVAILABLE == true</code>).</p>
1711      * <p>When this control is used, the ACAMERA_CONTROL_AE_MODE must be set to ON or OFF.
1712      * Otherwise, the camera device auto-exposure related flash control (ON_AUTO_FLASH,
1713      * ON_ALWAYS_FLASH, or ON_AUTO_FLASH_REDEYE) will override this control.</p>
1714      * <p>When set to OFF, the camera device will not fire flash for this capture.</p>
1715      * <p>When set to SINGLE, the camera device will fire flash regardless of the camera
1716      * device's auto-exposure routine's result. When used in still capture case, this
1717      * control should be used along with auto-exposure (AE) precapture metering sequence
1718      * (ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER), otherwise, the image may be incorrectly exposed.</p>
1719      * <p>When set to TORCH, the flash will be on continuously. This mode can be used
1720      * for use cases such as preview, auto-focus assist, still capture, or video recording.</p>
1721      * <p>The flash status will be reported by ACAMERA_FLASH_STATE in the capture result metadata.</p>
1722      *
1723      * @see ACAMERA_CONTROL_AE_MODE
1724      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
1725      * @see ACAMERA_FLASH_INFO_AVAILABLE
1726      * @see ACAMERA_FLASH_STATE
1727      */
1728     ACAMERA_FLASH_MODE =                                        // byte (acamera_metadata_enum_android_flash_mode_t)
1729             ACAMERA_FLASH_START + 2,
1730     /**
1731      * <p>Current state of the flash
1732      * unit.</p>
1733      *
1734      * <p>Type: byte (acamera_metadata_enum_android_flash_state_t)</p>
1735      *
1736      * <p>This tag may appear in:
1737      * <ul>
1738      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1739      * </ul></p>
1740      *
1741      * <p>When the camera device doesn't have flash unit
1742      * (i.e. <code>ACAMERA_FLASH_INFO_AVAILABLE == false</code>), this state will always be UNAVAILABLE.
1743      * Other states indicate the current flash status.</p>
1744      * <p>In certain conditions, this will be available on LEGACY devices:</p>
1745      * <ul>
1746      * <li>Flash-less cameras always return UNAVAILABLE.</li>
1747      * <li>Using ACAMERA_CONTROL_AE_MODE <code>==</code> ON_ALWAYS_FLASH
1748      *    will always return FIRED.</li>
1749      * <li>Using ACAMERA_FLASH_MODE <code>==</code> TORCH
1750      *    will always return FIRED.</li>
1751      * </ul>
1752      * <p>In all other conditions the state will not be available on
1753      * LEGACY devices (i.e. it will be <code>null</code>).</p>
1754      *
1755      * @see ACAMERA_CONTROL_AE_MODE
1756      * @see ACAMERA_FLASH_INFO_AVAILABLE
1757      * @see ACAMERA_FLASH_MODE
1758      */
1759     ACAMERA_FLASH_STATE =                                       // byte (acamera_metadata_enum_android_flash_state_t)
1760             ACAMERA_FLASH_START + 5,
1761     ACAMERA_FLASH_END,
1762 
1763     /**
1764      * <p>Whether this camera device has a
1765      * flash unit.</p>
1766      *
1767      * <p>Type: byte (acamera_metadata_enum_android_flash_info_available_t)</p>
1768      *
1769      * <p>This tag may appear in:
1770      * <ul>
1771      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1772      * </ul></p>
1773      *
1774      * <p>Will be <code>false</code> if no flash is available.</p>
1775      * <p>If there is no flash unit, none of the flash controls do
1776      * anything.</p>
1777      */
1778     ACAMERA_FLASH_INFO_AVAILABLE =                              // byte (acamera_metadata_enum_android_flash_info_available_t)
1779             ACAMERA_FLASH_INFO_START,
1780     ACAMERA_FLASH_INFO_END,
1781 
1782     /**
1783      * <p>Operational mode for hot pixel correction.</p>
1784      *
1785      * <p>Type: byte (acamera_metadata_enum_android_hot_pixel_mode_t)</p>
1786      *
1787      * <p>This tag may appear in:
1788      * <ul>
1789      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1790      *   <li>ACaptureRequest</li>
1791      * </ul></p>
1792      *
1793      * <p>Hotpixel correction interpolates out, or otherwise removes, pixels
1794      * that do not accurately measure the incoming light (i.e. pixels that
1795      * are stuck at an arbitrary value or are oversensitive).</p>
1796      */
1797     ACAMERA_HOT_PIXEL_MODE =                                    // byte (acamera_metadata_enum_android_hot_pixel_mode_t)
1798             ACAMERA_HOT_PIXEL_START,
1799     /**
1800      * <p>List of hot pixel correction modes for ACAMERA_HOT_PIXEL_MODE that are supported by this
1801      * camera device.</p>
1802      *
1803      * @see ACAMERA_HOT_PIXEL_MODE
1804      *
1805      * <p>Type: byte[n]</p>
1806      *
1807      * <p>This tag may appear in:
1808      * <ul>
1809      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1810      * </ul></p>
1811      *
1812      * <p>FULL mode camera devices will always support FAST.</p>
1813      */
1814     ACAMERA_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES =               // byte[n]
1815             ACAMERA_HOT_PIXEL_START + 1,
1816     ACAMERA_HOT_PIXEL_END,
1817 
1818     /**
1819      * <p>GPS coordinates to include in output JPEG
1820      * EXIF.</p>
1821      *
1822      * <p>Type: double[3]</p>
1823      *
1824      * <p>This tag may appear in:
1825      * <ul>
1826      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1827      *   <li>ACaptureRequest</li>
1828      * </ul></p>
1829      *
1830      */
1831     ACAMERA_JPEG_GPS_COORDINATES =                              // double[3]
1832             ACAMERA_JPEG_START,
1833     /**
1834      * <p>32 characters describing GPS algorithm to
1835      * include in EXIF.</p>
1836      *
1837      * <p>Type: byte</p>
1838      *
1839      * <p>This tag may appear in:
1840      * <ul>
1841      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1842      *   <li>ACaptureRequest</li>
1843      * </ul></p>
1844      *
1845      */
1846     ACAMERA_JPEG_GPS_PROCESSING_METHOD =                        // byte
1847             ACAMERA_JPEG_START + 1,
1848     /**
1849      * <p>Time GPS fix was made to include in
1850      * EXIF.</p>
1851      *
1852      * <p>Type: int64</p>
1853      *
1854      * <p>This tag may appear in:
1855      * <ul>
1856      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1857      *   <li>ACaptureRequest</li>
1858      * </ul></p>
1859      *
1860      */
1861     ACAMERA_JPEG_GPS_TIMESTAMP =                                // int64
1862             ACAMERA_JPEG_START + 2,
1863     /**
1864      * <p>The orientation for a JPEG image.</p>
1865      *
1866      * <p>Type: int32</p>
1867      *
1868      * <p>This tag may appear in:
1869      * <ul>
1870      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1871      *   <li>ACaptureRequest</li>
1872      * </ul></p>
1873      *
1874      * <p>The clockwise rotation angle in degrees, relative to the orientation
1875      * to the camera, that the JPEG picture needs to be rotated by, to be viewed
1876      * upright.</p>
1877      * <p>Camera devices may either encode this value into the JPEG EXIF header, or
1878      * rotate the image data to match this orientation. When the image data is rotated,
1879      * the thumbnail data will also be rotated.</p>
1880      * <p>Note that this orientation is relative to the orientation of the camera sensor, given
1881      * by ACAMERA_SENSOR_ORIENTATION.</p>
1882      * <p>To translate from the device orientation given by the Android sensor APIs, the following
1883      * sample code may be used:</p>
1884      * <pre><code>private int getJpegOrientation(CameraCharacteristics c, int deviceOrientation) {
1885      *     if (deviceOrientation == android.view.OrientationEventListener.ORIENTATION_UNKNOWN) return 0;
1886      *     int sensorOrientation = c.get(CameraCharacteristics.SENSOR_ORIENTATION);
1887      *
1888      *     // Round device orientation to a multiple of 90
1889      *     deviceOrientation = (deviceOrientation + 45) / 90 * 90;
1890      *
1891      *     // Reverse device orientation for front-facing cameras
1892      *     boolean facingFront = c.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT;
1893      *     if (facingFront) deviceOrientation = -deviceOrientation;
1894      *
1895      *     // Calculate desired JPEG orientation relative to camera orientation to make
1896      *     // the image upright relative to the device orientation
1897      *     int jpegOrientation = (sensorOrientation + deviceOrientation + 360) % 360;
1898      *
1899      *     return jpegOrientation;
1900      * }
1901      * </code></pre>
1902      *
1903      * @see ACAMERA_SENSOR_ORIENTATION
1904      */
1905     ACAMERA_JPEG_ORIENTATION =                                  // int32
1906             ACAMERA_JPEG_START + 3,
1907     /**
1908      * <p>Compression quality of the final JPEG
1909      * image.</p>
1910      *
1911      * <p>Type: byte</p>
1912      *
1913      * <p>This tag may appear in:
1914      * <ul>
1915      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1916      *   <li>ACaptureRequest</li>
1917      * </ul></p>
1918      *
1919      * <p>85-95 is typical usage range.</p>
1920      */
1921     ACAMERA_JPEG_QUALITY =                                      // byte
1922             ACAMERA_JPEG_START + 4,
1923     /**
1924      * <p>Compression quality of JPEG
1925      * thumbnail.</p>
1926      *
1927      * <p>Type: byte</p>
1928      *
1929      * <p>This tag may appear in:
1930      * <ul>
1931      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1932      *   <li>ACaptureRequest</li>
1933      * </ul></p>
1934      *
1935      */
1936     ACAMERA_JPEG_THUMBNAIL_QUALITY =                            // byte
1937             ACAMERA_JPEG_START + 5,
1938     /**
1939      * <p>Resolution of embedded JPEG thumbnail.</p>
1940      *
1941      * <p>Type: int32[2]</p>
1942      *
1943      * <p>This tag may appear in:
1944      * <ul>
1945      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
1946      *   <li>ACaptureRequest</li>
1947      * </ul></p>
1948      *
1949      * <p>When set to (0, 0) value, the JPEG EXIF will not contain thumbnail,
1950      * but the captured JPEG will still be a valid image.</p>
1951      * <p>For best results, when issuing a request for a JPEG image, the thumbnail size selected
1952      * should have the same aspect ratio as the main JPEG output.</p>
1953      * <p>If the thumbnail image aspect ratio differs from the JPEG primary image aspect
1954      * ratio, the camera device creates the thumbnail by cropping it from the primary image.
1955      * For example, if the primary image has 4:3 aspect ratio, the thumbnail image has
1956      * 16:9 aspect ratio, the primary image will be cropped vertically (letterbox) to
1957      * generate the thumbnail image. The thumbnail image will always have a smaller Field
1958      * Of View (FOV) than the primary image when aspect ratios differ.</p>
1959      * <p>When an ACAMERA_JPEG_ORIENTATION of non-zero degree is requested,
1960      * the camera device will handle thumbnail rotation in one of the following ways:</p>
1961      * <ul>
1962      * <li>Set the
1963      *   <a href="https://developer.android.com/reference/android/media/ExifInterface.html#TAG_ORIENTATION">EXIF orientation flag</a>
1964      *   and keep jpeg and thumbnail image data unrotated.</li>
1965      * <li>Rotate the jpeg and thumbnail image data and not set
1966      *   <a href="https://developer.android.com/reference/android/media/ExifInterface.html#TAG_ORIENTATION">EXIF orientation flag</a>.
1967      *   In this case, LIMITED or FULL hardware level devices will report rotated thumnail size
1968      *   in capture result, so the width and height will be interchanged if 90 or 270 degree
1969      *   orientation is requested. LEGACY device will always report unrotated thumbnail size.</li>
1970      * </ul>
1971      *
1972      * @see ACAMERA_JPEG_ORIENTATION
1973      */
1974     ACAMERA_JPEG_THUMBNAIL_SIZE =                               // int32[2]
1975             ACAMERA_JPEG_START + 6,
1976     /**
1977      * <p>List of JPEG thumbnail sizes for ACAMERA_JPEG_THUMBNAIL_SIZE supported by this
1978      * camera device.</p>
1979      *
1980      * @see ACAMERA_JPEG_THUMBNAIL_SIZE
1981      *
1982      * <p>Type: int32[2*n]</p>
1983      *
1984      * <p>This tag may appear in:
1985      * <ul>
1986      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
1987      * </ul></p>
1988      *
1989      * <p>This list will include at least one non-zero resolution, plus <code>(0,0)</code> for indicating no
1990      * thumbnail should be generated.</p>
1991      * <p>Below condiditions will be satisfied for this size list:</p>
1992      * <ul>
1993      * <li>The sizes will be sorted by increasing pixel area (width x height).
1994      * If several resolutions have the same area, they will be sorted by increasing width.</li>
1995      * <li>The aspect ratio of the largest thumbnail size will be same as the
1996      * aspect ratio of largest JPEG output size in ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS.
1997      * The largest size is defined as the size that has the largest pixel area
1998      * in a given size list.</li>
1999      * <li>Each output JPEG size in ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS will have at least
2000      * one corresponding size that has the same aspect ratio in availableThumbnailSizes,
2001      * and vice versa.</li>
2002      * <li>All non-<code>(0, 0)</code> sizes will have non-zero widths and heights.</li>
2003      * </ul>
2004      *
2005      * @see ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
2006      */
2007     ACAMERA_JPEG_AVAILABLE_THUMBNAIL_SIZES =                    // int32[2*n]
2008             ACAMERA_JPEG_START + 7,
2009     ACAMERA_JPEG_END,
2010 
2011     /**
2012      * <p>The desired lens aperture size, as a ratio of lens focal length to the
2013      * effective aperture diameter.</p>
2014      *
2015      * <p>Type: float</p>
2016      *
2017      * <p>This tag may appear in:
2018      * <ul>
2019      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2020      *   <li>ACaptureRequest</li>
2021      * </ul></p>
2022      *
2023      * <p>Setting this value is only supported on the camera devices that have a variable
2024      * aperture lens.</p>
2025      * <p>When this is supported and ACAMERA_CONTROL_AE_MODE is OFF,
2026      * this can be set along with ACAMERA_SENSOR_EXPOSURE_TIME,
2027      * ACAMERA_SENSOR_SENSITIVITY, and ACAMERA_SENSOR_FRAME_DURATION
2028      * to achieve manual exposure control.</p>
2029      * <p>The requested aperture value may take several frames to reach the
2030      * requested value; the camera device will report the current (intermediate)
2031      * aperture size in capture result metadata while the aperture is changing.
2032      * While the aperture is still changing, ACAMERA_LENS_STATE will be set to MOVING.</p>
2033      * <p>When this is supported and ACAMERA_CONTROL_AE_MODE is one of
2034      * the ON modes, this will be overridden by the camera device
2035      * auto-exposure algorithm, the overridden values are then provided
2036      * back to the user in the corresponding result.</p>
2037      *
2038      * @see ACAMERA_CONTROL_AE_MODE
2039      * @see ACAMERA_LENS_STATE
2040      * @see ACAMERA_SENSOR_EXPOSURE_TIME
2041      * @see ACAMERA_SENSOR_FRAME_DURATION
2042      * @see ACAMERA_SENSOR_SENSITIVITY
2043      */
2044     ACAMERA_LENS_APERTURE =                                     // float
2045             ACAMERA_LENS_START,
2046     /**
2047      * <p>The desired setting for the lens neutral density filter(s).</p>
2048      *
2049      * <p>Type: float</p>
2050      *
2051      * <p>This tag may appear in:
2052      * <ul>
2053      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2054      *   <li>ACaptureRequest</li>
2055      * </ul></p>
2056      *
2057      * <p>This control will not be supported on most camera devices.</p>
2058      * <p>Lens filters are typically used to lower the amount of light the
2059      * sensor is exposed to (measured in steps of EV). As used here, an EV
2060      * step is the standard logarithmic representation, which are
2061      * non-negative, and inversely proportional to the amount of light
2062      * hitting the sensor.  For example, setting this to 0 would result
2063      * in no reduction of the incoming light, and setting this to 2 would
2064      * mean that the filter is set to reduce incoming light by two stops
2065      * (allowing 1/4 of the prior amount of light to the sensor).</p>
2066      * <p>It may take several frames before the lens filter density changes
2067      * to the requested value. While the filter density is still changing,
2068      * ACAMERA_LENS_STATE will be set to MOVING.</p>
2069      *
2070      * @see ACAMERA_LENS_STATE
2071      */
2072     ACAMERA_LENS_FILTER_DENSITY =                               // float
2073             ACAMERA_LENS_START + 1,
2074     /**
2075      * <p>The desired lens focal length; used for optical zoom.</p>
2076      *
2077      * <p>Type: float</p>
2078      *
2079      * <p>This tag may appear in:
2080      * <ul>
2081      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2082      *   <li>ACaptureRequest</li>
2083      * </ul></p>
2084      *
2085      * <p>This setting controls the physical focal length of the camera
2086      * device's lens. Changing the focal length changes the field of
2087      * view of the camera device, and is usually used for optical zoom.</p>
2088      * <p>Like ACAMERA_LENS_FOCUS_DISTANCE and ACAMERA_LENS_APERTURE, this
2089      * setting won't be applied instantaneously, and it may take several
2090      * frames before the lens can change to the requested focal length.
2091      * While the focal length is still changing, ACAMERA_LENS_STATE will
2092      * be set to MOVING.</p>
2093      * <p>Optical zoom will not be supported on most devices.</p>
2094      *
2095      * @see ACAMERA_LENS_APERTURE
2096      * @see ACAMERA_LENS_FOCUS_DISTANCE
2097      * @see ACAMERA_LENS_STATE
2098      */
2099     ACAMERA_LENS_FOCAL_LENGTH =                                 // float
2100             ACAMERA_LENS_START + 2,
2101     /**
2102      * <p>Desired distance to plane of sharpest focus,
2103      * measured from frontmost surface of the lens.</p>
2104      *
2105      * <p>Type: float</p>
2106      *
2107      * <p>This tag may appear in:
2108      * <ul>
2109      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2110      *   <li>ACaptureRequest</li>
2111      * </ul></p>
2112      *
2113      * <p>Should be zero for fixed-focus cameras</p>
2114      */
2115     ACAMERA_LENS_FOCUS_DISTANCE =                               // float
2116             ACAMERA_LENS_START + 3,
2117     /**
2118      * <p>Sets whether the camera device uses optical image stabilization (OIS)
2119      * when capturing images.</p>
2120      *
2121      * <p>Type: byte (acamera_metadata_enum_android_lens_optical_stabilization_mode_t)</p>
2122      *
2123      * <p>This tag may appear in:
2124      * <ul>
2125      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2126      *   <li>ACaptureRequest</li>
2127      * </ul></p>
2128      *
2129      * <p>OIS is used to compensate for motion blur due to small
2130      * movements of the camera during capture. Unlike digital image
2131      * stabilization (ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE), OIS
2132      * makes use of mechanical elements to stabilize the camera
2133      * sensor, and thus allows for longer exposure times before
2134      * camera shake becomes apparent.</p>
2135      * <p>Switching between different optical stabilization modes may take several
2136      * frames to initialize, the camera device will report the current mode in
2137      * capture result metadata. For example, When "ON" mode is requested, the
2138      * optical stabilization modes in the first several capture results may still
2139      * be "OFF", and it will become "ON" when the initialization is done.</p>
2140      * <p>If a camera device supports both OIS and digital image stabilization
2141      * (ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE), turning both modes on may produce undesirable
2142      * interaction, so it is recommended not to enable both at the same time.</p>
2143      * <p>Not all devices will support OIS; see
2144      * ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION for
2145      * available controls.</p>
2146      *
2147      * @see ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
2148      * @see ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION
2149      */
2150     ACAMERA_LENS_OPTICAL_STABILIZATION_MODE =                   // byte (acamera_metadata_enum_android_lens_optical_stabilization_mode_t)
2151             ACAMERA_LENS_START + 4,
2152     /**
2153      * <p>Direction the camera faces relative to
2154      * device screen.</p>
2155      *
2156      * <p>Type: byte (acamera_metadata_enum_android_lens_facing_t)</p>
2157      *
2158      * <p>This tag may appear in:
2159      * <ul>
2160      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2161      * </ul></p>
2162      *
2163      */
2164     ACAMERA_LENS_FACING =                                       // byte (acamera_metadata_enum_android_lens_facing_t)
2165             ACAMERA_LENS_START + 5,
2166     /**
2167      * <p>The orientation of the camera relative to the sensor
2168      * coordinate system.</p>
2169      *
2170      * <p>Type: float[4]</p>
2171      *
2172      * <p>This tag may appear in:
2173      * <ul>
2174      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2175      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2176      * </ul></p>
2177      *
2178      * <p>The four coefficients that describe the quaternion
2179      * rotation from the Android sensor coordinate system to a
2180      * camera-aligned coordinate system where the X-axis is
2181      * aligned with the long side of the image sensor, the Y-axis
2182      * is aligned with the short side of the image sensor, and
2183      * the Z-axis is aligned with the optical axis of the sensor.</p>
2184      * <p>To convert from the quaternion coefficients <code>(x,y,z,w)</code>
2185      * to the axis of rotation <code>(a_x, a_y, a_z)</code> and rotation
2186      * amount <code>theta</code>, the following formulas can be used:</p>
2187      * <pre><code> theta = 2 * acos(w)
2188      * a_x = x / sin(theta/2)
2189      * a_y = y / sin(theta/2)
2190      * a_z = z / sin(theta/2)
2191      * </code></pre>
2192      * <p>To create a 3x3 rotation matrix that applies the rotation
2193      * defined by this quaternion, the following matrix can be
2194      * used:</p>
2195      * <pre><code>R = [ 1 - 2y^2 - 2z^2,       2xy - 2zw,       2xz + 2yw,
2196      *            2xy + 2zw, 1 - 2x^2 - 2z^2,       2yz - 2xw,
2197      *            2xz - 2yw,       2yz + 2xw, 1 - 2x^2 - 2y^2 ]
2198      * </code></pre>
2199      * <p>This matrix can then be used to apply the rotation to a
2200      *  column vector point with</p>
2201      * <p><code>p' = Rp</code></p>
2202      * <p>where <code>p</code> is in the device sensor coordinate system, and
2203      *  <code>p'</code> is in the camera-oriented coordinate system.</p>
2204      */
2205     ACAMERA_LENS_POSE_ROTATION =                                // float[4]
2206             ACAMERA_LENS_START + 6,
2207     /**
2208      * <p>Position of the camera optical center.</p>
2209      *
2210      * <p>Type: float[3]</p>
2211      *
2212      * <p>This tag may appear in:
2213      * <ul>
2214      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2215      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2216      * </ul></p>
2217      *
2218      * <p>The position of the camera device's lens optical center,
2219      * as a three-dimensional vector <code>(x,y,z)</code>, relative to the
2220      * optical center of the largest camera device facing in the
2221      * same direction as this camera, in the
2222      * <a href="https://developer.android.com/reference/android/hardware/SensorEvent.html">Android sensor coordinate axes</a>.
2223      * Note that only the axis definitions are shared with
2224      * the sensor coordinate system, but not the origin.</p>
2225      * <p>If this device is the largest or only camera device with a
2226      * given facing, then this position will be <code>(0, 0, 0)</code>; a
2227      * camera device with a lens optical center located 3 cm from
2228      * the main sensor along the +X axis (to the right from the
2229      * user's perspective) will report <code>(0.03, 0, 0)</code>.</p>
2230      * <p>To transform a pixel coordinates between two cameras
2231      * facing the same direction, first the source camera
2232      * ACAMERA_LENS_RADIAL_DISTORTION must be corrected for.  Then
2233      * the source camera ACAMERA_LENS_INTRINSIC_CALIBRATION needs
2234      * to be applied, followed by the ACAMERA_LENS_POSE_ROTATION
2235      * of the source camera, the translation of the source camera
2236      * relative to the destination camera, the
2237      * ACAMERA_LENS_POSE_ROTATION of the destination camera, and
2238      * finally the inverse of ACAMERA_LENS_INTRINSIC_CALIBRATION
2239      * of the destination camera. This obtains a
2240      * radial-distortion-free coordinate in the destination
2241      * camera pixel coordinates.</p>
2242      * <p>To compare this against a real image from the destination
2243      * camera, the destination camera image then needs to be
2244      * corrected for radial distortion before comparison or
2245      * sampling.</p>
2246      *
2247      * @see ACAMERA_LENS_INTRINSIC_CALIBRATION
2248      * @see ACAMERA_LENS_POSE_ROTATION
2249      * @see ACAMERA_LENS_RADIAL_DISTORTION
2250      */
2251     ACAMERA_LENS_POSE_TRANSLATION =                             // float[3]
2252             ACAMERA_LENS_START + 7,
2253     /**
2254      * <p>The range of scene distances that are in
2255      * sharp focus (depth of field).</p>
2256      *
2257      * <p>Type: float[2]</p>
2258      *
2259      * <p>This tag may appear in:
2260      * <ul>
2261      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2262      * </ul></p>
2263      *
2264      * <p>If variable focus not supported, can still report
2265      * fixed depth of field range</p>
2266      */
2267     ACAMERA_LENS_FOCUS_RANGE =                                  // float[2]
2268             ACAMERA_LENS_START + 8,
2269     /**
2270      * <p>Current lens status.</p>
2271      *
2272      * <p>Type: byte (acamera_metadata_enum_android_lens_state_t)</p>
2273      *
2274      * <p>This tag may appear in:
2275      * <ul>
2276      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2277      * </ul></p>
2278      *
2279      * <p>For lens parameters ACAMERA_LENS_FOCAL_LENGTH, ACAMERA_LENS_FOCUS_DISTANCE,
2280      * ACAMERA_LENS_FILTER_DENSITY and ACAMERA_LENS_APERTURE, when changes are requested,
2281      * they may take several frames to reach the requested values. This state indicates
2282      * the current status of the lens parameters.</p>
2283      * <p>When the state is STATIONARY, the lens parameters are not changing. This could be
2284      * either because the parameters are all fixed, or because the lens has had enough
2285      * time to reach the most recently-requested values.
2286      * If all these lens parameters are not changable for a camera device, as listed below:</p>
2287      * <ul>
2288      * <li>Fixed focus (<code>ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE == 0</code>), which means
2289      * ACAMERA_LENS_FOCUS_DISTANCE parameter will always be 0.</li>
2290      * <li>Fixed focal length (ACAMERA_LENS_INFO_AVAILABLE_FOCAL_LENGTHS contains single value),
2291      * which means the optical zoom is not supported.</li>
2292      * <li>No ND filter (ACAMERA_LENS_INFO_AVAILABLE_FILTER_DENSITIES contains only 0).</li>
2293      * <li>Fixed aperture (ACAMERA_LENS_INFO_AVAILABLE_APERTURES contains single value).</li>
2294      * </ul>
2295      * <p>Then this state will always be STATIONARY.</p>
2296      * <p>When the state is MOVING, it indicates that at least one of the lens parameters
2297      * is changing.</p>
2298      *
2299      * @see ACAMERA_LENS_APERTURE
2300      * @see ACAMERA_LENS_FILTER_DENSITY
2301      * @see ACAMERA_LENS_FOCAL_LENGTH
2302      * @see ACAMERA_LENS_FOCUS_DISTANCE
2303      * @see ACAMERA_LENS_INFO_AVAILABLE_APERTURES
2304      * @see ACAMERA_LENS_INFO_AVAILABLE_FILTER_DENSITIES
2305      * @see ACAMERA_LENS_INFO_AVAILABLE_FOCAL_LENGTHS
2306      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
2307      */
2308     ACAMERA_LENS_STATE =                                        // byte (acamera_metadata_enum_android_lens_state_t)
2309             ACAMERA_LENS_START + 9,
2310     /**
2311      * <p>The parameters for this camera device's intrinsic
2312      * calibration.</p>
2313      *
2314      * <p>Type: float[5]</p>
2315      *
2316      * <p>This tag may appear in:
2317      * <ul>
2318      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2319      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2320      * </ul></p>
2321      *
2322      * <p>The five calibration parameters that describe the
2323      * transform from camera-centric 3D coordinates to sensor
2324      * pixel coordinates:</p>
2325      * <pre><code>[f_x, f_y, c_x, c_y, s]
2326      * </code></pre>
2327      * <p>Where <code>f_x</code> and <code>f_y</code> are the horizontal and vertical
2328      * focal lengths, <code>[c_x, c_y]</code> is the position of the optical
2329      * axis, and <code>s</code> is a skew parameter for the sensor plane not
2330      * being aligned with the lens plane.</p>
2331      * <p>These are typically used within a transformation matrix K:</p>
2332      * <pre><code>K = [ f_x,   s, c_x,
2333      *        0, f_y, c_y,
2334      *        0    0,   1 ]
2335      * </code></pre>
2336      * <p>which can then be combined with the camera pose rotation
2337      * <code>R</code> and translation <code>t</code> (ACAMERA_LENS_POSE_ROTATION and
2338      * ACAMERA_LENS_POSE_TRANSLATION, respective) to calculate the
2339      * complete transform from world coordinates to pixel
2340      * coordinates:</p>
2341      * <pre><code>P = [ K 0   * [ R t
2342      *      0 1 ]     0 1 ]
2343      * </code></pre>
2344      * <p>and with <code>p_w</code> being a point in the world coordinate system
2345      * and <code>p_s</code> being a point in the camera active pixel array
2346      * coordinate system, and with the mapping including the
2347      * homogeneous division by z:</p>
2348      * <pre><code> p_h = (x_h, y_h, z_h) = P p_w
2349      * p_s = p_h / z_h
2350      * </code></pre>
2351      * <p>so <code>[x_s, y_s]</code> is the pixel coordinates of the world
2352      * point, <code>z_s = 1</code>, and <code>w_s</code> is a measurement of disparity
2353      * (depth) in pixel coordinates.</p>
2354      * <p>Note that the coordinate system for this transform is the
2355      * ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE system,
2356      * where <code>(0,0)</code> is the top-left of the
2357      * preCorrectionActiveArraySize rectangle. Once the pose and
2358      * intrinsic calibration transforms have been applied to a
2359      * world point, then the ACAMERA_LENS_RADIAL_DISTORTION
2360      * transform needs to be applied, and the result adjusted to
2361      * be in the ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE coordinate
2362      * system (where <code>(0, 0)</code> is the top-left of the
2363      * activeArraySize rectangle), to determine the final pixel
2364      * coordinate of the world point for processed (non-RAW)
2365      * output buffers.</p>
2366      *
2367      * @see ACAMERA_LENS_POSE_ROTATION
2368      * @see ACAMERA_LENS_POSE_TRANSLATION
2369      * @see ACAMERA_LENS_RADIAL_DISTORTION
2370      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
2371      * @see ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE
2372      */
2373     ACAMERA_LENS_INTRINSIC_CALIBRATION =                        // float[5]
2374             ACAMERA_LENS_START + 10,
2375     /**
2376      * <p>The correction coefficients to correct for this camera device's
2377      * radial and tangential lens distortion.</p>
2378      *
2379      * <p>Type: float[6]</p>
2380      *
2381      * <p>This tag may appear in:
2382      * <ul>
2383      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2384      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2385      * </ul></p>
2386      *
2387      * <p>Four radial distortion coefficients <code>[kappa_0, kappa_1, kappa_2,
2388      * kappa_3]</code> and two tangential distortion coefficients
2389      * <code>[kappa_4, kappa_5]</code> that can be used to correct the
2390      * lens's geometric distortion with the mapping equations:</p>
2391      * <pre><code> x_c = x_i * ( kappa_0 + kappa_1 * r^2 + kappa_2 * r^4 + kappa_3 * r^6 ) +
2392      *        kappa_4 * (2 * x_i * y_i) + kappa_5 * ( r^2 + 2 * x_i^2 )
2393      *  y_c = y_i * ( kappa_0 + kappa_1 * r^2 + kappa_2 * r^4 + kappa_3 * r^6 ) +
2394      *        kappa_5 * (2 * x_i * y_i) + kappa_4 * ( r^2 + 2 * y_i^2 )
2395      * </code></pre>
2396      * <p>Here, <code>[x_c, y_c]</code> are the coordinates to sample in the
2397      * input image that correspond to the pixel values in the
2398      * corrected image at the coordinate <code>[x_i, y_i]</code>:</p>
2399      * <pre><code> correctedImage(x_i, y_i) = sample_at(x_c, y_c, inputImage)
2400      * </code></pre>
2401      * <p>The pixel coordinates are defined in a normalized
2402      * coordinate system related to the
2403      * ACAMERA_LENS_INTRINSIC_CALIBRATION calibration fields.
2404      * Both <code>[x_i, y_i]</code> and <code>[x_c, y_c]</code> have <code>(0,0)</code> at the
2405      * lens optical center <code>[c_x, c_y]</code>. The maximum magnitudes
2406      * of both x and y coordinates are normalized to be 1 at the
2407      * edge further from the optical center, so the range
2408      * for both dimensions is <code>-1 &lt;= x &lt;= 1</code>.</p>
2409      * <p>Finally, <code>r</code> represents the radial distance from the
2410      * optical center, <code>r^2 = x_i^2 + y_i^2</code>, and its magnitude
2411      * is therefore no larger than <code>|r| &lt;= sqrt(2)</code>.</p>
2412      * <p>The distortion model used is the Brown-Conrady model.</p>
2413      *
2414      * @see ACAMERA_LENS_INTRINSIC_CALIBRATION
2415      */
2416     ACAMERA_LENS_RADIAL_DISTORTION =                            // float[6]
2417             ACAMERA_LENS_START + 11,
2418     ACAMERA_LENS_END,
2419 
2420     /**
2421      * <p>List of aperture size values for ACAMERA_LENS_APERTURE that are
2422      * supported by this camera device.</p>
2423      *
2424      * @see ACAMERA_LENS_APERTURE
2425      *
2426      * <p>Type: float[n]</p>
2427      *
2428      * <p>This tag may appear in:
2429      * <ul>
2430      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2431      * </ul></p>
2432      *
2433      * <p>If the camera device doesn't support a variable lens aperture,
2434      * this list will contain only one value, which is the fixed aperture size.</p>
2435      * <p>If the camera device supports a variable aperture, the aperture values
2436      * in this list will be sorted in ascending order.</p>
2437      */
2438     ACAMERA_LENS_INFO_AVAILABLE_APERTURES =                     // float[n]
2439             ACAMERA_LENS_INFO_START,
2440     /**
2441      * <p>List of neutral density filter values for
2442      * ACAMERA_LENS_FILTER_DENSITY that are supported by this camera device.</p>
2443      *
2444      * @see ACAMERA_LENS_FILTER_DENSITY
2445      *
2446      * <p>Type: float[n]</p>
2447      *
2448      * <p>This tag may appear in:
2449      * <ul>
2450      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2451      * </ul></p>
2452      *
2453      * <p>If a neutral density filter is not supported by this camera device,
2454      * this list will contain only 0. Otherwise, this list will include every
2455      * filter density supported by the camera device, in ascending order.</p>
2456      */
2457     ACAMERA_LENS_INFO_AVAILABLE_FILTER_DENSITIES =              // float[n]
2458             ACAMERA_LENS_INFO_START + 1,
2459     /**
2460      * <p>List of focal lengths for ACAMERA_LENS_FOCAL_LENGTH that are supported by this camera
2461      * device.</p>
2462      *
2463      * @see ACAMERA_LENS_FOCAL_LENGTH
2464      *
2465      * <p>Type: float[n]</p>
2466      *
2467      * <p>This tag may appear in:
2468      * <ul>
2469      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2470      * </ul></p>
2471      *
2472      * <p>If optical zoom is not supported, this list will only contain
2473      * a single value corresponding to the fixed focal length of the
2474      * device. Otherwise, this list will include every focal length supported
2475      * by the camera device, in ascending order.</p>
2476      */
2477     ACAMERA_LENS_INFO_AVAILABLE_FOCAL_LENGTHS =                 // float[n]
2478             ACAMERA_LENS_INFO_START + 2,
2479     /**
2480      * <p>List of optical image stabilization (OIS) modes for
2481      * ACAMERA_LENS_OPTICAL_STABILIZATION_MODE that are supported by this camera device.</p>
2482      *
2483      * @see ACAMERA_LENS_OPTICAL_STABILIZATION_MODE
2484      *
2485      * <p>Type: byte[n]</p>
2486      *
2487      * <p>This tag may appear in:
2488      * <ul>
2489      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2490      * </ul></p>
2491      *
2492      * <p>If OIS is not supported by a given camera device, this list will
2493      * contain only OFF.</p>
2494      */
2495     ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION =         // byte[n]
2496             ACAMERA_LENS_INFO_START + 3,
2497     /**
2498      * <p>Hyperfocal distance for this lens.</p>
2499      *
2500      * <p>Type: float</p>
2501      *
2502      * <p>This tag may appear in:
2503      * <ul>
2504      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2505      * </ul></p>
2506      *
2507      * <p>If the lens is not fixed focus, the camera device will report this
2508      * field when ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION is APPROXIMATE or CALIBRATED.</p>
2509      *
2510      * @see ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION
2511      */
2512     ACAMERA_LENS_INFO_HYPERFOCAL_DISTANCE =                     // float
2513             ACAMERA_LENS_INFO_START + 4,
2514     /**
2515      * <p>Shortest distance from frontmost surface
2516      * of the lens that can be brought into sharp focus.</p>
2517      *
2518      * <p>Type: float</p>
2519      *
2520      * <p>This tag may appear in:
2521      * <ul>
2522      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2523      * </ul></p>
2524      *
2525      * <p>If the lens is fixed-focus, this will be
2526      * 0.</p>
2527      */
2528     ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE =                  // float
2529             ACAMERA_LENS_INFO_START + 5,
2530     /**
2531      * <p>Dimensions of lens shading map.</p>
2532      *
2533      * <p>Type: int32[2]</p>
2534      *
2535      * <p>This tag may appear in:
2536      * <ul>
2537      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2538      * </ul></p>
2539      *
2540      * <p>The map should be on the order of 30-40 rows and columns, and
2541      * must be smaller than 64x64.</p>
2542      */
2543     ACAMERA_LENS_INFO_SHADING_MAP_SIZE =                        // int32[2]
2544             ACAMERA_LENS_INFO_START + 6,
2545     /**
2546      * <p>The lens focus distance calibration quality.</p>
2547      *
2548      * <p>Type: byte (acamera_metadata_enum_android_lens_info_focus_distance_calibration_t)</p>
2549      *
2550      * <p>This tag may appear in:
2551      * <ul>
2552      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2553      * </ul></p>
2554      *
2555      * <p>The lens focus distance calibration quality determines the reliability of
2556      * focus related metadata entries, i.e. ACAMERA_LENS_FOCUS_DISTANCE,
2557      * ACAMERA_LENS_FOCUS_RANGE, ACAMERA_LENS_INFO_HYPERFOCAL_DISTANCE, and
2558      * ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE.</p>
2559      * <p>APPROXIMATE and CALIBRATED devices report the focus metadata in
2560      * units of diopters (1/meter), so <code>0.0f</code> represents focusing at infinity,
2561      * and increasing positive numbers represent focusing closer and closer
2562      * to the camera device. The focus distance control also uses diopters
2563      * on these devices.</p>
2564      * <p>UNCALIBRATED devices do not use units that are directly comparable
2565      * to any real physical measurement, but <code>0.0f</code> still represents farthest
2566      * focus, and ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE represents the
2567      * nearest focus the device can achieve.</p>
2568      *
2569      * @see ACAMERA_LENS_FOCUS_DISTANCE
2570      * @see ACAMERA_LENS_FOCUS_RANGE
2571      * @see ACAMERA_LENS_INFO_HYPERFOCAL_DISTANCE
2572      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
2573      */
2574     ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION =              // byte (acamera_metadata_enum_android_lens_info_focus_distance_calibration_t)
2575             ACAMERA_LENS_INFO_START + 7,
2576     ACAMERA_LENS_INFO_END,
2577 
2578     /**
2579      * <p>Mode of operation for the noise reduction algorithm.</p>
2580      *
2581      * <p>Type: byte (acamera_metadata_enum_android_noise_reduction_mode_t)</p>
2582      *
2583      * <p>This tag may appear in:
2584      * <ul>
2585      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2586      *   <li>ACaptureRequest</li>
2587      * </ul></p>
2588      *
2589      * <p>The noise reduction algorithm attempts to improve image quality by removing
2590      * excessive noise added by the capture process, especially in dark conditions.</p>
2591      * <p>OFF means no noise reduction will be applied by the camera device, for both raw and
2592      * YUV domain.</p>
2593      * <p>MINIMAL means that only sensor raw domain basic noise reduction is enabled ,to remove
2594      * demosaicing or other processing artifacts. For YUV_REPROCESSING, MINIMAL is same as OFF.
2595      * This mode is optional, may not be support by all devices. The application should check
2596      * ACAMERA_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES before using it.</p>
2597      * <p>FAST/HIGH_QUALITY both mean camera device determined noise filtering
2598      * will be applied. HIGH_QUALITY mode indicates that the camera device
2599      * will use the highest-quality noise filtering algorithms,
2600      * even if it slows down capture rate. FAST means the camera device will not
2601      * slow down capture rate when applying noise filtering. FAST may be the same as MINIMAL if
2602      * MINIMAL is listed, or the same as OFF if any noise filtering will slow down capture rate.
2603      * Every output stream will have a similar amount of enhancement applied.</p>
2604      * <p>ZERO_SHUTTER_LAG is meant to be used by applications that maintain a continuous circular
2605      * buffer of high-resolution images during preview and reprocess image(s) from that buffer
2606      * into a final capture when triggered by the user. In this mode, the camera device applies
2607      * noise reduction to low-resolution streams (below maximum recording resolution) to maximize
2608      * preview quality, but does not apply noise reduction to high-resolution streams, since
2609      * those will be reprocessed later if necessary.</p>
2610      * <p>For YUV_REPROCESSING, these FAST/HIGH_QUALITY modes both mean that the camera device
2611      * will apply FAST/HIGH_QUALITY YUV domain noise reduction, respectively. The camera device
2612      * may adjust the noise reduction parameters for best image quality based on the
2613      * android.reprocess.effectiveExposureFactor if it is set.</p>
2614      *
2615      * @see ACAMERA_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES
2616      */
2617     ACAMERA_NOISE_REDUCTION_MODE =                              // byte (acamera_metadata_enum_android_noise_reduction_mode_t)
2618             ACAMERA_NOISE_REDUCTION_START,
2619     /**
2620      * <p>List of noise reduction modes for ACAMERA_NOISE_REDUCTION_MODE that are supported
2621      * by this camera device.</p>
2622      *
2623      * @see ACAMERA_NOISE_REDUCTION_MODE
2624      *
2625      * <p>Type: byte[n]</p>
2626      *
2627      * <p>This tag may appear in:
2628      * <ul>
2629      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2630      * </ul></p>
2631      *
2632      * <p>Full-capability camera devices will always support OFF and FAST.</p>
2633      * <p>Camera devices that support YUV_REPROCESSING or PRIVATE_REPROCESSING will support
2634      * ZERO_SHUTTER_LAG.</p>
2635      * <p>Legacy-capability camera devices will only support FAST mode.</p>
2636      */
2637     ACAMERA_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES =   // byte[n]
2638             ACAMERA_NOISE_REDUCTION_START + 2,
2639     ACAMERA_NOISE_REDUCTION_END,
2640 
2641     /**
2642      * <p>The maximum numbers of different types of output streams
2643      * that can be configured and used simultaneously by a camera device.</p>
2644      *
2645      * <p>Type: int32[3]</p>
2646      *
2647      * <p>This tag may appear in:
2648      * <ul>
2649      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2650      * </ul></p>
2651      *
2652      * <p>This is a 3 element tuple that contains the max number of output simultaneous
2653      * streams for raw sensor, processed (but not stalling), and processed (and stalling)
2654      * formats respectively. For example, assuming that JPEG is typically a processed and
2655      * stalling stream, if max raw sensor format output stream number is 1, max YUV streams
2656      * number is 3, and max JPEG stream number is 2, then this tuple should be <code>(1, 3, 2)</code>.</p>
2657      * <p>This lists the upper bound of the number of output streams supported by
2658      * the camera device. Using more streams simultaneously may require more hardware and
2659      * CPU resources that will consume more power. The image format for an output stream can
2660      * be any supported format provided by ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS.
2661      * The formats defined in ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS can be catergorized
2662      * into the 3 stream types as below:</p>
2663      * <ul>
2664      * <li>Processed (but stalling): any non-RAW format with a stallDurations &gt; 0.
2665      *   Typically {@link AIMAGE_FORMAT_JPEG} format.</li>
2666      * <li>Raw formats: {@link AIMAGE_FORMAT_RAW16}, {@link AIMAGE_FORMAT_RAW10}, or
2667      *   {@link AIMAGE_FORMAT_RAW12}.</li>
2668      * <li>Processed (but not-stalling): any non-RAW format without a stall duration.
2669      *   Typically {@link AIMAGE_FORMAT_YUV_420_888}.</li>
2670      * </ul>
2671      *
2672      * @see ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
2673      */
2674     ACAMERA_REQUEST_MAX_NUM_OUTPUT_STREAMS =                    // int32[3]
2675             ACAMERA_REQUEST_START + 6,
2676     /**
2677      * <p>Specifies the number of pipeline stages the frame went
2678      * through from when it was exposed to when the final completed result
2679      * was available to the framework.</p>
2680      *
2681      * <p>Type: byte</p>
2682      *
2683      * <p>This tag may appear in:
2684      * <ul>
2685      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2686      * </ul></p>
2687      *
2688      * <p>Depending on what settings are used in the request, and
2689      * what streams are configured, the data may undergo less processing,
2690      * and some pipeline stages skipped.</p>
2691      * <p>See ACAMERA_REQUEST_PIPELINE_MAX_DEPTH for more details.</p>
2692      *
2693      * @see ACAMERA_REQUEST_PIPELINE_MAX_DEPTH
2694      */
2695     ACAMERA_REQUEST_PIPELINE_DEPTH =                            // byte
2696             ACAMERA_REQUEST_START + 9,
2697     /**
2698      * <p>Specifies the number of maximum pipeline stages a frame
2699      * has to go through from when it's exposed to when it's available
2700      * to the framework.</p>
2701      *
2702      * <p>Type: byte</p>
2703      *
2704      * <p>This tag may appear in:
2705      * <ul>
2706      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2707      * </ul></p>
2708      *
2709      * <p>A typical minimum value for this is 2 (one stage to expose,
2710      * one stage to readout) from the sensor. The ISP then usually adds
2711      * its own stages to do custom HW processing. Further stages may be
2712      * added by SW processing.</p>
2713      * <p>Depending on what settings are used (e.g. YUV, JPEG) and what
2714      * processing is enabled (e.g. face detection), the actual pipeline
2715      * depth (specified by ACAMERA_REQUEST_PIPELINE_DEPTH) may be less than
2716      * the max pipeline depth.</p>
2717      * <p>A pipeline depth of X stages is equivalent to a pipeline latency of
2718      * X frame intervals.</p>
2719      * <p>This value will normally be 8 or less, however, for high speed capture session,
2720      * the max pipeline depth will be up to 8 x size of high speed capture request list.</p>
2721      *
2722      * @see ACAMERA_REQUEST_PIPELINE_DEPTH
2723      */
2724     ACAMERA_REQUEST_PIPELINE_MAX_DEPTH =                        // byte
2725             ACAMERA_REQUEST_START + 10,
2726     /**
2727      * <p>Defines how many sub-components
2728      * a result will be composed of.</p>
2729      *
2730      * <p>Type: int32</p>
2731      *
2732      * <p>This tag may appear in:
2733      * <ul>
2734      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2735      * </ul></p>
2736      *
2737      * <p>In order to combat the pipeline latency, partial results
2738      * may be delivered to the application layer from the camera device as
2739      * soon as they are available.</p>
2740      * <p>Optional; defaults to 1. A value of 1 means that partial
2741      * results are not supported, and only the final TotalCaptureResult will
2742      * be produced by the camera device.</p>
2743      * <p>A typical use case for this might be: after requesting an
2744      * auto-focus (AF) lock the new AF state might be available 50%
2745      * of the way through the pipeline.  The camera device could
2746      * then immediately dispatch this state via a partial result to
2747      * the application, and the rest of the metadata via later
2748      * partial results.</p>
2749      */
2750     ACAMERA_REQUEST_PARTIAL_RESULT_COUNT =                      // int32
2751             ACAMERA_REQUEST_START + 11,
2752     /**
2753      * <p>List of capabilities that this camera device
2754      * advertises as fully supporting.</p>
2755      *
2756      * <p>Type: byte[n] (acamera_metadata_enum_android_request_available_capabilities_t)</p>
2757      *
2758      * <p>This tag may appear in:
2759      * <ul>
2760      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2761      * </ul></p>
2762      *
2763      * <p>A capability is a contract that the camera device makes in order
2764      * to be able to satisfy one or more use cases.</p>
2765      * <p>Listing a capability guarantees that the whole set of features
2766      * required to support a common use will all be available.</p>
2767      * <p>Using a subset of the functionality provided by an unsupported
2768      * capability may be possible on a specific camera device implementation;
2769      * to do this query each of ACAMERA_REQUEST_AVAILABLE_REQUEST_KEYS,
2770      * ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS,
2771      * ACAMERA_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS.</p>
2772      * <p>The following capabilities are guaranteed to be available on
2773      * ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL <code>==</code> FULL devices:</p>
2774      * <ul>
2775      * <li>MANUAL_SENSOR</li>
2776      * <li>MANUAL_POST_PROCESSING</li>
2777      * </ul>
2778      * <p>Other capabilities may be available on either FULL or LIMITED
2779      * devices, but the application should query this key to be sure.</p>
2780      *
2781      * @see ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL
2782      * @see ACAMERA_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS
2783      * @see ACAMERA_REQUEST_AVAILABLE_REQUEST_KEYS
2784      * @see ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS
2785      */
2786     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES =                    // byte[n] (acamera_metadata_enum_android_request_available_capabilities_t)
2787             ACAMERA_REQUEST_START + 12,
2788     /**
2789      * <p>A list of all keys that the camera device has available
2790      * to use with {@link ACaptureRequest}.</p>
2791      *
2792      * <p>Type: int32[n]</p>
2793      *
2794      * <p>This tag may appear in:
2795      * <ul>
2796      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2797      * </ul></p>
2798      *
2799      * <p>Attempting to set a key into a CaptureRequest that is not
2800      * listed here will result in an invalid request and will be rejected
2801      * by the camera device.</p>
2802      * <p>This field can be used to query the feature set of a camera device
2803      * at a more granular level than capabilities. This is especially
2804      * important for optional keys that are not listed under any capability
2805      * in ACAMERA_REQUEST_AVAILABLE_CAPABILITIES.</p>
2806      *
2807      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
2808      */
2809     ACAMERA_REQUEST_AVAILABLE_REQUEST_KEYS =                    // int32[n]
2810             ACAMERA_REQUEST_START + 13,
2811     /**
2812      * <p>A list of all keys that the camera device has available
2813      * to query with {@link ACameraMetadata} from
2814      * {@link ACameraCaptureSession_captureCallback_result}.</p>
2815      *
2816      * <p>Type: int32[n]</p>
2817      *
2818      * <p>This tag may appear in:
2819      * <ul>
2820      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2821      * </ul></p>
2822      *
2823      * <p>Attempting to get a key from a CaptureResult that is not
2824      * listed here will always return a <code>null</code> value. Getting a key from
2825      * a CaptureResult that is listed here will generally never return a <code>null</code>
2826      * value.</p>
2827      * <p>The following keys may return <code>null</code> unless they are enabled:</p>
2828      * <ul>
2829      * <li>ACAMERA_STATISTICS_LENS_SHADING_MAP (non-null iff ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE == ON)</li>
2830      * </ul>
2831      * <p>(Those sometimes-null keys will nevertheless be listed here
2832      * if they are available.)</p>
2833      * <p>This field can be used to query the feature set of a camera device
2834      * at a more granular level than capabilities. This is especially
2835      * important for optional keys that are not listed under any capability
2836      * in ACAMERA_REQUEST_AVAILABLE_CAPABILITIES.</p>
2837      *
2838      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
2839      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP
2840      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
2841      */
2842     ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS =                     // int32[n]
2843             ACAMERA_REQUEST_START + 14,
2844     /**
2845      * <p>A list of all keys that the camera device has available
2846      * to query with {@link ACameraMetadata} from
2847      * {@link ACameraManager_getCameraCharacteristics}.</p>
2848      *
2849      * <p>Type: int32[n]</p>
2850      *
2851      * <p>This tag may appear in:
2852      * <ul>
2853      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2854      * </ul></p>
2855      *
2856      * <p>This entry follows the same rules as
2857      * ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS (except that it applies for
2858      * CameraCharacteristics instead of CaptureResult). See above for more
2859      * details.</p>
2860      *
2861      * @see ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS
2862      */
2863     ACAMERA_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS =            // int32[n]
2864             ACAMERA_REQUEST_START + 15,
2865     ACAMERA_REQUEST_END,
2866 
2867     /**
2868      * <p>The desired region of the sensor to read out for this capture.</p>
2869      *
2870      * <p>Type: int32[4]</p>
2871      *
2872      * <p>This tag may appear in:
2873      * <ul>
2874      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
2875      *   <li>ACaptureRequest</li>
2876      * </ul></p>
2877      *
2878      * <p>This control can be used to implement digital zoom.</p>
2879      * <p>The data representation is int[4], which maps to (left, top, width, height).</p>
2880      * <p>The crop region coordinate system is based off
2881      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE, with <code>(0, 0)</code> being the
2882      * top-left corner of the sensor active array.</p>
2883      * <p>Output streams use this rectangle to produce their output,
2884      * cropping to a smaller region if necessary to maintain the
2885      * stream's aspect ratio, then scaling the sensor input to
2886      * match the output's configured resolution.</p>
2887      * <p>The crop region is applied after the RAW to other color
2888      * space (e.g. YUV) conversion. Since raw streams
2889      * (e.g. RAW16) don't have the conversion stage, they are not
2890      * croppable. The crop region will be ignored by raw streams.</p>
2891      * <p>For non-raw streams, any additional per-stream cropping will
2892      * be done to maximize the final pixel area of the stream.</p>
2893      * <p>For example, if the crop region is set to a 4:3 aspect
2894      * ratio, then 4:3 streams will use the exact crop
2895      * region. 16:9 streams will further crop vertically
2896      * (letterbox).</p>
2897      * <p>Conversely, if the crop region is set to a 16:9, then 4:3
2898      * outputs will crop horizontally (pillarbox), and 16:9
2899      * streams will match exactly. These additional crops will
2900      * be centered within the crop region.</p>
2901      * <p>The width and height of the crop region cannot
2902      * be set to be smaller than
2903      * <code>floor( activeArraySize.width / ACAMERA_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM )</code> and
2904      * <code>floor( activeArraySize.height / ACAMERA_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM )</code>, respectively.</p>
2905      * <p>The camera device may adjust the crop region to account
2906      * for rounding and other hardware requirements; the final
2907      * crop region used will be included in the output capture
2908      * result.</p>
2909      *
2910      * @see ACAMERA_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM
2911      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
2912      */
2913     ACAMERA_SCALER_CROP_REGION =                                // int32[4]
2914             ACAMERA_SCALER_START,
2915     /**
2916      * <p>The maximum ratio between both active area width
2917      * and crop region width, and active area height and
2918      * crop region height, for ACAMERA_SCALER_CROP_REGION.</p>
2919      *
2920      * @see ACAMERA_SCALER_CROP_REGION
2921      *
2922      * <p>Type: float</p>
2923      *
2924      * <p>This tag may appear in:
2925      * <ul>
2926      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2927      * </ul></p>
2928      *
2929      * <p>This represents the maximum amount of zooming possible by
2930      * the camera device, or equivalently, the minimum cropping
2931      * window size.</p>
2932      * <p>Crop regions that have a width or height that is smaller
2933      * than this ratio allows will be rounded up to the minimum
2934      * allowed size by the camera device.</p>
2935      */
2936     ACAMERA_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM =                 // float
2937             ACAMERA_SCALER_START + 4,
2938     /**
2939      * <p>The available stream configurations that this
2940      * camera device supports
2941      * (i.e. format, width, height, output/input stream).</p>
2942      *
2943      * <p>Type: int32[n*4] (acamera_metadata_enum_android_scaler_available_stream_configurations_t)</p>
2944      *
2945      * <p>This tag may appear in:
2946      * <ul>
2947      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2948      * </ul></p>
2949      *
2950      * <p>The configurations are listed as <code>(format, width, height, input?)</code>
2951      * tuples.</p>
2952      * <p>For a given use case, the actual maximum supported resolution
2953      * may be lower than what is listed here, depending on the destination
2954      * Surface for the image data. For example, for recording video,
2955      * the video encoder chosen may have a maximum size limit (e.g. 1080p)
2956      * smaller than what the camera (e.g. maximum resolution is 3264x2448)
2957      * can provide.</p>
2958      * <p>Please reference the documentation for the image data destination to
2959      * check if it limits the maximum size for image data.</p>
2960      * <p>Not all output formats may be supported in a configuration with
2961      * an input stream of a particular format. For more details, see
2962      * android.scaler.availableInputOutputFormatsMap.</p>
2963      * <p>The following table describes the minimum required output stream
2964      * configurations based on the hardware level
2965      * (ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL):</p>
2966      * <p>Format         | Size                                         | Hardware Level | Notes
2967      * :-------------:|:--------------------------------------------:|:--------------:|:--------------:
2968      * JPEG           | ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE          | Any            |
2969      * JPEG           | 1920x1080 (1080p)                            | Any            | if 1080p &lt;= activeArraySize
2970      * JPEG           | 1280x720 (720)                               | Any            | if 720p &lt;= activeArraySize
2971      * JPEG           | 640x480 (480p)                               | Any            | if 480p &lt;= activeArraySize
2972      * JPEG           | 320x240 (240p)                               | Any            | if 240p &lt;= activeArraySize
2973      * YUV_420_888    | all output sizes available for JPEG          | FULL           |
2974      * YUV_420_888    | all output sizes available for JPEG, up to the maximum video size | LIMITED        |
2975      * IMPLEMENTATION_DEFINED | same as YUV_420_888                  | Any            |</p>
2976      * <p>Refer to ACAMERA_REQUEST_AVAILABLE_CAPABILITIES for additional
2977      * mandatory stream configurations on a per-capability basis.</p>
2978      *
2979      * @see ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL
2980      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
2981      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
2982      */
2983     ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS =            // int32[n*4] (acamera_metadata_enum_android_scaler_available_stream_configurations_t)
2984             ACAMERA_SCALER_START + 10,
2985     /**
2986      * <p>This lists the minimum frame duration for each
2987      * format/size combination.</p>
2988      *
2989      * <p>Type: int64[4*n]</p>
2990      *
2991      * <p>This tag may appear in:
2992      * <ul>
2993      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
2994      * </ul></p>
2995      *
2996      * <p>This should correspond to the frame duration when only that
2997      * stream is active, with all processing (typically in android.*.mode)
2998      * set to either OFF or FAST.</p>
2999      * <p>When multiple streams are used in a request, the minimum frame
3000      * duration will be max(individual stream min durations).</p>
3001      * <p>The minimum frame duration of a stream (of a particular format, size)
3002      * is the same regardless of whether the stream is input or output.</p>
3003      * <p>See ACAMERA_SENSOR_FRAME_DURATION and
3004      * ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS for more details about
3005      * calculating the max frame rate.</p>
3006      *
3007      * @see ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS
3008      * @see ACAMERA_SENSOR_FRAME_DURATION
3009      */
3010     ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS =              // int64[4*n]
3011             ACAMERA_SCALER_START + 11,
3012     /**
3013      * <p>This lists the maximum stall duration for each
3014      * output format/size combination.</p>
3015      *
3016      * <p>Type: int64[4*n]</p>
3017      *
3018      * <p>This tag may appear in:
3019      * <ul>
3020      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3021      * </ul></p>
3022      *
3023      * <p>A stall duration is how much extra time would get added
3024      * to the normal minimum frame duration for a repeating request
3025      * that has streams with non-zero stall.</p>
3026      * <p>For example, consider JPEG captures which have the following
3027      * characteristics:</p>
3028      * <ul>
3029      * <li>JPEG streams act like processed YUV streams in requests for which
3030      * they are not included; in requests in which they are directly
3031      * referenced, they act as JPEG streams. This is because supporting a
3032      * JPEG stream requires the underlying YUV data to always be ready for
3033      * use by a JPEG encoder, but the encoder will only be used (and impact
3034      * frame duration) on requests that actually reference a JPEG stream.</li>
3035      * <li>The JPEG processor can run concurrently to the rest of the camera
3036      * pipeline, but cannot process more than 1 capture at a time.</li>
3037      * </ul>
3038      * <p>In other words, using a repeating YUV request would result
3039      * in a steady frame rate (let's say it's 30 FPS). If a single
3040      * JPEG request is submitted periodically, the frame rate will stay
3041      * at 30 FPS (as long as we wait for the previous JPEG to return each
3042      * time). If we try to submit a repeating YUV + JPEG request, then
3043      * the frame rate will drop from 30 FPS.</p>
3044      * <p>In general, submitting a new request with a non-0 stall time
3045      * stream will <em>not</em> cause a frame rate drop unless there are still
3046      * outstanding buffers for that stream from previous requests.</p>
3047      * <p>Submitting a repeating request with streams (call this <code>S</code>)
3048      * is the same as setting the minimum frame duration from
3049      * the normal minimum frame duration corresponding to <code>S</code>, added with
3050      * the maximum stall duration for <code>S</code>.</p>
3051      * <p>If interleaving requests with and without a stall duration,
3052      * a request will stall by the maximum of the remaining times
3053      * for each can-stall stream with outstanding buffers.</p>
3054      * <p>This means that a stalling request will not have an exposure start
3055      * until the stall has completed.</p>
3056      * <p>This should correspond to the stall duration when only that stream is
3057      * active, with all processing (typically in android.*.mode) set to FAST
3058      * or OFF. Setting any of the processing modes to HIGH_QUALITY
3059      * effectively results in an indeterminate stall duration for all
3060      * streams in a request (the regular stall calculation rules are
3061      * ignored).</p>
3062      * <p>The following formats may always have a stall duration:</p>
3063      * <ul>
3064      * <li>{@link AIMAGE_FORMAT_JPEG}</li>
3065      * <li>{@link AIMAGE_FORMAT_RAW16}</li>
3066      * </ul>
3067      * <p>The following formats will never have a stall duration:</p>
3068      * <ul>
3069      * <li>{@link AIMAGE_FORMAT_YUV_420_888}</li>
3070      * <li>{@link AIMAGE_FORMAT_RAW10}</li>
3071      * </ul>
3072      * <p>All other formats may or may not have an allowed stall duration on
3073      * a per-capability basis; refer to ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
3074      * for more details.</p>
3075      * <p>See ACAMERA_SENSOR_FRAME_DURATION for more information about
3076      * calculating the max frame rate (absent stalls).</p>
3077      *
3078      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
3079      * @see ACAMERA_SENSOR_FRAME_DURATION
3080      */
3081     ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS =                  // int64[4*n]
3082             ACAMERA_SCALER_START + 12,
3083     /**
3084      * <p>The crop type that this camera device supports.</p>
3085      *
3086      * <p>Type: byte (acamera_metadata_enum_android_scaler_cropping_type_t)</p>
3087      *
3088      * <p>This tag may appear in:
3089      * <ul>
3090      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3091      * </ul></p>
3092      *
3093      * <p>When passing a non-centered crop region (ACAMERA_SCALER_CROP_REGION) to a camera
3094      * device that only supports CENTER_ONLY cropping, the camera device will move the
3095      * crop region to the center of the sensor active array (ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE)
3096      * and keep the crop region width and height unchanged. The camera device will return the
3097      * final used crop region in metadata result ACAMERA_SCALER_CROP_REGION.</p>
3098      * <p>Camera devices that support FREEFORM cropping will support any crop region that
3099      * is inside of the active array. The camera device will apply the same crop region and
3100      * return the final used crop region in capture result metadata ACAMERA_SCALER_CROP_REGION.</p>
3101      * <p>LEGACY capability devices will only support CENTER_ONLY cropping.</p>
3102      *
3103      * @see ACAMERA_SCALER_CROP_REGION
3104      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
3105      */
3106     ACAMERA_SCALER_CROPPING_TYPE =                              // byte (acamera_metadata_enum_android_scaler_cropping_type_t)
3107             ACAMERA_SCALER_START + 13,
3108     ACAMERA_SCALER_END,
3109 
3110     /**
3111      * <p>Duration each pixel is exposed to
3112      * light.</p>
3113      *
3114      * <p>Type: int64</p>
3115      *
3116      * <p>This tag may appear in:
3117      * <ul>
3118      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3119      *   <li>ACaptureRequest</li>
3120      * </ul></p>
3121      *
3122      * <p>If the sensor can't expose this exact duration, it will shorten the
3123      * duration exposed to the nearest possible value (rather than expose longer).
3124      * The final exposure time used will be available in the output capture result.</p>
3125      * <p>This control is only effective if ACAMERA_CONTROL_AE_MODE or ACAMERA_CONTROL_MODE is set to
3126      * OFF; otherwise the auto-exposure algorithm will override this value.</p>
3127      *
3128      * @see ACAMERA_CONTROL_AE_MODE
3129      * @see ACAMERA_CONTROL_MODE
3130      */
3131     ACAMERA_SENSOR_EXPOSURE_TIME =                              // int64
3132             ACAMERA_SENSOR_START,
3133     /**
3134      * <p>Duration from start of frame exposure to
3135      * start of next frame exposure.</p>
3136      *
3137      * <p>Type: int64</p>
3138      *
3139      * <p>This tag may appear in:
3140      * <ul>
3141      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3142      *   <li>ACaptureRequest</li>
3143      * </ul></p>
3144      *
3145      * <p>The maximum frame rate that can be supported by a camera subsystem is
3146      * a function of many factors:</p>
3147      * <ul>
3148      * <li>Requested resolutions of output image streams</li>
3149      * <li>Availability of binning / skipping modes on the imager</li>
3150      * <li>The bandwidth of the imager interface</li>
3151      * <li>The bandwidth of the various ISP processing blocks</li>
3152      * </ul>
3153      * <p>Since these factors can vary greatly between different ISPs and
3154      * sensors, the camera abstraction tries to represent the bandwidth
3155      * restrictions with as simple a model as possible.</p>
3156      * <p>The model presented has the following characteristics:</p>
3157      * <ul>
3158      * <li>The image sensor is always configured to output the smallest
3159      * resolution possible given the application's requested output stream
3160      * sizes.  The smallest resolution is defined as being at least as large
3161      * as the largest requested output stream size; the camera pipeline must
3162      * never digitally upsample sensor data when the crop region covers the
3163      * whole sensor. In general, this means that if only small output stream
3164      * resolutions are configured, the sensor can provide a higher frame
3165      * rate.</li>
3166      * <li>Since any request may use any or all the currently configured
3167      * output streams, the sensor and ISP must be configured to support
3168      * scaling a single capture to all the streams at the same time.  This
3169      * means the camera pipeline must be ready to produce the largest
3170      * requested output size without any delay.  Therefore, the overall
3171      * frame rate of a given configured stream set is governed only by the
3172      * largest requested stream resolution.</li>
3173      * <li>Using more than one output stream in a request does not affect the
3174      * frame duration.</li>
3175      * <li>Certain format-streams may need to do additional background processing
3176      * before data is consumed/produced by that stream. These processors
3177      * can run concurrently to the rest of the camera pipeline, but
3178      * cannot process more than 1 capture at a time.</li>
3179      * </ul>
3180      * <p>The necessary information for the application, given the model above,
3181      * is provided via
3182      * {@link ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS}.
3183      * These are used to determine the maximum frame rate / minimum frame
3184      * duration that is possible for a given stream configuration.</p>
3185      * <p>Specifically, the application can use the following rules to
3186      * determine the minimum frame duration it can request from the camera
3187      * device:</p>
3188      * <ol>
3189      * <li>Let the set of currently configured input/output streams
3190      * be called <code>S</code>.</li>
3191      * <li>Find the minimum frame durations for each stream in <code>S</code>, by looking
3192      * it up in {@link ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS}
3193      * (with its respective size/format). Let this set of frame durations be
3194      * called <code>F</code>.</li>
3195      * <li>For any given request <code>R</code>, the minimum frame duration allowed
3196      * for <code>R</code> is the maximum out of all values in <code>F</code>. Let the streams
3197      * used in <code>R</code> be called <code>S_r</code>.</li>
3198      * </ol>
3199      * <p>If none of the streams in <code>S_r</code> have a stall time (listed in {@link
3200      * ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS}
3201      * using its respective size/format), then the frame duration in <code>F</code>
3202      * determines the steady state frame rate that the application will get
3203      * if it uses <code>R</code> as a repeating request. Let this special kind of
3204      * request be called <code>Rsimple</code>.</p>
3205      * <p>A repeating request <code>Rsimple</code> can be <em>occasionally</em> interleaved
3206      * by a single capture of a new request <code>Rstall</code> (which has at least
3207      * one in-use stream with a non-0 stall time) and if <code>Rstall</code> has the
3208      * same minimum frame duration this will not cause a frame rate loss
3209      * if all buffers from the previous <code>Rstall</code> have already been
3210      * delivered.</p>
3211      * <p>For more details about stalling, see
3212      * {@link ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS}.</p>
3213      * <p>This control is only effective if ACAMERA_CONTROL_AE_MODE or ACAMERA_CONTROL_MODE is set to
3214      * OFF; otherwise the auto-exposure algorithm will override this value.</p>
3215      *
3216      * @see ACAMERA_CONTROL_AE_MODE
3217      * @see ACAMERA_CONTROL_MODE
3218      */
3219     ACAMERA_SENSOR_FRAME_DURATION =                             // int64
3220             ACAMERA_SENSOR_START + 1,
3221     /**
3222      * <p>The amount of gain applied to sensor data
3223      * before processing.</p>
3224      *
3225      * <p>Type: int32</p>
3226      *
3227      * <p>This tag may appear in:
3228      * <ul>
3229      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3230      *   <li>ACaptureRequest</li>
3231      * </ul></p>
3232      *
3233      * <p>The sensitivity is the standard ISO sensitivity value,
3234      * as defined in ISO 12232:2006.</p>
3235      * <p>The sensitivity must be within ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE, and
3236      * if if it less than ACAMERA_SENSOR_MAX_ANALOG_SENSITIVITY, the camera device
3237      * is guaranteed to use only analog amplification for applying the gain.</p>
3238      * <p>If the camera device cannot apply the exact sensitivity
3239      * requested, it will reduce the gain to the nearest supported
3240      * value. The final sensitivity used will be available in the
3241      * output capture result.</p>
3242      * <p>This control is only effective if ACAMERA_CONTROL_AE_MODE or ACAMERA_CONTROL_MODE is set to
3243      * OFF; otherwise the auto-exposure algorithm will override this value.</p>
3244      *
3245      * @see ACAMERA_CONTROL_AE_MODE
3246      * @see ACAMERA_CONTROL_MODE
3247      * @see ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE
3248      * @see ACAMERA_SENSOR_MAX_ANALOG_SENSITIVITY
3249      */
3250     ACAMERA_SENSOR_SENSITIVITY =                                // int32
3251             ACAMERA_SENSOR_START + 2,
3252     /**
3253      * <p>The standard reference illuminant used as the scene light source when
3254      * calculating the ACAMERA_SENSOR_COLOR_TRANSFORM1,
3255      * ACAMERA_SENSOR_CALIBRATION_TRANSFORM1, and
3256      * ACAMERA_SENSOR_FORWARD_MATRIX1 matrices.</p>
3257      *
3258      * @see ACAMERA_SENSOR_CALIBRATION_TRANSFORM1
3259      * @see ACAMERA_SENSOR_COLOR_TRANSFORM1
3260      * @see ACAMERA_SENSOR_FORWARD_MATRIX1
3261      *
3262      * <p>Type: byte (acamera_metadata_enum_android_sensor_reference_illuminant1_t)</p>
3263      *
3264      * <p>This tag may appear in:
3265      * <ul>
3266      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3267      * </ul></p>
3268      *
3269      * <p>The values in this key correspond to the values defined for the
3270      * EXIF LightSource tag. These illuminants are standard light sources
3271      * that are often used calibrating camera devices.</p>
3272      * <p>If this key is present, then ACAMERA_SENSOR_COLOR_TRANSFORM1,
3273      * ACAMERA_SENSOR_CALIBRATION_TRANSFORM1, and
3274      * ACAMERA_SENSOR_FORWARD_MATRIX1 will also be present.</p>
3275      * <p>Some devices may choose to provide a second set of calibration
3276      * information for improved quality, including
3277      * ACAMERA_SENSOR_REFERENCE_ILLUMINANT2 and its corresponding matrices.</p>
3278      *
3279      * @see ACAMERA_SENSOR_CALIBRATION_TRANSFORM1
3280      * @see ACAMERA_SENSOR_COLOR_TRANSFORM1
3281      * @see ACAMERA_SENSOR_FORWARD_MATRIX1
3282      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT2
3283      */
3284     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1 =                      // byte (acamera_metadata_enum_android_sensor_reference_illuminant1_t)
3285             ACAMERA_SENSOR_START + 3,
3286     /**
3287      * <p>The standard reference illuminant used as the scene light source when
3288      * calculating the ACAMERA_SENSOR_COLOR_TRANSFORM2,
3289      * ACAMERA_SENSOR_CALIBRATION_TRANSFORM2, and
3290      * ACAMERA_SENSOR_FORWARD_MATRIX2 matrices.</p>
3291      *
3292      * @see ACAMERA_SENSOR_CALIBRATION_TRANSFORM2
3293      * @see ACAMERA_SENSOR_COLOR_TRANSFORM2
3294      * @see ACAMERA_SENSOR_FORWARD_MATRIX2
3295      *
3296      * <p>Type: byte</p>
3297      *
3298      * <p>This tag may appear in:
3299      * <ul>
3300      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3301      * </ul></p>
3302      *
3303      * <p>See ACAMERA_SENSOR_REFERENCE_ILLUMINANT1 for more details.</p>
3304      * <p>If this key is present, then ACAMERA_SENSOR_COLOR_TRANSFORM2,
3305      * ACAMERA_SENSOR_CALIBRATION_TRANSFORM2, and
3306      * ACAMERA_SENSOR_FORWARD_MATRIX2 will also be present.</p>
3307      *
3308      * @see ACAMERA_SENSOR_CALIBRATION_TRANSFORM2
3309      * @see ACAMERA_SENSOR_COLOR_TRANSFORM2
3310      * @see ACAMERA_SENSOR_FORWARD_MATRIX2
3311      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
3312      */
3313     ACAMERA_SENSOR_REFERENCE_ILLUMINANT2 =                      // byte
3314             ACAMERA_SENSOR_START + 4,
3315     /**
3316      * <p>A per-device calibration transform matrix that maps from the
3317      * reference sensor colorspace to the actual device sensor colorspace.</p>
3318      *
3319      * <p>Type: rational[3*3]</p>
3320      *
3321      * <p>This tag may appear in:
3322      * <ul>
3323      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3324      * </ul></p>
3325      *
3326      * <p>This matrix is used to correct for per-device variations in the
3327      * sensor colorspace, and is used for processing raw buffer data.</p>
3328      * <p>The matrix is expressed as a 3x3 matrix in row-major-order, and
3329      * contains a per-device calibration transform that maps colors
3330      * from reference sensor color space (i.e. the "golden module"
3331      * colorspace) into this camera device's native sensor color
3332      * space under the first reference illuminant
3333      * (ACAMERA_SENSOR_REFERENCE_ILLUMINANT1).</p>
3334      *
3335      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
3336      */
3337     ACAMERA_SENSOR_CALIBRATION_TRANSFORM1 =                     // rational[3*3]
3338             ACAMERA_SENSOR_START + 5,
3339     /**
3340      * <p>A per-device calibration transform matrix that maps from the
3341      * reference sensor colorspace to the actual device sensor colorspace
3342      * (this is the colorspace of the raw buffer data).</p>
3343      *
3344      * <p>Type: rational[3*3]</p>
3345      *
3346      * <p>This tag may appear in:
3347      * <ul>
3348      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3349      * </ul></p>
3350      *
3351      * <p>This matrix is used to correct for per-device variations in the
3352      * sensor colorspace, and is used for processing raw buffer data.</p>
3353      * <p>The matrix is expressed as a 3x3 matrix in row-major-order, and
3354      * contains a per-device calibration transform that maps colors
3355      * from reference sensor color space (i.e. the "golden module"
3356      * colorspace) into this camera device's native sensor color
3357      * space under the second reference illuminant
3358      * (ACAMERA_SENSOR_REFERENCE_ILLUMINANT2).</p>
3359      * <p>This matrix will only be present if the second reference
3360      * illuminant is present.</p>
3361      *
3362      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT2
3363      */
3364     ACAMERA_SENSOR_CALIBRATION_TRANSFORM2 =                     // rational[3*3]
3365             ACAMERA_SENSOR_START + 6,
3366     /**
3367      * <p>A matrix that transforms color values from CIE XYZ color space to
3368      * reference sensor color space.</p>
3369      *
3370      * <p>Type: rational[3*3]</p>
3371      *
3372      * <p>This tag may appear in:
3373      * <ul>
3374      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3375      * </ul></p>
3376      *
3377      * <p>This matrix is used to convert from the standard CIE XYZ color
3378      * space to the reference sensor colorspace, and is used when processing
3379      * raw buffer data.</p>
3380      * <p>The matrix is expressed as a 3x3 matrix in row-major-order, and
3381      * contains a color transform matrix that maps colors from the CIE
3382      * XYZ color space to the reference sensor color space (i.e. the
3383      * "golden module" colorspace) under the first reference illuminant
3384      * (ACAMERA_SENSOR_REFERENCE_ILLUMINANT1).</p>
3385      * <p>The white points chosen in both the reference sensor color space
3386      * and the CIE XYZ colorspace when calculating this transform will
3387      * match the standard white point for the first reference illuminant
3388      * (i.e. no chromatic adaptation will be applied by this transform).</p>
3389      *
3390      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
3391      */
3392     ACAMERA_SENSOR_COLOR_TRANSFORM1 =                           // rational[3*3]
3393             ACAMERA_SENSOR_START + 7,
3394     /**
3395      * <p>A matrix that transforms color values from CIE XYZ color space to
3396      * reference sensor color space.</p>
3397      *
3398      * <p>Type: rational[3*3]</p>
3399      *
3400      * <p>This tag may appear in:
3401      * <ul>
3402      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3403      * </ul></p>
3404      *
3405      * <p>This matrix is used to convert from the standard CIE XYZ color
3406      * space to the reference sensor colorspace, and is used when processing
3407      * raw buffer data.</p>
3408      * <p>The matrix is expressed as a 3x3 matrix in row-major-order, and
3409      * contains a color transform matrix that maps colors from the CIE
3410      * XYZ color space to the reference sensor color space (i.e. the
3411      * "golden module" colorspace) under the second reference illuminant
3412      * (ACAMERA_SENSOR_REFERENCE_ILLUMINANT2).</p>
3413      * <p>The white points chosen in both the reference sensor color space
3414      * and the CIE XYZ colorspace when calculating this transform will
3415      * match the standard white point for the second reference illuminant
3416      * (i.e. no chromatic adaptation will be applied by this transform).</p>
3417      * <p>This matrix will only be present if the second reference
3418      * illuminant is present.</p>
3419      *
3420      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT2
3421      */
3422     ACAMERA_SENSOR_COLOR_TRANSFORM2 =                           // rational[3*3]
3423             ACAMERA_SENSOR_START + 8,
3424     /**
3425      * <p>A matrix that transforms white balanced camera colors from the reference
3426      * sensor colorspace to the CIE XYZ colorspace with a D50 whitepoint.</p>
3427      *
3428      * <p>Type: rational[3*3]</p>
3429      *
3430      * <p>This tag may appear in:
3431      * <ul>
3432      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3433      * </ul></p>
3434      *
3435      * <p>This matrix is used to convert to the standard CIE XYZ colorspace, and
3436      * is used when processing raw buffer data.</p>
3437      * <p>This matrix is expressed as a 3x3 matrix in row-major-order, and contains
3438      * a color transform matrix that maps white balanced colors from the
3439      * reference sensor color space to the CIE XYZ color space with a D50 white
3440      * point.</p>
3441      * <p>Under the first reference illuminant (ACAMERA_SENSOR_REFERENCE_ILLUMINANT1)
3442      * this matrix is chosen so that the standard white point for this reference
3443      * illuminant in the reference sensor colorspace is mapped to D50 in the
3444      * CIE XYZ colorspace.</p>
3445      *
3446      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
3447      */
3448     ACAMERA_SENSOR_FORWARD_MATRIX1 =                            // rational[3*3]
3449             ACAMERA_SENSOR_START + 9,
3450     /**
3451      * <p>A matrix that transforms white balanced camera colors from the reference
3452      * sensor colorspace to the CIE XYZ colorspace with a D50 whitepoint.</p>
3453      *
3454      * <p>Type: rational[3*3]</p>
3455      *
3456      * <p>This tag may appear in:
3457      * <ul>
3458      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3459      * </ul></p>
3460      *
3461      * <p>This matrix is used to convert to the standard CIE XYZ colorspace, and
3462      * is used when processing raw buffer data.</p>
3463      * <p>This matrix is expressed as a 3x3 matrix in row-major-order, and contains
3464      * a color transform matrix that maps white balanced colors from the
3465      * reference sensor color space to the CIE XYZ color space with a D50 white
3466      * point.</p>
3467      * <p>Under the second reference illuminant (ACAMERA_SENSOR_REFERENCE_ILLUMINANT2)
3468      * this matrix is chosen so that the standard white point for this reference
3469      * illuminant in the reference sensor colorspace is mapped to D50 in the
3470      * CIE XYZ colorspace.</p>
3471      * <p>This matrix will only be present if the second reference
3472      * illuminant is present.</p>
3473      *
3474      * @see ACAMERA_SENSOR_REFERENCE_ILLUMINANT2
3475      */
3476     ACAMERA_SENSOR_FORWARD_MATRIX2 =                            // rational[3*3]
3477             ACAMERA_SENSOR_START + 10,
3478     /**
3479      * <p>A fixed black level offset for each of the color filter arrangement
3480      * (CFA) mosaic channels.</p>
3481      *
3482      * <p>Type: int32[4]</p>
3483      *
3484      * <p>This tag may appear in:
3485      * <ul>
3486      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3487      * </ul></p>
3488      *
3489      * <p>This key specifies the zero light value for each of the CFA mosaic
3490      * channels in the camera sensor.  The maximal value output by the
3491      * sensor is represented by the value in ACAMERA_SENSOR_INFO_WHITE_LEVEL.</p>
3492      * <p>The values are given in the same order as channels listed for the CFA
3493      * layout key (see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT), i.e. the
3494      * nth value given corresponds to the black level offset for the nth
3495      * color channel listed in the CFA.</p>
3496      * <p>The black level values of captured images may vary for different
3497      * capture settings (e.g., ACAMERA_SENSOR_SENSITIVITY). This key
3498      * represents a coarse approximation for such case. It is recommended to
3499      * use ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL or use pixels from
3500      * ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS directly for captures when
3501      * supported by the camera device, which provides more accurate black
3502      * level values. For raw capture in particular, it is recommended to use
3503      * pixels from ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS to calculate black
3504      * level values for each frame.</p>
3505      *
3506      * @see ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL
3507      * @see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
3508      * @see ACAMERA_SENSOR_INFO_WHITE_LEVEL
3509      * @see ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS
3510      * @see ACAMERA_SENSOR_SENSITIVITY
3511      */
3512     ACAMERA_SENSOR_BLACK_LEVEL_PATTERN =                        // int32[4]
3513             ACAMERA_SENSOR_START + 12,
3514     /**
3515      * <p>Maximum sensitivity that is implemented
3516      * purely through analog gain.</p>
3517      *
3518      * <p>Type: int32</p>
3519      *
3520      * <p>This tag may appear in:
3521      * <ul>
3522      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3523      * </ul></p>
3524      *
3525      * <p>For ACAMERA_SENSOR_SENSITIVITY values less than or
3526      * equal to this, all applied gain must be analog. For
3527      * values above this, the gain applied can be a mix of analog and
3528      * digital.</p>
3529      *
3530      * @see ACAMERA_SENSOR_SENSITIVITY
3531      */
3532     ACAMERA_SENSOR_MAX_ANALOG_SENSITIVITY =                     // int32
3533             ACAMERA_SENSOR_START + 13,
3534     /**
3535      * <p>Clockwise angle through which the output image needs to be rotated to be
3536      * upright on the device screen in its native orientation.</p>
3537      *
3538      * <p>Type: int32</p>
3539      *
3540      * <p>This tag may appear in:
3541      * <ul>
3542      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3543      * </ul></p>
3544      *
3545      * <p>Also defines the direction of rolling shutter readout, which is from top to bottom in
3546      * the sensor's coordinate system.</p>
3547      */
3548     ACAMERA_SENSOR_ORIENTATION =                                // int32
3549             ACAMERA_SENSOR_START + 14,
3550     /**
3551      * <p>Time at start of exposure of first
3552      * row of the image sensor active array, in nanoseconds.</p>
3553      *
3554      * <p>Type: int64</p>
3555      *
3556      * <p>This tag may appear in:
3557      * <ul>
3558      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3559      * </ul></p>
3560      *
3561      * <p>The timestamps are also included in all image
3562      * buffers produced for the same capture, and will be identical
3563      * on all the outputs.</p>
3564      * <p>When ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE <code>==</code> UNKNOWN,
3565      * the timestamps measure time since an unspecified starting point,
3566      * and are monotonically increasing. They can be compared with the
3567      * timestamps for other captures from the same camera device, but are
3568      * not guaranteed to be comparable to any other time source.</p>
3569      * <p>When ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE <code>==</code> REALTIME, the
3570      * timestamps measure time in the same timebase as
3571      * <a href="https://developer.android.com/reference/android/os/SystemClock.html#elapsedRealtimeNanos">elapsedRealtimeNanos</a>
3572      * (or CLOCK_BOOTTIME), and they can
3573      * be compared to other timestamps from other subsystems that
3574      * are using that base.</p>
3575      * <p>For reprocessing, the timestamp will match the start of exposure of
3576      * the input image, i.e. {@link CaptureResult#SENSOR_TIMESTAMP the
3577      * timestamp} in the TotalCaptureResult that was used to create the
3578      * reprocess capture request.</p>
3579      *
3580      * @see ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE
3581      */
3582     ACAMERA_SENSOR_TIMESTAMP =                                  // int64
3583             ACAMERA_SENSOR_START + 16,
3584     /**
3585      * <p>The estimated camera neutral color in the native sensor colorspace at
3586      * the time of capture.</p>
3587      *
3588      * <p>Type: rational[3]</p>
3589      *
3590      * <p>This tag may appear in:
3591      * <ul>
3592      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3593      * </ul></p>
3594      *
3595      * <p>This value gives the neutral color point encoded as an RGB value in the
3596      * native sensor color space.  The neutral color point indicates the
3597      * currently estimated white point of the scene illumination.  It can be
3598      * used to interpolate between the provided color transforms when
3599      * processing raw sensor data.</p>
3600      * <p>The order of the values is R, G, B; where R is in the lowest index.</p>
3601      */
3602     ACAMERA_SENSOR_NEUTRAL_COLOR_POINT =                        // rational[3]
3603             ACAMERA_SENSOR_START + 18,
3604     /**
3605      * <p>Noise model coefficients for each CFA mosaic channel.</p>
3606      *
3607      * <p>Type: double[2*CFA Channels]</p>
3608      *
3609      * <p>This tag may appear in:
3610      * <ul>
3611      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3612      * </ul></p>
3613      *
3614      * <p>This key contains two noise model coefficients for each CFA channel
3615      * corresponding to the sensor amplification (S) and sensor readout
3616      * noise (O).  These are given as pairs of coefficients for each channel
3617      * in the same order as channels listed for the CFA layout key
3618      * (see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT).  This is
3619      * represented as an array of Pair&lt;Double, Double&gt;, where
3620      * the first member of the Pair at index n is the S coefficient and the
3621      * second member is the O coefficient for the nth color channel in the CFA.</p>
3622      * <p>These coefficients are used in a two parameter noise model to describe
3623      * the amount of noise present in the image for each CFA channel.  The
3624      * noise model used here is:</p>
3625      * <p>N(x) = sqrt(Sx + O)</p>
3626      * <p>Where x represents the recorded signal of a CFA channel normalized to
3627      * the range [0, 1], and S and O are the noise model coeffiecients for
3628      * that channel.</p>
3629      * <p>A more detailed description of the noise model can be found in the
3630      * Adobe DNG specification for the NoiseProfile tag.</p>
3631      *
3632      * @see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
3633      */
3634     ACAMERA_SENSOR_NOISE_PROFILE =                              // double[2*CFA Channels]
3635             ACAMERA_SENSOR_START + 19,
3636     /**
3637      * <p>The worst-case divergence between Bayer green channels.</p>
3638      *
3639      * <p>Type: float</p>
3640      *
3641      * <p>This tag may appear in:
3642      * <ul>
3643      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3644      * </ul></p>
3645      *
3646      * <p>This value is an estimate of the worst case split between the
3647      * Bayer green channels in the red and blue rows in the sensor color
3648      * filter array.</p>
3649      * <p>The green split is calculated as follows:</p>
3650      * <ol>
3651      * <li>A 5x5 pixel (or larger) window W within the active sensor array is
3652      * chosen. The term 'pixel' here is taken to mean a group of 4 Bayer
3653      * mosaic channels (R, Gr, Gb, B).  The location and size of the window
3654      * chosen is implementation defined, and should be chosen to provide a
3655      * green split estimate that is both representative of the entire image
3656      * for this camera sensor, and can be calculated quickly.</li>
3657      * <li>The arithmetic mean of the green channels from the red
3658      * rows (mean_Gr) within W is computed.</li>
3659      * <li>The arithmetic mean of the green channels from the blue
3660      * rows (mean_Gb) within W is computed.</li>
3661      * <li>The maximum ratio R of the two means is computed as follows:
3662      * <code>R = max((mean_Gr + 1)/(mean_Gb + 1), (mean_Gb + 1)/(mean_Gr + 1))</code></li>
3663      * </ol>
3664      * <p>The ratio R is the green split divergence reported for this property,
3665      * which represents how much the green channels differ in the mosaic
3666      * pattern.  This value is typically used to determine the treatment of
3667      * the green mosaic channels when demosaicing.</p>
3668      * <p>The green split value can be roughly interpreted as follows:</p>
3669      * <ul>
3670      * <li>R &lt; 1.03 is a negligible split (&lt;3% divergence).</li>
3671      * <li>1.20 &lt;= R &gt;= 1.03 will require some software
3672      * correction to avoid demosaic errors (3-20% divergence).</li>
3673      * <li>R &gt; 1.20 will require strong software correction to produce
3674      * a usuable image (&gt;20% divergence).</li>
3675      * </ul>
3676      */
3677     ACAMERA_SENSOR_GREEN_SPLIT =                                // float
3678             ACAMERA_SENSOR_START + 22,
3679     /**
3680      * <p>A pixel <code>[R, G_even, G_odd, B]</code> that supplies the test pattern
3681      * when ACAMERA_SENSOR_TEST_PATTERN_MODE is SOLID_COLOR.</p>
3682      *
3683      * @see ACAMERA_SENSOR_TEST_PATTERN_MODE
3684      *
3685      * <p>Type: int32[4]</p>
3686      *
3687      * <p>This tag may appear in:
3688      * <ul>
3689      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3690      *   <li>ACaptureRequest</li>
3691      * </ul></p>
3692      *
3693      * <p>Each color channel is treated as an unsigned 32-bit integer.
3694      * The camera device then uses the most significant X bits
3695      * that correspond to how many bits are in its Bayer raw sensor
3696      * output.</p>
3697      * <p>For example, a sensor with RAW10 Bayer output would use the
3698      * 10 most significant bits from each color channel.</p>
3699      */
3700     ACAMERA_SENSOR_TEST_PATTERN_DATA =                          // int32[4]
3701             ACAMERA_SENSOR_START + 23,
3702     /**
3703      * <p>When enabled, the sensor sends a test pattern instead of
3704      * doing a real exposure from the camera.</p>
3705      *
3706      * <p>Type: int32 (acamera_metadata_enum_android_sensor_test_pattern_mode_t)</p>
3707      *
3708      * <p>This tag may appear in:
3709      * <ul>
3710      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3711      *   <li>ACaptureRequest</li>
3712      * </ul></p>
3713      *
3714      * <p>When a test pattern is enabled, all manual sensor controls specified
3715      * by ACAMERA_SENSOR_* will be ignored. All other controls should
3716      * work as normal.</p>
3717      * <p>For example, if manual flash is enabled, flash firing should still
3718      * occur (and that the test pattern remain unmodified, since the flash
3719      * would not actually affect it).</p>
3720      * <p>Defaults to OFF.</p>
3721      */
3722     ACAMERA_SENSOR_TEST_PATTERN_MODE =                          // int32 (acamera_metadata_enum_android_sensor_test_pattern_mode_t)
3723             ACAMERA_SENSOR_START + 24,
3724     /**
3725      * <p>List of sensor test pattern modes for ACAMERA_SENSOR_TEST_PATTERN_MODE
3726      * supported by this camera device.</p>
3727      *
3728      * @see ACAMERA_SENSOR_TEST_PATTERN_MODE
3729      *
3730      * <p>Type: int32[n]</p>
3731      *
3732      * <p>This tag may appear in:
3733      * <ul>
3734      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3735      * </ul></p>
3736      *
3737      * <p>Defaults to OFF, and always includes OFF if defined.</p>
3738      */
3739     ACAMERA_SENSOR_AVAILABLE_TEST_PATTERN_MODES =               // int32[n]
3740             ACAMERA_SENSOR_START + 25,
3741     /**
3742      * <p>Duration between the start of first row exposure
3743      * and the start of last row exposure.</p>
3744      *
3745      * <p>Type: int64</p>
3746      *
3747      * <p>This tag may appear in:
3748      * <ul>
3749      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3750      * </ul></p>
3751      *
3752      * <p>This is the exposure time skew between the first and last
3753      * row exposure start times. The first row and the last row are
3754      * the first and last rows inside of the
3755      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.</p>
3756      * <p>For typical camera sensors that use rolling shutters, this is also equivalent
3757      * to the frame readout time.</p>
3758      *
3759      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
3760      */
3761     ACAMERA_SENSOR_ROLLING_SHUTTER_SKEW =                       // int64
3762             ACAMERA_SENSOR_START + 26,
3763     /**
3764      * <p>List of disjoint rectangles indicating the sensor
3765      * optically shielded black pixel regions.</p>
3766      *
3767      * <p>Type: int32[4*num_regions]</p>
3768      *
3769      * <p>This tag may appear in:
3770      * <ul>
3771      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3772      * </ul></p>
3773      *
3774      * <p>In most camera sensors, the active array is surrounded by some
3775      * optically shielded pixel areas. By blocking light, these pixels
3776      * provides a reliable black reference for black level compensation
3777      * in active array region.</p>
3778      * <p>The data representation is int[4], which maps to (left, top, width, height).</p>
3779      * <p>This key provides a list of disjoint rectangles specifying the
3780      * regions of optically shielded (with metal shield) black pixel
3781      * regions if the camera device is capable of reading out these black
3782      * pixels in the output raw images. In comparison to the fixed black
3783      * level values reported by ACAMERA_SENSOR_BLACK_LEVEL_PATTERN, this key
3784      * may provide a more accurate way for the application to calculate
3785      * black level of each captured raw images.</p>
3786      * <p>When this key is reported, the ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL and
3787      * ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL will also be reported.</p>
3788      *
3789      * @see ACAMERA_SENSOR_BLACK_LEVEL_PATTERN
3790      * @see ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL
3791      * @see ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL
3792      */
3793     ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS =                      // int32[4*num_regions]
3794             ACAMERA_SENSOR_START + 27,
3795     /**
3796      * <p>A per-frame dynamic black level offset for each of the color filter
3797      * arrangement (CFA) mosaic channels.</p>
3798      *
3799      * <p>Type: float[4]</p>
3800      *
3801      * <p>This tag may appear in:
3802      * <ul>
3803      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3804      * </ul></p>
3805      *
3806      * <p>Camera sensor black levels may vary dramatically for different
3807      * capture settings (e.g. ACAMERA_SENSOR_SENSITIVITY). The fixed black
3808      * level reported by ACAMERA_SENSOR_BLACK_LEVEL_PATTERN may be too
3809      * inaccurate to represent the actual value on a per-frame basis. The
3810      * camera device internal pipeline relies on reliable black level values
3811      * to process the raw images appropriately. To get the best image
3812      * quality, the camera device may choose to estimate the per frame black
3813      * level values either based on optically shielded black regions
3814      * (ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS) or its internal model.</p>
3815      * <p>This key reports the camera device estimated per-frame zero light
3816      * value for each of the CFA mosaic channels in the camera sensor. The
3817      * ACAMERA_SENSOR_BLACK_LEVEL_PATTERN may only represent a coarse
3818      * approximation of the actual black level values. This value is the
3819      * black level used in camera device internal image processing pipeline
3820      * and generally more accurate than the fixed black level values.
3821      * However, since they are estimated values by the camera device, they
3822      * may not be as accurate as the black level values calculated from the
3823      * optical black pixels reported by ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS.</p>
3824      * <p>The values are given in the same order as channels listed for the CFA
3825      * layout key (see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT), i.e. the
3826      * nth value given corresponds to the black level offset for the nth
3827      * color channel listed in the CFA.</p>
3828      * <p>This key will be available if ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS is
3829      * available or the camera device advertises this key via
3830      * {@link ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS}.</p>
3831      *
3832      * @see ACAMERA_SENSOR_BLACK_LEVEL_PATTERN
3833      * @see ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
3834      * @see ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS
3835      * @see ACAMERA_SENSOR_SENSITIVITY
3836      */
3837     ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL =                        // float[4]
3838             ACAMERA_SENSOR_START + 28,
3839     /**
3840      * <p>Maximum raw value output by sensor for this frame.</p>
3841      *
3842      * <p>Type: int32</p>
3843      *
3844      * <p>This tag may appear in:
3845      * <ul>
3846      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
3847      * </ul></p>
3848      *
3849      * <p>Since the ACAMERA_SENSOR_BLACK_LEVEL_PATTERN may change for different
3850      * capture settings (e.g., ACAMERA_SENSOR_SENSITIVITY), the white
3851      * level will change accordingly. This key is similar to
3852      * ACAMERA_SENSOR_INFO_WHITE_LEVEL, but specifies the camera device
3853      * estimated white level for each frame.</p>
3854      * <p>This key will be available if ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS is
3855      * available or the camera device advertises this key via
3856      * {@link ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS}.</p>
3857      *
3858      * @see ACAMERA_SENSOR_BLACK_LEVEL_PATTERN
3859      * @see ACAMERA_SENSOR_INFO_WHITE_LEVEL
3860      * @see ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS
3861      * @see ACAMERA_SENSOR_SENSITIVITY
3862      */
3863     ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL =                        // int32
3864             ACAMERA_SENSOR_START + 29,
3865     ACAMERA_SENSOR_END,
3866 
3867     /**
3868      * <p>The area of the image sensor which corresponds to active pixels after any geometric
3869      * distortion correction has been applied.</p>
3870      *
3871      * <p>Type: int32[4]</p>
3872      *
3873      * <p>This tag may appear in:
3874      * <ul>
3875      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3876      * </ul></p>
3877      *
3878      * <p>This is the rectangle representing the size of the active region of the sensor (i.e.
3879      * the region that actually receives light from the scene) after any geometric correction
3880      * has been applied, and should be treated as the maximum size in pixels of any of the
3881      * image output formats aside from the raw formats.</p>
3882      * <p>This rectangle is defined relative to the full pixel array; (0,0) is the top-left of
3883      * the full pixel array, and the size of the full pixel array is given by
3884      * ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE.</p>
3885      * <p>The data representation is int[4], which maps to (left, top, width, height).</p>
3886      * <p>The coordinate system for most other keys that list pixel coordinates, including
3887      * ACAMERA_SCALER_CROP_REGION, is defined relative to the active array rectangle given in
3888      * this field, with <code>(0, 0)</code> being the top-left of this rectangle.</p>
3889      * <p>The active array may be smaller than the full pixel array, since the full array may
3890      * include black calibration pixels or other inactive regions, and geometric correction
3891      * resulting in scaling or cropping may have been applied.</p>
3892      *
3893      * @see ACAMERA_SCALER_CROP_REGION
3894      * @see ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
3895      */
3896     ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE =                     // int32[4]
3897             ACAMERA_SENSOR_INFO_START,
3898     /**
3899      * <p>Range of sensitivities for ACAMERA_SENSOR_SENSITIVITY supported by this
3900      * camera device.</p>
3901      *
3902      * @see ACAMERA_SENSOR_SENSITIVITY
3903      *
3904      * <p>Type: int32[2]</p>
3905      *
3906      * <p>This tag may appear in:
3907      * <ul>
3908      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3909      * </ul></p>
3910      *
3911      * <p>The values are the standard ISO sensitivity values,
3912      * as defined in ISO 12232:2006.</p>
3913      */
3914     ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE =                     // int32[2]
3915             ACAMERA_SENSOR_INFO_START + 1,
3916     /**
3917      * <p>The arrangement of color filters on sensor;
3918      * represents the colors in the top-left 2x2 section of
3919      * the sensor, in reading order.</p>
3920      *
3921      * <p>Type: byte (acamera_metadata_enum_android_sensor_info_color_filter_arrangement_t)</p>
3922      *
3923      * <p>This tag may appear in:
3924      * <ul>
3925      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3926      * </ul></p>
3927      *
3928      */
3929     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT =              // byte (acamera_metadata_enum_android_sensor_info_color_filter_arrangement_t)
3930             ACAMERA_SENSOR_INFO_START + 2,
3931     /**
3932      * <p>The range of image exposure times for ACAMERA_SENSOR_EXPOSURE_TIME supported
3933      * by this camera device.</p>
3934      *
3935      * @see ACAMERA_SENSOR_EXPOSURE_TIME
3936      *
3937      * <p>Type: int64[2]</p>
3938      *
3939      * <p>This tag may appear in:
3940      * <ul>
3941      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3942      * </ul></p>
3943      *
3944      */
3945     ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE =                   // int64[2]
3946             ACAMERA_SENSOR_INFO_START + 3,
3947     /**
3948      * <p>The maximum possible frame duration (minimum frame rate) for
3949      * ACAMERA_SENSOR_FRAME_DURATION that is supported this camera device.</p>
3950      *
3951      * @see ACAMERA_SENSOR_FRAME_DURATION
3952      *
3953      * <p>Type: int64</p>
3954      *
3955      * <p>This tag may appear in:
3956      * <ul>
3957      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3958      * </ul></p>
3959      *
3960      * <p>Attempting to use frame durations beyond the maximum will result in the frame
3961      * duration being clipped to the maximum. See that control for a full definition of frame
3962      * durations.</p>
3963      * <p>Refer to {@link
3964      * ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS}
3965      * for the minimum frame duration values.</p>
3966      */
3967     ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION =                    // int64
3968             ACAMERA_SENSOR_INFO_START + 4,
3969     /**
3970      * <p>The physical dimensions of the full pixel
3971      * array.</p>
3972      *
3973      * <p>Type: float[2]</p>
3974      *
3975      * <p>This tag may appear in:
3976      * <ul>
3977      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3978      * </ul></p>
3979      *
3980      * <p>This is the physical size of the sensor pixel
3981      * array defined by ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE.</p>
3982      *
3983      * @see ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
3984      */
3985     ACAMERA_SENSOR_INFO_PHYSICAL_SIZE =                         // float[2]
3986             ACAMERA_SENSOR_INFO_START + 5,
3987     /**
3988      * <p>Dimensions of the full pixel array, possibly
3989      * including black calibration pixels.</p>
3990      *
3991      * <p>Type: int32[2]</p>
3992      *
3993      * <p>This tag may appear in:
3994      * <ul>
3995      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
3996      * </ul></p>
3997      *
3998      * <p>The pixel count of the full pixel array of the image sensor, which covers
3999      * ACAMERA_SENSOR_INFO_PHYSICAL_SIZE area.  This represents the full pixel dimensions of
4000      * the raw buffers produced by this sensor.</p>
4001      * <p>If a camera device supports raw sensor formats, either this or
4002      * ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE is the maximum dimensions for the raw
4003      * output formats listed in ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS (this depends on
4004      * whether or not the image sensor returns buffers containing pixels that are not
4005      * part of the active array region for blacklevel calibration or other purposes).</p>
4006      * <p>Some parts of the full pixel array may not receive light from the scene,
4007      * or be otherwise inactive.  The ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE key
4008      * defines the rectangle of active pixels that will be included in processed image
4009      * formats.</p>
4010      *
4011      * @see ACAMERA_SENSOR_INFO_PHYSICAL_SIZE
4012      * @see ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE
4013      */
4014     ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE =                      // int32[2]
4015             ACAMERA_SENSOR_INFO_START + 6,
4016     /**
4017      * <p>Maximum raw value output by sensor.</p>
4018      *
4019      * <p>Type: int32</p>
4020      *
4021      * <p>This tag may appear in:
4022      * <ul>
4023      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4024      * </ul></p>
4025      *
4026      * <p>This specifies the fully-saturated encoding level for the raw
4027      * sample values from the sensor.  This is typically caused by the
4028      * sensor becoming highly non-linear or clipping. The minimum for
4029      * each channel is specified by the offset in the
4030      * ACAMERA_SENSOR_BLACK_LEVEL_PATTERN key.</p>
4031      * <p>The white level is typically determined either by sensor bit depth
4032      * (8-14 bits is expected), or by the point where the sensor response
4033      * becomes too non-linear to be useful.  The default value for this is
4034      * maximum representable value for a 16-bit raw sample (2^16 - 1).</p>
4035      * <p>The white level values of captured images may vary for different
4036      * capture settings (e.g., ACAMERA_SENSOR_SENSITIVITY). This key
4037      * represents a coarse approximation for such case. It is recommended
4038      * to use ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL for captures when supported
4039      * by the camera device, which provides more accurate white level values.</p>
4040      *
4041      * @see ACAMERA_SENSOR_BLACK_LEVEL_PATTERN
4042      * @see ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL
4043      * @see ACAMERA_SENSOR_SENSITIVITY
4044      */
4045     ACAMERA_SENSOR_INFO_WHITE_LEVEL =                           // int32
4046             ACAMERA_SENSOR_INFO_START + 7,
4047     /**
4048      * <p>The time base source for sensor capture start timestamps.</p>
4049      *
4050      * <p>Type: byte (acamera_metadata_enum_android_sensor_info_timestamp_source_t)</p>
4051      *
4052      * <p>This tag may appear in:
4053      * <ul>
4054      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4055      * </ul></p>
4056      *
4057      * <p>The timestamps provided for captures are always in nanoseconds and monotonic, but
4058      * may not based on a time source that can be compared to other system time sources.</p>
4059      * <p>This characteristic defines the source for the timestamps, and therefore whether they
4060      * can be compared against other system time sources/timestamps.</p>
4061      */
4062     ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE =                      // byte (acamera_metadata_enum_android_sensor_info_timestamp_source_t)
4063             ACAMERA_SENSOR_INFO_START + 8,
4064     /**
4065      * <p>Whether the RAW images output from this camera device are subject to
4066      * lens shading correction.</p>
4067      *
4068      * <p>Type: byte (acamera_metadata_enum_android_sensor_info_lens_shading_applied_t)</p>
4069      *
4070      * <p>This tag may appear in:
4071      * <ul>
4072      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4073      * </ul></p>
4074      *
4075      * <p>If TRUE, all images produced by the camera device in the RAW image formats will
4076      * have lens shading correction already applied to it. If FALSE, the images will
4077      * not be adjusted for lens shading correction.
4078      * See android.request.maxNumOutputRaw for a list of RAW image formats.</p>
4079      * <p>This key will be <code>null</code> for all devices do not report this information.
4080      * Devices with RAW capability will always report this information in this key.</p>
4081      */
4082     ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED =                  // byte (acamera_metadata_enum_android_sensor_info_lens_shading_applied_t)
4083             ACAMERA_SENSOR_INFO_START + 9,
4084     /**
4085      * <p>The area of the image sensor which corresponds to active pixels prior to the
4086      * application of any geometric distortion correction.</p>
4087      *
4088      * <p>Type: int32[4]</p>
4089      *
4090      * <p>This tag may appear in:
4091      * <ul>
4092      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4093      * </ul></p>
4094      *
4095      * <p>The data representation is int[4], which maps to (left, top, width, height).</p>
4096      * <p>This is the rectangle representing the size of the active region of the sensor (i.e.
4097      * the region that actually receives light from the scene) before any geometric correction
4098      * has been applied, and should be treated as the active region rectangle for any of the
4099      * raw formats.  All metadata associated with raw processing (e.g. the lens shading
4100      * correction map, and radial distortion fields) treats the top, left of this rectangle as
4101      * the origin, (0,0).</p>
4102      * <p>The size of this region determines the maximum field of view and the maximum number of
4103      * pixels that an image from this sensor can contain, prior to the application of
4104      * geometric distortion correction. The effective maximum pixel dimensions of a
4105      * post-distortion-corrected image is given by the ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
4106      * field, and the effective maximum field of view for a post-distortion-corrected image
4107      * can be calculated by applying the geometric distortion correction fields to this
4108      * rectangle, and cropping to the rectangle given in ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.</p>
4109      * <p>E.g. to calculate position of a pixel, (x,y), in a processed YUV output image with the
4110      * dimensions in ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE given the position of a pixel,
4111      * (x', y'), in the raw pixel array with dimensions give in
4112      * ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE:</p>
4113      * <ol>
4114      * <li>Choose a pixel (x', y') within the active array region of the raw buffer given in
4115      * ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE, otherwise this pixel is considered
4116      * to be outside of the FOV, and will not be shown in the processed output image.</li>
4117      * <li>Apply geometric distortion correction to get the post-distortion pixel coordinate,
4118      * (x_i, y_i). When applying geometric correction metadata, note that metadata for raw
4119      * buffers is defined relative to the top, left of the
4120      * ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE rectangle.</li>
4121      * <li>If the resulting corrected pixel coordinate is within the region given in
4122      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE, then the position of this pixel in the
4123      * processed output image buffer is <code>(x_i - activeArray.left, y_i - activeArray.top)</code>,
4124      * when the top, left coordinate of that buffer is treated as (0, 0).</li>
4125      * </ol>
4126      * <p>Thus, for pixel x',y' = (25, 25) on a sensor where ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
4127      * is (100,100), ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE is (10, 10, 100, 100),
4128      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE is (20, 20, 80, 80), and the geometric distortion
4129      * correction doesn't change the pixel coordinate, the resulting pixel selected in
4130      * pixel coordinates would be x,y = (25, 25) relative to the top,left of the raw buffer
4131      * with dimensions given in ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE, and would be (5, 5)
4132      * relative to the top,left of post-processed YUV output buffer with dimensions given in
4133      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.</p>
4134      * <p>The currently supported fields that correct for geometric distortion are:</p>
4135      * <ol>
4136      * <li>ACAMERA_LENS_RADIAL_DISTORTION.</li>
4137      * </ol>
4138      * <p>If all of the geometric distortion fields are no-ops, this rectangle will be the same
4139      * as the post-distortion-corrected rectangle given in
4140      * ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.</p>
4141      * <p>This rectangle is defined relative to the full pixel array; (0,0) is the top-left of
4142      * the full pixel array, and the size of the full pixel array is given by
4143      * ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE.</p>
4144      * <p>The pre-correction active array may be smaller than the full pixel array, since the
4145      * full array may include black calibration pixels or other inactive regions.</p>
4146      *
4147      * @see ACAMERA_LENS_RADIAL_DISTORTION
4148      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
4149      * @see ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
4150      * @see ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE
4151      */
4152     ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE =      // int32[4]
4153             ACAMERA_SENSOR_INFO_START + 10,
4154     ACAMERA_SENSOR_INFO_END,
4155 
4156     /**
4157      * <p>Quality of lens shading correction applied
4158      * to the image data.</p>
4159      *
4160      * <p>Type: byte (acamera_metadata_enum_android_shading_mode_t)</p>
4161      *
4162      * <p>This tag may appear in:
4163      * <ul>
4164      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4165      *   <li>ACaptureRequest</li>
4166      * </ul></p>
4167      *
4168      * <p>When set to OFF mode, no lens shading correction will be applied by the
4169      * camera device, and an identity lens shading map data will be provided
4170      * if <code>ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE == ON</code>. For example, for lens
4171      * shading map with size of <code>[ 4, 3 ]</code>,
4172      * the output android.statistics.lensShadingCorrectionMap for this case will be an identity
4173      * map shown below:</p>
4174      * <pre><code>[ 1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0,
4175      *  1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0,
4176      *  1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0,
4177      *  1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0,
4178      *  1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0,
4179      *  1.0, 1.0, 1.0, 1.0,  1.0, 1.0, 1.0, 1.0 ]
4180      * </code></pre>
4181      * <p>When set to other modes, lens shading correction will be applied by the camera
4182      * device. Applications can request lens shading map data by setting
4183      * ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE to ON, and then the camera device will provide lens
4184      * shading map data in android.statistics.lensShadingCorrectionMap; the returned shading map
4185      * data will be the one applied by the camera device for this capture request.</p>
4186      * <p>The shading map data may depend on the auto-exposure (AE) and AWB statistics, therefore
4187      * the reliability of the map data may be affected by the AE and AWB algorithms. When AE and
4188      * AWB are in AUTO modes(ACAMERA_CONTROL_AE_MODE <code>!=</code> OFF and ACAMERA_CONTROL_AWB_MODE <code>!=</code>
4189      * OFF), to get best results, it is recommended that the applications wait for the AE and AWB
4190      * to be converged before using the returned shading map data.</p>
4191      *
4192      * @see ACAMERA_CONTROL_AE_MODE
4193      * @see ACAMERA_CONTROL_AWB_MODE
4194      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
4195      */
4196     ACAMERA_SHADING_MODE =                                      // byte (acamera_metadata_enum_android_shading_mode_t)
4197             ACAMERA_SHADING_START,
4198     /**
4199      * <p>List of lens shading modes for ACAMERA_SHADING_MODE that are supported by this camera device.</p>
4200      *
4201      * @see ACAMERA_SHADING_MODE
4202      *
4203      * <p>Type: byte[n]</p>
4204      *
4205      * <p>This tag may appear in:
4206      * <ul>
4207      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4208      * </ul></p>
4209      *
4210      * <p>This list contains lens shading modes that can be set for the camera device.
4211      * Camera devices that support the MANUAL_POST_PROCESSING capability will always
4212      * list OFF and FAST mode. This includes all FULL level devices.
4213      * LEGACY devices will always only support FAST mode.</p>
4214      */
4215     ACAMERA_SHADING_AVAILABLE_MODES =                           // byte[n]
4216             ACAMERA_SHADING_START + 2,
4217     ACAMERA_SHADING_END,
4218 
4219     /**
4220      * <p>Operating mode for the face detector
4221      * unit.</p>
4222      *
4223      * <p>Type: byte (acamera_metadata_enum_android_statistics_face_detect_mode_t)</p>
4224      *
4225      * <p>This tag may appear in:
4226      * <ul>
4227      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4228      *   <li>ACaptureRequest</li>
4229      * </ul></p>
4230      *
4231      * <p>Whether face detection is enabled, and whether it
4232      * should output just the basic fields or the full set of
4233      * fields.</p>
4234      */
4235     ACAMERA_STATISTICS_FACE_DETECT_MODE =                       // byte (acamera_metadata_enum_android_statistics_face_detect_mode_t)
4236             ACAMERA_STATISTICS_START,
4237     /**
4238      * <p>Operating mode for hot pixel map generation.</p>
4239      *
4240      * <p>Type: byte (acamera_metadata_enum_android_statistics_hot_pixel_map_mode_t)</p>
4241      *
4242      * <p>This tag may appear in:
4243      * <ul>
4244      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4245      *   <li>ACaptureRequest</li>
4246      * </ul></p>
4247      *
4248      * <p>If set to <code>true</code>, a hot pixel map is returned in ACAMERA_STATISTICS_HOT_PIXEL_MAP.
4249      * If set to <code>false</code>, no hot pixel map will be returned.</p>
4250      *
4251      * @see ACAMERA_STATISTICS_HOT_PIXEL_MAP
4252      */
4253     ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE =                     // byte (acamera_metadata_enum_android_statistics_hot_pixel_map_mode_t)
4254             ACAMERA_STATISTICS_START + 3,
4255     /**
4256      * <p>List of unique IDs for detected faces.</p>
4257      *
4258      * <p>Type: int32[n]</p>
4259      *
4260      * <p>This tag may appear in:
4261      * <ul>
4262      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4263      * </ul></p>
4264      *
4265      * <p>Each detected face is given a unique ID that is valid for as long as the face is visible
4266      * to the camera device.  A face that leaves the field of view and later returns may be
4267      * assigned a new ID.</p>
4268      * <p>Only available if ACAMERA_STATISTICS_FACE_DETECT_MODE == FULL</p>
4269      *
4270      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
4271      */
4272     ACAMERA_STATISTICS_FACE_IDS =                               // int32[n]
4273             ACAMERA_STATISTICS_START + 4,
4274     /**
4275      * <p>List of landmarks for detected
4276      * faces.</p>
4277      *
4278      * <p>Type: int32[n*6]</p>
4279      *
4280      * <p>This tag may appear in:
4281      * <ul>
4282      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4283      * </ul></p>
4284      *
4285      * <p>The coordinate system is that of ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE, with
4286      * <code>(0, 0)</code> being the top-left pixel of the active array.</p>
4287      * <p>Only available if ACAMERA_STATISTICS_FACE_DETECT_MODE == FULL</p>
4288      *
4289      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
4290      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
4291      */
4292     ACAMERA_STATISTICS_FACE_LANDMARKS =                         // int32[n*6]
4293             ACAMERA_STATISTICS_START + 5,
4294     /**
4295      * <p>List of the bounding rectangles for detected
4296      * faces.</p>
4297      *
4298      * <p>Type: int32[n*4]</p>
4299      *
4300      * <p>This tag may appear in:
4301      * <ul>
4302      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4303      * </ul></p>
4304      *
4305      * <p>The data representation is int[4], which maps to (left, top, width, height).</p>
4306      * <p>The coordinate system is that of ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE, with
4307      * <code>(0, 0)</code> being the top-left pixel of the active array.</p>
4308      * <p>Only available if ACAMERA_STATISTICS_FACE_DETECT_MODE != OFF</p>
4309      *
4310      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
4311      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
4312      */
4313     ACAMERA_STATISTICS_FACE_RECTANGLES =                        // int32[n*4]
4314             ACAMERA_STATISTICS_START + 6,
4315     /**
4316      * <p>List of the face confidence scores for
4317      * detected faces</p>
4318      *
4319      * <p>Type: byte[n]</p>
4320      *
4321      * <p>This tag may appear in:
4322      * <ul>
4323      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4324      * </ul></p>
4325      *
4326      * <p>Only available if ACAMERA_STATISTICS_FACE_DETECT_MODE != OFF.</p>
4327      *
4328      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
4329      */
4330     ACAMERA_STATISTICS_FACE_SCORES =                            // byte[n]
4331             ACAMERA_STATISTICS_START + 7,
4332     /**
4333      * <p>The shading map is a low-resolution floating-point map
4334      * that lists the coefficients used to correct for vignetting and color shading,
4335      * for each Bayer color channel of RAW image data.</p>
4336      *
4337      * <p>Type: float[4*n*m]</p>
4338      *
4339      * <p>This tag may appear in:
4340      * <ul>
4341      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4342      * </ul></p>
4343      *
4344      * <p>The map provided here is the same map that is used by the camera device to
4345      * correct both color shading and vignetting for output non-RAW images.</p>
4346      * <p>When there is no lens shading correction applied to RAW
4347      * output images (ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED <code>==</code>
4348      * false), this map is the complete lens shading correction
4349      * map; when there is some lens shading correction applied to
4350      * the RAW output image (ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED<code>==</code> true), this map reports the remaining lens shading
4351      * correction map that needs to be applied to get shading
4352      * corrected images that match the camera device's output for
4353      * non-RAW formats.</p>
4354      * <p>For a complete shading correction map, the least shaded
4355      * section of the image will have a gain factor of 1; all
4356      * other sections will have gains above 1.</p>
4357      * <p>When ACAMERA_COLOR_CORRECTION_MODE = TRANSFORM_MATRIX, the map
4358      * will take into account the colorCorrection settings.</p>
4359      * <p>The shading map is for the entire active pixel array, and is not
4360      * affected by the crop region specified in the request. Each shading map
4361      * entry is the value of the shading compensation map over a specific
4362      * pixel on the sensor.  Specifically, with a (N x M) resolution shading
4363      * map, and an active pixel array size (W x H), shading map entry
4364      * (x,y) ϵ (0 ... N-1, 0 ... M-1) is the value of the shading map at
4365      * pixel ( ((W-1)/(N-1)) * x, ((H-1)/(M-1)) * y) for the four color channels.
4366      * The map is assumed to be bilinearly interpolated between the sample points.</p>
4367      * <p>The channel order is [R, Geven, Godd, B], where Geven is the green
4368      * channel for the even rows of a Bayer pattern, and Godd is the odd rows.
4369      * The shading map is stored in a fully interleaved format, and its size
4370      * is provided in the camera static metadata by ACAMERA_LENS_INFO_SHADING_MAP_SIZE.</p>
4371      * <p>The shading map will generally have on the order of 30-40 rows and columns,
4372      * and will be smaller than 64x64.</p>
4373      * <p>As an example, given a very small map defined as:</p>
4374      * <pre><code>ACAMERA_LENS_INFO_SHADING_MAP_SIZE = [ 4, 3 ]
4375      * ACAMERA_STATISTICS_LENS_SHADING_MAP =
4376      * [ 1.3, 1.2, 1.15, 1.2,  1.2, 1.2, 1.15, 1.2,
4377      *     1.1, 1.2, 1.2, 1.2,  1.3, 1.2, 1.3, 1.3,
4378      *   1.2, 1.2, 1.25, 1.1,  1.1, 1.1, 1.1, 1.0,
4379      *     1.0, 1.0, 1.0, 1.0,  1.2, 1.3, 1.25, 1.2,
4380      *   1.3, 1.2, 1.2, 1.3,   1.2, 1.15, 1.1, 1.2,
4381      *     1.2, 1.1, 1.0, 1.2,  1.3, 1.15, 1.2, 1.3 ]
4382      * </code></pre>
4383      * <p>The low-resolution scaling map images for each channel are
4384      * (displayed using nearest-neighbor interpolation):</p>
4385      * <p><img alt="Red lens shading map" src="../images/camera2/metadata/android.statistics.lensShadingMap/red_shading.png" />
4386      * <img alt="Green (even rows) lens shading map" src="../images/camera2/metadata/android.statistics.lensShadingMap/green_e_shading.png" />
4387      * <img alt="Green (odd rows) lens shading map" src="../images/camera2/metadata/android.statistics.lensShadingMap/green_o_shading.png" />
4388      * <img alt="Blue lens shading map" src="../images/camera2/metadata/android.statistics.lensShadingMap/blue_shading.png" /></p>
4389      * <p>As a visualization only, inverting the full-color map to recover an
4390      * image of a gray wall (using bicubic interpolation for visual quality)
4391      * as captured by the sensor gives:</p>
4392      * <p><img alt="Image of a uniform white wall (inverse shading map)" src="../images/camera2/metadata/android.statistics.lensShadingMap/inv_shading.png" /></p>
4393      * <p>Note that the RAW image data might be subject to lens shading
4394      * correction not reported on this map. Query
4395      * ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED to see if RAW image data has subject
4396      * to lens shading correction. If ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED
4397      * is TRUE, the RAW image data is subject to partial or full lens shading
4398      * correction. In the case full lens shading correction is applied to RAW
4399      * images, the gain factor map reported in this key will contain all 1.0 gains.
4400      * In other words, the map reported in this key is the remaining lens shading
4401      * that needs to be applied on the RAW image to get images without lens shading
4402      * artifacts. See android.request.maxNumOutputRaw for a list of RAW image
4403      * formats.</p>
4404      *
4405      * @see ACAMERA_COLOR_CORRECTION_MODE
4406      * @see ACAMERA_LENS_INFO_SHADING_MAP_SIZE
4407      * @see ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED
4408      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP
4409      */
4410     ACAMERA_STATISTICS_LENS_SHADING_MAP =                       // float[4*n*m]
4411             ACAMERA_STATISTICS_START + 11,
4412     /**
4413      * <p>The camera device estimated scene illumination lighting
4414      * frequency.</p>
4415      *
4416      * <p>Type: byte (acamera_metadata_enum_android_statistics_scene_flicker_t)</p>
4417      *
4418      * <p>This tag may appear in:
4419      * <ul>
4420      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4421      * </ul></p>
4422      *
4423      * <p>Many light sources, such as most fluorescent lights, flicker at a rate
4424      * that depends on the local utility power standards. This flicker must be
4425      * accounted for by auto-exposure routines to avoid artifacts in captured images.
4426      * The camera device uses this entry to tell the application what the scene
4427      * illuminant frequency is.</p>
4428      * <p>When manual exposure control is enabled
4429      * (<code>ACAMERA_CONTROL_AE_MODE == OFF</code> or <code>ACAMERA_CONTROL_MODE ==
4430      * OFF</code>), the ACAMERA_CONTROL_AE_ANTIBANDING_MODE doesn't perform
4431      * antibanding, and the application can ensure it selects
4432      * exposure times that do not cause banding issues by looking
4433      * into this metadata field. See
4434      * ACAMERA_CONTROL_AE_ANTIBANDING_MODE for more details.</p>
4435      * <p>Reports NONE if there doesn't appear to be flickering illumination.</p>
4436      *
4437      * @see ACAMERA_CONTROL_AE_ANTIBANDING_MODE
4438      * @see ACAMERA_CONTROL_AE_MODE
4439      * @see ACAMERA_CONTROL_MODE
4440      */
4441     ACAMERA_STATISTICS_SCENE_FLICKER =                          // byte (acamera_metadata_enum_android_statistics_scene_flicker_t)
4442             ACAMERA_STATISTICS_START + 14,
4443     /**
4444      * <p>List of <code>(x, y)</code> coordinates of hot/defective pixels on the sensor.</p>
4445      *
4446      * <p>Type: int32[2*n]</p>
4447      *
4448      * <p>This tag may appear in:
4449      * <ul>
4450      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4451      * </ul></p>
4452      *
4453      * <p>A coordinate <code>(x, y)</code> must lie between <code>(0, 0)</code>, and
4454      * <code>(width - 1, height - 1)</code> (inclusive), which are the top-left and
4455      * bottom-right of the pixel array, respectively. The width and
4456      * height dimensions are given in ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE.
4457      * This may include hot pixels that lie outside of the active array
4458      * bounds given by ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE.</p>
4459      *
4460      * @see ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE
4461      * @see ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
4462      */
4463     ACAMERA_STATISTICS_HOT_PIXEL_MAP =                          // int32[2*n]
4464             ACAMERA_STATISTICS_START + 15,
4465     /**
4466      * <p>Whether the camera device will output the lens
4467      * shading map in output result metadata.</p>
4468      *
4469      * <p>Type: byte (acamera_metadata_enum_android_statistics_lens_shading_map_mode_t)</p>
4470      *
4471      * <p>This tag may appear in:
4472      * <ul>
4473      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4474      *   <li>ACaptureRequest</li>
4475      * </ul></p>
4476      *
4477      * <p>When set to ON,
4478      * ACAMERA_STATISTICS_LENS_SHADING_MAP will be provided in
4479      * the output result metadata.</p>
4480      * <p>ON is always supported on devices with the RAW capability.</p>
4481      *
4482      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP
4483      */
4484     ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE =                  // byte (acamera_metadata_enum_android_statistics_lens_shading_map_mode_t)
4485             ACAMERA_STATISTICS_START + 16,
4486     ACAMERA_STATISTICS_END,
4487 
4488     /**
4489      * <p>List of face detection modes for ACAMERA_STATISTICS_FACE_DETECT_MODE that are
4490      * supported by this camera device.</p>
4491      *
4492      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
4493      *
4494      * <p>Type: byte[n]</p>
4495      *
4496      * <p>This tag may appear in:
4497      * <ul>
4498      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4499      * </ul></p>
4500      *
4501      * <p>OFF is always supported.</p>
4502      */
4503     ACAMERA_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES =       // byte[n]
4504             ACAMERA_STATISTICS_INFO_START,
4505     /**
4506      * <p>The maximum number of simultaneously detectable
4507      * faces.</p>
4508      *
4509      * <p>Type: int32</p>
4510      *
4511      * <p>This tag may appear in:
4512      * <ul>
4513      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4514      * </ul></p>
4515      *
4516      */
4517     ACAMERA_STATISTICS_INFO_MAX_FACE_COUNT =                    // int32
4518             ACAMERA_STATISTICS_INFO_START + 2,
4519     /**
4520      * <p>List of hot pixel map output modes for ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE that are
4521      * supported by this camera device.</p>
4522      *
4523      * @see ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE
4524      *
4525      * <p>Type: byte[n]</p>
4526      *
4527      * <p>This tag may appear in:
4528      * <ul>
4529      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4530      * </ul></p>
4531      *
4532      * <p>If no hotpixel map output is available for this camera device, this will contain only
4533      * <code>false</code>.</p>
4534      * <p>ON is always supported on devices with the RAW capability.</p>
4535      */
4536     ACAMERA_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES =     // byte[n]
4537             ACAMERA_STATISTICS_INFO_START + 6,
4538     /**
4539      * <p>List of lens shading map output modes for ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE that
4540      * are supported by this camera device.</p>
4541      *
4542      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
4543      *
4544      * <p>Type: byte[n]</p>
4545      *
4546      * <p>This tag may appear in:
4547      * <ul>
4548      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4549      * </ul></p>
4550      *
4551      * <p>If no lens shading map output is available for this camera device, this key will
4552      * contain only OFF.</p>
4553      * <p>ON is always supported on devices with the RAW capability.
4554      * LEGACY mode devices will always only support OFF.</p>
4555      */
4556     ACAMERA_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES =  // byte[n]
4557             ACAMERA_STATISTICS_INFO_START + 7,
4558     ACAMERA_STATISTICS_INFO_END,
4559 
4560     /**
4561      * <p>Tonemapping / contrast / gamma curve for the blue
4562      * channel, to use when ACAMERA_TONEMAP_MODE is
4563      * CONTRAST_CURVE.</p>
4564      *
4565      * @see ACAMERA_TONEMAP_MODE
4566      *
4567      * <p>Type: float[n*2]</p>
4568      *
4569      * <p>This tag may appear in:
4570      * <ul>
4571      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4572      *   <li>ACaptureRequest</li>
4573      * </ul></p>
4574      *
4575      * <p>See ACAMERA_TONEMAP_CURVE_RED for more details.</p>
4576      *
4577      * @see ACAMERA_TONEMAP_CURVE_RED
4578      */
4579     ACAMERA_TONEMAP_CURVE_BLUE =                                // float[n*2]
4580             ACAMERA_TONEMAP_START,
4581     /**
4582      * <p>Tonemapping / contrast / gamma curve for the green
4583      * channel, to use when ACAMERA_TONEMAP_MODE is
4584      * CONTRAST_CURVE.</p>
4585      *
4586      * @see ACAMERA_TONEMAP_MODE
4587      *
4588      * <p>Type: float[n*2]</p>
4589      *
4590      * <p>This tag may appear in:
4591      * <ul>
4592      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4593      *   <li>ACaptureRequest</li>
4594      * </ul></p>
4595      *
4596      * <p>See ACAMERA_TONEMAP_CURVE_RED for more details.</p>
4597      *
4598      * @see ACAMERA_TONEMAP_CURVE_RED
4599      */
4600     ACAMERA_TONEMAP_CURVE_GREEN =                               // float[n*2]
4601             ACAMERA_TONEMAP_START + 1,
4602     /**
4603      * <p>Tonemapping / contrast / gamma curve for the red
4604      * channel, to use when ACAMERA_TONEMAP_MODE is
4605      * CONTRAST_CURVE.</p>
4606      *
4607      * @see ACAMERA_TONEMAP_MODE
4608      *
4609      * <p>Type: float[n*2]</p>
4610      *
4611      * <p>This tag may appear in:
4612      * <ul>
4613      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4614      *   <li>ACaptureRequest</li>
4615      * </ul></p>
4616      *
4617      * <p>Each channel's curve is defined by an array of control points:</p>
4618      * <pre><code>ACAMERA_TONEMAP_CURVE_RED =
4619      *   [ P0in, P0out, P1in, P1out, P2in, P2out, P3in, P3out, ..., PNin, PNout ]
4620      * 2 &lt;= N &lt;= ACAMERA_TONEMAP_MAX_CURVE_POINTS</code></pre>
4621      * <p>These are sorted in order of increasing <code>Pin</code>; it is
4622      * required that input values 0.0 and 1.0 are included in the list to
4623      * define a complete mapping. For input values between control points,
4624      * the camera device must linearly interpolate between the control
4625      * points.</p>
4626      * <p>Each curve can have an independent number of points, and the number
4627      * of points can be less than max (that is, the request doesn't have to
4628      * always provide a curve with number of points equivalent to
4629      * ACAMERA_TONEMAP_MAX_CURVE_POINTS).</p>
4630      * <p>A few examples, and their corresponding graphical mappings; these
4631      * only specify the red channel and the precision is limited to 4
4632      * digits, for conciseness.</p>
4633      * <p>Linear mapping:</p>
4634      * <pre><code>ACAMERA_TONEMAP_CURVE_RED = [ 0, 0, 1.0, 1.0 ]
4635      * </code></pre>
4636      * <p><img alt="Linear mapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/linear_tonemap.png" /></p>
4637      * <p>Invert mapping:</p>
4638      * <pre><code>ACAMERA_TONEMAP_CURVE_RED = [ 0, 1.0, 1.0, 0 ]
4639      * </code></pre>
4640      * <p><img alt="Inverting mapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/inverse_tonemap.png" /></p>
4641      * <p>Gamma 1/2.2 mapping, with 16 control points:</p>
4642      * <pre><code>ACAMERA_TONEMAP_CURVE_RED = [
4643      *   0.0000, 0.0000, 0.0667, 0.2920, 0.1333, 0.4002, 0.2000, 0.4812,
4644      *   0.2667, 0.5484, 0.3333, 0.6069, 0.4000, 0.6594, 0.4667, 0.7072,
4645      *   0.5333, 0.7515, 0.6000, 0.7928, 0.6667, 0.8317, 0.7333, 0.8685,
4646      *   0.8000, 0.9035, 0.8667, 0.9370, 0.9333, 0.9691, 1.0000, 1.0000 ]
4647      * </code></pre>
4648      * <p><img alt="Gamma = 1/2.2 tonemapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/gamma_tonemap.png" /></p>
4649      * <p>Standard sRGB gamma mapping, per IEC 61966-2-1:1999, with 16 control points:</p>
4650      * <pre><code>ACAMERA_TONEMAP_CURVE_RED = [
4651      *   0.0000, 0.0000, 0.0667, 0.2864, 0.1333, 0.4007, 0.2000, 0.4845,
4652      *   0.2667, 0.5532, 0.3333, 0.6125, 0.4000, 0.6652, 0.4667, 0.7130,
4653      *   0.5333, 0.7569, 0.6000, 0.7977, 0.6667, 0.8360, 0.7333, 0.8721,
4654      *   0.8000, 0.9063, 0.8667, 0.9389, 0.9333, 0.9701, 1.0000, 1.0000 ]
4655      * </code></pre>
4656      * <p><img alt="sRGB tonemapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/srgb_tonemap.png" /></p>
4657      *
4658      * @see ACAMERA_TONEMAP_CURVE_RED
4659      * @see ACAMERA_TONEMAP_MAX_CURVE_POINTS
4660      */
4661     ACAMERA_TONEMAP_CURVE_RED =                                 // float[n*2]
4662             ACAMERA_TONEMAP_START + 2,
4663     /**
4664      * <p>High-level global contrast/gamma/tonemapping control.</p>
4665      *
4666      * <p>Type: byte (acamera_metadata_enum_android_tonemap_mode_t)</p>
4667      *
4668      * <p>This tag may appear in:
4669      * <ul>
4670      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4671      *   <li>ACaptureRequest</li>
4672      * </ul></p>
4673      *
4674      * <p>When switching to an application-defined contrast curve by setting
4675      * ACAMERA_TONEMAP_MODE to CONTRAST_CURVE, the curve is defined
4676      * per-channel with a set of <code>(in, out)</code> points that specify the
4677      * mapping from input high-bit-depth pixel value to the output
4678      * low-bit-depth value.  Since the actual pixel ranges of both input
4679      * and output may change depending on the camera pipeline, the values
4680      * are specified by normalized floating-point numbers.</p>
4681      * <p>More-complex color mapping operations such as 3D color look-up
4682      * tables, selective chroma enhancement, or other non-linear color
4683      * transforms will be disabled when ACAMERA_TONEMAP_MODE is
4684      * CONTRAST_CURVE.</p>
4685      * <p>When using either FAST or HIGH_QUALITY, the camera device will
4686      * emit its own tonemap curve in android.tonemap.curve.
4687      * These values are always available, and as close as possible to the
4688      * actually used nonlinear/nonglobal transforms.</p>
4689      * <p>If a request is sent with CONTRAST_CURVE with the camera device's
4690      * provided curve in FAST or HIGH_QUALITY, the image's tonemap will be
4691      * roughly the same.</p>
4692      *
4693      * @see ACAMERA_TONEMAP_MODE
4694      */
4695     ACAMERA_TONEMAP_MODE =                                      // byte (acamera_metadata_enum_android_tonemap_mode_t)
4696             ACAMERA_TONEMAP_START + 3,
4697     /**
4698      * <p>Maximum number of supported points in the
4699      * tonemap curve that can be used for android.tonemap.curve.</p>
4700      *
4701      * <p>Type: int32</p>
4702      *
4703      * <p>This tag may appear in:
4704      * <ul>
4705      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4706      * </ul></p>
4707      *
4708      * <p>If the actual number of points provided by the application (in ACAMERA_TONEMAPCURVE_*) is
4709      * less than this maximum, the camera device will resample the curve to its internal
4710      * representation, using linear interpolation.</p>
4711      * <p>The output curves in the result metadata may have a different number
4712      * of points than the input curves, and will represent the actual
4713      * hardware curves used as closely as possible when linearly interpolated.</p>
4714      */
4715     ACAMERA_TONEMAP_MAX_CURVE_POINTS =                          // int32
4716             ACAMERA_TONEMAP_START + 4,
4717     /**
4718      * <p>List of tonemapping modes for ACAMERA_TONEMAP_MODE that are supported by this camera
4719      * device.</p>
4720      *
4721      * @see ACAMERA_TONEMAP_MODE
4722      *
4723      * <p>Type: byte[n]</p>
4724      *
4725      * <p>This tag may appear in:
4726      * <ul>
4727      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4728      * </ul></p>
4729      *
4730      * <p>Camera devices that support the MANUAL_POST_PROCESSING capability will always contain
4731      * at least one of below mode combinations:</p>
4732      * <ul>
4733      * <li>CONTRAST_CURVE, FAST and HIGH_QUALITY</li>
4734      * <li>GAMMA_VALUE, PRESET_CURVE, FAST and HIGH_QUALITY</li>
4735      * </ul>
4736      * <p>This includes all FULL level devices.</p>
4737      */
4738     ACAMERA_TONEMAP_AVAILABLE_TONE_MAP_MODES =                  // byte[n]
4739             ACAMERA_TONEMAP_START + 5,
4740     /**
4741      * <p>Tonemapping curve to use when ACAMERA_TONEMAP_MODE is
4742      * GAMMA_VALUE</p>
4743      *
4744      * @see ACAMERA_TONEMAP_MODE
4745      *
4746      * <p>Type: float</p>
4747      *
4748      * <p>This tag may appear in:
4749      * <ul>
4750      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4751      *   <li>ACaptureRequest</li>
4752      * </ul></p>
4753      *
4754      * <p>The tonemap curve will be defined the following formula:
4755      * * OUT = pow(IN, 1.0 / gamma)
4756      * where IN and OUT is the input pixel value scaled to range [0.0, 1.0],
4757      * pow is the power function and gamma is the gamma value specified by this
4758      * key.</p>
4759      * <p>The same curve will be applied to all color channels. The camera device
4760      * may clip the input gamma value to its supported range. The actual applied
4761      * value will be returned in capture result.</p>
4762      * <p>The valid range of gamma value varies on different devices, but values
4763      * within [1.0, 5.0] are guaranteed not to be clipped.</p>
4764      */
4765     ACAMERA_TONEMAP_GAMMA =                                     // float
4766             ACAMERA_TONEMAP_START + 6,
4767     /**
4768      * <p>Tonemapping curve to use when ACAMERA_TONEMAP_MODE is
4769      * PRESET_CURVE</p>
4770      *
4771      * @see ACAMERA_TONEMAP_MODE
4772      *
4773      * <p>Type: byte (acamera_metadata_enum_android_tonemap_preset_curve_t)</p>
4774      *
4775      * <p>This tag may appear in:
4776      * <ul>
4777      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4778      *   <li>ACaptureRequest</li>
4779      * </ul></p>
4780      *
4781      * <p>The tonemap curve will be defined by specified standard.</p>
4782      * <p>sRGB (approximated by 16 control points):</p>
4783      * <p><img alt="sRGB tonemapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/srgb_tonemap.png" /></p>
4784      * <p>Rec. 709 (approximated by 16 control points):</p>
4785      * <p><img alt="Rec. 709 tonemapping curve" src="../images/camera2/metadata/android.tonemap.curveRed/rec709_tonemap.png" /></p>
4786      * <p>Note that above figures show a 16 control points approximation of preset
4787      * curves. Camera devices may apply a different approximation to the curve.</p>
4788      */
4789     ACAMERA_TONEMAP_PRESET_CURVE =                              // byte (acamera_metadata_enum_android_tonemap_preset_curve_t)
4790             ACAMERA_TONEMAP_START + 7,
4791     ACAMERA_TONEMAP_END,
4792 
4793     /**
4794      * <p>Generally classifies the overall set of the camera device functionality.</p>
4795      *
4796      * <p>Type: byte (acamera_metadata_enum_android_info_supported_hardware_level_t)</p>
4797      *
4798      * <p>This tag may appear in:
4799      * <ul>
4800      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4801      * </ul></p>
4802      *
4803      * <p>The supported hardware level is a high-level description of the camera device's
4804      * capabilities, summarizing several capabilities into one field.  Each level adds additional
4805      * features to the previous one, and is always a strict superset of the previous level.
4806      * The ordering is <code>LEGACY &lt; LIMITED &lt; FULL &lt; LEVEL_3</code>.</p>
4807      * <p>Starting from <code>LEVEL_3</code>, the level enumerations are guaranteed to be in increasing
4808      * numerical value as well. To check if a given device is at least at a given hardware level,
4809      * the following code snippet can be used:</p>
4810      * <pre><code>// Returns true if the device supports the required hardware level, or better.
4811      * boolean isHardwareLevelSupported(CameraCharacteristics c, int requiredLevel) {
4812      *     int deviceLevel = c.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
4813      *     if (deviceLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
4814      *         return requiredLevel == deviceLevel;
4815      *     }
4816      *     // deviceLevel is not LEGACY, can use numerical sort
4817      *     return requiredLevel &lt;= deviceLevel;
4818      * }
4819      * </code></pre>
4820      * <p>At a high level, the levels are:</p>
4821      * <ul>
4822      * <li><code>LEGACY</code> devices operate in a backwards-compatibility mode for older
4823      *   Android devices, and have very limited capabilities.</li>
4824      * <li><code>LIMITED</code> devices represent the
4825      *   baseline feature set, and may also include additional capabilities that are
4826      *   subsets of <code>FULL</code>.</li>
4827      * <li><code>FULL</code> devices additionally support per-frame manual control of sensor, flash, lens and
4828      *   post-processing settings, and image capture at a high rate.</li>
4829      * <li><code>LEVEL_3</code> devices additionally support YUV reprocessing and RAW image capture, along
4830      *   with additional output stream configurations.</li>
4831      * </ul>
4832      * <p>See the individual level enums for full descriptions of the supported capabilities.  The
4833      * ACAMERA_REQUEST_AVAILABLE_CAPABILITIES entry describes the device's capabilities at a
4834      * finer-grain level, if needed. In addition, many controls have their available settings or
4835      * ranges defined in individual metadata tag entries in this document.</p>
4836      * <p>Some features are not part of any particular hardware level or capability and must be
4837      * queried separately. These include:</p>
4838      * <ul>
4839      * <li>Calibrated timestamps (ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE <code>==</code> REALTIME)</li>
4840      * <li>Precision lens control (ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION <code>==</code> CALIBRATED)</li>
4841      * <li>Face detection (ACAMERA_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES)</li>
4842      * <li>Optical or electrical image stabilization
4843      *   (ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
4844      *    ACAMERA_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES)</li>
4845      * </ul>
4846      *
4847      * @see ACAMERA_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES
4848      * @see ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION
4849      * @see ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION
4850      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
4851      * @see ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE
4852      * @see ACAMERA_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES
4853      */
4854     ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL =                     // byte (acamera_metadata_enum_android_info_supported_hardware_level_t)
4855             ACAMERA_INFO_START,
4856     ACAMERA_INFO_END,
4857 
4858     /**
4859      * <p>Whether black-level compensation is locked
4860      * to its current values, or is free to vary.</p>
4861      *
4862      * <p>Type: byte (acamera_metadata_enum_android_black_level_lock_t)</p>
4863      *
4864      * <p>This tag may appear in:
4865      * <ul>
4866      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4867      *   <li>ACaptureRequest</li>
4868      * </ul></p>
4869      *
4870      * <p>Whether the black level offset was locked for this frame.  Should be
4871      * ON if ACAMERA_BLACK_LEVEL_LOCK was ON in the capture request, unless
4872      * a change in other capture settings forced the camera device to
4873      * perform a black level reset.</p>
4874      *
4875      * @see ACAMERA_BLACK_LEVEL_LOCK
4876      */
4877     ACAMERA_BLACK_LEVEL_LOCK =                                  // byte (acamera_metadata_enum_android_black_level_lock_t)
4878             ACAMERA_BLACK_LEVEL_START,
4879     ACAMERA_BLACK_LEVEL_END,
4880 
4881     /**
4882      * <p>The frame number corresponding to the last request
4883      * with which the output result (metadata + buffers) has been fully
4884      * synchronized.</p>
4885      *
4886      * <p>Type: int64 (acamera_metadata_enum_android_sync_frame_number_t)</p>
4887      *
4888      * <p>This tag may appear in:
4889      * <ul>
4890      *   <li>ACameraMetadata from ACameraCaptureSession_captureCallback_result callbacks</li>
4891      * </ul></p>
4892      *
4893      * <p>When a request is submitted to the camera device, there is usually a
4894      * delay of several frames before the controls get applied. A camera
4895      * device may either choose to account for this delay by implementing a
4896      * pipeline and carefully submit well-timed atomic control updates, or
4897      * it may start streaming control changes that span over several frame
4898      * boundaries.</p>
4899      * <p>In the latter case, whenever a request's settings change relative to
4900      * the previous submitted request, the full set of changes may take
4901      * multiple frame durations to fully take effect. Some settings may
4902      * take effect sooner (in less frame durations) than others.</p>
4903      * <p>While a set of control changes are being propagated, this value
4904      * will be CONVERGING.</p>
4905      * <p>Once it is fully known that a set of control changes have been
4906      * finished propagating, and the resulting updated control settings
4907      * have been read back by the camera device, this value will be set
4908      * to a non-negative frame number (corresponding to the request to
4909      * which the results have synchronized to).</p>
4910      * <p>Older camera device implementations may not have a way to detect
4911      * when all camera controls have been applied, and will always set this
4912      * value to UNKNOWN.</p>
4913      * <p>FULL capability devices will always have this value set to the
4914      * frame number of the request corresponding to this result.</p>
4915      * <p><em>Further details</em>:</p>
4916      * <ul>
4917      * <li>Whenever a request differs from the last request, any future
4918      * results not yet returned may have this value set to CONVERGING (this
4919      * could include any in-progress captures not yet returned by the camera
4920      * device, for more details see pipeline considerations below).</li>
4921      * <li>Submitting a series of multiple requests that differ from the
4922      * previous request (e.g. r1, r2, r3 s.t. r1 != r2 != r3)
4923      * moves the new synchronization frame to the last non-repeating
4924      * request (using the smallest frame number from the contiguous list of
4925      * repeating requests).</li>
4926      * <li>Submitting the same request repeatedly will not change this value
4927      * to CONVERGING, if it was already a non-negative value.</li>
4928      * <li>When this value changes to non-negative, that means that all of the
4929      * metadata controls from the request have been applied, all of the
4930      * metadata controls from the camera device have been read to the
4931      * updated values (into the result), and all of the graphics buffers
4932      * corresponding to this result are also synchronized to the request.</li>
4933      * </ul>
4934      * <p><em>Pipeline considerations</em>:</p>
4935      * <p>Submitting a request with updated controls relative to the previously
4936      * submitted requests may also invalidate the synchronization state
4937      * of all the results corresponding to currently in-flight requests.</p>
4938      * <p>In other words, results for this current request and up to
4939      * ACAMERA_REQUEST_PIPELINE_MAX_DEPTH prior requests may have their
4940      * ACAMERA_SYNC_FRAME_NUMBER change to CONVERGING.</p>
4941      *
4942      * @see ACAMERA_REQUEST_PIPELINE_MAX_DEPTH
4943      * @see ACAMERA_SYNC_FRAME_NUMBER
4944      */
4945     ACAMERA_SYNC_FRAME_NUMBER =                                 // int64 (acamera_metadata_enum_android_sync_frame_number_t)
4946             ACAMERA_SYNC_START,
4947     /**
4948      * <p>The maximum number of frames that can occur after a request
4949      * (different than the previous) has been submitted, and before the
4950      * result's state becomes synchronized.</p>
4951      *
4952      * <p>Type: int32 (acamera_metadata_enum_android_sync_max_latency_t)</p>
4953      *
4954      * <p>This tag may appear in:
4955      * <ul>
4956      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4957      * </ul></p>
4958      *
4959      * <p>This defines the maximum distance (in number of metadata results),
4960      * between the frame number of the request that has new controls to apply
4961      * and the frame number of the result that has all the controls applied.</p>
4962      * <p>In other words this acts as an upper boundary for how many frames
4963      * must occur before the camera device knows for a fact that the new
4964      * submitted camera settings have been applied in outgoing frames.</p>
4965      */
4966     ACAMERA_SYNC_MAX_LATENCY =                                  // int32 (acamera_metadata_enum_android_sync_max_latency_t)
4967             ACAMERA_SYNC_START + 1,
4968     ACAMERA_SYNC_END,
4969 
4970     /**
4971      * <p>The available depth dataspace stream
4972      * configurations that this camera device supports
4973      * (i.e. format, width, height, output/input stream).</p>
4974      *
4975      * <p>Type: int32[n*4] (acamera_metadata_enum_android_depth_available_depth_stream_configurations_t)</p>
4976      *
4977      * <p>This tag may appear in:
4978      * <ul>
4979      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
4980      * </ul></p>
4981      *
4982      * <p>These are output stream configurations for use with
4983      * dataSpace HAL_DATASPACE_DEPTH. The configurations are
4984      * listed as <code>(format, width, height, input?)</code> tuples.</p>
4985      * <p>Only devices that support depth output for at least
4986      * the HAL_PIXEL_FORMAT_Y16 dense depth map may include
4987      * this entry.</p>
4988      * <p>A device that also supports the HAL_PIXEL_FORMAT_BLOB
4989      * sparse depth point cloud must report a single entry for
4990      * the format in this list as <code>(HAL_PIXEL_FORMAT_BLOB,
4991      * android.depth.maxDepthSamples, 1, OUTPUT)</code> in addition to
4992      * the entries for HAL_PIXEL_FORMAT_Y16.</p>
4993      */
4994     ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS =       // int32[n*4] (acamera_metadata_enum_android_depth_available_depth_stream_configurations_t)
4995             ACAMERA_DEPTH_START + 1,
4996     /**
4997      * <p>This lists the minimum frame duration for each
4998      * format/size combination for depth output formats.</p>
4999      *
5000      * <p>Type: int64[4*n]</p>
5001      *
5002      * <p>This tag may appear in:
5003      * <ul>
5004      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
5005      * </ul></p>
5006      *
5007      * <p>This should correspond to the frame duration when only that
5008      * stream is active, with all processing (typically in android.*.mode)
5009      * set to either OFF or FAST.</p>
5010      * <p>When multiple streams are used in a request, the minimum frame
5011      * duration will be max(individual stream min durations).</p>
5012      * <p>The minimum frame duration of a stream (of a particular format, size)
5013      * is the same regardless of whether the stream is input or output.</p>
5014      * <p>See ACAMERA_SENSOR_FRAME_DURATION and
5015      * ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS for more details about
5016      * calculating the max frame rate.</p>
5017      *
5018      * @see ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS
5019      * @see ACAMERA_SENSOR_FRAME_DURATION
5020      */
5021     ACAMERA_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS =         // int64[4*n]
5022             ACAMERA_DEPTH_START + 2,
5023     /**
5024      * <p>This lists the maximum stall duration for each
5025      * output format/size combination for depth streams.</p>
5026      *
5027      * <p>Type: int64[4*n]</p>
5028      *
5029      * <p>This tag may appear in:
5030      * <ul>
5031      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
5032      * </ul></p>
5033      *
5034      * <p>A stall duration is how much extra time would get added
5035      * to the normal minimum frame duration for a repeating request
5036      * that has streams with non-zero stall.</p>
5037      * <p>This functions similarly to
5038      * ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS for depth
5039      * streams.</p>
5040      * <p>All depth output stream formats may have a nonzero stall
5041      * duration.</p>
5042      *
5043      * @see ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS
5044      */
5045     ACAMERA_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS =             // int64[4*n]
5046             ACAMERA_DEPTH_START + 3,
5047     /**
5048      * <p>Indicates whether a capture request may target both a
5049      * DEPTH16 / DEPTH_POINT_CLOUD output, and normal color outputs (such as
5050      * YUV_420_888, JPEG, or RAW) simultaneously.</p>
5051      *
5052      * <p>Type: byte (acamera_metadata_enum_android_depth_depth_is_exclusive_t)</p>
5053      *
5054      * <p>This tag may appear in:
5055      * <ul>
5056      *   <li>ACameraMetadata from ACameraManager_getCameraCharacteristics</li>
5057      * </ul></p>
5058      *
5059      * <p>If TRUE, including both depth and color outputs in a single
5060      * capture request is not supported. An application must interleave color
5061      * and depth requests.  If FALSE, a single request can target both types
5062      * of output.</p>
5063      * <p>Typically, this restriction exists on camera devices that
5064      * need to emit a specific pattern or wavelength of light to
5065      * measure depth values, which causes the color image to be
5066      * corrupted during depth measurement.</p>
5067      */
5068     ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE =                          // byte (acamera_metadata_enum_android_depth_depth_is_exclusive_t)
5069             ACAMERA_DEPTH_START + 4,
5070     ACAMERA_DEPTH_END,
5071 
5072 } acamera_metadata_tag_t;
5073 
5074 /**
5075  * Enumeration definitions for the various entries that need them
5076  */
5077 
5078 // ACAMERA_COLOR_CORRECTION_MODE
5079 typedef enum acamera_metadata_enum_acamera_color_correction_mode {
5080     /**
5081      * <p>Use the ACAMERA_COLOR_CORRECTION_TRANSFORM matrix
5082      * and ACAMERA_COLOR_CORRECTION_GAINS to do color conversion.</p>
5083      * <p>All advanced white balance adjustments (not specified
5084      * by our white balance pipeline) must be disabled.</p>
5085      * <p>If AWB is enabled with <code>ACAMERA_CONTROL_AWB_MODE != OFF</code>, then
5086      * TRANSFORM_MATRIX is ignored. The camera device will override
5087      * this value to either FAST or HIGH_QUALITY.</p>
5088      *
5089      * @see ACAMERA_COLOR_CORRECTION_GAINS
5090      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5091      * @see ACAMERA_CONTROL_AWB_MODE
5092      */
5093     ACAMERA_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX                   = 0,
5094 
5095     /**
5096      * <p>Color correction processing must not slow down
5097      * capture rate relative to sensor raw output.</p>
5098      * <p>Advanced white balance adjustments above and beyond
5099      * the specified white balance pipeline may be applied.</p>
5100      * <p>If AWB is enabled with <code>ACAMERA_CONTROL_AWB_MODE != OFF</code>, then
5101      * the camera device uses the last frame's AWB values
5102      * (or defaults if AWB has never been run).</p>
5103      *
5104      * @see ACAMERA_CONTROL_AWB_MODE
5105      */
5106     ACAMERA_COLOR_CORRECTION_MODE_FAST                               = 1,
5107 
5108     /**
5109      * <p>Color correction processing operates at improved
5110      * quality but the capture rate might be reduced (relative to sensor
5111      * raw output rate)</p>
5112      * <p>Advanced white balance adjustments above and beyond
5113      * the specified white balance pipeline may be applied.</p>
5114      * <p>If AWB is enabled with <code>ACAMERA_CONTROL_AWB_MODE != OFF</code>, then
5115      * the camera device uses the last frame's AWB values
5116      * (or defaults if AWB has never been run).</p>
5117      *
5118      * @see ACAMERA_CONTROL_AWB_MODE
5119      */
5120     ACAMERA_COLOR_CORRECTION_MODE_HIGH_QUALITY                       = 2,
5121 
5122 } acamera_metadata_enum_android_color_correction_mode_t;
5123 
5124 // ACAMERA_COLOR_CORRECTION_ABERRATION_MODE
5125 typedef enum acamera_metadata_enum_acamera_color_correction_aberration_mode {
5126     /**
5127      * <p>No aberration correction is applied.</p>
5128      */
5129     ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_OFF                     = 0,
5130 
5131     /**
5132      * <p>Aberration correction will not slow down capture rate
5133      * relative to sensor raw output.</p>
5134      */
5135     ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_FAST                    = 1,
5136 
5137     /**
5138      * <p>Aberration correction operates at improved quality but the capture rate might be
5139      * reduced (relative to sensor raw output rate)</p>
5140      */
5141     ACAMERA_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY            = 2,
5142 
5143 } acamera_metadata_enum_android_color_correction_aberration_mode_t;
5144 
5145 
5146 // ACAMERA_CONTROL_AE_ANTIBANDING_MODE
5147 typedef enum acamera_metadata_enum_acamera_control_ae_antibanding_mode {
5148     /**
5149      * <p>The camera device will not adjust exposure duration to
5150      * avoid banding problems.</p>
5151      */
5152     ACAMERA_CONTROL_AE_ANTIBANDING_MODE_OFF                          = 0,
5153 
5154     /**
5155      * <p>The camera device will adjust exposure duration to
5156      * avoid banding problems with 50Hz illumination sources.</p>
5157      */
5158     ACAMERA_CONTROL_AE_ANTIBANDING_MODE_50HZ                         = 1,
5159 
5160     /**
5161      * <p>The camera device will adjust exposure duration to
5162      * avoid banding problems with 60Hz illumination
5163      * sources.</p>
5164      */
5165     ACAMERA_CONTROL_AE_ANTIBANDING_MODE_60HZ                         = 2,
5166 
5167     /**
5168      * <p>The camera device will automatically adapt its
5169      * antibanding routine to the current illumination
5170      * condition. This is the default mode if AUTO is
5171      * available on given camera device.</p>
5172      */
5173     ACAMERA_CONTROL_AE_ANTIBANDING_MODE_AUTO                         = 3,
5174 
5175 } acamera_metadata_enum_android_control_ae_antibanding_mode_t;
5176 
5177 // ACAMERA_CONTROL_AE_LOCK
5178 typedef enum acamera_metadata_enum_acamera_control_ae_lock {
5179     /**
5180      * <p>Auto-exposure lock is disabled; the AE algorithm
5181      * is free to update its parameters.</p>
5182      */
5183     ACAMERA_CONTROL_AE_LOCK_OFF                                      = 0,
5184 
5185     /**
5186      * <p>Auto-exposure lock is enabled; the AE algorithm
5187      * must not update the exposure and sensitivity parameters
5188      * while the lock is active.</p>
5189      * <p>ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION setting changes
5190      * will still take effect while auto-exposure is locked.</p>
5191      * <p>Some rare LEGACY devices may not support
5192      * this, in which case the value will always be overridden to OFF.</p>
5193      *
5194      * @see ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION
5195      */
5196     ACAMERA_CONTROL_AE_LOCK_ON                                       = 1,
5197 
5198 } acamera_metadata_enum_android_control_ae_lock_t;
5199 
5200 // ACAMERA_CONTROL_AE_MODE
5201 typedef enum acamera_metadata_enum_acamera_control_ae_mode {
5202     /**
5203      * <p>The camera device's autoexposure routine is disabled.</p>
5204      * <p>The application-selected ACAMERA_SENSOR_EXPOSURE_TIME,
5205      * ACAMERA_SENSOR_SENSITIVITY and
5206      * ACAMERA_SENSOR_FRAME_DURATION are used by the camera
5207      * device, along with ACAMERA_FLASH_* fields, if there's
5208      * a flash unit for this camera device.</p>
5209      * <p>Note that auto-white balance (AWB) and auto-focus (AF)
5210      * behavior is device dependent when AE is in OFF mode.
5211      * To have consistent behavior across different devices,
5212      * it is recommended to either set AWB and AF to OFF mode
5213      * or lock AWB and AF before setting AE to OFF.
5214      * See ACAMERA_CONTROL_AWB_MODE, ACAMERA_CONTROL_AF_MODE,
5215      * ACAMERA_CONTROL_AWB_LOCK, and ACAMERA_CONTROL_AF_TRIGGER
5216      * for more details.</p>
5217      * <p>LEGACY devices do not support the OFF mode and will
5218      * override attempts to use this value to ON.</p>
5219      *
5220      * @see ACAMERA_CONTROL_AF_MODE
5221      * @see ACAMERA_CONTROL_AF_TRIGGER
5222      * @see ACAMERA_CONTROL_AWB_LOCK
5223      * @see ACAMERA_CONTROL_AWB_MODE
5224      * @see ACAMERA_SENSOR_EXPOSURE_TIME
5225      * @see ACAMERA_SENSOR_FRAME_DURATION
5226      * @see ACAMERA_SENSOR_SENSITIVITY
5227      */
5228     ACAMERA_CONTROL_AE_MODE_OFF                                      = 0,
5229 
5230     /**
5231      * <p>The camera device's autoexposure routine is active,
5232      * with no flash control.</p>
5233      * <p>The application's values for
5234      * ACAMERA_SENSOR_EXPOSURE_TIME,
5235      * ACAMERA_SENSOR_SENSITIVITY, and
5236      * ACAMERA_SENSOR_FRAME_DURATION are ignored. The
5237      * application has control over the various
5238      * ACAMERA_FLASH_* fields.</p>
5239      *
5240      * @see ACAMERA_SENSOR_EXPOSURE_TIME
5241      * @see ACAMERA_SENSOR_FRAME_DURATION
5242      * @see ACAMERA_SENSOR_SENSITIVITY
5243      */
5244     ACAMERA_CONTROL_AE_MODE_ON                                       = 1,
5245 
5246     /**
5247      * <p>Like ON, except that the camera device also controls
5248      * the camera's flash unit, firing it in low-light
5249      * conditions.</p>
5250      * <p>The flash may be fired during a precapture sequence
5251      * (triggered by ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER) and
5252      * may be fired for captures for which the
5253      * ACAMERA_CONTROL_CAPTURE_INTENT field is set to
5254      * STILL_CAPTURE</p>
5255      *
5256      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
5257      * @see ACAMERA_CONTROL_CAPTURE_INTENT
5258      */
5259     ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH                            = 2,
5260 
5261     /**
5262      * <p>Like ON, except that the camera device also controls
5263      * the camera's flash unit, always firing it for still
5264      * captures.</p>
5265      * <p>The flash may be fired during a precapture sequence
5266      * (triggered by ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER) and
5267      * will always be fired for captures for which the
5268      * ACAMERA_CONTROL_CAPTURE_INTENT field is set to
5269      * STILL_CAPTURE</p>
5270      *
5271      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
5272      * @see ACAMERA_CONTROL_CAPTURE_INTENT
5273      */
5274     ACAMERA_CONTROL_AE_MODE_ON_ALWAYS_FLASH                          = 3,
5275 
5276     /**
5277      * <p>Like ON_AUTO_FLASH, but with automatic red eye
5278      * reduction.</p>
5279      * <p>If deemed necessary by the camera device, a red eye
5280      * reduction flash will fire during the precapture
5281      * sequence.</p>
5282      */
5283     ACAMERA_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE                     = 4,
5284 
5285 } acamera_metadata_enum_android_control_ae_mode_t;
5286 
5287 // ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
5288 typedef enum acamera_metadata_enum_acamera_control_ae_precapture_trigger {
5289     /**
5290      * <p>The trigger is idle.</p>
5291      */
5292     ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE                       = 0,
5293 
5294     /**
5295      * <p>The precapture metering sequence will be started
5296      * by the camera device.</p>
5297      * <p>The exact effect of the precapture trigger depends on
5298      * the current AE mode and state.</p>
5299      */
5300     ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_START                      = 1,
5301 
5302     /**
5303      * <p>The camera device will cancel any currently active or completed
5304      * precapture metering sequence, the auto-exposure routine will return to its
5305      * initial state.</p>
5306      */
5307     ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL                     = 2,
5308 
5309 } acamera_metadata_enum_android_control_ae_precapture_trigger_t;
5310 
5311 // ACAMERA_CONTROL_AF_MODE
5312 typedef enum acamera_metadata_enum_acamera_control_af_mode {
5313     /**
5314      * <p>The auto-focus routine does not control the lens;
5315      * ACAMERA_LENS_FOCUS_DISTANCE is controlled by the
5316      * application.</p>
5317      *
5318      * @see ACAMERA_LENS_FOCUS_DISTANCE
5319      */
5320     ACAMERA_CONTROL_AF_MODE_OFF                                      = 0,
5321 
5322     /**
5323      * <p>Basic automatic focus mode.</p>
5324      * <p>In this mode, the lens does not move unless
5325      * the autofocus trigger action is called. When that trigger
5326      * is activated, AF will transition to ACTIVE_SCAN, then to
5327      * the outcome of the scan (FOCUSED or NOT_FOCUSED).</p>
5328      * <p>Always supported if lens is not fixed focus.</p>
5329      * <p>Use ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE to determine if lens
5330      * is fixed-focus.</p>
5331      * <p>Triggering AF_CANCEL resets the lens position to default,
5332      * and sets the AF state to INACTIVE.</p>
5333      *
5334      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
5335      */
5336     ACAMERA_CONTROL_AF_MODE_AUTO                                     = 1,
5337 
5338     /**
5339      * <p>Close-up focusing mode.</p>
5340      * <p>In this mode, the lens does not move unless the
5341      * autofocus trigger action is called. When that trigger is
5342      * activated, AF will transition to ACTIVE_SCAN, then to
5343      * the outcome of the scan (FOCUSED or NOT_FOCUSED). This
5344      * mode is optimized for focusing on objects very close to
5345      * the camera.</p>
5346      * <p>When that trigger is activated, AF will transition to
5347      * ACTIVE_SCAN, then to the outcome of the scan (FOCUSED or
5348      * NOT_FOCUSED). Triggering cancel AF resets the lens
5349      * position to default, and sets the AF state to
5350      * INACTIVE.</p>
5351      */
5352     ACAMERA_CONTROL_AF_MODE_MACRO                                    = 2,
5353 
5354     /**
5355      * <p>In this mode, the AF algorithm modifies the lens
5356      * position continually to attempt to provide a
5357      * constantly-in-focus image stream.</p>
5358      * <p>The focusing behavior should be suitable for good quality
5359      * video recording; typically this means slower focus
5360      * movement and no overshoots. When the AF trigger is not
5361      * involved, the AF algorithm should start in INACTIVE state,
5362      * and then transition into PASSIVE_SCAN and PASSIVE_FOCUSED
5363      * states as appropriate. When the AF trigger is activated,
5364      * the algorithm should immediately transition into
5365      * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the
5366      * lens position until a cancel AF trigger is received.</p>
5367      * <p>Once cancel is received, the algorithm should transition
5368      * back to INACTIVE and resume passive scan. Note that this
5369      * behavior is not identical to CONTINUOUS_PICTURE, since an
5370      * ongoing PASSIVE_SCAN must immediately be
5371      * canceled.</p>
5372      */
5373     ACAMERA_CONTROL_AF_MODE_CONTINUOUS_VIDEO                         = 3,
5374 
5375     /**
5376      * <p>In this mode, the AF algorithm modifies the lens
5377      * position continually to attempt to provide a
5378      * constantly-in-focus image stream.</p>
5379      * <p>The focusing behavior should be suitable for still image
5380      * capture; typically this means focusing as fast as
5381      * possible. When the AF trigger is not involved, the AF
5382      * algorithm should start in INACTIVE state, and then
5383      * transition into PASSIVE_SCAN and PASSIVE_FOCUSED states as
5384      * appropriate as it attempts to maintain focus. When the AF
5385      * trigger is activated, the algorithm should finish its
5386      * PASSIVE_SCAN if active, and then transition into
5387      * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the
5388      * lens position until a cancel AF trigger is received.</p>
5389      * <p>When the AF cancel trigger is activated, the algorithm
5390      * should transition back to INACTIVE and then act as if it
5391      * has just been started.</p>
5392      */
5393     ACAMERA_CONTROL_AF_MODE_CONTINUOUS_PICTURE                       = 4,
5394 
5395     /**
5396      * <p>Extended depth of field (digital focus) mode.</p>
5397      * <p>The camera device will produce images with an extended
5398      * depth of field automatically; no special focusing
5399      * operations need to be done before taking a picture.</p>
5400      * <p>AF triggers are ignored, and the AF state will always be
5401      * INACTIVE.</p>
5402      */
5403     ACAMERA_CONTROL_AF_MODE_EDOF                                     = 5,
5404 
5405 } acamera_metadata_enum_android_control_af_mode_t;
5406 
5407 // ACAMERA_CONTROL_AF_TRIGGER
5408 typedef enum acamera_metadata_enum_acamera_control_af_trigger {
5409     /**
5410      * <p>The trigger is idle.</p>
5411      */
5412     ACAMERA_CONTROL_AF_TRIGGER_IDLE                                  = 0,
5413 
5414     /**
5415      * <p>Autofocus will trigger now.</p>
5416      */
5417     ACAMERA_CONTROL_AF_TRIGGER_START                                 = 1,
5418 
5419     /**
5420      * <p>Autofocus will return to its initial
5421      * state, and cancel any currently active trigger.</p>
5422      */
5423     ACAMERA_CONTROL_AF_TRIGGER_CANCEL                                = 2,
5424 
5425 } acamera_metadata_enum_android_control_af_trigger_t;
5426 
5427 // ACAMERA_CONTROL_AWB_LOCK
5428 typedef enum acamera_metadata_enum_acamera_control_awb_lock {
5429     /**
5430      * <p>Auto-white balance lock is disabled; the AWB
5431      * algorithm is free to update its parameters if in AUTO
5432      * mode.</p>
5433      */
5434     ACAMERA_CONTROL_AWB_LOCK_OFF                                     = 0,
5435 
5436     /**
5437      * <p>Auto-white balance lock is enabled; the AWB
5438      * algorithm will not update its parameters while the lock
5439      * is active.</p>
5440      */
5441     ACAMERA_CONTROL_AWB_LOCK_ON                                      = 1,
5442 
5443 } acamera_metadata_enum_android_control_awb_lock_t;
5444 
5445 // ACAMERA_CONTROL_AWB_MODE
5446 typedef enum acamera_metadata_enum_acamera_control_awb_mode {
5447     /**
5448      * <p>The camera device's auto-white balance routine is disabled.</p>
5449      * <p>The application-selected color transform matrix
5450      * (ACAMERA_COLOR_CORRECTION_TRANSFORM) and gains
5451      * (ACAMERA_COLOR_CORRECTION_GAINS) are used by the camera
5452      * device for manual white balance control.</p>
5453      *
5454      * @see ACAMERA_COLOR_CORRECTION_GAINS
5455      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5456      */
5457     ACAMERA_CONTROL_AWB_MODE_OFF                                     = 0,
5458 
5459     /**
5460      * <p>The camera device's auto-white balance routine is active.</p>
5461      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5462      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5463      * For devices that support the MANUAL_POST_PROCESSING capability, the
5464      * values used by the camera device for the transform and gains
5465      * will be available in the capture result for this request.</p>
5466      *
5467      * @see ACAMERA_COLOR_CORRECTION_GAINS
5468      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5469      */
5470     ACAMERA_CONTROL_AWB_MODE_AUTO                                    = 1,
5471 
5472     /**
5473      * <p>The camera device's auto-white balance routine is disabled;
5474      * the camera device uses incandescent light as the assumed scene
5475      * illumination for white balance.</p>
5476      * <p>While the exact white balance transforms are up to the
5477      * camera device, they will approximately match the CIE
5478      * standard illuminant A.</p>
5479      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5480      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5481      * For devices that support the MANUAL_POST_PROCESSING capability, the
5482      * values used by the camera device for the transform and gains
5483      * will be available in the capture result for this request.</p>
5484      *
5485      * @see ACAMERA_COLOR_CORRECTION_GAINS
5486      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5487      */
5488     ACAMERA_CONTROL_AWB_MODE_INCANDESCENT                            = 2,
5489 
5490     /**
5491      * <p>The camera device's auto-white balance routine is disabled;
5492      * the camera device uses fluorescent light as the assumed scene
5493      * illumination for white balance.</p>
5494      * <p>While the exact white balance transforms are up to the
5495      * camera device, they will approximately match the CIE
5496      * standard illuminant F2.</p>
5497      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5498      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5499      * For devices that support the MANUAL_POST_PROCESSING capability, the
5500      * values used by the camera device for the transform and gains
5501      * will be available in the capture result for this request.</p>
5502      *
5503      * @see ACAMERA_COLOR_CORRECTION_GAINS
5504      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5505      */
5506     ACAMERA_CONTROL_AWB_MODE_FLUORESCENT                             = 3,
5507 
5508     /**
5509      * <p>The camera device's auto-white balance routine is disabled;
5510      * the camera device uses warm fluorescent light as the assumed scene
5511      * illumination for white balance.</p>
5512      * <p>While the exact white balance transforms are up to the
5513      * camera device, they will approximately match the CIE
5514      * standard illuminant F4.</p>
5515      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5516      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5517      * For devices that support the MANUAL_POST_PROCESSING capability, the
5518      * values used by the camera device for the transform and gains
5519      * will be available in the capture result for this request.</p>
5520      *
5521      * @see ACAMERA_COLOR_CORRECTION_GAINS
5522      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5523      */
5524     ACAMERA_CONTROL_AWB_MODE_WARM_FLUORESCENT                        = 4,
5525 
5526     /**
5527      * <p>The camera device's auto-white balance routine is disabled;
5528      * the camera device uses daylight light as the assumed scene
5529      * illumination for white balance.</p>
5530      * <p>While the exact white balance transforms are up to the
5531      * camera device, they will approximately match the CIE
5532      * standard illuminant D65.</p>
5533      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5534      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5535      * For devices that support the MANUAL_POST_PROCESSING capability, the
5536      * values used by the camera device for the transform and gains
5537      * will be available in the capture result for this request.</p>
5538      *
5539      * @see ACAMERA_COLOR_CORRECTION_GAINS
5540      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5541      */
5542     ACAMERA_CONTROL_AWB_MODE_DAYLIGHT                                = 5,
5543 
5544     /**
5545      * <p>The camera device's auto-white balance routine is disabled;
5546      * the camera device uses cloudy daylight light as the assumed scene
5547      * illumination for white balance.</p>
5548      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5549      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5550      * For devices that support the MANUAL_POST_PROCESSING capability, the
5551      * values used by the camera device for the transform and gains
5552      * will be available in the capture result for this request.</p>
5553      *
5554      * @see ACAMERA_COLOR_CORRECTION_GAINS
5555      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5556      */
5557     ACAMERA_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT                         = 6,
5558 
5559     /**
5560      * <p>The camera device's auto-white balance routine is disabled;
5561      * the camera device uses twilight light as the assumed scene
5562      * illumination for white balance.</p>
5563      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5564      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5565      * For devices that support the MANUAL_POST_PROCESSING capability, the
5566      * values used by the camera device for the transform and gains
5567      * will be available in the capture result for this request.</p>
5568      *
5569      * @see ACAMERA_COLOR_CORRECTION_GAINS
5570      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5571      */
5572     ACAMERA_CONTROL_AWB_MODE_TWILIGHT                                = 7,
5573 
5574     /**
5575      * <p>The camera device's auto-white balance routine is disabled;
5576      * the camera device uses shade light as the assumed scene
5577      * illumination for white balance.</p>
5578      * <p>The application's values for ACAMERA_COLOR_CORRECTION_TRANSFORM
5579      * and ACAMERA_COLOR_CORRECTION_GAINS are ignored.
5580      * For devices that support the MANUAL_POST_PROCESSING capability, the
5581      * values used by the camera device for the transform and gains
5582      * will be available in the capture result for this request.</p>
5583      *
5584      * @see ACAMERA_COLOR_CORRECTION_GAINS
5585      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
5586      */
5587     ACAMERA_CONTROL_AWB_MODE_SHADE                                   = 8,
5588 
5589 } acamera_metadata_enum_android_control_awb_mode_t;
5590 
5591 // ACAMERA_CONTROL_CAPTURE_INTENT
5592 typedef enum acamera_metadata_enum_acamera_control_capture_intent {
5593     /**
5594      * <p>The goal of this request doesn't fall into the other
5595      * categories. The camera device will default to preview-like
5596      * behavior.</p>
5597      */
5598     ACAMERA_CONTROL_CAPTURE_INTENT_CUSTOM                            = 0,
5599 
5600     /**
5601      * <p>This request is for a preview-like use case.</p>
5602      * <p>The precapture trigger may be used to start off a metering
5603      * w/flash sequence.</p>
5604      */
5605     ACAMERA_CONTROL_CAPTURE_INTENT_PREVIEW                           = 1,
5606 
5607     /**
5608      * <p>This request is for a still capture-type
5609      * use case.</p>
5610      * <p>If the flash unit is under automatic control, it may fire as needed.</p>
5611      */
5612     ACAMERA_CONTROL_CAPTURE_INTENT_STILL_CAPTURE                     = 2,
5613 
5614     /**
5615      * <p>This request is for a video recording
5616      * use case.</p>
5617      */
5618     ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_RECORD                      = 3,
5619 
5620     /**
5621      * <p>This request is for a video snapshot (still
5622      * image while recording video) use case.</p>
5623      * <p>The camera device should take the highest-quality image
5624      * possible (given the other settings) without disrupting the
5625      * frame rate of video recording.  </p>
5626      */
5627     ACAMERA_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT                    = 4,
5628 
5629     /**
5630      * <p>This request is for a ZSL usecase; the
5631      * application will stream full-resolution images and
5632      * reprocess one or several later for a final
5633      * capture.</p>
5634      */
5635     ACAMERA_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG                  = 5,
5636 
5637     /**
5638      * <p>This request is for manual capture use case where
5639      * the applications want to directly control the capture parameters.</p>
5640      * <p>For example, the application may wish to manually control
5641      * ACAMERA_SENSOR_EXPOSURE_TIME, ACAMERA_SENSOR_SENSITIVITY, etc.</p>
5642      *
5643      * @see ACAMERA_SENSOR_EXPOSURE_TIME
5644      * @see ACAMERA_SENSOR_SENSITIVITY
5645      */
5646     ACAMERA_CONTROL_CAPTURE_INTENT_MANUAL                            = 6,
5647 
5648 } acamera_metadata_enum_android_control_capture_intent_t;
5649 
5650 // ACAMERA_CONTROL_EFFECT_MODE
5651 typedef enum acamera_metadata_enum_acamera_control_effect_mode {
5652     /**
5653      * <p>No color effect will be applied.</p>
5654      */
5655     ACAMERA_CONTROL_EFFECT_MODE_OFF                                  = 0,
5656 
5657     /**
5658      * <p>A "monocolor" effect where the image is mapped into
5659      * a single color.</p>
5660      * <p>This will typically be grayscale.</p>
5661      */
5662     ACAMERA_CONTROL_EFFECT_MODE_MONO                                 = 1,
5663 
5664     /**
5665      * <p>A "photo-negative" effect where the image's colors
5666      * are inverted.</p>
5667      */
5668     ACAMERA_CONTROL_EFFECT_MODE_NEGATIVE                             = 2,
5669 
5670     /**
5671      * <p>A "solarisation" effect (Sabattier effect) where the
5672      * image is wholly or partially reversed in
5673      * tone.</p>
5674      */
5675     ACAMERA_CONTROL_EFFECT_MODE_SOLARIZE                             = 3,
5676 
5677     /**
5678      * <p>A "sepia" effect where the image is mapped into warm
5679      * gray, red, and brown tones.</p>
5680      */
5681     ACAMERA_CONTROL_EFFECT_MODE_SEPIA                                = 4,
5682 
5683     /**
5684      * <p>A "posterization" effect where the image uses
5685      * discrete regions of tone rather than a continuous
5686      * gradient of tones.</p>
5687      */
5688     ACAMERA_CONTROL_EFFECT_MODE_POSTERIZE                            = 5,
5689 
5690     /**
5691      * <p>A "whiteboard" effect where the image is typically displayed
5692      * as regions of white, with black or grey details.</p>
5693      */
5694     ACAMERA_CONTROL_EFFECT_MODE_WHITEBOARD                           = 6,
5695 
5696     /**
5697      * <p>A "blackboard" effect where the image is typically displayed
5698      * as regions of black, with white or grey details.</p>
5699      */
5700     ACAMERA_CONTROL_EFFECT_MODE_BLACKBOARD                           = 7,
5701 
5702     /**
5703      * <p>An "aqua" effect where a blue hue is added to the image.</p>
5704      */
5705     ACAMERA_CONTROL_EFFECT_MODE_AQUA                                 = 8,
5706 
5707 } acamera_metadata_enum_android_control_effect_mode_t;
5708 
5709 // ACAMERA_CONTROL_MODE
5710 typedef enum acamera_metadata_enum_acamera_control_mode {
5711     /**
5712      * <p>Full application control of pipeline.</p>
5713      * <p>All control by the device's metering and focusing (3A)
5714      * routines is disabled, and no other settings in
5715      * ACAMERA_CONTROL_* have any effect, except that
5716      * ACAMERA_CONTROL_CAPTURE_INTENT may be used by the camera
5717      * device to select post-processing values for processing
5718      * blocks that do not allow for manual control, or are not
5719      * exposed by the camera API.</p>
5720      * <p>However, the camera device's 3A routines may continue to
5721      * collect statistics and update their internal state so that
5722      * when control is switched to AUTO mode, good control values
5723      * can be immediately applied.</p>
5724      *
5725      * @see ACAMERA_CONTROL_CAPTURE_INTENT
5726      */
5727     ACAMERA_CONTROL_MODE_OFF                                         = 0,
5728 
5729     /**
5730      * <p>Use settings for each individual 3A routine.</p>
5731      * <p>Manual control of capture parameters is disabled. All
5732      * controls in ACAMERA_CONTROL_* besides sceneMode take
5733      * effect.</p>
5734      */
5735     ACAMERA_CONTROL_MODE_AUTO                                        = 1,
5736 
5737     /**
5738      * <p>Use a specific scene mode.</p>
5739      * <p>Enabling this disables control.aeMode, control.awbMode and
5740      * control.afMode controls; the camera device will ignore
5741      * those settings while USE_SCENE_MODE is active (except for
5742      * FACE_PRIORITY scene mode). Other control entries are still active.
5743      * This setting can only be used if scene mode is supported (i.e.
5744      * ACAMERA_CONTROL_AVAILABLE_SCENE_MODES
5745      * contain some modes other than DISABLED).</p>
5746      *
5747      * @see ACAMERA_CONTROL_AVAILABLE_SCENE_MODES
5748      */
5749     ACAMERA_CONTROL_MODE_USE_SCENE_MODE                              = 2,
5750 
5751     /**
5752      * <p>Same as OFF mode, except that this capture will not be
5753      * used by camera device background auto-exposure, auto-white balance and
5754      * auto-focus algorithms (3A) to update their statistics.</p>
5755      * <p>Specifically, the 3A routines are locked to the last
5756      * values set from a request with AUTO, OFF, or
5757      * USE_SCENE_MODE, and any statistics or state updates
5758      * collected from manual captures with OFF_KEEP_STATE will be
5759      * discarded by the camera device.</p>
5760      */
5761     ACAMERA_CONTROL_MODE_OFF_KEEP_STATE                              = 3,
5762 
5763 } acamera_metadata_enum_android_control_mode_t;
5764 
5765 // ACAMERA_CONTROL_SCENE_MODE
5766 typedef enum acamera_metadata_enum_acamera_control_scene_mode {
5767     /**
5768      * <p>Indicates that no scene modes are set for a given capture request.</p>
5769      */
5770     ACAMERA_CONTROL_SCENE_MODE_DISABLED                              = 0,
5771 
5772     /**
5773      * <p>If face detection support exists, use face
5774      * detection data for auto-focus, auto-white balance, and
5775      * auto-exposure routines.</p>
5776      * <p>If face detection statistics are disabled
5777      * (i.e. ACAMERA_STATISTICS_FACE_DETECT_MODE is set to OFF),
5778      * this should still operate correctly (but will not return
5779      * face detection statistics to the framework).</p>
5780      * <p>Unlike the other scene modes, ACAMERA_CONTROL_AE_MODE,
5781      * ACAMERA_CONTROL_AWB_MODE, and ACAMERA_CONTROL_AF_MODE
5782      * remain active when FACE_PRIORITY is set.</p>
5783      *
5784      * @see ACAMERA_CONTROL_AE_MODE
5785      * @see ACAMERA_CONTROL_AF_MODE
5786      * @see ACAMERA_CONTROL_AWB_MODE
5787      * @see ACAMERA_STATISTICS_FACE_DETECT_MODE
5788      */
5789     ACAMERA_CONTROL_SCENE_MODE_FACE_PRIORITY                         = 1,
5790 
5791     /**
5792      * <p>Optimized for photos of quickly moving objects.</p>
5793      * <p>Similar to SPORTS.</p>
5794      */
5795     ACAMERA_CONTROL_SCENE_MODE_ACTION                                = 2,
5796 
5797     /**
5798      * <p>Optimized for still photos of people.</p>
5799      */
5800     ACAMERA_CONTROL_SCENE_MODE_PORTRAIT                              = 3,
5801 
5802     /**
5803      * <p>Optimized for photos of distant macroscopic objects.</p>
5804      */
5805     ACAMERA_CONTROL_SCENE_MODE_LANDSCAPE                             = 4,
5806 
5807     /**
5808      * <p>Optimized for low-light settings.</p>
5809      */
5810     ACAMERA_CONTROL_SCENE_MODE_NIGHT                                 = 5,
5811 
5812     /**
5813      * <p>Optimized for still photos of people in low-light
5814      * settings.</p>
5815      */
5816     ACAMERA_CONTROL_SCENE_MODE_NIGHT_PORTRAIT                        = 6,
5817 
5818     /**
5819      * <p>Optimized for dim, indoor settings where flash must
5820      * remain off.</p>
5821      */
5822     ACAMERA_CONTROL_SCENE_MODE_THEATRE                               = 7,
5823 
5824     /**
5825      * <p>Optimized for bright, outdoor beach settings.</p>
5826      */
5827     ACAMERA_CONTROL_SCENE_MODE_BEACH                                 = 8,
5828 
5829     /**
5830      * <p>Optimized for bright, outdoor settings containing snow.</p>
5831      */
5832     ACAMERA_CONTROL_SCENE_MODE_SNOW                                  = 9,
5833 
5834     /**
5835      * <p>Optimized for scenes of the setting sun.</p>
5836      */
5837     ACAMERA_CONTROL_SCENE_MODE_SUNSET                                = 10,
5838 
5839     /**
5840      * <p>Optimized to avoid blurry photos due to small amounts of
5841      * device motion (for example: due to hand shake).</p>
5842      */
5843     ACAMERA_CONTROL_SCENE_MODE_STEADYPHOTO                           = 11,
5844 
5845     /**
5846      * <p>Optimized for nighttime photos of fireworks.</p>
5847      */
5848     ACAMERA_CONTROL_SCENE_MODE_FIREWORKS                             = 12,
5849 
5850     /**
5851      * <p>Optimized for photos of quickly moving people.</p>
5852      * <p>Similar to ACTION.</p>
5853      */
5854     ACAMERA_CONTROL_SCENE_MODE_SPORTS                                = 13,
5855 
5856     /**
5857      * <p>Optimized for dim, indoor settings with multiple moving
5858      * people.</p>
5859      */
5860     ACAMERA_CONTROL_SCENE_MODE_PARTY                                 = 14,
5861 
5862     /**
5863      * <p>Optimized for dim settings where the main light source
5864      * is a flame.</p>
5865      */
5866     ACAMERA_CONTROL_SCENE_MODE_CANDLELIGHT                           = 15,
5867 
5868     /**
5869      * <p>Optimized for accurately capturing a photo of barcode
5870      * for use by camera applications that wish to read the
5871      * barcode value.</p>
5872      */
5873     ACAMERA_CONTROL_SCENE_MODE_BARCODE                               = 16,
5874 
5875     /**
5876      * <p>Turn on a device-specific high dynamic range (HDR) mode.</p>
5877      * <p>In this scene mode, the camera device captures images
5878      * that keep a larger range of scene illumination levels
5879      * visible in the final image. For example, when taking a
5880      * picture of a object in front of a bright window, both
5881      * the object and the scene through the window may be
5882      * visible when using HDR mode, while in normal AUTO mode,
5883      * one or the other may be poorly exposed. As a tradeoff,
5884      * HDR mode generally takes much longer to capture a single
5885      * image, has no user control, and may have other artifacts
5886      * depending on the HDR method used.</p>
5887      * <p>Therefore, HDR captures operate at a much slower rate
5888      * than regular captures.</p>
5889      * <p>In this mode, on LIMITED or FULL devices, when a request
5890      * is made with a ACAMERA_CONTROL_CAPTURE_INTENT of
5891      * STILL_CAPTURE, the camera device will capture an image
5892      * using a high dynamic range capture technique.  On LEGACY
5893      * devices, captures that target a JPEG-format output will
5894      * be captured with HDR, and the capture intent is not
5895      * relevant.</p>
5896      * <p>The HDR capture may involve the device capturing a burst
5897      * of images internally and combining them into one, or it
5898      * may involve the device using specialized high dynamic
5899      * range capture hardware. In all cases, a single image is
5900      * produced in response to a capture request submitted
5901      * while in HDR mode.</p>
5902      * <p>Since substantial post-processing is generally needed to
5903      * produce an HDR image, only YUV, PRIVATE, and JPEG
5904      * outputs are supported for LIMITED/FULL device HDR
5905      * captures, and only JPEG outputs are supported for LEGACY
5906      * HDR captures. Using a RAW output for HDR capture is not
5907      * supported.</p>
5908      * <p>Some devices may also support always-on HDR, which
5909      * applies HDR processing at full frame rate.  For these
5910      * devices, intents other than STILL_CAPTURE will also
5911      * produce an HDR output with no frame rate impact compared
5912      * to normal operation, though the quality may be lower
5913      * than for STILL_CAPTURE intents.</p>
5914      * <p>If SCENE_MODE_HDR is used with unsupported output types
5915      * or capture intents, the images captured will be as if
5916      * the SCENE_MODE was not enabled at all.</p>
5917      *
5918      * @see ACAMERA_CONTROL_CAPTURE_INTENT
5919      */
5920     ACAMERA_CONTROL_SCENE_MODE_HDR                                   = 18,
5921 
5922 } acamera_metadata_enum_android_control_scene_mode_t;
5923 
5924 // ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE
5925 typedef enum acamera_metadata_enum_acamera_control_video_stabilization_mode {
5926     /**
5927      * <p>Video stabilization is disabled.</p>
5928      */
5929     ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_OFF                     = 0,
5930 
5931     /**
5932      * <p>Video stabilization is enabled.</p>
5933      */
5934     ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_ON                      = 1,
5935 
5936 } acamera_metadata_enum_android_control_video_stabilization_mode_t;
5937 
5938 // ACAMERA_CONTROL_AE_STATE
5939 typedef enum acamera_metadata_enum_acamera_control_ae_state {
5940     /**
5941      * <p>AE is off or recently reset.</p>
5942      * <p>When a camera device is opened, it starts in
5943      * this state. This is a transient state, the camera device may skip reporting
5944      * this state in capture result.</p>
5945      */
5946     ACAMERA_CONTROL_AE_STATE_INACTIVE                                = 0,
5947 
5948     /**
5949      * <p>AE doesn't yet have a good set of control values
5950      * for the current scene.</p>
5951      * <p>This is a transient state, the camera device may skip
5952      * reporting this state in capture result.</p>
5953      */
5954     ACAMERA_CONTROL_AE_STATE_SEARCHING                               = 1,
5955 
5956     /**
5957      * <p>AE has a good set of control values for the
5958      * current scene.</p>
5959      */
5960     ACAMERA_CONTROL_AE_STATE_CONVERGED                               = 2,
5961 
5962     /**
5963      * <p>AE has been locked.</p>
5964      */
5965     ACAMERA_CONTROL_AE_STATE_LOCKED                                  = 3,
5966 
5967     /**
5968      * <p>AE has a good set of control values, but flash
5969      * needs to be fired for good quality still
5970      * capture.</p>
5971      */
5972     ACAMERA_CONTROL_AE_STATE_FLASH_REQUIRED                          = 4,
5973 
5974     /**
5975      * <p>AE has been asked to do a precapture sequence
5976      * and is currently executing it.</p>
5977      * <p>Precapture can be triggered through setting
5978      * ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER to START. Currently
5979      * active and completed (if it causes camera device internal AE lock) precapture
5980      * metering sequence can be canceled through setting
5981      * ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER to CANCEL.</p>
5982      * <p>Once PRECAPTURE completes, AE will transition to CONVERGED
5983      * or FLASH_REQUIRED as appropriate. This is a transient
5984      * state, the camera device may skip reporting this state in
5985      * capture result.</p>
5986      *
5987      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
5988      */
5989     ACAMERA_CONTROL_AE_STATE_PRECAPTURE                              = 5,
5990 
5991 } acamera_metadata_enum_android_control_ae_state_t;
5992 
5993 // ACAMERA_CONTROL_AF_STATE
5994 typedef enum acamera_metadata_enum_acamera_control_af_state {
5995     /**
5996      * <p>AF is off or has not yet tried to scan/been asked
5997      * to scan.</p>
5998      * <p>When a camera device is opened, it starts in this
5999      * state. This is a transient state, the camera device may
6000      * skip reporting this state in capture
6001      * result.</p>
6002      */
6003     ACAMERA_CONTROL_AF_STATE_INACTIVE                                = 0,
6004 
6005     /**
6006      * <p>AF is currently performing an AF scan initiated the
6007      * camera device in a continuous autofocus mode.</p>
6008      * <p>Only used by CONTINUOUS_* AF modes. This is a transient
6009      * state, the camera device may skip reporting this state in
6010      * capture result.</p>
6011      */
6012     ACAMERA_CONTROL_AF_STATE_PASSIVE_SCAN                            = 1,
6013 
6014     /**
6015      * <p>AF currently believes it is in focus, but may
6016      * restart scanning at any time.</p>
6017      * <p>Only used by CONTINUOUS_* AF modes. This is a transient
6018      * state, the camera device may skip reporting this state in
6019      * capture result.</p>
6020      */
6021     ACAMERA_CONTROL_AF_STATE_PASSIVE_FOCUSED                         = 2,
6022 
6023     /**
6024      * <p>AF is performing an AF scan because it was
6025      * triggered by AF trigger.</p>
6026      * <p>Only used by AUTO or MACRO AF modes. This is a transient
6027      * state, the camera device may skip reporting this state in
6028      * capture result.</p>
6029      */
6030     ACAMERA_CONTROL_AF_STATE_ACTIVE_SCAN                             = 3,
6031 
6032     /**
6033      * <p>AF believes it is focused correctly and has locked
6034      * focus.</p>
6035      * <p>This state is reached only after an explicit START AF trigger has been
6036      * sent (ACAMERA_CONTROL_AF_TRIGGER), when good focus has been obtained.</p>
6037      * <p>The lens will remain stationary until the AF mode (ACAMERA_CONTROL_AF_MODE) is changed or
6038      * a new AF trigger is sent to the camera device (ACAMERA_CONTROL_AF_TRIGGER).</p>
6039      *
6040      * @see ACAMERA_CONTROL_AF_MODE
6041      * @see ACAMERA_CONTROL_AF_TRIGGER
6042      */
6043     ACAMERA_CONTROL_AF_STATE_FOCUSED_LOCKED                          = 4,
6044 
6045     /**
6046      * <p>AF has failed to focus successfully and has locked
6047      * focus.</p>
6048      * <p>This state is reached only after an explicit START AF trigger has been
6049      * sent (ACAMERA_CONTROL_AF_TRIGGER), when good focus cannot be obtained.</p>
6050      * <p>The lens will remain stationary until the AF mode (ACAMERA_CONTROL_AF_MODE) is changed or
6051      * a new AF trigger is sent to the camera device (ACAMERA_CONTROL_AF_TRIGGER).</p>
6052      *
6053      * @see ACAMERA_CONTROL_AF_MODE
6054      * @see ACAMERA_CONTROL_AF_TRIGGER
6055      */
6056     ACAMERA_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED                      = 5,
6057 
6058     /**
6059      * <p>AF finished a passive scan without finding focus,
6060      * and may restart scanning at any time.</p>
6061      * <p>Only used by CONTINUOUS_* AF modes. This is a transient state, the camera
6062      * device may skip reporting this state in capture result.</p>
6063      * <p>LEGACY camera devices do not support this state. When a passive
6064      * scan has finished, it will always go to PASSIVE_FOCUSED.</p>
6065      */
6066     ACAMERA_CONTROL_AF_STATE_PASSIVE_UNFOCUSED                       = 6,
6067 
6068 } acamera_metadata_enum_android_control_af_state_t;
6069 
6070 // ACAMERA_CONTROL_AWB_STATE
6071 typedef enum acamera_metadata_enum_acamera_control_awb_state {
6072     /**
6073      * <p>AWB is not in auto mode, or has not yet started metering.</p>
6074      * <p>When a camera device is opened, it starts in this
6075      * state. This is a transient state, the camera device may
6076      * skip reporting this state in capture
6077      * result.</p>
6078      */
6079     ACAMERA_CONTROL_AWB_STATE_INACTIVE                               = 0,
6080 
6081     /**
6082      * <p>AWB doesn't yet have a good set of control
6083      * values for the current scene.</p>
6084      * <p>This is a transient state, the camera device
6085      * may skip reporting this state in capture result.</p>
6086      */
6087     ACAMERA_CONTROL_AWB_STATE_SEARCHING                              = 1,
6088 
6089     /**
6090      * <p>AWB has a good set of control values for the
6091      * current scene.</p>
6092      */
6093     ACAMERA_CONTROL_AWB_STATE_CONVERGED                              = 2,
6094 
6095     /**
6096      * <p>AWB has been locked.</p>
6097      */
6098     ACAMERA_CONTROL_AWB_STATE_LOCKED                                 = 3,
6099 
6100 } acamera_metadata_enum_android_control_awb_state_t;
6101 
6102 // ACAMERA_CONTROL_AE_LOCK_AVAILABLE
6103 typedef enum acamera_metadata_enum_acamera_control_ae_lock_available {
6104     ACAMERA_CONTROL_AE_LOCK_AVAILABLE_FALSE                          = 0,
6105 
6106     ACAMERA_CONTROL_AE_LOCK_AVAILABLE_TRUE                           = 1,
6107 
6108 } acamera_metadata_enum_android_control_ae_lock_available_t;
6109 
6110 // ACAMERA_CONTROL_AWB_LOCK_AVAILABLE
6111 typedef enum acamera_metadata_enum_acamera_control_awb_lock_available {
6112     ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_FALSE                         = 0,
6113 
6114     ACAMERA_CONTROL_AWB_LOCK_AVAILABLE_TRUE                          = 1,
6115 
6116 } acamera_metadata_enum_android_control_awb_lock_available_t;
6117 
6118 // ACAMERA_CONTROL_ENABLE_ZSL
6119 typedef enum acamera_metadata_enum_acamera_control_enable_zsl {
6120     /**
6121      * <p>Requests with ACAMERA_CONTROL_CAPTURE_INTENT == STILL_CAPTURE must be captured
6122      * after previous requests.</p>
6123      *
6124      * @see ACAMERA_CONTROL_CAPTURE_INTENT
6125      */
6126     ACAMERA_CONTROL_ENABLE_ZSL_FALSE                                 = 0,
6127 
6128     /**
6129      * <p>Requests with ACAMERA_CONTROL_CAPTURE_INTENT == STILL_CAPTURE may or may not be
6130      * captured before previous requests.</p>
6131      *
6132      * @see ACAMERA_CONTROL_CAPTURE_INTENT
6133      */
6134     ACAMERA_CONTROL_ENABLE_ZSL_TRUE                                  = 1,
6135 
6136 } acamera_metadata_enum_android_control_enable_zsl_t;
6137 
6138 
6139 
6140 // ACAMERA_EDGE_MODE
6141 typedef enum acamera_metadata_enum_acamera_edge_mode {
6142     /**
6143      * <p>No edge enhancement is applied.</p>
6144      */
6145     ACAMERA_EDGE_MODE_OFF                                            = 0,
6146 
6147     /**
6148      * <p>Apply edge enhancement at a quality level that does not slow down frame rate
6149      * relative to sensor output. It may be the same as OFF if edge enhancement will
6150      * slow down frame rate relative to sensor.</p>
6151      */
6152     ACAMERA_EDGE_MODE_FAST                                           = 1,
6153 
6154     /**
6155      * <p>Apply high-quality edge enhancement, at a cost of possibly reduced output frame rate.</p>
6156      */
6157     ACAMERA_EDGE_MODE_HIGH_QUALITY                                   = 2,
6158 
6159     /**
6160      * <p>Edge enhancement is applied at different levels for different output streams,
6161      * based on resolution. Streams at maximum recording resolution (see {@link
6162      * ACameraDevice_createCaptureSession}) or below have
6163      * edge enhancement applied, while higher-resolution streams have no edge enhancement
6164      * applied. The level of edge enhancement for low-resolution streams is tuned so that
6165      * frame rate is not impacted, and the quality is equal to or better than FAST (since it
6166      * is only applied to lower-resolution outputs, quality may improve from FAST).</p>
6167      * <p>This mode is intended to be used by applications operating in a zero-shutter-lag mode
6168      * with YUV or PRIVATE reprocessing, where the application continuously captures
6169      * high-resolution intermediate buffers into a circular buffer, from which a final image is
6170      * produced via reprocessing when a user takes a picture.  For such a use case, the
6171      * high-resolution buffers must not have edge enhancement applied to maximize efficiency of
6172      * preview and to avoid double-applying enhancement when reprocessed, while low-resolution
6173      * buffers (used for recording or preview, generally) need edge enhancement applied for
6174      * reasonable preview quality.</p>
6175      * <p>This mode is guaranteed to be supported by devices that support either the
6176      * YUV_REPROCESSING or PRIVATE_REPROCESSING capabilities
6177      * (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES lists either of those capabilities) and it will
6178      * be the default mode for CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG template.</p>
6179      *
6180      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
6181      */
6182     ACAMERA_EDGE_MODE_ZERO_SHUTTER_LAG                               = 3,
6183 
6184 } acamera_metadata_enum_android_edge_mode_t;
6185 
6186 
6187 // ACAMERA_FLASH_MODE
6188 typedef enum acamera_metadata_enum_acamera_flash_mode {
6189     /**
6190      * <p>Do not fire the flash for this capture.</p>
6191      */
6192     ACAMERA_FLASH_MODE_OFF                                           = 0,
6193 
6194     /**
6195      * <p>If the flash is available and charged, fire flash
6196      * for this capture.</p>
6197      */
6198     ACAMERA_FLASH_MODE_SINGLE                                        = 1,
6199 
6200     /**
6201      * <p>Transition flash to continuously on.</p>
6202      */
6203     ACAMERA_FLASH_MODE_TORCH                                         = 2,
6204 
6205 } acamera_metadata_enum_android_flash_mode_t;
6206 
6207 // ACAMERA_FLASH_STATE
6208 typedef enum acamera_metadata_enum_acamera_flash_state {
6209     /**
6210      * <p>No flash on camera.</p>
6211      */
6212     ACAMERA_FLASH_STATE_UNAVAILABLE                                  = 0,
6213 
6214     /**
6215      * <p>Flash is charging and cannot be fired.</p>
6216      */
6217     ACAMERA_FLASH_STATE_CHARGING                                     = 1,
6218 
6219     /**
6220      * <p>Flash is ready to fire.</p>
6221      */
6222     ACAMERA_FLASH_STATE_READY                                        = 2,
6223 
6224     /**
6225      * <p>Flash fired for this capture.</p>
6226      */
6227     ACAMERA_FLASH_STATE_FIRED                                        = 3,
6228 
6229     /**
6230      * <p>Flash partially illuminated this frame.</p>
6231      * <p>This is usually due to the next or previous frame having
6232      * the flash fire, and the flash spilling into this capture
6233      * due to hardware limitations.</p>
6234      */
6235     ACAMERA_FLASH_STATE_PARTIAL                                      = 4,
6236 
6237 } acamera_metadata_enum_android_flash_state_t;
6238 
6239 
6240 // ACAMERA_FLASH_INFO_AVAILABLE
6241 typedef enum acamera_metadata_enum_acamera_flash_info_available {
6242     ACAMERA_FLASH_INFO_AVAILABLE_FALSE                               = 0,
6243 
6244     ACAMERA_FLASH_INFO_AVAILABLE_TRUE                                = 1,
6245 
6246 } acamera_metadata_enum_android_flash_info_available_t;
6247 
6248 
6249 // ACAMERA_HOT_PIXEL_MODE
6250 typedef enum acamera_metadata_enum_acamera_hot_pixel_mode {
6251     /**
6252      * <p>No hot pixel correction is applied.</p>
6253      * <p>The frame rate must not be reduced relative to sensor raw output
6254      * for this option.</p>
6255      * <p>The hotpixel map may be returned in ACAMERA_STATISTICS_HOT_PIXEL_MAP.</p>
6256      *
6257      * @see ACAMERA_STATISTICS_HOT_PIXEL_MAP
6258      */
6259     ACAMERA_HOT_PIXEL_MODE_OFF                                       = 0,
6260 
6261     /**
6262      * <p>Hot pixel correction is applied, without reducing frame
6263      * rate relative to sensor raw output.</p>
6264      * <p>The hotpixel map may be returned in ACAMERA_STATISTICS_HOT_PIXEL_MAP.</p>
6265      *
6266      * @see ACAMERA_STATISTICS_HOT_PIXEL_MAP
6267      */
6268     ACAMERA_HOT_PIXEL_MODE_FAST                                      = 1,
6269 
6270     /**
6271      * <p>High-quality hot pixel correction is applied, at a cost
6272      * of possibly reduced frame rate relative to sensor raw output.</p>
6273      * <p>The hotpixel map may be returned in ACAMERA_STATISTICS_HOT_PIXEL_MAP.</p>
6274      *
6275      * @see ACAMERA_STATISTICS_HOT_PIXEL_MAP
6276      */
6277     ACAMERA_HOT_PIXEL_MODE_HIGH_QUALITY                              = 2,
6278 
6279 } acamera_metadata_enum_android_hot_pixel_mode_t;
6280 
6281 
6282 
6283 // ACAMERA_LENS_OPTICAL_STABILIZATION_MODE
6284 typedef enum acamera_metadata_enum_acamera_lens_optical_stabilization_mode {
6285     /**
6286      * <p>Optical stabilization is unavailable.</p>
6287      */
6288     ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_OFF                      = 0,
6289 
6290     /**
6291      * <p>Optical stabilization is enabled.</p>
6292      */
6293     ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_ON                       = 1,
6294 
6295 } acamera_metadata_enum_android_lens_optical_stabilization_mode_t;
6296 
6297 // ACAMERA_LENS_FACING
6298 typedef enum acamera_metadata_enum_acamera_lens_facing {
6299     /**
6300      * <p>The camera device faces the same direction as the device's screen.</p>
6301      */
6302     ACAMERA_LENS_FACING_FRONT                                        = 0,
6303 
6304     /**
6305      * <p>The camera device faces the opposite direction as the device's screen.</p>
6306      */
6307     ACAMERA_LENS_FACING_BACK                                         = 1,
6308 
6309     /**
6310      * <p>The camera device is an external camera, and has no fixed facing relative to the
6311      * device's screen.</p>
6312      */
6313     ACAMERA_LENS_FACING_EXTERNAL                                     = 2,
6314 
6315 } acamera_metadata_enum_android_lens_facing_t;
6316 
6317 // ACAMERA_LENS_STATE
6318 typedef enum acamera_metadata_enum_acamera_lens_state {
6319     /**
6320      * <p>The lens parameters (ACAMERA_LENS_FOCAL_LENGTH, ACAMERA_LENS_FOCUS_DISTANCE,
6321      * ACAMERA_LENS_FILTER_DENSITY and ACAMERA_LENS_APERTURE) are not changing.</p>
6322      *
6323      * @see ACAMERA_LENS_APERTURE
6324      * @see ACAMERA_LENS_FILTER_DENSITY
6325      * @see ACAMERA_LENS_FOCAL_LENGTH
6326      * @see ACAMERA_LENS_FOCUS_DISTANCE
6327      */
6328     ACAMERA_LENS_STATE_STATIONARY                                    = 0,
6329 
6330     /**
6331      * <p>One or several of the lens parameters
6332      * (ACAMERA_LENS_FOCAL_LENGTH, ACAMERA_LENS_FOCUS_DISTANCE,
6333      * ACAMERA_LENS_FILTER_DENSITY or ACAMERA_LENS_APERTURE) is
6334      * currently changing.</p>
6335      *
6336      * @see ACAMERA_LENS_APERTURE
6337      * @see ACAMERA_LENS_FILTER_DENSITY
6338      * @see ACAMERA_LENS_FOCAL_LENGTH
6339      * @see ACAMERA_LENS_FOCUS_DISTANCE
6340      */
6341     ACAMERA_LENS_STATE_MOVING                                        = 1,
6342 
6343 } acamera_metadata_enum_android_lens_state_t;
6344 
6345 
6346 // ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION
6347 typedef enum acamera_metadata_enum_acamera_lens_info_focus_distance_calibration {
6348     /**
6349      * <p>The lens focus distance is not accurate, and the units used for
6350      * ACAMERA_LENS_FOCUS_DISTANCE do not correspond to any physical units.</p>
6351      * <p>Setting the lens to the same focus distance on separate occasions may
6352      * result in a different real focus distance, depending on factors such
6353      * as the orientation of the device, the age of the focusing mechanism,
6354      * and the device temperature. The focus distance value will still be
6355      * in the range of <code>[0, ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE]</code>, where 0
6356      * represents the farthest focus.</p>
6357      *
6358      * @see ACAMERA_LENS_FOCUS_DISTANCE
6359      * @see ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE
6360      */
6361     ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED        = 0,
6362 
6363     /**
6364      * <p>The lens focus distance is measured in diopters.</p>
6365      * <p>However, setting the lens to the same focus distance
6366      * on separate occasions may result in a different real
6367      * focus distance, depending on factors such as the
6368      * orientation of the device, the age of the focusing
6369      * mechanism, and the device temperature.</p>
6370      */
6371     ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE         = 1,
6372 
6373     /**
6374      * <p>The lens focus distance is measured in diopters, and
6375      * is calibrated.</p>
6376      * <p>The lens mechanism is calibrated so that setting the
6377      * same focus distance is repeatable on multiple
6378      * occasions with good accuracy, and the focus distance
6379      * corresponds to the real physical distance to the plane
6380      * of best focus.</p>
6381      */
6382     ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED          = 2,
6383 
6384 } acamera_metadata_enum_android_lens_info_focus_distance_calibration_t;
6385 
6386 
6387 // ACAMERA_NOISE_REDUCTION_MODE
6388 typedef enum acamera_metadata_enum_acamera_noise_reduction_mode {
6389     /**
6390      * <p>No noise reduction is applied.</p>
6391      */
6392     ACAMERA_NOISE_REDUCTION_MODE_OFF                                 = 0,
6393 
6394     /**
6395      * <p>Noise reduction is applied without reducing frame rate relative to sensor
6396      * output. It may be the same as OFF if noise reduction will reduce frame rate
6397      * relative to sensor.</p>
6398      */
6399     ACAMERA_NOISE_REDUCTION_MODE_FAST                                = 1,
6400 
6401     /**
6402      * <p>High-quality noise reduction is applied, at the cost of possibly reduced frame
6403      * rate relative to sensor output.</p>
6404      */
6405     ACAMERA_NOISE_REDUCTION_MODE_HIGH_QUALITY                        = 2,
6406 
6407     /**
6408      * <p>MINIMAL noise reduction is applied without reducing frame rate relative to
6409      * sensor output. </p>
6410      */
6411     ACAMERA_NOISE_REDUCTION_MODE_MINIMAL                             = 3,
6412 
6413     /**
6414      * <p>Noise reduction is applied at different levels for different output streams,
6415      * based on resolution. Streams at maximum recording resolution (see {@link
6416      * ACameraDevice_createCaptureSession}) or below have noise
6417      * reduction applied, while higher-resolution streams have MINIMAL (if supported) or no
6418      * noise reduction applied (if MINIMAL is not supported.) The degree of noise reduction
6419      * for low-resolution streams is tuned so that frame rate is not impacted, and the quality
6420      * is equal to or better than FAST (since it is only applied to lower-resolution outputs,
6421      * quality may improve from FAST).</p>
6422      * <p>This mode is intended to be used by applications operating in a zero-shutter-lag mode
6423      * with YUV or PRIVATE reprocessing, where the application continuously captures
6424      * high-resolution intermediate buffers into a circular buffer, from which a final image is
6425      * produced via reprocessing when a user takes a picture.  For such a use case, the
6426      * high-resolution buffers must not have noise reduction applied to maximize efficiency of
6427      * preview and to avoid over-applying noise filtering when reprocessing, while
6428      * low-resolution buffers (used for recording or preview, generally) need noise reduction
6429      * applied for reasonable preview quality.</p>
6430      * <p>This mode is guaranteed to be supported by devices that support either the
6431      * YUV_REPROCESSING or PRIVATE_REPROCESSING capabilities
6432      * (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES lists either of those capabilities) and it will
6433      * be the default mode for CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG template.</p>
6434      *
6435      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
6436      */
6437     ACAMERA_NOISE_REDUCTION_MODE_ZERO_SHUTTER_LAG                    = 4,
6438 
6439 } acamera_metadata_enum_android_noise_reduction_mode_t;
6440 
6441 
6442 
6443 // ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
6444 typedef enum acamera_metadata_enum_acamera_request_available_capabilities {
6445     /**
6446      * <p>The minimal set of capabilities that every camera
6447      * device (regardless of ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL)
6448      * supports.</p>
6449      * <p>This capability is listed by all normal devices, and
6450      * indicates that the camera device has a feature set
6451      * that's comparable to the baseline requirements for the
6452      * older android.hardware.Camera API.</p>
6453      * <p>Devices with the DEPTH_OUTPUT capability might not list this
6454      * capability, indicating that they support only depth measurement,
6455      * not standard color output.</p>
6456      *
6457      * @see ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL
6458      */
6459     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE       = 0,
6460 
6461     /**
6462      * <p>The camera device can be manually controlled (3A algorithms such
6463      * as auto-exposure, and auto-focus can be bypassed).
6464      * The camera device supports basic manual control of the sensor image
6465      * acquisition related stages. This means the following controls are
6466      * guaranteed to be supported:</p>
6467      * <ul>
6468      * <li>Manual frame duration control<ul>
6469      * <li>ACAMERA_SENSOR_FRAME_DURATION</li>
6470      * <li>ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION</li>
6471      * </ul>
6472      * </li>
6473      * <li>Manual exposure control<ul>
6474      * <li>ACAMERA_SENSOR_EXPOSURE_TIME</li>
6475      * <li>ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE</li>
6476      * </ul>
6477      * </li>
6478      * <li>Manual sensitivity control<ul>
6479      * <li>ACAMERA_SENSOR_SENSITIVITY</li>
6480      * <li>ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE</li>
6481      * </ul>
6482      * </li>
6483      * <li>Manual lens control (if the lens is adjustable)<ul>
6484      * <li>ACAMERA_LENS_*</li>
6485      * </ul>
6486      * </li>
6487      * <li>Manual flash control (if a flash unit is present)<ul>
6488      * <li>ACAMERA_FLASH_*</li>
6489      * </ul>
6490      * </li>
6491      * <li>Manual black level locking<ul>
6492      * <li>ACAMERA_BLACK_LEVEL_LOCK</li>
6493      * </ul>
6494      * </li>
6495      * <li>Auto exposure lock<ul>
6496      * <li>ACAMERA_CONTROL_AE_LOCK</li>
6497      * </ul>
6498      * </li>
6499      * </ul>
6500      * <p>If any of the above 3A algorithms are enabled, then the camera
6501      * device will accurately report the values applied by 3A in the
6502      * result.</p>
6503      * <p>A given camera device may also support additional manual sensor controls,
6504      * but this capability only covers the above list of controls.</p>
6505      * <p>If this is supported, android.scaler.streamConfigurationMap will
6506      * additionally return a min frame duration that is greater than
6507      * zero for each supported size-format combination.</p>
6508      *
6509      * @see ACAMERA_BLACK_LEVEL_LOCK
6510      * @see ACAMERA_CONTROL_AE_LOCK
6511      * @see ACAMERA_SENSOR_EXPOSURE_TIME
6512      * @see ACAMERA_SENSOR_FRAME_DURATION
6513      * @see ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE
6514      * @see ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION
6515      * @see ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE
6516      * @see ACAMERA_SENSOR_SENSITIVITY
6517      */
6518     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR             = 1,
6519 
6520     /**
6521      * <p>The camera device post-processing stages can be manually controlled.
6522      * The camera device supports basic manual control of the image post-processing
6523      * stages. This means the following controls are guaranteed to be supported:</p>
6524      * <ul>
6525      * <li>
6526      * <p>Manual tonemap control</p>
6527      * <ul>
6528      * <li>android.tonemap.curve</li>
6529      * <li>ACAMERA_TONEMAP_MODE</li>
6530      * <li>ACAMERA_TONEMAP_MAX_CURVE_POINTS</li>
6531      * <li>ACAMERA_TONEMAP_GAMMA</li>
6532      * <li>ACAMERA_TONEMAP_PRESET_CURVE</li>
6533      * </ul>
6534      * </li>
6535      * <li>
6536      * <p>Manual white balance control</p>
6537      * <ul>
6538      * <li>ACAMERA_COLOR_CORRECTION_TRANSFORM</li>
6539      * <li>ACAMERA_COLOR_CORRECTION_GAINS</li>
6540      * </ul>
6541      * </li>
6542      * <li>Manual lens shading map control<ul>
6543      * <li>ACAMERA_SHADING_MODE</li>
6544      * <li>ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE</li>
6545      * <li>ACAMERA_STATISTICS_LENS_SHADING_MAP</li>
6546      * <li>ACAMERA_LENS_INFO_SHADING_MAP_SIZE</li>
6547      * </ul>
6548      * </li>
6549      * <li>Manual aberration correction control (if aberration correction is supported)<ul>
6550      * <li>ACAMERA_COLOR_CORRECTION_ABERRATION_MODE</li>
6551      * <li>ACAMERA_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES</li>
6552      * </ul>
6553      * </li>
6554      * <li>Auto white balance lock<ul>
6555      * <li>ACAMERA_CONTROL_AWB_LOCK</li>
6556      * </ul>
6557      * </li>
6558      * </ul>
6559      * <p>If auto white balance is enabled, then the camera device
6560      * will accurately report the values applied by AWB in the result.</p>
6561      * <p>A given camera device may also support additional post-processing
6562      * controls, but this capability only covers the above list of controls.</p>
6563      *
6564      * @see ACAMERA_COLOR_CORRECTION_ABERRATION_MODE
6565      * @see ACAMERA_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES
6566      * @see ACAMERA_COLOR_CORRECTION_GAINS
6567      * @see ACAMERA_COLOR_CORRECTION_TRANSFORM
6568      * @see ACAMERA_CONTROL_AWB_LOCK
6569      * @see ACAMERA_LENS_INFO_SHADING_MAP_SIZE
6570      * @see ACAMERA_SHADING_MODE
6571      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP
6572      * @see ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
6573      * @see ACAMERA_TONEMAP_GAMMA
6574      * @see ACAMERA_TONEMAP_MAX_CURVE_POINTS
6575      * @see ACAMERA_TONEMAP_MODE
6576      * @see ACAMERA_TONEMAP_PRESET_CURVE
6577      */
6578     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING    = 2,
6579 
6580     /**
6581      * <p>The camera device supports outputting RAW buffers and
6582      * metadata for interpreting them.</p>
6583      * <p>Devices supporting the RAW capability allow both for
6584      * saving DNG files, and for direct application processing of
6585      * raw sensor images.</p>
6586      * <ul>
6587      * <li>RAW_SENSOR is supported as an output format.</li>
6588      * <li>The maximum available resolution for RAW_SENSOR streams
6589      *   will match either the value in
6590      *   ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE or
6591      *   ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE.</li>
6592      * <li>All DNG-related optional metadata entries are provided
6593      *   by the camera device.</li>
6594      * </ul>
6595      *
6596      * @see ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE
6597      * @see ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE
6598      */
6599     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_RAW                       = 3,
6600 
6601     /**
6602      * <p>The camera device supports accurately reporting the sensor settings for many of
6603      * the sensor controls while the built-in 3A algorithm is running.  This allows
6604      * reporting of sensor settings even when these settings cannot be manually changed.</p>
6605      * <p>The values reported for the following controls are guaranteed to be available
6606      * in the CaptureResult, including when 3A is enabled:</p>
6607      * <ul>
6608      * <li>Exposure control<ul>
6609      * <li>ACAMERA_SENSOR_EXPOSURE_TIME</li>
6610      * </ul>
6611      * </li>
6612      * <li>Sensitivity control<ul>
6613      * <li>ACAMERA_SENSOR_SENSITIVITY</li>
6614      * </ul>
6615      * </li>
6616      * <li>Lens controls (if the lens is adjustable)<ul>
6617      * <li>ACAMERA_LENS_FOCUS_DISTANCE</li>
6618      * <li>ACAMERA_LENS_APERTURE</li>
6619      * </ul>
6620      * </li>
6621      * </ul>
6622      * <p>This capability is a subset of the MANUAL_SENSOR control capability, and will
6623      * always be included if the MANUAL_SENSOR capability is available.</p>
6624      *
6625      * @see ACAMERA_LENS_APERTURE
6626      * @see ACAMERA_LENS_FOCUS_DISTANCE
6627      * @see ACAMERA_SENSOR_EXPOSURE_TIME
6628      * @see ACAMERA_SENSOR_SENSITIVITY
6629      */
6630     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS      = 5,
6631 
6632     /**
6633      * <p>The camera device supports capturing high-resolution images at &gt;= 20 frames per
6634      * second, in at least the uncompressed YUV format, when post-processing settings are set
6635      * to FAST. Additionally, maximum-resolution images can be captured at &gt;= 10 frames
6636      * per second.  Here, 'high resolution' means at least 8 megapixels, or the maximum
6637      * resolution of the device, whichever is smaller.</p>
6638      * <p>More specifically, this means that at least one output {@link
6639      * AIMAGE_FORMAT_YUV_420_888} size listed in
6640      * {@link ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS} is larger or equal to the
6641      * 'high resolution' defined above, and can be captured at at least 20 fps.
6642      * For the largest {@link AIMAGE_FORMAT_YUV_420_888} size listed in
6643      * {@link ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS}, camera device can capture this
6644      * size for at least 10 frames per second.
6645      * Also the ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES entry lists at least one FPS range
6646      * where the minimum FPS is &gt;= 1 / minimumFrameDuration for the largest YUV_420_888 size.</p>
6647      * <p>If the device supports the {@link AIMAGE_FORMAT_RAW10}, {@link
6648      * AIMAGE_FORMAT_RAW12}, then those can also be captured at the same rate
6649      * as the maximum-size YUV_420_888 resolution is.</p>
6650      * <p>In addition, the ACAMERA_SYNC_MAX_LATENCY field is guaranted to have a value between 0
6651      * and 4, inclusive. ACAMERA_CONTROL_AE_LOCK_AVAILABLE and ACAMERA_CONTROL_AWB_LOCK_AVAILABLE
6652      * are also guaranteed to be <code>true</code> so burst capture with these two locks ON yields
6653      * consistent image output.</p>
6654      *
6655      * @see ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES
6656      * @see ACAMERA_CONTROL_AE_LOCK_AVAILABLE
6657      * @see ACAMERA_CONTROL_AWB_LOCK_AVAILABLE
6658      * @see ACAMERA_SYNC_MAX_LATENCY
6659      */
6660     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE             = 6,
6661 
6662     /**
6663      * <p>The camera device can produce depth measurements from its field of view.</p>
6664      * <p>This capability requires the camera device to support the following:</p>
6665      * <ul>
6666      * <li>{@link AIMAGE_FORMAT_DEPTH16} is supported as an output format.</li>
6667      * <li>{@link AIMAGE_FORMAT_DEPTH_POINT_CLOUD} is optionally supported as an
6668      *   output format.</li>
6669      * <li>This camera device, and all camera devices with the same ACAMERA_LENS_FACING,
6670      *   will list the following calibration entries in {@link ACameraMetadata} from both
6671      *   {@link ACameraManager_getCameraCharacteristics} and
6672      *   {@link ACameraCaptureSession_captureCallback_result}:<ul>
6673      * <li>ACAMERA_LENS_POSE_TRANSLATION</li>
6674      * <li>ACAMERA_LENS_POSE_ROTATION</li>
6675      * <li>ACAMERA_LENS_INTRINSIC_CALIBRATION</li>
6676      * <li>ACAMERA_LENS_RADIAL_DISTORTION</li>
6677      * </ul>
6678      * </li>
6679      * <li>The ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE entry is listed by this device.</li>
6680      * <li>A LIMITED camera with only the DEPTH_OUTPUT capability does not have to support
6681      *   normal YUV_420_888, JPEG, and PRIV-format outputs. It only has to support the DEPTH16
6682      *   format.</li>
6683      * </ul>
6684      * <p>Generally, depth output operates at a slower frame rate than standard color capture,
6685      * so the DEPTH16 and DEPTH_POINT_CLOUD formats will commonly have a stall duration that
6686      * should be accounted for (see
6687      * {@link ACAMERA_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS}).
6688      * On a device that supports both depth and color-based output, to enable smooth preview,
6689      * using a repeating burst is recommended, where a depth-output target is only included
6690      * once every N frames, where N is the ratio between preview output rate and depth output
6691      * rate, including depth stall time.</p>
6692      *
6693      * @see ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE
6694      * @see ACAMERA_LENS_FACING
6695      * @see ACAMERA_LENS_INTRINSIC_CALIBRATION
6696      * @see ACAMERA_LENS_POSE_ROTATION
6697      * @see ACAMERA_LENS_POSE_TRANSLATION
6698      * @see ACAMERA_LENS_RADIAL_DISTORTION
6699      */
6700     ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT              = 8,
6701 
6702 } acamera_metadata_enum_android_request_available_capabilities_t;
6703 
6704 
6705 // ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
6706 typedef enum acamera_metadata_enum_acamera_scaler_available_stream_configurations {
6707     ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT            = 0,
6708 
6709     ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT             = 1,
6710 
6711 } acamera_metadata_enum_android_scaler_available_stream_configurations_t;
6712 
6713 // ACAMERA_SCALER_CROPPING_TYPE
6714 typedef enum acamera_metadata_enum_acamera_scaler_cropping_type {
6715     /**
6716      * <p>The camera device only supports centered crop regions.</p>
6717      */
6718     ACAMERA_SCALER_CROPPING_TYPE_CENTER_ONLY                         = 0,
6719 
6720     /**
6721      * <p>The camera device supports arbitrarily chosen crop regions.</p>
6722      */
6723     ACAMERA_SCALER_CROPPING_TYPE_FREEFORM                            = 1,
6724 
6725 } acamera_metadata_enum_android_scaler_cropping_type_t;
6726 
6727 
6728 // ACAMERA_SENSOR_REFERENCE_ILLUMINANT1
6729 typedef enum acamera_metadata_enum_acamera_sensor_reference_illuminant1 {
6730     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT                    = 1,
6731 
6732     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT                 = 2,
6733 
6734     /**
6735      * <p>Incandescent light</p>
6736      */
6737     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN                    = 3,
6738 
6739     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FLASH                       = 4,
6740 
6741     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER                = 9,
6742 
6743     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER              = 10,
6744 
6745     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_SHADE                       = 11,
6746 
6747     /**
6748      * <p>D 5700 - 7100K</p>
6749      */
6750     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT        = 12,
6751 
6752     /**
6753      * <p>N 4600 - 5400K</p>
6754      */
6755     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT       = 13,
6756 
6757     /**
6758      * <p>W 3900 - 4500K</p>
6759      */
6760     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT      = 14,
6761 
6762     /**
6763      * <p>WW 3200 - 3700K</p>
6764      */
6765     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT           = 15,
6766 
6767     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A                  = 17,
6768 
6769     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B                  = 18,
6770 
6771     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C                  = 19,
6772 
6773     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D55                         = 20,
6774 
6775     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D65                         = 21,
6776 
6777     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D75                         = 22,
6778 
6779     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_D50                         = 23,
6780 
6781     ACAMERA_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN         = 24,
6782 
6783 } acamera_metadata_enum_android_sensor_reference_illuminant1_t;
6784 
6785 // ACAMERA_SENSOR_TEST_PATTERN_MODE
6786 typedef enum acamera_metadata_enum_acamera_sensor_test_pattern_mode {
6787     /**
6788      * <p>No test pattern mode is used, and the camera
6789      * device returns captures from the image sensor.</p>
6790      * <p>This is the default if the key is not set.</p>
6791      */
6792     ACAMERA_SENSOR_TEST_PATTERN_MODE_OFF                             = 0,
6793 
6794     /**
6795      * <p>Each pixel in <code>[R, G_even, G_odd, B]</code> is replaced by its
6796      * respective color channel provided in
6797      * ACAMERA_SENSOR_TEST_PATTERN_DATA.</p>
6798      * <p>For example:</p>
6799      * <pre><code>android.testPatternData = [0, 0xFFFFFFFF, 0xFFFFFFFF, 0]
6800      * </code></pre>
6801      * <p>All green pixels are 100% green. All red/blue pixels are black.</p>
6802      * <pre><code>android.testPatternData = [0xFFFFFFFF, 0, 0xFFFFFFFF, 0]
6803      * </code></pre>
6804      * <p>All red pixels are 100% red. Only the odd green pixels
6805      * are 100% green. All blue pixels are 100% black.</p>
6806      *
6807      * @see ACAMERA_SENSOR_TEST_PATTERN_DATA
6808      */
6809     ACAMERA_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR                     = 1,
6810 
6811     /**
6812      * <p>All pixel data is replaced with an 8-bar color pattern.</p>
6813      * <p>The vertical bars (left-to-right) are as follows:</p>
6814      * <ul>
6815      * <li>100% white</li>
6816      * <li>yellow</li>
6817      * <li>cyan</li>
6818      * <li>green</li>
6819      * <li>magenta</li>
6820      * <li>red</li>
6821      * <li>blue</li>
6822      * <li>black</li>
6823      * </ul>
6824      * <p>In general the image would look like the following:</p>
6825      * <pre><code>W Y C G M R B K
6826      * W Y C G M R B K
6827      * W Y C G M R B K
6828      * W Y C G M R B K
6829      * W Y C G M R B K
6830      * . . . . . . . .
6831      * . . . . . . . .
6832      * . . . . . . . .
6833      *
6834      * (B = Blue, K = Black)
6835      * </code></pre>
6836      * <p>Each bar should take up 1/8 of the sensor pixel array width.
6837      * When this is not possible, the bar size should be rounded
6838      * down to the nearest integer and the pattern can repeat
6839      * on the right side.</p>
6840      * <p>Each bar's height must always take up the full sensor
6841      * pixel array height.</p>
6842      * <p>Each pixel in this test pattern must be set to either
6843      * 0% intensity or 100% intensity.</p>
6844      */
6845     ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS                      = 2,
6846 
6847     /**
6848      * <p>The test pattern is similar to COLOR_BARS, except that
6849      * each bar should start at its specified color at the top,
6850      * and fade to gray at the bottom.</p>
6851      * <p>Furthermore each bar is further subdivided into a left and
6852      * right half. The left half should have a smooth gradient,
6853      * and the right half should have a quantized gradient.</p>
6854      * <p>In particular, the right half's should consist of blocks of the
6855      * same color for 1/16th active sensor pixel array width.</p>
6856      * <p>The least significant bits in the quantized gradient should
6857      * be copied from the most significant bits of the smooth gradient.</p>
6858      * <p>The height of each bar should always be a multiple of 128.
6859      * When this is not the case, the pattern should repeat at the bottom
6860      * of the image.</p>
6861      */
6862     ACAMERA_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY         = 3,
6863 
6864     /**
6865      * <p>All pixel data is replaced by a pseudo-random sequence
6866      * generated from a PN9 512-bit sequence (typically implemented
6867      * in hardware with a linear feedback shift register).</p>
6868      * <p>The generator should be reset at the beginning of each frame,
6869      * and thus each subsequent raw frame with this test pattern should
6870      * be exactly the same as the last.</p>
6871      */
6872     ACAMERA_SENSOR_TEST_PATTERN_MODE_PN9                             = 4,
6873 
6874     /**
6875      * <p>The first custom test pattern. All custom patterns that are
6876      * available only on this camera device are at least this numeric
6877      * value.</p>
6878      * <p>All of the custom test patterns will be static
6879      * (that is the raw image must not vary from frame to frame).</p>
6880      */
6881     ACAMERA_SENSOR_TEST_PATTERN_MODE_CUSTOM1                         = 256,
6882 
6883 } acamera_metadata_enum_android_sensor_test_pattern_mode_t;
6884 
6885 
6886 // ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
6887 typedef enum acamera_metadata_enum_acamera_sensor_info_color_filter_arrangement {
6888     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB                = 0,
6889 
6890     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG                = 1,
6891 
6892     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG                = 2,
6893 
6894     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR                = 3,
6895 
6896     /**
6897      * <p>Sensor is not Bayer; output has 3 16-bit
6898      * values for each pixel, instead of just 1 16-bit value
6899      * per pixel.</p>
6900      */
6901     ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB                 = 4,
6902 
6903 } acamera_metadata_enum_android_sensor_info_color_filter_arrangement_t;
6904 
6905 // ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE
6906 typedef enum acamera_metadata_enum_acamera_sensor_info_timestamp_source {
6907     /**
6908      * <p>Timestamps from ACAMERA_SENSOR_TIMESTAMP are in nanoseconds and monotonic,
6909      * but can not be compared to timestamps from other subsystems
6910      * (e.g. accelerometer, gyro etc.), or other instances of the same or different
6911      * camera devices in the same system. Timestamps between streams and results for
6912      * a single camera instance are comparable, and the timestamps for all buffers
6913      * and the result metadata generated by a single capture are identical.</p>
6914      *
6915      * @see ACAMERA_SENSOR_TIMESTAMP
6916      */
6917     ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN                     = 0,
6918 
6919     /**
6920      * <p>Timestamps from ACAMERA_SENSOR_TIMESTAMP are in the same timebase as
6921      * <a href="https://developer.android.com/reference/android/os/SystemClock.html#elapsedRealtimeNanos">elapsedRealtimeNanos</a>
6922      * (or CLOCK_BOOTTIME), and they can be compared to other timestamps using that base.</p>
6923      *
6924      * @see ACAMERA_SENSOR_TIMESTAMP
6925      */
6926     ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME                    = 1,
6927 
6928 } acamera_metadata_enum_android_sensor_info_timestamp_source_t;
6929 
6930 // ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED
6931 typedef enum acamera_metadata_enum_acamera_sensor_info_lens_shading_applied {
6932     ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_FALSE                   = 0,
6933 
6934     ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED_TRUE                    = 1,
6935 
6936 } acamera_metadata_enum_android_sensor_info_lens_shading_applied_t;
6937 
6938 
6939 // ACAMERA_SHADING_MODE
6940 typedef enum acamera_metadata_enum_acamera_shading_mode {
6941     /**
6942      * <p>No lens shading correction is applied.</p>
6943      */
6944     ACAMERA_SHADING_MODE_OFF                                         = 0,
6945 
6946     /**
6947      * <p>Apply lens shading corrections, without slowing
6948      * frame rate relative to sensor raw output</p>
6949      */
6950     ACAMERA_SHADING_MODE_FAST                                        = 1,
6951 
6952     /**
6953      * <p>Apply high-quality lens shading correction, at the
6954      * cost of possibly reduced frame rate.</p>
6955      */
6956     ACAMERA_SHADING_MODE_HIGH_QUALITY                                = 2,
6957 
6958 } acamera_metadata_enum_android_shading_mode_t;
6959 
6960 
6961 // ACAMERA_STATISTICS_FACE_DETECT_MODE
6962 typedef enum acamera_metadata_enum_acamera_statistics_face_detect_mode {
6963     /**
6964      * <p>Do not include face detection statistics in capture
6965      * results.</p>
6966      */
6967     ACAMERA_STATISTICS_FACE_DETECT_MODE_OFF                          = 0,
6968 
6969     /**
6970      * <p>Return face rectangle and confidence values only.</p>
6971      */
6972     ACAMERA_STATISTICS_FACE_DETECT_MODE_SIMPLE                       = 1,
6973 
6974     /**
6975      * <p>Return all face
6976      * metadata.</p>
6977      * <p>In this mode, face rectangles, scores, landmarks, and face IDs are all valid.</p>
6978      */
6979     ACAMERA_STATISTICS_FACE_DETECT_MODE_FULL                         = 2,
6980 
6981 } acamera_metadata_enum_android_statistics_face_detect_mode_t;
6982 
6983 // ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE
6984 typedef enum acamera_metadata_enum_acamera_statistics_hot_pixel_map_mode {
6985     /**
6986      * <p>Hot pixel map production is disabled.</p>
6987      */
6988     ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_OFF                        = 0,
6989 
6990     /**
6991      * <p>Hot pixel map production is enabled.</p>
6992      */
6993     ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE_ON                         = 1,
6994 
6995 } acamera_metadata_enum_android_statistics_hot_pixel_map_mode_t;
6996 
6997 // ACAMERA_STATISTICS_SCENE_FLICKER
6998 typedef enum acamera_metadata_enum_acamera_statistics_scene_flicker {
6999     /**
7000      * <p>The camera device does not detect any flickering illumination
7001      * in the current scene.</p>
7002      */
7003     ACAMERA_STATISTICS_SCENE_FLICKER_NONE                            = 0,
7004 
7005     /**
7006      * <p>The camera device detects illumination flickering at 50Hz
7007      * in the current scene.</p>
7008      */
7009     ACAMERA_STATISTICS_SCENE_FLICKER_50HZ                            = 1,
7010 
7011     /**
7012      * <p>The camera device detects illumination flickering at 60Hz
7013      * in the current scene.</p>
7014      */
7015     ACAMERA_STATISTICS_SCENE_FLICKER_60HZ                            = 2,
7016 
7017 } acamera_metadata_enum_android_statistics_scene_flicker_t;
7018 
7019 // ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE
7020 typedef enum acamera_metadata_enum_acamera_statistics_lens_shading_map_mode {
7021     /**
7022      * <p>Do not include a lens shading map in the capture result.</p>
7023      */
7024     ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_OFF                     = 0,
7025 
7026     /**
7027      * <p>Include a lens shading map in the capture result.</p>
7028      */
7029     ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE_ON                      = 1,
7030 
7031 } acamera_metadata_enum_android_statistics_lens_shading_map_mode_t;
7032 
7033 
7034 
7035 // ACAMERA_TONEMAP_MODE
7036 typedef enum acamera_metadata_enum_acamera_tonemap_mode {
7037     /**
7038      * <p>Use the tone mapping curve specified in
7039      * the ACAMERA_TONEMAPCURVE_* entries.</p>
7040      * <p>All color enhancement and tonemapping must be disabled, except
7041      * for applying the tonemapping curve specified by
7042      * android.tonemap.curve.</p>
7043      * <p>Must not slow down frame rate relative to raw
7044      * sensor output.</p>
7045      */
7046     ACAMERA_TONEMAP_MODE_CONTRAST_CURVE                              = 0,
7047 
7048     /**
7049      * <p>Advanced gamma mapping and color enhancement may be applied, without
7050      * reducing frame rate compared to raw sensor output.</p>
7051      */
7052     ACAMERA_TONEMAP_MODE_FAST                                        = 1,
7053 
7054     /**
7055      * <p>High-quality gamma mapping and color enhancement will be applied, at
7056      * the cost of possibly reduced frame rate compared to raw sensor output.</p>
7057      */
7058     ACAMERA_TONEMAP_MODE_HIGH_QUALITY                                = 2,
7059 
7060     /**
7061      * <p>Use the gamma value specified in ACAMERA_TONEMAP_GAMMA to peform
7062      * tonemapping.</p>
7063      * <p>All color enhancement and tonemapping must be disabled, except
7064      * for applying the tonemapping curve specified by ACAMERA_TONEMAP_GAMMA.</p>
7065      * <p>Must not slow down frame rate relative to raw sensor output.</p>
7066      *
7067      * @see ACAMERA_TONEMAP_GAMMA
7068      */
7069     ACAMERA_TONEMAP_MODE_GAMMA_VALUE                                 = 3,
7070 
7071     /**
7072      * <p>Use the preset tonemapping curve specified in
7073      * ACAMERA_TONEMAP_PRESET_CURVE to peform tonemapping.</p>
7074      * <p>All color enhancement and tonemapping must be disabled, except
7075      * for applying the tonemapping curve specified by
7076      * ACAMERA_TONEMAP_PRESET_CURVE.</p>
7077      * <p>Must not slow down frame rate relative to raw sensor output.</p>
7078      *
7079      * @see ACAMERA_TONEMAP_PRESET_CURVE
7080      */
7081     ACAMERA_TONEMAP_MODE_PRESET_CURVE                                = 4,
7082 
7083 } acamera_metadata_enum_android_tonemap_mode_t;
7084 
7085 // ACAMERA_TONEMAP_PRESET_CURVE
7086 typedef enum acamera_metadata_enum_acamera_tonemap_preset_curve {
7087     /**
7088      * <p>Tonemapping curve is defined by sRGB</p>
7089      */
7090     ACAMERA_TONEMAP_PRESET_CURVE_SRGB                                = 0,
7091 
7092     /**
7093      * <p>Tonemapping curve is defined by ITU-R BT.709</p>
7094      */
7095     ACAMERA_TONEMAP_PRESET_CURVE_REC709                              = 1,
7096 
7097 } acamera_metadata_enum_android_tonemap_preset_curve_t;
7098 
7099 
7100 
7101 // ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL
7102 typedef enum acamera_metadata_enum_acamera_info_supported_hardware_level {
7103     /**
7104      * <p>This camera device does not have enough capabilities to qualify as a <code>FULL</code> device or
7105      * better.</p>
7106      * <p>Only the stream configurations listed in the <code>LEGACY</code> and <code>LIMITED</code> tables in the
7107      * {@link ACameraDevice_createCaptureSession} documentation are guaranteed to be supported.</p>
7108      * <p>All <code>LIMITED</code> devices support the <code>BACKWARDS_COMPATIBLE</code> capability, indicating basic
7109      * support for color image capture. The only exception is that the device may
7110      * alternatively support only the <code>DEPTH_OUTPUT</code> capability, if it can only output depth
7111      * measurements and not color images.</p>
7112      * <p><code>LIMITED</code> devices and above require the use of ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
7113      * to lock exposure metering (and calculate flash power, for cameras with flash) before
7114      * capturing a high-quality still image.</p>
7115      * <p>A <code>LIMITED</code> device that only lists the <code>BACKWARDS_COMPATIBLE</code> capability is only
7116      * required to support full-automatic operation and post-processing (<code>OFF</code> is not
7117      * supported for ACAMERA_CONTROL_AE_MODE, ACAMERA_CONTROL_AF_MODE, or
7118      * ACAMERA_CONTROL_AWB_MODE)</p>
7119      * <p>Additional capabilities may optionally be supported by a <code>LIMITED</code>-level device, and
7120      * can be checked for in ACAMERA_REQUEST_AVAILABLE_CAPABILITIES.</p>
7121      *
7122      * @see ACAMERA_CONTROL_AE_MODE
7123      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
7124      * @see ACAMERA_CONTROL_AF_MODE
7125      * @see ACAMERA_CONTROL_AWB_MODE
7126      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
7127      */
7128     ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED                    = 0,
7129 
7130     /**
7131      * <p>This camera device is capable of supporting advanced imaging applications.</p>
7132      * <p>The stream configurations listed in the <code>FULL</code>, <code>LEGACY</code> and <code>LIMITED</code> tables in the
7133      * {@link ACameraDevice_createCaptureSession} documentation are guaranteed to be supported.</p>
7134      * <p>A <code>FULL</code> device will support below capabilities:</p>
7135      * <ul>
7136      * <li><code>BURST_CAPTURE</code> capability (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains
7137      *   <code>BURST_CAPTURE</code>)</li>
7138      * <li>Per frame control (ACAMERA_SYNC_MAX_LATENCY <code>==</code> PER_FRAME_CONTROL)</li>
7139      * <li>Manual sensor control (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains <code>MANUAL_SENSOR</code>)</li>
7140      * <li>Manual post-processing control (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains
7141      *   <code>MANUAL_POST_PROCESSING</code>)</li>
7142      * <li>The required exposure time range defined in ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE</li>
7143      * <li>The required maxFrameDuration defined in ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION</li>
7144      * </ul>
7145      * <p>Note:
7146      * Pre-API level 23, FULL devices also supported arbitrary cropping region
7147      * (ACAMERA_SCALER_CROPPING_TYPE <code>== FREEFORM</code>); this requirement was relaxed in API level
7148      * 23, and <code>FULL</code> devices may only support <code>CENTERED</code> cropping.</p>
7149      *
7150      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
7151      * @see ACAMERA_SCALER_CROPPING_TYPE
7152      * @see ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE
7153      * @see ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION
7154      * @see ACAMERA_SYNC_MAX_LATENCY
7155      */
7156     ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_FULL                       = 1,
7157 
7158     /**
7159      * <p>This camera device is running in backward compatibility mode.</p>
7160      * <p>Only the stream configurations listed in the <code>LEGACY</code> table in the {@link
7161      * ACameraDevice_createCaptureSession} documentation are supported.</p>
7162      * <p>A <code>LEGACY</code> device does not support per-frame control, manual sensor control, manual
7163      * post-processing, arbitrary cropping regions, and has relaxed performance constraints.
7164      * No additional capabilities beyond <code>BACKWARD_COMPATIBLE</code> will ever be listed by a
7165      * <code>LEGACY</code> device in ACAMERA_REQUEST_AVAILABLE_CAPABILITIES.</p>
7166      * <p>In addition, the ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER is not functional on <code>LEGACY</code>
7167      * devices. Instead, every request that includes a JPEG-format output target is treated
7168      * as triggering a still capture, internally executing a precapture trigger.  This may
7169      * fire the flash for flash power metering during precapture, and then fire the flash
7170      * for the final capture, if a flash is available on the device and the AE mode is set to
7171      * enable the flash.</p>
7172      *
7173      * @see ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER
7174      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
7175      */
7176     ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY                     = 2,
7177 
7178     /**
7179      * <p>This camera device is capable of YUV reprocessing and RAW data capture, in addition to
7180      * FULL-level capabilities.</p>
7181      * <p>The stream configurations listed in the <code>LEVEL_3</code>, <code>RAW</code>, <code>FULL</code>, <code>LEGACY</code> and
7182      * <code>LIMITED</code> tables in the {@link
7183      * ACameraDevice_createCaptureSession}
7184      * documentation are guaranteed to be supported.</p>
7185      * <p>The following additional capabilities are guaranteed to be supported:</p>
7186      * <ul>
7187      * <li><code>YUV_REPROCESSING</code> capability (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains
7188      *   <code>YUV_REPROCESSING</code>)</li>
7189      * <li><code>RAW</code> capability (ACAMERA_REQUEST_AVAILABLE_CAPABILITIES contains
7190      *   <code>RAW</code>)</li>
7191      * </ul>
7192      *
7193      * @see ACAMERA_REQUEST_AVAILABLE_CAPABILITIES
7194      */
7195     ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL_3                          = 3,
7196 
7197 } acamera_metadata_enum_android_info_supported_hardware_level_t;
7198 
7199 
7200 // ACAMERA_BLACK_LEVEL_LOCK
7201 typedef enum acamera_metadata_enum_acamera_black_level_lock {
7202     ACAMERA_BLACK_LEVEL_LOCK_OFF                                     = 0,
7203 
7204     ACAMERA_BLACK_LEVEL_LOCK_ON                                      = 1,
7205 
7206 } acamera_metadata_enum_android_black_level_lock_t;
7207 
7208 
7209 // ACAMERA_SYNC_FRAME_NUMBER
7210 typedef enum acamera_metadata_enum_acamera_sync_frame_number {
7211     /**
7212      * <p>The current result is not yet fully synchronized to any request.</p>
7213      * <p>Synchronization is in progress, and reading metadata from this
7214      * result may include a mix of data that have taken effect since the
7215      * last synchronization time.</p>
7216      * <p>In some future result, within ACAMERA_SYNC_MAX_LATENCY frames,
7217      * this value will update to the actual frame number frame number
7218      * the result is guaranteed to be synchronized to (as long as the
7219      * request settings remain constant).</p>
7220      *
7221      * @see ACAMERA_SYNC_MAX_LATENCY
7222      */
7223     ACAMERA_SYNC_FRAME_NUMBER_CONVERGING                             = -1,
7224 
7225     /**
7226      * <p>The current result's synchronization status is unknown.</p>
7227      * <p>The result may have already converged, or it may be in
7228      * progress.  Reading from this result may include some mix
7229      * of settings from past requests.</p>
7230      * <p>After a settings change, the new settings will eventually all
7231      * take effect for the output buffers and results. However, this
7232      * value will not change when that happens. Altering settings
7233      * rapidly may provide outcomes using mixes of settings from recent
7234      * requests.</p>
7235      * <p>This value is intended primarily for backwards compatibility with
7236      * the older camera implementations (for android.hardware.Camera).</p>
7237      */
7238     ACAMERA_SYNC_FRAME_NUMBER_UNKNOWN                                = -2,
7239 
7240 } acamera_metadata_enum_android_sync_frame_number_t;
7241 
7242 // ACAMERA_SYNC_MAX_LATENCY
7243 typedef enum acamera_metadata_enum_acamera_sync_max_latency {
7244     /**
7245      * <p>Every frame has the requests immediately applied.</p>
7246      * <p>Changing controls over multiple requests one after another will
7247      * produce results that have those controls applied atomically
7248      * each frame.</p>
7249      * <p>All FULL capability devices will have this as their maxLatency.</p>
7250      */
7251     ACAMERA_SYNC_MAX_LATENCY_PER_FRAME_CONTROL                       = 0,
7252 
7253     /**
7254      * <p>Each new frame has some subset (potentially the entire set)
7255      * of the past requests applied to the camera settings.</p>
7256      * <p>By submitting a series of identical requests, the camera device
7257      * will eventually have the camera settings applied, but it is
7258      * unknown when that exact point will be.</p>
7259      * <p>All LEGACY capability devices will have this as their maxLatency.</p>
7260      */
7261     ACAMERA_SYNC_MAX_LATENCY_UNKNOWN                                 = -1,
7262 
7263 } acamera_metadata_enum_android_sync_max_latency_t;
7264 
7265 
7266 
7267 // ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS
7268 typedef enum acamera_metadata_enum_acamera_depth_available_depth_stream_configurations {
7269     ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT       = 0,
7270 
7271     ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_INPUT        = 1,
7272 
7273 } acamera_metadata_enum_android_depth_available_depth_stream_configurations_t;
7274 
7275 // ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE
7276 typedef enum acamera_metadata_enum_acamera_depth_depth_is_exclusive {
7277     ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE                           = 0,
7278 
7279     ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE_TRUE                            = 1,
7280 
7281 } acamera_metadata_enum_android_depth_depth_is_exclusive_t;
7282 
7283 
7284 #endif /* __ANDROID_API__ >= 24 */
7285 
7286 __END_DECLS
7287 
7288 #endif /* _NDK_CAMERA_METADATA_TAGS_H */
7289 
7290 /** @} */
7291