| # Development | |
| The effects included are designed to be as portable as possible, as well as making it easy to add additional effects. | |
| ## Building | |
| To build the app, simply open the project in android studio and build. The app integrates Oboe via a git submodule. Make sure | |
| when cloning the repository to clone the submodule as well using `git clone --recursive`, or `git submodule update --init --recursive`. | |
| To update the version of Oboe being used, descend into the Oboe repository [(oboe location)](../app/src/main/cpp) | |
| and update from its remote. Then, call `git submodule update` in this repository. Alternatively `git submodule update --recursive --remote` will pull the latest version of Oboe from remote. | |
| Although the CMake file requires android headers (to use Oboe), the effects themselves can be compiled with any C++17 compliant compiler. | |
| ## Architecture | |
| The UI code (Kotlin) calls native code through the JNI bridge to query information about the various effects implemented, | |
| and how to render the effect information in the UI. This means that adding an effect only needs to be done on the | |
| native side. The JNI bridge passes information regarding implemented effects descriptions to the UI as well as functions | |
| called when the user modifies effects in the UI. | |
| The `DuplexEngine` is responsible for managing and syncing the input and output Oboe streams for rendering audio | |
| with as low latency as possible. The `FunctionList` class contains the a vector of effects that correspond to the list of | |
| effects (and their parameters) that the user wants to use to process their audio. Effects (and the `FunctionList`) overload | |
| their function operator to take in two numeric iterator types. E.g `<template iter_type> void operator() | |
| (iter_type begin, iter_type end)`, where the `iter_types` correspond to C++ iterators carrying audio data. To erase the type | |
| of different objects, the `FunctionList` holds objects of types `std::function<void(iter_type, iter_type)>` i.e. functions | |
| which operate on the range between two numeric iterators in place. The `DuplexEngine`simply calls the `FunctionList` on every | |
| buffer of samples it receives. | |
| The effects folder contains the classes of various implemented effects. It also contains `Effects.h` where a global tuple of | |
| all the Effect descriptions implemented lives. The description folder contains the description for all of the effects. | |
| Each description takes the form of a class with static methods providing information regarding the effect (including name, | |
| category, parameters, and a factory method). | |
| ## Adding Effects | |
| To add an effect, simply add a Description class similar to the existing classes, and add the class to the tuple in `Effects.h`. The description must provide a way to build the effect by either constructing another class corresponding | |
| to an effect, or pointing to a standalone function. Adding new effects is welcome! | |
| ## Existing Effects | |
| A instructional implemented effect to examine is the `TremoloEffect.h` (a modulating gain). | |
| Many of the effects in the delay category | |
| inherit from `DelayLineEffect` which provides a framework to easily implement many delay based effects, as well as | |
| the comb filter effects (FIR, IIR, allpass). The slides have a block diagram displaying the mathematical basis of the effect. | |
| The nonlinear effects (distortion and overdrive) are implemented using a standalone function (from `SingleEffectFunctions.h`. | |
| The gain effect is implemented by a simple lambda in its description class. |