refactor(graphics): drop now unused yuv/rgb code

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Author: elmarco

crates/ironrdp-graphics/src/color_conversion.rs

@@ -23,84 +23,6 @@ pub fn ycbcr_to_bgra(input: YCbCrBuffer<'_>, output: &mut [u8]) -> io::Result<()
     rdp_yuv444_to_bgra(&planar, output, len).map_err(io::Error::other)
 }
 
-fn iter_to_ycbcr<'a, I, C>(input: I, y: &mut [i16], cb: &mut [i16], cr: &mut [i16], conv: C)
-where
-    I: ExactSizeIterator<Item = &'a [u8]>,
-    C: Fn(&[u8]) -> Rgb,
-{
-    for (i, pixel) in input.into_iter().enumerate() {
-        let pixel = YCbCr::from(conv(pixel));
-
-        y[i] = pixel.y;
-        cb[i] = pixel.cb;
-        cr[i] = pixel.cr;
-    }
-}
-
-fn xrgb_to_rgb(pixel: &[u8]) -> Rgb {
-    Rgb {
-        r: pixel[1],
-        g: pixel[2],
-        b: pixel[3],
-    }
-}
-
-fn xbgr_to_rgb(pixel: &[u8]) -> Rgb {
-    Rgb {
-        b: pixel[1],
-        g: pixel[2],
-        r: pixel[3],
-    }
-}
-
-fn bgrx_to_rgb(pixel: &[u8]) -> Rgb {
-    Rgb {
-        b: pixel[0],
-        g: pixel[1],
-        r: pixel[2],
-    }
-}
-
-fn rgbx_to_rgb(pixel: &[u8]) -> Rgb {
-    Rgb {
-        r: pixel[0],
-        g: pixel[1],
-        b: pixel[2],
-    }
-}
-
-const fn pixel_format_to_rgb_fn(format: PixelFormat) -> fn(&[u8]) -> Rgb {
-    match format {
-        PixelFormat::ARgb32 | PixelFormat::XRgb32 => xrgb_to_rgb,
-        PixelFormat::ABgr32 | PixelFormat::XBgr32 => xbgr_to_rgb,
-        PixelFormat::BgrA32 | PixelFormat::BgrX32 => bgrx_to_rgb,
-        PixelFormat::RgbA32 | PixelFormat::RgbX32 => rgbx_to_rgb,
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn to_ycbcr(
-    mut input: &[u8],
-    width: usize,
-    height: usize,
-    stride: usize,
-    format: PixelFormat,
-    mut y: &mut [i16],
-    mut cb: &mut [i16],
-    mut cr: &mut [i16],
-) {
-    let to_rgb = pixel_format_to_rgb_fn(format);
-    let bpp = format.bytes_per_pixel() as usize;
-
-    for _ in 0..height {
-        iter_to_ycbcr(input[..width * bpp].chunks_exact(bpp), y, cb, cr, to_rgb);
-        input = &input[stride..];
-        y = &mut y[width..];
-        cb = &mut cb[width..];
-        cr = &mut cr[width..];
-    }
-}
-
 #[allow(clippy::too_many_arguments)]
 pub fn to_64x64_ycbcr_tile(
     input: &[u8],
@@ -147,10 +69,6 @@ pub fn rdp_16bit_to_rgb(color: u16) -> [u8; 3] {
     [r, g, b]
 }
 
-fn clip(v: i32) -> u8 {
-    v.clamp(0, 255) as u8
-}
-
 #[derive(Debug)]
 pub struct YCbCrBuffer<'a> {
     pub y: &'a [i16],
@@ -191,79 +109,3 @@ pub struct Rgb {
     pub g: u8,
     pub b: u8,
 }
-
-impl From<YCbCr> for Rgb {
-    fn from(YCbCr { y, cb, cr }: YCbCr) -> Self {
-        #![allow(clippy::similar_names)] // It’s hard to find better names here.
-
-        // We scale the factors by << 16 into 32-bit integers in order to
-        // avoid slower floating point multiplications.  Since the final
-        // result needs to be scaled by >> 5 we will extract only the
-        // upper 11 bits (>> 21) from the final sum.
-        // Hence we also have to scale the other terms of the sum by << 16.
-        const DIVISOR: f32 = (1 << 16) as f32;
-
-        let y = i32::from(y);
-        let cb = i32::from(cb);
-        let cr = i32::from(cr);
-
-        let yy = (y + 4096) << 16;
-        let cr_r = cr.overflowing_mul((1.402_525 * DIVISOR) as i32).0;
-        let cb_g = cb.overflowing_mul((0.343_730 * DIVISOR) as i32).0;
-        let cr_g = cr.overflowing_mul((0.714_401 * DIVISOR) as i32).0;
-        let cb_b = cb.overflowing_mul((1.769_905 * DIVISOR) as i32).0;
-        let cr_b = cb.overflowing_mul((0.000_013 * DIVISOR) as i32).0;
-
-        let r = clip((yy.overflowing_add(cr_r).0) >> 21);
-        let g = clip((yy.overflowing_sub(cb_g).0.overflowing_sub(cr_g).0) >> 21);
-        let b = clip((yy.overflowing_add(cb_b).0.overflowing_add(cr_b).0) >> 21);
-
-        Self { r, g, b }
-    }
-}
-
-impl From<Rgb> for YCbCr {
-    fn from(Rgb { r, g, b }: Rgb) -> Self {
-        #![allow(clippy::similar_names)] // It’s hard to find better names here.
-
-        // We scale the factors by << 15 into 32-bit integers in order
-        // to avoid slower floating point multiplications.  Since the
-        // terms need to be scaled by << 5 we simply scale the final
-        // sum by >> 10
-        const DIVISOR: f32 = (1 << 15) as f32;
-        const Y_R: i32 = (0.299 * DIVISOR) as i32;
-        const Y_G: i32 = (0.587 * DIVISOR) as i32;
-        const Y_B: i32 = (0.114 * DIVISOR) as i32;
-        const CB_R: i32 = (0.168_935 * DIVISOR) as i32;
-        const CB_G: i32 = (0.331_665 * DIVISOR) as i32;
-        const CB_B: i32 = (0.500_59 * DIVISOR) as i32;
-        const CR_R: i32 = (0.499_813 * DIVISOR) as i32;
-        const CR_G: i32 = (0.418_531 * DIVISOR) as i32;
-        const CR_B: i32 = (0.081_282 * DIVISOR) as i32;
-
-        let r = i32::from(r);
-        let g = i32::from(g);
-        let b = i32::from(b);
-
-        let y_r = r.overflowing_mul(Y_R).0;
-        let y_g = g.overflowing_mul(Y_G).0;
-        let y_b = b.overflowing_mul(Y_B).0;
-        let y = y_r.overflowing_add(y_g).0.overflowing_add(y_b).0 >> 10;
-
-        let cb_r = r.overflowing_mul(CB_R).0;
-        let cb_g = g.overflowing_mul(CB_G).0;
-        let cb_b = b.overflowing_mul(CB_B).0;
-        let cb = cb_b.overflowing_sub(cb_g).0.overflowing_sub(cb_r).0 >> 10;
-
-        let cr_r = r.overflowing_mul(CR_R).0;
-        let cr_g = g.overflowing_mul(CR_G).0;
-        let cr_b = b.overflowing_mul(CR_B).0;
-        let cr = cr_r.overflowing_sub(cr_g).0.overflowing_sub(cr_b).0 >> 10;
-
-        Self {
-            y: (y - 4096).clamp(-4096, 4095) as i16,
-            cb: cb.clamp(-4096, 4095) as i16,
-            cr: cr.clamp(-4096, 4095) as i16,
-        }
-    }
-}

crates/ironrdp-testsuite-core/tests/graphics/color_conversion.rs

@@ -11,24 +11,6 @@ fn to_64x64_ycbcr() {
     to_64x64_ycbcr_tile(&input, 1, 1, 4, PixelFormat::ABgr32, &mut y, &mut cb, &mut cr);
 }
 
-#[test]
-fn ycbcr_from_rgb_works_for_zeros() {
-    let rgb = Rgb { r: 0, g: 0, b: 0 };
-    let expected = YCbCr { y: -4096, cb: 0, cr: 0 };
-
-    let actual = YCbCr::from(rgb);
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn ycbcr_from_rgb_works_for_max_values() {
-    let rgb = Rgb { r: 255, g: 255, b: 255 };
-    let expected = YCbCr { y: 4063, cb: 0, cr: 0 };
-
-    let actual = YCbCr::from(rgb);
-    assert_eq!(expected, actual);
-}
-
 #[ignore]
 #[test]
 fn rgb_to_ycbcr_converts_large_buffer() {
@@ -39,61 +21,13 @@ fn rgb_to_ycbcr_converts_large_buffer() {
         cr: YCBCR_BUFFER_CR.as_ref(),
     };
 
-    let mut y = vec![0; 4096];
-    let mut cb = vec![0; 4096];
-    let mut cr = vec![0; 4096];
-    to_ycbcr(rgba, 64, 64, 64 * 4, PixelFormat::BgrA32, &mut y, &mut cb, &mut cr);
+    let mut y = [0; 4096];
+    let mut cb = [0; 4096];
+    let mut cr = [0; 4096];
+    to_64x64_ycbcr_tile(rgba, 64, 64, 64 * 4, PixelFormat::BgrA32, &mut y, &mut cb, &mut cr);
     assert_eq!(expected.y, y.as_slice());
 }
 
-#[test]
-fn rgb_from_ycbcr_works_for_zeros() {
-    let ycbcr = YCbCr { y: 0, cb: 0, cr: 0 };
-
-    let expected = Rgb { r: 128, g: 128, b: 128 };
-    let actual = Rgb::from(ycbcr);
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn rgb_from_ycbcr_works_for_max_values() {
-    let ycbcr = YCbCr {
-        y: 32767,
-        cb: 32767,
-        cr: 32767,
-    };
-
-    let expected = Rgb { r: 255, g: 68, b: 255 };
-    let actual = Rgb::from(ycbcr);
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn rgb_from_ycbcr_works_for_min_values() {
-    let ycbcr = YCbCr {
-        y: -32768,
-        cb: -32768,
-        cr: -32768,
-    };
-
-    let expected = Rgb { r: 0, g: 187, b: 0 };
-    let actual = Rgb::from(ycbcr);
-    assert_eq!(expected, actual);
-}
-
-#[test]
-fn rgb_from_ycbcr_works_for_regular_values() {
-    let ycbcr = YCbCr {
-        y: 68,
-        cb: 1710,
-        cr: -2128,
-    };
-
-    let expected = Rgb { r: 36, g: 159, b: 224 };
-    let actual = Rgb::from(ycbcr);
-    assert_eq!(expected, actual);
-}
-
 #[test]
 fn ycbcr_to_rgb_converts_one_element_buffer() {
     let ycbcr = YCbCrBuffer {