translator.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Std includes
#include <vector>
#include <functional>
#include <mathutils.h>
 
// Audio includes
#include <audio/utility/audiofunctions.h>
 
 
namespace nap
{
    namespace audio
    {
        
        template<typename T>
        class Translator
        {
        public:
            virtual ~Translator() { }
            
            virtual T translate(const T& inputValue) = 0;
        
        private:
        };
        
        
        template<typename T>
        class TableTranslator : public Translator<T>
        {
        public:
            using FillFunction = std::function<T(T)>;
            
            TableTranslator(unsigned int size) { mTable.resize(size); }
            
            T translate(const T& inputValue) override final
            {
                return translate(inputValue, mTable);
            }
            
            void fill(FillFunction fillFunction)
            {
                for (int i = 0; i < mTable.size(); i++)
                {
                    mTable[i] = fillFunction(i / T(mTable.size() - 1));
                }
            }
            
            static inline T translate(const T& inputValue, const std::vector<T>& inTable)
            {
                // scale input accross table size
                T index = math::clamp(inputValue, 0.f, 1.f) * (inTable.size() - 1);
                
                // convert to integer
                int floor = index;
                
                // interpolate
                T frac = index - floor;
                if (frac > 0)
                    return lerp(inTable[floor], inTable[floor + 1], frac);
                else
                    return inTable[floor];
            }
            
        private:
            std::vector<T> mTable;
        };
        
        
        template<typename T>
        class EqualPowerTranslator : public TableTranslator<T>
        {
        public:
            EqualPowerTranslator(unsigned int size) : TableTranslator<T>(size)
            {
                // fills the table using equal power function
                TableTranslator<T>::fill([](T x) { return sin(x * math::PI_2); });
            }
        
        private:
 
        };
        
    }
}