1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #pragma once
18
19 #include <algorithm>
20 #include <memory>
21 #include <optional>
22 #include <string>
23 #include <type_traits>
24 #include <unordered_map>
25 #include <utility>
26 #include <vector>
27
28 #include <Utils.h>
29 #include <aidl/android/hardware/audio/effect/IEffect.h>
30 #include <aidl/android/hardware/audio/effect/IFactory.h>
31 #include <aidl/android/media/audio/common/AudioChannelLayout.h>
32 #include <android/binder_auto_utils.h>
33 #include <fmq/AidlMessageQueue.h>
34 #include <gtest/gtest.h>
35 #include <system/audio_aidl_utils.h>
36 #include <system/audio_effects/aidl_effects_utils.h>
37 #include <system/audio_effects/effect_uuid.h>
38
39 #include "EffectFactoryHelper.h"
40 #include "TestUtils.h"
41 #include "pffft.hpp"
42
43 using namespace android;
44 using aidl::android::hardware::audio::effect::CommandId;
45 using aidl::android::hardware::audio::effect::Descriptor;
46 using aidl::android::hardware::audio::effect::getEffectTypeUuidSpatializer;
47 using aidl::android::hardware::audio::effect::getRange;
48 using aidl::android::hardware::audio::effect::IEffect;
49 using aidl::android::hardware::audio::effect::isRangeValid;
50 using aidl::android::hardware::audio::effect::kEffectTypeUuidSpatializer;
51 using aidl::android::hardware::audio::effect::kEventFlagDataMqNotEmpty;
52 using aidl::android::hardware::audio::effect::kEventFlagDataMqUpdate;
53 using aidl::android::hardware::audio::effect::kEventFlagNotEmpty;
54 using aidl::android::hardware::audio::effect::kReopenSupportedVersion;
55 using aidl::android::hardware::audio::effect::Parameter;
56 using aidl::android::hardware::audio::effect::Range;
57 using aidl::android::hardware::audio::effect::Spatializer;
58 using aidl::android::hardware::audio::effect::State;
59 using aidl::android::hardware::common::fmq::SynchronizedReadWrite;
60 using aidl::android::media::audio::common::AudioChannelLayout;
61 using aidl::android::media::audio::common::AudioFormatDescription;
62 using aidl::android::media::audio::common::AudioFormatType;
63 using aidl::android::media::audio::common::AudioUuid;
64 using aidl::android::media::audio::common::PcmType;
65 using ::android::audio::utils::toString;
66 using ::android::hardware::EventFlag;
67
68 const AudioFormatDescription kDefaultFormatDescription = {
69 .type = AudioFormatType::PCM, .pcm = PcmType::FLOAT_32_BIT, .encoding = ""};
70
71 typedef ::android::AidlMessageQueue<IEffect::Status,
72 ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
73 StatusMQ;
74 typedef ::android::AidlMessageQueue<float,
75 ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
76 DataMQ;
77
getPrefix(Descriptor & descriptor)78 static inline std::string getPrefix(Descriptor& descriptor) {
79 std::string prefix = "Implementor_" + descriptor.common.implementor + "_name_" +
80 descriptor.common.name + "_UUID_" + toString(descriptor.common.id.uuid);
81 std::replace_if(
82 prefix.begin(), prefix.end(), [](const char c) { return !std::isalnum(c); }, '_');
83 return prefix;
84 }
85
86 static constexpr float kMaxAudioSampleValue = 1;
87 static constexpr int kSamplingFrequency = 44100;
88
89 class EffectHelper {
90 public:
91 void create(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect>& effect,
92 Descriptor& desc, binder_status_t status = EX_NONE) {
93 ASSERT_NE(factory, nullptr);
94 auto& id = desc.common.id;
95 ASSERT_STATUS(status, factory->createEffect(id.uuid, &effect));
96 if (status == EX_NONE) {
97 ASSERT_NE(effect, nullptr) << toString(id.uuid);
98 ASSERT_NO_FATAL_FAILURE(expectState(effect, State::INIT));
99 }
100 mIsSpatializer = id.type == getEffectTypeUuidSpatializer();
101 mDescriptor = desc;
102 }
103
destroyIgnoreRet(std::shared_ptr<IFactory> factory,std::shared_ptr<IEffect> effect)104 static void destroyIgnoreRet(std::shared_ptr<IFactory> factory,
105 std::shared_ptr<IEffect> effect) {
106 if (factory && effect) {
107 factory->destroyEffect(effect);
108 }
109 }
110
111 static void destroy(std::shared_ptr<IFactory> factory, std::shared_ptr<IEffect> effect,
112 binder_status_t status = EX_NONE) {
113 ASSERT_NE(factory, nullptr);
114 ASSERT_NE(effect, nullptr);
115 ASSERT_STATUS(status, factory->destroyEffect(effect));
116 }
117
118 void open(std::shared_ptr<IEffect> effect, const Parameter::Common& common,
119 const std::optional<Parameter::Specific>& specific, IEffect::OpenEffectReturn* ret,
120 binder_status_t status = EX_NONE) {
121 ASSERT_NE(effect, nullptr);
122 ASSERT_STATUS(status, effect->open(common, specific, ret));
123 if (status != EX_NONE) {
124 return;
125 }
126
127 ASSERT_TRUE(expectState(effect, State::IDLE));
128 updateFrameSize(common);
129 }
130
131 void open(std::shared_ptr<IEffect> effect, int session = 0, binder_status_t status = EX_NONE) {
132 ASSERT_NE(effect, nullptr);
133 Parameter::Common common = createParamCommon(session);
134 IEffect::OpenEffectReturn ret;
135 ASSERT_NO_FATAL_FAILURE(open(effect, common, std::nullopt /* specific */, &ret, status));
136 }
137
138 void reopen(std::shared_ptr<IEffect> effect, const Parameter::Common& common,
139 IEffect::OpenEffectReturn* ret, binder_status_t status = EX_NONE) {
140 ASSERT_NE(effect, nullptr);
141 ASSERT_STATUS(status, effect->reopen(ret));
142 if (status != EX_NONE) {
143 return;
144 }
145 updateFrameSize(common);
146 }
147
closeIgnoreRet(std::shared_ptr<IEffect> effect)148 static void closeIgnoreRet(std::shared_ptr<IEffect> effect) {
149 if (effect) {
150 effect->close();
151 }
152 }
153
154 static void close(std::shared_ptr<IEffect> effect, binder_status_t status = EX_NONE) {
155 if (effect) {
156 ASSERT_STATUS(status, effect->close());
157 if (status == EX_NONE) {
158 ASSERT_TRUE(expectState(effect, State::INIT));
159 }
160 }
161 }
162
163 static void getDescriptor(std::shared_ptr<IEffect> effect, Descriptor& desc,
164 binder_status_t status = EX_NONE) {
165 ASSERT_NE(effect, nullptr);
166 ASSERT_STATUS(status, effect->getDescriptor(&desc));
167 }
168
expectState(std::shared_ptr<IEffect> effect,State expectState)169 static bool expectState(std::shared_ptr<IEffect> effect, State expectState) {
170 if (effect == nullptr) return false;
171
172 if (State state; EX_NONE != effect->getState(&state).getStatus() || expectState != state) {
173 return false;
174 }
175
176 return true;
177 }
178
commandIgnoreRet(std::shared_ptr<IEffect> effect,CommandId command)179 static void commandIgnoreRet(std::shared_ptr<IEffect> effect, CommandId command) {
180 if (effect) {
181 effect->command(command);
182 }
183 }
184
185 static void command(std::shared_ptr<IEffect> effect, CommandId command,
186 binder_status_t status = EX_NONE) {
187 ASSERT_NE(effect, nullptr);
188 ASSERT_STATUS(status, effect->command(command));
189 if (status != EX_NONE) {
190 return;
191 }
192
193 switch (command) {
194 case CommandId::START:
195 ASSERT_TRUE(expectState(effect, State::PROCESSING));
196 break;
197 case CommandId::STOP:
198 ASSERT_TRUE(expectState(effect, State::IDLE) ||
199 expectState(effect, State::DRAINING));
200 break;
201 case CommandId::RESET:
202 ASSERT_TRUE(expectState(effect, State::IDLE));
203 break;
204 default:
205 return;
206 }
207 }
208
writeToFmq(std::unique_ptr<StatusMQ> & statusMq,std::unique_ptr<DataMQ> & dataMq,const std::vector<float> & buffer,int version)209 static void writeToFmq(std::unique_ptr<StatusMQ>& statusMq, std::unique_ptr<DataMQ>& dataMq,
210 const std::vector<float>& buffer, int version) {
211 const size_t available = dataMq->availableToWrite();
212 ASSERT_NE(0Ul, available);
213 auto bufferFloats = buffer.size();
214 auto floatsToWrite = std::min(available, bufferFloats);
215 ASSERT_TRUE(dataMq->write(buffer.data(), floatsToWrite));
216
217 EventFlag* efGroup;
218 ASSERT_EQ(::android::OK,
219 EventFlag::createEventFlag(statusMq->getEventFlagWord(), &efGroup));
220 ASSERT_NE(nullptr, efGroup);
221 efGroup->wake(version >= kReopenSupportedVersion ? kEventFlagDataMqNotEmpty
222 : kEventFlagNotEmpty);
223 ASSERT_EQ(::android::OK, EventFlag::deleteEventFlag(&efGroup));
224 }
225
226 static void readFromFmq(std::unique_ptr<StatusMQ>& statusMq, size_t statusNum,
227 std::unique_ptr<DataMQ>& dataMq, size_t expectFloats,
228 std::vector<float>& buffer,
229 std::optional<int> expectStatus = STATUS_OK) {
230 if (0 == statusNum) {
231 ASSERT_EQ(0ul, statusMq->availableToRead());
232 return;
233 }
234 IEffect::Status status{};
235 ASSERT_TRUE(statusMq->readBlocking(&status, statusNum));
236 if (expectStatus.has_value()) {
237 ASSERT_EQ(expectStatus.value(), status.status);
238 }
239
240 ASSERT_EQ(expectFloats, (unsigned)status.fmqProduced);
241 ASSERT_EQ(expectFloats, dataMq->availableToRead());
242 if (expectFloats != 0) {
243 ASSERT_TRUE(dataMq->read(buffer.data(), expectFloats));
244 }
245 }
246
expectDataMqUpdateEventFlag(std::unique_ptr<StatusMQ> & statusMq)247 static void expectDataMqUpdateEventFlag(std::unique_ptr<StatusMQ>& statusMq) {
248 EventFlag* efGroup;
249 ASSERT_EQ(::android::OK,
250 EventFlag::createEventFlag(statusMq->getEventFlagWord(), &efGroup));
251 ASSERT_NE(nullptr, efGroup);
252 uint32_t efState = 0;
253 EXPECT_EQ(::android::OK, efGroup->wait(kEventFlagDataMqUpdate, &efState, 1'000'000 /*1ms*/,
254 true /* retry */));
255 EXPECT_TRUE(efState & kEventFlagDataMqUpdate);
256 }
257
258 Parameter::Common createParamCommon(int session = 0, int ioHandle = -1, int iSampleRate = 48000,
259 int oSampleRate = 48000, long iFrameCount = 0x100,
260 long oFrameCount = 0x100) {
261 AudioChannelLayout inputLayout = AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
262 AudioChannelLayout::LAYOUT_STEREO);
263 AudioChannelLayout outputLayout = inputLayout;
264
265 // query supported input layout and use it as the default parameter in common
266 if (mIsSpatializer && isRangeValid<Range::spatializer>(Spatializer::supportedChannelLayout,
267 mDescriptor.capability)) {
268 const auto layoutRange = getRange<Range::spatializer, Range::SpatializerRange>(
269 mDescriptor.capability, Spatializer::supportedChannelLayout);
270 if (std::vector<AudioChannelLayout> layouts;
271 layoutRange &&
272 0 != (layouts = layoutRange->min.get<Spatializer::supportedChannelLayout>())
273 .size()) {
274 inputLayout = layouts[0];
275 }
276 }
277
278 return createParamCommon(session, ioHandle, iSampleRate, oSampleRate, iFrameCount,
279 oFrameCount, inputLayout, outputLayout);
280 }
281
createParamCommon(int session,int ioHandle,int iSampleRate,int oSampleRate,long iFrameCount,long oFrameCount,AudioChannelLayout inputChannelLayout,AudioChannelLayout outputChannelLayout)282 static Parameter::Common createParamCommon(int session, int ioHandle, int iSampleRate,
283 int oSampleRate, long iFrameCount, long oFrameCount,
284 AudioChannelLayout inputChannelLayout,
285 AudioChannelLayout outputChannelLayout) {
286 Parameter::Common common;
287 common.session = session;
288 common.ioHandle = ioHandle;
289
290 auto& input = common.input;
291 auto& output = common.output;
292 input.base.sampleRate = iSampleRate;
293 input.base.channelMask = inputChannelLayout;
294 input.base.format = kDefaultFormatDescription;
295 input.frameCount = iFrameCount;
296 output.base.sampleRate = oSampleRate;
297 output.base.channelMask = outputChannelLayout;
298 output.base.format = kDefaultFormatDescription;
299 output.frameCount = oFrameCount;
300 return common;
301 }
302
303 typedef ::android::AidlMessageQueue<
304 IEffect::Status, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
305 StatusMQ;
306 typedef ::android::AidlMessageQueue<
307 float, ::aidl::android::hardware::common::fmq::SynchronizedReadWrite>
308 DataMQ;
309
310 class EffectParam {
311 public:
312 std::unique_ptr<StatusMQ> statusMQ;
313 std::unique_ptr<DataMQ> inputMQ;
314 std::unique_ptr<DataMQ> outputMQ;
315 };
316
317 template <typename T, Range::Tag tag>
isParameterValid(const T & target,const Descriptor & desc)318 static bool isParameterValid(const T& target, const Descriptor& desc) {
319 if (desc.capability.range.getTag() != tag) {
320 return true;
321 }
322 const auto& ranges = desc.capability.range.get<tag>();
323 return inRange(target, ranges);
324 }
325
326 /**
327 * Add to test value set: (min+max)/2, minimum/maximum numeric limits, and min-1/max+1 if
328 * result still in numeric limits after -1/+1.
329 * Only use this when the type of test value is basic type (std::is_arithmetic return true).
330 */
331 template <typename S, typename = std::enable_if_t<std::is_arithmetic_v<S>>>
expandTestValueBasic(std::set<S> & s)332 static std::set<S> expandTestValueBasic(std::set<S>& s) {
333 const auto minLimit = std::numeric_limits<S>::min(),
334 maxLimit = std::numeric_limits<S>::max();
335 if (s.size()) {
336 const auto min = *s.begin(), max = *s.rbegin();
337 s.insert((min & max) + ((min ^ max) >> 1));
338 if (min > minLimit + 1) {
339 s.insert(min - 1);
340 }
341 if (max < maxLimit - 1) {
342 s.insert(max + 1);
343 }
344 }
345 s.insert(minLimit);
346 s.insert(maxLimit);
347 return s;
348 }
349
350 template <typename T, typename S, Range::Tag R, typename T::Tag tag>
getTestValueSet(std::vector<std::pair<std::shared_ptr<IFactory>,Descriptor>> descList)351 static std::set<S> getTestValueSet(
352 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> descList) {
353 std::set<S> result;
354 for (const auto& [_, desc] : descList) {
355 if (desc.capability.range.getTag() == R) {
356 const auto& ranges = desc.capability.range.get<R>();
357 for (const auto& range : ranges) {
358 if (range.min.getTag() == tag) {
359 result.insert(range.min.template get<tag>());
360 }
361 if (range.max.getTag() == tag) {
362 result.insert(range.max.template get<tag>());
363 }
364 }
365 }
366 }
367 return result;
368 }
369
370 template <typename T, typename S, Range::Tag R, typename T::Tag tag, typename Functor>
getTestValueSet(std::vector<std::pair<std::shared_ptr<IFactory>,Descriptor>> descList,Functor functor)371 static std::set<S> getTestValueSet(
372 std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> descList,
373 Functor functor) {
374 auto result = getTestValueSet<T, S, R, tag>(descList);
375 return functor(result);
376 }
377
378 // keep writing data to the FMQ until effect transit from DRAINING to IDLE
waitForDrain(std::vector<float> & inputBuffer,std::vector<float> & outputBuffer,const std::shared_ptr<IEffect> & effect,std::unique_ptr<EffectHelper::StatusMQ> & statusMQ,std::unique_ptr<EffectHelper::DataMQ> & inputMQ,std::unique_ptr<EffectHelper::DataMQ> & outputMQ,int version)379 static void waitForDrain(std::vector<float>& inputBuffer, std::vector<float>& outputBuffer,
380 const std::shared_ptr<IEffect>& effect,
381 std::unique_ptr<EffectHelper::StatusMQ>& statusMQ,
382 std::unique_ptr<EffectHelper::DataMQ>& inputMQ,
383 std::unique_ptr<EffectHelper::DataMQ>& outputMQ, int version) {
384 State state;
385 while (effect->getState(&state).getStatus() == EX_NONE && state == State::DRAINING) {
386 EXPECT_NO_FATAL_FAILURE(
387 EffectHelper::writeToFmq(statusMQ, inputMQ, inputBuffer, version));
388 EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(
389 statusMQ, 1, outputMQ, outputBuffer.size(), outputBuffer, std::nullopt));
390 }
391 ASSERT_TRUE(State::IDLE == state);
392 EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 0, outputMQ, 0, outputBuffer));
393 return;
394 }
395
396 static void processAndWriteToOutput(std::vector<float>& inputBuffer,
397 std::vector<float>& outputBuffer,
398 const std::shared_ptr<IEffect>& effect,
399 IEffect::OpenEffectReturn* openEffectReturn,
400 int version = -1, int times = 1,
401 bool callStopReset = true) {
402 // Initialize AidlMessagequeues
403 auto statusMQ = std::make_unique<EffectHelper::StatusMQ>(openEffectReturn->statusMQ);
404 ASSERT_TRUE(statusMQ->isValid());
405 auto inputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->inputDataMQ);
406 ASSERT_TRUE(inputMQ->isValid());
407 auto outputMQ = std::make_unique<EffectHelper::DataMQ>(openEffectReturn->outputDataMQ);
408 ASSERT_TRUE(outputMQ->isValid());
409
410 // Enabling the process
411 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::START));
412
413 // Write from buffer to message queues and calling process
414 if (version == -1) {
415 ASSERT_IS_OK(effect->getInterfaceVersion(&version));
416 }
417
418 for (int i = 0; i < times; i++) {
419 EXPECT_NO_FATAL_FAILURE(
420 EffectHelper::writeToFmq(statusMQ, inputMQ, inputBuffer, version));
421 // Read the updated message queues into buffer
422 EXPECT_NO_FATAL_FAILURE(EffectHelper::readFromFmq(statusMQ, 1, outputMQ,
423 outputBuffer.size(), outputBuffer));
424 }
425
426 // Disable the process
427 if (callStopReset) {
428 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::STOP));
429 EXPECT_NO_FATAL_FAILURE(waitForDrain(inputBuffer, outputBuffer, effect, statusMQ,
430 inputMQ, outputMQ, version));
431 }
432
433 if (callStopReset) {
434 ASSERT_NO_FATAL_FAILURE(command(effect, CommandId::RESET));
435 }
436 }
437
438 // Find FFT bin indices for testFrequencies and get bin center frequencies
roundToFreqCenteredToFftBin(std::vector<int> & testFrequencies,std::vector<int> & binOffsets,const float kBinWidth)439 void roundToFreqCenteredToFftBin(std::vector<int>& testFrequencies,
440 std::vector<int>& binOffsets, const float kBinWidth) {
441 for (size_t i = 0; i < testFrequencies.size(); i++) {
442 binOffsets[i] = std::round(testFrequencies[i] / kBinWidth);
443 testFrequencies[i] = std::round(binOffsets[i] * kBinWidth);
444 }
445 }
446
447 // Fill inputBuffer with random values between -maxAudioSampleValue to maxAudioSampleValue
448 void generateInputBuffer(std::vector<float>& inputBuffer, size_t startPosition, bool isStrip,
449 size_t channelCount,
450 float maxAudioSampleValue = kMaxAudioSampleValue) {
451 size_t increment = isStrip ? 1 /*Fill input at all the channels*/
452 : channelCount /*Fill input at only one channel*/;
453
454 for (size_t i = startPosition; i < inputBuffer.size(); i += increment) {
455 inputBuffer[i] =
456 ((static_cast<float>(std::rand()) / RAND_MAX) * 2 - 1) * maxAudioSampleValue;
457 }
458 }
459
460 // Generate multitone input between -amplitude to +amplitude using testFrequencies
461 // All test frequencies are considered having the same amplitude
462 void generateSineWave(const std::vector<int>& testFrequencies, std::vector<float>& input,
463 const float amplitude = 1.0,
464 const int samplingFrequency = kSamplingFrequency) {
465 for (size_t i = 0; i < input.size(); i++) {
466 input[i] = 0;
467
468 for (size_t j = 0; j < testFrequencies.size(); j++) {
469 input[i] += sin(2 * M_PI * testFrequencies[j] * i / samplingFrequency);
470 }
471 input[i] *= amplitude / testFrequencies.size();
472 }
473 }
474
475 // Generate single tone input between -amplitude to +amplitude using testFrequency
476 void generateSineWave(const int testFrequency, std::vector<float>& input,
477 const float amplitude = 1.0,
478 const int samplingFrequency = kSamplingFrequency) {
479 generateSineWave(std::vector<int>{testFrequency}, input, amplitude, samplingFrequency);
480 }
481
482 // Use FFT transform to convert the buffer to frequency domain
483 // Compute its magnitude at binOffsets
calculateMagnitude(const std::vector<float> & buffer,const std::vector<int> & binOffsets,const int nPointFFT)484 std::vector<float> calculateMagnitude(const std::vector<float>& buffer,
485 const std::vector<int>& binOffsets, const int nPointFFT) {
486 std::vector<float> fftInput(nPointFFT);
487 PFFFT_Setup* inputHandle = pffft_new_setup(nPointFFT, PFFFT_REAL);
488 pffft_transform_ordered(inputHandle, buffer.data(), fftInput.data(), nullptr,
489 PFFFT_FORWARD);
490 pffft_destroy_setup(inputHandle);
491 std::vector<float> bufferMag(binOffsets.size());
492 for (size_t i = 0; i < binOffsets.size(); i++) {
493 size_t k = binOffsets[i];
494 bufferMag[i] = sqrt((fftInput[k * 2] * fftInput[k * 2]) +
495 (fftInput[k * 2 + 1] * fftInput[k * 2 + 1]));
496 }
497
498 return bufferMag;
499 }
500
updateFrameSize(const Parameter::Common & common)501 void updateFrameSize(const Parameter::Common& common) {
502 mInputFrameSize = ::aidl::android::hardware::audio::common::getFrameSizeInBytes(
503 common.input.base.format, common.input.base.channelMask);
504 mInputSamples = common.input.frameCount * mInputFrameSize / sizeof(float);
505 mOutputFrameSize = ::aidl::android::hardware::audio::common::getFrameSizeInBytes(
506 common.output.base.format, common.output.base.channelMask);
507 mOutputSamples = common.output.frameCount * mOutputFrameSize / sizeof(float);
508 }
509
510 void generateInput(std::vector<float>& input, float inputFrequency, float samplingFrequency,
511 size_t inputSize = 0) {
512 if (inputSize == 0 || inputSize > input.size()) {
513 inputSize = input.size();
514 }
515
516 for (size_t i = 0; i < inputSize; i++) {
517 input[i] = sin(2 * M_PI * inputFrequency * i / samplingFrequency);
518 }
519 }
520
521 bool mIsSpatializer;
522 Descriptor mDescriptor;
523 size_t mInputFrameSize, mOutputFrameSize;
524 size_t mInputSamples, mOutputSamples;
525 };
526