def main():
seqs = cfg.sequences
seq_names = cfg.class_sequence_names
version = 2
outname = r"kvz_gop_level_search_param_selection"
bin_vers = [
None, r"TZ1", r"TZ2", r"TZ3", r"F2_2_0", r"F1_1_0", r"F2_2_1", r"F3-1",
r"F3-2", r"F2-1", r"F1-1", r"F3-3", r"FF"
]
base_bin = f"D:\\bins\\kvz_v{version}.exe"
shared_param = ("--preset", "veryslow", "-p", "256", "--transform-skip")
#veryslow = ("--preset", "veryslow")
#ultrafast = ("--preset", "ultrafast")
tpg = TU.TestParameterGroup()
tpg.add_const_param(input_names = seq_names,
layer_args = shared_param,
inputs = seqs,
validate = False,
version = version) \
.add_param_set(bin_name = bin_vers,
_me = ['tz', 'hexbs'])
tpg.set_param_group_transformer(
TU.transformerFactory(
bin_name=lambda *, bin_name, **_: f"D:\\bins\\kvz_{bin_name}.exe"
if bin_name else base_bin,
test_name=lambda *, bin_name, _me, **_:
(bin_name if bin_name else "kvz") + "_" + _me,
layer_args=lambda *, layer_args, _me, **_: (layer_args +
('--me', _me), )))
tpg.filter_parameter_group(lambda *, _me, bin_name, **_: bin_name not in base_bin or _me in "tz")\
.filter_parameter_group(lambda *, _me, bin_name, **_: r"FF" not in bin_name or "hexbs" not in _me)
tests = tpg.to_kvz_test_instance()
summary = TU.make_BDBRMatrix_definition(TU.get_test_names(tests),
write_bits=False,
write_psnr=False)
summary2 = TU.make_AnchorList_singleAnchor_definition(
"kvz_tz",
TU.get_test_names(tests),
test_filter=lambda _, test: "TZ" not in test,
name="tz_anchor")
#summary3 = TU.make_AnchorList_singleAnchor_definition("kvz_hexbs", TU.get_test_names(tests), test_filter = lambda _, test: "kvz_tz" not in test, name="hexbs_anchor")
summary4 = TU.make_CurveChart_definition(
TU.get_test_names(tests),
filter_func=lambda t: t in ["F2_2_1_tz", "F2_2_0_tz", "kvz_tz"])
#summary5 = TU.make_CurveChart_definition(TU.get_test_names(tests), filter_func=lambda t: "veryslow" in t, name = "veryslow_curve")
#summary5["definition"]["charts"].extend([('psnr','rate'),('psnr','time'),('time','rate'),('time','psnr')])
runTests(tests, outname, summary, summary2, summary4)
def main():
seqs = cfg.sequences
seq_names = cfg.class_sequence_names
base_v = 5
new_v = base_v + 1
outname = f"kvz_conf_check_v{new_v}"
bin_vers = [f"kvz_v{base_v}", f"kvz_v{new_v}"]
shared_param = ("--preset", "ultrafast")
depth = [tuple(), ("--pu-depth-inter", "1-2", "--pu-depth-intra", "2-3")]
gop = [tuple(), ("--gop", "0"), ("--gop", "8")]
def has_bipred(b):
return (lambda _, t: ("bi" in t) == b)
tpg = TU.TestParameterGroup()
tpg.add_const_param(input_names = seq_names,
layer_args = shared_param,
inputs = seqs,
validate = False,
version = new_v) \
.add_param_set(_bin_name = bin_vers, _depth = depth, _gop = gop)
tpg.set_param_group_transformer(
TU.transformerFactory(
bin_name=lambda *, _bin_name, **_: cfg.bin_path + _bin_name +
".exe",
test_name=lambda *, _bin_name, _depth, _gop, **_: _bin_name +
("_depth" if _depth else "") + "_gop" + (_gop[1] if _gop else ""),
layer_args=lambda *, layer_args, _depth, _gop, **_: (
(layer_args + _depth + _gop), )))
tests = tpg.to_kvz_test_instance()
summary = [
TU.make_BDBRMatrix_definition(TU.get_test_names(tests),
write_bits=False,
write_psnr=False),
]
summary.append(
TU.make_AnchorList_multiAnchor_definition(
TU.get_test_names(tests), lambda test: [
a for a in TU.get_test_names(tests) if a.split('_')[2:] == test
.split('_')[2:] and a.split('_')[1] != test.split('_')[1]
], lambda test: f"v{new_v}" in test))
runTests(tests, outname, *summary)
def main():
seqs = cfg.sequences
seq_names = cfg.class_sequence_names
version = 4
outname = r"kvz_bframe_constraint"
bin_vers = [None, r"bframe_constr", r"bframe_constr_v2"]
base_bin = f"D:\\bins\\kvz_v{version}.exe"
shared_param = ("--preset", "ultrafast", "--gop", "8", "-p", "256", "--rd",
"1", "--subme", "1", "--pu-depth-intra", "2-3",
"--pu-depth-inter", "1-2", "--me-early-termination", "off",
"--bipred")
tpg = TU.TestParameterGroup()
tpg.add_const_param(input_names = seq_names,
layer_args = shared_param,
inputs = seqs,
validate = False,
version = version) \
.add_param_set(_bin_name = bin_vers)
tpg.set_param_group_transformer(
TU.transformerFactory(
bin_name=lambda *, _bin_name, **_: f"D:\\bins\\kvz_{_bin_name}.exe"
if _bin_name else base_bin,
test_name=lambda *, _bin_name, **_: ((_bin_name
if _bin_name else "kvz")),
layer_args=lambda *, layer_args, **_: (layer_args, )))
tests = tpg.to_kvz_test_instance()
summary = [
TU.make_BDBRMatrix_definition(TU.get_test_names(tests),
write_bits=False,
write_psnr=False),
]
summary.append(
TU.make_AnchorList_singleAnchor_definition(
bdbr_anchor="kvz",
bdbr_tests=TU.get_test_names(tests),
time_anchor="kvz",
time_tests=TU.get_test_names(tests)))
summary.append(TU.make_CurveChart_definition(TU.get_test_names(tests)))
runTests(tests, outname, *summary)
def main():
seqs = [(r"hevc-B\Kimono1_1920x1080_24.yuv",),
(r"hevc-B\Cactus_1920x1080_50.yuv",)]
tests = []
in_names = ["Kimono","Cactuar"]
name = "scale_test_low_qp_v2"
bl_qps = (7,12,17,22)#(22, 27, 32, 37)#(7,12,17,22)
el_qps = tuple(map(lambda x: x-5,bl_qps))
tests.append( skvzTestInstance(inputs = seqs,
test_name = "BL",
input_names = in_names,
qps = bl_qps,
layer_args = (("--preset","ultrafast","-n","5",'-r','1','--gop','0','--threads','3','--no-wpp'),),
input_layer_scales = (0.5,)
))
tests.append( skvzTestInstance(inputs = seqs,
test_name = "EL",
input_names = in_names,
qps = bl_qps,
layer_args = (("--preset","ultrafast","-n","5",'-r','1','--gop','0','--threads','3','--no-wpp'),),
input_layer_scales = (1,)
))
tests.append( skvzTestInstance(inputs = seqs,
test_name = "Scal",
input_names = in_names,
qps = bl_qps,#tuple(zip(bl_qps,el_qps)),
layer_args = (("--preset","ultrafast","-n","5",'-r','1','--gop','0'),
('--preset','ultrafast','-n','5','-r','0','--ilr','1','--gop','0','--threads','3','--no-wpp')),
input_layer_scales = (0.5,1)
))
runTests(tests, name,
layers={makeLayerCombiName(["BL","EL"]):(-1,),
"Scal":(-1,)},
# combi=[("EL","BL")],
layer_combi=[("BL","EL")])
def main():
seqs = cfg.sequences
seq_names = cfg.class_sequence_names
version = 3
outname = r"kvz_merge_cand_check_skip"
bin_vers = [
None, r"global_l1", r"global_l2", r"local_neqz", r"local_thresh",
*[f"local_thresh_bi_m{m}" for m in range(3)],
*[f"local_neqz_bi_m{m}" for m in range(3)]
]
base_bin = f"D:\\bins\\kvz_v{version}.exe"
shared_param = ("--preset", "ultrafast", "--gop", "8", "-p", "256", "--rd",
"1", "--subme", "1", "--pu-depth-intra", "2-3",
"--pu-depth-inter", "1-2", "--me-early-termination", "off")
bipred = [None, r"--bipred"]
#veryslow = ("--preset", "veryslow")
#ultrafast = ("--preset", "ultrafast")
def has_bipred(b):
return (lambda _, t: ("bi" in t) == b)
tpg = TU.TestParameterGroup()
tpg.add_const_param(input_names = seq_names,
layer_args = shared_param,
inputs = seqs,
validate = False,
version = version) \
.add_param_set(_bin_name = bin_vers, _bi = bipred)
tpg.filter_parameter_group(lambda *, _bin_name, _bi, **_: (
not _bi or not _bin_name) or ("bi" in _bin_name))
tpg.filter_parameter_group(lambda *, _bin_name, _bi, **_: True if (
_bi or not _bin_name) else not ("bi" in _bin_name))
tpg.set_param_group_transformer(
TU.transformerFactory(
bin_name=lambda *, _bin_name, **_: f"D:\\bins\\kvz_{_bin_name}.exe"
if _bin_name else base_bin,
test_name=lambda *, _bin_name, _bi, **_: (
(_bin_name if _bin_name else "kvz") + ("_bi" if _bi else "")),
layer_args=lambda *, layer_args, _bi, **_: (layer_args + (
(_bi, ) if _bi else tuple()), )))
tests = tpg.to_kvz_test_instance()
summary = [
TU.make_BDBRMatrix_definition(TU.get_test_names(tests),
write_bits=False,
write_psnr=False),
]
summary.append(
TU.make_AnchorList_singleAnchor_definition(
bdbr_anchor="kvz",
bdbr_tests=TU.get_test_names(tests),
time_anchor="kvz",
time_tests=TU.get_test_names(tests),
test_filter=has_bipred(False),
name="no_bipred_anchor"))
summary.append(
TU.make_AnchorList_singleAnchor_definition(
bdbr_anchor="kvz_bi",
bdbr_tests=TU.get_test_names(tests),
time_anchor="kvz_bi",
time_tests=TU.get_test_names(tests),
test_filter=has_bipred(True),
name="bipred_anchor"))
#summary3 = TU.make_AnchorList_singleAnchor_definition("kvz_hexbs", TU.get_test_names(tests), test_filter = lambda _, test: "kvz_tz" not in test, name="hexbs_anchor")
summary.append(
TU.make_CurveChart_definition(
TU.get_test_names(tests),
filter_func=lambda t: t in ["local_neqz", "local_thresh", "kvz"],
name="no_bipred_curve"))
#summary.append(TU.make_CurveChart_definition(TU.get_test_names(tests), filter_func=lambda t: t in ["local_neqz_bi", "local_thresh_bi", "kvz_bi"], name="bipred_curve"))
#summary5 = TU.make_CurveChart_definition(TU.get_test_names(tests), filter_func=lambda t: "veryslow" in t, name = "veryslow_curve")
#summary5["definition"]["charts"].extend([('psnr','rate'),('psnr','time'),('time','rate'),('time','psnr')])
runTests(tests, outname, *summary)
def main():
seqs = [(r"D:\stuff\Kimono1_960x540_24_zerophase_0.9pi.yuv",
cfg.sequence_path + r"hevc-B\Kimono1_1920x1080_24.yuv"),
(r"D:\stuff\Cactus_960x540_50_zerophase_0.9pi.yuv",
cfg.sequence_path + r"hevc-B\Cactus_1920x1080_50.yuv")]
const = (r"D:\stuff\encoder_my_scalable.cfg", r"D:\stuff\layers_no_mp.cfg")
confs = [
const + (r"D:\stuff\Kimono-2x.cfg", ),
const + (r"D:\stuff\Cactus-2x.cfg", )
]
confs_bl = [
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Kimono_halve.cfg"),
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Cactus_halve.cfg")
]
confs_el = [(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Kimono.cfg"),
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Cactus.cfg")]
tests = []
in_names = ["Kimono", "Cactuar"]
bl_qps = (22, 27, 32, 37) #(7,12,17,22) #(22, 27, 32, 37)
el_qps = bl_qps #tuple(map(lambda x: x-5,bl_qps))
tests.append(
shmTestInstance(
inputs=[(seq0, ) for (seq0, seq1) in seqs],
configs=confs_bl,
input_names=in_names,
qps=bl_qps,
layer_args=("-f", '5'),
#input_layer_scales = (0.5,),
test_name="BL"))
tests.append(
shmTestInstance(
inputs=[(seq1, ) for (seq0, seq1) in seqs],
configs=confs_el,
input_names=in_names,
qps=el_qps,
layer_args=("-f", '5'),
#input_layer_scales = (1,),
test_name="EL"))
tests.append(
shmTestInstance(
inputs=seqs,
configs=confs,
input_names=in_names,
qps=el_qps,
layer_args=("-f", '5'),
#layer_args = (("--preset","ultrafast","-n","5",'-r','1','--gop','0','--threads','0'),
# ('--preset','ultrafast','-n','5','-r','1','--gop','0','--threads','0')),
#input_layer_scales = (0.5,1)
test_name="Scal"))
runTests(
tests,
"shm_test_low_qp",
layers={
makeLayerCombiName(["BL", "EL"]): (-1, ),
"Scal": (-1, )
},
#combi=[("EL","BL")])#,
layer_combi=[("BL", "EL")])
def main():
seqs = cfg.sequences[cfg.hevc_A] + cfg.sequences[cfg.hevc_B]
in_names = cfg.class_sequence_names[cfg.hevc_A] + cfg.class_sequence_names[
cfg.hevc_B]
ver = 24
dqps = (0, -3, -9)
base_qp = (22, 27, 32, 37)
outname = "shm_ICIP2020_test_v{}".format(ver)
# Set shared param
HSCAL = "1.5x"
SCAL = "2x"
SNR = "SNR"
tpg_scal = TU.TestParameterGroup()
tpg_scal.add_const_param(version = ver,
input_names = in_names,
inputs = seqs) \
.add_param_set(_dqp = dqps,
_type = [SNR, SCAL, HSCAL]) \
.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or _dqp == 0 else False)
tpg_sim = tpg_scal.copy()
# Set scalable param
hscale = (1 / 1.5, 1)
scale = (0.5, 1)
snr_scale = (1, 1)
tpg_scal.filter_parameter_group(lambda *, _dqp, _type, **param: False
if _type == SNR and _dqp == 0 else True)
tpg_scal.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _dqp, _type, **param: "SCAL_{}_DQP{}".format(
_type, _dqp),
qps=lambda *, _dqp, **param: tuple(
zip(base_qp, [bqp + _dqp for bqp in base_qp])),
inputs=lambda *, _type, inputs, **param:
([(seq, seq) for (seq, ) in inputs])
if _type == SNR else TU.generate_scaled_seq_names(inputs, scale)
if _type == SCAL else TU.generate_scaled_seq_names(inputs, hscale),
configs=lambda *, _type, input_names, **param: [
(cfg.shm_cfg + "encoder_lowdelay_P_scalable.cfg", cfg.shm_cfg +
"layers.cfg", cfg.shm_cfg + seq.split("_")[
1] + "-" + _type + ".cfg") for seq in input_names
]))
# Set simulcast param
#BL = "BL"
#EL = "EL"
#tpg_sim.add_param_set(_layer=[BL,EL])
#tpg_sim.filter_parameter_group(lambda *, _dqp, _layer, **param: True if _layer != BL or _dqp == 0 else False) \
# .filter_parameter_group(lambda *, _layer, _type, **param: True if _layer != EL or _type == SNR else False)
tpg_sim.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _dqp, _type, **param: "{}_DQP{}".format(
_type, _dqp) if _type == SNR else "1÷{}".format(_type),
qps=lambda *, _dqp, **param: tuple(bqp + _dqp for bqp in base_qp),
configs=lambda *, input_names, **param: [
(cfg.shm_cfg + "encoder_lowdelay_P_scalable.cfg", cfg.shm_cfg +
seq.split("_")[1] + ".cfg") for seq in input_names
],
inputs=lambda *, inputs, _type, **param: inputs
if _type == SNR else TU.generate_scaled_seq_names(
inputs, (scale[0], ))
if _type == SCAL else TU.generate_scaled_seq_names(
inputs, (hscale[0], )),
input_layer_scales=lambda *, _type, **param: tuple()
if _type == SNR else (1, )))
#Run tests
tests_scal = tpg_scal.to_shm_test_instance()
tests_sim = tpg_sim.to_shm_test_instance()
combi = TU.generate_combi(
tpg_sim,
combi_cond=TU.combiFactory(
lambda g1, g2: (g1["_type"] == SNR == g2["_type"]) or
(g1["_type"] == SNR != g2["_type"] and g1["_dqp"] == 0) or
(g2["_type"] == SNR != g1["_type"] and g2["_dqp"] == 0),
_type=lambda t1, t2: -1 if t1 != SNR == t2 else 1
if t1 == SNR != t2 else t1 == t2,
_dqp=lambda d1, d2: True if d2 == d1 == 0 else d2
if d1 == 0 else (-d1 if d2 == 0 else 0)))
sim_names = TU.get_combi_names(combi)
test_names = TU.get_test_names(tests_scal) + sim_names
matrix_summary = TU.make_BDBRMatrix_definition(
test_names + TU.get_test_names(tests_sim),
write_bdbr=True,
write_bits=False,
write_psnr=False,
layering_func=lambda t:
(-1, 1), #(-1,1) if "SCAL" not in t else (-1,),
filter_func=lambda t: True
if len(t.split('_')) >= 3 or "SCAL" in t else False)
anchor_summary = TU.make_AnchorList_multiAnchor_definition(
test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in sim_names
if (t.split(sep='_')[1] in a) and (t.split(sep='_')[2] in a))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: (
None, ) + tuple((a, l) if l >= 0 else a for a in sim_names
if (t.split(sep='_')[1] in a) and
(t.split(sep='_')[2] in a) for l in [-1, 1])))
curve_summary1 = TU.make_CurveChart_definition(
test_names + TU.get_test_names(tests_sim),
filter_func=lambda x: ("2x" in x) or ("SNR_DQP0" == x or "1÷2x" == x))
curve_summary2 = TU.make_CurveChart_definition(
test_names + TU.get_test_names(tests_sim),
filter_func=lambda x:
("1.5x" in x) or ("SNR_DQP0" == x or "1÷1.5x" == x))
curve_summary3 = TU.make_CurveChart_definition(
test_names + TU.get_test_names(tests_sim),
filter_func=lambda x:
("DQP-3" in x) or ("SNR_DQP0" == x or "SNR_DQP-3" == x))
curve_summary4 = TU.make_CurveChart_definition(
test_names + TU.get_test_names(tests_sim),
filter_func=lambda x:
("DQP-9" in x) or ("SNR_DQP0" == x or "SNR_DQP-9" == x))
summaries = [
matrix_summary, anchor_summary, curve_summary1, curve_summary2,
curve_summary3, curve_summary4
]
tests = tests_scal + tests_sim
runTests(tests, outname, *summaries, layer_combi=combi)
def main():
seqs = cfg.sequences[cfg.hevc_A] + cfg.sequences[cfg.hevc_B]
in_names = cfg.class_sequence_names[cfg.hevc_A] + cfg.class_sequence_names[
cfg.hevc_B]
ver = 20
shared_param = ("--preset", "ultrafast", "--gop", "0", "--no-tmvp")
thread_range = (13, 14, 15, 16) #(4,6,8,10,12,14)
owf_range = (1, 2, 3) #(2,4,8,16)
outname = "skvz_thread_owf_test_v{}".format(ver)
# Set shared param
tpg_scal = TU.TestParameterGroup()
tpg_scal.add_const_param(version = ver,
bin_name = cfg.skvz_ver_bin.format(ver),
input_names = in_names,
layer_args = shared_param)\
.add_param_set(_thrd = thread_range,
_owf = owf_range)
tpg_sim = tpg_scal.copy()
# Set scalable param
round2 = lambda x, base=2: int(base * round(x / base))
strscale = lambda size, scale: "x".join(
map(lambda x: str(round2(int(x) * scale)),
re.search("_*(\d+)x(\d+)[_.]*", size).group(1, 2)))
seq_scale = lambda scale, st: (st[0], strscale(st[1], scale), st[2])
seq_map = lambda scale, seq: r"{}_{}_{}_zerophase_0.9pi.yuv".format(
*seq_scale(
scale,
re.search("(.+\\\\.+)_(\d+x\d+)_(\d+)[_.]", seq).group(1, 2, 3)))
bl_seq_map = lambda scale: lambda seq: (seq_map(scale[0], seq[0]), )
scal_seq_map = lambda scale: lambda seq: (seq_map(scale[0], seq[
0]), ) + seq #TODO: Add scaling to el seq?
scal_seqs = tuple(map(scal_seq_map((0.5, 1)), seqs))
tpg_scal.add_const_param(inputs=scal_seqs)
tpg_scal.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _thrd, _owf, **param: "SCAL_THRD{}_OWF{}".
format(_thrd, _owf),
layer_args=lambda *, layer_args, _thrd, _owf, **param:
(layer_args + ("--threads", str(_thrd)) +
("--owf", str(_owf)), layer_args + ("--threads", str(_thrd)) +
("--owf", str(_owf)))))
# Set simulcast param
tpg_sim.add_const_param(inputs = seqs)\
.add_param_set(_layer=("BL","EL"))
tpg_sim.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _layer, _thrd, _owf, **param: "{}_THRD{}_OWF{}"
.format(_layer, _thrd, _owf),
layer_args=lambda *, layer_args, _thrd, _owf, **param:
(layer_args + ("--threads", str(_thrd)) + ("--owf", str(_owf)), ),
inputs=lambda *, inputs, _layer, **param: tuple(
map(bl_seq_map((0.5, )), inputs))
if _layer in "BL" else inputs))
#Run tests
tests_scal = tpg_scal.to_skvz_test_instance()
tests_sim = tpg_sim.to_skvz_test_instance()
combi = TU.generate_combi(tpg_sim,
combi_cond=TU.combiFactory(
_thrd=op.eq,
_owf=op.eq,
_layer=lambda p1, p2: 0
if p1 == p2 else (-1 if p1 == "BL" else 1)))
sim_names = TU.get_combi_names(combi)
test_names = TU.get_test_names(tests_scal) + sim_names
matrix_summary = TU.make_BDBRMatrix_definition(
test_names + TU.get_test_names(tests_sim),
write_bdbr=True,
write_bits=False,
write_psnr=False,
layering_func=lambda t: (-1, 1) if "SCAL" not in t else (-1, ),
filter_func=lambda t: True
if ("BL" in t and "EL" in t) or "SCAL" in t else False)
anchor_summary = TU.make_AnchorList_multiAnchor_definition(
test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in sim_names
if (t.split(sep='_')[1] in a) and (t.split(sep='_')[2] in a))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: (
None, ) + tuple((a, l) if l >= 0 else a for a in sim_names
if (t.split(sep='_')[1] in a) and
(t.split(sep='_')[2] in a) for l in [-1, 1])))
summaries = {sn_BDBRM: matrix_summary, sn_ANCHOR: anchor_summary}
runTests(tests_scal + tests_sim, outname, layer_combi=combi, **summaries)
def main():
plus_shm = True
plus_threads = True
#################_Define_skvz_tests_#################
seqs = cfg.sequences[cfg.hevc_A] + cfg.sequences[cfg.hevc_B]
in_names = cfg.class_sequence_names[cfg.hevc_A] + cfg.class_sequence_names[cfg.hevc_B]
preset = 'ultrafast'#'veryslow'#'ultrafast'#"veryslow"#"ultrafast"
versions = [5, 6];
outname = "skvz_v{}_perf_test".format(6)
bl_snr_qps = (22, 27, 32, 37)#(26, 30, 34, 38) #SNR
bl_spat_qps = (22, 27, 32, 37)#(22, 26, 30, 34) #Spatial
#bl_qps = (22, 27, 32, 37)
delta_snr_qp = (-5,)#(-4,-6) #SNR
delta_spat_qp = (0,)#(0,2) #Spatial
dqps = (1,2,3,4,5,6,7,8,9,10)
el_snr_qps = [tuple(map(lambda x: x+dqp, bl_snr_qps)) for dqp in delta_snr_qp]
el_spat_qps = [tuple(map(lambda x: x+dqp, bl_spat_qps)) for dqp in delta_spat_qp]
scal_snr_qps = [ tuple(zip(bl_snr_qps,el_qps)) for el_qps in el_snr_qps ]
scal_spat_qps = [ tuple(zip(bl_spat_qps,el_qps)) for el_qps in el_spat_qps ]
shared_param = ("--preset",preset,'--gop','0')
thread_param = ('--threads','auto','--owf','auto','--wpp')
no_thread_param = ('--threads','0','--owf','1','--no-wpp','--cpuid','0')
tmvp =('--tmvp')
no_tmvp = ('--no-tmvp')
in_layer_0 = ('--input-layer','0')
in_layer_1 = ('--input-layer','1')
ref_frames = ('-r','1')
scal_ref_frames = ('--ilr','1')
bl_scale = (0.5,)
bl_snr_scale = (1,)
el_scale = (1,)
scal_scale = bl_scale + el_scale
scal_snr_scale = bl_snr_scale + el_scale
bl_halve_scale = (1/1.5,)
scal_halve_scale = bl_halve_scale + el_scale
SNR = "_SNR" #Spatial scalability not used
SCALED = "0.5X" #Downscaled by 0.5
HSCALED = "0.7X" #Downscaled by 1/1.5
SCAL = "2X" # 2x scalability
HSCAL = "1.5X" # 1.5x scalability
DQP1 = ""#"_DQP1" # First delta qp used
DQP2 = "_DQP2" # Second delta qp used
DQP = r"_DQP{}"
THRD = "_THRD" #Use threads
VER = "_v{}" #version
round2 = lambda x,base=2: int(base*round(x/base))
strscale = lambda size,scale: "x".join(map(lambda x: str(round2(int(x)*scale)),re.search("_*(\d+)x(\d+)[_.]*",size).group(1,2)))
seq_scale = lambda scale, st: (st[0], strscale(st[1],scale), st[2])
seq_map = lambda scale, seq: r"{}_{}_{}_zerophase_0.9pi.yuv".format( *seq_scale(scale,re.search("(.+\\\\.+)_(\d+x\d+)_(\d+)[_.]",seq).group(1,2,3)) )
bl_seq_map = lambda scale: lambda seq: (seq_map(scale[0], seq[0]),)
scal_seq_map = lambda scale: lambda seq: (seq_map(scale[0],seq[0]), ) + seq #TODO: Add scaling to el seq?
two_layer_param = [val for val in
((reduce(lambda x,y: x + y[0], param, "SC"),) + reduce(lambda x,y: x + y[1], param, tuple())
for param in
it.product(
[(SCAL,((1,1),tuple(map(scal_seq_map(scal_scale),seqs)))),("1X",(scal_snr_scale,seqs)),], #Scale
[(DQP1,(scal_spat_qps[0],)), (DQP1+SNR,(scal_snr_qps[0],)),], #Qp
[(THRD,(thread_param,)),],#[("",(tuple(),))]#[("",(no_thread_param,)),("_THRD",(thread_param,))], #Threads
[(VER.format(ver),((cfg.skvz_ver_bin.format(ver),ver),)) for ver in versions], #versions
)
) if ((SCAL in val[0] and not (SNR in val[0])) or (not (SCAL in val[0]) and SNR in val[0]))
]
tests = []
# Add scalable tests
for (name, scale, input, qp, thrd, ver) in two_layer_param:
tests.append( skvzTestInstance(
version = ver[1],
inputs = input,
input_names = in_names,
test_name = name,
qps = qp,
layer_args = (shared_param + ref_frames + thrd,
shared_param + ref_frames + scal_ref_frames + thrd),
input_layer_scales = scale,
bin_name = ver[0],
))
#################_Define_run_tests_parameters_#################
runTests(tests, outname,
input_res = True,
)
def main():
seqs = cfg.sequences
seq_names = cfg.sequence_names
seq_names[cfg.Kimono1] = "Kimono1"
version = 1
outname = r"kvz_gop_level_param_selection"
bins = [
r"D:\bins\kvz.exe", r"D:\bins\kvz_max.exe", r"D:\bins\kvz_mid.exe",
r"D:\bins\kvz_low.exe", r"D:\bins\kvz_xtra.exe"
]
shared_param = ("--gop", "8")
veryslow = ("--preset", "veryslow")
ultrafast = ("--preset", "ultrafast")
tpg = TU.TestParameterGroup()
tpg.add_const_param(input_names = seq_names,
layer_args = shared_param,
inputs = seqs,
validate = False,
version = version) \
.add_param_set(bin_name = bins,
_preset = [ultrafast, veryslow])
tpg.set_param_group_transformer(
TU.transformerFactory(test_name=lambda *, bin_name, _preset, **_:
bin_name.split('\\')[-1][:-4] + "_" + _preset[1],
layer_args=lambda *, layer_args, _preset, **_:
(_preset + layer_args, )))
tests = tpg.to_kvz_test_instance()
summary = TU.make_BDBRMatrix_definition(TU.get_test_names(tests),
write_bits=False,
write_psnr=False)
summary2 = TU.make_AnchorList_singleAnchor_definition(
"kvz_ultrafast",
TU.get_test_names(tests),
test_filter=lambda _, test: "ultrafast" in test,
name="ultrafast_anchor")
summary3 = TU.make_AnchorList_singleAnchor_definition(
"kvz_veryslow",
TU.get_test_names(tests),
test_filter=lambda _, test: "veryslow" in test,
name="veryslow_anchor")
summary4 = TU.make_CurveChart_definition(
TU.get_test_names(tests),
filter_func=lambda t: "ultrafast" in t,
name="ultrafast_curve")
summary5 = TU.make_CurveChart_definition(
TU.get_test_names(tests),
filter_func=lambda t: "veryslow" in t,
name="veryslow_curve")
summary5["definition"]["charts"].extend([
('psnr', 'rate'), ('psnr', 'time'), ('time', 'rate'), ('time', 'psnr')
])
runTests(tests, outname, summary, summary2, summary3, summary4, summary5)
def main():
seqs = cfg.sequences
in_names = cfg.class_sequence_names
me = 'full' # 'hexbs'
preset = 'ultrafast'#"veryslow"#"ultrafast"
version = 4
outname = "skvz_v{}_battery_{}_{}".format(version,preset,me)#"skvz_v{}_battery".format(version)
bl_qps = (22, 27, 32, 37)#(7,12,17,22)
el_qps = bl_qps#tuple(map(lambda x: x-5,bl_qps))
el_snr_qps = tuple(map(lambda x: x-5,bl_qps))
scal_qps = tuple(zip(bl_qps,el_qps))
scal_snr_qps = tuple(zip(bl_qps,el_snr_qps))
shared_param = ("--preset",preset,'--gop','0','--threads','3','--me',me)
scal_param = ("--no-wpp",)
no_tmvp = ("--no-tmvp",)
tmvp = ("--tmvp",)
bl2r_ref_frames = ('-r','2')
el1r_ref_frames = ('-r','1')
el2r_ref_frames = ('-r','2')
scal1r_ref_frames = ('-r','1','--ilr','1')
scal2r_ref_frames = ('-r','2','--ilr','1')
bl_scale = (0.5,)
bl_snr_scale = (1,)
el_scale = (1,)
scal_scale = bl_scale + el_scale
scal_snr_scale = bl_snr_scale + el_scale
bl_halve_scale = (1/1.5,)
scal_halve_scale = bl_halve_scale + el_scale
SNR = "_SNR" #Spatial scalability not used
SCALED = "0.5X" #Downscaled by 0.5
HSCALED = "0.7X" #Downscaled by 1/1.5
SCAL = "2X" # 2x scalability
HSCAL = "1.5X" # 1.5x scalability
REF2 = "2R" #Two ref
REF1 = "1R" #One ref
TMVP = "_TMVP" #Tmvp
NOTMVP = ""
single_layer_BL_param = [(reduce(lambda x,y: x + y[0], param, "BL"),) + reduce(lambda x,y: x + (y[1],), param, tuple())
for param in
it.product(
[(REF2,bl2r_ref_frames)], #Number of ref
[(SCALED,bl_scale),("",bl_snr_scale),(HSCALED,bl_halve_scale)], #Scale
[("",bl_qps)], #Qp
[("",tmvp)], #Use tmvp
)
]
single_layer_EL_param = [(reduce(lambda x,y: x + y[0], param, "EL"),) + reduce(lambda x,y: x + (y[1],), param, tuple())
for param in
it.product(
[(REF1,el1r_ref_frames),(REF2,el2r_ref_frames)], #Number of ref
[("",el_scale)], #Scale
[("",el_qps),(SNR,el_snr_qps)], #Qp
[(TMVP,tmvp),(NOTMVP,no_tmvp)], #Use tmvp
)
]
two_layer_param = [val for val in
((reduce(lambda x,y: x + y[0], param, "SC"),) + reduce(lambda x,y: x + (y[1],), param, tuple())
for param in
it.product(
[(REF1,scal1r_ref_frames),(REF2,scal2r_ref_frames)], #Number of ref
[(SCAL,scal_scale),("1X",scal_snr_scale),(HSCAL,scal_halve_scale)], #Scale
[("",scal_qps),(SNR,scal_snr_qps)], #Qp
[(TMVP,tmvp),(NOTMVP,no_tmvp)], #Use tmvp
)
) if (SNR in val[0] or SCAL in val[0] or HSCAL in val[0]) ]
tests = []
# Add BL/EL tests
for (name, ref, scale, qp, tmvpp) in single_layer_BL_param + single_layer_EL_param:
tests.append( skvzTestInstance(
bin_name = cfg.skvz_ver_bin.format(version),
inputs = seqs,
input_names = in_names,
test_name = name,
qps = qp,
layer_args = (shared_param + ref + tmvpp,),
input_layer_scales = scale,
))
# Add scalable tests
for (name, ref, scale, qp, tmvpp) in two_layer_param:
tests.append( skvzTestInstance(
bin_name = cfg.skvz_ver_bin.format(version),
inputs = seqs,
input_names = in_names,
test_name = name,
qps = qp,
layer_args = (shared_param + bl2r_ref_frames,
shared_param + scal_param + ref + tmvpp),
input_layer_scales = scale,
))
#Generate layer combi
combi = [(bl[0],el[0],) for el in single_layer_EL_param for bl in single_layer_BL_param if (SCALED in bl[0] or HSCALED in bl[0] or SNR in el[0]) ]
#Generate layers dict
layers = { makeLayerCombiName(name) : ((-1,1) if (len(name) > 1) or ((name[0] not in [val[0] for val in single_layer_BL_param]) and (name[0] not in [val[0] for val in single_layer_EL_param])) else tuple())
for name in [(val[0],) for val in single_layer_BL_param] + [(val[0],) for val in single_layer_EL_param] + [(val[0],) for val in two_layer_param] + combi}
runTests(tests, outname,
layers=layers,
layer_combi=combi,
s2_base=makeLayerCombiName(combi[3]))
def main():
seqs = [(r"hevc-B\Kimono1_1920x1080_24.yuv", ),
(r"hevc-B\Cactus_1920x1080_50.yuv", )]
tests = []
in_names = ["Kimono", "Cactuar"]
bl_qps = (22, 27, 32, 37)
el_qps = tuple(map(lambda x: x - 5, bl_qps))
# Ultra fast
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="BL_UF",
input_names=in_names,
#qps = bl_qps,
layer_args=(("--preset", "ultrafast", "-n", "5", '-r', '1',
'--gop', '0', '--threads', '3', '--no-wpp'), ),
input_layer_scales=(0.5, )))
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="EL_UF",
input_names=in_names,
#qps = el_qps,
layer_args=(("--preset", "ultrafast", "-n", "5", '-r', '1',
'--gop', '0', '--threads', '3', '--no-wpp'), ),
input_layer_scales=(1, )))
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="Scal_UF",
input_names=in_names,
#qps = tuple(zip(bl_qps,el_qps)),
layer_args=(("--preset", "ultrafast", "-n", "5", '-r', '1',
'--gop', '0'), ('--preset', 'ultrafast', '-n', '5',
'-r', '0', '--ilr', '1', '--gop', '0',
'--threads', '3', '--no-wpp')),
input_layer_scales=(0.5, 1)))
# Ultra slow
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="BL_VS",
input_names=in_names,
#qps = bl_qps,
layer_args=(("--preset", "veryslow", "-n", "5", '-r', '1', '--gop',
'0', '--threads', '3', '--no-wpp'), ),
input_layer_scales=(0.5, )))
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="EL_VS",
input_names=in_names,
#qps = el_qps,
layer_args=(("--preset", "veryslow", "-n", "5", '-r', '1', '--gop',
'0', '--threads', '3', '--no-wpp'), ),
input_layer_scales=(1, )))
tests.append(
skvzTestInstance(
inputs=seqs,
test_name="Scal_VS",
input_names=in_names,
#qps = tuple(zip(bl_qps,el_qps)),
layer_args=(("--preset", "veryslow", "-n", "5", '-r', '1', '--gop',
'0'),
('--preset', 'veryslow', '-n', '5', '-r', '0', '--ilr',
'1', '--gop', '0', '--threads', '3', '--no-wpp')),
input_layer_scales=(0.5, 1)))
runTests(tests,
"preset_scale_test",
layers={
makeLayerCombiName(["BL_UF", "EL_UF"]): (-1, ),
makeLayerCombiName(["BL_VS", "EL_VS"]): (-1, ),
"Scal_UF": (-1, ),
"Scal_VS": (-1, )
},
layer_combi=[("BL_VS", "EL_VS"), ("BL_UF", "EL_UF")])
def main():
seqs = cfg.sequences[cfg.hevc_A] + cfg.sequences[cfg.hevc_B]
in_names = cfg.class_sequence_names[cfg.hevc_A] + cfg.class_sequence_names[
cfg.hevc_B]
ver = 27
dqps = (2, 0, -4, -6) #(2, 0, -3, -6, -9)
ext_dqps = tuple(range(2, -10, -1))
base_qp = (22, 26, 30, 34)
snr_base_qp = (26, 30, 34, 38)
outname = "DI_tests_v{}".format(ver)
# Set shared param
HSCAL = "1.5X"
SCAL = "2X"
SNR = "SNR"
SNR_EXT = "SNRX"
# Basic init
skvz_tpg_scal = TU.TestParameterGroup()
skvz_tpg_scal.add_const_param(version=ver,
input_names=in_names,
inputs=seqs) #\
# .add_param_set(_type = [SNR, SNR_EXT, SCAL, HSCAL]) \
#.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or _dqp == 0 else False)
skvz_tpg_sim = skvz_tpg_scal.copy()
shm_tpg_scal = skvz_tpg_scal.copy()
shm_tpg_sim = skvz_tpg_scal.copy()
hscale = (1 / 1.5, 1)
scale = (0.5, 1)
snr_scale = (1, 1)
name_scaling = {
SNR: lambda s: s,
SNR_EXT: lambda s: s,
SCAL: lambda s: TU.generate_scaled_seq_names(s, scale),
HSCAL: lambda s: TU.generate_scaled_seq_names(s, hscale)
}
sim_scaling = {
SNR: lambda s: s,
SNR_EXT: lambda s: s,
SCAL: lambda s: TU.generate_scaled_seq_names(s, (scale[0], )),
HSCAL: lambda s: TU.generate_scaled_seq_names(s, (hscale[0], ))
}
shm_name_scaling = {
SNR: lambda s: ([(seq, seq) for (seq, ) in s]),
SNR_EXT: lambda s: ([(seq, seq) for (seq, ) in s]),
SCAL: lambda s: TU.generate_scaled_seq_names(s, scale),
HSCAL: lambda s: TU.generate_scaled_seq_names(s, hscale)
}
# Set kvazaar scalable param
threads = "15" #(4,6,8,10,12,14)
owf = "2" #(2,4,8,16)
shared_param = ("--preset", "ultrafast", "--threads", threads, "--owf",
owf)
skvz_tpg_scal.add_const_param(layer_args = shared_param,
retries = 5,
bin_name = cfg.skvz_ver_bin.format(ver)) \
.add_param_set(_dqp = ext_dqps,
_type = [SNR, SNR_EXT, SCAL, HSCAL])
#tpg_scal.filter_parameter_group(lambda *, _dqp, _type, **param: False if _type == SNR and _dqp == 0 else True)
skvz_tpg_scal.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _dqp, _type, **param: "SKVZ_SCAL_{}_DQP{}".
format(_type, _dqp),
qps=lambda *, _dqp, _type, **param: tuple(
zip((snr_base_qp if _type == SNR else base_qp), [
bqp + _dqp for bqp in (snr_base_qp
if _type == SNR else base_qp)
])),
inputs=lambda *, _type, inputs, **param: name_scaling[_type]
(inputs),
layer_args=lambda *, layer_args, **param:
(layer_args, layer_args)))
#.filter_parameter_group(lambda *, _dqp, _type, **param: False if (_type == SNR or _type == SNR_EXT) and _dqp >= 0 else True)
# Set kvazaar simulcast param
skvz_tpg_sim.add_const_param(bin_name = cfg.skvz_ver_bin.format(ver),
validate = False,
layer_args = shared_param) \
.add_param_set(_dqp = ext_dqps,
_type = [SNR, SNR_EXT, SCAL, HSCAL])
skvz_tpg_sim.set_param_group_transformer(
TU.transformerFactory(test_name = lambda *, _dqp, _type, **param: "SKVZ_{}_DQP{}".format(_type, _dqp) if (_type == SNR or _type == SNR_EXT) else "SKVZ_1÷{}".format(_type),
qps = lambda *, _dqp, _type, **param: tuple(bqp + _dqp for bqp in (snr_base_qp if _type == SNR else base_qp)),
layer_args = lambda *, layer_args, **param: (layer_args,),
inputs = lambda *, inputs, _type, **param: sim_scaling[_type](inputs))
)\
.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or _type == SNR_EXT or _dqp == 0 else False)
# Set shm scalable param
base_conf = cfg.shm_cfg + "encoder_lowdelay_P_scalable.cfg"
layer_conf = cfg.shm_cfg + "layers.cfg"
shm_tpg_scal.set_param_group_transformer(
TU.transformerFactory(test_name = lambda *, _dqp, _type, **param: "SHM_SCAL_{}_DQP{}".format(_type, _dqp),
qps = lambda *, _dqp, _type, **param: tuple(zip((snr_base_qp if _type == SNR else base_qp), [bqp + _dqp for bqp in (snr_base_qp if _type == SNR else base_qp)])),
inputs = lambda *, _type, inputs, **param: shm_name_scaling[_type](inputs),
configs = lambda *, _type, input_names, **param:
[ (base_conf, layer_conf, cfg.shm_cfg + seq.split("_")[1] + "-" + _type + ".cfg") for seq in input_names])
)\
.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or _dqp >= 0 else False)\
.filter_parameter_group(lambda *, _dqp, _type, **param: False if _type == SNR and _dqp >= 0 else True) \
.add_param_set(_dqp = dqps,
_type = [SNR, SCAL, HSCAL])
# Set shm simulcast param
shm_tpg_sim.set_param_group_transformer(
TU.transformerFactory(test_name = lambda *, _dqp, _type, **param: "SHM_{}_DQP{}".format(_type, _dqp) if (_type == SNR or _type == SNR_EXT) else "SHM_1÷{}".format(_type),
qps = lambda *, _dqp, _type, **param: tuple(bqp + _dqp for bqp in (snr_base_qp if _type == SNR else base_qp)),
configs = lambda *, input_names, **param:
[ (base_conf, cfg.shm_cfg + seq.split("_")[1] + ".cfg") for seq in input_names],
inputs = lambda *, inputs, _type, **param: sim_scaling[_type](inputs),
input_layer_scales = lambda *, _type, **param: tuple() if _type == SNR else (1,))
)\
.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or (_type == SNR_EXT and _dqp >= 0) or _dqp == 0 else False) \
.add_param_set(_dqp = dqps,
_type = [SNR, SNR_EXT, SCAL, HSCAL])
#Get tests
skvz_tests_scal = skvz_tpg_scal.to_skvz_test_instance()
skvz_tests_sim = skvz_tpg_sim.to_skvz_test_instance()
shm_tests_scal = shm_tpg_scal.to_shm_test_instance()
shm_tests_sim = shm_tpg_sim.to_shm_test_instance()
skvz_combi = TU.generate_combi(
skvz_tpg_sim,
combi_cond=TU.combiFactory(
lambda g1, g2: False
if (g1["_type"] in [SCAL, HSCAL] and g2["_type"] in [SCAL, HSCAL]
) else (True if g1["_type"] == g2["_type"] == SNR or g1[
"_type"] == g2["_type"] == SNR_EXT else
(g1["_type"] == SNR_EXT and g2["_type"] != SNR) or
(g2["_type"] == SNR_EXT and g1["_type"] != SNR)),
_type=lambda t1, t2: 1
if t1 == SNR != t2 or t1 == SNR_EXT != t2 else True
if t1 == t2 == SNR or t1 == t2 == SNR_EXT else -1,
_dqp=lambda d1, d2: 1 if -abs(d1) < -abs(d2) else -1
if d1 != d2 else True),
transform_func=lambda s: [(ss2, ss1) for ss1 in s[1:]
for ss2 in (s[0:2]
if SNR_EXT in s[1] else s[0:1])]
#transform_func = lambda s: [(ss2, ss1) for ss1 in s[1:] for ss2 in (s[0:2] if SNR_EXT in s[1] else s[0:1]) if ss2 != ss1 and "P1" not in ss1 and "P2" not in ss1]
)
#shm_combi = TU.generate_combi(shm_tpg_sim,
# combi_cond = TU.combiFactory(lambda g1, g2: (g1["_type"] == SNR == g2["_type"] and g1["_dqp"] <= 0 >= g2["_dqp"]) or (g1["_type"] == SNR != g2["_type"] and g1["_dqp"] >= 0) or (g2["_type"] == SNR != g1["_type"] and g2["_dqp"] >= 0),
# _type = lambda t1, t2: -1 if t1 != SNR == t2 else 1 if t1 == SNR != t2 else t1 == t2,
# _dqp = lambda d1, d2: True if d2 == d1 == 0 else -abs(d2) if d1 == 0 else (abs(d1) if d2 == 0 else 0)))
shm_combi = TU.generate_combi(
shm_tpg_sim,
combi_cond=TU.combiFactory(
lambda g1, g2: False
if (g1["_type"] in [SCAL, HSCAL] and g2["_type"] in [SCAL, HSCAL]
) else (True if g1["_type"] == g2["_type"] == SNR or g1[
"_type"] == g2["_type"] == SNR_EXT else
(g1["_type"] == SNR_EXT and g2["_type"] != SNR) or
(g2["_type"] == SNR_EXT and g1["_type"] != SNR)),
_type=lambda t1, t2: 1
if t1 == SNR != t2 or t1 == SNR_EXT != t2 else True
if t1 == t2 == SNR or t1 == t2 == SNR_EXT else -1,
_dqp=lambda d1, d2: 1 if -abs(d1) < -abs(d2) else -1
if d1 != d2 else True),
transform_func=lambda s: [(s[0], ss1)
for ss1 in (s[1:]
if SNR not in s[0] else s[2:])])
#shm_combi.append(('SHM_1÷1.5X', 'SHM_SNRX_DQP0'))
#shm_combi.append(('SHM_1÷2X', 'SHM_SNR_DQP0'))
skvz_sim_names = TU.get_combi_names(skvz_combi)
skvz_test_names = TU.get_test_names(skvz_tests_scal) + skvz_sim_names
shm_sim_names = TU.get_combi_names(shm_combi)
shm_test_names = TU.get_test_names(shm_tests_scal) + shm_sim_names
#Make summaries
summaries = []
# SKVZ
summaries.append(
TU.make_AnchorList_multiAnchor_definition(
skvz_test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(
lambda t: tuple(a for a in skvz_sim_names if (
(t.split(sep='_')[2] in a) and (t.split(sep='_')[3] in a)
if SNR_EXT != (t.split(sep='_')[2]) != SNR else
(t.split(sep='_')[2] in a.split(sep='_')[3:]) and (
(t.split(sep='_')[2] in a.split(sep='_')[0:3])) and
(t.split(sep='_')[3] in a.split(sep='_')[3:])))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.
anchorFuncFactory_match_layer(lambda t: (None, ) + tuple(
(a, l) if l >= 0 else a for a in skvz_sim_names if
((t.split(sep='_')[2] in a) and (t.split(sep='_')[3] in a)
if SNR_EXT != (t.split(sep='_')[2]) != SNR else
(t.split(sep='_')[2] in a.split(sep='_')[3:]) and
((t.split(sep='_')[2] in a.split(sep='_')[0:3])) and (t.split(
sep='_')[3] in a.split(sep='_')[3:])) for l in [-1, 1])),
name="SKVZ_LIST"))
# SKVZ param matrix
# SHM
summaries.append(
TU.make_AnchorList_multiAnchor_definition(
shm_test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in shm_sim_names
if (t.split(sep='_')[2] in a) and (t.split(sep='_')[3] in a))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: (
None, ) + tuple((a, l) if l >= 0 else a for a in shm_sim_names
if (t.split(sep='_')[2] in a) and
(t.split(sep='_')[3] in a) for l in [-1, 1])),
name="SHM_LIST"))
# SHM vs. SKVZ
summaries.append(
TU.make_AnchorList_multiAnchor_definition(
skvz_test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in TU.get_test_names(shm_tests_scal)
if (t.split(sep='_')[2] in a) and (t.split(sep='_')[3] in a))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in TU.get_test_names(shm_tests_scal)
if (t.split(sep='_')[2] in a) and (t.split(sep='_')[3] in a))),
name="SKVZ_vs_SHM"))
#Run tests
runTests(skvz_tests_scal + skvz_tests_sim + shm_tests_scal + shm_tests_sim,
outname,
*summaries,
layer_combi=skvz_combi + shm_combi)
def main():
seqs = cfg.sequences[cfg.hevc_A] + cfg.sequences[cfg.hevc_B]
in_names = cfg.class_sequence_names[cfg.hevc_A] + cfg.class_sequence_names[
cfg.hevc_B]
ver = 24
threads = "15" #(4,6,8,10,12,14)
owf = "2" #(2,4,8,16)
shared_param = ("--preset", "ultrafast", "--threads", threads, "--owf",
owf)
dqps = (0, -3, -6, -9)
base_qp = (22, 27, 32, 37)
outname = "skvz_ISCAS2020_test_v{}".format(ver)
# Set shared param
HSCAL = "1.5X"
SCAL = "2X"
SNR = "SNR"
tpg_scal = TU.TestParameterGroup()
tpg_scal.add_const_param(version = ver,
bin_name = cfg.skvz_ver_bin.format(ver),
input_names = in_names,
layer_args = shared_param,
inputs = seqs,
retries = 5) \
.add_param_set(_dqp = dqps,
_type = [SNR, SCAL, HSCAL]) \
.filter_parameter_group(lambda *, _dqp, _type, **param: True if _type == SNR or _dqp == 0 else False)
tpg_sim = tpg_scal.copy()
# Set scalable param
hscale = (1 / 1.5, 1)
scale = (0.5, 1)
snr_scale = (1, 1)
tpg_scal.filter_parameter_group(lambda *, _dqp, _type, **param: False
if _type == SNR and _dqp == 0 else True)
tpg_scal.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _dqp, _type, **param: "SCAL_{}_DQP{}".format(
_type, _dqp),
qps=lambda *, _dqp, **param: tuple(
zip(base_qp, [bqp + _dqp for bqp in base_qp])),
inputs=lambda *, _type, inputs, **param: inputs
if _type == SNR else TU.generate_scaled_seq_names(inputs, scale)
if _type == SCAL else TU.generate_scaled_seq_names(inputs, hscale),
layer_args=lambda *, layer_args, **param:
(layer_args, layer_args)))
# Set simulcast param
#BL = "BL"
#EL = "EL"
#tpg_sim.add_param_set(_layer=[BL,EL])
#tpg_sim.filter_parameter_group(lambda *, _dqp, _layer, **param: True if _layer != BL or _dqp == 0 else False) \
# .filter_parameter_group(lambda *, _layer, _type, **param: True if _layer != EL or _type == SNR else False)
tpg_sim.set_param_group_transformer(
TU.transformerFactory(
test_name=lambda *, _dqp, _type, **param: "{}_DQP{}".format(
_type, _dqp) if _type == SNR else "1÷{}".format(_type),
qps=lambda *, _dqp, **param: tuple(bqp + _dqp for bqp in base_qp),
layer_args=lambda *, layer_args, **param: (layer_args, ),
inputs=lambda *, inputs, _type, **param: inputs
if _type == SNR else TU.generate_scaled_seq_names(
inputs, (scale[0], ))
if _type == SCAL else TU.generate_scaled_seq_names(
inputs, (hscale[0], ))))
#Run tests
tests_scal = tpg_scal.to_skvz_test_instance()
tests_sim = tpg_sim.to_skvz_test_instance()
combi = TU.generate_combi(
tpg_sim,
combi_cond=TU.combiFactory(
lambda g1, g2: (g1["_type"] == SNR == g2["_type"]) or
(g1["_type"] == SNR != g2["_type"] and g1["_dqp"] == 0) or
(g2["_type"] == SNR != g1["_type"] and g2["_dqp"] == 0),
_type=lambda t1, t2: -1 if t1 != SNR == t2 else 1
if t1 == SNR != t2 else t1 == t2,
_dqp=lambda d1, d2: True if d2 == d1 == 0 else d2
if d1 == 0 else (-d1 if d2 == 0 else 0)))
sim_names = TU.get_combi_names(combi)
test_names = TU.get_test_names(tests_scal) + sim_names
matrix_summary = TU.make_BDBRMatrix_definition(
test_names + TU.get_test_names(tests_sim),
write_bdbr=True,
write_bits=False,
write_psnr=False,
layering_func=lambda t:
(-1, 1), #(-1,1) if "SCAL" not in t else (-1,),
filter_func=lambda t: True
if len(t.split('_')) >= 3 or "SCAL" in t else False)
anchor_summary = TU.make_AnchorList_multiAnchor_definition(
test_names,
global_filter=lambda t: True if "SCAL" in t else False,
bdbr_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: tuple(
a for a in sim_names
if (t.split(sep='_')[1] in a) and (t.split(sep='_')[2] in a))),
bdbr_layer_func=TU.layerFuncFactory([
[None, 1],
]),
time_anchor_func=TU.anchorFuncFactory_match_layer(lambda t: (
None, ) + tuple((a, l) if l >= 0 else a for a in sim_names
if (t.split(sep='_')[1] in a) and
(t.split(sep='_')[2] in a) for l in [-1, 1])))
summaries = [matrix_summary, anchor_summary]
runTests(tests_scal + tests_sim, outname, *summaries, layer_combi=combi)
def main():
#SHARED
in_names = ["Kimono", "Cactuar"]
name = "scal_test_v2" #"scal_test_low_qp"
bl_qps = (22, 27, 32, 37) #(7,12,17,22) #(22, 27, 32, 37)
el_qps = bl_qps
#bl_qps = (22, 27, 32, 37)
#el_qps = tuple(map(lambda x: x-5,bl_qps))
tests = []
#SHM
seqs = [(r"D:\stuff\Kimono1_960x540_24_zerophase_0.9pi.yuv",
cfg.sequence_path + r"hevc-B\Kimono1_1920x1080_24.yuv"),
(r"D:\stuff\Cactus_960x540_50_zerophase_0.9pi.yuv",
cfg.sequence_path + r"hevc-B\Cactus_1920x1080_50.yuv")]
const = (r"D:\stuff\encoder_my_scalable.cfg", r"D:\stuff\layers.cfg")
confs = [
const + (r"D:\stuff\Kimono-2x.cfg", ),
const + (r"D:\stuff\Cactus-2x.cfg", )
]
confs_bl = [
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Kimono_halve.cfg"),
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Cactus_halve.cfg")
]
confs_el = [(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Kimono.cfg"),
(r"D:\stuff\encoder_my_main.cfg", r"D:\stuff\Cactus.cfg")]
tests.append(
shmTestInstance(
inputs=[(seq0, ) for (seq0, seq1) in seqs],
configs=confs_bl,
input_names=in_names,
qps=bl_qps,
layer_args=("-f", '5'),
#input_layer_scales = (0.5,),
test_name="BL_SHM"))
tests.append(
shmTestInstance(
inputs=[(seq1, ) for (seq0, seq1) in seqs],
configs=confs_el,
input_names=in_names,
qps=el_qps,
layer_args=("-f", '5'),
#input_layer_scales = (1,),
test_name="EL_SHM"))
tests.append(
shmTestInstance(
inputs=seqs,
configs=confs,
input_names=in_names,
qps=bl_qps, #tuple(zip(bl_qps,el_qps)),
layer_args=("-f", '5'),
#layer_args = (("--preset","ultrafast","-n","5",'-r','1','--gop','0','--threads','0'),
# ('--preset','ultrafast','-n','5','-r','1','--gop','0','--threads','0')),
#input_layer_scales = (0.5,1)
test_name="Scal_SHM"))
#SKVZ
seqs = [(r"hevc-B\Kimono1_1920x1080_24.yuv", ),
(r"hevc-B\Cactus_1920x1080_50.yuv", )]
preset = "ultrafast" #"veryslow"
tests.append(
skvzTestInstance(inputs=seqs,
test_name="BL_SKVZ",
input_names=in_names,
qps=bl_qps,
layer_args=(("--preset", preset, "-n", "5", '-r', '1',
'--gop', '0', '--no-wpp', '--threads',
'3'), ),
input_layer_scales=(0.5, )))
tests.append(
skvzTestInstance(inputs=seqs,
test_name="EL_SKVZ",
input_names=in_names,
qps=el_qps,
layer_args=(("--preset", preset, "-n", "5", '-r', '1',
'--gop', '0', '--threads', '3',
'--no-wpp'), ),
input_layer_scales=(1, )))
tests.append(
skvzTestInstance(inputs=seqs,
test_name="Scal_SKVZ",
input_names=in_names,
qps=tuple(zip(bl_qps, el_qps)),
layer_args=(("--preset", preset, "-n", "5", '-r', '1',
'--gop', '0'),
('--preset', preset, '-n', '5', '-r', '0',
'--ilr', '1', '--gop', '0', '--threads',
'3', '--no-wpp')),
input_layer_scales=(0.5, 1)))
runTests(
tests,
name,
layers={
makeLayerCombiName(["BL_SHM", "EL_SHM"]): (-1, ),
makeLayerCombiName(["BL_SKVZ", "EL_SKVZ"]): (-1, ),
"Scal_SHM": (-1, ),
"Scal_SKVZ": (-1, ),
"BL_SHM": tuple(),
"EL_SHM": tuple(),
"BL_SKVZ": tuple(),
"EL_SKVZ": tuple()
},
#combi=[("EL","BL")])#,
layer_combi=[("BL_SHM", "EL_SHM"), ("BL_SKVZ", "EL_SKVZ")])
def main():
seqs = cfg.sequences
in_names = cfg.class_sequence_names
bin_zero = r"D:\bins\skvz_zero.exe"
bin_choose = r"D:\bins\skvz_choose.exe"
outname = "rmvp_merge_idx_test"
bl_qps = (22, 27, 32, 37) #(7,12,17,22)
el_qps = bl_qps #tuple(map(lambda x: x-5,bl_qps))
el_snr_qps = tuple(map(lambda x: x - 5, bl_qps))
scal_qps = tuple(zip(bl_qps, el_qps))
scal_snr_qps = tuple(zip(bl_qps, el_snr_qps))
shared_param = ("--preset", "ultrafast", '--gop', '0', '--threads', '3')
scal_param = ("--no-wpp", )
bl_ref_frames = ('-r', '3')
el_ref_frames = ('-r', '3')
scal_ref_frames = ('-r', '2', '--ilr', '1')
bl_scale = (0.5, )
bl_snr_scale = (1, )
el_scale = (1, )
scal_scale = bl_scale + el_scale
scal_snr_scale = bl_snr_scale + el_scale
SNR = "_SNR" #Spatial scalability not used
SCALED = "0.5X" #Downscaled by 0.5
SCAL = "2X" # 2x scalability
REF2 = "2R" #Two ref
REF1 = "1R" #One ref
ZERO = "Z" #TMVP merge idx zero
CHOOSE = "C" #TMVP merge idx zero only when lid > 0
single_layer_BL_param = [
(reduce(lambda x, y: x + y[0], param, "BL"), ) +
reduce(lambda x, y: x + (y[1], ), param, tuple())
for param in it.product(
[("", bl_ref_frames)], #Number of ref
[(SCALED, bl_scale), ("", bl_snr_scale)], #Scale
[("", bl_qps)], #Qp
[(CHOOSE, bin_choose), (ZERO, bin_zero)], #version
)
]
single_layer_EL_param = [
(reduce(lambda x, y: x + y[0], param, "EL"), ) +
reduce(lambda x, y: x + (y[1], ), param, tuple())
for param in it.product(
[("", el_ref_frames)], #Number of ref
[("", el_scale)], #Scale
[("", el_qps)], #Qp
[(CHOOSE, bin_choose), (ZERO, bin_zero)], #version
)
]
two_layer_param = [
val for val in (
(reduce(lambda x, y: x + y[0], param, "SC"), ) +
reduce(lambda x, y: x + (y[1], ), param, tuple())
for param in it.product(
[("", scal_ref_frames)], #Number of ref
[(SCAL, scal_scale), ("1X", scal_snr_scale)], #Scale
[("", scal_qps)], #Qp
[(CHOOSE, bin_choose), (ZERO, bin_zero)], #version
)) if (SNR in val[0] or SCAL in val[0])
]
tests = []
# Add BL/EL tests
for (name, ref, scale, qp,
ver) in single_layer_BL_param + single_layer_EL_param:
tests.append(
skvzTestInstance(
inputs=seqs,
input_names=in_names,
test_name=name,
qps=qp,
layer_args=(shared_param + ref, ),
input_layer_scales=scale,
bin_name=ver,
))
# Add scalable tests
for (name, ref, scale, qp, ver) in two_layer_param:
tests.append(
skvzTestInstance(
inputs=seqs,
input_names=in_names,
test_name=name,
qps=qp,
layer_args=(shared_param + bl_ref_frames,
shared_param + scal_param + ref),
input_layer_scales=scale,
bin_name=ver,
))
#tests.append( skvzTestInstance(inputs = seqs,
# test_name = "BL",
# input_names = in_names,
# qps = bl_qps,
# layer_args = (shared_param+bl_ref_frames,),
# input_layer_scales = bl_scale
# ))
#tests.append( skvzTestInstance(inputs = seqs,
# test_name = "EL",
# input_names = in_names,
# qps = bl_qps,
# layer_args = (shared_param+el_ref_frames,),
# input_layer_scales = el_scale
# ))
#tests.append( skvzTestInstance(inputs = seqs,
# test_name = "Scal",
# input_names = in_names,
# qps = el_qps,
# layer_args = (shared_param+bl_ref_frames,
# shared_param+scal_param+scal_ref_frames),
# input_layer_scales = bl_scale+el_scale
# ))
#Generate layer combi
combi = [(
bl[0],
el[0],
) for el in single_layer_EL_param for bl in single_layer_BL_param if (
ZERO in bl[0] and ZERO in el[0] or CHOOSE in bl[0] and CHOOSE in el[0])
]
#combi = []
#for el in single_layer_EL_param:
# for bl in single_layer_BL_param:
# if SNR in el[0] and not SCALED in bl[0]:
# combi.append((bl[0],el[0],))
# elif not SNR in el[0] and SCALED in bl[0]:
# combi.append((bl[0],el[0],))
#Generate layers dict
#layers = { makeLayerCombiName(name) : ((-1,) if (len(name) > 1) or ((name[0] not in [val[0] for val in single_layer_BL_param]) and (name[0] not in [val[0] for val in single_layer_EL_param])) else tuple())
# for name in [(val[0],) for val in single_layer_BL_param] + [(val[0],) for val in single_layer_EL_param] + [(val[0],) for val in two_layer_param] + combi}
layers = {}
runTests(tests,
outname,
layers=layers,
layer_combi=combi,
s2_base=makeLayerCombiName(combi[3]))
