Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-heic

Source of release 0.5.1

0.5.1 / src / heic / params.lucb

#==============================================================================================
#
#   heic/params - Sequence and picture parameter sets, and scaling lists
#
#   Only what an intra decoder needs is kept; the rest is parsed to stay in step. Range,
#   multilayer, 3D and screen-content extensions that change decoding are refused.
#
#==============================================================================================

## Table 7-6: the default 8x8 intra and inter scaling lists in up-right diagonal order.
let default_intra: u8[64] = [16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 16, 17, 16, 17, 18, 17, 18, 18, 17, 18, 21, 19, 20, 21, 20, 19, 21, 24, 22, 22, 24, 24, 22, 22, 24, 25, 25, 27, 30, 27, 25, 25, 29, 31, 35, 35, 31, 29, 36, 41, 44, 41, 36, 47, 54, 54, 47, 65, 70, 65, 88, 88, 115]
let default_inter: u8[64] = [16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 20, 20, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 28, 28, 28, 28, 28, 28, 33, 33, 33, 33, 33, 41, 41, 41, 41, 54, 54, 54, 71, 71, 91]

## Up-right diagonal scans: position `i` as x | y << 2 in a 4x4 block, x | y << 3 in 8x8.
let diag4: u8[16] = [0, 4, 1, 8, 5, 2, 12, 9, 6, 3, 13, 10, 7, 14, 11, 15]
let diag8: u8[64] = [0, 8, 1, 16, 9, 2, 24, 17, 10, 3, 32, 25, 18, 11, 4, 40, 33, 26, 19, 12, 5, 48, 41, 34, 27, 20, 13, 6, 56, 49, 42, 35, 28, 21, 14, 7, 57, 50, 43, 36, 29, 22, 15, 58, 51, 44, 37, 30, 23, 59, 52, 45, 38, 31, 60, 53, 46, 39, 61, 54, 47, 62, 55, 63]

## Scaling factors for every size (4x4 to 32x32) and matrix (intra Y, Cb, Cr, inter Y, Cb,
## Cr), each an 8x8 raster (4x4 uses its first 16 entries as a 4x4 raster) that larger
## blocks upsample, plus the DC factors of 16x16 and 32x32.
struct Scaling:
    var factors: u8[1536]
    var dc: u8[12]

    ## The factor for coefficient (x, y) of a 2^log2 block of `matrix`.
    func factor(log2: u32, matrix: u32, x: usize, y: usize) -> i32:
        let size = (usize)log2 - 2
        let base = (size * 6 + (usize)matrix) * 64
        if size == 0:
            return (i32)self.factors[base + y * 4 + x]
        if size >= 2 and x == 0 and y == 0:
            return (i32)self.dc[(size - 2) * 6 + (usize)matrix]
        let shift = size - 1
        return (i32)self.factors[base + (y >> shift) * 8 + (x >> shift)]

    ## Sets matrix `matrix` of size `size` to its default.
    func reset(size: usize, matrix: usize):
        let base = (size * 6 + matrix) * 64
        for i in 0..<(usize)64:
            if size == 0:
                self.factors[base + i] = 16
            else:
                self.factors[base + (usize)diag8[i]] = default_intra[i] if matrix < 3 else default_inter[i]
        if size >= 2:
            self.dc[(size - 2) * 6 + matrix] = 16

    func defaults():
        for size in 0..<(usize)4:
            for matrix in 0..<(usize)6:
                self.reset(size, matrix)

## scaling_list_data(): each list is predicted from a default or earlier list, or coded as
## differences in diagonal order.
func parse_scaling(bits: Bits*, s: Scaling*) -> !:
    s.defaults()
    for size in 0..<(usize)4:
        let step: usize = 3 if size == 3 else 1
        var matrix: usize = 0
        while matrix < 6:
            let base = (size * 6 + matrix) * 64
            if not try bits.flag():
                let delta = (usize)(try bits.ue_max(5)) * step
                if delta > matrix:
                    error(corrupt, "HEVC scaling list refers to a missing list")
                if delta == 0:
                    s.reset(size, matrix)
                else:
                    let source = (size * 6 + matrix - delta) * 64
                    for i in 0..<(usize)64:
                        s.factors[base + i] = s.factors[source + i]
                    if size >= 2:
                        s.dc[(size - 2) * 6 + matrix] = s.dc[(size - 2) * 6 + matrix - delta]
            else:
                var next: i32 = 8
                if size >= 2:
                    next = try bits.se_range(-7, 247) + 8
                    s.dc[(size - 2) * 6 + matrix] = (u8)next
                let count: usize = 16 if size == 0 else 64
                for i in 0..<count:
                    next = (next + (try bits.se_range(-128, 127)) + 256) % 256
                    if next == 0:
                        error(corrupt, "HEVC scaling list value is zero")
                    s.factors[base + ((usize)diag4[i] if size == 0 else (usize)diag8[i])] = (u8)next
            matrix += step

## profile_tier_level(1, max_sub_layers_minus1); returns general_profile_idc.
func parse_ptl(bits: Bits*, sub_layers: u32) -> u32!:
    _ = try bits.bits(3)
    let profile = try bits.bits(5)
    try bits.skip(32 + 48 + 8)
    var present: u32[8]
    for i in 0..<(usize)sub_layers:
        present[i] = try bits.bits(2)
    if sub_layers > 0:
        try bits.skip((usize)(8 - sub_layers) * 2)
    for i in 0..<(usize)sub_layers:
        if (present[i] & 2) != 0:
            try bits.skip(88)
        if (present[i] & 1) != 0:
            try bits.skip(8)
    return profile

## The parts of an SPS the decoder uses.
struct Sps:
    var present: bool
    var chroma: u32
    var width: usize
    var height: usize
    var crop_left: usize
    var crop_right: usize
    var crop_top: usize
    var crop_bottom: usize
    var bits: u32
    var bits_c: u32
    var log2_poc: u32
    var log2_min_cb: u32
    var log2_ctb: u32
    var log2_min_tb: u32
    var log2_max_tb: u32
    var depth_intra: u32
    var scaling_enabled: bool
    var scaling: Scaling
    var sao: bool
    var pcm: bool
    var pcm_bits: u32
    var pcm_bits_c: u32
    var log2_min_pcm: u32
    var log2_max_pcm: u32
    var pcm_loop_filter_disabled: bool
    var rps_count: u32
    ## NumDeltaPocs of each short-term reference picture set, for slice headers.
    var rps_deltas: u8[65]
    var long_term: bool
    var long_term_count: u32
    var temporal_mvp: bool
    var strong_smoothing: bool
    ## VUI video signal type: -1 when absent.
    var full_range: i32
    var matrix: i32

## st_ref_pic_set(index): records NumDeltaPocs; `deltas` holds each set's DeltaPoc values
## (16 negative then 16 positive) for inter-set prediction.
func parse_rps(bits: Bits*, sps: Sps*, index: u32, deltas: i32[]) -> !:
    var predicted = false
    if index != 0:
        predicted = try bits.flag()
    var values: i32[32]
    var count: usize = 0
    if predicted:
        var delta_index: u32 = 1
        if index == sps.rps_count:
            delta_index = try bits.ue_max(index - 1) + 1
        let sign = try bits.flag()
        let magnitude = (i32)(try bits.ue_max(32767)) + 1
        let delta_rps = -magnitude if sign else magnitude
        let reference = (usize)(index - delta_index)
        let reference_count = (usize)sps.rps_deltas[reference]
        for j in 0..=reference_count:
            let used = try bits.flag()
            let use_delta = used or try bits.flag()
            let delta = delta_rps + (deltas[reference * 32 + j] if j < reference_count else 0)
            if use_delta and delta != 0:
                if count >= 32:
                    error(corrupt, "HEVC reference picture set is too large")
                values[count] = delta
                count += 1
    else:
        let negative = try bits.ue_max(16)
        let positive = try bits.ue_max(16)
        var poc: i32 = 0
        for i in 0..<(usize)negative:
            poc -= (i32)(try bits.ue_max(32767)) + 1
            _ = try bits.flag()
            values[count] = poc
            count += 1
        poc = 0
        for i in 0..<(usize)positive:
            poc += (i32)(try bits.ue_max(32767)) + 1
            _ = try bits.flag()
            values[count] = poc
            count += 1
    if count > 16:
        error(corrupt, "HEVC reference picture set is too large")
    # Order as DeltaPocS0 (nearest first) then DeltaPocS1 (nearest first).
    for i in 1..<count:
        var j = i
        while j > 0 and rps_before(values[j], values[j - 1]):
            let swap = values[j]
            values[j] = values[j - 1]
            values[j - 1] = swap
            j -= 1
    if index < 65:
        sps.rps_deltas[index] = (u8)count
        if index < 64:
            for j in 0..<count:
                deltas[(usize)index * 32 + j] = values[j]

## Whether DeltaPoc `a` comes before `b`: negatives first, each side nearest first.
func rps_before(a: i32, b: i32) -> bool:
    if (a < 0) != (b < 0):
        return a < 0
    return a > b if a < 0 else a < b

## seq_parameter_set_rbsp(): stores the SPS by its ID in `table`.
func parse_sps(bits: Bits*, table: Sps[]) -> !:
    _ = try bits.bits(4)
    let sub_layers = try bits.bits(3)
    if sub_layers > 6:
        error(corrupt, "invalid HEVC sub-layer count")
    _ = try bits.flag()
    let profile = try parse_ptl(bits, sub_layers)
    let id = (usize)(try bits.ue_max(15))
    let sps = &table[id]
    *sps = Sps(full_range = -1, matrix = -1)
    sps.chroma = try bits.ue_max(3)
    if sps.chroma > 1:
        error(unsupported, "HEVC 4:2:2 and 4:4:4 chroma are not supported")
    if profile > 4 and profile != 0:
        error(unsupported, "unsupported HEVC profile")
    sps.width = (usize)(try bits.ue())
    sps.height = (usize)(try bits.ue())
    if try bits.flag():
        let crop_unit: usize = 2 if sps.chroma == 1 else 1
        sps.crop_left = (usize)(try bits.ue()) * crop_unit
        sps.crop_right = (usize)(try bits.ue()) * crop_unit
        sps.crop_top = (usize)(try bits.ue()) * crop_unit
        sps.crop_bottom = (usize)(try bits.ue()) * crop_unit
    sps.bits = try bits.ue_max(4) + 8
    sps.bits_c = try bits.ue_max(4) + 8
    sps.log2_poc = try bits.ue_max(12) + 4
    let ordering = try bits.flag()
    for i in (0 if ordering else sub_layers)..=sub_layers:
        _ = try bits.ue()
        _ = try bits.ue()
        _ = try bits.ue()
    sps.log2_min_cb = try bits.ue_max(3) + 3
    sps.log2_ctb = sps.log2_min_cb + try bits.ue_max(3)
    sps.log2_min_tb = try bits.ue_max(3) + 2
    sps.log2_max_tb = sps.log2_min_tb + try bits.ue_max(3)
    if sps.log2_ctb < 4 or sps.log2_ctb > 6 or sps.log2_max_tb > 5 or sps.log2_max_tb > sps.log2_ctb or sps.log2_min_tb >= sps.log2_min_cb:
        error(corrupt, "invalid HEVC block sizes")
    if sps.width == 0 or sps.height == 0 or sps.width > 16384 or sps.height > 16384 or sps.width % ((usize)1 << sps.log2_min_cb) != 0 or sps.height % ((usize)1 << sps.log2_min_cb) != 0:
        error(corrupt, "invalid HEVC picture size")
    if sps.crop_left + sps.crop_right >= sps.width or sps.crop_top + sps.crop_bottom >= sps.height:
        error(corrupt, "invalid HEVC conformance window")
    _ = try bits.ue_max(5)
    sps.depth_intra = try bits.ue_max(5)
    sps.scaling_enabled = try bits.flag()
    sps.scaling.defaults()
    if sps.scaling_enabled and try bits.flag():
        try parse_scaling(bits, &sps.scaling)
    _ = try bits.flag()
    sps.sao = try bits.flag()
    sps.pcm = try bits.flag()
    if sps.pcm:
        sps.pcm_bits = try bits.bits(4) + 1
        sps.pcm_bits_c = try bits.bits(4) + 1
        sps.log2_min_pcm = try bits.ue_max(2) + 3
        sps.log2_max_pcm = sps.log2_min_pcm + try bits.ue_max(2)
        sps.pcm_loop_filter_disabled = try bits.flag()
        if sps.pcm_bits > sps.bits or sps.pcm_bits_c > sps.bits_c or sps.log2_max_pcm > 5:
            error(corrupt, "invalid HEVC PCM parameters")
    sps.rps_count = try bits.ue_max(64)
    var deltas: i32[2048]
    for i in 0..<sps.rps_count:
        try parse_rps(bits, sps, i, deltas)
    sps.long_term = try bits.flag()
    if sps.long_term:
        sps.long_term_count = try bits.ue_max(32)
        for i in 0..<sps.long_term_count:
            _ = try bits.bits(sps.log2_poc)
            _ = try bits.flag()
    sps.temporal_mvp = try bits.flag()
    sps.strong_smoothing = try bits.flag()
    if try bits.flag():
        try parse_vui(bits, sps, sub_layers)
    if try bits.flag():
        let range = try bits.flag()
        if try bits.bits(7) != 0:
            error(unsupported, "HEVC multilayer, 3D and screen content extensions are not supported")
        if range and try bits.bits(9) != 0:
            error(unsupported, "HEVC range extension tools are not supported")
    sps.present = true