1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_codec_inner_avbuffer_unit_test.h"
17 #include <unistd.h>
18 #include <string>
19 #include <string_view>
20 #include <iostream>
21 #include <unistd.h>
22 #include <chrono>
23 #include "securec.h"
24 #include "demo_log.h"
25 #include "meta/audio_types.h"
26 #include "avcodec_audio_codec.h"
27 #include "avcodec_codec_name.h"
28 #include "avcodec_mime_type.h"
29 #include "avcodec_errors.h"
30 #include "avcodec_list.h"
31
32 using namespace std;
33 using namespace testing::ext;
34 using namespace OHOS::Media;
35 using namespace OHOS::MediaAVCodec;
36
37 namespace {
38 constexpr uint32_t CHANNEL_COUNT_STEREO = 2;
39 constexpr uint32_t SAMPLE_RATE = 48000;
40 constexpr std::string_view INPUT_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.dat";
41 constexpr std::string_view OUTPUT_PCM_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.pcm";
42 constexpr std::string_view INPUT_AC3_FILE_PATH = "/data/test/media/voice_ac3.dat";
43 constexpr std::string_view OUTPUT_AC3_PCM_FILE_PATH = "/data/test/media/voice_ac3.pcm";
44 constexpr int32_t INPUT_FRAME_BYTES = 2 * 1024 * 4;
45 constexpr int32_t TIME_OUT_MS = 8;
46 constexpr int64_t MILLISECOUND_TO_SECOND = 1000;
47 constexpr std::string_view MP3_CODEC_NAME = AVCodecCodecName::AUDIO_DECODER_MP3_NAME;
48 constexpr std::string_view AC3_CODEC_NAME = AVCodecCodecName::AUDIO_DECODER_AC3_NAME;
49 constexpr int64_t CHANGE_PLUGIN_INTERVAL_MS = 1;
50 constexpr uint32_t MAX_MIME_LENGTH = 255;
51
52 typedef enum OH_AVCodecBufferFlags {
53 AVCODEC_BUFFER_FLAGS_NONE = 0,
54 /* Indicates that the Buffer is an End-of-Stream frame */
55 AVCODEC_BUFFER_FLAGS_EOS = 1 << 0,
56 /* Indicates that the Buffer contains keyframes */
57 AVCODEC_BUFFER_FLAGS_SYNC_FRAME = 1 << 1,
58 /* Indicates that the data contained in the Buffer is only part of a frame */
59 AVCODEC_BUFFER_FLAGS_INCOMPLETE_FRAME = 1 << 2,
60 /* Indicates that the Buffer contains Codec-Specific-Data */
61 AVCODEC_BUFFER_FLAGS_CODEC_DATA = 1 << 3,
62 } OH_AVCodecBufferFlags;
63 } // namespace
64
65 namespace OHOS {
66 namespace MediaAVCodec {
GetCapabilityName(const char * mime,bool isEncoder)67 static std::string GetCapabilityName(const char *mime, bool isEncoder)
68 {
69 if (mime == nullptr) {
70 std::cout << "Get capability failed: mime is nullptr" << std::endl;
71 return "";
72 }
73 if (strlen(mime) == 0 || strlen(mime) > MAX_MIME_LENGTH) {
74 std::cout << "Get capability failed: invalid mime strlen, " << strlen(mime) << std::endl;
75 return "";
76 }
77 std::shared_ptr<AVCodecList> codeclist = AVCodecListFactory::CreateAVCodecList();
78 if (codeclist == nullptr) {
79 std::cout << "Get capability failed: CreateAVCodecList failed" << std::endl;
80 return "";
81 }
82 CapabilityData *capabilityData = codeclist->GetCapability(mime, isEncoder, AVCodecCategory::AVCODEC_NONE);
83 if (capabilityData == nullptr) {
84 std::cout << "Get capability failed: cannot find matched capability" << std::endl;
85 return "";
86 }
87 return capabilityData->codecName;
88 }
89
GetFileSize(const std::string & filePath)90 static int32_t GetFileSize(const std::string &filePath)
91 {
92 std::ifstream file(filePath, std::ios::binary | std::ios::ate);
93 if (!file) {
94 std::cerr << "Failed to open file:" << filePath << std::endl;
95 return -1;
96 }
97
98 std::streampos fileSize = file.tellg();
99 file.close();
100
101 return (int32_t)fileSize;
102 }
103
SetUpTestCase(void)104 void AVCodecAudioCodecUnitTest::SetUpTestCase(void)
105 {
106 cout << "[SetUpTestCase]: " << endl;
107 }
108
TearDownTestCase(void)109 void AVCodecAudioCodecUnitTest::TearDownTestCase(void)
110 {
111 cout << "[TearDownTestCase]: " << endl;
112 }
113
SetUp(void)114 void AVCodecAudioCodecUnitTest::SetUp(void)
115 {
116 cout << "[SetUp]: SetUp!!!" << endl;
117 }
118
TearDown(void)119 void AVCodecAudioCodecUnitTest::TearDown(void)
120 {
121 cout << "[TearDown]: over!!!" << endl;
122 }
123
RunCase(const std::string_view & codecName,const std::string_view & inputPath,const std::string_view & outputPath)124 int32_t AudioDecInnerAvBuffer::RunCase(
125 const std::string_view &codecName, const std::string_view &inputPath, const std::string_view &outputPath)
126 {
127 int32_t ret = AVCodecServiceErrCode::AVCS_ERR_OK;
128 innerBufferQueue_ = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "InnerDemo"); // 4
129 audioCodec_ = AudioCodecFactory::CreateByName(codecName.data());
130 DEMO_CHECK_AND_RETURN_RET_LOG(
131 audioCodec_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN, "audioCodec_ is null");
132 bool enableSync = false;
133 meta_->GetData(Tag::AV_CODEC_ENABLE_SYNC_MODE, enableSync);
134 EXPECT_EQ(static_cast<int32_t>(AVCS_ERR_OK), audioCodec_->Configure(meta_));
135
136 if (!enableSync) {
137 audioCodec_->SetOutputBufferQueue(innerBufferQueue_->GetProducer());
138 }
139 EXPECT_EQ(static_cast<int32_t>(AVCS_ERR_OK), audioCodec_->Prepare());
140
141 if (!enableSync) {
142 implConsumer_ = innerBufferQueue_->GetConsumer();
143 sptr<Media::IConsumerListener> comsumerListener = new AudioCodecConsumerListener(this);
144 implConsumer_->SetBufferAvailableListener(comsumerListener);
145 mediaCodecProducer_ = audioCodec_->GetInputBufferQueue();
146 }
147
148 EXPECT_EQ(static_cast<int32_t>(AVCS_ERR_OK), audioCodec_->Start());
149 isRunning_.store(true);
150
151 fileSize_ = GetFileSize(inputPath.data());
152 inputFile_ = std::make_unique<std::ifstream>(inputPath, std::ios::binary);
153 outputFile_ = std::make_unique<std::ofstream>(outputPath, std::ios::binary);
154
155 if (enableAsyncChangePluginTest_) {
156 isChangePluginThreadRunning_ = true;
157 changePluginThread_ = std::make_unique<std::thread>([this] {
158 constexpr bool isEncoder = false;
159 while (isChangePluginThreadRunning_) {
160 std::this_thread::sleep_for(std::chrono::milliseconds(CHANGE_PLUGIN_INTERVAL_MS));
161 audioCodec_->ChangePlugin("audio/mpeg", isEncoder, meta_);
162 }
163 });
164 }
165
166 if (!enableSync) {
167 InputFunc();
168 } else {
169 SyncFunc();
170 }
171 EXPECT_GT(outputSize_, 0);
172
173 if (changePluginThread_ && changePluginThread_->joinable()) {
174 isChangePluginThreadRunning_ = false;
175 enableAsyncChangePluginTest_ = false;
176 changePluginThread_->join();
177 changePluginThread_.reset();
178 }
179
180 inputFile_->close();
181 outputFile_->close();
182 return ret;
183 }
184
GetInputBufferSize()185 int32_t AudioDecInnerAvBuffer::GetInputBufferSize()
186 {
187 int32_t capacity = 0;
188 DEMO_CHECK_AND_RETURN_RET_LOG(audioCodec_ != nullptr, capacity, "audioCodec_ is nullptr");
189 std::shared_ptr<Media::Meta> bufferConfig = std::make_shared<Media::Meta>();
190 DEMO_CHECK_AND_RETURN_RET_LOG(bufferConfig != nullptr, capacity, "bufferConfig is nullptr");
191 int32_t ret = audioCodec_->GetOutputFormat(bufferConfig);
192 DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCodecServiceErrCode::AVCS_ERR_OK, capacity, "GetOutputFormat fail");
193 DEMO_CHECK_AND_RETURN_RET_LOG(
194 bufferConfig->Get<Media::Tag::AUDIO_MAX_INPUT_SIZE>(capacity), capacity, "get max input buffer size fail");
195 return capacity;
196 }
197
InputFunc()198 void AudioDecInnerAvBuffer::InputFunc()
199 {
200 DEMO_CHECK_AND_RETURN_LOG(inputFile_ != nullptr && inputFile_->is_open(), "Fatal: open file fail");
201 int32_t sumReadSize = 0;
202 Media::Status ret;
203 int64_t size;
204 int64_t pts;
205 Media::AVBufferConfig avBufferConfig;
206 avBufferConfig.size = GetInputBufferSize();
207 while (isRunning_) {
208 std::shared_ptr<AVBuffer> inputBuffer = nullptr;
209 DEMO_CHECK_AND_BREAK_LOG(mediaCodecProducer_ != nullptr, "mediaCodecProducer_ is nullptr");
210 ret = mediaCodecProducer_->RequestBuffer(inputBuffer, avBufferConfig, TIME_OUT_MS);
211 if (ret != Media::Status::OK) {
212 std::cout << "produceInputBuffer RequestBuffer fail,ret=" << (int32_t)ret << std::endl;
213 break;
214 }
215 DEMO_CHECK_AND_BREAK_LOG(inputBuffer != nullptr, "buffer is nullptr");
216 inputFile_->read(reinterpret_cast<char *>(&size), sizeof(size));
217 if (inputFile_->eof() || inputFile_->gcount() == 0 || size == 0) {
218 inputBuffer->memory_->SetSize(1);
219 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
220 sumReadSize += 0;
221 mediaCodecProducer_->PushBuffer(inputBuffer, true);
222 sumReadSize += inputFile_->gcount();
223 std::cout << "InputFunc, INPUT_FRAME_BYTES:" << INPUT_FRAME_BYTES << " flag:" << inputBuffer->flag_
224 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
225 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
226 std::cout << "end buffer\n";
227 break;
228 }
229 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(size), "Fatal: read size fail");
230 sumReadSize += inputFile_->gcount();
231 inputFile_->read(reinterpret_cast<char *>(&pts), sizeof(pts));
232 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(pts), "Fatal: read pts fail");
233 sumReadSize += inputFile_->gcount();
234 inputFile_->read(reinterpret_cast<char *>(inputBuffer->memory_->GetAddr()), size);
235 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == size, "Fatal: read buffer fail");
236 inputBuffer->memory_->SetSize(size);
237 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
238 sumReadSize += inputFile_->gcount();
239 mediaCodecProducer_->PushBuffer(inputBuffer, true);
240 std::cout << "InputFunc, INPUT_FRAME_BYTES:" << INPUT_FRAME_BYTES << " flag:" << inputBuffer->flag_
241 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
242 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
243 }
244 }
245
OutputFunc()246 void AudioDecInnerAvBuffer::OutputFunc()
247 {
248 bufferConsumerAvailableCount_++;
249 Media::Status ret = Media::Status::OK;
250 while (isRunning_ && (bufferConsumerAvailableCount_ > 0)) {
251 std::cout << "/**********ImplConsumerOutputBuffer while**********/" << std::endl;
252 std::shared_ptr<AVBuffer> outputBuffer;
253 ret = implConsumer_->AcquireBuffer(outputBuffer);
254 if (ret != Media::Status::OK) {
255 std::cout << "Consumer AcquireBuffer fail,ret=" << (int32_t)ret << std::endl;
256 break;
257 }
258 if (outputBuffer == nullptr) {
259 std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
260 continue;
261 }
262 outputFile_->write(
263 reinterpret_cast<char *>(outputBuffer->memory_->GetAddr()), outputBuffer->memory_->GetSize());
264 outputSize_ += outputBuffer->memory_->GetSize();
265 if (outputBuffer->flag_ == AVCODEC_BUFFER_FLAGS_EOS || outputBuffer->memory_->GetSize() == 0) {
266 std::cout << "out eos" << std::endl;
267 isRunning_.store(false);
268 }
269 implConsumer_->ReleaseBuffer(outputBuffer);
270 bufferConsumerAvailableCount_--;
271 }
272 }
273
SyncFunc()274 void AudioDecInnerAvBuffer::SyncFunc()
275 {
276 DEMO_CHECK_AND_RETURN_LOG(inputFile_ != nullptr && inputFile_->is_open(), "Fatal: open file fail");
277 int32_t sumReadSize = 0;
278 int32_t ret;
279 int64_t size;
280 int64_t pts;
281 uint32_t index = 0;
282 size_t requestBufferSize = GetInputBufferSize();
283 while (isRunning_) {
284 // input
285 ret = audioCodec_->QueryInputBuffer(
286 &index, requestBufferSize, static_cast<int64_t>(TIME_OUT_MS) * MILLISECOUND_TO_SECOND);
287 if (ret != static_cast<int32_t>(Media::Status::OK)) {
288 std::cout << "audioCodec_->QueryInputBuffer fail,ret=" << ret << std::endl;
289 break;
290 }
291 std::shared_ptr<AVBuffer> inputBuffer = audioCodec_->GetInputBuffer(index);
292 DEMO_CHECK_AND_BREAK_LOG(inputBuffer != nullptr, "buffer is nullptr");
293 inputFile_->read(reinterpret_cast<char *>(&size), sizeof(size));
294 if (inputFile_->eof() || inputFile_->gcount() == 0 || size == 0) {
295 inputBuffer->memory_->SetSize(1);
296 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
297 sumReadSize += 0;
298 audioCodec_->PushInputBuffer(index, true);
299 sumReadSize += inputFile_->gcount();
300 std::cout << "SyncFunc, INPUT_FRAME_BYTES:" << size << " flag:" << inputBuffer->flag_
301 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
302 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
303 std::cout << "end buffer\n";
304 break;
305 }
306 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(size), "Fatal: read size fail");
307 sumReadSize += inputFile_->gcount();
308 inputFile_->read(reinterpret_cast<char *>(&pts), sizeof(pts));
309 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(pts), "Fatal: read pts fail");
310 sumReadSize += inputFile_->gcount();
311 inputFile_->read(reinterpret_cast<char *>(inputBuffer->memory_->GetAddr()), size);
312 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == size, "Fatal: read buffer fail");
313 inputBuffer->memory_->SetSize(size);
314 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
315 sumReadSize += inputFile_->gcount();
316 audioCodec_->PushInputBuffer(index, true);
317 std::cout << "SyncFunc, INPUT_FRAME_BYTES:" << size << " flag:" << inputBuffer->flag_
318 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
319 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
320
321 SyncOutputFunc();
322 }
323 }
324
SyncOutputFunc()325 void AudioDecInnerAvBuffer::SyncOutputFunc()
326 {
327 int32_t sumWriteSize = 0;
328 while (isRunning_) {
329 std::shared_ptr<AVBuffer> outputBuffer =
330 audioCodec_->GetOutputBuffer(static_cast<int64_t>(TIME_OUT_MS) * MILLISECOUND_TO_SECOND);
331 if (outputBuffer == nullptr) {
332 std::cout << "SyncFunc OH_AVBuffer is nullptr" << std::endl;
333 break;
334 }
335 std::cout << "SyncFunc, OUT_FRAME_BYTES:" << outputBuffer->memory_->GetSize()
336 << ", sumWriteSize:" << sumWriteSize << std::endl;
337 sumWriteSize += outputBuffer->memory_->GetSize();
338 outputFile_->write(
339 reinterpret_cast<char *>(outputBuffer->memory_->GetAddr()), outputBuffer->memory_->GetSize());
340 outputSize_ += outputBuffer->memory_->GetSize();
341 if (outputBuffer->flag_ == AVCODEC_BUFFER_FLAGS_EOS || outputBuffer->memory_->GetSize() == 0) {
342 std::cout << "out eos" << std::endl;
343 isRunning_.store(false);
344 }
345 audioCodec_->ReleaseOutputBuffer(outputBuffer);
346 }
347 }
348
EnableAsyncChangePluginTest()349 void AudioDecInnerAvBuffer::EnableAsyncChangePluginTest()
350 {
351 enableAsyncChangePluginTest_ = true;
352 }
353
AudioCodecConsumerListener(AudioDecInnerAvBuffer * demo)354 AudioCodecConsumerListener::AudioCodecConsumerListener(AudioDecInnerAvBuffer *demo)
355 {
356 demo_ = demo;
357 }
358
OnBufferAvailable()359 void AudioCodecConsumerListener::OnBufferAvailable()
360 {
361 demo_->OutputFunc();
362 }
363
OnError(AVCodecErrorType errorType,int32_t errorCode)364 void AVCodecInnerCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
365 {
366 (void)errorType;
367 cout << "Error errorCode=" << errorCode << endl;
368 }
369
OnOutputFormatChanged(const Format & format)370 void AVCodecInnerCallback::OnOutputFormatChanged(const Format &format)
371 {
372 (void)format;
373 cout << "Format Changed" << endl;
374 }
375
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)376 void AVCodecInnerCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
377 {
378 (void)index;
379 (void)buffer;
380 }
381
OnOutputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)382 void AVCodecInnerCallback::OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
383 {
384 (void)index;
385 (void)buffer;
386 }
387
388 HWTEST_F(AVCodecAudioCodecUnitTest, Stop_001, TestSize.Level1)
389 {
390 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
391 auto &dec = audioDec->GetAudioCodec();
392 auto &meta = audioDec->GetAudioMeta();
393 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
394 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
395
396 meta = std::make_shared<Media::Meta>();
397 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
398 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
399 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
400 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
401 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
402 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
403 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
404 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
405 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
406
407 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Release());
408 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
409 }
410
411 HWTEST_F(AVCodecAudioCodecUnitTest, Flush_001, TestSize.Level1)
412 {
413 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
414 auto &dec = audioDec->GetAudioCodec();
415 auto &meta = audioDec->GetAudioMeta();
416 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
417 meta = std::make_shared<Media::Meta>();
418 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
419 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
420 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
421 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
422 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
423 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
424 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
425 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
426 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Flush());
427 }
428
429 HWTEST_F(AVCodecAudioCodecUnitTest, Reset_001, TestSize.Level1)
430 {
431 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
432 auto &dec = audioDec->GetAudioCodec();
433 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
434 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Reset());
435 }
436
437 HWTEST_F(AVCodecAudioCodecUnitTest, Release_001, TestSize.Level1)
438 {
439 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
440 auto &dec = audioDec->GetAudioCodec();
441 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
442 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Release());
443 }
444
445 HWTEST_F(AVCodecAudioCodecUnitTest, NotifyEos_001, TestSize.Level1)
446 {
447 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
448 auto &dec = audioDec->GetAudioCodec();
449 auto &meta = audioDec->GetAudioMeta();
450 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
451 meta = std::make_shared<Media::Meta>();
452 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
453 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
454 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
455 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
456 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
457 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
458 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
459 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
460 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->NotifyEos());
461 }
462
463 HWTEST_F(AVCodecAudioCodecUnitTest, SetParameter_001, TestSize.Level1)
464 {
465 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
466 auto &dec = audioDec->GetAudioCodec();
467 auto &meta = audioDec->GetAudioMeta();
468 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
469 meta = std::make_shared<Media::Meta>();
470 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
471 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
472 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
473 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
474 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
475 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
476 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
477 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
478 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetParameter(meta));
479 }
480
481 HWTEST_F(AVCodecAudioCodecUnitTest, ChangePlugin_001, TestSize.Level1)
482 {
483 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
484 auto &dec = audioDec->GetAudioCodec();
485 auto &meta = audioDec->GetAudioMeta();
486 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
487 meta = std::make_shared<Media::Meta>();
488 std::string mime;
489 meta->GetData(Tag::MIME_TYPE, mime);
490 meta->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::SAMPLE_S16LE);
491 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
492 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
493 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
494 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, dec->ChangePlugin(mime, false, meta));
495 }
496
497 HWTEST_F(AVCodecAudioCodecUnitTest, SetDataCallback_001, TestSize.Level1)
498 {
499 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
500 auto &dec = audioDec->GetAudioCodec();
501 auto &meta = audioDec->GetAudioMeta();
502 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
503 meta = std::make_shared<Media::Meta>();
504 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
505 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
506 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
507 std::shared_ptr<MediaCodecCallback> codecCallback = std::make_shared<AVCodecInnerCallback>();
508 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetCodecCallback(codecCallback));
509 }
510
511 HWTEST_F(AVCodecAudioCodecUnitTest, ProcessInputBuffer_001, TestSize.Level1)
512 {
513 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
514 auto &dec = audioDec->GetAudioCodec();
515 auto &meta = audioDec->GetAudioMeta();
516 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
517 meta = std::make_shared<Media::Meta>();
518 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
519 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
520 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
521 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
522 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
523 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
524 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
525 dec->ProcessInputBuffer();
526 }
527
528 HWTEST_F(AVCodecAudioCodecUnitTest, SetDumpInfo_001, TestSize.Level1)
529 {
530 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
531 auto &dec = audioDec->GetAudioCodec();
532 auto &meta = audioDec->GetAudioMeta();
533 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
534 meta = std::make_shared<Media::Meta>();
535 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
536 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
537 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
538 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
539 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
540 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
541 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
542 dec->SetDumpInfo(false, 0);
543 dec->SetDumpInfo(true, 1);
544 dec->SetDumpInfo(false, 0);
545 dec->SetDumpInfo(true, 1);
546 }
547
548 HWTEST_F(AVCodecAudioCodecUnitTest, GetInputBufferQueueConsumer_001, TestSize.Level1)
549 {
550 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
551 auto &dec = audioDec->GetAudioCodec();
552 auto &meta = audioDec->GetAudioMeta();
553 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
554 meta = std::make_shared<Media::Meta>();
555 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
556 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
557 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
558 sptr<Media::AVBufferQueueConsumer> inputConsumer = dec->GetInputBufferQueueConsumer();
559 EXPECT_EQ(inputConsumer, nullptr);
560 }
561
562 HWTEST_F(AVCodecAudioCodecUnitTest, GetOutputBufferQueueProducer_001, TestSize.Level1)
563 {
564 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
565 auto &dec = audioDec->GetAudioCodec();
566 auto &meta = audioDec->GetAudioMeta();
567 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
568 meta = std::make_shared<Media::Meta>();
569 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
570 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
571 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
572 sptr<Media::AVBufferQueueProducer> outputProducer = dec->GetOutputBufferQueueProducer();
573 EXPECT_EQ(outputProducer, nullptr);
574 }
575
576 HWTEST_F(AVCodecAudioCodecUnitTest, ProcessInputBufferInner_001, TestSize.Level1)
577 {
578 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
579 auto &innerBufferQueue = audioDec->GetInnerBufferQueue();
580 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
581 auto &dec = audioDec->GetAudioCodec();
582 auto &meta = audioDec->GetAudioMeta();
583 dec = AudioCodecFactory::CreateByName(MP3_CODEC_NAME.data());
584 meta = std::make_shared<Media::Meta>();
585 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
586 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
587 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
588 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
589 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
590
591 auto &implConsumer = audioDec->GetImplConsumer();
592 implConsumer = innerBufferQueue->GetConsumer();
593 bool isTriggeredByOutport = true;
594 bool isFlushed = true;
595 uint32_t bufferStatus = 0;
596 dec->ProcessInputBufferInner(isTriggeredByOutport, isFlushed, bufferStatus);
597 }
598
599 HWTEST_F(AVCodecAudioCodecUnitTest, AudioDecode_MP3, TestSize.Level1)
600 {
601 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
602 auto &meta = audioDec->GetAudioMeta();
603 meta = std::make_shared<Media::Meta>();
604 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
605 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
606 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
607 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // expected sampleRate
608 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
609 EXPECT_EQ(
610 AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase(MP3_CODEC_NAME, INPUT_FILE_PATH, OUTPUT_PCM_FILE_PATH));
611 }
612
613 HWTEST_F(AVCodecAudioCodecUnitTest, AudioDecode_AC3, TestSize.Level1)
614 {
615 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
616 auto &meta = audioDec->GetAudioMeta();
617 meta = std::make_shared<Media::Meta>();
618 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
619 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
620 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
621 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // expected sampleRate
622 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
623 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK,
624 audioDec->RunCase(AC3_CODEC_NAME, INPUT_AC3_FILE_PATH, OUTPUT_AC3_PCM_FILE_PATH));
625 }
626
627 HWTEST_F(AVCodecAudioCodecUnitTest, AudioSyncDecode_001, TestSize.Level1)
628 {
629 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
630 auto &meta = audioDec->GetAudioMeta();
631 meta = std::make_shared<Media::Meta>();
632 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
633 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
634 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
635 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // expected sampleRate
636 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
637 meta->Set<Tag::AV_CODEC_ENABLE_SYNC_MODE>(true);
638 EXPECT_EQ(
639 AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase(MP3_CODEC_NAME, INPUT_FILE_PATH, OUTPUT_PCM_FILE_PATH));
640 }
641
642 HWTEST_F(AVCodecAudioCodecUnitTest, OnOutputFormatChanged_001, TestSize.Level1)
643 {
644 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
645 auto &meta = audioDec->GetAudioMeta();
646 meta = std::make_shared<Media::Meta>();
647 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
648 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
649 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
650 meta->Set<Tag::AUDIO_SAMPLE_RATE>(48000); // supported but unexpected sampleRate
651 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
652 EXPECT_EQ(
653 AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase(MP3_CODEC_NAME, INPUT_FILE_PATH, OUTPUT_PCM_FILE_PATH));
654 }
655
656 HWTEST_F(AVCodecAudioCodecUnitTest, AsyncChangePluginWhileDecode_001, TestSize.Level1)
657 {
658 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
659 auto &meta = audioDec->GetAudioMeta();
660 meta = std::make_shared<Media::Meta>();
661 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
662 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
663 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
664 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // expected sampleRate
665 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
666 audioDec->EnableAsyncChangePluginTest();
667 EXPECT_EQ(
668 AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase(MP3_CODEC_NAME, INPUT_FILE_PATH, OUTPUT_PCM_FILE_PATH));
669 }
670
671 HWTEST_F(AVCodecAudioCodecUnitTest, CheckCreateDecoderByMimeType, TestSize.Level1)
672 {
673 const vector<std::string_view> allMimeTable = {
674 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
675 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
676 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS,
677 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
678 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
679 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
680 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
681 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID,
682 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
683 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711A,
684 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
685 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC,
686 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE,
687 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AC3,
688 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_RAW
689 };
690
691 const bool isEncoder = false;
692 for (const auto &mime : allMimeTable) {
693 const std::string name = GetCapabilityName(mime.data(), isEncoder);
694 if (name.empty()) {
695 std::cout << "without capability:" << mime << std::endl;
696 continue;
697 }
698 auto audioDec = AudioCodecFactory::CreateByMime(mime.data(), isEncoder);
699 EXPECT_NE(nullptr, audioDec);
700 if (audioDec == nullptr) {
701 std::cout << "create " << mime << " failed" << std::endl;
702 } else {
703 audioDec->Release();
704 }
705 }
706 }
707
708 HWTEST_F(AVCodecAudioCodecUnitTest, CheckCreateDecoderByCodecName, TestSize.Level1)
709 {
710 const vector<std::string_view> allMimeTable = {
711 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
712 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
713 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS,
714 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
715 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
716 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
717 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
718 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID,
719 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
720 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711A,
721 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
722 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC,
723 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE,
724 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AC3,
725 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_RAW
726 };
727
728 const bool isEncoder = false;
729 for (const auto &mime : allMimeTable) {
730 const std::string name = GetCapabilityName(mime.data(), isEncoder);
731 if (name.empty()) {
732 std::cout << "without capability:" << mime << std::endl;
733 continue;
734 }
735 auto audioDec = AudioCodecFactory::CreateByName(name.c_str());
736 EXPECT_NE(nullptr, audioDec);
737 if (audioDec == nullptr) {
738 std::cout << "create " << name << " failed" << std::endl;
739 } else {
740 audioDec->Release();
741 }
742 }
743 }
744
745 HWTEST_F(AVCodecAudioCodecUnitTest, CheckCreateEncoderByMimeType, TestSize.Level1)
746 {
747 const vector<std::string_view> allMimeTable = {
748 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
749 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
750 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
751 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
752 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
753 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
754 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
755 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
756 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC
757 };
758
759 const bool isEncoder = true;
760 for (const auto &mime : allMimeTable) {
761 const std::string name = GetCapabilityName(mime.data(), isEncoder);
762 if (name.empty()) {
763 std::cout << "without capability:" << mime << std::endl;
764 continue;
765 }
766 auto audioEnc = AudioCodecFactory::CreateByMime(mime.data(), isEncoder);
767 EXPECT_NE(nullptr, audioEnc);
768 if (audioEnc == nullptr) {
769 std::cout << "create " << mime << " failed" << std::endl;
770 } else {
771 audioEnc->Release();
772 }
773 }
774 }
775
776 HWTEST_F(AVCodecAudioCodecUnitTest, CheckCreateEncoderByCodecName, TestSize.Level1)
777 {
778 const vector<std::string_view> allMimeTable = {
779 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
780 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
781 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
782 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
783 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
784 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
785 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
786 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
787 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC
788 };
789
790 const bool isEncoder = true;
791 for (const auto &mime : allMimeTable) {
792 const std::string name = GetCapabilityName(mime.data(), isEncoder);
793 if (name.empty()) {
794 std::cout << "without capability:" << mime << std::endl;
795 continue;
796 }
797 auto audioEnc = AudioCodecFactory::CreateByName(name.c_str());
798 EXPECT_NE(nullptr, audioEnc);
799 if (audioEnc == nullptr) {
800 std::cout << "create " << name << " failed" << std::endl;
801 } else {
802 audioEnc->Release();
803 }
804 }
805 }
806
807 } // namespace MediaAVCodec
808 } // namespace OHOS