Line data Source code
1 :
2 : /* Copyright (c) 2012, Daniel Nachbaur <danielnachbaur@gmail.com>
3 : * 2012-2013, Stefan.Eilemann@epfl.ch
4 : *
5 : * This library is free software; you can redistribute it and/or modify it under
6 : * the terms of the GNU Lesser General Public License version 2.1 as published
7 : * by the Free Software Foundation.
8 : *
9 : * This library is distributed in the hope that it will be useful, but WITHOUT
10 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11 : * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12 : * details.
13 : *
14 : * You should have received a copy of the GNU Lesser General Public License
15 : * along with this library; if not, write to the Free Software Foundation, Inc.,
16 : * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 : */
18 :
19 : #include "equalizer.h"
20 :
21 : #include "configParams.h"
22 : #include "global.h"
23 :
24 : #include <co/dataIStream.h>
25 : #include <co/dataOStream.h>
26 :
27 : namespace eq
28 : {
29 : namespace fabric
30 : {
31 : namespace detail
32 : {
33 18 : class Equalizer
34 : {
35 : public:
36 1008 : Equalizer()
37 1008 : : damping(.5f)
38 1008 : , boundaryf(std::numeric_limits<float>::epsilon())
39 : , resistancef(.0f)
40 1008 : , assembleOnlyLimit(std::numeric_limits<float>::max())
41 : , frameRate(10.f)
42 : , boundary2i(1, 1)
43 : , resistance2i(0, 0)
44 : , tilesize(64, 64)
45 : , mode(fabric::Equalizer::MODE_2D)
46 3024 : , frozen(false)
47 : {
48 1008 : const uint32_t flags = eq::fabric::Global::getFlags();
49 1008 : switch (flags & fabric::ConfigParams::FLAG_LOAD_EQ_ALL)
50 : {
51 : case fabric::ConfigParams::FLAG_LOAD_EQ_2D:
52 0 : mode = fabric::Equalizer::MODE_2D;
53 0 : break;
54 : case fabric::ConfigParams::FLAG_LOAD_EQ_HORIZONTAL:
55 0 : mode = fabric::Equalizer::MODE_HORIZONTAL;
56 0 : break;
57 : case fabric::ConfigParams::FLAG_LOAD_EQ_VERTICAL:
58 0 : mode = fabric::Equalizer::MODE_VERTICAL;
59 0 : break;
60 : case fabric::ConfigParams::FLAG_NONE:
61 1008 : break;
62 : default:
63 0 : LBUNIMPLEMENTED;
64 : }
65 1008 : }
66 :
67 62 : Equalizer(const Equalizer& rhs)
68 62 : : damping(rhs.damping)
69 62 : , boundaryf(rhs.boundaryf)
70 62 : , resistancef(rhs.resistancef)
71 62 : , assembleOnlyLimit(rhs.assembleOnlyLimit)
72 62 : , frameRate(rhs.frameRate)
73 : , boundary2i(rhs.boundary2i)
74 : , resistance2i(rhs.resistance2i)
75 : , tilesize(rhs.tilesize)
76 62 : , mode(rhs.mode)
77 372 : , frozen(rhs.frozen)
78 : {
79 62 : }
80 :
81 : float damping;
82 : float boundaryf;
83 : float resistancef;
84 : float assembleOnlyLimit;
85 : float frameRate;
86 : Vector2i boundary2i;
87 : Vector2i resistance2i;
88 : Vector2i tilesize;
89 : fabric::Equalizer::Mode mode;
90 : bool frozen;
91 : };
92 : }
93 :
94 1008 : Equalizer::Equalizer()
95 1008 : : _data(new detail::Equalizer)
96 2016 : , _backup(0)
97 : {
98 1008 : }
99 :
100 44 : Equalizer::Equalizer(const Equalizer& rhs)
101 44 : : _data(new detail::Equalizer(*rhs._data))
102 88 : , _backup(0)
103 : {
104 44 : }
105 :
106 : // cppcheck-suppress operatorEqVarError
107 18 : Equalizer& Equalizer::operator=(const Equalizer& rhs)
108 : {
109 18 : if (this == &rhs)
110 0 : return *this;
111 :
112 18 : *_data = *rhs._data;
113 18 : return *this;
114 : }
115 :
116 2100 : Equalizer::~Equalizer()
117 : {
118 1050 : delete _data;
119 1050 : }
120 :
121 0 : void Equalizer::setFrozen(const bool onOff)
122 : {
123 0 : _data->frozen = onOff;
124 0 : }
125 :
126 36 : bool Equalizer::isFrozen() const
127 : {
128 36 : return _data->frozen;
129 : }
130 :
131 146 : void Equalizer::setMode(const Mode mode)
132 : {
133 146 : _data->mode = mode;
134 146 : }
135 :
136 164 : Equalizer::Mode Equalizer::getMode() const
137 : {
138 164 : return _data->mode;
139 : }
140 :
141 16 : void Equalizer::setDamping(const float damping)
142 : {
143 16 : _data->damping = damping;
144 16 : }
145 :
146 182 : float Equalizer::getDamping() const
147 : {
148 182 : return _data->damping;
149 : }
150 :
151 16 : void Equalizer::setFrameRate(const float frameRate)
152 : {
153 16 : _data->frameRate = frameRate;
154 16 : }
155 :
156 24 : float Equalizer::getFrameRate() const
157 : {
158 24 : return _data->frameRate;
159 : }
160 :
161 0 : void Equalizer::setBoundary(const Vector2i& boundary)
162 : {
163 0 : LBASSERT(boundary.x() > 0 && boundary.y() > 0);
164 0 : _data->boundary2i = boundary;
165 0 : }
166 :
167 0 : void Equalizer::setBoundary(const float boundary)
168 : {
169 0 : LBASSERT(boundary > 0.0f);
170 0 : _data->boundaryf = boundary;
171 0 : }
172 :
173 138 : const Vector2i& Equalizer::getBoundary2i() const
174 : {
175 138 : return _data->boundary2i;
176 : }
177 :
178 138 : float Equalizer::getBoundaryf() const
179 : {
180 138 : return _data->boundaryf;
181 : }
182 :
183 0 : void Equalizer::setResistance(const Vector2i& resistance)
184 : {
185 0 : _data->resistance2i = resistance;
186 0 : }
187 :
188 0 : void Equalizer::setResistance(const float resistance)
189 : {
190 0 : _data->resistancef = resistance;
191 0 : }
192 :
193 138 : const Vector2i& Equalizer::getResistance2i() const
194 : {
195 138 : return _data->resistance2i;
196 : }
197 :
198 138 : float Equalizer::getResistancef() const
199 : {
200 138 : return _data->resistancef;
201 : }
202 :
203 0 : void Equalizer::setAssembleOnlyLimit(const float limit)
204 : {
205 0 : _data->assembleOnlyLimit = limit;
206 0 : }
207 :
208 4 : float Equalizer::getAssembleOnlyLimit() const
209 : {
210 4 : return _data->assembleOnlyLimit;
211 : }
212 :
213 4 : void Equalizer::setTileSize(const Vector2i& size)
214 : {
215 4 : _data->tilesize = size;
216 4 : }
217 :
218 4 : const Vector2i& Equalizer::getTileSize() const
219 : {
220 4 : return _data->tilesize;
221 : }
222 :
223 58 : void Equalizer::serialize(co::DataOStream& os) const
224 : {
225 58 : os << _data->damping << _data->boundaryf << _data->resistancef
226 116 : << _data->assembleOnlyLimit << _data->frameRate << _data->boundary2i
227 116 : << _data->resistance2i << _data->tilesize << _data->mode
228 116 : << _data->frozen;
229 58 : }
230 :
231 26 : void Equalizer::deserialize(co::DataIStream& is)
232 : {
233 26 : is >> _data->damping >> _data->boundaryf >> _data->resistancef >>
234 52 : _data->assembleOnlyLimit >> _data->frameRate >> _data->boundary2i >>
235 52 : _data->resistance2i >> _data->tilesize >> _data->mode >> _data->frozen;
236 26 : }
237 :
238 18 : void Equalizer::backup()
239 : {
240 18 : _backup = new detail::Equalizer(*_data);
241 18 : }
242 :
243 0 : void Equalizer::restore()
244 : {
245 0 : LBASSERT(_backup);
246 0 : delete _data;
247 0 : _data = _backup;
248 0 : _backup = 0;
249 0 : }
250 :
251 58 : co::DataOStream& operator<<(co::DataOStream& os, const Equalizer& eq)
252 : {
253 58 : eq.serialize(os);
254 58 : return os;
255 : }
256 :
257 26 : co::DataIStream& operator>>(co::DataIStream& is, Equalizer& eq)
258 : {
259 26 : eq.deserialize(is);
260 26 : return is;
261 : }
262 :
263 130 : std::ostream& operator<<(std::ostream& os, const Equalizer::Mode mode)
264 : {
265 : os << (mode == Equalizer::MODE_2D
266 : ? "2D"
267 : : mode == Equalizer::MODE_VERTICAL
268 68 : ? "VERTICAL"
269 : : mode == Equalizer::MODE_HORIZONTAL
270 56 : ? "HORIZONTAL"
271 190 : : mode == Equalizer::MODE_DB ? "DB" : "ERROR");
272 130 : return os;
273 : }
274 : }
275 60 : }
|
