use super::fft_1d::Fft1D;
use crate::device::compute_pipeline::ComputeDispatch;
use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
use std::mem::size_of;
#[repr(C)]
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct NormalizeParams {
degree: u32,
padding: [u32; 3],
}
pub struct Ifft1D {
input: Tensor,
degree: u32,
}
impl Ifft1D {
pub fn new(input: Tensor, degree: u32) -> Result<Self> {
let shape = input.shape();
if shape.last() != Some(&2) {
return Err(BarracudaError::Device(
"IFFT input must have last dimension = 2 (complex)".to_string(),
));
}
if degree & (degree - 1) != 0 {
return Err(BarracudaError::Device(format!(
"IFFT degree {degree} must be power of 2"
)));
}
Ok(Self { input, degree })
}
pub fn execute(self) -> Result<Tensor> {
let device = self.input.device().clone();
let n = self.degree;
let buffer_bytes = (n as u64) * 2 * size_of::<f32>() as u64;
let fft = Fft1D::new(self.input, n)?;
let butterfly_result = fft.execute_internal(true)?;
let final_buffer = device.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("IFFT Final Buffer"),
size: buffer_bytes,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let normalize_params = NormalizeParams {
degree: n,
padding: [0; 3],
};
let normalize_params_buffer =
device.create_uniform_buffer("IFFT Normalize Params", &normalize_params);
let normalize_shader = include_str!("ifft_normalize.wgsl");
ComputeDispatch::new(&device, "IFFT Normalize")
.shader(normalize_shader, "main")
.storage_read(0, butterfly_result.buffer())
.storage_rw(1, &final_buffer)
.uniform(2, &normalize_params_buffer)
.dispatch_1d(n)
.submit()?;
Ok(Tensor::from_buffer(
final_buffer,
vec![n as usize, 2],
device,
))
}
}