dymokomi/luce-jpeg
Source of release 0.10.0
0.10.0 / src / jpeg / headers.lucb
#==============================================================================================
#
# jpeg/headers - The decoder state, markers, frame, tables and scan headers
#
#==============================================================================================
let zigzag: usize[64] = [0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63]
## One color component: its coding, its coefficients and, once rendering starts,
## the plane its IDCT writes and how that plane maps onto output pixels.
struct Component:
var id: u8
var horizontal: usize
var vertical: usize
var quant: usize
var dc: usize
var ac: usize
## Blocks across and down, padded to whole MCUs, and those covering the picture.
var bx: usize
var by: usize
var actual_bx: usize
var actual_by: usize
## Quantized coefficients, 64 a block in natural order, an allocation an MCU
## row (`vertical` block rows) so a render lets each go once it is made. A
## streamed scan keeps a ring of `ring` MCU rows instead (0: every row).
var bands: CoefficientRow[]
var ring: usize
## log2 of `vertical` when it is 1, 2 or 4 (8 otherwise): a shift finds a
## block row's MCU row in the scans' inner loops.
var band_shift: u32
## Progressive frames: each block's nonzero AC coefficients by zigzag index.
var nonzero: u64[]
## The successive-approximation bit each coefficient was last coded to, -1 before any.
var progression: i32[64]
## The IDCT's output block size: 8 at full size, fewer when DCT-scaled.
var out_w: usize
var out_h: usize
## IDCT output: bx * out_w samples across (the stride), by * out_h down; a
## streamed scan's is a ring of `plane_ring` rows (0: every row).
var plane: u8[]
var plane_ring: usize
var stride: usize
var rows: usize
## Plane samples that cover the picture, the limit of upsampling's edge clamp.
var valid_w: usize
var valid_h: usize
## Upsampled by repeating samples rather than interpolating (scaled decodes).
var replicate: bool
## Plane samples per output pixel, num/den, in each direction.
var num_x: usize
var den_x: usize
var num_y: usize
var den_y: usize
## One MCU row's coefficients of a component.
struct CoefficientRow:
var blocks: i16[]
## `count` MCU rows of zeroed coefficients for `c`.
func allocate_bands(c: Component*, count: usize) -> !:
c.band_shift = 0 if c.vertical == 1 else 1 if c.vertical == 2 else 2 if c.vertical == 4 else 8
c.bands = try new CoefficientRow[count] in memory.heap
for band in 0..<count:
c.bands[band].blocks = try new i16[c.vertical * c.bx * 64] in memory.heap
## Let go of MCU row `band`'s coefficients, made into planes.
func release_band(c: Component*, band: usize):
if c.bands[band].blocks.length > 0:
free(c.bands[band].blocks) in memory.heap
var empty: i16[]
c.bands[band].blocks = empty
## Let go of every coefficient `c` holds.
func release_bands(c: Component*):
if c.bands.length == 0:
return
for band in 0..<c.bands.length:
release_band(c, band)
free(c.bands) in memory.heap
var empty: CoefficientRow[]
c.bands = empty
## Block (`column`, `row`) of `c`'s coefficients: in its MCU row's allocation,
## or a streamed scan's ring slot.
inline func block_at(c: const Component*, row: usize, column: usize) -> i16*:
let band = row >> c.band_shift if c.band_shift < 8 else row // c.vertical
let slot = band if c.ring == 0 else band % c.ring
return c.bands[slot].blocks.data + ((row - band * c.vertical) * c.bx + column) * 64
struct Decoder:
var data: const u8[]
var max_bytes: usize
var width: usize
var height: usize
var components: Component[4]
var count: usize
## DC tables 0..3 then AC tables 4..7, on the heap (100 KB) to spare the stack.
var tables: Huffman[]
var quant: u32[256]
var quant_present: bool[4]
var max_h: usize
var max_v: usize
var mcux: usize
var mcuy: usize
var restart: usize
var progressive: bool
var adobe: i32 = -1
## Threads asked for (0: every processor), and those used once the size is known.
var requested: usize
var threads: usize = 1
## Where and at what scale the picture renders; `rendered` once it has, during
## its scan.
var target: Target*?
var scale: usize = 1
var rendered: bool
## A probed Raster the frame must match.
var expected: const Raster*?
## The file read in pieces (jpeg/source): `data` is what the window holds.
var window: Window*?
## A progressive picture's 1/8-size first sight goes here, once.
var coarse: CoarseSink?
var coarse_context: void*?
var coarse_done: bool
func close():
if self.tables.length > 0:
free(self.tables) in memory.heap
for i in 0..<self.count:
release_bands(&self.components[i])
if self.components[i].plane.length > 0:
free(self.components[i].plane) in memory.heap
if self.components[i].nonzero.length > 0:
free(self.components[i].nonzero) in memory.heap
## Read every marker segment through the end of image, entropy-decoding each scan
## into the components' coefficients, then render them into `target`.
func decode() -> !:
try self.read()
if not self.rendered:
try render(&self)
## Read every marker segment through the end of image, entropy-decoding each scan
## into the components' coefficients (and rendering a pipelined scan's rows).
func read() -> !:
self.tables = try new Huffman[8] in memory.heap
var reader = Reader(data = self.data, little = false)
if try reader.uint(2) != 65496:
error(corrupt, "invalid JPEG signature")
var ended = false
while true:
try ensure_segment(&self, &reader)
if reader.position >= reader.data.length:
break
let code = try marker(&reader)
if code == 217:
ended = true
break
var s = try segment(&reader)
if code == 192 or code == 193 or code == 194:
try self.frame(&s, code)
elif code == 219:
try self.quantization(&s)
elif code == 196:
try self.huffman(&s)
elif code == 221:
self.restart = (usize)(try s.uint(2))
elif code == 218:
if self.count == 0:
error(corrupt, "JPEG scan before frame")
let header = try scan_header(&self, &s)
if self.progressive:
try progressive_scan(&self, &header, &reader)
if self.coarse != none and not self.coarse_done and dc_ready(&self):
try render_coarse(&self)
elif streams(&self, &header):
try streamed_scan(&self, &header, &reader)
elif pipelines(&self, &header):
try pipelined_scan(&self, &header, &reader)
else:
try self.whole_coefficients()
try sequential_scan(&self, &header, &reader)
elif code == 238 and s.data.length >= 12 and (str)s.data[..<5] == "Adobe":
self.adobe = (i32)s.data[11]
elif (code >= 195 and code <= 207) or code == 220:
error(unsupported, "unsupported JPEG coding process")
if not ended:
error(corrupt, "JPEG end marker missing")
for i in 0..<self.count:
let c = &self.components[i]
if not self.quant_present[c.quant] or c.progression[0] == -1:
error(corrupt, "JPEG component lacks quantization or DC scan")
func frame(h: Reader*, code: u8) -> !:
if self.count != 0:
error(corrupt, "multiple JPEG frame headers")
if try h.byte() != 8:
error(unsupported, "JPEG requires 8-bit precision")
self.height = (usize)(try h.uint(2))
self.width = (usize)(try h.uint(2))
let count = (usize)(try h.byte())
if count != 1 and count != 3 and count != 4:
error(unsupported, "JPEG requires grayscale, RGB/YCbCr or CMYK/YCCK")
if self.width == 0 or self.height == 0 or self.width > 1000000 or self.height > 1000000:
error(unsupported, "JPEG dimensions must be 1 through 1000000")
if let probed = self.expected:
if probed.width != self.width or probed.height != self.height:
error(corrupt, "JPEG frame dimensions changed")
if probed.photo != (u64)count:
error(corrupt, "JPEG frame component count mismatch")
self.count = count
self.progressive = code == 194
self.threads = thread_count(self.requested, self.width * self.height)
var blocks: usize = 0
for i in 0..<self.count:
let c = &self.components[i]
c.id = try h.byte()
let sampling = try h.byte()
c.horizontal = (usize)(sampling >> 4)
c.vertical = (usize)(sampling & 15)
c.quant = (usize)(try h.byte())
if c.horizontal == 0 or c.horizontal > 4 or c.vertical == 0 or c.vertical > 4 or c.quant > 3:
error(corrupt, "invalid JPEG sampling factors")
for j in 0..<i:
if self.components[j].id == c.id:
error(corrupt, "duplicate JPEG component ID")
self.max_h = c.horizontal if c.horizontal > self.max_h else self.max_h
self.max_v = c.vertical if c.vertical > self.max_v else self.max_v
blocks += c.horizontal * c.vertical
if blocks > 10:
error(corrupt, "JPEG MCU has too many blocks")
self.mcux = (self.width + self.max_h * 8 - 1) // (self.max_h * 8)
self.mcuy = (self.height + self.max_v * 8 - 1) // (self.max_v * 8)
var allocated: usize = 0
for i in 0..<self.count:
let c = &self.components[i]
c.bx = self.mcux * c.horizontal
c.by = self.mcuy * c.vertical
c.actual_bx = (self.width * c.horizontal + self.max_h * 8 - 1) // (self.max_h * 8)
c.actual_by = (self.height * c.vertical + self.max_v * 8 - 1) // (self.max_v * 8)
# Two bytes a coefficient, up to one plane sample for each, and for a
# progressive frame a nonzero bitmap of eight bytes a block.
let coefficients = c.bx * c.by * 64
allocated += coefficients * 3 + (coefficients // 8 if self.progressive else 0)
if allocated > self.max_bytes:
error(limit, "JPEG coefficient and sample buffers exceed byte limit")
# A baseline picture going to a row sink may stream (render/streamed_scan):
# its coefficients wait for the scan to say whether it does.
c.ring = 0
if self.progressive or not self.to_sink():
try allocate_bands(c, self.mcuy)
if self.progressive:
c.nonzero = try new u64[c.bx * c.by] in memory.heap
for k in 0..<64:
c.progression[k] = -1
## Whether rows go to a sink rather than into a buffer.
func to_sink() -> bool:
let target = self.target else return false
return target.sink != none
## Coefficients for every block, where a streamed scan left them unmade.
func whole_coefficients() -> !:
for i in 0..<self.count:
let c = &self.components[i]
if c.bands.length == 0:
try allocate_bands(c, self.mcuy)
func quantization(s: Reader*) -> !:
while s.position < s.data.length:
let selector = try s.byte()
let index = (usize)(selector & 15)
let precision = selector >> 4
if index > 3 or precision > 1:
error(corrupt, "invalid JPEG quantization table")
for i in 0..<(usize)64:
let value = try s.uint(2 if precision == 1 else 1)
if value == 0:
error(corrupt, "zero JPEG quantization value")
self.quant[index * 64 + zigzag[i]] = (u32)value
self.quant_present[index] = true
func huffman(s: Reader*) -> !:
while s.position < s.data.length:
let selector = try s.byte()
if (selector >> 4) > 1 or (selector & 15) > 3:
error(corrupt, "invalid JPEG Huffman table selector")
var counts: u32[17]
var count: usize = 0
var left: i32 = 1
for n in 1..<(usize)17:
counts[n] = (u32)(try s.byte())
count += (usize)counts[n]
left = left * 2 - (i32)counts[n]
if left < 0:
error(corrupt, "oversubscribed JPEG Huffman table")
if count > 256 or count == 0:
error(corrupt, "invalid JPEG Huffman symbol count")
let values = try s.take(count)
build_huffman(&self.tables[(usize)(selector & 15) + (4 if (selector >> 4) == 1 else 0)], counts, values)
## The parameters of one scan, from its SOS segment.
struct Scan:
var count: usize
var selected: usize[4]
var ss: usize
var se: usize
var ah: u32
var al: u32
## MCUs across and down: the component's blocks for a one-component scan.
var across: usize
var down: usize
func scan_header(d: Decoder*, header: Reader*) -> Scan!:
var scan = Scan()
let ns = (usize)(try header.byte())
if ns < 1 or ns > d.count:
error(corrupt, "invalid JPEG scan component count")
scan.count = ns
for i in 0..<ns:
let id = try header.byte()
let tables = try header.byte()
if (tables >> 4) > 3 or (tables & 15) > 3:
error(corrupt, "invalid JPEG table selector")
var found = false
for c in 0..<d.count:
if d.components[c].id == id:
scan.selected[i] = c
found = true
if not found:
error(corrupt, "JPEG scan references unknown component")
for j in 0..<i:
if scan.selected[j] == scan.selected[i]:
error(corrupt, "duplicate JPEG scan component")
d.components[scan.selected[i]].dc = (usize)(tables >> 4)
d.components[scan.selected[i]].ac = (usize)(tables & 15)
scan.ss = (usize)(try header.byte())
scan.se = (usize)(try header.byte())
let approx = try header.byte()
scan.ah = (u32)(approx >> 4)
scan.al = (u32)(approx & 15)
let ss = scan.ss
let se = scan.se
let ah = scan.ah
let al = scan.al
if ss > se or se > 63 or al > 13 or ah > 13 or (not d.progressive and (ss != 0 or se != 63 or ah != 0 or al != 0)) or (d.progressive and ((ss == 0 and se != 0) or (ss > 0 and ns != 1))) or (ah != 0 and ah != al + 1):
error(corrupt, "invalid JPEG scan parameters")
for i in 0..<ns:
let component = &d.components[scan.selected[i]]
for k in ss..<se + 1:
if (ah == 0 and component.progression[k] != -1) or (ah != 0 and component.progression[k] != (i32)ah):
error(corrupt, "invalid JPEG progressive scan order")
component.progression[k] = (i32)al
scan.across = d.components[scan.selected[0]].actual_bx if ns == 1 else d.mcux
scan.down = d.components[scan.selected[0]].actual_by if ns == 1 else d.mcuy
return scan
func marker(reader: Reader*) -> u8!:
if try reader.byte() != 255:
error(corrupt, "JPEG marker prefix missing")
var value = try reader.byte()
while value == 255:
value = try reader.byte()
if value == 0:
error(corrupt, "JPEG stuffed byte outside scan")
return value
func segment(reader: Reader*) -> Reader!:
let size = (usize)(try reader.uint(2))
if size < 2:
error(corrupt, "JPEG marker length below two")
return Reader(data = try reader.take(size - 2), little = false)