dymokomi/luce-jpeg
Source of release 0.10.0
0.10.0 / src / jpeg / tests.lucb
#==============================================================================================
#
# jpeg/tests - The module's tests
#
# DESCRIPTION:
# Small pictures made by the module's own encoder, through every decoding API.
# tests/run.py covers files from other encoders, threads, sampling factors,
# progressive coding, restart markers and damaged data.
#
#==============================================================================================
## A width x height RGB (or gray) test picture: gradients and a hard edge, encoded.
func test_picture(encoded: Buffer*, width: usize, height: usize, channels: usize) -> !:
var raster = Raster()
defer raster.close()
raster.width = width
raster.height = height
try raster.standard(channels, .uint8)
try raster.allocate()
for y in 0..<height:
for x in 0..<width:
for c in 0..<channels:
let edge: usize = 90 if x * 3 > width * 2 else 0
raster.pixels[(y * width + x) * channels + c] = (f64)((x * 255 // width + y * 7 * (c + 1) + edge) % 256)
try encode(&raster, encoded, quality = 90)
## The Raster decode of `data`: its f64 samples as bytes, and the channel count.
func raster_samples(data: u8[], out: u8[]) -> usize!:
var raster = Raster()
raster.encoded = data
let channels = raster_decode(&raster, out) catch failure:
var empty: u8[]
raster.encoded = empty
raster.close()
error(failure.code, failure.message)
var empty: u8[]
raster.encoded = empty
raster.close()
return channels
func raster_decode(raster: Raster*, out: u8[]) -> usize!:
try probe(raster)
try raster.allocate()
try decode(raster)
for i in 0..<raster.pixels.length:
out[i] = (u8)raster.pixels[i]
return raster.channels.length
test "info reads the frame header and rounds scaled sizes up":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 21, 10, 3)
let found = try info(encoded.view())
assert(found.width == 21 and found.height == 10 and found.components == 3 and not found.progressive)
assert(found.scaled_width(2) == 11 and found.scaled_height(4) == 3 and found.scaled_width(8) == 3 and found.scaled_height(8) == 2)
test "8-bit output matches the Raster samples":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 23, 17, 3)
var samples: u8[1173]
assert(try raster_samples(encoded.data[..<encoded.used], samples) == 3)
var rgb: u8[1173]
try decode_rgb8(encoded.view(), rgb)
var rgba: u8[1564]
try decode_rgba8(encoded.view(), rgba)
for i in 0..<(usize)391:
for c in 0..<(usize)3:
assert(rgb[i * 3 + c] == samples[i * 3 + c])
assert(rgba[i * 4 + c] == samples[i * 3 + c])
assert(rgba[i * 4 + 3] == 255)
test "grayscale repeats into RGB":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 9, 9, 1)
var samples: u8[81]
assert(try raster_samples(encoded.data[..<encoded.used], samples) == 1)
var rgba: u8[324]
try decode_rgba8(encoded.view(), rgba)
for i in 0..<(usize)81:
assert(rgba[i * 4] == samples[i] and rgba[i * 4 + 1] == samples[i] and rgba[i * 4 + 2] == samples[i] and rgba[i * 4 + 3] == 255)
struct Rows:
var bytes: u8[1564]
var next: usize
var calls: usize
func collect_rows(context: void*?, first: usize, rows: usize, bytes: const u8[]) -> !:
let into = (Rows*)(context else return)
if first != into.next or bytes.length != rows * 23 * 4:
error(invalid, "rows out of order")
for i in 0..<bytes.length:
into.bytes[first * 23 * 4 + i] = bytes[i]
into.next = first + rows
into.calls += 1
func refuse_rows(context: void*?, first: usize, rows: usize, bytes: const u8[]) -> !:
error(limit, "the sink is full")
test "row callbacks deliver every row in order":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 23, 17, 3)
var whole: u8[1564]
try decode_rgba8(encoded.view(), whole)
var rows = Rows()
try decode_rows(encoded.view(), collect_rows, (void*)&rows)
assert(rows.next == 17 and rows.calls >= 1)
for i in 0..<whole.length:
assert(rows.bytes[i] == whole[i])
var failed = false
decode_rows(encoded.view(), refuse_rows, none) catch failure:
failed = failure.code == limit
recover ()
assert(failed)
test "scaled decodes have the scaled size and keep a flat color":
var raster = Raster()
defer raster.close()
raster.width = 40
raster.height = 24
try raster.standard(3, .uint8)
try raster.allocate()
for i in 0..<raster.pixels.length:
raster.pixels[i] = 200.0 if i % 3 == 0 else 60.0 if i % 3 == 1 else 120.0
var encoded = Buffer()
defer encoded.close()
try encode(&raster, &encoded, quality = 95)
let scales: usize[3] = [2, 4, 8]
for scale in scales:
let width = (40 + scale - 1) // scale
let height = (24 + scale - 1) // scale
var out: u8[960]
try decode_rgb8(encoded.view(), out[..<width * height * 3], Options(scale = scale))
for i in 0..<width * height:
assert(out[i * 3] >= 198 and out[i * 3] <= 202)
assert(out[i * 3 + 1] >= 58 and out[i * 3 + 1] <= 62)
assert(out[i * 3 + 2] >= 118 and out[i * 3 + 2] <= 122)
test "a scaled decode averages the full-size one":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 32, 16, 1)
var full: u8[1536]
try decode_rgb8(encoded.view(), full)
var half: u8[384]
try decode_rgb8(encoded.view(), half, Options(scale = 2))
# Each half-size pixel is the mean of its 2x2 full-size pixels before rounding,
# so within one of the mean of the rounded ones.
for y in 0..<(usize)8:
for x in 0..<(usize)16:
let sum = (i64)full[((2 * y) * 32 + 2 * x) * 3] + (i64)full[((2 * y) * 32 + 2 * x + 1) * 3] + (i64)full[((2 * y + 1) * 32 + 2 * x) * 3] + (i64)full[((2 * y + 1) * 32 + 2 * x + 1) * 3]
let difference = (i64)half[(y * 16 + x) * 3] * 4 - sum
assert(difference >= -6 and difference <= 6)
test "bad requests and bad data fail cleanly":
var encoded = Buffer()
defer encoded.close()
try test_picture(&encoded, 16, 8, 3)
var out: u8[512]
var refused = false
decode_rgba8(encoded.view(), out, Options(scale = 3)) catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
refused = false
decode_rgba8(encoded.view(), out[..<100]) catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
let data = encoded.view()
let cuts: usize[5] = [2, 20, 200, data.length - 40, data.length - 2]
for cut in cuts:
refused = false
decode_rgba8(data[..<cut], out) catch failure:
refused = failure.code == corrupt
recover ()
assert(refused)
refused = false
_ = info(b"not a jpeg at all") catch failure:
refused = failure.code == corrupt
recover Info(width = 0, height = 0, components = 0, progressive = false)
assert(refused)
## A smooth RGBA test picture with an edge, for the encoder.
func rgba_picture(pixels: u8[], width: usize, height: usize):
for y in 0..<height:
for x in 0..<width:
let at = (y * width + x) * 4
let edge: usize = 70 if x * 3 > width * 2 else 0
pixels[at] = (u8)((x * 255 // width + edge) % 256)
pixels[at + 1] = (u8)(y * 255 // height)
pixels[at + 2] = (u8)((x + y) * 2 % 256)
pixels[at + 3] = 255
## Mean and largest absolute difference between RGBA `source` and RGB `decoded`.
func compare_pixels(source: const u8[], decoded: const u8[], count: usize) -> (i64, i64):
var total: i64 = 0
var worst: i64 = 0
for i in 0..<count:
for c in 0..<(usize)3:
let d = (i64)source[i * 4 + c] - (i64)decoded[i * 3 + c]
let magnitude = d if d >= 0 else -d
total += magnitude
worst = magnitude if magnitude > worst else worst
return (total // (i64)(count * 3), worst)
test "the encoding APIs agree byte for byte":
var rgba: u8[3108]
rgba_picture(rgba, 37, 21)
var rgb: u8[2331]
for i in 0..<(usize)777:
rgb[i * 3] = rgba[i * 4]
rgb[i * 3 + 1] = rgba[i * 4 + 1]
rgb[i * 3 + 2] = rgba[i * 4 + 2]
var whole = Buffer()
defer whole.close()
try encode_rgba8(rgba, 37, 21, &whole)
var three = Buffer()
defer three.close()
try encode_rgb8(rgb, 37, 21, &three)
var streamed = Buffer()
defer streamed.close()
var encoder = try Encoder.begin(37, 21, .rgba, &streamed)
defer encoder.close()
var y: usize = 0
while y < 21:
let rows: usize = 5 if y + 5 <= 21 else 21 - y
try encoder.write_rows(rgba[y * 148..<(y + rows) * 148], rows)
y += rows
try encoder.finish()
assert(whole.used == three.used and whole.used == streamed.used)
for i in 0..<whole.used:
assert(whole.data[i] == three.data[i] and whole.data[i] == streamed.data[i])
test "every encoder option decodes close to the source":
var rgba: u8[6000]
rgba_picture(rgba, 50, 30)
let samplings: Subsampling[3] = [.s444, .s422, .s420]
for sampling in samplings:
for variant in 0..<(usize)4:
var out = Buffer()
defer out.close()
try encode_rgba8(rgba, 50, 30, &out, EncodeOptions(quality = 95, subsampling = sampling, restart = variant % 2 == 1, optimize = variant >= 2))
let found = try info(out.view())
assert(found.width == 50 and found.height == 30 and found.components == 3)
var decoded: u8[4500]
try decode_rgb8(out.view(), decoded)
let (mean, worst) = compare_pixels(rgba, decoded, 1500)
# Halved chroma blurs the hard color edge; elsewhere the error is small.
if sampling == .s444:
assert(mean <= 1 and worst <= 12)
else:
assert(mean <= 4 and worst <= 90)
test "gray and tiny pictures encode":
var gray: u8[153]
for i in 0..<gray.length:
gray[i] = (u8)(i * 5 % 256)
var out = Buffer()
defer out.close()
try encode_gray8(gray, 17, 9, &out, EncodeOptions(optimize = true))
let found = try info(out.view())
assert(found.components == 1 and found.width == 17 and found.height == 9)
var decoded: u8[459]
try decode_rgb8(out.view(), decoded)
var one = Buffer()
defer one.close()
let pixel: u8[4] = [200, 30, 90, 255]
try encode_rgba8(pixel, 1, 1, &one, EncodeOptions(quality = 100))
var back: u8[3]
try decode_rgb8(one.view(), back)
assert(back[0] >= 196 and back[0] <= 204 and back[1] >= 26 and back[1] <= 34 and back[2] >= 86 and back[2] <= 94)
test "the encoder refuses bad requests":
var out = Buffer()
defer out.close()
var pixels: u8[64]
var refused = false
encode_rgba8(pixels, 4, 4, &out, EncodeOptions(quality = 0)) catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
refused = false
encode_rgba8(pixels[..<60], 4, 4, &out) catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
var encoder = try Encoder.begin(4, 4, .rgba, &out)
defer encoder.close()
try encoder.write_rows(pixels[..<32], 2)
refused = false
encoder.finish() catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
refused = false
encoder.write_rows(pixels, 4) catch failure:
refused = failure.code == invalid
recover ()
assert(refused)
## Rows kept in one picture of `width` pixels, checked in order.
struct Streamed:
var pixels: u8[]
var width: usize
var pixel: usize
var next: usize
var calls: usize
func keep_streamed(context: void*?, first: usize, rows: usize, bytes: const u8[]) -> !:
let into = (Streamed*)(context else return)
if first != into.next or bytes.length != rows * into.width * into.pixel:
error(invalid, "rows out of order")
memory.copy(into.pixels[first * into.width * into.pixel..], bytes, bytes.length)
into.next = first + rows
into.calls += 1
test "a baseline picture streams its rows a group of MCU rows at a time, as it decodes whole":
# Tall enough for many groups at any thread count; every subsampling, a
# restart interval, gray, and a scaled decode.
let width: usize = 301
let height: usize = 1700
let pixels = try new u8[width * height * 4] --- in memory.heap
defer free(pixels) in memory.heap
for y in 0..<height:
for x in 0..<width:
let at = (y * width + x) * 4
pixels[at] = (u8)((x * 5 + y) % 256)
pixels[at + 1] = (u8)((y * 3 + x * x // 7) % 256)
pixels[at + 2] = (u8)(((x + y) // 11) * 13 % 256)
pixels[at + 3] = 255
let gray = try new u8[width * height] --- in memory.heap
defer free(gray) in memory.heap
for i in 0..<gray.length:
gray[i] = pixels[i * 4 + 1]
let whole = try new u8[width * height * 4] --- in memory.heap
defer free(whole) in memory.heap
let streamed = try new u8[width * height * 4] --- in memory.heap
defer free(streamed) in memory.heap
for case in 0..<(usize)6:
var encoded = Buffer()
defer encoded.close()
if case == 4:
try encode_gray8(gray, width, height, &encoded)
else:
let sampling = Subsampling.s444 if case == 0 else Subsampling.s422 if case == 1 else Subsampling.s420
try encode_rgba8(pixels, width, height, &encoded, EncodeOptions(subsampling = sampling, restart = case == 3))
let scale: usize = 2 if case == 5 else 1
let options = Options(scale = scale)
let wide = (width + scale - 1) // scale
let tall = (height + scale - 1) // scale
for threads in [(usize)1, 0]:
let chosen = Options(scale = scale, threads = threads)
try decode_rgba8(encoded.view(), whole[..<wide * tall * 4], options)
var rows = Streamed(pixels = streamed, width = wide, pixel = 4, next = 0, calls = 0)
try decode_rows(encoded.view(), keep_streamed, (void*)&rows, options = chosen)
assert(rows.next == tall and rows.calls > 1)
for i in 0..<wide * tall * 4:
assert(streamed[i] == whole[i])
test "the start of a file through its frame header is what info needs":
var pixels: u8[64 * 48 * 4]
for index in 0..<pixels.length:
pixels[index] = (u8)(index * 5)
var out = Buffer()
defer out.close()
try encode_rgba8(pixels, 64, 48, &out)
let data = out.view()
var have: usize = 1
while true:
let need = try head_bytes(data[..<have])
if need == 0:
break
assert(need > have and need <= data.length)
have = need
let found = try info(data[..<have])
assert(found.width == 64 and found.height == 48)
var refused = false
_ = head_bytes(b"\x89PNG") catch failure:
refused = failure.code == corrupt
recover 0
assert(refused)
# mark: ICC profiles ===========================================================================
from luce_std import files
import c as libc
import strings
## The bytes of tests/fixtures/icc/NAME, kept in the heap for the run (tests run from the
## repository root).
func icc_fixture(name: str) -> const u8[]:
var buffer: u8[256]
let path = strings.format(buffer, f"tests/fixtures/icc/{name}") else trap("a fixture path is too long")
with memory.heap:
return (files.read((libc.str)path) else trap("cannot read an ICC fixture")).value
## The profile joined from fixture `name`, or none; kept in the heap for the run.
func joined_profile(name: str) -> u8[]?:
with memory.heap:
return icc_profile(icc_fixture(name)) else trap("the fixture's markers read")
test "an ICC profile joins from its APP2 segments in sequence order":
let one = joined_profile("icc-one.jpg") else trap("one segment")
assert(one.length == 1000)
let names: str[6] = ["icc-three.jpg", "icc-reordered.jpg", "icc-other-app2.jpg", "icc-short-segment.jpg", "icc-one-empty-part.jpg", "icc-between-scans.jpg"]
for name in names:
let joined = joined_profile(name) else trap("the segments join")
assert((str)joined == (str)one)
let v4 = joined_profile("ladybird-icc-v4.jpg") else trap("Ladybird's profile")
assert(v4.length == 656 and (str)v4[36..<40] == "acsp")
test "inconsistent ICC segments give no profile, as in libjpeg-turbo":
let names: str[9] = ["icc-duplicate.jpg", "icc-missing.jpg", "icc-counts-differ.jpg", "icc-sequence-zero.jpg", "icc-sequence-past-count.jpg", "icc-empty-parts.jpg", "icc-zero-count.jpg", "ladybird-gradient-empty-icc.jpg", "icc-before-eoi.jpg"]
for name in names:
assert(joined_profile(name) == none)
test "an embedded ICC profile reads back, across segments":
var profile = try new u8[70000] in memory.heap
defer free(profile) in memory.heap
for at in 0..<profile.length:
profile[at] = (u8)(at % 251)
var pixels: u8[48]
var output = Buffer()
defer output.close()
try encode_rgb8(pixels, 4, 4, &output, EncodeOptions(icc_profile = profile))
let read = (try icc_profile(output.data[..<output.used])) else trap("the profile did not read back")
defer free(read)
assert(read.length == profile.length)
for at in 0..<read.length:
assert(read[at] == profile[at])
var plain = Buffer()
defer plain.close()
try encode_rgb8(pixels, 4, 4, &plain)
assert((try icc_profile(plain.data[..<plain.used])) == none)