CameraMetadata.java revision 00849b3a430ce164af2db94eeacfd46131de4be8
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_FACING 210 // 211 212 /** 213 * @see CameraCharacteristics#LENS_FACING 214 */ 215 public static final int LENS_FACING_FRONT = 0; 216 217 /** 218 * @see CameraCharacteristics#LENS_FACING 219 */ 220 public static final int LENS_FACING_BACK = 1; 221 222 // 223 // Enumeration values for CameraCharacteristics#LED_AVAILABLE_LEDS 224 // 225 226 /** 227 * <p>android.led.transmit control is used</p> 228 * @see CameraCharacteristics#LED_AVAILABLE_LEDS 229 * @hide 230 */ 231 public static final int LED_AVAILABLE_LEDS_TRANSMIT = 0; 232 233 // 234 // Enumeration values for CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 235 // 236 237 /** 238 * @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 239 */ 240 public static final int INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED = 0; 241 242 /** 243 * @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL 244 */ 245 public static final int INFO_SUPPORTED_HARDWARE_LEVEL_FULL = 1; 246 247 // 248 // Enumeration values for CaptureRequest#COLOR_CORRECTION_MODE 249 // 250 251 /** 252 * <p>Use the {@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform} matrix 253 * and {@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains} to do color conversion.</p> 254 * <p>All advanced white balance adjustments (not specified 255 * by our white balance pipeline) must be disabled.</p> 256 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 257 * TRANSFORM_MATRIX is ignored. The camera device will override 258 * this value to either FAST or HIGH_QUALITY.</p> 259 * 260 * @see CaptureRequest#COLOR_CORRECTION_GAINS 261 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 262 * @see CaptureRequest#CONTROL_AWB_MODE 263 * @see CaptureRequest#COLOR_CORRECTION_MODE 264 */ 265 public static final int COLOR_CORRECTION_MODE_TRANSFORM_MATRIX = 0; 266 267 /** 268 * <p>Must not slow down capture rate relative to sensor raw 269 * output.</p> 270 * <p>Advanced white balance adjustments above and beyond 271 * the specified white balance pipeline may be applied.</p> 272 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 273 * the camera device uses the last frame's AWB values 274 * (or defaults if AWB has never been run).</p> 275 * 276 * @see CaptureRequest#CONTROL_AWB_MODE 277 * @see CaptureRequest#COLOR_CORRECTION_MODE 278 */ 279 public static final int COLOR_CORRECTION_MODE_FAST = 1; 280 281 /** 282 * <p>Capture rate (relative to sensor raw output) 283 * may be reduced by high quality.</p> 284 * <p>Advanced white balance adjustments above and beyond 285 * the specified white balance pipeline may be applied.</p> 286 * <p>If AWB is enabled with <code>{@link CaptureRequest#CONTROL_AWB_MODE android.control.awbMode} != OFF</code>, then 287 * the camera device uses the last frame's AWB values 288 * (or defaults if AWB has never been run).</p> 289 * 290 * @see CaptureRequest#CONTROL_AWB_MODE 291 * @see CaptureRequest#COLOR_CORRECTION_MODE 292 */ 293 public static final int COLOR_CORRECTION_MODE_HIGH_QUALITY = 2; 294 295 // 296 // Enumeration values for CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 297 // 298 299 /** 300 * <p>The camera device will not adjust exposure duration to 301 * avoid banding problems.</p> 302 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 303 */ 304 public static final int CONTROL_AE_ANTIBANDING_MODE_OFF = 0; 305 306 /** 307 * <p>The camera device will adjust exposure duration to 308 * avoid banding problems with 50Hz illumination sources.</p> 309 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 310 */ 311 public static final int CONTROL_AE_ANTIBANDING_MODE_50HZ = 1; 312 313 /** 314 * <p>The camera device will adjust exposure duration to 315 * avoid banding problems with 60Hz illumination 316 * sources.</p> 317 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 318 */ 319 public static final int CONTROL_AE_ANTIBANDING_MODE_60HZ = 2; 320 321 /** 322 * <p>The camera device will automatically adapt its 323 * antibanding routine to the current illumination 324 * conditions. This is the default.</p> 325 * @see CaptureRequest#CONTROL_AE_ANTIBANDING_MODE 326 */ 327 public static final int CONTROL_AE_ANTIBANDING_MODE_AUTO = 3; 328 329 // 330 // Enumeration values for CaptureRequest#CONTROL_AE_MODE 331 // 332 333 /** 334 * <p>The camera device's autoexposure routine is disabled; 335 * the application-selected {@link CaptureRequest#SENSOR_EXPOSURE_TIME android.sensor.exposureTime}, 336 * {@link CaptureRequest#SENSOR_SENSITIVITY android.sensor.sensitivity} and 337 * {@link CaptureRequest#SENSOR_FRAME_DURATION android.sensor.frameDuration} are used by the camera 338 * device, along with android.flash.* fields, if there's 339 * a flash unit for this camera device.</p> 340 * 341 * @see CaptureRequest#SENSOR_EXPOSURE_TIME 342 * @see CaptureRequest#SENSOR_FRAME_DURATION 343 * @see CaptureRequest#SENSOR_SENSITIVITY 344 * @see CaptureRequest#CONTROL_AE_MODE 345 */ 346 public static final int CONTROL_AE_MODE_OFF = 0; 347 348 /** 349 * <p>The camera device's autoexposure routine is active, 350 * with no flash control. The application's values for 351 * {@link CaptureRequest#SENSOR_EXPOSURE_TIME android.sensor.exposureTime}, 352 * {@link CaptureRequest#SENSOR_SENSITIVITY android.sensor.sensitivity}, and 353 * {@link CaptureRequest#SENSOR_FRAME_DURATION android.sensor.frameDuration} are ignored. The 354 * application has control over the various 355 * android.flash.* fields.</p> 356 * 357 * @see CaptureRequest#SENSOR_EXPOSURE_TIME 358 * @see CaptureRequest#SENSOR_FRAME_DURATION 359 * @see CaptureRequest#SENSOR_SENSITIVITY 360 * @see CaptureRequest#CONTROL_AE_MODE 361 */ 362 public static final int CONTROL_AE_MODE_ON = 1; 363 364 /** 365 * <p>Like ON, except that the camera device also controls 366 * the camera's flash unit, firing it in low-light 367 * conditions. The flash may be fired during a 368 * precapture sequence (triggered by 369 * {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger}) and may be fired 370 * for captures for which the 371 * {@link CaptureRequest#CONTROL_CAPTURE_INTENT android.control.captureIntent} field is set to 372 * STILL_CAPTURE</p> 373 * 374 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 375 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 376 * @see CaptureRequest#CONTROL_AE_MODE 377 */ 378 public static final int CONTROL_AE_MODE_ON_AUTO_FLASH = 2; 379 380 /** 381 * <p>Like ON, except that the camera device also controls 382 * the camera's flash unit, always firing it for still 383 * captures. The flash may be fired during a precapture 384 * sequence (triggered by 385 * {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger}) and will always 386 * be fired for captures for which the 387 * {@link CaptureRequest#CONTROL_CAPTURE_INTENT android.control.captureIntent} field is set to 388 * STILL_CAPTURE</p> 389 * 390 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 391 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 392 * @see CaptureRequest#CONTROL_AE_MODE 393 */ 394 public static final int CONTROL_AE_MODE_ON_ALWAYS_FLASH = 3; 395 396 /** 397 * <p>Like ON_AUTO_FLASH, but with automatic red eye 398 * reduction. If deemed necessary by the camera device, 399 * a red eye reduction flash will fire during the 400 * precapture sequence.</p> 401 * @see CaptureRequest#CONTROL_AE_MODE 402 */ 403 public static final int CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE = 4; 404 405 // 406 // Enumeration values for CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 407 // 408 409 /** 410 * <p>The trigger is idle.</p> 411 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 412 */ 413 public static final int CONTROL_AE_PRECAPTURE_TRIGGER_IDLE = 0; 414 415 /** 416 * <p>The precapture metering sequence will be started 417 * by the camera device. The exact effect of the precapture 418 * trigger depends on the current AE mode and state.</p> 419 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 420 */ 421 public static final int CONTROL_AE_PRECAPTURE_TRIGGER_START = 1; 422 423 // 424 // Enumeration values for CaptureRequest#CONTROL_AF_MODE 425 // 426 427 /** 428 * <p>The auto-focus routine does not control the lens; 429 * {@link CaptureRequest#LENS_FOCUS_DISTANCE android.lens.focusDistance} is controlled by the 430 * application</p> 431 * 432 * @see CaptureRequest#LENS_FOCUS_DISTANCE 433 * @see CaptureRequest#CONTROL_AF_MODE 434 */ 435 public static final int CONTROL_AF_MODE_OFF = 0; 436 437 /** 438 * <p>If lens is not fixed focus.</p> 439 * <p>Use {@link CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE android.lens.info.minimumFocusDistance} to determine if lens 440 * is fixed-focus. In this mode, the lens does not move unless 441 * the autofocus trigger action is called. When that trigger 442 * is activated, AF must transition to ACTIVE_SCAN, then to 443 * the outcome of the scan (FOCUSED or NOT_FOCUSED).</p> 444 * <p>Triggering AF_CANCEL resets the lens position to default, 445 * and sets the AF state to INACTIVE.</p> 446 * 447 * @see CameraCharacteristics#LENS_INFO_MINIMUM_FOCUS_DISTANCE 448 * @see CaptureRequest#CONTROL_AF_MODE 449 */ 450 public static final int CONTROL_AF_MODE_AUTO = 1; 451 452 /** 453 * <p>In this mode, the lens does not move unless the 454 * autofocus trigger action is called.</p> 455 * <p>When that trigger is activated, AF must transition to 456 * ACTIVE_SCAN, then to the outcome of the scan (FOCUSED or 457 * NOT_FOCUSED). Triggering cancel AF resets the lens 458 * position to default, and sets the AF state to 459 * INACTIVE.</p> 460 * @see CaptureRequest#CONTROL_AF_MODE 461 */ 462 public static final int CONTROL_AF_MODE_MACRO = 2; 463 464 /** 465 * <p>In this mode, the AF algorithm modifies the lens 466 * position continually to attempt to provide a 467 * constantly-in-focus image stream.</p> 468 * <p>The focusing behavior should be suitable for good quality 469 * video recording; typically this means slower focus 470 * movement and no overshoots. When the AF trigger is not 471 * involved, the AF algorithm should start in INACTIVE state, 472 * and then transition into PASSIVE_SCAN and PASSIVE_FOCUSED 473 * states as appropriate. When the AF trigger is activated, 474 * the algorithm should immediately transition into 475 * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the 476 * lens position until a cancel AF trigger is received.</p> 477 * <p>Once cancel is received, the algorithm should transition 478 * back to INACTIVE and resume passive scan. Note that this 479 * behavior is not identical to CONTINUOUS_PICTURE, since an 480 * ongoing PASSIVE_SCAN must immediately be 481 * canceled.</p> 482 * @see CaptureRequest#CONTROL_AF_MODE 483 */ 484 public static final int CONTROL_AF_MODE_CONTINUOUS_VIDEO = 3; 485 486 /** 487 * <p>In this mode, the AF algorithm modifies the lens 488 * position continually to attempt to provide a 489 * constantly-in-focus image stream.</p> 490 * <p>The focusing behavior should be suitable for still image 491 * capture; typically this means focusing as fast as 492 * possible. When the AF trigger is not involved, the AF 493 * algorithm should start in INACTIVE state, and then 494 * transition into PASSIVE_SCAN and PASSIVE_FOCUSED states as 495 * appropriate as it attempts to maintain focus. When the AF 496 * trigger is activated, the algorithm should finish its 497 * PASSIVE_SCAN if active, and then transition into 498 * AF_FOCUSED or AF_NOT_FOCUSED as appropriate, and lock the 499 * lens position until a cancel AF trigger is received.</p> 500 * <p>When the AF cancel trigger is activated, the algorithm 501 * should transition back to INACTIVE and then act as if it 502 * has just been started.</p> 503 * @see CaptureRequest#CONTROL_AF_MODE 504 */ 505 public static final int CONTROL_AF_MODE_CONTINUOUS_PICTURE = 4; 506 507 /** 508 * <p>Extended depth of field (digital focus). AF 509 * trigger is ignored, AF state should always be 510 * INACTIVE.</p> 511 * @see CaptureRequest#CONTROL_AF_MODE 512 */ 513 public static final int CONTROL_AF_MODE_EDOF = 5; 514 515 // 516 // Enumeration values for CaptureRequest#CONTROL_AF_TRIGGER 517 // 518 519 /** 520 * <p>The trigger is idle.</p> 521 * @see CaptureRequest#CONTROL_AF_TRIGGER 522 */ 523 public static final int CONTROL_AF_TRIGGER_IDLE = 0; 524 525 /** 526 * <p>Autofocus will trigger now.</p> 527 * @see CaptureRequest#CONTROL_AF_TRIGGER 528 */ 529 public static final int CONTROL_AF_TRIGGER_START = 1; 530 531 /** 532 * <p>Autofocus will return to its initial 533 * state, and cancel any currently active trigger.</p> 534 * @see CaptureRequest#CONTROL_AF_TRIGGER 535 */ 536 public static final int CONTROL_AF_TRIGGER_CANCEL = 2; 537 538 // 539 // Enumeration values for CaptureRequest#CONTROL_AWB_MODE 540 // 541 542 /** 543 * <p>The camera device's auto white balance routine is disabled; 544 * the application-selected color transform matrix 545 * ({@link CaptureRequest#COLOR_CORRECTION_TRANSFORM android.colorCorrection.transform}) and gains 546 * ({@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains}) are used by the camera 547 * device for manual white balance control.</p> 548 * 549 * @see CaptureRequest#COLOR_CORRECTION_GAINS 550 * @see CaptureRequest#COLOR_CORRECTION_TRANSFORM 551 * @see CaptureRequest#CONTROL_AWB_MODE 552 */ 553 public static final int CONTROL_AWB_MODE_OFF = 0; 554 555 /** 556 * <p>The camera device's auto white balance routine is active; 557 * the application's values for android.colorCorrection.transform 558 * and {@link CaptureRequest#COLOR_CORRECTION_GAINS android.colorCorrection.gains} are ignored.</p> 559 * 560 * @see CaptureRequest#COLOR_CORRECTION_GAINS 561 * @see CaptureRequest#CONTROL_AWB_MODE 562 */ 563 public static final int CONTROL_AWB_MODE_AUTO = 1; 564 565 /** 566 * <p>The camera device's auto white balance routine is disabled; 567 * the camera device uses incandescent light as the assumed scene 568 * illumination for white balance. While the exact white balance 569 * transforms are up to the camera device, they will approximately 570 * match the CIE standard illuminant A.</p> 571 * @see CaptureRequest#CONTROL_AWB_MODE 572 */ 573 public static final int CONTROL_AWB_MODE_INCANDESCENT = 2; 574 575 /** 576 * <p>The camera device's auto white balance routine is disabled; 577 * the camera device uses fluorescent light as the assumed scene 578 * illumination for white balance. While the exact white balance 579 * transforms are up to the camera device, they will approximately 580 * match the CIE standard illuminant F2.</p> 581 * @see CaptureRequest#CONTROL_AWB_MODE 582 */ 583 public static final int CONTROL_AWB_MODE_FLUORESCENT = 3; 584 585 /** 586 * <p>The camera device's auto white balance routine is disabled; 587 * the camera device uses warm fluorescent light as the assumed scene 588 * illumination for white balance. While the exact white balance 589 * transforms are up to the camera device, they will approximately 590 * match the CIE standard illuminant F4.</p> 591 * @see CaptureRequest#CONTROL_AWB_MODE 592 */ 593 public static final int CONTROL_AWB_MODE_WARM_FLUORESCENT = 4; 594 595 /** 596 * <p>The camera device's auto white balance routine is disabled; 597 * the camera device uses daylight light as the assumed scene 598 * illumination for white balance. While the exact white balance 599 * transforms are up to the camera device, they will approximately 600 * match the CIE standard illuminant D65.</p> 601 * @see CaptureRequest#CONTROL_AWB_MODE 602 */ 603 public static final int CONTROL_AWB_MODE_DAYLIGHT = 5; 604 605 /** 606 * <p>The camera device's auto white balance routine is disabled; 607 * the camera device uses cloudy daylight light as the assumed scene 608 * illumination for white balance.</p> 609 * @see CaptureRequest#CONTROL_AWB_MODE 610 */ 611 public static final int CONTROL_AWB_MODE_CLOUDY_DAYLIGHT = 6; 612 613 /** 614 * <p>The camera device's auto white balance routine is disabled; 615 * the camera device uses twilight light as the assumed scene 616 * illumination for white balance.</p> 617 * @see CaptureRequest#CONTROL_AWB_MODE 618 */ 619 public static final int CONTROL_AWB_MODE_TWILIGHT = 7; 620 621 /** 622 * <p>The camera device's auto white balance routine is disabled; 623 * the camera device uses shade light as the assumed scene 624 * illumination for white balance.</p> 625 * @see CaptureRequest#CONTROL_AWB_MODE 626 */ 627 public static final int CONTROL_AWB_MODE_SHADE = 8; 628 629 // 630 // Enumeration values for CaptureRequest#CONTROL_CAPTURE_INTENT 631 // 632 633 /** 634 * <p>This request doesn't fall into the other 635 * categories. Default to preview-like 636 * behavior.</p> 637 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 638 */ 639 public static final int CONTROL_CAPTURE_INTENT_CUSTOM = 0; 640 641 /** 642 * <p>This request is for a preview-like usecase. The 643 * precapture trigger may be used to start off a metering 644 * w/flash sequence</p> 645 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 646 */ 647 public static final int CONTROL_CAPTURE_INTENT_PREVIEW = 1; 648 649 /** 650 * <p>This request is for a still capture-type 651 * usecase.</p> 652 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 653 */ 654 public static final int CONTROL_CAPTURE_INTENT_STILL_CAPTURE = 2; 655 656 /** 657 * <p>This request is for a video recording 658 * usecase.</p> 659 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 660 */ 661 public static final int CONTROL_CAPTURE_INTENT_VIDEO_RECORD = 3; 662 663 /** 664 * <p>This request is for a video snapshot (still 665 * image while recording video) usecase</p> 666 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 667 */ 668 public static final int CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT = 4; 669 670 /** 671 * <p>This request is for a ZSL usecase; the 672 * application will stream full-resolution images and 673 * reprocess one or several later for a final 674 * capture</p> 675 * @see CaptureRequest#CONTROL_CAPTURE_INTENT 676 */ 677 public static final int CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG = 5; 678 679 // 680 // Enumeration values for CaptureRequest#CONTROL_EFFECT_MODE 681 // 682 683 /** 684 * <p>No color effect will be applied.</p> 685 * @see CaptureRequest#CONTROL_EFFECT_MODE 686 */ 687 public static final int CONTROL_EFFECT_MODE_OFF = 0; 688 689 /** 690 * <p>A "monocolor" effect where the image is mapped into 691 * a single color. This will typically be grayscale.</p> 692 * @see CaptureRequest#CONTROL_EFFECT_MODE 693 */ 694 public static final int CONTROL_EFFECT_MODE_MONO = 1; 695 696 /** 697 * <p>A "photo-negative" effect where the image's colors 698 * are inverted.</p> 699 * @see CaptureRequest#CONTROL_EFFECT_MODE 700 */ 701 public static final int CONTROL_EFFECT_MODE_NEGATIVE = 2; 702 703 /** 704 * <p>A "solarisation" effect (Sabattier effect) where the 705 * image is wholly or partially reversed in 706 * tone.</p> 707 * @see CaptureRequest#CONTROL_EFFECT_MODE 708 */ 709 public static final int CONTROL_EFFECT_MODE_SOLARIZE = 3; 710 711 /** 712 * <p>A "sepia" effect where the image is mapped into warm 713 * gray, red, and brown tones.</p> 714 * @see CaptureRequest#CONTROL_EFFECT_MODE 715 */ 716 public static final int CONTROL_EFFECT_MODE_SEPIA = 4; 717 718 /** 719 * <p>A "posterization" effect where the image uses 720 * discrete regions of tone rather than a continuous 721 * gradient of tones.</p> 722 * @see CaptureRequest#CONTROL_EFFECT_MODE 723 */ 724 public static final int CONTROL_EFFECT_MODE_POSTERIZE = 5; 725 726 /** 727 * <p>A "whiteboard" effect where the image is typically displayed 728 * as regions of white, with black or grey details.</p> 729 * @see CaptureRequest#CONTROL_EFFECT_MODE 730 */ 731 public static final int CONTROL_EFFECT_MODE_WHITEBOARD = 6; 732 733 /** 734 * <p>A "blackboard" effect where the image is typically displayed 735 * as regions of black, with white or grey details.</p> 736 * @see CaptureRequest#CONTROL_EFFECT_MODE 737 */ 738 public static final int CONTROL_EFFECT_MODE_BLACKBOARD = 7; 739 740 /** 741 * <p>An "aqua" effect where a blue hue is added to the image.</p> 742 * @see CaptureRequest#CONTROL_EFFECT_MODE 743 */ 744 public static final int CONTROL_EFFECT_MODE_AQUA = 8; 745 746 // 747 // Enumeration values for CaptureRequest#CONTROL_MODE 748 // 749 750 /** 751 * <p>Full application control of pipeline. All 3A 752 * routines are disabled, no other settings in 753 * android.control.* have any effect</p> 754 * @see CaptureRequest#CONTROL_MODE 755 */ 756 public static final int CONTROL_MODE_OFF = 0; 757 758 /** 759 * <p>Use settings for each individual 3A routine. 760 * Manual control of capture parameters is disabled. All 761 * controls in android.control.* besides sceneMode take 762 * effect</p> 763 * @see CaptureRequest#CONTROL_MODE 764 */ 765 public static final int CONTROL_MODE_AUTO = 1; 766 767 /** 768 * <p>Use specific scene mode. Enabling this disables 769 * control.aeMode, control.awbMode and control.afMode 770 * controls; the HAL must ignore those settings while 771 * USE_SCENE_MODE is active (except for FACE_PRIORITY 772 * scene mode). Other control entries are still active. 773 * This setting can only be used if availableSceneModes != 774 * UNSUPPORTED</p> 775 * @see CaptureRequest#CONTROL_MODE 776 */ 777 public static final int CONTROL_MODE_USE_SCENE_MODE = 2; 778 779 // 780 // Enumeration values for CaptureRequest#CONTROL_SCENE_MODE 781 // 782 783 /** 784 * @see CaptureRequest#CONTROL_SCENE_MODE 785 */ 786 public static final int CONTROL_SCENE_MODE_UNSUPPORTED = 0; 787 788 /** 789 * <p>if face detection support exists Use face 790 * detection data to drive 3A routines. If face detection 791 * statistics are disabled, should still operate correctly 792 * (but not return face detection statistics to the 793 * framework).</p> 794 * <p>Unlike the other scene modes, aeMode, awbMode, and afMode 795 * remain active when FACE_PRIORITY is set. This is due to 796 * compatibility concerns with the old camera 797 * API</p> 798 * @see CaptureRequest#CONTROL_SCENE_MODE 799 */ 800 public static final int CONTROL_SCENE_MODE_FACE_PRIORITY = 1; 801 802 /** 803 * @see CaptureRequest#CONTROL_SCENE_MODE 804 */ 805 public static final int CONTROL_SCENE_MODE_ACTION = 2; 806 807 /** 808 * @see CaptureRequest#CONTROL_SCENE_MODE 809 */ 810 public static final int CONTROL_SCENE_MODE_PORTRAIT = 3; 811 812 /** 813 * @see CaptureRequest#CONTROL_SCENE_MODE 814 */ 815 public static final int CONTROL_SCENE_MODE_LANDSCAPE = 4; 816 817 /** 818 * @see CaptureRequest#CONTROL_SCENE_MODE 819 */ 820 public static final int CONTROL_SCENE_MODE_NIGHT = 5; 821 822 /** 823 * @see CaptureRequest#CONTROL_SCENE_MODE 824 */ 825 public static final int CONTROL_SCENE_MODE_NIGHT_PORTRAIT = 6; 826 827 /** 828 * @see CaptureRequest#CONTROL_SCENE_MODE 829 */ 830 public static final int CONTROL_SCENE_MODE_THEATRE = 7; 831 832 /** 833 * @see CaptureRequest#CONTROL_SCENE_MODE 834 */ 835 public static final int CONTROL_SCENE_MODE_BEACH = 8; 836 837 /** 838 * @see CaptureRequest#CONTROL_SCENE_MODE 839 */ 840 public static final int CONTROL_SCENE_MODE_SNOW = 9; 841 842 /** 843 * @see CaptureRequest#CONTROL_SCENE_MODE 844 */ 845 public static final int CONTROL_SCENE_MODE_SUNSET = 10; 846 847 /** 848 * @see CaptureRequest#CONTROL_SCENE_MODE 849 */ 850 public static final int CONTROL_SCENE_MODE_STEADYPHOTO = 11; 851 852 /** 853 * @see CaptureRequest#CONTROL_SCENE_MODE 854 */ 855 public static final int CONTROL_SCENE_MODE_FIREWORKS = 12; 856 857 /** 858 * @see CaptureRequest#CONTROL_SCENE_MODE 859 */ 860 public static final int CONTROL_SCENE_MODE_SPORTS = 13; 861 862 /** 863 * @see CaptureRequest#CONTROL_SCENE_MODE 864 */ 865 public static final int CONTROL_SCENE_MODE_PARTY = 14; 866 867 /** 868 * @see CaptureRequest#CONTROL_SCENE_MODE 869 */ 870 public static final int CONTROL_SCENE_MODE_CANDLELIGHT = 15; 871 872 /** 873 * @see CaptureRequest#CONTROL_SCENE_MODE 874 */ 875 public static final int CONTROL_SCENE_MODE_BARCODE = 16; 876 877 // 878 // Enumeration values for CaptureRequest#EDGE_MODE 879 // 880 881 /** 882 * <p>No edge enhancement is applied</p> 883 * @see CaptureRequest#EDGE_MODE 884 */ 885 public static final int EDGE_MODE_OFF = 0; 886 887 /** 888 * <p>Must not slow down frame rate relative to sensor 889 * output</p> 890 * @see CaptureRequest#EDGE_MODE 891 */ 892 public static final int EDGE_MODE_FAST = 1; 893 894 /** 895 * <p>Frame rate may be reduced by high 896 * quality</p> 897 * @see CaptureRequest#EDGE_MODE 898 */ 899 public static final int EDGE_MODE_HIGH_QUALITY = 2; 900 901 // 902 // Enumeration values for CaptureRequest#FLASH_MODE 903 // 904 905 /** 906 * <p>Do not fire the flash for this capture.</p> 907 * @see CaptureRequest#FLASH_MODE 908 */ 909 public static final int FLASH_MODE_OFF = 0; 910 911 /** 912 * <p>If the flash is available and charged, fire flash 913 * for this capture based on android.flash.firingPower and 914 * android.flash.firingTime.</p> 915 * @see CaptureRequest#FLASH_MODE 916 */ 917 public static final int FLASH_MODE_SINGLE = 1; 918 919 /** 920 * <p>Transition flash to continuously on.</p> 921 * @see CaptureRequest#FLASH_MODE 922 */ 923 public static final int FLASH_MODE_TORCH = 2; 924 925 // 926 // Enumeration values for CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 927 // 928 929 /** 930 * <p>Optical stabilization is unavailable.</p> 931 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 932 */ 933 public static final int LENS_OPTICAL_STABILIZATION_MODE_OFF = 0; 934 935 /** 936 * <p>Optical stabilization is enabled.</p> 937 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 938 */ 939 public static final int LENS_OPTICAL_STABILIZATION_MODE_ON = 1; 940 941 // 942 // Enumeration values for CaptureRequest#NOISE_REDUCTION_MODE 943 // 944 945 /** 946 * <p>No noise reduction is applied</p> 947 * @see CaptureRequest#NOISE_REDUCTION_MODE 948 */ 949 public static final int NOISE_REDUCTION_MODE_OFF = 0; 950 951 /** 952 * <p>Must not slow down frame rate relative to sensor 953 * output</p> 954 * @see CaptureRequest#NOISE_REDUCTION_MODE 955 */ 956 public static final int NOISE_REDUCTION_MODE_FAST = 1; 957 958 /** 959 * <p>May slow down frame rate to provide highest 960 * quality</p> 961 * @see CaptureRequest#NOISE_REDUCTION_MODE 962 */ 963 public static final int NOISE_REDUCTION_MODE_HIGH_QUALITY = 2; 964 965 // 966 // Enumeration values for CaptureRequest#SHADING_MODE 967 // 968 969 /** 970 * <p>No lens shading correction is applied</p> 971 * @see CaptureRequest#SHADING_MODE 972 * @hide 973 */ 974 public static final int SHADING_MODE_OFF = 0; 975 976 /** 977 * <p>Must not slow down frame rate relative to sensor raw output</p> 978 * @see CaptureRequest#SHADING_MODE 979 * @hide 980 */ 981 public static final int SHADING_MODE_FAST = 1; 982 983 /** 984 * <p>Frame rate may be reduced by high quality</p> 985 * @see CaptureRequest#SHADING_MODE 986 * @hide 987 */ 988 public static final int SHADING_MODE_HIGH_QUALITY = 2; 989 990 // 991 // Enumeration values for CaptureRequest#STATISTICS_FACE_DETECT_MODE 992 // 993 994 /** 995 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 996 */ 997 public static final int STATISTICS_FACE_DETECT_MODE_OFF = 0; 998 999 /** 1000 * <p>Optional Return rectangle and confidence 1001 * only</p> 1002 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1003 */ 1004 public static final int STATISTICS_FACE_DETECT_MODE_SIMPLE = 1; 1005 1006 /** 1007 * <p>Optional Return all face 1008 * metadata</p> 1009 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1010 */ 1011 public static final int STATISTICS_FACE_DETECT_MODE_FULL = 2; 1012 1013 // 1014 // Enumeration values for CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1015 // 1016 1017 /** 1018 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1019 */ 1020 public static final int STATISTICS_LENS_SHADING_MAP_MODE_OFF = 0; 1021 1022 /** 1023 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1024 */ 1025 public static final int STATISTICS_LENS_SHADING_MAP_MODE_ON = 1; 1026 1027 // 1028 // Enumeration values for CaptureRequest#TONEMAP_MODE 1029 // 1030 1031 /** 1032 * <p>Use the tone mapping curve specified in 1033 * android.tonemap.curve</p> 1034 * @see CaptureRequest#TONEMAP_MODE 1035 */ 1036 public static final int TONEMAP_MODE_CONTRAST_CURVE = 0; 1037 1038 /** 1039 * <p>Must not slow down frame rate relative to raw 1040 * bayer output</p> 1041 * @see CaptureRequest#TONEMAP_MODE 1042 */ 1043 public static final int TONEMAP_MODE_FAST = 1; 1044 1045 /** 1046 * <p>Frame rate may be reduced by high 1047 * quality</p> 1048 * @see CaptureRequest#TONEMAP_MODE 1049 */ 1050 public static final int TONEMAP_MODE_HIGH_QUALITY = 2; 1051 1052 // 1053 // Enumeration values for CaptureResult#CONTROL_AE_STATE 1054 // 1055 1056 /** 1057 * <p>AE is off or recently reset. When a camera device is opened, it starts in 1058 * this state.</p> 1059 * @see CaptureResult#CONTROL_AE_STATE 1060 */ 1061 public static final int CONTROL_AE_STATE_INACTIVE = 0; 1062 1063 /** 1064 * <p>AE doesn't yet have a good set of control values 1065 * for the current scene.</p> 1066 * @see CaptureResult#CONTROL_AE_STATE 1067 */ 1068 public static final int CONTROL_AE_STATE_SEARCHING = 1; 1069 1070 /** 1071 * <p>AE has a good set of control values for the 1072 * current scene.</p> 1073 * @see CaptureResult#CONTROL_AE_STATE 1074 */ 1075 public static final int CONTROL_AE_STATE_CONVERGED = 2; 1076 1077 /** 1078 * <p>AE has been locked.</p> 1079 * @see CaptureResult#CONTROL_AE_STATE 1080 */ 1081 public static final int CONTROL_AE_STATE_LOCKED = 3; 1082 1083 /** 1084 * <p>AE has a good set of control values, but flash 1085 * needs to be fired for good quality still 1086 * capture.</p> 1087 * @see CaptureResult#CONTROL_AE_STATE 1088 */ 1089 public static final int CONTROL_AE_STATE_FLASH_REQUIRED = 4; 1090 1091 /** 1092 * <p>AE has been asked to do a precapture sequence 1093 * (through the {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger} START), 1094 * and is currently executing it. Once PRECAPTURE 1095 * completes, AE will transition to CONVERGED or 1096 * FLASH_REQUIRED as appropriate.</p> 1097 * 1098 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 1099 * @see CaptureResult#CONTROL_AE_STATE 1100 */ 1101 public static final int CONTROL_AE_STATE_PRECAPTURE = 5; 1102 1103 // 1104 // Enumeration values for CaptureResult#CONTROL_AF_STATE 1105 // 1106 1107 /** 1108 * <p>AF off or has not yet tried to scan/been asked 1109 * to scan. When a camera device is opened, it starts in 1110 * this state.</p> 1111 * @see CaptureResult#CONTROL_AF_STATE 1112 */ 1113 public static final int CONTROL_AF_STATE_INACTIVE = 0; 1114 1115 /** 1116 * <p>if CONTINUOUS_* modes are supported. AF is 1117 * currently doing an AF scan initiated by a continuous 1118 * autofocus mode</p> 1119 * @see CaptureResult#CONTROL_AF_STATE 1120 */ 1121 public static final int CONTROL_AF_STATE_PASSIVE_SCAN = 1; 1122 1123 /** 1124 * <p>if CONTINUOUS_* modes are supported. AF currently 1125 * believes it is in focus, but may restart scanning at 1126 * any time.</p> 1127 * @see CaptureResult#CONTROL_AF_STATE 1128 */ 1129 public static final int CONTROL_AF_STATE_PASSIVE_FOCUSED = 2; 1130 1131 /** 1132 * <p>if AUTO or MACRO modes are supported. AF is doing 1133 * an AF scan because it was triggered by AF 1134 * trigger</p> 1135 * @see CaptureResult#CONTROL_AF_STATE 1136 */ 1137 public static final int CONTROL_AF_STATE_ACTIVE_SCAN = 3; 1138 1139 /** 1140 * <p>if any AF mode besides OFF is supported. AF 1141 * believes it is focused correctly and is 1142 * locked</p> 1143 * @see CaptureResult#CONTROL_AF_STATE 1144 */ 1145 public static final int CONTROL_AF_STATE_FOCUSED_LOCKED = 4; 1146 1147 /** 1148 * <p>if any AF mode besides OFF is supported. AF has 1149 * failed to focus successfully and is 1150 * locked</p> 1151 * @see CaptureResult#CONTROL_AF_STATE 1152 */ 1153 public static final int CONTROL_AF_STATE_NOT_FOCUSED_LOCKED = 5; 1154 1155 /** 1156 * <p>if CONTINUOUS_* modes are supported. AF finished a 1157 * passive scan without finding focus, and may restart 1158 * scanning at any time.</p> 1159 * @see CaptureResult#CONTROL_AF_STATE 1160 */ 1161 public static final int CONTROL_AF_STATE_PASSIVE_UNFOCUSED = 6; 1162 1163 // 1164 // Enumeration values for CaptureResult#CONTROL_AWB_STATE 1165 // 1166 1167 /** 1168 * <p>AWB is not in auto mode. When a camera device is opened, it 1169 * starts in this state.</p> 1170 * @see CaptureResult#CONTROL_AWB_STATE 1171 */ 1172 public static final int CONTROL_AWB_STATE_INACTIVE = 0; 1173 1174 /** 1175 * <p>AWB doesn't yet have a good set of control 1176 * values for the current scene.</p> 1177 * @see CaptureResult#CONTROL_AWB_STATE 1178 */ 1179 public static final int CONTROL_AWB_STATE_SEARCHING = 1; 1180 1181 /** 1182 * <p>AWB has a good set of control values for the 1183 * current scene.</p> 1184 * @see CaptureResult#CONTROL_AWB_STATE 1185 */ 1186 public static final int CONTROL_AWB_STATE_CONVERGED = 2; 1187 1188 /** 1189 * <p>AWB has been locked.</p> 1190 * @see CaptureResult#CONTROL_AWB_STATE 1191 */ 1192 public static final int CONTROL_AWB_STATE_LOCKED = 3; 1193 1194 // 1195 // Enumeration values for CaptureResult#FLASH_STATE 1196 // 1197 1198 /** 1199 * <p>No flash on camera</p> 1200 * @see CaptureResult#FLASH_STATE 1201 */ 1202 public static final int FLASH_STATE_UNAVAILABLE = 0; 1203 1204 /** 1205 * <p>if android.flash.available is true Flash is 1206 * charging and cannot be fired</p> 1207 * @see CaptureResult#FLASH_STATE 1208 */ 1209 public static final int FLASH_STATE_CHARGING = 1; 1210 1211 /** 1212 * <p>if android.flash.available is true Flash is 1213 * ready to fire</p> 1214 * @see CaptureResult#FLASH_STATE 1215 */ 1216 public static final int FLASH_STATE_READY = 2; 1217 1218 /** 1219 * <p>if android.flash.available is true Flash fired 1220 * for this capture</p> 1221 * @see CaptureResult#FLASH_STATE 1222 */ 1223 public static final int FLASH_STATE_FIRED = 3; 1224 1225 // 1226 // Enumeration values for CaptureResult#LENS_STATE 1227 // 1228 1229 /** 1230 * @see CaptureResult#LENS_STATE 1231 */ 1232 public static final int LENS_STATE_STATIONARY = 0; 1233 1234 /** 1235 * @see CaptureResult#LENS_STATE 1236 */ 1237 public static final int LENS_STATE_MOVING = 1; 1238 1239 // 1240 // Enumeration values for CaptureResult#STATISTICS_SCENE_FLICKER 1241 // 1242 1243 /** 1244 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1245 */ 1246 public static final int STATISTICS_SCENE_FLICKER_NONE = 0; 1247 1248 /** 1249 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1250 */ 1251 public static final int STATISTICS_SCENE_FLICKER_50HZ = 1; 1252 1253 /** 1254 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1255 */ 1256 public static final int STATISTICS_SCENE_FLICKER_60HZ = 2; 1257 1258 /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 1259 * End generated code 1260 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/ 1261 1262} 1263