1 /* 2 * Copyright (c) 2023-2025 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 uint32_t SEND_HDI_COMMAND_LEN = 20; 36 constexpr int32_t AUDIO_EFFECT_PRIOR_SCENE_UPPER_LIMIT = 7; 37 constexpr int32_t AUDIO_EFFECT_CHAIN_CONFIG_UPPER_LIMIT = 64; 38 constexpr int32_t AUDIO_EFFECT_COUNT_PROPERTY_UPPER_LIMIT = 20; 39 40 enum HdiSetParamCommandCode { 41 HDI_INIT = 0, 42 HDI_BYPASS = 1, 43 HDI_HEAD_MODE = 2, 44 HDI_ROOM_MODE = 3, 45 HDI_BLUETOOTH_MODE = 4, 46 HDI_DESTROY = 5, 47 HDI_UPDATE_SPATIAL_DEVICE_TYPE = 6, 48 HDI_VOLUME = 7, 49 HDI_ROTATION = 8, 50 HDI_EXTRA_SCENE_TYPE = 9, 51 HDI_SPATIALIZATION_SCENE_TYPE = 10, 52 HDI_STREAM_USAGE = 11, 53 HDI_FOLD_STATE = 12, 54 HDI_LID_STATE = 13, 55 HDI_QUERY_CHANNELLAYOUT = 14, 56 HDI_ABS_VOLUME_STATE = 15, 57 }; 58 59 enum AudioSpatialDeviceType { 60 EARPHONE_TYPE_NONE = 0, 61 EARPHONE_TYPE_INEAR, 62 EARPHONE_TYPE_HALF_INEAR, 63 EARPHONE_TYPE_HEADPHONE, 64 EARPHONE_TYPE_GLASSES, 65 EARPHONE_TYPE_OTHERS, 66 }; 67 68 enum FoldState : uint32_t { 69 FOLD_STATE_EXPAND = 1, 70 FOLD_STATE_CLOSE = 2, 71 FOLD_STATE_MIDDLE = 3, 72 }; 73 74 struct AudioSpatialDeviceState : public Parcelable { 75 std::string address; 76 bool isSpatializationSupported; 77 bool isHeadTrackingSupported; 78 AudioSpatialDeviceType spatialDeviceType; 79 80 AudioSpatialDeviceState() = default; AudioSpatialDeviceStateAudioSpatialDeviceState81 AudioSpatialDeviceState(const std::string &address, bool isSpatializationSupported, 82 bool isHeadTrackingSupported, AudioSpatialDeviceType spatialDeviceType) 83 : address(address), isSpatializationSupported(isSpatializationSupported), 84 isHeadTrackingSupported(isHeadTrackingSupported), spatialDeviceType(spatialDeviceType) 85 { 86 } 87 MarshallingAudioSpatialDeviceState88 bool Marshalling(Parcel &parcel) const override 89 { 90 return parcel.WriteString(address) && 91 parcel.WriteBool(isSpatializationSupported) && 92 parcel.WriteBool(isHeadTrackingSupported) && 93 parcel.WriteInt32(spatialDeviceType); 94 } 95 UnmarshallingAudioSpatialDeviceState96 static AudioSpatialDeviceState *Unmarshalling(Parcel &parcel) 97 { 98 auto deviceState = new(std::nothrow) AudioSpatialDeviceState(); 99 if (deviceState == nullptr) { 100 return nullptr; 101 } 102 deviceState->address = parcel.ReadString(); 103 deviceState->isSpatializationSupported = parcel.ReadBool(); 104 deviceState->isHeadTrackingSupported = parcel.ReadBool(); 105 deviceState->spatialDeviceType = static_cast<AudioSpatialDeviceType>(parcel.ReadInt32()); 106 return deviceState; 107 } 108 }; 109 110 struct Library : public Parcelable { 111 std::string name; 112 std::string path; 113 MarshallingLibrary114 bool Marshalling(Parcel &parcel) const override 115 { 116 return parcel.WriteString(name) && parcel.WriteString(path); 117 } 118 UnmarshallingSelfLibrary119 void UnmarshallingSelf(Parcel &parcel) 120 { 121 name = parcel.ReadString(); 122 path = parcel.ReadString(); 123 } 124 UnmarshallingLibrary125 static Library *Unmarshalling(Parcel &parcel) 126 { 127 auto library = new(std::nothrow) Library(); 128 if (library == nullptr) { 129 return nullptr; 130 } 131 library->UnmarshallingSelf(parcel); 132 return library; 133 } 134 }; 135 136 struct Effect : public Parcelable { 137 std::string name; 138 std::string libraryName; 139 std::vector<std::string> effectProperty; 140 static constexpr int32_t MAX_EFFECT_PROPERTY_SIZE = 1000; 141 MarshallingEffect142 bool Marshalling(Parcel &parcel) const override 143 { 144 parcel.WriteString(name); 145 parcel.WriteString(libraryName); 146 int32_t size = static_cast<int32_t>(effectProperty.size()); 147 parcel.WriteInt32(size); 148 for (auto &property : effectProperty) { 149 parcel.WriteString(property); 150 } 151 return true; 152 } 153 UnmarshallingEffect154 static Effect *Unmarshalling(Parcel &parcel) 155 { 156 auto effect = new(std::nothrow) Effect(); 157 if (effect == nullptr) { 158 return nullptr; 159 } 160 161 effect->name = parcel.ReadString(); 162 effect->libraryName = parcel.ReadString(); 163 int32_t size = parcel.ReadInt32(); 164 if (size < 0 || size > MAX_EFFECT_PROPERTY_SIZE) { 165 delete effect; 166 return nullptr; 167 } 168 for (int32_t i = 0; i < size; ++i) { 169 effect->effectProperty.push_back(parcel.ReadString()); 170 } 171 return effect; 172 } 173 }; 174 175 struct EffectChain : public Parcelable { 176 std::string name; 177 std::vector<std::string> apply; 178 std::string label = ""; 179 static constexpr int32_t AUDIO_EFFECT_COUNT_PER_CHAIN_UPPER_LIMIT = 16; 180 181 EffectChain() = default; EffectChainEffectChain182 EffectChain(std::string sName, std::vector<std::string> applyVec, std::string sLabel) 183 : name(sName), apply(applyVec), label(sLabel) 184 { 185 } 186 MarshallingEffectChain187 bool Marshalling(Parcel &parcel) const override 188 { 189 parcel.WriteString(name); 190 int32_t size = static_cast<int32_t>(apply.size()); 191 parcel.WriteInt32(size); 192 for (auto &effect : apply) { 193 parcel.WriteString(effect); 194 } 195 parcel.WriteString(label); 196 return true; 197 } 198 UnmarshallingEffectChain199 static EffectChain *Unmarshalling(Parcel &parcel) 200 { 201 auto effectChain = new(std::nothrow) EffectChain(); 202 if (effectChain == nullptr) { 203 return nullptr; 204 } 205 effectChain->name = parcel.ReadString(); 206 int32_t size = parcel.ReadInt32(); 207 if (size < 0 || size > AUDIO_EFFECT_COUNT_PER_CHAIN_UPPER_LIMIT) { 208 delete effectChain; 209 return nullptr; 210 } 211 for (int32_t i = 0; i < size; ++i) { 212 effectChain->apply.push_back(parcel.ReadString()); 213 } 214 effectChain->label = parcel.ReadString(); 215 return effectChain; 216 } 217 }; 218 219 struct Device { 220 std::string type; 221 std::string chain; 222 }; 223 224 struct PreStreamScene { 225 std::string stream; 226 std::vector<std::string> mode; 227 std::vector<std::vector<Device>> device; 228 }; 229 230 struct PostStreamScene { 231 std::string stream; 232 std::vector<std::string> mode; 233 std::vector<std::vector<Device>> device; 234 }; 235 236 struct SceneMappingItem { 237 std::string name; 238 std::string sceneType; 239 }; 240 241 struct PreProcessConfig { 242 uint32_t maxExtSceneNum; 243 std::vector<PreStreamScene> defaultScenes; 244 std::vector<PreStreamScene> priorScenes; 245 std::vector<PreStreamScene> normalScenes; 246 }; 247 248 struct PostProcessConfig { 249 uint32_t maxExtSceneNum; 250 std::vector<PostStreamScene> defaultScenes; 251 std::vector<PostStreamScene> priorScenes; 252 std::vector<PostStreamScene> normalScenes; 253 std::vector<SceneMappingItem> sceneMap; 254 }; 255 256 struct OriginalEffectConfig { 257 std::string version; 258 std::vector<Library> libraries; 259 std::vector<Effect> effects; 260 std::vector<EffectChain> effectChains; 261 PreProcessConfig preProcess; 262 PostProcessConfig postProcess; 263 }; 264 265 struct EffectChainManagerParam : public Parcelable { 266 uint32_t maxExtraNum = 0; 267 std::string defaultSceneName; 268 std::vector<std::string> priorSceneList; 269 std::unordered_map<std::string, std::string> sceneTypeToChainNameMap; 270 std::unordered_map<std::string, std::string> effectDefaultProperty; 271 272 EffectChainManagerParam() = default; EffectChainManagerParamEffectChainManagerParam273 EffectChainManagerParam(uint32_t maxExtraNum, std::string defaultSceneName, std::vector<std::string> priorSceneList, 274 std::unordered_map<std::string, std::string> sceneTypeToChainNameMap, 275 std::unordered_map<std::string, std::string> effectDefaultProperty) 276 : maxExtraNum(maxExtraNum), defaultSceneName(defaultSceneName), priorSceneList(priorSceneList), 277 sceneTypeToChainNameMap(sceneTypeToChainNameMap), effectDefaultProperty(effectDefaultProperty) 278 { 279 } 280 MarshallingEffectChainManagerParam281 bool Marshalling(Parcel &parcel) const override 282 { 283 parcel.WriteUint32(maxExtraNum); 284 parcel.WriteString(defaultSceneName); 285 int32_t size = static_cast<int32_t>(priorSceneList.size()); 286 parcel.WriteInt32(size); 287 for (auto &scene : priorSceneList) { 288 parcel.WriteString(scene); 289 } 290 size = static_cast<int32_t>(sceneTypeToChainNameMap.size()); 291 parcel.WriteInt32(size); 292 for (const auto &[scene, chain] : sceneTypeToChainNameMap) { 293 parcel.WriteString(scene); 294 parcel.WriteString(chain); 295 } 296 size = static_cast<int32_t>(effectDefaultProperty.size()); 297 parcel.WriteInt32(size); 298 for (const auto &[effect, property] : effectDefaultProperty) { 299 parcel.WriteString(effect); 300 parcel.WriteString(property); 301 } 302 return true; 303 } 304 UnmarshallingEffectChainManagerParam305 static EffectChainManagerParam *Unmarshalling(Parcel &parcel) 306 { 307 auto param = new(std::nothrow) EffectChainManagerParam(); 308 if (param == nullptr) { 309 return nullptr; 310 } 311 param->maxExtraNum = parcel.ReadUint32(); 312 param->defaultSceneName = parcel.ReadString(); 313 int32_t size = parcel.ReadInt32(); 314 if (size < 0 || size > AUDIO_EFFECT_PRIOR_SCENE_UPPER_LIMIT) { 315 delete param; 316 return nullptr; 317 } 318 for (int32_t i = 0; i < size; ++i) { 319 param->priorSceneList.push_back(parcel.ReadString()); 320 } 321 size = parcel.ReadInt32(); 322 if (size < 0 || size > AUDIO_EFFECT_CHAIN_CONFIG_UPPER_LIMIT) { 323 delete param; 324 return nullptr; 325 } 326 for (int32_t i = 0; i < size; ++i) { 327 std::string scene = parcel.ReadString(); 328 std::string chain = parcel.ReadString(); 329 param->sceneTypeToChainNameMap[scene] = chain; 330 } 331 size = parcel.ReadInt32(); 332 if (size < 0 || size > AUDIO_EFFECT_COUNT_PROPERTY_UPPER_LIMIT) { 333 delete param; 334 return nullptr; 335 } 336 for (int32_t i = 0; i < size; ++i) { 337 std::string effect = parcel.ReadString(); 338 std::string property = parcel.ReadString(); 339 param->effectDefaultProperty[effect] = property; 340 } 341 return param; 342 } 343 }; 344 345 struct StreamEffectMode { 346 std::string mode; 347 std::vector<Device> devicePort; 348 }; 349 350 enum ScenePriority { 351 DEFAULT_SCENE = 0, 352 PRIOR_SCENE = 1, 353 NORMAL_SCENE = 2 354 }; 355 356 struct Stream { 357 ScenePriority priority; 358 std::string scene; 359 std::vector<StreamEffectMode> streamEffectMode; 360 }; 361 362 struct ProcessNew { 363 std::vector<Stream> stream; 364 }; 365 366 struct SupportedEffectConfig : public Parcelable { 367 std::vector<EffectChain> effectChains; 368 ProcessNew preProcessNew; 369 ProcessNew postProcessNew; 370 std::vector<SceneMappingItem> postProcessSceneMap; 371 static constexpr uint32_t POST_PROCESS_SCENE_MAP_MAX_SIZE = 1000; 372 static constexpr uint32_t STREAM_MAX_SIZE = 1000; 373 static constexpr uint32_t STREAM_EFFECT_MODE_MAX_SIZE = 1000; 374 MarshallingStreamSupportedEffectConfig375 bool MarshallingStream(Parcel &parcel, const Stream &stream) const 376 { 377 parcel.WriteInt32(stream.priority); 378 parcel.WriteString(stream.scene); 379 uint32_t count = static_cast<uint32_t>(stream.streamEffectMode.size()); 380 parcel.WriteUint32(count); 381 for (const auto &item : stream.streamEffectMode) { 382 parcel.WriteString(item.mode); 383 uint32_t deviceCount = static_cast<uint32_t>(item.devicePort.size()); 384 parcel.WriteUint32(deviceCount); 385 for (const auto &device : item.devicePort) { 386 parcel.WriteString(device.type); 387 parcel.WriteString(device.chain); 388 } 389 } 390 return true; 391 } 392 MarshallingSupportedEffectConfig393 bool Marshalling(Parcel &parcel) const override 394 { 395 uint32_t countPre = static_cast<uint32_t>(preProcessNew.stream.size()); 396 parcel.WriteUint32(countPre); 397 for (const auto &item : preProcessNew.stream) { 398 MarshallingStream(parcel, item); 399 } 400 401 uint32_t countPost = static_cast<uint32_t>(postProcessNew.stream.size()); 402 parcel.WriteUint32(countPost); 403 for (const auto &item : postProcessNew.stream) { 404 MarshallingStream(parcel, item); 405 } 406 407 uint32_t countPostMap = static_cast<uint32_t>(postProcessSceneMap.size()); 408 parcel.WriteUint32(countPostMap); 409 for (const auto &item : postProcessSceneMap) { 410 parcel.WriteString(item.name); 411 parcel.WriteString(item.sceneType); 412 } 413 return true; 414 } 415 UnmarshallingStreamSupportedEffectConfig416 static bool UnmarshallingStream(Parcel &parcel, Stream &stream) 417 { 418 stream.priority = static_cast<ScenePriority>(parcel.ReadInt32()); 419 stream.scene = parcel.ReadString(); 420 uint32_t count = parcel.ReadUint32(); 421 if (count > STREAM_MAX_SIZE) { 422 return false; 423 } 424 for (uint32_t i = 0; i < count; ++i) { 425 StreamEffectMode mode; 426 mode.mode = parcel.ReadString(); 427 uint32_t deviceCount = parcel.ReadUint32(); 428 if (deviceCount > STREAM_EFFECT_MODE_MAX_SIZE) { 429 return false; 430 } 431 for (uint32_t j = 0; j < deviceCount; ++j) { 432 Device device; 433 device.type = parcel.ReadString(); 434 device.chain = parcel.ReadString(); 435 mode.devicePort.push_back(device); 436 } 437 stream.streamEffectMode.push_back(mode); 438 } 439 return true; 440 } 441 UnmarshallingSupportedEffectConfig442 static SupportedEffectConfig *Unmarshalling(Parcel &parcel) 443 { 444 auto config = new(std::nothrow) SupportedEffectConfig(); 445 if (config == nullptr) { 446 return nullptr; 447 } 448 uint32_t countPre = parcel.ReadUint32(); 449 if (countPre > AUDIO_EFFECT_COUNT_UPPER_LIMIT) { 450 delete config; 451 return nullptr; 452 } 453 for (uint32_t i = 0; i < countPre; ++i) { 454 Stream stream = {}; 455 if (!UnmarshallingStream(parcel, stream)) { 456 delete config; 457 return nullptr; 458 } 459 config->preProcessNew.stream.push_back(stream); 460 } 461 462 uint32_t countPost = parcel.ReadUint32(); 463 if (countPost > AUDIO_EFFECT_COUNT_UPPER_LIMIT) { 464 delete config; 465 return nullptr; 466 } 467 for (uint32_t i = 0; i < countPost; ++i) { 468 Stream stream = {}; 469 if (!UnmarshallingStream(parcel, stream)) { 470 delete config; 471 return nullptr; 472 } 473 config->postProcessNew.stream.push_back(stream); 474 } 475 uint32_t countPostMap = parcel.ReadUint32(); 476 if (countPostMap > POST_PROCESS_SCENE_MAP_MAX_SIZE) { 477 delete config; 478 return nullptr; 479 } 480 for (uint32_t i = 0; i < countPostMap; ++i) { 481 SceneMappingItem item; 482 item.name = parcel.ReadString(); 483 item.sceneType = parcel.ReadString(); 484 config->postProcessSceneMap.push_back(item); 485 } 486 return config; 487 } 488 }; 489 490 /** 491 * Enumerates the audio scene effect type. 492 */ 493 enum AudioEffectScene { 494 SCENE_OTHERS = 0, 495 SCENE_MUSIC = 1, 496 SCENE_MOVIE = 2, 497 SCENE_GAME = 3, 498 SCENE_SPEECH = 4, 499 SCENE_RING = 5, 500 SCENE_VOIP_DOWN = 6, 501 SCENE_COLLABORATIVE = 7, 502 }; 503 504 /** 505 * Enumerates the audio enhance scene effect type. 506 */ 507 enum AudioEnhanceScene { 508 SCENE_VOIP_UP = 0, 509 SCENE_RECORD = 1, 510 SCENE_PRE_ENHANCE = 2, 511 SCENE_ASR = 4, 512 SCENE_VOICE_MESSAGE = 5, 513 SCENE_RECOGNITION = 6, 514 SCENE_NONE = 7, 515 }; 516 517 /** 518 * Enumerates the audio scene effct mode. 519 */ 520 enum AudioEffectMode { 521 EFFECT_NONE = 0, 522 EFFECT_DEFAULT = 1 523 }; 524 525 /** 526 * Enumerates the audio enhance scene effct mode. 527 */ 528 enum AudioEnhanceMode { 529 ENHANCE_NONE = 0, 530 ENHANCE_DEFAULT = 1 531 }; 532 533 struct AudioSceneEffectInfo { 534 std::vector<AudioEffectMode> mode; 535 }; 536 537 enum EffectFlag { RENDER_EFFECT_FLAG = 0, CAPTURE_EFFECT_FLAG = 1}; 538 539 struct AudioEffectPropertyV3 { 540 std::string name; 541 std::string category; 542 EffectFlag flag; 543 friend bool operator==(const AudioEffectPropertyV3 &lhs, const AudioEffectPropertyV3 &rhs) 544 { 545 return (lhs.category == rhs.category && lhs.name == rhs.name && lhs.flag == rhs.flag); 546 }; 547 friend bool operator<(const AudioEffectPropertyV3 &lhs, const AudioEffectPropertyV3 &rhs) 548 { 549 return ((lhs.name == rhs.name) || (lhs.name == rhs.name && lhs.category < rhs.category) 550 || (lhs.name == rhs.name && lhs.category == rhs.category && lhs.flag < rhs.flag)); 551 }; MarshallingAudioEffectPropertyV3552 bool Marshalling(Parcel &parcel) const 553 { 554 return parcel.WriteString(name)&& 555 parcel.WriteString(category)&& 556 parcel.WriteInt32(flag); 557 }; UnmarshallingSelfAudioEffectPropertyV3558 void UnmarshallingSelf(Parcel &parcel) 559 { 560 name = parcel.ReadString(); 561 category = parcel.ReadString(); 562 flag = static_cast<EffectFlag>(parcel.ReadInt32()); 563 }; 564 }; 565 566 struct AudioEffectPropertyArrayV3 : public Parcelable { 567 std::vector<AudioEffectPropertyV3> property; 568 MarshallingAudioEffectPropertyArrayV3569 bool Marshalling(Parcel &parcel) const override 570 { 571 int32_t size = static_cast<int32_t>(property.size()); 572 parcel.WriteInt32(size); 573 for (const auto &item : property) { 574 if (!item.Marshalling(parcel)) { 575 return false; 576 } 577 } 578 return true; 579 } 580 UnmarshallingAudioEffectPropertyArrayV3581 static AudioEffectPropertyArrayV3 *Unmarshalling(Parcel &parcel) 582 { 583 auto propertyArray = new(std::nothrow) AudioEffectPropertyArrayV3(); 584 if (propertyArray == nullptr) { 585 return nullptr; 586 } 587 588 int32_t size = parcel.ReadInt32(); 589 if (size < 0 || size > AUDIO_EFFECT_COUNT_UPPER_LIMIT) { 590 delete propertyArray; 591 return nullptr; 592 } 593 for (int32_t i = 0; i < size; i++) { 594 AudioEffectPropertyV3 property; 595 property.UnmarshallingSelf(parcel); 596 propertyArray->property.push_back(property); 597 } 598 return propertyArray; 599 } 600 }; 601 602 struct AudioEnhanceProperty { 603 std::string enhanceClass; 604 std::string enhanceProp; 605 friend bool operator==(const AudioEnhanceProperty &lhs, const AudioEnhanceProperty &rhs) 606 { 607 return lhs.enhanceClass == rhs.enhanceClass && lhs.enhanceProp == rhs.enhanceProp; 608 } MarshallingAudioEnhanceProperty609 bool Marshalling(Parcel &parcel) const 610 { 611 return parcel.WriteString(enhanceClass)&& 612 parcel.WriteString(enhanceProp); 613 } UnmarshallingSelfAudioEnhanceProperty614 void UnmarshallingSelf(Parcel &parcel) 615 { 616 enhanceClass = parcel.ReadString(); 617 enhanceProp = parcel.ReadString(); 618 } 619 }; 620 621 struct AudioEnhancePropertyArray : public Parcelable { 622 std::vector<AudioEnhanceProperty> property; 623 MarshallingAudioEnhancePropertyArray624 bool Marshalling(Parcel &parcel) const override 625 { 626 int32_t size = static_cast<int32_t>(property.size()); 627 parcel.WriteInt32(size); 628 for (const auto &item : property) { 629 if (!item.Marshalling(parcel)) { 630 return false; 631 } 632 } 633 return true; 634 } 635 UnmarshallingAudioEnhancePropertyArray636 static AudioEnhancePropertyArray *Unmarshalling(Parcel &parcel) 637 { 638 auto propertyArray = new(std::nothrow) AudioEnhancePropertyArray(); 639 if (propertyArray == nullptr) { 640 return nullptr; 641 } 642 643 int32_t size = parcel.ReadInt32(); 644 if (size < 0 || size > AUDIO_EFFECT_COUNT_UPPER_LIMIT) { 645 delete propertyArray; 646 return nullptr; 647 } 648 for (int32_t i = 0; i < size; i++) { 649 AudioEnhanceProperty property; 650 property.UnmarshallingSelf(parcel); 651 propertyArray->property.push_back(property); 652 } 653 return propertyArray; 654 } 655 }; 656 657 struct AudioEffectProperty { 658 std::string effectClass; 659 std::string effectProp; 660 friend bool operator==(const AudioEffectProperty &lhs, const AudioEffectProperty &rhs) 661 { 662 return lhs.effectClass == rhs.effectClass && lhs.effectProp == rhs.effectProp; 663 } MarshallingAudioEffectProperty664 bool Marshalling(Parcel &parcel) const 665 { 666 return parcel.WriteString(effectClass)&& 667 parcel.WriteString(effectProp); 668 } UnmarshallingSelfAudioEffectProperty669 void UnmarshallingSelf(Parcel &parcel) 670 { 671 effectClass = parcel.ReadString(); 672 effectProp = parcel.ReadString(); 673 } 674 }; 675 676 struct AudioEffectPropertyArray : public Parcelable { 677 std::vector<AudioEffectProperty> property; 678 MarshallingAudioEffectPropertyArray679 bool Marshalling(Parcel &parcel) const override 680 { 681 int32_t size = static_cast<int32_t>(property.size()); 682 parcel.WriteInt32(size); 683 for (const auto &item : property) { 684 if (!item.Marshalling(parcel)) { 685 return false; 686 } 687 } 688 return true; 689 } 690 UnmarshallingAudioEffectPropertyArray691 static AudioEffectPropertyArray *Unmarshalling(Parcel &parcel) 692 { 693 auto propertyArray = new(std::nothrow) AudioEffectPropertyArray(); 694 if (propertyArray == nullptr) { 695 return nullptr; 696 } 697 698 int32_t size = parcel.ReadInt32(); 699 if (size < 0 || size > AUDIO_EFFECT_COUNT_UPPER_LIMIT) { 700 delete propertyArray; 701 return nullptr; 702 } 703 for (int32_t i = 0; i < size; i++) { 704 AudioEffectProperty property; 705 property.UnmarshallingSelf(parcel); 706 propertyArray->property.push_back(property); 707 } 708 return propertyArray; 709 } 710 }; 711 712 enum AudioEffectChainSetParamIndex { 713 COMMAND_CODE_INDEX = 0, 714 SCENE_TYPE_INDEX = 1, 715 EFFECT_MODE_INDEX = 2, 716 ROTATION_INDEX = 3, 717 VOLUME_INDEX = 4, 718 EXTRA_SCENE_TYPE_INDEX = 5, 719 SPATIAL_DEVICE_TYPE_INDEX = 6, 720 SPATIALIZATION_SCENE_TYPE_INDEX = 7, 721 SPATIALIZATION_ENABLED_INDEX = 8, 722 STREAM_USAGE_INDEX = 9, 723 FOLD_STATE_INDEX = 10, 724 LID_STATE_INDEX = 11, 725 LOUDNESS_GAIN_INDEX = 12, 726 ABS_VOLUME_STATE = 13, 727 MAX_PARAM_INDEX, 728 }; 729 730 enum AudioEffectCommandCode { 731 EFFECT_CMD_INIT = 0, 732 EFFECT_CMD_SET_CONFIG = 1, 733 EFFECT_CMD_ENABLE = 2, 734 EFFECT_CMD_DISABLE = 3, 735 EFFECT_CMD_SET_PARAM = 4, 736 EFFECT_CMD_GET_PARAM = 5, 737 EFFECT_CMD_GET_CONFIG = 6, 738 EFFECT_CMD_SET_IMU = 7, 739 EFFECT_CMD_SET_PROPERTY = 8 740 }; 741 742 enum AudioEffectParamSetCode { 743 EFFECT_SET_BYPASS = 1, 744 EFFECT_SET_PARAM = 2, 745 }; 746 747 enum AudioDataFormat { 748 DATA_FORMAT_S16 = SAMPLE_S16LE, 749 DATA_FORMAT_S24 = SAMPLE_S24LE, 750 DATA_FORMAT_S32 = SAMPLE_S32LE, 751 DATA_FORMAT_F32 = SAMPLE_F32LE, 752 }; 753 754 struct AudioEffectParam { 755 int32_t status; 756 uint32_t paramSize; 757 uint32_t valueSize; 758 int32_t data[]; 759 }; 760 761 struct AudioBuffer { 762 size_t frameLength; 763 union { 764 void* raw; 765 float* f32; 766 int32_t* s32; 767 int16_t* s16; 768 uint8_t* u8; 769 }; 770 void *metaData = nullptr; 771 }; 772 773 struct AudioBufferConfig { 774 uint32_t samplingRate; 775 uint32_t channels; 776 uint8_t format; 777 uint64_t channelLayout; 778 AudioEncodingType encoding; 779 }; 780 781 struct AudioEffectConfig { 782 AudioBufferConfig inputCfg; 783 AudioBufferConfig outputCfg; 784 }; 785 786 struct AudioEffectTransInfo { 787 uint32_t size; 788 void *data; 789 }; 790 791 struct AudioEffectDescriptor { 792 std::string libraryName; 793 std::string effectName; 794 }; 795 796 typedef struct AudioEffectInterface **AudioEffectHandle; 797 798 struct AudioEffectInterface { 799 int32_t (*process) (AudioEffectHandle self, AudioBuffer *inBuffer, AudioBuffer *outBuffer); 800 int32_t (*command) (AudioEffectHandle self, uint32_t cmdCode, 801 AudioEffectTransInfo *cmdInfo, AudioEffectTransInfo *replyInfo); 802 }; 803 804 struct AudioEffectLibrary { 805 uint32_t version; 806 const char *name; 807 const char *implementor; 808 bool (*checkEffect) (const AudioEffectDescriptor descriptor); 809 int32_t (*createEffect) (const AudioEffectDescriptor descriptor, AudioEffectHandle *handle); 810 int32_t (*releaseEffect) (AudioEffectHandle handle); 811 }; 812 813 struct AudioEffectLibEntry { 814 AudioEffectLibrary *audioEffectLibHandle; 815 std::string libraryName; 816 std::vector<std::string> effectName; 817 }; 818 819 struct AudioSpatializationState : public Parcelable { 820 bool spatializationEnabled = false; 821 bool headTrackingEnabled = false; 822 823 AudioSpatializationState() = default; AudioSpatializationStateAudioSpatializationState824 AudioSpatializationState(bool spatializationEnabled, bool headTrackingEnabled) 825 { 826 this->spatializationEnabled = spatializationEnabled; 827 this->headTrackingEnabled = headTrackingEnabled; 828 } 829 MarshallingAudioSpatializationState830 bool Marshalling(Parcel &parcel) const override 831 { 832 return parcel.WriteBool(spatializationEnabled) 833 && parcel.WriteBool(headTrackingEnabled); 834 } 835 UnmarshallingAudioSpatializationState836 static AudioSpatializationState *Unmarshalling(Parcel &parcel) 837 { 838 auto info = new(std::nothrow) AudioSpatializationState(); 839 if (info == nullptr) { 840 return nullptr; 841 } 842 info->spatializationEnabled = parcel.ReadBool(); 843 info->headTrackingEnabled = parcel.ReadBool(); 844 return info; 845 } 846 }; 847 848 struct ConverterConfig : public Parcelable { 849 std::string version; 850 Library library; 851 uint64_t outChannelLayout = 0; 852 MarshallingConverterConfig853 bool Marshalling(Parcel &parcel) const override 854 { 855 return parcel.WriteString(version) && 856 library.Marshalling(parcel) && 857 parcel.WriteUint64(outChannelLayout); 858 } 859 UnmarshallingConverterConfig860 static ConverterConfig *Unmarshalling(Parcel &parcel) 861 { 862 auto config = new(std::nothrow) ConverterConfig(); 863 if (config == nullptr) { 864 return nullptr; 865 } 866 config->version = parcel.ReadString(); 867 config->library.UnmarshallingSelf(parcel); 868 config->outChannelLayout = parcel.ReadUint64(); 869 return config; 870 } 871 }; 872 873 enum AudioSpatializationSceneType { 874 SPATIALIZATION_SCENE_TYPE_DEFAULT = 0, 875 SPATIALIZATION_SCENE_TYPE_MUSIC = 1, 876 SPATIALIZATION_SCENE_TYPE_MOVIE = 2, 877 SPATIALIZATION_SCENE_TYPE_AUDIOBOOK = 3, 878 SPATIALIZATION_SCENE_TYPE_MAX = SPATIALIZATION_SCENE_TYPE_AUDIOBOOK, 879 }; 880 881 struct AudioRendererInfoForSpatialization { 882 RendererState rendererState; 883 std::string deviceMacAddress; 884 StreamUsage streamUsage; 885 }; 886 887 struct AudioEnhanceParam { 888 uint32_t muteInfo; 889 uint32_t volumeInfo; 890 uint32_t foldState; 891 const char *preDevice; 892 const char *postDevice; 893 const char *sceneType; 894 const char *preDeviceName; 895 }; 896 897 struct AlgoConfig { 898 uint32_t frameLength; 899 uint32_t sampleRate; 900 uint32_t dataFormat; 901 uint32_t micNum; 902 uint32_t ecNum; 903 uint32_t micRefNum; 904 uint32_t outNum; 905 }; 906 907 enum ProcessClusterOperation { 908 NO_NEED_TO_CREATE_PROCESSCLUSTER, 909 CREATE_NEW_PROCESSCLUSTER, 910 CREATE_DEFAULT_PROCESSCLUSTER, 911 USE_DEFAULT_PROCESSCLUSTER, 912 USE_NONE_PROCESSCLUSTER, 913 CREATE_EXTRA_PROCESSCLUSTER 914 }; 915 } // namespace AudioStandard 916 } // namespace OHOS 917 918 #endif // AUDIO_FRAMEWORK_AUDIO_EFFECT_H