CameraMetadata.java revision a486624a6d9631fd434468fec7e3b57431f0b785
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 scene mode is supported 1006 * (i.e. {@link CameraCharacteristics#CONTROL_AVAILABLE_SCENE_MODES android.control.availableSceneModes} contain some modes 1007 * other than DISABLED).</p> 1008 * 1009 * @see CameraCharacteristics#CONTROL_AVAILABLE_SCENE_MODES 1010 * @see CaptureRequest#CONTROL_MODE 1011 */ 1012 public static final int CONTROL_MODE_USE_SCENE_MODE = 2; 1013 1014 /** 1015 * <p>Same as OFF mode, except that this capture will not be 1016 * used by camera device background auto-exposure, auto-white balance and 1017 * auto-focus algorithms to update their statistics.</p> 1018 * @see CaptureRequest#CONTROL_MODE 1019 */ 1020 public static final int CONTROL_MODE_OFF_KEEP_STATE = 3; 1021 1022 // 1023 // Enumeration values for CaptureRequest#CONTROL_SCENE_MODE 1024 // 1025 1026 /** 1027 * <p>Indicates that no scene modes are set for a given capture request.</p> 1028 * @see CaptureRequest#CONTROL_SCENE_MODE 1029 */ 1030 public static final int CONTROL_SCENE_MODE_DISABLED = 0; 1031 1032 /** 1033 * <p>If face detection support exists, use face 1034 * detection data for auto-focus, auto-white balance, and 1035 * auto-exposure routines. If face detection statistics are 1036 * disabled (i.e. {@link CaptureRequest#STATISTICS_FACE_DETECT_MODE android.statistics.faceDetectMode} is set to OFF), 1037 * this should still operate correctly (but will not return 1038 * face detection statistics to the framework).</p> 1039 * <p>Unlike the other scene modes, {@link CaptureRequest#CONTROL_AE_MODE android.control.aeMode}, 1040 * {@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode}, and {@link CaptureRequest#CONTROL_AF_MODE android.control.afMode} 1041 * remain active when FACE_PRIORITY is set.</p> 1042 * 1043 * @see CaptureRequest#CONTROL_AE_MODE 1044 * @see CaptureRequest#CONTROL_AF_MODE 1045 * @see CaptureRequest#CONTROL_AWB_MODE 1046 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1047 * @see CaptureRequest#CONTROL_SCENE_MODE 1048 */ 1049 public static final int CONTROL_SCENE_MODE_FACE_PRIORITY = 1; 1050 1051 /** 1052 * <p>Optimized for photos of quickly moving objects. 1053 * Similar to SPORTS.</p> 1054 * @see CaptureRequest#CONTROL_SCENE_MODE 1055 */ 1056 public static final int CONTROL_SCENE_MODE_ACTION = 2; 1057 1058 /** 1059 * <p>Optimized for still photos of people.</p> 1060 * @see CaptureRequest#CONTROL_SCENE_MODE 1061 */ 1062 public static final int CONTROL_SCENE_MODE_PORTRAIT = 3; 1063 1064 /** 1065 * <p>Optimized for photos of distant macroscopic objects.</p> 1066 * @see CaptureRequest#CONTROL_SCENE_MODE 1067 */ 1068 public static final int CONTROL_SCENE_MODE_LANDSCAPE = 4; 1069 1070 /** 1071 * <p>Optimized for low-light settings.</p> 1072 * @see CaptureRequest#CONTROL_SCENE_MODE 1073 */ 1074 public static final int CONTROL_SCENE_MODE_NIGHT = 5; 1075 1076 /** 1077 * <p>Optimized for still photos of people in low-light 1078 * settings.</p> 1079 * @see CaptureRequest#CONTROL_SCENE_MODE 1080 */ 1081 public static final int CONTROL_SCENE_MODE_NIGHT_PORTRAIT = 6; 1082 1083 /** 1084 * <p>Optimized for dim, indoor settings where flash must 1085 * remain off.</p> 1086 * @see CaptureRequest#CONTROL_SCENE_MODE 1087 */ 1088 public static final int CONTROL_SCENE_MODE_THEATRE = 7; 1089 1090 /** 1091 * <p>Optimized for bright, outdoor beach settings.</p> 1092 * @see CaptureRequest#CONTROL_SCENE_MODE 1093 */ 1094 public static final int CONTROL_SCENE_MODE_BEACH = 8; 1095 1096 /** 1097 * <p>Optimized for bright, outdoor settings containing snow.</p> 1098 * @see CaptureRequest#CONTROL_SCENE_MODE 1099 */ 1100 public static final int CONTROL_SCENE_MODE_SNOW = 9; 1101 1102 /** 1103 * <p>Optimized for scenes of the setting sun.</p> 1104 * @see CaptureRequest#CONTROL_SCENE_MODE 1105 */ 1106 public static final int CONTROL_SCENE_MODE_SUNSET = 10; 1107 1108 /** 1109 * <p>Optimized to avoid blurry photos due to small amounts of 1110 * device motion (for example: due to hand shake).</p> 1111 * @see CaptureRequest#CONTROL_SCENE_MODE 1112 */ 1113 public static final int CONTROL_SCENE_MODE_STEADYPHOTO = 11; 1114 1115 /** 1116 * <p>Optimized for nighttime photos of fireworks.</p> 1117 * @see CaptureRequest#CONTROL_SCENE_MODE 1118 */ 1119 public static final int CONTROL_SCENE_MODE_FIREWORKS = 12; 1120 1121 /** 1122 * <p>Optimized for photos of quickly moving people. 1123 * Similar to ACTION.</p> 1124 * @see CaptureRequest#CONTROL_SCENE_MODE 1125 */ 1126 public static final int CONTROL_SCENE_MODE_SPORTS = 13; 1127 1128 /** 1129 * <p>Optimized for dim, indoor settings with multiple moving 1130 * people.</p> 1131 * @see CaptureRequest#CONTROL_SCENE_MODE 1132 */ 1133 public static final int CONTROL_SCENE_MODE_PARTY = 14; 1134 1135 /** 1136 * <p>Optimized for dim settings where the main light source 1137 * is a flame.</p> 1138 * @see CaptureRequest#CONTROL_SCENE_MODE 1139 */ 1140 public static final int CONTROL_SCENE_MODE_CANDLELIGHT = 15; 1141 1142 /** 1143 * <p>Optimized for accurately capturing a photo of barcode 1144 * for use by camera applications that wish to read the 1145 * barcode value.</p> 1146 * @see CaptureRequest#CONTROL_SCENE_MODE 1147 */ 1148 public static final int CONTROL_SCENE_MODE_BARCODE = 16; 1149 1150 // 1151 // Enumeration values for CaptureRequest#EDGE_MODE 1152 // 1153 1154 /** 1155 * <p>No edge enhancement is applied</p> 1156 * @see CaptureRequest#EDGE_MODE 1157 */ 1158 public static final int EDGE_MODE_OFF = 0; 1159 1160 /** 1161 * <p>Must not slow down frame rate relative to sensor 1162 * output</p> 1163 * @see CaptureRequest#EDGE_MODE 1164 */ 1165 public static final int EDGE_MODE_FAST = 1; 1166 1167 /** 1168 * <p>Frame rate may be reduced by high 1169 * quality</p> 1170 * @see CaptureRequest#EDGE_MODE 1171 */ 1172 public static final int EDGE_MODE_HIGH_QUALITY = 2; 1173 1174 // 1175 // Enumeration values for CaptureRequest#FLASH_MODE 1176 // 1177 1178 /** 1179 * <p>Do not fire the flash for this capture.</p> 1180 * @see CaptureRequest#FLASH_MODE 1181 */ 1182 public static final int FLASH_MODE_OFF = 0; 1183 1184 /** 1185 * <p>If the flash is available and charged, fire flash 1186 * for this capture based on android.flash.firingPower and 1187 * android.flash.firingTime.</p> 1188 * @see CaptureRequest#FLASH_MODE 1189 */ 1190 public static final int FLASH_MODE_SINGLE = 1; 1191 1192 /** 1193 * <p>Transition flash to continuously on.</p> 1194 * @see CaptureRequest#FLASH_MODE 1195 */ 1196 public static final int FLASH_MODE_TORCH = 2; 1197 1198 // 1199 // Enumeration values for CaptureRequest#HOT_PIXEL_MODE 1200 // 1201 1202 /** 1203 * <p>The frame rate must not be reduced relative to sensor raw output 1204 * for this option.</p> 1205 * <p>No hot pixel correction is applied. 1206 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1207 * 1208 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1209 * @see CaptureRequest#HOT_PIXEL_MODE 1210 */ 1211 public static final int HOT_PIXEL_MODE_OFF = 0; 1212 1213 /** 1214 * <p>The frame rate must not be reduced relative to sensor raw output 1215 * for this option.</p> 1216 * <p>Hot pixel correction is applied. 1217 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1218 * 1219 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1220 * @see CaptureRequest#HOT_PIXEL_MODE 1221 */ 1222 public static final int HOT_PIXEL_MODE_FAST = 1; 1223 1224 /** 1225 * <p>The frame rate may be reduced relative to sensor raw output 1226 * for this option.</p> 1227 * <p>A high-quality hot pixel correction is applied. 1228 * The hotpixel map may be returned in {@link CaptureResult#STATISTICS_HOT_PIXEL_MAP android.statistics.hotPixelMap}.</p> 1229 * 1230 * @see CaptureResult#STATISTICS_HOT_PIXEL_MAP 1231 * @see CaptureRequest#HOT_PIXEL_MODE 1232 */ 1233 public static final int HOT_PIXEL_MODE_HIGH_QUALITY = 2; 1234 1235 // 1236 // Enumeration values for CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1237 // 1238 1239 /** 1240 * <p>Optical stabilization is unavailable.</p> 1241 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1242 */ 1243 public static final int LENS_OPTICAL_STABILIZATION_MODE_OFF = 0; 1244 1245 /** 1246 * <p>Optical stabilization is enabled.</p> 1247 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 1248 */ 1249 public static final int LENS_OPTICAL_STABILIZATION_MODE_ON = 1; 1250 1251 // 1252 // Enumeration values for CaptureRequest#NOISE_REDUCTION_MODE 1253 // 1254 1255 /** 1256 * <p>No noise reduction is applied</p> 1257 * @see CaptureRequest#NOISE_REDUCTION_MODE 1258 */ 1259 public static final int NOISE_REDUCTION_MODE_OFF = 0; 1260 1261 /** 1262 * <p>Must not slow down frame rate relative to sensor 1263 * output</p> 1264 * @see CaptureRequest#NOISE_REDUCTION_MODE 1265 */ 1266 public static final int NOISE_REDUCTION_MODE_FAST = 1; 1267 1268 /** 1269 * <p>May slow down frame rate to provide highest 1270 * quality</p> 1271 * @see CaptureRequest#NOISE_REDUCTION_MODE 1272 */ 1273 public static final int NOISE_REDUCTION_MODE_HIGH_QUALITY = 2; 1274 1275 // 1276 // Enumeration values for CaptureRequest#SENSOR_TEST_PATTERN_MODE 1277 // 1278 1279 /** 1280 * <p>Default. No test pattern mode is used, and the camera 1281 * device returns captures from the image sensor.</p> 1282 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1283 */ 1284 public static final int SENSOR_TEST_PATTERN_MODE_OFF = 0; 1285 1286 /** 1287 * <p>Each pixel in <code>[R, G_even, G_odd, B]</code> is replaced by its 1288 * respective color channel provided in 1289 * {@link CaptureRequest#SENSOR_TEST_PATTERN_DATA android.sensor.testPatternData}.</p> 1290 * <p>For example:</p> 1291 * <pre><code>android.testPatternData = [0, 0xFFFFFFFF, 0xFFFFFFFF, 0] 1292 * </code></pre> 1293 * <p>All green pixels are 100% green. All red/blue pixels are black.</p> 1294 * <pre><code>android.testPatternData = [0xFFFFFFFF, 0, 0xFFFFFFFF, 0] 1295 * </code></pre> 1296 * <p>All red pixels are 100% red. Only the odd green pixels 1297 * are 100% green. All blue pixels are 100% black.</p> 1298 * 1299 * @see CaptureRequest#SENSOR_TEST_PATTERN_DATA 1300 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1301 */ 1302 public static final int SENSOR_TEST_PATTERN_MODE_SOLID_COLOR = 1; 1303 1304 /** 1305 * <p>All pixel data is replaced with an 8-bar color pattern.</p> 1306 * <p>The vertical bars (left-to-right) are as follows:</p> 1307 * <ul> 1308 * <li>100% white</li> 1309 * <li>yellow</li> 1310 * <li>cyan</li> 1311 * <li>green</li> 1312 * <li>magenta</li> 1313 * <li>red</li> 1314 * <li>blue</li> 1315 * <li>black</li> 1316 * </ul> 1317 * <p>In general the image would look like the following:</p> 1318 * <pre><code>W Y C G M R B K 1319 * W Y C G M R B K 1320 * W Y C G M R B K 1321 * W Y C G M R B K 1322 * W Y C G M R B K 1323 * . . . . . . . . 1324 * . . . . . . . . 1325 * . . . . . . . . 1326 * 1327 * (B = Blue, K = Black) 1328 * </code></pre> 1329 * <p>Each bar should take up 1/8 of the sensor pixel array width. 1330 * When this is not possible, the bar size should be rounded 1331 * down to the nearest integer and the pattern can repeat 1332 * on the right side.</p> 1333 * <p>Each bar's height must always take up the full sensor 1334 * pixel array height.</p> 1335 * <p>Each pixel in this test pattern must be set to either 1336 * 0% intensity or 100% intensity.</p> 1337 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1338 */ 1339 public static final int SENSOR_TEST_PATTERN_MODE_COLOR_BARS = 2; 1340 1341 /** 1342 * <p>The test pattern is similar to COLOR_BARS, except that 1343 * each bar should start at its specified color at the top, 1344 * and fade to gray at the bottom.</p> 1345 * <p>Furthermore each bar is further subdivided into a left and 1346 * right half. The left half should have a smooth gradient, 1347 * and the right half should have a quantized gradient.</p> 1348 * <p>In particular, the right half's should consist of blocks of the 1349 * same color for 1/16th active sensor pixel array width.</p> 1350 * <p>The least significant bits in the quantized gradient should 1351 * be copied from the most significant bits of the smooth gradient.</p> 1352 * <p>The height of each bar should always be a multiple of 128. 1353 * When this is not the case, the pattern should repeat at the bottom 1354 * of the image.</p> 1355 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1356 */ 1357 public static final int SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY = 3; 1358 1359 /** 1360 * <p>All pixel data is replaced by a pseudo-random sequence 1361 * generated from a PN9 512-bit sequence (typically implemented 1362 * in hardware with a linear feedback shift register).</p> 1363 * <p>The generator should be reset at the beginning of each frame, 1364 * and thus each subsequent raw frame with this test pattern should 1365 * be exactly the same as the last.</p> 1366 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1367 */ 1368 public static final int SENSOR_TEST_PATTERN_MODE_PN9 = 4; 1369 1370 /** 1371 * <p>The first custom test pattern. All custom patterns that are 1372 * available only on this camera device are at least this numeric 1373 * value.</p> 1374 * <p>All of the custom test patterns will be static 1375 * (that is the raw image must not vary from frame to frame).</p> 1376 * @see CaptureRequest#SENSOR_TEST_PATTERN_MODE 1377 */ 1378 public static final int SENSOR_TEST_PATTERN_MODE_CUSTOM1 = 256; 1379 1380 // 1381 // Enumeration values for CaptureRequest#SHADING_MODE 1382 // 1383 1384 /** 1385 * <p>No lens shading correction is applied</p> 1386 * @see CaptureRequest#SHADING_MODE 1387 */ 1388 public static final int SHADING_MODE_OFF = 0; 1389 1390 /** 1391 * <p>Must not slow down frame rate relative to sensor raw output</p> 1392 * @see CaptureRequest#SHADING_MODE 1393 */ 1394 public static final int SHADING_MODE_FAST = 1; 1395 1396 /** 1397 * <p>Frame rate may be reduced by high quality</p> 1398 * @see CaptureRequest#SHADING_MODE 1399 */ 1400 public static final int SHADING_MODE_HIGH_QUALITY = 2; 1401 1402 // 1403 // Enumeration values for CaptureRequest#STATISTICS_FACE_DETECT_MODE 1404 // 1405 1406 /** 1407 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1408 */ 1409 public static final int STATISTICS_FACE_DETECT_MODE_OFF = 0; 1410 1411 /** 1412 * <p>Optional Return rectangle and confidence 1413 * only</p> 1414 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1415 */ 1416 public static final int STATISTICS_FACE_DETECT_MODE_SIMPLE = 1; 1417 1418 /** 1419 * <p>Optional Return all face 1420 * metadata</p> 1421 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1422 */ 1423 public static final int STATISTICS_FACE_DETECT_MODE_FULL = 2; 1424 1425 // 1426 // Enumeration values for CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1427 // 1428 1429 /** 1430 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1431 */ 1432 public static final int STATISTICS_LENS_SHADING_MAP_MODE_OFF = 0; 1433 1434 /** 1435 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1436 */ 1437 public static final int STATISTICS_LENS_SHADING_MAP_MODE_ON = 1; 1438 1439 // 1440 // Enumeration values for CaptureRequest#TONEMAP_MODE 1441 // 1442 1443 /** 1444 * <p>Use the tone mapping curve specified in 1445 * the android.tonemap.curve* entries.</p> 1446 * <p>All color enhancement and tonemapping must be disabled, except 1447 * for applying the tonemapping curve specified by 1448 * {@link CaptureRequest#TONEMAP_CURVE_RED android.tonemap.curveRed}, {@link CaptureRequest#TONEMAP_CURVE_BLUE android.tonemap.curveBlue}, or 1449 * {@link CaptureRequest#TONEMAP_CURVE_GREEN android.tonemap.curveGreen}.</p> 1450 * <p>Must not slow down frame rate relative to raw 1451 * sensor output.</p> 1452 * 1453 * @see CaptureRequest#TONEMAP_CURVE_BLUE 1454 * @see CaptureRequest#TONEMAP_CURVE_GREEN 1455 * @see CaptureRequest#TONEMAP_CURVE_RED 1456 * @see CaptureRequest#TONEMAP_MODE 1457 */ 1458 public static final int TONEMAP_MODE_CONTRAST_CURVE = 0; 1459 1460 /** 1461 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1462 * <p>Should not slow down frame rate relative to raw sensor output.</p> 1463 * @see CaptureRequest#TONEMAP_MODE 1464 */ 1465 public static final int TONEMAP_MODE_FAST = 1; 1466 1467 /** 1468 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1469 * <p>May slow down frame rate relative to raw sensor output.</p> 1470 * @see CaptureRequest#TONEMAP_MODE 1471 */ 1472 public static final int TONEMAP_MODE_HIGH_QUALITY = 2; 1473 1474 // 1475 // Enumeration values for CaptureResult#CONTROL_AE_STATE 1476 // 1477 1478 /** 1479 * <p>AE is off or recently reset. When a camera device is opened, it starts in 1480 * this state. This is a transient state, the camera device may skip reporting 1481 * this state in capture result.</p> 1482 * @see CaptureResult#CONTROL_AE_STATE 1483 */ 1484 public static final int CONTROL_AE_STATE_INACTIVE = 0; 1485 1486 /** 1487 * <p>AE doesn't yet have a good set of control values 1488 * for the current scene. This is a transient state, the camera device may skip 1489 * reporting this state in capture result.</p> 1490 * @see CaptureResult#CONTROL_AE_STATE 1491 */ 1492 public static final int CONTROL_AE_STATE_SEARCHING = 1; 1493 1494 /** 1495 * <p>AE has a good set of control values for the 1496 * current scene.</p> 1497 * @see CaptureResult#CONTROL_AE_STATE 1498 */ 1499 public static final int CONTROL_AE_STATE_CONVERGED = 2; 1500 1501 /** 1502 * <p>AE has been locked.</p> 1503 * @see CaptureResult#CONTROL_AE_STATE 1504 */ 1505 public static final int CONTROL_AE_STATE_LOCKED = 3; 1506 1507 /** 1508 * <p>AE has a good set of control values, but flash 1509 * needs to be fired for good quality still 1510 * capture.</p> 1511 * @see CaptureResult#CONTROL_AE_STATE 1512 */ 1513 public static final int CONTROL_AE_STATE_FLASH_REQUIRED = 4; 1514 1515 /** 1516 * <p>AE has been asked to do a precapture sequence 1517 * (through the {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger} START), 1518 * and is currently executing it. Once PRECAPTURE 1519 * completes, AE will transition to CONVERGED or 1520 * FLASH_REQUIRED as appropriate. This is a transient state, the 1521 * camera device may skip reporting this state in capture result.</p> 1522 * 1523 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 1524 * @see CaptureResult#CONTROL_AE_STATE 1525 */ 1526 public static final int CONTROL_AE_STATE_PRECAPTURE = 5; 1527 1528 // 1529 // Enumeration values for CaptureResult#CONTROL_AF_STATE 1530 // 1531 1532 /** 1533 * <p>AF off or has not yet tried to scan/been asked 1534 * to scan. When a camera device is opened, it starts in 1535 * this state. This is a transient state, the camera device may 1536 * skip reporting this state in capture result.</p> 1537 * @see CaptureResult#CONTROL_AF_STATE 1538 */ 1539 public static final int CONTROL_AF_STATE_INACTIVE = 0; 1540 1541 /** 1542 * <p>if CONTINUOUS_* modes are supported. AF is 1543 * currently doing an AF scan initiated by a continuous 1544 * autofocus mode. This is a transient state, the camera device may 1545 * skip reporting this state in capture result.</p> 1546 * @see CaptureResult#CONTROL_AF_STATE 1547 */ 1548 public static final int CONTROL_AF_STATE_PASSIVE_SCAN = 1; 1549 1550 /** 1551 * <p>if CONTINUOUS_* modes are supported. AF currently 1552 * believes it is in focus, but may restart scanning at 1553 * any time. This is a transient state, the camera device may skip 1554 * reporting this state in capture result.</p> 1555 * @see CaptureResult#CONTROL_AF_STATE 1556 */ 1557 public static final int CONTROL_AF_STATE_PASSIVE_FOCUSED = 2; 1558 1559 /** 1560 * <p>if AUTO or MACRO modes are supported. AF is doing 1561 * an AF scan because it was triggered by AF trigger. This is a 1562 * transient state, the camera device may skip reporting 1563 * this state in capture result.</p> 1564 * @see CaptureResult#CONTROL_AF_STATE 1565 */ 1566 public static final int CONTROL_AF_STATE_ACTIVE_SCAN = 3; 1567 1568 /** 1569 * <p>if any AF mode besides OFF is supported. AF 1570 * believes it is focused correctly and is 1571 * locked.</p> 1572 * @see CaptureResult#CONTROL_AF_STATE 1573 */ 1574 public static final int CONTROL_AF_STATE_FOCUSED_LOCKED = 4; 1575 1576 /** 1577 * <p>if any AF mode besides OFF is supported. AF has 1578 * failed to focus successfully and is 1579 * locked.</p> 1580 * @see CaptureResult#CONTROL_AF_STATE 1581 */ 1582 public static final int CONTROL_AF_STATE_NOT_FOCUSED_LOCKED = 5; 1583 1584 /** 1585 * <p>if CONTINUOUS_* modes are supported. AF finished a 1586 * passive scan without finding focus, and may restart 1587 * scanning at any time. This is a transient state, the camera 1588 * device may skip reporting this state in capture result.</p> 1589 * @see CaptureResult#CONTROL_AF_STATE 1590 */ 1591 public static final int CONTROL_AF_STATE_PASSIVE_UNFOCUSED = 6; 1592 1593 // 1594 // Enumeration values for CaptureResult#CONTROL_AWB_STATE 1595 // 1596 1597 /** 1598 * <p>AWB is not in auto mode. When a camera device is opened, it 1599 * starts in this state. This is a transient state, the camera device may 1600 * skip reporting this state in capture result.</p> 1601 * @see CaptureResult#CONTROL_AWB_STATE 1602 */ 1603 public static final int CONTROL_AWB_STATE_INACTIVE = 0; 1604 1605 /** 1606 * <p>AWB doesn't yet have a good set of control 1607 * values for the current scene. This is a transient state, the camera device 1608 * may skip reporting this state in capture result.</p> 1609 * @see CaptureResult#CONTROL_AWB_STATE 1610 */ 1611 public static final int CONTROL_AWB_STATE_SEARCHING = 1; 1612 1613 /** 1614 * <p>AWB has a good set of control values for the 1615 * current scene.</p> 1616 * @see CaptureResult#CONTROL_AWB_STATE 1617 */ 1618 public static final int CONTROL_AWB_STATE_CONVERGED = 2; 1619 1620 /** 1621 * <p>AWB has been locked.</p> 1622 * @see CaptureResult#CONTROL_AWB_STATE 1623 */ 1624 public static final int CONTROL_AWB_STATE_LOCKED = 3; 1625 1626 // 1627 // Enumeration values for CaptureResult#FLASH_STATE 1628 // 1629 1630 /** 1631 * <p>No flash on camera.</p> 1632 * @see CaptureResult#FLASH_STATE 1633 */ 1634 public static final int FLASH_STATE_UNAVAILABLE = 0; 1635 1636 /** 1637 * <p>Flash is charging and cannot be fired.</p> 1638 * @see CaptureResult#FLASH_STATE 1639 */ 1640 public static final int FLASH_STATE_CHARGING = 1; 1641 1642 /** 1643 * <p>Flash is ready to fire.</p> 1644 * @see CaptureResult#FLASH_STATE 1645 */ 1646 public static final int FLASH_STATE_READY = 2; 1647 1648 /** 1649 * <p>Flash fired for this capture.</p> 1650 * @see CaptureResult#FLASH_STATE 1651 */ 1652 public static final int FLASH_STATE_FIRED = 3; 1653 1654 /** 1655 * <p>Flash partially illuminated this frame. This is usually due to the next 1656 * or previous frame having the flash fire, and the flash spilling into this capture 1657 * due to hardware limitations.</p> 1658 * @see CaptureResult#FLASH_STATE 1659 */ 1660 public static final int FLASH_STATE_PARTIAL = 4; 1661 1662 // 1663 // Enumeration values for CaptureResult#LENS_STATE 1664 // 1665 1666 /** 1667 * <p>The lens parameters ({@link CaptureRequest#LENS_FOCAL_LENGTH android.lens.focalLength}, {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance}, 1668 * {@link CaptureRequest#LENS_FILTER_DENSITY android.lens.filterDensity} and {@link CaptureRequest#LENS_APERTURE android.lens.aperture}) are not changing.</p> 1669 * 1670 * @see CaptureRequest#LENS_APERTURE 1671 * @see CaptureRequest#LENS_FILTER_DENSITY 1672 * @see CaptureRequest#LENS_FOCAL_LENGTH 1673 * @see CaptureRequest#LENS_FOCUS_DISTANCE 1674 * @see CaptureResult#LENS_STATE 1675 */ 1676 public static final int LENS_STATE_STATIONARY = 0; 1677 1678 /** 1679 * <p>Any of the lens parameters ({@link CaptureRequest#LENS_FOCAL_LENGTH android.lens.focalLength}, {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance}, 1680 * {@link CaptureRequest#LENS_FILTER_DENSITY android.lens.filterDensity} or {@link CaptureRequest#LENS_APERTURE android.lens.aperture}) is changing.</p> 1681 * 1682 * @see CaptureRequest#LENS_APERTURE 1683 * @see CaptureRequest#LENS_FILTER_DENSITY 1684 * @see CaptureRequest#LENS_FOCAL_LENGTH 1685 * @see CaptureRequest#LENS_FOCUS_DISTANCE 1686 * @see CaptureResult#LENS_STATE 1687 */ 1688 public static final int LENS_STATE_MOVING = 1; 1689 1690 // 1691 // Enumeration values for CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1692 // 1693 1694 /** 1695 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1696 */ 1697 public static final int SENSOR_REFERENCE_ILLUMINANT_DAYLIGHT = 1; 1698 1699 /** 1700 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1701 */ 1702 public static final int SENSOR_REFERENCE_ILLUMINANT_FLUORESCENT = 2; 1703 1704 /** 1705 * <p>Incandescent light</p> 1706 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1707 */ 1708 public static final int SENSOR_REFERENCE_ILLUMINANT_TUNGSTEN = 3; 1709 1710 /** 1711 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1712 */ 1713 public static final int SENSOR_REFERENCE_ILLUMINANT_FLASH = 4; 1714 1715 /** 1716 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1717 */ 1718 public static final int SENSOR_REFERENCE_ILLUMINANT_FINE_WEATHER = 9; 1719 1720 /** 1721 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1722 */ 1723 public static final int SENSOR_REFERENCE_ILLUMINANT_CLOUDY_WEATHER = 10; 1724 1725 /** 1726 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1727 */ 1728 public static final int SENSOR_REFERENCE_ILLUMINANT_SHADE = 11; 1729 1730 /** 1731 * <p>D 5700 - 7100K</p> 1732 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1733 */ 1734 public static final int SENSOR_REFERENCE_ILLUMINANT_DAYLIGHT_FLUORESCENT = 12; 1735 1736 /** 1737 * <p>N 4600 - 5400K</p> 1738 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1739 */ 1740 public static final int SENSOR_REFERENCE_ILLUMINANT_DAY_WHITE_FLUORESCENT = 13; 1741 1742 /** 1743 * <p>W 3900 - 4500K</p> 1744 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1745 */ 1746 public static final int SENSOR_REFERENCE_ILLUMINANT_COOL_WHITE_FLUORESCENT = 14; 1747 1748 /** 1749 * <p>WW 3200 - 3700K</p> 1750 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1751 */ 1752 public static final int SENSOR_REFERENCE_ILLUMINANT_WHITE_FLUORESCENT = 15; 1753 1754 /** 1755 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1756 */ 1757 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_A = 17; 1758 1759 /** 1760 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1761 */ 1762 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_B = 18; 1763 1764 /** 1765 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1766 */ 1767 public static final int SENSOR_REFERENCE_ILLUMINANT_STANDARD_C = 19; 1768 1769 /** 1770 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1771 */ 1772 public static final int SENSOR_REFERENCE_ILLUMINANT_D55 = 20; 1773 1774 /** 1775 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1776 */ 1777 public static final int SENSOR_REFERENCE_ILLUMINANT_D65 = 21; 1778 1779 /** 1780 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1781 */ 1782 public static final int SENSOR_REFERENCE_ILLUMINANT_D75 = 22; 1783 1784 /** 1785 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1786 */ 1787 public static final int SENSOR_REFERENCE_ILLUMINANT_D50 = 23; 1788 1789 /** 1790 * @see CaptureResult#SENSOR_REFERENCE_ILLUMINANT 1791 */ 1792 public static final int SENSOR_REFERENCE_ILLUMINANT_ISO_STUDIO_TUNGSTEN = 24; 1793 1794 // 1795 // Enumeration values for CaptureResult#STATISTICS_SCENE_FLICKER 1796 // 1797 1798 /** 1799 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1800 */ 1801 public static final int STATISTICS_SCENE_FLICKER_NONE = 0; 1802 1803 /** 1804 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1805 */ 1806 public static final int STATISTICS_SCENE_FLICKER_50HZ = 1; 1807 1808 /** 1809 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1810 */ 1811 public static final int STATISTICS_SCENE_FLICKER_60HZ = 2; 1812 1813 // 1814 // Enumeration values for CaptureResult#SYNC_FRAME_NUMBER 1815 // 1816 1817 /** 1818 * <p>The current result is not yet fully synchronized to any request. 1819 * Synchronization is in progress, and reading metadata from this 1820 * result may include a mix of data that have taken effect since the 1821 * last synchronization time.</p> 1822 * <p>In some future result, within {@link CameraCharacteristics#SYNC_MAX_LATENCY android.sync.maxLatency} frames, 1823 * this value will update to the actual frame number frame number 1824 * the result is guaranteed to be synchronized to (as long as the 1825 * request settings remain constant).</p> 1826 * 1827 * @see CameraCharacteristics#SYNC_MAX_LATENCY 1828 * @see CaptureResult#SYNC_FRAME_NUMBER 1829 * @hide 1830 */ 1831 public static final int SYNC_FRAME_NUMBER_CONVERGING = -1; 1832 1833 /** 1834 * <p>The current result's synchronization status is unknown. The 1835 * result may have already converged, or it may be in progress. 1836 * Reading from this result may include some mix of settings from 1837 * past requests.</p> 1838 * <p>After a settings change, the new settings will eventually all 1839 * take effect for the output buffers and results. However, this 1840 * value will not change when that happens. Altering settings 1841 * rapidly may provide outcomes using mixes of settings from recent 1842 * requests.</p> 1843 * <p>This value is intended primarily for backwards compatibility with 1844 * the older camera implementations (for android.hardware.Camera).</p> 1845 * @see CaptureResult#SYNC_FRAME_NUMBER 1846 * @hide 1847 */ 1848 public static final int SYNC_FRAME_NUMBER_UNKNOWN = -2; 1849 1850 /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 1851 * End generated code 1852 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/ 1853 1854} 1855