procedure TForm1.Button1Click(Sender: TObject);
const
  ND2 = 128;
  N = 2 * ND2;
var
  aIn: array of Single;
  aOutt: array[0..N - 1, 0..ND2] of TComplexSingle;
  x, y: Integer;
  plan: Pointer;
  i: Integer;
  b: Byte;
  C: Single;
begin
  SetLength(aIn, N * N);
  for y := 0 to N - 1 do
    for x := 0 to N - 1 do begin
      if (Abs(y - ND2) < 32) and (Abs(x - ND2) < 32) then
        b := 255
      else
        b := 0;
      aIn[y * N + x] := b;
      Canvas.Pixels[x, y] := RGB(b, b, b);
    end;

  plan := fftwf_plan_dft_r2c_2d(N, N, @aIn[0], @aOutt[0], FFTW_ESTIMATE);
  fftwf_execute(plan);
  for y := 0 to N - 1 do
    for x := 0 to N div 2 - 1 do begin
      i := Round(Hypot(aOutt[y, x].Re, aOutt[y, x].Im)/ N);
      b := i;
      Canvas.Pixels[N + x + ND2, (y + ND2) mod N] := RGB(b, b, b);
      Canvas.Pixels[N + ND2 - x, (y + ND2) mod N] := RGB(b, b, b);
    end;
  fftwf_destroy_plan(plan);

  C := 1;
  for y := 0 to N - 1 do
    for x := 0 to N div 2 - 1 do begin
//      C := 1 /(Sqr(x) + Sqr(y) + 1); // некий фильтр нижних частот
      aOutt[y, x].Re := aOutt[y, x].Re  * C;
      aOutt[y, x].Im := aOutt[y, x].Im  * C;
    end;


  plan := fftwf_plan_dft_c2r_2d(N, N, @aOutt[0], @aIn[0], FFTW_ESTIMATE);
  fftwf_execute(plan);
  for y := 0 to N - 1 do
    for x := 0 to N - 1 do begin
      i := Round(aIn[y * N + x]/(Sqr(ND2)));
      b := i;
      Canvas.Pixels[2 * N + x, y] := RGB(b, b, b);
    end;
  fftwf_destroy_plan(plan);
end;

fftw_complex = record
    re, im: Double;
  end;
  pfftw_complex = ^fftw_complex;

  fftw_plan = type Pointer;

const
  FFTW_FORWARD = DWORD(-1);
  FFTW_BACKWARD = 1;

  FFTW_MEASURE = 0;
  FFTW_DESTROY_INPUT = 1; {1U << 0}
  FFTW_UNALIGNED = 2; {1U << 1}
  FFTW_CONSERVE_MEMORY = 4; {1U << 2}
  FFTW_EXHAUSTIVE = 8; {1U << 3} {NO_EXHAUSTIVE is default }
  FFTW_PRESERVE_INPUT = 16; {1U << 4} {cancels FFTW_DESTROY_INPUT}
  FFTW_PATIENT = 32; {1U << 5} {IMPATIENT is default }
  FFTW_ESTIMATE = 64; {1U << 6}

const
  fftw3f = 'fftw3.dll';

function fftw_malloc(n: LongWord): Pointer; cdecl;
external fftw3f Name 'fftw_malloc';
procedure fftw_free(P: Pointer); cdecl;
external fftw3f Name 'fftw_free';

procedure fftw_destroy_plan(plan: fftw_plan); cdecl;
external fftw3f Name 'fftw_destroy_plan';
procedure fftw_execute(plan: fftw_plan); cdecl;
external fftw3f Name 'fftw_execute';

function fftw_plan_dft_r2c_2d(n0, n1: Integer; _in: PDouble; _out: pfftw_complex;
  flags: LongWord): fftw_plan; cdecl; external fftw3f Name 'fftw_plan_dft_r2c_2d';
function fftw_plan_dft_c2r_2d(n0, n1: Integer; _in: pfftw_complex; _out: PDouble;
  flags: LongWord): fftw_plan; cdecl; external fftw3f Name 'fftw_plan_dft_c2r_2d';

procedure FFT2(ABitmap: TBitmap);
type
  PDoubleArray = ^TDoubleArray;
  TDoubleArray = array[0..0] of Double;
  PComplexArray = ^TComplexArray;
  TComplexArray = array[0..0] of fftw_complex;

var
  lScanLine: PByte;
  lInArray: PDoubleArray;
  lOutArray: PComplexArray;
  I, J, lInt,
    lSizeX, lSizeY,
    lInLength,
    lOutLength: Integer;
  plan: fftw_plan;
begin
  if ABitmap = nil then
    Exit;
  ABitmap.PixelFormat := pf8bit;
  lSizeX := ABitmap.Width;
  lSizeY := ABitmap.Height;
  lInLength := lSizeX * lSizeY;
  lOutLength := lSizeX * (lSizeY div 2 + 1);

  lInArray := fftw_malloc(lInLength * SizeOf(Double));
  try
    lInt := 0;
    for J := 0 to ABitmap.Height - 1 do
    begin
      lScanLine := ABitmap.ScanLine[J];
      for I := 0 to ABitmap.Width - 1 do
      begin
        lInArray[lInt] := lScanLine^;
        Inc(lInt);
        Inc(lScanLine);
      end;
    end;

    lOutArray := fftw_malloc(lOutLength * SizeOf(fftw_complex));
    try
      plan := fftw_plan_dft_r2c_2d(lSizeX, lSizeY, @lInArray[0], @lOutArray[0],
        FFTW_ESTIMATE);
      try
        fftw_execute(plan);
      finally
        fftw_destroy_plan(plan);
      end;

      ZeroMemory(lInArray, lInLength);
      plan := fftw_plan_dft_c2r_2d(lSizeX, lSizeY, @lOutArray[0], @lInArray[0],
        FFTW_ESTIMATE);
      try
        fftw_execute(plan);
      finally
        fftw_destroy_plan(plan);
      end;

      lInt := 0;
      for J := 0 to ABitmap.Height - 1 do
      begin
        lScanLine := ABitmap.ScanLine[J];
        for I := 0 to ABitmap.Width - 1 do
        begin
          lScanLine^ := Round(lInArray^[lInt]);
          Inc(lInt);
          Inc(lScanLine);
        end;
      end;

      ABitmap.SaveToFile('D:\232.bmp');
    finally
      fftw_free(lOutArray);
    end;
  finally
    fftw_free(lInArray);
  end;
end;

Если волнует скорость - да, стоит.