dymokomi/luce-heic
Source of release 0.5.2
0.5.2 / src / heic / cabac.lucb
#==============================================================================================
#
# heic/cabac - The CABAC arithmetic decoder and its context variables
#
# The engine keeps the 9-bit offset scaled by 2^7 with up to seven prefetched bits below
# it, reading whole bytes. After a terminating bin equal to 1 (end of a substream or a
# pcm_flag) the bits already fetched are exactly the stop bit and its alignment, so the
# next substream starts at `position`. Only I slices exist here, so each context has the
# one initialisation value of initType 0.
#
#==============================================================================================
# Context offsets, one run of contexts per syntax element.
let ctx_sao_merge: usize = 0
let ctx_sao_type: usize = 1
let ctx_split_cu: usize = 2
let ctx_bypass: usize = 5
let ctx_part_mode: usize = 6
let ctx_prev_intra: usize = 7
let ctx_chroma_mode: usize = 8
let ctx_split_tu: usize = 9
let ctx_cbf_luma: usize = 12
let ctx_cbf_chroma: usize = 14
let ctx_transform_skip: usize = 19
let ctx_qp_delta: usize = 21
let ctx_last_x: usize = 23
let ctx_last_y: usize = 41
let ctx_csbf: usize = 59
let ctx_sig: usize = 63
let ctx_gt1: usize = 107
let ctx_gt2: usize = 131
let contexts: usize = 137
## Tables 9-5 to 9-37: initValue of every context for initType 0, in the order above.
let init_values: u8[137] = [
153, 200, 139, 141, 157, 154, 184, 184, 63, 153, 138, 138, 111, 141, 94, 138, 182, 154, 154, 139, 139, 154, 154,
110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 79, 108, 123, 63,
110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 79, 108, 123, 63,
91, 171, 134, 141,
111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140, 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111, 141, 111,
140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107, 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
138, 153, 136, 167, 152, 152,
]
## Table 9-46: rangeTabLps[pStateIdx][(ivlCurrRange >> 6) & 3].
let range_lps: u8[256] = [
128, 176, 208, 240, 128, 167, 197, 227, 128, 158, 187, 216, 123, 150, 178, 205, 116, 142, 169, 195, 111, 135, 160, 185,
105, 128, 152, 175, 100, 122, 144, 166, 95, 116, 137, 158, 90, 110, 130, 150, 85, 104, 123, 142, 81, 99, 117, 135,
77, 94, 111, 128, 73, 89, 105, 122, 69, 85, 100, 116, 66, 80, 95, 110, 62, 76, 90, 104, 59, 72, 86, 99,
56, 69, 81, 94, 53, 65, 77, 89, 51, 62, 73, 85, 48, 59, 69, 80, 46, 56, 66, 76, 43, 53, 63, 72,
41, 50, 59, 69, 39, 48, 56, 65, 37, 45, 54, 62, 35, 43, 51, 59, 33, 41, 48, 56, 32, 39, 46, 53,
30, 37, 43, 50, 29, 35, 41, 48, 27, 33, 39, 45, 26, 31, 37, 43, 24, 30, 35, 41, 23, 28, 33, 39,
22, 27, 32, 37, 21, 26, 30, 35, 20, 24, 29, 33, 19, 23, 27, 31, 18, 22, 26, 30, 17, 21, 25, 28,
16, 20, 23, 27, 15, 19, 22, 25, 14, 18, 21, 24, 14, 17, 20, 23, 13, 16, 19, 22, 12, 15, 18, 21,
12, 14, 17, 20, 11, 14, 16, 19, 11, 13, 15, 18, 10, 12, 15, 17, 10, 12, 14, 16, 9, 11, 13, 15,
9, 11, 12, 14, 8, 10, 12, 14, 8, 9, 11, 13, 7, 9, 11, 12, 7, 9, 10, 12, 7, 8, 10, 11,
6, 8, 9, 11, 6, 7, 9, 10, 6, 7, 8, 9, 2, 2, 2, 2,
]
## Table 9-47: transIdxLps.
let next_lps: u8[64] = [0, 0, 1, 2, 2, 4, 4, 5, 6, 7, 8, 9, 9, 11, 11, 12, 13, 13, 15, 15, 16, 16, 18, 18, 19, 19, 21, 21, 22, 22, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 30, 30, 31, 32, 32, 33, 33, 33, 34, 34, 35, 35, 35, 36, 36, 36, 37, 37, 37, 38, 38, 63]
## The renormalisation shift after an LPS, by rangeTabLps >> 3.
let renorm: u8[32] = [6, 5, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
## The arithmetic decoder over one slice segment's data. Each context state is
## pStateIdx << 1 | valMps.
struct Cabac:
var data: const u8[]
var position: usize
var value: u32
var range: u32
var needed: i32
var states: u8[137]
## Initialises the engine (9.3.2.5) at byte `position`; contexts are untouched.
func start(position: usize):
self.position = position
self.range = 510
self.needed = -8
self.value = (u32)self.fetch() << 8
self.value |= (u32)self.fetch()
## The next byte, or zero past the end of the data.
func fetch() -> u8:
if self.position >= self.data.length:
self.position += 1
return 0
let value = self.data[self.position]
self.position += 1
return value
## Initialises every context for slice QP `qp` (9.3.2.2).
func reset(qp: i32):
let q = 0 if qp < 0 else 51 if qp > 51 else qp
for i in 0..<contexts:
let init = (i32)init_values[i]
let m = (init >> 4) * 5 - 45
let n = ((init & 15) << 3) - 16
var state = ((m * q) >> 4) + n
state = 1 if state < 1 else 126 if state > 126 else state
self.states[i] = (u8)(((state - 64) << 1) | 1) if state > 63 else (u8)((63 - state) << 1)
## A context-coded bin (9.3.4.3.2).
func decode(context: usize) -> u32:
let s = (u32)self.states[context]
let state = s >> 1
let mps = s & 1
let lps = (u32)range_lps[(usize)((state << 2) | ((self.range >> 6) & 3))]
self.range -= lps
let scaled = self.range << 7
if self.value < scaled:
self.states[context] = (u8)(((state + 1 if state < 62 else 62) << 1) | mps)
if scaled < 32768:
self.range = scaled >> 6
self.value <<= 1
self.needed += 1
if self.needed == 0:
self.needed = -8
self.value |= (u32)self.fetch()
return mps
self.value -= scaled
let shift = (u32)renorm[(usize)(lps >> 3)]
self.value <<= shift
self.range = lps << shift
let flipped = 1 - mps if state == 0 else mps
self.states[context] = (u8)(((u32)next_lps[(usize)state] << 1) | flipped)
self.needed += (i32)shift
if self.needed >= 0:
self.value |= (u32)self.fetch() << (u32)self.needed
self.needed -= 8
return 1 - mps
## A bypass bin (9.3.4.3.4).
func bypass() -> u32:
self.value <<= 1
self.needed += 1
if self.needed >= 0:
self.needed = -8
self.value |= (u32)self.fetch()
let scaled = self.range << 7
if self.value >= scaled:
self.value -= scaled
return 1
return 0
## `count` bypass bins, first bin most significant.
func bypass_bits(count: u32) -> u32:
var value: u32 = 0
var left = count
while left > 0:
value = (value << 1) | self.bypass()
left -= 1
return value
## A terminating bin (9.3.4.3.5).
func terminate() -> u32:
self.range -= 2
let scaled = self.range << 7
if self.value >= scaled:
return 1
if scaled < 32768:
self.range = scaled >> 6
self.value <<= 1
self.needed += 1
if self.needed == 0:
self.needed = -8
self.value |= (u32)self.fetch()
return 0