edgefirst_image/

cpu.rs

// SPDX-FileCopyrightText: Copyright 2025 Au-Zone Technologies
// SPDX-License-Identifier: Apache-2.0

use crate::{
    fourcc_is_int8, fourcc_uint8_equivalent, Crop, Error, Flip, FunctionTimer, ImageProcessorTrait,
    Rect, Result, Rotation, TensorImage, TensorImageDst, TensorImageRef, BGRA, GREY, NV12, NV16,
    PLANAR_RGB, PLANAR_RGBA, RGB, RGBA, VYUY, YUYV,
};
use edgefirst_decoder::{DetectBox, ProtoData, Segmentation};
use edgefirst_tensor::{TensorMapTrait, TensorTrait};
use four_char_code::FourCharCode;
use ndarray::{ArrayView3, ArrayViewMut3, Axis};
use rayon::iter::{
    IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator,
};
use std::ops::Shr;

/// CPUConverter implements the ImageProcessor trait using the fallback CPU
/// implementation for image processing.
#[derive(Debug, Clone)]
pub struct CPUProcessor {
    resizer: fast_image_resize::Resizer,
    options: fast_image_resize::ResizeOptions,
    colors: [[u8; 4]; 20],
}

unsafe impl Send for CPUProcessor {}
unsafe impl Sync for CPUProcessor {}

#[inline(always)]
fn limit_to_full(l: u8) -> u8 {
    (((l as u16 - 16) * 255 + (240 - 16) / 2) / (240 - 16)) as u8
}

#[inline(always)]
fn full_to_limit(l: u8) -> u8 {
    ((l as u16 * (240 - 16) + 255 / 2) / 255 + 16) as u8
}

impl Default for CPUProcessor {
    fn default() -> Self {
        Self::new_bilinear()
    }
}

impl CPUProcessor {
    /// Creates a new CPUConverter with bilinear resizing.
    pub fn new() -> Self {
        Self::new_bilinear()
    }

    /// Creates a new CPUConverter with bilinear resizing.
    fn new_bilinear() -> Self {
        let resizer = fast_image_resize::Resizer::new();
        let options = fast_image_resize::ResizeOptions::new()
            .resize_alg(fast_image_resize::ResizeAlg::Convolution(
                fast_image_resize::FilterType::Bilinear,
            ))
            .use_alpha(false);

        log::debug!("CPUConverter created");
        Self {
            resizer,
            options,
            colors: crate::DEFAULT_COLORS_U8,
        }
    }

    /// Creates a new CPUConverter with nearest neighbor resizing.
    pub fn new_nearest() -> Self {
        let resizer = fast_image_resize::Resizer::new();
        let options = fast_image_resize::ResizeOptions::new()
            .resize_alg(fast_image_resize::ResizeAlg::Nearest)
            .use_alpha(false);
        log::debug!("CPUConverter created");
        Self {
            resizer,
            options,
            colors: crate::DEFAULT_COLORS_U8,
        }
    }

    pub(crate) fn flip_rotate_ndarray(
        src_map: &[u8],
        dst_map: &mut [u8],
        dst: &TensorImage,
        rotation: Rotation,
        flip: Flip,
    ) -> Result<(), crate::Error> {
        let mut dst_view =
            ArrayViewMut3::from_shape((dst.height(), dst.width(), dst.channels()), dst_map)?;
        let mut src_view = match rotation {
            Rotation::None | Rotation::Rotate180 => {
                ArrayView3::from_shape((dst.height(), dst.width(), dst.channels()), src_map)?
            }
            Rotation::Clockwise90 | Rotation::CounterClockwise90 => {
                ArrayView3::from_shape((dst.width(), dst.height(), dst.channels()), src_map)?
            }
        };

        match flip {
            Flip::None => {}
            Flip::Vertical => {
                src_view.invert_axis(Axis(0));
            }
            Flip::Horizontal => {
                src_view.invert_axis(Axis(1));
            }
        }

        match rotation {
            Rotation::None => {}
            Rotation::Clockwise90 => {
                src_view.swap_axes(0, 1);
                src_view.invert_axis(Axis(1));
            }
            Rotation::Rotate180 => {
                src_view.invert_axis(Axis(0));
                src_view.invert_axis(Axis(1));
            }
            Rotation::CounterClockwise90 => {
                src_view.swap_axes(0, 1);
                src_view.invert_axis(Axis(0));
            }
        }

        dst_view.assign(&src_view);

        Ok(())
    }

    fn convert_nv12_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), NV12);
        assert_eq!(dst.fourcc(), RGB);
        let map = src.tensor.map()?;
        let y_stride = src.width() as u32;
        let uv_stride = src.width() as u32;
        let slices = map.as_slice().split_at(y_stride as usize * src.height());

        let src = yuv::YuvBiPlanarImage {
            y_plane: slices.0,
            y_stride,
            uv_plane: slices.1,
            uv_stride,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuv_nv12_to_rgb(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    // NOTE: The `*_to_rgba` helpers below all accept BGRA destinations
    // (`assert!(matches!(dst.fourcc(), RGBA | BGRA))`). They always write
    // pixels in RGBA channel order; for BGRA destinations the caller applies
    // an R↔B swizzle afterwards via `swizzle_rb_4chan`.
    fn convert_nv12_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), NV12);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));
        let map = src.tensor.map()?;
        let y_stride = src.width() as u32;
        let uv_stride = src.width() as u32;
        let slices = map.as_slice().split_at(y_stride as usize * src.height());

        let src = yuv::YuvBiPlanarImage {
            y_plane: slices.0,
            y_stride,
            uv_plane: slices.1,
            uv_stride,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuv_nv12_to_rgba(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    fn convert_nv12_to_grey(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), NV12);
        assert_eq!(dst.fourcc(), GREY);
        let src_map = src.tensor.map()?;
        let mut dst_map = dst.tensor.map()?;
        let y_stride = src.width() as u32;
        let y_slice = src_map
            .as_slice()
            .split_at(y_stride as usize * src.height())
            .0;
        let src_chunks = y_slice.as_chunks::<8>();
        let dst_chunks = dst_map.as_chunks_mut::<8>();
        for (s, d) in src_chunks.0.iter().zip(dst_chunks.0) {
            s.iter().zip(d).for_each(|(s, d)| *d = limit_to_full(*s));
        }

        for (s, d) in src_chunks.1.iter().zip(dst_chunks.1) {
            *d = limit_to_full(*s);
        }

        Ok(())
    }

    fn convert_yuyv_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert_eq!(dst.fourcc(), RGB);
        let src = yuv::YuvPackedImage::<u8> {
            yuy: &src.tensor.map()?,
            yuy_stride: src.row_stride() as u32, // we assume packed yuyv
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuyv422_to_rgb(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.width() as u32 * 3,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_yuyv_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));
        let src = yuv::YuvPackedImage::<u8> {
            yuy: &src.tensor.map()?,
            yuy_stride: src.row_stride() as u32, // we assume packed yuyv
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuyv422_to_rgba(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_yuyv_to_8bps(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert_eq!(dst.fourcc(), PLANAR_RGB);
        let mut tmp = TensorImage::new(src.width(), src.height(), RGB, None)?;
        Self::convert_yuyv_to_rgb(src, &mut tmp)?;
        Self::convert_rgb_to_8bps(&tmp, dst)
    }

    fn convert_yuyv_to_prgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert_eq!(dst.fourcc(), PLANAR_RGBA);
        let mut tmp = TensorImage::new(src.width(), src.height(), RGB, None)?;
        Self::convert_yuyv_to_rgb(src, &mut tmp)?;
        Self::convert_rgb_to_prgba(&tmp, dst)
    }

    fn convert_yuyv_to_grey(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert_eq!(dst.fourcc(), GREY);
        let src_map = src.tensor.map()?;
        let mut dst_map = dst.tensor.map()?;
        let src_chunks = src_map.as_chunks::<16>();
        let dst_chunks = dst_map.as_chunks_mut::<8>();
        for (s, d) in src_chunks.0.iter().zip(dst_chunks.0) {
            s.iter()
                .step_by(2)
                .zip(d)
                .for_each(|(s, d)| *d = limit_to_full(*s));
        }

        for (s, d) in src_chunks.1.iter().step_by(2).zip(dst_chunks.1) {
            *d = limit_to_full(*s);
        }

        Ok(())
    }

    fn convert_yuyv_to_nv16(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), YUYV);
        assert_eq!(dst.fourcc(), NV16);
        let src_map = src.tensor.map()?;
        let mut dst_map = dst.tensor.map()?;

        let src_chunks = src_map.as_chunks::<2>().0;
        let (y_plane, uv_plane) = dst_map.split_at_mut(dst.row_stride() * dst.height());

        for ((s, y), uv) in src_chunks.iter().zip(y_plane).zip(uv_plane) {
            *y = s[0];
            *uv = s[1];
        }
        Ok(())
    }

    fn convert_vyuy_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert_eq!(dst.fourcc(), RGB);
        let src = yuv::YuvPackedImage::<u8> {
            yuy: &src.tensor.map()?,
            yuy_stride: src.row_stride() as u32,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::vyuy422_to_rgb(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.width() as u32 * 3,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_vyuy_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));
        let src = yuv::YuvPackedImage::<u8> {
            yuy: &src.tensor.map()?,
            yuy_stride: src.row_stride() as u32,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::vyuy422_to_rgba(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_vyuy_to_8bps(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert_eq!(dst.fourcc(), PLANAR_RGB);
        let mut tmp = TensorImage::new(src.width(), src.height(), RGB, None)?;
        Self::convert_vyuy_to_rgb(src, &mut tmp)?;
        Self::convert_rgb_to_8bps(&tmp, dst)
    }

    fn convert_vyuy_to_prgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert_eq!(dst.fourcc(), PLANAR_RGBA);
        let mut tmp = TensorImage::new(src.width(), src.height(), RGB, None)?;
        Self::convert_vyuy_to_rgb(src, &mut tmp)?;
        Self::convert_rgb_to_prgba(&tmp, dst)
    }

    fn convert_vyuy_to_grey(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert_eq!(dst.fourcc(), GREY);
        let src_map = src.tensor.map()?;
        let mut dst_map = dst.tensor.map()?;
        // VYUY byte order: [V, Y0, U, Y1] — Y at offsets 1, 3
        let src_chunks = src_map.as_chunks::<16>();
        let dst_chunks = dst_map.as_chunks_mut::<8>();
        for (s, d) in src_chunks.0.iter().zip(dst_chunks.0) {
            for (di, si) in (1..16).step_by(2).enumerate() {
                d[di] = limit_to_full(s[si]);
            }
        }

        for (di, si) in (1..src_chunks.1.len()).step_by(2).enumerate() {
            dst_chunks.1[di] = limit_to_full(src_chunks.1[si]);
        }

        Ok(())
    }

    fn convert_vyuy_to_nv16(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), VYUY);
        assert_eq!(dst.fourcc(), NV16);
        let src_map = src.tensor.map()?;
        let mut dst_map = dst.tensor.map()?;

        // VYUY byte order: [V, Y0, U, Y1] — per 4-byte macropixel
        let src_chunks = src_map.as_chunks::<4>().0;
        let (y_plane, uv_plane) = dst_map.split_at_mut(dst.row_stride() * dst.height());
        let y_pairs = y_plane.as_chunks_mut::<2>().0;
        let uv_pairs = uv_plane.as_chunks_mut::<2>().0;

        for ((s, y), uv) in src_chunks.iter().zip(y_pairs).zip(uv_pairs) {
            y[0] = s[1]; // Y0
            y[1] = s[3]; // Y1
            uv[0] = s[2]; // U
            uv[1] = s[0]; // V
        }
        Ok(())
    }

    fn convert_grey_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert_eq!(dst.fourcc(), RGB);
        let src = yuv::YuvGrayImage::<u8> {
            y_plane: &src.tensor.map()?,
            y_stride: src.row_stride() as u32, // we assume packed Y
            width: src.width() as u32,
            height: src.height() as u32,
        };
        Ok(yuv::yuv400_to_rgb(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Full,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_grey_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));
        let src = yuv::YuvGrayImage::<u8> {
            y_plane: &src.tensor.map()?,
            y_stride: src.row_stride() as u32,
            width: src.width() as u32,
            height: src.height() as u32,
        };
        Ok(yuv::yuv400_to_rgba(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Full,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_grey_to_8bps(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert_eq!(dst.fourcc(), PLANAR_RGB);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());

        rayon::scope(|s| {
            s.spawn(|_| dst0.copy_from_slice(src));
            s.spawn(|_| dst1.copy_from_slice(src));
            s.spawn(|_| dst2.copy_from_slice(src));
        });
        Ok(())
    }

    fn convert_grey_to_prgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert_eq!(dst.fourcc(), PLANAR_RGBA);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());
        let (dst2, dst3) = dst2.split_at_mut(dst.width() * dst.height());
        rayon::scope(|s| {
            s.spawn(|_| dst0.copy_from_slice(src));
            s.spawn(|_| dst1.copy_from_slice(src));
            s.spawn(|_| dst2.copy_from_slice(src));
            s.spawn(|_| dst3.fill(255));
        });
        Ok(())
    }

    fn convert_grey_to_yuyv(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert_eq!(dst.fourcc(), YUYV);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst = dst.tensor().map()?;
        let dst = dst.as_mut_slice();
        for (s, d) in src
            .as_chunks::<2>()
            .0
            .iter()
            .zip(dst.as_chunks_mut::<4>().0.iter_mut())
        {
            d[0] = full_to_limit(s[0]);
            d[1] = 128;

            d[2] = full_to_limit(s[1]);
            d[3] = 128;
        }
        Ok(())
    }

    fn convert_grey_to_nv16(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), GREY);
        assert_eq!(dst.fourcc(), NV16);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst = dst.tensor().map()?;
        let dst = dst.as_mut_slice();

        for (s, d) in src.iter().zip(dst[0..src.len()].iter_mut()) {
            *d = full_to_limit(*s);
        }
        dst[src.len()..].fill(128);

        Ok(())
    }

    fn convert_rgba_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), RGB);

        Ok(yuv::rgba_to_rgb(
            src.tensor.map()?.as_slice(),
            (src.width() * src.channels()) as u32,
            dst.tensor.map()?.as_mut_slice(),
            (dst.width() * dst.channels()) as u32,
            src.width() as u32,
            src.height() as u32,
        )?)
    }

    fn convert_rgba_to_grey(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), GREY);

        let mut dst = yuv::YuvGrayImageMut::<u8> {
            y_plane: yuv::BufferStoreMut::Borrowed(&mut dst.tensor.map()?),
            y_stride: dst.row_stride() as u32,
            width: dst.width() as u32,
            height: dst.height() as u32,
        };
        Ok(yuv::rgba_to_yuv400(
            &mut dst,
            src.tensor.map()?.as_slice(),
            src.row_stride() as u32,
            yuv::YuvRange::Full,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_rgba_to_8bps(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), PLANAR_RGB);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<4>().0;

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());

        src.par_iter()
            .zip_eq(dst0)
            .zip_eq(dst1)
            .zip_eq(dst2)
            .for_each(|(((s, d0), d1), d2)| {
                *d0 = s[0];
                *d1 = s[1];
                *d2 = s[2];
            });
        Ok(())
    }

    fn convert_rgba_to_prgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), PLANAR_RGBA);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<4>().0;

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());
        let (dst2, dst3) = dst2.split_at_mut(dst.width() * dst.height());

        src.par_iter()
            .zip_eq(dst0)
            .zip_eq(dst1)
            .zip_eq(dst2)
            .zip_eq(dst3)
            .for_each(|((((s, d0), d1), d2), d3)| {
                *d0 = s[0];
                *d1 = s[1];
                *d2 = s[2];
                *d3 = s[3];
            });
        Ok(())
    }

    fn convert_rgba_to_yuyv(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), YUYV);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst = dst.tensor().map()?;
        let dst = dst.as_mut_slice();

        // compute quantized Bt.709 limited range RGB to YUV matrix
        const KR: f64 = 0.2126f64;
        const KB: f64 = 0.0722f64;
        const KG: f64 = 1.0 - KR - KB;
        const BIAS: i32 = 20;

        const Y_R: i32 = (KR * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_G: i32 = (KG * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_B: i32 = (KB * (219 << BIAS) as f64 / 255.0).round() as i32;

        const U_R: i32 = (-KR / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_G: i32 = (-KG / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_B: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;

        const V_R: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;
        const V_G: i32 = (-KG / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const V_B: i32 = (-KB / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const ROUND: i32 = 1 << (BIAS - 1);
        const ROUND2: i32 = 1 << BIAS;
        let process_rgba_to_yuyv = |s: &[u8; 8], d: &mut [u8; 4]| {
            let [r0, g0, b0, _, r1, g1, b1, _] = *s;
            let r0 = r0 as i32;
            let g0 = g0 as i32;
            let b0 = b0 as i32;
            let r1 = r1 as i32;
            let g1 = g1 as i32;
            let b1 = b1 as i32;
            d[0] = ((Y_R * r0 + Y_G * g0 + Y_B * b0 + ROUND).shr(BIAS) + 16) as u8;
            d[1] = ((U_R * r0 + U_G * g0 + U_B * b0 + U_R * r1 + U_G * g1 + U_B * b1 + ROUND2)
                .shr(BIAS + 1)
                + 128) as u8;
            d[2] = ((Y_R * r1 + Y_G * g1 + Y_B * b1 + ROUND).shr(BIAS) + 16) as u8;
            d[3] = ((V_R * r0 + V_G * g0 + V_B * b0 + V_R * r1 + V_G * g1 + V_B * b1 + ROUND2)
                .shr(BIAS + 1)
                + 128) as u8;
        };

        let src = src.as_chunks::<{ 8 * 32 }>();
        let dst = dst.as_chunks_mut::<{ 4 * 32 }>();

        for (s, d) in src.0.iter().zip(dst.0.iter_mut()) {
            let s = s.as_chunks::<8>().0;
            let d = d.as_chunks_mut::<4>().0;
            for (s, d) in s.iter().zip(d.iter_mut()) {
                process_rgba_to_yuyv(s, d);
            }
        }

        let s = src.1.as_chunks::<8>().0;
        let d = dst.1.as_chunks_mut::<4>().0;
        for (s, d) in s.iter().zip(d.iter_mut()) {
            process_rgba_to_yuyv(s, d);
        }

        Ok(())
    }

    fn convert_rgba_to_nv16(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), NV16);

        let mut dst_map = dst.tensor().map()?;

        let (y_plane, uv_plane) = dst_map.split_at_mut(dst.width() * dst.height());
        let mut bi_planar_image = yuv::YuvBiPlanarImageMut::<u8> {
            y_plane: yuv::BufferStoreMut::Borrowed(y_plane),
            y_stride: dst.width() as u32,
            uv_plane: yuv::BufferStoreMut::Borrowed(uv_plane),
            uv_stride: dst.width() as u32,
            width: dst.width() as u32,
            height: dst.height() as u32,
        };

        Ok(yuv::rgba_to_yuv_nv16(
            &mut bi_planar_image,
            src.tensor.map()?.as_slice(),
            src.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    fn convert_rgb_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));

        Ok(yuv::rgb_to_rgba(
            src.tensor.map()?.as_slice(),
            (src.width() * src.channels()) as u32,
            dst.tensor.map()?.as_mut_slice(),
            (dst.width() * dst.channels()) as u32,
            src.width() as u32,
            src.height() as u32,
        )?)
    }

    fn convert_rgb_to_grey(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), GREY);

        let mut dst = yuv::YuvGrayImageMut::<u8> {
            y_plane: yuv::BufferStoreMut::Borrowed(&mut dst.tensor.map()?),
            y_stride: dst.row_stride() as u32,
            width: dst.width() as u32,
            height: dst.height() as u32,
        };
        Ok(yuv::rgb_to_yuv400(
            &mut dst,
            src.tensor.map()?.as_slice(),
            src.row_stride() as u32,
            yuv::YuvRange::Full,
            yuv::YuvStandardMatrix::Bt709,
        )?)
    }

    fn convert_rgb_to_8bps(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), PLANAR_RGB);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<3>().0;

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());

        src.par_iter()
            .zip_eq(dst0)
            .zip_eq(dst1)
            .zip_eq(dst2)
            .for_each(|(((s, d0), d1), d2)| {
                *d0 = s[0];
                *d1 = s[1];
                *d2 = s[2];
            });
        Ok(())
    }

    fn convert_rgb_to_prgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), PLANAR_RGBA);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<3>().0;

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());
        let (dst2, dst3) = dst2.split_at_mut(dst.width() * dst.height());

        rayon::scope(|s| {
            s.spawn(|_| {
                src.par_iter()
                    .zip_eq(dst0)
                    .zip_eq(dst1)
                    .zip_eq(dst2)
                    .for_each(|(((s, d0), d1), d2)| {
                        *d0 = s[0];
                        *d1 = s[1];
                        *d2 = s[2];
                    })
            });
            s.spawn(|_| dst3.fill(255));
        });
        Ok(())
    }

    fn convert_rgb_to_yuyv(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), YUYV);

        let src = src.tensor().map()?;
        let src = src.as_slice();

        let mut dst = dst.tensor().map()?;
        let dst = dst.as_mut_slice();

        // compute quantized Bt.709 limited range RGB to YUV matrix
        const BIAS: i32 = 20;
        const KR: f64 = 0.2126f64;
        const KB: f64 = 0.0722f64;
        const KG: f64 = 1.0 - KR - KB;
        const Y_R: i32 = (KR * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_G: i32 = (KG * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_B: i32 = (KB * (219 << BIAS) as f64 / 255.0).round() as i32;

        const U_R: i32 = (-KR / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_G: i32 = (-KG / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_B: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;

        const V_R: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;
        const V_G: i32 = (-KG / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const V_B: i32 = (-KB / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const ROUND: i32 = 1 << (BIAS - 1);
        const ROUND2: i32 = 1 << BIAS;
        let process_rgb_to_yuyv = |s: &[u8; 6], d: &mut [u8; 4]| {
            let [r0, g0, b0, r1, g1, b1] = *s;
            let r0 = r0 as i32;
            let g0 = g0 as i32;
            let b0 = b0 as i32;
            let r1 = r1 as i32;
            let g1 = g1 as i32;
            let b1 = b1 as i32;
            d[0] = ((Y_R * r0 + Y_G * g0 + Y_B * b0 + ROUND).shr(BIAS) + 16) as u8;
            d[1] = ((U_R * r0 + U_G * g0 + U_B * b0 + U_R * r1 + U_G * g1 + U_B * b1 + ROUND2)
                .shr(BIAS + 1)
                + 128) as u8;
            d[2] = ((Y_R * r1 + Y_G * g1 + Y_B * b1 + ROUND).shr(BIAS) + 16) as u8;
            d[3] = ((V_R * r0 + V_G * g0 + V_B * b0 + V_R * r1 + V_G * g1 + V_B * b1 + ROUND2)
                .shr(BIAS + 1)
                + 128) as u8;
        };

        let src = src.as_chunks::<{ 6 * 32 }>();
        let dst = dst.as_chunks_mut::<{ 4 * 32 }>();
        for (s, d) in src.0.iter().zip(dst.0.iter_mut()) {
            let s = s.as_chunks::<6>().0;
            let d = d.as_chunks_mut::<4>().0;
            for (s, d) in s.iter().zip(d.iter_mut()) {
                process_rgb_to_yuyv(s, d);
            }
        }

        let s = src.1.as_chunks::<6>().0;
        let d = dst.1.as_chunks_mut::<4>().0;
        for (s, d) in s.iter().zip(d.iter_mut()) {
            process_rgb_to_yuyv(s, d);
        }

        Ok(())
    }

    fn convert_rgb_to_nv16(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), NV16);

        let mut dst_map = dst.tensor().map()?;

        let (y_plane, uv_plane) = dst_map.split_at_mut(dst.width() * dst.height());
        let mut bi_planar_image = yuv::YuvBiPlanarImageMut::<u8> {
            y_plane: yuv::BufferStoreMut::Borrowed(y_plane),
            y_stride: dst.width() as u32,
            uv_plane: yuv::BufferStoreMut::Borrowed(uv_plane),
            uv_stride: dst.width() as u32,
            width: dst.width() as u32,
            height: dst.height() as u32,
        };

        Ok(yuv::rgb_to_yuv_nv16(
            &mut bi_planar_image,
            src.tensor.map()?.as_slice(),
            src.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    fn copy_image(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), dst.fourcc());
        dst.tensor().map()?.copy_from_slice(&src.tensor().map()?);
        Ok(())
    }

    /// Swap R and B channels in-place for an interleaved 4-channel image.
    fn swizzle_rb_4chan(dst: &mut TensorImage) -> Result<()> {
        let mut map = dst.tensor().map()?;
        let buf = map.as_mut_slice();
        for chunk in buf.chunks_exact_mut(4) {
            chunk.swap(0, 2);
        }
        Ok(())
    }

    fn convert_nv16_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), NV16);
        assert_eq!(dst.fourcc(), RGB);
        let map = src.tensor.map()?;
        let y_stride = src.width() as u32;
        let uv_stride = src.width() as u32;
        let slices = map.as_slice().split_at(y_stride as usize * src.height());

        let src = yuv::YuvBiPlanarImage {
            y_plane: slices.0,
            y_stride,
            uv_plane: slices.1,
            uv_stride,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuv_nv16_to_rgb(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    fn convert_nv16_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), NV16);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));
        let map = src.tensor.map()?;
        let y_stride = src.width() as u32;
        let uv_stride = src.width() as u32;
        let slices = map.as_slice().split_at(y_stride as usize * src.height());

        let src = yuv::YuvBiPlanarImage {
            y_plane: slices.0,
            y_stride,
            uv_plane: slices.1,
            uv_stride,
            width: src.width() as u32,
            height: src.height() as u32,
        };

        Ok(yuv::yuv_nv16_to_rgba(
            &src,
            dst.tensor.map()?.as_mut_slice(),
            dst.row_stride() as u32,
            yuv::YuvRange::Limited,
            yuv::YuvStandardMatrix::Bt709,
            yuv::YuvConversionMode::Balanced,
        )?)
    }

    fn convert_8bps_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), PLANAR_RGB);
        assert_eq!(dst.fourcc(), RGB);

        let src_map = src.tensor().map()?;
        let src_ = src_map.as_slice();

        let (src0, src1) = src_.split_at(src.width() * src.height());
        let (src1, src2) = src1.split_at(src.width() * src.height());

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        src0.par_iter()
            .zip_eq(src1)
            .zip_eq(src2)
            .zip_eq(dst_.as_chunks_mut::<3>().0.par_iter_mut())
            .for_each(|(((s0, s1), s2), d)| {
                d[0] = *s0;
                d[1] = *s1;
                d[2] = *s2;
            });
        Ok(())
    }

    fn convert_8bps_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), PLANAR_RGB);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));

        let src_map = src.tensor().map()?;
        let src_ = src_map.as_slice();

        let (src0, src1) = src_.split_at(src.width() * src.height());
        let (src1, src2) = src1.split_at(src.width() * src.height());

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        src0.par_iter()
            .zip_eq(src1)
            .zip_eq(src2)
            .zip_eq(dst_.as_chunks_mut::<4>().0.par_iter_mut())
            .for_each(|(((s0, s1), s2), d)| {
                d[0] = *s0;
                d[1] = *s1;
                d[2] = *s2;
                d[3] = 255;
            });
        Ok(())
    }

    fn convert_prgba_to_rgb(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), PLANAR_RGBA);
        assert_eq!(dst.fourcc(), RGB);

        let src_map = src.tensor().map()?;
        let src_ = src_map.as_slice();

        let (src0, src1) = src_.split_at(src.width() * src.height());
        let (src1, src2) = src1.split_at(src.width() * src.height());
        let (src2, _src3) = src2.split_at(src.width() * src.height());

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        src0.par_iter()
            .zip_eq(src1)
            .zip_eq(src2)
            .zip_eq(dst_.as_chunks_mut::<3>().0.par_iter_mut())
            .for_each(|(((s0, s1), s2), d)| {
                d[0] = *s0;
                d[1] = *s1;
                d[2] = *s2;
            });
        Ok(())
    }

    fn convert_prgba_to_rgba(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        assert_eq!(src.fourcc(), PLANAR_RGBA);
        assert!(matches!(dst.fourcc(), RGBA | BGRA));

        let src_map = src.tensor().map()?;
        let src_ = src_map.as_slice();

        let (src0, src1) = src_.split_at(src.width() * src.height());
        let (src1, src2) = src1.split_at(src.width() * src.height());
        let (src2, src3) = src2.split_at(src.width() * src.height());

        let mut dst_map = dst.tensor().map()?;
        let dst_ = dst_map.as_mut_slice();

        src0.par_iter()
            .zip_eq(src1)
            .zip_eq(src2)
            .zip_eq(src3)
            .zip_eq(dst_.as_chunks_mut::<4>().0.par_iter_mut())
            .for_each(|((((s0, s1), s2), s3), d)| {
                d[0] = *s0;
                d[1] = *s1;
                d[2] = *s2;
                d[3] = *s3;
            });
        Ok(())
    }

    pub(crate) fn support_conversion(src: FourCharCode, dst: FourCharCode) -> bool {
        matches!(
            (src, dst),
            (NV12, RGB)
                | (NV12, RGBA)
                | (NV12, GREY)
                | (NV16, RGB)
                | (NV16, RGBA)
                | (YUYV, RGB)
                | (YUYV, RGBA)
                | (YUYV, GREY)
                | (YUYV, YUYV)
                | (YUYV, PLANAR_RGB)
                | (YUYV, PLANAR_RGBA)
                | (YUYV, NV16)
                | (VYUY, RGB)
                | (VYUY, RGBA)
                | (VYUY, GREY)
                | (VYUY, VYUY)
                | (VYUY, PLANAR_RGB)
                | (VYUY, PLANAR_RGBA)
                | (VYUY, NV16)
                | (RGBA, RGB)
                | (RGBA, RGBA)
                | (RGBA, GREY)
                | (RGBA, YUYV)
                | (RGBA, PLANAR_RGB)
                | (RGBA, PLANAR_RGBA)
                | (RGBA, NV16)
                | (RGB, RGB)
                | (RGB, RGBA)
                | (RGB, GREY)
                | (RGB, YUYV)
                | (RGB, PLANAR_RGB)
                | (RGB, PLANAR_RGBA)
                | (RGB, NV16)
                | (GREY, RGB)
                | (GREY, RGBA)
                | (GREY, GREY)
                | (GREY, YUYV)
                | (GREY, PLANAR_RGB)
                | (GREY, PLANAR_RGBA)
                | (GREY, NV16)
                | (NV12, BGRA)
                | (YUYV, BGRA)
                | (VYUY, BGRA)
                | (RGBA, BGRA)
                | (RGB, BGRA)
                | (GREY, BGRA)
                | (BGRA, BGRA)
        )
    }

    pub(crate) fn convert_format(src: &TensorImage, dst: &mut TensorImage) -> Result<()> {
        // shapes should be equal
        let _timer = FunctionTimer::new(format!(
            "ImageProcessor::convert_format {} to {}",
            src.fourcc().display(),
            dst.fourcc().display()
        ));
        assert_eq!(src.height(), dst.height());
        assert_eq!(src.width(), dst.width());

        match (src.fourcc(), dst.fourcc()) {
            (NV12, RGB) => Self::convert_nv12_to_rgb(src, dst),
            (NV12, RGBA) => Self::convert_nv12_to_rgba(src, dst),
            (NV12, GREY) => Self::convert_nv12_to_grey(src, dst),
            (YUYV, RGB) => Self::convert_yuyv_to_rgb(src, dst),
            (YUYV, RGBA) => Self::convert_yuyv_to_rgba(src, dst),
            (YUYV, GREY) => Self::convert_yuyv_to_grey(src, dst),
            (YUYV, YUYV) => Self::copy_image(src, dst),
            (YUYV, PLANAR_RGB) => Self::convert_yuyv_to_8bps(src, dst),
            (YUYV, PLANAR_RGBA) => Self::convert_yuyv_to_prgba(src, dst),
            (YUYV, NV16) => Self::convert_yuyv_to_nv16(src, dst),
            (VYUY, RGB) => Self::convert_vyuy_to_rgb(src, dst),
            (VYUY, RGBA) => Self::convert_vyuy_to_rgba(src, dst),
            (VYUY, GREY) => Self::convert_vyuy_to_grey(src, dst),
            (VYUY, VYUY) => Self::copy_image(src, dst),
            (VYUY, PLANAR_RGB) => Self::convert_vyuy_to_8bps(src, dst),
            (VYUY, PLANAR_RGBA) => Self::convert_vyuy_to_prgba(src, dst),
            (VYUY, NV16) => Self::convert_vyuy_to_nv16(src, dst),
            (RGBA, RGB) => Self::convert_rgba_to_rgb(src, dst),
            (RGBA, RGBA) => Self::copy_image(src, dst),
            (RGBA, GREY) => Self::convert_rgba_to_grey(src, dst),
            (RGBA, YUYV) => Self::convert_rgba_to_yuyv(src, dst),
            (RGBA, PLANAR_RGB) => Self::convert_rgba_to_8bps(src, dst),
            (RGBA, PLANAR_RGBA) => Self::convert_rgba_to_prgba(src, dst),
            (RGBA, NV16) => Self::convert_rgba_to_nv16(src, dst),
            (RGB, RGB) => Self::copy_image(src, dst),
            (RGB, RGBA) => Self::convert_rgb_to_rgba(src, dst),
            (RGB, GREY) => Self::convert_rgb_to_grey(src, dst),
            (RGB, YUYV) => Self::convert_rgb_to_yuyv(src, dst),
            (RGB, PLANAR_RGB) => Self::convert_rgb_to_8bps(src, dst),
            (RGB, PLANAR_RGBA) => Self::convert_rgb_to_prgba(src, dst),
            (RGB, NV16) => Self::convert_rgb_to_nv16(src, dst),
            (GREY, RGB) => Self::convert_grey_to_rgb(src, dst),
            (GREY, RGBA) => Self::convert_grey_to_rgba(src, dst),
            (GREY, GREY) => Self::copy_image(src, dst),
            (GREY, YUYV) => Self::convert_grey_to_yuyv(src, dst),
            (GREY, PLANAR_RGB) => Self::convert_grey_to_8bps(src, dst),
            (GREY, PLANAR_RGBA) => Self::convert_grey_to_prgba(src, dst),
            (GREY, NV16) => Self::convert_grey_to_nv16(src, dst),

            // the following converts are added for use in testing
            (NV16, RGB) => Self::convert_nv16_to_rgb(src, dst),
            (NV16, RGBA) => Self::convert_nv16_to_rgba(src, dst),
            (PLANAR_RGB, RGB) => Self::convert_8bps_to_rgb(src, dst),
            (PLANAR_RGB, RGBA) => Self::convert_8bps_to_rgba(src, dst),
            (PLANAR_RGBA, RGB) => Self::convert_prgba_to_rgb(src, dst),
            (PLANAR_RGBA, RGBA) => Self::convert_prgba_to_rgba(src, dst),

            // BGRA destination: convert to RGBA layout, then swap R and B
            (BGRA, BGRA) => Self::copy_image(src, dst),
            (NV12, BGRA) => {
                Self::convert_nv12_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (NV16, BGRA) => {
                Self::convert_nv16_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (YUYV, BGRA) => {
                Self::convert_yuyv_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (VYUY, BGRA) => {
                Self::convert_vyuy_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (RGBA, BGRA) => {
                dst.tensor().map()?.copy_from_slice(&src.tensor().map()?);
                Self::swizzle_rb_4chan(dst)
            }
            (RGB, BGRA) => {
                Self::convert_rgb_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (GREY, BGRA) => {
                Self::convert_grey_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (PLANAR_RGB, BGRA) => {
                Self::convert_8bps_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }
            (PLANAR_RGBA, BGRA) => {
                Self::convert_prgba_to_rgba(src, dst)?;
                Self::swizzle_rb_4chan(dst)
            }

            (s, d) => Err(Error::NotSupported(format!(
                "Conversion from {} to {}",
                s.display(),
                d.display()
            ))),
        }
    }

    /// Generic RGB to PLANAR_RGB conversion that works with any TensorImageDst.
    fn convert_rgb_to_planar_rgb_generic<D: TensorImageDst>(
        src: &TensorImage,
        dst: &mut D,
    ) -> Result<()> {
        assert_eq!(src.fourcc(), RGB);
        assert_eq!(dst.fourcc(), PLANAR_RGB);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<3>().0;

        let mut dst_map = dst.tensor_mut().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());

        src.par_iter()
            .zip_eq(dst0)
            .zip_eq(dst1)
            .zip_eq(dst2)
            .for_each(|(((s, d0), d1), d2)| {
                *d0 = s[0];
                *d1 = s[1];
                *d2 = s[2];
            });
        Ok(())
    }

    /// Generic RGBA to PLANAR_RGB conversion that works with any
    /// TensorImageDst.
    fn convert_rgba_to_planar_rgb_generic<D: TensorImageDst>(
        src: &TensorImage,
        dst: &mut D,
    ) -> Result<()> {
        assert_eq!(src.fourcc(), RGBA);
        assert_eq!(dst.fourcc(), PLANAR_RGB);

        let src = src.tensor().map()?;
        let src = src.as_slice();
        let src = src.as_chunks::<4>().0;

        let mut dst_map = dst.tensor_mut().map()?;
        let dst_ = dst_map.as_mut_slice();

        let (dst0, dst1) = dst_.split_at_mut(dst.width() * dst.height());
        let (dst1, dst2) = dst1.split_at_mut(dst.width() * dst.height());

        src.par_iter()
            .zip_eq(dst0)
            .zip_eq(dst1)
            .zip_eq(dst2)
            .for_each(|(((s, d0), d1), d2)| {
                *d0 = s[0];
                *d1 = s[1];
                *d2 = s[2];
            });
        Ok(())
    }

    /// Generic copy for same-format images that works with any TensorImageDst.
    fn copy_image_generic<D: TensorImageDst>(src: &TensorImage, dst: &mut D) -> Result<()> {
        assert_eq!(src.fourcc(), dst.fourcc());
        dst.tensor_mut()
            .map()?
            .copy_from_slice(&src.tensor().map()?);
        Ok(())
    }

    /// Format conversion that writes to a generic TensorImageDst.
    /// Supports common zero-copy preprocessing cases.
    pub(crate) fn convert_format_generic<D: TensorImageDst>(
        src: &TensorImage,
        dst: &mut D,
    ) -> Result<()> {
        let _timer = FunctionTimer::new(format!(
            "ImageProcessor::convert_format_generic {} to {}",
            src.fourcc().display(),
            dst.fourcc().display()
        ));
        assert_eq!(src.height(), dst.height());
        assert_eq!(src.width(), dst.width());

        match (src.fourcc(), dst.fourcc()) {
            (RGB, PLANAR_RGB) => Self::convert_rgb_to_planar_rgb_generic(src, dst),
            (RGBA, PLANAR_RGB) => Self::convert_rgba_to_planar_rgb_generic(src, dst),
            (f1, f2) if f1 == f2 => Self::copy_image_generic(src, dst),
            (s, d) => Err(Error::NotSupported(format!(
                "Generic conversion from {} to {} not supported",
                s.display(),
                d.display()
            ))),
        }
    }

    /// The src and dest img should be in RGB/RGBA/grey format for correct
    /// output. If the format is not 1, 3, or 4 bits per pixel, and error will
    /// be returned. The src and dest img must have the same fourcc,
    /// otherwise the function will panic.
    fn resize_flip_rotate(
        &mut self,
        src: &TensorImage,
        dst: &mut TensorImage,
        rotation: Rotation,
        flip: Flip,
        crop: Crop,
    ) -> Result<()> {
        let _timer = FunctionTimer::new(format!(
            "ImageProcessor::resize_flip_rotate {}x{} to {}x{} {}",
            src.width(),
            src.height(),
            dst.width(),
            dst.height(),
            dst.fourcc().display()
        ));
        assert_eq!(src.fourcc(), dst.fourcc());

        let src_type = match src.channels() {
            1 => fast_image_resize::PixelType::U8,
            3 => fast_image_resize::PixelType::U8x3,
            4 => fast_image_resize::PixelType::U8x4,
            _ => {
                return Err(Error::NotImplemented(
                    "Unsupported source image format".to_string(),
                ));
            }
        };

        let mut src_map = src.tensor().map()?;

        let mut dst_map = dst.tensor().map()?;

        let options = if let Some(crop) = crop.src_rect {
            self.options.crop(
                crop.left as f64,
                crop.top as f64,
                crop.width as f64,
                crop.height as f64,
            )
        } else {
            self.options
        };

        let mut dst_rect = crop.dst_rect.unwrap_or_else(|| Rect {
            left: 0,
            top: 0,
            width: dst.width(),
            height: dst.height(),
        });

        // adjust crop box for rotation/flip
        Self::adjust_dest_rect_for_rotate_flip(&mut dst_rect, dst, rotation, flip);

        let needs_resize = src.width() != dst.width()
            || src.height() != dst.height()
            || crop.src_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: src.width(),
                    height: src.height(),
                }
            })
            || crop.dst_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: dst.width(),
                    height: dst.height(),
                }
            });

        if needs_resize {
            let src_view = fast_image_resize::images::Image::from_slice_u8(
                src.width() as u32,
                src.height() as u32,
                &mut src_map,
                src_type,
            )?;

            match (rotation, flip) {
                (Rotation::None, Flip::None) => {
                    let mut dst_view = fast_image_resize::images::Image::from_slice_u8(
                        dst.width() as u32,
                        dst.height() as u32,
                        &mut dst_map,
                        src_type,
                    )?;

                    let mut dst_view = fast_image_resize::images::CroppedImageMut::new(
                        &mut dst_view,
                        dst_rect.left as u32,
                        dst_rect.top as u32,
                        dst_rect.width as u32,
                        dst_rect.height as u32,
                    )?;

                    self.resizer.resize(&src_view, &mut dst_view, &options)?;
                }
                (Rotation::Clockwise90, _) | (Rotation::CounterClockwise90, _) => {
                    let mut tmp = vec![0; dst.row_stride() * dst.height()];
                    let mut tmp_view = fast_image_resize::images::Image::from_slice_u8(
                        dst.height() as u32,
                        dst.width() as u32,
                        &mut tmp,
                        src_type,
                    )?;

                    let mut tmp_view = fast_image_resize::images::CroppedImageMut::new(
                        &mut tmp_view,
                        dst_rect.left as u32,
                        dst_rect.top as u32,
                        dst_rect.width as u32,
                        dst_rect.height as u32,
                    )?;

                    self.resizer.resize(&src_view, &mut tmp_view, &options)?;
                    Self::flip_rotate_ndarray(&tmp, &mut dst_map, dst, rotation, flip)?;
                }
                (Rotation::None, _) | (Rotation::Rotate180, _) => {
                    let mut tmp = vec![0; dst.row_stride() * dst.height()];
                    let mut tmp_view = fast_image_resize::images::Image::from_slice_u8(
                        dst.width() as u32,
                        dst.height() as u32,
                        &mut tmp,
                        src_type,
                    )?;

                    let mut tmp_view = fast_image_resize::images::CroppedImageMut::new(
                        &mut tmp_view,
                        dst_rect.left as u32,
                        dst_rect.top as u32,
                        dst_rect.width as u32,
                        dst_rect.height as u32,
                    )?;

                    self.resizer.resize(&src_view, &mut tmp_view, &options)?;
                    Self::flip_rotate_ndarray(&tmp, &mut dst_map, dst, rotation, flip)?;
                }
            }
        } else {
            Self::flip_rotate_ndarray(&src_map, &mut dst_map, dst, rotation, flip)?;
        }
        Ok(())
    }

    fn adjust_dest_rect_for_rotate_flip(
        crop: &mut Rect,
        dst: &TensorImage,
        rot: Rotation,
        flip: Flip,
    ) {
        match rot {
            Rotation::None => {}
            Rotation::Clockwise90 => {
                *crop = Rect {
                    left: crop.top,
                    top: dst.width() - crop.left - crop.width,
                    width: crop.height,
                    height: crop.width,
                }
            }
            Rotation::Rotate180 => {
                *crop = Rect {
                    left: dst.width() - crop.left - crop.width,
                    top: dst.height() - crop.top - crop.height,
                    width: crop.width,
                    height: crop.height,
                }
            }
            Rotation::CounterClockwise90 => {
                *crop = Rect {
                    left: dst.height() - crop.top - crop.height,
                    top: crop.left,
                    width: crop.height,
                    height: crop.width,
                }
            }
        }

        match flip {
            Flip::None => {}
            Flip::Vertical => crop.top = dst.height() - crop.top - crop.height,
            Flip::Horizontal => crop.left = dst.width() - crop.left - crop.width,
        }
    }

    /// Fills the area outside a crop rectangle with the specified color.
    pub fn fill_image_outside_crop(dst: &mut TensorImage, rgba: [u8; 4], crop: Rect) -> Result<()> {
        let dst_fourcc = dst.fourcc();
        let mut dst_map = dst.tensor().map()?;
        let dst = (dst_map.as_mut_slice(), dst.width(), dst.height());
        match dst_fourcc {
            RGBA => Self::fill_image_outside_crop_(dst, rgba, crop),
            RGB => Self::fill_image_outside_crop_(dst, Self::rgba_to_rgb(rgba), crop),
            GREY => Self::fill_image_outside_crop_(dst, Self::rgba_to_grey(rgba), crop),
            YUYV => Self::fill_image_outside_crop_(
                (dst.0, dst.1 / 2, dst.2),
                Self::rgba_to_yuyv(rgba),
                Rect::new(crop.left / 2, crop.top, crop.width.div_ceil(2), crop.height),
            ),
            PLANAR_RGB => Self::fill_image_outside_crop_planar(dst, Self::rgba_to_rgb(rgba), crop),
            PLANAR_RGBA => Self::fill_image_outside_crop_planar(dst, rgba, crop),
            NV16 => {
                let yuyv = Self::rgba_to_yuyv(rgba);
                Self::fill_image_outside_crop_yuv_semiplanar(dst, yuyv[0], [yuyv[1], yuyv[3]], crop)
            }
            _ => Err(Error::Internal(format!(
                "Found unexpected destination {}",
                dst_fourcc.display()
            ))),
        }
    }

    /// Generic fill for TensorImageDst types.
    pub(crate) fn fill_image_outside_crop_generic<D: TensorImageDst>(
        dst: &mut D,
        rgba: [u8; 4],
        crop: Rect,
    ) -> Result<()> {
        let dst_fourcc = dst.fourcc();
        let dst_width = dst.width();
        let dst_height = dst.height();
        let mut dst_map = dst.tensor_mut().map()?;
        let dst = (dst_map.as_mut_slice(), dst_width, dst_height);
        match dst_fourcc {
            RGBA => Self::fill_image_outside_crop_(dst, rgba, crop),
            RGB => Self::fill_image_outside_crop_(dst, Self::rgba_to_rgb(rgba), crop),
            GREY => Self::fill_image_outside_crop_(dst, Self::rgba_to_grey(rgba), crop),
            YUYV => Self::fill_image_outside_crop_(
                (dst.0, dst.1 / 2, dst.2),
                Self::rgba_to_yuyv(rgba),
                Rect::new(crop.left / 2, crop.top, crop.width.div_ceil(2), crop.height),
            ),
            PLANAR_RGB => Self::fill_image_outside_crop_planar(dst, Self::rgba_to_rgb(rgba), crop),
            PLANAR_RGBA => Self::fill_image_outside_crop_planar(dst, rgba, crop),
            NV16 => {
                let yuyv = Self::rgba_to_yuyv(rgba);
                Self::fill_image_outside_crop_yuv_semiplanar(dst, yuyv[0], [yuyv[1], yuyv[3]], crop)
            }
            _ => Err(Error::Internal(format!(
                "Found unexpected destination {}",
                dst_fourcc.display()
            ))),
        }
    }

    fn fill_image_outside_crop_<const N: usize>(
        (dst, dst_width, _dst_height): (&mut [u8], usize, usize),
        pix: [u8; N],
        crop: Rect,
    ) -> Result<()> {
        use rayon::{
            iter::{IntoParallelRefMutIterator, ParallelIterator},
            prelude::ParallelSliceMut,
        };

        let s = dst.as_chunks_mut::<N>().0;
        // calculate the top/bottom
        let top_offset = (0, (crop.top * dst_width + crop.left));
        let bottom_offset = (
            ((crop.top + crop.height) * dst_width + crop.left).min(s.len()),
            s.len(),
        );

        s[top_offset.0..top_offset.1]
            .par_iter_mut()
            .for_each(|x| *x = pix);

        s[bottom_offset.0..bottom_offset.1]
            .par_iter_mut()
            .for_each(|x| *x = pix);

        if dst_width == crop.width {
            return Ok(());
        }

        // the middle part has a stride as well
        let middle_stride = dst_width - crop.width;
        let middle_offset = (
            (crop.top * dst_width + crop.left + crop.width),
            ((crop.top + crop.height) * dst_width + crop.left + crop.width).min(s.len()),
        );

        s[middle_offset.0..middle_offset.1]
            .par_chunks_exact_mut(dst_width)
            .for_each(|row| {
                for p in &mut row[0..middle_stride] {
                    *p = pix;
                }
            });

        Ok(())
    }

    fn fill_image_outside_crop_planar<const N: usize>(
        (dst, dst_width, dst_height): (&mut [u8], usize, usize),
        pix: [u8; N],
        crop: Rect,
    ) -> Result<()> {
        use rayon::{
            iter::{IntoParallelRefMutIterator, ParallelIterator},
            prelude::ParallelSliceMut,
        };

        // map.as_mut_slice().splitn_mut(n, pred)
        let s_rem = dst;

        s_rem
            .par_chunks_exact_mut(dst_height * dst_width)
            .zip(pix)
            .for_each(|(s, p)| {
                let top_offset = (0, (crop.top * dst_width + crop.left));
                let bottom_offset = (
                    ((crop.top + crop.height) * dst_width + crop.left).min(s.len()),
                    s.len(),
                );

                s[top_offset.0..top_offset.1]
                    .par_iter_mut()
                    .for_each(|x| *x = p);

                s[bottom_offset.0..bottom_offset.1]
                    .par_iter_mut()
                    .for_each(|x| *x = p);

                if dst_width == crop.width {
                    return;
                }

                // the middle part has a stride as well
                let middle_stride = dst_width - crop.width;
                let middle_offset = (
                    (crop.top * dst_width + crop.left + crop.width),
                    ((crop.top + crop.height) * dst_width + crop.left + crop.width).min(s.len()),
                );

                s[middle_offset.0..middle_offset.1]
                    .par_chunks_exact_mut(dst_width)
                    .for_each(|row| {
                        for x in &mut row[0..middle_stride] {
                            *x = p;
                        }
                    });
            });
        Ok(())
    }

    fn fill_image_outside_crop_yuv_semiplanar(
        (dst, dst_width, dst_height): (&mut [u8], usize, usize),
        y: u8,
        uv: [u8; 2],
        mut crop: Rect,
    ) -> Result<()> {
        let (y_plane, uv_plane) = dst.split_at_mut(dst_width * dst_height);
        Self::fill_image_outside_crop_::<1>((y_plane, dst_width, dst_height), [y], crop)?;
        crop.left /= 2;
        crop.width /= 2;
        Self::fill_image_outside_crop_::<2>((uv_plane, dst_width / 2, dst_height), uv, crop)?;
        Ok(())
    }

    fn rgba_to_rgb(rgba: [u8; 4]) -> [u8; 3] {
        let [r, g, b, _] = rgba;
        [r, g, b]
    }

    fn rgba_to_grey(rgba: [u8; 4]) -> [u8; 1] {
        const BIAS: i32 = 20;
        const KR: f64 = 0.2126f64;
        const KB: f64 = 0.0722f64;
        const KG: f64 = 1.0 - KR - KB;
        const Y_R: i32 = (KR * (255 << BIAS) as f64 / 255.0).round() as i32;
        const Y_G: i32 = (KG * (255 << BIAS) as f64 / 255.0).round() as i32;
        const Y_B: i32 = (KB * (255 << BIAS) as f64 / 255.0).round() as i32;

        const ROUND: i32 = 1 << (BIAS - 1);

        let [r, g, b, _] = rgba;
        let y = ((Y_R * r as i32 + Y_G * g as i32 + Y_B * b as i32 + ROUND) >> BIAS) as u8;
        [y]
    }

    fn rgba_to_yuyv(rgba: [u8; 4]) -> [u8; 4] {
        const KR: f64 = 0.2126f64;
        const KB: f64 = 0.0722f64;
        const KG: f64 = 1.0 - KR - KB;
        const BIAS: i32 = 20;

        const Y_R: i32 = (KR * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_G: i32 = (KG * (219 << BIAS) as f64 / 255.0).round() as i32;
        const Y_B: i32 = (KB * (219 << BIAS) as f64 / 255.0).round() as i32;

        const U_R: i32 = (-KR / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_G: i32 = (-KG / (KR + KG) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const U_B: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;

        const V_R: i32 = (0.5_f64 * (224 << BIAS) as f64 / 255.0).ceil() as i32;
        const V_G: i32 = (-KG / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const V_B: i32 = (-KB / (KG + KB) / 2.0 * (224 << BIAS) as f64 / 255.0).round() as i32;
        const ROUND: i32 = 1 << (BIAS - 1);

        let [r, g, b, _] = rgba;
        let r = r as i32;
        let g = g as i32;
        let b = b as i32;
        let y = (((Y_R * r + Y_G * g + Y_B * b + ROUND) >> BIAS) + 16) as u8;
        let u = (((U_R * r + U_G * g + U_B * b + ROUND) >> BIAS) + 128) as u8;
        let v = (((V_R * r + V_G * g + V_B * b + ROUND) >> BIAS) + 128) as u8;

        [y, u, y, v]
    }

    fn render_modelpack_segmentation(
        &mut self,
        dst: &TensorImage,
        dst_slice: &mut [u8],
        segmentation: &Segmentation,
    ) -> Result<()> {
        use ndarray_stats::QuantileExt;

        let seg = &segmentation.segmentation;
        let [seg_height, seg_width, seg_classes] = *seg.shape() else {
            unreachable!("Array3 did not have [usize; 3] as shape");
        };
        let start_y = (dst.height() as f32 * segmentation.ymin).round();
        let end_y = (dst.height() as f32 * segmentation.ymax).round();
        let start_x = (dst.width() as f32 * segmentation.xmin).round();
        let end_x = (dst.width() as f32 * segmentation.xmax).round();

        let scale_x = (seg_width as f32 - 1.0) / ((end_x - start_x) - 1.0);
        let scale_y = (seg_height as f32 - 1.0) / ((end_y - start_y) - 1.0);

        let start_x_u = (start_x as usize).min(dst.width());
        let start_y_u = (start_y as usize).min(dst.height());
        let end_x_u = (end_x as usize).min(dst.width());
        let end_y_u = (end_y as usize).min(dst.height());

        let argmax = seg.map_axis(Axis(2), |r| r.argmax().unwrap());
        let get_value_at_nearest = |x: f32, y: f32| -> usize {
            let x = x.round() as usize;
            let y = y.round() as usize;
            argmax
                .get([y.min(seg_height - 1), x.min(seg_width - 1)])
                .copied()
                .unwrap_or(0)
        };

        for y in start_y_u..end_y_u {
            for x in start_x_u..end_x_u {
                let seg_x = (x as f32 - start_x) * scale_x;
                let seg_y = (y as f32 - start_y) * scale_y;
                let label = get_value_at_nearest(seg_x, seg_y);

                if label == seg_classes - 1 {
                    continue;
                }

                let color = self.colors[label % self.colors.len()];

                let alpha = color[3] as u16;

                let dst_index = (y * dst.row_stride()) + (x * dst.channels());
                for c in 0..3 {
                    dst_slice[dst_index + c] = ((color[c] as u16 * alpha
                        + dst_slice[dst_index + c] as u16 * (255 - alpha))
                        / 255) as u8;
                }
            }
        }

        Ok(())
    }

    fn render_yolo_segmentation(
        &mut self,
        dst: &TensorImage,
        dst_slice: &mut [u8],
        segmentation: &Segmentation,
        class: usize,
    ) -> Result<()> {
        let seg = &segmentation.segmentation;
        let [seg_height, seg_width, classes] = *seg.shape() else {
            unreachable!("Array3 did not have [usize;3] as shape");
        };
        debug_assert_eq!(classes, 1);

        let start_y = (dst.height() as f32 * segmentation.ymin).round();
        let end_y = (dst.height() as f32 * segmentation.ymax).round();
        let start_x = (dst.width() as f32 * segmentation.xmin).round();
        let end_x = (dst.width() as f32 * segmentation.xmax).round();

        let scale_x = (seg_width as f32 - 1.0) / ((end_x - start_x) - 1.0);
        let scale_y = (seg_height as f32 - 1.0) / ((end_y - start_y) - 1.0);

        let start_x_u = (start_x as usize).min(dst.width());
        let start_y_u = (start_y as usize).min(dst.height());
        let end_x_u = (end_x as usize).min(dst.width());
        let end_y_u = (end_y as usize).min(dst.height());

        for y in start_y_u..end_y_u {
            for x in start_x_u..end_x_u {
                let seg_x = ((x as f32 - start_x) * scale_x) as usize;
                let seg_y = ((y as f32 - start_y) * scale_y) as usize;
                let val = *seg.get([seg_y, seg_x, 0]).unwrap_or(&0);

                if val < 127 {
                    continue;
                }

                let color = self.colors[class % self.colors.len()];

                let alpha = color[3] as u16;

                let dst_index = (y * dst.row_stride()) + (x * dst.channels());
                for c in 0..3 {
                    dst_slice[dst_index + c] = ((color[c] as u16 * alpha
                        + dst_slice[dst_index + c] as u16 * (255 - alpha))
                        / 255) as u8;
                }
            }
        }

        Ok(())
    }

    fn render_box(
        &mut self,
        dst: &TensorImage,
        dst_slice: &mut [u8],
        detect: &[DetectBox],
    ) -> Result<()> {
        const LINE_THICKNESS: usize = 3;
        for d in detect {
            use edgefirst_decoder::BoundingBox;

            let label = d.label;
            let [r, g, b, _] = self.colors[label % self.colors.len()];
            let bbox = d.bbox.to_canonical();
            let bbox = BoundingBox {
                xmin: bbox.xmin.clamp(0.0, 1.0),
                ymin: bbox.ymin.clamp(0.0, 1.0),
                xmax: bbox.xmax.clamp(0.0, 1.0),
                ymax: bbox.ymax.clamp(0.0, 1.0),
            };
            let inner = [
                ((dst.width() - 1) as f32 * bbox.xmin - 0.5).round() as usize,
                ((dst.height() - 1) as f32 * bbox.ymin - 0.5).round() as usize,
                ((dst.width() - 1) as f32 * bbox.xmax + 0.5).round() as usize,
                ((dst.height() - 1) as f32 * bbox.ymax + 0.5).round() as usize,
            ];

            let outer = [
                inner[0].saturating_sub(LINE_THICKNESS),
                inner[1].saturating_sub(LINE_THICKNESS),
                (inner[2] + LINE_THICKNESS).min(dst.width()),
                (inner[3] + LINE_THICKNESS).min(dst.height()),
            ];

            // top line
            for y in outer[1] + 1..=inner[1] {
                for x in outer[0] + 1..outer[2] {
                    let index = (y * dst.row_stride()) + (x * dst.channels());
                    dst_slice[index..(index + 3)].copy_from_slice(&[r, g, b]);
                }
            }

            // left and right lines
            for y in inner[1]..inner[3] {
                for x in outer[0] + 1..=inner[0] {
                    let index = (y * dst.row_stride()) + (x * dst.channels());
                    dst_slice[index..(index + 3)].copy_from_slice(&[r, g, b]);
                }

                for x in inner[2]..outer[2] {
                    let index = (y * dst.row_stride()) + (x * dst.channels());
                    dst_slice[index..(index + 3)].copy_from_slice(&[r, g, b]);
                }
            }

            // bottom line
            for y in inner[3]..outer[3] {
                for x in outer[0] + 1..outer[2] {
                    let index = (y * dst.row_stride()) + (x * dst.channels());
                    dst_slice[index..(index + 3)].copy_from_slice(&[r, g, b]);
                }
            }
        }
        Ok(())
    }

    /// Materialize segmentation masks from proto data into `Vec<Segmentation>`.
    ///
    /// This is the CPU-side decode step of the hybrid mask rendering path:
    /// call this to get pre-decoded masks, then pass them to
    /// [`draw_masks`](crate::ImageProcessorTrait::draw_masks) for GPU overlay.
    /// Benchmarks show this hybrid path (CPU decode + GL overlay) is faster
    /// than the fused GPU `draw_masks_proto` on all tested platforms.
    pub fn materialize_segmentations(
        &self,
        detect: &[crate::DetectBox],
        proto_data: &crate::ProtoData,
    ) -> crate::Result<Vec<edgefirst_decoder::Segmentation>> {
        if detect.is_empty() || proto_data.mask_coefficients.is_empty() {
            return Ok(Vec::new());
        }

        let protos_cow = proto_data.protos.as_f32();
        let protos = protos_cow.as_ref();
        let proto_h = protos.shape()[0];
        let proto_w = protos.shape()[1];
        let num_protos = protos.shape()[2];

        detect
            .iter()
            .zip(proto_data.mask_coefficients.iter())
            .map(|(det, coeff)| {
                // Clamp bbox to [0, 1]
                let xmin = det.bbox.xmin.clamp(0.0, 1.0);
                let ymin = det.bbox.ymin.clamp(0.0, 1.0);
                let xmax = det.bbox.xmax.clamp(0.0, 1.0);
                let ymax = det.bbox.ymax.clamp(0.0, 1.0);

                // Map to proto-space pixel coordinates (clamp to valid range)
                let x0 = ((xmin * proto_w as f32) as usize).min(proto_w.saturating_sub(1));
                let y0 = ((ymin * proto_h as f32) as usize).min(proto_h.saturating_sub(1));
                let x1 = ((xmax * proto_w as f32).ceil() as usize).min(proto_w);
                let y1 = ((ymax * proto_h as f32).ceil() as usize).min(proto_h);

                let roi_w = x1.saturating_sub(x0).max(1);
                let roi_h = y1.saturating_sub(y0).max(1);

                // Extract proto ROI and compute mask_coeff @ protos
                let roi = protos.slice(ndarray::s![y0..y0 + roi_h, x0..x0 + roi_w, ..]);
                let coeff_arr = ndarray::Array2::from_shape_vec((1, num_protos), coeff.clone())
                    .map_err(|e| crate::Error::Internal(format!("mask coeff shape: {e}")))?;
                let protos_2d = roi
                    .to_shape((roi_h * roi_w, num_protos))
                    .map_err(|e| crate::Error::Internal(format!("proto reshape: {e}")))?
                    .reversed_axes();
                let mask = coeff_arr.dot(&protos_2d);
                let mask = mask
                    .into_shape_with_order((roi_h, roi_w, 1))
                    .map_err(|e| crate::Error::Internal(format!("mask reshape: {e}")))?
                    .mapv(|x: f32| {
                        let sigmoid = 1.0 / (1.0 + (-x).exp());
                        (sigmoid * 255.0).round() as u8
                    });

                Ok(edgefirst_decoder::Segmentation {
                    xmin: x0 as f32 / proto_w as f32,
                    ymin: y0 as f32 / proto_h as f32,
                    xmax: x1 as f32 / proto_w as f32,
                    ymax: y1 as f32 / proto_h as f32,
                    segmentation: mask,
                })
            })
            .collect::<crate::Result<Vec<_>>>()
    }

    /// Renders per-instance grayscale masks from raw prototype data at full
    /// output resolution. Used internally by [`decode_masks_atlas`] to generate
    /// per-detection mask crops that are then packed into the atlas.
    fn render_masks_from_protos(
        &mut self,
        detect: &[crate::DetectBox],
        proto_data: crate::ProtoData,
        output_width: usize,
        output_height: usize,
    ) -> Result<Vec<crate::MaskResult>> {
        use crate::FunctionTimer;

        let _timer = FunctionTimer::new("CPUProcessor::render_masks_from_protos");

        if detect.is_empty() || proto_data.mask_coefficients.is_empty() {
            return Ok(Vec::new());
        }

        let protos_cow = proto_data.protos.as_f32();
        let protos = protos_cow.as_ref();
        let proto_h = protos.shape()[0];
        let proto_w = protos.shape()[1];
        let num_protos = protos.shape()[2];

        let mut results = Vec::with_capacity(detect.len());

        for (det, coeff) in detect.iter().zip(proto_data.mask_coefficients.iter()) {
            let start_x = (output_width as f32 * det.bbox.xmin).round() as usize;
            let start_y = (output_height as f32 * det.bbox.ymin).round() as usize;
            // Use span-based rounding to match the numpy reference convention.
            let bbox_w = ((det.bbox.xmax - det.bbox.xmin) * output_width as f32)
                .round()
                .max(1.0) as usize;
            let bbox_h = ((det.bbox.ymax - det.bbox.ymin) * output_height as f32)
                .round()
                .max(1.0) as usize;
            let bbox_w = bbox_w.min(output_width.saturating_sub(start_x));
            let bbox_h = bbox_h.min(output_height.saturating_sub(start_y));

            let mut pixels = vec![0u8; bbox_w * bbox_h];

            for row in 0..bbox_h {
                let y = start_y + row;
                for col in 0..bbox_w {
                    let x = start_x + col;
                    let px = (x as f32 / output_width as f32) * proto_w as f32 - 0.5;
                    let py = (y as f32 / output_height as f32) * proto_h as f32 - 0.5;
                    let acc = bilinear_dot(protos, coeff, num_protos, px, py, proto_w, proto_h);
                    let mask = 1.0 / (1.0 + (-acc).exp());
                    pixels[row * bbox_w + col] = if mask > 0.5 { 255 } else { 0 };
                }
            }

            results.push(crate::MaskResult {
                x: start_x,
                y: start_y,
                w: bbox_w,
                h: bbox_h,
                pixels,
            });
        }

        Ok(results)
    }
}

impl ImageProcessorTrait for CPUProcessor {
    fn convert(
        &mut self,
        src: &TensorImage,
        dst: &mut TensorImage,
        rotation: Rotation,
        flip: Flip,
        crop: Crop,
    ) -> Result<()> {
        // Int8 formats: convert directly into dst as uint8 (layouts are
        // identical), then XOR 0x80 in-place. Avoids a temporary allocation.
        if fourcc_is_int8(dst.fourcc()) {
            let int8_fourcc = dst.fourcc();
            dst.set_fourcc(fourcc_uint8_equivalent(int8_fourcc));
            self.convert(src, dst, rotation, flip, crop)?;
            dst.set_fourcc(int8_fourcc);
            let mut dst_map = dst.tensor().map()?;
            for byte in dst_map.iter_mut() {
                *byte ^= 0x80;
            }
            return Ok(());
        }

        crop.check_crop(src, dst)?;
        // supported destinations and srcs:
        let intermediate = match (src.fourcc(), dst.fourcc()) {
            (NV12, RGB) => RGB,
            (NV12, RGBA) => RGBA,
            (NV12, GREY) => GREY,
            (NV12, YUYV) => RGBA, // RGBA intermediary for YUYV dest resize/convert/rotation/flip
            (NV12, NV16) => RGBA, // RGBA intermediary for YUYV dest resize/convert/rotation/flip
            (NV12, PLANAR_RGB) => RGB,
            (NV12, PLANAR_RGBA) => RGBA,
            (YUYV, RGB) => RGB,
            (YUYV, RGBA) => RGBA,
            (YUYV, GREY) => GREY,
            (YUYV, YUYV) => RGBA, // RGBA intermediary for YUYV dest resize/convert/rotation/flip
            (YUYV, PLANAR_RGB) => RGB,
            (YUYV, PLANAR_RGBA) => RGBA,
            (YUYV, NV16) => RGBA,
            (VYUY, RGB) => RGB,
            (VYUY, RGBA) => RGBA,
            (VYUY, GREY) => GREY,
            (VYUY, VYUY) => RGBA, // RGBA intermediary for VYUY dest resize/convert/rotation/flip
            (VYUY, PLANAR_RGB) => RGB,
            (VYUY, PLANAR_RGBA) => RGBA,
            (VYUY, NV16) => RGBA,
            (RGBA, RGB) => RGBA,
            (RGBA, RGBA) => RGBA,
            (RGBA, GREY) => GREY,
            (RGBA, YUYV) => RGBA, // RGBA intermediary for YUYV dest resize/convert/rotation/flip
            (RGBA, PLANAR_RGB) => RGBA,
            (RGBA, PLANAR_RGBA) => RGBA,
            (RGBA, NV16) => RGBA,
            (RGB, RGB) => RGB,
            (RGB, RGBA) => RGB,
            (RGB, GREY) => GREY,
            (RGB, YUYV) => RGB, // RGB intermediary for YUYV dest resize/convert/rotation/flip
            (RGB, PLANAR_RGB) => RGB,
            (RGB, PLANAR_RGBA) => RGB,
            (RGB, NV16) => RGB,
            (GREY, RGB) => RGB,
            (GREY, RGBA) => RGBA,
            (GREY, GREY) => GREY,
            (GREY, YUYV) => GREY,
            (GREY, PLANAR_RGB) => GREY,
            (GREY, PLANAR_RGBA) => GREY,
            (GREY, NV16) => GREY,
            (NV12, BGRA) => RGBA,
            (YUYV, BGRA) => RGBA,
            (VYUY, BGRA) => RGBA,
            (RGBA, BGRA) => RGBA,
            (RGB, BGRA) => RGB,
            (GREY, BGRA) => GREY,
            (BGRA, BGRA) => BGRA,
            (s, d) => {
                return Err(Error::NotSupported(format!(
                    "Conversion from {} to {}",
                    s.display(),
                    d.display()
                )));
            }
        };

        // let crop = crop.src_rect;

        let need_resize_flip_rotation = rotation != Rotation::None
            || flip != Flip::None
            || src.width() != dst.width()
            || src.height() != dst.height()
            || crop.src_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: src.width(),
                    height: src.height(),
                }
            })
            || crop.dst_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: dst.width(),
                    height: dst.height(),
                }
            });

        // check if a direct conversion can be done
        if !need_resize_flip_rotation && Self::support_conversion(src.fourcc(), dst.fourcc()) {
            return Self::convert_format(src, dst);
        };

        // any extra checks
        if dst.fourcc() == YUYV && !dst.width().is_multiple_of(2) {
            return Err(Error::NotSupported(format!(
                "{} destination must have width divisible by 2",
                dst.fourcc().display(),
            )));
        }

        // create tmp buffer
        let mut tmp_buffer;
        let tmp;
        if intermediate != src.fourcc() {
            tmp_buffer = TensorImage::new(
                src.width(),
                src.height(),
                intermediate,
                Some(edgefirst_tensor::TensorMemory::Mem),
            )?;

            Self::convert_format(src, &mut tmp_buffer)?;
            tmp = &tmp_buffer;
        } else {
            tmp = src;
        }

        // format must be RGB/RGBA/GREY
        matches!(tmp.fourcc(), RGB | RGBA | GREY);
        if tmp.fourcc() == dst.fourcc() {
            self.resize_flip_rotate(tmp, dst, rotation, flip, crop)?;
        } else if !need_resize_flip_rotation {
            Self::convert_format(tmp, dst)?;
        } else {
            let mut tmp2 = TensorImage::new(
                dst.width(),
                dst.height(),
                tmp.fourcc(),
                Some(edgefirst_tensor::TensorMemory::Mem),
            )?;
            if crop.dst_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: dst.width(),
                    height: dst.height(),
                }
            }) && crop.dst_color.is_none()
            {
                // convert the dst into tmp2 when there is a dst crop
                // TODO: this could be optimized by changing convert_format to take a
                // destination crop?

                Self::convert_format(dst, &mut tmp2)?;
            }
            self.resize_flip_rotate(tmp, &mut tmp2, rotation, flip, crop)?;
            Self::convert_format(&tmp2, dst)?;
        }
        if let (Some(dst_rect), Some(dst_color)) = (crop.dst_rect, crop.dst_color) {
            let full_rect = Rect {
                left: 0,
                top: 0,
                width: dst.width(),
                height: dst.height(),
            };
            if dst_rect != full_rect {
                Self::fill_image_outside_crop(dst, dst_color, dst_rect)?;
            }
        }

        Ok(())
    }

    fn convert_ref(
        &mut self,
        src: &TensorImage,
        dst: &mut TensorImageRef<'_>,
        rotation: Rotation,
        flip: Flip,
        crop: Crop,
    ) -> Result<()> {
        crop.check_crop_ref(src, dst)?;

        // Determine intermediate format needed for conversion
        let intermediate = match (src.fourcc(), dst.fourcc()) {
            (NV12, RGB) => RGB,
            (NV12, RGBA) => RGBA,
            (NV12, GREY) => GREY,
            (NV12, PLANAR_RGB) => RGB,
            (NV12, PLANAR_RGBA) => RGBA,
            (YUYV, RGB) => RGB,
            (YUYV, RGBA) => RGBA,
            (YUYV, GREY) => GREY,
            (YUYV, PLANAR_RGB) => RGB,
            (YUYV, PLANAR_RGBA) => RGBA,
            (VYUY, RGB) => RGB,
            (VYUY, RGBA) => RGBA,
            (VYUY, GREY) => GREY,
            (VYUY, PLANAR_RGB) => RGB,
            (VYUY, PLANAR_RGBA) => RGBA,
            (RGBA, RGB) => RGBA,
            (RGBA, RGBA) => RGBA,
            (RGBA, GREY) => GREY,
            (RGBA, PLANAR_RGB) => RGBA,
            (RGBA, PLANAR_RGBA) => RGBA,
            (RGB, RGB) => RGB,
            (RGB, RGBA) => RGB,
            (RGB, GREY) => GREY,
            (RGB, PLANAR_RGB) => RGB,
            (RGB, PLANAR_RGBA) => RGB,
            (GREY, RGB) => RGB,
            (GREY, RGBA) => RGBA,
            (GREY, GREY) => GREY,
            (GREY, PLANAR_RGB) => GREY,
            (GREY, PLANAR_RGBA) => GREY,
            (s, d) => {
                return Err(Error::NotSupported(format!(
                    "Conversion from {} to {}",
                    s.display(),
                    d.display()
                )));
            }
        };

        let need_resize_flip_rotation = rotation != Rotation::None
            || flip != Flip::None
            || src.width() != dst.width()
            || src.height() != dst.height()
            || crop.src_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: src.width(),
                    height: src.height(),
                }
            })
            || crop.dst_rect.is_some_and(|crop| {
                crop != Rect {
                    left: 0,
                    top: 0,
                    width: dst.width(),
                    height: dst.height(),
                }
            });

        // Simple case: no resize/flip/rotation needed
        if !need_resize_flip_rotation {
            // Try direct generic conversion (zero-copy path)
            if let Ok(()) = Self::convert_format_generic(src, dst) {
                return Ok(());
            }
        }

        // Complex case: need intermediate buffers
        // First, convert source to intermediate format if needed
        let mut tmp_buffer;
        let tmp: &TensorImage;
        if intermediate != src.fourcc() {
            tmp_buffer = TensorImage::new(
                src.width(),
                src.height(),
                intermediate,
                Some(edgefirst_tensor::TensorMemory::Mem),
            )?;
            Self::convert_format(src, &mut tmp_buffer)?;
            tmp = &tmp_buffer;
        } else {
            tmp = src;
        }

        // Process resize/flip/rotation if needed
        if need_resize_flip_rotation {
            // Create intermediate buffer for resize output
            let mut tmp2 = TensorImage::new(
                dst.width(),
                dst.height(),
                tmp.fourcc(),
                Some(edgefirst_tensor::TensorMemory::Mem),
            )?;
            self.resize_flip_rotate(tmp, &mut tmp2, rotation, flip, crop)?;

            // Final conversion to destination (zero-copy into dst)
            Self::convert_format_generic(&tmp2, dst)?;
        } else {
            // Direct conversion (already checked above, but handle edge cases)
            Self::convert_format_generic(tmp, dst)?;
        }

        // Handle destination crop fill if needed
        if let (Some(dst_rect), Some(dst_color)) = (crop.dst_rect, crop.dst_color) {
            let full_rect = Rect {
                left: 0,
                top: 0,
                width: dst.width(),
                height: dst.height(),
            };
            if dst_rect != full_rect {
                Self::fill_image_outside_crop_generic(dst, dst_color, dst_rect)?;
            }
        }

        Ok(())
    }

    fn draw_masks(
        &mut self,
        dst: &mut TensorImage,
        detect: &[DetectBox],
        segmentation: &[Segmentation],
    ) -> Result<()> {
        if !matches!(dst.fourcc(), RGBA | RGB) {
            return Err(crate::Error::NotSupported(
                "CPU image rendering only supports RGBA or RGB images".to_string(),
            ));
        }

        let _timer = FunctionTimer::new("CPUProcessor::draw_masks");

        let mut map = dst.tensor.map()?;
        let dst_slice = map.as_mut_slice();

        self.render_box(dst, dst_slice, detect)?;

        if segmentation.is_empty() {
            return Ok(());
        }

        // Semantic segmentation (e.g. ModelPack) has C > 1 (multi-class),
        // instance segmentation (e.g. YOLO) has C = 1 (binary per-instance).
        let is_semantic = segmentation[0].segmentation.shape()[2] > 1;

        if is_semantic {
            self.render_modelpack_segmentation(dst, dst_slice, &segmentation[0])?;
        } else {
            for (seg, detect) in segmentation.iter().zip(detect) {
                self.render_yolo_segmentation(dst, dst_slice, seg, detect.label)?;
            }
        }

        Ok(())
    }

    fn draw_masks_proto(
        &mut self,
        dst: &mut TensorImage,
        detect: &[DetectBox],
        proto_data: &ProtoData,
    ) -> Result<()> {
        if !matches!(dst.fourcc(), RGBA | RGB) {
            return Err(crate::Error::NotSupported(
                "CPU image rendering only supports RGBA or RGB images".to_string(),
            ));
        }

        let _timer = FunctionTimer::new("CPUProcessor::draw_masks_proto");

        let mut map = dst.tensor.map()?;
        let dst_slice = map.as_mut_slice();

        self.render_box(dst, dst_slice, detect)?;

        if detect.is_empty() || proto_data.mask_coefficients.is_empty() {
            return Ok(());
        }

        let protos_cow = proto_data.protos.as_f32();
        let protos = protos_cow.as_ref();
        let proto_h = protos.shape()[0];
        let proto_w = protos.shape()[1];
        let num_protos = protos.shape()[2];
        let dst_w = dst.width();
        let dst_h = dst.height();
        let row_stride = dst.row_stride();
        let channels = dst.channels();

        for (det, coeff) in detect.iter().zip(proto_data.mask_coefficients.iter()) {
            let color = self.colors[det.label % self.colors.len()];
            let alpha = color[3] as u16;

            // Pixel bounds of the detection in dst image space
            let start_x = (dst_w as f32 * det.bbox.xmin).round() as usize;
            let start_y = (dst_h as f32 * det.bbox.ymin).round() as usize;
            let end_x = ((dst_w as f32 * det.bbox.xmax).round() as usize).min(dst_w);
            let end_y = ((dst_h as f32 * det.bbox.ymax).round() as usize).min(dst_h);

            for y in start_y..end_y {
                for x in start_x..end_x {
                    // Map pixel (x, y) to proto space
                    let px = (x as f32 / dst_w as f32) * proto_w as f32 - 0.5;
                    let py = (y as f32 / dst_h as f32) * proto_h as f32 - 0.5;

                    // Bilinear interpolation + dot product
                    let acc = bilinear_dot(protos, coeff, num_protos, px, py, proto_w, proto_h);

                    // Sigmoid threshold
                    let mask = 1.0 / (1.0 + (-acc).exp());
                    if mask < 0.5 {
                        continue;
                    }

                    // Alpha blend
                    let dst_index = y * row_stride + x * channels;
                    for c in 0..3 {
                        dst_slice[dst_index + c] = ((color[c] as u16 * alpha
                            + dst_slice[dst_index + c] as u16 * (255 - alpha))
                            / 255) as u8;
                    }
                }
            }
        }

        Ok(())
    }

    fn decode_masks_atlas(
        &mut self,
        detect: &[crate::DetectBox],
        proto_data: crate::ProtoData,
        output_width: usize,
        output_height: usize,
    ) -> Result<(Vec<u8>, Vec<crate::MaskRegion>)> {
        use crate::FunctionTimer;

        let _timer = FunctionTimer::new("CPUProcessor::decode_masks_atlas");

        let padding = 4usize;

        // Render per-detection masks via existing path
        let mask_results =
            self.render_masks_from_protos(detect, proto_data, output_width, output_height)?;

        // Pack into compact atlas: each strip is padded bbox height
        let ow = output_width as i32;
        let oh = output_height as i32;
        let pad = padding as i32;

        let mut regions = Vec::with_capacity(mask_results.len());
        let mut atlas_y = 0usize;

        // Pre-compute regions
        for mr in &mask_results {
            let bx = mr.x as i32;
            let by = mr.y as i32;
            let bw = mr.w as i32;
            let bh = mr.h as i32;
            let padded_x = (bx - pad).max(0);
            let padded_y = (by - pad).max(0);
            let padded_w = ((bx + bw + pad).min(ow) - padded_x).max(1);
            let padded_h = ((by + bh + pad).min(oh) - padded_y).max(1);
            regions.push(crate::MaskRegion {
                atlas_y_offset: atlas_y,
                padded_x: padded_x as usize,
                padded_y: padded_y as usize,
                padded_w: padded_w as usize,
                padded_h: padded_h as usize,
                bbox_x: mr.x,
                bbox_y: mr.y,
                bbox_w: mr.w,
                bbox_h: mr.h,
            });
            atlas_y += padded_h as usize;
        }

        let atlas_height = atlas_y;
        let mut atlas = vec![0u8; output_width * atlas_height];

        for (mr, region) in mask_results.iter().zip(regions.iter()) {
            // Copy mask pixels into the atlas at the correct position
            for row in 0..mr.h {
                let dst_row = region.atlas_y_offset + (mr.y - region.padded_y) + row;
                let dst_start = dst_row * output_width + mr.x;
                let src_start = row * mr.w;
                if dst_start + mr.w <= atlas.len() && src_start + mr.w <= mr.pixels.len() {
                    atlas[dst_start..dst_start + mr.w]
                        .copy_from_slice(&mr.pixels[src_start..src_start + mr.w]);
                }
            }
        }

        Ok((atlas, regions))
    }

    fn set_class_colors(&mut self, colors: &[[u8; 4]]) -> Result<()> {
        for (c, new_c) in self.colors.iter_mut().zip(colors.iter()) {
            *c = *new_c;
        }
        Ok(())
    }
}

/// Bilinear interpolation of proto values at `(px, py)` combined with dot
/// product against `coeff`. Returns the scalar accumulator before sigmoid.
///
/// Samples the four nearest proto texels, weights by bilinear coefficients,
/// and simultaneously computes the dot product with the mask coefficients.
#[inline]
fn bilinear_dot(
    protos: &ndarray::Array3<f32>,
    coeff: &[f32],
    num_protos: usize,
    px: f32,
    py: f32,
    proto_w: usize,
    proto_h: usize,
) -> f32 {
    let x0 = (px.floor() as isize).clamp(0, proto_w as isize - 1) as usize;
    let y0 = (py.floor() as isize).clamp(0, proto_h as isize - 1) as usize;
    let x1 = (x0 + 1).min(proto_w - 1);
    let y1 = (y0 + 1).min(proto_h - 1);

    let fx = px - px.floor();
    let fy = py - py.floor();

    let w00 = (1.0 - fx) * (1.0 - fy);
    let w10 = fx * (1.0 - fy);
    let w01 = (1.0 - fx) * fy;
    let w11 = fx * fy;

    let mut acc = 0.0f32;
    for p in 0..num_protos {
        let val = w00 * protos[[y0, x0, p]]
            + w10 * protos[[y0, x1, p]]
            + w01 * protos[[y1, x0, p]]
            + w11 * protos[[y1, x1, p]];
        acc += coeff[p] * val;
    }
    acc
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod cpu_tests {

    use super::*;
    use crate::{CPUProcessor, Rotation, TensorImageRef, BGRA, RGBA};
    use edgefirst_tensor::{Tensor, TensorMapTrait, TensorMemory};
    use image::buffer::ConvertBuffer;

    macro_rules! function {
        () => {{
            fn f() {}
            fn type_name_of<T>(_: T) -> &'static str {
                std::any::type_name::<T>()
            }
            let name = type_name_of(f);

            // Find and cut the rest of the path
            match &name[..name.len() - 3].rfind(':') {
                Some(pos) => &name[pos + 1..name.len() - 3],
                None => &name[..name.len() - 3],
            }
        }};
    }

    fn compare_images_convert_to_grey(
        img1: &TensorImage,
        img2: &TensorImage,
        threshold: f64,
        name: &str,
    ) {
        assert_eq!(img1.height(), img2.height(), "Heights differ");
        assert_eq!(img1.width(), img2.width(), "Widths differ");

        let mut img_rgb1 = TensorImage::new(img1.width(), img1.height(), RGBA, None).unwrap();
        let mut img_rgb2 = TensorImage::new(img1.width(), img1.height(), RGBA, None).unwrap();
        CPUProcessor::convert_format(img1, &mut img_rgb1).unwrap();
        CPUProcessor::convert_format(img2, &mut img_rgb2).unwrap();

        let image1 = image::RgbaImage::from_vec(
            img_rgb1.width() as u32,
            img_rgb1.height() as u32,
            img_rgb1.tensor().map().unwrap().to_vec(),
        )
        .unwrap();

        let image2 = image::RgbaImage::from_vec(
            img_rgb2.width() as u32,
            img_rgb2.height() as u32,
            img_rgb2.tensor().map().unwrap().to_vec(),
        )
        .unwrap();

        let similarity = image_compare::gray_similarity_structure(
            &image_compare::Algorithm::RootMeanSquared,
            &image1.convert(),
            &image2.convert(),
        )
        .expect("Image Comparison failed");
        if similarity.score < threshold {
            // image1.save(format!("{name}_1.png"));
            // image2.save(format!("{name}_2.png"));
            similarity
                .image
                .to_color_map()
                .save(format!("{name}.png"))
                .unwrap();
            panic!(
                "{name}: converted image and target image have similarity score too low: {} < {}",
                similarity.score, threshold
            )
        }
    }

    fn compare_images_convert_to_rgb(
        img1: &TensorImage,
        img2: &TensorImage,
        threshold: f64,
        name: &str,
    ) {
        assert_eq!(img1.height(), img2.height(), "Heights differ");
        assert_eq!(img1.width(), img2.width(), "Widths differ");

        let mut img_rgb1 = TensorImage::new(img1.width(), img1.height(), RGB, None).unwrap();
        let mut img_rgb2 = TensorImage::new(img1.width(), img1.height(), RGB, None).unwrap();
        CPUProcessor::convert_format(img1, &mut img_rgb1).unwrap();
        CPUProcessor::convert_format(img2, &mut img_rgb2).unwrap();

        let image1 = image::RgbImage::from_vec(
            img_rgb1.width() as u32,
            img_rgb1.height() as u32,
            img_rgb1.tensor().map().unwrap().to_vec(),
        )
        .unwrap();

        let image2 = image::RgbImage::from_vec(
            img_rgb2.width() as u32,
            img_rgb2.height() as u32,
            img_rgb2.tensor().map().unwrap().to_vec(),
        )
        .unwrap();

        let similarity = image_compare::rgb_similarity_structure(
            &image_compare::Algorithm::RootMeanSquared,
            &image1,
            &image2,
        )
        .expect("Image Comparison failed");
        if similarity.score < threshold {
            // image1.save(format!("{name}_1.png"));
            // image2.save(format!("{name}_2.png"));
            similarity
                .image
                .to_color_map()
                .save(format!("{name}.png"))
                .unwrap();
            panic!(
                "{name}: converted image and target image have similarity score too low: {} < {}",
                similarity.score, threshold
            )
        }
    }

    fn load_bytes_to_tensor(
        width: usize,
        height: usize,
        fourcc: FourCharCode,
        memory: Option<TensorMemory>,
        bytes: &[u8],
    ) -> Result<TensorImage, Error> {
        log::debug!("Current function is {}", function!());
        let src = TensorImage::new(width, height, fourcc, memory)?;
        src.tensor().map()?.as_mut_slice()[0..bytes.len()].copy_from_slice(bytes);
        Ok(src)
    }

    macro_rules! generate_conversion_tests {
        (
        $src_fmt:ident,  $src_file:expr, $dst_fmt:ident, $dst_file:expr
    ) => {{
            // Load source
            let src = load_bytes_to_tensor(
                1280,
                720,
                $src_fmt,
                None,
                include_bytes!(concat!("../../../testdata/", $src_file)),
            )?;

            // Load destination reference
            let dst = load_bytes_to_tensor(
                1280,
                720,
                $dst_fmt,
                None,
                include_bytes!(concat!("../../../testdata/", $dst_file)),
            )?;

            let mut converter = CPUProcessor::default();

            let mut converted = TensorImage::new(src.width(), src.height(), dst.fourcc(), None)?;

            converter.convert(
                &src,
                &mut converted,
                Rotation::None,
                Flip::None,
                Crop::default(),
            )?;

            compare_images_convert_to_rgb(&dst, &converted, 0.99, function!());

            Ok(())
        }};
    }

    macro_rules! generate_conversion_tests_greyscale {
        (
        $src_fmt:ident,  $src_file:expr, $dst_fmt:ident, $dst_file:expr
    ) => {{
            // Load source
            let src = load_bytes_to_tensor(
                1280,
                720,
                $src_fmt,
                None,
                include_bytes!(concat!("../../../testdata/", $src_file)),
            )?;

            // Load destination reference
            let dst = load_bytes_to_tensor(
                1280,
                720,
                $dst_fmt,
                None,
                include_bytes!(concat!("../../../testdata/", $dst_file)),
            )?;

            let mut converter = CPUProcessor::default();

            let mut converted = TensorImage::new(src.width(), src.height(), dst.fourcc(), None)?;

            converter.convert(
                &src,
                &mut converted,
                Rotation::None,
                Flip::None,
                Crop::default(),
            )?;

            compare_images_convert_to_grey(&dst, &converted, 0.985, function!());

            Ok(())
        }};
    }

    // let mut dsts = [yuyv, rgb, rgba, grey, nv16, planar_rgb, planar_rgba];

    #[test]
    fn test_cpu_yuyv_to_yuyv() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", YUYV, "camera720p.yuyv")
    }

    #[test]
    fn test_cpu_yuyv_to_rgb() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", RGB, "camera720p.rgb")
    }

    #[test]
    fn test_cpu_yuyv_to_rgba() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", RGBA, "camera720p.rgba")
    }

    #[test]
    fn test_cpu_yuyv_to_grey() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", GREY, "camera720p.y800")
    }

    #[test]
    fn test_cpu_yuyv_to_nv16() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", NV16, "camera720p.nv16")
    }

    #[test]
    fn test_cpu_yuyv_to_planar_rgb() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", PLANAR_RGB, "camera720p.8bps")
    }

    #[test]
    fn test_cpu_yuyv_to_planar_rgba() -> Result<()> {
        generate_conversion_tests!(YUYV, "camera720p.yuyv", PLANAR_RGBA, "camera720p.8bpa")
    }

    #[test]
    fn test_cpu_rgb_to_yuyv() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", YUYV, "camera720p.yuyv")
    }

    #[test]
    fn test_cpu_rgb_to_rgb() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", RGB, "camera720p.rgb")
    }

    #[test]
    fn test_cpu_rgb_to_rgba() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", RGBA, "camera720p.rgba")
    }

    #[test]
    fn test_cpu_rgb_to_grey() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", GREY, "camera720p.y800")
    }

    #[test]
    fn test_cpu_rgb_to_nv16() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", NV16, "camera720p.nv16")
    }

    #[test]
    fn test_cpu_rgb_to_planar_rgb() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", PLANAR_RGB, "camera720p.8bps")
    }

    #[test]
    fn test_cpu_rgb_to_planar_rgba() -> Result<()> {
        generate_conversion_tests!(RGB, "camera720p.rgb", PLANAR_RGBA, "camera720p.8bpa")
    }

    #[test]
    fn test_cpu_rgba_to_yuyv() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", YUYV, "camera720p.yuyv")
    }

    #[test]
    fn test_cpu_rgba_to_rgb() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", RGB, "camera720p.rgb")
    }

    #[test]
    fn test_cpu_rgba_to_rgba() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", RGBA, "camera720p.rgba")
    }

    #[test]
    fn test_cpu_rgba_to_grey() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", GREY, "camera720p.y800")
    }

    #[test]
    fn test_cpu_rgba_to_nv16() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", NV16, "camera720p.nv16")
    }

    #[test]
    fn test_cpu_rgba_to_planar_rgb() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", PLANAR_RGB, "camera720p.8bps")
    }

    #[test]
    fn test_cpu_rgba_to_planar_rgba() -> Result<()> {
        generate_conversion_tests!(RGBA, "camera720p.rgba", PLANAR_RGBA, "camera720p.8bpa")
    }

    #[test]
    fn test_cpu_nv12_to_rgb() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", RGB, "camera720p.rgb")
    }

    #[test]
    fn test_cpu_nv12_to_yuyv() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", YUYV, "camera720p.yuyv")
    }

    #[test]
    fn test_cpu_nv12_to_rgba() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", RGBA, "camera720p.rgba")
    }

    #[test]
    fn test_cpu_nv12_to_grey() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", GREY, "camera720p.y800")
    }

    #[test]
    fn test_cpu_nv12_to_nv16() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", NV16, "camera720p.nv16")
    }

    #[test]
    fn test_cpu_nv12_to_planar_rgb() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", PLANAR_RGB, "camera720p.8bps")
    }

    #[test]
    fn test_cpu_nv12_to_planar_rgba() -> Result<()> {
        generate_conversion_tests!(NV12, "camera720p.nv12", PLANAR_RGBA, "camera720p.8bpa")
    }

    #[test]
    fn test_cpu_grey_to_yuyv() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", YUYV, "camera720p.yuyv")
    }

    #[test]
    fn test_cpu_grey_to_rgb() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", RGB, "camera720p.rgb")
    }

    #[test]
    fn test_cpu_grey_to_rgba() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", RGBA, "camera720p.rgba")
    }

    #[test]
    fn test_cpu_grey_to_grey() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", GREY, "camera720p.y800")
    }

    #[test]
    fn test_cpu_grey_to_nv16() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", NV16, "camera720p.nv16")
    }

    #[test]
    fn test_cpu_grey_to_planar_rgb() -> Result<()> {
        generate_conversion_tests_greyscale!(GREY, "camera720p.y800", PLANAR_RGB, "camera720p.8bps")
    }

    #[test]
    fn test_cpu_grey_to_planar_rgba() -> Result<()> {
        generate_conversion_tests_greyscale!(
            GREY,
            "camera720p.y800",
            PLANAR_RGBA,
            "camera720p.8bpa"
        )
    }

    #[test]
    fn test_cpu_nearest() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(2, 1, RGB, None, &[0, 0, 0, 255, 255, 255])?;

        let mut converter = CPUProcessor::new_nearest();

        let mut converted = TensorImage::new(4, 1, RGB, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop::default(),
        )?;

        assert_eq!(
            &converted.tensor().map()?.as_slice(),
            &[0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_rotate_cw() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(
            2,
            2,
            RGBA,
            None,
            &[0, 0, 0, 255, 1, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255],
        )?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(4, 4, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::Clockwise90,
            Flip::None,
            Crop::default(),
        )?;

        assert_eq!(&converted.tensor().map()?.as_slice()[0..4], &[2, 2, 2, 255]);
        assert_eq!(
            &converted.tensor().map()?.as_slice()[12..16],
            &[0, 0, 0, 255]
        );
        assert_eq!(
            &converted.tensor().map()?.as_slice()[48..52],
            &[3, 3, 3, 255]
        );

        assert_eq!(
            &converted.tensor().map()?.as_slice()[60..64],
            &[1, 1, 1, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_rotate_ccw() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(
            2,
            2,
            RGBA,
            None,
            &[0, 0, 0, 255, 1, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255],
        )?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(4, 4, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::CounterClockwise90,
            Flip::None,
            Crop::default(),
        )?;

        assert_eq!(&converted.tensor().map()?.as_slice()[0..4], &[1, 1, 1, 255]);
        assert_eq!(
            &converted.tensor().map()?.as_slice()[12..16],
            &[3, 3, 3, 255]
        );
        assert_eq!(
            &converted.tensor().map()?.as_slice()[48..52],
            &[0, 0, 0, 255]
        );

        assert_eq!(
            &converted.tensor().map()?.as_slice()[60..64],
            &[2, 2, 2, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_rotate_180() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(
            2,
            2,
            RGBA,
            None,
            &[0, 0, 0, 255, 1, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255],
        )?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(4, 4, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::Rotate180,
            Flip::None,
            Crop::default(),
        )?;

        assert_eq!(&converted.tensor().map()?.as_slice()[0..4], &[3, 3, 3, 255]);
        assert_eq!(
            &converted.tensor().map()?.as_slice()[12..16],
            &[2, 2, 2, 255]
        );
        assert_eq!(
            &converted.tensor().map()?.as_slice()[48..52],
            &[1, 1, 1, 255]
        );

        assert_eq!(
            &converted.tensor().map()?.as_slice()[60..64],
            &[0, 0, 0, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_flip_v() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(
            2,
            2,
            RGBA,
            None,
            &[0, 0, 0, 255, 1, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255],
        )?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(4, 4, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::Vertical,
            Crop::default(),
        )?;

        assert_eq!(&converted.tensor().map()?.as_slice()[0..4], &[2, 2, 2, 255]);
        assert_eq!(
            &converted.tensor().map()?.as_slice()[12..16],
            &[3, 3, 3, 255]
        );
        assert_eq!(
            &converted.tensor().map()?.as_slice()[48..52],
            &[0, 0, 0, 255]
        );

        assert_eq!(
            &converted.tensor().map()?.as_slice()[60..64],
            &[1, 1, 1, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_flip_h() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(
            2,
            2,
            RGBA,
            None,
            &[0, 0, 0, 255, 1, 1, 1, 255, 2, 2, 2, 255, 3, 3, 3, 255],
        )?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(4, 4, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::Horizontal,
            Crop::default(),
        )?;

        assert_eq!(&converted.tensor().map()?.as_slice()[0..4], &[1, 1, 1, 255]);
        assert_eq!(
            &converted.tensor().map()?.as_slice()[12..16],
            &[0, 0, 0, 255]
        );
        assert_eq!(
            &converted.tensor().map()?.as_slice()[48..52],
            &[3, 3, 3, 255]
        );

        assert_eq!(
            &converted.tensor().map()?.as_slice()[60..64],
            &[2, 2, 2, 255]
        );

        Ok(())
    }

    #[test]
    fn test_cpu_src_crop() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(2, 2, GREY, None, &[10, 20, 30, 40])?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(2, 2, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop::new().with_src_rect(Some(Rect::new(0, 0, 1, 2))),
        )?;

        assert_eq!(
            converted.tensor().map()?.as_slice(),
            &[10, 10, 10, 255, 13, 13, 13, 255, 30, 30, 30, 255, 33, 33, 33, 255]
        );
        Ok(())
    }

    #[test]
    fn test_cpu_dst_crop() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(2, 2, GREY, None, &[2, 4, 6, 8])?;

        let mut converter = CPUProcessor::default();

        let mut converted =
            load_bytes_to_tensor(2, 2, YUYV, None, &[200, 128, 200, 128, 200, 128, 200, 128])?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop::new().with_dst_rect(Some(Rect::new(0, 0, 2, 1))),
        )?;

        assert_eq!(
            converted.tensor().map()?.as_slice(),
            &[20, 128, 21, 128, 200, 128, 200, 128]
        );
        Ok(())
    }

    #[test]
    fn test_cpu_fill_rgba() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(1, 1, RGBA, None, &[3, 3, 3, 255])?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(2, 2, RGBA, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop {
                src_rect: None,
                dst_rect: Some(Rect {
                    left: 1,
                    top: 1,
                    width: 1,
                    height: 1,
                }),
                dst_color: Some([255, 0, 0, 255]),
            },
        )?;

        assert_eq!(
            converted.tensor().map()?.as_slice(),
            &[255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 3, 3, 3, 255]
        );
        Ok(())
    }

    #[test]
    fn test_cpu_fill_yuyv() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(2, 1, RGBA, None, &[3, 3, 3, 255, 3, 3, 3, 255])?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(2, 3, YUYV, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop {
                src_rect: None,
                dst_rect: Some(Rect {
                    left: 0,
                    top: 1,
                    width: 2,
                    height: 1,
                }),
                dst_color: Some([255, 0, 0, 255]),
            },
        )?;

        assert_eq!(
            converted.tensor().map()?.as_slice(),
            &[63, 102, 63, 240, 19, 128, 19, 128, 63, 102, 63, 240]
        );
        Ok(())
    }

    #[test]
    fn test_cpu_fill_grey() -> Result<()> {
        // Load source
        let src = load_bytes_to_tensor(2, 1, RGBA, None, &[3, 3, 3, 255, 3, 3, 3, 255])?;

        let mut converter = CPUProcessor::default();

        let mut converted = TensorImage::new(2, 3, GREY, None)?;

        converter.convert(
            &src,
            &mut converted,
            Rotation::None,
            Flip::None,
            Crop {
                src_rect: None,
                dst_rect: Some(Rect {
                    left: 0,
                    top: 1,
                    width: 2,
                    height: 1,
                }),
                dst_color: Some([200, 200, 200, 255]),
            },
        )?;

        assert_eq!(
            converted.tensor().map()?.as_slice(),
            &[200, 200, 3, 3, 200, 200]
        );
        Ok(())
    }

    #[test]
    fn test_segmentation() {
        use edgefirst_decoder::Segmentation;
        use ndarray::Array3;

        let mut image = TensorImage::load(
            include_bytes!("../../../testdata/giraffe.jpg"),
            Some(RGBA),
            None,
        )
        .unwrap();

        let mut segmentation = Array3::from_shape_vec(
            (2, 160, 160),
            include_bytes!("../../../testdata/modelpack_seg_2x160x160.bin").to_vec(),
        )
        .unwrap();
        segmentation.swap_axes(0, 1);
        segmentation.swap_axes(1, 2);
        let segmentation = segmentation.as_standard_layout().to_owned();

        let seg = Segmentation {
            segmentation,
            xmin: 0.0,
            ymin: 0.0,
            xmax: 1.0,
            ymax: 1.0,
        };

        let mut renderer = CPUProcessor::new();
        renderer.draw_masks(&mut image, &[], &[seg]).unwrap();

        image.save_jpeg("test_segmentation.jpg", 80).unwrap();
    }

    #[test]
    fn test_segmentation_yolo() {
        use edgefirst_decoder::Segmentation;
        use ndarray::Array3;

        let mut image = TensorImage::load(
            include_bytes!("../../../testdata/giraffe.jpg"),
            Some(RGBA),
            None,
        )
        .unwrap();

        let segmentation = Array3::from_shape_vec(
            (76, 55, 1),
            include_bytes!("../../../testdata/yolov8_seg_crop_76x55.bin").to_vec(),
        )
        .unwrap();

        let detect = DetectBox {
            bbox: [0.59375, 0.25, 0.9375, 0.725].into(),
            score: 0.99,
            label: 1,
        };

        let seg = Segmentation {
            segmentation,
            xmin: 0.59375,
            ymin: 0.25,
            xmax: 0.9375,
            ymax: 0.725,
        };

        let mut renderer = CPUProcessor::new();
        renderer
            .set_class_colors(&[[255, 255, 0, 233], [128, 128, 255, 100]])
            .unwrap();
        assert_eq!(renderer.colors[1], [128, 128, 255, 100]);
        renderer.draw_masks(&mut image, &[detect], &[seg]).unwrap();
        let expected = TensorImage::load(
            include_bytes!("../../../testdata/output_render_cpu.jpg"),
            Some(RGBA),
            None,
        )
        .unwrap();
        compare_images_convert_to_rgb(&image, &expected, 0.99, function!());
    }

    // =========================================================================
    // Generic Conversion Tests (TensorImageRef support)
    // =========================================================================

    #[test]
    fn test_convert_rgb_to_planar_rgb_generic() {
        // Create RGB source image
        let mut src = TensorImage::new(4, 4, RGB, None).unwrap();
        {
            let mut map = src.tensor_mut().map().unwrap();
            let data = map.as_mut_slice();
            // Fill with pattern: pixel 0 = [10, 20, 30], pixel 1 = [40, 50, 60], etc.
            for i in 0..16 {
                data[i * 3] = (i * 10) as u8;
                data[i * 3 + 1] = (i * 10 + 1) as u8;
                data[i * 3 + 2] = (i * 10 + 2) as u8;
            }
        }

        // Create planar RGB destination using TensorImageRef
        let mut tensor = Tensor::<u8>::new(&[3, 4, 4], None, None).unwrap();
        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, PLANAR_RGB).unwrap();

        CPUProcessor::convert_format_generic(&src, &mut dst).unwrap();

        // Verify the conversion - check first few pixels of each plane
        let map = dst.tensor().map().unwrap();
        let data = map.as_slice();

        // R plane starts at 0, G at 16, B at 32
        assert_eq!(data[0], 0); // R of pixel 0
        assert_eq!(data[16], 1); // G of pixel 0
        assert_eq!(data[32], 2); // B of pixel 0

        assert_eq!(data[1], 10); // R of pixel 1
        assert_eq!(data[17], 11); // G of pixel 1
        assert_eq!(data[33], 12); // B of pixel 1
    }

    #[test]
    fn test_convert_rgba_to_planar_rgb_generic() {
        // Create RGBA source image
        let mut src = TensorImage::new(4, 4, RGBA, None).unwrap();
        {
            let mut map = src.tensor_mut().map().unwrap();
            let data = map.as_mut_slice();
            // Fill with pattern
            for i in 0..16 {
                data[i * 4] = (i * 10) as u8; // R
                data[i * 4 + 1] = (i * 10 + 1) as u8; // G
                data[i * 4 + 2] = (i * 10 + 2) as u8; // B
                data[i * 4 + 3] = 255; // A (ignored)
            }
        }

        // Create planar RGB destination
        let mut tensor = Tensor::<u8>::new(&[3, 4, 4], None, None).unwrap();
        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, PLANAR_RGB).unwrap();

        CPUProcessor::convert_format_generic(&src, &mut dst).unwrap();

        // Verify the conversion
        let map = dst.tensor().map().unwrap();
        let data = map.as_slice();

        assert_eq!(data[0], 0); // R of pixel 0
        assert_eq!(data[16], 1); // G of pixel 0
        assert_eq!(data[32], 2); // B of pixel 0
    }

    #[test]
    fn test_copy_image_generic_same_format() {
        // Create source image with data
        let mut src = TensorImage::new(4, 4, RGB, None).unwrap();
        {
            let mut map = src.tensor_mut().map().unwrap();
            let data = map.as_mut_slice();
            for (i, byte) in data.iter_mut().enumerate() {
                *byte = (i % 256) as u8;
            }
        }

        // Create destination tensor
        let mut tensor = Tensor::<u8>::new(&[4, 4, 3], None, None).unwrap();
        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, RGB).unwrap();

        CPUProcessor::convert_format_generic(&src, &mut dst).unwrap();

        // Verify data was copied
        let src_map = src.tensor().map().unwrap();
        let dst_map = dst.tensor().map().unwrap();
        assert_eq!(src_map.as_slice(), dst_map.as_slice());
    }

    #[test]
    fn test_convert_format_generic_unsupported() {
        // Try unsupported conversion (NV12 to PLANAR_RGB)
        let src = TensorImage::new(8, 8, NV12, None).unwrap();
        let mut tensor = Tensor::<u8>::new(&[3, 8, 8], None, None).unwrap();
        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, PLANAR_RGB).unwrap();

        let result = CPUProcessor::convert_format_generic(&src, &mut dst);
        assert!(result.is_err());
        assert!(matches!(result, Err(Error::NotSupported(_))));
    }

    #[test]
    fn test_fill_image_outside_crop_generic_rgba() {
        let mut tensor = Tensor::<u8>::new(&[4, 4, 4], None, None).unwrap();
        // Initialize to zeros
        tensor.map().unwrap().as_mut_slice().fill(0);

        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, RGBA).unwrap();

        // Fill outside a 2x2 crop in the center with red
        let crop = Rect::new(1, 1, 2, 2);
        CPUProcessor::fill_image_outside_crop_generic(&mut dst, [255, 0, 0, 255], crop).unwrap();

        let map = dst.tensor().map().unwrap();
        let data = map.as_slice();

        // Top-left corner should be filled (red)
        assert_eq!(&data[0..4], &[255, 0, 0, 255]);

        // Center pixel (1,1) should still be zero (inside crop)
        // row=1, col=1, width=4, bytes_per_pixel=4 -> offset = (1*4 + 1) * 4 = 20
        let center_offset = 20;
        assert_eq!(&data[center_offset..center_offset + 4], &[0, 0, 0, 0]);
    }

    #[test]
    fn test_fill_image_outside_crop_generic_rgb() {
        let mut tensor = Tensor::<u8>::new(&[4, 4, 3], None, None).unwrap();
        tensor.map().unwrap().as_mut_slice().fill(0);

        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, RGB).unwrap();

        let crop = Rect::new(1, 1, 2, 2);
        CPUProcessor::fill_image_outside_crop_generic(&mut dst, [0, 255, 0, 255], crop).unwrap();

        let map = dst.tensor().map().unwrap();
        let data = map.as_slice();

        // Top-left corner should be green
        assert_eq!(&data[0..3], &[0, 255, 0]);

        // Center pixel (1,1): row=1, col=1, width=4, bytes=3 -> offset = (1*4 + 1) * 3
        // = 15
        let center_offset = 15;
        assert_eq!(&data[center_offset..center_offset + 3], &[0, 0, 0]);
    }

    #[test]
    fn test_fill_image_outside_crop_generic_planar_rgb() {
        let mut tensor = Tensor::<u8>::new(&[3, 4, 4], None, None).unwrap();
        tensor.map().unwrap().as_mut_slice().fill(0);

        let mut dst = TensorImageRef::from_borrowed_tensor(&mut tensor, PLANAR_RGB).unwrap();

        let crop = Rect::new(1, 1, 2, 2);
        CPUProcessor::fill_image_outside_crop_generic(&mut dst, [128, 64, 32, 255], crop).unwrap();

        let map = dst.tensor().map().unwrap();
        let data = map.as_slice();

        // For planar: R plane is [0..16], G plane is [16..32], B plane is [32..48]
        // Top-left pixel (0,0) should have R=128, G=64, B=32
        assert_eq!(data[0], 128); // R plane, pixel 0
        assert_eq!(data[16], 64); // G plane, pixel 0
        assert_eq!(data[32], 32); // B plane, pixel 0

        // Center pixel (1,1): row=1, col=1, width=4 -> index = 1*4 + 1 = 5
        let center_idx = 5;
        assert_eq!(data[center_idx], 0); // R
        assert_eq!(data[16 + center_idx], 0); // G
        assert_eq!(data[32 + center_idx], 0); // B
    }

    #[test]
    fn test_convert_rgba_to_bgra() {
        use edgefirst_tensor::TensorMemory;
        // 2x1 image: pixel0 = [R=10, G=20, B=30, A=255], pixel1 = [R=40, G=50, B=60, A=128]
        let src = TensorImage::new(2, 1, RGBA, Some(TensorMemory::Mem)).unwrap();
        {
            let mut map = src.tensor().map().unwrap();
            let buf = map.as_mut_slice();
            buf[0..4].copy_from_slice(&[10, 20, 30, 255]);
            buf[4..8].copy_from_slice(&[40, 50, 60, 128]);
        }
        let mut dst = TensorImage::new(2, 1, BGRA, Some(TensorMemory::Mem)).unwrap();
        CPUProcessor::convert_format(&src, &mut dst).unwrap();
        let map = dst.tensor().map().unwrap();
        let buf = map.as_slice();
        // BGRA byte order: [B, G, R, A]
        assert_eq!(&buf[0..4], &[30, 20, 10, 255]);
        assert_eq!(&buf[4..8], &[60, 50, 40, 128]);
    }

    #[test]
    fn test_convert_rgb_to_bgra() {
        // Convert RGB→RGBA and RGB→BGRA, verify R↔B swap matches
        let src = TensorImage::new(2, 1, RGB, Some(TensorMemory::Mem)).unwrap();
        {
            let mut map = src.tensor().map().unwrap();
            let buf = map.as_mut_slice();
            buf[0..3].copy_from_slice(&[100, 150, 200]);
            buf[3..6].copy_from_slice(&[50, 75, 25]);
        }
        let mut rgba_dst = TensorImage::new(2, 1, RGBA, Some(TensorMemory::Mem)).unwrap();
        CPUProcessor::convert_format(&src, &mut rgba_dst).unwrap();

        let mut bgra_dst = TensorImage::new(2, 1, BGRA, Some(TensorMemory::Mem)).unwrap();
        CPUProcessor::convert_format(&src, &mut bgra_dst).unwrap();

        assert_bgra_matches_rgba(&bgra_dst, &rgba_dst);

        // Also verify the B,G,R channels are correct (alpha may vary)
        let map = bgra_dst.tensor().map().unwrap();
        let buf = map.as_slice();
        assert_eq!(buf[0], 200, "pixel 0 B");
        assert_eq!(buf[1], 150, "pixel 0 G");
        assert_eq!(buf[2], 100, "pixel 0 R");
        assert_eq!(buf[4], 25, "pixel 1 B");
        assert_eq!(buf[5], 75, "pixel 1 G");
        assert_eq!(buf[6], 50, "pixel 1 R");
    }

    #[test]
    fn test_convert_grey_to_bgra() {
        // 2x1 greyscale image
        let src = TensorImage::new(2, 1, GREY, Some(TensorMemory::Mem)).unwrap();
        {
            let mut map = src.tensor().map().unwrap();
            let buf = map.as_mut_slice();
            buf[0] = 128;
            buf[1] = 64;
        }
        let mut dst = TensorImage::new(2, 1, BGRA, Some(TensorMemory::Mem)).unwrap();
        CPUProcessor::convert_format(&src, &mut dst).unwrap();
        let map = dst.tensor().map().unwrap();
        let buf = map.as_slice();
        // Grey→BGRA: all channels same value, A=255; R↔B swap is no-op on grey
        assert_eq!(&buf[0..4], &[128, 128, 128, 255]);
        assert_eq!(&buf[4..8], &[64, 64, 64, 255]);
    }

    #[test]
    fn test_convert_bgra_to_bgra_copy() {
        // Verify BGRA→BGRA is a straight copy
        let src = TensorImage::new(2, 1, BGRA, Some(TensorMemory::Mem)).unwrap();
        {
            let mut map = src.tensor().map().unwrap();
            let buf = map.as_mut_slice();
            buf[0..4].copy_from_slice(&[10, 20, 30, 255]);
            buf[4..8].copy_from_slice(&[40, 50, 60, 128]);
        }
        let mut dst = TensorImage::new(2, 1, BGRA, Some(TensorMemory::Mem)).unwrap();
        CPUProcessor::convert_format(&src, &mut dst).unwrap();
        let map = dst.tensor().map().unwrap();
        let buf = map.as_slice();
        assert_eq!(&buf[0..4], &[10, 20, 30, 255]);
        assert_eq!(&buf[4..8], &[40, 50, 60, 128]);
    }

    /// Helper: compare BGRA output against RGBA output by verifying R↔B swap.
    /// Since CPU BGRA conversion is RGBA conversion + R↔B swizzle, the results
    /// must be byte-exact after accounting for the channel swap.
    fn assert_bgra_matches_rgba(bgra: &TensorImage, rgba: &TensorImage) {
        assert_eq!(bgra.fourcc(), BGRA);
        assert_eq!(rgba.fourcc(), RGBA);
        assert_eq!(bgra.width(), rgba.width());
        assert_eq!(bgra.height(), rgba.height());

        let bgra_map = bgra.tensor().map().unwrap();
        let rgba_map = rgba.tensor().map().unwrap();
        let bgra_buf = bgra_map.as_slice();
        let rgba_buf = rgba_map.as_slice();

        assert_eq!(bgra_buf.len(), rgba_buf.len());
        for (i, (bc, rc)) in bgra_buf
            .chunks_exact(4)
            .zip(rgba_buf.chunks_exact(4))
            .enumerate()
        {
            assert_eq!(bc[0], rc[2], "pixel {i}: B(bgra) != B(rgba)");
            assert_eq!(bc[1], rc[1], "pixel {i}: G mismatch");
            assert_eq!(bc[2], rc[0], "pixel {i}: R(bgra) != R(rgba)");
            assert_eq!(bc[3], rc[3], "pixel {i}: A mismatch");
        }
    }

    #[test]
    fn test_convert_nv12_to_bgra() {
        let src = load_bytes_to_tensor(
            1280,
            720,
            NV12,
            None,
            include_bytes!("../../../testdata/camera720p.nv12"),
        )
        .unwrap();

        // Convert to both RGBA and BGRA, then compare
        let mut rgba_dst = TensorImage::new(1280, 720, RGBA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut rgba_dst).unwrap();

        let mut bgra_dst = TensorImage::new(1280, 720, BGRA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut bgra_dst).unwrap();

        assert_bgra_matches_rgba(&bgra_dst, &rgba_dst);
    }

    #[test]
    fn test_convert_yuyv_to_bgra() {
        let src = load_bytes_to_tensor(
            1280,
            720,
            YUYV,
            None,
            include_bytes!("../../../testdata/camera720p.yuyv"),
        )
        .unwrap();

        let mut rgba_dst = TensorImage::new(1280, 720, RGBA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut rgba_dst).unwrap();

        let mut bgra_dst = TensorImage::new(1280, 720, BGRA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut bgra_dst).unwrap();

        assert_bgra_matches_rgba(&bgra_dst, &rgba_dst);
    }

    #[test]
    fn test_convert_vyuy_to_bgra() {
        let src = load_bytes_to_tensor(
            1280,
            720,
            VYUY,
            None,
            include_bytes!("../../../testdata/camera720p.vyuy"),
        )
        .unwrap();

        let mut rgba_dst = TensorImage::new(1280, 720, RGBA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut rgba_dst).unwrap();

        let mut bgra_dst = TensorImage::new(1280, 720, BGRA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut bgra_dst).unwrap();

        assert_bgra_matches_rgba(&bgra_dst, &rgba_dst);
    }

    #[test]
    fn test_convert_nv16_to_bgra() {
        let src = load_bytes_to_tensor(
            1280,
            720,
            NV16,
            None,
            include_bytes!("../../../testdata/camera720p.nv16"),
        )
        .unwrap();

        let mut rgba_dst = TensorImage::new(1280, 720, RGBA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut rgba_dst).unwrap();

        let mut bgra_dst = TensorImage::new(1280, 720, BGRA, None).unwrap();
        CPUProcessor::convert_format(&src, &mut bgra_dst).unwrap();

        assert_bgra_matches_rgba(&bgra_dst, &rgba_dst);
    }

    // ========================================================================
    // Tests for materialize_segmentations
    // ========================================================================

    fn make_proto_data(
        proto_h: usize,
        proto_w: usize,
        num_protos: usize,
        coefficients: Vec<Vec<f32>>,
    ) -> crate::ProtoData {
        crate::ProtoData {
            mask_coefficients: coefficients,
            protos: edgefirst_decoder::ProtoTensor::Float(ndarray::Array3::<f32>::zeros((
                proto_h, proto_w, num_protos,
            ))),
        }
    }

    fn make_detect_box(xmin: f32, ymin: f32, xmax: f32, ymax: f32) -> crate::DetectBox {
        crate::DetectBox {
            bbox: edgefirst_decoder::BoundingBox {
                xmin,
                ymin,
                xmax,
                ymax,
            },
            score: 0.9,
            label: 0,
        }
    }

    #[test]
    fn test_materialize_empty_detections() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![1.0; 4]]);
        let result = cpu.materialize_segmentations(&[], &proto_data);
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());
    }

    #[test]
    fn test_materialize_empty_proto_data() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![]);
        let det = [make_detect_box(0.1, 0.1, 0.5, 0.5)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());
    }

    #[test]
    fn test_materialize_single_detection() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 4]]);
        let det = [make_detect_box(0.1, 0.1, 0.5, 0.5)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(result.is_ok());
        let segs = result.unwrap();
        assert_eq!(segs.len(), 1);
        // Segmentation should have shape (H, W, 1) with non-zero spatial dims
        assert!(segs[0].segmentation.shape()[0] > 0);
        assert!(segs[0].segmentation.shape()[1] > 0);
        assert_eq!(segs[0].segmentation.shape()[2], 1);
    }

    #[test]
    fn test_materialize_bbox_edge_one() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 4]]);
        let det = [make_detect_box(0.5, 0.5, 1.0, 1.0)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(
            result.is_ok(),
            "bbox at exact boundary (1.0) should not panic"
        );
        let segs = result.unwrap();
        assert_eq!(segs.len(), 1);
    }

    #[test]
    fn test_materialize_bbox_negative_clamp() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 4]]);
        let det = [make_detect_box(-0.5, -0.5, 0.5, 0.5)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(
            result.is_ok(),
            "negative coordinates should be clamped to 0"
        );
        let segs = result.unwrap();
        assert_eq!(segs.len(), 1);
        // xmin should be clamped to 0.0
        assert!((segs[0].xmin - 0.0).abs() < 0.01);
        assert!((segs[0].ymin - 0.0).abs() < 0.01);
    }

    #[test]
    fn test_materialize_invalid_coeff_shape() {
        let cpu = CPUProcessor::new();
        // Proto has 4 channels but coefficients have 6 elements — mismatch
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 6]]);
        let det = [make_detect_box(0.1, 0.1, 0.5, 0.5)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(
            result.is_err(),
            "mismatched coeff count vs proto channels should error"
        );
        let err = result.unwrap_err();
        assert!(
            matches!(&err, crate::Error::Internal(s) if s.contains("coeff")),
            "error should mention coefficient shape: {err:?}"
        );
    }

    #[test]
    fn test_materialize_multiple_detections() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 4], vec![0.3; 4], vec![0.1; 4]]);
        let det = [
            make_detect_box(0.0, 0.0, 0.5, 0.5),
            make_detect_box(0.5, 0.0, 1.0, 0.5),
            make_detect_box(0.0, 0.5, 0.5, 1.0),
        ];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(result.is_ok());
        assert_eq!(result.unwrap().len(), 3);
    }

    #[test]
    fn test_materialize_zero_area_bbox() {
        let cpu = CPUProcessor::new();
        let proto_data = make_proto_data(8, 8, 4, vec![vec![0.5; 4]]);
        // xmin == xmax → zero-width bbox
        let det = [make_detect_box(0.5, 0.1, 0.5, 0.5)];
        let result = cpu.materialize_segmentations(&det, &proto_data);
        assert!(
            result.is_ok(),
            "zero-area bbox should return Ok with degenerate segmentation"
        );
        let segs = result.unwrap();
        assert_eq!(segs.len(), 1);
    }
}