blob: 7e1549dab86b7f62cbf31447e788012c73650d1a [file] [log] [blame]
Shunkai Yao725af212023-01-05 23:01:40 +00001/*
2 * Copyright (C) 2023 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#define LOG_TAG "AHAL_DynamicsProcessingLibEffects"
18
19#include <android-base/logging.h>
Shunkai Yao399be682023-03-06 18:54:18 +000020#include <system/audio_effects/effect_uuid.h>
Shunkai Yao725af212023-01-05 23:01:40 +000021
22#include "DynamicsProcessing.h"
23
24#include <dsp/DPBase.h>
25#include <dsp/DPFrequency.h>
26
27using aidl::android::hardware::audio::effect::Descriptor;
28using aidl::android::hardware::audio::effect::DynamicsProcessingImpl;
Shunkai Yao399be682023-03-06 18:54:18 +000029using aidl::android::hardware::audio::effect::getEffectImplUuidDynamicsProcessing;
30using aidl::android::hardware::audio::effect::getEffectTypeUuidDynamicsProcessing;
Shunkai Yao725af212023-01-05 23:01:40 +000031using aidl::android::hardware::audio::effect::IEffect;
Shunkai Yao725af212023-01-05 23:01:40 +000032using aidl::android::hardware::audio::effect::State;
33using aidl::android::media::audio::common::AudioUuid;
34using aidl::android::media::audio::common::PcmType;
35
36extern "C" binder_exception_t createEffect(const AudioUuid* in_impl_uuid,
37 std::shared_ptr<IEffect>* instanceSpp) {
Shunkai Yao399be682023-03-06 18:54:18 +000038 if (!in_impl_uuid || *in_impl_uuid != getEffectImplUuidDynamicsProcessing()) {
Shunkai Yao725af212023-01-05 23:01:40 +000039 LOG(ERROR) << __func__ << "uuid not supported";
40 return EX_ILLEGAL_ARGUMENT;
41 }
42 if (instanceSpp) {
43 *instanceSpp = ndk::SharedRefBase::make<DynamicsProcessingImpl>();
44 LOG(DEBUG) << __func__ << " instance " << instanceSpp->get() << " created";
45 return EX_NONE;
46 } else {
47 LOG(ERROR) << __func__ << " invalid input parameter!";
48 return EX_ILLEGAL_ARGUMENT;
49 }
50}
51
52extern "C" binder_exception_t queryEffect(const AudioUuid* in_impl_uuid, Descriptor* _aidl_return) {
Shunkai Yao399be682023-03-06 18:54:18 +000053 if (!in_impl_uuid || *in_impl_uuid != getEffectImplUuidDynamicsProcessing()) {
Shunkai Yao725af212023-01-05 23:01:40 +000054 LOG(ERROR) << __func__ << "uuid not supported";
55 return EX_ILLEGAL_ARGUMENT;
56 }
57 *_aidl_return = DynamicsProcessingImpl::kDescriptor;
58 return EX_NONE;
59}
60
61namespace aidl::android::hardware::audio::effect {
62
63const std::string DynamicsProcessingImpl::kEffectName = "DynamicsProcessing";
Shunkai Yao6b857c92023-02-13 17:44:52 +000064
Ram Mohanc89817d2023-03-14 21:39:26 +053065static const Range::DynamicsProcessingRange kEngineConfigRange = {
66 .min = DynamicsProcessing::make<
67 DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
68 {.resolutionPreference =
69 DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
Ram Mohanf045ba42023-04-11 11:51:20 +053070 .preferredProcessingDurationMs = 1.0f,
Ram Mohanc89817d2023-03-14 21:39:26 +053071 .preEqStage = {.inUse = false, .bandCount = 0},
72 .postEqStage = {.inUse = false, .bandCount = 0},
73 .mbcStage = {.inUse = false, .bandCount = 0},
74 .limiterInUse = false})),
75 .max = DynamicsProcessing::make<
76 DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
77 {.resolutionPreference =
Ram Mohanf045ba42023-04-11 11:51:20 +053078 DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
79 .preferredProcessingDurationMs = 1000.0f,
80 .preEqStage = {.inUse = true, .bandCount = 128},
81 .postEqStage = {.inUse = true, .bandCount = 128},
82 .mbcStage = {.inUse = true, .bandCount = 128},
Ram Mohanc89817d2023-03-14 21:39:26 +053083 .limiterInUse = true}))};
84
85static const DynamicsProcessing::ChannelConfig kChannelConfigMin =
86 DynamicsProcessing::ChannelConfig({.channel = 0, .enable = false});
87
88static const DynamicsProcessing::ChannelConfig kChannelConfigMax =
89 DynamicsProcessing::ChannelConfig(
90 {.channel = std::numeric_limits<int>::max(), .enable = true});
91
92static const Range::DynamicsProcessingRange kPreEqChannelConfigRange = {
93 .min = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMin}),
94 .max = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMax})};
95
96static const Range::DynamicsProcessingRange kPostEqChannelConfigRange = {
97 .min = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMin}),
98 .max = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMax})};
99
100static const Range::DynamicsProcessingRange kMbcChannelConfigRange = {
101 .min = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMin}),
102 .max = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMax})};
103
104static const DynamicsProcessing::EqBandConfig kEqBandConfigMin =
Shunkai Yao6b857c92023-02-13 17:44:52 +0000105 DynamicsProcessing::EqBandConfig({.channel = 0,
106 .band = 0,
107 .enable = false,
David Licb5bcc42023-11-13 16:01:48 +0800108 .cutoffFrequencyHz = 0,
Ram Mohanf045ba42023-04-11 11:51:20 +0530109 .gainDb = -200});
Ram Mohanc89817d2023-03-14 21:39:26 +0530110
111static const DynamicsProcessing::EqBandConfig kEqBandConfigMax =
Shunkai Yao6b857c92023-02-13 17:44:52 +0000112 DynamicsProcessing::EqBandConfig({.channel = std::numeric_limits<int>::max(),
113 .band = std::numeric_limits<int>::max(),
114 .enable = true,
David Licb5bcc42023-11-13 16:01:48 +0800115 .cutoffFrequencyHz = 192000,
Ram Mohanf045ba42023-04-11 11:51:20 +0530116 .gainDb = 200});
Shunkai Yao6b857c92023-02-13 17:44:52 +0000117
Ram Mohanc89817d2023-03-14 21:39:26 +0530118static const Range::DynamicsProcessingRange kPreEqBandConfigRange = {
119 .min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMin}),
120 .max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMax})};
121
122static const Range::DynamicsProcessingRange kPostEqBandConfigRange = {
123 .min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMin}),
124 .max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMax})};
125
126static const Range::DynamicsProcessingRange kMbcBandConfigRange = {
127 .min = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(
128 {DynamicsProcessing::MbcBandConfig(
129 {.channel = 0,
130 .band = 0,
131 .enable = false,
David Licb5bcc42023-11-13 16:01:48 +0800132 .cutoffFrequencyHz = 0,
Ram Mohanc89817d2023-03-14 21:39:26 +0530133 .attackTimeMs = 0,
134 .releaseTimeMs = 0,
Ram Mohanf045ba42023-04-11 11:51:20 +0530135 .ratio = 1,
136 .thresholdDb = -200,
Ram Mohanc89817d2023-03-14 21:39:26 +0530137 .kneeWidthDb = 0,
Ram Mohanf045ba42023-04-11 11:51:20 +0530138 .noiseGateThresholdDb = -200,
139 .expanderRatio = 1,
140 .preGainDb = -200,
141 .postGainDb = -200})}),
Ram Mohanc89817d2023-03-14 21:39:26 +0530142 .max = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(
143 {DynamicsProcessing::MbcBandConfig(
144 {.channel = std::numeric_limits<int>::max(),
145 .band = std::numeric_limits<int>::max(),
146 .enable = true,
David Licb5bcc42023-11-13 16:01:48 +0800147 .cutoffFrequencyHz = 192000,
Ram Mohanf045ba42023-04-11 11:51:20 +0530148 .attackTimeMs = 60000,
149 .releaseTimeMs = 60000,
150 .ratio = 50,
151 .thresholdDb = 200,
152 .kneeWidthDb = 100,
153 .noiseGateThresholdDb = 200,
154 .expanderRatio = 50,
155 .preGainDb = 200,
156 .postGainDb = 200})})};
Ram Mohanc89817d2023-03-14 21:39:26 +0530157
158static const Range::DynamicsProcessingRange kInputGainRange = {
159 .min = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
160 {DynamicsProcessing::InputGain(
Ram Mohanf045ba42023-04-11 11:51:20 +0530161 {.channel = 0, .gainDb = -200.0f})}),
Ram Mohanc89817d2023-03-14 21:39:26 +0530162 .max = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
163 {DynamicsProcessing::InputGain({.channel = std::numeric_limits<int>::max(),
Ram Mohanf045ba42023-04-11 11:51:20 +0530164 .gainDb = 200.0f})})};
Ram Mohanc89817d2023-03-14 21:39:26 +0530165
166static const Range::DynamicsProcessingRange kLimiterRange = {
167 .min = DynamicsProcessing::make<DynamicsProcessing::limiter>(
168 {DynamicsProcessing::LimiterConfig(
169 {.channel = 0,
170 .enable = false,
171 .linkGroup = std::numeric_limits<int>::min(),
172 .attackTimeMs = 0,
173 .releaseTimeMs = 0,
Ram Mohanf045ba42023-04-11 11:51:20 +0530174 .ratio = 1,
175 .thresholdDb = -200,
176 .postGainDb = -200})}),
Ram Mohanc89817d2023-03-14 21:39:26 +0530177 .max = DynamicsProcessing::make<DynamicsProcessing::limiter>(
178 {DynamicsProcessing::LimiterConfig(
179 {.channel = std::numeric_limits<int>::max(),
180 .enable = true,
181 .linkGroup = std::numeric_limits<int>::max(),
Ram Mohanf045ba42023-04-11 11:51:20 +0530182 .attackTimeMs = 60000,
183 .releaseTimeMs = 60000,
184 .ratio = 50,
185 .thresholdDb = 200,
186 .postGainDb = 200})})};
Ram Mohanc89817d2023-03-14 21:39:26 +0530187
188const std::vector<Range::DynamicsProcessingRange> kRanges = {
189 kEngineConfigRange, kPreEqChannelConfigRange, kPostEqChannelConfigRange,
190 kMbcChannelConfigRange, kPreEqBandConfigRange, kPostEqBandConfigRange,
191 kMbcBandConfigRange, kInputGainRange, kLimiterRange};
192
193const Capability DynamicsProcessingImpl::kCapability = {.range = kRanges};
Shunkai Yao6b857c92023-02-13 17:44:52 +0000194
Shunkai Yao725af212023-01-05 23:01:40 +0000195const Descriptor DynamicsProcessingImpl::kDescriptor = {
Shunkai Yao399be682023-03-06 18:54:18 +0000196 .common = {.id = {.type = getEffectTypeUuidDynamicsProcessing(),
197 .uuid = getEffectImplUuidDynamicsProcessing(),
Shunkai Yao725af212023-01-05 23:01:40 +0000198 .proxy = std::nullopt},
199 .flags = {.type = Flags::Type::INSERT,
200 .insert = Flags::Insert::LAST,
201 .volume = Flags::Volume::CTRL},
202 .name = DynamicsProcessingImpl::kEffectName,
203 .implementor = "The Android Open Source Project"},
Shunkai Yao6b857c92023-02-13 17:44:52 +0000204 .capability = DynamicsProcessingImpl::kCapability};
Shunkai Yao725af212023-01-05 23:01:40 +0000205
206ndk::ScopedAStatus DynamicsProcessingImpl::open(const Parameter::Common& common,
207 const std::optional<Parameter::Specific>& specific,
208 OpenEffectReturn* ret) {
209 LOG(DEBUG) << __func__;
210 // effect only support 32bits float
211 RETURN_IF(common.input.base.format.pcm != common.output.base.format.pcm ||
212 common.input.base.format.pcm != PcmType::FLOAT_32_BIT,
213 EX_ILLEGAL_ARGUMENT, "dataMustBe32BitsFloat");
Shunkai Yao1afb46c2024-01-09 20:40:45 +0000214 std::lock_guard lg(mImplMutex);
Shunkai Yao725af212023-01-05 23:01:40 +0000215 RETURN_OK_IF(mState != State::INIT);
Shunkai Yao1afb46c2024-01-09 20:40:45 +0000216 mImplContext = createContext(common);
217 RETURN_IF(!mContext || !mImplContext, EX_NULL_POINTER, "createContextFailed");
Shunkai Yao2839b852024-02-03 06:48:10 +0000218 int version = 0;
219 RETURN_IF(!getInterfaceVersion(&version).isOk(), EX_UNSUPPORTED_OPERATION,
220 "FailedToGetInterfaceVersion");
221 mImplContext->setVersion(version);
Shunkai Yao1afb46c2024-01-09 20:40:45 +0000222 mEventFlag = mImplContext->getStatusEventFlag();
Shunkai Yao725af212023-01-05 23:01:40 +0000223
Shunkai Yao725af212023-01-05 23:01:40 +0000224 if (specific.has_value()) {
225 RETURN_IF_ASTATUS_NOT_OK(setParameterSpecific(specific.value()), "setSpecParamErr");
226 } else {
227 Parameter::Specific defaultSpecific =
228 Parameter::Specific::make<Parameter::Specific::dynamicsProcessing>(
229 DynamicsProcessing::make<DynamicsProcessing::engineArchitecture>(
230 mContext->getEngineArchitecture()));
231 RETURN_IF_ASTATUS_NOT_OK(setParameterSpecific(defaultSpecific), "setDefaultEngineErr");
232 }
233
234 mState = State::IDLE;
Shunkai Yao1afb46c2024-01-09 20:40:45 +0000235 mContext->dupeFmq(ret);
236 RETURN_IF(createThread(getEffectName()) != RetCode::SUCCESS, EX_UNSUPPORTED_OPERATION,
Shunkai Yao725af212023-01-05 23:01:40 +0000237 "FailedToCreateWorker");
238 return ndk::ScopedAStatus::ok();
239}
240
241ndk::ScopedAStatus DynamicsProcessingImpl::getDescriptor(Descriptor* _aidl_return) {
242 RETURN_IF(!_aidl_return, EX_ILLEGAL_ARGUMENT, "Parameter:nullptr");
243 LOG(DEBUG) << __func__ << kDescriptor.toString();
244 *_aidl_return = kDescriptor;
245 return ndk::ScopedAStatus::ok();
246}
247
248ndk::ScopedAStatus DynamicsProcessingImpl::commandImpl(CommandId command) {
249 RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
250 switch (command) {
251 case CommandId::START:
252 mContext->enable();
253 return ndk::ScopedAStatus::ok();
254 case CommandId::STOP:
255 mContext->disable();
256 return ndk::ScopedAStatus::ok();
257 case CommandId::RESET:
258 mContext->disable();
259 mContext->resetBuffer();
260 return ndk::ScopedAStatus::ok();
261 default:
262 // Need this default handling for vendor extendable CommandId::VENDOR_COMMAND_*
263 LOG(ERROR) << __func__ << " commandId " << toString(command) << " not supported";
264 return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
265 "commandIdNotSupported");
266 }
267}
268
Ram Mohanc89817d2023-03-14 21:39:26 +0530269bool DynamicsProcessingImpl::isParamInRange(const Parameter::Specific& specific) {
270 auto& dp = specific.get<Parameter::Specific::dynamicsProcessing>();
271 return DynamicsProcessingRanges::isParamInRange(dp, kRanges);
272}
273
Shunkai Yao725af212023-01-05 23:01:40 +0000274ndk::ScopedAStatus DynamicsProcessingImpl::setParameterSpecific(
275 const Parameter::Specific& specific) {
276 RETURN_IF(Parameter::Specific::dynamicsProcessing != specific.getTag(), EX_ILLEGAL_ARGUMENT,
277 "EffectNotSupported");
278 RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
279
Ram Mohanc89817d2023-03-14 21:39:26 +0530280 RETURN_IF(!isParamInRange(specific), EX_ILLEGAL_ARGUMENT, "outOfRange");
Shunkai Yao725af212023-01-05 23:01:40 +0000281 auto& param = specific.get<Parameter::Specific::dynamicsProcessing>();
Shunkai Yao725af212023-01-05 23:01:40 +0000282 auto tag = param.getTag();
283
284 switch (tag) {
285 case DynamicsProcessing::engineArchitecture: {
286 RETURN_IF(mContext->setEngineArchitecture(
287 param.get<DynamicsProcessing::engineArchitecture>()) !=
288 RetCode::SUCCESS,
289 EX_ILLEGAL_ARGUMENT, "setEngineArchitectureFailed");
290 return ndk::ScopedAStatus::ok();
291 }
292 case DynamicsProcessing::preEq: {
293 RETURN_IF(
294 mContext->setPreEq(param.get<DynamicsProcessing::preEq>()) != RetCode::SUCCESS,
295 EX_ILLEGAL_ARGUMENT, "setPreEqFailed");
296 return ndk::ScopedAStatus::ok();
297 }
298 case DynamicsProcessing::postEq: {
299 RETURN_IF(mContext->setPostEq(param.get<DynamicsProcessing::postEq>()) !=
300 RetCode::SUCCESS,
301 EX_ILLEGAL_ARGUMENT, "setPostEqFailed");
302 return ndk::ScopedAStatus::ok();
303 }
304 case DynamicsProcessing::preEqBand: {
305 RETURN_IF(mContext->setPreEqBand(param.get<DynamicsProcessing::preEqBand>()) !=
306 RetCode::SUCCESS,
307 EX_ILLEGAL_ARGUMENT, "setPreEqBandFailed");
308 return ndk::ScopedAStatus::ok();
309 }
310 case DynamicsProcessing::postEqBand: {
311 RETURN_IF(mContext->setPostEqBand(param.get<DynamicsProcessing::postEqBand>()) !=
312 RetCode::SUCCESS,
313 EX_ILLEGAL_ARGUMENT, "setPostEqBandFailed");
314 return ndk::ScopedAStatus::ok();
315 }
316 case DynamicsProcessing::mbc: {
317 RETURN_IF(mContext->setMbc(param.get<DynamicsProcessing::mbc>()) != RetCode::SUCCESS,
318 EX_ILLEGAL_ARGUMENT, "setMbcFailed");
319 return ndk::ScopedAStatus::ok();
320 }
321 case DynamicsProcessing::mbcBand: {
322 RETURN_IF(mContext->setMbcBand(param.get<DynamicsProcessing::mbcBand>()) !=
323 RetCode::SUCCESS,
324 EX_ILLEGAL_ARGUMENT, "setMbcBandFailed");
325 return ndk::ScopedAStatus::ok();
326 }
327 case DynamicsProcessing::limiter: {
328 RETURN_IF(mContext->setLimiter(param.get<DynamicsProcessing::limiter>()) !=
329 RetCode::SUCCESS,
330 EX_ILLEGAL_ARGUMENT, "setLimiterFailed");
331 return ndk::ScopedAStatus::ok();
332 }
333 case DynamicsProcessing::inputGain: {
334 RETURN_IF(mContext->setInputGain(param.get<DynamicsProcessing::inputGain>()) !=
335 RetCode::SUCCESS,
336 EX_ILLEGAL_ARGUMENT, "setInputGainFailed");
337 return ndk::ScopedAStatus::ok();
338 }
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000339 case DynamicsProcessing::vendor: {
Shunkai Yao725af212023-01-05 23:01:40 +0000340 LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
341 return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
342 EX_ILLEGAL_ARGUMENT, "DPVendorExtensionTagNotSupported");
343 }
344 }
345}
346
347ndk::ScopedAStatus DynamicsProcessingImpl::getParameterSpecific(const Parameter::Id& id,
348 Parameter::Specific* specific) {
349 RETURN_IF(!specific, EX_NULL_POINTER, "nullPtr");
350 auto tag = id.getTag();
351 RETURN_IF(Parameter::Id::dynamicsProcessingTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
352 auto dpId = id.get<Parameter::Id::dynamicsProcessingTag>();
353 auto dpIdTag = dpId.getTag();
354 switch (dpIdTag) {
355 case DynamicsProcessing::Id::commonTag:
356 return getParameterDynamicsProcessing(dpId.get<DynamicsProcessing::Id::commonTag>(),
357 specific);
358 case DynamicsProcessing::Id::vendorExtensionTag:
359 LOG(ERROR) << __func__ << " unsupported ID: " << toString(dpIdTag);
360 return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
361 EX_ILLEGAL_ARGUMENT, "DPVendorExtensionIdNotSupported");
362 }
363}
364
365ndk::ScopedAStatus DynamicsProcessingImpl::getParameterDynamicsProcessing(
366 const DynamicsProcessing::Tag& tag, Parameter::Specific* specific) {
367 RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
368
369 switch (tag) {
370 case DynamicsProcessing::engineArchitecture: {
371 specific->set<Parameter::Specific::dynamicsProcessing>(
372 DynamicsProcessing::make<DynamicsProcessing::engineArchitecture>(
373 mContext->getEngineArchitecture()));
374 return ndk::ScopedAStatus::ok();
375 }
376 case DynamicsProcessing::preEq: {
377 specific->set<Parameter::Specific::dynamicsProcessing>(
378 DynamicsProcessing::make<DynamicsProcessing::preEq>(mContext->getPreEq()));
379 return ndk::ScopedAStatus::ok();
380 }
381 case DynamicsProcessing::postEq: {
382 specific->set<Parameter::Specific::dynamicsProcessing>(
383 DynamicsProcessing::make<DynamicsProcessing::postEq>(mContext->getPostEq()));
384 return ndk::ScopedAStatus::ok();
385 }
386 case DynamicsProcessing::preEqBand: {
387 specific->set<Parameter::Specific::dynamicsProcessing>(
388 DynamicsProcessing::make<DynamicsProcessing::preEqBand>(
389 mContext->getPreEqBand()));
390 return ndk::ScopedAStatus::ok();
391 }
392 case DynamicsProcessing::postEqBand: {
393 specific->set<Parameter::Specific::dynamicsProcessing>(
394 DynamicsProcessing::make<DynamicsProcessing::postEqBand>(
395 mContext->getPostEqBand()));
396 return ndk::ScopedAStatus::ok();
397 }
398 case DynamicsProcessing::mbc: {
399 specific->set<Parameter::Specific::dynamicsProcessing>(
400 DynamicsProcessing::make<DynamicsProcessing::mbc>(mContext->getMbc()));
401 return ndk::ScopedAStatus::ok();
402 }
403 case DynamicsProcessing::mbcBand: {
404 specific->set<Parameter::Specific::dynamicsProcessing>(
405 DynamicsProcessing::make<DynamicsProcessing::mbcBand>(mContext->getMbcBand()));
406 return ndk::ScopedAStatus::ok();
407 }
408 case DynamicsProcessing::limiter: {
409 specific->set<Parameter::Specific::dynamicsProcessing>(
410 DynamicsProcessing::make<DynamicsProcessing::limiter>(mContext->getLimiter()));
411 return ndk::ScopedAStatus::ok();
412 }
413 case DynamicsProcessing::inputGain: {
414 specific->set<Parameter::Specific::dynamicsProcessing>(
415 DynamicsProcessing::make<DynamicsProcessing::inputGain>(
416 mContext->getInputGain()));
417 return ndk::ScopedAStatus::ok();
418 }
Shunkai Yaoda4a6402023-03-03 19:38:17 +0000419 case DynamicsProcessing::vendor: {
Shunkai Yao725af212023-01-05 23:01:40 +0000420 LOG(ERROR) << __func__ << " wrong vendor tag in CommonTag: " << toString(tag);
421 return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
422 EX_ILLEGAL_ARGUMENT, "DPVendorExtensionTagInWrongId");
423 }
424 }
425}
426
427std::shared_ptr<EffectContext> DynamicsProcessingImpl::createContext(
428 const Parameter::Common& common) {
429 if (mContext) {
430 LOG(DEBUG) << __func__ << " context already exist";
431 return mContext;
432 }
433
434 mContext = std::make_shared<DynamicsProcessingContext>(1 /* statusFmqDepth */, common);
435 return mContext;
436}
437
438RetCode DynamicsProcessingImpl::releaseContext() {
439 if (mContext) {
440 mContext->disable();
441 mContext->resetBuffer();
442 mContext.reset();
443 }
444 return RetCode::SUCCESS;
445}
446
447// Processing method running in EffectWorker thread.
448IEffect::Status DynamicsProcessingImpl::effectProcessImpl(float* in, float* out, int samples) {
449 IEffect::Status status = {EX_NULL_POINTER, 0, 0};
450 RETURN_VALUE_IF(!mContext, status, "nullContext");
David Licb5bcc42023-11-13 16:01:48 +0800451 return mContext->dpeProcess(in, out, samples);
Shunkai Yao725af212023-01-05 23:01:40 +0000452}
453
454} // namespace aidl::android::hardware::audio::effect