Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-raw

Source of release 0.8.0

0.8.0 / src / raw / tests_codec.lucb

#==============================================================================================
#
#   raw/tests_codec - Bit reader, Huffman and lossless JPEG tests
#
#   DESCRIPTION:
#       A minimal lossless JPEG encoder (every difference category coded in five
#       bits, any predictor, optional restart intervals) produces streams that the
#       decoder must reproduce sample for sample; truncated streams must fail with
#       errors. The Huffman and bit reader tests use hand-built codes.
#
#==============================================================================================

## Most-significant-first bit writer with JPEG's zero byte after 0xFF.
struct BitWriter:
    var out: Buffer
    var value: u32
    var count: u32

    func put(bits: u32, length: u32) -> !:
        for i in 0..<length:
            self.value = (self.value << 1) | ((bits >> (length - 1 - i)) & 1)
            self.count += 1
            if self.count == 8:
                try self.out.byte((u8)self.value)
                if self.value == 255:
                    try self.out.byte(0)
                self.value = 0
                self.count = 0

    func flush() -> !:
        while self.count != 0:
            try self.put(1, 1)

## Encode `samples` (`width` × `height` pixels of `components` interleaved) as a
## lossless JPEG with `predictor`, a restart every `restart` pixels (0: none).
func encode_ljpeg(samples: const u16[], width: usize, height: usize, components: usize, precision: u32, predictor: u32, restart: usize) -> Buffer!:
    var writer = BitWriter(out = Buffer())
    errdefer writer.out.close()
    try writer.out.put([0xff, 0xd8, 0xff, 0xc3, 0, (u8)(8 + 3 * components), (u8)precision, (u8)(height >> 8), (u8)height, (u8)(width >> 8), (u8)width, (u8)components])
    for c in 0..<components:
        try writer.out.put([(u8)(c + 1), 0x11, 0])
    if restart > 0:
        try writer.out.put([0xff, 0xdd, 0, 4, (u8)(restart >> 8), (u8)restart])
    # One table: categories 0 to 16, five bits each.
    try writer.out.put([0xff, 0xc4, 0, 36, 0x00, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
    for symbol: u8 in 0..<17:
        try writer.out.byte(symbol)
    try writer.out.put([0xff, 0xda, 0, (u8)(6 + 2 * components), (u8)components])
    for c in 0..<components:
        try writer.out.put([(u8)(c + 1), 0x00])
    try writer.out.put([(u8)predictor, 0, 0])
    var marker: u8 = 0
    for y in 0..<height:
        let first = y == 0 or (restart > 0 and (y * width) % restart == 0)
        if restart > 0 and y > 0 and (y * width) % restart == 0:
            try writer.flush()
            try writer.out.put([0xff, 0xd0 + marker])
            marker = (marker + 1) % 8
        for x in 0..<width:
            for c in 0..<components:
                let at = (y * width + x) * components + c
                let a = (i32)samples[at - components] if x > 0 else 0
                let b = (i32)samples[at - width * components] if y > 0 else 0
                let d = (i32)samples[at - width * components - components] if x > 0 and y > 0 else 0
                var prediction = (i32)1 << (precision - 1)
                if x > 0 and first:
                    prediction = a
                elif x == 0 and not first:
                    prediction = b
                elif x > 0:
                    prediction = a if predictor == 1 else b if predictor == 2 else d if predictor == 3 else a + b - d if predictor == 4 else a + ((b - d) >> 1) if predictor == 5 else b + ((a - d) >> 1) if predictor == 6 else (a + b) >> 1
                var delta = ((i32)samples[at] - prediction) & 65535
                if delta >= 32768:
                    delta -= 65536
                var category: u32 = 0
                var magnitude = delta if delta >= 0 else -delta
                while magnitude > 0:
                    category += 1
                    magnitude >>= 1
                try writer.put(category, 5)
                if category > 0 and category < 16:
                    try writer.put((u32)(delta if delta > 0 else delta + ((i32)1 << category) - 1), category)
    try writer.flush()
    try writer.out.put([0xff, 0xd9])
    return writer.out

## Decode every line of `data` into `out`.
func decode_ljpeg(data: const u8[], out: u16[]) -> !:
    var jpeg = try LosslessJpeg.open(data)
    defer jpeg.close()
    let line = jpeg.width * jpeg.components
    for y in 0..<jpeg.height:
        let samples = try jpeg.next()
        memory.copy(out[y * line..], samples, line)

test "lossless JPEG round-trips every predictor, component count and restart interval":
    let width: usize = 13
    let height: usize = 7
    let samples = try new u16[width * height * 4] in memory.heap
    defer free(samples) in memory.heap
    let decoded = try new u16[width * height * 4] in memory.heap
    defer free(decoded) in memory.heap
    let restarts: usize[2] = [0, width * 2]
    for components: usize in 1..=4:
        for i in 0..<width * height * components:
            samples[i] = (u16)(testing.random() % 4096)
        for predictor: u32 in 1..=7:
            for restart in restarts:
                var stream = try encode_ljpeg(samples[..<width * height * components], width, height, components, 12, predictor, restart)
                defer stream.close()
                try decode_ljpeg(stream.view(), decoded)
                for i in 0..<width * height * components:
                    assert(decoded[i] == samples[i], "lossless JPEG sample differs")

test "16-bit lossless JPEG codes the ±32768 difference as category 16":
    var samples: u16[8] = [0, 32768, 0, 65535, 1, 65534, 32767, 32768]
    var stream = try encode_ljpeg(samples, 8, 1, 1, 16, 1, 0)
    defer stream.close()
    var decoded: u16[8]
    try decode_ljpeg(stream.view(), decoded)
    for i: usize in 0..<8:
        assert(decoded[i] == samples[i], "16-bit sample differs")

test "a truncated or corrupted lossless JPEG fails with an error":
    var samples: u16[120]
    for i in 0..<samples.length:
        samples[i] = (u16)(testing.random() % 16384)
    var stream = try encode_ljpeg(samples, 12, 10, 1, 14, 6, 24)
    defer stream.close()
    var decoded: u16[120]
    let data = stream.view()
    for cut in 0..<data.length - 2:
        var failed = false
        decode_ljpeg(data[..<cut], decoded) catch failure:
            failed = true
            recover ()
        assert(failed, "a truncated lossless JPEG decoded")
    let copy = try new u8[data.length] in memory.heap
    defer free(copy) in memory.heap
    for round in 0..<400:
        memory.copy(copy, data, data.length)
        copy[(usize)(testing.random() % (u64)data.length)] = (u8)(testing.random() % 256)
        decode_ljpeg(copy, decoded) catch failure:
            recover ()

test "Huffman tables decode dcraw's example code":
    let counts: u8[16] = [0, 1, 4, 2, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    let symbols: u8[13] = [0x04, 0x03, 0x05, 0x06, 0x02, 0x07, 0x01, 0x08, 0x09, 0x00, 0x0a, 0x0b, 0xff]
    var table = try Huffman.build(counts, symbols)
    defer table.close()
    # 00 010 011 100 101 1100 1101 11100 11101 11110 111110 1111110 1111111: 57
    # bits, then seven 1s, which read as one more 0xff.
    let stream: u8[8] = [0x13, 0x97, 0x37, 0x9d, 0xf7, 0xdf, 0xbf, 0xff]
    var reader = Bits(data = stream)
    for expected in symbols:
        assert(try table.decode(&reader) == (u32)expected, "Huffman symbol differs")
    assert(try table.decode(&reader) == 0xff, "the final padding code differs")
    var failed = false
    _ = table.decode(&reader) catch failure:
        failed = true
        recover 0
    assert(failed, "reading past the data succeeded")

test "the JPEG bit reader drops stuffed zeros and stops at markers":
    let stream: u8[6] = [0xff, 0x00, 0x81, 0xff, 0xd9, 0x55]
    var reader = Bits(data = stream, stuffed = true)
    assert(try reader.read(8) == 0xff and try reader.read(8) == 0x81, "stuffed byte mishandled")
    var failed = false
    _ = reader.read(1) catch failure:
        failed = true
        recover 0
    assert(failed, "the reader read through a marker")

test "a lossless JPEG scan decodes alike on many threads and serially":
    let width: usize = 700
    let height: usize = 800
    let predictors: u32[2] = [1, 6]
    for predictor in predictors:
        # Two components wandering independently, with the odd large step.
        let samples = try new u16[width * height * 2] in memory.heap
        defer free(samples) in memory.heap
        var seed: u32 = 99 +% predictor
        var level: i32[2] = [2000, 3000]
        for i in 0..<samples.length:
            seed = seed *% 1103515245 +% 12345
            let step = (i32)(seed >> 26) - 32 if (seed & 0xff) != 7 else (i32)(seed >> 20) - 2048
            level[i % 2] = (level[i % 2] + step) & 16383
            samples[i] = (u16)level[i % 2]
        var stream = try encode_ljpeg(samples, width, height, 2, 14, predictor, 0)
        defer stream.close()
        var parallel_jpeg = try LosslessJpeg.open(stream.view())
        defer parallel_jpeg.close()
        let decoded = try decode_jpeg_parallel(&parallel_jpeg, stream.view(), 8)
        defer release_samples(decoded)
        assert(decoded.length == samples.length, "the scan was not decoded in parallel")
        var serial = try LosslessJpeg.open(stream.view())
        defer serial.close()
        for y in 0..<height:
            let line = try serial.next()
            for i in 0..<line.length:
                assert(line[i] == decoded[y * width * 2 + i] and line[i] == samples[y * width * 2 + i], "a sample differs")