1 /*
2 * Copyright (c) 2025 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 #include <vector>
20 #include <memory>
21 #include <queue>
22 #include <string>
23 #include "hpae_resample_node.h"
24 #include "hpae_source_input_node.h"
25 #include "audio_engine_log.h"
26 #include "audio_info.h"
27 #include <fstream>
28 #include <streambuf>
29 #include <string>
30 using namespace std;
31 using namespace OHOS::AudioStandard::HPAE;
32
33
34 namespace OHOS {
35 namespace AudioStandard {
36
37 static const uint8_t *RAW_DATA = nullptr;
38 static size_t g_dataSize = 0;
39 static size_t g_pos;
40 const size_t THRESHOLD = 10;
41 const uint32_t TEST_ID = 1243;
42 const uint32_t TEST_ID2 = 1246;
43 const uint32_t TEST_FRAMELEN1 = 960;
44 const uint32_t TEST_FRAMELEN2 = 640;
45
46 template<class T>
GetData()47 T GetData()
48 {
49 T object {};
50 size_t objectSize = sizeof(object);
51 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
52 return object;
53 }
54 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
55 if (ret != EOK) {
56 return {};
57 }
58 g_pos += objectSize;
59 return object;
60 }
61
62 template<class T>
GetArrLength(T & arr)63 uint32_t GetArrLength(T& arr)
64 {
65 if (arr == nullptr) {
66 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
67 return 0;
68 }
69 return sizeof(arr) / sizeof(arr[0]);
70 }
71
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)72 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
73 {
74 nodeInfo.nodeId = TEST_ID;
75 nodeInfo.frameLen = TEST_FRAMELEN1;
76 nodeInfo.samplingRate = SAMPLE_RATE_48000;
77 nodeInfo.channels = STEREO;
78 nodeInfo.format = SAMPLE_F32LE;
79 }
80
GetTestDtsNodeInfo(HpaeNodeInfo & nodeInfo)81 static void GetTestDtsNodeInfo(HpaeNodeInfo &nodeInfo)
82 {
83 nodeInfo.nodeId = TEST_ID2;
84 nodeInfo.frameLen = TEST_FRAMELEN2;
85 nodeInfo.samplingRate = SAMPLE_RATE_44100;
86 nodeInfo.channels = CHANNEL_4;
87 nodeInfo.format = SAMPLE_F32LE;
88 }
89
HpaeResampleNodeResetFuzzTest()90 void HpaeResampleNodeResetFuzzTest()
91 {
92 HpaeNodeInfo nodeInfo;
93 HpaeNodeInfo dstNodeInfo;
94 GetTestNodeInfo(nodeInfo);
95 GetTestDtsNodeInfo(dstNodeInfo);
96 auto hpaeResampleNode = std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo, ResamplerType::PRORESAMPLER);
97 hpaeResampleNode->GetSampleRate();
98 hpaeResampleNode->GetFrameLen();
99 hpaeResampleNode->GetChannelCount();
100 hpaeResampleNode->GetBitWidth();
101 hpaeResampleNode->Reset();
102 }
103
HpaeResampleNodeSignalProcessFuzzTest01()104 void HpaeResampleNodeSignalProcessFuzzTest01()
105 {
106 HpaeNodeInfo nodeInfo;
107 HpaeNodeInfo dstNodeInfo;
108 GetTestNodeInfo(nodeInfo);
109 GetTestDtsNodeInfo(dstNodeInfo);
110 auto hpaeResampleNode = std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo);
111 std::vector<HpaePcmBuffer *> inputs;
112 hpaeResampleNode->SignalProcess(inputs);
113 }
114
HpaeResampleNodeSignalProcessFuzzTest02()115 void HpaeResampleNodeSignalProcessFuzzTest02()
116 {
117 HpaeNodeInfo nodeInfo;
118 HpaeNodeInfo dstNodeInfo;
119 GetTestNodeInfo(nodeInfo);
120 GetTestDtsNodeInfo(dstNodeInfo);
121 auto hpaeResampleNode = std::make_shared<HpaeResampleNode>(nodeInfo, dstNodeInfo);
122 std::vector<HpaePcmBuffer *> inputs;
123 PcmBufferInfo pcmBufferInfo(STEREO, TEST_FRAMELEN1, SAMPLE_RATE_48000);
124 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
125 inputs.emplace_back(&hpaePcmBuffer);
126 hpaeResampleNode->SignalProcess(inputs);
127 }
128
HpaeResampleNodeConnectAndDisconnectWithInfoFuzzTest()129 void HpaeResampleNodeConnectAndDisconnectWithInfoFuzzTest()
130 {
131 HpaeNodeInfo srcNodeInfo;
132 HpaeNodeInfo dstNodeInfo;
133 GetTestNodeInfo(srcNodeInfo);
134 GetTestDtsNodeInfo(dstNodeInfo);
135 auto hpaeResampleNode = std::make_shared<HpaeResampleNode>(srcNodeInfo, dstNodeInfo);
136 auto hpaeInputNode = std::make_shared<HpaeSourceInputNode>(srcNodeInfo);
137 hpaeResampleNode->ConnectWithInfo(hpaeInputNode, srcNodeInfo);
138 hpaeResampleNode->DisConnectWithInfo(hpaeInputNode, srcNodeInfo);
139 }
140
141 typedef void (*TestFuncs[4])();
142
143 TestFuncs g_testFuncs = {
144 HpaeResampleNodeResetFuzzTest,
145 HpaeResampleNodeSignalProcessFuzzTest01,
146 HpaeResampleNodeSignalProcessFuzzTest02,
147 HpaeResampleNodeConnectAndDisconnectWithInfoFuzzTest,
148 };
149
FuzzTest(const uint8_t * rawData,size_t size)150 bool FuzzTest(const uint8_t* rawData, size_t size)
151 {
152 if (rawData == nullptr) {
153 return false;
154 }
155
156 // initialize data
157 RAW_DATA = rawData;
158 g_dataSize = size;
159 g_pos = 0;
160
161 uint32_t code = GetData<uint32_t>();
162 uint32_t len = GetArrLength(g_testFuncs);
163 if (len > 0) {
164 g_testFuncs[code % len]();
165 } else {
166 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
167 }
168
169 return true;
170 }
171
172 } // namespace AudioStandard
173 } // namesapce OHOS
174
175 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)176 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
177 {
178 if (size < OHOS::AudioStandard::THRESHOLD) {
179 return 0;
180 }
181
182 OHOS::AudioStandard::FuzzTest(data, size);
183 return 0;
184 }
185