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]))