1 /*
2 * Copyright (C) 2023 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 <vector>
17 #include <queue>
18 #include <mutex>
19 #include <gtest/gtest.h>
20 #include <iostream>
21 #include <unistd.h>
22 #include <atomic>
23 #include <fstream>
24 #include <queue>
25 #include <string>
26 #include <thread>
27 #include "avcodec_codec_name.h"
28 #include "avcodec_common.h"
29 #include "avcodec_errors.h"
30 #include "avcodec_mime_type.h"
31 #include "media_description.h"
32 #include "native_avcodec_base.h"
33 #include "native_avformat.h"
34 #include "avcodec_common.h"
35 #include "avcodec_errors.h"
36 #include "securec.h"
37 #include "avcodec_audio_common.h"
38 #include "native_avbuffer.h"
39 #include "common/native_mfmagic.h"
40 #include "native_avcodec_audiocodec.h"
41 #include "native_audio_channel_layout.h"
42 #include "native_avcapability.h"
43
44 using namespace std;
45 using namespace testing::ext;
46 using namespace OHOS::MediaAVCodec;
47
48 namespace {
49 constexpr uint32_t CHANNEL_COUNT = 2;
50 constexpr uint32_t ABNORMAL_CHANNEL_COUNT = 10;
51 constexpr uint32_t SAMPLE_RATE = 44100;
52 constexpr uint32_t OPUS_SAMPLE_RATE = 48000;
53 constexpr uint32_t CHANNEL_1CHAN_COUNT = 1;
54 constexpr uint32_t SAMPLE_RATE_8K = 8000;
55 constexpr uint32_t SAMPLE_RATE_48K = 48000;
56 constexpr uint32_t ABNORMAL_SAMPLE_RATE = 9999999;
57 constexpr uint32_t BITS_RATE = 261000;
58 constexpr int32_t MP3_BIT_RATE = 128000;
59 constexpr int32_t ABNORMAL_BITS_RATE = -1;
60 constexpr int32_t BITS_PER_CODED_SAMPLE = AudioSampleFormat::SAMPLE_S16LE;
61 constexpr uint64_t CHANNEL_LAYOUT = OH_AudioChannelLayout::CH_LAYOUT_STEREO;
62 constexpr uint64_t ABNORMAL_CHANNEL_LAYOUT = OH_AudioChannelLayout::CH_LAYOUT_10POINT2;
63 constexpr uint64_t ABNORMAL_CHANNEL_LAYOUT_UNKNOWN = OH_AudioChannelLayout::CH_LAYOUT_UNKNOWN;
64 constexpr int32_t SAMPLE_FORMAT = AudioSampleFormat::SAMPLE_S16LE;
65 constexpr int32_t ABNORMAL_SAMPLE_FORMAT = AudioSampleFormat::SAMPLE_U8;
66 constexpr uint32_t FLAC_DEFAULT_FRAME_BYTES = 18432;
67 constexpr uint32_t AAC_DEFAULT_FRAME_BYTES = 2 * 1024 * 4;
68 constexpr uint32_t G711MU_DEFAULT_FRAME_BYTES = 320;
69 constexpr uint32_t MP3_DEFAULT_FRAME_BYTES = 4608;
70 constexpr int32_t MAX_INPUT_SIZE = 8192;
71 constexpr uint32_t ILLEGAL_CHANNEL_COUNT = 9;
72 constexpr uint32_t AAC_ILLEGAL_CHANNEL_COUNT = 7;
73 constexpr uint32_t ILLEGAL_SAMPLE_RATE = 441000;
74 constexpr int32_t COMPLIANCE_LEVEL = 0;
75 constexpr int32_t ABNORMAL_COMPLIANCE_LEVEL_L = -9999999;
76 constexpr int32_t ABNORMAL_COMPLIANCE_LEVEL_R = 9999999;
77
78 constexpr string_view FLAC_INPUT_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
79 constexpr string_view FLAC_OUTPUT_FILE_PATH = "/data/test/media/encoderTest.flac";
80 constexpr string_view AAC_INPUT_FILE_PATH = "/data/test/media/aac_2c_44100hz_199k.pcm";
81 constexpr string_view AAC_OUTPUT_FILE_PATH = "/data/test/media/aac_2c_44100hz_encode.aac";
82 constexpr string_view G711MU_INPUT_FILE_PATH = "/data/test/media/g711mu_8kHz_10s.pcm";
83 constexpr string_view G711MU_OUTPUT_FILE_PATH = "/data/test/media/g711mu_8kHz_10s_afterEncode.raw";
84 constexpr string_view OPUS_INPUT_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
85 constexpr string_view OPUS_OUTPUT_FILE_PATH = "/data/test/media/encoderTest.opus";
86 const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so";
87 constexpr string_view MP3_INPUT_FILE_PATH = "/data/test/media/flac_2c_44100hz_261k.pcm";
88 constexpr string_view MP3_OUTPUT_FILE_PATH = "/data/test/media/mp3_2c_44100hz_afterEncode.mp3";
89 } // namespace
90
91 namespace OHOS {
92 namespace MediaAVCodec {
93 enum class AudioBufferFormatType : int32_t {
94 TYPE_AAC = 0,
95 TYPE_FLAC = 1,
96 TYPE_MP3 = 2,
97 TYPE_VORBIS = 3,
98 TYPE_AMRNB = 4,
99 TYPE_AMRWB = 5,
100 TYPE_G711MU = 6,
101 TYPE_OPUS = 7,
102 TYPE_MAX = 8,
103 };
104
105 class AudioCodecBufferSignal {
106 public:
107 std::mutex inMutex_;
108 std::mutex outMutex_;
109 std::mutex startMutex_;
110 std::condition_variable inCond_;
111 std::condition_variable outCond_;
112 std::condition_variable startCond_;
113 std::queue<uint32_t> inQueue_;
114 std::queue<uint32_t> outQueue_;
115 std::queue<OH_AVBuffer *> inBufferQueue_;
116 std::queue<OH_AVBuffer *> outBufferQueue_;
117 };
118
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)119 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
120 {
121 (void)codec;
122 (void)errorCode;
123 (void)userData;
124 cout << "Error received, errorCode:" << errorCode << endl;
125 }
126
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)127 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
128 {
129 (void)codec;
130 (void)format;
131 (void)userData;
132 cout << "OnOutputFormatChanged received" << endl;
133 }
134
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * buffer,void * userData)135 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *buffer, void *userData)
136 {
137 (void)codec;
138 AudioCodecBufferSignal *signal = static_cast<AudioCodecBufferSignal *>(userData);
139 unique_lock<mutex> lock(signal->inMutex_);
140 signal->inQueue_.push(index);
141 signal->inBufferQueue_.push(buffer);
142 signal->inCond_.notify_all();
143 }
144
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * buffer,void * userData)145 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *buffer, void *userData)
146 {
147 (void)codec;
148 AudioCodecBufferSignal *signal = static_cast<AudioCodecBufferSignal *>(userData);
149 unique_lock<mutex> lock(signal->outMutex_);
150 signal->outQueue_.push(index);
151 signal->outBufferQueue_.push(buffer);
152 if (buffer) {
153 cout << "OnOutputBufferAvailable received, index:" << index << ", size:" << buffer->buffer_->memory_->GetSize()
154 << ", flags:" << buffer->buffer_->flag_ << ", pts: " << buffer->buffer_->pts_ << endl;
155 } else {
156 cout << "OnOutputBufferAvailable error, attr is nullptr!" << endl;
157 }
158 signal->outCond_.notify_all();
159 }
160
161 class AudioEncoderBufferCapiUnitTest : public testing::Test {
162 public:
163 static void SetUpTestCase(void);
164 static void TearDownTestCase(void);
165 void SetUp();
166 void TearDown();
167 void SleepTest();
168 void Release();
169 void HandleEOS(const uint32_t &index);
170 void InputFunc();
171 void OutputFunc();
172 int32_t GetFileSize(const std::string &filePath);
173 int32_t GetFrameBytes();
174 int32_t InitFile(AudioBufferFormatType audioType);
175 int32_t CreateCodecFunc(AudioBufferFormatType audioType);
176 int32_t CheckSoFunc();
177 int32_t Start();
178 int32_t Stop();
179 void JoinThread();
180
181 protected:
182 std::atomic<bool> isRunning_ = false;
183 std::unique_ptr<std::thread> inputLoop_;
184 std::unique_ptr<std::thread> outputLoop_;
185 struct OH_AVCodecCallback cb_;
186 AudioCodecBufferSignal *signal_ = nullptr;
187 OH_AVCodec *audioEnc_ = nullptr;
188 OH_AVFormat *format = nullptr;
189 bool isFirstFrame_ = true;
190 std::unique_ptr<std::ifstream> inputFile_;
191 std::unique_ptr<std::ofstream> outputFile_;
192 std::unique_ptr<std::ifstream> soFile_;
193 int32_t fileSize_ = 0;
194 uint32_t frameBytes_ = FLAC_DEFAULT_FRAME_BYTES; // default for flac
195 int32_t outputFrameCnt_ = 0;
196 };
197
SetUpTestCase(void)198 void AudioEncoderBufferCapiUnitTest::SetUpTestCase(void)
199 {
200 cout << "[SetUpTestCase]: " << endl;
201 }
202
TearDownTestCase(void)203 void AudioEncoderBufferCapiUnitTest::TearDownTestCase(void)
204 {
205 cout << "[TearDownTestCase]: " << endl;
206 }
207
SetUp(void)208 void AudioEncoderBufferCapiUnitTest::SetUp(void)
209 {
210 cout << "[SetUp]: SetUp!!!" << endl;
211 }
212
TearDown(void)213 void AudioEncoderBufferCapiUnitTest::TearDown(void)
214 {
215 cout << "[TearDown]: over!!!" << endl;
216
217 if (signal_) {
218 delete signal_;
219 signal_ = nullptr;
220 }
221 if (inputFile_ != nullptr) {
222 if (inputFile_->is_open()) {
223 inputFile_->close();
224 }
225 }
226
227 if (outputFile_ != nullptr) {
228 if (outputFile_->is_open()) {
229 outputFile_->close();
230 }
231 }
232 }
233
SleepTest()234 void AudioEncoderBufferCapiUnitTest::SleepTest()
235 {
236 sleep(1);
237 }
238
Release()239 void AudioEncoderBufferCapiUnitTest::Release()
240 {
241 SleepTest();
242 Stop();
243 OH_AudioCodec_Destroy(audioEnc_);
244 }
245
HandleEOS(const uint32_t & index)246 void AudioEncoderBufferCapiUnitTest::HandleEOS(const uint32_t &index)
247 {
248 OH_AudioCodec_PushInputBuffer(audioEnc_, index);
249 std::cout << "end buffer\n";
250 signal_->inQueue_.pop();
251 signal_->inBufferQueue_.pop();
252 }
253
InputFunc()254 void AudioEncoderBufferCapiUnitTest::InputFunc()
255 {
256 if (!inputFile_->is_open()) {
257 cout << "Fatal: open file fail" << endl;
258 return;
259 }
260 while (isRunning_.load()) {
261 unique_lock<mutex> lock(signal_->inMutex_);
262 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
263 if (!isRunning_.load()) {
264 break;
265 }
266 uint32_t index = signal_->inQueue_.front();
267 auto buffer = signal_->inBufferQueue_.front();
268 if (buffer == nullptr) {
269 cout << "Fatal: GetInputBuffer fail" << endl;
270 break;
271 }
272 if (!inputFile_->eof()) {
273 inputFile_->read((char *)OH_AVBuffer_GetAddr(buffer), frameBytes_);
274 int32_t readSize = inputFile_->gcount();
275 if (readSize == 0) {
276 continue;
277 }
278 buffer->buffer_->memory_->SetSize(readSize);
279 } else {
280 buffer->buffer_->memory_->SetSize(1);
281 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
282 HandleEOS(index);
283 break;
284 }
285 int32_t ret = AVCS_ERR_OK;
286 if (isFirstFrame_) {
287 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
288 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
289 isFirstFrame_ = false;
290 } else {
291 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
292 ret = OH_AudioCodec_PushInputBuffer(audioEnc_, index);
293 }
294 signal_->inQueue_.pop();
295 signal_->inBufferQueue_.pop();
296 if (ret != AVCS_ERR_OK) {
297 cout << "Fatal error, exit" << endl;
298 break;
299 }
300 }
301 cout << "stop, exit" << endl;
302 inputFile_->close();
303 }
304
OutputFunc()305 void AudioEncoderBufferCapiUnitTest::OutputFunc()
306 {
307 if (!outputFile_->is_open()) {
308 cout << "Fatal: open output file fail" << endl;
309 return;
310 }
311 outputFrameCnt_ = 0;
312 while (isRunning_.load()) {
313 unique_lock<mutex> lock(signal_->outMutex_);
314 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
315
316 if (!isRunning_.load()) {
317 cout << "wait to stop, exit" << endl;
318 break;
319 }
320 uint32_t index = signal_->outQueue_.front();
321 OH_AVBuffer *avBuffer = signal_->outBufferQueue_.front();
322 if (avBuffer == nullptr) {
323 cout << "OutputFunc OH_AVBuffer is nullptr" << endl;
324 continue;
325 }
326 if (avBuffer != nullptr) {
327 cout << "OutputFunc write file,buffer index:"
328 << index << ", data size:" << avBuffer->buffer_->memory_->GetSize() << endl;
329 outputFile_->write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(avBuffer)),
330 avBuffer->buffer_->memory_->GetSize());
331 }
332 if (avBuffer != nullptr &&
333 (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || avBuffer->buffer_->memory_->GetSize()== 0)) {
334 cout << "encode eos" << endl;
335 isRunning_.store(false);
336 signal_->startCond_.notify_all();
337 }
338 signal_->outBufferQueue_.pop();
339 signal_->outQueue_.pop();
340 if (OH_AudioCodec_FreeOutputBuffer(audioEnc_, index) != AV_ERR_OK) {
341 cout << "Fatal: FreeOutputData fail" << endl;
342 break;
343 }
344 if (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
345 cout << "decode eos" << endl;
346 isRunning_.store(false);
347 signal_->startCond_.notify_all();
348 } else {
349 outputFrameCnt_++;
350 }
351 }
352 cout << "stop, exit" << endl;
353 outputFile_->close();
354 }
355
GetFileSize(const std::string & filePath)356 int32_t AudioEncoderBufferCapiUnitTest::GetFileSize(const std::string &filePath)
357 {
358 std::ifstream file(filePath, std::ios::binary | std::ios::ate);
359 if (!file) {
360 std::cerr << "Failed to open file: " << filePath << std::endl;
361 return -1;
362 }
363
364 std::streampos fileSize = file.tellg(); // 获取文件大小
365 file.close();
366
367 return (int32_t)fileSize;
368 }
369
InitFile(AudioBufferFormatType audioType)370 int32_t AudioEncoderBufferCapiUnitTest::InitFile(AudioBufferFormatType audioType)
371 {
372 if (audioType == AudioBufferFormatType::TYPE_FLAC) {
373 fileSize_ = GetFileSize(FLAC_INPUT_FILE_PATH.data());
374 inputFile_ = std::make_unique<std::ifstream>(FLAC_INPUT_FILE_PATH, std::ios::binary);
375 outputFile_ = std::make_unique<std::ofstream>(FLAC_OUTPUT_FILE_PATH, std::ios::binary);
376 } else if (audioType == AudioBufferFormatType::TYPE_AAC) {
377 fileSize_ = GetFileSize(AAC_INPUT_FILE_PATH.data());
378 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
379 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
380 } else if (audioType == AudioBufferFormatType::TYPE_G711MU) {
381 fileSize_ = GetFileSize(G711MU_INPUT_FILE_PATH.data());
382 inputFile_ = std::make_unique<std::ifstream>(G711MU_INPUT_FILE_PATH, std::ios::binary);
383 outputFile_ = std::make_unique<std::ofstream>(G711MU_OUTPUT_FILE_PATH, std::ios::binary);
384 } else if (audioType == AudioBufferFormatType::TYPE_OPUS) {
385 fileSize_ = GetFileSize(AAC_INPUT_FILE_PATH.data());
386 inputFile_ = std::make_unique<std::ifstream>(OPUS_INPUT_FILE_PATH, std::ios::binary);
387 outputFile_ = std::make_unique<std::ofstream>(OPUS_OUTPUT_FILE_PATH, std::ios::binary);
388 } else if (audioType == AudioBufferFormatType::TYPE_MP3) {
389 fileSize_ = GetFileSize(MP3_INPUT_FILE_PATH.data());
390 inputFile_ = std::make_unique<std::ifstream>(MP3_INPUT_FILE_PATH, std::ios::binary);
391 outputFile_ = std::make_unique<std::ofstream>(MP3_OUTPUT_FILE_PATH, std::ios::binary);
392 } else {
393 cout << "audio name not support" << endl;
394 return OH_AVErrCode::AV_ERR_UNKNOWN;
395 }
396 if (!inputFile_->is_open()) {
397 cout << "Fatal: open input file failed" << endl;
398 return OH_AVErrCode::AV_ERR_UNKNOWN;
399 }
400 if (!outputFile_->is_open()) {
401 cout << "Fatal: open output file failed" << endl;
402 return OH_AVErrCode::AV_ERR_UNKNOWN;
403 }
404 return OH_AVErrCode::AV_ERR_OK;
405 }
406
CreateCodecFunc(AudioBufferFormatType audioType)407 int32_t AudioEncoderBufferCapiUnitTest::CreateCodecFunc(AudioBufferFormatType audioType)
408 {
409 if (audioType == AudioBufferFormatType::TYPE_FLAC) {
410 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME).data());
411 } else if (audioType == AudioBufferFormatType::TYPE_AAC) {
412 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data());
413 } else if (audioType == AudioBufferFormatType::TYPE_G711MU) {
414 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_G711MU_NAME).data());
415 } else if (audioType == AudioBufferFormatType::TYPE_OPUS) {
416 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME).data());
417 } else if (audioType == AudioBufferFormatType::TYPE_MP3) {
418 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_MP3_NAME).data());
419 } else {
420 cout << "audio name not support" << endl;
421 return OH_AVErrCode::AV_ERR_UNKNOWN;
422 }
423
424 if (audioEnc_ == nullptr) {
425 cout << "Fatal: CreateByName fail" << endl;
426 return OH_AVErrCode::AV_ERR_UNKNOWN;
427 }
428
429 signal_ = new AudioCodecBufferSignal();
430 if (signal_ == nullptr) {
431 cout << "Fatal: create signal fail" << endl;
432 return OH_AVErrCode::AV_ERR_UNKNOWN;
433 }
434 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
435 int32_t ret = OH_AudioCodec_RegisterCallback(audioEnc_, cb_, signal_);
436 if (ret != OH_AVErrCode::AV_ERR_OK) {
437 cout << "Fatal: SetCallback fail" << endl;
438 return OH_AVErrCode::AV_ERR_UNKNOWN;
439 }
440
441 return OH_AVErrCode::AV_ERR_OK;
442 }
443
Start()444 int32_t AudioEncoderBufferCapiUnitTest::Start()
445 {
446 isRunning_.store(true);
447 inputLoop_ = make_unique<thread>(&AudioEncoderBufferCapiUnitTest::InputFunc, this);
448 if (inputLoop_ == nullptr) {
449 cout << "Fatal: No memory" << endl;
450 return OH_AVErrCode::AV_ERR_UNKNOWN;
451 }
452
453 outputLoop_ = make_unique<thread>(&AudioEncoderBufferCapiUnitTest::OutputFunc, this);
454 if (outputLoop_ == nullptr) {
455 cout << "Fatal: No memory" << endl;
456 return OH_AVErrCode::AV_ERR_UNKNOWN;
457 }
458
459 return OH_AudioCodec_Start(audioEnc_);
460 }
461
JoinThread()462 void AudioEncoderBufferCapiUnitTest::JoinThread()
463 {
464 SleepTest();
465 isRunning_.store(false);
466
467 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
468 {
469 unique_lock<mutex> lock(signal_->inMutex_);
470 signal_->inCond_.notify_all();
471 }
472 inputLoop_->join();
473 inputLoop_ = nullptr;
474 while (!signal_->inQueue_.empty()) {
475 signal_->inQueue_.pop();
476 }
477 while (!signal_->inBufferQueue_.empty()) {
478 signal_->inBufferQueue_.pop();
479 }
480 }
481
482 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
483 {
484 unique_lock<mutex> lock(signal_->outMutex_);
485 signal_->outCond_.notify_all();
486 }
487 outputLoop_->join();
488 outputLoop_ = nullptr;
489 while (!signal_->outQueue_.empty()) {
490 signal_->outQueue_.pop();
491 }
492 while (!signal_->outBufferQueue_.empty()) {
493 signal_->outBufferQueue_.pop();
494 }
495 }
496 }
497
Stop()498 int32_t AudioEncoderBufferCapiUnitTest::Stop()
499 {
500 isRunning_.store(false);
501
502 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
503 {
504 unique_lock<mutex> lock(signal_->inMutex_);
505 signal_->inCond_.notify_all();
506 }
507 inputLoop_->join();
508 inputLoop_ = nullptr;
509 while (!signal_->inQueue_.empty()) {
510 signal_->inQueue_.pop();
511 }
512 while (!signal_->inBufferQueue_.empty()) {
513 signal_->inBufferQueue_.pop();
514 }
515 }
516
517 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
518 {
519 unique_lock<mutex> lock(signal_->outMutex_);
520 signal_->outCond_.notify_all();
521 }
522 outputLoop_->join();
523 outputLoop_ = nullptr;
524 while (!signal_->outQueue_.empty()) {
525 signal_->outQueue_.pop();
526 }
527 while (!signal_->outBufferQueue_.empty()) {
528 signal_->outBufferQueue_.pop();
529 }
530 }
531
532 return OH_AudioCodec_Stop(audioEnc_);
533 }
534
CheckSoFunc()535 int32_t AudioEncoderBufferCapiUnitTest::CheckSoFunc()
536 {
537 soFile_ = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
538 if (!soFile_->is_open()) {
539 cout << "Fatal: Open so file failed" << endl;
540 return false;
541 }
542 soFile_->close();
543 return true;
544 }
545
546 HWTEST_F(AudioEncoderBufferCapiUnitTest, encodeTest_01, TestSize.Level1)
547 {
548 InitFile(AudioBufferFormatType::TYPE_AAC);
549 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
550 format = OH_AVFormat_Create();
551 EXPECT_NE(nullptr, format);
552 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
553 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
554 AudioSampleFormat::SAMPLE_F32LE);
555
556 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), 0);
557 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
558 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
559 Start();
560
561 {
562 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180402() 563 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
564 }
565
566 JoinThread();
567 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
568 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
569 }
570
571
572 HWTEST_F(AudioEncoderBufferCapiUnitTest, encodeTest_02, TestSize.Level1)
573 {
574 InitFile(AudioBufferFormatType::TYPE_AAC);
575 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
576 int32_t needOutputCnt = fileSize_ / AAC_DEFAULT_FRAME_BYTES;
577 needOutputCnt++; // 1 frame less than outputFrameCnt_ due to initial_padding
578 format = OH_AVFormat_Create();
579 EXPECT_NE(nullptr, format);
580 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
581 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
582 AudioSampleFormat::SAMPLE_F32LE);
583
584 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), 1);
585 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
586 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
587 Start();
588
589 {
590 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180502() 591 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
592 }
593
594 JoinThread();
595 EXPECT_EQ(outputFrameCnt_, needOutputCnt);
596 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
597 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
598 }
599
600 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckChannelCount, TestSize.Level1)
601 {
602 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
603 format = OH_AVFormat_Create();
604 EXPECT_NE(nullptr, format);
605 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_48K);
606 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
607 AudioSampleFormat::SAMPLE_S16LE);
608 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
609
610 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
611 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
612 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
613 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
614
615 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
616 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
617 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
618
619 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
620 }
621
622 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckSampleFormat, TestSize.Level1)
623 {
624 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
625 format = OH_AVFormat_Create();
626 EXPECT_NE(nullptr, format);
627 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
628 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_48K);
629 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
630 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
631
632 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
633 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
634 AudioSampleFormat::SAMPLE_U8);
635 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
636
637 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
638 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
639 AudioSampleFormat::SAMPLE_S16LE);
640 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
641
642 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
643 }
644
645 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckSampleRate, TestSize.Level1)
646 {
647 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
648 format = OH_AVFormat_Create();
649 EXPECT_NE(nullptr, format);
650 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
651 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
652 AudioSampleFormat::SAMPLE_S16LE);
653 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
654 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
655
656 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
657 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
658 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
659
660 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
661 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
662 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
663
664 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
665 }
666
667 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckBitRate, TestSize.Level1)
668 {
669 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
670 format = OH_AVFormat_Create();
671 EXPECT_NE(nullptr, format);
672 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
673 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
674 AudioSampleFormat::SAMPLE_S16LE);
675 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
676
677 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing bit rate
678
679 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
680 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), ABNORMAL_BITS_RATE);
681 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal bit rate
682
683 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
684 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE); // normal bit rate
685
686 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
687 }
688
689 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_mp3_Start, TestSize.Level1) {
690 frameBytes_ = MP3_DEFAULT_FRAME_BYTES;
691 format = OH_AVFormat_Create();
692 EXPECT_NE(nullptr, format);
693 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
694 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
695 AudioSampleFormat::SAMPLE_S16LE);
696 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
697 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
698 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(AudioBufferFormatType::TYPE_MP3));
699 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(AudioBufferFormatType::TYPE_MP3));
700 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
701 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
702 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
703 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
704 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
705 {
706 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180602() 707 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
708 }
709 OH_AVFormat_Destroy(format);
710 Release();
711 }
712
713 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_mp3, TestSize.Level1)
714 {
715 frameBytes_ = MP3_DEFAULT_FRAME_BYTES;
716 InitFile(AudioBufferFormatType::TYPE_MP3);
717 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
718 format = OH_AVFormat_Create();
719 EXPECT_NE(nullptr, format);
720 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
721 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
722 AudioSampleFormat::SAMPLE_S16LE);
723 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
724 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
725 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
726 OH_AVFormat_Destroy(format);
727 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
728 {
729 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180702() 730 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
731 }
732
733 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
734 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
735 }
736
737 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_CreateByName_01, TestSize.Level1)
738 {
739 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data());
740 EXPECT_NE(nullptr, audioEnc_);
741 Release();
742 }
743
744 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_CreateByMime_01, TestSize.Level1)
745 {
746 audioEnc_ = OH_AudioCodec_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC).data(), true);
747 EXPECT_NE(nullptr, audioEnc_);
748 }
749
750 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Prepare_01, TestSize.Level1)
751 {
752 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
753 format = OH_AVFormat_Create();
754 EXPECT_NE(nullptr, format);
755 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
756 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
757 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
758 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
759 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
760 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
761 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
762
763 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
764 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
765 }
766
767 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_GetOutputDescription_01, TestSize.Level1)
768 {
769 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
770 format = OH_AVFormat_Create();
771 EXPECT_NE(nullptr, format);
772 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
773 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
774 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
775 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
776 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
777 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
778 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
779
780 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
781 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioEnc_));
782 }
783
784 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_IsValid_01, TestSize.Level1)
785 {
786 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
787 format = OH_AVFormat_Create();
788 EXPECT_NE(nullptr, format);
789 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
790 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
791 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
792 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
793 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
794 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
795 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
796
797 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
798 bool value = true;
799 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioEnc_, &value));
800 }
801
802 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_SetParameter_01, TestSize.Level1)
803 {
804 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
805 format = OH_AVFormat_Create();
806 EXPECT_NE(nullptr, format);
807 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
808 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
809 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
810 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
811 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
812 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
813 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
814
815 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
816
817 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
818
819 {
820 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180802() 821 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
822 }
823
824 JoinThread();
825
826 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
827 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioEnc_, format));
828 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
829 }
830
831
832 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_01, TestSize.Level1)
833 {
834 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
835 format = OH_AVFormat_Create();
836 EXPECT_NE(nullptr, format);
837 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
838 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
839 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
840 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
841 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
842 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
843 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
844
845 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
846 }
847
848 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_02, TestSize.Level1)
849 {
850 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
851 format = OH_AVFormat_Create();
852 EXPECT_NE(nullptr, format);
853 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
854 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
855 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
856 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
857 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
858 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), ABNORMAL_CHANNEL_LAYOUT);
859 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
860
861 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
862 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
863
864 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(),
865 ABNORMAL_CHANNEL_LAYOUT_UNKNOWN);
866
867 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
868 }
869
870 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_04, TestSize.Level1)
871 {
872 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
873 format = OH_AVFormat_Create();
874 EXPECT_NE(nullptr, format);
875 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_CHANNEL_COUNT);
876 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
877 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
878 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
879 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
880 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
881 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
882
883 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
884 }
885
886 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_05, TestSize.Level1)
887 {
888 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
889 format = OH_AVFormat_Create();
890 EXPECT_NE(nullptr, format);
891 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
892 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
893 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), ABNORMAL_BITS_RATE);
894 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
895 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
896 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
897 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
898
899 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
900 }
901
902 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_06, TestSize.Level1)
903 {
904 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
905 format = OH_AVFormat_Create();
906 EXPECT_NE(nullptr, format);
907 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
908 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
909 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE); // SetIntValue
910 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
911 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
912 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
913 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
914
915 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
916 }
917
918 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_07, TestSize.Level1)
919 {
920 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
921 format = OH_AVFormat_Create();
922 EXPECT_NE(nullptr, format);
923 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
924 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
925 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
926 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
927 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
928 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
929 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), ABNORMAL_COMPLIANCE_LEVEL_L);
930
931 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
932 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
933
934 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), ABNORMAL_COMPLIANCE_LEVEL_R);
935 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
936 }
937
938 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_08, TestSize.Level1)
939 {
940 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
941 format = OH_AVFormat_Create();
942 EXPECT_NE(nullptr, format);
943 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
944 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ABNORMAL_SAMPLE_RATE);
945 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
946 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
947 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
948 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
949 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
950
951 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
952 }
953
954 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_09, TestSize.Level1)
955 {
956 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
957 format = OH_AVFormat_Create();
958 EXPECT_NE(nullptr, format);
959 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
960 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ABNORMAL_SAMPLE_RATE);
961 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
962 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
963 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), ABNORMAL_SAMPLE_FORMAT);
964 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
965 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
966
967 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
968 }
969
970 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_01, TestSize.Level1)
971 {
972 InitFile(AudioBufferFormatType::TYPE_FLAC);
973 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
974 format = OH_AVFormat_Create();
975 EXPECT_NE(nullptr, format);
976 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
977 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
978 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
979 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
980 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
981 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
982 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
983
984 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
985 OH_AVFormat_Destroy(format);
986 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
987
988 {
989 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180902() 990 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
991 }
992
993 JoinThread();
994 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
995 }
996
997 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_02, TestSize.Level1)
998 {
999 InitFile(AudioBufferFormatType::TYPE_FLAC);
1000 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1001 format = OH_AVFormat_Create();
1002 EXPECT_NE(nullptr, format);
1003 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1004 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1005 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1006 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1007 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1008 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1009 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1010
1011 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1012 OH_AVFormat_Destroy(format);
1013 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1014
1015 {
1016 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180a02() 1017 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1018 }
1019
1020 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1021 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1022 }
1023
1024 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_03, TestSize.Level1)
1025 {
1026 InitFile(AudioBufferFormatType::TYPE_FLAC);
1027 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1028 format = OH_AVFormat_Create();
1029 EXPECT_NE(nullptr, format);
1030 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1031 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1032 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1033 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1034 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1035 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1036 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1037
1038 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1039 OH_AVFormat_Destroy(format);
1040 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1041
1042 {
1043 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180b02() 1044 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1045 }
1046
1047 JoinThread();
1048 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1049 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1050 }
1051
1052 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_04, TestSize.Level1)
1053 {
1054 InitFile(AudioBufferFormatType::TYPE_FLAC);
1055 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1056 format = OH_AVFormat_Create();
1057 EXPECT_NE(nullptr, format);
1058 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1059 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1060 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1061 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1062 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1063 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1064 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1065
1066 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1067 OH_AVFormat_Destroy(format);
1068 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1069
1070 {
1071 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180c02() 1072 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1073 }
1074
1075 JoinThread();
1076 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1077 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1078 }
1079
1080 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_05, TestSize.Level1)
1081 {
1082 InitFile(AudioBufferFormatType::TYPE_FLAC);
1083 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1084 format = OH_AVFormat_Create();
1085 EXPECT_NE(nullptr, format);
1086 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1087 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1088 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1089 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1090 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1091 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1092 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1093
1094 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1095 OH_AVFormat_Destroy(format);
1096 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1097
1098 {
1099 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180d02() 1100 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1101 }
1102
1103 JoinThread();
1104 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1105 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1106 }
1107
1108 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacNormalCase, TestSize.Level1)
1109 {
1110 InitFile(AudioBufferFormatType::TYPE_AAC);
1111 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1112 format = OH_AVFormat_Create();
1113 EXPECT_NE(nullptr, format);
1114 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1115 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1116 AudioSampleFormat::SAMPLE_F32LE);
1117
1118 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1119 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1120 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1121
1122 {
1123 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180e02() 1124 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1125 }
1126
1127 JoinThread();
1128 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1129 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1130 }
1131
1132 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckChannelCount, TestSize.Level1)
1133 {
1134 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1135 format = OH_AVFormat_Create();
1136 EXPECT_NE(nullptr, format);
1137 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1138 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1139 AudioSampleFormat::SAMPLE_F32LE);
1140 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1141
1142 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1143 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1144 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1145
1146 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1147 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), AAC_ILLEGAL_CHANNEL_COUNT);
1148 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // aac illegal channel count
1149
1150 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1151 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1152 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1153
1154 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1155 }
1156
1157 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckSampleFormat, TestSize.Level1)
1158 {
1159 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1160 format = OH_AVFormat_Create();
1161 EXPECT_NE(nullptr, format);
1162 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1163 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1164
1165 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1166 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1167
1168 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1169 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1170 AudioSampleFormat::SAMPLE_U8);
1171 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1172
1173 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1174 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1175 AudioSampleFormat::SAMPLE_F32LE);
1176 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1177
1178 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1179 }
1180
1181 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckbitRate, TestSize.Level1)
1182 {
1183 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1184 format = OH_AVFormat_Create();
1185 EXPECT_NE(nullptr, format);
1186 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1187 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1188 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), 500001); // wrong bit rate
1189 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1190 AudioSampleFormat::SAMPLE_F32LE);
1191 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1192
1193 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1194 }
1195
1196 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckSampleRate, TestSize.Level1)
1197 {
1198 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1199 format = OH_AVFormat_Create();
1200 EXPECT_NE(nullptr, format);
1201 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1202 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1203 AudioSampleFormat::SAMPLE_F32LE);
1204 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1205
1206 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1207 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1208 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1209
1210 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1211 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1212 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1213
1214 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1215 }
1216
1217 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckChannelLayout, TestSize.Level1)
1218 {
1219 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1220 format = OH_AVFormat_Create();
1221 EXPECT_NE(nullptr, format);
1222 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1223 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1224 AudioSampleFormat::SAMPLE_F32LE);
1225 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1226 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_7POINT1);
1227 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1228
1229 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1230 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1231 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel layout
1232
1233 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1234 }
1235
1236 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckMaxinputSize, TestSize.Level1)
1237 {
1238 frameBytes_ = AAC_DEFAULT_FRAME_BYTES;
1239 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1240 format = OH_AVFormat_Create();
1241 EXPECT_NE(nullptr, format);
1242 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1243 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1244 AudioSampleFormat::SAMPLE_F32LE);
1245 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1246 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), MAX_INPUT_SIZE);
1247 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1248 OH_AVFormat_Destroy(format);
1249
1250 auto fmt = OH_AudioCodec_GetOutputDescription(audioEnc_);
1251 EXPECT_NE(fmt, nullptr);
1252 OH_AVFormat_Destroy(fmt);
1253
1254 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
1255
1256 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1257 }
1258
1259 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckChannelCount, TestSize.Level1)
1260 {
1261 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1262 format = OH_AVFormat_Create();
1263 EXPECT_NE(nullptr, format);
1264 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1265 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1266 AudioSampleFormat::SAMPLE_S16LE);
1267 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1268
1269 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1270 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1271 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1272
1273 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1274 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1275 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1276
1277 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1278 }
1279
1280 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckSampleFormat, TestSize.Level1)
1281 {
1282 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1283 format = OH_AVFormat_Create();
1284 EXPECT_NE(nullptr, format);
1285 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1286 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1287 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1288
1289 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1290 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1291 AudioSampleFormat::SAMPLE_U8);
1292 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1293
1294 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1295 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1296 AudioSampleFormat::SAMPLE_S16LE);
1297 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1298
1299 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1300 }
1301
1302 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckSampleRate, TestSize.Level1)
1303 {
1304 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1305 format = OH_AVFormat_Create();
1306 EXPECT_NE(nullptr, format);
1307 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1308 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1309 AudioSampleFormat::SAMPLE_S16LE);
1310 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1311
1312 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1313 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1314 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1315
1316 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1317 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1318 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1319
1320 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1321 }
1322
1323 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_G711mu_Start, TestSize.Level1) {
1324 frameBytes_ = G711MU_DEFAULT_FRAME_BYTES;
1325 format = OH_AVFormat_Create();
1326 EXPECT_NE(nullptr, format);
1327 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1328 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1329 AudioSampleFormat::SAMPLE_S16LE);
1330 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1331
1332 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(AudioBufferFormatType::TYPE_G711MU));
1333 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU));
1334 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1335 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
1336 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1337 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1338 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
1339 {
1340 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a180f02() 1341 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1342 }
1343 OH_AVFormat_Destroy(format);
1344 Release();
1345 }
1346
1347 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckChannelCount, TestSize.Level1)
1348 {
1349 if (!CheckSoFunc()) {
1350 return;
1351 }
1352 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1353 format = OH_AVFormat_Create();
1354 EXPECT_NE(nullptr, format);
1355 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1356 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1357 AudioSampleFormat::SAMPLE_S16LE);
1358 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1359 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1360
1361 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1362 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1363 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1364
1365 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1366 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1367 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1368
1369 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1370 }
1371
1372 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckSampleFormat, TestSize.Level1)
1373 {
1374 if (!CheckSoFunc()) {
1375 return;
1376 }
1377 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1378 format = OH_AVFormat_Create();
1379 EXPECT_NE(nullptr, format);
1380 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1381 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1382 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1383 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1384
1385 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1386 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1387 AudioSampleFormat::SAMPLE_U8);
1388 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1389
1390 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1391 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1392 AudioSampleFormat::SAMPLE_S16LE);
1393 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1394
1395 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1396 }
1397
1398 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckSampleRate, TestSize.Level1)
1399 {
1400 if (!CheckSoFunc()) {
1401 return;
1402 }
1403 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1404 format = OH_AVFormat_Create();
1405 EXPECT_NE(nullptr, format);
1406 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1407 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1408 AudioSampleFormat::SAMPLE_S16LE);
1409 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1410 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1411
1412 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1413 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1414 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1415
1416 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1417 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1418 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1419
1420 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1421 }
1422
1423 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckChannelLayout, TestSize.Level1)
1424 {
1425 if (!CheckSoFunc()) {
1426 return;
1427 }
1428 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1429 format = OH_AVFormat_Create();
1430 EXPECT_NE(nullptr, format);
1431 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1432 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1433 AudioSampleFormat::SAMPLE_S16LE);
1434 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1435 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1436 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1437 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1438 }
1439
1440 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusGetOutputDescription_01, TestSize.Level1)
1441 {
1442 if (!CheckSoFunc()) {
1443 return;
1444 }
1445 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1446 format = OH_AVFormat_Create();
1447 EXPECT_NE(nullptr, format);
1448 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1449 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1450 AudioSampleFormat::SAMPLE_S16LE);
1451 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1452 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1453 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1454
1455 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioEnc_));
1456 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1457 }
1458
1459 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_g711mu, TestSize.Level1)
1460 {
1461 frameBytes_ = G711MU_DEFAULT_FRAME_BYTES;
1462 InitFile(AudioBufferFormatType::TYPE_G711MU);
1463 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1464 format = OH_AVFormat_Create();
1465 EXPECT_NE(nullptr, format);
1466 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1467 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1468 AudioSampleFormat::SAMPLE_S16LE);
1469 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1470 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1471 OH_AVFormat_Destroy(format);
1472 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1473 {
1474 unique_lock<mutex> lock(signal_->startMutex_);
__anonc48d1a181002() 1475 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1476 }
1477
1478 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1479 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1480 }
1481
1482 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_outer_support_mime_check, TestSize.Level1)
1483 {
1484 const vector<std::string_view> allMimeTable = {
1485 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
1486 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
1487 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
1488 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
1489 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711A,
1490 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_RAW,
1491 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS,
1492 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
1493 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID,
1494 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
1495 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
1496 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE,
1497 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
1498 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC,
1499 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_COOK,
1500 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AC3,
1501 };
1502
1503 const bool isEncoder = true;
1504 for (const auto &mime : allMimeTable) {
1505 auto capability = OH_AVCodec_GetCapability(mime.data(), isEncoder);
1506 const char *name = OH_AVCapability_GetName(capability);
1507 if (name == nullptr) {
1508 cout << "without capaility:" << mime << endl;
1509 continue;
1510 }
1511 auto audioEnc = OH_AudioCodec_CreateByMime(mime.data(), isEncoder);
1512 if (AVCodecMimeType::CheckAudioCodecMimeSupportOuter(mime.data(), isEncoder)) {
1513 EXPECT_NE(nullptr, audioEnc);
1514 if (audioEnc == nullptr) {
1515 cout << "create " << mime << " failed" << endl;
1516 }
1517 } else {
1518 EXPECT_EQ(nullptr, audioEnc);
1519 if (audioEnc != nullptr) {
1520 cout << "limit " << mime << " failed" << endl;
1521 }
1522 }
1523
1524 if (audioEnc != nullptr) {
1525 OH_AudioCodec_Destroy(audioEnc);
1526 }
1527 }
1528 }
1529
1530 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_outer_support_codec_name_check, TestSize.Level1)
1531 {
1532 const vector<std::string_view> allMimeTable = {
1533 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC,
1534 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC,
1535 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_OPUS,
1536 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711MU,
1537 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_G711A,
1538 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_RAW,
1539 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VORBIS,
1540 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_MPEG,
1541 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID,
1542 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRNB,
1543 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AMRWB,
1544 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_APE,
1545 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_L2HC,
1546 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_LBVC,
1547 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_COOK,
1548 AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AC3,
1549 };
1550
1551 const bool isEncoder = true;
1552 for (const auto &mime : allMimeTable) {
1553 auto capability = OH_AVCodec_GetCapability(mime.data(), isEncoder);
1554 const char *name = OH_AVCapability_GetName(capability);
1555 auto audioEnc = OH_AudioCodec_CreateByName(name);
1556 if (AVCodecCodecName::CheckAudioCodecNameSupportOuter(name)) {
1557 EXPECT_NE(nullptr, audioEnc);
1558 if (audioEnc == nullptr) {
1559 cout << "create " << name << " failed" << endl;
1560 }
1561 } else {
1562 EXPECT_EQ(nullptr, audioEnc);
1563 if (audioEnc != nullptr) {
1564 cout << "limit " << name << " failed" << endl;
1565 }
1566 }
1567
1568 if (audioEnc != nullptr) {
1569 OH_AudioCodec_Destroy(audioEnc);
1570 }
1571 }
1572 }
1573 }
1574 }