zenjxl-decoder 0.3.8

High performance Rust implementation of a JPEG XL decoder
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// 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 crate::{
    bit_reader::BitReader,
    error::{Error, Result},
    frame::quant_weights,
    headers::encodings::{Empty, UnconditionalCoder},
};

pub const NUM_QUANT_TABLES: usize = 17;
pub const GLOBAL_SCALE_DENOM: usize = 1 << 16;

#[derive(Debug)]
pub struct LfQuantFactors {
    pub quant_factors: [f32; 3],
    #[allow(dead_code)] // Inverse factors computed at parse time for future dequantization
    pub inv_quant_factors: [f32; 3],
}

impl LfQuantFactors {
    pub fn new(br: &mut BitReader) -> Result<LfQuantFactors> {
        let mut quant_factors = [0.0f32; 3];
        if br.read(1)? == 1 {
            quant_factors = quant_weights::LF_QUANT;
        } else {
            for qf in quant_factors.iter_mut() {
                *qf = f32::read_unconditional(&(), br, &Empty {})? / 128.0;
                if *qf < 1e-8 {
                    return Err(Error::LfQuantFactorTooSmall(*qf));
                }
            }
        }

        let inv_quant_factors = quant_factors.map(f32::recip);

        Ok(LfQuantFactors {
            quant_factors,
            inv_quant_factors,
        })
    }
}

#[derive(Debug)]
pub struct QuantizerParams {
    pub global_scale: u32,
    pub quant_lf: u32,
}

impl QuantizerParams {
    pub fn read(br: &mut BitReader) -> Result<QuantizerParams> {
        let global_scale = match br.read(2)? {
            0 => br.read(11)? + 1,
            1 => br.read(11)? + 2049,
            2 => br.read(12)? + 4097,
            _ => br.read(16)? + 8193,
        };
        let quant_lf = match br.read(2)? {
            0 => 16,
            1 => br.read(5)? + 1,
            2 => br.read(8)? + 1,
            _ => br.read(16)? + 1,
        };
        Ok(QuantizerParams {
            global_scale: global_scale as u32,
            quant_lf: quant_lf as u32,
        })
    }
    pub fn inv_global_scale(&self) -> f32 {
        GLOBAL_SCALE_DENOM as f32 / self.global_scale as f32
    }
    pub fn inv_quant_lf(&self) -> f32 {
        self.inv_global_scale() / self.quant_lf as f32
    }
}