Pedalboard

https://github.com/spotify/pedalboard
Admin
Pedalboard is a Python library for audio processing, offering reading/writing capabilities, built-in...
Tokens:302,430
Snippets:2,040
Trust Score:9.7
License:GPL-3.0
Update:6 days ago
Show doc for...
Tokens:
Raw
### Basic FFTW installation: ./configure, make, make install

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Installation-on-Unix.html

Standard installation steps for FFTW on Unix. Builds uniprocessor complex and real transform libraries and test programs. make install installs fftw and rfftw libraries in standard places and typically requires root privileges unless --prefix is used.

```shell
./configure
make
make install
```

--------------------------------

### Transform each column of a 10x3 array

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Advanced-Complex-DFTs.html

Example setup for computing 1D DFTs of length 10 for each of the 3 columns of a 10x3 array. rank is 1, howmany is 3, and istride/ostride are 3 to step between rows in the same column.

```c
   int rank = 1; /* not 2: we are computing 1d transforms */
   int n[] = {10}; /* 1d transforms of length 10 */
   int howmany = 3;
   int idist = odist = 1;
   int istride = ostride = 3; /* distance between two elements in 
                                 the same column */
   int *inembed = n, *onembed = n;
```

--------------------------------

### dfftw_init_threads, dfftw_plan_with_nthreads - Multi-threaded Setup

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Fortran example for initializing FFTW threads and setting the number of threads for planning. The dfftw_init_threads subroutine initializes the thread support, and dfftw_plan_with_nthreads sets the number of threads to use.

```APIDOC
## dfftw_init_threads, dfftw_plan_with_nthreads

### Description
Initializes FFTW's thread support and sets the number of threads for planning. The dfftw_init_threads subroutine returns a status code in iret; a zero value indicates an error during thread initialization.

### Subroutines
- **dfftw_init_threads(iret)** - Initializes thread support.
- **dfftw_plan_with_nthreads(nthreads)** - Sets the number of threads for planning.

### Parameters
- **iret** (integer) - Output: Status code; zero indicates an error.
- **nthreads** (integer) - Input: Number of threads to use.

### Example
```fortran
integer iret
call dfftw_init_threads(iret)
call dfftw_plan_with_nthreads(8)
```
```

--------------------------------

### Basic Unix Installation

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Standard commands to configure, build, and install the FFTW library on Unix systems.

```bash
./configure make make install
```

--------------------------------

### Clone and install Pedalboard

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Clones the repository with submodules and installs build dependencies (pybind11, tox) before installing the package with pip.

```shell
git clone --recurse-submodules --shallow-submodules git@github.com:spotify/pedalboard.git
cd pedalboard
pip3 install pybind11 tox
pip3 install .
```

--------------------------------

### Install tox and run tests

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Install tox and run the test suite from the project root. This is the recommended way to run tests end-to-end.

```bash
pip3 install tox
tox
```

--------------------------------

### Generate and install pkg-config file

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/CMakeLists.txt

Configures the fftw.pc.in template and installs the resulting pkg-config file to the system library directory.

```cmake
set (prefix ${CMAKE_INSTALL_PREFIX})
set (exec_prefix ${CMAKE_INSTALL_PREFIX})
set (libdir ${CMAKE_INSTALL_FULL_LIBDIR})
set (includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
set (VERSION ${FFTW_VERSION})
configure_file (fftw.pc.in fftw3${PREC_SUFFIX}.pc @ONLY)
install (FILES
          ${CMAKE_CURRENT_BINARY_DIR}/fftw3${PREC_SUFFIX}.pc
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
         COMPONENT Development)
```

--------------------------------

### Install Pedalboard via pip

Source: https://github.com/spotify/pedalboard/blob/master/README.md

Use this command to install the pedalboard package from PyPI.

```bash
pip install pedalboard
```

--------------------------------

### Install Targets and API Headers

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/CMakeLists.txt

Sets installation rules for the library targets and header files, including auto-generated Fortran headers.

```cmake
foreach(subtarget ${subtargets})
  set_target_properties (${subtarget} PROPERTIES SOVERSION 3.6.9 VERSION 3)
  install (TARGETS ${subtarget}
	  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
	  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
endforeach ()
install(TARGETS ${fftw3_lib}
          EXPORT FFTW3LibraryDepends
          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})

install (FILES api/fftw3.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
if (EXISTS ${CMAKE_SOURCE_DIR}/api/fftw3.f)
  install (FILES api/fftw3.f api/fftw3l.f03 api/fftw3q.f03 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
endif ()
if (EXISTS ${CMAKE_SOURCE_DIR}/api/fftw3.f03.in)
  file (READ api/fftw3.f03.in FFTW3_F03_IN OFFSET 42)
  file (WRITE ${CMAKE_CURRENT_BINARY_DIR}/fftw3.f03 "! Generated automatically.  DO NOT EDIT!\n\n")
  file (APPEND ${CMAKE_CURRENT_BINARY_DIR}/fftw3.f03 "  integer, parameter :: C_FFTW_R2R_KIND = ${C_FFTW_R2R_KIND}\n\n")
  file (APPEND ${CMAKE_CURRENT_BINARY_DIR}/fftw3.f03 "${FFTW3_F03_IN}")
  install (FILES ${CMAKE_CURRENT_BINARY_DIR}/fftw3.f03 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
endif ()
```

--------------------------------

### One transform of a 5 by 6 contiguous array

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Advanced-Complex-DFTs.html

Example setup for a single 2D DFT of size 5x6 with contiguous memory. howmany is 1, so idist and odist are unused and set to 0; strides are 1.

```c
   int rank = 2;
   int n[] = {5, 6};
   int howmany = 1;
   int idist = odist = 0; /* unused because howmany = 1 */
   int istride = ostride = 1; /* array is contiguous in memory */
   int *inembed = n, *onembed = n;
```

--------------------------------

### Quick start audio processing

Source: https://github.com/spotify/pedalboard/blob/master/README.md

Demonstrates creating a Pedalboard with Chorus and Reverb, then processing an audio file in chunks.

```python
from pedalboard import Pedalboard, Chorus, Reverb
from pedalboard.io import AudioFile

# Make a Pedalboard object, containing multiple audio plugins:
board = Pedalboard([Chorus(), Reverb(room_size=0.25)])

# Open an audio file for reading, just like a regular file:
with AudioFile('some-file.wav') as f:
  
  # Open an audio file to write to:
  with AudioFile('output.wav', 'w', f.samplerate, f.num_channels) as o:
  
    # Read one second of audio at a time, until the file is empty:
    while f.tell() < f.frames:
      chunk = f.read(f.samplerate)
      
      # Run the audio through our pedalboard:
      effected = board(chunk, f.samplerate, reset=False)
      
      # Write the output to our output file:
      o.write(effected)
```

--------------------------------

### FFTW MPI 2D DFT Fortran Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/FFTW-MPI-Fortran-Interface.html

A complete example demonstrating how to allocate local memory, create an MPI plan for a 2D DFT, and execute the transform in Fortran.

```fortran
  use, intrinsic :: iso_c_binding
  include 'fftw3-mpi.f03'
  integer(C_INTPTR_T), parameter :: L = ...
  integer(C_INTPTR_T), parameter :: M = ...
  type(C_PTR) :: plan, cdata
  complex(C_DOUBLE_COMPLEX), pointer :: data(:,:)
  integer(C_INTPTR_T) :: i, j, alloc_local, local_M, local_j_offset

!   get local data size and allocate (note dimension reversal)
  alloc_local = fftw_mpi_local_size_2d(M, L, MPI_COMM_WORLD, &
                                       local_M, local_j_offset)
  cdata = fftw_alloc_complex(alloc_local)
  call c_f_pointer(cdata, data, [L,local_M])

!   create MPI plan for in-place forward DFT (note dimension reversal)
  plan = fftw_mpi_plan_dft_2d(M, L, data, data, MPI_COMM_WORLD, &
                              FFTW_FORWARD, FFTW_MEASURE)

! initialize data to some function my_function(i,j)
  do j = 1, local_M
    do i = 1, L
      data(i, j) = my_function(i, j + local_j_offset)
    end do
  end do

! compute transform (as many times as desired)
  call fftw_mpi_execute_dft(plan, data, data)

  call fftw_destroy_plan(plan)
  call fftw_free(cdata)
```

--------------------------------

### Install Matplotlib

Source: https://github.com/spotify/pedalboard/blob/master/INSTALLATION.md

Command to install the Matplotlib package for data visualization.

```bash
pip install matplotlib
```

--------------------------------

### Example FFTW Plan Execution in Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Demonstrates declaring a plan, creating a 2D DFT plan, executing it, and destroying the plan.

```fortran
type(C_PTR) :: plan complex(C_DOUBLE_COMPLEX), dimension(1024,1000) :: in, out plan = fftw_plan_dft_2d(1000,1024, in,out, FFTW_FORWARD,FFTW_ESTIMATE) ... call fftw_execute_dft(plan, in, out) ... call fftw_destroy_plan(plan)
```

--------------------------------

### Generate and install CMake configuration files

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/CMakeLists.txt

Configures and installs the CMake package configuration and version files for FFTW3.

```cmake
set (FFTW3_LIBRARIES "FFTW3::${fftw3_lib}")
configure_file (FFTW3Config.cmake.in FFTW3${PREC_SUFFIX}Config.cmake @ONLY)
configure_file (FFTW3ConfigVersion.cmake.in FFTW3${PREC_SUFFIX}ConfigVersion.cmake @ONLY)
install (FILES
          ${CMAKE_CURRENT_BINARY_DIR}/FFTW3${PREC_SUFFIX}Config.cmake
          ${CMAKE_CURRENT_BINARY_DIR}/FFTW3${PREC_SUFFIX}ConfigVersion.cmake
	  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fftw3${PREC_SUFFIX}
         COMPONENT Development)
```

--------------------------------

### Install pedalboard_native target

Source: https://github.com/spotify/pedalboard/blob/master/CMakeLists.txt

Installs the pedalboard_native target to the current directory (DESTINATION .). This is a standard CMake install command for placing the built target in the specified location.

```CMake
install(TARGETS pedalboard_native DESTINATION .)
```

--------------------------------

### Three contiguous 5 by 6 arrays

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Advanced-Complex-DFTs.html

Example setup for three 2D DFTs of size 5x6 stored contiguously in memory. idist and odist are set to 30, the distance between the first elements of consecutive arrays.

```c
   int rank = 2;
   int n[] = {5, 6};
   int howmany = 3;
   int idist = odist = n[0]*n[1]; /* = 30, the distance in memory
                                     between the first element
                                     of the first array and the
                                     first element of the second array */
   int istride = ostride = 1; /* array is contiguous in memory */
   int *inembed = n, *onembed = n;
```

--------------------------------

### Example parallel loop callback

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Usage-of-Multi_002dthreaded-FFTW.html

An example implementation of a parallel loop using OpenMP to be used with the callback interface.

```c
void parallel_loop(void *(*work)(char *), char *jobdata, size_t elsize, int njobs, void *data)
{
#pragma omp parallel for
    for (int i = 0; i < njobs; ++i)
        work(jobdata + elsize * i);
}
```

--------------------------------

### Fortran 2D Real DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Example of performing a two-dimensional real-to-complex DFT in Fortran.

```Fortran
        double precision in
        dimension in(M,N)
        double complex out
        dimension out(M/2 + 1, N)
        integer*8 plan

        call dfftw_plan_dft_r2c_2d(plan,M,N,in,out,FFTW_ESTIMATE)
        call dfftw_execute_dft_r2c(plan, in, out)
        call dfftw_destroy_plan(plan)
```

--------------------------------

### Generate configuration file from wisdom

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/tools/fftw-wisdom-to-conf.1

This example demonstrates how to use fftw-wisdom to generate wisdom for specific transforms and then pipe that output into fftw-wisdom-to-conf to create a C configuration file.

```bash
fftw-wisdom -n -o wisdom cof1024 cob1024  
fftw-wisdom-to-conf < wisdom > conf.c
```

--------------------------------

### Install NumPy

Source: https://github.com/spotify/pedalboard/blob/master/INSTALLATION.md

Command to install the NumPy package, which is required by pedalboard.

```bash
pip install numpy
```

--------------------------------

### Fortran 1D Real DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Example of performing a one-dimensional real-to-complex DFT in Fortran.

```Fortran
        double precision in
        dimension in(N)
        double complex out
        dimension out(N/2 + 1)
        integer*8 plan

        call dfftw_plan_dft_r2c_1d(plan,N,in,out,FFTW_ESTIMATE)
        call dfftw_execute_dft_r2c(plan, in, out)
        call dfftw_destroy_plan(plan)
```

--------------------------------

### C 3D In-place DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

A C example for performing a three-dimensional in-place complex DFT.

```C
        fftw_complex arr[L][M][N];
        fftw_plan plan;

        plan = fftw_plan_dft_3d(L,M,N, arr,arr,
                                FFTW_FORWARD, FFTW_ESTIMATE);
        fftw_execute(plan);
        fftw_destroy_plan(plan);
```

--------------------------------

### Initializing MPI and Threads for FFTW

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Combining-MPI-and-Threads.html

This example demonstrates the correct initialization sequence for combining MPI and threads, including checking for thread support and initializing FFTW threads before MPI.

```c
int threads_ok;

int main(int argc, char **argv)
{
    int provided;
    MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided);
    threads_ok = provided >= MPI_THREAD_FUNNELED;

    if (threads_ok) threads_ok = fftw_init_threads();
    fftw_mpi_init();

    ...
    if (threads_ok) fftw_plan_with_nthreads(...);
    ...
    
    MPI_Finalize();
}
```

--------------------------------

### Fortran 3D In-place DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

The equivalent Fortran implementation for a three-dimensional in-place complex DFT.

```Fortran
        double complex arr
        dimension arr(L,M,N)
        integer*8 plan

        call dfftw_plan_dft_3d(plan, L,M,N, arr,arr,
       &                       FFTW_FORWARD, FFTW_ESTIMATE)
        call dfftw_execute_dft(plan, arr, arr)
        call dfftw_destroy_plan(plan)
```

--------------------------------

### Install librosa

Source: https://github.com/spotify/pedalboard/blob/master/INSTALLATION.md

Command to install the librosa package, which is used for audio file access and analysis.

```bash
pip install librosa
```

--------------------------------

### 2D REDFT10 x RODFT10 MPI r2r transform example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html

Performs a two-dimensional L x M real-to-real transform using FFTW's MPI interface: REDFT10 (DCT-II) in the first dimension and RODFT10 (DST-II) in the second. Uses fftw_mpi_local_size_2d to get local data size, fftw_alloc_real for real data, and fftw_mpi_plan_r2r_2d with FFTW_MEASURE. The transform is executed in-place with fftw_execute.

```c
    const ptrdiff_t L = ..., M = ...;
    fftw_plan plan;
    double *data;
    ptrdiff_t alloc_local, local_n0, local_0_start, i, j;

    /* get local data size and allocate */
    alloc_local = fftw_mpi_local_size_2d(L, M, MPI_COMM_WORLD,
                                         &local_n0, &local_0_start);
    data = fftw_alloc_real(alloc_local);

    /* create plan for in-place REDFT10 x RODFT10 */
    plan = fftw_mpi_plan_r2r_2d(L, M, data, data, MPI_COMM_WORLD,
                                FFTW_REDFT10, FFTW_RODFT10, FFTW_MEASURE);

    /* initialize data to some function my_function(x,y) */
    for (i = 0; i < local_n0; ++i) for (j = 0; j < M; ++j)
       data[i*M + j] = my_function(local_0_start + i, j);

    /* compute transforms, in-place, as many times as desired */
    fftw_execute(plan);

    fftw_destroy_plan(plan);
```

--------------------------------

### Configure FFTW for ARM with NEON support

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Installation-on-Unix.html

Example command line configuration for cross-compiling FFTW for an ARM architecture with NEON support enabled.

```bash
./configure --with-slow-timer --host=arm-linux-gnueabi \
  --enable-single --enable-neon \
  "CC=arm-linux-gnueabi-gcc -march=armv7-a -mfloat-abi=softfp"
```

--------------------------------

### Create and activate a virtual environment

Source: https://github.com/spotify/pedalboard/blob/master/INSTALLATION.md

Commands to install the virtualenv tool, create a new virtual environment, and activate it within your project directory.

```bash
# Create a virtual environment
python3 -m pip install --user virtualenv 
python3 -m venv .venv

# Activate the virtual environment
source .venv/bin/activate
```

--------------------------------

### Plan 3D DFT using generic routine

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example of using the generic fftw_plan_dft_3d routine with an integer array for dimensions.

```fortran
integer(C_INT), dimension(3) :: n = [N,M,L] plan = fftw_plan_dft_3d(3, n, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
```

--------------------------------

### Import System Wisdom in Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example of importing system-wide wisdom in a Fortran program.

```Fortran
integer isuccess call dfftw_import_system_wisdom(isuccess)
```

--------------------------------

### Example OpenMP Parallel Loop Callback

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

An example implementation of a parallel loop callback using OpenMP to execute FFTW work.

```c
void parallel_loop(void *(*work)(char *), char *jobdata, size_t elsize, int njobs, void *data) { #pragma omp parallel for for (int i = 0; i < njobs; ++i) work(jobdata + elsize * i); }
```

--------------------------------

### Install Ccache on macOS

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Installs Ccache via Homebrew and builds a debug version with clang, using ccache to speed up compilation.

```shell
brew install ccache
rm -rf build && CC="ccache clang" CXX="ccache clang++" DEBUG=1 python3 -j8 -m pip install -e .
```

--------------------------------

### Equivalent call to fftw_plan_dft_2d using fftw_plan_dft

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Complex-Multi_002dDimensional-DFTs.html

This example shows that calling fftw_plan_dft_2d(n0, n1, in, out, sign, flags) is equivalent to setting up an integer array n and calling fftw_plan_dft with rank 2.

```c
fftw_plan_dft_2d(n0, n1, in, out, sign, flags);
```

```c
int n[2];
n[0] = n0;
n[1] = n1;
fftw_plan_dft(2, n, in, out, sign, flags);
```

--------------------------------

### Basic 1D DFT usage pattern

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Complex-One_002dDimensional-DFTs.html

This example demonstrates the standard workflow for a 1D DFT: allocating memory, creating a plan, executing the transform, and cleaning up resources.

```c
#include <fftw3.h>
...
{
    fftw_complex *in, *out;
    fftw_plan p;
    ...
    in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
    out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
    p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
    ...
    fftw_execute(p); /* repeat as needed */
    ...
    fftw_destroy_plan(p);
    fftw_free(in); fftw_free(out);
}
```

--------------------------------

### Compute a 1D DFT with FFTW3

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

A basic example showing the lifecycle of a 1D DFT: allocating memory, creating a plan, executing the transform, and cleaning up resources.

```c
#include <fftw3.h> ... { fftw_complex *in, *out; fftw_plan p; ... in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N); out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N); p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE); ... fftw_execute(p); /* repeat as needed */ ... fftw_destroy_plan(p); fftw_free(in); fftw_free(out); }
```

--------------------------------

### Execute 3D real-to-complex DFT

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example of planning and executing a 3D real-to-complex transform in Fortran.

```fortran
type(C_PTR) :: plan real(C_DOUBLE), dimension(L,M,N) :: in complex(C_DOUBLE_COMPLEX), dimension(L/2+1,M,N) :: out plan = fftw_plan_dft_r2c_3d(N,M,L, in,out, FFTW_ESTIMATE) ... call fftw_execute_dft_r2c(plan, in, out)
```

--------------------------------

### Out-of-place r2c MPI DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

An example demonstrating an out-of-place r2c transform of L x M x N real data, including memory allocation and plan creation.

```c
#include <fftw3-mpi.h>

int main(int argc, char **argv) {
const ptrdiff_t L =..., M =..., N =...;
fftw_plan plan;

double *rin; fftw_complex *cout; ptrdiff_t alloc_local, local_n0, local_0_start, i, j, k;

MPI_Init(&argc, &argv); fftw_mpi_init();

/* get local data size and allocate */ alloc_local = fftw_mpi_local_size_3d(L, M, N/2+1, MPI_COMM_WORLD, &local_n0, &local_0_start); rin = fftw_alloc_real(2 * alloc_local); cout = fftw_alloc_complex(alloc_local);

/* create plan for out-of-place r2c DFT */ plan = fftw_mpi_plan_dft_r2c_3d(L, M, N, rin, cout, MPI_COMM_WORLD, FFTW_MEASURE);

/* initialize rin to some function my_func(x,y,z) */ for (i = 0; i < local_n0; ++i) for (j = 0; j < M; ++j) for (k = 0; k < N; ++k) rin[(i*M + j) * (2*(N/2+1)) + k] = my_func(local_0_start+i, j, k);

/* compute transforms as many times as desired */ fftw_execute(plan);

fftw_destroy_plan(plan);

MPI_Finalize(); }
```

--------------------------------

### Plan column-wise 1D DFTs for a 2D array

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example of planning 1D transforms for each column of a 10-row by 3-column 2D array.

```C
int rank = 1; /* not 2: we are computing 1d transforms */ int n[] = {10}; /* 1d transforms of length 10 */ int howmany = 3; int idist = odist = 1;
int istride = ostride = 3; /* distance between two elements in the same column */ int *inembed = n, *onembed = n;
```

--------------------------------

### Install Ccache on Linux and build with GCC

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Installs ccache via yum (or apt on Debian) and builds a debug version with GCC, using ccache for faster compilation.

```shell
sudo yum install ccache  # or apt, if on a Debian

# If using GCC:
rm -rf build && CC="ccache gcc" CXX="scripts/ccache_g++" DEBUG=1 python3 setup.py build -j8 develop
```

--------------------------------

### Verify and upgrade pip

Source: https://github.com/spotify/pedalboard/blob/master/INSTALLATION.md

Commands to ensure pip is installed and updated to the latest version.

```bash
# pip is installed
python3 -m pip install --user --upgrade pip

# pip is updated 
python3 -m pip --version
```

--------------------------------

### Build debug version with setup.py develop

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Compiles a debug build of pedalboard that allows using a debugger (like gdb or lldb) and installs a symbolic link for debugging.

```shell
python3 setup.py build develop
```

--------------------------------

### 2D Complex DFT with MPI

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/2d-MPI-example.html

A complete C example showing the initialization, planning, data allocation, and execution of a 2D complex DFT using FFTW's MPI interface.

```c
#include <fftw3-mpi.h>

int main(int argc, char **argv)
{
    const ptrdiff_t N0 = ..., N1 = ...;
    fftw_plan plan;
    fftw_complex *data;
    ptrdiff_t alloc_local, local_n0, local_0_start, i, j;

    MPI_Init(&argc, &argv);
    fftw_mpi_init();

    /* get local data size and allocate */
    alloc_local = fftw_mpi_local_size_2d(N0, N1, MPI_COMM_WORLD,
                                         &local_n0, &local_0_start);
    data = fftw_alloc_complex(alloc_local);

    /* create plan for in-place forward DFT */
    plan = fftw_mpi_plan_dft_2d(N0, N1, data, data, MPI_COMM_WORLD,
                                FFTW_FORWARD, FFTW_ESTIMATE);    

    /* initialize data to some function my_function(x,y) */
    for (i = 0; i < local_n0; ++i) for (j = 0; j < N1; ++j)
       data[i*N1 + j] = my_function(local_0_start + i, j);

    /* compute transforms, in-place, as many times as desired */
    fftw_execute(plan);

    fftw_destroy_plan(plan);

    MPI_Finalize();
}
```

--------------------------------

### Call FFTW C interface from Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Overview-of-Fortran-interface.html

Example of declaring a plan and executing a 2D DFT. Note that FFTW plans are represented as type(C_PTR).

```fortran
  type(C_PTR) :: plan
  complex(C_DOUBLE_COMPLEX), dimension(1024,1000) :: in, out
  plan = fftw_plan_dft_2d(1000,1024, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
  ...
  call fftw_execute_dft(plan, in, out)
  ...
  call fftw_destroy_plan(plan)
```

--------------------------------

### Planning a 3D DFT with a fixed-size array

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fixed_002dsize-Arrays-in-C.html

Example of planning a 3D in-place transform using a fixed-size array declared at compile time. The address of the zero-th element is passed to the planner.

```c
{
     fftw_complex data[N0][N1][N2];
     fftw_plan plan;
     ...
     plan = fftw_plan_dft_3d(N0, N1, N2, &data[0][0][0], &data[0][0][0],
                             FFTW_FORWARD, FFTW_ESTIMATE);
     ...
}
```

--------------------------------

### dfftw_planner_nthreads - Get Planner Thread Count

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Fortran example for retrieving the number of threads currently used by the planner. The dfftw_planner_nthreads subroutine returns the thread count in iret.

```APIDOC
## dfftw_planner_nthreads

### Description
Retrieves the number of threads currently being used by the planner.

### Subroutine
- **dfftw_planner_nthreads(iret)** - Returns the current planner thread count.

### Parameters
- **iret** (integer) - Output: The number of threads.

### Example
```fortran
integer iret
call dfftw_planner_nthreads(iret)
```
```

--------------------------------

### Set up includes and library sources

Source: https://github.com/spotify/pedalboard/blob/master/CMakeLists.txt

Defines ALL_INCLUDES with paths to pybind11, JUCE modules, and vendor libraries. Also globs libgsm include directories and appends them.

```CMake
set(ALL_INCLUDES
    "vendors/pybind11/include/"
    "JUCE/modules/"
    "JUCE/modules/juce_audio_processors/format_types/VST3_SDK/"
    "JUCE/modules/juce_audio_formats/codecs/"
    "vendors/"
    "vendors/libgsm/inc/"
    "vendors/lame/include/"
    "vendors/lame/libmp3lame/"
    "vendors/lame/"
)

# Add any paths containing subfolders that need to be included
file(GLOB GSM_INCLUDE_DIRS "vendors/libgsm/inc")
list(APPEND ALL_INCLUDES ${GSM_INCLUDE_DIRS})
```

--------------------------------

### Load and use VST3 or Audio Unit plugins

Source: https://github.com/spotify/pedalboard/blob/master/README.md

Demonstrates loading external plugins, inspecting parameters, and rendering audio using MIDI messages.

```python
from pedalboard import Pedalboard, Reverb, load_plugin
from pedalboard.io import AudioFile
from mido import Message # not part of Pedalboard, but convenient!

# Load a VST3 or Audio Unit plugin from a known path on disk:
instrument = load_plugin("./VSTs/Magical8BitPlug2.vst3")
effect = load_plugin("./VSTs/RoughRider3.vst3")

print(effect.parameters.keys())
# dict_keys([
#   'sc_hpf_hz', 'input_lvl_db', 'sensitivity_db',
#   'ratio', 'attack_ms', 'release_ms', 'makeup_db',
#   'mix', 'output_lvl_db', 'sc_active',
#   'full_bandwidth', 'bypass', 'program',
# ])

# Set the "ratio" parameter to 15
effect.ratio = 15

# Render some audio by passing MIDI to an instrument:
sample_rate = 44100
audio = instrument(
  [Message("note_on", note=60), Message("note_off", note=60, time=5)],
  duration=5, # seconds
  sample_rate=sample_rate,
)

# Apply effects to this audio:
effected = effect(audio, sample_rate)

# ...or put the effect into a chain with other plugins:
board = Pedalboard([effect, Reverb()])
# ...and run that pedalboard with the same VST instance!
effected = board(audio, sample_rate)
```

--------------------------------

### Configure FFTW for a different Fortran compiler

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/FAQ/fftw-faq.html/section2.html

Use ./configure F77=foobar to set the Fortran compiler when installing FFTW, if the default compiler (e.g., g77) is incompatible.

```shell
./configure F77=foobar
```

--------------------------------

### Create and use a Pedalboard

Source: https://github.com/spotify/pedalboard/blob/master/docs/source/reference/pedalboard.rst

Demonstrates how to initialize a Pedalboard, append various effects like Chorus, Distortion, and Reverb, and process audio through the chain.

```python
from pedalboard import Pedalboard, Chorus, Distortion, Reverb

# Create an empty Pedalboard object:
my_pedalboard = Pedalboard()

# Treat this object like a Python list:
my_pedalboard.append(Chorus())
my_pedalboard.append(Distortion())
my_pedalboard.append(Reverb())

# Pass audio through this pedalboard:
output_audio = my_pedalboard(input_audio, input_audio_samplerate)
```

--------------------------------

### dfftw_plan_dft_r2c_1d, dfftw_execute_dft_r2c, dfftw_destroy_plan - 1D Real-to-Complex Transform

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Fortran example for a one-dimensional real-to-complex (r2c) transform. The plan is created with dfftw_plan_dft_r2c_1d, executed with dfftw_execute_dft_r2c, and destroyed with dfftw_destroy_plan.

```APIDOC
## dfftw_plan_dft_r2c_1d, dfftw_execute_dft_r2c, dfftw_destroy_plan

### Description
Performs a one-dimensional real-to-complex (r2c) transform in Fortran. The plan is created with dfftw_plan_dft_r2c_1d, executed with dfftw_execute_dft_r2c, and destroyed with dfftw_destroy_plan.

### Subroutines
- **dfftw_plan_dft_r2c_1d(plan, N, in, out, flags)** - Creates a plan for a 1D r2c transform.
- **dfftw_execute_dft_r2c(plan, in, out)** - Executes the plan.
- **dfftw_destroy_plan(plan)** - Destroys the plan.

### Parameters
- **plan** (integer*8) - Output: The plan handle.
- **N** (integer) - Input: The size of the transform.
- **in** (double precision array) - Input: The real input array.
- **out** (double complex array) - Output: The complex output array of size N/2 + 1.
- **flags** (integer) - Input: FFTW_ESTIMATE or other flags.

### Example
```fortran
double precision in
dimension in(N)
double complex out
dimension out(N/2 + 1)
integer*8 plan

call dfftw_plan_dft_r2c_1d(plan,N,in,out,FFTW_ESTIMATE)
call dfftw_execute_dft_r2c(plan, in, out)
call dfftw_destroy_plan(plan)
```
```

--------------------------------

### dfftw_plan_dft_3d, dfftw_execute_dft, dfftw_destroy_plan - 3D In-place Complex DFT

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

Fortran example for a three-dimensional in-place complex DFT, equivalent to the C code using fftw_plan_dft_3d. The plan is created with dfftw_plan_dft_3d, executed with dfftw_execute_dft, and destroyed with dfftw_destroy_plan.

```APIDOC
## dfftw_plan_dft_3d, dfftw_execute_dft, dfftw_destroy_plan

### Description
Performs a three-dimensional in-place complex DFT in Fortran. The plan is created with dfftw_plan_dft_3d, executed with dfftw_execute_dft, and destroyed with dfftw_destroy_plan.

### Subroutines
- **dfftw_plan_dft_3d(plan, L, M, N, in, out, sign, flags)** - Creates a plan for a 3D complex DFT.
- **dfftw_execute_dft(plan, in, out)** - Executes the plan.
- **dfftw_destroy_plan(plan)** - Destroys the plan.

### Parameters
- **plan** (integer*8) - Output: The plan handle.
- **L, M, N** (integer) - Input: The dimensions of the transform.
- **in** (double complex array) - Input/Output: The input array (in-place).
- **out** (double complex array) - Output: The output array (same as in for in-place).
- **sign** (integer) - Input: FFTW_FORWARD or FFTW_BACKWARD.
- **flags** (integer) - Input: FFTW_ESTIMATE or other flags.

### Example
```fortran
double complex arr
dimension arr(L,M,N)
integer*8 plan

call dfftw_plan_dft_3d(plan, L,M,N, arr,arr,
&                       FFTW_FORWARD, FFTW_ESTIMATE)
call dfftw_execute_dft(plan, arr, arr)
call dfftw_destroy_plan(plan)
```
```

--------------------------------

### Create a guitar-style pedalboard

Source: https://github.com/spotify/pedalboard/blob/master/README.md

Shows how to chain multiple effects, append plugins to an existing board, and modify parameters dynamically.

```python
# Don't do import *! (It just makes this example smaller)
from pedalboard import *
from pedalboard.io import AudioFile

# Read in a whole file, resampling to our desired sample rate:
samplerate = 44100.0
with AudioFile('guitar-input.wav').resampled_to(samplerate) as f:
  audio = f.read(f.frames)

# Make a pretty interesting sounding guitar pedalboard:
board = Pedalboard([
    Compressor(threshold_db=-50, ratio=25),
    Gain(gain_db=30),
    Chorus(),
    LadderFilter(mode=LadderFilter.Mode.HPF12, cutoff_hz=900),
    Phaser(),
    Convolution("./guitar_amp.wav", 1.0),
    Reverb(room_size=0.25),
])

# Pedalboard objects behave like lists, so you can add plugins:
board.append(Compressor(threshold_db=-25, ratio=10))
board.append(Gain(gain_db=10))
board.append(Limiter())

# ... or change parameters easily:
board[0].threshold_db = -40

# Run the audio through this pedalboard!
effected = board(audio, samplerate)

# Write the audio back as a wav file:
with AudioFile('processed-output.wav', 'w', samplerate, effected.shape[0]) as f:
  f.write(effected)
```

--------------------------------

### Configure Test Suite

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/CMakeLists.txt

Sets up the benchmark executable and test macros if testing is enabled.

```cmake
if (BUILD_TESTS)

  add_executable (bench ${fftw_libbench2_SOURCE} tests/bench.c tests/hook.c tests/fftw-bench.c)

  if (ENABLE_THREADS AND NOT WITH_COMBINED_THREADS)
    target_link_libraries (bench ${fftw3_lib}_threads)
  else ()
    target_link_libraries (bench ${fftw3_lib})
  endif ()


  enable_testing ()

  if (Threads_FOUND)

    macro (fftw_add_test problem)
      add_test (NAME ${problem} COMMAND bench -s ${problem})
    endmacro ()

    fftw_add_test (32x64)
    fftw_add_test (ib256)

  endif ()
endif ()
```

--------------------------------

### C 1D Complex DFT Example

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Fortran-Examples.html

A standard C example for performing a one-dimensional complex DFT.

```C
        fftw_complex in[N], out[N];
        fftw_plan plan;

        plan = fftw_plan_dft_1d(N,in,out,FFTW_FORWARD,FFTW_ESTIMATE);
        fftw_execute(plan);
        fftw_destroy_plan(plan);
```

--------------------------------

### Importing FFTW MPI Wisdom from a File

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/FFTW-MPI-Wisdom.html

This snippet demonstrates importing wisdom from a file on process 0 and broadcasting it to all other processes in the communicator.

```c
{
    int rank;

    fftw_mpi_init();
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if (rank == 0) fftw_import_wisdom_from_filename("mywisdom");
    fftw_mpi_broadcast_wisdom(MPI_COMM_WORLD);
}
```

--------------------------------

### Generate type stubs and documentation

Source: https://github.com/spotify/pedalboard/blob/master/pedalboard_native/README.md

Run this command to automatically update the contents of the type hints directory.

```bash
python3 -m scripts.generate_type_stubs_and_docs
```

--------------------------------

### 1D Complex DFT in Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example of transforming a one-dimensional complex array in Fortran.

```Fortran
double complex in, out dimension in(N), out(N) integer*8 plan

call dfftw_plan_dft_1d(plan,N,in,out,FFTW_FORWARD,FFTW_ESTIMATE) call dfftw_execute_dft(plan, in, out)

call dfftw_destroy_plan(plan)
```

--------------------------------

### fftw_mpi_local_size_3d

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/MPI-Data-Distribution-Functions.html

Determines the local size and starting index for a 3D distributed transform.

```APIDOC
## fftw_mpi_local_size_3d

### Description
Returns the number of elements to allocate for a 3D distributed transform and the local portion of the first dimension.

### Function Signature
```c
ptrdiff_t fftw_mpi_local_size_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
                                 MPI_Comm comm,
                                 ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
```

### Parameters
- **n0** (ptrdiff_t) - Required - Size of the first dimension.
- **n1** (ptrdiff_t) - Required - Size of the second dimension.
- **n2** (ptrdiff_t) - Required - Size of the third dimension.
- **comm** (MPI_Comm) - Required - MPI communicator.
- **local_n0** (ptrdiff_t *) - Required - Output: local size of the first dimension.
- **local_0_start** (ptrdiff_t *) - Required - Output: starting index of the local portion.

### Return Value
- **ptrdiff_t** - Number of elements to allocate (complex numbers for DFT/r2c/c2r plans, real numbers for r2r plans).
```

--------------------------------

### Creating parallel effects chains

Source: https://github.com/spotify/pedalboard/blob/master/README.md

Demonstrates how to run multiple Pedalboard objects in parallel by nesting them within a Mix plugin. Pedalboard objects act as Plugin objects, allowing for complex, nested effect chains.

```python
from pedalboard import Pedalboard, Compressor, Delay, Distortion, Gain, PitchShift, Reverb, Mix

passthrough = Gain(gain_db=0)

delay_and_pitch_shift = Pedalboard([
  Delay(delay_seconds=0.25, mix=1.0),
  PitchShift(semitones=7),
  Gain(gain_db=-3),
])

delay_longer_and_more_pitch_shift = Pedalboard([
  Delay(delay_seconds=0.5, mix=1.0),
  PitchShift(semitones=12),
  Gain(gain_db=-6),
])

board = Pedalboard([
  # Put a compressor at the front of the chain:
  Compressor(),
  # Run all of these pedalboards simultaneously with the Mix plugin:
  Mix([
    passthrough,
    delay_and_pitch_shift,
    delay_longer_and_more_pitch_shift,
  ]),
  # Add a reverb on the final mix:
  Reverb()
])
```

--------------------------------

### Perform a distributed L x M complex DFT in-place in Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

This snippet demonstrates initializing an MPI-aware FFTW plan, allocating memory, initializing data, and executing the transform.

```Fortran
use, intrinsic :: iso_c_binding include ’fftw3-mpi.f03’ integer(C_INTPTR_T), parameter :: L =... integer(C_INTPTR_T), parameter :: M =... type(C_PTR) :: plan, cdata complex(C_DOUBLE_COMPLEX), pointer :: data(:,:) integer(C_INTPTR_T) :: i, j, alloc_local, local_M, local_j_offset

! get local data size and allocate (note dimension reversal) alloc_local = fftw_mpi_local_size_2d(M, L, MPI_COMM_WORLD, & local_M, local_j_offset) cdata = fftw_alloc_complex(alloc_local) call c_f_pointer(cdata, data, [L,local_M])

! create MPI plan for in-place forward DFT (note dimension reversal) plan = fftw_mpi_plan_dft_2d(M, L, data, data, MPI_COMM_WORLD, & FFTW_FORWARD, FFTW_MEASURE)

! initialize data to some function my_function(i,j) do j = 1, local_M do i = 1, L data(i, j) = my_function(i, j + local_j_offset) end do end do

! compute transform (as many times as desired) call fftw_mpi_execute_dft(plan, data, data)

call fftw_destroy_plan(plan)

call fftw_free(cdata)
```

--------------------------------

### Initialize Git submodules to fix lame.h error

Source: https://github.com/spotify/pedalboard/blob/master/CONTRIBUTING.md

Execute this command to update and initialize all Git submodules, which resolves the 'fatal error: lame/include/lame.h: No such file or directory' error.

```shell
git submodule update --init
```

--------------------------------

### Select compiler with ./configure CC=...

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/html/Installation-on-Unix.html

The configure script chooses gcc by default if available. Use this command to select a different C compiler.

```shell
./configure CC="<the name of your C compiler>"
```

--------------------------------

### Incompatible multi-dimensional array allocation

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

An example of the 'array of pointers' method, which is incompatible with FFTW and should be avoided.

```c
int i,j; fftw_complex ***a_bad_array; /* another way to make a 5x12x27 array */

a_bad_array = (fftw_complex ***) malloc(5 * sizeof(fftw_complex **)); for (i = 0; i < 5; ++i) { a_bad_array[i] = (fftw_complex **) malloc(12 * sizeof(fftw_complex *)); for (j = 0; j < 12; ++j) a_bad_array[i][j] = (fftw_complex *) malloc(27 * sizeof(fftw_complex)); }
```

--------------------------------

### Declare 3D complex array in Fortran

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/fftw3.pdf

Example declaration of a 3D complex array using C_DOUBLE_COMPLEX.

```fortran
complex(C_DOUBLE_COMPLEX), dimension(L,M,N) :: in, out
```

--------------------------------

### Solaris compiler error message

Source: https://github.com/spotify/pedalboard/blob/master/vendors/fftw3/doc/FAQ/fftw-faq.html/section2.html

Example of the warning message encountered when using a non-ANSI compiler on Solaris.

```text
"./fftw.h", line 88: warning: const is a keyword in ANSI C
```
Tokens:
Raw