dsputilities.h

Go to the documentation of this file.

/********************************************************************************************
 * Twitch Broadcasting SDK
 *
 * This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
 * may not be copied or used except in accordance with the terms of that agreement
 * Copyright (c) 2012-2017 Twitch Interactive, Inc.
 *
 *********************************************************************************************/

#pragma once

#include <array>
#include <cmath>

namespace ttv
{
    constexpr double kPi = 3.14159265358979323846;
    
    struct SampleRange
    {
        SampleRange()
        :   startIndex(0)
        ,   sampleCount(0)
        {}
        
        SampleRange(size_t startIndex, size_t sampleCount)
        :   startIndex(startIndex)
        ,   sampleCount(sampleCount)
        {}
        
        size_t startIndex;
        
        size_t sampleCount;
    };
    
    
    SampleRange IntersectSampleRanges(SampleRange firstRange, SampleRange secondRange)
    {
        size_t outputRangeStart = std::max(firstRange.startIndex, secondRange.startIndex);
        size_t outputRangeEnd = std::min(firstRange.startIndex + firstRange.sampleCount, secondRange.startIndex + secondRange.sampleCount);
        
        if (outputRangeStart < outputRangeEnd)
        {
            return {outputRangeStart, outputRangeEnd - outputRangeStart};
        }
        else
        {
            return {};
        }
    }
    
    SampleRange ExtendSampleRange(SampleRange range, SampleRange extension)
    {
        if ((extension.startIndex + extension.sampleCount >= range.startIndex) && (range.startIndex + range.sampleCount >= extension.startIndex))
        {
            size_t outputRangeStart = std::min(range.startIndex, extension.startIndex);
            size_t outputRangeEnd = std::max(range.startIndex + range.sampleCount, extension.startIndex + extension.sampleCount);
            
            return {outputRangeStart, outputRangeEnd - outputRangeStart};
        }
        
        return range;
    }
    
    template <typename SampleTypeArg, size_t SampleRateArg, size_t ChannelCountArg = 1>
    struct BufferFormat
    {
        static_assert(ChannelCountArg != 0, "Channel count can't be zero.");
        static_assert(SampleRateArg != 0, "Sample rate cannot be zero.");
        
        using SampleType = SampleTypeArg;
        static constexpr size_t SampleRate = SampleRateArg;
        static constexpr size_t ChannelCount = ChannelCountArg;
    };
    
    template <typename IntegralType>
    constexpr size_t BisectRange()
    {
        static_assert(std::is_integral<IntegralType>::value, "Must be an integral type.");
        return 1 << ((sizeof(IntegralType) * 8) - 1);
    }
    
    
    template <typename SampleType>
    std::enable_if_t<std::is_floating_point<SampleType>::value, SampleType> ClampAndCastSample(double input)
    {
        if (input > 1.0)
        {
            return static_cast<SampleType>(1.0);
        }
        
        if (input < -1.0)
        {
            return static_cast<SampleType>(-1.0);
        }
        
        return static_cast<SampleType>(input);
    }
    
    template <typename SampleType>
    std::enable_if_t<std::is_integral<SampleType>::value, SampleType> ClampAndCastSample(double input)
    {
        if (input > std::numeric_limits<SampleType>::max())
        {
            return std::numeric_limits<SampleType>::max();
        }
        
        if (input < std::numeric_limits<SampleType>::min())
        {
            return std::numeric_limits<SampleType>::min();
        }
        
        return static_cast<SampleType>(input);
    }
    
    
    template <typename Generator, size_t Length>
    class LookupTable
    {
    public:
        LookupTable()
        {
            for (size_t i = 0; i < Length; i++)
            {
                mValues[i] = Generator::Generate(i, Length);
            }
        }
        
        typename Generator::ReturnType operator[](size_t index) const
        {
            assert(index < mValues.size());
            
            return mValues[index];
        }
        
    private:
        std::array<typename Generator::ReturnType, Length> mValues;
    };
    
    template <typename FirstGenerator, typename SecondGenerator>
    struct ProductGenerator
    {
        static_assert(std::is_same<typename FirstGenerator::ReturnType, typename SecondGenerator::ReturnType>::value, "Factors of ProductGenerator must return the same type.");
        using ReturnType = typename FirstGenerator::ReturnType;
        
        static ReturnType Generate(size_t index, size_t length)
        {
            return FirstGenerator::Generate(index, length) * SecondGenerator::Generate(index, length);
        }
    };
    
    
    template <typename InputGenerator, size_t SamplingInterval>
    struct CyclingGenerator
    {
        using ReturnType = typename InputGenerator::ReturnType;
        
        static ReturnType Generate(size_t index, size_t length)
        {
            size_t cycleCount = length / SamplingInterval;
            size_t intervalCount = index % cycleCount;
            size_t shift = index / cycleCount;
            
            size_t cycledIndex = intervalCount * SamplingInterval + shift;
            
            return InputGenerator::Generate(cycledIndex, length);
        }
    };
    
    
    template <typename SincFunctionParameters>
    struct SincFunctionGenerator
    {
        using ReturnType = double;
        
        static ReturnType Generate(size_t index, size_t length)
        {
            if (index * 2 == length + 1)
            {
                // We're exactly in the center.
                return 1.0;
            }
            
            double time = static_cast<double>(index) / static_cast<double>(length - 1);
            
            // Center along the domain
            time -= 0.5;
            
            time *= static_cast<double>(SincFunctionParameters::Range);
            
            double x = 2.0 * kPi * time * SincFunctionParameters::Cutoff;
            
            return std::sin(x) / x;
        }
    };
    
    
    template <typename Parameters>
    struct KaiserBesselWindowFunctionGenerator
    {
        using ReturnType = double;
        
        static double BesselFunction(double x)
        {
            constexpr double epsilon = 1E-21;
            double halfXSquared = x * x / 4.0;
            
            double sigmaTerm = 1.0; // First sigma term is always 1
            double sigma = sigmaTerm;
            
            for (double sigmaIndex = 1.0; sigmaTerm > sigma * epsilon; sigmaIndex++)
            {
                // We can calculate the next term by modifying the previous term.
                sigmaTerm *= halfXSquared;
                sigmaTerm /= (sigmaIndex * sigmaIndex);
                
                sigma += sigmaTerm;
            }
            
            return sigma;
        }

        
        static ReturnType Generate(size_t index, size_t length)
        {
            double windowLengthMinusOne = static_cast<double>(Parameters::Length - 1);
            double position = static_cast<double>(index) * static_cast<double>(windowLengthMinusOne) / static_cast<double>(length);
            
            double value = 2 * position - windowLengthMinusOne;
            value /= windowLengthMinusOne;
            value *= value;
            value = 1.0 - value;
            value = sqrt(value);
            value *= Parameters::Beta;
            value = BesselFunction(value);
            value /= BesselFunction(Parameters::Beta);
            return value;
        }
    };
}