Revision control
Copy as Markdown
Other Tools
// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
use std::{borrow::Cow, f32::consts::SQRT_2, sync::OnceLock};
use crate::util::f16;
use crate::{
BLOCK_DIM, BLOCK_SIZE,
bit_reader::BitReader,
error::{
Error::{
HfQuantFactorTooSmall, InvalidDistanceBand, InvalidQuantEncoding,
InvalidQuantEncodingMode, InvalidQuantizationTableWeight, InvalidRawQuantTable,
},
Result,
},
frame::{
LfGlobalState,
modular::{ModularChannel, ModularStreamId, decode::decode_modular_subbitstream},
},
headers::{bit_depth::BitDepth, frame_header::FrameHeader},
image::Rect,
};
use jxl_transforms::transform_map::*;
pub const INV_LF_QUANT: [f32; 3] = [4096.0, 512.0, 256.0];
pub const LF_QUANT: [f32; 3] = [
1.0 / INV_LF_QUANT[0],
1.0 / INV_LF_QUANT[1],
1.0 / INV_LF_QUANT[2],
];
const ALMOST_ZERO: f32 = 1e-8;
const LOG2_NUM_QUANT_MODES: usize = 3;
#[derive(Debug)]
pub struct DctQuantWeightParams {
params: [[f32; Self::MAX_DISTANCE_BANDS]; 3],
num_bands: usize,
}
impl DctQuantWeightParams {
const LOG2_MAX_DISTANCE_BANDS: usize = 4;
const MAX_DISTANCE_BANDS: usize = 1 + (1 << Self::LOG2_MAX_DISTANCE_BANDS);
#[inline(never)]
pub fn from_array<const N: usize>(values: &[[f32; N]; 3]) -> Self {
let mut result = Self {
params: [[0.0; Self::MAX_DISTANCE_BANDS]; 3],
num_bands: N,
};
for (params, values) in result.params.iter_mut().zip(values) {
params[..values.len()].copy_from_slice(values);
}
result
}
#[inline(never)]
pub fn decode(br: &mut BitReader) -> Result<Self> {
let num_bands = br.read(Self::LOG2_MAX_DISTANCE_BANDS)? as usize + 1;
let mut params = [[0.0; Self::MAX_DISTANCE_BANDS]; 3];
for row in params.iter_mut() {
for item in row[..num_bands].iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
}
if row[0] < ALMOST_ZERO {
return Err(HfQuantFactorTooSmall(row[0]));
}
row[0] *= 64.0;
}
Ok(DctQuantWeightParams { params, num_bands })
}
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug)]
pub enum QuantEncoding {
Library,
// a.k.a. "Hornuss"
Identity {
xyb_weights: [[f32; 3]; 3],
},
Dct2 {
xyb_weights: [[f32; 6]; 3],
},
Dct4 {
params: DctQuantWeightParams,
xyb_mul: [[f32; 2]; 3],
},
Dct4x8 {
params: DctQuantWeightParams,
xyb_mul: [f32; 3],
},
Afv {
params4x8: DctQuantWeightParams,
params4x4: DctQuantWeightParams,
weights: [[f32; 9]; 3],
},
Dct {
params: DctQuantWeightParams,
},
Raw {
qtable: Vec<i32>,
qtable_den: f32,
},
}
impl QuantEncoding {
// TODO(veluca): figure out if this should actually be unused.
#[allow(dead_code)]
pub fn raw_from_qtable(qtable: Vec<i32>, shift: i32) -> Self {
Self::Raw {
qtable,
qtable_den: (1 << shift) as f32 * (1.0 / (8.0 * 255.0)),
}
}
pub fn decode(
mut required_size_x: usize,
mut required_size_y: usize,
index: usize,
header: &FrameHeader,
lf_global: &LfGlobalState,
br: &mut BitReader,
) -> Result<Self> {
let required_size = required_size_x * required_size_y;
required_size_x *= BLOCK_DIM;
required_size_y *= BLOCK_DIM;
let mode = br.read(LOG2_NUM_QUANT_MODES)? as u8;
match mode {
0 => Ok(Self::Library),
1 => {
if required_size != 1 {
return Err(InvalidQuantEncoding {
mode,
required_size,
});
}
let mut xyb_weights = [[0.0; 3]; 3];
for row in xyb_weights.iter_mut() {
for item in row.iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
if item.abs() < ALMOST_ZERO {
return Err(HfQuantFactorTooSmall(*item));
}
*item *= 64.0;
}
}
Ok(Self::Identity { xyb_weights })
}
2 => {
if required_size != 1 {
return Err(InvalidQuantEncoding {
mode,
required_size,
});
}
let mut xyb_weights = [[0.0; 6]; 3];
for row in xyb_weights.iter_mut() {
for item in row.iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
if item.abs() < ALMOST_ZERO {
return Err(HfQuantFactorTooSmall(*item));
}
*item *= 64.0;
}
}
Ok(Self::Dct2 { xyb_weights })
}
3 => {
if required_size != 1 {
return Err(InvalidQuantEncoding {
mode,
required_size,
});
}
let mut xyb_mul = [[0.0; 2]; 3];
for row in xyb_mul.iter_mut() {
for item in row.iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
if item.abs() < ALMOST_ZERO {
return Err(HfQuantFactorTooSmall(*item));
}
}
}
let params = DctQuantWeightParams::decode(br)?;
Ok(Self::Dct4 { params, xyb_mul })
}
4 => {
if required_size != 1 {
return Err(InvalidQuantEncoding {
mode,
required_size,
});
}
let mut xyb_mul = [0.0; 3];
for item in xyb_mul.iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
if item.abs() < ALMOST_ZERO {
return Err(HfQuantFactorTooSmall(*item));
}
}
let params = DctQuantWeightParams::decode(br)?;
Ok(Self::Dct4x8 { params, xyb_mul })
}
5 => {
if required_size != 1 {
return Err(InvalidQuantEncoding {
mode,
required_size,
});
}
let mut weights = [[0.0; 9]; 3];
for row in weights.iter_mut() {
for item in row.iter_mut() {
*item = f32::from(f16::from_bits(br.read(16)? as u16));
}
for item in row[0..6].iter_mut() {
*item *= 64.0;
}
}
let params4x8 = DctQuantWeightParams::decode(br)?;
let params4x4 = DctQuantWeightParams::decode(br)?;
Ok(Self::Afv {
params4x8,
params4x4,
weights,
})
}
6 => {
let params = DctQuantWeightParams::decode(br)?;
Ok(Self::Dct { params })
}
7 => {
let qtable_den = f32::from(f16::from_bits(br.read(16)? as u16));
if qtable_den < ALMOST_ZERO {
// qtable[] values are already checked for <= 0 so the denominator may not be negative.
return Err(InvalidRawQuantTable);
}
let bit_depth = BitDepth::integer_samples(8);
let mut image = [
ModularChannel::new((required_size_x, required_size_y), bit_depth)?,
ModularChannel::new((required_size_x, required_size_y), bit_depth)?,
ModularChannel::new((required_size_x, required_size_y), bit_depth)?,
];
let stream_id = ModularStreamId::QuantTable(index).get_id(header);
decode_modular_subbitstream(
image.iter_mut().collect(),
stream_id,
None,
&lf_global.tree,
br,
)?;
let mut qtable = Vec::with_capacity(required_size_x * required_size_y * 3);
for channel in image.iter_mut() {
for entry in channel
.data
.get_rect(Rect {
size: (required_size_x, required_size_y),
origin: (0, 0),
})
.iter()
{
qtable.push(entry);
if entry <= 0 {
return Err(InvalidRawQuantTable);
}
}
}
Ok(Self::Raw { qtable, qtable_den })
}
_ => Err(InvalidQuantEncoding {
mode,
required_size,
}),
}
}
}
#[derive(Clone, Copy, Debug)]
enum QuantTable {
// Update QuantTable::VALUES when changing this!
Dct,
Identity,
Dct2x2,
Dct4x4,
Dct16x16,
Dct32x32,
// Dct16x8
Dct8x16,
// Dct32x8
Dct8x32,
// Dct32x16
Dct16x32,
Dct4x8,
// Dct8x4
Afv0,
// Afv1
// Afv2
// Afv3
Dct64x64,
// Dct64x32,
Dct32x64,
Dct128x128,
// Dct128x64,
Dct64x128,
Dct256x256,
// Dct256x128,
Dct128x256,
}
impl QuantTable {
pub const CARDINALITY: usize = Self::VALUES.len();
pub const VALUES: [QuantTable; 17] = [
QuantTable::Dct,
QuantTable::Identity,
QuantTable::Dct2x2,
QuantTable::Dct4x4,
QuantTable::Dct16x16,
QuantTable::Dct32x32,
// QuantTable::Dct16x8
QuantTable::Dct8x16,
// QuantTable::Dct32x8
QuantTable::Dct8x32,
// QuantTable::Dct32x16
QuantTable::Dct16x32,
QuantTable::Dct4x8,
// QuantTable::Dct8x4
QuantTable::Afv0,
// QuantTable::Afv1
// QuantTable::Afv2
// QuantTable::Afv3
QuantTable::Dct64x64,
// QuantTable::Dct64x32,
QuantTable::Dct32x64,
QuantTable::Dct128x128,
// QuantTable::Dct128x64,
QuantTable::Dct64x128,
QuantTable::Dct256x256,
// QuantTable::Dct256x128,
QuantTable::Dct128x256,
];
fn for_strategy(strategy: HfTransformType) -> QuantTable {
match strategy {
HfTransformType::DCT => QuantTable::Dct,
HfTransformType::IDENTITY => QuantTable::Identity,
HfTransformType::DCT2X2 => QuantTable::Dct2x2,
HfTransformType::DCT4X4 => QuantTable::Dct4x4,
HfTransformType::DCT16X16 => QuantTable::Dct16x16,
HfTransformType::DCT32X32 => QuantTable::Dct32x32,
HfTransformType::DCT16X8 | HfTransformType::DCT8X16 => QuantTable::Dct8x16,
HfTransformType::DCT32X8 | HfTransformType::DCT8X32 => QuantTable::Dct8x32,
HfTransformType::DCT32X16 | HfTransformType::DCT16X32 => QuantTable::Dct16x32,
HfTransformType::DCT4X8 | HfTransformType::DCT8X4 => QuantTable::Dct4x8,
HfTransformType::AFV0
| HfTransformType::AFV1
| HfTransformType::AFV2
| HfTransformType::AFV3 => QuantTable::Afv0,
HfTransformType::DCT64X64 => QuantTable::Dct64x64,
HfTransformType::DCT64X32 | HfTransformType::DCT32X64 => QuantTable::Dct32x64,
HfTransformType::DCT128X128 => QuantTable::Dct128x128,
HfTransformType::DCT128X64 | HfTransformType::DCT64X128 => QuantTable::Dct64x128,
HfTransformType::DCT256X256 => QuantTable::Dct256x256,
HfTransformType::DCT256X128 | HfTransformType::DCT128X256 => QuantTable::Dct128x256,
}
}
}
pub struct DequantMatrices {
/// 17 separate tables, one per QuantTable type.
/// Uses Cow to allow zero-copy borrowing from static cache for library tables.
tables: [Cow<'static, [f32]>; QuantTable::CARDINALITY],
}
/// Cached computed library tables per QuantTable type.
/// Each entry contains the computed f32 weights for all 3 channels.
/// Computed lazily on first access.
static LIBRARY_TABLES: [OnceLock<Box<[f32]>>; QuantTable::CARDINALITY] = [
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
OnceLock::new(),
];
#[allow(clippy::excessive_precision)]
impl DequantMatrices {
fn dct() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[3150.0, 0.0, -0.4, -0.4, -0.4, -2.0],
[560.0, 0.0, -0.3, -0.3, -0.3, -0.3],
[512.0, -2.0, -1.0, 0.0, -1.0, -2.0],
]),
}
}
fn id() -> QuantEncoding {
QuantEncoding::Identity {
xyb_weights: [
[280.0, 3160.0, 3160.0],
[60.0, 864.0, 864.0],
[18.0, 200.0, 200.0],
],
}
}
fn dct2x2() -> QuantEncoding {
QuantEncoding::Dct2 {
xyb_weights: [
[3840.0, 2560.0, 1280.0, 640.0, 480.0, 300.0],
[960.0, 640.0, 320.0, 180.0, 140.0, 120.0],
[640.0, 320.0, 128.0, 64.0, 32.0, 16.0],
],
}
}
fn dct4x4() -> QuantEncoding {
QuantEncoding::Dct4 {
params: DctQuantWeightParams::from_array(&[
[2200.0, 0.0, 0.0, 0.0],
[392.0, 0.0, 0.0, 0.0],
[112.0, -0.25, -0.25, -0.5],
]),
xyb_mul: [[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]],
}
}
fn dct16x16() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
8996.8725711814115328,
-1.3000777393353804,
-0.49424529824571225,
-0.439093774457103443,
-0.6350101832695744,
-0.90177264050827612,
-1.6162099239887414,
],
[
3191.48366296844234752,
-0.67424582104194355,
-0.80745813428471001,
-0.44925837484843441,
-0.35865440981033403,
-0.31322389111877305,
-0.37615025315725483,
],
[
1157.50408145487200256,
-2.0531423165804414,
-1.4,
-0.50687130033378396,
-0.42708730624733904,
-1.4856834539296244,
-4.9209142884401604,
],
]),
}
}
fn dct32x32() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
15718.40830982518931456,
-1.025,
-0.98,
-0.9012,
-0.4,
-0.48819395464,
-0.421064,
-0.27,
],
[
7305.7636810695983104,
-0.8041958212306401,
-0.7633036457487539,
-0.55660379990111464,
-0.49785304658857626,
-0.43699592683512467,
-0.40180866526242109,
-0.27321683125358037,
],
[
3803.53173721215041536,
-3.060733579805728,
-2.0413270132490346,
-2.0235650159727417,
-0.5495389509954993,
-0.4,
-0.4,
-0.3,
],
]),
}
}
// dct16x8
fn dct8x16() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[7240.7734393502, -0.7, -0.7, -0.2, -0.2, -0.2, -0.5],
[1448.15468787004, -0.5, -0.5, -0.5, -0.2, -0.2, -0.2],
[506.854140754517, -1.4, -0.2, -0.5, -0.5, -1.5, -3.6],
]),
}
}
// dct32x8
fn dct8x32() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
16283.2494710648897,
-1.7812845336559429,
-1.6309059012653515,
-1.0382179034313539,
-0.85,
-0.7,
-0.9,
-1.2360638576849587,
],
[
5089.15750884921511936,
-0.320049391452786891,
-0.35362849922161446,
-0.30340000000000003,
-0.61,
-0.5,
-0.5,
-0.6,
],
[
3397.77603275308720128,
-0.321327362693153371,
-0.34507619223117997,
-0.70340000000000003,
-0.9,
-1.0,
-1.0,
-1.1754605576265209,
],
]),
}
}
// dct32x16
fn dct16x32() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
13844.97076442300573,
-0.97113799999999995,
-0.658,
-0.42026,
-0.22712,
-0.2206,
-0.226,
-0.6,
],
[
4798.964084220744293,
-0.61125308982767057,
-0.83770786552491361,
-0.79014862079498627,
-0.2692727459704829,
-0.38272769465388551,
-0.22924222653091453,
-0.20719098826199578,
],
[
1807.236946760964614,
-1.2,
-1.2,
-0.7,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
// dct8x4
fn dct4x8() -> QuantEncoding {
QuantEncoding::Dct4x8 {
params: DctQuantWeightParams::from_array(&[
[
2198.050556016380522,
-0.96269623020744692,
-0.76194253026666783,
-0.6551140670773547,
],
[
764.3655248643528689,
-0.92630200888366945,
-0.9675229603596517,
-0.27845290869168118,
],
[
527.107573587542228,
-1.4594385811273854,
-1.450082094097871593,
-1.5843722511996204,
],
]),
xyb_mul: [1.0, 1.0, 1.0],
}
}
// AFV
fn afv0() -> QuantEncoding {
let QuantEncoding::Dct4x8 {
params: params4x8, ..
} = Self::dct4x8()
else {
unreachable!();
};
let QuantEncoding::Dct4 {
params: params4x4, ..
} = Self::dct4x4()
else {
unreachable!()
};
QuantEncoding::Afv {
params4x8,
params4x4,
weights: [
[
3072.0, 3072.0, // 4x4/4x8 DC tendency.
256.0, 256.0, 256.0, // AFV corner.
414.0, 0.0, 0.0, 0.0, // AFV high freqs.
],
[
1024.0, 1024.0, // 4x4/4x8 DC tendency.
50.0, 50.0, 50.0, // AFV corner.
58.0, 0.0, 0.0, 0.0, // AFV high freqs.
],
[
384.0, 384.0, // 4x4/4x8 DC tendency.
12.0, 12.0, 12.0, // AFV corner.
22.0, -0.25, -0.25, -0.25, // AFV high freqs.
],
],
}
}
fn dct64x64() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
0.9 * 26629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
0.9 * 9311.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
0.9 * 4992.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
// dct64x32
fn dct32x64() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
0.65 * 23629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
0.65 * 8611.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
0.65 * 4492.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
fn dct128x128() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
1.8 * 26629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
1.8 * 9311.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
1.8 * 4992.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
// dct128x64
fn dct64x128() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
1.3 * 23629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
1.3 * 8611.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
1.3 * 4492.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
fn dct256x256() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
3.6 * 26629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
3.6 * 9311.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
3.6 * 4992.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
// dct256x128
fn dct128x256() -> QuantEncoding {
QuantEncoding::Dct {
params: DctQuantWeightParams::from_array(&[
[
2.6 * 23629.073922049845,
-1.025,
-0.78,
-0.65012,
-0.19041574084286472,
-0.20819395464,
-0.421064,
-0.32733845535848671,
],
[
2.6 * 8611.3238710010046,
-0.3041958212306401,
-0.3633036457487539,
-0.35660379990111464,
-0.3443074455424403,
-0.33699592683512467,
-0.30180866526242109,
-0.27321683125358037,
],
[
2.6 * 4492.2486445538634,
-1.2,
-1.2,
-0.8,
-0.7,
-0.7,
-0.4,
-0.5,
],
]),
}
}
/// Get library quantization encoding for a table type index.
fn get_library_encoding(idx: usize) -> QuantEncoding {
match idx {
0 => Self::dct(),
1 => Self::id(),
2 => Self::dct2x2(),
3 => Self::dct4x4(),
4 => Self::dct16x16(),
5 => Self::dct32x32(),
6 => Self::dct8x16(),
7 => Self::dct8x32(),
8 => Self::dct16x32(),
9 => Self::dct4x8(),
10 => Self::afv0(),
11 => Self::dct64x64(),
12 => Self::dct32x64(),
// Same default for large transforms (128+) as for 64x* transforms.
13 => Self::dct128x128(),
14 => Self::dct64x128(),
15 => Self::dct256x256(),
16 => Self::dct128x256(),
_ => unreachable!(),
}
}
/// Get cached computed library table for a QuantTable type index.
/// Computes the table lazily on first access.
fn get_library_table(idx: usize) -> &'static [f32] {
LIBRARY_TABLES[idx].get_or_init(|| {
let encoding = Self::get_library_encoding(idx);
Self::compute_table(&encoding, idx).expect("library table computation should not fail")
})
}
/// Compute a single quant table from an encoding.
/// Returns the computed weights as a boxed slice for all 3 channels.
fn compute_table(encoding: &QuantEncoding, table_idx: usize) -> Result<Box<[f32]>> {
let wrows = 8 * Self::REQUIRED_SIZE_X[table_idx];
let wcols = 8 * Self::REQUIRED_SIZE_Y[table_idx];
let num = wrows * wcols;
let mut weights = vec![0f32; 3 * num];
match encoding {
QuantEncoding::Library => {
// Library encoding should be resolved by the caller.
return Err(InvalidQuantEncodingMode);
}
QuantEncoding::Identity { xyb_weights } => {
for c in 0..3 {
for i in 0..64 {
weights[64 * c + i] = xyb_weights[c][0];
}
weights[64 * c + 1] = xyb_weights[c][1];
weights[64 * c + 8] = xyb_weights[c][1];
weights[64 * c + 9] = xyb_weights[c][2];
}
}
QuantEncoding::Dct2 { xyb_weights } => {
for (c, xyb_weight) in xyb_weights.iter().enumerate() {
let start = c * 64;
weights[start] = 0xBAD as f32;
weights[start + 1] = xyb_weight[0];
weights[start + 8] = xyb_weight[0];
weights[start + 9] = xyb_weight[1];
for y in 0..2 {
for x in 0..2 {
weights[start + y * 8 + x + 2] = xyb_weight[2];
weights[start + (y + 2) * 8 + x] = xyb_weight[2];
}
}
for y in 0..2 {
for x in 0..2 {
weights[start + (y + 2) * 8 + x + 2] = xyb_weight[3];
}
}
for y in 0..4 {
for x in 0..4 {
weights[start + y * 8 + x + 4] = xyb_weight[4];
weights[start + (y + 4) * 8 + x] = xyb_weight[4];
}
}
for y in 0..4 {
for x in 0..4 {
weights[start + (y + 4) * 8 + x + 4] = xyb_weight[5];
}
}
}
}
QuantEncoding::Dct4 { params, xyb_mul } => {
let mut weights4x4 = [0f32; 3 * 4 * 4];
get_quant_weights(4, 4, params, &mut weights4x4)?;
for c in 0..3 {
for y in 0..BLOCK_DIM {
for x in 0..BLOCK_DIM {
weights[c * num + y * BLOCK_DIM + x] =
weights4x4[c * 16 + (y / 2) * 4 + (x / 2)];
}
}
weights[c * num + 1] /= xyb_mul[c][0];
weights[c * num + BLOCK_DIM] /= xyb_mul[c][0];
weights[c * num + BLOCK_DIM + 1] /= xyb_mul[c][1];
}
}
QuantEncoding::Dct4x8 { params, xyb_mul } => {
let mut weights4x8 = [0f32; 3 * 4 * 8];
get_quant_weights(4, 8, params, &mut weights4x8)?;
for c in 0..3 {
for y in 0..BLOCK_DIM {
for x in 0..BLOCK_DIM {
weights[c * num + y * BLOCK_DIM + x] =
weights4x8[c * 32 + (y / 2) * 8 + x];
}
}
weights[c * num + BLOCK_DIM] /= xyb_mul[c];
}
}
QuantEncoding::Dct { params } => {
get_quant_weights(wrows, wcols, params, &mut weights)?;
}
QuantEncoding::Raw { qtable, qtable_den } => {
if qtable.len() != 3 * num {
return Err(InvalidRawQuantTable);
}
for i in 0..3 * num {
weights[i] = 1f32 / (qtable_den * qtable[i] as f32);
}
}
QuantEncoding::Afv {
params4x8,
params4x4,
weights: afv_weights,
} => {
const FREQS: [f32; 16] = [
0xBAD as f32,
0xBAD as f32,
0.8517778890324296,
5.37778436506804,
0xBAD as f32,
0xBAD as f32,
4.734747904497923,
5.449245381693219,
1.6598270267479331,
4f32,
7.275749096817861,
10.423227632456525,
2.662932286148962,
7.630657783650829,
8.962388608184032,
12.97166202570235,
];
let mut weights4x8 = [0f32; 3 * 4 * 8];
get_quant_weights(4, 8, params4x8, &mut weights4x8)?;
let mut weights4x4 = [0f32; 3 * 4 * 4];
get_quant_weights(4, 4, params4x4, &mut weights4x4)?;
const LO: f32 = 0.8517778890324296;
const HI: f32 = 12.97166202570235f32 - LO + 1e-6f32;
for c in 0..3 {
let mut bands = [0f32; 4];
bands[0] = afv_weights[c][5];
if bands[0] < ALMOST_ZERO {
return Err(InvalidDistanceBand(0, bands[0]));
}
for i in 1..4 {
bands[i] = bands[i - 1] * mult(afv_weights[c][i + 5]);
if bands[i] < ALMOST_ZERO {
return Err(InvalidDistanceBand(i, bands[i]));
}
}
{
let start = c * 64;
weights[start] = 1f32;
let mut set = |x, y, val| {
weights[start + y * 8 + x] = val;
};
set(0, 1, afv_weights[c][0]);
set(1, 0, afv_weights[c][1]);
set(0, 2, afv_weights[c][2]);
set(2, 0, afv_weights[c][3]);
set(2, 2, afv_weights[c][4]);
for y in 0..4 {
for x in 0..4 {
if x < 2 && y < 2 {
continue;
}
let val = interpolate(FREQS[y * 4 + x] - LO, HI, &bands);
set(2 * x, 2 * y, val);
}
}
}
for y in 0..BLOCK_DIM / 2 {
for x in 0..BLOCK_DIM {
if x == 0 && y == 0 {
continue;
}
weights[c * num + (2 * y + 1) * BLOCK_DIM + x] =
weights4x8[c * 32 + y * 8 + x];
}
}
for y in 0..BLOCK_DIM / 2 {
for x in 0..BLOCK_DIM / 2 {
if x == 0 && y == 0 {
continue;
}
weights[c * num + (2 * y) * BLOCK_DIM + 2 * x + 1] =
weights4x4[c * 16 + y * 4 + x];
}
}
}
}
}
// Convert weights in place to the final table format (1.0 / weight)
for weight in &mut weights {
if !(ALMOST_ZERO..=1.0 / ALMOST_ZERO).contains(weight) {
return Err(InvalidQuantizationTableWeight(*weight));
}
*weight = 1f32 / *weight;
}
Ok(weights.into_boxed_slice())
}
pub fn matrix(&self, quant_kind: HfTransformType, c: usize) -> &[f32] {
let qt_idx = QuantTable::for_strategy(quant_kind) as usize;
let table = &self.tables[qt_idx];
let num = Self::REQUIRED_SIZE_X[qt_idx] * Self::REQUIRED_SIZE_Y[qt_idx] * BLOCK_SIZE;
&table[c * num..]
}
pub fn decode(
header: &FrameHeader,
lf_global: &LfGlobalState,
br: &mut BitReader,
) -> Result<Self> {
let all_default = br.read(1)? == 1;
// Compute all tables during decode
let tables: [Cow<'static, [f32]>; QuantTable::CARDINALITY] = if all_default {
// All library tables - borrow from static cache (zero-copy)
std::array::from_fn(|idx| Cow::Borrowed(Self::get_library_table(idx)))
} else {
// Decode and compute each table
let mut tables_vec: Vec<Cow<'static, [f32]>> =
Vec::with_capacity(QuantTable::CARDINALITY);
for (i, (&required_size_x, required_size_y)) in Self::REQUIRED_SIZE_X
.iter()
.zip(Self::REQUIRED_SIZE_Y)
.enumerate()
{
let encoding = QuantEncoding::decode(
required_size_x,
required_size_y,
i,
header,
lf_global,
br,
)?;
let table = match encoding {
QuantEncoding::Library => Cow::Borrowed(Self::get_library_table(i)),
_ => Cow::Owned(Self::compute_table(&encoding, i)?.into_vec()),
};
tables_vec.push(table);
}
tables_vec.try_into().unwrap()
};
Ok(Self { tables })
}
pub const REQUIRED_SIZE_X: [usize; QuantTable::CARDINALITY] =
[1, 1, 1, 1, 2, 4, 1, 1, 2, 1, 1, 8, 4, 16, 8, 32, 16];
pub const REQUIRED_SIZE_Y: [usize; QuantTable::CARDINALITY] =
[1, 1, 1, 1, 2, 4, 2, 4, 4, 1, 1, 8, 8, 16, 16, 32, 32];
#[cfg(test)]
const SUM_REQUIRED_X_Y: usize = 2056;
}
fn get_quant_weights(
rows: usize,
cols: usize,
distance_bands: &DctQuantWeightParams,
out: &mut [f32],
) -> Result<()> {
for c in 0..3 {
let mut bands = [0f32; DctQuantWeightParams::MAX_DISTANCE_BANDS];
bands[0] = distance_bands.params[c][0];
if bands[0] < ALMOST_ZERO {
return Err(InvalidDistanceBand(0, bands[0]));
}
for i in 1..distance_bands.num_bands {
bands[i] = bands[i - 1] * mult(distance_bands.params[c][i]);
if bands[i] < ALMOST_ZERO {
return Err(InvalidDistanceBand(i, bands[i]));
}
}
let scale = (distance_bands.num_bands - 1) as f32 / (SQRT_2 + 1e-6);
let rcpcol = scale / (cols - 1) as f32;
let rcprow = scale / (rows - 1) as f32;
for y in 0..rows {
let dy = y as f32 * rcprow;
let dy2 = dy * dy;
for x in 0..cols {
let dx = x as f32 * rcpcol;
let scaled_distance = (dx * dx + dy2).sqrt();
let weight = if distance_bands.num_bands == 1 {
bands[0]
} else {
interpolate_vec(scaled_distance, &bands)
};
out[c * cols * rows + y * cols + x] = weight;
}
}
}
Ok(())
}
fn interpolate_vec(scaled_pos: f32, array: &[f32]) -> f32 {
let idxf32 = scaled_pos.floor();
let frac = scaled_pos - idxf32;
let idx = idxf32 as usize;
let a = array[idx];
let b = array[1..][idx];
(b / a).powf(frac) * a
}
fn interpolate(pos: f32, max: f32, array: &[f32]) -> f32 {
let scaled_pos = pos * (array.len() - 1) as f32 / max;
let idx = scaled_pos as usize;
let a = array[idx];
let b = array[idx + 1];
a * (b / a).powf(scaled_pos - idx as f32)
}
fn mult(v: f32) -> f32 {
if v > 0f32 {
1f32 + v
} else {
1f32 / (1f32 - v)
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::error::Result;
use crate::frame::quant_weights::DequantMatrices;
use crate::util::test::assert_almost_abs_eq;
#[test]
fn check_required_x_y() {
assert_eq!(
DequantMatrices::SUM_REQUIRED_X_Y,
DequantMatrices::REQUIRED_SIZE_X
.iter()
.zip(DequantMatrices::REQUIRED_SIZE_Y)
.map(|(&x, y)| x * y)
.sum()
);
}
#[test]
fn check_dequant_matrix_correctness() -> Result<()> {
// All library tables
let matrices = DequantMatrices {
tables: std::array::from_fn(|idx| {
Cow::Borrowed(DequantMatrices::get_library_table(idx))
}),
};
// Golden data produced by libjxl.
let target_table = [
0.000317f32,
0.000629f32,
0.000457f32,
0.000367f32,
0.000378f32,
0.000709f32,
0.000593f32,
0.000566f32,
0.000629f32,
0.001192f32,
0.000943f32,
0.001786f32,
0.003042f32,
0.002372f32,
0.001998f32,
0.002044f32,
0.003341f32,
0.002907f32,
0.002804f32,
0.003042f32,
0.004229f32,
0.003998f32,
0.001953f32,
0.011969f32,
0.011719f32,
0.007886f32,
0.008374f32,
0.015337f32,
0.011719f32,
0.011719f32,
0.011969f32,
0.032080f32,
0.025368f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.003571f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.016667f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.055556f32,
0.000335f32,
0.002083f32,
0.002083f32,
0.001563f32,
0.000781f32,
0.002083f32,
0.003333f32,
0.002083f32,
0.002083f32,
0.003333f32,
0.003333f32,
0.000335f32,
0.007143f32,
0.007143f32,
0.005556f32,
0.003125f32,
0.007143f32,
0.008333f32,
0.007143f32,
0.007143f32,
0.008333f32,
0.008333f32,
0.000335f32,
0.031250f32,
0.031250f32,
0.015625f32,
0.007812f32,
0.031250f32,
0.062500f32,
0.031250f32,
0.031250f32,
0.062500f32,
0.062500f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.000455f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.002551f32,
0.008929f32,
0.014654f32,
0.012241f32,
0.011161f32,
0.010455f32,
0.015352f32,
0.013951f32,
0.012706f32,
0.014654f32,
0.020926f32,
0.017433f32,
0.000111f32,
0.000469f32,
0.000258f32,
0.000640f32,
0.000388f32,
0.001007f32,
0.000566f32,
0.001880f32,
0.000946f32,
0.000886f32,
0.001880f32,
0.000313f32,
0.001168f32,
0.000531f32,
0.001511f32,
0.000962f32,
0.001959f32,
0.001399f32,
0.002531f32,
0.001908f32,
0.001850f32,
0.002531f32,
0.000864f32,
0.007969f32,
0.002684f32,
0.010653f32,
0.006434f32,
0.015981f32,
0.009743f32,
0.040354f32,
0.014631f32,
0.013468f32,
0.040354f32,
0.000064f32,
0.000135f32,
0.000279f32,
0.000521f32,
0.000760f32,
0.001145f32,
0.000502f32,
0.000647f32,
0.000911f32,
0.001286f32,
0.001685f32,
0.000137f32,
0.000257f32,
0.000464f32,
0.000739f32,
0.001126f32,
0.001645f32,
0.000706f32,
0.000959f32,
0.001327f32,
0.001839f32,
0.002404f32,
0.000263f32,
0.001155f32,
0.003800f32,
0.010779f32,
0.016740f32,
0.024003f32,
0.010258f32,
0.014299f32,
0.019509f32,
0.026824f32,
0.035546f32,
0.000138f32,
0.000515f32,
0.000425f32,
0.000333f32,
0.000362f32,
0.000559f32,
0.000507f32,
0.000500f32,
0.000538f32,
0.000686f32,
0.000666f32,
0.000691f32,
0.002504f32,
0.001785f32,
0.001353f32,
0.001443f32,
0.002721f32,
0.002469f32,
0.002432f32,
0.002617f32,
0.003340f32,
0.003241f32,
0.001973f32,
0.010000f32,
0.006529f32,
0.005339f32,
0.005497f32,
0.012033f32,
0.009689f32,
0.009374f32,
0.011033f32,
0.031220f32,
0.026814f32,
0.000138f32,
0.000515f32,
0.000425f32,
0.000333f32,
0.000362f32,
0.000559f32,
0.000507f32,
0.000500f32,
0.000538f32,
0.000686f32,
0.000666f32,
0.000691f32,
0.002504f32,
0.001785f32,
0.001353f32,
0.001443f32,
0.002721f32,
0.002469f32,
0.002432f32,
0.002617f32,
0.003340f32,
0.003241f32,
0.001973f32,
0.010000f32,
0.006529f32,
0.005339f32,
0.005497f32,
0.012033f32,
0.009689f32,
0.009374f32,
0.011033f32,
0.031220f32,
0.026814f32,
0.000061f32,
0.001686f32,
0.000890f32,
0.000539f32,
0.000524f32,
0.003058f32,
0.002221f32,
0.001956f32,
0.002130f32,
0.002809f32,
0.007926f32,
0.000196f32,
0.000734f32,
0.000453f32,
0.000376f32,
0.000372f32,
0.001148f32,
0.000906f32,
0.000822f32,
0.000877f32,
0.001084f32,
0.002058f32,
0.000294f32,
0.001684f32,
0.000872f32,
0.000599f32,
0.000587f32,
0.003612f32,
0.002411f32,
0.002042f32,
0.002282f32,
0.003276f32,
0.009683f32,
0.000061f32,
0.001686f32,
0.000890f32,
0.000539f32,
0.000524f32,
0.003058f32,
0.002221f32,
0.001956f32,
0.002130f32,
0.002809f32,
0.007926f32,
0.000196f32,
0.000734f32,
0.000453f32,
0.000376f32,
0.000372f32,
0.001148f32,
0.000906f32,
0.000822f32,
0.000877f32,
0.001084f32,
0.002058f32,
0.000294f32,
0.001684f32,
0.000872f32,
0.000599f32,
0.000587f32,
0.003612f32,
0.002411f32,
0.002042f32,
0.002282f32,
0.003276f32,
0.009683f32,
0.000072f32,
0.000339f32,
0.000172f32,
0.000429f32,
0.000308f32,
0.000552f32,
0.000422f32,
0.000388f32,
0.000557f32,
0.000496f32,
0.000935f32,
0.000208f32,
0.001118f32,
0.000422f32,
0.001498f32,
0.000958f32,
0.002133f32,
0.001464f32,
0.001310f32,
0.002154f32,
0.001903f32,
0.002817f32,
0.000553f32,
0.004679f32,
0.001639f32,
0.008626f32,
0.003998f32,
0.015372f32,
0.008305f32,
0.006659f32,
0.015623f32,
0.012761f32,
0.026404f32,
0.000072f32,
0.000339f32,
0.000172f32,
0.000429f32,
0.000308f32,
0.000552f32,
0.000422f32,
0.000388f32,
0.000557f32,
0.000496f32,
0.000935f32,
0.000208f32,
0.001118f32,
0.000422f32,
0.001498f32,
0.000958f32,
0.002133f32,
0.001464f32,
0.001310f32,
0.002154f32,
0.001903f32,
0.002817f32,
0.000553f32,
0.004679f32,
0.001639f32,
0.008626f32,
0.003998f32,
0.015372f32,
0.008305f32,
0.006659f32,
0.015623f32,
0.012761f32,
0.026404f32,
0.000455f32,
0.001419f32,
0.001007f32,
0.000853f32,
0.000733f32,
0.001530f32,
0.001456f32,
0.001211f32,
0.001672f32,
0.002347f32,
0.001967f32,
0.001308f32,
0.004385f32,
0.002909f32,
0.002409f32,
0.002080f32,
0.004796f32,
0.004518f32,
0.003629f32,
0.005108f32,
0.006026f32,
0.005529f32,
0.001897f32,
0.009714f32,
0.005643f32,
0.004386f32,
0.003585f32,
0.010940f32,
0.010108f32,
0.007561f32,
0.012828f32,
0.024294f32,
0.017414f32,
0.000455f32,
0.001419f32,
0.001007f32,
0.000853f32,
0.000733f32,
0.001530f32,
0.001456f32,
0.001211f32,
0.001672f32,
0.002347f32,
0.001967f32,
0.001308f32,
0.004385f32,
0.002909f32,
0.002409f32,
0.002080f32,
0.004796f32,
0.004518f32,
0.003629f32,
0.005108f32,
0.006026f32,
0.005529f32,
0.001897f32,
0.009714f32,
0.005643f32,
0.004386f32,
0.003585f32,
0.010940f32,
0.010108f32,
0.007561f32,
0.012828f32,
0.024294f32,
0.017414f32,
1.000000f32,
0.002415f32,
0.001007f32,
0.003906f32,
0.000733f32,
0.001530f32,
0.002415f32,
0.001211f32,
0.002415f32,
0.002415f32,
0.001967f32,
1.000000f32,
0.017241f32,
0.002909f32,
0.020000f32,
0.002080f32,
0.004796f32,
0.017241f32,
0.003629f32,
0.017241f32,
0.017241f32,
0.005529f32,
1.000000f32,
0.058364f32,
0.005643f32,
0.083333f32,
0.003585f32,
0.010940f32,
0.064815f32,
0.007561f32,
0.050237f32,
0.088778f32,
0.017414f32,
1.000000f32,
0.002415f32,
0.001007f32,
0.003906f32,
0.000733f32,
0.001530f32,
0.002415f32,
0.001211f32,
0.002415f32,
0.002415f32,
0.001967f32,
1.000000f32,
0.017241f32,
0.002909f32,
0.020000f32,
0.002080f32,
0.004796f32,
0.017241f32,
0.003629f32,
0.017241f32,
0.017241f32,
0.005529f32,
1.000000f32,
0.058364f32,
0.005643f32,
0.083333f32,
0.003585f32,
0.010940f32,
0.064815f32,
0.007561f32,
0.050237f32,
0.088778f32,
0.017414f32,
1.000000f32,
0.002415f32,
0.001007f32,
0.003906f32,
0.000733f32,
0.001530f32,
0.002415f32,
0.001211f32,
0.002415f32,
0.002415f32,
0.001967f32,
1.000000f32,
0.017241f32,
0.002909f32,
0.020000f32,
0.002080f32,
0.004796f32,
0.017241f32,
0.003629f32,
0.017241f32,
0.017241f32,
0.005529f32,
1.000000f32,
0.058364f32,
0.005643f32,
0.083333f32,
0.003585f32,
0.010940f32,
0.064815f32,
0.007561f32,
0.050237f32,
0.088778f32,
0.017414f32,
1.000000f32,
0.002415f32,
0.001007f32,
0.003906f32,
0.000733f32,
0.001530f32,
0.002415f32,
0.001211f32,
0.002415f32,
0.002415f32,
0.001967f32,
1.000000f32,
0.017241f32,
0.002909f32,
0.020000f32,
0.002080f32,
0.004796f32,
0.017241f32,
0.003629f32,
0.017241f32,
0.017241f32,
0.005529f32,
1.000000f32,
0.058364f32,
0.005643f32,
0.083333f32,
0.003585f32,
0.010940f32,
0.064815f32,
0.007561f32,
0.050237f32,
0.088778f32,
0.017414f32,
0.000042f32,
0.000152f32,
0.000298f32,
0.000128f32,
0.000268f32,
0.000407f32,
0.000268f32,
0.000364f32,
0.000299f32,
0.000380f32,
0.000623f32,
0.000119f32,
0.000213f32,
0.000391f32,
0.000195f32,
0.000328f32,
0.000571f32,
0.000329f32,
0.000525f32,
0.000393f32,
0.000542f32,
0.000803f32,
0.000223f32,
0.001090f32,
0.003367f32,
0.000867f32,
0.002454f32,
0.006359f32,
0.002462f32,
0.005715f32,
0.003396f32,
0.005943f32,
0.010539f32,
0.000065f32,
0.000136f32,
0.000249f32,
0.000399f32,
0.000481f32,
0.000616f32,
0.000394f32,
0.000449f32,
0.000528f32,
0.000700f32,
0.000944f32,
0.000179f32,
0.000237f32,
0.000329f32,
0.000453f32,
0.000619f32,
0.000836f32,
0.000444f32,
0.000554f32,
0.000714f32,
0.000920f32,
0.001172f32,
0.000342f32,
0.000788f32,
0.001774f32,
0.003270f32,
0.005731f32,
0.009499f32,
0.003143f32,
0.004679f32,
0.007422f32,
0.010736f32,
0.015538f32,
0.000065f32,
0.000136f32,
0.000249f32,
0.000399f32,
0.000481f32,
0.000616f32,
0.000394f32,
0.000449f32,
0.000528f32,
0.000700f32,
0.000944f32,
0.000179f32,
0.000237f32,
0.000329f32,
0.000453f32,
0.000619f32,
0.000836f32,
0.000444f32,
0.000554f32,
0.000714f32,
0.000920f32,
0.001172f32,
0.000342f32,
0.000788f32,
0.001774f32,
0.003270f32,
0.005731f32,
0.009499f32,
0.003143f32,
0.004679f32,
0.007422f32,
0.010736f32,
0.015538f32,
0.000021f32,
0.000148f32,
0.000127f32,
0.000094f32,
0.000083f32,
0.000212f32,
0.000175f32,
0.000163f32,
0.000159f32,
0.000164f32,
0.000329f32,
0.000060f32,
0.000194f32,
0.000149f32,
0.000122f32,
0.000113f32,
0.000294f32,
0.000251f32,
0.000224f32,
0.000217f32,
0.000228f32,
0.000420f32,
0.000111f32,
0.001651f32,
0.001032f32,
0.000701f32,
0.000605f32,
0.003305f32,
0.002650f32,
0.002162f32,
0.002031f32,
0.002222f32,
0.005691f32,
0.000033f32,
0.000120f32,
0.000234f32,
0.000104f32,
0.000213f32,
0.000334f32,
0.000214f32,
0.000303f32,
0.000236f32,
0.000315f32,
0.000521f32,
0.000089f32,
0.000161f32,
0.000297f32,
0.000148f32,
0.000254f32,
0.000444f32,
0.000255f32,
0.000412f32,
0.000299f32,
0.000424f32,
0.000638f32,
0.000171f32,
0.000850f32,
0.002654f32,
0.000698f32,
0.002002f32,
0.005130f32,
0.002014f32,
0.004672f32,
0.002695f32,
0.004847f32,
0.008953f32,
0.000033f32,
0.000120f32,
0.000234f32,
0.000104f32,
0.000213f32,
0.000334f32,
0.000214f32,
0.000303f32,
0.000236f32,
0.000315f32,
0.000521f32,
0.000089f32,
0.000161f32,
0.000297f32,
0.000148f32,
0.000254f32,
0.000444f32,
0.000255f32,
0.000412f32,
0.000299f32,
0.000424f32,
0.000638f32,
0.000171f32,
0.000850f32,
0.002654f32,
0.000698f32,
0.002002f32,
0.005130f32,
0.002014f32,
0.004672f32,
0.002695f32,
0.004847f32,
0.008953f32,
0.000010f32,
0.000062f32,
0.000026f32,
0.000077f32,
0.000055f32,
0.000106f32,
0.000076f32,
0.000069f32,
0.000108f32,
0.000087f32,
0.000165f32,
0.000030f32,
0.000072f32,
0.000044f32,
0.000103f32,
0.000067f32,
0.000147f32,
0.000101f32,
0.000086f32,
0.000149f32,
0.000124f32,
0.000211f32,
0.000056f32,
0.000487f32,
0.000166f32,
0.000920f32,
0.000424f32,
0.001655f32,
0.000897f32,
0.000664f32,
0.001683f32,
0.001291f32,
0.002862f32,
0.000016f32,
0.000115f32,
0.000099f32,
0.000073f32,
0.000065f32,
0.000164f32,
0.000136f32,
0.000127f32,
0.000124f32,
0.000128f32,
0.000256f32,
0.000045f32,
0.000144f32,
0.000111f32,
0.000091f32,
0.000084f32,
0.000219f32,
0.000187f32,
0.000168f32,
0.000162f32,
0.000171f32,
0.000314f32,
0.000086f32,
0.001260f32,
0.000790f32,
0.000537f32,
0.000465f32,
0.002528f32,
0.002026f32,
0.001657f32,
0.001560f32,
0.001709f32,
0.004355f32,
0.000016f32,
0.000115f32,
0.000099f32,
0.000073f32,
0.000065f32,
0.000164f32,
0.000136f32,
0.000127f32,
0.000124f32,
0.000128f32,
0.000256f32,
0.000045f32,
0.000144f32,
0.000111f32,
0.000091f32,
0.000084f32,
0.000219f32,
0.000187f32,
0.000168f32,
0.000162f32,
0.000171f32,
0.000314f32,
0.000086f32,
0.001260f32,
0.000790f32,
0.000537f32,
0.000465f32,
0.002528f32,
0.002026f32,
0.001657f32,
0.001560f32,
0.001709f32,
0.004355f32,
];
let mut target_table_index = 0;
for i in 0..HfTransformType::CARDINALITY {
let hf_type = HfTransformType::from_usize(i).unwrap();
let qt_idx = QuantTable::for_strategy(hf_type) as usize;
let size = DequantMatrices::REQUIRED_SIZE_X[qt_idx]
* DequantMatrices::REQUIRED_SIZE_Y[qt_idx]
* BLOCK_SIZE;
for c in 0..3 {
let table = matrices.matrix(hf_type, c);
for j in (0..size).step_by(size / 10) {
assert_almost_abs_eq(table[j], target_table[target_table_index], 1e-5);
target_table_index += 1;
}
}
}
Ok(())
}
}