The script runs tests that configure and streams
the rkisp1. The script wraps the commands
provided by v4l-utils and can optionally
use the 'cam' command from libcamera.
Signed-off-by: Dafna Hirschfeld <dafna.hirschfeld@xxxxxxxxxxxxx>
---
contrib/test/test-rkisp1.py | 576 ++++++++++++++++++++++++++++++++++++
contrib/test/v4l2lib.py | 90 ++++++
2 files changed, 666 insertions(+)
create mode 100755 contrib/test/test-rkisp1.py
create mode 100644 contrib/test/v4l2lib.py
diff --git a/contrib/test/test-rkisp1.py b/contrib/test/test-rkisp1.py
new file mode 100755
index 00000000..dcdd1ca6
--- /dev/null
+++ b/contrib/test/test-rkisp1.py
@@ -0,0 +1,576 @@
+#!/bin/env python3
+
+# SPDX-License-Identifier: GPL-2.0-only
+# Copyright 2020 Collabora
+
+import argparse
+import enum
+import logging
+import re
+import subprocess
+import sys
+import os
+import v4l2lib
+
+BUS_INFO = "platform:rkisp1"
+MODULE = "rockchip_isp1"
+
+# --------------------------------------------------------
+# Generic v4l2 functions
+# --------------------------------------------------------
+
+libcamera_dic = {
+ "YUYV" : "YUYV",
+ "422P" : None,
+ "NV16" : "NV16",
+ "NV61" : "NV61",
+ "YM61" : None,
+ "NV21" : "NV21",
+ "NV12" : "NV12",
+ "NM21" : None,
+ "NM12" : None,
+ "YU12" : None,
+ "YV12" : None,
+ "GREY" : "R8"
+}
+
+v4l2_ffmpeg_fmt = {
+ "422P" : "yuv422p",
+ "YM24" : "yuv444p",
+ "YU12" : "yuv420p",
+ "YV12" : "yuv420p", #this will swap the colors but ffmpeg has no support for yvu
+ "NV12" : "nv12",
+ "NV21" : "nv21",
+ "NM12" : "nv12",
+ "NM21" : "nv21",
+# The nv16 does not work on ffplay :(
+# "NV16" : "nv16",
+ "BA24" : "argb",
+ "GREY" : "gray",
+ "YUYV" : "yuyv422",
+ "RGBP" : "rgb565le",
+ "RGB3" : "rgb24",
+ "XR24" : "bgr0"
+}
+
+rsz_yuv_fmts = [ "YUYV8_2X8", "YUYV8_1_5X8"]
+
+pix_mbus_bayer_map = {
+'RGGB' : 'SRGGB8_1X8',
+'GRBG' : 'SGRBG8_1X8',
+'GBRG' : 'SGBRG8_1X8',
+'BA81' : 'SBGGR8_1X8',
+'RG10' : 'SRGGB10_1X10',
+'BA10' : 'SGRBG10_1X10',
+'GB10' : 'SGBRG10_1X10',
+'BG10' : 'SBGGR10_1X10',
+'RG12' : 'SRGGB12_1X12',
+'BA12' : 'SGRBG12_1X12',
+'GB12' : 'SGBRG12_1X12',
+'BG12' : 'SBGGR12_1X12',
+}
+
+pix_mbus_rsz_map = {
+ "422P" : "YUYV8_2X8",
+ "GREY" : "YUYV8_2X8",
+ "NM12" : "YUYV8_1_5X8",
+ "NM21" : "YUYV8_1_5X8",
+ "NV12" : "YUYV8_1_5X8",
+ "NV16" : "YUYV8_2X8",
+ "NV21" : "YUYV8_1_5X8",
+ "NV61" : "YUYV8_2X8",
+ "RGBP" : "YUYV8_2X8",
+ "VYUY" : "YUYV8_2X8",
+ "XR24" : "YUYV8_2X8",
+ "YM61" : "YUYV8_2X8",
+ "YU12" : "YUYV8_1_5X8",
+ "YUYV" : "YUYV8_2X8",
+ "YV12" : "YUYV8_1_5X8",
+ "YVYU" : "YUYV8_2X8",
+}
+
+pix_mbus_map = { **pix_mbus_bayer_map, **pix_mbus_rsz_map}
+
+# run a shell command.
+# by default wait for the command to finish and return its output.
+# if called with wait=False, then run the command and return
+# immediately. The return value is then the the handle to the subprocess.
+# the calling function can use it to wait
+# wait=False is used for simultaneous streaming
+def run(cmd, wait=True):
+ logging.debug(" ".join(['"{0}"'.format(x) for x in cmd]))
+ if wait:
+ try:
+ proc = subprocess.run(cmd, capture_output=True, check=True, timeout=10)
+ except subprocess.CalledProcessError as e:
+ logging.error(e.stdout.decode('ascii'))
+ raise
+ return proc.stdout.decode('ascii')
+ else:
+ try:
+ proc = subprocess.Popen(cmd)
+ except subprocess.CalledProcessError as e:
+ logging.error(e.stdout.decode('ascii'))
+ raise
+ return proc
+
+def find_sensor():
+ topo = run(["media-ctl", "-d", BUS_INFO, "-p"])
+ entities = re.findall("^- entity \d+:.*\n", topo, re.MULTILINE)
+ for ent in entities:
+ if "rkisp1" not in ent:
+ sensor = re.search("^- entity \d+: (.+) \(", ent)
+ sensor = sensor.group(1)
+ logging.debug("found sensor " + sensor)
+ return sensor
+ return None
+
+def get_subdev_fmt(entity, pad):
+ padprop = run(["media-ctl", "-d", BUS_INFO, "--get-v4l2",
+ '"{entity}":{pad}'.format(entity=entity, pad=pad)])
+ fmt = re.search("fmt:(.*?)/(\d+)x(\d+)", padprop)
+ bounds = re.search("crop.bounds:\((\d+),(\d+)\)/(\d+)x(\d+)", padprop)
+ crop = re.search("crop:\((\d+),(\d+)\)/(\d+)x(\d+)", padprop)
+ ret = {
+ "mbus": fmt.group(1),
+ "size": tuple(map(int, (fmt.group(2), fmt.group(3))))
+ }
+ if bounds:
+ ret["crop_bounds"] = tuple(map(int, bounds.groups()))
+ if crop:
+ ret["crop"] = tuple(map(int, crop.groups()))
+
+ return ret
+
+
+def set_subdev_fmt(entity, pad, fmt):
+ curr_fmt = get_subdev_fmt(entity, pad)
+
+ if not fmt:
+ return curr_fmt
+
+ logging.debug("set format for {entity}:{pad}".format(entity=entity,pad=pad))
+ logging.debug("old format: {curr}".format(curr=curr_fmt))
+
+ if "size" in fmt:
+ curr_fmt["size"] = fmt["size"]
+ if "mbus" in fmt:
+ curr_fmt["mbus"] = fmt["mbus"]
+ if "crop" in fmt:
+ curr_fmt["crop"] = fmt["crop"]
+ logging.debug("cropping")
+
+ # we have no control on the behaviour of the sensor
+ # the imx219 for example have "crop" as read only
+ # so we have to delete it, otherwise the media-ctl command fails
+ if entity == args.sensor:
+ del(curr_fmt["crop"])
+ properties = "fmt:{mbus}/{width}x{height}".format(mbus=curr_fmt["mbus"],
+ width=curr_fmt["size"][0],
+ height=curr_fmt["size"][1])
+ if ("crop" in curr_fmt):
+ crop = " crop: ({left},{top})/{width}x{height}".format(left=curr_fmt["crop"][0],
+ top=curr_fmt["crop"][1],
+ width=curr_fmt["crop"][2],
+ height=curr_fmt["crop"][3])
+ properties = properties + crop
+
+ run(["media-ctl", "-d", BUS_INFO, "--set-v4l2",
+ '"{entity}":{pad} [{properties}]'.format(entity=entity,
+ pad=pad,
+ properties=properties)])
+
+ updated_fmt = get_subdev_fmt(entity, pad)
+
+ logging.debug("new format: {new}".format(new=updated_fmt))
+ return updated_fmt
+
+
+def get_video_fmt(entity):
+ fmt = run(["v4l2-ctl", "-z", BUS_INFO, "-d", str(entity), "-V"])
+ size = re.search("(\d+)/(\d+)", fmt)
+ pixelformat = re.search("'(.*?)'", fmt)
+ return {
+ "size": (int(size.group(1)), int(size.group(2))),
+ "pixelformat": pixelformat.group(1)
+ }
+
+
+def set_video_fmt(entity, fmt):
+ properties = ""
+ if "size" in fmt:
+ size = "width={width},height={height},".format(width=fmt["size"][0],
+ height=fmt["size"][1])
+ properties = properties + size
+ if "pixelformat" in fmt:
+ pixfmt = "pixelformat={pixelformat}"
+ properties = properties + pixfmt.format(pixelformat=fmt["pixelformat"])
+
+ run(["v4l2-ctl", "-z", BUS_INFO, "-d", str(entity), "-v", properties])
+
+ current_fmt = get_video_fmt(entity)
+ if (
+ ("size" in fmt and fmt["size"] != current_fmt["size"]) or
+ ("pixelformat" in fmt and
+ fmt["pixelformat"] != current_fmt["pixelformat"])
+ ):
+ error_msg = "{entity}: Format couldn't be set. " \
+ "Expected {expected}; Got {got}"
+ raise Exception(error_msg.format(entity=entity, expected=fmt, got=current_fmt))
+ return current_fmt
+
+def disable_links():
+ run(["media-ctl", "-r"])
+
+def get_mbus_codes(entity, pad):
+ output = run(["v4l2-ctl", "-z", BUS_INFO, "-d", str(entity),
+ "--list-subdev-mbus-codes", str(pad)])
+ return re.findall("MEDIA_BUS_FMT_([^,]+)", output)
+
+def get_pixelformats(entity):
+ output = run(["v4l2-ctl", "-z", BUS_INFO, "-d", str(entity),
+ "--list-formats"])
+ return re.findall("'([A-Z0-9_]*)'", output)
+
+def get_expected_file_size(n_frames, entity):
+ fmt = get_video_fmt(entity)
+ pix = fmt["pixelformat"]
+ return int(n_frames) * fmt["size"][0] * fmt["size"][1] * v4l2lib.V4L2_PIX_MUL[pix] / v4l2lib.V4L2_PIX_DIV[pix]
+
+def set_file_name_for_stream(entity):
+ if not args.store:
+ return None
+
+ fmt = get_video_fmt(entity)
+ out_file = "{out}/stream-{path}-{w}x{h}-{pixfmt}.raw".format(out=args.output,
+ path=str(entity),
+ w=fmt["size"][0], h=fmt["size"][1],
+ pixfmt=fmt["pixelformat"])
+
+ if fmt["pixelformat"] in v4l2_ffmpeg_fmt:
+ ffplay_file = "{out}/ffplay.sh".format(out=args.output)
+ with open(ffplay_file, "a") as ff:
+ cmd = "ffplay -f rawvideo -pixel_format {pixfmt} -video_size {w}x{h} {f}\n"
+ cmd = cmd.format(pixfmt=v4l2_ffmpeg_fmt[fmt["pixelformat"]], w=fmt["size"][0], h=fmt["size"][1],f=out_file)
+ ff.write(cmd)
+ return out_file
+
+
+#the wait argument will be False when testing simultaneous streaming
+def start_stream(entity, out_file=None, wait=True, n_frames = "1"):
+ stream_cmd = ["v4l2-ctl", "-z", BUS_INFO, "-d", str(entity), "--stream-mmap",
+ "--stream-count", n_frames]
+ if out_file:
+ stream_cmd = stream_cmd + ["--stream-to", out_file]
+ logging.debug("will capture stream to file {f}".format(f=out_file))
+
+ ret = run(stream_cmd,wait=wait)
+
+
+ if args.compliance and wait:
+ output = run(["v4l2-compliance", "-z", BUS_INFO, "-d", str(entity), "-s", n_frames])
+ logging.debug(output)
+ return ret
+
+class LimDim(enum.IntEnum):
+ RSZ_MP_SRC_MAX_WIDTH = 4416
+ RSZ_MP_SRC_MAX_HEIGHT = 3312
+ RSZ_SP_SRC_MAX_WIDTH = 1920
+ RSZ_SP_SRC_MAX_HEIGHT = 1920
+ RSZ_SRC_MIN_WIDTH = 32
+ RSZ_SRC_MIN_HEIGHT = 16
+
+
+class Link(enum.IntEnum):
+ ENABLED = 1
+ ENABLE = 1
+ DISABLED = 0
+ DISABLE = 0
+
+class Entities(enum.Enum):
+ isp = "rkisp1_isp"
+ resizer_mp = "rkisp1_resizer_mainpath"
+ resizer_sp = "rkisp1_resizer_selfpath"
+ cap_mp = "rkisp1_mainpath"
+ cap_sp = "rkisp1_selfpath"
+
+ def __str__(self):
+ return str(self.value)
+
+class IspPads(enum.IntEnum):
+ SINK_VIDEO = 0,
+ SINK_PARAMS = 1,
+ SOURCE_VIDEO = 2,
+ SOURCE_STATS = 3,
+
+ def __str__(self):
+ return str(self.value)
+
+class ResizerPads(enum.IntEnum):
+ SINK = 0,
+ SOURCE = 1,
+
+def rkisp1_is_link_to_sink_enabled(sink_entity, sink_pad):
+ topology = run(["media-ctl", "-d", BUS_INFO, "-p"])
+ pattern = '"{sink_entity}":{sink_pad} \[(.+?)\]'
+ pattern = pattern.format(sink_entity=sink_entity, sink_pad=sink_pad)
+ status = re.findall(pattern, topology)
+ if 'ENABLED' in status or 'ENABLED,IMMUTABLE' in status:
+ return True
+ else:
+ return False
+
+def rkisp1_set_link(src_entity, src_pad, sink_entity, sink_pad, is_on=1):
+ link = "'{src_entity}':{src_pad} -> '{sink_entity}':{sink_pad} [{is_on}]"
+ link = link.format(src_entity=src_entity,
+ src_pad=src_pad,
+ sink_entity=sink_entity,
+ sink_pad=sink_pad, is_on=is_on)
+ run(["media-ctl", "-d", BUS_INFO, "-l", link])
+ is_en = rkisp1_is_link_to_sink_enabled(sink_entity, sink_pad)
+ if (is_en and not is_on) or (not is_en and is_on):
+ raise Exception("Couldn't set link {link}".format(link=link))
+
+def rkisp1_disable_link(src_entity, src_pad, sink_entity, sink_pad):
+ rkisp1_set_link(src_entity, src_pad, sink_entity, sink_pad, is_on=0)
+
+def rkisp1_enable_link(src_entity, src_pad, sink_entity, sink_pad):
+ rkisp1_set_link(src_entity, src_pad, sink_entity, sink_pad, is_on=1)
+
+def rkisp1_propagate_resizer_fmt(resizer, src_fmt=None):
+ pfmt = set_subdev_fmt(resizer, ResizerPads.SOURCE, src_fmt)
+ if resizer == Entities.resizer_sp:
+ set_video_fmt(Entities.cap_sp, pfmt)
+ else:
+ set_video_fmt(Entities.cap_mp, pfmt)
+
+# Note, for the isp source format, only the crop can change on the sink pad
+# since the format should be the same as the sensor
+# otherwise we get EPIPE
+# for now we support cropping only in the sink
+# and the mbus format of the source
+def rkisp1_propagate_isp_fmt(src_fmt=None, sink_fmt=None):
+ set_subdev_fmt(Entities.isp, IspPads.SINK_VIDEO, sink_fmt)
+ pfmt = set_subdev_fmt(Entities.isp, IspPads.SOURCE_VIDEO, src_fmt)
+ # this settings already include cropping
+ set_subdev_fmt(Entities.resizer_mp, ResizerPads.SINK, pfmt)
+ set_subdev_fmt(Entities.resizer_sp, ResizerPads.SINK, pfmt)
+
+def rkisp1_propagate_sensor_fmt(src_fmt=None):
+ pfmt = set_subdev_fmt(args.sensor, 0, src_fmt)
+ set_subdev_fmt(Entities.isp, IspPads.SINK_VIDEO, pfmt)
+
+# Put the driver in a known state
+def rkisp1_prepare_test():
+ disable_links()
+ rkisp1_enable_link(args.sensor, 0, Entities.isp, IspPads.SINK_VIDEO)
+ rkisp1_enable_link(Entities.isp, IspPads.SOURCE_VIDEO,
+ Entities.resizer_mp, ResizerPads.SINK)
+ rkisp1_enable_link(Entities.isp, IspPads.SOURCE_VIDEO,
+ Entities.resizer_sp, ResizerPads.SINK)
+
+ rkisp1_propagate_sensor_fmt(src_fmt={"size": (800, 600)})
+ rkisp1_propagate_isp_fmt(src_fmt={"mbus" : "YUYV8_2X8", "crop": (0,0,800,600)},sink_fmt={"crop" : (0,0,800,600)})
+ rkisp1_propagate_resizer_fmt(Entities.resizer_mp, src_fmt={"size":(800,600)})
+ rkisp1_propagate_resizer_fmt(Entities.resizer_sp, src_fmt={"size":(800,600)})
+ set_video_fmt(Entities.cap_mp, {"pixelformat": "NV12"})
+ set_video_fmt(Entities.cap_sp, {"pixelformat": "NV12"})
+ logging.debug("end of test prepare")
+
+def test_debugfs():
+ debugfs_files = [ "outform_size_err", "img_stabilization_size_error", "inform_size_error"]
+ for dfs in debugfs_files:
+ dfs_path = "/sys/kernel/debug/rkisp1/" + dfs
+ with open(dfs_path) as de:
+ if de.read(1) != '0':
+ raise Exception("the debugfs file {dfs} indicates an error".format(dfs=dfs_path))
+
+
+# --------------------------------------------------------
+# rkisp1 tests
+# --------------------------------------------------------
+def configure_and_stream(pixelformat, path, isp_dim, resizer_dim):
+ caps = []
+ resizers = []
+
+ for p in path:
+ if p == "mainpath":
+ resizers.append(Entities.resizer_mp)
+ caps.append(Entities.cap_mp)
+ other_resizer = Entities.resizer_sp
+ elif p == "selfpath":
+ resizers.append(Entities.resizer_sp)
+ caps.append(Entities.cap_sp)
+ other_resizer = Entities.resizer_mp
+ else:
+ logging.error("bad path value '{path}' only selfpath and mainpath are supported".format(path=path))
+ return
+
+ if len(caps) == 0:
+ logging.error("at least one path is needed")
+ return
+
+ rkisp1_prepare_test()
+ if len(caps) == 1:
+ rkisp1_disable_link(Entities.isp, IspPads.SOURCE_VIDEO,
+ other_resizer, ResizerPads.SINK)
+
+ sensor_fmt = None
+ isp_sink_fmt = None
+ isp_src_fmt = {}
+ rsz_fmt = None
+
+ pix0 = pixelformat[0]
+ if pix0 in pix_mbus_rsz_map:
+ isp_src_fmt["mbus"] = "YUYV8_2X8"
+ elif pix0 in pix_mbus_bayer_map:
+ isp_src_fmt["mbus"] = pix_mbus_bayer_map[pix0]
+ else:
+ logging.error("bad pixelformat: {p}".format(p=pix0))
+ return
+
+ if isp_dim:
+ isp_width = re.match("(\d+)x(\d+)", isp_dim).group(1)
+ isp_height = re.match("(\d+)x(\d+)", isp_dim).group(2)
+ sensor_fmt={"size" : tuple([isp_width,isp_height])}
+ isp_sink_fmt={"crop" : tuple([0,0,isp_width,isp_height])}
+ isp_src_fmt["crop"] = tuple([0,0,isp_width,isp_height])
+
+ rkisp1_propagate_sensor_fmt(src_fmt=sensor_fmt)
+ rkisp1_propagate_isp_fmt(src_fmt=isp_src_fmt, sink_fmt=isp_sink_fmt)
+
+ #we first loop the two paths to configure the whole topology
+ for (resz_dim, pixfmt, cap, resz) in zip(resizer_dim, pixelformat, caps, resizers):
+
+ pixfmts = get_pixelformats(cap)
+
+ if pixfmt not in pixfmts:
+ logging.info("given pixelformat {p} is not supported, possible values are:".format(p=pixfmt))
+ for p in pixfmts:
+ logging.info(p)
+ return
+
+ rsz_width = re.match("(\d+)x(\d+)", resz_dim).group(1)
+ rsz_height = re.match("(\d+)x(\d+)", resz_dim).group(2)
+ rsz_fmt={"size" : tuple([rsz_width,rsz_height])}
+ rsz_fmt["mbus"] = pix_mbus_map[pixfmt]
+
+ rkisp1_propagate_resizer_fmt(resz, src_fmt=rsz_fmt)
+ set_video_fmt(cap, {"pixelformat": pixfmt})
+ # after EVERYTHING is configured we start streaming
+ n_frames = '5' if len(caps) > 1 else '1'
+ handles = []
+ out_files = []
+ for cap in caps:
+ out_file = set_file_name_for_stream(cap)
+ handles.append(start_stream(cap, out_file=out_file, wait=(len(caps) == 1), n_frames=n_frames))
+ if out_file:
+ out_files.append(out_file)
+
+ # if we run both mainpath and selfpath together then wait both of them to finish.
+ if (len(caps) > 1):
+ for h in handles:
+ h.wait()
+ for (f,cap) in zip(out_files,caps):
+ file_size = os.path.getsize(f)
+ expected_size = get_expected_file_size(n_frames, cap)
+ if (file_size != expected_size):
+ raise Exception("file size is {fs}, expected size is {es}".format(fs=file_size, es=expected_size))
+
+ test_debugfs()
+
+def cam_streamer(pixelformat, width, height):
+
+ n_frames = '10'
+ cam_file="{out}/cam-{p}-{w}-{h}.raw".format(out=args.output, p=pixelformat, w=width, h=height)
+ cam_cmd = ['cam','-c', '1', '--capture=' + n_frames, '-s', "pixelformat={p},width={w},height={h}".format(p=pixelformat,w=width,h=height)]
+
+ if args.store:
+ cam_file="{out}/cam-{p}-{w}-{h}.raw".format(out=args.output, p=pixelformat, w=width, h=height)
+ cam_cmd = cam_cmd + ["--file={f}".format(f=cam_file)]
+ logging.debug("will capture stream to file {f}".format(f=cam_file))
+
+ run(cam_cmd)
+ test_debugfs()
+
+def automatic_tests():
+ fmts = ["YUYV", "422P","NV16","NV61","YM61","NV21","NV12","NM21","NM12","YU12","YV12","GREY" ]
+
+
+ for fmt in fmts:
+ logging.info("pixel {p}".format(p=fmt))
+ logging.info("mainpath")
+ configure_and_stream(pixelformat=[fmt], path=["mainpath"], isp_dim="1920x1080", resizer_dim=["1900x1000"])
+ logging.info("selfpath")
+ configure_and_stream(pixelformat=[fmt], path=["selfpath"], isp_dim="1620x1000", resizer_dim=["900x100"])
+ if args.cam and libcamera_dic[fmt]:
+ logging.info("cam")
+ cam_streamer(libcamera_dic[fmt], 1000, 1000)
+
+ logging.info("Simultaneous streaming:")
+
+ configure_and_stream(pixelformat=["YUYV","NV12"], path=["mainpath","selfpath"], isp_dim="1920x1080", resizer_dim=["1900x1000","800x1100"])
+ configure_and_stream(pixelformat=["YV12","NV61"], path=["mainpath","selfpath"], isp_dim="1920x1080", resizer_dim=["1900x500","800x700"])
+
+if __name__ == "__main__":
+ rformatter = argparse.RawDescriptionHelpFormatter
+ parser = argparse.ArgumentParser(formatter_class=rformatter, description='''TL;DR: just run `python3 test-rkisp1.py`.\n
+ This is a tests script for rkisp1 driver. There are two ways to run the script, either by using
+ a hardcoded set of tests, or by giving parameters for a custom test (see 'customized test' options).\n
+ To run a custom test, you should define all the parameters under the 'customized test' section.
+ If both selfpath and mainpath are given in the '--path' option then the '--pixelformat' and '--resizer-dim'
+ should also have two values, one for each path.
+ For example:
+ Configure selfpath to YUYV,640x480 and mainpath to NV12,800x600:\n
+ python3 ./test-rkisp1.py -p selfpath mainpath -P YUYV NV12 --isp-dim 640x480 --resizer-dim 640x480 800x600 -S\n
+ The script was developed for python version 3.7.6 and might not work with other versions.
+
+ ''')
+ parser.add_argument("-v", "--verbose", help="verbose output, logs are printed to stdout and to {outputdir}/log.txt", action="store_true")
+ parser.add_argument("-s", "--sensor", help="sensor to use. If not given, then the first sensor found is used")
+ parser.add_argument("-o", "--output", help="directory to add output streams. Default is current directory '.'", default=".")
+ parser.add_argument("-S", "--store", help="store stream to output folder", action="store_true")
+ parser.add_argument("-c", "--compliance", help="run compliance tests when streaming", action="store_true")
+ parser.add_argument("-C", "--cam", help="also run some tests with the 'cam' command from libcamera", action="store_true")
+ group = parser.add_argument_group('customized test', 'those options are for running specific tests of you own.')
+ group.add_argument("-P", "--pixelformat", nargs="+", help="the pixelformat(s)")
+ group.add_argument("-p", "--path", nargs="+", help="the stream path. Allowed values are 'selfpath', 'mainpath'")
+ group.add_argument("--isp-dim", help="the {width}x{height} of the isp output.")
+ group.add_argument("--resizer-dim", nargs="+", help="the {width}x{height} of the final image")
+
+ args = parser.parse_args()
+
+ if args.verbose:
+ level = logging.DEBUG
+ else:
+ level = logging.INFO
+
+ logfile = "{output_folder}/log.txt".format(output_folder=args.output)
+ logging.basicConfig(level=level, filename=logfile, filemode='w')
+
+ # define a Handler which writes INFO messages or higher to the sys.stderr
+ console = logging.StreamHandler()
+ console.setLevel(level)
+
+ # add the handler to the root logger
+ logging.getLogger('').addHandler(console)
+
+ if not args.sensor:
+ args.sensor = find_sensor()
+ logging.info("Saving logs at " + logfile)
+ logging.info("Testing with sensor " + args.sensor)
+ logging.info("Output directory " + args.output)
+
+
+ # now we parse all the options of the customized tests.
+ # if all of them are set we run only the customized test
+ # if none of them are set, we run our tests.
+ # if only some of them are set we return error
+ if (args.pixelformat and args.path and args.isp_dim and args.resizer_dim):
+ configure_and_stream(pixelformat=args.pixelformat, path=args.path, isp_dim=args.isp_dim, resizer_dim=args.resizer_dim)
+ exit(0)
+ elif (args.pixelformat or args.path or args.isp_dim or args.resizer_dim):
+ logging.error("For customized test all customized test options should be given")
+ exit(1)
+
+ automatic_tests()
diff --git a/contrib/test/v4l2lib.py b/contrib/test/v4l2lib.py
new file mode 100644
index 00000000..fdfbf790
--- /dev/null
+++ b/contrib/test/v4l2lib.py
@@ -0,0 +1,90 @@
+import enum
+
+class FmtTypes(enum.IntEnum):
+ BAYER = 0
+ YUV = 1
+ RGB = 2
+
+CAP_FORMAT_TYPES = {
+ "YUYV": FmtTypes.YUV, # (YUYV 4:2:2)
+ "YVYU": FmtTypes.YUV, # (YVYU 4:2:2)
+ "VYUY": FmtTypes.YUV, # (VYUY 4:2:2)
+ "422P": FmtTypes.YUV, # (Planar YUV 4:2:2)
+ "NV16": FmtTypes.YUV, # (Y/CbCr 4:2:2)
+ "NV61": FmtTypes.YUV, # (Y/CrCb 4:2:2)
+ "YM61": FmtTypes.YUV, # (Planar YVU 4:2:2 (N-C))
+ "NV21": FmtTypes.YUV, # (Y/CrCb 4:2:0)
+ "NV12": FmtTypes.YUV, # (Y/CbCr 4:2:0)
+ "NM21": FmtTypes.YUV, # (Y/CrCb 4:2:0 (N-C))
+ "NM12": FmtTypes.YUV, # (Y/CbCr 4:2:0 (N-C))
+ "YU12": FmtTypes.YUV, # (Planar YUV 4:2:0)
+ "YV12": FmtTypes.YUV, # (Planar YVU 4:2:0)
+ "YM24": FmtTypes.YUV, # (Planar YUV 4:4:4 (N-C))
+ "GREY": FmtTypes.YUV, # (8-bit Greyscale)
+ "RGGB": FmtTypes.BAYER, # (8-bit Bayer RGRG/GBGB)
+ "GRBG": FmtTypes.BAYER, # (8-bit Bayer GRGR/BGBG)
+ "GBRG": FmtTypes.BAYER, # (8-bit Bayer GBGB/RGRG)
+ "BA81": FmtTypes.BAYER, # (8-bit Bayer BGBG/GRGR)
+ "RG10": FmtTypes.BAYER, # (10-bit Bayer RGRG/GBGB)
+ "BA10": FmtTypes.BAYER, # (10-bit Bayer GRGR/BGBG)
+ "GB10": FmtTypes.BAYER, # (10-bit Bayer GBGB/RGRG)
+ "BG10": FmtTypes.BAYER, # (10-bit Bayer BGBG/GRGR)
+ "RG12": FmtTypes.BAYER, # (12-bit Bayer RGRG/GBGB)
+ "BA12": FmtTypes.BAYER, # (12-bit Bayer GRGR/BGBG)
+ "GB12": FmtTypes.BAYER, # (12-bit Bayer GBGB/RGRG)
+ "BG12": FmtTypes.BAYER, # (12-bit Bayer BGBG/GRGR)
+ "BGRH" : FmtTypes.RGB, # (18 BGR-6-6-6), V4L2_PIX_FMT_BGR666
+ "RGBP" : FmtTypes.RGB, # (16 RGB-5-6-5), V4L2_PIX_FMT_RGB565
+ "RGB3" : FmtTypes.RGB, # (24 RGB-8-8-8), V4L2_PIX_FMT_RGB24
+}
+
+ISP_FORMAT_TYPES = {
+ "YUYV8_2X8": FmtTypes.YUV,
+ "SRGGB10_1X10": FmtTypes.BAYER,
+ "SBGGR10_1X10": FmtTypes.BAYER,
+ "SGBRG10_1X10": FmtTypes.BAYER,
+ "SGRBG10_1X10": FmtTypes.BAYER,
+ "SRGGB12_1X12": FmtTypes.BAYER,
+ "SBGGR12_1X12": FmtTypes.BAYER,
+ "SGBRG12_1X12": FmtTypes.BAYER,
+ "SGRBG12_1X12": FmtTypes.BAYER,
+ "SRGGB8_1X8": FmtTypes.BAYER,
+ "SBGGR8_1X8": FmtTypes.BAYER,
+ "SGBRG8_1X8": FmtTypes.BAYER,
+ "SGRBG8_1X8": FmtTypes.BAYER,
+ "YUYV8_1X16": FmtTypes.YUV,
+ "YVYU8_1X16": FmtTypes.YUV,
+ "UYVY8_1X16": FmtTypes.YUV,
+ "VYUY8_1X16": FmtTypes.YUV,
+}
+
+V4L2_PIX_MUL = {
+ "YUYV": 2,
+ "422P": 2,
+ "NV16": 2,
+ "NV61": 2,
+ "YM61": 2,
+ "NV21": 3,
+ "NV12": 3,
+ "NM21": 3,
+ "NM12": 3,
+ "YU12": 3,
+ "YV12": 3,
+ "GREY": 1
+}
+
+V4L2_PIX_DIV = {
+ "YUYV": 1,
+ "422P": 1,
+ "NV16": 1,
+ "NV61": 1,
+ "YM61": 1,
+ "NV21": 2,
+ "NV12": 2,
+ "NM21": 2,
+ "NM12": 2,
+ "YU12": 2,
+ "YV12": 2,
+ "GREY": 1
+}
+
--
2.17.1
