CaptureResult.java revision 2807936f5dfdeff25e9ace3482100511a69dcf13
1/* 2 * Copyright (C) 2012 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 21/** 22 * <p>The results of a single image capture from the image sensor.</p> 23 * 24 * <p>Contains the final configuration for the capture hardware (sensor, lens, 25 * flash), the processing pipeline, the control algorithms, and the output 26 * buffers.</p> 27 * 28 * <p>CaptureResults are produced by a {@link CameraDevice} after processing a 29 * {@link CaptureRequest}. All properties listed for capture requests can also 30 * be queried on the capture result, to determine the final values used for 31 * capture. The result also includes additional metadata about the state of the 32 * camera device during the capture.</p> 33 * 34 */ 35public final class CaptureResult extends CameraMetadata { 36 37 private final CameraMetadataNative mResults; 38 private final CaptureRequest mRequest; 39 private final int mSequenceId; 40 41 /** 42 * Takes ownership of the passed-in properties object 43 * @hide 44 */ 45 public CaptureResult(CameraMetadataNative results, CaptureRequest parent, int sequenceId) { 46 if (results == null) { 47 throw new IllegalArgumentException("results was null"); 48 } 49 50 if (parent == null) { 51 throw new IllegalArgumentException("parent was null"); 52 } 53 54 mResults = results; 55 mRequest = parent; 56 mSequenceId = sequenceId; 57 } 58 59 @Override 60 public <T> T get(Key<T> key) { 61 return mResults.get(key); 62 } 63 64 /** 65 * Get the request associated with this result. 66 * 67 * <p>Whenever a request is successfully captured, with 68 * {@link CameraDevice.CaptureListener#onCaptureCompleted}, 69 * the {@code result}'s {@code getRequest()} will return that {@code request}. 70 * </p> 71 * 72 * <p>In particular, 73 * <code><pre>cameraDevice.capture(someRequest, new CaptureListener() { 74 * {@literal @}Override 75 * void onCaptureCompleted(CaptureRequest myRequest, CaptureResult myResult) { 76 * assert(myResult.getRequest.equals(myRequest) == true); 77 * } 78 * }; 79 * </code></pre> 80 * </p> 81 * 82 * @return The request associated with this result. Never {@code null}. 83 */ 84 public CaptureRequest getRequest() { 85 return mRequest; 86 } 87 88 /** 89 * Get the frame number associated with this result. 90 * 91 * <p>Whenever a request has been processed, regardless of failure or success, 92 * it gets a unique frame number assigned to its future result/failure.</p> 93 * 94 * <p>This value monotonically increments, starting with 0, 95 * for every new result or failure; and the scope is the lifetime of the 96 * {@link CameraDevice}.</p> 97 * 98 * @return int frame number 99 */ 100 public int getFrameNumber() { 101 return get(REQUEST_FRAME_COUNT); 102 } 103 104 /** 105 * The sequence ID for this failure that was returned by the 106 * {@link CameraDevice#capture} family of functions. 107 * 108 * <p>The sequence ID is a unique monotonically increasing value starting from 0, 109 * incremented every time a new group of requests is submitted to the CameraDevice.</p> 110 * 111 * @return int The ID for the sequence of requests that this capture result is a part of 112 * 113 * @see CameraDevice.CaptureListener#onCaptureSequenceCompleted 114 */ 115 public int getSequenceId() { 116 return mSequenceId; 117 } 118 119 /*@O~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 120 * The key entries below this point are generated from metadata 121 * definitions in /system/media/camera/docs. Do not modify by hand or 122 * modify the comment blocks at the start or end. 123 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~*/ 124 125 /** 126 * <p>A color transform matrix to use to transform 127 * from sensor RGB color space to output linear sRGB color space</p> 128 * <p>This matrix is either set by HAL when the request 129 * android.colorCorrection.mode is not TRANSFORM_MATRIX, or 130 * directly by the application in the request when the 131 * android.colorCorrection.mode is TRANSFORM_MATRIX.</p> 132 * <p>In the latter case, the HAL may round the matrix to account 133 * for precision issues; the final rounded matrix should be 134 * reported back in this matrix result metadata.</p> 135 */ 136 public static final Key<Rational[]> COLOR_CORRECTION_TRANSFORM = 137 new Key<Rational[]>("android.colorCorrection.transform", Rational[].class); 138 139 /** 140 * <p>Gains applying to Bayer color channels for 141 * white-balance</p> 142 * <p>The 4-channel white-balance gains are defined in 143 * the order of [R G_even G_odd B], where G_even is the gain 144 * for green pixels on even rows of the output, and G_odd 145 * is the gain for greenpixels on the odd rows. if a HAL 146 * does not support a separate gain for even/odd green channels, 147 * it should use the G_even value,and write G_odd equal to 148 * G_even in the output result metadata.</p> 149 * <p>This array is either set by HAL when the request 150 * android.colorCorrection.mode is not TRANSFORM_MATRIX, or 151 * directly by the application in the request when the 152 * android.colorCorrection.mode is TRANSFORM_MATRIX.</p> 153 * <p>The ouput should be the gains actually applied by the HAL to 154 * the current frame.</p> 155 */ 156 public static final Key<float[]> COLOR_CORRECTION_GAINS = 157 new Key<float[]>("android.colorCorrection.gains", float[].class); 158 159 /** 160 * <p>The ID sent with the latest 161 * CAMERA2_TRIGGER_PRECAPTURE_METERING call</p> 162 * <p>Must be 0 if no 163 * CAMERA2_TRIGGER_PRECAPTURE_METERING trigger received yet 164 * by HAL. Always updated even if AE algorithm ignores the 165 * trigger</p> 166 * 167 * @hide 168 */ 169 public static final Key<Integer> CONTROL_AE_PRECAPTURE_ID = 170 new Key<Integer>("android.control.aePrecaptureId", int.class); 171 172 /** 173 * <p>List of areas to use for 174 * metering</p> 175 * <p>Each area is a rectangle plus weight: xmin, ymin, 176 * xmax, ymax, weight. The rectangle is defined inclusive of the 177 * specified coordinates.</p> 178 * <p>The coordinate system is based on the active pixel array, 179 * with (0,0) being the top-left pixel in the active pixel array, and 180 * (android.sensor.info.activeArraySize.width - 1, 181 * android.sensor.info.activeArraySize.height - 1) being the 182 * bottom-right pixel in the active pixel array. The weight 183 * should be nonnegative.</p> 184 * <p>If all regions have 0 weight, then no specific metering area 185 * needs to be used by the HAL. If the metering region is 186 * outside the current android.scaler.cropRegion, the HAL 187 * should ignore the sections outside the region and output the 188 * used sections in the frame metadata</p> 189 */ 190 public static final Key<int[]> CONTROL_AE_REGIONS = 191 new Key<int[]>("android.control.aeRegions", int[].class); 192 193 /** 194 * <p>Current state of AE algorithm</p> 195 * <p>Whenever the AE algorithm state changes, a 196 * MSG_AUTOEXPOSURE notification must be send if a 197 * notification callback is registered.</p> 198 * @see #CONTROL_AE_STATE_INACTIVE 199 * @see #CONTROL_AE_STATE_SEARCHING 200 * @see #CONTROL_AE_STATE_CONVERGED 201 * @see #CONTROL_AE_STATE_LOCKED 202 * @see #CONTROL_AE_STATE_FLASH_REQUIRED 203 * @see #CONTROL_AE_STATE_PRECAPTURE 204 */ 205 public static final Key<Integer> CONTROL_AE_STATE = 206 new Key<Integer>("android.control.aeState", int.class); 207 208 /** 209 * <p>Whether AF is currently enabled, and what 210 * mode it is set to</p> 211 * <p>Only effective if android.control.mode = AUTO.</p> 212 * <p>If lens is controlled by HAL auto-focus algorithm, the HAL should 213 * report the current AF status in android.control.afState in 214 * result metadata.</p> 215 * @see #CONTROL_AF_MODE_OFF 216 * @see #CONTROL_AF_MODE_AUTO 217 * @see #CONTROL_AF_MODE_MACRO 218 * @see #CONTROL_AF_MODE_CONTINUOUS_VIDEO 219 * @see #CONTROL_AF_MODE_CONTINUOUS_PICTURE 220 * @see #CONTROL_AF_MODE_EDOF 221 */ 222 public static final Key<Integer> CONTROL_AF_MODE = 223 new Key<Integer>("android.control.afMode", int.class); 224 225 /** 226 * <p>List of areas to use for focus 227 * estimation</p> 228 * <p>Each area is a rectangle plus weight: xmin, ymin, 229 * xmax, ymax, weight. The rectangle is defined inclusive of the 230 * specified coordinates.</p> 231 * <p>The coordinate system is based on the active pixel array, 232 * with (0,0) being the top-left pixel in the active pixel array, and 233 * (android.sensor.info.activeArraySize.width - 1, 234 * android.sensor.info.activeArraySize.height - 1) being the 235 * bottom-right pixel in the active pixel array. The weight 236 * should be nonnegative.</p> 237 * <p>If all regions have 0 weight, then no specific focus area 238 * needs to be used by the HAL. If the focusing region is 239 * outside the current android.scaler.cropRegion, the HAL 240 * should ignore the sections outside the region and output the 241 * used sections in the frame metadata</p> 242 */ 243 public static final Key<int[]> CONTROL_AF_REGIONS = 244 new Key<int[]>("android.control.afRegions", int[].class); 245 246 /** 247 * <p>Current state of AF algorithm</p> 248 * <p>Whenever the AF algorithm state changes, a 249 * MSG_AUTOFOCUS notification must be send if a notification 250 * callback is registered.</p> 251 * @see #CONTROL_AF_STATE_INACTIVE 252 * @see #CONTROL_AF_STATE_PASSIVE_SCAN 253 * @see #CONTROL_AF_STATE_PASSIVE_FOCUSED 254 * @see #CONTROL_AF_STATE_ACTIVE_SCAN 255 * @see #CONTROL_AF_STATE_FOCUSED_LOCKED 256 * @see #CONTROL_AF_STATE_NOT_FOCUSED_LOCKED 257 * @see #CONTROL_AF_STATE_PASSIVE_UNFOCUSED 258 */ 259 public static final Key<Integer> CONTROL_AF_STATE = 260 new Key<Integer>("android.control.afState", int.class); 261 262 /** 263 * <p>The ID sent with the latest 264 * CAMERA2_TRIGGER_AUTOFOCUS call</p> 265 * <p>Must be 0 if no CAMERA2_TRIGGER_AUTOFOCUS trigger 266 * received yet by HAL. Always updated even if AF algorithm 267 * ignores the trigger</p> 268 * 269 * @hide 270 */ 271 public static final Key<Integer> CONTROL_AF_TRIGGER_ID = 272 new Key<Integer>("android.control.afTriggerId", int.class); 273 274 /** 275 * <p>Whether AWB is currently setting the color 276 * transform fields, and what its illumination target 277 * is</p> 278 * <p>[BC - AWB lock,AWB modes]</p> 279 * <p>Only effective if android.control.mode = AUTO.</p> 280 * @see #CONTROL_AWB_MODE_OFF 281 * @see #CONTROL_AWB_MODE_AUTO 282 * @see #CONTROL_AWB_MODE_INCANDESCENT 283 * @see #CONTROL_AWB_MODE_FLUORESCENT 284 * @see #CONTROL_AWB_MODE_WARM_FLUORESCENT 285 * @see #CONTROL_AWB_MODE_DAYLIGHT 286 * @see #CONTROL_AWB_MODE_CLOUDY_DAYLIGHT 287 * @see #CONTROL_AWB_MODE_TWILIGHT 288 * @see #CONTROL_AWB_MODE_SHADE 289 */ 290 public static final Key<Integer> CONTROL_AWB_MODE = 291 new Key<Integer>("android.control.awbMode", int.class); 292 293 /** 294 * <p>List of areas to use for illuminant 295 * estimation</p> 296 * <p>Only used in AUTO mode.</p> 297 * <p>Each area is a rectangle plus weight: xmin, ymin, 298 * xmax, ymax, weight. The rectangle is defined inclusive of the 299 * specified coordinates.</p> 300 * <p>The coordinate system is based on the active pixel array, 301 * with (0,0) being the top-left pixel in the active pixel array, and 302 * (android.sensor.info.activeArraySize.width - 1, 303 * android.sensor.info.activeArraySize.height - 1) being the 304 * bottom-right pixel in the active pixel array. The weight 305 * should be nonnegative.</p> 306 * <p>If all regions have 0 weight, then no specific metering area 307 * needs to be used by the HAL. If the metering region is 308 * outside the current android.scaler.cropRegion, the HAL 309 * should ignore the sections outside the region and output the 310 * used sections in the frame metadata</p> 311 */ 312 public static final Key<int[]> CONTROL_AWB_REGIONS = 313 new Key<int[]>("android.control.awbRegions", int[].class); 314 315 /** 316 * <p>Current state of AWB algorithm</p> 317 * <p>Whenever the AWB algorithm state changes, a 318 * MSG_AUTOWHITEBALANCE notification must be send if a 319 * notification callback is registered.</p> 320 * @see #CONTROL_AWB_STATE_INACTIVE 321 * @see #CONTROL_AWB_STATE_SEARCHING 322 * @see #CONTROL_AWB_STATE_CONVERGED 323 * @see #CONTROL_AWB_STATE_LOCKED 324 */ 325 public static final Key<Integer> CONTROL_AWB_STATE = 326 new Key<Integer>("android.control.awbState", int.class); 327 328 /** 329 * <p>Overall mode of 3A control 330 * routines</p> 331 * <p>High-level 3A control. When set to OFF, all 3A control 332 * by the HAL is disabled. The application must set the fields for 333 * capture parameters itself.</p> 334 * <p>When set to AUTO, the individual algorithm controls in 335 * android.control.* are in effect, such as android.control.afMode.</p> 336 * <p>When set to USE_SCENE_MODE, the individual controls in 337 * android.control.* are mostly disabled, and the HAL implements 338 * one of the scene mode settings (such as ACTION, SUNSET, or PARTY) 339 * as it wishes. The HAL scene mode 3A settings are provided by 340 * android.control.sceneModeOverrides.</p> 341 * @see #CONTROL_MODE_OFF 342 * @see #CONTROL_MODE_AUTO 343 * @see #CONTROL_MODE_USE_SCENE_MODE 344 */ 345 public static final Key<Integer> CONTROL_MODE = 346 new Key<Integer>("android.control.mode", int.class); 347 348 /** 349 * <p>Operation mode for edge 350 * enhancement</p> 351 * <p>Edge/sharpness/detail enhancement. OFF means no 352 * enhancement will be applied by the HAL.</p> 353 * <p>FAST/HIGH_QUALITY both mean HAL-determined enhancement 354 * will be applied. HIGH_QUALITY mode indicates that the 355 * HAL should use the highest-quality enhancement algorithms, 356 * even if it slows down capture rate. FAST means the HAL should 357 * not slow down capture rate when applying edge enhancement.</p> 358 * @see #EDGE_MODE_OFF 359 * @see #EDGE_MODE_FAST 360 * @see #EDGE_MODE_HIGH_QUALITY 361 */ 362 public static final Key<Integer> EDGE_MODE = 363 new Key<Integer>("android.edge.mode", int.class); 364 365 /** 366 * <p>Select flash operation mode</p> 367 * @see #FLASH_MODE_OFF 368 * @see #FLASH_MODE_SINGLE 369 * @see #FLASH_MODE_TORCH 370 */ 371 public static final Key<Integer> FLASH_MODE = 372 new Key<Integer>("android.flash.mode", int.class); 373 374 /** 375 * <p>Current state of the flash 376 * unit</p> 377 * @see #FLASH_STATE_UNAVAILABLE 378 * @see #FLASH_STATE_CHARGING 379 * @see #FLASH_STATE_READY 380 * @see #FLASH_STATE_FIRED 381 */ 382 public static final Key<Integer> FLASH_STATE = 383 new Key<Integer>("android.flash.state", int.class); 384 385 /** 386 * <p>GPS coordinates to include in output JPEG 387 * EXIF</p> 388 */ 389 public static final Key<double[]> JPEG_GPS_COORDINATES = 390 new Key<double[]>("android.jpeg.gpsCoordinates", double[].class); 391 392 /** 393 * <p>32 characters describing GPS algorithm to 394 * include in EXIF</p> 395 */ 396 public static final Key<String> JPEG_GPS_PROCESSING_METHOD = 397 new Key<String>("android.jpeg.gpsProcessingMethod", String.class); 398 399 /** 400 * <p>Time GPS fix was made to include in 401 * EXIF</p> 402 */ 403 public static final Key<Long> JPEG_GPS_TIMESTAMP = 404 new Key<Long>("android.jpeg.gpsTimestamp", long.class); 405 406 /** 407 * <p>Orientation of JPEG image to 408 * write</p> 409 */ 410 public static final Key<Integer> JPEG_ORIENTATION = 411 new Key<Integer>("android.jpeg.orientation", int.class); 412 413 /** 414 * <p>Compression quality of the final JPEG 415 * image</p> 416 * <p>85-95 is typical usage range</p> 417 */ 418 public static final Key<Byte> JPEG_QUALITY = 419 new Key<Byte>("android.jpeg.quality", byte.class); 420 421 /** 422 * <p>Compression quality of JPEG 423 * thumbnail</p> 424 */ 425 public static final Key<Byte> JPEG_THUMBNAIL_QUALITY = 426 new Key<Byte>("android.jpeg.thumbnailQuality", byte.class); 427 428 /** 429 * <p>Resolution of embedded JPEG 430 * thumbnail</p> 431 */ 432 public static final Key<android.hardware.camera2.Size> JPEG_THUMBNAIL_SIZE = 433 new Key<android.hardware.camera2.Size>("android.jpeg.thumbnailSize", android.hardware.camera2.Size.class); 434 435 /** 436 * <p>Size of the lens aperture</p> 437 * <p>Will not be supported on most devices. Can only 438 * pick from supported list</p> 439 */ 440 public static final Key<Float> LENS_APERTURE = 441 new Key<Float>("android.lens.aperture", float.class); 442 443 /** 444 * <p>State of lens neutral density 445 * filter(s)</p> 446 * <p>Will not be supported on most devices. Can only 447 * pick from supported list</p> 448 */ 449 public static final Key<Float> LENS_FILTER_DENSITY = 450 new Key<Float>("android.lens.filterDensity", float.class); 451 452 /** 453 * <p>Lens optical zoom setting</p> 454 * <p>Will not be supported on most devices.</p> 455 */ 456 public static final Key<Float> LENS_FOCAL_LENGTH = 457 new Key<Float>("android.lens.focalLength", float.class); 458 459 /** 460 * <p>Distance to plane of sharpest focus, 461 * measured from frontmost surface of the lens</p> 462 * <p>Should be zero for fixed-focus cameras</p> 463 */ 464 public static final Key<Float> LENS_FOCUS_DISTANCE = 465 new Key<Float>("android.lens.focusDistance", float.class); 466 467 /** 468 * <p>The range of scene distances that are in 469 * sharp focus (depth of field)</p> 470 * <p>If variable focus not supported, can still report 471 * fixed depth of field range</p> 472 */ 473 public static final Key<float[]> LENS_FOCUS_RANGE = 474 new Key<float[]>("android.lens.focusRange", float[].class); 475 476 /** 477 * <p>Whether optical image stabilization is 478 * enabled.</p> 479 * <p>Will not be supported on most devices.</p> 480 * @see #LENS_OPTICAL_STABILIZATION_MODE_OFF 481 * @see #LENS_OPTICAL_STABILIZATION_MODE_ON 482 */ 483 public static final Key<Integer> LENS_OPTICAL_STABILIZATION_MODE = 484 new Key<Integer>("android.lens.opticalStabilizationMode", int.class); 485 486 /** 487 * <p>Current lens status</p> 488 * @see #LENS_STATE_STATIONARY 489 * @see #LENS_STATE_MOVING 490 */ 491 public static final Key<Integer> LENS_STATE = 492 new Key<Integer>("android.lens.state", int.class); 493 494 /** 495 * <p>Mode of operation for the noise reduction 496 * algorithm</p> 497 * <p>Noise filtering control. OFF means no noise reduction 498 * will be applied by the HAL.</p> 499 * <p>FAST/HIGH_QUALITY both mean HAL-determined noise filtering 500 * will be applied. HIGH_QUALITY mode indicates that the HAL 501 * should use the highest-quality noise filtering algorithms, 502 * even if it slows down capture rate. FAST means the HAL should not 503 * slow down capture rate when applying noise filtering.</p> 504 * @see #NOISE_REDUCTION_MODE_OFF 505 * @see #NOISE_REDUCTION_MODE_FAST 506 * @see #NOISE_REDUCTION_MODE_HIGH_QUALITY 507 */ 508 public static final Key<Integer> NOISE_REDUCTION_MODE = 509 new Key<Integer>("android.noiseReduction.mode", int.class); 510 511 /** 512 * <p>Whether a result given to the framework is the 513 * final one for the capture, or only a partial that contains a 514 * subset of the full set of dynamic metadata 515 * values.</p> 516 * <p>The entries in the result metadata buffers for a 517 * single capture may not overlap, except for this entry. The 518 * FINAL buffers must retain FIFO ordering relative to the 519 * requests that generate them, so the FINAL buffer for frame 3 must 520 * always be sent to the framework after the FINAL buffer for frame 2, and 521 * before the FINAL buffer for frame 4. PARTIAL buffers may be returned 522 * in any order relative to other frames, but all PARTIAL buffers for a given 523 * capture must arrive before the FINAL buffer for that capture. This entry may 524 * only be used by the HAL if quirks.usePartialResult is set to 1.</p> 525 * 526 * <b>Optional</b> - This value may be null on some devices. 527 * 528 * @hide 529 */ 530 public static final Key<Boolean> QUIRKS_PARTIAL_RESULT = 531 new Key<Boolean>("android.quirks.partialResult", boolean.class); 532 533 /** 534 * <p>A frame counter set by the framework. This value monotonically 535 * increases with every new result (that is, each new result has a unique 536 * frameCount value).</p> 537 * <p>Reset on release()</p> 538 */ 539 public static final Key<Integer> REQUEST_FRAME_COUNT = 540 new Key<Integer>("android.request.frameCount", int.class); 541 542 /** 543 * <p>An application-specified ID for the current 544 * request. Must be maintained unchanged in output 545 * frame</p> 546 * 547 * @hide 548 */ 549 public static final Key<Integer> REQUEST_ID = 550 new Key<Integer>("android.request.id", int.class); 551 552 /** 553 * <p>(x, y, width, height).</p> 554 * <p>A rectangle with the top-level corner of (x,y) and size 555 * (width, height). The region of the sensor that is used for 556 * output. Each stream must use this rectangle to produce its 557 * output, cropping to a smaller region if necessary to 558 * maintain the stream's aspect ratio.</p> 559 * <p>HAL2.x uses only (x, y, width)</p> 560 * <p>Any additional per-stream cropping must be done to 561 * maximize the final pixel area of the stream.</p> 562 * <p>For example, if the crop region is set to a 4:3 aspect 563 * ratio, then 4:3 streams should use the exact crop 564 * region. 16:9 streams should further crop vertically 565 * (letterbox).</p> 566 * <p>Conversely, if the crop region is set to a 16:9, then 4:3 567 * outputs should crop horizontally (pillarbox), and 16:9 568 * streams should match exactly. These additional crops must 569 * be centered within the crop region.</p> 570 * <p>The output streams must maintain square pixels at all 571 * times, no matter what the relative aspect ratios of the 572 * crop region and the stream are. Negative values for 573 * corner are allowed for raw output if full pixel array is 574 * larger than active pixel array. Width and height may be 575 * rounded to nearest larger supportable width, especially 576 * for raw output, where only a few fixed scales may be 577 * possible. The width and height of the crop region cannot 578 * be set to be smaller than floor( activeArraySize.width / 579 * android.scaler.maxDigitalZoom ) and floor( 580 * activeArraySize.height / android.scaler.maxDigitalZoom), 581 * respectively.</p> 582 */ 583 public static final Key<android.graphics.Rect> SCALER_CROP_REGION = 584 new Key<android.graphics.Rect>("android.scaler.cropRegion", android.graphics.Rect.class); 585 586 /** 587 * <p>Duration each pixel is exposed to 588 * light.</p> 589 * <p>If the sensor can't expose this exact duration, it should shorten the 590 * duration exposed to the nearest possible value (rather than expose longer).</p> 591 * <p>1/10000 - 30 sec range. No bulb mode</p> 592 */ 593 public static final Key<Long> SENSOR_EXPOSURE_TIME = 594 new Key<Long>("android.sensor.exposureTime", long.class); 595 596 /** 597 * <p>Duration from start of frame exposure to 598 * start of next frame exposure</p> 599 * <p>Exposure time has priority, so duration is set to 600 * max(duration, exposure time + overhead)</p> 601 */ 602 public static final Key<Long> SENSOR_FRAME_DURATION = 603 new Key<Long>("android.sensor.frameDuration", long.class); 604 605 /** 606 * <p>Gain applied to image data. Must be 607 * implemented through analog gain only if set to values 608 * below 'maximum analog sensitivity'.</p> 609 * <p>If the sensor can't apply this exact gain, it should lessen the 610 * gain to the nearest possible value (rather than gain more).</p> 611 * <p>ISO 12232:2006 REI method</p> 612 */ 613 public static final Key<Integer> SENSOR_SENSITIVITY = 614 new Key<Integer>("android.sensor.sensitivity", int.class); 615 616 /** 617 * <p>Time at start of exposure of first 618 * row</p> 619 * <p>Monotonic, should be synced to other timestamps in 620 * system</p> 621 */ 622 public static final Key<Long> SENSOR_TIMESTAMP = 623 new Key<Long>("android.sensor.timestamp", long.class); 624 625 /** 626 * <p>The temperature of the sensor, sampled at the time 627 * exposure began for this frame.</p> 628 * <p>The thermal diode being queried should be inside the sensor PCB, or 629 * somewhere close to it.</p> 630 * 631 * <b>Optional</b> - This value may be null on some devices. 632 * 633 * <b>{@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL_FULL HARDWARE_LEVEL_FULL}</b> - 634 * Present on all devices that report being FULL level hardware devices in the 635 * {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL HARDWARE_LEVEL} key. 636 */ 637 public static final Key<Float> SENSOR_TEMPERATURE = 638 new Key<Float>("android.sensor.temperature", float.class); 639 640 /** 641 * <p>State of the face detector 642 * unit</p> 643 * <p>Whether face detection is enabled, and whether it 644 * should output just the basic fields or the full set of 645 * fields. Value must be one of the 646 * android.statistics.info.availableFaceDetectModes.</p> 647 * @see #STATISTICS_FACE_DETECT_MODE_OFF 648 * @see #STATISTICS_FACE_DETECT_MODE_SIMPLE 649 * @see #STATISTICS_FACE_DETECT_MODE_FULL 650 */ 651 public static final Key<Integer> STATISTICS_FACE_DETECT_MODE = 652 new Key<Integer>("android.statistics.faceDetectMode", int.class); 653 654 /** 655 * <p>List of unique IDs for detected 656 * faces</p> 657 * <p>Only available if faceDetectMode == FULL</p> 658 * 659 * @hide 660 */ 661 public static final Key<int[]> STATISTICS_FACE_IDS = 662 new Key<int[]>("android.statistics.faceIds", int[].class); 663 664 /** 665 * <p>List of landmarks for detected 666 * faces</p> 667 * <p>Only available if faceDetectMode == FULL</p> 668 * 669 * @hide 670 */ 671 public static final Key<int[]> STATISTICS_FACE_LANDMARKS = 672 new Key<int[]>("android.statistics.faceLandmarks", int[].class); 673 674 /** 675 * <p>List of the bounding rectangles for detected 676 * faces</p> 677 * <p>Only available if faceDetectMode != OFF</p> 678 * 679 * @hide 680 */ 681 public static final Key<android.graphics.Rect[]> STATISTICS_FACE_RECTANGLES = 682 new Key<android.graphics.Rect[]>("android.statistics.faceRectangles", android.graphics.Rect[].class); 683 684 /** 685 * <p>List of the face confidence scores for 686 * detected faces</p> 687 * <p>Only available if faceDetectMode != OFF. The value should be 688 * meaningful (for example, setting 100 at all times is illegal).</p> 689 * 690 * @hide 691 */ 692 public static final Key<byte[]> STATISTICS_FACE_SCORES = 693 new Key<byte[]>("android.statistics.faceScores", byte[].class); 694 695 /** 696 * <p>The shading map is a low-resolution floating-point map 697 * that lists the coefficients used to correct for vignetting, for each 698 * Bayer color channel.</p> 699 * <p>The least shaded section of the image should have a gain factor 700 * of 1; all other sections should have gains above 1.</p> 701 * <p>When android.colorCorrection.mode = TRANSFORM_MATRIX, the map 702 * must take into account the colorCorrection settings.</p> 703 * <p>The shading map is for the entire active pixel array, and is not 704 * affected by the crop region specified in the request. Each shading map 705 * entry is the value of the shading compensation map over a specific 706 * pixel on the sensor. Specifically, with a (N x M) resolution shading 707 * map, and an active pixel array size (W x H), shading map entry 708 * (x,y) ϵ (0 ... N-1, 0 ... M-1) is the value of the shading map at 709 * pixel ( ((W-1)/(N-1)) * x, ((H-1)/(M-1)) * y) for the four color channels. 710 * The map is assumed to be bilinearly interpolated between the sample points.</p> 711 * <p>The channel order is [R, Geven, Godd, B], where Geven is the green 712 * channel for the even rows of a Bayer pattern, and Godd is the odd rows. 713 * The shading map is stored in a fully interleaved format, and its size 714 * is provided in the camera static metadata by android.lens.info.shadingMapSize.</p> 715 * <p>The shading map should have on the order of 30-40 rows and columns, 716 * and must be smaller than 64x64.</p> 717 * <p>As an example, given a very small map defined as:</p> 718 * <pre><code>android.lens.info.shadingMapSize = [ 4, 3 ] 719 * android.statistics.lensShadingMap = 720 * [ 1.3, 1.2, 1.15, 1.2, 1.2, 1.2, 1.15, 1.2, 721 * 1.1, 1.2, 1.2, 1.2, 1.3, 1.2, 1.3, 1.3, 722 * 1.2, 1.2, 1.25, 1.1, 1.1, 1.1, 1.1, 1.0, 723 * 1.0, 1.0, 1.0, 1.0, 1.2, 1.3, 1.25, 1.2, 724 * 1.3, 1.2, 1.2, 1.3, 1.2, 1.15, 1.1, 1.2, 725 * 1.2, 1.1, 1.0, 1.2, 1.3, 1.15, 1.2, 1.3 ] 726 * </code></pre> 727 * <p>The low-resolution scaling map images for each channel are 728 * (displayed using nearest-neighbor interpolation):</p> 729 * <p><img alt="Red lens shading map" src="../../../../images/camera2/metadata/android.statistics.lensShadingMap/red_shading.png" /> 730 * <img alt="Green (even rows) lens shading map" src="../../../../images/camera2/metadata/android.statistics.lensShadingMap/green_e_shading.png" /> 731 * <img alt="Green (odd rows) lens shading map" src="../../../../images/camera2/metadata/android.statistics.lensShadingMap/green_o_shading.png" /> 732 * <img alt="Blue lens shading map" src="../../../../images/camera2/metadata/android.statistics.lensShadingMap/blue_shading.png" /></p> 733 * <p>As a visualization only, inverting the full-color map to recover an 734 * image of a gray wall (using bicubic interpolation for visual quality) as captured by the sensor gives:</p> 735 * <p><img alt="Image of a uniform white wall (inverse shading map)" src="../../../../images/camera2/metadata/android.statistics.lensShadingMap/inv_shading.png" /></p> 736 */ 737 public static final Key<float[]> STATISTICS_LENS_SHADING_MAP = 738 new Key<float[]>("android.statistics.lensShadingMap", float[].class); 739 740 /** 741 * <p>The best-fit color channel gains calculated 742 * by the HAL's statistics units for the current output frame</p> 743 * <p>This may be different than the gains used for this frame, 744 * since statistics processing on data from a new frame 745 * typically completes after the transform has already been 746 * applied to that frame.</p> 747 * <p>The 4 channel gains are defined in Bayer domain, 748 * see android.colorCorrection.gains for details.</p> 749 * <p>This value should always be calculated by the AWB block, 750 * regardless of the android.control.* current values.</p> 751 */ 752 public static final Key<float[]> STATISTICS_PREDICTED_COLOR_GAINS = 753 new Key<float[]>("android.statistics.predictedColorGains", float[].class); 754 755 /** 756 * <p>The best-fit color transform matrix estimate 757 * calculated by the HAL's statistics units for the current 758 * output frame</p> 759 * <p>The HAL must provide the estimate from its 760 * statistics unit on the white balance transforms to use 761 * for the next frame. These are the values the HAL believes 762 * are the best fit for the current output frame. This may 763 * be different than the transform used for this frame, since 764 * statistics processing on data from a new frame typically 765 * completes after the transform has already been applied to 766 * that frame.</p> 767 * <p>These estimates must be provided for all frames, even if 768 * capture settings and color transforms are set by the application.</p> 769 * <p>This value should always be calculated by the AWB block, 770 * regardless of the android.control.* current values.</p> 771 */ 772 public static final Key<Rational[]> STATISTICS_PREDICTED_COLOR_TRANSFORM = 773 new Key<Rational[]>("android.statistics.predictedColorTransform", Rational[].class); 774 775 /** 776 * <p>The HAL estimated scene illumination lighting 777 * frequency</p> 778 * <p>Report NONE if there doesn't appear to be flickering 779 * illumination</p> 780 * @see #STATISTICS_SCENE_FLICKER_NONE 781 * @see #STATISTICS_SCENE_FLICKER_50HZ 782 * @see #STATISTICS_SCENE_FLICKER_60HZ 783 */ 784 public static final Key<Integer> STATISTICS_SCENE_FLICKER = 785 new Key<Integer>("android.statistics.sceneFlicker", int.class); 786 787 /** 788 * <p>Table mapping blue input values to output 789 * values</p> 790 * <p>Tonemapping / contrast / gamma curve for the blue 791 * channel, to use when android.tonemap.mode is CONTRAST_CURVE.</p> 792 * <p>See android.tonemap.curveRed for more details.</p> 793 */ 794 public static final Key<float[]> TONEMAP_CURVE_BLUE = 795 new Key<float[]>("android.tonemap.curveBlue", float[].class); 796 797 /** 798 * <p>Table mapping green input values to output 799 * values</p> 800 * <p>Tonemapping / contrast / gamma curve for the green 801 * channel, to use when android.tonemap.mode is CONTRAST_CURVE.</p> 802 * <p>See android.tonemap.curveRed for more details.</p> 803 */ 804 public static final Key<float[]> TONEMAP_CURVE_GREEN = 805 new Key<float[]>("android.tonemap.curveGreen", float[].class); 806 807 /** 808 * <p>Table mapping red input values to output 809 * values</p> 810 * <p>Tonemapping / contrast / gamma curve for the red 811 * channel, to use when android.tonemap.mode is CONTRAST_CURVE.</p> 812 * <p>Since the input and output ranges may vary depending on 813 * the camera pipeline, the input and output pixel values 814 * are represented by normalized floating-point values 815 * between 0 and 1, with 0 == black and 1 == white.</p> 816 * <p>The curve should be linearly interpolated between the 817 * defined points. The points will be listed in increasing 818 * order of P_IN. For example, if the array is: [0.0, 0.0, 819 * 0.3, 0.5, 1.0, 1.0], then the input->output mapping 820 * for a few sample points would be: 0 -> 0, 0.15 -> 821 * 0.25, 0.3 -> 0.5, 0.5 -> 0.64</p> 822 */ 823 public static final Key<float[]> TONEMAP_CURVE_RED = 824 new Key<float[]>("android.tonemap.curveRed", float[].class); 825 826 /** 827 * @see #TONEMAP_MODE_CONTRAST_CURVE 828 * @see #TONEMAP_MODE_FAST 829 * @see #TONEMAP_MODE_HIGH_QUALITY 830 */ 831 public static final Key<Integer> TONEMAP_MODE = 832 new Key<Integer>("android.tonemap.mode", int.class); 833 834 /** 835 * <p>This LED is nominally used to indicate to the user 836 * that the camera is powered on and may be streaming images back to the 837 * Application Processor. In certain rare circumstances, the OS may 838 * disable this when video is processed locally and not transmitted to 839 * any untrusted applications.</p> 840 * <p>In particular, the LED <em>must</em> always be on when the data could be 841 * transmitted off the device. The LED <em>should</em> always be on whenever 842 * data is stored locally on the device.</p> 843 * <p>The LED <em>may</em> be off if a trusted application is using the data that 844 * doesn't violate the above rules.</p> 845 * 846 * @hide 847 */ 848 public static final Key<Boolean> LED_TRANSMIT = 849 new Key<Boolean>("android.led.transmit", boolean.class); 850 851 /** 852 * <p>Whether black-level compensation is locked 853 * to its current values, or is free to vary</p> 854 * <p>Whether the black level offset was locked for this frame. 855 * Should be ON if android.blackLevel.lock was ON in the capture request, 856 * unless a change in capture settings forced a black level reset.</p> 857 */ 858 public static final Key<Boolean> BLACK_LEVEL_LOCK = 859 new Key<Boolean>("android.blackLevel.lock", boolean.class); 860 861 /*~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~ 862 * End generated code 863 *~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~@~O@*/ 864 865 /** 866 * <p> 867 * List of the {@link Face Faces} detected through camera face detection 868 * in this result. 869 * </p> 870 * <p> 871 * Only available if {@link #STATISTICS_FACE_DETECT_MODE} {@code !=} 872 * {@link CameraMetadata#STATISTICS_FACE_DETECT_MODE_OFF OFF}. 873 * </p> 874 * 875 * @see Face 876 */ 877 public static final Key<Face[]> STATISTICS_FACES = 878 new Key<Face[]>("android.statistics.faces", Face[].class); 879} 880
