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, Test_Release_02, TestSize.Level1)
384 {
385 auto mediaCodec = std::make_shared<MediaCodec>();
386 EXPECT_EQ((int32_t) Status::ERROR_INVALID_PARAMETER, mediaCodec->Init(std::string("not_exist_mimetype"), false));
387 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Release());
388 EXPECT_EQ((int32_t) Status::ERROR_INVALID_PARAMETER, mediaCodec->Init(std::string("not_exist_codec_name")));
389 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Release());
390 }
391
392 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseEncoderPlugin_01, TestSize.Level1)
393 {
394 // AudioSampleFormat2AVSampleFormat fail branch
395 std::string codecName = "OH.Media.Codec.Encoder.Audio.Flac";
396 auto plugin = CreatePlugin(codecName);
397 EXPECT_NE(nullptr, plugin);
398 std::shared_ptr<AVAllocator> avAllocator =
399 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
400 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
401 EXPECT_EQ(Status::ERROR_INVALID_DATA, plugin->QueueInputBuffer(inputBuffer));
402 inputBuffer->memory_->SetSize(10); //test 10
403 EXPECT_EQ(Status::ERROR_WRONG_STATE, plugin->QueueInputBuffer(inputBuffer));
404 }
405
406 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseEncoderPlugin_02, TestSize.Level1)
407 {
408 // AudioSampleFormat2AVSampleFormat fail branch
409 std::string codecName = "OH.Media.Codec.Encoder.Audio.Flac";
410 auto plugin = CreatePlugin(codecName);
411 EXPECT_NE(nullptr, plugin);
412 auto meta = std::make_shared<Meta>();
413 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
414 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
415 meta->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_96K_SAMPLE_RATE);
416 meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_FLAC_BITRATE);
417 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Plugins::AudioChannelLayout::STEREO);
418 meta->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
419 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
420 std::shared_ptr<AVAllocator> avAllocator =
421 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
422 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
423 inputBuffer->memory_->SetSize(10); //test 10
424 }
425
426 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_01, TestSize.Level1)
427 {
428 // AudioSampleFormat2AVSampleFormat fail branch
429 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
430 auto plugin = CreatePlugin(codecName);
431 EXPECT_NE(nullptr, plugin);
432 auto meta = std::make_shared<Meta>();
433 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S24P);
434 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
435 EXPECT_NE(Status::OK, plugin->Start());
436 }
437
438 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_02, TestSize.Level1)
439 {
440 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
441 auto plugin = CreatePlugin(codecName);
442 EXPECT_NE(nullptr, plugin);
443 std::shared_ptr<AVAllocator> avAllocator =
444 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
445 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
446 inputBuffer->memory_ = nullptr;
447 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
448 }
449
450 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_03, TestSize.Level1)
451 {
452 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
453 auto plugin = CreatePlugin(codecName);
454 EXPECT_NE(nullptr, plugin);
455 std::shared_ptr<AVAllocator> avAllocator =
456 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
457 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
458 inputBuffer->memory_->SetSize(0);
459 inputBuffer->flag_ = 0;
460 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
461 }
462
463 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_04, TestSize.Level1)
464 {
465 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
466 auto plugin = CreatePlugin(codecName);
467 EXPECT_NE(nullptr, plugin);
468 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
469 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
470 inputBuffer->memory_->SetSize(1); // 1:data size
471 inputBuffer->flag_ = 0;
472 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
473 }
474
475 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_05, TestSize.Level1)
476 {
477 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
478 auto plugin = CreatePlugin(codecName);
479 EXPECT_NE(nullptr, plugin);
480 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
481 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
482 plugin->QueueOutputBuffer(outputBuffer);
483 }
484
485 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_06, TestSize.Level1)
486 {
487 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
488 auto plugin = CreatePlugin(codecName);
489 EXPECT_NE(nullptr, plugin);
490 plugin->Init();
491
492 auto meta = std::make_shared<Meta>();
493 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
494 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
495 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
496 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
497 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
498 EXPECT_EQ(Status::OK, plugin->Prepare());
499 EXPECT_EQ(Status::OK, plugin->Start());
500 EXPECT_EQ(Status::OK, plugin->Flush());
501 }
502
503 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_07, TestSize.Level1)
504 {
505 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
506 auto plugin = CreatePlugin(codecName);
507 EXPECT_NE(nullptr, plugin);
508 plugin->Init();
509
510 auto meta = std::make_shared<Meta>();
511 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(AUDIO_AAC_IS_ADTS);
512 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
513 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
514 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_8k);
515 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
516 EXPECT_EQ(Status::OK, plugin->Prepare());
517 EXPECT_EQ(Status::OK, plugin->Start());
518 EXPECT_EQ(Status::OK, plugin->Flush());
519 }
520
521 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_08, TestSize.Level1)
522 {
523 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
524 auto plugin = CreatePlugin(codecName);
525 EXPECT_NE(nullptr, plugin);
526 plugin->Init();
527
528 auto meta = std::make_shared<Meta>();
529 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(0);
530 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
531 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
532 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
533 meta->Set<Tag::AUDIO_MAX_INPUT_SIZE>(100); // 100: input buffer size
534 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
535 EXPECT_EQ(Status::OK, plugin->Prepare());
536 EXPECT_EQ(Status::OK, plugin->Start());
537 }
538
539 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_09, TestSize.Level1)
540 {
541 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
542 auto plugin = CreatePlugin(codecName);
543 EXPECT_NE(nullptr, plugin);
544 plugin->Init();
545
546 auto meta = std::make_shared<Meta>();
547 meta->Set<Tag::AUDIO_AAC_IS_ADTS>(0);
548 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
549 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
550 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
551 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
552 EXPECT_EQ(Status::OK, plugin->Start());
553 EXPECT_EQ(Status::OK, plugin->Stop());
554 }
555
556 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_10, TestSize.Level1)
557 {
558 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
559 auto plugin = CreatePlugin(codecName);
560 EXPECT_NE(nullptr, plugin);
561 std::shared_ptr<AVAllocator> avAllocator =
562 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
563 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
564 inputBuffer = nullptr;
565 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
566 }
567
568 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACEncoderPlugin_11, TestSize.Level1)
569 {
570 std::string codecName = "OH.Media.Codec.Encoder.Audio.AAC";
571 auto plugin = CreatePlugin(codecName);
572 EXPECT_NE(nullptr, plugin);
573
574 EXPECT_EQ(Status::OK, plugin->Flush());
575 }
576
577 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_01, TestSize.Level1)
578 {
579 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
580 auto plugin = CreatePlugin(codecName);
581 EXPECT_NE(nullptr, plugin);
582 EXPECT_EQ(Status::OK, plugin->Init());
583
584 auto meta = std::make_shared<Meta>();
585 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
586 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
587 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
588 meta->Set<Tag::MEDIA_BITRATE>(320000); // 320000: valid param
589 meta->Set<Tag::AUDIO_MAX_INPUT_SIZE>(100); // 100: input buffer size
590 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
591 }
592
593 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_02, TestSize.Level1)
594 {
595 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
596 auto plugin = CreatePlugin(codecName);
597 EXPECT_NE(nullptr, plugin);
598 EXPECT_EQ(Status::OK, plugin->Init());
599
600 auto meta = std::make_shared<Meta>();
601 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
602 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
603 meta->Set<Tag::AUDIO_SAMPLE_RATE>(8000); // sampleRate:8000 bitRate:80000 invalid
604 meta->Set<Tag::MEDIA_BITRATE>(80000); // sampleRate:8000 bitRate:80000 invalid
605 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
606 meta->Set<Tag::AUDIO_SAMPLE_RATE>(22050); // sampleRate:22050 bitRate:192000 invalid
607 meta->Set<Tag::MEDIA_BITRATE>(192000); // sampleRate:22050 bitRate:192000 invalid
608 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
609 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // sampleRate:44100 bitRate:16000 invalid
610 meta->Set<Tag::MEDIA_BITRATE>(16000); // sampleRate:44100 bitRate:16000 invalid
611 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
612 }
613
614 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_03, TestSize.Level1)
615 {
616 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
617 auto plugin = CreatePlugin(codecName);
618 EXPECT_NE(nullptr, plugin);
619 EXPECT_EQ(Status::OK, plugin->Init());
620 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
621 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
622 inputBuffer->memory_->SetSize(-1); // -1: invalid param
623 inputBuffer->flag_ = 0;
624 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
625 }
626
627 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_04, TestSize.Level1)
628 {
629 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
630 auto plugin = CreatePlugin(codecName);
631 EXPECT_NE(nullptr, plugin);
632 EXPECT_EQ(Status::OK, plugin->Init());
633 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
634 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
635 inputBuffer->memory_->SetSize(0); // 0: invalid param
636 inputBuffer->flag_ = 0;
637 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
638 }
639
640 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_05, TestSize.Level1)
641 {
642 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
643 auto plugin = CreatePlugin(codecName);
644 EXPECT_NE(nullptr, plugin);
645 EXPECT_EQ(Status::OK, plugin->Init());
646
647 auto meta = std::make_shared<Meta>();
648 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_MONO);
649 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
650 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
651 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
652 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
653 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
654 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
655 inputBuffer->memory_->SetSize(3000); // 3000: invalid param
656 inputBuffer->flag_ = 0;
657 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
658 }
659
660 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_06, TestSize.Level1)
661 {
662 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
663 auto plugin = CreatePlugin(codecName);
664 EXPECT_NE(nullptr, plugin);
665 EXPECT_EQ(Status::OK, plugin->Init());
666
667 auto meta = std::make_shared<Meta>();
668 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
669 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
670 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
671 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
672 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
673 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
674 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
675 inputBuffer->memory_->SetSize(5000); // 5000: invalid param
676 inputBuffer->flag_ = 0;
677 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
678 }
679
680 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_07, TestSize.Level1)
681 {
682 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
683 auto plugin = CreatePlugin(codecName);
684 EXPECT_NE(nullptr, plugin);
685 EXPECT_EQ(Status::OK, plugin->Init());
686
687 auto meta = std::make_shared<Meta>();
688 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_MONO);
689 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
690 meta->Set<Tag::AUDIO_SAMPLE_RATE>(16000); // 16000: sample rate
691 meta->Set<Tag::MEDIA_BITRATE>(BIT_RATE_16k);
692 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
693 EXPECT_EQ(Status::OK, plugin->Prepare());
694 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
695 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
696 outputBuffer->memory_->SetSize(0); // invalid param
697 outputBuffer->flag_ = 0;
698 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(outputBuffer));
699 EXPECT_EQ(Status::OK, plugin->Flush());
700 EXPECT_EQ(Status::OK, plugin->Reset());
701 }
702
703 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_08, TestSize.Level1)
704 {
705 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
706 auto plugin = CreatePlugin(codecName);
707 EXPECT_NE(nullptr, plugin);
708 std::shared_ptr<AVAllocator> avAllocator =
709 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
710 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
711 inputBuffer = nullptr;
712 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
713 }
714
715 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_09, 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_EQ(Status::OK, plugin->Reset());
722 }
723
724 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_10, TestSize.Level1)
725 {
726 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
727 auto plugin = CreatePlugin(codecName);
728 EXPECT_NE(nullptr, plugin);
729
730 EXPECT_NE(Status::OK, plugin->Stop());
731 }
732
733 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_11, TestSize.Level1)
734 {
735 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
736 auto plugin = CreatePlugin(codecName);
737 EXPECT_NE(nullptr, plugin);
738 EXPECT_NE(Status::OK, plugin->Start());
739 }
740
741 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_12, TestSize.Level1)
742 {
743 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
744 auto plugin = CreatePlugin(codecName);
745 EXPECT_NE(nullptr, plugin);
746 std::shared_ptr<AVAllocator> avAllocator =
747 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
748 std::shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_DEFAULT);
749 outputBuffer->memory_->SetSize(-1); // invalid param
750 outputBuffer->flag_ = 0;
751 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(outputBuffer));
752 }
753
754 HWTEST_F(AudioMediaCodecUnitTest, Mp3EncoderPlugin_13, TestSize.Level1)
755 {
756 std::string codecName = "OH.Media.Codec.Encoder.Audio.Mp3";
757 auto plugin = CreatePlugin(codecName);
758 EXPECT_NE(nullptr, plugin);
759 std::shared_ptr<AVBuffer> outputBuffer = nullptr;
760
761 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(outputBuffer));
762 }
763
764 HWTEST_F(AudioMediaCodecUnitTest, G711EncoderPlugin_01, TestSize.Level1)
765 {
766 std::string codecName = "OH.Media.Codec.Encoder.Audio.G711mu";
767 auto plugin = CreatePlugin(codecName);
768 EXPECT_NE(nullptr, plugin);
769 std::shared_ptr<AVAllocator> avAllocator =
770 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
771 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
772 inputBuffer = nullptr;
773 EXPECT_EQ(Status::OK, plugin->Prepare());
774 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
775 }
776
777 HWTEST_F(AudioMediaCodecUnitTest, FFmpegAACDecoderPlugin_01, TestSize.Level1)
778 {
779 std::string codecName = "OH.Media.Codec.Decoder.Audio.AAC";
780 auto plugin = CreatePlugin(codecName);
781 EXPECT_NE(nullptr, plugin);
782 EXPECT_EQ(Status::OK, plugin->Prepare());
783 }
784
785 HWTEST_F(AudioMediaCodecUnitTest, Mp3DecoderPlugin_01, TestSize.Level1)
786 {
787 std::string codecName = "OH.Media.Codec.Decoder.Audio.Mpeg";
788 auto plugin = CreatePlugin(codecName);
789 EXPECT_NE(nullptr, plugin);
790 EXPECT_EQ(Status::OK, plugin->Prepare());
791 }
792
793 HWTEST_F(AudioMediaCodecUnitTest, AmrwbDecoderPlugin_01, TestSize.Level1)
794 {
795 std::string codecName = "OH.Media.Codec.Decoder.Audio.Amrwb";
796 auto plugin = CreatePlugin(codecName);
797 EXPECT_NE(nullptr, plugin);
798 EXPECT_EQ(Status::OK, plugin->Prepare());
799 }
800
801 HWTEST_F(AudioMediaCodecUnitTest, AmrnbDecoderPlugin_01, TestSize.Level1)
802 {
803 std::string codecName = "OH.Media.Codec.Decoder.Audio.Amrnb";
804 auto plugin = CreatePlugin(codecName);
805 EXPECT_NE(nullptr, plugin);
806 EXPECT_EQ(Status::OK, plugin->Prepare());
807 }
808
809 HWTEST_F(AudioMediaCodecUnitTest, G711DecoderPlugin_01, TestSize.Level1)
810 {
811 std::string codecName = "OH.Media.Codec.Decoder.Audio.G711mu";
812 auto plugin = CreatePlugin(codecName);
813 EXPECT_NE(nullptr, plugin);
814 std::shared_ptr<AVAllocator> avAllocator =
815 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
816 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
817 inputBuffer = nullptr;
818 EXPECT_EQ(Status::OK, plugin->Prepare());
819 EXPECT_NE(Status::OK, plugin->QueueOutputBuffer(inputBuffer));
820 }
821
822 HWTEST_F(AudioMediaCodecUnitTest, VorbisDecoderPlugin_01, TestSize.Level1)
823 {
824 std::string codecName = "OH.Media.Codec.Decoder.Audio.Vorbis";
825 auto plugin = CreatePlugin(codecName);
826 EXPECT_NE(nullptr, plugin);
827 EXPECT_EQ(Status::OK, plugin->Prepare());
828 }
829
830 HWTEST_F(AudioMediaCodecUnitTest, APEDecoderPlugin_01, TestSize.Level1)
831 {
832 std::string codecName = "OH.Media.Codec.Decoder.Audio.Ape";
833 auto plugin = CreatePlugin(codecName);
834 EXPECT_NE(nullptr, plugin);
835 EXPECT_EQ(Status::OK, plugin->Prepare());
836 }
837
838 HWTEST_F(AudioMediaCodecUnitTest, APEDecoderPlugin_02, TestSize.Level1)
839 {
840 std::string codecName = "OH.Media.Codec.Decoder.Audio.Ape";
841 auto plugin = CreatePlugin(codecName);
842 EXPECT_NE(nullptr, plugin);
843 auto meta = std::make_shared<Meta>();
844 meta->Set<Tag::AUDIO_SAMPLE_RATE>(16000); //16000 samplerate
845 EXPECT_NE(Status::OK, plugin->SetParameter(meta));
846 }
847
848 HWTEST_F(AudioMediaCodecUnitTest, APEVersion_01, TestSize.Level1)
849 {
850 auto mediaCodec = std::make_shared<MediaCodec>();
851 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
852 EXPECT_EQ(0, mediaCodec->Init(APE_DEC_CODEC_NAME));
853 auto implBufferQueue_ =
854 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
855 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
856 auto meta = std::make_shared<Meta>();
857 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
858 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
859 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
860
861 vector<uint8_t> extradata(6);
862 int16_t *fakedata = reinterpret_cast<int16_t *>(extradata.data());
863 fakedata[0] = 3990; // 3990 version
864 fakedata[1] = 2000; // 2000 complexity
865 fakedata[2] = 0; // flags 0
866 meta->Set<Tag::MEDIA_CODEC_CONFIG>(extradata);
867 EXPECT_EQ(0, mediaCodec->Configure(meta));
868 auto format = make_shared<Meta>();
869 mediaCodec->GetOutputFormat(format);
870 int32_t size;
871 format->Get<Tag::AUDIO_MAX_INPUT_SIZE>(size);
872 EXPECT_EQ(size, 300000); //Normal input size 300000
873 }
874
875 HWTEST_F(AudioMediaCodecUnitTest, APEVersion_02, TestSize.Level1)
876 {
877 auto mediaCodec = std::make_shared<MediaCodec>();
878 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
879 EXPECT_EQ(0, mediaCodec->Init(APE_DEC_CODEC_NAME));
880 auto implBufferQueue_ =
881 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
882 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
883 auto meta = std::make_shared<Meta>();
884 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
885 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
886 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
887
888 vector<uint8_t> extradata(6);
889 int16_t *fakedata = reinterpret_cast<int16_t *>(extradata.data());
890 fakedata[0] = 3990; // 3990 version
891 fakedata[1] = 3000; // 3000 complexity
892 fakedata[2] = 0; // flags 0
893 meta->Set<Tag::MEDIA_CODEC_CONFIG>(extradata);
894 EXPECT_EQ(0, mediaCodec->Configure(meta));
895 auto format = make_shared<Meta>();
896 mediaCodec->GetOutputFormat(format);
897 int32_t size;
898 format->Get<Tag::AUDIO_MAX_INPUT_SIZE>(size);
899 EXPECT_EQ(size, 1179648); //Medium input size 1179648
900 }
901
902 HWTEST_F(AudioMediaCodecUnitTest, APEVersion_03, TestSize.Level1)
903 {
904 auto mediaCodec = std::make_shared<MediaCodec>();
905 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
906 EXPECT_EQ(0, mediaCodec->Init(APE_DEC_CODEC_NAME));
907 auto implBufferQueue_ =
908 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
909 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
910 auto meta = std::make_shared<Meta>();
911 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
912 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
913 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
914
915 vector<uint8_t> extradata(6);
916 int16_t *fakedata = reinterpret_cast<int16_t *>(extradata.data());
917 fakedata[0] = 3990; // 3990 version
918 fakedata[1] = 5000; // 5000 complexity
919 fakedata[2] = 0; // flags 0
920 meta->Set<Tag::MEDIA_CODEC_CONFIG>(extradata);
921 EXPECT_EQ(0, mediaCodec->Configure(meta));
922 auto format = make_shared<Meta>();
923 mediaCodec->GetOutputFormat(format);
924 int32_t size;
925 format->Get<Tag::AUDIO_MAX_INPUT_SIZE>(size);
926 EXPECT_EQ(size, 4718592); //Insane input size 4718592
927 }
928
929 HWTEST_F(AudioMediaCodecUnitTest, APEVersion_04, TestSize.Level1)
930 {
931 auto mediaCodec = std::make_shared<MediaCodec>();
932 EXPECT_EQ((int32_t) Status::OK, mediaCodec->Stop());
933 EXPECT_EQ(0, mediaCodec->Init(APE_DEC_CODEC_NAME));
934 auto implBufferQueue_ =
935 Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY, "UT-TEST");
936 EXPECT_EQ(0, mediaCodec->SetOutputBufferQueue(implBufferQueue_->GetProducer()));
937 auto meta = std::make_shared<Meta>();
938 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
939 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
940 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
941
942 vector<uint8_t> extradata(6);
943 int16_t *fakedata = reinterpret_cast<int16_t *>(extradata.data());
944 fakedata[0] = 3800; // 3800 version
945 fakedata[1] = 2000; // 3000 complexity
946 fakedata[2] = 0; // flags 0
947 meta->Set<Tag::MEDIA_CODEC_CONFIG>(extradata);
948 EXPECT_EQ(0, mediaCodec->Configure(meta));
949 auto format = make_shared<Meta>();
950 mediaCodec->GetOutputFormat(format);
951 int32_t size;
952 format->Get<Tag::AUDIO_MAX_INPUT_SIZE>(size);
953 EXPECT_EQ(size, 300000); //min input size 300000
954 }
955
956 HWTEST_F(AudioMediaCodecUnitTest, FlacDecoderPlugin_01, TestSize.Level1)
957 {
958 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
959 auto plugin = CreatePlugin(codecName);
960 EXPECT_NE(nullptr, plugin);
961 EXPECT_EQ(Status::OK, plugin->Prepare());
962 }
963
964 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_01, TestSize.Level1)
965 {
966 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
967 auto plugin = CreatePlugin(codecName);
968 EXPECT_NE(nullptr, plugin);
969 std::shared_ptr<AVAllocator> avAllocator =
970 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
971 std::shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, BUFFER_CAPACITY_SAMLL);
972 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
973 inputBuffer->memory_->SetSize(10); //test 10
974 EXPECT_NE(Status::OK, plugin->QueueInputBuffer(inputBuffer));
975 }
976
977 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_02, TestSize.Level1)
978 {
979 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
980 auto plugin = CreatePlugin(codecName);
981 EXPECT_NE(nullptr, plugin);
982 auto meta = std::make_shared<Meta>();
983 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
984 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
985 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
986 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
987 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
988 }
989
990 HWTEST_F(AudioMediaCodecUnitTest, FFmpegBaseDecoderPlugin_03, TestSize.Level1)
991 {
992 std::string codecName = "OH.Media.Codec.Decoder.Audio.Flac";
993 auto plugin = CreatePlugin(codecName);
994 EXPECT_NE(nullptr, plugin);
995 auto meta = std::make_shared<Meta>();
996 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
997 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
998 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
999 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
1000 EXPECT_EQ(Status::OK, plugin->SetParameter(meta));
1001 }
1002
1003 HWTEST_F(AudioMediaCodecUnitTest, EncoderConfigureLCAAC, TestSize.Level1)
1004 {
1005 auto mediaCodec = std::make_shared<MediaCodec>();
1006 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
1007 auto meta = std::make_shared<Meta>();
1008 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(1);
1009 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
1010 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
1011 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
1012 EXPECT_EQ(0, mediaCodec->Configure(meta));
1013 EXPECT_EQ(0, mediaCodec->Release());
1014 }
1015
1016 HWTEST_F(AudioMediaCodecUnitTest, EncoderConfigureHEAAC, TestSize.Level1)
1017 {
1018 auto detect = std::make_shared<MediaCodec>();
1019 bool vendorExist = (detect->Init("OH.Media.Codec.Encoder.Audio.Vendor.AAC") == 0);
1020 auto mediaCodec = std::make_shared<MediaCodec>();
1021 EXPECT_EQ(0, mediaCodec->Init(AAC_MIME_TYPE, true));
1022 auto meta = std::make_shared<Meta>();
1023 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
1024 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32LE);
1025 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE_48k);
1026 meta->Set<Tag::MEDIA_BITRATE>(64000); // 64000: valid param
1027 meta->Set<Tag::MEDIA_PROFILE>(Media::Plugins::AAC_PROFILE_HE);
1028 if (vendorExist) {
1029 EXPECT_EQ(0, mediaCodec->Configure(meta));
1030 mediaCodec->Reset();
1031 meta->Set<Tag::MEDIA_PROFILE>(Media::Plugins::AAC_PROFILE_HE_V2);
1032 EXPECT_EQ(0, mediaCodec->Configure(meta));
1033 } else {
1034 EXPECT_NE(0, mediaCodec->Configure(meta));
1035 }
1036 EXPECT_EQ(0, mediaCodec->Release());
1037 }
1038
1039 } // namespace MediaAVCodec
1040 } // namespace OHOS