CameraMetadata.java revision e0060930cbff1af0486466e03605e6e8ee525302
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 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 931 */ 932 public static final int LENS_OPTICAL_STABILIZATION_MODE_OFF = 0; 933 934 /** 935 * @see CaptureRequest#LENS_OPTICAL_STABILIZATION_MODE 936 */ 937 public static final int LENS_OPTICAL_STABILIZATION_MODE_ON = 1; 938 939 // 940 // Enumeration values for CaptureRequest#NOISE_REDUCTION_MODE 941 // 942 943 /** 944 * <p>No noise reduction is applied</p> 945 * @see CaptureRequest#NOISE_REDUCTION_MODE 946 */ 947 public static final int NOISE_REDUCTION_MODE_OFF = 0; 948 949 /** 950 * <p>Must not slow down frame rate relative to sensor 951 * output</p> 952 * @see CaptureRequest#NOISE_REDUCTION_MODE 953 */ 954 public static final int NOISE_REDUCTION_MODE_FAST = 1; 955 956 /** 957 * <p>May slow down frame rate to provide highest 958 * quality</p> 959 * @see CaptureRequest#NOISE_REDUCTION_MODE 960 */ 961 public static final int NOISE_REDUCTION_MODE_HIGH_QUALITY = 2; 962 963 // 964 // Enumeration values for CaptureRequest#SHADING_MODE 965 // 966 967 /** 968 * <p>No lens shading correction is applied</p> 969 * @see CaptureRequest#SHADING_MODE 970 * @hide 971 */ 972 public static final int SHADING_MODE_OFF = 0; 973 974 /** 975 * <p>Must not slow down frame rate relative to sensor raw output</p> 976 * @see CaptureRequest#SHADING_MODE 977 * @hide 978 */ 979 public static final int SHADING_MODE_FAST = 1; 980 981 /** 982 * <p>Frame rate may be reduced by high quality</p> 983 * @see CaptureRequest#SHADING_MODE 984 * @hide 985 */ 986 public static final int SHADING_MODE_HIGH_QUALITY = 2; 987 988 // 989 // Enumeration values for CaptureRequest#STATISTICS_FACE_DETECT_MODE 990 // 991 992 /** 993 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 994 */ 995 public static final int STATISTICS_FACE_DETECT_MODE_OFF = 0; 996 997 /** 998 * <p>Optional Return rectangle and confidence 999 * only</p> 1000 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1001 */ 1002 public static final int STATISTICS_FACE_DETECT_MODE_SIMPLE = 1; 1003 1004 /** 1005 * <p>Optional Return all face 1006 * metadata</p> 1007 * @see CaptureRequest#STATISTICS_FACE_DETECT_MODE 1008 */ 1009 public static final int STATISTICS_FACE_DETECT_MODE_FULL = 2; 1010 1011 // 1012 // Enumeration values for CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1013 // 1014 1015 /** 1016 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1017 */ 1018 public static final int STATISTICS_LENS_SHADING_MAP_MODE_OFF = 0; 1019 1020 /** 1021 * @see CaptureRequest#STATISTICS_LENS_SHADING_MAP_MODE 1022 */ 1023 public static final int STATISTICS_LENS_SHADING_MAP_MODE_ON = 1; 1024 1025 // 1026 // Enumeration values for CaptureRequest#TONEMAP_MODE 1027 // 1028 1029 /** 1030 * <p>Use the tone mapping curve specified in 1031 * android.tonemap.curve.</p> 1032 * <p>All color enhancement and tonemapping must be disabled, except 1033 * for applying the tonemapping curve specified by 1034 * {@link CaptureRequest#TONEMAP_CURVE_RED android.tonemap.curveRed}, {@link CaptureRequest#TONEMAP_CURVE_BLUE android.tonemap.curveBlue}, or 1035 * {@link CaptureRequest#TONEMAP_CURVE_GREEN android.tonemap.curveGreen}.</p> 1036 * <p>Must not slow down frame rate relative to raw 1037 * sensor output.</p> 1038 * 1039 * @see CaptureRequest#TONEMAP_CURVE_BLUE 1040 * @see CaptureRequest#TONEMAP_CURVE_GREEN 1041 * @see CaptureRequest#TONEMAP_CURVE_RED 1042 * @see CaptureRequest#TONEMAP_MODE 1043 */ 1044 public static final int TONEMAP_MODE_CONTRAST_CURVE = 0; 1045 1046 /** 1047 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1048 * <p>Should not slow down frame rate relative to raw sensor output.</p> 1049 * @see CaptureRequest#TONEMAP_MODE 1050 */ 1051 public static final int TONEMAP_MODE_FAST = 1; 1052 1053 /** 1054 * <p>Advanced gamma mapping and color enhancement may be applied.</p> 1055 * <p>May slow down frame rate relative to raw sensor output.</p> 1056 * @see CaptureRequest#TONEMAP_MODE 1057 */ 1058 public static final int TONEMAP_MODE_HIGH_QUALITY = 2; 1059 1060 // 1061 // Enumeration values for CaptureResult#CONTROL_AE_STATE 1062 // 1063 1064 /** 1065 * <p>AE is off or recently reset. When a camera device is opened, it starts in 1066 * this state.</p> 1067 * @see CaptureResult#CONTROL_AE_STATE 1068 */ 1069 public static final int CONTROL_AE_STATE_INACTIVE = 0; 1070 1071 /** 1072 * <p>AE doesn't yet have a good set of control values 1073 * for the current scene.</p> 1074 * @see CaptureResult#CONTROL_AE_STATE 1075 */ 1076 public static final int CONTROL_AE_STATE_SEARCHING = 1; 1077 1078 /** 1079 * <p>AE has a good set of control values for the 1080 * current scene.</p> 1081 * @see CaptureResult#CONTROL_AE_STATE 1082 */ 1083 public static final int CONTROL_AE_STATE_CONVERGED = 2; 1084 1085 /** 1086 * <p>AE has been locked.</p> 1087 * @see CaptureResult#CONTROL_AE_STATE 1088 */ 1089 public static final int CONTROL_AE_STATE_LOCKED = 3; 1090 1091 /** 1092 * <p>AE has a good set of control values, but flash 1093 * needs to be fired for good quality still 1094 * capture.</p> 1095 * @see CaptureResult#CONTROL_AE_STATE 1096 */ 1097 public static final int CONTROL_AE_STATE_FLASH_REQUIRED = 4; 1098 1099 /** 1100 * <p>AE has been asked to do a precapture sequence 1101 * (through the {@link CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER android.control.aePrecaptureTrigger} START), 1102 * and is currently executing it. Once PRECAPTURE 1103 * completes, AE will transition to CONVERGED or 1104 * FLASH_REQUIRED as appropriate.</p> 1105 * 1106 * @see CaptureRequest#CONTROL_AE_PRECAPTURE_TRIGGER 1107 * @see CaptureResult#CONTROL_AE_STATE 1108 */ 1109 public static final int CONTROL_AE_STATE_PRECAPTURE = 5; 1110 1111 // 1112 // Enumeration values for CaptureResult#CONTROL_AF_STATE 1113 // 1114 1115 /** 1116 * <p>AF off or has not yet tried to scan/been asked 1117 * to scan. When a camera device is opened, it starts in 1118 * this state.</p> 1119 * @see CaptureResult#CONTROL_AF_STATE 1120 */ 1121 public static final int CONTROL_AF_STATE_INACTIVE = 0; 1122 1123 /** 1124 * <p>if CONTINUOUS_* modes are supported. AF is 1125 * currently doing an AF scan initiated by a continuous 1126 * autofocus mode</p> 1127 * @see CaptureResult#CONTROL_AF_STATE 1128 */ 1129 public static final int CONTROL_AF_STATE_PASSIVE_SCAN = 1; 1130 1131 /** 1132 * <p>if CONTINUOUS_* modes are supported. AF currently 1133 * believes it is in focus, but may restart scanning at 1134 * any time.</p> 1135 * @see CaptureResult#CONTROL_AF_STATE 1136 */ 1137 public static final int CONTROL_AF_STATE_PASSIVE_FOCUSED = 2; 1138 1139 /** 1140 * <p>if AUTO or MACRO modes are supported. AF is doing 1141 * an AF scan because it was triggered by AF 1142 * trigger</p> 1143 * @see CaptureResult#CONTROL_AF_STATE 1144 */ 1145 public static final int CONTROL_AF_STATE_ACTIVE_SCAN = 3; 1146 1147 /** 1148 * <p>if any AF mode besides OFF is supported. AF 1149 * believes it is focused correctly and is 1150 * locked</p> 1151 * @see CaptureResult#CONTROL_AF_STATE 1152 */ 1153 public static final int CONTROL_AF_STATE_FOCUSED_LOCKED = 4; 1154 1155 /** 1156 * <p>if any AF mode besides OFF is supported. AF has 1157 * failed to focus successfully and is 1158 * locked</p> 1159 * @see CaptureResult#CONTROL_AF_STATE 1160 */ 1161 public static final int CONTROL_AF_STATE_NOT_FOCUSED_LOCKED = 5; 1162 1163 /** 1164 * <p>if CONTINUOUS_* modes are supported. AF finished a 1165 * passive scan without finding focus, and may restart 1166 * scanning at any time.</p> 1167 * @see CaptureResult#CONTROL_AF_STATE 1168 */ 1169 public static final int CONTROL_AF_STATE_PASSIVE_UNFOCUSED = 6; 1170 1171 // 1172 // Enumeration values for CaptureResult#CONTROL_AWB_STATE 1173 // 1174 1175 /** 1176 * <p>AWB is not in auto mode. When a camera device is opened, it 1177 * starts in this state.</p> 1178 * @see CaptureResult#CONTROL_AWB_STATE 1179 */ 1180 public static final int CONTROL_AWB_STATE_INACTIVE = 0; 1181 1182 /** 1183 * <p>AWB doesn't yet have a good set of control 1184 * values for the current scene.</p> 1185 * @see CaptureResult#CONTROL_AWB_STATE 1186 */ 1187 public static final int CONTROL_AWB_STATE_SEARCHING = 1; 1188 1189 /** 1190 * <p>AWB has a good set of control values for the 1191 * current scene.</p> 1192 * @see CaptureResult#CONTROL_AWB_STATE 1193 */ 1194 public static final int CONTROL_AWB_STATE_CONVERGED = 2; 1195 1196 /** 1197 * <p>AWB has been locked.</p> 1198 * @see CaptureResult#CONTROL_AWB_STATE 1199 */ 1200 public static final int CONTROL_AWB_STATE_LOCKED = 3; 1201 1202 // 1203 // Enumeration values for CaptureResult#FLASH_STATE 1204 // 1205 1206 /** 1207 * <p>No flash on camera</p> 1208 * @see CaptureResult#FLASH_STATE 1209 */ 1210 public static final int FLASH_STATE_UNAVAILABLE = 0; 1211 1212 /** 1213 * <p>if android.flash.available is true Flash is 1214 * charging and cannot be fired</p> 1215 * @see CaptureResult#FLASH_STATE 1216 */ 1217 public static final int FLASH_STATE_CHARGING = 1; 1218 1219 /** 1220 * <p>if android.flash.available is true Flash is 1221 * ready to fire</p> 1222 * @see CaptureResult#FLASH_STATE 1223 */ 1224 public static final int FLASH_STATE_READY = 2; 1225 1226 /** 1227 * <p>if android.flash.available is true Flash fired 1228 * for this capture</p> 1229 * @see CaptureResult#FLASH_STATE 1230 */ 1231 public static final int FLASH_STATE_FIRED = 3; 1232 1233 // 1234 // Enumeration values for CaptureResult#LENS_STATE 1235 // 1236 1237 /** 1238 * @see CaptureResult#LENS_STATE 1239 */ 1240 public static final int LENS_STATE_STATIONARY = 0; 1241 1242 /** 1243 * @see CaptureResult#LENS_STATE 1244 */ 1245 public static final int LENS_STATE_MOVING = 1; 1246 1247 // 1248 // Enumeration values for CaptureResult#STATISTICS_SCENE_FLICKER 1249 // 1250 1251 /** 1252 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1253 */ 1254 public static final int STATISTICS_SCENE_FLICKER_NONE = 0; 1255 1256 /** 1257 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1258 */ 1259 public static final int STATISTICS_SCENE_FLICKER_50HZ = 1; 1260 1261 /** 1262 * @see CaptureResult#STATISTICS_SCENE_FLICKER 1263 */ 1264 public static final int STATISTICS_SCENE_FLICKER_60HZ = 2; 1265 1266 /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 1267 * End generated code 1268 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/ 1269 1270} 1271