1 /*
2 * Copyright (C) 2024 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 <gtest/gtest.h>
17 #include <iostream>
18 #include <string>
19 #include "plugin/plugin_manager_v2.h"
20 #include "media_codec.h"
21
22 using namespace std;
23 using namespace testing::ext;
24 using namespace OHOS::MediaAVCodec;
25
26 namespace {
27 constexpr uint32_t CHANNEL_COUNT_MONO = 1;
28 constexpr uint32_t CHANNEL_COUNT_STEREO = 2;
29 constexpr uint32_t SAMPLE_RATE_48k = 48000;
30 constexpr uint32_t SAMPLE_RATE_8k = 8000;
31 constexpr uint32_t BIT_RATE_16k = 16000;
32 constexpr uint32_t AUDIO_AAC_IS_ADTS = 1;
33 constexpr uint32_t DEFAULT_BUFFER_NUM = 1;
34 constexpr int32_t BUFFER_CAPACITY_SAMLL = 100;
35 constexpr int32_t BUFFER_CAPACITY_DEFAULT = 5120;
36 constexpr uint32_t DEFAULT_FLAC_BITRATE = 261000;
37 constexpr uint32_t FLAC_96K_SAMPLE_RATE = 96000;
38 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
39 const std::string AAC_MIME_TYPE = "audio/mp4a-latm";
40 const std::string UNKNOW_MIME_TYPE = "audio/unknow";
41 const std::string AAC_DEC_CODEC_NAME = "OH.Media.Codec.Decoder.Audio.AAC";
42 } // namespace
43
44 namespace OHOS {
45 namespace MediaAVCodec {
46
47 class AudioCodecCallback : public Media::AudioBaseCodecCallback {
48 public:
AudioCodecCallback()49 AudioCodecCallback()
50 {}
~AudioCodecCallback()51 virtual ~AudioCodecCallback()
52 {}
53
54 void OnError(Media::CodecErrorType errorType, int32_t errorCode) override;
55
56 void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer) override;
57
58 void OnOutputFormatChanged(const std::shared_ptr<Meta> &format) override;
59 };
60
OnError(Media::CodecErrorType errorType,int32_t errorCode)61 void AudioCodecCallback::OnError(Media::CodecErrorType errorType, int32_t errorCode)
62 {
63 (void)errorType;
64 (void)errorCode;
65 }
66
OnOutputBufferDone(const std::shared_ptr<AVBuffer> & outputBuffer)67 void AudioCodecCallback::OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
68 {
69 (void)outputBuffer;
70 }
71
OnOutputFormatChanged(const std::shared_ptr<Meta> & format)72 void AudioCodecCallback::OnOutputFormatChanged(const std::shared_ptr<Meta> &format)
73 {
74 (void)format;
75 }
76
77 class TestCodecCallback : public Media::CodecCallback {
78 public:
TestCodecCallback()79 TestCodecCallback()
80 {}
~TestCodecCallback()81 virtual ~TestCodecCallback()
82 {}
83
84 void OnError(Media::CodecErrorType errorType, int32_t errorCode) override;
85
86 void OnOutputFormatChanged(const std::shared_ptr<Meta> &format) override;
87 };
88
OnError(Media::CodecErrorType errorType,int32_t errorCode)89 void TestCodecCallback::OnError(Media::CodecErrorType errorType, int32_t errorCode)
90 {
91 (void)errorType;
92 (void)errorCode;
93 }
94
OnOutputFormatChanged(const std::shared_ptr<Meta> & format)95 void TestCodecCallback::OnOutputFormatChanged(const std::shared_ptr<Meta> &format)
96 {
97 (void)format;
98 }
99
100 class AudioMediaCodecUnitTest : public testing::Test {
101 public:
102 static void SetUpTestCase(void);
103 static void TearDownTestCase(void);
104 void SetUp();
105 void TearDown();
106
107 std::shared_ptr<Plugins::CodecPlugin> CreatePlugin(const std::string &codecName);
108 };
109
SetUpTestCase(void)110 void AudioMediaCodecUnitTest::SetUpTestCase(void)
111 {
112 cout << "[SetUpTestCase]: " << endl;
113 }
114
TearDownTestCase(void)115 void AudioMediaCodecUnitTest::TearDownTestCase(void)
116 {
117 cout << "[TearDownTestCase]: " << endl;
118 }
119
SetUp(void)120 void AudioMediaCodecUnitTest::SetUp(void)
121 {
122 cout << "[SetUp]: SetUp!!!" << endl;
123 }
124
TearDown(void)125 void AudioMediaCodecUnitTest::TearDown(void)
126 {
127 cout << "[TearDown]: over!!!" << endl;
128 }
129
CreatePlugin(const std::string & codecName)130 std::shared_ptr<Plugins::CodecPlugin> AudioMediaCodecUnitTest::CreatePlugin(const std::string &codecName)
131 {
132 auto plugin = Plugins::PluginManagerV2::Instance().CreatePluginByName(codecName);
133 if (plugin == nullptr) {
134 return nullptr;
135 }
136 return std::reinterpret_pointer_cast<Plugins::CodecPlugin>(plugin);
137 }
138
139 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_01, TestSize.Level1)
140 {
141 auto mediaCodec = std::make_shared<MediaCodec>();
142 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
143 mediaCodec = nullptr;
144 }
145
146 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_02, TestSize.Level1)
147 {
148 auto mediaCodec = std::make_shared<MediaCodec>();
149 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
150 mediaCodec = nullptr;
151 }
152
153 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_03, TestSize.Level1)
154 {
155 auto mediaCodec = std::make_shared<MediaCodec>();
156 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, false));
157 mediaCodec = nullptr;
158 }
159
160 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_04, TestSize.Level1)
161 {
162 auto mediaCodec = std::make_shared<MediaCodec>();
163 EXPECT_NE(0, mediaCodec->Init(UNKNOW_MIME_TYPE, true));
164 mediaCodec = nullptr;
165 }
166
167 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_05, TestSize.Level1)
168 {
169 auto mediaCodec = std::make_shared<MediaCodec>();
170 EXPECT_NE(0, mediaCodec->Init(UNKNOW_MIME_TYPE, false));
171 mediaCodec = nullptr;
172 }
173
174 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_06, TestSize.Level1)
175 {
176 auto mediaCodec = std::make_shared<MediaCodec>();
177 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, false));
178 EXPECT_NE(0, mediaCodec->Init(UNKNOW_MIME_TYPE, false));
179 mediaCodec = nullptr;
180 }
181
182 HWTEST_F(AudioMediaCodecUnitTest, Test_Init_07, TestSize.Level1)
183 {
184 auto mediaCodec = std::make_shared<MediaCodec>();
185 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
186 EXPECT_NE(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
187 mediaCodec = nullptr;
188 }
189
190 HWTEST_F(AudioMediaCodecUnitTest, Test_Configure_08, TestSize.Level1)
191 {
192 auto mediaCodec = std::make_shared<MediaCodec>();
193 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
194 EXPECT_NE(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
195 mediaCodec = nullptr;
196 }
197
198 HWTEST_F(AudioMediaCodecUnitTest, Test_Prepare_01, TestSize.Level1)
199 {
200 auto mediaCodec = std::make_shared<MediaCodec>();
201 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
202 EXPECT_NE(0, mediaCodec->Prepare());
203 mediaCodec = nullptr;
204 }
205
206 HWTEST_F(AudioMediaCodecUnitTest, Test_SetDumpInfo_01, TestSize.Level1)
207 {
208 auto mediaCodec = std::make_shared<MediaCodec>();
209 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
210 mediaCodec->SetDumpInfo(false, 0);
211 mediaCodec->SetDumpInfo(true, 0);
212 mediaCodec->SetDumpInfo(false, 0);
213 mediaCodec->SetDumpInfo(true, 1); // 1:fd param
214 mediaCodec = nullptr;
215 }
216
217 HWTEST_F(AudioMediaCodecUnitTest, Test_OnDumpInfo_01, TestSize.Level1)
218 {
219 auto mediaCodec = std::make_shared<MediaCodec>();
220 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, false));
221 auto meta = std::make_shared<Meta>();
222 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
223 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
224 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
225 EXPECT_EQ(0, mediaCodec->Configure(meta));
226 auto implBufferQueue_ =
227 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
228 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
229 EXPECT_EQ(0, mediaCodec->Prepare());
230 mediaCodec->OnDumpInfo(0);
231 mediaCodec->OnDumpInfo(1); // 1:fd param
232 mediaCodec = nullptr;
233 }
234
235 HWTEST_F(AudioMediaCodecUnitTest, Test_OnDumpInfo_02, TestSize.Level1)
236 {
237 auto mediaCodec = std::make_shared<MediaCodec>();
238 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
239 mediaCodec->OnDumpInfo(-1);
240 }
241
242 HWTEST_F(AudioMediaCodecUnitTest, Test_ProcessInputBuffer_01, TestSize.Level1)
243 {
244 auto mediaCodec = std::make_shared<MediaCodec>();
245 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, false));
246 mediaCodec->ProcessInputBuffer();
247 mediaCodec = nullptr;
248 }
249
250 HWTEST_F(AudioMediaCodecUnitTest, Test_SetCodecCallback_01, TestSize.Level1)
251 {
252 auto mediaCodec = std::make_shared<MediaCodec>();
253 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
254 std::shared_ptr<Media::CodecCallback> codecCallback = std::make_shared<TestCodecCallback>();
255 EXPECT_EQ(0, mediaCodec->SetCodecCallback(codecCallback));
256 mediaCodec = nullptr;
257 }
258
259 HWTEST_F(AudioMediaCodecUnitTest, Test_SetCodecCallback_02, TestSize.Level1)
260 {
261 auto mediaCodec = std::make_shared<MediaCodec>();
262 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
263 std::shared_ptr<Media::AudioBaseCodecCallback> mediaCallback = std::make_shared<AudioCodecCallback>();
264 EXPECT_EQ(0, mediaCodec->SetCodecCallback(mediaCallback));
265 mediaCodec = nullptr;
266 }
267
268 HWTEST_F(AudioMediaCodecUnitTest, Test_SetOutputSurface_01, TestSize.Level1)
269 {
270 auto mediaCodec = std::make_shared<MediaCodec>();
271 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
272 sptr<Surface> surface = nullptr;
273 EXPECT_EQ(0, mediaCodec->SetOutputSurface(surface));
274 mediaCodec = nullptr;
275 }
276
277 HWTEST_F(AudioMediaCodecUnitTest, Test_GetInputSurface_01, TestSize.Level1)
278 {
279 auto mediaCodec = std::make_shared<MediaCodec>();
280 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
281 EXPECT_EQ(nullptr, mediaCodec->GetInputSurface());
282 mediaCodec = nullptr;
283 }
284
285 HWTEST_F(AudioMediaCodecUnitTest, Test_GetInputBufferQueue_01, TestSize.Level1)
286 {
287 auto mediaCodec = std::make_shared<MediaCodec>();
288 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
289 auto implBufferQueue_ =
290 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
291 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
292
293 sptr<Surface> surface = nullptr;
294 EXPECT_EQ(0, mediaCodec->SetOutputSurface(surface));
295
296 auto meta = std::make_shared<Meta>();
297 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
298 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
299 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
300 EXPECT_EQ(0, mediaCodec->Configure(meta));
301 EXPECT_EQ((int32_t) Status::ERROR_UNKNOWN, mediaCodec->Prepare());
302 EXPECT_EQ(nullptr, mediaCodec->GetInputSurface());
303 }
304
305 HWTEST_F(AudioMediaCodecUnitTest, Test_GetInputBufferQueue_02, TestSize.Level1)
306 {
307 auto mediaCodec = std::make_shared<MediaCodec>();
308 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
309 sptr<Surface> surface = nullptr;
310 EXPECT_EQ(0, mediaCodec->SetOutputSurface(surface));
311 EXPECT_NE((int32_t) Status::OK, mediaCodec->Prepare());
312 }
313
314 HWTEST_F(AudioMediaCodecUnitTest, Test_GetInputBufferQueue_03, TestSize.Level1)
315 {
316 auto mediaCodec = std::make_shared<MediaCodec>();
317 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
318 auto implBufferQueue_ =
319 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
320 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
321 auto meta = std::make_shared<Meta>();
322 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
323 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
324 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
325 EXPECT_EQ(0, mediaCodec->Configure(meta));
326 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Prepare());
327
328 EXPECT_EQ(nullptr, mediaCodec->GetInputSurface());
329 }
330
331 HWTEST_F(AudioMediaCodecUnitTest, Test_Stop_01, TestSize.Level1)
332 {
333 auto mediaCodec = std::make_shared<MediaCodec>();
334 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
335 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
336 auto implBufferQueue_ =
337 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
338 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
339 auto meta = std::make_shared<Meta>();
340 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
341 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
342 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
343 EXPECT_EQ(0, mediaCodec->Configure(meta));
344
345 EXPECT_EQ((int32_t) Status::ERROR_INVALID_STATE, mediaCodec->Stop());
346 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Release());
347 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
348 }
349
350 HWTEST_F(AudioMediaCodecUnitTest, Test_Flush_01, TestSize.Level1)
351 {
352 auto mediaCodec = std::make_shared<MediaCodec>();
353 EXPECT_EQ(0, mediaCodec->Init(AAC_DEC_CODEC_NAME));
354
355 EXPECT_NE((int32_t) Status::OK, mediaCodec->Flush());
356 auto implBufferQueue_ =
357 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
358 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
359 auto meta = std::make_shared<Meta>();
360 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
361 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
362 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
363 EXPECT_EQ(0, mediaCodec->Configure(meta));
364 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Prepare());
365 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Start());
366 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Flush());
367 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Flush());
368 }
369
370 HWTEST_F(AudioMediaCodecUnitTest, Test_Reset_01, TestSize.Level1)
371 {
372 auto mediaCodec = std::make_shared<MediaCodec>();
373 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Reset());
374 }
375
376 HWTEST_F(AudioMediaCodecUnitTest, Test_Release_01, TestSize.Level1)
377 {
378 auto mediaCodec = std::make_shared<MediaCodec>();
379 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Release());
380 }
381
382 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseEncoderPlugin_01, TestSize.Level1)
383 {
384 // AudioSampleFormat2AVSampleFormat fail branch
385 std::string codecName = "OH.Media.Codec.Encoder.Audio.Flac";
386 auto plugin = CreatePlugin(codecName);
387 EXPECT_NE(nullptr, plugin);
388 std::shared_ptr<AVAllocator> avAllocator =
389 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
390 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
391 EXPECT_EQ(Status::ERROR_INVALID_DATA, plugin->QueueInputBuffer(inputBuffer));
392 inputBuffer->memory_->SetSize(10); //test 10
393 EXPECT_EQ(Status::ERROR_WRONG_STATE, plugin->QueueInputBuffer(inputBuffer));
394 }
395
396 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseEncoderPlugin_02, TestSize.Level1)
397 {
398 // AudioSampleFormat2AVSampleFormat fail branch
399 std::string codecName = "OH.Media.Codec.Encoder.Audio.Flac";
400 auto plugin = CreatePlugin(codecName);
401 EXPECT_NE(nullptr, plugin);
402 auto meta = std::make_shared<Meta>();
403 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
404 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
405 meta->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_96K_SAMPLE_RATE);
406 meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_FLAC_BITRATE);
407 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Plugins::AudioChannelLayout::STEREO);
408 meta->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
409 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
410 std::shared_ptr<AVAllocator> avAllocator =
411 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
412 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
413 inputBuffer->memory_->SetSize(10); //test 10
414 }
415
416 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_01, TestSize.Level1)
417 {
418 // AudioSampleFormat2AVSampleFormat fail branch
419 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
420 auto plugin = CreatePlugin(codecName);
421 EXPECT_NE(nullptr, plugin);
422 auto meta = std::make_shared<Meta>();
423 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S24P);
424 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
425 EXPECT_NE(Status::OK, plugin->Start());
426 }
427
428 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_02, TestSize.Level1)
429 {
430 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
431 auto plugin = CreatePlugin(codecName);
432 EXPECT_NE(nullptr, plugin);
433 std::shared_ptr<AVAllocator> avAllocator =
434 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
435 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
436 inputBuffer->memory_ = nullptr;
437 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
438 }
439
440 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_03, TestSize.Level1)
441 {
442 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
443 auto plugin = CreatePlugin(codecName);
444 EXPECT_NE(nullptr, plugin);
445 std::shared_ptr<AVAllocator> avAllocator =
446 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
447 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
448 inputBuffer->memory_->SetSize(0);
449 inputBuffer->flag_ = 0;
450 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
451 }
452
453 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_04, TestSize.Level1)
454 {
455 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
456 auto plugin = CreatePlugin(codecName);
457 EXPECT_NE(nullptr, plugin);
458 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
459 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
460 inputBuffer->memory_->SetSize(1); // 1:data size
461 inputBuffer->flag_ = 0;
462 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
463 }
464
465 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_05, TestSize.Level1)
466 {
467 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
468 auto plugin = CreatePlugin(codecName);
469 EXPECT_NE(nullptr, plugin);
470 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
471 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
472 plugin->QueueOutputBuffer(outputBuffer);
473 }
474
475 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_06, TestSize.Level1)
476 {
477 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
478 auto plugin = CreatePlugin(codecName);
479 EXPECT_NE(nullptr, plugin);
480 plugin->Init();
481
482 auto meta = std::make_shared<Meta>();
483 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
484 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
485 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
486 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
487 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
488 EXPECT_EQ(Status::OK, plugin->Prepare());
489 EXPECT_EQ(Status::OK, plugin->Start());
490 EXPECT_EQ(Status::OK, plugin->Flush());
491 }
492
493 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_07, TestSize.Level1)
494 {
495 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
496 auto plugin = CreatePlugin(codecName);
497 EXPECT_NE(nullptr, plugin);
498 plugin->Init();
499
500 auto meta = std::make_shared<Meta>();
501 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
502 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
503 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
504 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_8k);
505 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
506 EXPECT_EQ(Status::OK, plugin->Prepare());
507 EXPECT_EQ(Status::OK, plugin->Start());
508 EXPECT_EQ(Status::OK, plugin->Flush());
509 }
510
511 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_08, TestSize.Level1)
512 {
513 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
514 auto plugin = CreatePlugin(codecName);
515 EXPECT_NE(nullptr, plugin);
516 plugin->Init();
517
518 auto meta = std::make_shared<Meta>();
519 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(0);
520 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
521 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
522 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
523 meta->Set<Tag::AUDIO_MAX_INPUT_SIZE>(100); // 100: input buffer size
524 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
525 EXPECT_EQ(Status::OK, plugin->Prepare());
526 EXPECT_EQ(Status::OK, plugin->Start());
527 }
528
529 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_09, TestSize.Level1)
530 {
531 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
532 auto plugin = CreatePlugin(codecName);
533 EXPECT_NE(nullptr, plugin);
534 plugin->Init();
535
536 auto meta = std::make_shared<Meta>();
537 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(0);
538 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
539 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
540 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
541 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
542 EXPECT_EQ(Status::OK, plugin->Start());
543 EXPECT_EQ(Status::OK, plugin->Stop());
544 }
545
546 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_10, TestSize.Level1)
547 {
548 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
549 auto plugin = CreatePlugin(codecName);
550 EXPECT_NE(nullptr, plugin);
551 std::shared_ptr<AVAllocator> avAllocator =
552 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
553 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
554 inputBuffer = nullptr;
555 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
556 }
557
558 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_11, TestSize.Level1)
559 {
560 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
561 auto plugin = CreatePlugin(codecName);
562 EXPECT_NE(nullptr, plugin);
563
564 EXPECT_EQ(Status::OK, plugin->Flush());
565 }
566
567 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_01, TestSize.Level1)
568 {
569 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
570 auto plugin = CreatePlugin(codecName);
571 EXPECT_NE(nullptr, plugin);
572 EXPECT_EQ(Status::OK, plugin->Init());
573
574 auto meta = std::make_shared<Meta>();
575 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
576 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
577 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
578 meta->Set<Tag::MEDIA_BITRATE>(320000); // 320000: valid param
579 meta->Set<Tag::AUDIO_MAX_INPUT_SIZE>(100); // 100: input buffer size
580 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
581 }
582
583 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_02, TestSize.Level1)
584 {
585 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
586 auto plugin = CreatePlugin(codecName);
587 EXPECT_NE(nullptr, plugin);
588 EXPECT_EQ(Status::OK, plugin->Init());
589
590 auto meta = std::make_shared<Meta>();
591 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
592 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
593 meta->Set<Tag::AUDIO_SAMPLE_RATE>(8000); // sampleRate:8000 bitRate:80000 invalid
594 meta->Set<Tag::MEDIA_BITRATE>(80000); // sampleRate:8000 bitRate:80000 invalid
595 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
596 meta->Set<Tag::AUDIO_SAMPLE_RATE>(22050); // sampleRate:22050 bitRate:192000 invalid
597 meta->Set<Tag::MEDIA_BITRATE>(192000); // sampleRate:22050 bitRate:192000 invalid
598 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
599 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // sampleRate:44100 bitRate:16000 invalid
600 meta->Set<Tag::MEDIA_BITRATE>(16000); // sampleRate:44100 bitRate:16000 invalid
601 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
602 }
603
604 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_03, TestSize.Level1)
605 {
606 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
607 auto plugin = CreatePlugin(codecName);
608 EXPECT_NE(nullptr, plugin);
609 EXPECT_EQ(Status::OK, plugin->Init());
610 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
611 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
612 inputBuffer->memory_->SetSize(-1); // -1: invalid param
613 inputBuffer->flag_ = 0;
614 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
615 }
616
617 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_04, TestSize.Level1)
618 {
619 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
620 auto plugin = CreatePlugin(codecName);
621 EXPECT_NE(nullptr, plugin);
622 EXPECT_EQ(Status::OK, plugin->Init());
623 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
624 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
625 inputBuffer->memory_->SetSize(0); // 0: invalid param
626 inputBuffer->flag_ = 0;
627 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
628 }
629
630 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_05, TestSize.Level1)
631 {
632 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
633 auto plugin = CreatePlugin(codecName);
634 EXPECT_NE(nullptr, plugin);
635 EXPECT_EQ(Status::OK, plugin->Init());
636
637 auto meta = std::make_shared<Meta>();
638 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_MONO);
639 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
640 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
641 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
642 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
643 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
644 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
645 inputBuffer->memory_->SetSize(3000); // 3000: invalid param
646 inputBuffer->flag_ = 0;
647 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
648 }
649
650 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_06, TestSize.Level1)
651 {
652 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
653 auto plugin = CreatePlugin(codecName);
654 EXPECT_NE(nullptr, plugin);
655 EXPECT_EQ(Status::OK, plugin->Init());
656
657 auto meta = std::make_shared<Meta>();
658 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
659 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
660 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
661 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
662 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
663 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
664 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
665 inputBuffer->memory_->SetSize(5000); // 5000: invalid param
666 inputBuffer->flag_ = 0;
667 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
668 }
669
670 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_07, TestSize.Level1)
671 {
672 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
673 auto plugin = CreatePlugin(codecName);
674 EXPECT_NE(nullptr, plugin);
675 EXPECT_EQ(Status::OK, plugin->Init());
676
677 auto meta = std::make_shared<Meta>();
678 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_MONO);
679 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
680 meta->Set<Tag::AUDIO_SAMPLE_RATE>(16000); // 16000: sample rate
681 meta->Set<Tag::MEDIA_BITRATE>(BIT_RATE_16k);
682 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
683 EXPECT_EQ(Status::OK, plugin->Prepare());
684 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
685 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
686 outputBuffer->memory_->SetSize(0); // invalid param
687 outputBuffer->flag_ = 0;
688 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(outputBuffer));
689 EXPECT_EQ(Status::OK, plugin->Flush());
690 EXPECT_EQ(Status::OK, plugin->Reset());
691 }
692
693 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_08, TestSize.Level1)
694 {
695 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
696 auto plugin = CreatePlugin(codecName);
697 EXPECT_NE(nullptr, plugin);
698 std::shared_ptr<AVAllocator> avAllocator =
699 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
700 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
701 inputBuffer = nullptr;
702 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
703 }
704
705 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_09, TestSize.Level1)
706 {
707 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
708 auto plugin = CreatePlugin(codecName);
709 EXPECT_NE(nullptr, plugin);
710
711 EXPECT_EQ(Status::OK, plugin->Reset());
712 }
713
714 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_10, TestSize.Level1)
715 {
716 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
717 auto plugin = CreatePlugin(codecName);
718 EXPECT_NE(nullptr, plugin);
719
720 EXPECT_NE(Status::OK, plugin->Stop());
721 }
722
723 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_11, TestSize.Level1)
724 {
725 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
726 auto plugin = CreatePlugin(codecName);
727 EXPECT_NE(nullptr, plugin);
728 EXPECT_NE(Status::OK, plugin->Start());
729 }
730
731 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_12, TestSize.Level1)
732 {
733 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
734 auto plugin = CreatePlugin(codecName);
735 EXPECT_NE(nullptr, plugin);
736 std::shared_ptr<AVAllocator> avAllocator =
737 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
738 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
739 outputBuffer->memory_->SetSize(-1); // invalid param
740 outputBuffer->flag_ = 0;
741 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(outputBuffer));
742 }
743
744 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_13, TestSize.Level1)
745 {
746 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
747 auto plugin = CreatePlugin(codecName);
748 EXPECT_NE(nullptr, plugin);
749 std::shared_ptr<AVBuffer> outputBuffer = nullptr;
750
751 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(outputBuffer));
752 }
753
754 HWTEST_F(AudioMediaCodecUnitTest, G711EncoderPlugin_01, TestSize.Level1)
755 {
756 std::string codecName = "OH.Media.Codec.Encoder.Audio.G711mu";
757 auto plugin = CreatePlugin(codecName);
758 EXPECT_NE(nullptr, plugin);
759 std::shared_ptr<AVAllocator> avAllocator =
760 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
761 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
762 inputBuffer = nullptr;
763 EXPECT_EQ(Status::OK, plugin->Prepare());
764 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
765 }
766
767 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACDecoderPlugin_01, TestSize.Level1)
768 {
769 std::string codecName = "OH.Media.Codec.Decoder.Audio.AAC";
770 auto plugin = CreatePlugin(codecName);
771 EXPECT_NE(nullptr, plugin);
772 EXPECT_EQ(Status::OK, plugin->Prepare());
773 }
774
775 HWTEST_F(AudioMediaCodecUnitTest, Mp3DecoderPlugin_01, TestSize.Level1)
776 {
777 std::string codecName = "OH.Media.Codec.Decoder.Audio.Mpeg";
778 auto plugin = CreatePlugin(codecName);
779 EXPECT_NE(nullptr, plugin);
780 EXPECT_EQ(Status::OK, plugin->Prepare());
781 }
782
783 HWTEST_F(AudioMediaCodecUnitTest, AmrwbDecoderPlugin_01, TestSize.Level1)
784 {
785 std::string codecName = "OH.Media.Codec.Decoder.Audio.Amrwb";
786 auto plugin = CreatePlugin(codecName);
787 EXPECT_NE(nullptr, plugin);
788 EXPECT_EQ(Status::OK, plugin->Prepare());
789 }
790
791 HWTEST_F(AudioMediaCodecUnitTest, AmrnbDecoderPlugin_01, TestSize.Level1)
792 {
793 std::string codecName = "OH.Media.Codec.Decoder.Audio.Amrnb";
794 auto plugin = CreatePlugin(codecName);
795 EXPECT_NE(nullptr, plugin);
796 EXPECT_EQ(Status::OK, plugin->Prepare());
797 }
798
799 HWTEST_F(AudioMediaCodecUnitTest, G711DecoderPlugin_01, TestSize.Level1)
800 {
801 std::string codecName = "OH.Media.Codec.Decoder.Audio.G711mu";
802 auto plugin = CreatePlugin(codecName);
803 EXPECT_NE(nullptr, plugin);
804 std::shared_ptr<AVAllocator> avAllocator =
805 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
806 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
807 inputBuffer = nullptr;
808 EXPECT_EQ(Status::OK, plugin->Prepare());
809 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
810 }
811
812 HWTEST_F(AudioMediaCodecUnitTest, VorbisDecoderPlugin_01, TestSize.Level1)
813 {
814 std::string codecName = "OH.Media.Codec.Decoder.Audio.Vorbis";
815 auto plugin = CreatePlugin(codecName);
816 EXPECT_NE(nullptr, plugin);
817 EXPECT_EQ(Status::OK, plugin->Prepare());
818 }
819
820 HWTEST_F(AudioMediaCodecUnitTest, APEDecoderPlugin_01, TestSize.Level1)
821 {
822 std::string codecName = "OH.Media.Codec.Decoder.Audio.Ape";
823 auto plugin = CreatePlugin(codecName);
824 EXPECT_NE(nullptr, plugin);
825 EXPECT_EQ(Status::OK, plugin->Prepare());
826 }
827
828 HWTEST_F(AudioMediaCodecUnitTest, APEDecoderPlugin_02, TestSize.Level1)
829 {
830 std::string codecName = "OH.Media.Codec.Decoder.Audio.Ape";
831 auto plugin = CreatePlugin(codecName);
832 EXPECT_NE(nullptr, plugin);
833 auto meta = std::make_shared<Meta>();
834 meta->Set<Tag::AUDIO_SAMPLE_RATE>(16000); //16000 samplerate
835 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
836 }
837
838 HWTEST_F(AudioMediaCodecUnitTest, FlacDecoderPlugin_01, TestSize.Level1)
839 {
840 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
841 auto plugin = CreatePlugin(codecName);
842 EXPECT_NE(nullptr, plugin);
843 EXPECT_EQ(Status::OK, plugin->Prepare());
844 }
845
846 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_01, TestSize.Level1)
847 {
848 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
849 auto plugin = CreatePlugin(codecName);
850 EXPECT_NE(nullptr, plugin);
851 std::shared_ptr<AVAllocator> avAllocator =
852 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
853 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
854 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
855 inputBuffer->memory_->SetSize(10); //test 10
856 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
857 }
858
859 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_02, TestSize.Level1)
860 {
861 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
862 auto plugin = CreatePlugin(codecName);
863 EXPECT_NE(nullptr, plugin);
864 auto meta = std::make_shared<Meta>();
865 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
866 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
867 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
868 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
869 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
870 }
871
872 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_03, TestSize.Level1)
873 {
874 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
875 auto plugin = CreatePlugin(codecName);
876 EXPECT_NE(nullptr, plugin);
877 auto meta = std::make_shared<Meta>();
878 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
879 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
880 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
881 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
882 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
883 }
884
885 HWTEST_F(AudioMediaCodecUnitTest, EncoderConfigureLCAAC, TestSize.Level1)
886 {
887 auto mediaCodec = std::make_shared<MediaCodec>();
888 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
889 auto meta = std::make_shared<Meta>();
890 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
891 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
892 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
893 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
894 EXPECT_EQ(0, mediaCodec->Configure(meta));
895 EXPECT_EQ(0, mediaCodec->Release());
896 }
897
898 HWTEST_F(AudioMediaCodecUnitTest, EncoderConfigureHEAAC, TestSize.Level1)
899 {
900 auto detect = std::make_shared<MediaCodec>();
901 bool vendorExist = (detect->Init("OH.Media.Codec.Encoder.Audio.Vendor.AAC") == 0);
902 auto mediaCodec = std::make_shared<MediaCodec>();
903 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
904 auto meta = std::make_shared<Meta>();
905 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
906 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
907 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
908 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
909 meta->Set<Tag::MEDIA_PROFILE>(Media::Plugins::AAC_PROFILE_HE);
910 if (vendorExist) {
911 EXPECT_EQ(0, mediaCodec->Configure(meta));
912 mediaCodec->Reset();
913 meta->Set<Tag::MEDIA_PROFILE>(Media::Plugins::AAC_PROFILE_HE_V2);
914 EXPECT_EQ(0, mediaCodec->Configure(meta));
915 } else {
916 EXPECT_NE(0, mediaCodec->Configure(meta));
917 }
918 EXPECT_EQ(0, mediaCodec->Release());
919 }
920
921 } // namespace MediaAVCodec
922 } // namespace OHOS