CameraMetadata.java revision 8dda7273dbb4ff6eeffe7d4c3831e9b31b8e5ac1
1/* 2 * Copyright (C) 2013 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 17package android.hardware.camera2; 18 19import android.hardware.camera2.impl.CameraMetadataNative; 20 21import java.lang.reflect.Field; 22import java.lang.reflect.Modifier; 23import java.util.ArrayList; 24import java.util.Collections; 25import java.util.List; 26 27/** 28 * The base class for camera controls and information. 29 * 30 * <p> 31 * This class defines the basic key/value map used for querying for camera 32 * characteristics or capture results, and for setting camera request 33 * parameters. 34 * </p> 35 * 36 * <p> 37 * All instances of CameraMetadata are immutable. The list of keys with {@link #getKeys()} 38 * never changes, nor do the values returned by any key with {@link #get} throughout 39 * the lifetime of the object. 40 * </p> 41 * 42 * @see CameraDevice 43 * @see CameraManager 44 * @see CameraCharacteristics 45 **/ 46public abstract class CameraMetadata { 47 48 /** 49 * Set a camera metadata field to a value. The field definitions can be 50 * found in {@link CameraCharacteristics}, {@link CaptureResult}, and 51 * {@link CaptureRequest}. 52 * 53 * @param key The metadata field to write. 54 * @param value The value to set the field to, which must be of a matching 55 * type to the key. 56 * 57 * @hide 58 */ 59 protected CameraMetadata() { 60 } 61 62 /** 63 * Get a camera metadata field value. 64 * 65 * <p>The field definitions can be 66 * found in {@link CameraCharacteristics}, {@link CaptureResult}, and 67 * {@link CaptureRequest}.</p> 68 * 69 * <p>Querying the value for the same key more than once will return a value 70 * which is equal to the previous queried value.</p> 71 * 72 * @throws IllegalArgumentException if the key was not valid 73 * 74 * @param key The metadata field to read. 75 * @return The value of that key, or {@code null} if the field is not set. 76 */ 77 public abstract <T> T get(Key<T> key); 78 79 /** 80 * Returns a list of the keys contained in this map. 81 * 82 * <p>The list returned is not modifiable, so any attempts to modify it will throw 83 * a {@code UnsupportedOperationException}.</p> 84 * 85 * <p>All values retrieved by a key from this list with {@link #get} are guaranteed to be 86 * non-{@code null}. Each key is only listed once in the list. The order of the keys 87 * is undefined.</p> 88 * 89 * @return List of the keys contained in this map. 90 */ 91 public List<Key<?>> getKeys() { 92 return Collections.unmodifiableList(getKeysStatic(this.getClass(), this)); 93 } 94 95 /** 96 * Return a list of all the Key<?> that are declared as a field inside of the class 97 * {@code type}. 98 * 99 * <p> 100 * Optionally, if {@code instance} is not null, then filter out any keys with null values. 101 * </p> 102 */ 103 /*package*/ static ArrayList<Key<?>> getKeysStatic(Class<? extends CameraMetadata> type, 104 CameraMetadata instance) { 105 ArrayList<Key<?>> keyList = new ArrayList<Key<?>>(); 106 107 Field[] fields = type.getDeclaredFields(); 108 for (Field field : fields) { 109 // Filter for Keys that are public 110 if (field.getType().isAssignableFrom(Key.class) && 111 (field.getModifiers() & Modifier.PUBLIC) != 0) { 112 Key<?> key; 113 try { 114 key = (Key<?>) field.get(instance); 115 } catch (IllegalAccessException e) { 116 throw new AssertionError("Can't get IllegalAccessException", e); 117 } catch (IllegalArgumentException e) { 118 throw new AssertionError("Can't get IllegalArgumentException", e); 119 } 120 if (instance == null || instance.get(key) != null) { 121 keyList.add(key); 122 } 123 } 124 } 125 126 return keyList; 127 } 128 129 public static class Key<T> { 130 131 private boolean mHasTag; 132 private int mTag; 133 private final Class<T> mType; 134 private final String mName; 135 136 /** 137 * @hide 138 */ 139 public Key(String name, Class<T> type) { 140 if (name == null) { 141 throw new NullPointerException("Key needs a valid name"); 142 } else if (type == null) { 143 throw new NullPointerException("Type needs to be non-null"); 144 } 145 mName = name; 146 mType = type; 147 } 148 149 public final String getName() { 150 return mName; 151 } 152 153 @Override 154 public final int hashCode() { 155 return mName.hashCode(); 156 } 157 158 @Override 159 @SuppressWarnings("unchecked") 160 public final boolean equals(Object o) { 161 if (this == o) { 162 return true; 163 } 164 165 if (!(o instanceof Key)) { 166 return false; 167 } 168 169 Key lhs = (Key) o; 170 171 return mName.equals(lhs.mName) && mType.equals(lhs.mType); 172 } 173 174 /** 175 * <p> 176 * Get the tag corresponding to this key. This enables insertion into the 177 * native metadata. 178 * </p> 179 * 180 * <p>This value is looked up the first time, and cached subsequently.</p> 181 * 182 * @return The tag numeric value corresponding to the string 183 * 184 * @hide 185 */ 186 public final int getTag() { 187 if (!mHasTag) { 188 mTag = CameraMetadataNative.getTag(mName); 189 mHasTag = true; 190 } 191 return mTag; 192 } 193 194 /** 195 * @hide 196 */ 197 public final Class<T> getType() { 198 return mType; 199 } 200 } 201 202 /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 203 * The enum values below this point are generated from metadata 204 * definitions in /system/media/camera/docs. Do not modify by hand or 205 * modify the comment blocks at the start or end. 206 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/ 207 208 // 209 // Enumeration values for CameraCharacteristics#LENS_INFO_FOCUS_DISTANCE_CALIBRATION 210 // 211 212 /** 213 * <p>The lens focus distance is not accurate, and the units used for 214 * {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance} do not correspond to any physical units. 215 * Setting the lens to the same focus distance on separate occasions may 216 * result in a different real focus distance, depending on factors such 217 * as the orientation of the device, the age of the focusing mechanism, 218 * and the device temperature. The focus distance value will still be 219 * in the range of <code>[0, {@link CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE android.lens.info.minimumFocusDistance}]</code>, where 0 220 * represents the farthest focus.</p> 221 * 222 * @see CaptureRequest#LENS_FOCUS_DISTANCE 223 * @see CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE 224 * @see CameraCharacteristics#LENS_INFO_FOCUS_DISTANCE_CALIBRATION 225 */ 226 public static final int LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED = 0; 227 228 /** 229 * <p>The lens focus distance is measured in diopters. However, setting the lens 230 * to the same focus distance on separate occasions may result in a 231 * different real focus distance, depending on factors such as the 232 * orientation of the device, the age of the focusing mechanism, and 233 * the device temperature.</p> 234 * @see CameraCharacteristics#LENS_INFO_FOCUS_DISTANCE_CALIBRATION 235 */ 236 public static final int LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE = 1; 237 238 /** 239 * <p>The lens focus distance is measured in diopters. The lens mechanism is 240 * calibrated so that setting the same focus distance is repeatable on 241 * multiple occasions with good accuracy, and the focus distance corresponds 242 * to the real physical distance to the plane of best focus.</p> 243 * @see CameraCharacteristics#LENS_INFO_FOCUS_DISTANCE_CALIBRATION 244 */ 245 public static final int LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED = 2; 246 247 // 248 // Enumeration values for CameraCharacteristics#LENS_FACING 249 // 250 251 /** 252 * @see CameraCharacteristics#LENS_FACING 253 */ 254 public static final int LENS_FACING_FRONT = 0; 255 256 /** 257 * @see CameraCharacteristics#LENS_FACING 258 */ 259 public static final int LENS_FACING_BACK = 1; 260 261 // 262 // Enumeration values for CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 263 // 264 265 /** 266 * <p>The minimal set of capabilities that every camera 267 * device (regardless of {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL android.info.supportedHardwareLevel}) 268 * will support.</p> 269 * <p>The full set of features supported by this capability makes 270 * the camera2 api backwards compatible with the camera1 271 * (android.hardware.Camera) API.</p> 272 * <p>TODO: @hide this. Doesn't really mean anything except 273 * act as a catch-all for all the 'base' functionality.</p> 274 * 275 * @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 276 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 277 */ 278 public static final int REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE = 0; 279 280 /** 281 * <p>This is a catch-all capability to include all other 282 * tags or functionality not encapsulated by one of the other 283 * capabilities.</p> 284 * <p>A typical example is all tags marked 'optional'.</p> 285 * <p>TODO: @hide. We may not need this if we @hide all the optional 286 * tags not belonging to a capability.</p> 287 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 288 */ 289 public static final int REQUEST_AVAILABLE_CAPABILITIES_OPTIONAL = 1; 290 291 /** 292 * <p>The camera device can be manually controlled (3A algorithms such 293 * as auto exposure, and auto focus can be 294 * bypassed), this includes but is not limited to:</p> 295 * <ul> 296 * <li>Manual exposure control<ul> 297 * <li>{@link CaptureRequest#SENSOR_EXPOSURE_TIME android.sensor.exposureTime}</li> 298 * <li>{@link CameraCharacteristics#SENSOR_INFO_EXPOSURE_TIME_RANGE android.sensor.info.exposureTimeRange}</li> 299 * </ul> 300 * </li> 301 * <li>Manual sensitivity control<ul> 302 * <li>{@link CaptureRequest#SENSOR_SENSITIVITY android.sensor.sensitivity}</li> 303 * <li>{@link CameraCharacteristics#SENSOR_INFO_SENSITIVITY_RANGE android.sensor.info.sensitivityRange}</li> 304 * <li>{@link CameraCharacteristics#SENSOR_BASE_GAIN_FACTOR android.sensor.baseGainFactor}</li> 305 * </ul> 306 * </li> 307 * <li>Manual lens control<ul> 308 * <li>android.lens.*</li> 309 * </ul> 310 * </li> 311 * <li>Manual flash control<ul> 312 * <li>android.flash.*</li> 313 * </ul> 314 * </li> 315 * <li>Manual black level locking<ul> 316 * <li>{@link CaptureRequest#BLACK_LEVEL_LOCK android.blackLevel.lock}</li> 317 * </ul> 318 * </li> 319 * </ul> 320 * <p>If any of the above 3A algorithms are enabled, then the camera 321 * device will accurately report the values applied by 3A in the 322 * result.</p> 323 * 324 * @see CaptureRequest#BLACK_LEVEL_LOCK 325 * @see CameraCharacteristics#SENSOR_BASE_GAIN_FACTOR 326 * @see CaptureRequest#SENSOR_EXPOSURE_TIME 327 * @see CameraCharacteristics#SENSOR_INFO_EXPOSURE_TIME_RANGE 328 * @see CameraCharacteristics#SENSOR_INFO_SENSITIVITY_RANGE 329 * @see CaptureRequest#SENSOR_SENSITIVITY 330 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 331 */ 332 public static final int REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR = 2; 333 334 /** 335 * <p>TODO: This should be @hide</p> 336 * <ul> 337 * <li>Manual tonemap control<ul> 338 * <li>{@link CaptureRequest#TONEMAP_CURVE_BLUE android.tonemap.curveBlue}</li> 339 * <li>{@link CaptureRequest#TONEMAP_CURVE_GREEN android.tonemap.curveGreen}</li> 340 * <li>{@link CaptureRequest#TONEMAP_CURVE_RED android.tonemap.curveRed}</li> 341 * <li>{@link CaptureRequest#TONEMAP_MODE android.tonemap.mode}</li> 342 * <li>{@link CameraCharacteristics#TONEMAP_MAX_CURVE_POINTS android.tonemap.maxCurvePoints}</li> 343 * </ul> 344 * </li> 345 * <li>Manual white balance control<ul> 346 * <li>{@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform}</li> 347 * <li>{@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains}</li> 348 * </ul> 349 * </li> 350 * <li>Lens shading map information<ul> 351 * <li>{@link CaptureResult#STATISTICS_LENS_SHADING_MAP android.statistics.lensShadingMap}</li> 352 * <li>{@link CameraCharacteristics#LENS_INFO_SHADING_MAP_SIZE android.lens.info.shadingMapSize}</li> 353 * </ul> 354 * </li> 355 * </ul> 356 * <p>If auto white balance is enabled, then the camera device 357 * will accurately report the values applied by AWB in the result.</p> 358 * <p>The camera device will also support everything in MANUAL_SENSOR 359 * except manual lens control and manual flash control.</p> 360 * 361 * @see CaptureRequest#COLOR_CORRECTION_GAINS 362 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 363 * @see CameraCharacteristics#LENS_INFO_SHADING_MAP_SIZE 364 * @see CaptureResult#STATISTICS_LENS_SHADING_MAP 365 * @see CaptureRequest#TONEMAP_CURVE_BLUE 366 * @see CaptureRequest#TONEMAP_CURVE_GREEN 367 * @see CaptureRequest#TONEMAP_CURVE_RED 368 * @see CameraCharacteristics#TONEMAP_MAX_CURVE_POINTS 369 * @see CaptureRequest#TONEMAP_MODE 370 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 371 */ 372 public static final int REQUEST_AVAILABLE_CAPABILITIES_GCAM = 3; 373 374 /** 375 * <p>The camera device supports the Zero Shutter Lag use case.</p> 376 * <ul> 377 * <li>At least one input stream can be used.</li> 378 * <li>RAW_OPAQUE is supported as an output/input format</li> 379 * <li>Using RAW_OPAQUE does not cause a frame rate drop 380 * relative to the sensor's maximum capture rate (at that 381 * resolution).</li> 382 * <li>RAW_OPAQUE will be reprocessable into both YUV_420_888 383 * and JPEG formats.</li> 384 * <li>The maximum available resolution for RAW_OPAQUE streams 385 * (both input/output) will match the maximum available 386 * resolution of JPEG streams.</li> 387 * </ul> 388 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 389 */ 390 public static final int REQUEST_AVAILABLE_CAPABILITIES_ZSL = 4; 391 392 /** 393 * <p>The camera device supports outputting RAW buffers that can be 394 * saved offline into a DNG format. It can reprocess DNG 395 * files (produced from the same camera device) back into YUV.</p> 396 * <ul> 397 * <li>At least one input stream can be used.</li> 398 * <li>RAW16 is supported as output/input format.</li> 399 * <li>RAW16 is reprocessable into both YUV_420_888 and JPEG 400 * formats.</li> 401 * <li>The maximum available resolution for RAW16 streams (both 402 * input/output) will match the value in 403 * {@link CameraCharacteristics#SENSOR_INFO_PIXEL_ARRAY_SIZE android.sensor.info.pixelArraySize}.</li> 404 * <li>All DNG-related optional metadata entries are provided 405 * by the camera device.</li> 406 * </ul> 407 * 408 * @see CameraCharacteristics#SENSOR_INFO_PIXEL_ARRAY_SIZE 409 * @see CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES 410 */ 411 public static final int REQUEST_AVAILABLE_CAPABILITIES_DNG = 5; 412 413 // 414 // Enumeration values for CameraCharacteristics#SCALER_AVAILABLE_STREAM_CONFIGURATIONS 415 // 416 417 /** 418 * @see CameraCharacteristics#SCALER_AVAILABLE_STREAM_CONFIGURATIONS 419 */ 420 public static final int SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT = 0; 421 422 /** 423 * @see CameraCharacteristics#SCALER_AVAILABLE_STREAM_CONFIGURATIONS 424 */ 425 public static final int SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT = 1; 426 427 // 428 // Enumeration values for CameraCharacteristics#LED_AVAILABLE_LEDS 429 // 430 431 /** 432 * <p>android.led.transmit control is used</p> 433 * @see CameraCharacteristics#LED_AVAILABLE_LEDS 434 * @hide 435 */ 436 public static final int LED_AVAILABLE_LEDS_TRANSMIT = 0; 437 438 // 439 // Enumeration values for CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 440 // 441 442 /** 443 * @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 444 */ 445 public static final int INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED = 0; 446 447 /** 448 * @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 449 */ 450 public static final int INFO_SUPPORTED_HARDWARE_LEVEL_FULL = 1; 451 452 // 453 // Enumeration values for CameraCharacteristics#SYNC_MAX_LATENCY 454 // 455 456 /** 457 * <p>Every frame has the requests immediately applied. 458 * (and furthermore for all results, 459 * <code>android.sync.frameNumber == android.request.frameCount</code>)</p> 460 * <p>Changing controls over multiple requests one after another will 461 * produce results that have those controls applied atomically 462 * each frame.</p> 463 * <p>All FULL capability devices will have this as their maxLatency.</p> 464 * @see CameraCharacteristics#SYNC_MAX_LATENCY 465 */ 466 public static final int SYNC_MAX_LATENCY_PER_FRAME_CONTROL = 0; 467 468 /** 469 * <p>Each new frame has some subset (potentially the entire set) 470 * of the past requests applied to the camera settings.</p> 471 * <p>By submitting a series of identical requests, the camera device 472 * will eventually have the camera settings applied, but it is 473 * unknown when that exact point will be.</p> 474 * @see CameraCharacteristics#SYNC_MAX_LATENCY 475 */ 476 public static final int SYNC_MAX_LATENCY_UNKNOWN = -1; 477 478 // 479 // Enumeration values for CaptureRequest#COLOR_CORRECTION_MODE 480 // 481 482 /** 483 * <p>Use the {@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform} matrix 484 * and {@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains} to do color conversion.</p> 485 * <p>All advanced white balance adjustments (not specified 486 * by our white balance pipeline) must be disabled.</p> 487 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 488 * TRANSFORM_MATRIX is ignored. The camera device will override 489 * this value to either FAST or HIGH_QUALITY.</p> 490 * 491 * @see CaptureRequest#COLOR_CORRECTION_GAINS 492 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 493 * @see CaptureRequest#CONTROL_AWB_MODE 494 * @see CaptureRequest#COLOR_CORRECTION_MODE 495 */ 496 public static final int COLOR_CORRECTION_MODE_TRANSFORM_MATRIX = 0; 497 498 /** 499 * <p>Must not slow down capture rate relative to sensor raw 500 * output.</p> 501 * <p>Advanced white balance adjustments above and beyond 502 * the specified white balance pipeline may be applied.</p> 503 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 504 * the camera device uses the last frame's AWB values 505 * (or defaults if AWB has never been run).</p> 506 * 507 * @see CaptureRequest#CONTROL_AWB_MODE 508 * @see CaptureRequest#COLOR_CORRECTION_MODE 509 */ 510 public static final int COLOR_CORRECTION_MODE_FAST = 1; 511 512 /** 513 * <p>Capture rate (relative to sensor raw output) 514 * may be reduced by high quality.</p> 515 * <p>Advanced white balance adjustments above and beyond 516 * the specified white balance pipeline may be applied.</p> 517 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 518 * the camera device uses the last frame's AWB values 519 * (or defaults if AWB has never been run).</p> 520 * 521 * @see CaptureRequest#CONTROL_AWB_MODE 522 * @see CaptureRequest#COLOR_CORRECTION_MODE 523 */ 524 public static final int COLOR_CORRECTION_MODE_HIGH_QUALITY = 2; 525 526 // 527 // Enumeration values for CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 528 // 529 530 /** 531 * <p>The camera device will not adjust exposure duration to 532 * avoid banding problems.</p> 533 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 534 */ 535 public static final int CONTROL_AE_ANTIBANDING_MODE_OFF = 0; 536 537 /** 538 * <p>The camera device will adjust exposure duration to 539 * avoid banding problems with 50Hz illumination sources.</p> 540 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 541 */ 542 public static final int CONTROL_AE_ANTIBANDING_MODE_50HZ = 1; 543 544 /** 545 * <p>The camera device will adjust exposure duration to 546 * avoid banding problems with 60Hz illumination 547 * sources.</p> 548 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 549 */ 550 public static final int CONTROL_AE_ANTIBANDING_MODE_60HZ = 2; 551 552 /** 553 * <p>The camera device will automatically adapt its 554 * antibanding routine to the current illumination 555 * conditions. This is the default.</p> 556 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 557 */ 558 public static final int CONTROL_AE_ANTIBANDING_MODE_AUTO = 3; 559 560 // 561 // Enumeration values for CaptureRequest#CONTROL_AE_MODE 562 // 563 564 /** 565 * <p>The camera device's autoexposure routine is disabled; 566 * the application-selected {@link CaptureRequest#SENSOR_EXPOSURE_TIME android.sensor.exposureTime}, 567 * {@link CaptureRequest#SENSOR_SENSITIVITY android.sensor.sensitivity} and 568 * {@link CaptureRequest#SENSOR_FRAME_DURATION android.sensor.frameDuration} are used by the camera 569 * device, along with android.flash.* fields, if there's 570 * a flash unit for this camera device.</p> 571 * 572 * @see CaptureRequest#SENSOR_EXPOSURE_TIME 573 * @see CaptureRequest#SENSOR_FRAME_DURATION 574 * @see CaptureRequest#SENSOR_SENSITIVITY 575 * @see CaptureRequest#CONTROL_AE_MODE 576 */ 577 public static final int CONTROL_AE_MODE_OFF = 0; 578 579 /** 580 * <p>The camera device's autoexposure routine is active, 581 * with no flash control. The application's values for 582 * {@link CaptureRequest#SENSOR_EXPOSURE_TIME android.sensor.exposureTime}, 583 * {@link CaptureRequest#SENSOR_SENSITIVITY android.sensor.sensitivity}, and 584 * {@link CaptureRequest#SENSOR_FRAME_DURATION android.sensor.frameDuration} are ignored. The 585 * application has control over the various 586 * android.flash.* fields.</p> 587 * 588 * @see CaptureRequest#SENSOR_EXPOSURE_TIME 589 * @see CaptureRequest#SENSOR_FRAME_DURATION 590 * @see CaptureRequest#SENSOR_SENSITIVITY 591 * @see CaptureRequest#CONTROL_AE_MODE 592 */ 593 public static final int CONTROL_AE_MODE_ON = 1; 594 595 /** 596 * <p>Like ON, except that the camera device also controls 597 * the camera's flash unit, firing it in low-light 598 * conditions. The flash may be fired during a 599 * precapture sequence (triggered by 600 * {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger}) and may be fired 601 * for captures for which the 602 * {@link CaptureRequest#CONTROL_CAPTURE_INTENT android.control.captureIntent} field is set to 603 * STILL_CAPTURE</p> 604 * 605 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 606 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 607 * @see CaptureRequest#CONTROL_AE_MODE 608 */ 609 public static final int CONTROL_AE_MODE_ON_AUTO_FLASH = 2; 610 611 /** 612 * <p>Like ON, except that the camera device also controls 613 * the camera's flash unit, always firing it for still 614 * captures. The flash may be fired during a precapture 615 * sequence (triggered by 616 * {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger}) and will always 617 * be fired for captures for which the 618 * {@link CaptureRequest#CONTROL_CAPTURE_INTENT android.control.captureIntent} field is set to 619 * STILL_CAPTURE</p> 620 * 621 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 622 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 623 * @see CaptureRequest#CONTROL_AE_MODE 624 */ 625 public static final int CONTROL_AE_MODE_ON_ALWAYS_FLASH = 3; 626 627 /** 628 * <p>Like ON_AUTO_FLASH, but with automatic red eye 629 * reduction. If deemed necessary by the camera device, 630 * a red eye reduction flash will fire during the 631 * precapture sequence.</p> 632 * @see CaptureRequest#CONTROL_AE_MODE 633 */ 634 public static final int CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE = 4; 635 636 // 637 // Enumeration values for CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 638 // 639 640 /** 641 * <p>The trigger is idle.</p> 642 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 643 */ 644 public static final int CONTROL_AE_PRECAPTURE_TRIGGER_IDLE = 0; 645 646 /** 647 * <p>The precapture metering sequence will be started 648 * by the camera device. The exact effect of the precapture 649 * trigger depends on the current AE mode and state.</p> 650 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 651 */ 652 public static final int CONTROL_AE_PRECAPTURE_TRIGGER_START = 1; 653 654 // 655 // Enumeration values for CaptureRequest#CONTROL_AF_MODE 656 // 657 658 /** 659 * <p>The auto-focus routine does not control the lens; 660 * {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance} is controlled by the 661 * application</p> 662 * 663 * @see CaptureRequest#LENS_FOCUS_DISTANCE 664 * @see CaptureRequest#CONTROL_AF_MODE 665 */ 666 public static final int CONTROL_AF_MODE_OFF = 0; 667 668 /** 669 * <p>If lens is not fixed focus.</p> 670 * <p>Use {@link CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE android.lens.info.minimumFocusDistance} to determine if lens 671 * is fixed-focus. In this mode, the lens does not move unless 672 * the autofocus trigger action is called. When that trigger 673 * is activated, AF must transition to ACTIVE_SCAN, then to 674 * the outcome of the scan (FOCUSED or NOT_FOCUSED).</p> 675 * <p>Triggering AF_CANCEL resets the lens position to default, 676 * and sets the AF state to INACTIVE.</p> 677 * 678 * @see CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE 679 * @see CaptureRequest#CONTROL_AF_MODE 680 */ 681 public static final int CONTROL_AF_MODE_AUTO = 1; 682 683 /** 684 * <p>In this mode, the lens does not move unless the 685 * autofocus trigger action is called.</p> 686 * <p>When that trigger is activated, AF must transition to 687 * ACTIVE_SCAN, then to the outcome of the scan (FOCUSED or 688 * NOT_FOCUSED). Triggering cancel AF resets the lens 689 * position to default, and sets the AF state to 690 * INACTIVE.</p> 691 * @see CaptureRequest#CONTROL_AF_MODE 692 */ 693 public static final int CONTROL_AF_MODE_MACRO = 2; 694 695 /** 696 * <p>In this mode, the AF algorithm modifies the lens 697 * position continually to attempt to provide a 698 * constantly-in-focus image stream.</p> 699 * <p>The focusing behavior should be suitable for good quality 700 * video recording; typically this means slower focus 701 * movement and no overshoots. When the AF trigger is not 702 * involved, the AF algorithm should start in INACTIVE state, 703 * and then transition into PASSIVE_SCAN and PASSIVE_FOCUSED 704 * states as appropriate. When the AF trigger is activated, 705 * the algorithm should immediately transition into 706 * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the 707 * lens position until a cancel AF trigger is received.</p> 708 * <p>Once cancel is received, the algorithm should transition 709 * back to INACTIVE and resume passive scan. Note that this 710 * behavior is not identical to CONTINUOUS_PICTURE, since an 711 * ongoing PASSIVE_SCAN must immediately be 712 * canceled.</p> 713 * @see CaptureRequest#CONTROL_AF_MODE 714 */ 715 public static final int CONTROL_AF_MODE_CONTINUOUS_VIDEO = 3; 716 717 /** 718 * <p>In this mode, the AF algorithm modifies the lens 719 * position continually to attempt to provide a 720 * constantly-in-focus image stream.</p> 721 * <p>The focusing behavior should be suitable for still image 722 * capture; typically this means focusing as fast as 723 * possible. When the AF trigger is not involved, the AF 724 * algorithm should start in INACTIVE state, and then 725 * transition into PASSIVE_SCAN and PASSIVE_FOCUSED states as 726 * appropriate as it attempts to maintain focus. When the AF 727 * trigger is activated, the algorithm should finish its 728 * PASSIVE_SCAN if active, and then transition into 729 * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the 730 * lens position until a cancel AF trigger is received.</p> 731 * <p>When the AF cancel trigger is activated, the algorithm 732 * should transition back to INACTIVE and then act as if it 733 * has just been started.</p> 734 * @see CaptureRequest#CONTROL_AF_MODE 735 */ 736 public static final int CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4; 737 738 /** 739 * <p>Extended depth of field (digital focus). AF 740 * trigger is ignored, AF state should always be 741 * INACTIVE.</p> 742 * @see CaptureRequest#CONTROL_AF_MODE 743 */ 744 public static final int CONTROL_AF_MODE_EDOF = 5; 745 746 // 747 // Enumeration values for CaptureRequest#CONTROL_AF_TRIGGER 748 // 749 750 /** 751 * <p>The trigger is idle.</p> 752 * @see CaptureRequest#CONTROL_AF_TRIGGER 753 */ 754 public static final int CONTROL_AF_TRIGGER_IDLE = 0; 755 756 /** 757 * <p>Autofocus will trigger now.</p> 758 * @see CaptureRequest#CONTROL_AF_TRIGGER 759 */ 760 public static final int CONTROL_AF_TRIGGER_START = 1; 761 762 /** 763 * <p>Autofocus will return to its initial 764 * state, and cancel any currently active trigger.</p> 765 * @see CaptureRequest#CONTROL_AF_TRIGGER 766 */ 767 public static final int CONTROL_AF_TRIGGER_CANCEL = 2; 768 769 // 770 // Enumeration values for CaptureRequest#CONTROL_AWB_MODE 771 // 772 773 /** 774 * <p>The camera device's auto white balance routine is disabled; 775 * the application-selected color transform matrix 776 * ({@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform}) and gains 777 * ({@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains}) are used by the camera 778 * device for manual white balance control.</p> 779 * 780 * @see CaptureRequest#COLOR_CORRECTION_GAINS 781 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 782 * @see CaptureRequest#CONTROL_AWB_MODE 783 */ 784 public static final int CONTROL_AWB_MODE_OFF = 0; 785 786 /** 787 * <p>The camera device's auto white balance routine is active; 788 * the application's values for {@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform} 789 * and {@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains} are ignored.</p> 790 * 791 * @see CaptureRequest#COLOR_CORRECTION_GAINS 792 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 793 * @see CaptureRequest#CONTROL_AWB_MODE 794 */ 795 public static final int CONTROL_AWB_MODE_AUTO = 1; 796 797 /** 798 * <p>The camera device's auto white balance routine is disabled; 799 * the camera device uses incandescent light as the assumed scene 800 * illumination for white balance. While the exact white balance 801 * transforms are up to the camera device, they will approximately 802 * match the CIE standard illuminant A.</p> 803 * @see CaptureRequest#CONTROL_AWB_MODE 804 */ 805 public static final int CONTROL_AWB_MODE_INCANDESCENT = 2; 806 807 /** 808 * <p>The camera device's auto white balance routine is disabled; 809 * the camera device uses fluorescent light as the assumed scene 810 * illumination for white balance. While the exact white balance 811 * transforms are up to the camera device, they will approximately 812 * match the CIE standard illuminant F2.</p> 813 * @see CaptureRequest#CONTROL_AWB_MODE 814 */ 815 public static final int CONTROL_AWB_MODE_FLUORESCENT = 3; 816 817 /** 818 * <p>The camera device's auto white balance routine is disabled; 819 * the camera device uses warm fluorescent light as the assumed scene 820 * illumination for white balance. While the exact white balance 821 * transforms are up to the camera device, they will approximately 822 * match the CIE standard illuminant F4.</p> 823 * @see CaptureRequest#CONTROL_AWB_MODE 824 */ 825 public static final int CONTROL_AWB_MODE_WARM_FLUORESCENT = 4; 826 827 /** 828 * <p>The camera device's auto white balance routine is disabled; 829 * the camera device uses daylight light as the assumed scene 830 * illumination for white balance. While the exact white balance 831 * transforms are up to the camera device, they will approximately 832 * match the CIE standard illuminant D65.</p> 833 * @see CaptureRequest#CONTROL_AWB_MODE 834 */ 835 public static final int CONTROL_AWB_MODE_DAYLIGHT = 5; 836 837 /** 838 * <p>The camera device's auto white balance routine is disabled; 839 * the camera device uses cloudy daylight light as the assumed scene 840 * illumination for white balance.</p> 841 * @see CaptureRequest#CONTROL_AWB_MODE 842 */ 843 public static final int CONTROL_AWB_MODE_CLOUDY_DAYLIGHT = 6; 844 845 /** 846 * <p>The camera device's auto white balance routine is disabled; 847 * the camera device uses twilight light as the assumed scene 848 * illumination for white balance.</p> 849 * @see CaptureRequest#CONTROL_AWB_MODE 850 */ 851 public static final int CONTROL_AWB_MODE_TWILIGHT = 7; 852 853 /** 854 * <p>The camera device's auto white balance routine is disabled; 855 * the camera device uses shade light as the assumed scene 856 * illumination for white balance.</p> 857 * @see CaptureRequest#CONTROL_AWB_MODE 858 */ 859 public static final int CONTROL_AWB_MODE_SHADE = 8; 860 861 // 862 // Enumeration values for CaptureRequest#CONTROL_CAPTURE_INTENT 863 // 864 865 /** 866 * <p>This request doesn't fall into the other 867 * categories. Default to preview-like 868 * behavior.</p> 869 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 870 */ 871 public static final int CONTROL_CAPTURE_INTENT_CUSTOM = 0; 872 873 /** 874 * <p>This request is for a preview-like usecase. The 875 * precapture trigger may be used to start off a metering 876 * w/flash sequence</p> 877 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 878 */ 879 public static final int CONTROL_CAPTURE_INTENT_PREVIEW = 1; 880 881 /** 882 * <p>This request is for a still capture-type 883 * usecase.</p> 884 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 885 */ 886 public static final int CONTROL_CAPTURE_INTENT_STILL_CAPTURE = 2; 887 888 /** 889 * <p>This request is for a video recording 890 * usecase.</p> 891 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 892 */ 893 public static final int CONTROL_CAPTURE_INTENT_VIDEO_RECORD = 3; 894 895 /** 896 * <p>This request is for a video snapshot (still 897 * image while recording video) usecase</p> 898 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 899 */ 900 public static final int CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT = 4; 901 902 /** 903 * <p>This request is for a ZSL usecase; the 904 * application will stream full-resolution images and 905 * reprocess one or several later for a final 906 * capture</p> 907 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 908 */ 909 public static final int CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG = 5; 910 911 // 912 // Enumeration values for CaptureRequest#CONTROL_EFFECT_MODE 913 // 914 915 /** 916 * <p>No color effect will be applied.</p> 917 * @see CaptureRequest#CONTROL_EFFECT_MODE 918 */ 919 public static final int CONTROL_EFFECT_MODE_OFF = 0; 920 921 /** 922 * <p>A "monocolor" effect where the image is mapped into 923 * a single color. This will typically be grayscale.</p> 924 * @see CaptureRequest#CONTROL_EFFECT_MODE 925 */ 926 public static final int CONTROL_EFFECT_MODE_MONO = 1; 927 928 /** 929 * <p>A "photo-negative" effect where the image's colors 930 * are inverted.</p> 931 * @see CaptureRequest#CONTROL_EFFECT_MODE 932 */ 933 public static final int CONTROL_EFFECT_MODE_NEGATIVE = 2; 934 935 /** 936 * <p>A "solarisation" effect (Sabattier effect) where the 937 * image is wholly or partially reversed in 938 * tone.</p> 939 * @see CaptureRequest#CONTROL_EFFECT_MODE 940 */ 941 public static final int CONTROL_EFFECT_MODE_SOLARIZE = 3; 942 943 /** 944 * <p>A "sepia" effect where the image is mapped into warm 945 * gray, red, and brown tones.</p> 946 * @see CaptureRequest#CONTROL_EFFECT_MODE 947 */ 948 public static final int CONTROL_EFFECT_MODE_SEPIA = 4; 949 950 /** 951 * <p>A "posterization" effect where the image uses 952 * discrete regions of tone rather than a continuous 953 * gradient of tones.</p> 954 * @see CaptureRequest#CONTROL_EFFECT_MODE 955 */ 956 public static final int CONTROL_EFFECT_MODE_POSTERIZE = 5; 957 958 /** 959 * <p>A "whiteboard" effect where the image is typically displayed 960 * as regions of white, with black or grey details.</p> 961 * @see CaptureRequest#CONTROL_EFFECT_MODE 962 */ 963 public static final int CONTROL_EFFECT_MODE_WHITEBOARD = 6; 964 965 /** 966 * <p>A "blackboard" effect where the image is typically displayed 967 * as regions of black, with white or grey details.</p> 968 * @see CaptureRequest#CONTROL_EFFECT_MODE 969 */ 970 public static final int CONTROL_EFFECT_MODE_BLACKBOARD = 7; 971 972 /** 973 * <p>An "aqua" effect where a blue hue is added to the image.</p> 974 * @see CaptureRequest#CONTROL_EFFECT_MODE 975 */ 976 public static final int CONTROL_EFFECT_MODE_AQUA = 8; 977 978 // 979 // Enumeration values for CaptureRequest#CONTROL_MODE 980 // 981 982 /** 983 * <p>Full application control of pipeline. All 3A 984 * routines are disabled, no other settings in 985 * android.control.* have any effect</p> 986 * @see CaptureRequest#CONTROL_MODE 987 */ 988 public static final int CONTROL_MODE_OFF = 0; 989 990 /** 991 * <p>Use settings for each individual 3A routine. 992 * Manual control of capture parameters is disabled. All 993 * controls in android.control.* besides sceneMode take 994 * effect</p> 995 * @see CaptureRequest#CONTROL_MODE 996 */ 997 public static final int CONTROL_MODE_AUTO = 1; 998 999 /** 1000 * <p>Use specific scene mode. Enabling this disables 1001 * control.aeMode, control.awbMode and control.afMode 1002 * controls; the camera device will ignore those settings while 1003 * USE_SCENE_MODE is active (except for FACE_PRIORITY 1004 * scene mode). Other control entries are still active. 1005 * This setting can only be used if availableSceneModes != 1006 * UNSUPPORTED</p> 1007 * @see CaptureRequest#CONTROL_MODE 1008 */ 1009 public static final int CONTROL_MODE_USE_SCENE_MODE = 2; 1010 1011 /** 1012 * <p>Same as OFF mode, except that this capture will not be 1013 * used by camera device background auto-exposure, auto-white balance and 1014 * auto-focus algorithms to update their statistics.</p> 1015 * @see CaptureRequest#CONTROL_MODE 1016 */ 1017 public static final int CONTROL_MODE_OFF_KEEP_STATE = 3; 1018 1019 // 1020 // Enumeration values for CaptureRequest#CONTROL_SCENE_MODE 1021 // 1022 1023 /** 1024 * <p>Indicates that no scene modes are set for a given capture request.</p> 1025 * @see CaptureRequest#CONTROL_SCENE_MODE 1026 */ 1027 public static final int CONTROL_SCENE_MODE_DISABLED = 0; 1028 1029 /** 1030 * <p>If face detection support exists, use face 1031 * detection data for auto-focus, auto-white balance, and 1032 * auto-exposure routines. If face detection statistics are 1033 * disabled (i.e. {@link CaptureRequest#STATISTICS_FACE_DETECT_MODE android.statistics.faceDetectMode} is set to OFF), 1034 * this should still operate correctly (but will not return 1035 * face detection statistics to the framework).</p> 1036 * <p>Unlike the other scene modes, {@link CaptureRequest#CONTROL_AE_MODE android.control.aeMode}, 1037 * {@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode}, and {@link CaptureRequest#CONTROL_AF_MODE android.control.afMode} 1038 * remain active when FACE_PRIORITY is set.</p> 1039 * 1040 * @see CaptureRequest#CONTROL_AE_MODE 1041 * @see CaptureRequest#CONTROL_AF_MODE 1042 * @see CaptureRequest#CONTROL_AWB_MODE 1043 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1044 * @see CaptureRequest#CONTROL_SCENE_MODE 1045 */ 1046 public static final int CONTROL_SCENE_MODE_FACE_PRIORITY = 1; 1047 1048 /** 1049 * <p>Optimized for photos of quickly moving objects. 1050 * Similar to SPORTS.</p> 1051 * @see CaptureRequest#CONTROL_SCENE_MODE 1052 */ 1053 public static final int CONTROL_SCENE_MODE_ACTION = 2; 1054 1055 /** 1056 * <p>Optimized for still photos of people.</p> 1057 * @see CaptureRequest#CONTROL_SCENE_MODE 1058 */ 1059 public static final int CONTROL_SCENE_MODE_PORTRAIT = 3; 1060 1061 /** 1062 * <p>Optimized for photos of distant macroscopic objects.</p> 1063 * @see CaptureRequest#CONTROL_SCENE_MODE 1064 */ 1065 public static final int CONTROL_SCENE_MODE_LANDSCAPE = 4; 1066 1067 /** 1068 * <p>Optimized for low-light settings.</p> 1069 * @see CaptureRequest#CONTROL_SCENE_MODE 1070 */ 1071 public static final int CONTROL_SCENE_MODE_NIGHT = 5; 1072 1073 /** 1074 * <p>Optimized for still photos of people in low-light 1075 * settings.</p> 1076 * @see CaptureRequest#CONTROL_SCENE_MODE 1077 */ 1078 public static final int CONTROL_SCENE_MODE_NIGHT_PORTRAIT = 6; 1079 1080 /** 1081 * <p>Optimized for dim, indoor settings where flash must 1082 * remain off.</p> 1083 * @see CaptureRequest#CONTROL_SCENE_MODE 1084 */ 1085 public static final int CONTROL_SCENE_MODE_THEATRE = 7; 1086 1087 /** 1088 * <p>Optimized for bright, outdoor beach settings.</p> 1089 * @see CaptureRequest#CONTROL_SCENE_MODE 1090 */ 1091 public static final int CONTROL_SCENE_MODE_BEACH = 8; 1092 1093 /** 1094 * <p>Optimized for bright, outdoor settings containing snow.</p> 1095 * @see CaptureRequest#CONTROL_SCENE_MODE 1096 */ 1097 public static final int CONTROL_SCENE_MODE_SNOW = 9; 1098 1099 /** 1100 * <p>Optimized for scenes of the setting sun.</p> 1101 * @see CaptureRequest#CONTROL_SCENE_MODE 1102 */ 1103 public static final int CONTROL_SCENE_MODE_SUNSET = 10; 1104 1105 /** 1106 * <p>Optimized to avoid blurry photos due to small amounts of 1107 * device motion (for example: due to hand shake).</p> 1108 * @see CaptureRequest#CONTROL_SCENE_MODE 1109 */ 1110 public static final int CONTROL_SCENE_MODE_STEADYPHOTO = 11; 1111 1112 /** 1113 * <p>Optimized for nighttime photos of fireworks.</p> 1114 * @see CaptureRequest#CONTROL_SCENE_MODE 1115 */ 1116 public static final int CONTROL_SCENE_MODE_FIREWORKS = 12; 1117 1118 /** 1119 * <p>Optimized for photos of quickly moving people. 1120 * Similar to ACTION.</p> 1121 * @see CaptureRequest#CONTROL_SCENE_MODE 1122 */ 1123 public static final int CONTROL_SCENE_MODE_SPORTS = 13; 1124 1125 /** 1126 * <p>Optimized for dim, indoor settings with multiple moving 1127 * people.</p> 1128 * @see CaptureRequest#CONTROL_SCENE_MODE 1129 */ 1130 public static final int CONTROL_SCENE_MODE_PARTY = 14; 1131 1132 /** 1133 * <p>Optimized for dim settings where the main light source 1134 * is a flame.</p> 1135 * @see CaptureRequest#CONTROL_SCENE_MODE 1136 */ 1137 public static final int CONTROL_SCENE_MODE_CANDLELIGHT = 15; 1138 1139 /** 1140 * <p>Optimized for accurately capturing a photo of barcode 1141 * for use by camera applications that wish to read the 1142 * barcode value.</p> 1143 * @see CaptureRequest#CONTROL_SCENE_MODE 1144 */ 1145 public static final int CONTROL_SCENE_MODE_BARCODE = 16; 1146 1147 // 1148 // Enumeration values for CaptureRequest#EDGE_MODE 1149 // 1150 1151 /** 1152 * <p>No edge enhancement is applied</p> 1153 * @see CaptureRequest#EDGE_MODE 1154 */ 1155 public static final int EDGE_MODE_OFF = 0; 1156 1157 /** 1158 * <p>Must not slow down frame rate relative to sensor 1159 * output</p> 1160 * @see CaptureRequest#EDGE_MODE 1161 */ 1162 public static final int EDGE_MODE_FAST = 1; 1163 1164 /** 1165 * <p>Frame rate may be reduced by high 1166 * quality</p> 1167 * @see CaptureRequest#EDGE_MODE 1168 */ 1169 public static final int EDGE_MODE_HIGH_QUALITY = 2; 1170 1171 // 1172 // Enumeration values for CaptureRequest#FLASH_MODE 1173 // 1174 1175 /** 1176 * <p>Do not fire the flash for this capture.</p> 1177 * @see CaptureRequest#FLASH_MODE 1178 */ 1179 public static final int FLASH_MODE_OFF = 0; 1180 1181 /** 1182 * <p>If the flash is available and charged, fire flash 1183 * for this capture based on android.flash.firingPower and 1184 * android.flash.firingTime.</p> 1185 * @see CaptureRequest#FLASH_MODE 1186 */ 1187 public static final int FLASH_MODE_SINGLE = 1; 1188 1189 /** 1190 * <p>Transition flash to continuously on.</p> 1191 * @see CaptureRequest#FLASH_MODE 1192 */ 1193 public static final int FLASH_MODE_TORCH = 2; 1194 1195 // 1196 // Enumeration values for CaptureRequest#HOT_PIXEL_MODE 1197 // 1198 1199 /** 1200 * <p>The frame rate must not be reduced relative to sensor raw output 1201 * for this option.</p> 1202 * <p>No hot pixel correction is applied. 1203 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1204 * 1205 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1206 * @see CaptureRequest#HOT_PIXEL_MODE 1207 */ 1208 public static final int HOT_PIXEL_MODE_OFF = 0; 1209 1210 /** 1211 * <p>The frame rate must not be reduced relative to sensor raw output 1212 * for this option.</p> 1213 * <p>Hot pixel correction is applied. 1214 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1215 * 1216 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1217 * @see CaptureRequest#HOT_PIXEL_MODE 1218 */ 1219 public static final int HOT_PIXEL_MODE_FAST = 1; 1220 1221 /** 1222 * <p>The frame rate may be reduced relative to sensor raw output 1223 * for this option.</p> 1224 * <p>A high-quality hot pixel correction is applied. 1225 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1226 * 1227 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1228 * @see CaptureRequest#HOT_PIXEL_MODE 1229 */ 1230 public static final int HOT_PIXEL_MODE_HIGH_QUALITY = 2; 1231 1232 // 1233 // Enumeration values for CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1234 // 1235 1236 /** 1237 * <p>Optical stabilization is unavailable.</p> 1238 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1239 */ 1240 public static final int LENS_OPTICAL_STABILIZATION_MODE_OFF = 0; 1241 1242 /** 1243 * <p>Optical stabilization is enabled.</p> 1244 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1245 */ 1246 public static final int LENS_OPTICAL_STABILIZATION_MODE_ON = 1; 1247 1248 // 1249 // Enumeration values for CaptureRequest#NOISE_REDUCTION_MODE 1250 // 1251 1252 /** 1253 * <p>No noise reduction is applied</p> 1254 * @see CaptureRequest#NOISE_REDUCTION_MODE 1255 */ 1256 public static final int NOISE_REDUCTION_MODE_OFF = 0; 1257 1258 /** 1259 * <p>Must not slow down frame rate relative to sensor 1260 * output</p> 1261 * @see CaptureRequest#NOISE_REDUCTION_MODE 1262 */ 1263 public static final int NOISE_REDUCTION_MODE_FAST = 1; 1264 1265 /** 1266 * <p>May slow down frame rate to provide highest 1267 * quality</p> 1268 * @see CaptureRequest#NOISE_REDUCTION_MODE 1269 */ 1270 public static final int NOISE_REDUCTION_MODE_HIGH_QUALITY = 2; 1271 1272 // 1273 // Enumeration values for CaptureRequest#SENSOR_TEST_PATTERN_MODE 1274 // 1275 1276 /** 1277 * <p>Default. No test pattern mode is used, and the camera 1278 * device returns captures from the image sensor.</p> 1279 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1280 */ 1281 public static final int SENSOR_TEST_PATTERN_MODE_OFF = 0; 1282 1283 /** 1284 * <p>Each pixel in <code>[R, G_even, G_odd, B]</code> is replaced by its 1285 * respective color channel provided in 1286 * {@link CaptureRequest#SENSOR_TEST_PATTERN_DATA android.sensor.testPatternData}.</p> 1287 * <p>For example:</p> 1288 * <pre><code>android.testPatternData = [0, 0xFFFFFFFF, 0xFFFFFFFF, 0] 1289 * </code></pre> 1290 * <p>All green pixels are 100% green. All red/blue pixels are black.</p> 1291 * <pre><code>android.testPatternData = [0xFFFFFFFF, 0, 0xFFFFFFFF, 0] 1292 * </code></pre> 1293 * <p>All red pixels are 100% red. Only the odd green pixels 1294 * are 100% green. All blue pixels are 100% black.</p> 1295 * 1296 * @see CaptureRequest#SENSOR_TEST_PATTERN_DATA 1297 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1298 */ 1299 public static final int SENSOR_TEST_PATTERN_MODE_SOLID_COLOR = 1; 1300 1301 /** 1302 * <p>All pixel data is replaced with an 8-bar color pattern.</p> 1303 * <p>The vertical bars (left-to-right) are as follows:</p> 1304 * <ul> 1305 * <li>100% white</li> 1306 * <li>yellow</li> 1307 * <li>cyan</li> 1308 * <li>green</li> 1309 * <li>magenta</li> 1310 * <li>red</li> 1311 * <li>blue</li> 1312 * <li>black</li> 1313 * </ul> 1314 * <p>In general the image would look like the following:</p> 1315 * <pre><code>W Y C G M R B K 1316 * W Y C G M R B K 1317 * W Y C G M R B K 1318 * W Y C G M R B K 1319 * W Y C G M R B K 1320 * . . . . . . . . 1321 * . . . . . . . . 1322 * . . . . . . . . 1323 * 1324 * (B = Blue, K = Black) 1325 * </code></pre> 1326 * <p>Each bar should take up 1/8 of the sensor pixel array width. 1327 * When this is not possible, the bar size should be rounded 1328 * down to the nearest integer and the pattern can repeat 1329 * on the right side.</p> 1330 * <p>Each bar's height must always take up the full sensor 1331 * pixel array height.</p> 1332 * <p>Each pixel in this test pattern must be set to either 1333 * 0% intensity or 100% intensity.</p> 1334 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1335 */ 1336 public static final int SENSOR_TEST_PATTERN_MODE_COLOR_BARS = 2; 1337 1338 /** 1339 * <p>The test pattern is similar to COLOR_BARS, except that 1340 * each bar should start at its specified color at the top, 1341 * and fade to gray at the bottom.</p> 1342 * <p>Furthermore each bar is further subdivided into a left and 1343 * right half. The left half should have a smooth gradient, 1344 * and the right half should have a quantized gradient.</p> 1345 * <p>In particular, the right half's should consist of blocks of the 1346 * same color for 1/16th active sensor pixel array width.</p> 1347 * <p>The least significant bits in the quantized gradient should 1348 * be copied from the most significant bits of the smooth gradient.</p> 1349 * <p>The height of each bar should always be a multiple of 128. 1350 * When this is not the case, the pattern should repeat at the bottom 1351 * of the image.</p> 1352 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1353 */ 1354 public static final int SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY = 3; 1355 1356 /** 1357 * <p>All pixel data is replaced by a pseudo-random sequence 1358 * generated from a PN9 512-bit sequence (typically implemented 1359 * in hardware with a linear feedback shift register).</p> 1360 * <p>The generator should be reset at the beginning of each frame, 1361 * and thus each subsequent raw frame with this test pattern should 1362 * be exactly the same as the last.</p> 1363 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1364 */ 1365 public static final int SENSOR_TEST_PATTERN_MODE_PN9 = 4; 1366 1367 /** 1368 * <p>The first custom test pattern. All custom patterns that are 1369 * available only on this camera device are at least this numeric 1370 * value.</p> 1371 * <p>All of the custom test patterns will be static 1372 * (that is the raw image must not vary from frame to frame).</p> 1373 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1374 */ 1375 public static final int SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256; 1376 1377 // 1378 // Enumeration values for CaptureRequest#SHADING_MODE 1379 // 1380 1381 /** 1382 * <p>No lens shading correction is applied</p> 1383 * @see CaptureRequest#SHADING_MODE 1384 */ 1385 public static final int SHADING_MODE_OFF = 0; 1386 1387 /** 1388 * <p>Must not slow down frame rate relative to sensor raw output</p> 1389 * @see CaptureRequest#SHADING_MODE 1390 */ 1391 public static final int SHADING_MODE_FAST = 1; 1392 1393 /** 1394 * <p>Frame rate may be reduced by high quality</p> 1395 * @see CaptureRequest#SHADING_MODE 1396 */ 1397 public static final int SHADING_MODE_HIGH_QUALITY = 2; 1398 1399 // 1400 // Enumeration values for CaptureRequest#STATISTICS_FACE_DETECT_MODE 1401 // 1402 1403 /** 1404 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1405 */ 1406 public static final int STATISTICS_FACE_DETECT_MODE_OFF = 0; 1407 1408 /** 1409 * <p>Optional Return rectangle and confidence 1410 * only</p> 1411 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1412 */ 1413 public static final int STATISTICS_FACE_DETECT_MODE_SIMPLE = 1; 1414 1415 /** 1416 * <p>Optional Return all face 1417 * metadata</p> 1418 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1419 */ 1420 public static final int STATISTICS_FACE_DETECT_MODE_FULL = 2; 1421 1422 // 1423 // Enumeration values for CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1424 // 1425 1426 /** 1427 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1428 */ 1429 public static final int STATISTICS_LENS_SHADING_MAP_MODE_OFF = 0; 1430 1431 /** 1432 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1433 */ 1434 public static final int STATISTICS_LENS_SHADING_MAP_MODE_ON = 1; 1435 1436 // 1437 // Enumeration values for CaptureRequest#TONEMAP_MODE 1438 // 1439 1440 /** 1441 * <p>Use the tone mapping curve specified in 1442 * the android.tonemap.curve* entries.</p> 1443 * <p>All color enhancement and tonemapping must be disabled, except 1444 * for applying the tonemapping curve specified by 1445 * {@link CaptureRequest#TONEMAP_CURVE_RED android.tonemap.curveRed}, {@link CaptureRequest#TONEMAP_CURVE_BLUE android.tonemap.curveBlue}, or 1446 * {@link CaptureRequest#TONEMAP_CURVE_GREEN android.tonemap.curveGreen}.</p> 1447 * <p>Must not slow down frame rate relative to raw 1448 * sensor output.</p> 1449 * 1450 * @see CaptureRequest#TONEMAP_CURVE_BLUE 1451 * @see CaptureRequest#TONEMAP_CURVE_GREEN 1452 * @see CaptureRequest#TONEMAP_CURVE_RED 1453 * @see CaptureRequest#TONEMAP_MODE 1454 */ 1455 public static final int TONEMAP_MODE_CONTRAST_CURVE = 0; 1456 1457 /** 1458 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1459 * <p>Should not slow down frame rate relative to raw sensor output.</p> 1460 * @see CaptureRequest#TONEMAP_MODE 1461 */ 1462 public static final int TONEMAP_MODE_FAST = 1; 1463 1464 /** 1465 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1466 * <p>May slow down frame rate relative to raw sensor output.</p> 1467 * @see CaptureRequest#TONEMAP_MODE 1468 */ 1469 public static final int TONEMAP_MODE_HIGH_QUALITY = 2; 1470 1471 // 1472 // Enumeration values for CaptureResult#CONTROL_AE_STATE 1473 // 1474 1475 /** 1476 * <p>AE is off or recently reset. When a camera device is opened, it starts in 1477 * this state. This is a transient state, the camera device may skip reporting 1478 * this state in capture result.</p> 1479 * @see CaptureResult#CONTROL_AE_STATE 1480 */ 1481 public static final int CONTROL_AE_STATE_INACTIVE = 0; 1482 1483 /** 1484 * <p>AE doesn't yet have a good set of control values 1485 * for the current scene. This is a transient state, the camera device may skip 1486 * reporting this state in capture result.</p> 1487 * @see CaptureResult#CONTROL_AE_STATE 1488 */ 1489 public static final int CONTROL_AE_STATE_SEARCHING = 1; 1490 1491 /** 1492 * <p>AE has a good set of control values for the 1493 * current scene.</p> 1494 * @see CaptureResult#CONTROL_AE_STATE 1495 */ 1496 public static final int CONTROL_AE_STATE_CONVERGED = 2; 1497 1498 /** 1499 * <p>AE has been locked.</p> 1500 * @see CaptureResult#CONTROL_AE_STATE 1501 */ 1502 public static final int CONTROL_AE_STATE_LOCKED = 3; 1503 1504 /** 1505 * <p>AE has a good set of control values, but flash 1506 * needs to be fired for good quality still 1507 * capture.</p> 1508 * @see CaptureResult#CONTROL_AE_STATE 1509 */ 1510 public static final int CONTROL_AE_STATE_FLASH_REQUIRED = 4; 1511 1512 /** 1513 * <p>AE has been asked to do a precapture sequence 1514 * (through the {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger} START), 1515 * and is currently executing it. Once PRECAPTURE 1516 * completes, AE will transition to CONVERGED or 1517 * FLASH_REQUIRED as appropriate. This is a transient state, the 1518 * camera device may skip reporting this state in capture result.</p> 1519 * 1520 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 1521 * @see CaptureResult#CONTROL_AE_STATE 1522 */ 1523 public static final int CONTROL_AE_STATE_PRECAPTURE = 5; 1524 1525 // 1526 // Enumeration values for CaptureResult#CONTROL_AF_STATE 1527 // 1528 1529 /** 1530 * <p>AF off or has not yet tried to scan/been asked 1531 * to scan. When a camera device is opened, it starts in 1532 * this state. This is a transient state, the camera device may 1533 * skip reporting this state in capture result.</p> 1534 * @see CaptureResult#CONTROL_AF_STATE 1535 */ 1536 public static final int CONTROL_AF_STATE_INACTIVE = 0; 1537 1538 /** 1539 * <p>if CONTINUOUS_* modes are supported. AF is 1540 * currently doing an AF scan initiated by a continuous 1541 * autofocus mode. This is a transient state, the camera device may 1542 * skip reporting this state in capture result.</p> 1543 * @see CaptureResult#CONTROL_AF_STATE 1544 */ 1545 public static final int CONTROL_AF_STATE_PASSIVE_SCAN = 1; 1546 1547 /** 1548 * <p>if CONTINUOUS_* modes are supported. AF currently 1549 * believes it is in focus, but may restart scanning at 1550 * any time. This is a transient state, the camera device may skip 1551 * reporting this state in capture result.</p> 1552 * @see CaptureResult#CONTROL_AF_STATE 1553 */ 1554 public static final int CONTROL_AF_STATE_PASSIVE_FOCUSED = 2; 1555 1556 /** 1557 * <p>if AUTO or MACRO modes are supported. AF is doing 1558 * an AF scan because it was triggered by AF trigger. This is a 1559 * transient state, the camera device may skip reporting 1560 * this state in capture result.</p> 1561 * @see CaptureResult#CONTROL_AF_STATE 1562 */ 1563 public static final int CONTROL_AF_STATE_ACTIVE_SCAN = 3; 1564 1565 /** 1566 * <p>if any AF mode besides OFF is supported. AF 1567 * believes it is focused correctly and is 1568 * locked.</p> 1569 * @see CaptureResult#CONTROL_AF_STATE 1570 */ 1571 public static final int CONTROL_AF_STATE_FOCUSED_LOCKED = 4; 1572 1573 /** 1574 * <p>if any AF mode besides OFF is supported. AF has 1575 * failed to focus successfully and is 1576 * locked.</p> 1577 * @see CaptureResult#CONTROL_AF_STATE 1578 */ 1579 public static final int CONTROL_AF_STATE_NOT_FOCUSED_LOCKED = 5; 1580 1581 /** 1582 * <p>if CONTINUOUS_* modes are supported. AF finished a 1583 * passive scan without finding focus, and may restart 1584 * scanning at any time. This is a transient state, the camera 1585 * device may skip reporting this state in capture result.</p> 1586 * @see CaptureResult#CONTROL_AF_STATE 1587 */ 1588 public static final int CONTROL_AF_STATE_PASSIVE_UNFOCUSED = 6; 1589 1590 // 1591 // Enumeration values for CaptureResult#CONTROL_AWB_STATE 1592 // 1593 1594 /** 1595 * <p>AWB is not in auto mode. When a camera device is opened, it 1596 * starts in this state. This is a transient state, the camera device may 1597 * skip reporting this state in capture result.</p> 1598 * @see CaptureResult#CONTROL_AWB_STATE 1599 */ 1600 public static final int CONTROL_AWB_STATE_INACTIVE = 0; 1601 1602 /** 1603 * <p>AWB doesn't yet have a good set of control 1604 * values for the current scene. This is a transient state, the camera device 1605 * may skip reporting this state in capture result.</p> 1606 * @see CaptureResult#CONTROL_AWB_STATE 1607 */ 1608 public static final int CONTROL_AWB_STATE_SEARCHING = 1; 1609 1610 /** 1611 * <p>AWB has a good set of control values for the 1612 * current scene.</p> 1613 * @see CaptureResult#CONTROL_AWB_STATE 1614 */ 1615 public static final int CONTROL_AWB_STATE_CONVERGED = 2; 1616 1617 /** 1618 * <p>AWB has been locked.</p> 1619 * @see CaptureResult#CONTROL_AWB_STATE 1620 */ 1621 public static final int CONTROL_AWB_STATE_LOCKED = 3; 1622 1623 // 1624 // Enumeration values for CaptureResult#FLASH_STATE 1625 // 1626 1627 /** 1628 * <p>No flash on camera.</p> 1629 * @see CaptureResult#FLASH_STATE 1630 */ 1631 public static final int FLASH_STATE_UNAVAILABLE = 0; 1632 1633 /** 1634 * <p>Flash is charging and cannot be fired.</p> 1635 * @see CaptureResult#FLASH_STATE 1636 */ 1637 public static final int FLASH_STATE_CHARGING = 1; 1638 1639 /** 1640 * <p>Flash is ready to fire.</p> 1641 * @see CaptureResult#FLASH_STATE 1642 */ 1643 public static final int FLASH_STATE_READY = 2; 1644 1645 /** 1646 * <p>Flash fired for this capture.</p> 1647 * @see CaptureResult#FLASH_STATE 1648 */ 1649 public static final int FLASH_STATE_FIRED = 3; 1650 1651 /** 1652 * <p>Flash partially illuminated this frame. This is usually due to the next 1653 * or previous frame having the flash fire, and the flash spilling into this capture 1654 * due to hardware limitations.</p> 1655 * @see CaptureResult#FLASH_STATE 1656 */ 1657 public static final int FLASH_STATE_PARTIAL = 4; 1658 1659 // 1660 // Enumeration values for CaptureResult#LENS_STATE 1661 // 1662 1663 /** 1664 * <p>The lens parameters ({@link CaptureRequest#LENS_FOCAL_LENGTH android.lens.focalLength}, {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance}, 1665 * {@link CaptureRequest#LENS_FILTER_DENSITY android.lens.filterDensity} and {@link CaptureRequest#LENS_APERTURE android.lens.aperture}) are not changing.</p> 1666 * 1667 * @see CaptureRequest#LENS_APERTURE 1668 * @see CaptureRequest#LENS_FILTER_DENSITY 1669 * @see CaptureRequest#LENS_FOCAL_LENGTH 1670 * @see CaptureRequest#LENS_FOCUS_DISTANCE 1671 * @see CaptureResult#LENS_STATE 1672 */ 1673 public static final int LENS_STATE_STATIONARY = 0; 1674 1675 /** 1676 * <p>Any of the lens parameters ({@link CaptureRequest#LENS_FOCAL_LENGTH android.lens.focalLength}, {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance}, 1677 * {@link CaptureRequest#LENS_FILTER_DENSITY android.lens.filterDensity} or {@link CaptureRequest#LENS_APERTURE android.lens.aperture}) is changing.</p> 1678 * 1679 * @see CaptureRequest#LENS_APERTURE 1680 * @see CaptureRequest#LENS_FILTER_DENSITY 1681 * @see CaptureRequest#LENS_FOCAL_LENGTH 1682 * @see CaptureRequest#LENS_FOCUS_DISTANCE 1683 * @see CaptureResult#LENS_STATE 1684 */ 1685 public static final int LENS_STATE_MOVING = 1; 1686 1687 // 1688 // Enumeration values for CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1689 // 1690 1691 /** 1692 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1693 */ 1694 public static final int SENSOR_REFERENCE_ILLUMINANT_DAYLIGHT = 1; 1695 1696 /** 1697 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1698 */ 1699 public static final int SENSOR_REFERENCE_ILLUMINANT_FLUORESCENT = 2; 1700 1701 /** 1702 * <p>Incandescent light</p> 1703 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1704 */ 1705 public static final int SENSOR_REFERENCE_ILLUMINANT_TUNGSTEN = 3; 1706 1707 /** 1708 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1709 */ 1710 public static final int SENSOR_REFERENCE_ILLUMINANT_FLASH = 4; 1711 1712 /** 1713 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1714 */ 1715 public static final int SENSOR_REFERENCE_ILLUMINANT_FINE_WEATHER = 9; 1716 1717 /** 1718 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1719 */ 1720 public static final int SENSOR_REFERENCE_ILLUMINANT_CLOUDY_WEATHER = 10; 1721 1722 /** 1723 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1724 */ 1725 public static final int SENSOR_REFERENCE_ILLUMINANT_SHADE = 11; 1726 1727 /** 1728 * <p>D 5700 - 7100K</p> 1729 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1730 */ 1731 public static final int SENSOR_REFERENCE_ILLUMINANT_DAYLIGHT_FLUORESCENT = 12; 1732 1733 /** 1734 * <p>N 4600 - 5400K</p> 1735 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1736 */ 1737 public static final int SENSOR_REFERENCE_ILLUMINANT_DAY_WHITE_FLUORESCENT = 13; 1738 1739 /** 1740 * <p>W 3900 - 4500K</p> 1741 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1742 */ 1743 public static final int SENSOR_REFERENCE_ILLUMINANT_COOL_WHITE_FLUORESCENT = 14; 1744 1745 /** 1746 * <p>WW 3200 - 3700K</p> 1747 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1748 */ 1749 public static final int SENSOR_REFERENCE_ILLUMINANT_WHITE_FLUORESCENT = 15; 1750 1751 /** 1752 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1753 */ 1754 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_A = 17; 1755 1756 /** 1757 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1758 */ 1759 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_B = 18; 1760 1761 /** 1762 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1763 */ 1764 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_C = 19; 1765 1766 /** 1767 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1768 */ 1769 public static final int SENSOR_REFERENCE_ILLUMINANT_D55 = 20; 1770 1771 /** 1772 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1773 */ 1774 public static final int SENSOR_REFERENCE_ILLUMINANT_D65 = 21; 1775 1776 /** 1777 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1778 */ 1779 public static final int SENSOR_REFERENCE_ILLUMINANT_D75 = 22; 1780 1781 /** 1782 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1783 */ 1784 public static final int SENSOR_REFERENCE_ILLUMINANT_D50 = 23; 1785 1786 /** 1787 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1788 */ 1789 public static final int SENSOR_REFERENCE_ILLUMINANT_ISO_STUDIO_TUNGSTEN = 24; 1790 1791 // 1792 // Enumeration values for CaptureResult#STATISTICS_SCENE_FLICKER 1793 // 1794 1795 /** 1796 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1797 */ 1798 public static final int STATISTICS_SCENE_FLICKER_NONE = 0; 1799 1800 /** 1801 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1802 */ 1803 public static final int STATISTICS_SCENE_FLICKER_50HZ = 1; 1804 1805 /** 1806 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1807 */ 1808 public static final int STATISTICS_SCENE_FLICKER_60HZ = 2; 1809 1810 // 1811 // Enumeration values for CaptureResult#SYNC_FRAME_NUMBER 1812 // 1813 1814 /** 1815 * <p>The current result is not yet fully synchronized to any request. 1816 * Synchronization is in progress, and reading metadata from this 1817 * result may include a mix of data that have taken effect since the 1818 * last synchronization time.</p> 1819 * <p>In some future result, within {@link CameraCharacteristics#SYNC_MAX_LATENCY android.sync.maxLatency} frames, 1820 * this value will update to the actual frame number frame number 1821 * the result is guaranteed to be synchronized to (as long as the 1822 * request settings remain constant).</p> 1823 * 1824 * @see CameraCharacteristics#SYNC_MAX_LATENCY 1825 * @see CaptureResult#SYNC_FRAME_NUMBER 1826 * @hide 1827 */ 1828 public static final int SYNC_FRAME_NUMBER_CONVERGING = -1; 1829 1830 /** 1831 * <p>The current result's synchronization status is unknown. The 1832 * result may have already converged, or it may be in progress. 1833 * Reading from this result may include some mix of settings from 1834 * past requests.</p> 1835 * <p>After a settings change, the new settings will eventually all 1836 * take effect for the output buffers and results. However, this 1837 * value will not change when that happens. Altering settings 1838 * rapidly may provide outcomes using mixes of settings from recent 1839 * requests.</p> 1840 * <p>This value is intended primarily for backwards compatibility with 1841 * the older camera implementations (for android.hardware.Camera).</p> 1842 * @see CaptureResult#SYNC_FRAME_NUMBER 1843 * @hide 1844 */ 1845 public static final int SYNC_FRAME_NUMBER_UNKNOWN = -2; 1846 1847 /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 1848 * End generated code 1849 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/ 1850 1851} 1852