chromium/third_party/libaom/source/libaom/aom_dsp/fft.c

/*
 * Copyright (c) 2018, Alliance for Open Media. All rights reserved.
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "aom_dsp/aom_dsp_common.h"
#include "aom_dsp/fft_common.h"
#include "config/aom_dsp_rtcd.h"

static inline void simple_transpose(const float *A, float *B, int n) { … }

// The 1d transform is real to complex and packs the complex results in
// a way to take advantage of conjugate symmetry (e.g., the n/2 + 1 real
// components, followed by the n/2 - 1 imaginary components). After the
// transform is done on the rows, the first n/2 + 1 columns are real, and
// the remaining are the imaginary components. After the transform on the
// columns, the region of [0, n/2]x[0, n/2] contains the real part of
// fft of the real columns. The real part of the 2d fft also includes the
// imaginary part of transformed imaginary columns. This function assembles
// the correct outputs while putting the real and imaginary components
// next to each other.
static inline void unpack_2d_output(const float *col_fft, float *output,
                                    int n) { … }

void aom_fft_2d_gen(const float *input, float *temp, float *output, int n,
                    aom_fft_1d_func_t tform, aom_fft_transpose_func_t transpose,
                    aom_fft_unpack_func_t unpack, int vec_size) { … }

static inline void store_float(float *output, float input) { … }
static inline float add_float(float a, float b) { … }
static inline float sub_float(float a, float b) { … }
static inline float mul_float(float a, float b) { … }

GEN_FFT_2(…)
GEN_FFT_4(…)
GEN_FFT_8(…)
GEN_FFT_16(…)
GEN_FFT_32(…)

void aom_fft2x2_float_c(const float *input, float *temp, float *output) { … }

void aom_fft4x4_float_c(const float *input, float *temp, float *output) { … }

void aom_fft8x8_float_c(const float *input, float *temp, float *output) { … }

void aom_fft16x16_float_c(const float *input, float *temp, float *output) { … }

void aom_fft32x32_float_c(const float *input, float *temp, float *output) { … }

void aom_ifft_2d_gen(const float *input, float *temp, float *output, int n,
                     aom_fft_1d_func_t fft_single, aom_fft_1d_func_t fft_multi,
                     aom_fft_1d_func_t ifft_multi,
                     aom_fft_transpose_func_t transpose, int vec_size) { … }

GEN_IFFT_2(…)
GEN_IFFT_4(…)
GEN_IFFT_8(…)
GEN_IFFT_16(…)
GEN_IFFT_32(…)

void aom_ifft2x2_float_c(const float *input, float *temp, float *output) { … }

void aom_ifft4x4_float_c(const float *input, float *temp, float *output) { … }

void aom_ifft8x8_float_c(const float *input, float *temp, float *output) { … }

void aom_ifft16x16_float_c(const float *input, float *temp, float *output) { … }

void aom_ifft32x32_float_c(const float *input, float *temp, float *output) { … }