///|
pub(all) struct LfGlobal {
patches : Patches?
splines : Splines?
noise : NoiseParameters?
lf_dequant : @vardct.LfChannelDequantization
vardct : LfGlobalVarDct?
gmodular : GlobalModular
}
///|
pub(all) struct LfGlobalParams {
image_header : @image.ImageHeader
frame_header : FrameHeader
tracker : @grid.AllocTracker?
allow_partial : Bool
}
///|
pub fn LfGlobalParams::new(
image_header : @image.ImageHeader,
frame_header : FrameHeader,
tracker : @grid.AllocTracker?,
allow_partial : Bool,
) -> LfGlobalParams {
{ image_header, frame_header, tracker, allow_partial, }
}
///|
pub fn LfGlobal::parse(
bs : @bitstream.Bitstream,
params : LfGlobalParams,
) -> LfGlobal raise @bitstream.JxlError {
let { image_header, frame_header: header, .. } = params
// `(header.width * header.height) as u64` (u32 multiplication)
let image_size = (header.width.reinterpret_as_uint() *
header.height.reinterpret_as_uint()).to_uint64()
let patches = if header.flags.patches() {
let patches = Patches::parse(bs, image_header, header)
for patch in patches.patches {
for target in patch.patch_targets {
for blending_info in target.blending {
if blending_info.mode.use_alpha() &&
blending_info.alpha_channel >=
image_header.metadata.ec_info.length() {
raise ValidationFailed("blending_info.alpha_channel out of range")
}
}
}
}
Some(patches)
} else {
None
}
let splines = if header.flags.splines() {
Some(Splines::parse(bs, header))
} else {
None
}
let noise = if header.flags.noise() {
Some(NoiseParameters::parse(bs))
} else {
None
}
let lf_dequant = @vardct.LfChannelDequantization::parse(bs)
let modular_dequants : FixedArray[Float] = [
lf_dequant.m_x_lf_unscaled(),
lf_dequant.m_y_lf_unscaled(),
lf_dequant.m_b_lf_unscaled(),
]
let min_weight : Float = 1.0e-8
if modular_dequants.iter().any(v => v < min_weight) {
raise ValidationFailed("Modular dequant weight is too small")
}
let vardct = if header.encoding == VarDct {
Some(LfGlobalVarDct::parse(bs))
} else {
None
}
if splines is Some(splines) {
let base_correlation_xb = match vardct {
Some(vardct) => {
let lf_chan_corr = vardct.lf_chan_corr
Some((lf_chan_corr.base_correlation_x, lf_chan_corr.base_correlation_b))
}
None => None
}
let estimated_area = splines.estimate_area(base_correlation_xb)
// Maximum total_estimated_area_reached for Level 10
let a = 1UL << 42
let b = 1024UL * image_size + (1UL << 32)
let max_estimated_area = if a < b { a } else { b }
if estimated_area > max_estimated_area {
raise ProfileConformance("too large estimated area for splines")
}
// Upstream warns (Level 5 limit) here; logging is dropped.
}
let gmodular = GlobalModular::parse(bs, params)
{ patches, splines, noise, lf_dequant, vardct, gmodular, }
}
///|
pub(all) struct LfGlobalVarDct {
quantizer : @vardct.Quantizer
hf_block_ctx : @vardct.HfBlockContext
lf_chan_corr : @vardct.LfChannelCorrelation
}
///|
pub fn LfGlobalVarDct::parse(
bs : @bitstream.Bitstream,
) -> LfGlobalVarDct raise @bitstream.JxlError {
let quantizer = @vardct.Quantizer::parse(bs)
let hf_block_ctx = @vardct.HfBlockContext::parse(bs)
let lf_chan_corr = @vardct.LfChannelCorrelation::parse(bs)
{ quantizer, hf_block_ctx, lf_chan_corr, }
}
///|
pub struct GlobalModular {
ma_config : @modular.MaConfig?
modular : @modular.Modular
priv extra_channel_from : Int32
priv is_partial : Bool
}
///|
pub fn GlobalModular::try_clone(self : GlobalModular) -> GlobalModular {
{
ma_config: self.ma_config,
modular: self.modular.try_clone(),
extra_channel_from: self.extra_channel_from,
is_partial: self.is_partial,
}
}
///|
pub fn GlobalModular::ma_config(self : GlobalModular) -> @modular.MaConfig? {
self.ma_config
}
///|
pub fn GlobalModular::extra_channel_from(self : GlobalModular) -> Int32 {
self.extra_channel_from
}
///|
pub fn GlobalModular::is_partial(self : GlobalModular) -> Bool {
self.is_partial
}
///|
pub fn GlobalModular::parse(
bs : @bitstream.Bitstream,
params : LfGlobalParams,
) -> GlobalModular raise @bitstream.JxlError {
let { image_header, frame_header: header, tracker, allow_partial, } = params
let num_channels = (header.encoded_color_channels() +
image_header.metadata.ec_info.length()).to_uint64()
let max_global_ma_nodes = 1024UL +
header.width.reinterpret_as_uint().to_uint64() *
header.height.reinterpret_as_uint().to_uint64() *
num_channels /
16UL
let max_global_ma_nodes = if max_global_ma_nodes < 1UL << 22 {
max_global_ma_nodes.to_int()
} else {
1 << 22
}
let ma_config_params : @modular.MaConfigParams = {
tracker,
node_limit: max_global_ma_nodes,
depth_limit: 2048,
}
let ma_config = if bs.read_bool() {
Some(@modular.MaConfig::parse(bs, ma_config_params))
} else {
None
}
let color_width = header.color_sample_width()
let color_height = header.color_sample_height()
let shifts : Array[@modular.ModularChannelParams] = []
if header.encoding == Modular {
if header.do_ycbcr {
// Cb, Y, Cr
for idx in 0..<3 {
shifts.push(
@modular.ModularChannelParams::jpeg(
color_width,
color_height,
header.jpeg_upsampling,
idx,
),
)
}
} else {
let channel_param = @modular.ModularChannelParams::new(
color_width, color_height,
)
let channels = header.encoded_color_channels()
for _ in 0..