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 <unistd.h>
27 #include <unordered_map>
28 #include <parcel.h>
29 #include <audio_source_type.h>
30 #include <audio_device_info.h>
31 #include <audio_interrupt_info.h>
32 #include <audio_stream_info.h>
33
34 namespace OHOS {
35 namespace AudioStandard {
36 constexpr int32_t MAX_NUM_STREAMS = 3;
37 constexpr int32_t RENDERER_STREAM_USAGE_SHIFT = 16;
38 constexpr int32_t MINIMUM_BUFFER_SIZE_MSEC = 5;
39 constexpr int32_t MAXIMUM_BUFFER_SIZE_MSEC = 20;
40 constexpr int32_t MIN_SERVICE_COUNT = 2;
41 constexpr int32_t ROOT_UID = 0;
42 constexpr int32_t INVALID_UID = -1;
43 constexpr int32_t INTELL_VOICE_SERVICR_UID = 1042;
44 constexpr int32_t NETWORK_ID_SIZE = 80;
45 constexpr int32_t DEFAULT_VOLUME_GROUP_ID = 1;
46 constexpr int32_t DEFAULT_VOLUME_INTERRUPT_ID = 1;
47 constexpr uint32_t STREAM_FLAG_FORCED_NORMAL = 2;
48 constexpr uint32_t STREAM_FLAG_FAST = 1;
49 constexpr uint32_t STREAM_FLAG_NORMAL = 0;
50 constexpr float MAX_STREAM_SPEED_LEVEL = 4.0f;
51 constexpr float MIN_STREAM_SPEED_LEVEL = 0.25f;
52 constexpr int32_t EMPTY_UID = 0;
53
54 const std::string MICROPHONE_PERMISSION = "ohos.permission.MICROPHONE";
55 const std::string MANAGE_INTELLIGENT_VOICE_PERMISSION = "ohos.permission.MANAGE_INTELLIGENT_VOICE";
56 const std::string MANAGE_AUDIO_CONFIG = "ohos.permission.MANAGE_AUDIO_CONFIG";
57 const std::string MODIFY_AUDIO_SETTINGS_PERMISSION = "ohos.permission.MODIFY_AUDIO_SETTINGS";
58 const std::string ACCESS_NOTIFICATION_POLICY_PERMISSION = "ohos.permission.ACCESS_NOTIFICATION_POLICY";
59 const std::string USE_BLUETOOTH_PERMISSION = "ohos.permission.USE_BLUETOOTH";
60 const std::string CAPTURER_VOICE_DOWNLINK_PERMISSION = "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO";
61 const std::string RECORD_VOICE_CALL_PERMISSION = "ohos.permission.RECORD_VOICE_CALL";
62 const std::string MANAGE_SYSTEM_AUDIO_EFFECTS = "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS";
63
64 const std::string LOCAL_NETWORK_ID = "LocalDevice";
65 const std::string REMOTE_NETWORK_ID = "RemoteDevice";
66
67 constexpr int32_t WAKEUP_LIMIT = 2;
68 constexpr std::string_view PRIMARY_WAKEUP = "Built_in_wakeup";
69 constexpr std::string_view PRIMARY_WAKEUP_MIRROR = "Built_in_wakeup_mirror";
70 constexpr std::string_view WAKEUP_NAMES[WAKEUP_LIMIT] = {
71 PRIMARY_WAKEUP,
72 PRIMARY_WAKEUP_MIRROR
73 };
74 constexpr std::string_view VOICE_CALL_REC_NAME = "Voice_call_rec";
75
76 const std::string INNER_CAPTURER_SOURCE = "Speaker.monitor";
77
78 #ifdef FEATURE_DTMF_TONE
79 // Maximun number of sine waves in a tone segment
80 constexpr uint32_t TONEINFO_MAX_WAVES = 3;
81
82 // Maximun number of segments in a tone descriptor
83 constexpr uint32_t TONEINFO_MAX_SEGMENTS = 12;
84 constexpr uint32_t TONEINFO_INF = 0xFFFFFFFF;
85 class ToneSegment : public Parcelable {
86 public:
87 uint32_t duration;
88 uint16_t waveFreq[TONEINFO_MAX_WAVES+1];
89 uint16_t loopCnt;
90 uint16_t loopIndx;
Marshalling(Parcel & parcel)91 bool Marshalling(Parcel &parcel) const override
92 {
93 parcel.WriteUint32(duration);
94 parcel.WriteUint16(loopCnt);
95 parcel.WriteUint16(loopIndx);
96 for (uint32_t i = 0; i < TONEINFO_MAX_WAVES + 1; i++) {
97 parcel.WriteUint16(waveFreq[i]);
98 }
99 return true;
100 }
Unmarshalling(Parcel & parcel)101 void Unmarshalling(Parcel &parcel)
102 {
103 duration = parcel.ReadUint32();
104 loopCnt = parcel.ReadUint16();
105 loopIndx = parcel.ReadUint16();
106 for (uint32_t i = 0; i < TONEINFO_MAX_WAVES + 1; i++) {
107 waveFreq[i] = parcel.ReadUint16();
108 }
109 }
110 };
111
112 class ToneInfo : public Parcelable {
113 public:
114 ToneSegment segments[TONEINFO_MAX_SEGMENTS+1];
115 uint32_t segmentCnt;
116 uint32_t repeatCnt;
117 uint32_t repeatSegment;
Marshalling(Parcel & parcel)118 bool Marshalling(Parcel &parcel) const override
119 {
120 parcel.WriteUint32(segmentCnt);
121 parcel.WriteUint32(repeatCnt);
122 parcel.WriteUint32(repeatSegment);
123 for (uint32_t i = 0; i < segmentCnt; i++) {
124 segments[i].Marshalling(parcel);
125 }
126 return true;
127 }
Unmarshalling(Parcel & parcel)128 void Unmarshalling(Parcel &parcel)
129 {
130 segmentCnt = parcel.ReadUint32();
131 repeatCnt = parcel.ReadUint32();
132 repeatSegment = parcel.ReadUint32();
133 for (uint32_t i = 0; i < segmentCnt; i++) {
134 segments[i].Unmarshalling(parcel);
135 }
136 }
137 };
138 #endif
139
140 enum VolumeAdjustType {
141 /**
142 * Adjust volume up
143 */
144 VOLUME_UP = 0,
145 /**
146 * Adjust volume down
147 */
148 VOLUME_DOWN = 1,
149 };
150
151 enum ChannelBlendMode {
152 /**
153 * No channel process.
154 */
155 MODE_DEFAULT = 0,
156 /**
157 * Blend left and right channel.
158 */
159 MODE_BLEND_LR = 1,
160 /**
161 * Replicate left to right channel.
162 */
163 MODE_ALL_LEFT = 2,
164 /**
165 * Replicate right to left channel.
166 */
167 MODE_ALL_RIGHT = 3,
168 };
169
170 enum ConnectType {
171 /**
172 * Group connect type of local device
173 */
174 CONNECT_TYPE_LOCAL = 0,
175 /**
176 * Group connect type of distributed device
177 */
178 CONNECT_TYPE_DISTRIBUTED
179 };
180
181 typedef AudioStreamType AudioVolumeType;
182
183 enum AudioOffloadType {
184 /**
185 * Indicates audio offload state default.
186 */
187 OFFLOAD_DEFAULT = -1,
188 /**
189 * Indicates audio offload state : screen is active & app is foreground.
190 */
191 OFFLOAD_ACTIVE_FOREGROUND = 0,
192 /**
193 * Indicates audio offload state : screen is active & app is background.
194 */
195 OFFLOAD_ACTIVE_BACKGROUND = 1,
196 /**
197 * Indicates audio offload state : screen is inactive & app is background.
198 */
199 OFFLOAD_INACTIVE_BACKGROUND = 3,
200 };
201
202 enum FocusType {
203 /**
204 * Recording type.
205 */
206 FOCUS_TYPE_RECORDING = 0,
207 };
208
209 enum AudioErrors {
210 /**
211 * Common errors.
212 */
213 ERROR_INVALID_PARAM = 6800101,
214 ERROR_NO_MEMORY = 6800102,
215 ERROR_ILLEGAL_STATE = 6800103,
216 ERROR_UNSUPPORTED = 6800104,
217 ERROR_TIMEOUT = 6800105,
218 /**
219 * Audio specific errors.
220 */
221 ERROR_STREAM_LIMIT = 6800201,
222 /**
223 * Default error.
224 */
225 ERROR_SYSTEM = 6800301
226 };
227
228 // Ringer Mode
229 enum AudioRingerMode {
230 RINGER_MODE_SILENT = 0,
231 RINGER_MODE_VIBRATE = 1,
232 RINGER_MODE_NORMAL = 2
233 };
234
235 /**
236 * Enumerates audio stream privacy type for playback capture.
237 */
238 enum AudioPrivacyType {
239 PRIVACY_TYPE_PUBLIC = 0,
240 PRIVACY_TYPE_PRIVATE = 1
241 };
242
243 /**
244 * Enumerates the renderer playback speed.
245 */
246 enum AudioRendererRate {
247 RENDER_RATE_NORMAL = 0,
248 RENDER_RATE_DOUBLE = 1,
249 RENDER_RATE_HALF = 2,
250 };
251
252 struct VolumeEvent {
253 AudioVolumeType volumeType;
254 int32_t volume;
255 bool updateUi;
256 int32_t volumeGroupId;
257 std::string networkId;
258 };
259
260 struct AudioParameters {
261 AudioSampleFormat format;
262 AudioChannel channels;
263 AudioSamplingRate samplingRate;
264 AudioEncodingType encoding;
265 ContentType contentType;
266 StreamUsage usage;
267 DeviceRole deviceRole;
268 DeviceType deviceType;
269 };
270
271 struct A2dpDeviceConfigInfo {
272 DeviceStreamInfo streamInfo;
273 bool absVolumeSupport = false;
274 int32_t volumeLevel;
275 bool mute = false;
276 };
277
278 struct AudioRendererInfo {
279 ContentType contentType = CONTENT_TYPE_UNKNOWN;
280 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
281 int32_t rendererFlags = 0;
MarshallingAudioRendererInfo282 bool Marshalling(Parcel &parcel) const
283 {
284 return parcel.WriteInt32(static_cast<int32_t>(contentType))
285 && parcel.WriteInt32(static_cast<int32_t>(streamUsage))
286 && parcel.WriteInt32(rendererFlags);
287 }
UnmarshallingAudioRendererInfo288 void Unmarshalling(Parcel &parcel)
289 {
290 contentType = static_cast<ContentType>(parcel.ReadInt32());
291 streamUsage = static_cast<StreamUsage>(parcel.ReadInt32());
292 rendererFlags = parcel.ReadInt32();
293 }
294 };
295
296 class AudioCapturerInfo {
297 public:
298 SourceType sourceType = SOURCE_TYPE_INVALID;
299 int32_t capturerFlags = 0;
AudioCapturerInfo(SourceType sourceType_,int32_t capturerFlags_)300 AudioCapturerInfo(SourceType sourceType_, int32_t capturerFlags_) : sourceType(sourceType_),
301 capturerFlags(capturerFlags_) {}
AudioCapturerInfo(const AudioCapturerInfo & audioCapturerInfo)302 AudioCapturerInfo(const AudioCapturerInfo &audioCapturerInfo)
303 {
304 *this = audioCapturerInfo;
305 }
306 AudioCapturerInfo() = default;
307 ~AudioCapturerInfo()= default;
Marshalling(Parcel & parcel)308 bool Marshalling(Parcel &parcel) const
309 {
310 return parcel.WriteInt32(static_cast<int32_t>(sourceType))
311 && parcel.WriteInt32(capturerFlags);
312 }
Unmarshalling(Parcel & parcel)313 void Unmarshalling(Parcel &parcel)
314 {
315 sourceType = static_cast<SourceType>(parcel.ReadInt32());
316 capturerFlags = parcel.ReadInt32();
317 }
318 };
319
320 struct AudioRendererDesc {
321 ContentType contentType = CONTENT_TYPE_UNKNOWN;
322 StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
323 };
324
325 struct AudioRendererOptions {
326 AudioStreamInfo streamInfo;
327 AudioRendererInfo rendererInfo;
328 AudioPrivacyType privacyType = PRIVACY_TYPE_PUBLIC;
329 };
330
331 struct MicStateChangeEvent {
332 bool mute;
333 };
334
335 enum AudioScene : int32_t {
336 /**
337 * Invalid
338 */
339 AUDIO_SCENE_INVALID = -1,
340 /**
341 * Default audio scene
342 */
343 AUDIO_SCENE_DEFAULT,
344 /**
345 * Ringing audio scene
346 * Only available for system api.
347 */
348 AUDIO_SCENE_RINGING,
349 /**
350 * Phone call audio scene
351 * Only available for system api.
352 */
353 AUDIO_SCENE_PHONE_CALL,
354 /**
355 * Voice chat audio scene
356 */
357 AUDIO_SCENE_PHONE_CHAT,
358 /**
359 * AvSession set call start flag
360 */
361 AUDIO_SCENE_CALL_START,
362 /**
363 * AvSession set call end flag
364 */
365 AUDIO_SCENE_CALL_END,
366 /**
367 * Max
368 */
369 AUDIO_SCENE_MAX,
370 };
371
372 enum AudioDeviceUsage : int32_t {
373 /**
374 * Media output devices.
375 * @syscap SystemCapability.Multimedia.Audio.Device
376 * @systemapi
377 * @since 11
378 */
379 MEDIA_OUTPUT_DEVICES = 1,
380 /**
381 * Media input devices.
382 * @syscap SystemCapability.Multimedia.Audio.Device
383 * @systemapi
384 * @since 11
385 */
386 MEDIA_INPUT_DEVICES = 2,
387 /**
388 * All media devices.
389 * @syscap SystemCapability.Multimedia.Audio.Device
390 * @systemapi
391 * @since 11
392 */
393 ALL_MEDIA_DEVICES = 3,
394 /**
395 * Call output devices.
396 * @syscap SystemCapability.Multimedia.Audio.Device
397 * @systemapi
398 * @since 11
399 */
400 CALL_OUTPUT_DEVICES = 4,
401 /**
402 * Call input devices.
403 * @syscap SystemCapability.Multimedia.Audio.Device
404 * @systemapi
405 * @since 11
406 */
407 CALL_INPUT_DEVICES = 8,
408 /**
409 * All call devices.
410 * @syscap SystemCapability.Multimedia.Audio.Device
411 * @systemapi
412 * @since 11
413 */
414 ALL_CALL_DEVICES = 12,
415 /**
416 * All devices.
417 * @syscap SystemCapability.Multimedia.Audio.Device
418 * @systemapi
419 * @since 11
420 */
421 D_ALL_DEVICES = 15,
422 };
423
GetAudioSceneFromStreamType(AudioStreamType streamType,StreamUsage streamUsage)424 inline AudioScene GetAudioSceneFromStreamType(AudioStreamType streamType, StreamUsage streamUsage)
425 {
426 if (streamType == STREAM_RING) {
427 return AUDIO_SCENE_RINGING;
428 } else if (streamType == STREAM_VOICE_CALL) {
429 return streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION ?
430 AUDIO_SCENE_PHONE_CALL : AUDIO_SCENE_PHONE_CHAT;
431 }
432 return AUDIO_SCENE_DEFAULT;
433 }
434
GetAudioSceneFromAudioInterrupt(const AudioInterrupt & audioInterrupt)435 inline AudioScene GetAudioSceneFromAudioInterrupt(const AudioInterrupt &audioInterrupt)
436 {
437 return GetAudioSceneFromStreamType(audioInterrupt.audioFocusType.streamType, audioInterrupt.streamUsage);
438 }
439
440 inline const std::unordered_map<const AudioScene, const int> audioScenePriority = {
441 {AUDIO_SCENE_PHONE_CALL, 4}, // highest priority
442 {AUDIO_SCENE_PHONE_CHAT, 3},
443 {AUDIO_SCENE_RINGING, 2},
444 {AUDIO_SCENE_DEFAULT, 1}
445 };
446
GetAudioScenePriority(const AudioScene audioScene)447 inline int GetAudioScenePriority(const AudioScene audioScene)
448 {
449 if (audioScenePriority.count(audioScene) == 0) {
450 return audioScenePriority.at(AUDIO_SCENE_DEFAULT);
451 }
452 return audioScenePriority.at(audioScene);
453 }
454
455 struct CaptureFilterOptions {
456 std::vector<StreamUsage> usages;
457 };
458
459 struct AudioPlaybackCaptureConfig {
460 CaptureFilterOptions filterOptions;
461 bool silentCapture {false};
462 };
463
464 struct AudioCapturerOptions {
465 AudioStreamInfo streamInfo;
466 AudioCapturerInfo capturerInfo;
467 AudioPlaybackCaptureConfig playbackCaptureConfig;
468 };
469
470 struct AppInfo {
471 int32_t appUid { INVALID_UID };
472 uint32_t appTokenId { 0 };
473 int32_t appPid { 0 };
474 uint64_t appFullTokenId { 0 };
475 };
476
477 struct BufferQueueState {
478 uint32_t numBuffers;
479 uint32_t currentIndex;
480 };
481
482 enum AudioRenderMode {
483 RENDER_MODE_NORMAL,
484 RENDER_MODE_CALLBACK
485 };
486
487 enum AudioCaptureMode {
488 CAPTURE_MODE_NORMAL,
489 CAPTURE_MODE_CALLBACK
490 };
491
492 struct SinkInfo {
493 uint32_t sinkId; // sink id
494 std::string sinkName;
495 std::string adapterName;
496 };
497
498 struct SinkInput {
499 int32_t streamId;
500 AudioStreamType streamType;
501
502 // add for routing stream.
503 int32_t uid; // client uid
504 int32_t pid; // client pid
505 uint32_t paStreamId; // streamId
506 uint32_t deviceSinkId; // sink id
507 std::string sinkName; // sink name
508 int32_t statusMark; // mark the router status
509 uint64_t startTime; // when this router is created
510 };
511
512 struct SourceOutput {
513 int32_t streamId;
514 AudioStreamType streamType;
515
516 // add for routing stream.
517 int32_t uid; // client uid
518 int32_t pid; // client pid
519 uint32_t paStreamId; // streamId
520 uint32_t deviceSourceId; // sink id
521 int32_t statusMark; // mark the router status
522 uint64_t startTime; // when this router is created
523 };
524
525 typedef uint32_t AudioIOHandle;
526
FLOAT_COMPARE_EQ(const float & x,const float & y)527 static inline bool FLOAT_COMPARE_EQ(const float& x, const float& y)
528 {
529 return (std::abs((x) - (y)) <= (std::numeric_limits<float>::epsilon()));
530 }
531
532 enum AudioServiceIndex {
533 HDI_SERVICE_INDEX = 0,
534 AUDIO_SERVICE_INDEX
535 };
536
537 /**
538 * @brief Enumerates the rendering states of the current device.
539 */
540 enum RendererState {
541 /** INVALID state */
542 RENDERER_INVALID = -1,
543 /** Create New Renderer instance */
544 RENDERER_NEW,
545 /** Reneder Prepared state */
546 RENDERER_PREPARED,
547 /** Rendere Running state */
548 RENDERER_RUNNING,
549 /** Renderer Stopped state */
550 RENDERER_STOPPED,
551 /** Renderer Released state */
552 RENDERER_RELEASED,
553 /** Renderer Paused state */
554 RENDERER_PAUSED
555 };
556
557 /**
558 * @brief Enumerates the capturing states of the current device.
559 */
560 enum CapturerState {
561 /** Capturer INVALID state */
562 CAPTURER_INVALID = -1,
563 /** Create new capturer instance */
564 CAPTURER_NEW,
565 /** Capturer Prepared state */
566 CAPTURER_PREPARED,
567 /** Capturer Running state */
568 CAPTURER_RUNNING,
569 /** Capturer Stopped state */
570 CAPTURER_STOPPED,
571 /** Capturer Released state */
572 CAPTURER_RELEASED,
573 /** Capturer Paused state */
574 CAPTURER_PAUSED
575 };
576
577 enum State {
578 /** INVALID */
579 INVALID = -1,
580 /** New */
581 NEW,
582 /** Prepared */
583 PREPARED,
584 /** Running */
585 RUNNING,
586 /** Stopped */
587 STOPPED,
588 /** Released */
589 RELEASED,
590 /** Paused */
591 PAUSED,
592 /** Stopping */
593 STOPPING
594 };
595
596 struct AudioRegisterTrackerInfo {
597 uint32_t sessionId;
598 int32_t clientPid;
599 State state;
600 AudioRendererInfo rendererInfo;
601 AudioCapturerInfo capturerInfo;
602 int32_t channelCount;
603 uint32_t appTokenId;
604 };
605
606 enum StateChangeCmdType {
607 CMD_FROM_CLIENT = 0,
608 CMD_FROM_SYSTEM = 1
609 };
610
611 enum AudioMode {
612 AUDIO_MODE_PLAYBACK,
613 AUDIO_MODE_RECORD
614 };
615
616 struct AudioProcessConfig {
617 AppInfo appInfo;
618
619 AudioStreamInfo streamInfo;
620
621 AudioMode audioMode;
622
623 AudioRendererInfo rendererInfo;
624
625 AudioCapturerInfo capturerInfo;
626
627 AudioStreamType streamType;
628
629 bool isInnerCapturer;
630
631 bool isWakeupCapturer;
632
633 AudioPrivacyType privacyType;
634
635 // Waiting for review: add isWakeupCapturer isInnerCapturer
636 };
637
638 struct Volume {
639 bool isMute = false;
640 float volumeFloat = 1.0f;
641 uint32_t volumeInt = 0;
642 };
643
644 enum StreamSetState {
645 STREAM_PAUSE,
646 STREAM_RESUME
647 };
648
649 struct StreamSetStateEventInternal {
650 StreamSetState streamSetState;
651 AudioStreamType audioStreamType;
652 };
653
654 class AudioRendererChangeInfo {
655 public:
656 int32_t createrUID;
657 int32_t clientUID;
658 int32_t sessionId;
659 int32_t callerPid;
660 int32_t clientPid;
661 int32_t tokenId;
662 int32_t channelCount;
663 AudioRendererInfo rendererInfo;
664 RendererState rendererState;
665 DeviceInfo outputDeviceInfo;
666
AudioRendererChangeInfo(const AudioRendererChangeInfo & audioRendererChangeInfo)667 AudioRendererChangeInfo(const AudioRendererChangeInfo &audioRendererChangeInfo)
668 {
669 *this = audioRendererChangeInfo;
670 }
671 AudioRendererChangeInfo() = default;
672 ~AudioRendererChangeInfo() = default;
Marshalling(Parcel & parcel)673 bool Marshalling(Parcel &parcel) const
674 {
675 return parcel.WriteInt32(createrUID)
676 && parcel.WriteInt32(clientUID)
677 && parcel.WriteInt32(sessionId)
678 && parcel.WriteInt32(callerPid)
679 && parcel.WriteInt32(clientPid)
680 && parcel.WriteInt32(tokenId)
681 && parcel.WriteInt32(channelCount)
682 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType))
683 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage))
684 && parcel.WriteInt32(rendererInfo.rendererFlags)
685 && parcel.WriteInt32(static_cast<int32_t>(rendererState))
686 && outputDeviceInfo.Marshalling(parcel);
687 }
Marshalling(Parcel & parcel,bool hasBTPermission,bool hasSystemPermission,int32_t apiVersion)688 bool Marshalling(Parcel &parcel, bool hasBTPermission, bool hasSystemPermission, int32_t apiVersion) const
689 {
690 return parcel.WriteInt32(createrUID)
691 && parcel.WriteInt32(hasSystemPermission ? clientUID : EMPTY_UID)
692 && parcel.WriteInt32(sessionId)
693 && parcel.WriteInt32(callerPid)
694 && parcel.WriteInt32(clientPid)
695 && parcel.WriteInt32(tokenId)
696 && parcel.WriteInt32(channelCount)
697 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.contentType))
698 && parcel.WriteInt32(static_cast<int32_t>(rendererInfo.streamUsage))
699 && parcel.WriteInt32(rendererInfo.rendererFlags)
700 && parcel.WriteInt32(hasSystemPermission ? static_cast<int32_t>(rendererState) :
701 RENDERER_INVALID)
702 && outputDeviceInfo.Marshalling(parcel, hasBTPermission, hasSystemPermission, apiVersion);
703 }
Unmarshalling(Parcel & parcel)704 void Unmarshalling(Parcel &parcel)
705 {
706 createrUID = parcel.ReadInt32();
707 clientUID = parcel.ReadInt32();
708 sessionId = parcel.ReadInt32();
709 callerPid = parcel.ReadInt32();
710 clientPid = parcel.ReadInt32();
711 tokenId = parcel.ReadInt32();
712 channelCount = parcel.ReadInt32();
713
714 rendererInfo.contentType = static_cast<ContentType>(parcel.ReadInt32());
715 rendererInfo.streamUsage = static_cast<StreamUsage>(parcel.ReadInt32());
716 rendererInfo.rendererFlags = parcel.ReadInt32();
717
718 rendererState = static_cast<RendererState>(parcel.ReadInt32());
719 outputDeviceInfo.Unmarshalling(parcel);
720 }
721 };
722
723 class AudioCapturerChangeInfo {
724 public:
725 int32_t createrUID;
726 int32_t clientUID;
727 int32_t sessionId;
728 int32_t callerPid;
729 int32_t clientPid;
730 AudioCapturerInfo capturerInfo;
731 CapturerState capturerState;
732 DeviceInfo inputDeviceInfo;
733 bool muted;
734 uint32_t appTokenId;
735
AudioCapturerChangeInfo(const AudioCapturerChangeInfo & audioCapturerChangeInfo)736 AudioCapturerChangeInfo(const AudioCapturerChangeInfo &audioCapturerChangeInfo)
737 {
738 *this = audioCapturerChangeInfo;
739 }
740 AudioCapturerChangeInfo() = default;
741 ~AudioCapturerChangeInfo() = default;
Marshalling(Parcel & parcel)742 bool Marshalling(Parcel &parcel) const
743 {
744 return parcel.WriteInt32(createrUID)
745 && parcel.WriteInt32(clientUID)
746 && parcel.WriteInt32(sessionId)
747 && parcel.WriteInt32(callerPid)
748 && parcel.WriteInt32(clientPid)
749 && capturerInfo.Marshalling(parcel)
750 && parcel.WriteInt32(static_cast<int32_t>(capturerState))
751 && inputDeviceInfo.Marshalling(parcel)
752 && parcel.WriteBool(muted)
753 && parcel.WriteUint32(appTokenId);
754 }
755
Marshalling(Parcel & parcel,bool hasBTPermission,bool hasSystemPermission,int32_t apiVersion)756 bool Marshalling(Parcel &parcel, bool hasBTPermission, bool hasSystemPermission, int32_t apiVersion) const
757 {
758 return parcel.WriteInt32(createrUID)
759 && parcel.WriteInt32(clientUID)
760 && parcel.WriteInt32(sessionId)
761 && parcel.WriteInt32(callerPid)
762 && parcel.WriteInt32(clientPid)
763 && capturerInfo.Marshalling(parcel)
764 && parcel.WriteInt32(static_cast<int32_t>(capturerState))
765 && inputDeviceInfo.Marshalling(parcel, hasBTPermission, hasSystemPermission, apiVersion)
766 && parcel.WriteBool(muted)
767 && parcel.WriteUint32(appTokenId);
768 }
769
Unmarshalling(Parcel & parcel)770 void Unmarshalling(Parcel &parcel)
771 {
772 createrUID = parcel.ReadInt32();
773 clientUID = parcel.ReadInt32();
774 sessionId = parcel.ReadInt32();
775 callerPid = parcel.ReadInt32();
776 clientPid = parcel.ReadInt32();
777 capturerInfo.Unmarshalling(parcel);
778 capturerState = static_cast<CapturerState>(parcel.ReadInt32());
779 inputDeviceInfo.Unmarshalling(parcel);
780 muted = parcel.ReadBool();
781 appTokenId = parcel.ReadUint32();
782 }
783 };
784
785 struct AudioStreamChangeInfo {
786 AudioRendererChangeInfo audioRendererChangeInfo;
787 AudioCapturerChangeInfo audioCapturerChangeInfo;
788 };
789
790 enum AudioPin {
791 AUDIO_PIN_NONE = 0, // Invalid pin
792 AUDIO_PIN_OUT_SPEAKER = 1 << 0, // Speaker output pin
793 AUDIO_PIN_OUT_HEADSET = 1 << 1, // Wired headset pin for output
794 AUDIO_PIN_OUT_LINEOUT = 1 << 2, // Line-out pin
795 AUDIO_PIN_OUT_HDMI = 1 << 3, // HDMI output pin
796 AUDIO_PIN_OUT_USB = 1 << 4, // USB output pin
797 AUDIO_PIN_OUT_USB_EXT = 1 << 5, // Extended USB output pin
798 AUDIO_PIN_OUT_BLUETOOTH_SCO = 1 << 6, // Bluetooth SCO output pin
799 AUDIO_PIN_OUT_DAUDIO_DEFAULT = 1 << 7, // Daudio default output pin
800 AUDIO_PIN_OUT_HEADPHONE = 1 << 8, // Wired headphone output pin
801 AUDIO_PIN_OUT_USB_HEADSET = 1 << 9, // Arm usb output pin
802 AUDIO_PIN_IN_MIC = 1 << 27 | 1 << 0, // Microphone input pin
803 AUDIO_PIN_IN_HS_MIC = 1 << 27 | 1 << 1, // Wired headset microphone pin for input
804 AUDIO_PIN_IN_LINEIN = 1 << 27 | 1 << 2, // Line-in pin
805 AUDIO_PIN_IN_USB_EXT = 1 << 27 | 1 << 3, // Extended USB input pin
806 AUDIO_PIN_IN_BLUETOOTH_SCO_HEADSET = 1 << 27 | 1 << 4, // Bluetooth SCO headset input pin
807 AUDIO_PIN_IN_DAUDIO_DEFAULT = 1 << 27 | 1 << 5, // Daudio default input pin
808 AUDIO_PIN_IN_USB_HEADSET = 1 << 27 | 1 << 6, // Arm usb input pin
809 };
810
811 enum AudioParamKey {
812 NONE = 0,
813 VOLUME = 1,
814 INTERRUPT = 2,
815 PARAM_KEY_STATE = 5,
816 A2DP_SUSPEND_STATE = 6, // for bluetooth sink
817 BT_HEADSET_NREC = 7,
818 BT_WBS = 8,
819 A2DP_OFFLOAD_STATE = 9, //for a2dp offload
820 USB_DEVICE = 101, // Check USB device type ARM or HIFI
821 PERF_INFO = 201,
822 MMI = 301,
823 PARAM_KEY_LOWPOWER = 1000,
824 };
825
826 struct DStatusInfo {
827 char networkId[NETWORK_ID_SIZE];
828 AudioPin hdiPin = AUDIO_PIN_NONE;
829 int32_t mappingVolumeId = 0;
830 int32_t mappingInterruptId = 0;
831 int32_t deviceId;
832 int32_t channelMasks;
833 std::string deviceName = "";
834 bool isConnected = false;
835 std::string macAddress;
836 DeviceStreamInfo streamInfo = {};
837 ConnectType connectType = CONNECT_TYPE_LOCAL;
838 };
839
840 struct AudioRendererDataInfo {
841 uint8_t *buffer;
842 size_t flag;
843 };
844
845 enum AudioPermissionState {
846 AUDIO_PERMISSION_START = 0,
847 AUDIO_PERMISSION_STOP = 1,
848 };
849
850 class AudioRendererPolicyServiceDiedCallback {
851 public:
852 virtual ~AudioRendererPolicyServiceDiedCallback() = default;
853
854 /**
855 * Called when audio policy service died.
856 * @since 10
857 */
858 virtual void OnAudioPolicyServiceDied() = 0;
859 };
860
861 class AudioStreamPolicyServiceDiedCallback {
862 public:
863 virtual ~AudioStreamPolicyServiceDiedCallback() = default;
864
865 /**
866 * Called when audio policy service died.
867 * @since 11
868 */
869 virtual void OnAudioPolicyServiceDied() = 0;
870 };
871
872 /**
873 * Describes three-dimensional value.
874 * @since 11
875 */
876 struct Vector3D {
877 /**
878 * X-axis value.
879 * @since 11
880 */
881 float x;
882 /**
883 * Y-axis value.
884 * @since 11
885 */
886 float y;
887 /**
888 * Z-axis value.
889 * @since 11
890 */
891 float z;
892 };
893
894 struct SessionInfo {
895 SourceType sourceType;
896 uint32_t rate;
897 uint32_t channels;
898 };
899
900 enum BluetoothOffloadState {
901 NO_A2DP_DEVICE = 0,
902 A2DP_NOT_OFFLOAD = 1,
903 A2DP_OFFLOAD = 2,
904 };
905
906 enum CastType {
907 CAST_TYPE_NULL = 0,
908 CAST_TYPE_ALL,
909 CAST_TYPE_PROJECTION,
910 CAST_TYPE_COOPERATION,
911 };
912
913 class AudioPnpDeviceChangeCallback {
914 public:
915 virtual ~AudioPnpDeviceChangeCallback() = default;
916 virtual void OnPnpDeviceStatusChanged(const std::string &info) = 0;
917 };
918
919 struct SourceInfo {
920 SourceType sourceType_;
921 uint32_t rate_;
922 uint32_t channels_;
923 };
924 } // namespace AudioStandard
925 } // namespace OHOS
926 #endif // AUDIO_INFO_H
927