1 /*
2 * Copyright (C) 2021 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 #include <string>
18
19 #include <gtest/gtest.h>
20
21 #define LOG_TAG "EffectUtils_Test"
22 #include <log/log.h>
23
24 #include <android_audio_policy_configuration_V7_0-enums.h>
25 #include <system/audio_effect.h>
26 #include <util/EffectUtils.h>
27 #include <xsdc/XsdcSupport.h>
28
29 using namespace android;
30 using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
31 using namespace ::android::hardware::audio::effect::CPP_VERSION;
32 using ::android::hardware::audio::effect::CPP_VERSION::implementation::EffectUtils;
33 namespace xsd {
34 using namespace ::android::audio::policy::configuration::V7_0;
35 }
36
37 static constexpr audio_channel_mask_t kInvalidHalChannelMask = AUDIO_CHANNEL_INVALID;
38 static constexpr audio_format_t kInvalidHalFormat = AUDIO_FORMAT_INVALID;
39
40 // Not generated automatically because AudioBuffer contains
41 // instances of hidl_memory which can't be compared properly
42 // in general case due to presence of handles.
43 //
44 // However, in this particular case, handles must not present
45 // thus comparison is possible.
46 //
47 // operator== must be defined in the same namespace as the structures.
48 namespace android {
49 namespace hardware {
50 namespace audio {
51 namespace effect {
52 namespace CPP_VERSION {
operator ==(const AudioBuffer & lhs,const AudioBuffer & rhs)53 inline bool operator==(const AudioBuffer& lhs, const AudioBuffer& rhs) {
54 return lhs.id == rhs.id && lhs.frameCount == rhs.frameCount && lhs.data.handle() == nullptr &&
55 rhs.data.handle() == nullptr;
56 }
57
operator ==(const EffectBufferConfig & lhs,const EffectBufferConfig & rhs)58 inline bool operator==(const EffectBufferConfig& lhs, const EffectBufferConfig& rhs) {
59 return lhs.buffer.getDiscriminator() == rhs.buffer.getDiscriminator() &&
60 (lhs.buffer.getDiscriminator() ==
61 EffectBufferConfig::OptionalBuffer::hidl_discriminator::unspecified ||
62 lhs.buffer.buf() == rhs.buffer.buf()) &&
63 lhs.base == rhs.base && lhs.accessMode == rhs.accessMode;
64 }
65
operator ==(const EffectConfig & lhs,const EffectConfig & rhs)66 inline bool operator==(const EffectConfig& lhs, const EffectConfig& rhs) {
67 return lhs.inputCfg == rhs.inputCfg && lhs.outputCfg == rhs.outputCfg;
68 }
69 } // namespace CPP_VERSION
70 } // namespace effect
71 } // namespace audio
72 } // namespace hardware
73 } // namespace android
74
TEST(EffectUtils,ConvertInvalidBufferConfig)75 TEST(EffectUtils, ConvertInvalidBufferConfig) {
76 buffer_config_t halInvalid;
77 EffectBufferConfig invalidChannelMask;
78 invalidChannelMask.base.channelMask.value("random string");
79 EXPECT_EQ(BAD_VALUE, EffectUtils::effectBufferConfigToHal(invalidChannelMask, &halInvalid));
80 EffectBufferConfig invalidFormat;
81 invalidFormat.base.format.value("random string");
82 EXPECT_EQ(BAD_VALUE, EffectUtils::effectBufferConfigToHal(invalidFormat, &halInvalid));
83
84 buffer_config_t halInvalidChannelMask;
85 EffectBufferConfig invalid;
86 halInvalidChannelMask.channels = kInvalidHalChannelMask;
87 halInvalidChannelMask.mask = EFFECT_CONFIG_CHANNELS;
88 EXPECT_EQ(BAD_VALUE, EffectUtils::effectBufferConfigFromHal(halInvalidChannelMask,
89 false /*isInput*/, &invalid));
90 EXPECT_EQ(BAD_VALUE, EffectUtils::effectBufferConfigFromHal(halInvalidChannelMask,
91 true /*isInput*/, &invalid));
92 buffer_config_t halInvalidFormat;
93 halInvalidFormat.format = (uint8_t)kInvalidHalFormat;
94 halInvalidFormat.mask = EFFECT_CONFIG_FORMAT;
95 EXPECT_EQ(BAD_VALUE, EffectUtils::effectBufferConfigFromHal(halInvalidFormat, false /*isInput*/,
96 &invalid));
97 EXPECT_EQ(BAD_VALUE,
98 EffectUtils::effectBufferConfigFromHal(halInvalidFormat, true /*isInput*/, &invalid));
99 }
100
TEST(EffectUtils,ConvertBufferConfig)101 TEST(EffectUtils, ConvertBufferConfig) {
102 EffectBufferConfig empty;
103 buffer_config_t halEmpty;
104 EXPECT_EQ(NO_ERROR, EffectUtils::effectBufferConfigToHal(empty, &halEmpty));
105 EffectBufferConfig emptyBackOut;
106 EXPECT_EQ(NO_ERROR,
107 EffectUtils::effectBufferConfigFromHal(halEmpty, false /*isInput*/, &emptyBackOut));
108 EXPECT_EQ(empty, emptyBackOut);
109 EffectBufferConfig emptyBackIn;
110 EXPECT_EQ(NO_ERROR,
111 EffectUtils::effectBufferConfigFromHal(halEmpty, true /*isInput*/, &emptyBackIn));
112 EXPECT_EQ(empty, emptyBackIn);
113
114 EffectBufferConfig chanMask;
115 chanMask.base.channelMask.value(toString(xsd::AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO));
116 buffer_config_t halChanMask;
117 EXPECT_EQ(NO_ERROR, EffectUtils::effectBufferConfigToHal(chanMask, &halChanMask));
118 EffectBufferConfig chanMaskBack;
119 EXPECT_EQ(NO_ERROR, EffectUtils::effectBufferConfigFromHal(halChanMask, false /*isInput*/,
120 &chanMaskBack));
121 EXPECT_EQ(chanMask, chanMaskBack);
122
123 EffectBufferConfig format;
124 format.base.format.value(toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT));
125 buffer_config_t halFormat;
126 EXPECT_EQ(NO_ERROR, EffectUtils::effectBufferConfigToHal(format, &halFormat));
127 EffectBufferConfig formatBackOut;
128 EXPECT_EQ(NO_ERROR,
129 EffectUtils::effectBufferConfigFromHal(halFormat, false /*isInput*/, &formatBackOut));
130 EXPECT_EQ(format, formatBackOut);
131 EffectBufferConfig formatBackIn;
132 EXPECT_EQ(NO_ERROR,
133 EffectUtils::effectBufferConfigFromHal(halFormat, true /*isInput*/, &formatBackIn));
134 EXPECT_EQ(format, formatBackIn);
135 }
136
TEST(EffectUtils,ConvertInvalidDescriptor)137 TEST(EffectUtils, ConvertInvalidDescriptor) {
138 effect_descriptor_t halDesc;
139 EffectDescriptor longName{};
140 longName.name = std::string(EFFECT_STRING_LEN_MAX, 'x');
141 EXPECT_EQ(BAD_VALUE, EffectUtils::effectDescriptorToHal(longName, &halDesc));
142 EffectDescriptor longImplementor{};
143 longImplementor.implementor = std::string(EFFECT_STRING_LEN_MAX, 'x');
144 EXPECT_EQ(BAD_VALUE, EffectUtils::effectDescriptorToHal(longImplementor, &halDesc));
145 }
146
TEST(EffectUtils,ConvertDescriptor)147 TEST(EffectUtils, ConvertDescriptor) {
148 EffectDescriptor desc{};
149 desc.name = "test";
150 desc.implementor = "foo";
151 effect_descriptor_t halDesc;
152 EXPECT_EQ(NO_ERROR, EffectUtils::effectDescriptorToHal(desc, &halDesc));
153 EffectDescriptor descBack;
154 EXPECT_EQ(NO_ERROR, EffectUtils::effectDescriptorFromHal(halDesc, &descBack));
155 EXPECT_EQ(desc, descBack);
156 }
157
TEST(EffectUtils,ConvertNameAndImplementor)158 TEST(EffectUtils, ConvertNameAndImplementor) {
159 for (size_t i = 0; i < EFFECT_STRING_LEN_MAX; ++i) {
160 effect_descriptor_t halDesc{};
161 for (size_t c = 0; c < i; ++c) { // '<' to accommodate NUL terminator.
162 halDesc.name[c] = halDesc.implementor[c] = 'A' + static_cast<char>(c);
163 }
164 EffectDescriptor desc;
165 EXPECT_EQ(NO_ERROR, EffectUtils::effectDescriptorFromHal(halDesc, &desc));
166 effect_descriptor_t halDescBack;
167 EXPECT_EQ(NO_ERROR, EffectUtils::effectDescriptorToHal(desc, &halDescBack));
168 EXPECT_EQ(i, strlen(halDescBack.name));
169 EXPECT_EQ(i, strlen(halDescBack.implementor));
170 EXPECT_EQ(0, strcmp(halDesc.name, halDescBack.name));
171 EXPECT_EQ(0, strcmp(halDesc.implementor, halDescBack.implementor));
172 }
173 }
174