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
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS::Media;
24 using namespace OHOS::Media::Plugins;
25
26 namespace OHOS {
27 namespace Media {
28 namespace Plugins {
29 constexpr uint32_t CHANNELS = 2;
30 constexpr uint32_t SAMPLE_RATE = 44100;
31 constexpr uint32_t UNSUPPORTED_CHANNELS_MIN = 0;
32 constexpr uint32_t UNSUPPORTED_CHANNELS_MAX = 256;
33 constexpr uint32_t UNSUPPORTED_MAX_INPUT_SIZE = 80 * 1024 * 1024 + 1;
34 constexpr uint32_t UNSUPPORTED_SAMPLE_RATE = 0;
35 constexpr int32_t MAX_INPUT_SIZE = 4096;
36 constexpr int32_t MIN_INPUT_SIZE = 16;
37 constexpr AudioSampleFormat SAMPLE_FORMAT = AudioSampleFormat::SAMPLE_S16LE;
38 constexpr AudioSampleFormat RAW_SAMPLE_FORMAT = AudioSampleFormat::SAMPLE_S16BE;
39
40 class RawDecoderUnitTest : public testing::Test, public DataCallback {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp() override;
45 void TearDown() override;
46
OnInputBufferDone(const shared_ptr<Media::AVBuffer> & inputBuffer)47 void OnInputBufferDone(const shared_ptr<Media::AVBuffer> &inputBuffer) override
48 {
49 (void)inputBuffer;
50 std::shared_ptr<Meta> para = std::make_shared<Meta>();
51 // for mutex test
52 decoder_->GetParameter(para);
53 }
54
OnOutputBufferDone(const shared_ptr<Media::AVBuffer> & outputBuffer)55 void OnOutputBufferDone(const shared_ptr<Media::AVBuffer> &outputBuffer) override
56 {
57 (void)outputBuffer;
58 std::shared_ptr<Meta> para = std::make_shared<Meta>();
59 // for mutex test
60 decoder_->GetParameter(para);
61 }
62
OnEvent(const shared_ptr<Plugins::PluginEvent> event)63 void OnEvent(const shared_ptr<Plugins::PluginEvent> event) override
64 {
65 (void)event;
66 }
67
68 protected:
69 shared_ptr<Media::Meta> meta_ = nullptr;
70 shared_ptr<CodecPlugin> decoder_ = nullptr;
71 };
72
SetUpTestCase(void)73 void RawDecoderUnitTest::SetUpTestCase(void)
74 {
75 cout << "[SetUpTestCase]: " << endl;
76 }
77
TearDownTestCase(void)78 void RawDecoderUnitTest::TearDownTestCase(void)
79 {
80 cout << "[TearDownTestCase]: " << endl;
81 }
82
SetUp(void)83 void RawDecoderUnitTest::SetUp(void)
84 {
85 auto plugin = PluginManagerV2::Instance().CreatePluginByName("OH.Media.Codec.Decoder.Audio.Raw");
86 if (plugin == nullptr) {
87 cout << "not support raw" << endl;
88 return;
89 }
90 decoder_ = reinterpret_pointer_cast<CodecPlugin>(plugin);
91 decoder_->SetDataCallback(this);
92 meta_ = make_shared<Media::Meta>();
93 }
94
TearDown(void)95 void RawDecoderUnitTest::TearDown(void)
96 {
97 if (decoder_ != nullptr) {
98 decoder_ = nullptr;
99 }
100 }
101
102 HWTEST_F(RawDecoderUnitTest, InputBuffer_Nullptr_001, TestSize.Level1)
103 {
104 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
105 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
106 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
107 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
108 decoder_->SetParameter(meta_);
109 EXPECT_EQ(Status::OK, decoder_->Init());
110 EXPECT_EQ(Status::OK, decoder_->Prepare());
111 EXPECT_EQ(Status::OK, decoder_->Start());
112 EXPECT_EQ(Status::OK, decoder_->Stop()); // set inputBuffer_ nullptr
113 EXPECT_EQ(Status::OK, decoder_->Stop());
114 EXPECT_EQ(Status::OK, decoder_->Flush());
115 EXPECT_EQ(Status::OK, decoder_->Reset());
116 EXPECT_EQ(Status::OK, decoder_->Release());
117 }
118
119 HWTEST_F(RawDecoderUnitTest, GetMetaData_001, TestSize.Level1)
120 {
121 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE); // no AUDIO_CHANNEL_COUNT
122 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
123 }
124
125 HWTEST_F(RawDecoderUnitTest, GetMetaData_002, TestSize.Level1)
126 {
127 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS); // no AUDIO_SAMPLE_RATE
128 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
129 }
130
131 HWTEST_F(RawDecoderUnitTest, GetMetaData_003, TestSize.Level1)
132 {
133 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
134 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE); // no AUDIO_SAMPLE_FORMAT
135 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
136 }
137
138 HWTEST_F(RawDecoderUnitTest, GetMetaData_004, TestSize.Level1)
139 {
140 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
141 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
142 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT); // no AUDIO_RAW_SAMPLE_FORMAT
143 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
144 }
145
146 HWTEST_F(RawDecoderUnitTest, CheckFormat_001, TestSize.Level1)
147 {
148 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(UNSUPPORTED_CHANNELS_MIN); // check channels fail
149 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
150 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
151 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
152 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
153 }
154
155 HWTEST_F(RawDecoderUnitTest, CheckFormat_002, TestSize.Level1)
156 {
157 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
158 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(UNSUPPORTED_SAMPLE_RATE); // check sampleRate fail
159 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
160 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
161 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
162 }
163
164 HWTEST_F(RawDecoderUnitTest, CheckFormat_003, TestSize.Level1)
165 {
166 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
167 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
168 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(INVALID_WIDTH); // check sampleFormat fail
169 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
170 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
171 }
172
173 HWTEST_F(RawDecoderUnitTest, CheckFormat_004, TestSize.Level1)
174 {
175 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
176 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
177 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
178 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(INVALID_WIDTH); // check sampleFormat fail
179 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
180 }
181
182 HWTEST_F(RawDecoderUnitTest, CheckFormat_005, TestSize.Level1)
183 {
184 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(UNSUPPORTED_CHANNELS_MAX); // check channels fail
185 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
186 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
187 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
188 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
189 }
190
191 HWTEST_F(RawDecoderUnitTest, SetParameter_001, TestSize.Level1)
192 {
193 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
194 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
195 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
196 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
197 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(MAX_INPUT_SIZE);
198 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
199 }
200
201 HWTEST_F(RawDecoderUnitTest, SetParameter_002, TestSize.Level1)
202 {
203 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
204 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
205 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
206 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
207 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(MIN_INPUT_SIZE);
208 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
209 }
210
211 HWTEST_F(RawDecoderUnitTest, SetParameter_003, TestSize.Level1)
212 {
213 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
214 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
215 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
216 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
217 meta_->Set<Tag::AUDIO_MAX_INPUT_SIZE>(UNSUPPORTED_MAX_INPUT_SIZE);
218 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
219 }
220
221 HWTEST_F(RawDecoderUnitTest, GetFormatBytes_001, TestSize.Level1)
222 {
223 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
224 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
225 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(SAMPLE_FORMAT);
226 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(RAW_SAMPLE_FORMAT);
227 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
228 EXPECT_EQ(Status::OK, decoder_->Start());
229 std::shared_ptr<Meta> config = std::make_shared<Meta>();
230 EXPECT_EQ(Status::OK, decoder_->GetParameter(config));
231 }
232
233 HWTEST_F(RawDecoderUnitTest, GetFormatBytes_002, TestSize.Level1)
234 {
235 EXPECT_NE(Status::OK, decoder_->SetParameter(meta_));
236 EXPECT_EQ(Status::OK, decoder_->Start());
237 std::shared_ptr<Meta> config = std::make_shared<Meta>();
238 EXPECT_EQ(Status::OK, decoder_->GetParameter(config));
239 }
240
241 HWTEST_F(RawDecoderUnitTest, QueueInputBuffer_001, TestSize.Level1)
242 {
243 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
244 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
245 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32LE);
246 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F64BE); // SAMPLE_F64BE
247 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
248 int32_t oneFrameSize = 64000; // capacity
249 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
250 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
251 inputBuffer->memory_->SetSize(64000); // size % bytesSize == 0 && size > maxInputSize_
252 EXPECT_EQ(Status::OK, decoder_->QueueInputBuffer(inputBuffer));
253 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
254 EXPECT_NE(Status::OK, decoder_->QueueOutputBuffer(outputBuffer));
255 }
256
257 HWTEST_F(RawDecoderUnitTest, QueueInputBuffer_002, TestSize.Level1)
258 {
259 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
260 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
261 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32LE);
262 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F64BE); // SAMPLE_F64BE
263 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
264 int32_t oneFrameSize = 9; // capacity
265 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
266 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
267 inputBuffer->memory_->SetSize(9); // size % bytesSize != 0
268 EXPECT_EQ(Status::ERROR_UNKNOWN, decoder_->QueueInputBuffer(inputBuffer));
269 }
270
271 HWTEST_F(RawDecoderUnitTest, QueueInputBuffer_003, TestSize.Level1)
272 {
273 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
274 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
275 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32LE);
276 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32BE); // not SAMPLE_F64BE
277 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
278 int32_t oneFrameSize = 16000; // capacity
279 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
280 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
281 inputBuffer->memory_->SetSize(16000); // size % bytesSize == 0
282 EXPECT_EQ(Status::OK, decoder_->QueueInputBuffer(inputBuffer));
283 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
284 EXPECT_NE(Status::OK, decoder_->QueueOutputBuffer(outputBuffer));
285 }
286
287 HWTEST_F(RawDecoderUnitTest, QueueInputBuffer_004, TestSize.Level1)
288 {
289 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNELS);
290 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
291 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32LE);
292 meta_->Set<Tag::AUDIO_RAW_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_F32BE); // not SAMPLE_F64BE
293 EXPECT_EQ(Status::OK, decoder_->SetParameter(meta_));
294 int32_t oneFrameSize = 16; // capacity
295 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
296 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
297 inputBuffer->memory_->SetSize(16); // size % bytesSize == 0 && size < maxInputSize_
298 EXPECT_EQ(Status::OK, decoder_->QueueInputBuffer(inputBuffer));
299 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, oneFrameSize);
300 EXPECT_EQ(Status::OK, decoder_->QueueOutputBuffer(outputBuffer));
301 }
302 } // namespace Plugins
303 }
304 }