dymokomi/luce-raw
Source of release 0.8.2
0.8.2 / src / raw / ljpeg.lucb
#==============================================================================================
#
# raw/ljpeg - Lossless JPEG, ITU T.81 process 14
#
# DESCRIPTION:
# DNG tiles, Canon CR2 slices and many other raws are lossless JPEG: a frame
# (SOF3) of up to four interleaved components, Huffman-coded differences from
# one of seven predictors, and optional restart intervals. LosslessJpeg parses
# the markers and yields one decoded line of interleaved samples at a time;
# callers lay those samples into the mosaic as their format arranges them.
#
#==============================================================================================
## A lossless JPEG stream being decoded line by line.
struct LosslessJpeg:
var width: usize
var height: usize
var components: usize
var precision: u32
var predictor: u32
var restart: usize
var tables: Huffman[4]
var selectors: usize[4]
var reader: Bits
var lines: u16[]
var line: usize
## Parse the markers up to the scan and prepare to decode its lines.
static func open(data: const u8[]) -> LosslessJpeg!:
var jpeg = LosslessJpeg()
errdefer jpeg.close()
var reader = Reader(data = data, little = false)
if try reader.uint(2) != 0xffd8:
error(corrupt, "lossless JPEG lacks its start marker")
var identifiers: u8[4]
var scanned = false
while not scanned:
var code = try reader.byte()
if code != 255:
error(corrupt, "lossless JPEG marker expected")
code = try reader.byte()
while code == 255:
code = try reader.byte()
let length = (usize)(try reader.uint(2))
if length < 2:
error(corrupt, "lossless JPEG segment too short")
var segment = Reader(data = try reader.take(length - 2), little = false)
if code == 0xc3:
jpeg.precision = (u32)(try segment.byte())
jpeg.height = (usize)(try segment.uint(2))
jpeg.width = (usize)(try segment.uint(2))
jpeg.components = (usize)(try segment.byte())
if jpeg.components < 1 or jpeg.components > 4 or jpeg.precision < 2 or jpeg.precision > 16 or jpeg.width == 0 or jpeg.height == 0:
error(corrupt, "invalid lossless JPEG frame")
for c in 0..<jpeg.components:
identifiers[c] = try segment.byte()
if try segment.byte() != 0x11:
error(unsupported, "subsampled lossless JPEG (sRAW) is not supported")
_ = try segment.byte()
elif code == 0xc0 or code == 0xc1 or code == 0xc2 or (code >= 0xc5 and code <= 0xcf and code != 0xc8 and code != 0xcc):
error(unsupported, "only lossless (process 14) JPEG raws are supported")
elif code == 0xc4:
while segment.position < segment.data.length:
let target = (usize)(try segment.byte())
if (target >> 4) != 0 or (target & 15) > 3:
error(corrupt, "invalid lossless JPEG Huffman table")
let counts = try segment.take(16)
var total: usize = 0
for n in counts:
total += (usize)n
let symbols = try segment.take(total)
for symbol in symbols:
if symbol > 16:
error(corrupt, "lossless JPEG difference category above 16")
let table = try Huffman.build(counts, symbols)
jpeg.tables[target].close()
jpeg.tables[target] = table
elif code == 0xdd:
jpeg.restart = (usize)(try segment.uint(2))
elif code == 0xda:
if jpeg.components == 0:
error(corrupt, "lossless JPEG scan before its frame")
let count = (usize)(try segment.byte())
if count != jpeg.components:
error(unsupported, "lossless JPEG with several scans is not supported")
for c in 0..<count:
let identifier = try segment.byte()
if identifier != identifiers[c]:
error(unsupported, "lossless JPEG scan reorders components")
let selector = (usize)(try segment.byte() >> 4)
if selector > 3 or jpeg.tables[selector].bits == 0:
error(corrupt, "lossless JPEG scan names a missing Huffman table")
jpeg.selectors[c] = selector
jpeg.predictor = (u32)(try segment.byte())
_ = try segment.byte()
if (try segment.byte() & 15) != 0 or jpeg.predictor < 1 or jpeg.predictor > 7:
error(unsupported, "lossless JPEG predictor or point transform unsupported")
scanned = true
elif code == 0xd9:
error(corrupt, "lossless JPEG ends before its scan")
let samples = jpeg.width *? jpeg.components else error(limit, "lossless JPEG line overflows")
if jpeg.restart != 0 and jpeg.restart % jpeg.width != 0:
error(unsupported, "lossless JPEG restart intervals must span whole lines")
jpeg.lines = try new u16[samples * 2] in memory.heap
jpeg.reader = Bits(data = data, position = reader.position, stuffed = true)
return jpeg
## Decode the next line: `width` pixels of `components` interleaved samples.
func next() -> const u16[]!:
if self.line >= self.height:
error(corrupt, "lossless JPEG read past its last line")
let samples = self.width * self.components
let current = self.lines[(self.line & 1) * samples..<((self.line & 1) + 1) * samples]
let above = self.lines[((self.line + 1) & 1) * samples..<(((self.line + 1) & 1) + 1) * samples]
var first = self.line == 0
if self.restart != 0 and self.line > 0 and (self.line * self.width) % self.restart == 0:
try self.reader.restart()
first = true
let nc = self.components
let base: i32 = (i32)1 << (self.precision - 1)
let p = self.predictor
# The bit buffer lives in locals for the line and the tables are
# pointers, so the loop touches no field of `self`; `open` checked that
# every symbol is a category of at most 16.
var reader = self.reader
var buffer = reader.buffer
var count = reader.count
var tables: (const u16*)[4] = ---
var widths: u32[4]
for c: usize in 0..<4:
let table = &self.tables[self.selectors[c if c < nc else 0]]
tables[c] = table.table.data
widths[c] = 64 - table.bits
let out = current.data
let prior = above.data
var c: usize = 0
for at in 0..<samples:
if count < 32:
reader.buffer = buffer
reader.count = count
reader.fill()
buffer = reader.buffer
count = reader.count
let entry = tables[c][buffer >> widths[c]]
if entry == 0:
error(corrupt, "invalid Huffman code in raw data")
let length = (u32)(entry >> 8)
let category = (u32)(entry & 255)
var delta: i32 = 0
var used = length
if category == 16:
delta = -32768
elif category > 0:
let value = (i32)((buffer << length) >> (64 - category))
delta = value if value >= ((i32)1 << (category - 1)) else value -% ((i32)1 << category) +% 1
used = length + category
buffer = buffer << used
count -= used
var prediction = base
if at < nc:
if not first:
prediction = (i32)prior[at]
elif first or p == 1:
prediction = (i32)out[at - nc]
else:
let a = (i32)out[at - nc]
let b = (i32)prior[at]
let d = (i32)prior[at - nc]
prediction = b if p == 2 else d if p == 3 else a +% b -% d if p == 4 else a +% ((b -% d) >> 1) if p == 5 else b +% ((a -% d) >> 1) if p == 6 else (a +% b) >> 1
out[at] = (u16)((prediction +% delta) & 65535)
c = 0 if c + 1 == nc else c + 1
reader.buffer = buffer
reader.count = count
if count < reader.padding:
error(corrupt, "raw bit stream is truncated")
self.reader = reader
self.line += 1
return current
func close():
for i: usize in 0..<4:
self.tables[i].close()
if self.lines.length > 0:
free(self.lines) in memory.heap
self = LosslessJpeg()