1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "i_audio_stream.h"
17 #include <map>
18
19 #include "audio_log.h"
20 #include "audio_stream.h"
21 #include "fast_audio_stream.h"
22
23 namespace OHOS {
24 namespace AudioStandard {
25 const std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> streamTypeMap_ = IAudioStream::CreateStreamMap();
CreateStreamMap()26 std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> IAudioStream::CreateStreamMap()
27 {
28 std::map<std::pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
29 // Mapping relationships from content and usage to stream type in design
30 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
31 streamMap[std::make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_CALL;
32 streamMap[std::make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
33 streamMap[std::make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
34 streamMap[std::make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
35 streamMap[std::make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
36 streamMap[std::make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
37 streamMap[std::make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
38 streamMap[std::make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
39 streamMap[std::make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
40 streamMap[std::make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
41 streamMap[std::make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
42 streamMap[std::make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
43 streamMap[std::make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
44 streamMap[std::make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
45 streamMap[std::make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
46
47 // Old mapping relationships from content and usage to stream type
48 streamMap[std::make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
49 streamMap[std::make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
50 streamMap[std::make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
51 streamMap[std::make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
52 streamMap[std::make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
53 streamMap[std::make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
54 streamMap[std::make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
55
56 // Only use stream usage to choose stream type
57 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
58 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
59 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_CALL;
60 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
61 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
62 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
63 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
64 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
65 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
66 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
67 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
68 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
69 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
70 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
71 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
72 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
73 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
74 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
75 streamMap[std::make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
76
77 return streamMap;
78 }
79
GetStreamType(ContentType contentType,StreamUsage streamUsage)80 AudioStreamType IAudioStream::GetStreamType(ContentType contentType, StreamUsage streamUsage)
81 {
82 AudioStreamType streamType = STREAM_MUSIC;
83 auto pos = streamTypeMap_.find(std::make_pair(contentType, streamUsage));
84 if (pos != streamTypeMap_.end()) {
85 streamType = pos->second;
86 }
87
88 if (streamType == STREAM_MEDIA) {
89 streamType = STREAM_MUSIC;
90 }
91
92 return streamType;
93 }
94
GetEffectSceneName(AudioStreamType audioType)95 const std::string IAudioStream::GetEffectSceneName(AudioStreamType audioType)
96 {
97 std::string name;
98 switch (audioType) {
99 case STREAM_MUSIC:
100 name = "SCENE_MUSIC";
101 break;
102 case STREAM_GAME:
103 name = "SCENE_GAME";
104 break;
105 case STREAM_MOVIE:
106 name = "SCENE_MOVIE";
107 break;
108 case STREAM_SPEECH:
109 case STREAM_VOICE_CALL:
110 case STREAM_VOICE_ASSISTANT:
111 name = "SCENE_SPEECH";
112 break;
113 case STREAM_RING:
114 case STREAM_ALARM:
115 case STREAM_NOTIFICATION:
116 case STREAM_SYSTEM:
117 case STREAM_DTMF:
118 case STREAM_SYSTEM_ENFORCED:
119 name = "SCENE_RING";
120 break;
121 default:
122 name = "SCENE_OTHERS";
123 }
124
125 const std::string sceneName = name;
126 return sceneName;
127 }
128
IsStreamSupported(int32_t streamFlags,const AudioStreamParams & params)129 bool IAudioStream::IsStreamSupported(int32_t streamFlags, const AudioStreamParams ¶ms)
130 {
131 // 0 for normal stream
132 if (streamFlags == 0) {
133 return true;
134 }
135 // 1 for fast stream
136 if (streamFlags == STREAM_FLAG_FAST) {
137 // check audio sample rate
138 AudioSamplingRate samplingRate = static_cast<AudioSamplingRate>(params.samplingRate);
139 auto rateItem = std::find(AUDIO_FAST_STREAM_SUPPORTED_SAMPLING_RATES.begin(),
140 AUDIO_FAST_STREAM_SUPPORTED_SAMPLING_RATES.end(), samplingRate);
141 if (rateItem == AUDIO_FAST_STREAM_SUPPORTED_SAMPLING_RATES.end()) {
142 return false;
143 }
144
145 // check audio channel
146 AudioChannel channels = static_cast<AudioChannel>(params.channels);
147 auto channelItem = std::find(AUDIO_FAST_STREAM_SUPPORTED_CHANNELS.begin(),
148 AUDIO_FAST_STREAM_SUPPORTED_CHANNELS.end(), channels);
149 if (channelItem == AUDIO_FAST_STREAM_SUPPORTED_CHANNELS.end()) {
150 return false;
151 }
152
153 // check audio sample format
154 AudioSampleFormat format = static_cast<AudioSampleFormat>(params.format);
155 auto formatItem = std::find(AUDIO_FAST_STREAM_SUPPORTED_FORMATS.begin(),
156 AUDIO_FAST_STREAM_SUPPORTED_FORMATS.end(), format);
157 if (formatItem == AUDIO_FAST_STREAM_SUPPORTED_FORMATS.end()) {
158 return false;
159 }
160 }
161 return true;
162 }
163
GetPlaybackStream(StreamClass streamClass,AudioStreamParams params,AudioStreamType eStreamType,int32_t appUid)164 std::shared_ptr<IAudioStream> IAudioStream::GetPlaybackStream(StreamClass streamClass, AudioStreamParams params,
165 AudioStreamType eStreamType, int32_t appUid)
166 {
167 if (streamClass == FAST_STREAM) {
168 (void)params;
169 AUDIO_INFO_LOG("Create fast playback stream");
170 return std::make_shared<FastAudioStream>(eStreamType, AUDIO_MODE_PLAYBACK, appUid);
171 }
172 if (streamClass == PA_STREAM) {
173 return std::make_shared<AudioStream>(eStreamType, AUDIO_MODE_PLAYBACK, appUid);
174 }
175 return nullptr;
176 }
177
GetRecordStream(StreamClass streamClass,AudioStreamParams params,AudioStreamType eStreamType,int32_t appUid)178 std::shared_ptr<IAudioStream> IAudioStream::GetRecordStream(StreamClass streamClass, AudioStreamParams params,
179 AudioStreamType eStreamType, int32_t appUid)
180 {
181 if (streamClass == FAST_STREAM) {
182 (void)params;
183 AUDIO_INFO_LOG("Create fast record stream");
184 return std::make_shared<FastAudioStream>(eStreamType, AUDIO_MODE_RECORD, appUid);
185 }
186 if (streamClass == PA_STREAM) {
187 return std::make_shared<AudioStream>(eStreamType, AUDIO_MODE_RECORD, appUid);
188 }
189 return nullptr;
190 }
191 } // namespace AudioStandard
192 } // namespace OHOS
193