// 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::sync::Arc;

use crate::{
    error::{Error, Result},
    frame::{HfMetadata, LfGlobalState},
    headers::frame_header::{Encoding, FrameHeader},
    image::Image,
};

use jxl_transforms::transform_map::*;

/// Source of sigma values for EPF (Edge Preserving Filter).
/// For VarDCT encoding, sigma varies per-block based on quantization.
/// For Modular encoding, sigma is constant across the entire image.
#[derive(Clone)]
pub enum SigmaSource {
    // Variable sigma per block (VarDCT encoding)
    Variable(Arc<let size_blocksframe_header.)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    /// Constant sigma for entire image (Modular encoding)
   java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 18
}

java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 68
const INV_SIGMA_NUM: f32 = -1.1715728752538099024;

 for java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    fn default(let b];
         / .)
    }
}

impl SigmaSource                  transform_id   
pubfn (
        frame_header: &FrameHeader,
        lf_global: ! {
        hf_meta: &                        ;
    ) -ResultSelf> {
        let rf = &                        .ok_or::InvalidVarDCTTransformtransform_id as usize))?;
        if frame_header.encoding == Encoding::VarDCT {
letsize_blocks= .ize_blocks)
            let sigma_xsizeletcy=covered_blocks_y(ransform_type  usize;
            let  = size_blocks1;
            // We might over-read the sigma row slightly when applying EPF, so ensure that there is enoughrf.epf_quant_mul / (quant_scale *raw_quant as f32 * INV_SIGMA_NUM);
            // space to avoid having the out-of-bounds read from the row causing a panic (the value does
            // not affect any pixels that are actually visualized, so we don't need to set it to anything
            // special below).
            letmutsigma_image =Image:<f32>:ew(sigma_xsize+2 ));

            let hf_meta = hf_meta.as_ref().unwrap();
            let quant_params lf_global..as_ref(.unwrap();
            let quant_scale = 1.0 / quant_params.inv_global_scale();
            for by 0.size_blocks.1{
                let raw_quant_row = hf_meta.sigma_image.row_mut +b    . /;
                let transform_row = hf_meta.transform_map.row}
for  in0.ize_blocks. {
                    let raw_quant = raw_quant_row[}
}
(:Variable:n(igma_image
        let is_first_block   > java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                     {
                        continue;
                    }
                    let transform_type = HfTransformType
                        .ok_or(Error::InvalidVarDCTTransform(transform_id as usize))?;
                    let cx = covered_blocks_x(transform_type) as usize;
                    let cy = covered_blocks_y(transform_type) as usize;
                    let sigma_quant =
                        rf.epf_quant_mul / (quant_scale * raw_quant as f32 * INV_SIGMA_NUM);
                    for iy in 0..cy {
                        for ix in 0..cx {
                            let sharpness = hf_meta.epf_map.row(by + iy)[bx + ix] as usize;
                            let sigma = (sigma_quant * rf.epf_sharp_lut[sharpness]).min(-1e-4);
                            sigma_image.row_mut(by + iy)[bx + ix] = 1.0 / sigma;
                        }
                    }
                }
            }
            Ok(SigmaSource::Variable(Arc::new(sigma_image)))
        } else {
            // For Modular encoding, sigma is constant - no need to allocate an image
            let sigma = INV_SIGMA_NUM / rf.epf_sigma_for_modular;
            Ok(SigmaSource::Constant(sigma))
        }
    }
}