def check_metric(**params):
metric = params["metric"]
type = metric["type"]
if "ssim" == type:
miny = metric.get("miny", 1.0)
minu = metric.get("minu", 1.0)
minv = metric.get("minv", 1.0)
ssim = calculate_ssim(params["reference"], params["decoded"],
params["width"], params["height"],
params["frames"], params["format"],
params.get("format2", None))
get_media()._set_test_details(ssim=ssim)
assert 1.0 >= ssim[0] >= miny
assert 1.0 >= ssim[1] >= minu
assert 1.0 >= ssim[2] >= minv
elif "md5" == type:
numbytes = get_framesize(
params["width"], params["height"],
params.get("format2", params["format"])) * params["frames"]
res = md5(filename=params["decoded"], numbytes=numbytes)
get_media().baseline.check_md5(md5=res,
context=params.get("refctx", []))
else:
assert False, "unknown metric"
def check_filesize(filename, width, height, nframes, fourcc):
expected = get_framesize(width, height, fourcc) * nframes
actual = os.stat(filename).st_size
get_media()._set_test_details(**{"filesize:expect": expected})
get_media()._set_test_details(**{"filesize:actual": actual})
assert expected == actual
def format_value(value, **params):
from common import get_media
augmented = dict(
driver=get_media()._get_driver_name(),
platform=get_media()._get_platform_name(),
)
augmented.update(**params)
return value.format(**augmented)
def check_metric(**params):
metric = params["metric"]
type = metric["type"]
if "ssim" == type:
miny = metric.get("miny", 1.0)
minu = metric.get("minu", 1.0)
minv = metric.get("minv", 1.0)
ssim = calculate_ssim(params["reference"], params["decoded"],
params["width"], params["height"],
params["frames"], params["format"],
params.get("format2", None))
get_media()._set_test_details(ssim=ssim)
assert 1.0 >= ssim[0] >= miny
assert 1.0 >= ssim[1] >= minu
assert 1.0 >= ssim[2] >= minv
elif "md5" == type:
numbytes = metric.get(
"numbytes",
get_framesize(params["width"], params["height"],
params.get("format2", params["format"])) *
params["frames"])
res = md5(filename=params["decoded"], numbytes=numbytes)
get_media().baseline.check_md5(md5=res,
context=params.get("refctx", []))
elif "psnr" == type:
get_media().baseline.check_psnr(psnr=calculate_psnr(
params["reference"], params["decoded"], params["width"],
params["height"], params["frames"], params["format"]),
context=params.get("refctx", []))
elif "mse" == type:
mse = calculate_mse(params["reference"], params["decoded"],
params["width"], params["height"],
params["frames"], params["format"])
get_media()._set_test_details(mse=mse)
avg_range = metric.get("avg_range", [(0, 256), (0, 256), (0, 256)])
assert avg_range[0][0] <= mse[-3] <= avg_range[0][1]
assert avg_range[1][0] <= mse[-2] <= avg_range[1][1]
assert avg_range[2][0] <= mse[-1] <= avg_range[2][1]
elif "nrmse" == type:
nrmse = calculate_nrmse(params["reference"], params["decoded"],
params["width"], params["height"],
params["frames"], params["format"])
get_media()._set_test_details(nrmse=nrmse)
avg_range = metric.get("avg_range", [(0, 0.07), (0, 0.07), (0, 0.07)])
assert avg_range[0][0] <= nrmse[-3] <= avg_range[0][1]
assert avg_range[1][0] <= nrmse[-2] <= avg_range[1][1]
assert avg_range[2][0] <= nrmse[-1] <= avg_range[2][1]
else:
assert False, "unknown metric"
def check_result(self, compare, context=[], **kwargs):
addr = slash.context.test.__slash__.address
actual = self.actuals.setdefault(addr, dict())
reference = self.__get_reference(addr, context)
actual.update(**kwargs)
if self.rebase:
reference.update(**kwargs)
for key, val in kwargs.iteritems():
refval = reference.get(key, None)
get_media()._set_test_details(**{key: val})
get_media()._set_test_details(**{"ref_{}".format(key): refval})
compare(key, refval, val)
def check_result(self, compare, context=[], **kwargs):
reference = self.__get_reference(context)
if self.rebase:
reference.update(**kwargs)
econtext = list(get_media()._expand_context(context))
for key, val in kwargs.iteritems():
refval = reference.get(key, None)
strkey = '.'.join(econtext + [key])
get_media()._set_test_details(
**{"{}:expect".format(strkey): refval})
get_media()._set_test_details(**{"{}:actual".format(strkey): val})
compare(key, refval, val)
def __append(self, func, iterable):
if get_media().metrics_pool is not None:
self.async_results.append(get_media().metrics_pool.map_async(
func, iterable))
# Update bytes of yuv data that is being held by async_results
self.async_bytes += sum([
i.nbytes for i in itertools.chain(*iterable) if i is not None
])
# If we are holding onto too much yuv data, then we need to collect and
# purge the current async_results to release the data
if self.async_bytes >= self.async_thresh:
self.__collect_async()
else:
self.results.append([func(i) for i in iterable])
def __get_reference(self, addr, context=[]):
reference = self.references.setdefault(addr, dict())
for c in sorted(context):
c = c.strip().lower()
if "driver" == c:
c = "drv.{}".format(get_media()._get_driver_name())
reference = reference.setdefault(c, dict())
return reference
def calculate_ssim(filename1,
filename2,
width,
height,
nframes=1,
fourcc="I420",
fourcc2=None):
reader = FrameReaders[fourcc]
reader2 = FrameReaders[fourcc2 or fourcc]
results = list()
with open(filename1, "rb") as fd1, open(filename2, "rb") as fd2:
for i in range(nframes):
y1, u1, v1 = __try_read_frame(reader,
fd1,
width,
height,
debug=(i, nframes, 1))
y2, u2, v2 = __try_read_frame(reader2,
fd2,
width,
height,
debug=(i, nframes, 2))
if get_media().metrics_pool is not None:
results.append(get_media().metrics_pool.map_async(
__compare_ssim, ((y1, y2), (u1, u2), (v1, v2))))
else:
results.append(
MetricsResult(__compare_ssim((y1, y2)),
__compare_ssim((u1, u2)),
__compare_ssim((v1, v2))))
result = list(itertools.chain(*[r.get() for r in results]))
return (
min(result[0::3]),
min(result[1::3]),
min(result[2::3]),
sum(result[0::3]) / nframes,
sum(result[1::3]) / nframes,
sum(result[2::3]) / nframes,
)
def __get_reference(self, context=[]):
addr = get_media()._get_ref_addr(context)
reference = self.references.setdefault(addr, dict())
for c in get_media()._expand_context(context):
reference = reference.setdefault(c, dict())
return reference
