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
43 using namespace std;
44 using namespace testing::ext;
45 using namespace OHOS::MediaAVCodec;
46
47 namespace {
48 constexpr uint32_t CHANNEL_COUNT = 2;
49 constexpr uint32_t ABNORMAL_CHANNEL_COUNT = 10;
50 constexpr uint32_t SAMPLE_RATE = 44100;
51 constexpr uint32_t OPUS_SAMPLE_RATE = 48000;
52 constexpr uint32_t CHANNEL_1CHAN_COUNT = 1;
53 constexpr uint32_t SAMPLE_RATE_8K = 8000;
54 constexpr uint32_t SAMPLE_RATE_48K = 48000;
55 constexpr uint32_t ABNORMAL_SAMPLE_RATE = 9999999;
56 constexpr uint32_t BITS_RATE = 261000;
57 constexpr int32_t MP3_BIT_RATE = 128000;
58 constexpr int32_t ABNORMAL_BITS_RATE = -1;
59 constexpr int32_t BITS_PER_CODED_SAMPLE = AudioSampleFormat::SAMPLE_S16LE;
60 constexpr int32_t ABNORMAL_BITS_SAMPLE = AudioSampleFormat::INVALID_WIDTH;
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 outputFrameCnt_++;
332 }
333 if (avBuffer != nullptr &&
334 (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS || avBuffer->buffer_->memory_->GetSize()== 0)) {
335 cout << "encode eos" << endl;
336 isRunning_.store(false);
337 signal_->startCond_.notify_all();
338 }
339 signal_->outBufferQueue_.pop();
340 signal_->outQueue_.pop();
341 if (OH_AudioCodec_FreeOutputBuffer(audioEnc_, index) != AV_ERR_OK) {
342 cout << "Fatal: FreeOutputData fail" << endl;
343 break;
344 }
345 if (avBuffer->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
346 cout << "decode eos" << endl;
347 isRunning_.store(false);
348 signal_->startCond_.notify_all();
349 }
350 }
351 cout << "stop, exit" << endl;
352 outputFile_->close();
353 }
354
GetFileSize(const std::string & filePath)355 int32_t AudioEncoderBufferCapiUnitTest::GetFileSize(const std::string &filePath)
356 {
357 std::ifstream file(filePath, std::ios::binary | std::ios::ate);
358 if (!file) {
359 std::cerr << "Failed to open file: " << filePath << std::endl;
360 return -1;
361 }
362
363 std::streampos fileSize = file.tellg(); // 获取文件大小
364 file.close();
365
366 return (int32_t)fileSize;
367 }
368
InitFile(AudioBufferFormatType audioType)369 int32_t AudioEncoderBufferCapiUnitTest::InitFile(AudioBufferFormatType audioType)
370 {
371 if (audioType == AudioBufferFormatType::TYPE_FLAC) {
372 fileSize_ = GetFileSize(FLAC_INPUT_FILE_PATH.data());
373 inputFile_ = std::make_unique<std::ifstream>(FLAC_INPUT_FILE_PATH, std::ios::binary);
374 outputFile_ = std::make_unique<std::ofstream>(FLAC_OUTPUT_FILE_PATH, std::ios::binary);
375 } else if (audioType == AudioBufferFormatType::TYPE_AAC) {
376 fileSize_ = GetFileSize(AAC_INPUT_FILE_PATH.data());
377 inputFile_ = std::make_unique<std::ifstream>(AAC_INPUT_FILE_PATH, std::ios::binary);
378 outputFile_ = std::make_unique<std::ofstream>(AAC_OUTPUT_FILE_PATH, std::ios::binary);
379 } else if (audioType == AudioBufferFormatType::TYPE_G711MU) {
380 fileSize_ = GetFileSize(G711MU_INPUT_FILE_PATH.data());
381 inputFile_ = std::make_unique<std::ifstream>(G711MU_INPUT_FILE_PATH, std::ios::binary);
382 outputFile_ = std::make_unique<std::ofstream>(G711MU_OUTPUT_FILE_PATH, std::ios::binary);
383 } else if (audioType == AudioBufferFormatType::TYPE_OPUS) {
384 fileSize_ = GetFileSize(AAC_INPUT_FILE_PATH.data());
385 inputFile_ = std::make_unique<std::ifstream>(OPUS_INPUT_FILE_PATH, std::ios::binary);
386 outputFile_ = std::make_unique<std::ofstream>(OPUS_OUTPUT_FILE_PATH, std::ios::binary);
387 } else if (audioType == AudioBufferFormatType::TYPE_MP3) {
388 fileSize_ = GetFileSize(MP3_INPUT_FILE_PATH.data());
389 inputFile_ = std::make_unique<std::ifstream>(MP3_INPUT_FILE_PATH, std::ios::binary);
390 outputFile_ = std::make_unique<std::ofstream>(MP3_OUTPUT_FILE_PATH, std::ios::binary);
391 } else {
392 cout << "audio name not support" << endl;
393 return OH_AVErrCode::AV_ERR_UNKNOWN;
394 }
395 if (!inputFile_->is_open()) {
396 cout << "Fatal: open input file failed" << endl;
397 return OH_AVErrCode::AV_ERR_UNKNOWN;
398 }
399 if (!outputFile_->is_open()) {
400 cout << "Fatal: open output file failed" << endl;
401 return OH_AVErrCode::AV_ERR_UNKNOWN;
402 }
403 return OH_AVErrCode::AV_ERR_OK;
404 }
405
CreateCodecFunc(AudioBufferFormatType audioType)406 int32_t AudioEncoderBufferCapiUnitTest::CreateCodecFunc(AudioBufferFormatType audioType)
407 {
408 if (audioType == AudioBufferFormatType::TYPE_FLAC) {
409 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME).data());
410 } else if (audioType == AudioBufferFormatType::TYPE_AAC) {
411 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data());
412 } else if (audioType == AudioBufferFormatType::TYPE_G711MU) {
413 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_G711MU_NAME).data());
414 } else if (audioType == AudioBufferFormatType::TYPE_OPUS) {
415 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME).data());
416 } else if (audioType == AudioBufferFormatType::TYPE_MP3) {
417 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_MP3_NAME).data());
418 } else {
419 cout << "audio name not support" << endl;
420 return OH_AVErrCode::AV_ERR_UNKNOWN;
421 }
422
423 if (audioEnc_ == nullptr) {
424 cout << "Fatal: CreateByName fail" << endl;
425 return OH_AVErrCode::AV_ERR_UNKNOWN;
426 }
427
428 signal_ = new AudioCodecBufferSignal();
429 if (signal_ == nullptr) {
430 cout << "Fatal: create signal fail" << endl;
431 return OH_AVErrCode::AV_ERR_UNKNOWN;
432 }
433 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
434 int32_t ret = OH_AudioCodec_RegisterCallback(audioEnc_, cb_, signal_);
435 if (ret != OH_AVErrCode::AV_ERR_OK) {
436 cout << "Fatal: SetCallback fail" << endl;
437 return OH_AVErrCode::AV_ERR_UNKNOWN;
438 }
439
440 return OH_AVErrCode::AV_ERR_OK;
441 }
442
Start()443 int32_t AudioEncoderBufferCapiUnitTest::Start()
444 {
445 isRunning_.store(true);
446 inputLoop_ = make_unique<thread>(&AudioEncoderBufferCapiUnitTest::InputFunc, this);
447 if (inputLoop_ == nullptr) {
448 cout << "Fatal: No memory" << endl;
449 return OH_AVErrCode::AV_ERR_UNKNOWN;
450 }
451
452 outputLoop_ = make_unique<thread>(&AudioEncoderBufferCapiUnitTest::OutputFunc, this);
453 if (outputLoop_ == nullptr) {
454 cout << "Fatal: No memory" << endl;
455 return OH_AVErrCode::AV_ERR_UNKNOWN;
456 }
457
458 return OH_AudioCodec_Start(audioEnc_);
459 }
460
JoinThread()461 void AudioEncoderBufferCapiUnitTest::JoinThread()
462 {
463 SleepTest();
464 isRunning_.store(false);
465
466 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
467 {
468 unique_lock<mutex> lock(signal_->inMutex_);
469 signal_->inCond_.notify_all();
470 }
471 inputLoop_->join();
472 inputLoop_ = nullptr;
473 while (!signal_->inQueue_.empty()) {
474 signal_->inQueue_.pop();
475 }
476 while (!signal_->inBufferQueue_.empty()) {
477 signal_->inBufferQueue_.pop();
478 }
479 }
480
481 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
482 {
483 unique_lock<mutex> lock(signal_->outMutex_);
484 signal_->outCond_.notify_all();
485 }
486 outputLoop_->join();
487 outputLoop_ = nullptr;
488 while (!signal_->outQueue_.empty()) {
489 signal_->outQueue_.pop();
490 }
491 while (!signal_->outBufferQueue_.empty()) {
492 signal_->outBufferQueue_.pop();
493 }
494 }
495 }
496
Stop()497 int32_t AudioEncoderBufferCapiUnitTest::Stop()
498 {
499 isRunning_.store(false);
500
501 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
502 {
503 unique_lock<mutex> lock(signal_->inMutex_);
504 signal_->inCond_.notify_all();
505 }
506 inputLoop_->join();
507 inputLoop_ = nullptr;
508 while (!signal_->inQueue_.empty()) {
509 signal_->inQueue_.pop();
510 }
511 while (!signal_->inBufferQueue_.empty()) {
512 signal_->inBufferQueue_.pop();
513 }
514 }
515
516 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
517 {
518 unique_lock<mutex> lock(signal_->outMutex_);
519 signal_->outCond_.notify_all();
520 }
521 outputLoop_->join();
522 outputLoop_ = nullptr;
523 while (!signal_->outQueue_.empty()) {
524 signal_->outQueue_.pop();
525 }
526 while (!signal_->outBufferQueue_.empty()) {
527 signal_->outBufferQueue_.pop();
528 }
529 }
530
531 return OH_AudioCodec_Stop(audioEnc_);
532 }
533
CheckSoFunc()534 int32_t AudioEncoderBufferCapiUnitTest::CheckSoFunc()
535 {
536 soFile_ = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
537 if (!soFile_->is_open()) {
538 cout << "Fatal: Open so file failed" << endl;
539 return false;
540 }
541 soFile_->close();
542 return true;
543 }
544
545 HWTEST_F(AudioEncoderBufferCapiUnitTest, encodeTest_01, TestSize.Level1)
546 {
547 InitFile(AudioBufferFormatType::TYPE_AAC);
548 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
549 format = OH_AVFormat_Create();
550 EXPECT_NE(nullptr, format);
551 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
552 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
553 AudioSampleFormat::SAMPLE_F32LE);
554
555 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), 0);
556 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
557 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
558 Start();
559
560 {
561 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60402() 562 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
563 }
564
565 JoinThread();
566 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
567 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
568 }
569
570
571 HWTEST_F(AudioEncoderBufferCapiUnitTest, encodeTest_02, TestSize.Level1)
572 {
573 InitFile(AudioBufferFormatType::TYPE_AAC);
574 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
575 int32_t needOutputCnt = fileSize_ / AAC_DEFAULT_FRAME_BYTES;
576 format = OH_AVFormat_Create();
577 EXPECT_NE(nullptr, format);
578 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
579 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
580 AudioSampleFormat::SAMPLE_F32LE);
581
582 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), 1);
583 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
584 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
585 Start();
586
587 {
588 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60502() 589 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
590 }
591
592 JoinThread();
593 EXPECT_EQ(outputFrameCnt_, needOutputCnt);
594 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
595 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
596 }
597
598 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckChannelCount, TestSize.Level1)
599 {
600 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
601 format = OH_AVFormat_Create();
602 EXPECT_NE(nullptr, format);
603 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_48K);
604 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
605 AudioSampleFormat::SAMPLE_S16LE);
606 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
607
608 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
609 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
610 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
611 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
612
613 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
614 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
615 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
616
617 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
618 }
619
620 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckSampleFormat, TestSize.Level1)
621 {
622 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
623 format = OH_AVFormat_Create();
624 EXPECT_NE(nullptr, format);
625 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
626 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_48K);
627 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
628 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
629
630 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
631 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
632 AudioSampleFormat::SAMPLE_U8);
633 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
634
635 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
636 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
637 AudioSampleFormat::SAMPLE_S16LE);
638 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
639
640 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
641 }
642
643 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckSampleRate, TestSize.Level1)
644 {
645 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
646 format = OH_AVFormat_Create();
647 EXPECT_NE(nullptr, format);
648 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
649 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
650 AudioSampleFormat::SAMPLE_S16LE);
651 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
652 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
653
654 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
655 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
656 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
657
658 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
659 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
660 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
661
662 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
663 }
664
665 HWTEST_F(AudioEncoderBufferCapiUnitTest, mp3CheckBitRate, TestSize.Level1)
666 {
667 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
668 format = OH_AVFormat_Create();
669 EXPECT_NE(nullptr, format);
670 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
671 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
672 AudioSampleFormat::SAMPLE_S16LE);
673 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
674
675 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing bit rate
676
677 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
678 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), ABNORMAL_BITS_RATE);
679 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal bit rate
680
681 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
682 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE); // normal bit rate
683
684 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
685 }
686
687 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_mp3_Start, TestSize.Level1) {
688 frameBytes_ = MP3_DEFAULT_FRAME_BYTES;
689 format = OH_AVFormat_Create();
690 EXPECT_NE(nullptr, format);
691 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
692 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
693 AudioSampleFormat::SAMPLE_S16LE);
694 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
695 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
696 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(AudioBufferFormatType::TYPE_MP3));
697 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(AudioBufferFormatType::TYPE_MP3));
698 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
699 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
700 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
701 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
702 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
703 {
704 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60602() 705 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
706 }
707 OH_AVFormat_Destroy(format);
708 Release();
709 }
710
711 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_mp3, TestSize.Level1)
712 {
713 frameBytes_ = MP3_DEFAULT_FRAME_BYTES;
714 InitFile(AudioBufferFormatType::TYPE_MP3);
715 CreateCodecFunc(AudioBufferFormatType::TYPE_MP3);
716 format = OH_AVFormat_Create();
717 EXPECT_NE(nullptr, format);
718 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
719 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
720 AudioSampleFormat::SAMPLE_S16LE);
721 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
722 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), MP3_BIT_RATE);
723 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
724 OH_AVFormat_Destroy(format);
725 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
726 {
727 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60702() 728 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
729 }
730
731 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
732 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
733 }
734
735 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_CreateByName_01, TestSize.Level1)
736 {
737 audioEnc_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_ENCODER_AAC_NAME).data());
738 EXPECT_NE(nullptr, audioEnc_);
739 Release();
740 }
741
742 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_CreateByMime_01, TestSize.Level1)
743 {
744 audioEnc_ = OH_AudioCodec_CreateByMime((AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_FLAC).data(), true);
745 EXPECT_NE(nullptr, audioEnc_);
746 }
747
748 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Prepare_01, TestSize.Level1)
749 {
750 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
751 format = OH_AVFormat_Create();
752 EXPECT_NE(nullptr, format);
753 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
754 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
755 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
756 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
757 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
758 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
759 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
760
761 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
762 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
763 }
764
765 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_GetOutputDescription_01, TestSize.Level1)
766 {
767 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
768 format = OH_AVFormat_Create();
769 EXPECT_NE(nullptr, format);
770 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
771 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
772 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
773 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
774 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
775 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
776 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
777
778 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
779 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioEnc_));
780 }
781
782 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_IsValid_01, TestSize.Level1)
783 {
784 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
785 format = OH_AVFormat_Create();
786 EXPECT_NE(nullptr, format);
787 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
788 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
789 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
790 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
791 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
792 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
793 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
794
795 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
796 bool value = true;
797 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioEnc_, &value));
798 }
799
800 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_SetParameter_01, TestSize.Level1)
801 {
802 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
803 format = OH_AVFormat_Create();
804 EXPECT_NE(nullptr, format);
805 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
806 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
807 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
808 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
809 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
810 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
811 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
812
813 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
814
815 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
816
817 {
818 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60802() 819 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
820 }
821
822 JoinThread();
823
824 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
825 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioEnc_, format));
826 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
827 }
828
829
830 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_01, TestSize.Level1)
831 {
832 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
833 format = OH_AVFormat_Create();
834 EXPECT_NE(nullptr, format);
835 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
836 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
837 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
838 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
839 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
840 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
841 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
842
843 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
844 }
845
846 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_02, TestSize.Level1)
847 {
848 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
849 format = OH_AVFormat_Create();
850 EXPECT_NE(nullptr, format);
851 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
852 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
853 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
854 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
855 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
856 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), ABNORMAL_CHANNEL_LAYOUT);
857 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
858
859 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
860 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
861
862 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(),
863 ABNORMAL_CHANNEL_LAYOUT_UNKNOWN);
864
865 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
866 }
867
868 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_03, TestSize.Level1)
869 {
870 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
871 format = OH_AVFormat_Create();
872 EXPECT_NE(nullptr, format);
873 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
874 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
875 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
876 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), ABNORMAL_BITS_SAMPLE);
877 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
878 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
879 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
880
881 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
882 }
883
884 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_04, TestSize.Level1)
885 {
886 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
887 format = OH_AVFormat_Create();
888 EXPECT_NE(nullptr, format);
889 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ABNORMAL_CHANNEL_COUNT);
890 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
891 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
892 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
893 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
894 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
895 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
896
897 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
898 }
899
900 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_05, TestSize.Level1)
901 {
902 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
903 format = OH_AVFormat_Create();
904 EXPECT_NE(nullptr, format);
905 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
906 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
907 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), ABNORMAL_BITS_RATE);
908 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
909 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
910 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
911 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
912
913 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
914 }
915
916 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_06, TestSize.Level1)
917 {
918 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
919 format = OH_AVFormat_Create();
920 EXPECT_NE(nullptr, format);
921 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
922 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
923 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE); // SetIntValue
924 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
925 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
926 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
927 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
928
929 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
930 }
931
932 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_07, TestSize.Level1)
933 {
934 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
935 format = OH_AVFormat_Create();
936 EXPECT_NE(nullptr, format);
937 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
938 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
939 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
940 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
941 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
942 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
943 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), ABNORMAL_COMPLIANCE_LEVEL_L);
944
945 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
946 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
947
948 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), ABNORMAL_COMPLIANCE_LEVEL_R);
949 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
950 }
951
952 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_08, TestSize.Level1)
953 {
954 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
955 format = OH_AVFormat_Create();
956 EXPECT_NE(nullptr, format);
957 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
958 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ABNORMAL_SAMPLE_RATE);
959 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
960 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
961 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
962 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
963 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
964
965 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
966 }
967
968 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_Configure_09, TestSize.Level1)
969 {
970 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
971 format = OH_AVFormat_Create();
972 EXPECT_NE(nullptr, format);
973 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
974 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ABNORMAL_SAMPLE_RATE);
975 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
976 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
977 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), ABNORMAL_SAMPLE_FORMAT);
978 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
979 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
980
981 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
982 }
983
984 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_01, TestSize.Level1)
985 {
986 InitFile(AudioBufferFormatType::TYPE_FLAC);
987 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
988 format = OH_AVFormat_Create();
989 EXPECT_NE(nullptr, format);
990 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
991 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
992 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
993 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
994 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
995 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
996 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
997
998 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
999 OH_AVFormat_Destroy(format);
1000 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1001
1002 {
1003 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60902() 1004 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1005 }
1006
1007 JoinThread();
1008 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1009 }
1010
1011 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_02, TestSize.Level1)
1012 {
1013 InitFile(AudioBufferFormatType::TYPE_FLAC);
1014 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1015 format = OH_AVFormat_Create();
1016 EXPECT_NE(nullptr, format);
1017 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1018 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1019 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1020 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1021 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1022 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1023 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1024
1025 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1026 OH_AVFormat_Destroy(format);
1027 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1028
1029 {
1030 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60a02() 1031 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1032 }
1033
1034 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1035 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1036 }
1037
1038 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_03, TestSize.Level1)
1039 {
1040 InitFile(AudioBufferFormatType::TYPE_FLAC);
1041 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1042 format = OH_AVFormat_Create();
1043 EXPECT_NE(nullptr, format);
1044 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1045 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1046 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1047 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1048 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1049 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1050 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1051
1052 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1053 OH_AVFormat_Destroy(format);
1054 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1055
1056 {
1057 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60b02() 1058 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1059 }
1060
1061 JoinThread();
1062 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1063 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1064 }
1065
1066 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_04, TestSize.Level1)
1067 {
1068 InitFile(AudioBufferFormatType::TYPE_FLAC);
1069 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1070 format = OH_AVFormat_Create();
1071 EXPECT_NE(nullptr, format);
1072 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1073 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1074 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1075 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1076 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1077 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1078 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1079
1080 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1081 OH_AVFormat_Destroy(format);
1082 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1083
1084 {
1085 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60c02() 1086 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1087 }
1088
1089 JoinThread();
1090 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1091 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1092 }
1093
1094 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_05, TestSize.Level1)
1095 {
1096 InitFile(AudioBufferFormatType::TYPE_FLAC);
1097 CreateCodecFunc(AudioBufferFormatType::TYPE_FLAC);
1098 format = OH_AVFormat_Create();
1099 EXPECT_NE(nullptr, format);
1100 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1101 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1102 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1103 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_BITS_PER_CODED_SAMPLE.data(), BITS_PER_CODED_SAMPLE);
1104 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(), SAMPLE_FORMAT);
1105 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1106 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_COMPLIANCE_LEVEL.data(), COMPLIANCE_LEVEL);
1107
1108 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1109 OH_AVFormat_Destroy(format);
1110 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1111
1112 {
1113 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60d02() 1114 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1115 }
1116
1117 JoinThread();
1118 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1119 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1120 }
1121
1122 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacNormalCase, TestSize.Level1)
1123 {
1124 InitFile(AudioBufferFormatType::TYPE_AAC);
1125 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1126 format = OH_AVFormat_Create();
1127 EXPECT_NE(nullptr, format);
1128 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1129 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1130 AudioSampleFormat::SAMPLE_F32LE);
1131
1132 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1133 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1134 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1135
1136 {
1137 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60e02() 1138 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1139 }
1140
1141 JoinThread();
1142 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioEnc_));
1143 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1144 }
1145
1146 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckChannelCount, TestSize.Level1)
1147 {
1148 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1149 format = OH_AVFormat_Create();
1150 EXPECT_NE(nullptr, format);
1151 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1152 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1153 AudioSampleFormat::SAMPLE_F32LE);
1154 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1155
1156 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1157 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1158 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1159
1160 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1161 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), AAC_ILLEGAL_CHANNEL_COUNT);
1162 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // aac illegal channel count
1163
1164 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1165 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1166 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1167
1168 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1169 }
1170
1171 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckSampleFormat, TestSize.Level1)
1172 {
1173 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1174 format = OH_AVFormat_Create();
1175 EXPECT_NE(nullptr, format);
1176 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1177 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1178
1179 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1180 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1181
1182 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1183 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1184 AudioSampleFormat::SAMPLE_U8);
1185 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1186
1187 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1188 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1189 AudioSampleFormat::SAMPLE_F32LE);
1190 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1191
1192 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1193 }
1194
1195 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckbitRate, TestSize.Level1)
1196 {
1197 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1198 format = OH_AVFormat_Create();
1199 EXPECT_NE(nullptr, format);
1200 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1201 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1202 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), 500001); // wrong bit rate
1203 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1204 AudioSampleFormat::SAMPLE_F32LE);
1205 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1206
1207 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1208 }
1209
1210 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckSampleRate, TestSize.Level1)
1211 {
1212 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1213 format = OH_AVFormat_Create();
1214 EXPECT_NE(nullptr, format);
1215 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1216 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1217 AudioSampleFormat::SAMPLE_F32LE);
1218 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1219
1220 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1221 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1222 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1223
1224 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1225 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1226 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1227
1228 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1229 }
1230
1231 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckChannelLayout, TestSize.Level1)
1232 {
1233 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1234 format = OH_AVFormat_Create();
1235 EXPECT_NE(nullptr, format);
1236 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1237 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1238 AudioSampleFormat::SAMPLE_F32LE);
1239 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1240 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CH_LAYOUT_7POINT1);
1241 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1242
1243 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1244 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT.data(), CHANNEL_LAYOUT);
1245 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel layout
1246
1247 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1248 }
1249
1250 HWTEST_F(AudioEncoderBufferCapiUnitTest, aacCheckMaxinputSize, TestSize.Level1)
1251 {
1252 frameBytes_ = AAC_DEFAULT_FRAME_BYTES;
1253 CreateCodecFunc(AudioBufferFormatType::TYPE_AAC);
1254 format = OH_AVFormat_Create();
1255 EXPECT_NE(nullptr, format);
1256 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1257 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1258 AudioSampleFormat::SAMPLE_F32LE);
1259 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE);
1260 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), MAX_INPUT_SIZE);
1261 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1262 OH_AVFormat_Destroy(format);
1263
1264 auto fmt = OH_AudioCodec_GetOutputDescription(audioEnc_);
1265 EXPECT_NE(fmt, nullptr);
1266 OH_AVFormat_Destroy(fmt);
1267
1268 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
1269
1270 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1271 }
1272
1273 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckChannelCount, TestSize.Level1)
1274 {
1275 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1276 format = OH_AVFormat_Create();
1277 EXPECT_NE(nullptr, format);
1278 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1279 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1280 AudioSampleFormat::SAMPLE_S16LE);
1281 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1282
1283 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1284 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1285 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1286
1287 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1288 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1289 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1290
1291 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1292 }
1293
1294 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckSampleFormat, TestSize.Level1)
1295 {
1296 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1297 format = OH_AVFormat_Create();
1298 EXPECT_NE(nullptr, format);
1299 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1300 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1301 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1302
1303 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1304 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1305 AudioSampleFormat::SAMPLE_U8);
1306 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1307
1308 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1309 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1310 AudioSampleFormat::SAMPLE_S16LE);
1311 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1312
1313 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1314 }
1315
1316 HWTEST_F(AudioEncoderBufferCapiUnitTest, g711muCheckSampleRate, TestSize.Level1)
1317 {
1318 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1319 format = OH_AVFormat_Create();
1320 EXPECT_NE(nullptr, format);
1321 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1322 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1323 AudioSampleFormat::SAMPLE_S16LE);
1324 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1325
1326 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1327 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1328 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1329
1330 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1331 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1332 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1333
1334 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1335 }
1336
1337 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_G711mu_Start, TestSize.Level1) {
1338 frameBytes_ = G711MU_DEFAULT_FRAME_BYTES;
1339 format = OH_AVFormat_Create();
1340 EXPECT_NE(nullptr, format);
1341 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1342 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1343 AudioSampleFormat::SAMPLE_S16LE);
1344 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1345
1346 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(AudioBufferFormatType::TYPE_G711MU));
1347 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU));
1348 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1349 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioEnc_));
1350 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1351 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1352 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioEnc_));
1353 {
1354 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f60f02() 1355 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1356 }
1357 OH_AVFormat_Destroy(format);
1358 Release();
1359 }
1360
1361 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckChannelCount, TestSize.Level1)
1362 {
1363 if (!CheckSoFunc()) {
1364 return;
1365 }
1366 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1367 format = OH_AVFormat_Create();
1368 EXPECT_NE(nullptr, format);
1369 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1370 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1371 AudioSampleFormat::SAMPLE_S16LE);
1372 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1373 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing channel count
1374
1375 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1376 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), ILLEGAL_CHANNEL_COUNT);
1377 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal channel count
1378
1379 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1380 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1381 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal channel count
1382
1383 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1384 }
1385
1386 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckSampleFormat, TestSize.Level1)
1387 {
1388 if (!CheckSoFunc()) {
1389 return;
1390 }
1391 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1392 format = OH_AVFormat_Create();
1393 EXPECT_NE(nullptr, format);
1394 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1395 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1396 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1397 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample format
1398
1399 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1400 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1401 AudioSampleFormat::SAMPLE_U8);
1402 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample format
1403
1404 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1405 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1406 AudioSampleFormat::SAMPLE_S16LE);
1407 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample format
1408
1409 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1410 }
1411
1412 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckSampleRate, TestSize.Level1)
1413 {
1414 if (!CheckSoFunc()) {
1415 return;
1416 }
1417 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1418 format = OH_AVFormat_Create();
1419 EXPECT_NE(nullptr, format);
1420 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1421 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1422 AudioSampleFormat::SAMPLE_S16LE);
1423 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1424 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // missing sample rate
1425
1426 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1427 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), ILLEGAL_SAMPLE_RATE);
1428 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // illegal sample rate
1429
1430 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioEnc_));
1431 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1432 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // normal sample rate
1433
1434 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1435 }
1436
1437 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusCheckChannelLayout, TestSize.Level1)
1438 {
1439 if (!CheckSoFunc()) {
1440 return;
1441 }
1442 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1443 format = OH_AVFormat_Create();
1444 EXPECT_NE(nullptr, format);
1445 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1446 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1447 AudioSampleFormat::SAMPLE_S16LE);
1448 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1449 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1450 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1451 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1452 }
1453
1454 HWTEST_F(AudioEncoderBufferCapiUnitTest, opusGetOutputDescription_01, TestSize.Level1)
1455 {
1456 if (!CheckSoFunc()) {
1457 return;
1458 }
1459 CreateCodecFunc(AudioBufferFormatType::TYPE_OPUS);
1460 format = OH_AVFormat_Create();
1461 EXPECT_NE(nullptr, format);
1462 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_COUNT);
1463 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1464 AudioSampleFormat::SAMPLE_S16LE);
1465 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), OPUS_SAMPLE_RATE);
1466 OH_AVFormat_SetLongValue(format, MediaDescriptionKey::MD_KEY_BITRATE.data(), BITS_RATE);
1467 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format)); // channel mismatch channel_layout
1468
1469 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioEnc_));
1470 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1471 }
1472
1473 HWTEST_F(AudioEncoderBufferCapiUnitTest, audioEncoder_normalcase_g711mu, TestSize.Level1)
1474 {
1475 frameBytes_ = G711MU_DEFAULT_FRAME_BYTES;
1476 InitFile(AudioBufferFormatType::TYPE_G711MU);
1477 CreateCodecFunc(AudioBufferFormatType::TYPE_G711MU);
1478 format = OH_AVFormat_Create();
1479 EXPECT_NE(nullptr, format);
1480 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), CHANNEL_1CHAN_COUNT);
1481 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
1482 AudioSampleFormat::SAMPLE_S16LE);
1483 OH_AVFormat_SetIntValue(format, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), SAMPLE_RATE_8K);
1484 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioEnc_, format));
1485 OH_AVFormat_Destroy(format);
1486 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
1487 {
1488 unique_lock<mutex> lock(signal_->startMutex_);
__anonbfc204f61002() 1489 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
1490 }
1491
1492 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
1493 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioEnc_));
1494 }
1495 }
1496 }