1 /*
2 * Copyright (C) 2024 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 #include <atomic>
16 #include <chrono>
17 #include <fstream>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include <queue>
21 #include <string>
22 #include <thread>
23 #include <unistd.h>
24
25 #include "avcodec_codec_name.h"
26 #include "avcodec_mime_type.h"
27 #include "common/native_mfmagic.h"
28 #include "media_description.h"
29 #include "native_avbuffer.h"
30 #include "native_avcodec_audiocodec.h"
31
32 using namespace std;
33 using namespace testing::ext;
34 using namespace OHOS::MediaAVCodec;
35 namespace {
36 const string CODEC_VIVID_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_VIVID_NAME);
37 constexpr uint32_t VIVID_MIN_CHANNEL_COUNT = 0;
38 constexpr uint32_t VIVID_MAX_CHANNEL_COUNT = 17;
39 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
40 constexpr uint32_t DEFAULT_SAMPLE_RATE = 48000;
41 constexpr uint32_t TEST_SAMPLE_RATE = 32000;
42 constexpr uint32_t VIVID_MAX_INPUT_SIZE = 99999999;
43 constexpr string_view INPUT_VIVID_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.dat";
44 constexpr string_view OUTPUT_VIVID_PCM_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.pcm";
45 } // namespace
46
47 namespace OHOS {
48 namespace MediaAVCodec {
49
50 static uint32_t g_outputFormatChangedTimes = 0;
51 static int32_t g_outputSampleRate = 0;
52 static int32_t g_outputChannels = 0;
53
54 class ADecBufferSignal {
55 public:
56 std::mutex inMutex_;
57 std::mutex outMutex_;
58 std::mutex startMutex_;
59 std::condition_variable inCond_;
60 std::condition_variable outCond_;
61 std::condition_variable startCond_;
62 std::queue<uint32_t> inQueue_;
63 std::queue<uint32_t> outQueue_;
64 std::queue<OH_AVBuffer *> inBufferQueue_;
65 std::queue<OH_AVBuffer *> outBufferQueue_;
66 };
67
OnError(OH_AVCodec * codec,int32_t errorCode,void * userData)68 static void OnError(OH_AVCodec *codec, int32_t errorCode, void *userData)
69 {
70 (void)codec;
71 (void)errorCode;
72 (void)userData;
73 cout << "Error received, errorCode:" << errorCode << endl;
74 }
75
OnOutputFormatChanged(OH_AVCodec * codec,OH_AVFormat * format,void * userData)76 static void OnOutputFormatChanged(OH_AVCodec *codec, OH_AVFormat *format, void *userData)
77 {
78 (void)codec;
79 (void)userData;
80 g_outputFormatChangedTimes++;
81 OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, &g_outputChannels);
82 OH_AVFormat_GetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, &g_outputSampleRate);
83 cout << "OnOutputFormatChanged received, rate:" << g_outputSampleRate << ", channel:" << g_outputChannels << endl;
84 }
85
OnInputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)86 static void OnInputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
87 {
88 (void)codec;
89 ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
90 unique_lock<mutex> lock(signal->inMutex_);
91 signal->inQueue_.push(index);
92 signal->inBufferQueue_.push(data);
93 signal->inCond_.notify_all();
94 }
95
OnOutputBufferAvailable(OH_AVCodec * codec,uint32_t index,OH_AVBuffer * data,void * userData)96 static void OnOutputBufferAvailable(OH_AVCodec *codec, uint32_t index, OH_AVBuffer *data, void *userData)
97 {
98 (void)codec;
99 ADecBufferSignal *signal = static_cast<ADecBufferSignal *>(userData);
100 unique_lock<mutex> lock(signal->outMutex_);
101 signal->outQueue_.push(index);
102 signal->outBufferQueue_.push(data);
103 signal->outCond_.notify_all();
104 }
105
106 class AudioVividCodeCapiDecoderUnitTest : public testing::Test {
107 public:
108 static void SetUpTestCase(void);
109 static void TearDownTestCase(void);
110 void SetUp();
111 void TearDown();
112 int32_t InitFile(const string &codecName);
113 void InputFunc();
114 void OutputFunc();
115 int32_t CreateCodecFunc(const string &codecName);
116 int32_t HandleInputBuffer(const uint32_t index);
117 int32_t Configure();
118 int32_t Configure24Bit();
119 int32_t Start();
120 int32_t Stop();
121 void Release();
122
123 protected:
124 std::atomic<bool> isRunning_ = false;
125 std::unique_ptr<std::thread> inputLoop_;
126 std::unique_ptr<std::thread> outputLoop_;
127 struct OH_AVCodecCallback cb_;
128 ADecBufferSignal *signal_ = nullptr;
129 OH_AVCodec *audioDec_ = nullptr;
130 OH_AVFormat *format_ = nullptr;
131 bool isFirstFrame_ = true;
132 bool isTestingFormat_ = false;
133 std::ifstream inputFile_;
134 std::ofstream pcmOutputFile_;
135 };
136
SetUpTestCase(void)137 void AudioVividCodeCapiDecoderUnitTest::SetUpTestCase(void)
138 {
139 cout << "[SetUpTestCase]: " << endl;
140 }
141
TearDownTestCase(void)142 void AudioVividCodeCapiDecoderUnitTest::TearDownTestCase(void)
143 {
144 cout << "[TearDownTestCase]: " << endl;
145 }
146
SetUp(void)147 void AudioVividCodeCapiDecoderUnitTest::SetUp(void)
148 {
149 g_outputFormatChangedTimes = 0;
150 g_outputSampleRate = 0;
151 g_outputChannels = 0;
152 cout << "[SetUp]: SetUp!!!" << endl;
153 }
154
TearDown(void)155 void AudioVividCodeCapiDecoderUnitTest::TearDown(void)
156 {
157 if (isTestingFormat_) {
158 EXPECT_EQ(g_outputFormatChangedTimes, 1);
159 } else {
160 EXPECT_EQ(g_outputFormatChangedTimes, 0);
161 }
162 cout << "[TearDown]: over!!!" << endl;
163
164 if (signal_) {
165 delete signal_;
166 signal_ = nullptr;
167 }
168 if (inputFile_.is_open()) {
169 inputFile_.close();
170 }
171 if (pcmOutputFile_.is_open()) {
172 pcmOutputFile_.close();
173 }
174 }
175
Release()176 void AudioVividCodeCapiDecoderUnitTest::Release()
177 {
178 Stop();
179 OH_AudioCodec_Destroy(audioDec_);
180 }
181
HandleInputBuffer(const uint32_t index)182 int32_t AudioVividCodeCapiDecoderUnitTest::HandleInputBuffer(const uint32_t index)
183 {
184 int32_t ret = OH_AudioCodec_PushInputBuffer(audioDec_, index);
185 signal_->inBufferQueue_.pop();
186 signal_->inQueue_.pop();
187 return ret;
188 }
189
InputFunc()190 void AudioVividCodeCapiDecoderUnitTest::InputFunc()
191 {
192 int64_t size;
193 while (isRunning_.load()) {
194 unique_lock<mutex> lock(signal_->inMutex_);
195 signal_->inCond_.wait(lock, [this]() { return (signal_->inQueue_.size() > 0 || !isRunning_.load()); });
196 if (!isRunning_.load()) {
197 break;
198 }
199 uint32_t index = signal_->inQueue_.front();
200 auto buffer = signal_->inBufferQueue_.front();
201 if (buffer == nullptr) {
202 cout << "Fatal: GetInputBuffer fail" << endl;
203 break;
204 }
205 inputFile_.read(reinterpret_cast<char *>(&size), sizeof(size));
206 if (inputFile_.eof() || inputFile_.gcount() == 0) {
207 buffer->buffer_->memory_->SetSize(1);
208 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
209 HandleInputBuffer(index);
210 cout << "end buffer\n";
211 break;
212 }
213 if (inputFile_.gcount() != sizeof(size)) {
214 cout << "Fatal: read size fail" << endl;
215 break;
216 }
217 inputFile_.read(reinterpret_cast<char *>(&buffer->buffer_->pts_), sizeof(buffer->buffer_->pts_));
218 if (inputFile_.gcount() != sizeof(buffer->buffer_->pts_)) {
219 cout << "Fatal: read size fail" << endl;
220 break;
221 }
222 inputFile_.read((char *)OH_AVBuffer_GetAddr(buffer), size);
223 if (inputFile_.gcount() != size) {
224 cout << "Fatal: read buffer fail" << endl;
225 break;
226 }
227 buffer->buffer_->memory_->SetSize(size);
228 if (isFirstFrame_) {
229 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_CODEC_DATA;
230 isFirstFrame_ = false;
231 } else {
232 buffer->buffer_->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
233 }
234 if (HandleInputBuffer(index) != AV_ERR_OK) {
235 cout << "Fatal error, exit" << endl;
236 break;
237 }
238 }
239 inputFile_.close();
240 }
241
OutputFunc()242 void AudioVividCodeCapiDecoderUnitTest::OutputFunc()
243 {
244 if (!pcmOutputFile_.is_open()) {
245 std::cout << "open " << OUTPUT_VIVID_PCM_FILE_PATH << " failed!" << std::endl;
246 }
247 while (isRunning_.load()) {
248 unique_lock<mutex> lock(signal_->outMutex_);
249 signal_->outCond_.wait(lock, [this]() { return (signal_->outQueue_.size() > 0 || !isRunning_.load()); });
250 if (!isRunning_.load()) {
251 cout << "wait to stop, exit" << endl;
252 break;
253 }
254 uint32_t index = signal_->outQueue_.front();
255 OH_AVBuffer *data = signal_->outBufferQueue_.front();
256 if (data == nullptr) {
257 std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
258 isRunning_.store(false);
259 signal_->startCond_.notify_all();
260 break;
261 }
262 pcmOutputFile_.write(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(data)), data->buffer_->memory_->GetSize());
263 if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
264 cout << "decode eos" << endl;
265 isRunning_.store(false);
266 signal_->startCond_.notify_all();
267 }
268 signal_->outBufferQueue_.pop();
269 signal_->outQueue_.pop();
270 EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
271 }
272 pcmOutputFile_.close();
273 signal_->startCond_.notify_all();
274 }
275
Start()276 int32_t AudioVividCodeCapiDecoderUnitTest::Start()
277 {
278 isRunning_.store(true);
279 inputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::InputFunc, this);
280 if (inputLoop_ == nullptr) {
281 cout << "Fatal: No memory" << endl;
282 return OH_AVErrCode::AV_ERR_UNKNOWN;
283 }
284
285 outputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::OutputFunc, this);
286 if (outputLoop_ == nullptr) {
287 cout << "Fatal: No memory" << endl;
288 return OH_AVErrCode::AV_ERR_UNKNOWN;
289 }
290
291 return OH_AudioCodec_Start(audioDec_);
292 }
293
Stop()294 int32_t AudioVividCodeCapiDecoderUnitTest::Stop()
295 {
296 isRunning_.store(false);
297 if (!signal_) {
298 return OH_AVErrCode::AV_ERR_UNKNOWN;
299 }
300 signal_->startCond_.notify_all();
301 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
302 {
303 unique_lock<mutex> lock(signal_->inMutex_);
304 signal_->inCond_.notify_all();
305 }
306 inputLoop_->join();
307 }
308
309 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
310 {
311 unique_lock<mutex> lock(signal_->outMutex_);
312 signal_->outCond_.notify_all();
313 }
314 outputLoop_->join();
315 }
316 return OH_AudioCodec_Stop(audioDec_);
317 }
318
InitFile(const string & codecName)319 int32_t AudioVividCodeCapiDecoderUnitTest::InitFile(const string &codecName)
320 {
321 if (codecName.compare(CODEC_VIVID_NAME) == 0) {
322 inputFile_.open(INPUT_VIVID_FILE_PATH.data(), std::ios::binary);
323 pcmOutputFile_.open(OUTPUT_VIVID_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
324 } else {
325 cout << "Fatal: audio format type not support" << endl;
326 return OH_AVErrCode::AV_ERR_UNKNOWN;
327 }
328
329 if (!inputFile_.is_open()) {
330 cout << "Fatal: open input file failed" << endl;
331 return OH_AVErrCode::AV_ERR_UNKNOWN;
332 }
333 if (!pcmOutputFile_.is_open()) {
334 cout << "Fatal: open output file failed" << endl;
335 return OH_AVErrCode::AV_ERR_UNKNOWN;
336 }
337 return OH_AVErrCode::AV_ERR_OK;
338 }
339
CreateCodecFunc(const string & codecName)340 int32_t AudioVividCodeCapiDecoderUnitTest::CreateCodecFunc(const string &codecName)
341 {
342 if (codecName.compare(CODEC_VIVID_NAME) == 0) {
343 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
344 } else {
345 cout << "audio name not support" << endl;
346 return OH_AVErrCode::AV_ERR_UNKNOWN;
347 }
348
349 if (audioDec_ == nullptr) {
350 cout << "Fatal: CreateByName fail" << endl;
351 return OH_AVErrCode::AV_ERR_UNKNOWN;
352 }
353
354 signal_ = new ADecBufferSignal();
355 if (signal_ == nullptr) {
356 cout << "Fatal: create signal fail" << endl;
357 return OH_AVErrCode::AV_ERR_UNKNOWN;
358 }
359 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
360 int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_);
361 if (ret != OH_AVErrCode::AV_ERR_OK) {
362 cout << "Fatal: SetCallback fail" << endl;
363 return OH_AVErrCode::AV_ERR_UNKNOWN;
364 }
365
366 return OH_AVErrCode::AV_ERR_OK;
367 }
368
Configure()369 int32_t AudioVividCodeCapiDecoderUnitTest::Configure()
370 {
371 format_ = OH_AVFormat_Create();
372 if (format_ == nullptr) {
373 cout << "Fatal: create format failed" << endl;
374 return OH_AVErrCode::AV_ERR_UNKNOWN;
375 }
376
377 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
378 if (isTestingFormat_) {
379 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), TEST_SAMPLE_RATE);
380 } else {
381 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
382 }
383
384 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
385 OH_BitsPerSample::SAMPLE_S16LE);
386
387 return OH_AudioCodec_Configure(audioDec_, format_);
388 }
389
Configure24Bit()390 int32_t AudioVividCodeCapiDecoderUnitTest::Configure24Bit()
391 {
392 format_ = OH_AVFormat_Create();
393 if (format_ == nullptr) {
394 cout << "Fatal: create format failed" << endl;
395 return OH_AVErrCode::AV_ERR_UNKNOWN;
396 }
397
398 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
399 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
400
401 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
402 OH_BitsPerSample::SAMPLE_S24LE);
403
404 return OH_AudioCodec_Configure(audioDec_, format_);
405 }
406
407 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByMime_01, TestSize.Level1)
408 {
409 audioDec_ = OH_AudioCodec_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID.data(), false);
410 EXPECT_NE(nullptr, audioDec_);
411 Release();
412 }
413
414 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByName_01, TestSize.Level1)
415 {
416 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
417 EXPECT_NE(nullptr, audioDec_);
418 Release();
419 }
420
421 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_01, TestSize.Level1)
422 {
423 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
424 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
425 Release();
426 }
427
428 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_02, TestSize.Level1)
429 {
430 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
431 format_ = OH_AVFormat_Create();
432 EXPECT_NE(nullptr, format_);
433 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MIN_CHANNEL_COUNT);
434 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
435 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
436 Release();
437 }
438
439 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_03, TestSize.Level1)
440 {
441 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
442 format_ = OH_AVFormat_Create();
443 EXPECT_NE(nullptr, format_);
444 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MAX_CHANNEL_COUNT);
445 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
446 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
447 Release();
448 }
449
450 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_04, TestSize.Level1)
451 {
452 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
453 format_ = OH_AVFormat_Create();
454 EXPECT_NE(nullptr, format_);
455 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
456 OH_BitsPerSample::SAMPLE_S32LE);
457 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
458 Release();
459 }
460
461 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_05, TestSize.Level1)
462 {
463 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
464 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
465 Release();
466 }
467
468 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_01, TestSize.Level1)
469 {
470 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
471 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
472 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
473 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
474 {
475 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0402() 476 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
477 }
478 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
479 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
480 Release();
481 }
482
483 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_02, TestSize.Level1)
484 {
485 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
486 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
487 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
488 Release();
489 }
490
491 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_03, TestSize.Level1)
492 {
493 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
494 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
495 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
496 Release();
497 }
498
499 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_01, TestSize.Level1)
500 {
501 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
502 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
503 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
504 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
505 {
506 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0502() 507 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
508 }
509 Release();
510 }
511
512 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_02, TestSize.Level1)
513 {
514 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
515 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
516 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
517 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
518 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
519 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
520 {
521 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0602() 522 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
523 }
524 Release();
525 }
526
527 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_03, TestSize.Level1)
528 {
529 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
530 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
531 format_ = OH_AVFormat_Create();
532 EXPECT_NE(nullptr, format_);
533 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
534 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
535 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), VIVID_MAX_INPUT_SIZE);
536 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
537
538 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
539 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
540 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
541 {
542 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0702() 543 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
544 }
545 Release();
546 }
547
548 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_04, TestSize.Level1)
549 {
550 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
551 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
552 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
553 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
554 {
555 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0802() 556 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
557 }
558 Release();
559 }
560
561 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_05, TestSize.Level1)
562 {
563 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
564 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
565 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
566 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
567 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
568 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
569 {
570 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0902() 571 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
572 }
573 Release();
574 }
575
576 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_01, TestSize.Level1)
577 {
578 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
579 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
580 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
581 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
582 sleep(1);
583
584 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
585 Release();
586 }
587
588 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_02, TestSize.Level1)
589 {
590 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
591 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
592 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
593 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
594 sleep(1);
595
596 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
597 Release();
598 }
599
600 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_01, TestSize.Level1)
601 {
602 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
603 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
604 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
605 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
606 {
607 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0a02() 608 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
609 }
610 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
611 Release();
612 }
613
614 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_02, TestSize.Level1)
615 {
616 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
617 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
618 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
619 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
620 {
621 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0b02() 622 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
623 }
624 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
625 Release();
626 }
627
628 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_01, TestSize.Level1)
629 {
630 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
631 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
632 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
633 Release();
634 }
635
636 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_02, TestSize.Level1)
637 {
638 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
639 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
640 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
641 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
642 {
643 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0c02() 644 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
645 }
646 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
647 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
648 Release();
649 }
650
651 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_03, TestSize.Level1)
652 {
653 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
654 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
655 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
656 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
657 {
658 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0d02() 659 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
660 }
661 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
662 Release();
663 }
664
665 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_04, TestSize.Level1)
666 {
667 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
668 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
669 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
670 Release();
671 }
672
673 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_05, TestSize.Level1)
674 {
675 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
676 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
677 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
678 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
679 {
680 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0e02() 681 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
682 }
683 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
684 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
685 Release();
686 }
687
688 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_06, TestSize.Level1)
689 {
690 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
691 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
692 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
693 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
694 {
695 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee0f02() 696 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
697 }
698 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
699 Release();
700 }
701
702 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_01, TestSize.Level1)
703 {
704 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
705 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
706 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
707 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
708 {
709 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee1002() 710 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
711 }
712 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
713 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
714 }
715
716 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_02, TestSize.Level1)
717 {
718 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
719 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
720 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
721
722 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
723 }
724
725 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_03, TestSize.Level1)
726 {
727 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
728 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
729 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
730 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
731 {
732 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee1102() 733 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
734 }
735 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
736 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
737 }
738
739 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_04, TestSize.Level1)
740 {
741 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
742 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
743 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
744
745 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
746 }
747
748 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_01, TestSize.Level1)
749 {
750 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
751 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
752 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
753
754 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
755 Release();
756 }
757
758 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_02, TestSize.Level1)
759 {
760 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
761 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
762 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
763
764 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
765 Release();
766 }
767
768 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_IsValid_01, TestSize.Level1)
769 {
770 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
771 bool isValid = false;
772 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioDec_, &isValid));
773 Release();
774 }
775
776 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_01, TestSize.Level1)
777 {
778 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
779 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
780 Release();
781 }
782
783 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_02, TestSize.Level1)
784 {
785 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
786 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
787 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
788 Release();
789 }
790
791 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_03, TestSize.Level1)
792 {
793 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
794 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
795 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
796 Release();
797 }
798
799 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_01, TestSize.Level1)
800 {
801 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
802 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
803 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
804 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
805
806 uint32_t index = 0;
807 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
808 Release();
809 }
810
811 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_02, TestSize.Level1)
812 {
813 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
814 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
815 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
816 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
817
818 uint32_t index = 0;
819 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
820 Release();
821 }
822
823 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_01, TestSize.Level1)
824 {
825 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
826 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
827 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
828 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
829
830 uint32_t index = 1024;
831 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
832 Release();
833 }
834
835 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_02, TestSize.Level1)
836 {
837 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
838 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
839 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
840 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
841
842 uint32_t index = 1024;
843 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
844 Release();
845 }
846
847 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_formatChanged, TestSize.Level1)
848 {
849 isTestingFormat_ = true;
850 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
851 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
852 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
853 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
854 {
855 unique_lock<mutex> lock(signal_->startMutex_);
__anonb8216dee1202() 856 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
857 }
858 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
859 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
860 }
861
862 } // namespace MediaAVCodec
863 } // namespace OHOS