dymokomi/luce-raw
Source of release 0.8.1
0.8.1 / src / raw / fuji_strips.lucb
#==============================================================================================
#
# raw/fuji_strips - Decoding Fujifilm's compressed strips
#
# DESCRIPTION:
# Each strip decodes six sensor rows per step in six passes over pairs of line
# buffers; within a pass the even positions run eight samples ahead of the odd
# ones, which predict from the even neighbour to their right. A sample is
# either coded (a count of zero bits, then a remainder whose width adapts to
# the context's mean magnitude) or, on X-Trans, interpolated from the line
# above. After six passes the lines are laid into the mosaic by the filter
# pattern. `unpack_fuji` runs the strips in parallel.
#
#==============================================================================================
## One pass: two line buffers, how each treats its even positions (0 coded,
## 1 interpolated, 2 interpolated where pos & 3 == 0, 3 where pos & 3 == 2),
## and the statistics set it uses.
struct FujiPass:
var a: u8
var a_rule: u8
var b: u8
var b_rule: u8
var set: u8
let xtrans_passes: FujiPass[6] = [
FujiPass(a = 2, a_rule = 1, b = 7, b_rule = 0, set = 0), FujiPass(a = 8, a_rule = 0, b = 15, b_rule = 1, set = 1),
FujiPass(a = 3, a_rule = 2, b = 9, b_rule = 1, set = 2), FujiPass(a = 10, a_rule = 0, b = 16, b_rule = 3, set = 0),
FujiPass(a = 4, a_rule = 3, b = 11, b_rule = 0, set = 1), FujiPass(a = 12, a_rule = 1, b = 17, b_rule = 2, set = 2)]
let bayer_passes: FujiPass[6] = [
FujiPass(a = 2, a_rule = 0, b = 7, b_rule = 0, set = 0), FujiPass(a = 8, a_rule = 0, b = 15, b_rule = 0, set = 1),
FujiPass(a = 3, a_rule = 0, b = 9, b_rule = 0, set = 2), FujiPass(a = 10, a_rule = 0, b = 16, b_rule = 0, set = 0),
FujiPass(a = 4, a_rule = 0, b = 11, b_rule = 0, set = 1), FujiPass(a = 12, a_rule = 0, b = 17, b_rule = 0, set = 2)]
inline func absolute(value: i32) -> i32:
return value if value >= 0 else -value
## The bits of remainder a context wants: the smallest shift of its count
## reaching its sum.
inline func remainder_bits(sum: i32, count: i32) -> i32:
var bits: i32 = 0
if count < sum:
bits += 1
while bits <= 14 and (count << bits) < sum:
bits += 1
return bits
## Decode one coded sample at `at` (index into the strip's lines) predicted as
## `prediction`, with the gradient `grad` of its neighbours; `even` samples
## scale their prediction down by four first. Returns the stored value.
func fuji_code(strip: FujiStrip*, params: const FujiParams*, grads: FujiGrads*, quant_index: usize, grad: i32, prediction: i32) -> u16:
let quant = (const FujiQuant*)&strip.main if quant_index == 0 else ¶ms.quant[quant_index]
var gradient = (usize)absolute(grad)
if (quant_index == 0 and gradient > 40) or (quant_index > 0 and gradient > 4):
strip.reader.fault = true
gradient = 0
let at = gradient * 2 if quant_index == 0 else ((quant_index - 1) * 5 + gradient) * 2
let sums: i32[] = grads.main[0..] if quant_index == 0 else grads.lossy[0..]
let zeros = fuji_zeros(&strip.reader)
var code: i32 = 0
if zeros < strip.max_bits - quant.raw_bits - 1:
let bits = remainder_bits(sums[at], sums[at + 1])
code = fuji_read(&strip.reader, bits) + (zeros << bits)
else:
code = fuji_read(&strip.reader, quant.raw_bits) + 1
code = -1 - code // 2 if (code & 1) != 0 else code // 2
sums[at] += absolute(code)
if sums[at + 1] == params.min_value:
sums[at] >>= 1
sums[at + 1] >>= 1
sums[at + 1] += 1
let step = 2 * quant.base + 1
var value = prediction - code * step if grad < 0 else prediction + code * step
if value < -quant.base:
value += quant.total_values * step
elif value > quant.base + params.max_value:
value -= quant.total_values * step
return 0 if value < 0 else (u16)(value if value < params.max_value else params.max_value)
## The quantization table for a sample whose neighbour differences sum to
## `flatness`: a lossy fixed table in flat areas, else the main one.
inline func fuji_table(strip: const FujiStrip*, params: const FujiParams*, flatness: i32) -> usize:
var i: usize = 1
while i < 4 and strip.main.base >= (i32)i:
if flatness <= params.quant[i].max_grad:
return i
i += 1
return 0
## The class of a pair of differences in table `index`.
inline func fuji_grad(strip: const FujiStrip*, params: const FujiParams*, index: usize, first: i32, second: i32) -> i32:
let table = strip.main.table if index == 0 else params.quant[index].table
let m = (usize)params.max_value
let quant = strip.main.grad_mult if index == 0 else params.quant[index].grad_mult
return quant * (i32)table[(usize)((i64)m + (i64)first)] + (i32)table[(usize)((i64)m + (i64)second)]
## An even position: coded, or when `interpolate`, predicted only.
func fuji_even(strip: FujiStrip*, params: const FujiParams*, line: usize, pos: usize, grads: FujiGrads*, interpolate: bool):
let w = params.line_width + 2
let at = line * w + 1 + pos
let l = strip.lines
let rb = (i32)l[at - w]
let rc = (i32)l[at - w - 1]
let rd = (i32)l[at - w + 1]
let rf = (i32)l[at - 2 * w]
let cb = absolute(rc - rb)
let fb = absolute(rf - rb)
let db = absolute(rd - rb)
let sum = rf + rd + 2 * rb if cb > fb and cb > db else rf + rc + 2 * rb if db > cb and db > fb else rd + rc + 2 * rb
if interpolate:
l[at] = (u16)(sum >> 2)
return
let index = fuji_table(strip, params, fb + cb)
let grad = fuji_grad(strip, params, index, rb - rf, rc - rb)
l[at] = fuji_code(strip, params, grads, index, grad, sum >> 2)
## An odd position, predicted from its left and right neighbours.
func fuji_odd(strip: FujiStrip*, params: const FujiParams*, line: usize, pos: usize, grads: FujiGrads*):
let w = params.line_width + 2
let at = line * w + 1 + pos
let l = strip.lines
let ra = (i32)l[at - 1]
let rb = (i32)l[at - w]
let rc = (i32)l[at - w - 1]
let rd = (i32)l[at - w + 1]
let rg = (i32)l[at + 1]
let index = fuji_table(strip, params, absolute(rb - rc) + absolute(rc - ra))
let grad = fuji_grad(strip, params, index, rb - rc, rc - ra)
let prediction = (rg + ra + 2 * rb) >> 2 if (rb > rc and rb > rd) or (rb < rc and rb < rd) else (ra + rg) >> 1
l[at] = fuji_code(strip, params, grads, index, grad, prediction)
## Copy each line's edge from the line before, for lines `first` to `last`.
func fuji_extend(strip: FujiStrip*, width: usize, first: usize, last: usize):
let w = width + 2
for line in first..=last:
strip.lines[line * w] = strip.lines[(line - 1) * w + 1]
strip.lines[line * w + width + 1] = strip.lines[(line - 1) * w + width]
## The extension of the color group holding line `line`.
func fuji_extend_group(strip: FujiStrip*, width: usize, line: usize):
if line <= 4:
fuji_extend(strip, width, 2, 4)
elif line <= 12:
fuji_extend(strip, width, 7, 12)
else:
fuji_extend(strip, width, 15, 17)
## One step of six rows: the six passes.
func fuji_block(strip: FujiStrip*, params: const FujiParams*):
let lw = params.line_width
for pass in (xtrans_passes if params.xtrans else bayer_passes):
let set = (usize)pass.set
var even: usize = 0
var odd: usize = 1
while even < lw or odd < lw:
if even < lw:
for side: usize in 0..<2:
let line = (usize)(pass.a if side == 0 else pass.b)
let rule = pass.a_rule if side == 0 else pass.b_rule
let interpolate = rule == 1 or (rule == 2 and (even & 3) == 0) or (rule == 3 and (even & 3) == 2)
fuji_even(strip, params, line, even, &strip.even[set], interpolate)
even += 2
if even > 8:
fuji_odd(strip, params, (usize)pass.a, odd, &strip.odd[set])
fuji_odd(strip, params, (usize)pass.b, odd, &strip.odd[set])
odd += 2
fuji_extend_group(strip, lw, (usize)pass.a)
fuji_extend_group(strip, lw, (usize)pass.b)
## Where each of the six rows of a step finds its samples in the line
## buffers, for every column of strip `block` (`width` columns): the filter
## color picks the buffer, X-Trans packs two of every three columns.
func fuji_layout(params: const FujiParams*, meta: const Meta*, block: usize, width: usize, layout: u32[]):
let w = params.line_width + 2
for row: usize in 0..<6:
for p in 0..<width:
let color = meta.color(block * params.block_width + p, row)
let buffer = fuji_r2 + (row >> 1) if color == 0 else fuji_b2 + (row >> 1) if color == 2 else fuji_g2 + row
let index = ((((p * 2 // 3) & ~(usize)1) | ((p % 3) & 1)) + ((p % 3) >> 1)) if params.xtrans else p >> 1
layout[row * width + p] = (u32)(buffer * w + 1 + index)
## Lay the six decoded rows of step `line` of strip `block` into the mosaic.
func fuji_copy(strip: const FujiStrip*, params: const FujiParams*, mosaic: Mosaic*, line: usize, block: usize, width: usize, layout: const u32[]):
let lines = strip.lines.data
for row: usize in 0..<6:
let y = line * 6 + row
let target = mosaic.data.data + (y * mosaic.width + block * params.block_width)
let map = layout.data + row * width
for p in 0..<width:
target[p] = lines[map[p]]
## What `fuji_strip` reads: the strips' data and where to write.
struct FujiJob:
var params: const FujiParams*
var meta: const Meta*
var mosaic: Mosaic*
var strips: const u8[]
var offsets: usize[17]
var q_bases: const u8[]
var progress: Progress*?
## Decode strip `block`; strips write disjoint columns, so `parallel` may run them at once.
func fuji_strip(context: void*, block: usize, worker: usize) -> !:
let job = (FujiJob*)context
let params = job.params
let lw = params.line_width
let w = lw + 2
var strip = FujiStrip(reader = Bits(data = job.strips[job.offsets[block]..<job.offsets[block + 1]]))
strip.lines = try new u16[fuji_lines * w] in memory.heap
defer free(strip.lines) in memory.heap
let table_size = (usize)2 << (usize)params.bits
let table = try new i8[table_size] in memory.heap
defer free(table) in memory.heap
strip.main = FujiQuant(table = table)
strip.max_bits = fuji_main_table(&strip.main, params.max_value, 0)
for set: usize in 0..<3:
for k: usize in 0..<3:
let spread = math.imax(2, (i64)((params.quant[k + 1].total_values + 0x20) >> 6))
for i: usize in 0..<5:
strip.even[set].lossy[(k * 5 + i) * 2] = (i32)spread
strip.even[set].lossy[(k * 5 + i) * 2 + 1] = 1
strip.odd[set].lossy[(k * 5 + i) * 2] = (i32)spread
strip.odd[set].lossy[(k * 5 + i) * 2 + 1] = 1
if params.lossless:
fuji_main_grads(&strip)
let width = params.block_width if block + 1 < params.blocks else job.mosaic.width - params.block_width * block
# The filter repeats every six rows, as a step does.
let layout = try new u32[6 * width] in memory.heap
defer free(layout) in memory.heap
fuji_layout(params, job.meta, block, width, layout)
let step = (params.lines + 15) & ~(usize)15
# Lines 0 and 1 of each color take lines 3 and 4 (or 6 and 7) after each step.
let keep: usize[12] = [0, 3, 1, 4, 5, 11, 6, 12, 13, 16, 14, 17]
for line in 0..<params.lines:
if not params.lossless:
let base = (i32)job.q_bases[block * step + line]
if line == 0 or base != strip.main.base:
strip.max_bits = fuji_main_table(&strip.main, params.max_value, base)
fuji_main_grads(&strip)
fuji_block(&strip, params)
if strip.reader.fault:
error(corrupt, "Fujifilm compressed data is invalid or truncated")
for k: usize in 0..<6:
memory.copy(strip.lines[keep[k * 2] * w..], strip.lines[keep[k * 2 + 1] * w..], w)
fuji_copy(&strip, params, job.mosaic, line, block, width, layout)
if let progress = job.progress:
progress.publish(block, (line + 1) * 6)
for group: usize in 0..<3:
let first = fuji_r2 if group == 0 else fuji_g2 if group == 1 else fuji_b2
let count: usize = 6 if group == 1 else 3
for i in first * w..<(first + count) * w:
strip.lines[i] = 0
strip.lines[first * w] = strip.lines[(first - 1) * w + 1]
strip.lines[first * w + lw + 1] = strip.lines[(first - 1) * w + lw]
## Reset every main context to the table's starting statistics.
func fuji_main_grads(strip: FujiStrip*):
let spread = (i32)math.imax(2, (i64)((strip.main.total_values + 0x20) >> 6))
for set: usize in 0..<3:
for i: usize in 0..<41:
strip.even[set].main[i * 2] = spread
strip.even[set].main[i * 2 + 1] = 1
strip.odd[set].main[i * 2] = spread
strip.odd[set].main[i * 2 + 1] = 1
## Fujifilm's compressed RAF: header, strip sizes, lossy bases, then strips.
func unpack_fuji(file: const u8[], meta: const Meta*, mosaic: Mosaic*, threads: usize, progress: Progress*?) -> !:
let data = try binary.slice(file, (u64)meta.data_offset, (u64)meta.data_size)
var params = try fuji_params(data)
defer params.close()
if params.lines * 6 != mosaic.height or mosaic.width > params.blocks * params.block_width:
error(corrupt, "Fujifilm compressed header disagrees with the raw size")
var sizes = Reader(data = data, position = 16, little = false)
var job = FujiJob(params = ¶ms, meta = meta, mosaic = mosaic, progress = progress)
if let tracker = progress:
tracker.producers(params.blocks)
var total: usize = 0
var lengths: usize[17]
for b in 0..<params.blocks:
lengths[b] = (usize)(try sizes.uint(4))
var at = 16 + ((4 * params.blocks + 15) & ~(usize)15)
if not params.lossless:
let count = params.blocks * ((params.lines + 15) & ~(usize)15)
job.q_bases = try binary.slice(data, (u64)at, (u64)count)
at += count
if at > data.length:
error(corrupt, "Fujifilm compressed data is truncated")
job.strips = data[at..]
for b in 0..<params.blocks:
job.offsets[b] = total
total = (usize)math.imin((i64)(total + lengths[b]), (i64)job.strips.length)
job.offsets[params.blocks] = total
try parallel.for_each(params.blocks, (void*)&job, fuji_strip, threads = threads)