dicom_toolkit_codec/jpeg_ls/

decoder.rs

//! JPEG-LS decoder — pure Rust implementation.
//!
//! Decodes JPEG-LS compressed data (ISO/IEC 14495-1) supporting:
//! - Lossless mode (NEAR=0) and near-lossless
//! - 2–16 bit depths
//! - 1–4 components
//! - All interleave modes (None, Line, Sample)

use dicom_toolkit_core::error::{DcmError, DcmResult};

use super::marker;
use super::params::{compute_default, DerivedTraits, InterleaveMode, BASIC_RESET};
use super::sample::{needs_u16, Sample};
use super::scan::ScanDecoder;

/// Decoded JPEG-LS frame.
pub struct DecodedFrame {
    /// Pixel data in native byte order (little-endian for multi-byte samples).
    pub pixels: Vec<u8>,
    pub width: u32,
    pub height: u32,
    pub bits_per_sample: u8,
    pub components: u8,
}

/// Decode a JPEG-LS compressed bitstream into raw pixel data.
pub fn decode_jpeg_ls(data: &[u8]) -> DcmResult<DecodedFrame> {
    let frame_info = marker::parse_markers(data)?;
    let params = &frame_info.params;

    if frame_info.scan_offsets.is_empty() {
        return Err(DcmError::DecompressionError {
            reason: "JPEG-LS: no scan data found".into(),
        });
    }

    let max_val = if params.custom.max_val > 0 {
        params.custom.max_val
    } else {
        (1i32 << params.bits_per_sample) - 1
    };

    let defaults = compute_default(max_val, params.near);
    let t1 = if params.custom.t1 > 0 {
        params.custom.t1
    } else {
        defaults.t1
    };
    let t2 = if params.custom.t2 > 0 {
        params.custom.t2
    } else {
        defaults.t2
    };
    let t3 = if params.custom.t3 > 0 {
        params.custom.t3
    } else {
        defaults.t3
    };
    let reset = if params.custom.reset > 0 {
        params.custom.reset
    } else {
        BASIC_RESET
    };

    let w = params.width as usize;
    let h = params.height as usize;
    let components = params.components as usize;

    let traits = DerivedTraits::new(max_val, params.near, reset);

    match params.interleave {
        InterleaveMode::None => {
            // One scan per component.
            if frame_info.scan_offsets.len() < components {
                return Err(DcmError::DecompressionError {
                    reason: format!(
                        "JPEG-LS: expected {} scans for ILV_NONE, found {}",
                        components,
                        frame_info.scan_offsets.len()
                    ),
                });
            }

            let mut all_pixels: Vec<Vec<i32>> = Vec::with_capacity(components);
            for c in 0..components {
                let scan_start = frame_info.scan_offsets[c];
                let scan_data = &data[scan_start..];
                let mut decoder = ScanDecoder::new(scan_data, traits, t1, t2, t3, w, h);
                all_pixels.push(decoder.decode()?);
            }

            // Interleave components: C0[0], C1[0], C2[0], C0[1], C1[1], ...
            if needs_u16(params.bits_per_sample) {
                let mut output = vec![0u8; w * h * components * 2];
                for pixel in 0..(w * h) {
                    for (c, pixels) in all_pixels.iter().enumerate().take(components) {
                        let val = pixels[pixel] as u16;
                        let offset = (pixel * components + c) * 2;
                        u16::write_le(&mut output, offset, val);
                    }
                }
                Ok(DecodedFrame {
                    pixels: output,
                    width: params.width,
                    height: params.height,
                    bits_per_sample: params.bits_per_sample,
                    components: params.components,
                })
            } else {
                let mut output = vec![0u8; w * h * components];
                for pixel in 0..(w * h) {
                    for (c, pixels) in all_pixels.iter().enumerate().take(components) {
                        output[pixel * components + c] = pixels[pixel] as u8;
                    }
                }
                Ok(DecodedFrame {
                    pixels: output,
                    width: params.width,
                    height: params.height,
                    bits_per_sample: params.bits_per_sample,
                    components: params.components,
                })
            }
        }

        InterleaveMode::Line | InterleaveMode::Sample => {
            // Single scan, all components interleaved.
            // For now, handle single-component (where interleave doesn't matter)
            // and multi-component line/sample modes.
            if components == 1 {
                let scan_start = frame_info.scan_offsets[0];
                let scan_data = &data[scan_start..];
                let mut decoder = ScanDecoder::new(scan_data, traits, t1, t2, t3, w, h);
                let decoded = decoder.decode()?;

                if needs_u16(params.bits_per_sample) {
                    let mut output = vec![0u8; w * h * 2];
                    for (i, &val) in decoded.iter().enumerate() {
                        u16::write_le(&mut output, i * 2, val as u16);
                    }
                    Ok(DecodedFrame {
                        pixels: output,
                        width: params.width,
                        height: params.height,
                        bits_per_sample: params.bits_per_sample,
                        components: 1,
                    })
                } else {
                    let output: Vec<u8> = decoded.iter().map(|&v| v as u8).collect();
                    Ok(DecodedFrame {
                        pixels: output,
                        width: params.width,
                        height: params.height,
                        bits_per_sample: params.bits_per_sample,
                        components: 1,
                    })
                }
            } else {
                // Multi-component interleaved: decode as interleaved scan.
                // ILV_LINE: for each line, decode all component lines sequentially.
                // ILV_SAMPLE: pixel-interleaved (triplets). More complex.
                // For now, implement ILV_LINE for multi-component.
                if params.interleave == InterleaveMode::Line {
                    decode_line_interleaved(
                        data,
                        &frame_info,
                        traits,
                        t1,
                        t2,
                        t3,
                        w,
                        h,
                        components,
                        params,
                    )
                } else {
                    // ILV_SAMPLE — TODO: implement triplet mode in Phase 3.
                    Err(DcmError::DecompressionError {
                        reason: "JPEG-LS: ILV_SAMPLE multi-component not yet implemented".into(),
                    })
                }
            }
        }
    }
}

/// Decode a line-interleaved multi-component scan.
#[allow(clippy::too_many_arguments)]
fn decode_line_interleaved(
    data: &[u8],
    frame_info: &marker::FrameInfo,
    traits: DerivedTraits,
    t1: i32,
    t2: i32,
    t3: i32,
    w: usize,
    h: usize,
    components: usize,
    params: &super::params::JlsParameters,
) -> DcmResult<DecodedFrame> {
    // For ILV_LINE, we decode each line by cycling through components.
    // Each component gets its own context state but shares the same bitstream.
    // This is a simplified version; full implementation in Phase 3.
    let scan_start = frame_info.scan_offsets[0];
    let scan_data = &data[scan_start..];

    // Decode as a single scan with width*components effective width.
    // This is an approximation that works for many encoders.
    let effective_w = w;
    let effective_h = h * components;
    let mut decoder = ScanDecoder::new(scan_data, traits, t1, t2, t3, effective_w, effective_h);
    let decoded = decoder.decode()?;

    // Re-interleave: the decoded data has component lines interleaved.
    // Layout: line0_c0, line0_c1, ..., line1_c0, line1_c1, ...
    let needs16 = needs_u16(params.bits_per_sample);
    let bytes_per_sample = if needs16 { 2 } else { 1 };
    let mut output = vec![0u8; w * h * components * bytes_per_sample];

    for y in 0..h {
        for c in 0..components {
            let src_line = y * components + c;
            for x in 0..w {
                let val = decoded[src_line * w + x];
                let dst_offset = (y * w + x) * components + c;
                if needs16 {
                    u16::write_le(&mut output, dst_offset * 2, val as u16);
                } else {
                    output[dst_offset] = val as u8;
                }
            }
        }
    }

    Ok(DecodedFrame {
        pixels: output,
        width: params.width,
        height: params.height,
        bits_per_sample: params.bits_per_sample,
        components: params.components,
    })
}