Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-raw

Source of release 0.8.1

0.8.1 / src / raw / fuji_compressed.lucb

#==============================================================================================
#
#   raw/fuji_compressed - Fujifilm's compressed RAF coding
#
#   DESCRIPTION:
#       Since the X-Pro2 and X-T2, Fujifilm raws may be compressed, losslessly or
#       lossily: the sensor is cut into vertical strips (768 columns) that decode
#       independently, six rows at a time, into eighteen line buffers per strip
#       (five red, eight green, five blue, each color's samples of a row packed
#       together). Each sample is an adaptive Golomb-style code relative to a
#       gradient-chosen prediction from the lines above; X-Trans files interpolate
#       some positions instead of coding them. This follows LibRaw's
#       fuji_compressed.cpp (Alexey Danilchenko's decoder) step for step.
#
#==============================================================================================

## Line buffers of one strip: red 0-4, green 5-12, blue 13-17. Lines 0 and 1
## of each color keep the previous six rows' last lines as context.
let fuji_r2: usize = 2
let fuji_g2: usize = 7
let fuji_b2: usize = 15
let fuji_lines: usize = 18

## One quantization table: the gradient class of every difference.
struct FujiQuant:
    var table: i8[]
    var base: i32
    var max_grad: i32
    var grad_mult: i32
    var total_values: i32
    var raw_bits: i32

## What every strip shares: the header's facts and the lossy tables.
struct FujiParams:
    var quant: FujiQuant[4]
    var tables: i8[]
    var max_value: i32
    var min_value: i32 = 0x40
    var line_width: usize
    var block_width: usize
    var blocks: usize
    var lines: usize
    var bits: u32
    var xtrans: bool
    var lossless: bool

    func close():
        if self.tables.length > 0:
            free(self.tables) in memory.heap
        self = FujiParams()

## Adaptive statistics for one context: sum and count of magnitudes per
## gradient class (41 classes, or 5 for each of the three lossy tables).
struct FujiGrads:
    var main: i32[82]
    var lossy: i32[30]

## The state of one strip being decoded.
struct FujiStrip:
    var reader: Bits
    var even: FujiGrads[3]
    var odd: FujiGrads[3]
    var lines: u16[]
    var main: FujiQuant
    var max_bits: i32

func log2ceil(value: i32) -> i32:
    var result: i32 = 0
    var v = value
    if v != 0:
        v -= 1
        result += 1
        v >>= 1
        while v != 0:
            result += 1
            v >>= 1
    return result

## Fill `table` (2 × maximum + 1 entries) with the class of each difference.
func fuji_qlut(table: i8[], q: i32[5]):
    var at: usize = 0
    var value = -q[4]
    while value <= q[4]:
        table[at] = -4 if value <= -q[3] else -3 if value <= -q[2] else -2 if value <= -q[1] else -1 if value < -q[0] else 0 if value <= q[0] else 1 if value < q[1] else 2 if value < q[2] else 3 if value < q[3] else 4
        at += 1
        value += 1

## The main table for quantization base `base`, as init_main_qtable.
func fuji_main_table(quant: FujiQuant*, max_value: i32, base: i32) -> i32:
    var q: i32[5] = [base, 3 * base + 0x12, 5 * base + 0x43, 7 * base + 0x114, max_value]
    let ceiling = max_value + 1
    if q[1] >= ceiling or q[1] < base + 1:
        q[1] = base + 1
    if q[2] < q[1] or q[2] >= ceiling:
        q[2] = q[1]
    if q[3] < q[2] or q[3] >= ceiling:
        q[3] = q[2]
    fuji_qlut(quant.table, q)
    quant.base = base
    quant.max_grad = 0
    quant.total_values = (q[4] + 2 * base) // (2 * base + 1) + 1
    quant.raw_bits = log2ceil(quant.total_values)
    quant.grad_mult = 9
    return 4 * log2ceil(q[4] + 1)

## Parse the 16-byte header at the start of the raw data.
func fuji_params(data: const u8[]) -> FujiParams!:
    var header = Reader(data = data, little = false)
    let signature = try header.uint(2)
    let lossless = try header.byte()
    let kind = try header.byte()
    let bits = (u32)(try header.byte())
    let height = (usize)(try header.uint(2))
    let rounded = (usize)(try header.uint(2))
    let width = (usize)(try header.uint(2))
    let block = (usize)(try header.uint(2))
    let blocks = (usize)(try header.byte())
    let lines = (usize)(try header.uint(2))
    if signature != 0x4953 or lossless > 1 or height > 0x4002 or height < 6 or height % 6 != 0 or width > 0x4200 or width < 0x300 or width % 24 != 0 or rounded > 0x4200 or block != 0x300 or rounded % block != 0 or rounded < width or rounded - width >= block or blocks == 0 or blocks > 0x10 or blocks != rounded // block or lines == 0 or lines > 0xaab or lines != height // 6 or (bits != 12 and bits != 14 and bits != 16) or (kind != 16 and kind != 0):
        error(corrupt, "Fujifilm compressed header is invalid")
    var params = FujiParams(block_width = block, blocks = blocks, lines = lines, bits = bits, xtrans = kind == 16, lossless = lossless == 1)
    errdefer params.close()
    params.line_width = block * 2 // 3 if params.xtrans else block // 2
    params.max_value = ((i32)1 << bits) - 1
    let size = (usize)2 << (usize)bits
    if not params.lossless:
        # Three fixed tables for flat areas; the main one is set per line.
        params.tables = try new i8[3 * size] in memory.heap
        let bases: i32[3] = [0, 1, 2]
        let grads: i32[3] = [5, 6, 7]
        let firsts: i32[3] = [0x12, 0x15, 0x18]
        let seconds: i32[3] = [0x43, 0x48, 0x4d]
        let thirds: i32[3] = [0x114, 0x11b, 0x122]
        for k: usize in 0..<3:
            var quant = FujiQuant(table = params.tables[k * size..<(k + 1) * size], base = bases[k], max_grad = grads[k], grad_mult = 3)
            quant.total_values = (params.max_value + 2 * bases[k]) // (2 * bases[k] + 1) + 1
            quant.raw_bits = log2ceil(quant.total_values)
            var q: i32[5] = [bases[k], 0, 0, 0, params.max_value]
            q[1] = firsts[k] if q[4] >= firsts[k] else q[0] + 1
            q[2] = seconds[k] if q[4] >= seconds[k] else q[1]
            q[3] = thirds[k] if q[4] >= thirds[k] else q[2]
            fuji_qlut(quant.table, q)
            params.quant[k + 1] = quant
    return params

## The number of zero bits above the highest one bit of `value` (not zero),
## from the exponent of its exact double: no branches.
inline func leading32(value: u32) -> i32:
    var real = (f64)value
    let bits = *(const u64*)&real
    return 1054 - (i32)(bits >> 52)

## Consume `n` bits; LibRaw tolerates reading one zero byte past the data.
## These helpers never fail: they set `reader.fault`, which their callers
## check once per line, as returning errors per code would cost more than
## the decoding.
inline func fuji_consume(reader: Bits*, n: u32):
    reader.buffer = reader.buffer << n if n < 64 else 0
    reader.count -= n
    if reader.count + 8 < reader.padding:
        reader.fault = true

## Count zero bits up to and including the next one bit.
func fuji_zeros(reader: Bits*) -> i32:
    if reader.count < 33:
        reader.fill()
    let top = (u32)(reader.buffer >> 32)
    if top != 0:
        let n = leading32(top)
        fuji_consume(reader, (u32)n + 1)
        return n
    var zeros: i32 = 0
    while true:
        if reader.count < 33:
            reader.fill()
        let upper = (u32)(reader.buffer >> 32)
        if upper != 0:
            let n = leading32(upper)
            fuji_consume(reader, (u32)n + 1)
            return zeros + n
        zeros += 32
        fuji_consume(reader, 32)
        if zeros > 1024 or reader.fault:
            reader.fault = true
            return 0
    return zeros

## The next `n` bits.
func fuji_read(reader: Bits*, n: i32) -> i32:
    if n <= 0:
        return 0
    if n > 32:
        reader.fault = true
        return 0
    if reader.count < (u32)n:
        reader.fill()
    let value = (i32)(u32)(reader.buffer >> (64 - (u32)n))
    fuji_consume(reader, (u32)n)
    return value