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_errors.h"
29
30 using namespace std;
31 using namespace testing::ext;
32 using namespace OHOS::Media;
33 using namespace OHOS::MediaAVCodec;
34
35 namespace {
36 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
37 constexpr uint32_t CHANNEL_COUNT_STEREO = 2;
38 constexpr uint32_t SAMPLE_RATE = 48000;
39 constexpr std::string_view INPUT_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.dat";
40 constexpr std::string_view OUTPUT_PCM_FILE_PATH = "/data/test/media/mp3_2c_44100hz_60k.pcm";
41 constexpr int32_t INPUT_FRAME_BYTES = 2 * 1024 * 4;
42 constexpr int32_t TIME_OUT_MS = 8;
43
44 typedef enum OH_AVCodecBufferFlags {
45 AVCODEC_BUFFER_FLAGS_NONE = 0,
46 /* Indicates that the Buffer is an End-of-Stream frame */
47 AVCODEC_BUFFER_FLAGS_EOS = 1 << 0,
48 /* Indicates that the Buffer contains keyframes */
49 AVCODEC_BUFFER_FLAGS_SYNC_FRAME = 1 << 1,
50 /* Indicates that the data contained in the Buffer is only part of a frame */
51 AVCODEC_BUFFER_FLAGS_INCOMPLETE_FRAME = 1 << 2,
52 /* Indicates that the Buffer contains Codec-Specific-Data */
53 AVCODEC_BUFFER_FLAGS_CODEC_DATA = 1 << 3,
54 } OH_AVCodecBufferFlags;
55 } // namespace
56
57 namespace OHOS {
58 namespace MediaAVCodec {
GetFileSize(const std::string & filePath)59 static int32_t GetFileSize(const std::string &filePath)
60 {
61 std::ifstream file(filePath, std::ios::binary | std::ios::ate);
62 if (!file) {
63 std::cerr << "Failed to open file:" << filePath << std::endl;
64 return -1;
65 }
66
67 std::streampos fileSize = file.tellg();
68 file.close();
69
70 return (int32_t)fileSize;
71 }
72
SetUpTestCase(void)73 void AVCodecAudioCodecUnitTest::SetUpTestCase(void)
74 {
75 cout << "[SetUpTestCase]: " << endl;
76 }
77
TearDownTestCase(void)78 void AVCodecAudioCodecUnitTest::TearDownTestCase(void)
79 {
80 cout << "[TearDownTestCase]: " << endl;
81 }
82
SetUp(void)83 void AVCodecAudioCodecUnitTest::SetUp(void)
84 {
85 cout << "[SetUp]: SetUp!!!" << endl;
86 }
87
TearDown(void)88 void AVCodecAudioCodecUnitTest::TearDown(void)
89 {
90 cout << "[TearDown]: over!!!" << endl;
91 }
92
RunCase()93 int32_t AudioDecInnerAvBuffer::RunCase()
94 {
95 int32_t ret = AVCodecServiceErrCode::AVCS_ERR_OK;
96 innerBufferQueue_ = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "InnerDemo"); // 4
97 audioCodec_ = AudioCodecFactory::CreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
98 DEMO_CHECK_AND_RETURN_RET_LOG(audioCodec_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN,
99 "audioCodec_ is null");
100 audioCodec_->Configure(meta_);
101
102 audioCodec_->SetOutputBufferQueue(innerBufferQueue_->GetProducer());
103 audioCodec_->Prepare();
104
105 implConsumer_ = innerBufferQueue_->GetConsumer();
106 sptr<Media::IConsumerListener> comsumerListener = new AudioCodecConsumerListener(this);
107 implConsumer_->SetBufferAvailableListener(comsumerListener);
108 mediaCodecProducer_ = audioCodec_->GetInputBufferQueue();
109
110 audioCodec_->Start();
111 isRunning_.store(true);
112
113 fileSize_ = GetFileSize(INPUT_FILE_PATH.data());
114 inputFile_ = std::make_unique<std::ifstream>(INPUT_FILE_PATH, std::ios::binary);
115 outputFile_ = std::make_unique<std::ofstream>(OUTPUT_PCM_FILE_PATH, std::ios::binary);
116 InputFunc();
117 inputFile_->close();
118 outputFile_->close();
119 return ret;
120 }
121
GetInputBufferSize()122 int32_t AudioDecInnerAvBuffer::GetInputBufferSize()
123 {
124 int32_t capacity = 0;
125 DEMO_CHECK_AND_RETURN_RET_LOG(audioCodec_ != nullptr, capacity, "audioCodec_ is nullptr");
126 std::shared_ptr<Media::Meta> bufferConfig = std::make_shared<Media::Meta>();
127 DEMO_CHECK_AND_RETURN_RET_LOG(bufferConfig != nullptr, capacity, "bufferConfig is nullptr");
128 int32_t ret = audioCodec_->GetOutputFormat(bufferConfig);
129 DEMO_CHECK_AND_RETURN_RET_LOG(ret == AVCodecServiceErrCode::AVCS_ERR_OK, capacity, "GetOutputFormat fail");
130 DEMO_CHECK_AND_RETURN_RET_LOG(bufferConfig->Get<Media::Tag::AUDIO_MAX_INPUT_SIZE>(capacity),
131 capacity, "get max input buffer size fail");
132 return capacity;
133 }
134
InputFunc()135 void AudioDecInnerAvBuffer::InputFunc()
136 {
137 DEMO_CHECK_AND_RETURN_LOG(inputFile_ != nullptr && inputFile_->is_open(), "Fatal: open file fail");
138 int32_t sumReadSize = 0;
139 Media::Status ret;
140 int64_t size;
141 int64_t pts;
142 Media::AVBufferConfig avBufferConfig;
143 avBufferConfig.size = GetInputBufferSize();
144 while (isRunning_) {
145 std::shared_ptr<AVBuffer> inputBuffer = nullptr;
146 DEMO_CHECK_AND_BREAK_LOG(mediaCodecProducer_ != nullptr, "mediaCodecProducer_ is nullptr");
147 ret = mediaCodecProducer_->RequestBuffer(inputBuffer, avBufferConfig, TIME_OUT_MS);
148 if (ret != Media::Status::OK) {
149 std::cout << "produceInputBuffer RequestBuffer fail,ret=" << (int32_t)ret << std::endl;
150 break;
151 }
152 DEMO_CHECK_AND_BREAK_LOG(inputBuffer != nullptr, "buffer is nullptr");
153 inputFile_->read(reinterpret_cast<char *>(&size), sizeof(size));
154 if (inputFile_->eof() || inputFile_->gcount() == 0 || size == 0) {
155 inputBuffer->memory_->SetSize(1);
156 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
157 sumReadSize += 0;
158 mediaCodecProducer_->PushBuffer(inputBuffer, true);
159 sumReadSize += inputFile_->gcount();
160 std::cout << "InputFunc, INPUT_FRAME_BYTES:" << INPUT_FRAME_BYTES << " flag:" << inputBuffer->flag_
161 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
162 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
163 std::cout << "end buffer\n";
164 break;
165 }
166 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(size), "Fatal: read size fail");
167 sumReadSize += inputFile_->gcount();
168 inputFile_->read(reinterpret_cast<char *>(&pts), sizeof(pts));
169 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == sizeof(pts), "Fatal: read pts fail");
170 sumReadSize += inputFile_->gcount();
171 inputFile_->read(reinterpret_cast<char *>(inputBuffer->memory_->GetAddr()), size);
172 DEMO_CHECK_AND_BREAK_LOG(inputFile_->gcount() == size, "Fatal: read buffer fail");
173 inputBuffer->memory_->SetSize(size);
174 inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
175 sumReadSize += inputFile_->gcount();
176 mediaCodecProducer_->PushBuffer(inputBuffer, true);
177 std::cout << "InputFunc, INPUT_FRAME_BYTES:" << INPUT_FRAME_BYTES << " flag:" << inputBuffer->flag_
178 << " sumReadSize:" << sumReadSize << " fileSize_:" << fileSize_
179 << " process:" << 100 * sumReadSize / fileSize_ << "%" << std::endl; // 100
180 }
181 }
182
OutputFunc()183 void AudioDecInnerAvBuffer::OutputFunc()
184 {
185 bufferConsumerAvailableCount_++;
186 Media::Status ret = Media::Status::OK;
187 while (isRunning_ && (bufferConsumerAvailableCount_ > 0)) {
188 std::cout << "/**********ImplConsumerOutputBuffer while**********/" << std::endl;
189 std::shared_ptr<AVBuffer> outputBuffer;
190 ret = implConsumer_->AcquireBuffer(outputBuffer);
191 if (ret != Media::Status::OK) {
192 std::cout << "Consumer AcquireBuffer fail,ret=" << (int32_t)ret << std::endl;
193 break;
194 }
195 if (outputBuffer == nullptr) {
196 std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
197 continue;
198 }
199 outputFile_->write(reinterpret_cast<char *>(outputBuffer->memory_->GetAddr()),
200 outputBuffer->memory_->GetSize());
201 if (outputBuffer->flag_ == AVCODEC_BUFFER_FLAGS_EOS || outputBuffer->memory_->GetSize() == 0) {
202 std::cout << "out eos" << std::endl;
203 isRunning_.store(false);
204 }
205 implConsumer_->ReleaseBuffer(outputBuffer);
206 bufferConsumerAvailableCount_--;
207 }
208 }
209
AudioCodecConsumerListener(AudioDecInnerAvBuffer * demo)210 AudioCodecConsumerListener::AudioCodecConsumerListener(AudioDecInnerAvBuffer *demo)
211 {
212 demo_ = demo;
213 }
214
OnBufferAvailable()215 void AudioCodecConsumerListener::OnBufferAvailable()
216 {
217 demo_->OutputFunc();
218 }
219
OnError(AVCodecErrorType errorType,int32_t errorCode)220 void AVCodecInnerCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
221 {
222 (void)errorType;
223 cout << "Error errorCode=" << errorCode << endl;
224 }
225
OnOutputFormatChanged(const Format & format)226 void AVCodecInnerCallback::OnOutputFormatChanged(const Format &format)
227 {
228 (void)format;
229 cout << "Format Changed" << endl;
230 }
231
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)232 void AVCodecInnerCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
233 {
234 (void)index;
235 (void)buffer;
236 }
237
OnOutputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)238 void AVCodecInnerCallback::OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
239 {
240 (void)index;
241 (void)buffer;
242 }
243
244 HWTEST_F(AVCodecAudioCodecUnitTest, Stop_001, TestSize.Level1)
245 {
246 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
247 auto& dec = audioDec->GetAudioCodec();
248 auto& meta = audioDec->GetAudioMeta();
249 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
250 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
251
252 meta = std::make_shared<Media::Meta>();
253 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
254 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
255 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
256 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
257 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
258 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
259 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
260 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
261 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
262
263 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Release());
264 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Stop());
265 }
266
267 HWTEST_F(AVCodecAudioCodecUnitTest, Flush_001, TestSize.Level1)
268 {
269 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
270 auto& dec = audioDec->GetAudioCodec();
271 auto& meta = audioDec->GetAudioMeta();
272 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
273 meta = std::make_shared<Media::Meta>();
274 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
275 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
276 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
277 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
278 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
279 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
280 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
281 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
282 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Flush());
283 }
284
285 HWTEST_F(AVCodecAudioCodecUnitTest, Reset_001, TestSize.Level1)
286 {
287 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
288 auto& dec = audioDec->GetAudioCodec();
289 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
290 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Reset());
291 }
292
293 HWTEST_F(AVCodecAudioCodecUnitTest, Release_001, TestSize.Level1)
294 {
295 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
296 auto& dec = audioDec->GetAudioCodec();
297 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
298 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Release());
299 }
300
301 HWTEST_F(AVCodecAudioCodecUnitTest, NotifyEos_001, TestSize.Level1)
302 {
303 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
304 auto& dec = audioDec->GetAudioCodec();
305 auto& meta = audioDec->GetAudioMeta();
306 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
307 meta = std::make_shared<Media::Meta>();
308 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
309 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
310 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
311 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
312 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
313 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
314 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
315 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
316 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->NotifyEos());
317 }
318
319 HWTEST_F(AVCodecAudioCodecUnitTest, SetParameter_001, TestSize.Level1)
320 {
321 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
322 auto& dec = audioDec->GetAudioCodec();
323 auto& meta = audioDec->GetAudioMeta();
324 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
325 meta = std::make_shared<Media::Meta>();
326 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
327 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
328 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
329 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
330 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
331 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
332 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
333 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Start());
334 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetParameter(meta));
335 }
336
337 HWTEST_F(AVCodecAudioCodecUnitTest, ChangePlugin_001, TestSize.Level1)
338 {
339 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
340 auto& dec = audioDec->GetAudioCodec();
341 auto& meta = audioDec->GetAudioMeta();
342 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
343 meta = std::make_shared<Media::Meta>();
344 std::string mime;
345 meta->GetData(Tag::MIME_TYPE, mime);
346 meta->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::SAMPLE_S16LE);
347 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
348 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
349 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
350 EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, dec->ChangePlugin(mime, false, meta));
351 }
352
353 HWTEST_F(AVCodecAudioCodecUnitTest, SetDataCallback_001, TestSize.Level1)
354 {
355 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
356 auto& dec = audioDec->GetAudioCodec();
357 auto& meta = audioDec->GetAudioMeta();
358 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
359 meta = std::make_shared<Media::Meta>();
360 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
361 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
362 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
363 std::shared_ptr<MediaCodecCallback> codecCallback = std::make_shared<AVCodecInnerCallback>();
364 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetCodecCallback(codecCallback));
365 }
366
367 HWTEST_F(AVCodecAudioCodecUnitTest, ProcessInputBuffer_001, TestSize.Level1)
368 {
369 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
370 auto& dec = audioDec->GetAudioCodec();
371 auto& meta = audioDec->GetAudioMeta();
372 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
373 meta = std::make_shared<Media::Meta>();
374 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
375 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
376 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
377 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
378 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
379 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
380 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
381 dec->ProcessInputBuffer();
382 }
383
384 HWTEST_F(AVCodecAudioCodecUnitTest, SetDumpInfo_001, TestSize.Level1)
385 {
386 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
387 auto& dec = audioDec->GetAudioCodec();
388 auto& meta = audioDec->GetAudioMeta();
389 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
390 meta = std::make_shared<Media::Meta>();
391 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
392 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
393 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
394 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
395 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
396 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
397 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
398 dec->SetDumpInfo(false, 0);
399 dec->SetDumpInfo(true, 1);
400 dec->SetDumpInfo(false, 0);
401 dec->SetDumpInfo(true, 1);
402 }
403
404 HWTEST_F(AVCodecAudioCodecUnitTest, GetInputBufferQueueConsumer_001, TestSize.Level1)
405 {
406 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
407 auto& dec = audioDec->GetAudioCodec();
408 auto& meta = audioDec->GetAudioMeta();
409 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
410 meta = std::make_shared<Media::Meta>();
411 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
412 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
413 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
414 sptr<Media::AVBufferQueueConsumer> inputConsumer = dec->GetInputBufferQueueConsumer();
415 EXPECT_EQ(inputConsumer, nullptr);
416 }
417
418 HWTEST_F(AVCodecAudioCodecUnitTest, GetOutputBufferQueueProducer_001, TestSize.Level1)
419 {
420 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
421 auto& dec = audioDec->GetAudioCodec();
422 auto& meta = audioDec->GetAudioMeta();
423 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
424 meta = std::make_shared<Media::Meta>();
425 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
426 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
427 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
428 sptr<Media::AVBufferQueueProducer> outputProducer = dec->GetOutputBufferQueueProducer();
429 EXPECT_EQ(outputProducer, nullptr);
430 }
431
432 HWTEST_F(AVCodecAudioCodecUnitTest, ProcessInputBufferInner_001, TestSize.Level1)
433 {
434 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
435 auto& innerBufferQueue = audioDec->GetInnerBufferQueue();
436 innerBufferQueue = Media::AVBufferQueue::Create(4, Media::MemoryType::SHARED_MEMORY, "AVBufferInnerUT"); // 4
437 auto& dec = audioDec->GetAudioCodec();
438 auto& meta = audioDec->GetAudioMeta();
439 dec = AudioCodecFactory::CreateByName(CODEC_MP3_NAME);
440 meta = std::make_shared<Media::Meta>();
441 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
442 meta->Set<Tag::AUDIO_SAMPLE_RATE>(SAMPLE_RATE);
443 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Configure(meta));
444 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->SetOutputBufferQueue(innerBufferQueue->GetProducer()));
445 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, dec->Prepare());
446
447 auto& implConsumer = audioDec->GetImplConsumer();
448 implConsumer = innerBufferQueue->GetConsumer();
449 bool isTriggeredByOutport = true;
450 bool isFlushed = true;
451 dec->ProcessInputBufferInner(isTriggeredByOutport, isFlushed);
452 }
453
454 HWTEST_F(AVCodecAudioCodecUnitTest, AudioDecode_001, TestSize.Level1)
455 {
456 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
457 auto& meta = audioDec->GetAudioMeta();
458 meta = std::make_shared<Media::Meta>();
459 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
460 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
461 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
462 meta->Set<Tag::AUDIO_SAMPLE_RATE>(44100); // expected sampleRate
463 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
464 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase());
465 }
466
467 HWTEST_F(AVCodecAudioCodecUnitTest, OnOutputFormatChanged_001, TestSize.Level1)
468 {
469 auto audioDec = std::make_shared<AudioDecInnerAvBuffer>();
470 auto& meta = audioDec->GetAudioMeta();
471 meta = std::make_shared<Media::Meta>();
472 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(CHANNEL_COUNT_STEREO);
473 meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
474 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
475 meta->Set<Tag::AUDIO_SAMPLE_RATE>(48000); // supported but unexpected sampleRate
476 meta->Set<Tag::MEDIA_BITRATE>(60000); // BITRATE is 60000
477 EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audioDec->RunCase());
478 }
479 } // namespace MediaAVCodec
480 } // namespace OHOS