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