ultrahdr-core 0.5.0

//! Streaming APIs for low-memory gain map processing.
//!
//! This module provides four streaming processors, two for decode (SDR+gainmap → HDR)
//! and two for encode (HDR+SDR → gainmap):
//!
//! | Type | Direction | Memory Model | Use When |
//! |------|-----------|--------------|----------|
//! | [`RowDecoder`] | Decode | Full gainmap in memory | Gainmap fits in RAM |
//! | [`StreamDecoder`] | Decode | Ring buffer (16 rows) | Parallel JPEG decode |
//! | [`RowEncoder`] | Encode | Synchronized batches | Same-rate HDR/SDR |
//! | [`StreamEncoder`] | Encode | Independent buffers | Parallel JPEG decode |
//!
//! # Linear f32 Input/Output
//!
//! All streaming APIs work with **linear f32 RGB** data. The caller is responsible
//! for converting encoded formats (sRGB, PQ, HLG) to/from linear using an external
//! CMS such as moxcms.
//!
//! ```text
//! Decode: SDR (linear f32) + GainMap → HDR (linear f32)
//! Encode: HDR (linear f32) + SDR (linear f32) → GainMap (u8)
//! ```
//!
//! # Memory Comparison (4K image, 3840x2160)
//!
//! | API | Peak Memory |
//! |-----|-------------|
//! | Full decode | ~166 MB |
//! | Streaming decode (16 rows) | ~2 MB |
//! | Full encode | ~170 MB |
//! | Streaming encode (16 rows) | ~4 MB |
//!
//! # Example: Streaming HDR Reconstruction
//!
//! ```
//! use ultrahdr_core::{
//!     ColorPrimaries, GainMap, GainMapMetadata,
//!     gainmap::streaming::RowDecoder,
//! };
//!
//! // Inputs would come from your JPEG decoder + metadata parser; this shows
//! // the call shape with a trivial 8×8 gain map.
//! let width = 8u32;
//! let height = 8u32;
//! let gainmap = GainMap::new(width, height)?;
//! let metadata = GainMapMetadata::default();
//!
//! let mut decoder =
//!     RowDecoder::new(gainmap, metadata, width, height, 4.0, ColorPrimaries::Bt709)?;
//!
//! // Caller converts sRGB JPEG output to linear f32 via their own CMS; here
//! // we just pass zeros at the right row stride (3 floats per pixel).
//! let batch_rows = 4u32;
//! let sdr_linear = vec![0.0_f32; (width * batch_rows * 3) as usize];
//! let _hdr_batch = decoder.process_rows(&sdr_linear, batch_rows)?;
//! // hdr_batch is linear f32 RGBA; convert to PQ/sRGB on the way out.
//! # Ok::<(), ultrahdr_core::Error>(())
//! ```

use alloc::format;
use alloc::vec;
use alloc::vec::Vec;

use crate::color::gamut::rgb_to_luminance;
use crate::types::{ColorPrimaries, Error, GainMap, GainMapMetadata, Result};

use super::compute::GainMapConfig;

// ============================================================================
// Row Decoder (full gainmap in memory, linear f32 I/O)
// ============================================================================

/// Row-based HDR decoder that holds the full gainmap in memory.
///
/// Accepts SDR image rows as **linear f32 RGB** and outputs reconstructed HDR rows
/// as **linear f32 RGBA**. The caller is responsible for converting encoded formats
/// (sRGB, PQ, etc.) to linear before calling this decoder.
///
/// # Input Format
///
/// Input must be linear f32 RGB with values in `[0, 1]` for SDR content.
/// Layout: `[R, G, B, R, G, B, ...]` - 3 floats per pixel.
///
/// # Output Format
///
/// Output is linear f32 RGBA where `1.0 = SDR white (203 nits)`.
/// Values above 1.0 represent HDR highlights. Layout: `[R, G, B, A, R, G, B, A, ...]`.
///
/// # Memory Usage
///
/// - Gainmap: `gm_width × gm_height × channels` bytes
/// - Per batch: `width × batch_rows × 16` bytes (RGBA f32)
/// **Deprecated API surface** — slated for removal in 0.5.0.
///
/// No known external callers. The per-row kernels this type wraps
/// (`sample_gainmap_row_lut`, `apply_gain_row_presampled`) are the
/// reusable surface; this state machine is Ultra-HDR-specific glue
/// that doesn't compose cleanly with zenjpeg's streaming model.
#[doc(hidden)]
#[derive(Debug)]
pub struct RowDecoder {
    gainmap: GainMap,
    width: u32,
    height: u32,
    lut: super::apply::GainMapLut,
    shepards: Option<super::apply::ShepardsLut>,
    base_offset: [f32; 3],
    alternate_offset: [f32; 3],
    current_row: u32,
    gamut: ColorPrimaries,
    // Row-reusable scratch buffers
    sdr_row: Vec<[f32; 3]>,
    gains_row: Vec<[f32; 3]>,
    hdr_row: Vec<[f32; 3]>,
}

impl RowDecoder {
    /// Create a new streaming HDR reconstructor.
    ///
    /// # Arguments
    /// * `gainmap` - The gain map (loaded entirely, typically small)
    /// * `metadata` - Gain map metadata
    /// * `width` - Output image width
    /// * `height` - Output image height
    /// * `display_boost` - HDR boost factor (e.g., 4.0)
    /// * `gamut` - Color gamut of the SDR input
    pub fn new(
        gainmap: GainMap,
        metadata: GainMapMetadata,
        width: u32,
        height: u32,
        display_boost: f32,
        gamut: ColorPrimaries,
    ) -> Result<Self> {
        let weight = super::apply::calculate_weight(display_boost, &metadata);
        let lut = super::apply::GainMapLut::new(&metadata, weight);
        let shepards =
            super::apply::ShepardsLut::try_new(width, height, gainmap.width, gainmap.height);
        let base_offset = [
            metadata.channels[0].base_offset as f32,
            metadata.channels[1].base_offset as f32,
            metadata.channels[2].base_offset as f32,
        ];
        let alternate_offset = [
            metadata.channels[0].alternate_offset as f32,
            metadata.channels[1].alternate_offset as f32,
            metadata.channels[2].alternate_offset as f32,
        ];
        let row_pixels = width as usize;

        Ok(Self {
            gainmap,
            width,
            height,
            lut,
            shepards,
            base_offset,
            alternate_offset,
            current_row: 0,
            gamut,
            sdr_row: vec![[0.0; 3]; row_pixels],
            gains_row: vec![[0.0; 3]; row_pixels],
            hdr_row: vec![[0.0; 3]; row_pixels],
        })
    }

    /// Get the source color gamut.
    pub fn gamut(&self) -> ColorPrimaries {
        self.gamut
    }

    /// Process multiple SDR rows (linear f32 RGB) and return HDR rows (linear f32 RGBA).
    ///
    /// # Arguments
    /// * `sdr_linear` - Linear f32 RGB data, 3 floats per pixel, `width * num_rows` pixels
    /// * `num_rows` - Number of rows in the batch
    ///
    /// # Returns
    /// Linear f32 RGBA data, 4 floats per pixel.
    pub fn process_rows(&mut self, sdr_linear: &[f32], num_rows: u32) -> Result<Vec<f32>> {
        let remaining = self.height - self.current_row;
        let actual_rows = num_rows.min(remaining);

        if actual_rows == 0 {
            return Err(Error::InvalidPixelData("all rows already processed".into()));
        }

        let input_stride = self.width as usize * 3; // RGB
        let expected_len = input_stride * actual_rows as usize;
        if sdr_linear.len() < expected_len {
            return Err(Error::InvalidPixelData(format!(
                "input data too short: {} < {} floats",
                sdr_linear.len(),
                expected_len
            )));
        }

        let output_stride = self.width as usize * 4; // RGBA
        let mut output = vec![0.0f32; output_stride * actual_rows as usize];
        let row_pixels = self.width as usize;

        for row_offset in 0..actual_rows {
            let y = self.current_row + row_offset;
            let input_start = row_offset as usize * input_stride;
            let output_start = row_offset as usize * output_stride;

            // Copy linear SDR rgb into [[f32; 3]; width] scratch buffer.
            for (x, dst) in self.sdr_row.iter_mut().enumerate() {
                let in_idx = input_start + x * 3;
                *dst = [
                    sdr_linear[in_idx],
                    sdr_linear[in_idx + 1],
                    sdr_linear[in_idx + 2],
                ];
            }

            // Sample per-channel gains for this row (Shepard's IDW + LUT).
            super::apply::sample_gainmap_row_lut(
                &self.gainmap,
                &self.lut,
                self.shepards.as_ref(),
                y,
                self.width,
                self.height,
                &mut self.gains_row,
            );

            // Apply ISO 21496-1 gain formula.
            super::apply_simd::apply_gain_row_presampled(
                &self.sdr_row,
                &self.gains_row,
                self.base_offset,
                self.alternate_offset,
                &mut self.hdr_row,
            );

            // Scatter into packed RGBA output.
            for x in 0..row_pixels {
                let out_idx = output_start + x * 4;
                output[out_idx] = self.hdr_row[x][0];
                output[out_idx + 1] = self.hdr_row[x][1];
                output[out_idx + 2] = self.hdr_row[x][2];
                output[out_idx + 3] = 1.0;
            }
        }

        self.current_row += actual_rows;
        Ok(output)
    }

    /// Process a single row (convenience wrapper).
    pub fn process_row(&mut self, sdr_linear: &[f32]) -> Result<Vec<f32>> {
        self.process_rows(sdr_linear, 1)
    }

    /// Check if all rows have been processed.
    pub fn is_complete(&self) -> bool {
        self.current_row >= self.height
    }

    /// Get current row index.
    pub fn current_row(&self) -> u32 {
        self.current_row
    }

    /// Get total rows.
    pub fn total_rows(&self) -> u32 {
        self.height
    }

    /// Rows remaining to process.
    pub fn rows_remaining(&self) -> u32 {
        self.height - self.current_row
    }

    /// Reset for reprocessing.
    pub fn reset(&mut self) {
        self.current_row = 0;
    }
}

// ============================================================================
// Stream Decoder (streamed gainmap, minimal memory, linear f32 I/O)
// ============================================================================

/// Streaming HDR decoder that accepts both SDR and gainmap rows independently.
///
/// Unlike [`RowDecoder`] which loads the full gainmap upfront, this variant
/// streams both the SDR image and the gainmap simultaneously.
///
/// # Input/Output Format
///
/// - SDR input: Linear f32 RGB, 3 floats per pixel
/// - HDR output: Linear f32 RGBA, 4 floats per pixel
///
/// # Memory Model
///
/// - Gainmap ring buffer: 16 rows × `gm_width × channels` bytes
/// **Deprecated API surface** — slated for removal in 0.5.0. See
/// [`RowDecoder`] for rationale.
#[doc(hidden)]
#[derive(Debug)]
pub struct StreamDecoder {
    sdr_width: u32,
    sdr_height: u32,
    gm_width: u32,
    gm_height: u32,
    gm_channels: u8,
    lut: super::apply::GainMapLut,
    base_offset: [f32; 3],
    alternate_offset: [f32; 3],
    current_sdr_row: u32,
    current_gm_row: u32,
    gamut: ColorPrimaries,
    gm_buffer: GainMapRingBuffer,
    // Row-reusable scratch buffers
    sdr_row: Vec<[f32; 3]>,
    gains_row: Vec<[f32; 3]>,
    hdr_row: Vec<[f32; 3]>,
}

/// Ring buffer for gainmap rows during streaming decode.
#[derive(Debug)]
struct GainMapRingBuffer {
    rows: Vec<Vec<u8>>,
    first_row: u32,
    count: u32,
    row_bytes: usize,
    capacity: u32,
}

impl GainMapRingBuffer {
    fn new(gm_width: u32, gm_channels: u8, capacity: u32) -> Self {
        let row_bytes = gm_width as usize * gm_channels as usize;
        Self {
            rows: vec![vec![0u8; row_bytes]; capacity as usize],
            first_row: 0,
            count: 0,
            row_bytes,
            capacity,
        }
    }

    fn push(&mut self, row_index: u32, data: &[u8]) {
        let slot = (row_index % self.capacity) as usize;
        let copy_len = data.len().min(self.row_bytes);
        self.rows[slot][..copy_len].copy_from_slice(&data[..copy_len]);

        if self.count == 0 {
            self.first_row = row_index;
        }
        let new_last = row_index + 1;
        let new_first = new_last.saturating_sub(self.capacity);
        if new_first > self.first_row {
            self.first_row = new_first;
        }
        self.count = (new_last - self.first_row).min(self.capacity);
    }

    fn contains(&self, row: u32) -> bool {
        if self.count == 0 {
            return false;
        }
        row >= self.first_row && row < self.first_row + self.count
    }

    fn get(&self, row: u32) -> Option<&[u8]> {
        if !self.contains(row) {
            return None;
        }
        let slot = (row % self.capacity) as usize;
        Some(&self.rows[slot])
    }
}

impl StreamDecoder {
    /// Create a new streaming decoder.
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        metadata: GainMapMetadata,
        sdr_width: u32,
        sdr_height: u32,
        gm_width: u32,
        gm_height: u32,
        gm_channels: u8,
        display_boost: f32,
        gamut: ColorPrimaries,
    ) -> Result<Self> {
        let weight = super::apply::calculate_weight(display_boost, &metadata);
        let lut = super::apply::GainMapLut::new(&metadata, weight);
        let base_offset = [
            metadata.channels[0].base_offset as f32,
            metadata.channels[1].base_offset as f32,
            metadata.channels[2].base_offset as f32,
        ];
        let alternate_offset = [
            metadata.channels[0].alternate_offset as f32,
            metadata.channels[1].alternate_offset as f32,
            metadata.channels[2].alternate_offset as f32,
        ];
        let gm_buffer = GainMapRingBuffer::new(gm_width, gm_channels, 16);
        let row_pixels = sdr_width as usize;

        Ok(Self {
            sdr_width,
            sdr_height,
            gm_width,
            gm_height,
            gm_channels,
            lut,
            base_offset,
            alternate_offset,
            current_sdr_row: 0,
            current_gm_row: 0,
            gamut,
            gm_buffer,
            sdr_row: vec![[0.0; 3]; row_pixels],
            gains_row: vec![[0.0; 3]; row_pixels],
            hdr_row: vec![[0.0; 3]; row_pixels],
        })
    }

    /// Get the source color gamut.
    pub fn gamut(&self) -> ColorPrimaries {
        self.gamut
    }

    /// Push a gainmap row into the buffer.
    pub fn push_gainmap_row(&mut self, data: &[u8]) -> Result<()> {
        if self.current_gm_row >= self.gm_height {
            return Err(Error::InvalidPixelData(
                "all gainmap rows already received".into(),
            ));
        }

        self.gm_buffer.push(self.current_gm_row, data);
        self.current_gm_row += 1;
        Ok(())
    }

    /// Push multiple gainmap rows at once.
    pub fn push_gainmap_rows(&mut self, data: &[u8], num_rows: u32) -> Result<()> {
        let row_bytes = self.gm_width as usize * self.gm_channels as usize;
        for i in 0..num_rows {
            let start = i as usize * row_bytes;
            let end = start + row_bytes;
            if end > data.len() {
                return Err(Error::InvalidPixelData("gainmap data too short".into()));
            }
            self.push_gainmap_row(&data[start..end])?;
        }
        Ok(())
    }

    /// Check if we have enough gainmap data to process the given number of SDR rows.
    pub fn can_process(&self, num_sdr_rows: u32) -> bool {
        if self.current_sdr_row >= self.sdr_height {
            return false;
        }

        let last_sdr_row = (self.current_sdr_row + num_sdr_rows - 1).min(self.sdr_height - 1);
        let gm_y_last = (last_sdr_row as f32 / self.sdr_height as f32) * self.gm_height as f32;
        let gm_y1_needed = (gm_y_last.ceil() as u32).min(self.gm_height - 1);

        self.current_gm_row > gm_y1_needed || self.gm_buffer.contains(gm_y1_needed)
    }

    /// Process SDR rows (linear f32 RGB) and return HDR output (linear f32 RGBA).
    pub fn process_sdr_rows(&mut self, sdr_linear: &[f32], num_rows: u32) -> Result<Vec<f32>> {
        let remaining = self.sdr_height - self.current_sdr_row;
        let actual_rows = num_rows.min(remaining);

        if actual_rows == 0 {
            return Err(Error::InvalidPixelData(
                "all SDR rows already processed".into(),
            ));
        }

        if !self.can_process(actual_rows) {
            return Err(Error::InvalidPixelData(
                "insufficient gainmap data buffered".into(),
            ));
        }

        let input_stride = self.sdr_width as usize * 3;
        let expected_len = input_stride * actual_rows as usize;
        if sdr_linear.len() < expected_len {
            return Err(Error::InvalidPixelData(format!(
                "SDR data too short: {} < {} floats",
                sdr_linear.len(),
                expected_len
            )));
        }

        let output_stride = self.sdr_width as usize * 4;
        let mut output = vec![0.0f32; output_stride * actual_rows as usize];
        let row_pixels = self.sdr_width as usize;

        for row_offset in 0..actual_rows {
            let y = self.current_sdr_row + row_offset;
            let input_start = row_offset as usize * input_stride;
            let output_start = row_offset as usize * output_stride;

            // Copy linear SDR rgb into [[f32; 3]; width] scratch.
            for (x, dst) in self.sdr_row.iter_mut().enumerate() {
                let in_idx = input_start + x * 3;
                *dst = [
                    sdr_linear[in_idx],
                    sdr_linear[in_idx + 1],
                    sdr_linear[in_idx + 2],
                ];
            }

            // Sample per-channel gains for this row via ring-buffer bilinear + LUT.
            sample_gainmap_row_ring(
                &self.gm_buffer,
                &self.lut,
                self.gm_channels,
                y,
                self.sdr_width,
                self.sdr_height,
                self.gm_width,
                self.gm_height,
                &mut self.gains_row,
            );

            // Apply ISO 21496-1 gain formula using the shared row kernel.
            super::apply_simd::apply_gain_row_presampled(
                &self.sdr_row,
                &self.gains_row,
                self.base_offset,
                self.alternate_offset,
                &mut self.hdr_row,
            );

            // Scatter into packed RGBA output.
            for x in 0..row_pixels {
                let out_idx = output_start + x * 4;
                output[out_idx] = self.hdr_row[x][0];
                output[out_idx + 1] = self.hdr_row[x][1];
                output[out_idx + 2] = self.hdr_row[x][2];
                output[out_idx + 3] = 1.0;
            }
        }

        self.current_sdr_row += actual_rows;
        Ok(output)
    }

    #[inline]
    fn sample_row_gray(row: Option<&[u8]>, x: u32) -> f32 {
        row.and_then(|r| r.get(x as usize).copied()).unwrap_or(128) as f32 / 255.0
    }

    #[inline]
    fn sample_row_rgb(row: Option<&[u8]>, x: u32, c: usize) -> f32 {
        row.and_then(|r| r.get(x as usize * 3 + c).copied())
            .unwrap_or(128) as f32
            / 255.0
    }

    /// Get remaining SDR rows to process.
    pub fn sdr_rows_remaining(&self) -> u32 {
        self.sdr_height - self.current_sdr_row
    }

    /// Get remaining gainmap rows to receive.
    pub fn gainmap_rows_remaining(&self) -> u32 {
        self.gm_height - self.current_gm_row
    }

    /// Check if reconstruction is complete.
    pub fn is_complete(&self) -> bool {
        self.current_sdr_row >= self.sdr_height
    }
}

// ============================================================================
// Row Encoder (synchronized HDR+SDR batches, linear f32 input)
// ============================================================================

/// Row-based gainmap encoder for synchronized HDR+SDR input.
///
/// Accepts HDR and SDR rows as **linear f32 RGB** and outputs 8-bit gain map values.
///
/// # Input Format
///
/// - HDR: Linear f32 RGB, 3 floats per pixel, values typically `[0, ~10]`
/// - SDR: Linear f32 RGB, 3 floats per pixel, values in `[0, 1]`
/// **Deprecated API surface** — slated for removal in 0.5.0. See
/// [`RowDecoder`] for rationale.
#[doc(hidden)]
#[derive(Debug)]
pub struct RowEncoder {
    config: GainMapConfig,
    width: u32,
    height: u32,
    gm_width: u32,
    gm_height: u32,
    scale: u32,
    current_input_row: u32,
    current_gm_row: u32,
    hdr_buffer: LinearRowBuffer,
    sdr_buffer: LinearRowBuffer,
    actual_min_boost: f32,
    actual_max_boost: f32,
    gainmap_data: Vec<u8>,
    gm_row_stride: usize,
    hdr_gamut: ColorPrimaries,
    sdr_gamut: ColorPrimaries,
}

/// Buffer for storing a sliding window of linear f32 rows.
#[derive(Debug)]
struct LinearRowBuffer {
    rows: Vec<Vec<f32>>,
    first_row: u32,
    count: u32,
    width: u32,
}

impl LinearRowBuffer {
    fn new(capacity: usize, width: u32) -> Self {
        let row_len = width as usize * 3; // RGB
        Self {
            rows: vec![vec![0.0f32; row_len]; capacity],
            first_row: 0,
            count: 0,
            width,
        }
    }

    fn push_row(&mut self, row: u32, data: &[f32]) {
        let capacity = self.rows.len() as u32;
        let idx = (row % capacity) as usize;
        let copy_len = data.len().min(self.rows[idx].len());
        self.rows[idx][..copy_len].copy_from_slice(&data[..copy_len]);

        if self.count == 0 {
            self.first_row = row;
        }
        self.count = self.count.saturating_add(1).min(capacity);
    }

    fn push_rows(&mut self, start_row: u32, data: &[f32], num_rows: u32) {
        let stride = self.width as usize * 3;
        for i in 0..num_rows {
            let row_data = &data[i as usize * stride..];
            self.push_row(start_row + i, row_data);
        }
    }

    fn get_pixel(&self, row: u32, x: u32) -> Option<[f32; 3]> {
        let capacity = self.rows.len() as u32;

        if row < self.first_row || row >= self.first_row + self.count {
            return None;
        }

        let idx = (row % capacity) as usize;
        let row_data = &self.rows[idx];
        let px_idx = x as usize * 3;

        if px_idx + 2 < row_data.len() {
            Some([row_data[px_idx], row_data[px_idx + 1], row_data[px_idx + 2]])
        } else {
            None
        }
    }
}

impl RowEncoder {
    /// Create a new row-based encoder.
    ///
    /// # Arguments
    /// * `width`, `height` - Image dimensions
    /// * `config` - Gain map configuration
    /// * `hdr_gamut` - HDR input color gamut
    /// * `sdr_gamut` - SDR input color gamut
    pub fn new(
        width: u32,
        height: u32,
        config: GainMapConfig,
        hdr_gamut: ColorPrimaries,
        sdr_gamut: ColorPrimaries,
    ) -> Result<Self> {
        let scale = config.scale_factor.max(1) as u32;
        let gm_width = width.div_ceil(scale);
        let gm_height = height.div_ceil(scale);

        let buffer_size = (scale as usize + 16).max(32);
        let channels = if config.multi_channel { 3 } else { 1 };
        let gm_row_stride = gm_width as usize * channels;
        let gainmap_data = vec![0u8; gm_row_stride * gm_height as usize];

        Ok(Self {
            config,
            width,
            height,
            gm_width,
            gm_height,
            scale,
            current_input_row: 0,
            current_gm_row: 0,
            hdr_buffer: LinearRowBuffer::new(buffer_size, width),
            sdr_buffer: LinearRowBuffer::new(buffer_size, width),
            actual_min_boost: f32::MAX,
            actual_max_boost: f32::MIN,
            gainmap_data,
            gm_row_stride,
            hdr_gamut,
            sdr_gamut,
        })
    }

    /// Process multiple rows at once.
    ///
    /// # Arguments
    /// * `hdr_linear` - HDR linear f32 RGB data, 3 floats per pixel
    /// * `sdr_linear` - SDR linear f32 RGB data, 3 floats per pixel
    /// * `num_rows` - Number of rows
    ///
    /// # Returns
    /// Vector of completed gainmap rows (may be empty if waiting for more data).
    pub fn process_rows(
        &mut self,
        hdr_linear: &[f32],
        sdr_linear: &[f32],
        num_rows: u32,
    ) -> Result<Vec<Vec<u8>>> {
        let remaining = self.height - self.current_input_row;
        let actual_rows = num_rows.min(remaining);

        if actual_rows == 0 {
            return Ok(Vec::new());
        }

        self.hdr_buffer
            .push_rows(self.current_input_row, hdr_linear, actual_rows);
        self.sdr_buffer
            .push_rows(self.current_input_row, sdr_linear, actual_rows);

        self.current_input_row += actual_rows;

        let mut output_rows = Vec::new();

        while self.current_gm_row < self.gm_height {
            let target_y = self.current_gm_row * self.scale + self.scale / 2;
            let target_y = target_y.min(self.height - 1);

            if self.current_input_row > target_y {
                let gy = self.current_gm_row as usize;
                let start = gy * self.gm_row_stride;
                let end = start + self.gm_row_stride;
                self.compute_gainmap_row_into_buffer();
                output_rows.push(self.gainmap_data[start..end].to_vec());
                self.current_gm_row += 1;
            } else {
                break;
            }
        }

        Ok(output_rows)
    }

    /// Process a single pair of rows.
    pub fn process_row(
        &mut self,
        hdr_linear: &[f32],
        sdr_linear: &[f32],
    ) -> Result<Option<Vec<u8>>> {
        let rows = self.process_rows(hdr_linear, sdr_linear, 1)?;
        Ok(rows.into_iter().next())
    }

    /// Finish and return the complete gainmap with metadata.
    pub fn finish(mut self) -> Result<(GainMap, GainMapMetadata)> {
        while self.current_gm_row < self.gm_height {
            self.compute_gainmap_row_into_buffer();
            self.current_gm_row += 1;
        }

        let mut gainmap = if self.config.multi_channel {
            GainMap::new_multichannel(self.gm_width, self.gm_height)?
        } else {
            GainMap::new(self.gm_width, self.gm_height)?
        };

        gainmap.data = self.gainmap_data;

        let actual_min = self.actual_min_boost.max(self.config.min_boost);
        let actual_max = self.actual_max_boost.min(self.config.max_boost);

        let metadata = crate::types::metadata_from_arrays(
            [(actual_min as f64).log2(); 3],
            [(actual_max as f64).log2(); 3],
            [self.config.gamma as f64; 3],
            [self.config.base_offset as f64; 3],
            [self.config.alternate_offset as f64; 3],
            (self.config.base_hdr_headroom as f64).log2(),
            (self.config.alternate_hdr_headroom.max(actual_max) as f64).log2(),
            true,
            false,
        );

        Ok((gainmap, metadata))
    }

    /// Get progress info.
    pub fn progress(&self) -> (u32, u32) {
        (self.current_input_row, self.height)
    }

    /// Compute the next gainmap row directly into `self.gainmap_data`
    /// at offset `self.current_gm_row * self.gm_row_stride`.
    fn compute_gainmap_row_into_buffer(&mut self) {
        let gy = self.current_gm_row;
        let start = gy as usize * self.gm_row_stride;
        let end = start + self.gm_row_stride;

        let log_min = self.config.min_boost.ln();
        let log_max = self.config.max_boost.ln();
        let log_range = log_max - log_min;

        let mut min_boost = self.actual_min_boost;
        let mut max_boost = self.actual_max_boost;
        let multi = self.config.multi_channel;
        let scale = self.scale;
        let width = self.width;
        let height = self.height;
        let gm_width = self.gm_width;
        let hdr_gamut = self.hdr_gamut;
        let sdr_gamut = self.sdr_gamut;
        let config = &self.config;

        let row = &mut self.gainmap_data[start..end];
        for gx in 0..gm_width {
            let x = (gx * scale + scale / 2).min(width - 1);
            let y = (gy * scale + scale / 2).min(height - 1);

            let hdr_rgb = self.hdr_buffer.get_pixel(y, x).unwrap_or([0.5, 0.5, 0.5]);
            let sdr_rgb = self.sdr_buffer.get_pixel(y, x).unwrap_or([0.5, 0.5, 0.5]);

            if multi {
                for c in 0..3 {
                    row[gx as usize * 3 + c] = super::compute::compute_and_encode_gain(
                        hdr_rgb[c],
                        sdr_rgb[c],
                        config,
                        log_min,
                        log_range,
                        &mut min_boost,
                        &mut max_boost,
                    );
                }
            } else {
                let hdr_lum = rgb_to_luminance(hdr_rgb, hdr_gamut);
                let sdr_lum = rgb_to_luminance(sdr_rgb, sdr_gamut);
                row[gx as usize] = super::compute::compute_and_encode_gain(
                    hdr_lum,
                    sdr_lum,
                    config,
                    log_min,
                    log_range,
                    &mut min_boost,
                    &mut max_boost,
                );
            }
        }

        self.actual_min_boost = min_boost;
        self.actual_max_boost = max_boost;
    }
}

// ============================================================================
// Stream Encoder (independent HDR/SDR streams, linear f32 input)
// ============================================================================

/// Streaming gainmap encoder that accepts HDR and SDR rows independently.
///
/// Unlike [`RowEncoder`] which requires synchronized batches, this variant
/// allows feeding HDR and SDR rows from separate sources at different rates.
///
/// # Input Format
///
/// - HDR: Linear f32 RGB, 3 floats per pixel
/// - SDR: Linear f32 RGB, 3 floats per pixel
/// **Deprecated API surface** — slated for removal in 0.5.0. See
/// [`RowDecoder`] for rationale.
#[doc(hidden)]
#[derive(Debug)]
pub struct StreamEncoder {
    config: GainMapConfig,
    width: u32,
    height: u32,
    gm_width: u32,
    gm_height: u32,
    scale: u32,
    hdr_rows: LinearInputRingBuffer,
    sdr_rows: LinearInputRingBuffer,
    next_hdr_row: u32,
    next_sdr_row: u32,
    next_gm_row: u32,
    actual_min_boost: f32,
    actual_max_boost: f32,
    pending_gm_rows: Vec<Vec<u8>>,
    hdr_gamut: ColorPrimaries,
    sdr_gamut: ColorPrimaries,
}

/// Ring buffer for linear f32 input rows.
#[derive(Debug)]
struct LinearInputRingBuffer {
    rows: Vec<Vec<f32>>,
    first_row: u32,
    count: u32,
    row_floats: usize,
    capacity: u32,
}

impl LinearInputRingBuffer {
    fn new(row_floats: usize, capacity: u32) -> Self {
        Self {
            rows: vec![vec![0.0f32; row_floats]; capacity as usize],
            first_row: 0,
            count: 0,
            row_floats,
            capacity,
        }
    }

    fn push(&mut self, row_index: u32, data: &[f32]) {
        let slot = (row_index % self.capacity) as usize;
        let copy_len = data.len().min(self.row_floats);
        self.rows[slot][..copy_len].copy_from_slice(&data[..copy_len]);

        if self.count == 0 {
            self.first_row = row_index;
        }
        let new_last = row_index + 1;
        let new_first = new_last.saturating_sub(self.capacity);
        if new_first > self.first_row {
            self.first_row = new_first;
        }
        self.count = (new_last - self.first_row).min(self.capacity);
    }

    fn get(&self, row: u32) -> Option<&[f32]> {
        if self.count == 0 || row < self.first_row || row >= self.first_row + self.count {
            return None;
        }
        let slot = (row % self.capacity) as usize;
        Some(&self.rows[slot])
    }

    fn has_row(&self, row: u32) -> bool {
        self.count > 0 && row >= self.first_row && row < self.first_row + self.count
    }
}

impl StreamEncoder {
    /// Create a new streaming encoder.
    pub fn new(
        width: u32,
        height: u32,
        config: GainMapConfig,
        hdr_gamut: ColorPrimaries,
        sdr_gamut: ColorPrimaries,
    ) -> Result<Self> {
        let scale = config.scale_factor.max(1) as u32;
        let gm_width = width.div_ceil(scale);
        let gm_height = height.div_ceil(scale);

        let row_floats = width as usize * 3; // RGB
        let buffer_capacity = (scale + 16).min(32);

        Ok(Self {
            config,
            width,
            height,
            gm_width,
            gm_height,
            scale,
            hdr_rows: LinearInputRingBuffer::new(row_floats, buffer_capacity),
            sdr_rows: LinearInputRingBuffer::new(row_floats, buffer_capacity),
            next_hdr_row: 0,
            next_sdr_row: 0,
            next_gm_row: 0,
            actual_min_boost: f32::MAX,
            actual_max_boost: f32::MIN,
            pending_gm_rows: Vec::new(),
            hdr_gamut,
            sdr_gamut,
        })
    }

    /// Push HDR rows (linear f32 RGB) into the buffer.
    pub fn push_hdr_rows(&mut self, data: &[f32], num_rows: u32) -> Result<()> {
        let remaining = self.height - self.next_hdr_row;
        let actual = num_rows.min(remaining);
        let stride = self.width as usize * 3;

        for i in 0..actual {
            let start = i as usize * stride;
            let end = start + stride;
            if end > data.len() {
                return Err(Error::InvalidPixelData("HDR data too short".into()));
            }
            self.hdr_rows.push(self.next_hdr_row + i, &data[start..end]);
        }
        self.next_hdr_row += actual;

        self.try_produce_gainmap_rows();
        Ok(())
    }

    /// Push a single HDR row.
    pub fn push_hdr_row(&mut self, data: &[f32]) -> Result<()> {
        if self.next_hdr_row >= self.height {
            return Err(Error::InvalidPixelData(
                "all HDR rows already received".into(),
            ));
        }
        self.hdr_rows.push(self.next_hdr_row, data);
        self.next_hdr_row += 1;
        self.try_produce_gainmap_rows();
        Ok(())
    }

    /// Push SDR rows (linear f32 RGB) into the buffer.
    pub fn push_sdr_rows(&mut self, data: &[f32], num_rows: u32) -> Result<()> {
        let remaining = self.height - self.next_sdr_row;
        let actual = num_rows.min(remaining);
        let stride = self.width as usize * 3;

        for i in 0..actual {
            let start = i as usize * stride;
            let end = start + stride;
            if end > data.len() {
                return Err(Error::InvalidPixelData("SDR data too short".into()));
            }
            self.sdr_rows.push(self.next_sdr_row + i, &data[start..end]);
        }
        self.next_sdr_row += actual;

        self.try_produce_gainmap_rows();
        Ok(())
    }

    /// Push a single SDR row.
    pub fn push_sdr_row(&mut self, data: &[f32]) -> Result<()> {
        if self.next_sdr_row >= self.height {
            return Err(Error::InvalidPixelData(
                "all SDR rows already received".into(),
            ));
        }
        self.sdr_rows.push(self.next_sdr_row, data);
        self.next_sdr_row += 1;
        self.try_produce_gainmap_rows();
        Ok(())
    }

    /// Take a completed gainmap row if available.
    pub fn take_gainmap_row(&mut self) -> Option<Vec<u8>> {
        if self.pending_gm_rows.is_empty() {
            None
        } else {
            Some(self.pending_gm_rows.remove(0))
        }
    }

    /// Check how many gainmap rows are ready.
    pub fn pending_gainmap_rows(&self) -> usize {
        self.pending_gm_rows.len()
    }

    /// Try to produce gainmap rows from buffered data.
    fn try_produce_gainmap_rows(&mut self) {
        while self.next_gm_row < self.gm_height {
            let center_y = self.next_gm_row * self.scale + self.scale / 2;
            let center_y = center_y.min(self.height - 1);

            if !self.hdr_rows.has_row(center_y) || !self.sdr_rows.has_row(center_y) {
                break;
            }

            let gm_row = self.compute_gainmap_row(self.next_gm_row);
            self.pending_gm_rows.push(gm_row);
            self.next_gm_row += 1;
        }
    }

    /// Compute a single gainmap row.
    fn compute_gainmap_row(&mut self, gm_y: u32) -> Vec<u8> {
        let channels = if self.config.multi_channel { 3 } else { 1 };
        let mut row = vec![0u8; self.gm_width as usize * channels];

        let center_y = (gm_y * self.scale + self.scale / 2).min(self.height - 1);
        let hdr_row_data = self.hdr_rows.get(center_y);
        let sdr_row_data = self.sdr_rows.get(center_y);

        let log_min = self.config.min_boost.ln();
        let log_max = self.config.max_boost.ln();
        let log_range = log_max - log_min;

        for gx in 0..self.gm_width {
            let center_x = (gx * self.scale + self.scale / 2).min(self.width - 1);

            let hdr_rgb = self.get_pixel(hdr_row_data, center_x);
            let sdr_rgb = self.get_pixel(sdr_row_data, center_x);

            if self.config.multi_channel {
                #[allow(clippy::needless_range_loop)]
                for c in 0..3 {
                    row[gx as usize * 3 + c] = super::compute::compute_and_encode_gain(
                        hdr_rgb[c],
                        sdr_rgb[c],
                        &self.config,
                        log_min,
                        log_range,
                        &mut self.actual_min_boost,
                        &mut self.actual_max_boost,
                    );
                }
            } else {
                let hdr_lum = rgb_to_luminance(hdr_rgb, self.hdr_gamut);
                let sdr_lum = rgb_to_luminance(sdr_rgb, self.sdr_gamut);
                row[gx as usize] = super::compute::compute_and_encode_gain(
                    hdr_lum,
                    sdr_lum,
                    &self.config,
                    log_min,
                    log_range,
                    &mut self.actual_min_boost,
                    &mut self.actual_max_boost,
                );
            }
        }

        row
    }

    /// Get pixel from row data.
    fn get_pixel(&self, row: Option<&[f32]>, x: u32) -> [f32; 3] {
        match row {
            Some(r) => {
                let idx = x as usize * 3;
                if idx + 2 < r.len() {
                    [r[idx], r[idx + 1], r[idx + 2]]
                } else {
                    [0.5, 0.5, 0.5]
                }
            }
            None => [0.5, 0.5, 0.5],
        }
    }

    /// Finish encoding and return the gainmap and metadata.
    pub fn finish(mut self) -> Result<(GainMap, GainMapMetadata)> {
        let mut all_rows = Vec::new();
        all_rows.append(&mut self.pending_gm_rows);

        if all_rows.len() != self.gm_height as usize {
            return Err(Error::InvalidPixelData(format!(
                "incomplete gainmap: {} of {} rows",
                all_rows.len(),
                self.gm_height
            )));
        }

        let channels = if self.config.multi_channel { 3u8 } else { 1u8 };
        let row_bytes = self.gm_width as usize * channels as usize;
        let mut data = Vec::with_capacity(row_bytes * self.gm_height as usize);

        for row in all_rows {
            data.extend_from_slice(&row);
        }

        let gainmap = GainMap {
            width: self.gm_width,
            height: self.gm_height,
            channels,
            data,
        };

        let actual_max = if self.actual_max_boost > f32::MIN {
            self.actual_max_boost
        } else {
            self.config.max_boost
        };
        let actual_min = if self.actual_min_boost < f32::MAX {
            self.actual_min_boost
        } else {
            self.config.min_boost
        };

        let metadata = crate::types::metadata_from_arrays(
            [(actual_min as f64).log2(); 3],
            [(actual_max as f64).log2(); 3],
            [self.config.gamma as f64; 3],
            [self.config.base_offset as f64; 3],
            [self.config.alternate_offset as f64; 3],
            0.0, // log2(1.0) = 0
            (actual_max as f64).log2(),
            true,
            false,
        );

        Ok((gainmap, metadata))
    }

    /// Check if all input rows have been received.
    pub fn inputs_complete(&self) -> bool {
        self.next_hdr_row >= self.height && self.next_sdr_row >= self.height
    }

    /// Check if encoding is complete.
    pub fn is_complete(&self) -> bool {
        self.next_gm_row >= self.gm_height && self.pending_gm_rows.is_empty()
    }

    /// Get remaining HDR rows to receive.
    pub fn hdr_rows_remaining(&self) -> u32 {
        self.height - self.next_hdr_row
    }

    /// Get remaining SDR rows to receive.
    pub fn sdr_rows_remaining(&self) -> u32 {
        self.height - self.next_sdr_row
    }

    /// Get remaining gainmap rows to produce.
    pub fn gainmap_rows_remaining(&self) -> u32 {
        self.gm_height - self.next_gm_row
    }
}

// ============================================================================
// Helper Functions
// ============================================================================

/// Sample one row of per-channel gains from a gain-map ring buffer.
///
/// Mirrors `super::apply::sample_gainmap_row_lut` but sources bytes from a
/// `GainMapRingBuffer` instead of an owned `GainMap`. Bilinear-interpolates
/// byte values across the two nearest gain-map rows, then looks up each
/// byte in `GainMapLut` once.
#[allow(clippy::too_many_arguments)]
fn sample_gainmap_row_ring(
    gm_buffer: &GainMapRingBuffer,
    lut: &super::apply::GainMapLut,
    gm_channels: u8,
    y: u32,
    sdr_width: u32,
    sdr_height: u32,
    gm_width: u32,
    gm_height: u32,
    out: &mut [[f32; 3]],
) {
    debug_assert_eq!(out.len(), sdr_width as usize);
    let gm_y = (y as f32 / sdr_height as f32) * gm_height as f32;
    let y0 = (gm_y.floor() as u32).min(gm_height - 1);
    let y1 = (y0 + 1).min(gm_height - 1);
    let fy = gm_y - gm_y.floor();
    let row0 = gm_buffer.get(y0);
    let row1 = gm_buffer.get(y1);

    for (x, gain_out) in out.iter_mut().enumerate() {
        let gm_x = (x as f32 / sdr_width as f32) * gm_width as f32;
        let x0 = (gm_x.floor() as u32).min(gm_width - 1);
        let x1 = (x0 + 1).min(gm_width - 1);
        let fx = gm_x - gm_x.floor();

        if gm_channels == 1 {
            let v00 = StreamDecoder::sample_row_gray(row0, x0);
            let v10 = StreamDecoder::sample_row_gray(row0, x1);
            let v01 = StreamDecoder::sample_row_gray(row1, x0);
            let v11 = StreamDecoder::sample_row_gray(row1, x1);
            let v = bilinear(v00, v10, v01, v11, fx, fy);
            let byte = (v * 255.0).round().clamp(0.0, 255.0) as u8;
            let g = lut.lookup(byte, 0);
            *gain_out = [g, g, g];
        } else {
            for (c, dst) in gain_out.iter_mut().enumerate() {
                let v00 = StreamDecoder::sample_row_rgb(row0, x0, c);
                let v10 = StreamDecoder::sample_row_rgb(row0, x1, c);
                let v01 = StreamDecoder::sample_row_rgb(row1, x0, c);
                let v11 = StreamDecoder::sample_row_rgb(row1, x1, c);
                let v = bilinear(v00, v10, v01, v11, fx, fy);
                let byte = (v * 255.0).round().clamp(0.0, 255.0) as u8;
                *dst = lut.lookup(byte, c);
            }
        }
    }
}

/// Bilinear interpolation helper (used by `sample_gainmap_row_ring`).
#[inline]
fn bilinear(v00: f32, v10: f32, v01: f32, v11: f32, fx: f32, fy: f32) -> f32 {
    let top = v00 * (1.0 - fx) + v10 * fx;
    let bottom = v01 * (1.0 - fx) + v11 * fx;
    top * (1.0 - fy) + bottom * fy
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_row_decoder_linear_f32() {
        let mut gainmap = GainMap::new(2, 2).unwrap();
        for v in &mut gainmap.data {
            *v = 128;
        }

        let metadata = crate::types::metadata_from_arrays(
            [0.0; 3],
            [2.0; 3],
            [1.0; 3],
            [0.015625; 3],
            [0.015625; 3],
            0.0,
            2.0,
            true,
            false,
        );

        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 4.0, ColorPrimaries::Bt709).unwrap();

        // Linear f32 RGB input (mid-gray = 0.18)
        let sdr_linear = vec![0.18f32; 4 * 3]; // One row, 4 pixels, RGB
        let hdr = decoder.process_row(&sdr_linear).unwrap();

        // Output is RGBA f32
        assert_eq!(hdr.len(), 4 * 4); // 4 pixels × 4 floats
        assert!(hdr[0] > 0.0); // Non-zero output
    }

    #[test]
    fn test_row_encoder_linear_f32() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            RowEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        // HDR brighter than SDR (both linear f32)
        let hdr_linear = vec![0.5f32; 4 * 3]; // Brighter
        let sdr_linear = vec![0.18f32; 4 * 3]; // Mid-gray

        for _ in 0..4 {
            let _ = encoder.process_row(&hdr_linear, &sdr_linear).unwrap();
        }

        let (gainmap, metadata) = encoder.finish().unwrap();
        assert_eq!(gainmap.width, 2);
        assert_eq!(gainmap.height, 2);
        assert!(metadata.channels[0].max >= 1.0);
    }

    #[test]
    fn test_stream_encoder_linear_f32() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            StreamEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        let hdr_linear = vec![0.5f32; 4 * 3];
        let sdr_linear = vec![0.18f32; 4 * 3];

        for _ in 0..4 {
            encoder.push_hdr_row(&hdr_linear).unwrap();
            encoder.push_sdr_row(&sdr_linear).unwrap();
        }

        // DON'T drain pending rows before finish() - let finish() collect them
        let (gainmap, _) = encoder.finish().unwrap();
        assert_eq!(gainmap.width, 2);
        assert_eq!(gainmap.height, 2);
    }

    /// Helper: standard metadata used across tests.
    fn test_metadata() -> GainMapMetadata {
        // log2(1.0)=0.0, log2(4.0)=2.0
        crate::types::metadata_from_arrays(
            [0.0; 3],
            [2.0; 3],
            [1.0; 3],
            [0.015625; 3],
            [0.015625; 3],
            0.0,
            2.0,
            true,
            false,
        )
    }

    /// Helper: 2x2 gainmap filled with a constant byte value.
    fn test_gainmap(value: u8) -> GainMap {
        let mut gm = GainMap::new(2, 2).unwrap();
        for v in &mut gm.data {
            *v = value;
        }
        gm
    }

    #[test]
    fn test_row_decoder_completion() {
        let gainmap = test_gainmap(128);
        let metadata = test_metadata();

        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 4.0, ColorPrimaries::Bt709).unwrap();

        assert!(!decoder.is_complete());
        assert_eq!(decoder.rows_remaining(), 4);

        let sdr_row = vec![0.18f32; 4 * 3];
        for i in 0..4u32 {
            assert!(!decoder.is_complete());
            assert_eq!(decoder.rows_remaining(), 4 - i);
            assert_eq!(decoder.current_row(), i);
            let hdr = decoder.process_row(&sdr_row).unwrap();
            assert_eq!(hdr.len(), 4 * 4); // RGBA
        }

        assert!(decoder.is_complete());
        assert_eq!(decoder.rows_remaining(), 0);
        assert_eq!(decoder.current_row(), 4);
    }

    #[test]
    fn test_row_decoder_reset() {
        let gainmap = test_gainmap(128);
        let metadata = test_metadata();

        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 4.0, ColorPrimaries::Bt709).unwrap();

        let sdr_row = vec![0.18f32; 4 * 3];

        // Process 2 rows
        decoder.process_row(&sdr_row).unwrap();
        decoder.process_row(&sdr_row).unwrap();
        assert_eq!(decoder.current_row(), 2);
        assert_eq!(decoder.rows_remaining(), 2);

        // Reset
        decoder.reset();
        assert_eq!(decoder.current_row(), 0);
        assert_eq!(decoder.rows_remaining(), 4);
        assert!(!decoder.is_complete());

        // Can reprocess from the beginning
        let hdr = decoder.process_row(&sdr_row).unwrap();
        assert_eq!(hdr.len(), 4 * 4);
        assert_eq!(decoder.current_row(), 1);
    }

    #[test]
    fn test_row_decoder_input_too_short() {
        let gainmap = test_gainmap(128);
        let metadata = test_metadata();

        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 4.0, ColorPrimaries::Bt709).unwrap();

        // Only 2 pixels worth of data (6 floats) instead of 4 pixels (12 floats)
        let short_input = vec![0.18f32; 2 * 3];
        let result = decoder.process_row(&short_input);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(
            err_msg.contains("too short"),
            "expected 'too short' in error: {err_msg}"
        );
    }

    #[test]
    fn test_row_decoder_after_complete() {
        let gainmap = test_gainmap(128);
        let metadata = test_metadata();

        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 4.0, ColorPrimaries::Bt709).unwrap();

        let sdr_row = vec![0.18f32; 4 * 3];
        for _ in 0..4 {
            decoder.process_row(&sdr_row).unwrap();
        }
        assert!(decoder.is_complete());

        // Another row should error
        let result = decoder.process_row(&sdr_row);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(
            err_msg.contains("already processed"),
            "expected 'already processed' in error: {err_msg}"
        );
    }

    #[test]
    fn test_stream_decoder_basic() {
        let metadata = test_metadata();

        // SDR: 4x4, gainmap: 2x2, 1 channel
        let mut decoder =
            StreamDecoder::new(metadata.clone(), 4, 4, 2, 2, 1, 4.0, ColorPrimaries::Bt709)
                .unwrap();

        assert!(!decoder.is_complete());
        assert_eq!(decoder.sdr_rows_remaining(), 4);
        assert_eq!(decoder.gainmap_rows_remaining(), 2);

        // Push all gainmap rows first (2 rows, each 2 bytes for 2×1-channel)
        let gm_row = vec![128u8; 2];
        decoder.push_gainmap_row(&gm_row).unwrap();
        decoder.push_gainmap_row(&gm_row).unwrap();
        assert_eq!(decoder.gainmap_rows_remaining(), 0);

        // Now push SDR rows and get HDR output
        let sdr_row = vec![0.18f32; 4 * 3];
        for _ in 0..4 {
            assert!(decoder.can_process(1));
            let hdr = decoder.process_sdr_rows(&sdr_row, 1).unwrap();
            assert_eq!(hdr.len(), 4 * 4); // 4 pixels × RGBA
            // Output values should be positive
            for &v in &hdr {
                assert!(v >= 0.0, "HDR output should be non-negative, got {v}");
            }
        }

        assert!(decoder.is_complete());
        assert_eq!(decoder.sdr_rows_remaining(), 0);
    }

    #[test]
    fn test_row_encoder_process_rows_batch() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            RowEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        // Provide all 4 rows at once
        let hdr_linear = vec![0.5f32; 4 * 4 * 3]; // 4 rows × 4 pixels × RGB
        let sdr_linear = vec![0.18f32; 4 * 4 * 3];

        let gm_rows = encoder.process_rows(&hdr_linear, &sdr_linear, 4).unwrap();

        // With scale_factor=2 and height=4, gm_height=2
        // After providing all 4 input rows, both gainmap rows should be produced
        let (current, total) = encoder.progress();
        assert_eq!(total, 4);
        assert_eq!(current, 4);

        let (gainmap, metadata) = encoder.finish().unwrap();
        assert_eq!(gainmap.width, 2);
        assert_eq!(gainmap.height, 2);
        assert!(metadata.channels[0].max >= 1.0);
        // The batch call should have produced the same number of gm rows
        // as the total gm height (2), since all input was provided at once.
        assert_eq!(gm_rows.len(), 2);
    }

    #[test]
    fn test_stream_encoder_status_methods() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            StreamEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        // Initial state
        assert_eq!(encoder.hdr_rows_remaining(), 4);
        assert_eq!(encoder.sdr_rows_remaining(), 4);
        assert!(!encoder.inputs_complete());
        assert!(!encoder.is_complete());

        let hdr_row = vec![0.5f32; 4 * 3];
        let sdr_row = vec![0.18f32; 4 * 3];

        // Push 2 HDR rows
        encoder.push_hdr_row(&hdr_row).unwrap();
        encoder.push_hdr_row(&hdr_row).unwrap();
        assert_eq!(encoder.hdr_rows_remaining(), 2);
        assert_eq!(encoder.sdr_rows_remaining(), 4);
        assert!(!encoder.inputs_complete());

        // Push 2 SDR rows
        encoder.push_sdr_row(&sdr_row).unwrap();
        encoder.push_sdr_row(&sdr_row).unwrap();
        assert_eq!(encoder.sdr_rows_remaining(), 2);
        assert!(!encoder.inputs_complete());

        // Push remaining rows
        encoder.push_hdr_row(&hdr_row).unwrap();
        encoder.push_hdr_row(&hdr_row).unwrap();
        encoder.push_sdr_row(&sdr_row).unwrap();
        encoder.push_sdr_row(&sdr_row).unwrap();

        assert_eq!(encoder.hdr_rows_remaining(), 0);
        assert_eq!(encoder.sdr_rows_remaining(), 0);
        assert!(encoder.inputs_complete());
        // All gainmap rows should have been produced and are pending
        assert_eq!(encoder.gainmap_rows_remaining(), 0);
    }

    #[test]
    fn test_stream_encoder_interleaved() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            StreamEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        let hdr_row = vec![0.5f32; 4 * 3];
        let sdr_row = vec![0.18f32; 4 * 3];
        let mut total_gm_rows = 0;

        // Interleave HDR and SDR rows
        for _ in 0..4 {
            encoder.push_hdr_row(&hdr_row).unwrap();
            encoder.push_sdr_row(&sdr_row).unwrap();
            // Check for pending gainmap rows after each pair
            while let Some(gm_row) = encoder.take_gainmap_row() {
                total_gm_rows += 1;
                // Gainmap width is 4/2=2, single-channel, so row is 2 bytes
                assert_eq!(gm_row.len(), 2);
            }
        }

        // gm_height = ceil(4/2) = 2, so we should get exactly 2 gainmap rows total
        assert_eq!(total_gm_rows, 2);
        assert!(encoder.inputs_complete());
    }

    #[test]
    fn test_stream_encoder_drain_pending() {
        let config = GainMapConfig {
            scale_factor: 2,
            ..Default::default()
        };

        let mut encoder =
            StreamEncoder::new(4, 4, config, ColorPrimaries::Bt709, ColorPrimaries::Bt709).unwrap();

        let hdr_row = vec![0.5f32; 4 * 3];
        let sdr_row = vec![0.18f32; 4 * 3];

        // Push all rows without draining
        for _ in 0..4 {
            encoder.push_hdr_row(&hdr_row).unwrap();
            encoder.push_sdr_row(&sdr_row).unwrap();
        }

        // Now drain all pending gainmap rows using take_gainmap_row
        assert!(encoder.pending_gainmap_rows() > 0);
        let mut drained = Vec::new();
        while let Some(row) = encoder.take_gainmap_row() {
            drained.push(row);
        }

        // gm_height = ceil(4/2) = 2
        assert_eq!(drained.len(), 2);
        assert_eq!(encoder.pending_gainmap_rows(), 0);

        // Each gainmap row should be 2 bytes (gm_width=2, 1 channel)
        for row in &drained {
            assert_eq!(row.len(), 2);
        }
    }

    #[test]
    fn test_row_decoder_boost_1() {
        let gainmap = test_gainmap(128);
        let metadata = test_metadata();

        // display_boost=1.0 means weight=0 → gain should be exp(0)=1.0 for all pixels
        let mut decoder =
            RowDecoder::new(gainmap, metadata, 4, 4, 1.0, ColorPrimaries::Bt709).unwrap();

        let sdr_val = 0.5f32;
        let sdr_row = vec![sdr_val; 4 * 3];
        let hdr = decoder.process_row(&sdr_row).unwrap();

        // With weight=0 (display_boost=1.0, hdr_capacity_min=1.0), gain = exp(0) = 1.0
        // apply_gain: (sdr + offset_sdr) * gain - offset_hdr
        // With offset_sdr=offset_hdr=0.015625 and gain=1.0:
        //   output = (0.5 + 0.015625) * 1.0 - 0.015625 = 0.5
        // So output should be very close to input
        for px in 0..4 {
            let r = hdr[px * 4];
            let g = hdr[px * 4 + 1];
            let b = hdr[px * 4 + 2];
            let a = hdr[px * 4 + 3];

            assert!(
                (r - sdr_val).abs() < 0.01,
                "R at pixel {px}: expected ~{sdr_val}, got {r}"
            );
            assert!(
                (g - sdr_val).abs() < 0.01,
                "G at pixel {px}: expected ~{sdr_val}, got {g}"
            );
            assert!(
                (b - sdr_val).abs() < 0.01,
                "B at pixel {px}: expected ~{sdr_val}, got {b}"
            );
            assert!(
                (a - 1.0).abs() < f32::EPSILON,
                "A at pixel {px}: expected 1.0, got {a}"
            );
        }
    }
}