///|
pub(all) struct PassGroupParams {
frame_header : FrameHeader
lf_group : LfGroup
pass_idx : Int32
group_idx : Int32
global_ma_config : @modular.MaConfig?
modular : @modular.TransformedModularSubimage?
vardct : PassGroupParamsVardct?
allow_partial : Bool
tracker : @grid.AllocTracker?
}
///|
pub(all) struct PassGroupParamsVardct {
lf_vardct : LfGlobalVarDct
hf_global : HfGlobal
hf_coeff_output : FixedArray[@grid.SubGrid[Int32]]
}
///|
pub fn decode_pass_group(
bs : @bitstream.Bitstream,
params : PassGroupParams,
) -> Unit raise @bitstream.JxlError {
let {
frame_header,
lf_group,
pass_idx,
group_idx,
global_ma_config,
modular,
vardct,
allow_partial,
tracker,
} = params
if vardct is Some({ lf_vardct, hf_global, hf_coeff_output, }) &&
lf_group.hf_meta is Some(hf_meta) {
let hf_pass = hf_global.hf_passes[pass_idx]
let coeff_shift = if pass_idx < frame_header.passes.shift.length() {
frame_header.passes.shift[pass_idx]
} else {
0
}
let group_col = group_idx % frame_header.groups_per_row()
let group_row = group_idx / frame_header.groups_per_row()
let lf_col = group_col % 8
let lf_row = group_row % 8
let group_dim_blocks = frame_header.group_dim() / 8
let block_info = hf_meta.block_info
let block_left = lf_col * group_dim_blocks
let block_top = lf_row * group_dim_blocks
let block_width = @cmp.minimum(
block_info.width() - block_left,
group_dim_blocks,
)
let block_height = @cmp.minimum(
block_info.height() - block_top,
group_dim_blocks,
)
let jpeg_upsampling = frame_header.jpeg_upsampling
let block_info = block_info
.as_subgrid()
.subgrid(block_left, block_top, block_width, block_height)
let lf_quant : FixedArray[@grid.SubGrid[Int32]]? = match lf_group.lf_coeff {
Some(lf_coeff) => {
let lf_quant_channels = lf_coeff.lf_quant
.image()
.unwrap()
.image_channels()
Some(
FixedArray::makei(3, idx => {
let lf_quant = lf_quant_channels[[1, 0, 2][idx]]
let shift = @modular.ChannelShift::from_jpeg_upsampling(
jpeg_upsampling, idx,
)
let block_left = block_left >> shift.hshift()
let block_top = block_top >> shift.vshift()
let (block_width, block_height) = shift.shift_size(
(block_width, block_height),
)
lf_quant
.as_subgrid()
.subgrid(block_left, block_top, block_width, block_height)
}),
)
}
None => None
}
let params : @vardct.HfCoeffParams = {
num_hf_presets: hf_global.num_hf_presets,
hf_block_ctx: lf_vardct.hf_block_ctx,
block_info,
jpeg_upsampling,
lf_quant,
hf_pass,
coeff_shift,
tracker,
}
@vardct.write_hf_coeff(bs, params, hf_coeff_output) catch {
e if e.unexpected_eof() && allow_partial =>
// Partially decoded HfCoeff
return
e => raise e
}
}
if modular is Some(modular) {
decode_pass_group_modular(
bs, frame_header, global_ma_config, pass_idx, group_idx, modular, allow_partial,
tracker,
)
}
}
///|
pub fn decode_pass_group_modular(
bs : @bitstream.Bitstream,
frame_header : FrameHeader,
global_ma_config : @modular.MaConfig?,
pass_idx : Int32,
group_idx : Int32,
modular : @modular.TransformedModularSubimage,
allow_partial : Bool,
tracker : @grid.AllocTracker?,
) -> Unit raise @bitstream.JxlError {
if modular.is_empty() {
return
}
let modular = modular.recursive(bs, global_ma_config, tracker)
let subimage = modular.prepare_subimage()
subimage.decode(
bs,
1 +
3 * frame_header.num_lf_groups() +
17 +
pass_idx * frame_header.num_groups() +
group_idx,
allow_partial,
)
subimage.finish() |> ignore
}