1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef AUDIO_FRAMEWORK_AUDIO_EFFECT_H
17 #define AUDIO_FRAMEWORK_AUDIO_EFFECT_H
18 
19 #include <cassert>
20 #include <cstdint>
21 #include <stddef.h>
22 #include <map>
23 #include <memory>
24 #include <string>
25 #include <vector>
26 #include "audio_info.h"
27 
28 #define AUDIO_EFFECT_LIBRARY_INFO_SYM_AS_STR "AELI"
29 #define EFFECT_STRING_LEN_MAX 64
30 
31 namespace OHOS {
32 namespace AudioStandard {
33 // audio effect manager info
34 constexpr int32_t AUDIO_EFFECT_COUNT_UPPER_LIMIT = 20;
35 constexpr int32_t AUDIO_EFFECT_COUNT_STREAM_USAGE_UPPER_LIMIT = 200;
36 constexpr int32_t AUDIO_EFFECT_COUNT_FIRST_NODE_UPPER_LIMIT = 1;
37 constexpr int32_t AUDIO_EFFECT_COUNT_POST_SECOND_NODE_UPPER_LIMIT = 1;
38 constexpr int32_t AUDIO_EFFECT_COUNT_PRE_SECOND_NODE_UPPER_LIMIT = 1;
39 constexpr int32_t AUDIO_EFFECT_CHAIN_CONFIG_UPPER_LIMIT = 64; // max conf for sceneType + effectMode + deviceType
40 constexpr int32_t AUDIO_EFFECT_CHAIN_COUNT_UPPER_LIMIT = 32; // max num of effectChain
41 constexpr int32_t AUDIO_EFFECT_COUNT_PER_CHAIN_UPPER_LIMIT = 16; // max num of effect per effectChain
42 constexpr int32_t AUDIO_EFFECT_PRIOR_SCENE_UPPER_LIMIT = 7; // max num of effect prior scene
43 constexpr int32_t AUDIO_EFFECT_COUNT_PROPERTY_UPPER_LIMIT = 20; // max num of property
44 
45 constexpr int32_t HDI_EFFECT_NUM = 2;
46 constexpr int32_t HDI_SET_PATAM = 6;
47 
48 enum HdiSetParamCommandCode {
49     HDI_INIT = 0,
50     HDI_BYPASS = 1,
51     HDI_HEAD_MODE = 2,
52     HDI_ROOM_MODE = 3,
53     HDI_BLUETOOTH_MODE = 4,
54     HDI_DESTROY = 5,
55     HDI_UPDATE_SPATIAL_DEVICE_TYPE = 6,
56     HDI_VOLUME = 7,
57     HDI_ROTATION = 8,
58     HDI_EXTRA_SCENE_TYPE = 9,
59     HDI_SPATIALIZATION_SCENE_TYPE = 10,
60     HDI_STREAM_USAGE = 11,
61 };
62 
63 enum AudioSpatialDeviceType {
64     EARPHONE_TYPE_NONE = 0,
65     EARPHONE_TYPE_INEAR,
66     EARPHONE_TYPE_HALF_INEAR,
67     EARPHONE_TYPE_HEADPHONE,
68     EARPHONE_TYPE_GLASSES,
69     EARPHONE_TYPE_OTHERS,
70 };
71 
72 struct AudioSpatialDeviceState {
73     std::string address;
74     bool isSpatializationSupported;
75     bool isHeadTrackingSupported;
76     AudioSpatialDeviceType spatialDeviceType;
77 };
78 
79 struct Library {
80     std::string name;
81     std::string path;
82 };
83 
84 struct Effect {
85     std::string name;
86     std::string libraryName;
87     std::vector<std::string> effectProperty;
88 };
89 
90 struct EffectChain {
91     std::string name;
92     std::vector<std::string> apply;
93     std::string label = "";
94 };
95 
96 struct Device {
97     std::string type;
98     std::string chain;
99 };
100 
101 struct PreStreamScene {
102     std::string stream;
103     std::vector<std::string> mode;
104     std::vector<std::vector<Device>> device;
105 };
106 
107 struct PostStreamScene {
108     std::string stream;
109     std::vector<std::string> mode;
110     std::vector<std::vector<Device>> device;
111 };
112 
113 struct SceneMappingItem {
114     std::string name;
115     std::string sceneType;
116 };
117 
118 struct PreProcessConfig {
119     uint32_t maxExtSceneNum;
120     std::vector<PreStreamScene> defaultScenes;
121     std::vector<PreStreamScene> priorScenes;
122     std::vector<PreStreamScene> normalScenes;
123 };
124 
125 struct PostProcessConfig {
126     uint32_t maxExtSceneNum;
127     std::vector<PostStreamScene> defaultScenes;
128     std::vector<PostStreamScene> priorScenes;
129     std::vector<PostStreamScene> normalScenes;
130     std::vector<SceneMappingItem> sceneMap;
131 };
132 
133 struct OriginalEffectConfig {
134     std::string version;
135     std::vector<Library> libraries;
136     std::vector<Effect> effects;
137     std::vector<EffectChain> effectChains;
138     PreProcessConfig preProcess;
139     PostProcessConfig postProcess;
140 };
141 
142 struct EffectChainManagerParam {
143     uint32_t maxExtraNum = 0;
144     std::string defaultSceneName;
145     std::vector<std::string> priorSceneList;
146     std::unordered_map<std::string, std::string> sceneTypeToChainNameMap;
147     std::unordered_map<std::string, std::string> effectDefaultProperty;
148 };
149 
150 struct StreamEffectMode {
151     std::string mode;
152     std::vector<Device> devicePort;
153 };
154 
155 enum ScenePriority {
156     DEFAULT_SCENE = 0,
157     PRIOR_SCENE = 1,
158     NORMAL_SCENE = 2
159 };
160 
161 struct Stream {
162     ScenePriority priority;
163     std::string scene;
164     std::vector<StreamEffectMode> streamEffectMode;
165 };
166 
167 struct ProcessNew {
168     std::vector<Stream> stream;
169 };
170 
171 struct SupportedEffectConfig {
172     std::vector<EffectChain> effectChains;
173     ProcessNew preProcessNew;
174     ProcessNew postProcessNew;
175     std::vector<SceneMappingItem> postProcessSceneMap;
176 };
177 
178 
179 /**
180 * Enumerates the audio scene effect type.
181 */
182 enum AudioEffectScene {
183     SCENE_OTHERS = 0,
184     SCENE_MUSIC = 1,
185     SCENE_MOVIE = 2,
186     SCENE_GAME = 3,
187     SCENE_SPEECH = 4,
188     SCENE_RING = 5,
189     SCENE_VOIP_DOWN = 6,
190 };
191 
192 /**
193 * Enumerates the audio enhance scene effect type.
194 */
195 enum AudioEnhanceScene {
196     SCENE_VOIP_UP = 0,
197     SCENE_RECORD = 1,
198     SCENE_PRE_ENHANCE = 2,
199     SCENE_ASR = 4,
200 };
201 
202 /**
203 * Enumerates the audio scene effct mode.
204 */
205 enum AudioEffectMode {
206     EFFECT_NONE = 0,
207     EFFECT_DEFAULT = 1
208 };
209 
210 struct AudioSceneEffectInfo {
211     std::vector<AudioEffectMode> mode;
212 };
213 
214 const std::unordered_map<AudioEffectScene, std::string> AUDIO_SUPPORTED_SCENE_TYPES {
215     {SCENE_OTHERS, "SCENE_OTHERS"},
216     {SCENE_MUSIC, "SCENE_MUSIC"},
217     {SCENE_MOVIE, "SCENE_MOVIE"},
218     {SCENE_GAME, "SCENE_GAME"},
219     {SCENE_SPEECH, "SCENE_SPEECH"},
220     {SCENE_RING, "SCENE_RING"},
221     {SCENE_VOIP_DOWN, "SCENE_VOIP_DOWN"},
222 };
223 
224 const std::unordered_map<AudioEnhanceScene, std::string> AUDIO_ENHANCE_SUPPORTED_SCENE_TYPES {
225     {SCENE_VOIP_UP, "SCENE_VOIP_UP"},
226     {SCENE_RECORD, "SCENE_RECORD"},
227     {SCENE_ASR, "SCENE_ASR"},
228     {SCENE_PRE_ENHANCE, "SCENE_PRE_ENHANCE"},
229 };
230 
231 const std::unordered_map<AudioEffectMode, std::string> AUDIO_SUPPORTED_SCENE_MODES {
232     {EFFECT_NONE, "EFFECT_NONE"},
233     {EFFECT_DEFAULT, "EFFECT_DEFAULT"},
234 };
235 
236 const std::unordered_map<DeviceType, std::string> SUPPORTED_DEVICE_TYPE {
237     {DEVICE_TYPE_NONE, "DEVICE_TYPE_NONE"},
238     {DEVICE_TYPE_INVALID, "DEVICE_TYPE_INVALID"},
239     {DEVICE_TYPE_EARPIECE, "DEVICE_TYPE_EARPIECE"},
240     {DEVICE_TYPE_SPEAKER, "DEVICE_TYPE_SPEAKER"},
241     {DEVICE_TYPE_WIRED_HEADSET, "DEVICE_TYPE_WIRED_HEADSET"},
242     {DEVICE_TYPE_WIRED_HEADPHONES, "DEVICE_TYPE_WIRED_HEADPHONES"},
243     {DEVICE_TYPE_BLUETOOTH_SCO, "DEVICE_TYPE_BLUETOOTH_SCO"},
244     {DEVICE_TYPE_BLUETOOTH_A2DP, "DEVICE_TYPE_BLUETOOTH_A2DP"},
245     {DEVICE_TYPE_MIC, "DEVICE_TYPE_MIC"},
246     {DEVICE_TYPE_WAKEUP, "DEVICE_TYPE_WAKEUP"},
247     {DEVICE_TYPE_USB_HEADSET, "DEVICE_TYPE_USB_HEADSET"},
248     {DEVICE_TYPE_USB_ARM_HEADSET, "DEVICE_TYPE_USB_ARM_HEADSET"},
249     {DEVICE_TYPE_DP, "DEVICE_TYPE_DP"},
250     {DEVICE_TYPE_FILE_SINK, "DEVICE_TYPE_FILE_SINK"},
251     {DEVICE_TYPE_FILE_SOURCE, "DEVICE_TYPE_FILE_SOURCE"},
252     {DEVICE_TYPE_EXTERN_CABLE, "DEVICE_TYPE_EXTERN_CABLE"},
253     {DEVICE_TYPE_DEFAULT, "DEVICE_TYPE_DEFAULT"},
254 };
255 
256 enum AudioEffectCommandCode {
257     EFFECT_CMD_INIT = 0,
258     EFFECT_CMD_SET_CONFIG = 1,
259     EFFECT_CMD_ENABLE = 2,
260     EFFECT_CMD_DISABLE = 3,
261     EFFECT_CMD_SET_PARAM = 4,
262     EFFECT_CMD_GET_PARAM = 5,
263     EFFECT_CMD_GET_CONFIG = 6,
264     EFFECT_CMD_SET_IMU = 7
265 };
266 
267 enum AudioEffectParamSetCode {
268     EFFECT_SET_BYPASS = 1,
269     EFFECT_SET_PARAM = 2,
270 };
271 
272 enum AudioDataFormat {
273     DATA_FORMAT_S16 = SAMPLE_S16LE,
274     DATA_FORMAT_S24 = SAMPLE_S24LE,
275     DATA_FORMAT_S32 = SAMPLE_S32LE,
276     DATA_FORMAT_F32 = SAMPLE_F32LE,
277 };
278 
279 struct AudioEffectParam {
280     int32_t status;
281     uint32_t paramSize;
282     uint32_t valueSize;
283     int32_t data[];
284 };
285 
286 struct AudioBuffer {
287     size_t frameLength;
288     union {
289         void*     raw;
290         float*    f32;
291         int32_t*  s32;
292         int16_t*  s16;
293         uint8_t*  u8;
294     };
295     void *metaData = nullptr;
296 };
297 
298 struct AudioBufferConfig {
299     uint32_t samplingRate;
300     uint32_t channels;
301     uint8_t format;
302     uint64_t channelLayout;
303     AudioEncodingType encoding;
304 };
305 
306 struct AudioEffectConfig {
307     AudioBufferConfig inputCfg;
308     AudioBufferConfig outputCfg;
309 };
310 
311 struct AudioEffectTransInfo {
312     uint32_t size;
313     void *data;
314 };
315 
316 struct AudioEffectDescriptor {
317     std::string libraryName;
318     std::string effectName;
319 };
320 
321 typedef struct AudioEffectInterface **AudioEffectHandle;
322 
323 struct AudioEffectInterface {
324     int32_t (*process) (AudioEffectHandle self, AudioBuffer *inBuffer, AudioBuffer *outBuffer);
325     int32_t (*command) (AudioEffectHandle self, uint32_t cmdCode,
326         AudioEffectTransInfo *cmdInfo, AudioEffectTransInfo *replyInfo);
327 };
328 
329 struct AudioEffectLibrary {
330     uint32_t version;
331     const char *name;
332     const char *implementor;
333     bool (*checkEffect) (const AudioEffectDescriptor descriptor);
334     int32_t (*createEffect) (const AudioEffectDescriptor descriptor, AudioEffectHandle *handle);
335     int32_t (*releaseEffect) (AudioEffectHandle handle);
336 };
337 
338 struct AudioEffectLibEntry {
339     AudioEffectLibrary *audioEffectLibHandle;
340     std::string libraryName;
341     std::vector<std::string> effectName;
342 };
343 
344 struct AudioSpatializationState {
345     bool spatializationEnabled = false;
346     bool headTrackingEnabled = false;
347 };
348 
349 struct ConverterConfig {
350     std::string version;
351     Library library;
352     uint64_t outChannelLayout = 0;
353 };
354 
355 enum AudioSpatializationSceneType {
356     SPATIALIZATION_SCENE_TYPE_DEFAULT = 0,
357     SPATIALIZATION_SCENE_TYPE_MUSIC = 1,
358     SPATIALIZATION_SCENE_TYPE_MOVIE = 2,
359     SPATIALIZATION_SCENE_TYPE_AUDIOBOOK = 3,
360     SPATIALIZATION_SCENE_TYPE_MAX = SPATIALIZATION_SCENE_TYPE_AUDIOBOOK,
361 };
362 
363 const std::unordered_map<DeviceType, std::vector<std::string>> HDI_EFFECT_LIB_MAP {
364     {DEVICE_TYPE_SPEAKER, {"libspeaker_processing_dsp", "aaaabbbb-8888-9999-6666-aabbccdd9966oo"}},
365     {DEVICE_TYPE_BLUETOOTH_A2DP, {"libspatialization_processing_dsp", "aaaabbbb-8888-9999-6666-aabbccdd9966gg"}},
366 };
367 
368 const std::unordered_map<std::string, uint8_t> EFFECT_CHAIN_TYPE_MAP {
369     {"UNKNOWN", 0},
370     {"NONE", 1},
371     {"SCENE_MUSIC", 2},
372     {"SCENE_MOVIE", 3},
373     {"SCENE_GAME", 4},
374     {"SCENE_SPEECH", 5},
375     {"SCENE_RING", 6},
376     {"SCENE_OTHERS", 7}
377 } ;
378 
379 struct AudioRendererInfoForSpatialization {
380     RendererState rendererState;
381     std::string deviceMacAddress;
382     StreamUsage streamUsage;
383 };
384 } // namespace AudioStandard
385 } // namespace OHOS
386 
387 #endif // AUDIO_FRAMEWORK_AUDIO_EFFECT_H