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
127
128
129
130
131
132
133
134
135
|
/*
* Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
* (C) 2020 Vladimir Sadovnikov <sadko4u@gmail.com>
*
* This file is part of lsp-dsp-units
* Created on: 07 дек. 2015 г.
*
* lsp-dsp-units is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-dsp-units is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-dsp-units. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef LSP_PLUG_IN_DSP_UNITS_CTL_BYPASS_H_
#define LSP_PLUG_IN_DSP_UNITS_CTL_BYPASS_H_
#include <lsp-plug.in/dsp-units/version.h>
#include <lsp-plug.in/dsp-units/iface/IStateDumper.h>
namespace lsp
{
namespace dspu
{
/**
* Bypass class, provides utilitary class for implementing mono bypass function
*/
class LSP_DSP_UNITS_PUBLIC Bypass
{
private:
Bypass & operator = (const Bypass &);
Bypass(const Bypass &);
private:
enum state_t
{
S_ON,
S_ACTIVE,
S_OFF
};
state_t nState;
float fDelta;
float fGain;
public:
explicit Bypass();
~Bypass();
/**
* Construct object
*/
void construct();
/**
* Destroy object
*/
void destroy();
public:
/**
* Initialize bypass
* @param sample_rate sample rate
* @param time the bypass switch time, by default 5 milliseconds
*/
void init(int sample_rate, float time = 0.005f);
/**
* Process the signal. If Bypass is on, then dry signal is passed to output.
* If bypass is off, then wet signal is passed.
* When bypass is in active state, the mix of dry and wet signal is passed to
* output.
*
* @param dst output buffer
* @param dry dry signal buffer
* @param wet wet signal buffer
* @param count number of samples to process
*/
void process(float *dst, const float *dry, const float *wet, size_t count);
/**
* Enable/disable bypass
* @param bypass bypass value
* @return true if bypass state has changed
*/
bool set_bypass(bool bypass);
/** Enable/disable bypass
*
* @param bypass bypass value, when less than 0.5, bypass is considered to become shut down
* @return true if bypass state has changed
*/
inline bool set_bypass(float bypass) { return set_bypass(bypass >= 0.5f); };
/**
* Return true if bypass is on (final state)
* @return true if bypass is on
*/
inline bool on() const { return nState == S_ON; };
/**
* Return true if bypass is off (final state)
* @return true if bypass is off
*/
inline bool off() const { return nState == S_OFF; };
/**
* Return true if bypass is active
* @return true if bypass is active
*/
inline bool active() const { return nState == S_ACTIVE; };
/**
* Return true if bypass is on or is currently going to become on
* @return true if bypass is on or is currently going to become on
*/
bool bypassing() const;
/**
* Dump the state
* @param dumper dumper
*/
void dump(IStateDumper *v) const;
};
}
} /* namespace lsp */
#endif /* LSP_PLUG_IN_DSP_UNITS_CTL_BYPASS_H_ */
|
