1 /* 2 * Copyright (c) 2021-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 #ifndef AUDIO_INFO_H 16 #define AUDIO_INFO_H 17 18 #ifdef __MUSL__ 19 #include <stdint.h> 20 #endif // __MUSL__ 21 22 #include <cmath> 23 #include <limits> 24 #include <string> 25 #include <vector> 26 #include <array> 27 #include <unistd.h> 28 #include <unordered_map> 29 #include <parcel.h> 30 #include <audio_source_type.h> 31 #include <audio_device_info.h> 32 #include <audio_interrupt_info.h> 33 #include <audio_session_info.h> 34 #include <audio_stream_info.h> 35 #include <audio_asr.h> 36 37 namespace OHOS { 38 namespace AudioStandard { 39 constexpr int32_t MAX_NUM_STREAMS = 3; 40 constexpr int32_t RENDERER_STREAM_USAGE_SHIFT = 16; 41 constexpr int32_t MINIMUM_BUFFER_SIZE_MSEC = 5; 42 constexpr int32_t MAXIMUM_BUFFER_SIZE_MSEC = 20; 43 constexpr int32_t MIN_SERVICE_COUNT = 2; 44 constexpr int32_t ROOT_UID = 0; 45 constexpr int32_t INVALID_UID = -1; 46 constexpr int32_t INTELL_VOICE_SERVICR_UID = 1042; 47 constexpr int32_t RSS_UID = 1096; 48 constexpr int32_t NETWORK_ID_SIZE = 80; 49 constexpr int32_t DEFAULT_VOLUME_GROUP_ID = 1; 50 constexpr int32_t DEFAULT_VOLUME_INTERRUPT_ID = 1; 51 constexpr int32_t AUDIO_FLAG_INVALID = -1; 52 constexpr int32_t AUDIO_FLAG_NORMAL = 0; 53 constexpr int32_t AUDIO_FLAG_MMAP = 1; 54 constexpr int32_t AUDIO_FLAG_VOIP_FAST = 2; 55 constexpr int32_t AUDIO_FLAG_DIRECT = 3; 56 constexpr int32_t AUDIO_FLAG_VOIP_DIRECT = 4; 57 constexpr int32_t AUDIO_FLAG_FORCED_NORMAL = 10; 58 constexpr int32_t AUDIO_USAGE_NORMAL = 0; 59 constexpr int32_t AUDIO_USAGE_VOIP = 1; 60 constexpr uint32_t STREAM_FLAG_NORMAL = 0; 61 constexpr uint32_t STREAM_FLAG_FAST = 1; 62 constexpr uint32_t STREAM_FLAG_DIRECT = 2; 63 constexpr float MAX_STREAM_SPEED_LEVEL = 4.0f; 64 constexpr float MIN_STREAM_SPEED_LEVEL = 0.125f; 65 constexpr int32_t EMPTY_UID = 0; 66 constexpr int32_t AUDIO_NORMAL_MANAGER_TYPE = 0; 67 constexpr int32_t AUDIO_DIRECT_MANAGER_TYPE = 2; 68 69 constexpr uint32_t MIN_SESSIONID = 100000; 70 constexpr uint32_t MAX_SESSIONID = UINT32_MAX - MIN_SESSIONID; 71 72 const float MIN_FLOAT_VOLUME = 0.0f; 73 const float MAX_FLOAT_VOLUME = 1.0f; 74 75 const std::string MICROPHONE_PERMISSION = "ohos.permission.MICROPHONE"; 76 const std::string MANAGE_INTELLIGENT_VOICE_PERMISSION = "ohos.permission.MANAGE_INTELLIGENT_VOICE"; 77 const std::string MANAGE_AUDIO_CONFIG = "ohos.permission.MANAGE_AUDIO_CONFIG"; 78 const std::string MICROPHONE_CONTROL_PERMISSION = "ohos.permission.MICROPHONE_CONTROL"; 79 const std::string MODIFY_AUDIO_SETTINGS_PERMISSION = "ohos.permission.MODIFY_AUDIO_SETTINGS"; 80 const std::string ACCESS_NOTIFICATION_POLICY_PERMISSION = "ohos.permission.ACCESS_NOTIFICATION_POLICY"; 81 const std::string USE_BLUETOOTH_PERMISSION = "ohos.permission.USE_BLUETOOTH"; 82 const std::string CAPTURER_VOICE_DOWNLINK_PERMISSION = "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO"; 83 const std::string RECORD_VOICE_CALL_PERMISSION = "ohos.permission.RECORD_VOICE_CALL"; 84 const std::string MANAGE_SYSTEM_AUDIO_EFFECTS = "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS"; 85 const std::string CAST_AUDIO_OUTPUT_PERMISSION = "ohos.permission.CAST_AUDIO_OUTPUT"; 86 const std::string DUMP_AUDIO_PERMISSION = "ohos.permission.DUMP_AUDIO"; 87 const std::string CAPTURE_PLAYBACK_PERMISSION = "ohos.permission.CAPTURE_PLAYBACK"; 88 89 constexpr std::string_view PRIMARY_WAKEUP = "Built_in_wakeup"; 90 constexpr std::string_view VOICE_CALL_REC_NAME = "Voice_call_rec"; 91 92 const std::string INNER_CAPTURER_SOURCE = "Speaker.monitor"; 93 const std::string INNER_CAPTURER_SINK = "InnerCapturerSink"; 94 const std::string NEW_INNER_CAPTURER_SOURCE = "InnerCapturerSink.monitor"; 95 const std::string REMOTE_CAST_INNER_CAPTURER_SINK_NAME = "RemoteCastInnerCapturer"; 96 const std::string MONITOR_SOURCE_SUFFIX = ".monitor"; 97 const std::string DUP_STREAM = "DupStream"; 98 const std::string DUAL_TONE_STREAM = "DualToneStream"; 99 const std::string NORMAL_STREAM = "NormalStream"; 100 101 #ifdef FEATURE_DTMF_TONE 102 // Maximun number of sine waves in a tone segment 103 constexpr uint32_t TONEINFO_MAX_WAVES = 3; 104 105 // Maximun number of segments in a tone descriptor 106 constexpr uint32_t TONEINFO_MAX_SEGMENTS = 12; 107 constexpr uint32_t TONEINFO_INF = 0xFFFFFFFF; 108 class ToneSegment : public Parcelable { 109 public: 110 uint32_t duration; 111 uint16_t waveFreq[TONEINFO_MAX_WAVES+1]; 112 uint16_t loopCnt; 113 uint16_t loopIndx; Marshalling(Parcel & parcel)114 bool Marshalling(Parcel &parcel) const override 115 { 116 parcel.WriteUint32(duration); 117 parcel.WriteUint16(loopCnt); 118 parcel.WriteUint16(loopIndx); 119 for (uint32_t i = 0; i < TONEINFO_MAX_WAVES + 1; i++) { 120 parcel.WriteUint16(waveFreq[i]); 121 } 122 return true; 123 } Unmarshalling(Parcel & parcel)124 void Unmarshalling(Parcel &parcel) 125 { 126 duration = parcel.ReadUint32(); 127 loopCnt = parcel.ReadUint16(); 128 loopIndx = parcel.ReadUint16(); 129 for (uint32_t i = 0; i < TONEINFO_MAX_WAVES + 1; i++) { 130 waveFreq[i] = parcel.ReadUint16(); 131 } 132 } 133 }; 134 135 class ToneInfo : public Parcelable { 136 public: 137 ToneSegment segments[TONEINFO_MAX_SEGMENTS+1]; 138 uint32_t segmentCnt; 139 uint32_t repeatCnt; 140 uint32_t repeatSegment; Marshalling(Parcel & parcel)141 bool Marshalling(Parcel &parcel) const override 142 { 143 parcel.WriteUint32(segmentCnt); 144 parcel.WriteUint32(repeatCnt); 145 parcel.WriteUint32(repeatSegment); 146 if (!(segmentCnt >= 0 && segmentCnt <= TONEINFO_MAX_SEGMENTS + 1)) { 147 return false; 148 } 149 for (uint32_t i = 0; i < segmentCnt; i++) { 150 segments[i].Marshalling(parcel); 151 } 152 return true; 153 } Unmarshalling(Parcel & parcel)154 void Unmarshalling(Parcel &parcel) 155 { 156 segmentCnt = parcel.ReadUint32(); 157 repeatCnt = parcel.ReadUint32(); 158 repeatSegment = parcel.ReadUint32(); 159 if (!(segmentCnt >= 0 && segmentCnt <= TONEINFO_MAX_SEGMENTS + 1)) { 160 return; 161 } 162 for (uint32_t i = 0; i < segmentCnt; i++) { 163 segments[i].Unmarshalling(parcel); 164 } 165 } 166 }; 167 #endif 168 169 enum VolumeAdjustType { 170 /** 171 * Adjust volume up 172 */ 173 VOLUME_UP = 0, 174 /** 175 * Adjust volume down 176 */ 177 VOLUME_DOWN = 1, 178 }; 179 180 enum ChannelBlendMode { 181 /** 182 * No channel process. 183 */ 184 MODE_DEFAULT = 0, 185 /** 186 * Blend left and right channel. 187 */ 188 MODE_BLEND_LR = 1, 189 /** 190 * Replicate left to right channel. 191 */ 192 MODE_ALL_LEFT = 2, 193 /** 194 * Replicate right to left channel. 195 */ 196 MODE_ALL_RIGHT = 3, 197 }; 198 199 enum ConnectType { 200 /** 201 * Group connect type of local device 202 */ 203 CONNECT_TYPE_LOCAL = 0, 204 /** 205 * Group connect type of distributed device 206 */ 207 CONNECT_TYPE_DISTRIBUTED 208 }; 209 210 typedef AudioStreamType AudioVolumeType; 211 212 enum VolumeFlag { 213 /** 214 * Show system volume bar 215 */ 216 FLAG_SHOW_SYSTEM_UI = 1, 217 }; 218 219 enum AudioOffloadType { 220 /** 221 * Indicates audio offload state default. 222 */ 223 OFFLOAD_DEFAULT = -1, 224 /** 225 * Indicates audio offload state : screen is active & app is foreground. 226 */ 227 OFFLOAD_ACTIVE_FOREGROUND = 0, 228 /** 229 * Indicates audio offload state : screen is active & app is background. 230 */ 231 OFFLOAD_ACTIVE_BACKGROUND = 1, 232 /** 233 * Indicates audio offload state : screen is inactive & app is background. 234 */ 235 OFFLOAD_INACTIVE_BACKGROUND = 3, 236 }; 237 238 enum FocusType { 239 /** 240 * Recording type. 241 */ 242 FOCUS_TYPE_RECORDING = 0, 243 }; 244 245 enum AudioErrors { 246 /** 247 * Common errors. 248 */ 249 ERROR_INVALID_PARAM = 6800101, 250 ERROR_NO_MEMORY = 6800102, 251 ERROR_ILLEGAL_STATE = 6800103, 252 ERROR_UNSUPPORTED = 6800104, 253 ERROR_TIMEOUT = 6800105, 254 /** 255 * Audio specific errors. 256 */ 257 ERROR_STREAM_LIMIT = 6800201, 258 /** 259 * Default error. 260 */ 261 ERROR_SYSTEM = 6800301 262 }; 263 264 // Ringer Mode 265 enum AudioRingerMode { 266 RINGER_MODE_SILENT = 0, 267 RINGER_MODE_VIBRATE = 1, 268 RINGER_MODE_NORMAL = 2 269 }; 270 271 /** 272 * Enumerates audio stream privacy type for playback capture. 273 */ 274 enum AudioPrivacyType { 275 PRIVACY_TYPE_PUBLIC = 0, 276 PRIVACY_TYPE_PRIVATE = 1 277 }; 278 279 /** 280 * Enumerates the renderer playback speed. 281 */ 282 enum AudioRendererRate { 283 RENDER_RATE_NORMAL = 0, 284 RENDER_RATE_DOUBLE = 1, 285 RENDER_RATE_HALF = 2, 286 }; 287 288 /** 289 * media safe volume status 290 */ 291 enum SafeStatus : int32_t { 292 SAFE_UNKNOWN = -1, 293 SAFE_INACTIVE = 0, 294 SAFE_ACTIVE = 1, 295 }; 296 297 enum CallbackChange : int32_t { 298 CALLBACK_UNKNOWN = 0, 299 CALLBACK_FOCUS_INFO_CHANGE, 300 CALLBACK_RENDERER_STATE_CHANGE, 301 CALLBACK_CAPTURER_STATE_CHANGE, 302 CALLBACK_MICMUTE_STATE_CHANGE, 303 CALLBACK_AUDIO_SESSION, 304 CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE, 305 CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE, 306 CALLBACK_SET_VOLUME_KEY_EVENT, 307 CALLBACK_SET_DEVICE_CHANGE, 308 CALLBACK_SET_RINGER_MODE, 309 CALLBACK_SET_MIC_STATE_CHANGE, 310 CALLBACK_SPATIALIZATION_ENABLED_CHANGE, 311 CALLBACK_HEAD_TRACKING_ENABLED_CHANGE, 312 CALLBACK_SET_MICROPHONE_BLOCKED, 313 CALLBACK_DEVICE_CHANGE_WITH_INFO, 314 CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE, 315 CALLBACK_MAX, 316 }; 317 318 constexpr CallbackChange CALLBACK_ENUMS[] = { 319 CALLBACK_UNKNOWN, 320 CALLBACK_FOCUS_INFO_CHANGE, 321 CALLBACK_RENDERER_STATE_CHANGE, 322 CALLBACK_CAPTURER_STATE_CHANGE, 323 CALLBACK_MICMUTE_STATE_CHANGE, 324 CALLBACK_AUDIO_SESSION, 325 CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE, 326 CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE, 327 CALLBACK_SET_VOLUME_KEY_EVENT, 328 CALLBACK_SET_DEVICE_CHANGE, 329 CALLBACK_SET_RINGER_MODE, 330 CALLBACK_SET_MIC_STATE_CHANGE, 331 CALLBACK_SPATIALIZATION_ENABLED_CHANGE, 332 CALLBACK_HEAD_TRACKING_ENABLED_CHANGE, 333 CALLBACK_SET_MICROPHONE_BLOCKED, 334 CALLBACK_DEVICE_CHANGE_WITH_INFO, 335 CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE, 336 }; 337 338 static_assert((sizeof(CALLBACK_ENUMS) / sizeof(CallbackChange)) == static_cast<size_t>(CALLBACK_MAX), 339 "check CALLBACK_ENUMS"); 340 341 struct VolumeEvent { 342 AudioVolumeType volumeType; 343 int32_t volume; 344 bool updateUi; 345 int32_t volumeGroupId; 346 std::string networkId; 347 }; 348 349 struct AudioParameters { 350 AudioSampleFormat format; 351 AudioChannel channels; 352 AudioSamplingRate samplingRate; 353 AudioEncodingType encoding; 354 ContentType contentType; 355 StreamUsage usage; 356 DeviceRole deviceRole; 357 DeviceType deviceType; 358 }; 359 360 struct A2dpDeviceConfigInfo { 361 DeviceStreamInfo streamInfo; 362 bool absVolumeSupport = false; 363 int32_t volumeLevel; 364 bool mute = false; 365 }; 366 367 struct AudioRendererInfo { 368 ContentType contentType = CONTENT_TYPE_UNKNOWN; 369 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN; 370 int32_t rendererFlags = AUDIO_FLAG_NORMAL; 371 std::string sceneType = ""; 372 bool spatializationEnabled = false; 373 bool headTrackingEnabled = false; 374 int32_t originalFlag = AUDIO_FLAG_NORMAL; 375 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; 376 AudioSamplingRate samplingRate = SAMPLE_RATE_8000; 377 AudioSampleFormat format = SAMPLE_S16LE; 378 uint8_t encodingType = 0; 379 uint64_t channelLayout = 0ULL; 380 bool isOffloadAllowed = true; 381 MarshallingAudioRendererInfo382 bool Marshalling(Parcel &parcel) const 383 { 384 return parcel.WriteInt32(static_cast<int32_t>(contentType)) 385 && parcel.WriteInt32(static_cast<int32_t>(streamUsage)) 386 && parcel.WriteInt32(rendererFlags) 387 && parcel.WriteInt32(originalFlag) 388 && parcel.WriteString(sceneType) 389 && parcel.WriteBool(spatializationEnabled) 390 && parcel.WriteBool(headTrackingEnabled) 391 && parcel.WriteInt32(static_cast<int32_t>(pipeType)) 392 && parcel.WriteInt32(static_cast<int32_t>(samplingRate)) 393 && parcel.WriteInt32(format) 394 && parcel.WriteUint8(encodingType) 395 && parcel.WriteUint64(channelLayout) 396 && parcel.WriteBool(isOffloadAllowed); 397 } UnmarshallingAudioRendererInfo398 void Unmarshalling(Parcel &parcel) 399 { 400 contentType = static_cast<ContentType>(parcel.ReadInt32()); 401 streamUsage = static_cast<StreamUsage>(parcel.ReadInt32()); 402 rendererFlags = parcel.ReadInt32(); 403 originalFlag = parcel.ReadInt32(); 404 sceneType = parcel.ReadString(); 405 spatializationEnabled = parcel.ReadBool(); 406 headTrackingEnabled = parcel.ReadBool(); 407 pipeType = static_cast<AudioPipeType>(parcel.ReadInt32()); 408 samplingRate = static_cast<AudioSamplingRate>(parcel.ReadInt32()); 409 format = static_cast<AudioSampleFormat>(parcel.ReadInt32()); 410 encodingType = parcel.ReadUint8(); 411 channelLayout = parcel.ReadUint64(); 412 isOffloadAllowed = parcel.ReadBool(); 413 } 414 }; 415 416 class AudioCapturerInfo { 417 public: 418 SourceType sourceType = SOURCE_TYPE_INVALID; 419 int32_t capturerFlags = 0; 420 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN; 421 AudioSamplingRate samplingRate = SAMPLE_RATE_8000; 422 uint8_t encodingType = 0; 423 uint64_t channelLayout = 0ULL; 424 std::string sceneType = ""; 425 int32_t originalFlag = AUDIO_FLAG_NORMAL; AudioCapturerInfo(SourceType sourceType_,int32_t capturerFlags_)426 AudioCapturerInfo(SourceType sourceType_, int32_t capturerFlags_) : sourceType(sourceType_), 427 capturerFlags(capturerFlags_) {} AudioCapturerInfo(const AudioCapturerInfo & audioCapturerInfo)428 AudioCapturerInfo(const AudioCapturerInfo &audioCapturerInfo) 429 { 430 *this = audioCapturerInfo; 431 } 432 AudioCapturerInfo() = default; 433 ~AudioCapturerInfo()= default; Marshalling(Parcel & parcel)434 bool Marshalling(Parcel &parcel) const 435 { 436 return parcel.WriteInt32(static_cast<int32_t>(sourceType)) 437 && parcel.WriteInt32(capturerFlags) 438 && parcel.WriteInt32(static_cast<int32_t>(pipeType)) 439 && parcel.WriteInt32(static_cast<int32_t>(samplingRate)) 440 && parcel.WriteUint8(encodingType) 441 && parcel.WriteUint64(channelLayout) 442 && parcel.WriteString(sceneType) 443 && parcel.WriteInt32(originalFlag); 444 } Unmarshalling(Parcel & parcel)445 void Unmarshalling(Parcel &parcel) 446 { 447 sourceType = static_cast<SourceType>(parcel.ReadInt32()); 448 capturerFlags = parcel.ReadInt32(); 449 pipeType = static_cast<AudioPipeType>(parcel.ReadInt32()); 450 samplingRate = static_cast<AudioSamplingRate>(parcel.ReadInt32()); 451 encodingType = parcel.ReadUint8(); 452 channelLayout = parcel.ReadUint64(); 453 sceneType = parcel.ReadString(); 454 originalFlag = parcel.ReadInt32(); 455 } 456 }; 457 458 struct AudioRendererDesc { 459 ContentType contentType = CONTENT_TYPE_UNKNOWN; 460 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN; 461 }; 462 463 struct AudioRendererOptions { 464 AudioStreamInfo streamInfo; 465 AudioRendererInfo rendererInfo; 466 AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC; 467 AudioSessionStrategy strategy = { AudioConcurrencyMode::INVALID }; 468 }; 469 470 struct MicStateChangeEvent { 471 bool mute; 472 }; 473 474 enum AudioScene : int32_t { 475 /** 476 * Invalid 477 */ 478 AUDIO_SCENE_INVALID = -1, 479 /** 480 * Default audio scene 481 */ 482 AUDIO_SCENE_DEFAULT, 483 /** 484 * Ringing audio scene 485 * Only available for system api. 486 */ 487 AUDIO_SCENE_RINGING, 488 /** 489 * Phone call audio scene 490 * Only available for system api. 491 */ 492 AUDIO_SCENE_PHONE_CALL, 493 /** 494 * Voice chat audio scene 495 */ 496 AUDIO_SCENE_PHONE_CHAT, 497 /** 498 * AvSession set call start flag 499 */ 500 AUDIO_SCENE_CALL_START, 501 /** 502 * AvSession set call end flag 503 */ 504 AUDIO_SCENE_CALL_END, 505 /** 506 * Voice ringing audio scene 507 * Only available for system api. 508 */ 509 AUDIO_SCENE_VOICE_RINGING, 510 /** 511 * Max 512 */ 513 AUDIO_SCENE_MAX, 514 }; 515 516 enum AudioDeviceUsage : uint32_t { 517 /** 518 * Media output devices. 519 * @syscap SystemCapability.Multimedia.Audio.Device 520 * @systemapi 521 * @since 11 522 */ 523 MEDIA_OUTPUT_DEVICES = 1, 524 /** 525 * Media input devices. 526 * @syscap SystemCapability.Multimedia.Audio.Device 527 * @systemapi 528 * @since 11 529 */ 530 MEDIA_INPUT_DEVICES = 2, 531 /** 532 * All media devices. 533 * @syscap SystemCapability.Multimedia.Audio.Device 534 * @systemapi 535 * @since 11 536 */ 537 ALL_MEDIA_DEVICES = 3, 538 /** 539 * Call output devices. 540 * @syscap SystemCapability.Multimedia.Audio.Device 541 * @systemapi 542 * @since 11 543 */ 544 CALL_OUTPUT_DEVICES = 4, 545 /** 546 * Call input devices. 547 * @syscap SystemCapability.Multimedia.Audio.Device 548 * @systemapi 549 * @since 11 550 */ 551 CALL_INPUT_DEVICES = 8, 552 /** 553 * All call devices. 554 * @syscap SystemCapability.Multimedia.Audio.Device 555 * @systemapi 556 * @since 11 557 */ 558 ALL_CALL_DEVICES = 12, 559 /** 560 * All devices. 561 * @syscap SystemCapability.Multimedia.Audio.Device 562 * @systemapi 563 * @since 11 564 */ 565 D_ALL_DEVICES = 15, 566 }; 567 568 enum FilterMode : uint32_t { 569 INCLUDE = 0, 570 EXCLUDE, 571 MAX_FILTER_MODE 572 }; 573 574 // 1.If the size of usages or pids is 0, FilterMode will not work. 575 // 2.Filters will only works with FileterMode INCLUDE or EXCLUDE while the vector size is not zero. 576 // 3.If usages and pids are both not empty, the result is the intersection of the two Filter. 577 // 4.If usages.size() == 0, defalut usages will be filtered with FilterMode::INCLUDE. 578 // 5.Default usages are MEDIA MUSIC MOVIE GAME and BOOK. 579 struct CaptureFilterOptions { 580 std::vector<StreamUsage> usages; 581 FilterMode usageFilterMode {FilterMode::INCLUDE}; 582 std::vector<int32_t> pids; 583 FilterMode pidFilterMode {FilterMode::INCLUDE}; 584 }; 585 586 struct AudioPlaybackCaptureConfig { 587 CaptureFilterOptions filterOptions; 588 bool silentCapture {false}; // To be deprecated since 12 589 }; 590 591 struct AudioCapturerOptions { 592 AudioStreamInfo streamInfo; 593 AudioCapturerInfo capturerInfo; 594 AudioPlaybackCaptureConfig playbackCaptureConfig; 595 AudioSessionStrategy strategy = { AudioConcurrencyMode::INVALID }; 596 }; 597 598 struct AppInfo { 599 int32_t appUid { INVALID_UID }; 600 uint32_t appTokenId { 0 }; 601 int32_t appPid { 0 }; 602 uint64_t appFullTokenId { 0 }; 603 }; 604 605 struct BufferQueueState { 606 uint32_t numBuffers; 607 uint32_t currentIndex; 608 }; 609 610 enum AudioRenderMode { 611 RENDER_MODE_NORMAL, 612 RENDER_MODE_CALLBACK 613 }; 614 615 enum AudioCaptureMode { 616 CAPTURE_MODE_NORMAL, 617 CAPTURE_MODE_CALLBACK 618 }; 619 620 struct SinkInfo { 621 uint32_t sinkId; // sink id 622 std::string sinkName; 623 std::string adapterName; 624 }; 625 626 struct SinkInput { 627 int32_t streamId; 628 AudioStreamType streamType; 629 630 // add for routing stream. 631 int32_t uid; // client uid 632 int32_t pid; // client pid 633 uint32_t paStreamId; // streamId 634 uint32_t deviceSinkId; // sink id 635 std::string sinkName; // sink name 636 int32_t statusMark; // mark the router status 637 uint64_t startTime; // when this router is created 638 }; 639 640 struct SourceOutput { 641 int32_t streamId; 642 AudioStreamType streamType; 643 644 // add for routing stream. 645 int32_t uid; // client uid 646 int32_t pid; // client pid 647 uint32_t paStreamId; // streamId 648 uint32_t deviceSourceId; // sink id 649 int32_t statusMark; // mark the router status 650 uint64_t startTime; // when this router is created 651 }; 652 653 typedef uint32_t AudioIOHandle; 654 FLOAT_COMPARE_EQ(const float & x,const float & y)655 static inline bool FLOAT_COMPARE_EQ(const float& x, const float& y) 656 { 657 return (std::abs((x) - (y)) <= (std::numeric_limits<float>::epsilon())); 658 } 659 660 enum AudioServiceIndex { 661 HDI_SERVICE_INDEX = 0, 662 AUDIO_SERVICE_INDEX 663 }; 664 665 /** 666 * @brief Enumerates the rendering states of the current device. 667 */ 668 enum RendererState { 669 /** INVALID state */ 670 RENDERER_INVALID = -1, 671 /** Create New Renderer instance */ 672 RENDERER_NEW, 673 /** Reneder Prepared state */ 674 RENDERER_PREPARED, 675 /** Rendere Running state */ 676 RENDERER_RUNNING, 677 /** Renderer Stopped state */ 678 RENDERER_STOPPED, 679 /** Renderer Released state */ 680 RENDERER_RELEASED, 681 /** Renderer Paused state */ 682 RENDERER_PAUSED 683 }; 684 685 /** 686 * @brief Enumerates the capturing states of the current device. 687 */ 688 enum CapturerState { 689 /** Capturer INVALID state */ 690 CAPTURER_INVALID = -1, 691 /** Create new capturer instance */ 692 CAPTURER_NEW, 693 /** Capturer Prepared state */ 694 CAPTURER_PREPARED, 695 /** Capturer Running state */ 696 CAPTURER_RUNNING, 697 /** Capturer Stopped state */ 698 CAPTURER_STOPPED, 699 /** Capturer Released state */ 700 CAPTURER_RELEASED, 701 /** Capturer Paused state */ 702 CAPTURER_PAUSED 703 }; 704 705 enum State { 706 /** INVALID */ 707 INVALID = -1, 708 /** New */ 709 NEW, 710 /** Prepared */ 711 PREPARED, 712 /** Running */ 713 RUNNING, 714 /** Stopped */ 715 STOPPED, 716 /** Released */ 717 RELEASED, 718 /** Paused */ 719 PAUSED, 720 /** Stopping */ 721 STOPPING 722 }; 723 724 struct AudioRegisterTrackerInfo { 725 uint32_t sessionId; 726 int32_t clientPid; 727 State state; 728 AudioRendererInfo rendererInfo; 729 AudioCapturerInfo capturerInfo; 730 int32_t channelCount; 731 uint32_t appTokenId; 732 }; 733 734 enum StateChangeCmdType { 735 CMD_FROM_CLIENT = 0, 736 CMD_FROM_SYSTEM = 1 737 }; 738 739 enum AudioMode { 740 AUDIO_MODE_PLAYBACK, 741 AUDIO_MODE_RECORD 742 }; 743 744 // LEGACY_INNER_CAP: Called from hap build with api < 12, work normally. 745 // LEGACY_MUTE_CAP: Called from hap build with api >= 12, will cap mute data. 746 // MODERN_INNER_CAP: Called from SA with inner-cap right, work with filter. 747 enum InnerCapMode : uint32_t { 748 LEGACY_INNER_CAP = 0, 749 LEGACY_MUTE_CAP, 750 MODERN_INNER_CAP, 751 INVALID_CAP_MODE 752 }; 753 754 struct AudioProcessConfig { 755 int32_t callerUid = INVALID_UID; 756 757 AppInfo appInfo; 758 759 AudioStreamInfo streamInfo; 760 761 AudioMode audioMode = AUDIO_MODE_PLAYBACK; 762 763 AudioRendererInfo rendererInfo; 764 765 AudioCapturerInfo capturerInfo; 766 767 AudioStreamType streamType = STREAM_DEFAULT; 768 769 DeviceType deviceType = DEVICE_TYPE_INVALID; 770 771 bool isInnerCapturer = false; 772 773 bool isWakeupCapturer = false; 774 775 uint32_t originalSessionId = 0; 776 777 AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC; 778 779 InnerCapMode innerCapMode {InnerCapMode::INVALID_CAP_MODE}; 780 }; 781 782 struct Volume { 783 bool isMute = false; 784 float volumeFloat = 1.0f; 785 uint32_t volumeInt = 0; 786 }; 787 788 enum StreamSetState { 789 STREAM_PAUSE, 790 STREAM_RESUME 791 }; 792 793 struct StreamSetStateEventInternal { 794 StreamSetState streamSetState; 795 StreamUsage streamUsage; 796 }; 797 798 class AudioRendererChangeInfo { 799 public: 800 int32_t createrUID; 801 int32_t clientUID; 802 int32_t sessionId; 803 int32_t callerPid; 804 int32_t clientPid; 805 int32_t tokenId; 806 int32_t channelCount; 807 AudioRendererInfo rendererInfo; 808 RendererState rendererState; 809 DeviceInfo outputDeviceInfo; 810 bool prerunningState = false; 811 AudioRendererChangeInfo(const AudioRendererChangeInfo & audioRendererChangeInfo)812 AudioRendererChangeInfo(const AudioRendererChangeInfo &audioRendererChangeInfo) 813 { 814 *this = audioRendererChangeInfo; 815 } 816 AudioRendererChangeInfo() = default; 817 ~AudioRendererChangeInfo() = default; Marshalling(Parcel & parcel)818 bool Marshalling(Parcel &parcel) const 819 { 820 return parcel.WriteInt32(createrUID) 821 && parcel.WriteInt32(clientUID) 822 && parcel.WriteInt32(sessionId) 823 && parcel.WriteInt32(callerPid) 824 && parcel.WriteInt32(clientPid) 825 && parcel.WriteInt32(tokenId) 826 && parcel.WriteInt32(channelCount) 827 && rendererInfo.Marshalling(parcel) 828 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType)) 829 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage)) 830 && parcel.WriteInt32(rendererInfo.rendererFlags) 831 && parcel.WriteInt32(rendererInfo.originalFlag) 832 && parcel.WriteInt32(rendererInfo.samplingRate) 833 && parcel.WriteInt32(rendererInfo.format) 834 && parcel.WriteInt32(static_cast<int32_t>(rendererState)) 835 && outputDeviceInfo.Marshalling(parcel); 836 } Marshalling(Parcel & parcel,bool hasBTPermission,bool hasSystemPermission,int32_t apiVersion)837 bool Marshalling(Parcel &parcel, bool hasBTPermission, bool hasSystemPermission, int32_t apiVersion) const 838 { 839 return parcel.WriteInt32(createrUID) 840 && parcel.WriteInt32(hasSystemPermission ? clientUID : EMPTY_UID) 841 && parcel.WriteInt32(sessionId) 842 && parcel.WriteInt32(callerPid) 843 && parcel.WriteInt32(clientPid) 844 && parcel.WriteInt32(tokenId) 845 && parcel.WriteInt32(channelCount) 846 && rendererInfo.Marshalling(parcel) 847 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType)) 848 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage)) 849 && parcel.WriteInt32(rendererInfo.rendererFlags) 850 && parcel.WriteInt32(rendererInfo.originalFlag) 851 && parcel.WriteInt32(rendererInfo.samplingRate) 852 && parcel.WriteInt32(rendererInfo.format) 853 && parcel.WriteInt32(hasSystemPermission ? static_cast<int32_t>(rendererState) : 854 RENDERER_INVALID) 855 && outputDeviceInfo.Marshalling(parcel, hasBTPermission, hasSystemPermission, apiVersion); 856 } Unmarshalling(Parcel & parcel)857 void Unmarshalling(Parcel &parcel) 858 { 859 createrUID = parcel.ReadInt32(); 860 clientUID = parcel.ReadInt32(); 861 sessionId = parcel.ReadInt32(); 862 callerPid = parcel.ReadInt32(); 863 clientPid = parcel.ReadInt32(); 864 tokenId = parcel.ReadInt32(); 865 channelCount = parcel.ReadInt32(); 866 867 rendererInfo.Unmarshalling(parcel); 868 869 rendererInfo.contentType = static_cast<ContentType>(parcel.ReadInt32()); 870 rendererInfo.streamUsage = static_cast<StreamUsage>(parcel.ReadInt32()); 871 rendererInfo.rendererFlags = parcel.ReadInt32(); 872 rendererInfo.originalFlag = parcel.ReadInt32(); 873 rendererInfo.samplingRate = static_cast<AudioSamplingRate>(parcel.ReadInt32()); 874 rendererInfo.format = static_cast<AudioSampleFormat>(parcel.ReadInt32()); 875 876 rendererState = static_cast<RendererState>(parcel.ReadInt32()); 877 outputDeviceInfo.Unmarshalling(parcel); 878 } 879 }; 880 881 class AudioCapturerChangeInfo { 882 public: 883 int32_t createrUID; 884 int32_t clientUID; 885 int32_t sessionId; 886 int32_t callerPid; 887 int32_t clientPid; 888 AudioCapturerInfo capturerInfo; 889 CapturerState capturerState; 890 DeviceInfo inputDeviceInfo; 891 bool muted; 892 uint32_t appTokenId; 893 AudioCapturerChangeInfo(const AudioCapturerChangeInfo & audioCapturerChangeInfo)894 AudioCapturerChangeInfo(const AudioCapturerChangeInfo &audioCapturerChangeInfo) 895 { 896 *this = audioCapturerChangeInfo; 897 } 898 AudioCapturerChangeInfo() = default; 899 ~AudioCapturerChangeInfo() = default; Marshalling(Parcel & parcel)900 bool Marshalling(Parcel &parcel) const 901 { 902 return parcel.WriteInt32(createrUID) 903 && parcel.WriteInt32(clientUID) 904 && parcel.WriteInt32(sessionId) 905 && parcel.WriteInt32(callerPid) 906 && parcel.WriteInt32(clientPid) 907 && capturerInfo.Marshalling(parcel) 908 && parcel.WriteInt32(static_cast<int32_t>(capturerState)) 909 && inputDeviceInfo.Marshalling(parcel) 910 && parcel.WriteBool(muted) 911 && parcel.WriteUint32(appTokenId); 912 } 913 Marshalling(Parcel & parcel,bool hasBTPermission,bool hasSystemPermission,int32_t apiVersion)914 bool Marshalling(Parcel &parcel, bool hasBTPermission, bool hasSystemPermission, int32_t apiVersion) const 915 { 916 return parcel.WriteInt32(createrUID) 917 && parcel.WriteInt32(hasSystemPermission ? clientUID : EMPTY_UID) 918 && parcel.WriteInt32(sessionId) 919 && parcel.WriteInt32(callerPid) 920 && parcel.WriteInt32(clientPid) 921 && capturerInfo.Marshalling(parcel) 922 && parcel.WriteInt32(hasSystemPermission ? static_cast<int32_t>(capturerState) : CAPTURER_INVALID) 923 && inputDeviceInfo.Marshalling(parcel, hasBTPermission, hasSystemPermission, apiVersion) 924 && parcel.WriteBool(muted) 925 && parcel.WriteUint32(appTokenId); 926 } 927 Unmarshalling(Parcel & parcel)928 void Unmarshalling(Parcel &parcel) 929 { 930 createrUID = parcel.ReadInt32(); 931 clientUID = parcel.ReadInt32(); 932 sessionId = parcel.ReadInt32(); 933 callerPid = parcel.ReadInt32(); 934 clientPid = parcel.ReadInt32(); 935 capturerInfo.Unmarshalling(parcel); 936 capturerState = static_cast<CapturerState>(parcel.ReadInt32()); 937 inputDeviceInfo.Unmarshalling(parcel); 938 muted = parcel.ReadBool(); 939 appTokenId = parcel.ReadUint32(); 940 } 941 }; 942 943 struct AudioStreamChangeInfo { 944 AudioRendererChangeInfo audioRendererChangeInfo; 945 AudioCapturerChangeInfo audioCapturerChangeInfo; 946 }; 947 948 enum AudioPin { 949 AUDIO_PIN_NONE = 0, // Invalid pin 950 AUDIO_PIN_OUT_SPEAKER = 1 << 0, // Speaker output pin 951 AUDIO_PIN_OUT_HEADSET = 1 << 1, // Wired headset pin for output 952 AUDIO_PIN_OUT_LINEOUT = 1 << 2, // Line-out pin 953 AUDIO_PIN_OUT_HDMI = 1 << 3, // HDMI output pin 954 AUDIO_PIN_OUT_USB = 1 << 4, // USB output pin 955 AUDIO_PIN_OUT_USB_EXT = 1 << 5, // Extended USB output pin 956 AUDIO_PIN_OUT_BLUETOOTH_SCO = 1 << 6, // Bluetooth SCO output pin 957 AUDIO_PIN_OUT_DAUDIO_DEFAULT = 1 << 7, // Daudio default output pin 958 AUDIO_PIN_OUT_HEADPHONE = 1 << 8, // Wired headphone output pin 959 AUDIO_PIN_OUT_USB_HEADSET = 1 << 9, // Arm usb output pin 960 AUDIO_PIN_OUT_DP = 1 << 11, 961 AUDIO_PIN_IN_MIC = 1 << 27 | 1 << 0, // Microphone input pin 962 AUDIO_PIN_IN_HS_MIC = 1 << 27 | 1 << 1, // Wired headset microphone pin for input 963 AUDIO_PIN_IN_LINEIN = 1 << 27 | 1 << 2, // Line-in pin 964 AUDIO_PIN_IN_USB_EXT = 1 << 27 | 1 << 3, // Extended USB input pin 965 AUDIO_PIN_IN_BLUETOOTH_SCO_HEADSET = 1 << 27 | 1 << 4, // Bluetooth SCO headset input pin 966 AUDIO_PIN_IN_DAUDIO_DEFAULT = 1 << 27 | 1 << 5, // Daudio default input pin 967 AUDIO_PIN_IN_USB_HEADSET = 1 << 27 | 1 << 6, // Arm usb input pin 968 }; 969 970 enum AudioParamKey { 971 NONE = 0, 972 VOLUME = 1, 973 INTERRUPT = 2, 974 PARAM_KEY_STATE = 5, 975 A2DP_SUSPEND_STATE = 6, // for bluetooth sink 976 BT_HEADSET_NREC = 7, 977 BT_WBS = 8, 978 A2DP_OFFLOAD_STATE = 9, // for a2dp offload 979 GET_DP_DEVICE_INFO = 10, // for dp sink 980 USB_DEVICE = 101, // Check USB device type ARM or HIFI 981 PERF_INFO = 201, 982 MMI = 301, 983 PARAM_KEY_LOWPOWER = 1000, 984 }; 985 986 struct DStatusInfo { 987 char networkId[NETWORK_ID_SIZE]; 988 AudioPin hdiPin = AUDIO_PIN_NONE; 989 int32_t mappingVolumeId = 0; 990 int32_t mappingInterruptId = 0; 991 int32_t deviceId; 992 int32_t channelMasks; 993 std::string deviceName = ""; 994 bool isConnected = false; 995 std::string macAddress; 996 DeviceStreamInfo streamInfo = {}; 997 ConnectType connectType = CONNECT_TYPE_LOCAL; 998 }; 999 1000 struct AudioRendererDataInfo { 1001 uint8_t *buffer; 1002 size_t flag; 1003 }; 1004 1005 enum AudioPermissionState { 1006 AUDIO_PERMISSION_START = 0, 1007 AUDIO_PERMISSION_STOP = 1, 1008 }; 1009 1010 class AudioRendererPolicyServiceDiedCallback { 1011 public: 1012 virtual ~AudioRendererPolicyServiceDiedCallback() = default; 1013 1014 /** 1015 * Called when audio policy service died. 1016 * @since 10 1017 */ 1018 virtual void OnAudioPolicyServiceDied() = 0; 1019 }; 1020 1021 class AudioStreamPolicyServiceDiedCallback { 1022 public: 1023 virtual ~AudioStreamPolicyServiceDiedCallback() = default; 1024 1025 /** 1026 * Called when audio policy service died. 1027 * @since 11 1028 */ 1029 virtual void OnAudioPolicyServiceDied() = 0; 1030 }; 1031 1032 /** 1033 * Describes three-dimensional value. 1034 * @since 11 1035 */ 1036 struct Vector3D { 1037 /** 1038 * X-axis value. 1039 * @since 11 1040 */ 1041 float x; 1042 /** 1043 * Y-axis value. 1044 * @since 11 1045 */ 1046 float y; 1047 /** 1048 * Z-axis value. 1049 * @since 11 1050 */ 1051 float z; 1052 }; 1053 1054 struct SessionInfo { 1055 SourceType sourceType; 1056 uint32_t rate; 1057 uint32_t channels; 1058 }; 1059 1060 enum CastType { 1061 CAST_TYPE_NULL = 0, 1062 CAST_TYPE_ALL, 1063 CAST_TYPE_PROJECTION, 1064 CAST_TYPE_COOPERATION, 1065 }; 1066 1067 class AudioPnpDeviceChangeCallback { 1068 public: 1069 virtual ~AudioPnpDeviceChangeCallback() = default; 1070 virtual void OnPnpDeviceStatusChanged(const std::string &info) = 0; 1071 virtual void OnMicrophoneBlocked(const std::string &info) = 0; 1072 }; 1073 1074 struct SourceInfo { 1075 SourceType sourceType_; 1076 uint32_t rate_; 1077 uint32_t channels_; 1078 }; 1079 1080 /** 1081 * @brief Device group used by set/get volume. 1082 */ 1083 enum DeviceGroup { 1084 /** Invalid device group */ 1085 DEVICE_GROUP_INVALID = -1, 1086 /** Built in device */ 1087 DEVICE_GROUP_BUILT_IN, 1088 /** Wired device */ 1089 DEVICE_GROUP_WIRED, 1090 /** Wireless device */ 1091 DEVICE_GROUP_WIRELESS, 1092 /** Remote cast device */ 1093 DEVICE_GROUP_REMOTE_CAST, 1094 /* earpiece device*/ 1095 DEVICE_GROUP_EARPIECE, 1096 }; 1097 1098 static const std::map<DeviceType, DeviceGroup> DEVICE_GROUP_FOR_VOLUME = { 1099 {DEVICE_TYPE_EARPIECE, DEVICE_GROUP_EARPIECE}, 1100 {DEVICE_TYPE_SPEAKER, DEVICE_GROUP_BUILT_IN}, 1101 {DEVICE_TYPE_WIRED_HEADSET, DEVICE_GROUP_WIRED}, 1102 {DEVICE_TYPE_USB_HEADSET, DEVICE_GROUP_WIRED}, 1103 {DEVICE_TYPE_USB_ARM_HEADSET, DEVICE_GROUP_WIRED}, 1104 {DEVICE_TYPE_DP, DEVICE_GROUP_WIRED}, 1105 {DEVICE_TYPE_BLUETOOTH_A2DP, DEVICE_GROUP_WIRELESS}, 1106 {DEVICE_TYPE_BLUETOOTH_SCO, DEVICE_GROUP_WIRELESS}, 1107 {DEVICE_TYPE_REMOTE_CAST, DEVICE_GROUP_REMOTE_CAST}, 1108 }; 1109 GetVolumeGroupForDevice(DeviceType deviceType)1110 static inline DeviceGroup GetVolumeGroupForDevice(DeviceType deviceType) 1111 { 1112 auto it = DEVICE_GROUP_FOR_VOLUME.find(deviceType); 1113 if (it == DEVICE_GROUP_FOR_VOLUME.end()) { 1114 return DEVICE_GROUP_INVALID; 1115 } 1116 return it->second; 1117 } 1118 1119 enum RouterType { 1120 /** 1121 * None router. 1122 * @since 12 1123 */ 1124 ROUTER_TYPE_NONE = 0, 1125 /** 1126 * Default router. 1127 * @since 12 1128 */ 1129 ROUTER_TYPE_DEFAULT, 1130 /** 1131 * Stream filter router. 1132 * @since 12 1133 */ 1134 ROUTER_TYPE_STREAM_FILTER, 1135 /** 1136 * Package filter router. 1137 * @since 12 1138 */ 1139 ROUTER_TYPE_PACKAGE_FILTER, 1140 /** 1141 * Cockpit phone router. 1142 * @since 12 1143 */ 1144 ROUTER_TYPE_COCKPIT_PHONE, 1145 /** 1146 * Privacy priority router. 1147 * @since 12 1148 */ 1149 ROUTER_TYPE_PRIVACY_PRIORITY, 1150 /** 1151 * Public priority router. 1152 * @since 12 1153 */ 1154 ROUTER_TYPE_PUBLIC_PRIORITY, 1155 /** 1156 * Pair device router. 1157 * @since 12 1158 */ 1159 ROUTER_TYPE_PAIR_DEVICE, 1160 /** 1161 * User select router. 1162 * @since 12 1163 */ 1164 ROUTER_TYPE_USER_SELECT, 1165 }; 1166 1167 enum RenderMode { 1168 /** 1169 * Primary render mode. 1170 * @since 12 1171 */ 1172 PRIMARY, 1173 /** 1174 * VOIP render mode. 1175 * @since 12 1176 */ 1177 VOIP, 1178 /** 1179 * Offload render mode. 1180 * @since 12 1181 */ 1182 OFFLOAD, 1183 /** 1184 * Low latency render mode. 1185 * @since 12 1186 */ 1187 LOW_LATENCY, 1188 }; 1189 1190 enum WriteDataCallbackType { 1191 /** 1192 * Use OH_AudioRenderer_Callbacks.OH_AudioRenderer_OnWriteData 1193 * @since 12 1194 */ 1195 WRITE_DATA_CALLBACK_WITHOUT_RESULT = 0, 1196 /** 1197 * Use OH_AudioRenderer_OnWriteDataCallback. 1198 * @since 12 1199 */ 1200 WRITE_DATA_CALLBACK_WITH_RESULT = 1 1201 }; 1202 1203 enum PolicyType { 1204 EDM_POLICY_TYPE = 0, 1205 PRIVACY_POLCIY_TYPE = 1, 1206 TEMPORARY_POLCIY_TYPE = 2, 1207 }; 1208 1209 static inline const std::unordered_set<SourceType> specialSourceTypeSet_ = { 1210 SOURCE_TYPE_PLAYBACK_CAPTURE, 1211 SOURCE_TYPE_WAKEUP, 1212 SOURCE_TYPE_VIRTUAL_CAPTURE, 1213 SOURCE_TYPE_REMOTE_CAST 1214 }; 1215 } // namespace AudioStandard 1216 } // namespace OHOS 1217 #endif // AUDIO_INFO_H 1218