1 /*
2 * Copyright (c) 2022 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 <iostream>
17 #include <cstddef>
18 #include <cstdint>
19
20 #include "i_audio_renderer_sink.h"
21 #include "audio_manager_base.h"
22 #include "audio_policy_manager_listener_stub.h"
23 #include "audio_server.h"
24 #include "message_parcel.h"
25 using namespace std;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 constexpr int32_t OFFSET = 4;
30 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IStandardAudioService";
31 const int32_t SYSTEM_ABILITY_ID = 3001;
32 const bool RUN_ON_CREATE = false;
33 const int32_t LIMITSIZE = 4;
34 const int32_t SHIFT_LEFT_8 = 8;
35 const int32_t SHIFT_LEFT_16 = 16;
36 const int32_t SHIFT_LEFT_24 = 24;
37 const uint32_t LIMIT_MIN = 0;
38 const uint32_t LIMIT_MAX = static_cast<uint32_t>(AudioServerInterfaceCode::AUDIO_SERVER_CODE_MAX);
39
Convert2Uint32(const uint8_t * ptr)40 uint32_t Convert2Uint32(const uint8_t *ptr)
41 {
42 if (ptr == nullptr) {
43 return 0;
44 }
45 /* Move the 0th digit to the left by 24 bits, the 1st digit to the left by 16 bits,
46 the 2nd digit to the left by 8 bits, and the 3rd digit not to the left */
47 return (ptr[0] << SHIFT_LEFT_24) | (ptr[1] << SHIFT_LEFT_16) | (ptr[2] << SHIFT_LEFT_8) | (ptr[3]);
48 }
49
AudioServerFuzzTest(const uint8_t * rawData,size_t size)50 void AudioServerFuzzTest(const uint8_t *rawData, size_t size)
51 {
52 if (rawData == nullptr || size < LIMITSIZE) {
53 return;
54 }
55 uint32_t code = Convert2Uint32(rawData) % (LIMIT_MAX - LIMIT_MIN + 1) + LIMIT_MIN;
56 rawData = rawData + OFFSET;
57 size = size - OFFSET;
58
59 MessageParcel data;
60 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
61 data.WriteBuffer(rawData, size);
62 data.RewindRead(0);
63 MessageParcel reply;
64 MessageOption option;
65
66 std::shared_ptr<AudioServer> AudioServerPtr =
67 std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
68
69 if (code == static_cast<uint32_t>(AudioServerInterfaceCode::SET_PARAMETER_CALLBACK)) {
70 sptr<AudioPolicyManagerListenerStub> focusListenerStub = new(std::nothrow) AudioPolicyManagerListenerStub();
71 sptr<IRemoteObject> object = focusListenerStub->AsObject();
72 AudioServerPtr->SetParameterCallback(object);
73 return;
74 }
75 AudioServerPtr->OnRemoteRequest(code, data, reply, option);
76
77 if (size < LIMITSIZE) {
78 return;
79 }
80 std::string netWorkId(reinterpret_cast<const char*>(rawData), size - 1);
81 AudioParamKey key = *reinterpret_cast<const AudioParamKey *>(rawData);
82 std::string condition(reinterpret_cast<const char*>(rawData), size - 1);
83 std::string value(reinterpret_cast<const char*>(rawData), size - 1);
84 AudioServerPtr->OnAudioSinkParamChange(netWorkId, key, condition, value);
85 }
86
Convert2Float(const uint8_t * ptr)87 float Convert2Float(const uint8_t *ptr)
88 {
89 float floatValue = static_cast<float>(*ptr);
90 return floatValue / 128.0f - 1.0f;
91 }
92
AudioServerOffloadSetVolumeFuzzTest(const uint8_t * rawData,size_t size)93 void AudioServerOffloadSetVolumeFuzzTest(const uint8_t *rawData, size_t size)
94 {
95 if (rawData == nullptr || size < LIMITSIZE) {
96 return;
97 }
98
99 MessageParcel data;
100 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
101 float volume = Convert2Float(rawData);
102 data.WriteFloat(volume);
103 MessageParcel reply;
104 MessageOption option;
105
106 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
107 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::OFFLOAD_SET_VOLUME),
108 data, reply, option);
109 }
110
AudioServerNotifyStreamVolumeChangedFuzzTest(const uint8_t * rawData,size_t size)111 void AudioServerNotifyStreamVolumeChangedFuzzTest(const uint8_t *rawData, size_t size)
112 {
113 if (rawData == nullptr || size < LIMITSIZE) {
114 return;
115 }
116
117 MessageParcel data;
118 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
119 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
120 data.WriteUint32(sizeMs);
121 MessageParcel reply;
122 MessageOption option;
123
124 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
125 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_STREAM_VOLUME_CHANGED),
126 data, reply, option);
127 }
128
AudioServerResetRouteForDisconnectFuzzTest(const uint8_t * rawData,size_t size)129 void AudioServerResetRouteForDisconnectFuzzTest(const uint8_t *rawData, size_t size)
130 {
131 if (rawData == nullptr || size < LIMITSIZE) {
132 return;
133 }
134
135 MessageParcel data;
136 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
137 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
138 data.WriteInt32(deviceType);
139 MessageParcel reply;
140 MessageOption option;
141
142 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
143 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_ROUTE_FOR_DISCONNECT),
144 data, reply, option);
145 }
146
AudioServerGetEffectLatencyTest(const uint8_t * rawData,size_t size)147 void AudioServerGetEffectLatencyTest(const uint8_t *rawData, size_t size)
148 {
149 if (rawData == nullptr || size < LIMITSIZE) {
150 return;
151 }
152
153 MessageParcel data;
154 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
155 std::string sessionId(reinterpret_cast<const char*>(rawData), size);
156 data.WriteString(sessionId);
157
158 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
159 MessageParcel reply;
160 MessageOption option;
161 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_EFFECT_LATENCY),
162 data, reply, option);
163 }
164
AudioServerUpdateLatencyTimestampTest(const uint8_t * rawData,size_t size)165 void AudioServerUpdateLatencyTimestampTest(const uint8_t *rawData, size_t size)
166 {
167 if (rawData == nullptr || size < LIMITSIZE) {
168 return;
169 }
170
171 MessageParcel data;
172 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
173 std::string timestamp(reinterpret_cast<const char*>(rawData), size - 1);
174 bool isRenderer = *reinterpret_cast<const bool*>(rawData);
175 data.WriteString(timestamp);
176 data.WriteBool(isRenderer);
177
178 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
179 MessageParcel reply;
180 MessageOption option;
181 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_LATENCY_TIMESTAMP),
182 data, reply, option);
183 }
184
AudioServerGetMaxAmplitudeTest(const uint8_t * rawData,size_t size)185 void AudioServerGetMaxAmplitudeTest(const uint8_t *rawData, size_t size)
186 {
187 if (rawData == nullptr || size < LIMITSIZE) {
188 return;
189 }
190
191 MessageParcel data;
192 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
193 bool isOutputDevice = *reinterpret_cast<const bool*>(rawData);
194 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
195 data.WriteBool(isOutputDevice);
196 data.WriteInt32(deviceType);
197
198 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
199 MessageParcel reply;
200 MessageOption option;
201 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_MAX_AMPLITUDE),
202 data, reply, option);
203 }
204
AudioServerResetAudioEndpointTest(const uint8_t * rawData,size_t size)205 void AudioServerResetAudioEndpointTest(const uint8_t *rawData, size_t size)
206 {
207 if (rawData == nullptr || size < LIMITSIZE) {
208 return;
209 }
210
211 MessageParcel data;
212 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
213
214 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
215 MessageParcel reply;
216 MessageOption option;
217 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_AUDIO_ENDPOINT),
218 data, reply, option);
219 }
220
AudioServerCreatePlaybackCapturerManagerTest(const uint8_t * rawData,size_t size)221 void AudioServerCreatePlaybackCapturerManagerTest(const uint8_t *rawData, size_t size)
222 {
223 if (rawData == nullptr || size < LIMITSIZE) {
224 return;
225 }
226
227 MessageParcel data;
228 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
229
230 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
231 MessageParcel reply;
232 MessageOption option;
233 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_PLAYBACK_CAPTURER_MANAGER),
234 data, reply, option);
235 }
236
AudioServerSetOutputDeviceSinkTest(const uint8_t * rawData,size_t size)237 void AudioServerSetOutputDeviceSinkTest(const uint8_t *rawData, size_t size)
238 {
239 if (rawData == nullptr || size < LIMITSIZE) {
240 return;
241 }
242
243 MessageParcel data;
244 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
245 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
246 std::string sinkName(reinterpret_cast<const char*>(rawData), size - 1);
247 data.WriteInt32(deviceType);
248 data.WriteString(sinkName);
249
250 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
251 MessageParcel reply;
252 MessageOption option;
253 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_OUTPUT_DEVICE_SINK),
254 data, reply, option);
255 }
256
AudioServerRequestThreadPriorityTest(const uint8_t * rawData,size_t size)257 void AudioServerRequestThreadPriorityTest(const uint8_t *rawData, size_t size)
258 {
259 if (rawData == nullptr || size < LIMITSIZE) {
260 return;
261 }
262
263 MessageParcel data;
264 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
265 uint32_t tid = *reinterpret_cast<const uint32_t*>(rawData);
266 std::string bundleName(reinterpret_cast<const char*>(rawData), size - 1);
267 data.WriteUint32(tid);
268 data.WriteString(bundleName);
269
270 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
271 MessageParcel reply;
272 MessageOption option;
273 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::REQUEST_THREAD_PRIORITY),
274 data, reply, option);
275 }
276
AudioServerSetAudioMonoStateTest(const uint8_t * rawData,size_t size)277 void AudioServerSetAudioMonoStateTest(const uint8_t *rawData, size_t size)
278 {
279 if (rawData == nullptr || size < LIMITSIZE) {
280 return;
281 }
282
283 MessageParcel data;
284 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
285 bool audioMono = *reinterpret_cast<const bool*>(rawData);
286 data.WriteBool(audioMono);
287
288 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
289 MessageParcel reply;
290 MessageOption option;
291 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_MONO_STATE),
292 data, reply, option);
293 }
294
AudioServerSetVoiceVolumeTest(const uint8_t * rawData,size_t size)295 void AudioServerSetVoiceVolumeTest(const uint8_t *rawData, size_t size)
296 {
297 if (rawData == nullptr || size < LIMITSIZE) {
298 return;
299 }
300
301 MessageParcel data;
302 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
303 float volume = *reinterpret_cast<const float*>(rawData);
304 data.WriteFloat(volume);
305
306 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
307 MessageParcel reply;
308 MessageOption option;
309 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_VOICE_VOLUME),
310 data, reply, option);
311 }
312
AudioServerCheckRemoteDeviceStateTest(const uint8_t * rawData,size_t size)313 void AudioServerCheckRemoteDeviceStateTest(const uint8_t *rawData, size_t size)
314 {
315 if (rawData == nullptr || size < LIMITSIZE) {
316 return;
317 }
318
319 MessageParcel data;
320 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
321 std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
322 DeviceRole deviceRole = *reinterpret_cast<const DeviceRole*>(rawData);
323 bool isStartDevice = *reinterpret_cast<const bool*>(rawData);
324 data.WriteString(networkId);
325 data.WriteInt32(static_cast<int32_t>(deviceRole));
326 data.WriteBool(isStartDevice);
327
328 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
329 MessageParcel reply;
330 MessageOption option;
331 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CHECK_REMOTE_DEVICE_STATE),
332 data, reply, option);
333 }
334
AudioServerNotifyDeviceInfoTest(const uint8_t * rawData,size_t size)335 void AudioServerNotifyDeviceInfoTest(const uint8_t *rawData, size_t size)
336 {
337 if (rawData == nullptr || size < LIMITSIZE) {
338 return;
339 }
340
341 MessageParcel data;
342 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
343 std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
344 bool connected = *reinterpret_cast<const bool*>(rawData);
345 data.WriteString(networkId);
346 data.WriteBool(connected);
347
348 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
349 MessageParcel reply;
350 MessageOption option;
351 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_DEVICE_INFO),
352 data, reply, option);
353 }
354
AudioServerGetAudioParameterTest(const uint8_t * rawData,size_t size)355 void AudioServerGetAudioParameterTest(const uint8_t *rawData, size_t size)
356 {
357 if (rawData == nullptr || size < LIMITSIZE) {
358 return;
359 }
360
361 MessageParcel data;
362 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
363 std::string key(reinterpret_cast<const char*>(rawData), size - 1);
364 data.WriteString(key);
365
366 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
367 MessageParcel reply;
368 MessageOption option;
369 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_AUDIO_PARAMETER),
370 data, reply, option);
371 }
372
AudioServerSetAudioParameterTest(const uint8_t * rawData,size_t size)373 void AudioServerSetAudioParameterTest(const uint8_t *rawData, size_t size)
374 {
375 if (rawData == nullptr || size < LIMITSIZE) {
376 return;
377 }
378
379 MessageParcel data;
380 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
381 std::string key(reinterpret_cast<const char*>(rawData), size - 1);
382 std::string value(reinterpret_cast<const char*>(rawData), size - 1);
383 data.WriteString(key);
384 data.WriteString(value);
385
386 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
387 MessageParcel reply;
388 MessageOption option;
389 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_PARAMETER),
390 data, reply, option);
391 }
392
AudioServerSetMicrophoneMuteTest(const uint8_t * rawData,size_t size)393 void AudioServerSetMicrophoneMuteTest(const uint8_t *rawData, size_t size)
394 {
395 if (rawData == nullptr || size < LIMITSIZE) {
396 return;
397 }
398
399 MessageParcel data;
400 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
401 bool isMute = *reinterpret_cast<const bool*>(rawData);
402 data.WriteBool(isMute);
403
404 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
405 MessageParcel reply;
406 MessageOption option;
407 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_MICROPHONE_MUTE),
408 data, reply, option);
409 }
410
AudioServerSetAudioBalanceValueTest(const uint8_t * rawData,size_t size)411 void AudioServerSetAudioBalanceValueTest(const uint8_t *rawData, size_t size)
412 {
413 if (rawData == nullptr || size < LIMITSIZE) {
414 return;
415 }
416
417 MessageParcel data;
418 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
419 float audioBalance = *reinterpret_cast<const float*>(rawData);
420 data.WriteFloat(audioBalance);
421
422 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
423 MessageParcel reply;
424 MessageOption option;
425 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_BALANCE_VALUE),
426 data, reply, option);
427 }
428
AudioServerSetAudioSceneTest(const uint8_t * rawData,size_t size)429 void AudioServerSetAudioSceneTest(const uint8_t *rawData, size_t size)
430 {
431 if (rawData == nullptr || size < LIMITSIZE) {
432 return;
433 }
434
435 MessageParcel data;
436 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
437 AudioScene audioScene = *reinterpret_cast<const AudioScene*>(rawData);
438 DeviceType outputDevice = *reinterpret_cast<const DeviceType*>(rawData);
439 DeviceType inputDevice = *reinterpret_cast<const DeviceType*>(rawData);
440 data.WriteInt32(static_cast<int32_t>(audioScene));
441 data.WriteInt32(static_cast<int32_t>(outputDevice));
442 data.WriteInt32(static_cast<int32_t>(inputDevice));
443
444 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
445 MessageParcel reply;
446 MessageOption option;
447 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_SCENE),
448 data, reply, option);
449 }
450 } // namespace AudioStandard
451 } // namesapce OHOS
452
453 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)454 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
455 {
456 /* Run your code on data */
457 OHOS::AudioStandard::AudioServerFuzzTest(data, size);
458 OHOS::AudioStandard::AudioServerOffloadSetVolumeFuzzTest(data, size);
459 OHOS::AudioStandard::AudioServerNotifyStreamVolumeChangedFuzzTest(data, size);
460 OHOS::AudioStandard::AudioServerResetRouteForDisconnectFuzzTest(data, size);
461 OHOS::AudioStandard::AudioServerGetEffectLatencyTest(data, size);
462 OHOS::AudioStandard::AudioServerGetMaxAmplitudeTest(data, size);
463 OHOS::AudioStandard::AudioServerResetAudioEndpointTest(data, size);
464 OHOS::AudioStandard::AudioServerCreatePlaybackCapturerManagerTest(data, size);
465 OHOS::AudioStandard::AudioServerSetOutputDeviceSinkTest(data, size);
466 OHOS::AudioStandard::AudioServerRequestThreadPriorityTest(data, size);
467 OHOS::AudioStandard::AudioServerSetAudioMonoStateTest(data, size);
468 OHOS::AudioStandard::AudioServerSetVoiceVolumeTest(data, size);
469 OHOS::AudioStandard::AudioServerCheckRemoteDeviceStateTest(data, size);
470 OHOS::AudioStandard::AudioServerNotifyDeviceInfoTest(data, size);
471 OHOS::AudioStandard::AudioServerGetAudioParameterTest(data, size);
472 OHOS::AudioStandard::AudioServerSetAudioParameterTest(data, size);
473 OHOS::AudioStandard::AudioServerSetMicrophoneMuteTest(data, size);
474 OHOS::AudioStandard::AudioServerSetAudioBalanceValueTest(data, size);
475 OHOS::AudioStandard::AudioServerSetAudioSceneTest(data, size);
476 return 0;
477 }
478