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 #include <gtest/gtest.h>
16 #include <fstream>
17 #include "plugin/plugin_manager_v2.h"
18 #include "plugin/codec_plugin.h"
19 #include "avcodec_codec_name.h"
20 #include "avcodec_common.h"
21
22 using namespace std;
23 using namespace testing::ext;
24 using namespace OHOS::Media;
25 using namespace OHOS::Media::Plugins;
26
27 namespace OHOS {
28 namespace Media {
29 namespace Plugins {
30
31 const string CODEC_G711A_DEC_NAME = std::string(MediaAVCodec::AVCodecCodecName::AUDIO_DECODER_G711A_NAME);
32 constexpr int32_t G711A_SAMPLE_RATE = 16000;
33 constexpr int64_t G711A_BIT_RATE = 6000;
34 constexpr int32_t G711A_SIZE = 640; // 40ms
35 constexpr int32_t G711A_MAX_INPUT_SIZE = 8192;
36 constexpr int32_t G711A_MAX_OUTPUT_SIZE = G711A_MAX_INPUT_SIZE * 2;
37 static constexpr int32_t TEST_INPUT_SIZE = 8;
38 static const uint8_t TEST_INPUT_ARR[TEST_INPUT_SIZE] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
39 static const uint8_t TEST_OUTPUT_ARR[TEST_INPUT_SIZE * 2] = {0x80, 0xeb, 0x00, 0xa6, 0xf8, 0xfe, 0x60, 0xfb, 0x80, 0x1c,
40 0x00, 0x7a, 0x88, 0x01, 0xa0, 0x06};
41
42 class G711aUnitTest : public testing::Test, public DataCallback {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp() override;
47 void TearDown() override;
OnInputBufferDone(const shared_ptr<Media::AVBuffer> & inputBuffer)48 void OnInputBufferDone(const shared_ptr<Media::AVBuffer> &inputBuffer) override
49 {
50 (void)inputBuffer;
51 }
OnOutputBufferDone(const shared_ptr<Media::AVBuffer> & outputBuffer)52 void OnOutputBufferDone(const shared_ptr<Media::AVBuffer> &outputBuffer) override
53 {
54 (void)outputBuffer;
55 }
OnEvent(const shared_ptr<Plugins::PluginEvent> event)56 void OnEvent(const shared_ptr<Plugins::PluginEvent> event) override
57 {
58 (void)event;
59 }
60 protected:
61 // std::unique_ptr<std::ifstream> soFile_;
62 shared_ptr<Media::Meta> meta_ = nullptr;
63 shared_ptr<CodecPlugin> plugin_ = nullptr;
64 shared_ptr<AVBuffer> avBuffer_ = nullptr;
65 };
66
SetUpTestCase(void)67 void G711aUnitTest::SetUpTestCase(void)
68 {
69 }
70
TearDownTestCase(void)71 void G711aUnitTest::TearDownTestCase(void)
72 {
73 }
74
SetUp(void)75 void G711aUnitTest::SetUp(void)
76 {
77 auto tmp = PluginManagerV2::Instance().CreatePluginByName(CODEC_G711A_DEC_NAME);
78 plugin_ = reinterpret_pointer_cast<CodecPlugin>(tmp);
79 meta_ = make_shared<Media::Meta>();
80 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
81 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(G711A_SAMPLE_RATE);
82 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
83 meta_->Set<Tag::MEDIA_BITRATE>(G711A_BIT_RATE);
84 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
85 avBuffer_ = AVBuffer::CreateAVBuffer(avAllocator, (G711A_SIZE << 1));
86 avBuffer_->memory_->SetSize(G711A_SIZE);
87 }
88
TearDown(void)89 void G711aUnitTest::TearDown(void)
90 {
91 if (plugin_) {
92 plugin_->Release();
93 plugin_ = nullptr;
94 meta_ = nullptr;
95 }
96 }
97
98 HWTEST_F(G711aUnitTest, SetParamter_001, TestSize.Level1)
99 {
100 ASSERT_NE(plugin_, nullptr);
101 plugin_->Init();
102 plugin_->SetDataCallback(this);
103 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
104 meta_->Remove(Tag::AUDIO_CHANNEL_COUNT);
105 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
106 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
107 meta_->Remove(Tag::AUDIO_SAMPLE_RATE);
108 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
109 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(G711A_SAMPLE_RATE);
110 meta_->Remove(Tag::AUDIO_SAMPLE_FORMAT);
111 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
112 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
113 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(G711A_MAX_INPUT_SIZE);
114 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
115 plugin_->Start();
116 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
117 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
118 avBuffer_->memory_->SetSize(0);
119 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
120 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
121 plugin_->Flush();
122 plugin_->Stop();
123 EXPECT_EQ(plugin_->Reset(), Status::OK);
124 }
125
126 HWTEST_F(G711aUnitTest, SetParamter_002, TestSize.Level1)
127 {
128 ASSERT_NE(plugin_, nullptr);
129 plugin_->Init();
130 plugin_->SetDataCallback(this);
131 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(0);
132 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
133 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(-1);
134 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
135 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
136
137 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(0);
138 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
139 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(-1);
140 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
141 plugin_->Flush();
142 plugin_->Stop();
143 EXPECT_EQ(plugin_->Reset(), Status::OK);
144 }
145
146 HWTEST_F(G711aUnitTest, GetParamter_001, TestSize.Level1)
147 {
148 ASSERT_NE(plugin_, nullptr);
149 shared_ptr<Media::Meta> tmpMeta = make_shared<Media::Meta>();
150 int32_t maxInputSize = 0;
151 int32_t maxOutputSize = 0;
152 plugin_->Init();
153 plugin_->Reset();
154 plugin_->SetDataCallback(this);
155 int32_t testMaxInput = G711A_MAX_INPUT_SIZE + 1;
156 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(testMaxInput);
157 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
158 EXPECT_EQ(plugin_->GetParameter(tmpMeta), Status::OK);
159 tmpMeta->Get<Tag::AUDIO_MAX_INPUT_SIZE>(maxInputSize);
160 EXPECT_EQ(maxInputSize, testMaxInput);
161 tmpMeta->Get<Tag::AUDIO_MAX_OUTPUT_SIZE>(maxOutputSize);
162 EXPECT_EQ(maxOutputSize, testMaxInput * sizeof(int16_t));
163
164 testMaxInput = -1;
165 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(testMaxInput);
166 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
167 EXPECT_EQ(plugin_->GetParameter(tmpMeta), Status::OK);
168 tmpMeta->Get<Tag::AUDIO_MAX_INPUT_SIZE>(maxInputSize);
169 EXPECT_EQ(maxInputSize, G711A_MAX_INPUT_SIZE);
170 tmpMeta->Get<Tag::AUDIO_MAX_OUTPUT_SIZE>(maxOutputSize);
171 EXPECT_EQ(maxOutputSize, G711A_MAX_OUTPUT_SIZE);
172
173 testMaxInput = 0xf7777777 / 2 + 1;
174 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(testMaxInput);
175 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
176 EXPECT_EQ(plugin_->GetParameter(tmpMeta), Status::OK);
177 tmpMeta->Get<Tag::AUDIO_MAX_INPUT_SIZE>(maxInputSize);
178 EXPECT_EQ(maxInputSize, G711A_MAX_INPUT_SIZE);
179 tmpMeta->Get<Tag::AUDIO_MAX_OUTPUT_SIZE>(maxOutputSize);
180 EXPECT_EQ(maxOutputSize, G711A_MAX_OUTPUT_SIZE);
181 plugin_->Flush();
182 plugin_->Stop();
183 EXPECT_EQ(plugin_->Reset(), Status::OK);
184 }
185
186 HWTEST_F(G711aUnitTest, Decode_001, TestSize.Level1)
187 {
188 ASSERT_NE(plugin_, nullptr);
189 plugin_->Init();
190 plugin_->SetDataCallback(this);
191 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
192 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(G711A_MAX_INPUT_SIZE + 1);
193 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
194 plugin_->Start();
195 uint8_t *buffer = avBuffer_->memory_->GetAddr();
196 for (int i = 0; i < TEST_INPUT_SIZE; i++) {
197 buffer[i] = TEST_INPUT_ARR[i];
198 }
199 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
200 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
201 buffer = avBuffer_->memory_->GetAddr();
202 EXPECT_EQ(avBuffer_->memory_->GetSize(), G711A_SIZE * 2);
203 EXPECT_EQ(avBuffer_->duration_, 40000); // 40000us -> 40ms
204 for (int i = 0; i < TEST_INPUT_SIZE * 2; i++) {
205 EXPECT_EQ(buffer[i], TEST_OUTPUT_ARR[i]);
206 }
207 plugin_->Flush();
208 plugin_->Stop();
209 EXPECT_EQ(plugin_->Reset(), Status::OK);
210 }
211
212 HWTEST_F(G711aUnitTest, Decode_002, TestSize.Level1)
213 {
214 ASSERT_NE(plugin_, nullptr);
215 plugin_->Init();
216 plugin_->SetDataCallback(this);
217 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S32LE);
218 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
219 plugin_->Start();
220 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
221 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
222 EXPECT_NE(avBuffer_->duration_, 40000); // 40000us -> 40ms
223 plugin_->Flush();
224 plugin_->Stop();
225 EXPECT_EQ(plugin_->Reset(), Status::OK);
226 }
227
228 HWTEST_F(G711aUnitTest, Decode_003, TestSize.Level1)
229 {
230 ASSERT_NE(plugin_, nullptr);
231 plugin_->SetDataCallback(this);
232 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S32LE);
233 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
234 plugin_->Init();
235 plugin_->Start();
236 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
237 shared_ptr<AVBuffer> avBuffer = AVBuffer::CreateAVBuffer(avAllocator, (G711A_MAX_OUTPUT_SIZE << 1));
238 avBuffer->memory_->SetSize(G711A_MAX_OUTPUT_SIZE);
239 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer), Status::OK);
240 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer), Status::OK);
241 plugin_->Flush();
242 plugin_->Stop();
243 EXPECT_EQ(plugin_->Reset(), Status::OK);
244 }
245
246 HWTEST_F(G711aUnitTest, Decode_004, TestSize.Level1)
247 {
248 ASSERT_NE(plugin_, nullptr);
249 plugin_->Init();
250 plugin_->SetDataCallback(this);
251 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(0);
252 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
253 plugin_->Start();
254 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
255 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
256 EXPECT_NE(avBuffer_->duration_, 40000); // 40000us -> 40ms
257 plugin_->Flush();
258 plugin_->Stop();
259 EXPECT_EQ(plugin_->Reset(), Status::OK);
260 }
261
262 HWTEST_F(G711aUnitTest, Decode_005, TestSize.Level1)
263 {
264 ASSERT_NE(plugin_, nullptr);
265 plugin_->Init();
266 plugin_->SetDataCallback(this);
267 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(0);
268 EXPECT_NE(plugin_->SetParameter(meta_), Status::OK);
269 plugin_->Start();
270 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
271 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::OK);
272 EXPECT_NE(avBuffer_->duration_, 40000); // 40000us -> 40ms
273 plugin_->Flush();
274 plugin_->Stop();
275 EXPECT_EQ(plugin_->Reset(), Status::OK);
276 }
277
278 HWTEST_F(G711aUnitTest, Eos_001, TestSize.Level1)
279 {
280 ASSERT_NE(plugin_, nullptr);
281 plugin_->Init();
282 plugin_->SetDataCallback(this);
283 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
284 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(G711A_MAX_INPUT_SIZE);
285 EXPECT_EQ(plugin_->SetParameter(meta_), Status::OK);
286 plugin_->Start();
287 uint8_t *buffer = avBuffer_->memory_->GetAddr();
288 for (int i = 0; i < TEST_INPUT_SIZE; i++) {
289 buffer[i] = TEST_INPUT_ARR[i];
290 }
291 avBuffer_->memory_->SetSize(0);
292 avBuffer_->flag_ = MediaAVCodec::AVCODEC_BUFFER_FLAG_EOS;
293 EXPECT_EQ(plugin_->QueueInputBuffer(avBuffer_), Status::OK);
294 EXPECT_EQ(plugin_->QueueOutputBuffer(avBuffer_), Status::END_OF_STREAM);
295 buffer = avBuffer_->memory_->GetAddr();
296 plugin_->Flush();
297 plugin_->Stop();
298 EXPECT_EQ(plugin_->Reset(), Status::OK);
299 }
300 } // namespace Plugins
301 } // namespace Media
302 } // namespace OHOS