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