# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import glob, logging, os, re, stat
from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.cros.graphics import graphics_utils
class camera_V4L2(test.test):
version = 1
preserve_srcdir = True
v4l2_major_dev_num = 81
v4l2_minor_dev_num_min = 0
v4l2_minor_dev_num_max = 64
def setup(self):
# TODO(jiesun): make binary here when cross compile issue is resolved.
os.chdir(self.srcdir)
utils.make('clean')
utils.make()
def run_once(self, run_unit_tests=True, run_capture_tests=True,
run_default_capture_test=False, time=0,
assert_mandatory_controls=False):
self.assert_mandatory_controls = assert_mandatory_controls
self.find_video_capture_devices()
time = time / len(self.v4l2_devices)
for device in self.v4l2_devices:
if run_unit_tests:
self.run_v4l2_unittests(device)
if run_capture_tests:
self.run_v4l2_capture_tests(device)
if run_default_capture_test:
self.run_v4l2_default_capture_test(device, time)
def is_v4l2_capture_device(self, device):
executable = os.path.join(self.bindir, "media_v4l2_is_capture_device")
cmd = "%s %s" % (executable, device)
logging.info("Running %s" % cmd)
return (utils.system(cmd, ignore_status=True) == 0)
def find_video_capture_devices(self):
self.v4l2_devices = []
for device in glob.glob("/dev/video*"):
statinfo = os.stat(device)
if (stat.S_ISCHR(statinfo.st_mode) and
os.major(statinfo.st_rdev) == self.v4l2_major_dev_num and
os.minor(statinfo.st_rdev) >= self.v4l2_minor_dev_num_min and
os.minor(statinfo.st_rdev) < self.v4l2_minor_dev_num_max and
self.is_v4l2_capture_device(device)):
self.v4l2_devices.append(device)
logging.info("Detected devices: %s\n" % self.v4l2_devices)
if not self.v4l2_devices:
raise error.TestFail("No V4L2 devices found!")
def unittest_passed(self, testname, stdout):
return re.search(r"OK \] V4L2DeviceTest\." + testname, stdout);
def run_v4l2_unittests(self, device):
self.executable = os.path.join(self.bindir, "media_v4l2_unittest")
cmd = "%s --device=%s" % (self.executable, device)
logging.info("Running %s" % cmd)
stdout = utils.system_output(cmd, retain_output=True)
# Check the result of unittests.
# We had exercise all the optional ioctls in unittest which maybe
# optional by V4L2 Specification. Therefore we need to check those
# tests that we thought are mandatory.
# 1. Multiple open should be supported for panel application.
if not self.unittest_passed("MultipleOpen", stdout):
raise error.TestError(device + " does not support multiple open!")
# 2. Need to make sure this is really support or just driver error.
if not self.unittest_passed("MultipleInit", stdout):
raise error.TestError(device + " does support multiple init!")
# 3. EnumInput and EnumStandard is optional.
# 4. EnumControl is mandatory.
if not self.unittest_passed("EnumControl", stdout):
raise error.TestError(device + " does support enum controls!")
pattern = re.compile(r"Control (\w+) is enabled\((\d+)-(\d+):(\d+)\)")
control_info = pattern.findall(stdout)
self.supported_controls = [ x[0] for x in control_info ]
logging.info("Supported Controls: %s\n" % self.supported_controls)
# TODO(jiesun): what is required?
mandatory_controls = [
"Brightness",
"Contrast",
"Saturation",
"Hue",
"Gamma"]
for control in mandatory_controls:
if self.assert_mandatory_controls and \
control not in self.supported_controls:
raise error.TestError(device + " does not support " + control)
# 5. SetControl is mandatory.
if not self.unittest_passed("SetControl", stdout):
raise error.TestError(device + " does not support set controls!")
# 6. 7. Set/GetCrop are both optional.
# 8. ProbeCaps is mandatory.
if not self.unittest_passed("ProbeCaps", stdout):
raise error.TestError(device + " does not support probe caps!")
if not re.search(r"support video capture interface.>>>", stdout):
raise error.TestFail(device + " does not support video capture!")
pattern = r"support streaming i/o interface.>>>"
self.support_streaming = True if re.search(pattern, stdout) else False
pattern = r"support streaming read/write interface.>>>"
self.support_readwrite = True if re.search(pattern, stdout) else False
# Currently I assume streaming (mmap) is mandatroy.
if not self.support_streaming:
raise error.TestFail(device + " does not support streaming!")
# 9. EnumFormats is always mandatory.
if not self.unittest_passed("EnumFormats", stdout):
raise error.TestError(device + " does not support enum formats!")
pattern = re.compile(r"supported format #\d+: .* \((....)\)")
format_info = pattern.findall(stdout)
# Remove duplicated pixel formats from list.
self.supported_formats = list(set(format_info))
logging.info("Supported pixel format: %s\n", self.supported_formats)
# 10. Get/SetParam for framerate is optional.
# 11. EnumFrameSize is optional on some kernel/v4l2 version.
def run_v4l2_capture_test(self, fail_okay, options):
executable = os.path.join(self.bindir, "media_v4l2_test")
try:
cmd = "%s %s" % (executable, " ".join(options))
cmd = graphics_utils.xcommand(cmd)
logging.info("Running %s" % cmd)
stdout = utils.system_output(cmd, retain_output=True)
except:
if fail_okay:
stdout = ""
return (False, stdout)
else:
raise
else:
return (True, stdout)
def run_v4l2_default_capture_test(self, device, time):
options = ["--device=%s" % device ]
if time:
options.append("--time=%d" % time)
okay, stdout = self.run_v4l2_capture_test(False, options)
def run_v4l2_capture_tests(self, device):
default_options = ["--device=%s" % device ]
# If the device claims to support read/write i/o.
if self.support_readwrite:
option = default_options + ["--read"]
okay, stdout = self.run_v4l2_capture_test(False, option)
# If the device claims to support stream i/o.
# This could mean either mmap stream i/o or user pointer stream i/o.
if self.support_streaming:
option = default_options + ["--mmap"]
mmap_okay, stdout = self.run_v4l2_capture_test(True, option)
option = default_options + ["--userp"]
userp_okay, stdout = self.run_v4l2_capture_test(True, option)
if not userp_okay and not mmap_okay:
raise error.TestFail("Stream i/o failed!")
# TODO(jiesun): test with different mandatory resultions that
# the capture device must support without scaling by ourselves.
required_resolutions = [
(320, 240, 30), # QVGA
(640, 480, 30)] # VGA
for (width, height, minfps) in required_resolutions:
# Note use default mmap i/o here.
option = default_options[:]
# Note use first supported pixel format.
option.append("--pixel-format=%s" % self.supported_formats[0])
option.append("--width=%s" % width)
option.append("--height=%s" % height)
okay, stdout = self.run_v4l2_capture_test(False, option)
# Check if the actual format is desired.
pattern = (r"actual format for capture (\d+)x(\d+)"
r" (....) picture at (\d+) fps")
match = re.search(pattern, stdout)
if (not match or
int(match.group(1)) != width or
int(match.group(2)) != height or
match.group(3) != self.supported_formats[0] or
int(match.group(4)) < minfps):
raise error.TestError("capture test failed")
okay, stdout = self.run_v4l2_capture_test(False, option)