/* * Copyright (c) 2023. * * This software is free software; * * You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license */ //! Platform independent IDCT algorithm //! //! Not as fast as AVX one. const SCALE_BITS: i32 = 512 + 65536 + (128 << 17); #[allow(unused_assignments)] #[allow( clippy::too_many_lines, clippy::op_ref, clippy::cast_possible_truncation )] pub fn idct_int(in_vector: &mut [i32; 64], out_vector: &mut [i16], stride: usize) { // Temporary variables. let mut pos = 0; let mut i = 0; // Don't check for zeroes inside loop, lift it and check outside // we want to accelerate the case with 63 0 ac coeff if &in_vector[1..] == &[0_i32; 63] { // okay then if you work, yay, let's write you really quick let coeff = [((in_vector[0] + 4 + 1024) >> 3).clamp(0, 255) as i16; 8]; macro_rules! store { ($index:tt) => { // position of the MCU let mcu_stride: &mut [i16; 8] = out_vector .get_mut($index..$index + 8) .unwrap() .try_into() .unwrap(); // copy coefficients mcu_stride.copy_from_slice(&coeff); // increment index $index += stride; }; } // write to four positions store!(pos); store!(pos); store!(pos); store!(pos); store!(pos); store!(pos); store!(pos); store!(pos); } else { // because the compiler fails to see that it can be auto_vectorised so i'll // leave it here check out [idct_int_slow, and idct_int_1D to get what i mean ] https://godbolt.org/z/8hqW9z9j9 for ptr in 0..8 { let p2 = in_vector[ptr + 16]; let p3 = in_vector[ptr + 48]; let p1 = (p2 + p3).wrapping_mul(2217); let t2 = p1 + p3 * -7567; let t3 = p1 + p2 * 3135; let p2 = in_vector[ptr]; let p3 = in_vector[32 + ptr]; let t0 = fsh(p2 + p3); let t1 = fsh(p2 - p3); let x0 = t0 + t3 + 512; let x3 = t0 - t3 + 512; let x1 = t1 + t2 + 512; let x2 = t1 - t2 + 512; // odd part let mut t0 = in_vector[ptr + 56]; let mut t1 = in_vector[ptr + 40]; let mut t2 = in_vector[ptr + 24]; let mut t3 = in_vector[ptr + 8]; let p3 = t0 + t2; let p4 = t1 + t3; let p1 = t0 + t3; let p2 = t1 + t2; let p5 = (p3 + p4) * 4816; t0 *= 1223; t1 *= 8410; t2 *= 12586; t3 *= 6149; let p1 = p5 + p1 * -3685; let p2 = p5 + p2 * -10497; let p3 = p3 * -8034; let p4 = p4 * -1597; t3 += p1 + p4; t2 += p2 + p3; t1 += p2 + p4; t0 += p1 + p3; // constants scaled things up by 1<<12; let's bring them back // down, but keep 2 extra bits of precision in_vector[ptr] = (x0 + t3) >> 10; in_vector[ptr + 8] = (x1 + t2) >> 10; in_vector[ptr + 16] = (x2 + t1) >> 10; in_vector[ptr + 24] = (x3 + t0) >> 10; in_vector[ptr + 32] = (x3 - t0) >> 10; in_vector[ptr + 40] = (x2 - t1) >> 10; in_vector[ptr + 48] = (x1 - t2) >> 10; in_vector[ptr + 56] = (x0 - t3) >> 10; } // This is vectorised in architectures supporting SSE 4.1 while i < 64 { // We won't try to short circuit here because it rarely works // Even part let p2 = in_vector[i + 2]; let p3 = in_vector[i + 6]; let p1 = (p2 + p3) * 2217; let t2 = p1 + p3 * -7567; let t3 = p1 + p2 * 3135; let p2 = in_vector[i]; let p3 = in_vector[i + 4]; let t0 = fsh(p2 + p3); let t1 = fsh(p2 - p3); // constants scaled things up by 1<<12, plus we had 1<<2 from first // loop, plus horizontal and vertical each scale by sqrt(8) so together // we've got an extra 1<<3, so 1<<17 total we need to remove. // so we want to round that, which means adding 0.5 * 1<<17, // aka 65536. Also, we'll end up with -128 to 127 that we want // to encode as 0..255 by adding 128, so we'll add that before the shift let x0 = t0 + t3 + SCALE_BITS; let x3 = t0 - t3 + SCALE_BITS; let x1 = t1 + t2 + SCALE_BITS; let x2 = t1 - t2 + SCALE_BITS; // odd part let mut t0 = in_vector[i + 7]; let mut t1 = in_vector[i + 5]; let mut t2 = in_vector[i + 3]; let mut t3 = in_vector[i + 1]; let p3 = t0 + t2; let p4 = t1 + t3; let p1 = t0 + t3; let p2 = t1 + t2; let p5 = (p3 + p4) * f2f(1.175875602); t0 = t0.wrapping_mul(1223); t1 = t1.wrapping_mul(8410); t2 = t2.wrapping_mul(12586); t3 = t3.wrapping_mul(6149); let p1 = p5 + p1 * -3685; let p2 = p5 + p2 * -10497; let p3 = p3 * -8034; let p4 = p4 * -1597; t3 += p1 + p4; t2 += p2 + p3; t1 += p2 + p4; t0 += p1 + p3; let out: &mut [i16; 8] = out_vector .get_mut(pos..pos + 8) .unwrap() .try_into() .unwrap(); out[0] = clamp((x0 + t3) >> 17); out[1] = clamp((x1 + t2) >> 17); out[2] = clamp((x2 + t1) >> 17); out[3] = clamp((x3 + t0) >> 17); out[4] = clamp((x3 - t0) >> 17); out[5] = clamp((x2 - t1) >> 17); out[6] = clamp((x1 - t2) >> 17); out[7] = clamp((x0 - t3) >> 17); i += 8; pos += stride; } } } #[inline] #[allow(clippy::cast_possible_truncation)] /// Multiply a number by 4096 fn f2f(x: f32) -> i32 { (x * 4096.0 + 0.5) as i32 } #[inline] /// Multiply a number by 4096 fn fsh(x: i32) -> i32 { x << 12 } /// Clamp values between 0 and 255 #[inline] #[allow(clippy::cast_possible_truncation)] fn clamp(a: i32) -> i16 { a.clamp(0, 255) as i16 }