Hi Dafna, On 11/10/20 8:35 AM, Dafna Hirschfeld wrote: > 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> Thanks for this work! Could you please fix the issues found by pycodestyle tool? Example: pycodestyle --show-source --show-pep8 contrib/test/test-rkisp1.py project page: https://pypi.org/project/pycodestyle/ Also, this is my log.txt http://ix.io/2DTZ Maybe this could be improved a bit to show which tests suceeded, failed or have warnings, what do you think? Thanks Helen > --- > 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 > +} > + >
