新增DelayMono模块

chenlh

2026-03-26 36e42207da4c088b5bfd96f2cfc8944f890440d7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include "LinearInterpolationCircularBuffer.h"
 
template <typename SampleType>
LinearInterpolationCircularBuffer<SampleType>::LinearInterpolationCircularBuffer()
{
    buffer.reset(new std::vector<SampleType>);
}
 
template <typename SampleType>
LinearInterpolationCircularBuffer<SampleType>::~LinearInterpolationCircularBuffer()
{
    buffer->clear();
    buffer.reset(nullptr);
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::prepare(int sampleRate)
{
    this->sampleRate = sampleRate;
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::clear()
{
    buffer->clear();
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::setSize(int newBufferSize)
{
    clear();
    buffer->resize(newBufferSize);
    this->bufferSize = newBufferSize;
    writePointer = 0;
    readPointer = 0;
}
 
template <typename SampleType>
int LinearInterpolationCircularBuffer<SampleType>::getNumSamples()
{
    return buffer->size();
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::setDelayInSamples(SampleType delayInSamples)
{
    delay = limitWithinRange(SampleType(0), SampleType(bufferSize - 1), delayInSamples);    
    delayInt  = static_cast<int> (std::floor (delay));
    delayFrac = delay - (SampleType) delayInt;
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::setDelayInMs(SampleType delayInMs)
{
    setDelayInSamples((delayInMs / 1000) * sampleRate);
}
 
template <typename SampleType>
SampleType LinearInterpolationCircularBuffer<SampleType>::processSample(SampleType input)
{
    pushSample(input);
 
    return popSample();
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::process(SampleType* channelData, int startSample, int endSample)
{
    for(int sample = startSample; sample < endSample; ++sample)
        channelData[sample] = processSample(channelData[sample]);
}
 
template <typename SampleType>
void LinearInterpolationCircularBuffer<SampleType>::pushSample(SampleType sample)
{
    (*buffer)[writePointer] = sample;
    writePointer = (writePointer + bufferSize - 1) % bufferSize;
}
 
template <typename SampleType>
SampleType LinearInterpolationCircularBuffer<SampleType>::popSample()
{
    SampleType returnValue = interpolateSample();
    readPointer = (readPointer + bufferSize - 1) % bufferSize;
 
    return returnValue;
}
 
template <typename SampleType>
SampleType LinearInterpolationCircularBuffer<SampleType>::interpolateSample()
{
    auto index1 = readPointer + delayInt;
    auto index2 = index1 + 1;
 
    if(index2 >= bufferSize)
    {
        index1 %= bufferSize;
        index2 %= bufferSize;
    }
 
    SampleType value1 = (*buffer)[index1];
    SampleType value2 = (*buffer)[index2];
 
    return value1 + delayFrac * (value2 - value1);
}
 
template <typename SampleType>
int LinearInterpolationCircularBuffer<SampleType>::getReadPointerIndex()
{
    return readPointer;
}
 
template <typename SampleType>
int LinearInterpolationCircularBuffer<SampleType>::getWritePointerIndex()
{
    return writePointer;
}
 
template <typename SampleType>
SampleType LinearInterpolationCircularBuffer<SampleType>::limitWithinRange(SampleType lowerLimit, SampleType upperLimit, SampleType value)
{
    return value < lowerLimit ? lowerLimit : (upperLimit < value ? upperLimit : value);
}
 
template class LinearInterpolationCircularBuffer<float>;
template class LinearInterpolationCircularBuffer<double>;