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