| # Copyright 2014 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """CameraITS test to verify metadata entries.""" |
| |
| import logging |
| import math |
| |
| from mobly import test_runner |
| |
| import its_base_test |
| import camera_properties_utils |
| import capture_request_utils |
| import its_session_utils |
| |
| |
| class MetadataTest(its_base_test.ItsBaseTest): |
| """Test the validity of some metadata entries. |
| |
| Looks at the capture results and at the camera characteristics objects. |
| """ |
| |
| def test_metadata(self): |
| with its_session_utils.ItsSession( |
| device_id=self.dut.serial, |
| camera_id=self.camera_id, |
| hidden_physical_id=self.hidden_physical_id) as cam: |
| # Arbitrary capture request exposure values; image content is not |
| # important for this test, only the metadata. |
| props = cam.get_camera_properties() |
| props = cam.override_with_hidden_physical_camera_props(props) |
| camera_properties_utils.skip_unless( |
| camera_properties_utils.backward_compatible(props)) |
| auto_req = capture_request_utils.auto_capture_request() |
| cap = cam.do_capture(auto_req) |
| md = cap['metadata'] |
| self.failed = False |
| logging.debug('Hardware level') |
| logging.debug('Legacy: %s', camera_properties_utils.legacy(props)) |
| |
| logging.debug('Limited: %s', camera_properties_utils.limited(props)) |
| logging.debug('Full or better: %s', |
| camera_properties_utils.full_or_better(props)) |
| logging.debug('Level 3: %s', camera_properties_utils.level3(props)) |
| logging.debug('Capabilities') |
| logging.debug('Manual sensor: %s', |
| camera_properties_utils.manual_sensor(props)) |
| logging.debug('Manual post-proc: %s', |
| camera_properties_utils.manual_post_proc(props)) |
| logging.debug('Raw: %s', camera_properties_utils.raw(props)) |
| logging.debug('Sensor fusion: %s', |
| camera_properties_utils.sensor_fusion(props)) |
| |
| check(self, 'android.info.supportedHardwareLevel' in props, |
| 'android.info.supportedHardwareLevel in props') |
| check(self, props['android.info.supportedHardwareLevel'] is not None, |
| 'props[android.info.supportedHardwareLevel] is not None') |
| check(self, props['android.info.supportedHardwareLevel'] in [0, 1, 2, 3], |
| 'props[android.info.supportedHardwareLevel] in [0, 1, 2, 3]') |
| manual_sensor = camera_properties_utils.manual_sensor(props) |
| # Test: rollingShutterSkew, and frameDuration tags must all be present, |
| # and rollingShutterSkew must be greater than zero and smaller than all |
| # of the possible frame durations. |
| if manual_sensor: |
| check(self, 'android.sensor.frameDuration' in md, |
| 'md.has_key("android.sensor.frameDuration")') |
| check(self, md['android.sensor.frameDuration'] is not None, |
| 'md["android.sensor.frameDuration"] is not None') |
| check(self, md['android.sensor.rollingShutterSkew'] > 0, |
| 'md["android.sensor.rollingShutterSkew"] > 0') |
| check(self, md['android.sensor.frameDuration'] > 0, |
| 'md["android.sensor.frameDuration"] > 0') |
| check( |
| self, md['android.sensor.rollingShutterSkew'] <= |
| md['android.sensor.frameDuration'], |
| ('md["android.sensor.rollingShutterSkew"] <= ' |
| 'md["android.sensor.frameDuration"]')) |
| logging.debug('frameDuration: %d ns', |
| md['android.sensor.frameDuration']) |
| |
| check(self, 'android.sensor.rollingShutterSkew' in md, |
| 'md.has_key("android.sensor.rollingShutterSkew")') |
| check(self, md['android.sensor.rollingShutterSkew'] is not None, |
| 'md["android.sensor.rollingShutterSkew"] is not None') |
| logging.debug('rollingShutterSkew: %d ns', |
| md['android.sensor.rollingShutterSkew']) |
| |
| # Test: timestampSource must be a valid value. |
| check(self, 'android.sensor.info.timestampSource' in props, |
| 'props.has_key("android.sensor.info.timestampSource")') |
| check(self, props['android.sensor.info.timestampSource'] is not None, |
| 'props["android.sensor.info.timestampSource"] is not None') |
| check(self, props['android.sensor.info.timestampSource'] in [0, 1], |
| 'props["android.sensor.info.timestampSource"] in [0,1]') |
| |
| # Test: croppingType must be a valid value, and for full devices, it |
| # must be FREEFORM=1. |
| check(self, 'android.scaler.croppingType' in props, |
| 'props.has_key("android.scaler.croppingType")') |
| check(self, props['android.scaler.croppingType'] is not None, |
| 'props["android.scaler.croppingType"] is not None') |
| check(self, props['android.scaler.croppingType'] in [0, 1], |
| 'props["android.scaler.croppingType"] in [0,1]') |
| |
| # Test: android.sensor.blackLevelPattern exists for RAW and is not None |
| if camera_properties_utils.raw(props): |
| check(self, 'android.sensor.blackLevelPattern' in props, |
| 'props.has_key("android.sensor.blackLevelPattern")') |
| check(self, props['android.sensor.blackLevelPattern'] is not None, |
| 'props["android.sensor.blackLevelPattern"] is not None') |
| |
| assert not self.failed |
| |
| if not camera_properties_utils.legacy(props): |
| # Test: pixel_pitch, FOV, and hyperfocal distance are reasonable |
| fmts = props['android.scaler.streamConfigurationMap'][ |
| 'availableStreamConfigurations'] |
| fmts = sorted( |
| fmts, key=lambda k: k['width'] * k['height'], reverse=True) |
| sensor_size = props['android.sensor.info.physicalSize'] |
| pixel_pitch_h = (sensor_size['height'] / fmts[0]['height'] * 1E3) |
| pixel_pitch_w = (sensor_size['width'] / fmts[0]['width'] * 1E3) |
| logging.debug('Assert pixel_pitch WxH: %.2f um, %.2f um', pixel_pitch_w, |
| pixel_pitch_h) |
| assert 0.7 <= pixel_pitch_w <= 10 |
| assert 0.7 <= pixel_pitch_h <= 10 |
| assert 0.333 <= pixel_pitch_w/pixel_pitch_h <= 3.0 |
| |
| diag = math.sqrt(sensor_size['height']**2 + sensor_size['width']**2) |
| fl = md['android.lens.focalLength'] |
| logging.debug('Focal length: %.3f', fl) |
| fov = 2 * math.degrees(math.atan(diag / (2 * fl))) |
| logging.debug('Assert field of view: %.1f degrees', fov) |
| assert 10 <= fov <= 130 |
| |
| if camera_properties_utils.lens_approx_calibrated(props): |
| diopter_hyperfocal = props['android.lens.info.hyperfocalDistance'] |
| if diopter_hyperfocal != 0.0: |
| hyperfocal = 1.0 / diopter_hyperfocal |
| logging.debug('Assert hyperfocal distance: %.2f m', hyperfocal) |
| assert 0.02 <= hyperfocal |
| |
| logging.debug('Minimum focus distance: %3.f', |
| props['android.lens.info.minimumFocusDistance']) |
| |
| |
| def check(self, expr, msg): |
| if expr: |
| logging.debug('Passed>>%s', msg) |
| else: |
| logging.debug('Failed>>%s', msg) |
| self.failed = True |
| |
| |
| if __name__ == '__main__': |
| test_runner.main() |
