Camera ITS tests

This page provides a comprehensive list of the tests under the Camera Image Test Suite (ITS), which is part of the Android Compatibility Test Suite (CTS) Verifier. ITS tests are functional tests, meaning that they don't measure image quality, but that all of the advertised camera functions are working as expected. This document lets developers and testers understand what the individual tests do and how to debug test failures.

Camera ITS gates tests by required camera properties, API level, and media performance class (MPC) level. For API level, ITS uses ro.product.first_api_level to gate tests added in a specific API level that test for negative user experiences for functionality in lower API levels. ITS uses ro.vendor.api_level to gate tests for features added in a specific API level that require new hardware capability. If is defined for a device, ITS requires specific tests to be run depending on the MPC level.

Tests are grouped by scene as follows:

  • scene0: Capture metadata, jitter, gyroscope, vibration
  • scene1: Exposure, sensitivity, EV compensation, YUV vs JPEG/RAW
  • scene2: Face detection, tests requiring color scenes or complete darkness
  • scene3: Edge enhancement, lens movement
  • scene4: Aspect ratio, cropping, field-of-view
  • scene5: Lens shading
  • scene6: Zoom
  • scene_extensions: Camera extensions
  • sensor_fusion: Camera/gyroscope timing offset

See individual sections for a description of each scene.


Scene0 tests require no specific scene information. However, the phone must be stationary for gyroscope and vibration testing.


Verifies that the entire capture pipeline can keep up with the speed of fullsize capture and CPU time.

APIs tested:

Pass: Captures a burst of full size images and the camera is fast enough to avoid timeout.


Tests that a capture result is returned from a manual capture and then dumps it.

APIs tested:

Pass: Completes capture and dumps the capture results.


Tests if the gyro has stable output when the device is stationary. Data is plotted as an average of 20 data points.

APIs tested:

Pass: The gyro reading's delta is less than 0.01 over time.




Measures jitter in camera timestamps.

APIs tested:

Pass: There's at least a 30 ms delta between frames.


test_jitter_plot.png (Note the small y-axis range. Jitter is actually small in this plot.)


Tests the validity of metadata entries. Looks at capture results and at the camera characteristics objects. This test uses auto_capture_request exposure and gain values because image content isn't important.

APIs tested:

Pass: Hardware level, rollingShutterSkew, frameDuration tags, timestampSource, croppingType, blackLevelPattern, pixel_pitch, FoV, hyperfocal distance are present and have valid values.


Tests that the android.sensor.sensitivity parameter is applied properly in burst. Inspects the output metadata only.

APIs tested:

Pass: Output data has an error tolerance of less than 0.2%.


Tests that the device writes the correct exposure and gain values by reading back the capture metadata.

APIs tested:

Pass: Read and write values match across all shots.


Tests that device queries and prints out sensor events for devices that advertise sensor fusion support. The sensors expected are accelerometer, gyroscope, and magnetometer. This test only works if the screen is on, meaning the device isn't in standby mode.

APIs tested:

Pass: Events for each sensor are received.


Tests that solid color test patterns are generated properly for camera muting. If camera muting is supported, solid color test patterns must be supported. If camera muting is not supported, solid color test patterns are only tested if the capability is advertised.

If RAW images are supported, color assignment is tested as well. The colors tested are black, white, red, blue, and green. For cameras that don't support RAW images, only black is tested.

APIs tested:

Pass: Solid test patterns supported are the correct color and there is low variance in the image.


Tests the android.sensor.testPatternMode parameter to capture frames for each valid test pattern and checks that the frames are generated correctly for solid colors and color bars. This test includes the following steps:

  1. Captures images for all supported test patterns.
  2. Performs a simple correctness check for solid color test pattern and color bars.

APIs tested:

Pass: Supported test patterns are generated correctly.




Tests conversion of test pattern from RAW to YUV with linear tonemap. This test requires android.sensor.testPatternMode = 2 (COLOR_BARS) to generate a perfect image pattern for tonemap conversion. Ensures pipeline has proper color outputs with linear tonemap and ideal image input (relies on test_test_patterns).

APIs tested:

Pass: The YUV and the RAW look similar to each other.






Tests if image and motion sensor events are in the same time domain.

APIs tested:

Pass: Motion timestamps are between the two image timestamps.


Tests if the device's vibration is functioning as expected.

APIs tested:

Pass: The device doesn't vibrate when muted by the camera audio restriction API.


scene1 is a gray chart. The gray chart must cover the center 30% of the camera field of view. The gray chart is expected to challenge 3A (auto exposure, auto white balance, auto focus) moderately as the center region has no features. However, the capture request specifies the entire scene which includes sufficient features for 3A to converge.

RFoV cameras can be tested in the WFoV or the RFoV test rig. If a RFoV camera is tested in the WFoV test rig, the chart is scaled by ⅔ to ensure some boundaries for the gray chart in the FoV to help 3A converge. For more detailed descriptions of the camera test rigs, see Camera ITS-in-a-box.


scene1: Full size chart (left). ⅔ scaled chart (right).


Tests the convergence of 3A with a moderately challenging target.

APIs tested:

Pass: 3A converges and the returned 3A values are valid.


Tests the 3A auto exposure (AE) and auto focus (AF) algorithms individually.

APIs tested:

Pass: 3A converges and the returned 3A values are legal.


Tests the AE state machine when using the precapture trigger. Captures five manual requests with AE disabled. The last request has an AE precapture trigger, which should be ignored because AE is disabled.

APIs tested:

Pass: AE converges.


Tests that captured auto and manual shots look the same.

APIs tested:

Pass: Manual white balance gains and transform reported in each capture result match with the auto white balance estimate from camera's 3A algorithm.








Tests that the device produces full black and white images. Takes two captures, the first with extremely low gain and short exposure, which results in a black photo, and the second with extremely high gain and long exposure, which results in a white photo.

APIs tested:

Pass: Produces black and white images. Saturated channels of white images have RGB values of [255, 255, 255] with a margin of error of less than 1% difference.

test_black_white_black test_black_white_black
test_black_white_black.jpg test_black_white_white.jpg




Takes 5 bursts of 50 images with manual capture setting and checks that they're all identical. This test can be used to identify if there are sporadic frames that are processed differently or have artifacts.

APIs tested:

Pass: Images are identical visually and in RGB values.

Fail: Shows a spike or drop of the RGB average chart at the beginning of each burst

  • Tolerance is 3% for first_API_level < 30
  • Tolerance is 2% for first_API_level >= 30






Tests that valid data comes back in CaptureResult objects. Does an auto, manual, and auto capture.

APIs tested:

Pass: Metadata is valid for all captures and the manual settings don't leak into the second auto capture. Plots out the lens shading correction for the captures.




Tests that the RAW streams aren't croppable.

APIs tested:

Pass: YUV images get center-cropped but not RAW images.










Tests that crop regions work. Takes a full image and creates patches of 5 different regions (corners and center.) Takes images with crop set for the 5 regions. Compares the patch and the crop image values.

APIs tested:

Pass: Image of the cropped region matches the patch that corresponds to the crop image.


Verifies that the DNG raw model parameters are correct. The plot depicts the measured variance of a center patch of the grey card in raw shots captured over a range of sensitivities, and compares these values with the variance that is expected at each sensitivity by the DNG noise model in the camera HAL (based on the O,S parameters returned in the capture result objects). For a more details on the DNG noise model, download the following document on the DNG Noise Model.

APIs tested:

Pass: DNG raw model parameters are correct. Expected RGB values match that of the actual RGB values measured.




Tests that the exposure value (EV) compensation is applied. The test increases exposure in eight steps, and checks measured brightness versus expected brightness. Expected values are calculated from image brightness of image with no EV compensation applied and the expected value will saturate if the calculated values exceed the actual image value range. Test fails if the expected values and measured values don't match or images overexpose within five steps.

APIs tested:

Pass: Images show increasing exposure without overexposing within five steps.




Tests that the EV compensation is applied using a range created with CONTROL_AE_COMPENSATION_STEP. Eight frames are captured at each compensation value.

APIs tested:

Pass: Captures increase in luma with increased EV compensation setting, and the eight frames captured for each EV compensation setting have stable luma values.




Tests that a constant exposure is achieved as ISO and exposure time vary. Takes a series of shots that have ISO and exposure time chosen to balance each other. Results should have the same brightness, but over the sequence the image should get noisier. Verifies sample pixel mean values are close to each other. Ensures that the images aren't clamped to 0 or 1 (which would make them look like flat lines). The test can also be run with RAW images by setting the debug flag in your configuration file.

APIs tested:

Pass: Images have the same brightness, but get noisier with higher ISO. RGB planes are flat when the value of ISO*exposure is constant over the tested gain space.



test_exposure_mult=1.00 test_exposure_mult=64.00
test_exposure_mult=1.00.jpg test_exposure_mult=64.00.jpg


Tests that converted YUV images and device JPEG images look the same. Test takes the center 10% of the image and calculates the RGB value, and verifies that they match.

APIs tested:

Pass: The average RGB difference between each image is less than 3%.

test_jpeg_fmt=jpg.jpg test_jpeg=fmt=yuv.jpg
test_jpeg_fmt=jpg.jpg test_jpeg=fmt=yuv.jpg


Tests that settings (exposure and gain) latch on the right frame for FULL and LEVEL_3 cameras. Takes a series of shots using back-to-back requests, varying the capture request parameters between shots. Checks that the images have the expected properties.

APIs tested:

Pass: Images [2, 3, 6, 8, 10, 12, 13] have increased ISO or exposure and show up with higher RGB means on test_latching_plot_means.png.

test_latching_i=00.jpg test_latching_i=01.jpg test_latching_i=02.jpg
test_latching_i=00.jpg test_latching_i=01.jpg test_latching_i=02.jpg
test_latching_i=03.jpg test_latching_i=04.jpg test_latching_i=05.jpg
test_latching_i=03.jpg test_latching_i=04.jpg test_latching_i=05.jpg
test_latching_i=06.jpg test_latching_i=07.jpg test_latching_i=08.jpg
test_latching_i=06.jpg test_latching_i=07.jpg test_latching_i=08.jpg
test_latching_i=09.jpg test_latching_i=10.jpg test_latching_i=11.jpg
test_latching_i=09.jpg test_latching_i=10.jpg test_latching_i=11.jpg




Tests that device processing can be inverted to linear pixels. Captures a sequence of shots with the device pointed at a uniform target.

APIs tested:

Pass: R, G, B values must increase linearly with increased sensitivity.




Tests 3A lock and YUV burst (using auto setting). This test is designed to pass even on limited devices that don't have MANUAL_SENSOR or PER_FRAME_CONTROLS. The test checks YUV image consistency while the frame rate check is in CTS.

APIs tested:

Pass: Captures look consistent.








Tests that the android.colorCorrection.* parameters are applied when set. Takes shots with different transform and gain values, and tests that they look correspondingly different. The transform and gains are chosen to make the output increasingly red or blue. Uses a linear tonemap. Tone mapping is a technique used in image processing to map one set of colors to another to approximate the appearance of high-dynamic-range images in a medium that has a more limited dynamic range.

APIs tested:

Pass: R and B values boost according to transformation.



*The x-axis is the capture requests: 0 = unity, 1=red boost, 2= blue boost




test_param_color_correctness_req=1.jpg (R boost)


test_param_color_correction_req=2.jpg (B boost)


Tests that the android.sensor.exposureTime parameter is applied.

APIs tested:

Pass: Each shot is brighter than the previous shot.






Tests that the android.flash.mode parameter is applied. Manually sets the exposure to be on the dark side, so that it is obvious whether the flash fired or not, and uses a linear tonemap. Checks the center with the tile image to see if there's a large gradient that's created to verify whether the flash fired.

APIs tested:

Pass: The center of the tile image has a large gradient meaning that the flash fired.










Tests that the android.noiseReduction.mode parameter is applied correctly when set. Captures images with the camera dimly lit. Uses a high analog gain to ensure the captured image is noisy. Captures three images, for NR off, "fast", and "high quality". Also captures an image with low gain and NR off, and uses the variance of this as the baseline. The higher the SNR (Signal to Noise Ratio), the better the image quality.

APIs tested:

Pass: SNR varies with different noise reduction modes and behaves similarly as the graph below.



0: OFF, 1: FAST, 2: HQ, 3: MIN , 4: ZSL












Tests that the android.sensor.sensitivity parameter is applied. The test increases the sensitivity in 5 steps with fixed exposure for each shot.

APIs tested:

Pass: RGB means of center 10% gets brighter with increased sensitivity.














Tests that the android.shading.mode parameter is applied.

APIs tested:

Pass: Shading modes are switched and the lens shading maps are modified as expected.








Tests that the android.tonemap.mode parameter is applied. Applies different tonemap curves to each R, G, B channel, and checks that the output images are modified as expected. This test consists of two tests, test1 and test2.

APIs tested:


  • test1: Both images have a linear tonemap, but n=1 has a steeper gradient. The G (green) channel is brighter for the n=1 image.
  • test2: Same tonemap, but different length. Images are the same.
test_param_tonemap_mode_n=0.jpg test_param_tonemap_mode_n=1.jpg
test_param_tonemap_mode_n=0.jpg test_param_tonemap_mode_n=1.jpg


Checks post RAW sensitivity boost. Captures a set of RAW and YUV images with different sensitivity, posts RAW sensitivity boost combination and checks if the output pixel mean matches request settings.

APIs tested:

Pass: RAW images get darker as boost increases while YUV images stay constant in brightness




























Captures a set of raw images with increasing gains and measures the noise. Captures raw-only, in a burst.

APIs tested:

Pass: Each shot is noisier than the previous shot, as the gain is increasing.

Uses the variance of the center stats grid cell.




Captures a set of raw images with increasing exposure time and measures the pixel values.

APIs tested:

Pass: Increasing the ISO (gain) makes the pixels more sensitive to light, so the plot moves towards the left.



(10⁰ is 1 ms, 10¹ is 10 ms, 10⁻¹ is 0.1 ms)












Captures a set of raw images with increasing sensitivities and measures the noise (variance) in the center 10% of image. Tests that each shot is noisier than the previous one.

APIs tested:

Pass: Variance increases with each shot.




Tests that android.noiseReduction.mode is applied for reprocessing requests. Captures reprocessed images with the camera dimly lit. Uses a high analog gain to ensure the capture image is noisy. Captures three reprocessed images, for NR off, "fast", and "high quality". Captures a reprocessed image with low gain and NR off, and uses the variance of this as the baseline.

APIs tested:

Pass: FAST >= OFF, HQ >= FAST, HQ >> OFF

Typical SNR vs NR_MODE plot

Typical SNR vs NR_MODE plot


Tests a sequence of shots with different tonemap curves. Captures 3 manual shots with a linear tonemap. Captures 3 manual shots with default tonemap. Computes the delta between each consecutive frame pair.

APIs tested:

Pass: There are 3 identical frames followed by a different set of 3 identical frames.














Tests that all reported sizes and formats for image capture work. Uses a manual request with a linear tonemap so that the YUV and JPEG look the same when converted by the image_processing_utils module. Images aren't saved by default, but can be saved by enabling debug_mode.

APIs tested:

Pass: All image centers have a max RMS (root-mean-square value of a signal) difference in RGB converted images with 3% of highest resolution YUV image.




Tests that the reported sizes and formats for image capture work.

APIs tested:

Pass: Test completes and returns the images requested.




Tests capturing a single frame as both YUV and JPEG outputs. Uses a manual request with a linear tonemap so that the YUV and JPEG look the same when converted by the image_processing_utils module.

APIs tested:

Pass: YUV and JPEG images are similar and have less than 1% RMS (root-mean-square value of a signal) difference.

test_yuv_plus_jpg_jpg.jpg test_yuv_plus_jpeg_yuv.jpg
test_yuv_plus_jpg_jpg.jpg test_yuv_plus_jpeg_yuv.jpg


Tests capturing a single frame as both RAW/RAW10/RAW12 and YUV outputs if supported. Uses a manual request with linear tonemap so raw and YUV are expected to be the same. Compares RGB converted images' center 10% RGB values. Logsandroid.shading.mode.

APIs tested:

Pass: YUV and raw images are similar and have less than 3.5% RMS (root-mean-square value of a signal) difference.

test_yuv_plus_raw_shading=1_raw.jpg test_yuv_plus_raw_shading=1_yuv.jpg
test_yuv_plus_raw_shading=1_raw.jpg test_yuv_plus_raw_shading=1_yuv.jpg


scene2_a has three faces with a gray background and neutral clothing. The faces are chosen to have a wide range of skin tones. The chart must have the correct orientation for face detection to work optimally.




Tests that auto-flash is triggered in a dark scene. Verifies that auto-flash is fired by checking that the center of the tile image has a large gradient. To trigger auto-flash, the tablet and lights in the test rig must be turned off. The tablet is turned off by the test, and the lights can be turned off automatically with the Arduino controller. The scene must be completely dark for the test to work correctly. As such, the rear tablet opening must be completely covered by the scene tablet, and the front opening must be covered by an aperture and the DUT phone to block stray light from entering the rig.

APIs tested:

Pass: The center of the tile image has a large gradient meaning that auto-flash fired.


Tests the camera device's autoframing behavior. Performs a large zoom such that none of the faces in the scene are visible, enables the autoframing mode by setting AUTOFRAMING in CaptureRequest to True, and verifies whether all the faces in the original scene can be detected when the state converges (that is, when AUTOFRAMING_STATE in CaptureResult is set to AUTOFRAMING_STATE_CONVERGED).

APIs tested:

Pass: All three faces are detected.


Tests Display P3 capture in JPEG using the ColorSpaceProfiles API. Tests that the captured JPEG has an appropriate ICC profile in its header, and that the image contains colors outside of the sRGB gamut.

APIs tested:

Pass: The JPEG contains a Display P3 ICC profile and colors outside the sRGB gamut.


Captures frame for supported camera effects and checks if they are generated correctly. The test only checks effects OFF and MONO, but saves images for all supported effects.

APIs tested:

Pass: Captures the scene image with effects OFF and a monochrome image with effects set to MONO.




Tests different combinations of output formats.

APIs tested:

Pass: All the combinations are successfully captured.


Tests the camera JPEG compression quality. Step JPEG qualities through android.jpeg.quality and ensures Quantization Tables change correctly.

APIs tested:

Pass: Quantization matrix decreases with quality increase. (Matrix represents the division factor.)


Pixel 4 rear camera luma/chroma DQT matrix averages vs JPEG quality

test_jpeg_quality failed

Failed test example

Note that for very low quality images (jpeg.quality < 50), there is no increase in compression in the quantization matrix.


Tests face detection.

APIs tested:

Pass: Finds three faces.




Tests that the preview frame rate decreases correctly in a dark scene. For this test to work correctly, the lights in the test rig must be turned off by the controller or manually by the test operator.

APIs tested:

Pass: The preview frame rate is at the minimum of the requested frame rate range, and the variation between frames is less than the absolute tolerance set in the test.


Tests that YUV reprocessing doesn't swap the U and V planes. This is detected by calculating the sum of absolute differences (SAD) between the reprocessed image and a non-reprocessed capture. If swapping the output U and V planes of the reprocessed capture results in an increased SAD, then the output is assumed to have the correct U and V planes.

APIs tested:

Pass: The U and V planes aren't swapped.





Tests face detection with increased skin tone diversity in face scenes.

APIs tested:

Pass: Finds 3 faces.




Captures two images using the largest common YUV and JPEG formats with the same aspect ratio as the largest JPEG format not exceeding a resolution of 1920x1440. Sets jpeg.quality to 100 and captures a dual surface request. Converts both images to RGB arrays and calculates the 3D root mean square (RMS) difference between the two images.

APIs tested:

Pass: YUV and JPEG images are similar and have less than 1% RMS (root-mean-square value of a signal) difference.



Tests face detection with increased skin tone diversity in face scenes.

APIs tested:

Pass: Finds 3 faces.




Tests JPEG capture latency for the S performance class as specified in section Camera in the CDD.

Pass: MUST have camera2 JPEG capture latency < 1000ms for 1080p resolution as measured by the CTS camera PerformanceTest under ITS lighting conditions (3000K) for both primary cameras.


Tests camera launch latency for the S performance class as specified section Camera in the CDD.

Pass: MUST have camera2 startup latency (open camera to first preview frame) < 600ms as measured by the CTS camera PerformanceTest under ITS lighting conditions (3000K) for both primary cameras.



Tests face detection with increased skin tone diversity in face scenes.

APIs tested:

Pass: Finds 3 faces.



50 VGA resolution frames are captured with the capture request first setting android.control.afMode = 4 (CONTINUOUS_PICTURE).

APIs tested:

Pass: 3A system settles by the end of a 50-frame capture.


Tests face detection with increased skin tone diversity in face scenes.

APIs tested:

Pass: Finds 3 faces.


scene2_f has three faces with a white background and white clothing. The faces have a wide range of skin tones and high contrast with the background.




Tests face detection with increased skin tone diversity in face scenes.

APIs tested:

Pass: Finds 3 faces.




Scene3 uses the ISO12233 chart, and most tests use a chart extractor method to find the chart in the scene. For this reason, most of the saved images don't have borders like the images for scenes 1, 2 or 4, but only the chart. The chart must be in the correct orientation for the chart finder to work optimally.


Tests for 3A consistency.

APIs tested:

Pass: 3A converges for exposure, gain, awb (auto white balance), and fd (focus distance) three times within tolerance.


Tests that the android.edge.mode parameter is applied correctly. Captures non-reprocess images for each edge mode and returns sharpness of the output image and the capture result metadata. Processes a capture request with a given edge mode, sensitivity, exposure time, focus distance, and output surface parameter.

Pass: HQ mode (2) sharper than OFF mode (0). FAST mode (1) sharper than OFF mode. HQ mode sharper or equal to FAST mode.

APIs tested:

Impacted camera parameters:





test_edge_enhancement_edge=1.jpg (fast mode)


test_edge_enhancement_edge=2.jpg (high quality mode)


Tests if image is properly oriented as per CDD section 7.5.2 Front-Facing Camera [C-1-5].

Mirrored, flipped, or rotated images can be identified by the diamond feature near the center.

Pass: Image isn't flipped, mirrored or rotated.




Tests if the landscape to portrait override functions correctly for landscape-oriented sensors.

APIs tested:

Pass: The test is able to locate a chart with the expected rotation (0 degrees when the landscape to portrait override is disabled, 90 degrees when enabled).




Tests if the lens movement flag is properly reported. Captures a burst of 24 images with the first 12 frames at the optimum focus distance (as found by 3A) and the last 12 frames at the minimum focus distance. Around frame 12, the lens moves causing the sharpness to drop. The sharpness eventually stabilizes as the lens moves to the final position. The lens movement flag should be asserted in all frames where the sharpness is intermediate to sharpness in the first few frames with the lens stationary at optimum focal distance, and the final few frames where the lens is stationary in the minimum focal distance. The exact frame the lens moves isn't important: what is checked is that the movement flag is asserted when the lens is moving.

APIs tested:

Pass: Lens movement flag is True in the frame with sharpness change.

Fail mechanisms:

  • lens_moving: True (android.hardware.camera2.CaptureResult#LENS_STATE = 1) in test_log.DEBUG is asserted only in frames where sharpness isn't changing.
  • Frames with lens_moving: False (android.hardware.camera2.CaptureResult#LENS_STATE = 0) in test_log.DEBUG has a sharpness difference compared to the first few frames at optimum focal distance or the last few frames at minimum focus distance.


Tests if supported reprocess methods for edge enhancement work properly. Processes a capture request with a given reprocess edge mode and compares different modes to capture with reprocess edge modes disabled.

APIs tested:

Pass: Sharpness for the different edge modes is correct. HQ (mode 2) is sharper than OFF (mode 0), and improvement between different modes is similar.




Scene4 consists of a black circle on a white background inside a square.




Tests if images are distorted or cropped unexpectedly in the image pipeline. Takes pictures of a circle over all formats. Verifies the circle isn't distorted, the circle doesn't move from the center of image, and the circle doesn't change size incorrectly with different aspect ratios or resolutions.

APIs tested:

Pass: Images aren't stretched, the center of images don't differ by more than 3%, and the maximum possible FoV (field of view) is preserved.

Fail mechanisms:

  • The circle in the captured image is distorted by the processing pipeline.
  • Lower resolution image is double cropped in the image pipeline creating different FoV between high and low resolution images.
  • The circle in the captured image is cropped due to an extreme aspect ratio capture request reducing the height or width of the image.
  • The circle in the captured image has a reflection in the center and doesn't appear fully filled.


Tests the camera calibration parameters related to camera positioning for multi-camera systems. Using the multi-camera physical sub-cameras, takes a picture with one of the physical cameras. Finds the circle center. Projects the circle center to the world coordinates for each camera. Compares the difference between the cameras' circle centers in world coordinates. Reprojects the world coordinate back to pixel coordinates and compares against originals as a validity check. Compares the circle sizes checking if the focal lengths of the cameras are different.

APIs tested:

Pass: Circle centers and sizes are as expected in projected images compared to captured images using camera calibration data and focal lengths.

Fail mechanisms:

  • LENS_INTRINSIC_CALIBRATION, LENS_POSE_TRANSLATION, or LENS_POSE_ROTATION are design values and not actual calibration data.
  • The camera system isn't appropriate for the test setup. For example, testing a wide and an ultra-wide camera system with the RFoV test rig. For more information, see Camera ITS-in-a-box FAQ1.


Similar to the test_aspect_ratio_and_crop test for still captures, this test checks the supported preview formats to ensure the preview frames aren't stretched or cropped inappropriately. Verifies that the aspect ratio of the circle doesn't change, the cropped images keep the circle in center of the frame, and the circle size doesn't change for a constant format or with different resolutions (field of view check).

APIs tested:

Pass: Images aren't stretched, the center of images don't differ by more than 3%, and the maximum possible FoV (field of view) is preserved.


Checks the supported preview sizes to ensure the FoV is cropped appropriately. The test captures two videos, one with preview stabilization ON, and another with preview stabilization OFF. A representative frame is selected from each video, and analyzed to ensure that the FoV changes in the two videos are within spec.

APIs tested:

Pass: The circle aspect ratio remains about constant, the center location of the circle remains stable, and the size of circle changes no more that 20%.


Takes videos of a circle inside of a square over all video formats. Extracts the key frames, and verifies the aspect ratio of the circle doesn't change, the cropped images keep the circle in center, and the circle size doesn't change for a constant format or with different resolution (field of view check).

APIs tested:

Pass: Video frames aren't stretched, the center of frames don't differ by more than 3%, and the maximum possible FoV (field of view) is preserved.


Scene5 requires a uniformly lit gray scene. This is accomplished by a diffuser placed over the camera lens. We recommend the following diffuser:

To prepare the scene, attach a diffuser in front of the camera and point the camera to a lighting source of around 2000 lux. Images captured for scene5 require diffuse lighting with no features evident. The following is a sample image:


scene5 capture


Tests that the lens shading correction is applied appropriately, and color of a monochrome uniform scene is evenly distributed. Performs this test on a YUV frame with auto 3A. Lens shading is evaluated based on the y channel. Measures the average y value for each sample block specified, and determines pass or fail by comparing with the center y value. The color uniformity test is evaluated in r/g and b/g space.

APIs tested:

Pass: At the specified radius of the image, the variance of r/g and b/g value must be less than 20% to pass the test.


Scene6 is a grid of small circles with a square in one corner to indicate orientation. The small circles are needed to test zoom function over a large range.




Tests the behavior of the camera in-sensor zoom feature, which produces cropped RAW images.

With the stream use case set to CROPPED_RAW, the test takes two captures over the zoom range, a full field of view (FoV) RAW image and a cropped RAW image. The test converts the images to RGB arrays, downscales the full-sized cropped RAW image to the size reported by SCALER_RAW_CROP_REGION, and calculates the 3D root mean square (RMS) difference between the two images.

APIs tested:

Pass: The 3D root mean square (RMS) difference between the downscaled cropped RAW image and the full FoV RAW image is less than 1%.


Tests the camera zoom behavior. Takes captures over the zoom range and checks if the circles get bigger as the camera zooms in.

APIs tested:

Pass: Relative size of captured circle is accurate against requested zoom ratio to ensure camera is zooming correctly.


test_zoom to find the contour of the circle closest to the center.


Tests the camera low latency zoom behavior. Takes captures over the zoom range with android.control.settingsOverride = 1 (SETTINGS_OVERRIDE_ZOOM), and checks if the circles in the output images match the zoom ratios in the capture metadata.

APIs tested:

Pass: Relative size of captured circle is accurate against the zoom ratio result metadata.


Tests that while recording and zooming, video preview and video output display and record the same output. Calculates the size of the circle closest to the center at different zoom ratios and checks whether the size of the circle increases as the zoom ratio increases.

APIs tested:

Pass: Relative size of captured circle is accurate against requested zoom ratio in video and preview.


VGA_640x480_key_frame.png (before zoom)


preview_640x480_key_frame.png (before zoom)


VGA_640x480_key_frame.png (after zoom)


preview_640x480_key_frame.png (after zoom)


The scene_extensions tests are for camera extensions and must use Camera ITS-in-a-Box, as they require precise control of the testing environment.


The scene_hdr scene consists of a portrait on the left and a low-contrast QR code on the right.




Tests the HDR extension. Takes captures with and without the extension enabled, and checks if the extension makes the QR code more detectable.

APIs tested:

Pass: The HDR extension reduces the number of contrast changes needed to detect the QR code or reduces the gradient across the QR code.


The scene_night scene consists of a white circle with four smaller circles inside of it, all against a black background. The smaller circle in the top right corner is darker than the others to indicate orientation.




Tests the Night extension. Takes captures with and without the extension enabled, and checks for the following:

  • The capture with the Night extension enabled takes longer.
  • The capture with the Night extension enabled is brighter or has scene artifacts with an improved appearance.

APIs tested:

Pass: Compared to a capture without the Night extension enabled, a capture with the Night extension enabled takes at least 0.5 seconds longer. The capture must be at least 10% brighter, or the gray dots in the scene must be 20 pixel values lower than the surrounding circle's center.


Sensor fusion tests require specific phone movement in front of a checkerboard pattern. For optimum results, ensure the test chart is mounted flat. Charts that aren't flat affect the rotation calculations for many of the tests. The sensor_fusion tests can be automated with the Sensor Fusion Box.


Image of checkerboard


Tests that frame timestamps captured by logical camera are within 10 ms by computing angles of squares within the checkerboard to determine the timestamp.

APIs tested:

Pass: Angle between images from each camera doesn't change appreciably as phone is rotated.


Tests that stabilized preview video rotates less than gyroscope.

APIs tested:

Pass: Max angle rotation over frames is less than 70% of gyroscope rotation.

The following are sample videos with and without stabilization.

  • Sample video with stabilization

  • Sample video without stabilization


Tests the timestamp difference between the camera and the gyroscope for AR and VR applications. Phone is rotated 90 degrees 10 times in front of the checkerboard pattern. Motion is about 2 s round trip. This test is skipped if no gyroscope is included or if the timestamp source REALTIME parameter is not enabled.

The test_sensor_fusion test generates a number of plots. The two most important plots for debugging are:

  • test_sensor_fusion_gyro_events: Shows the gyroscope events for the phone during the test. Movement in the x and y direction implies the phone isn't securely mounted on the mounting plate, reducing the probability of the test passing. The number of cycles in the plot depends on the write speed for saving frames.



  • test_sensor_fusion_plot_rotations: Shows the alignment of the gyroscope and camera events. This plot must show matching movement between camera and gyroscope to +/-1 ms.



APIs tested:

Pass: Camera and gyroscope timestamps' offset is less than 1 ms as per CDD section 7.3.9 High Fidelity Sensors [C-2-14].

Fail mechanisms:

  • Offset error: The camera-gyroscope offset isn't correctly calibrated to within +/-1 ms.
  • Frame drops: The pipeline isn't fast enough to capture 200 frames consecutively.
  • Socket errors: adb can't reliably connect to the DUT long enough to execute the test.
  • The chart isn't mounted flat. The plot test_sensor_fusion_plot_rotations has frames where the gyroscope and camera rotation vary considerably as the camera rotates through the parts of the chart that aren't flat.
  • The camera isn't mounted flat. The plot test_sensor_fusion_gyro_events shows movement in the X and Y planes. This failure is more common in front-facing cameras as the rear camera often has a raised bump to the rest of the phone body, creating a tilt when mounting the rear of the phone to the mounting plate.


Tests that stabilized video rotates less than gyroscope.

APIs tested:

Pass: Max angle rotation over frames is less than 60% of gyroscope rotation.

The following are sample videos with and without stabilization.

  • Sample video with stabilization

  • Sample video without stabilization


Tests that the LED snapshots don't saturate or tint the image.

This test adds a lighting controller to the sensor fusion box to control the lights. With the lights set to OFF, the test takes a capture with the AUTO_FLASH mode set to ON. During this capture, the test runs a precapture sequence with the aePrecapture trigger set to START, and sets the capture intent to Preview to take the capture with flash.

Because the capture has a distinctive hotspot due to flash, the test computes the flash image mean of the entire capture and verifies whether the value is within the (68, 102) range. To check if the image is reasonably white-balanced, the test calculates the R/G and B/G ratios and verifies whether the ratios are within 0.95 and 1.05.

APIs tested:

Pass: The R/G and B/G ratios are within 0.95 and 1.05. The flash image mean is within the (68, 102) range.