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 enum PlayerType : int32_t {
368 PLAYER_TYPE_DEFAULT = 0,
369
370 // AudioFramework internal type.
371 PLAYER_TYPE_OH_AUDIO_RENDERER = 100,
372 PLAYER_TYPE_ARKTS_AUDIO_RENDERER = 101,
373 PLAYER_TYPE_CJ_AUDIO_RENDERER = 102,
374 PLAYER_TYPE_OPENSL_ES = 103,
375
376 // Indicates a type from the system internals, but not from the AudioFramework.
377 PLAYER_TYPE_SOUND_POOL = 1000,
378 PLAYER_TYPE_AV_PLAYER = 1001,
379 PLAYER_TYPE_SYSTEM_WEBVIEW = 1002,
380 };
381
382 struct AudioRendererInfo {
383 ContentType contentType = CONTENT_TYPE_UNKNOWN;
384 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
385 int32_t rendererFlags = AUDIO_FLAG_NORMAL;
386 std::string sceneType = "";
387 bool spatializationEnabled = false;
388 bool headTrackingEnabled = false;
389 int32_t originalFlag = AUDIO_FLAG_NORMAL;
390 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
391 AudioSamplingRate samplingRate = SAMPLE_RATE_8000;
392 AudioSampleFormat format = SAMPLE_S16LE;
393 uint8_t encodingType = 0;
394 uint64_t channelLayout = 0ULL;
395 bool isOffloadAllowed = true;
396 bool isSatellite = false;
397 PlayerType playerType = PLAYER_TYPE_DEFAULT;
398 // Expected length of audio stream to be played.
399 // Currently only used for making decisions on fade-in and fade-out strategies.
400 // 0 is the default value, it is considered that no
401 uint64_t expectedPlaybackDurationBytes = 0;
402
MarshallingAudioRendererInfo403 bool Marshalling(Parcel &parcel) const
404 {
405 return parcel.WriteInt32(static_cast<int32_t>(contentType))
406 && parcel.WriteInt32(static_cast<int32_t>(streamUsage))
407 && parcel.WriteInt32(rendererFlags)
408 && parcel.WriteInt32(originalFlag)
409 && parcel.WriteString(sceneType)
410 && parcel.WriteBool(spatializationEnabled)
411 && parcel.WriteBool(headTrackingEnabled)
412 && parcel.WriteInt32(static_cast<int32_t>(pipeType))
413 && parcel.WriteInt32(static_cast<int32_t>(samplingRate))
414 && parcel.WriteInt32(format)
415 && parcel.WriteUint8(encodingType)
416 && parcel.WriteUint64(channelLayout)
417 && parcel.WriteBool(isOffloadAllowed)
418 && parcel.WriteInt32(playerType)
419 && parcel.WriteUint64(expectedPlaybackDurationBytes);
420 }
UnmarshallingAudioRendererInfo421 void Unmarshalling(Parcel &parcel)
422 {
423 contentType = static_cast<ContentType>(parcel.ReadInt32());
424 streamUsage = static_cast<StreamUsage>(parcel.ReadInt32());
425 rendererFlags = parcel.ReadInt32();
426 originalFlag = parcel.ReadInt32();
427 sceneType = parcel.ReadString();
428 spatializationEnabled = parcel.ReadBool();
429 headTrackingEnabled = parcel.ReadBool();
430 pipeType = static_cast<AudioPipeType>(parcel.ReadInt32());
431 samplingRate = static_cast<AudioSamplingRate>(parcel.ReadInt32());
432 format = static_cast<AudioSampleFormat>(parcel.ReadInt32());
433 encodingType = parcel.ReadUint8();
434 channelLayout = parcel.ReadUint64();
435 isOffloadAllowed = parcel.ReadBool();
436 playerType = static_cast<PlayerType>(parcel.ReadInt32());
437 expectedPlaybackDurationBytes = parcel.ReadUint64();
438 }
439 };
440
441 class AudioCapturerInfo {
442 public:
443 SourceType sourceType = SOURCE_TYPE_INVALID;
444 int32_t capturerFlags = 0;
445 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
446 AudioSamplingRate samplingRate = SAMPLE_RATE_8000;
447 uint8_t encodingType = 0;
448 uint64_t channelLayout = 0ULL;
449 std::string sceneType = "";
450 int32_t originalFlag = AUDIO_FLAG_NORMAL;
AudioCapturerInfo(SourceType sourceType_,int32_t capturerFlags_)451 AudioCapturerInfo(SourceType sourceType_, int32_t capturerFlags_) : sourceType(sourceType_),
452 capturerFlags(capturerFlags_) {}
AudioCapturerInfo(const AudioCapturerInfo & audioCapturerInfo)453 AudioCapturerInfo(const AudioCapturerInfo &audioCapturerInfo)
454 {
455 *this = audioCapturerInfo;
456 }
457 AudioCapturerInfo() = default;
458 ~AudioCapturerInfo()= default;
Marshalling(Parcel & parcel)459 bool Marshalling(Parcel &parcel) const
460 {
461 return parcel.WriteInt32(static_cast<int32_t>(sourceType))
462 && parcel.WriteInt32(capturerFlags)
463 && parcel.WriteInt32(static_cast<int32_t>(pipeType))
464 && parcel.WriteInt32(static_cast<int32_t>(samplingRate))
465 && parcel.WriteUint8(encodingType)
466 && parcel.WriteUint64(channelLayout)
467 && parcel.WriteString(sceneType)
468 && parcel.WriteInt32(originalFlag);
469 }
Unmarshalling(Parcel & parcel)470 void Unmarshalling(Parcel &parcel)
471 {
472 sourceType = static_cast<SourceType>(parcel.ReadInt32());
473 capturerFlags = parcel.ReadInt32();
474 pipeType = static_cast<AudioPipeType>(parcel.ReadInt32());
475 samplingRate = static_cast<AudioSamplingRate>(parcel.ReadInt32());
476 encodingType = parcel.ReadUint8();
477 channelLayout = parcel.ReadUint64();
478 sceneType = parcel.ReadString();
479 originalFlag = parcel.ReadInt32();
480 }
481 };
482
483 struct AudioRendererDesc {
484 ContentType contentType = CONTENT_TYPE_UNKNOWN;
485 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
486 };
487
488 struct AudioRendererOptions {
489 AudioStreamInfo streamInfo;
490 AudioRendererInfo rendererInfo;
491 AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC;
492 AudioSessionStrategy strategy = { AudioConcurrencyMode::INVALID };
493 };
494
495 struct MicStateChangeEvent {
496 bool mute;
497 };
498
499 enum AudioScene : int32_t {
500 /**
501 * Invalid
502 */
503 AUDIO_SCENE_INVALID = -1,
504 /**
505 * Default audio scene
506 */
507 AUDIO_SCENE_DEFAULT,
508 /**
509 * Ringing audio scene
510 * Only available for system api.
511 */
512 AUDIO_SCENE_RINGING,
513 /**
514 * Phone call audio scene
515 * Only available for system api.
516 */
517 AUDIO_SCENE_PHONE_CALL,
518 /**
519 * Voice chat audio scene
520 */
521 AUDIO_SCENE_PHONE_CHAT,
522 /**
523 * AvSession set call start flag
524 */
525 AUDIO_SCENE_CALL_START,
526 /**
527 * AvSession set call end flag
528 */
529 AUDIO_SCENE_CALL_END,
530 /**
531 * Voice ringing audio scene
532 * Only available for system api.
533 */
534 AUDIO_SCENE_VOICE_RINGING,
535 /**
536 * Max
537 */
538 AUDIO_SCENE_MAX,
539 };
540
541 enum AudioDeviceUsage : uint32_t {
542 /**
543 * Media output devices.
544 * @syscap SystemCapability.Multimedia.Audio.Device
545 * @systemapi
546 * @since 11
547 */
548 MEDIA_OUTPUT_DEVICES = 1,
549 /**
550 * Media input devices.
551 * @syscap SystemCapability.Multimedia.Audio.Device
552 * @systemapi
553 * @since 11
554 */
555 MEDIA_INPUT_DEVICES = 2,
556 /**
557 * All media devices.
558 * @syscap SystemCapability.Multimedia.Audio.Device
559 * @systemapi
560 * @since 11
561 */
562 ALL_MEDIA_DEVICES = 3,
563 /**
564 * Call output devices.
565 * @syscap SystemCapability.Multimedia.Audio.Device
566 * @systemapi
567 * @since 11
568 */
569 CALL_OUTPUT_DEVICES = 4,
570 /**
571 * Call input devices.
572 * @syscap SystemCapability.Multimedia.Audio.Device
573 * @systemapi
574 * @since 11
575 */
576 CALL_INPUT_DEVICES = 8,
577 /**
578 * All call devices.
579 * @syscap SystemCapability.Multimedia.Audio.Device
580 * @systemapi
581 * @since 11
582 */
583 ALL_CALL_DEVICES = 12,
584 /**
585 * All devices.
586 * @syscap SystemCapability.Multimedia.Audio.Device
587 * @systemapi
588 * @since 11
589 */
590 D_ALL_DEVICES = 15,
591 };
592
593 enum FilterMode : uint32_t {
594 INCLUDE = 0,
595 EXCLUDE,
596 MAX_FILTER_MODE
597 };
598
599 // 1.If the size of usages or pids is 0, FilterMode will not work.
600 // 2.Filters will only works with FileterMode INCLUDE or EXCLUDE while the vector size is not zero.
601 // 3.If usages and pids are both not empty, the result is the intersection of the two Filter.
602 // 4.If usages.size() == 0, defalut usages will be filtered with FilterMode::INCLUDE.
603 // 5.Default usages are MEDIA MUSIC MOVIE GAME and BOOK.
604 struct CaptureFilterOptions {
605 std::vector<StreamUsage> usages;
606 FilterMode usageFilterMode {FilterMode::INCLUDE};
607 std::vector<int32_t> pids;
608 FilterMode pidFilterMode {FilterMode::INCLUDE};
609 };
610
611 struct AudioPlaybackCaptureConfig {
612 CaptureFilterOptions filterOptions;
613 bool silentCapture {false}; // To be deprecated since 12
614 };
615
616 struct AudioCapturerOptions {
617 AudioStreamInfo streamInfo;
618 AudioCapturerInfo capturerInfo;
619 AudioPlaybackCaptureConfig playbackCaptureConfig;
620 AudioSessionStrategy strategy = { AudioConcurrencyMode::INVALID };
621 };
622
623 struct AppInfo {
624 int32_t appUid { INVALID_UID };
625 uint32_t appTokenId { 0 };
626 int32_t appPid { 0 };
627 uint64_t appFullTokenId { 0 };
628 };
629
630 struct BufferQueueState {
631 uint32_t numBuffers;
632 uint32_t currentIndex;
633 };
634
635 enum AudioRenderMode {
636 RENDER_MODE_NORMAL,
637 RENDER_MODE_CALLBACK
638 };
639
640 enum AudioCaptureMode {
641 CAPTURE_MODE_NORMAL,
642 CAPTURE_MODE_CALLBACK
643 };
644
645 struct SinkInfo {
646 uint32_t sinkId; // sink id
647 std::string sinkName;
648 std::string adapterName;
649 };
650
651 struct SinkInput {
652 int32_t streamId;
653 AudioStreamType streamType;
654
655 // add for routing stream.
656 int32_t uid; // client uid
657 int32_t pid; // client pid
658 uint32_t paStreamId; // streamId
659 uint32_t deviceSinkId; // sink id
660 std::string sinkName; // sink name
661 int32_t statusMark; // mark the router status
662 uint64_t startTime; // when this router is created
663 };
664
665 struct SourceOutput {
666 int32_t streamId;
667 AudioStreamType streamType;
668
669 // add for routing stream.
670 int32_t uid; // client uid
671 int32_t pid; // client pid
672 uint32_t paStreamId; // streamId
673 uint32_t deviceSourceId; // sink id
674 int32_t statusMark; // mark the router status
675 uint64_t startTime; // when this router is created
676 };
677
678 typedef uint32_t AudioIOHandle;
679
FLOAT_COMPARE_EQ(const float & x,const float & y)680 static inline bool FLOAT_COMPARE_EQ(const float& x, const float& y)
681 {
682 return (std::abs((x) - (y)) <= (std::numeric_limits<float>::epsilon()));
683 }
684
685 enum AudioServiceIndex {
686 HDI_SERVICE_INDEX = 0,
687 AUDIO_SERVICE_INDEX
688 };
689
690 /**
691 * @brief Enumerates the rendering states of the current device.
692 */
693 enum RendererState {
694 /** INVALID state */
695 RENDERER_INVALID = -1,
696 /** Create New Renderer instance */
697 RENDERER_NEW,
698 /** Reneder Prepared state */
699 RENDERER_PREPARED,
700 /** Rendere Running state */
701 RENDERER_RUNNING,
702 /** Renderer Stopped state */
703 RENDERER_STOPPED,
704 /** Renderer Released state */
705 RENDERER_RELEASED,
706 /** Renderer Paused state */
707 RENDERER_PAUSED
708 };
709
710 /**
711 * @brief Enumerates the capturing states of the current device.
712 */
713 enum CapturerState {
714 /** Capturer INVALID state */
715 CAPTURER_INVALID = -1,
716 /** Create new capturer instance */
717 CAPTURER_NEW,
718 /** Capturer Prepared state */
719 CAPTURER_PREPARED,
720 /** Capturer Running state */
721 CAPTURER_RUNNING,
722 /** Capturer Stopped state */
723 CAPTURER_STOPPED,
724 /** Capturer Released state */
725 CAPTURER_RELEASED,
726 /** Capturer Paused state */
727 CAPTURER_PAUSED
728 };
729
730 enum State {
731 /** INVALID */
732 INVALID = -1,
733 /** New */
734 NEW,
735 /** Prepared */
736 PREPARED,
737 /** Running */
738 RUNNING,
739 /** Stopped */
740 STOPPED,
741 /** Released */
742 RELEASED,
743 /** Paused */
744 PAUSED,
745 /** Stopping */
746 STOPPING
747 };
748
749 struct StreamSwitchingInfo {
750 bool isSwitching_ = false;
751 State state_ = INVALID;
752 };
753
754 struct AudioRegisterTrackerInfo {
755 uint32_t sessionId;
756 int32_t clientPid;
757 State state;
758 AudioRendererInfo rendererInfo;
759 AudioCapturerInfo capturerInfo;
760 int32_t channelCount;
761 uint32_t appTokenId;
762 };
763
764 enum StateChangeCmdType {
765 CMD_FROM_CLIENT = 0,
766 CMD_FROM_SYSTEM = 1
767 };
768
769 enum AudioMode {
770 AUDIO_MODE_PLAYBACK,
771 AUDIO_MODE_RECORD
772 };
773
774 // LEGACY_INNER_CAP: Called from hap build with api < 12, work normally.
775 // LEGACY_MUTE_CAP: Called from hap build with api >= 12, will cap mute data.
776 // MODERN_INNER_CAP: Called from SA with inner-cap right, work with filter.
777 enum InnerCapMode : uint32_t {
778 LEGACY_INNER_CAP = 0,
779 LEGACY_MUTE_CAP,
780 MODERN_INNER_CAP,
781 INVALID_CAP_MODE
782 };
783
784 struct AudioProcessConfig {
785 int32_t callerUid = INVALID_UID;
786
787 AppInfo appInfo;
788
789 AudioStreamInfo streamInfo;
790
791 AudioMode audioMode = AUDIO_MODE_PLAYBACK;
792
793 AudioRendererInfo rendererInfo;
794
795 AudioCapturerInfo capturerInfo;
796
797 AudioStreamType streamType = STREAM_DEFAULT;
798
799 DeviceType deviceType = DEVICE_TYPE_INVALID;
800
801 bool isInnerCapturer = false;
802
803 bool isWakeupCapturer = false;
804
805 uint32_t originalSessionId = 0;
806
807 AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC;
808
809 InnerCapMode innerCapMode {InnerCapMode::INVALID_CAP_MODE};
810 };
811
812 struct Volume {
813 bool isMute = false;
814 float volumeFloat = 1.0f;
815 uint32_t volumeInt = 0;
816 };
817
818 enum StreamSetState {
819 STREAM_PAUSE,
820 STREAM_RESUME
821 };
822
823 struct StreamSetStateEventInternal {
824 StreamSetState streamSetState;
825 StreamUsage streamUsage;
826 };
827
828 enum AudioPin {
829 AUDIO_PIN_NONE = 0, // Invalid pin
830 AUDIO_PIN_OUT_SPEAKER = 1 << 0, // Speaker output pin
831 AUDIO_PIN_OUT_HEADSET = 1 << 1, // Wired headset pin for output
832 AUDIO_PIN_OUT_LINEOUT = 1 << 2, // Line-out pin
833 AUDIO_PIN_OUT_HDMI = 1 << 3, // HDMI output pin
834 AUDIO_PIN_OUT_USB = 1 << 4, // USB output pin
835 AUDIO_PIN_OUT_USB_EXT = 1 << 5, // Extended USB output pin
836 AUDIO_PIN_OUT_BLUETOOTH_SCO = 1 << 6, // Bluetooth SCO output pin
837 AUDIO_PIN_OUT_DAUDIO_DEFAULT = 1 << 7, // Daudio default output pin
838 AUDIO_PIN_OUT_HEADPHONE = 1 << 8, // Wired headphone output pin
839 AUDIO_PIN_OUT_USB_HEADSET = 1 << 9, // Arm usb output pin
840 AUDIO_PIN_OUT_DP = 1 << 11,
841 AUDIO_PIN_IN_MIC = 1 << 27 | 1 << 0, // Microphone input pin
842 AUDIO_PIN_IN_HS_MIC = 1 << 27 | 1 << 1, // Wired headset microphone pin for input
843 AUDIO_PIN_IN_LINEIN = 1 << 27 | 1 << 2, // Line-in pin
844 AUDIO_PIN_IN_USB_EXT = 1 << 27 | 1 << 3, // Extended USB input pin
845 AUDIO_PIN_IN_BLUETOOTH_SCO_HEADSET = 1 << 27 | 1 << 4, // Bluetooth SCO headset input pin
846 AUDIO_PIN_IN_DAUDIO_DEFAULT = 1 << 27 | 1 << 5, // Daudio default input pin
847 AUDIO_PIN_IN_USB_HEADSET = 1 << 27 | 1 << 6, // Arm usb input pin
848 };
849
850 enum AudioParamKey {
851 NONE = 0,
852 VOLUME = 1,
853 INTERRUPT = 2,
854 PARAM_KEY_STATE = 5,
855 A2DP_SUSPEND_STATE = 6, // for bluetooth sink
856 BT_HEADSET_NREC = 7,
857 BT_WBS = 8,
858 A2DP_OFFLOAD_STATE = 9, // for a2dp offload
859 GET_DP_DEVICE_INFO = 10, // for dp sink
860 USB_DEVICE = 101, // Check USB device type ARM or HIFI
861 PERF_INFO = 201,
862 MMI = 301,
863 PARAM_KEY_LOWPOWER = 1000,
864 };
865
866 struct DStatusInfo {
867 char networkId[NETWORK_ID_SIZE];
868 AudioPin hdiPin = AUDIO_PIN_NONE;
869 int32_t mappingVolumeId = 0;
870 int32_t mappingInterruptId = 0;
871 int32_t deviceId;
872 int32_t channelMasks;
873 std::string deviceName = "";
874 bool isConnected = false;
875 std::string macAddress;
876 DeviceStreamInfo streamInfo = {};
877 ConnectType connectType = CONNECT_TYPE_LOCAL;
878 };
879
880 struct AudioRendererDataInfo {
881 uint8_t *buffer;
882 size_t flag;
883 };
884
885 enum AudioPermissionState {
886 AUDIO_PERMISSION_START = 0,
887 AUDIO_PERMISSION_STOP = 1,
888 };
889
890 class AudioRendererPolicyServiceDiedCallback {
891 public:
892 virtual ~AudioRendererPolicyServiceDiedCallback() = default;
893
894 /**
895 * Called when audio policy service died.
896 * @since 10
897 */
898 virtual void OnAudioPolicyServiceDied() = 0;
899 };
900
901 class AudioStreamPolicyServiceDiedCallback {
902 public:
903 virtual ~AudioStreamPolicyServiceDiedCallback() = default;
904
905 /**
906 * Called when audio policy service died.
907 * @since 11
908 */
909 virtual void OnAudioPolicyServiceDied() = 0;
910 };
911
912 /**
913 * Describes three-dimensional value.
914 * @since 11
915 */
916 struct Vector3D {
917 /**
918 * X-axis value.
919 * @since 11
920 */
921 float x;
922 /**
923 * Y-axis value.
924 * @since 11
925 */
926 float y;
927 /**
928 * Z-axis value.
929 * @since 11
930 */
931 float z;
932 };
933
934 struct SessionInfo {
935 SourceType sourceType;
936 uint32_t rate;
937 uint32_t channels;
938 };
939
940 enum CastType {
941 CAST_TYPE_NULL = 0,
942 CAST_TYPE_ALL,
943 CAST_TYPE_PROJECTION,
944 CAST_TYPE_COOPERATION,
945 };
946
947 class AudioPnpDeviceChangeCallback {
948 public:
949 virtual ~AudioPnpDeviceChangeCallback() = default;
950 virtual void OnPnpDeviceStatusChanged(const std::string &info) = 0;
951 virtual void OnMicrophoneBlocked(const std::string &info) = 0;
952 };
953
954 struct SourceInfo {
955 SourceType sourceType_;
956 uint32_t rate_;
957 uint32_t channels_;
958 };
959
960 /**
961 * @brief Device group used by set/get volume.
962 */
963 enum DeviceGroup {
964 /** Invalid device group */
965 DEVICE_GROUP_INVALID = -1,
966 /** Built in device */
967 DEVICE_GROUP_BUILT_IN,
968 /** Wired device */
969 DEVICE_GROUP_WIRED,
970 /** Wireless device */
971 DEVICE_GROUP_WIRELESS,
972 /** Remote cast device */
973 DEVICE_GROUP_REMOTE_CAST,
974 /* earpiece device*/
975 DEVICE_GROUP_EARPIECE,
976 };
977
978 static const std::map<DeviceType, DeviceGroup> DEVICE_GROUP_FOR_VOLUME = {
979 {DEVICE_TYPE_EARPIECE, DEVICE_GROUP_EARPIECE},
980 {DEVICE_TYPE_SPEAKER, DEVICE_GROUP_BUILT_IN},
981 {DEVICE_TYPE_WIRED_HEADSET, DEVICE_GROUP_WIRED},
982 {DEVICE_TYPE_USB_HEADSET, DEVICE_GROUP_WIRED},
983 {DEVICE_TYPE_USB_ARM_HEADSET, DEVICE_GROUP_WIRED},
984 {DEVICE_TYPE_DP, DEVICE_GROUP_WIRED},
985 {DEVICE_TYPE_BLUETOOTH_A2DP, DEVICE_GROUP_WIRELESS},
986 {DEVICE_TYPE_BLUETOOTH_SCO, DEVICE_GROUP_WIRELESS},
987 {DEVICE_TYPE_REMOTE_CAST, DEVICE_GROUP_REMOTE_CAST},
988 };
989
GetVolumeGroupForDevice(DeviceType deviceType)990 static inline DeviceGroup GetVolumeGroupForDevice(DeviceType deviceType)
991 {
992 auto it = DEVICE_GROUP_FOR_VOLUME.find(deviceType);
993 if (it == DEVICE_GROUP_FOR_VOLUME.end()) {
994 return DEVICE_GROUP_INVALID;
995 }
996 return it->second;
997 }
998
999 enum RouterType {
1000 /**
1001 * None router.
1002 * @since 12
1003 */
1004 ROUTER_TYPE_NONE = 0,
1005 /**
1006 * Default router.
1007 * @since 12
1008 */
1009 ROUTER_TYPE_DEFAULT,
1010 /**
1011 * Stream filter router.
1012 * @since 12
1013 */
1014 ROUTER_TYPE_STREAM_FILTER,
1015 /**
1016 * Package filter router.
1017 * @since 12
1018 */
1019 ROUTER_TYPE_PACKAGE_FILTER,
1020 /**
1021 * Cockpit phone router.
1022 * @since 12
1023 */
1024 ROUTER_TYPE_COCKPIT_PHONE,
1025 /**
1026 * Privacy priority router.
1027 * @since 12
1028 */
1029 ROUTER_TYPE_PRIVACY_PRIORITY,
1030 /**
1031 * Public priority router.
1032 * @since 12
1033 */
1034 ROUTER_TYPE_PUBLIC_PRIORITY,
1035 /**
1036 * Pair device router.
1037 * @since 12
1038 */
1039 ROUTER_TYPE_PAIR_DEVICE,
1040 /**
1041 * User select router.
1042 * @since 12
1043 */
1044 ROUTER_TYPE_USER_SELECT,
1045 };
1046
1047 enum RenderMode {
1048 /**
1049 * Primary render mode.
1050 * @since 12
1051 */
1052 PRIMARY,
1053 /**
1054 * VOIP render mode.
1055 * @since 12
1056 */
1057 VOIP,
1058 /**
1059 * Offload render mode.
1060 * @since 12
1061 */
1062 OFFLOAD,
1063 /**
1064 * Low latency render mode.
1065 * @since 12
1066 */
1067 LOW_LATENCY,
1068 };
1069
1070 enum WriteDataCallbackType {
1071 /**
1072 * Use OH_AudioRenderer_Callbacks.OH_AudioRenderer_OnWriteData
1073 * @since 12
1074 */
1075 WRITE_DATA_CALLBACK_WITHOUT_RESULT = 0,
1076 /**
1077 * Use OH_AudioRenderer_OnWriteDataCallback.
1078 * @since 12
1079 */
1080 WRITE_DATA_CALLBACK_WITH_RESULT = 1
1081 };
1082
1083 enum PolicyType {
1084 EDM_POLICY_TYPE = 0,
1085 PRIVACY_POLCIY_TYPE = 1,
1086 TEMPORARY_POLCIY_TYPE = 2,
1087 };
1088
1089 static inline const std::unordered_set<SourceType> specialSourceTypeSet_ = {
1090 SOURCE_TYPE_PLAYBACK_CAPTURE,
1091 SOURCE_TYPE_WAKEUP,
1092 SOURCE_TYPE_VIRTUAL_CAPTURE,
1093 SOURCE_TYPE_REMOTE_CAST
1094 };
1095 } // namespace AudioStandard
1096 } // namespace OHOS
1097 #endif // AUDIO_INFO_H
1098