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 signal_->outBufferQueue_.pop();
264 signal_->outQueue_.pop();
265 if (data->buffer_->flag_ == AVCODEC_BUFFER_FLAGS_EOS) {
266 cout << "decode eos" << endl;
267 isRunning_.store(false);
268 signal_->startCond_.notify_all();
269 break;
270 }
271 EXPECT_EQ(AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
272 }
273 pcmOutputFile_.close();
274 signal_->startCond_.notify_all();
275 }
276
Start()277 int32_t AudioVividCodeCapiDecoderUnitTest::Start()
278 {
279 isRunning_.store(true);
280 inputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::InputFunc, this);
281 if (inputLoop_ == nullptr) {
282 cout << "Fatal: No memory" << endl;
283 return OH_AVErrCode::AV_ERR_UNKNOWN;
284 }
285
286 outputLoop_ = make_unique<thread>(&AudioVividCodeCapiDecoderUnitTest::OutputFunc, this);
287 if (outputLoop_ == nullptr) {
288 cout << "Fatal: No memory" << endl;
289 return OH_AVErrCode::AV_ERR_UNKNOWN;
290 }
291
292 return OH_AudioCodec_Start(audioDec_);
293 }
294
Stop()295 int32_t AudioVividCodeCapiDecoderUnitTest::Stop()
296 {
297 isRunning_.store(false);
298 if (!signal_) {
299 return OH_AVErrCode::AV_ERR_UNKNOWN;
300 }
301 signal_->startCond_.notify_all();
302 if (inputLoop_ != nullptr && inputLoop_->joinable()) {
303 {
304 unique_lock<mutex> lock(signal_->inMutex_);
305 signal_->inCond_.notify_all();
306 }
307 inputLoop_->join();
308 }
309
310 if (outputLoop_ != nullptr && outputLoop_->joinable()) {
311 {
312 unique_lock<mutex> lock(signal_->outMutex_);
313 signal_->outCond_.notify_all();
314 }
315 outputLoop_->join();
316 }
317 return OH_AudioCodec_Stop(audioDec_);
318 }
319
InitFile(const string & codecName)320 int32_t AudioVividCodeCapiDecoderUnitTest::InitFile(const string &codecName)
321 {
322 if (codecName.compare(CODEC_VIVID_NAME) == 0) {
323 inputFile_.open(INPUT_VIVID_FILE_PATH.data(), std::ios::binary);
324 pcmOutputFile_.open(OUTPUT_VIVID_PCM_FILE_PATH.data(), std::ios::out | std::ios::binary);
325 } else {
326 cout << "Fatal: audio format type not support" << endl;
327 return OH_AVErrCode::AV_ERR_UNKNOWN;
328 }
329
330 if (!inputFile_.is_open()) {
331 cout << "Fatal: open input file failed" << endl;
332 return OH_AVErrCode::AV_ERR_UNKNOWN;
333 }
334 if (!pcmOutputFile_.is_open()) {
335 cout << "Fatal: open output file failed" << endl;
336 return OH_AVErrCode::AV_ERR_UNKNOWN;
337 }
338 return OH_AVErrCode::AV_ERR_OK;
339 }
340
CreateCodecFunc(const string & codecName)341 int32_t AudioVividCodeCapiDecoderUnitTest::CreateCodecFunc(const string &codecName)
342 {
343 if (codecName.compare(CODEC_VIVID_NAME) == 0) {
344 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
345 } else {
346 cout << "audio name not support" << endl;
347 return OH_AVErrCode::AV_ERR_UNKNOWN;
348 }
349
350 if (audioDec_ == nullptr) {
351 cout << "Fatal: CreateByName fail" << endl;
352 return OH_AVErrCode::AV_ERR_UNKNOWN;
353 }
354
355 signal_ = new ADecBufferSignal();
356 if (signal_ == nullptr) {
357 cout << "Fatal: create signal fail" << endl;
358 return OH_AVErrCode::AV_ERR_UNKNOWN;
359 }
360 cb_ = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable, &OnOutputBufferAvailable};
361 int32_t ret = OH_AudioCodec_RegisterCallback(audioDec_, cb_, signal_);
362 if (ret != OH_AVErrCode::AV_ERR_OK) {
363 cout << "Fatal: SetCallback fail" << endl;
364 return OH_AVErrCode::AV_ERR_UNKNOWN;
365 }
366
367 return OH_AVErrCode::AV_ERR_OK;
368 }
369
Configure()370 int32_t AudioVividCodeCapiDecoderUnitTest::Configure()
371 {
372 format_ = OH_AVFormat_Create();
373 if (format_ == nullptr) {
374 cout << "Fatal: create format failed" << endl;
375 return OH_AVErrCode::AV_ERR_UNKNOWN;
376 }
377
378 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
379 if (isTestingFormat_) {
380 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), TEST_SAMPLE_RATE);
381 } else {
382 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
383 }
384
385 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
386 OH_BitsPerSample::SAMPLE_S16LE);
387
388 return OH_AudioCodec_Configure(audioDec_, format_);
389 }
390
Configure24Bit()391 int32_t AudioVividCodeCapiDecoderUnitTest::Configure24Bit()
392 {
393 format_ = OH_AVFormat_Create();
394 if (format_ == nullptr) {
395 cout << "Fatal: create format failed" << endl;
396 return OH_AVErrCode::AV_ERR_UNKNOWN;
397 }
398
399 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
400 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
401
402 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
403 OH_BitsPerSample::SAMPLE_S24LE);
404
405 return OH_AudioCodec_Configure(audioDec_, format_);
406 }
407
408 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByMime_01, TestSize.Level1)
409 {
410 audioDec_ = OH_AudioCodec_CreateByMime(AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_VIVID.data(), false);
411 EXPECT_NE(nullptr, audioDec_);
412 Release();
413 }
414
415 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_CreateByName_01, TestSize.Level1)
416 {
417 audioDec_ = OH_AudioCodec_CreateByName((AVCodecCodecName::AUDIO_DECODER_VIVID_NAME).data());
418 EXPECT_NE(nullptr, audioDec_);
419 Release();
420 }
421
422 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_01, TestSize.Level1)
423 {
424 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
425 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
426 Release();
427 }
428
429 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_02, TestSize.Level1)
430 {
431 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
432 format_ = OH_AVFormat_Create();
433 EXPECT_NE(nullptr, format_);
434 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MIN_CHANNEL_COUNT);
435 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
436 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
437 Release();
438 }
439
440 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_03, TestSize.Level1)
441 {
442 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
443 format_ = OH_AVFormat_Create();
444 EXPECT_NE(nullptr, format_);
445 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), VIVID_MAX_CHANNEL_COUNT);
446 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
447 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
448 Release();
449 }
450
451 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_04, TestSize.Level1)
452 {
453 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
454 format_ = OH_AVFormat_Create();
455 EXPECT_NE(nullptr, format_);
456 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT.data(),
457 OH_BitsPerSample::SAMPLE_S32LE);
458 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
459 Release();
460 }
461
462 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Configure_05, TestSize.Level1)
463 {
464 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
465 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
466 Release();
467 }
468
469 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_01, TestSize.Level1)
470 {
471 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
472 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
473 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
474 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
475 {
476 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100402() 477 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
478 }
479 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
480 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
481 Release();
482 }
483
484 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_02, TestSize.Level1)
485 {
486 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
487 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
488 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
489 Release();
490 }
491
492 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_SetParameter_03, TestSize.Level1)
493 {
494 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
495 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
496 ASSERT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_SetParameter(audioDec_, format_));
497 Release();
498 }
499
500 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_01, TestSize.Level1)
501 {
502 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
503 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
504 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
505 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
506 {
507 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100502() 508 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
509 }
510 Release();
511 }
512
513 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_02, TestSize.Level1)
514 {
515 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
516 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
517 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
518 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
519 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
520 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
521 {
522 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100602() 523 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
524 }
525 Release();
526 }
527
528 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_03, TestSize.Level1)
529 {
530 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
531 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
532 format_ = OH_AVFormat_Create();
533 EXPECT_NE(nullptr, format_);
534 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_CHANNEL_COUNT.data(), MAX_CHANNEL_COUNT);
535 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_SAMPLE_RATE.data(), DEFAULT_SAMPLE_RATE);
536 OH_AVFormat_SetIntValue(format_, MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE.data(), VIVID_MAX_INPUT_SIZE);
537 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Configure(audioDec_, format_));
538
539 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
540 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
541 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
542 {
543 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100702() 544 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
545 }
546 Release();
547 }
548
549 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_04, TestSize.Level1)
550 {
551 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
552 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
553 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
554 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
555 {
556 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100802() 557 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
558 }
559 Release();
560 }
561
562 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Start_05, TestSize.Level1)
563 {
564 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
565 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
566 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
567 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
568 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
569 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Start(audioDec_));
570 {
571 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100902() 572 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
573 }
574 Release();
575 }
576
577 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_01, TestSize.Level1)
578 {
579 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
580 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
581 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
582 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
583 sleep(1);
584
585 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
586 Release();
587 }
588
589 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Stop_02, TestSize.Level1)
590 {
591 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
592 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
593 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
594 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
595 sleep(1);
596
597 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
598 Release();
599 }
600
601 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_01, TestSize.Level1)
602 {
603 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
604 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
605 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
606 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
607 {
608 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100a02() 609 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
610 }
611 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
612 Release();
613 }
614
615 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Flush_02, TestSize.Level1)
616 {
617 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
618 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
619 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
620 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
621 {
622 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100b02() 623 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
624 }
625 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Flush(audioDec_));
626 Release();
627 }
628
629 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_01, TestSize.Level1)
630 {
631 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
632 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
633 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
634 Release();
635 }
636
637 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_02, TestSize.Level1)
638 {
639 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
640 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
641 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
642 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
643 {
644 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100c02() 645 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
646 }
647 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
648 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
649 Release();
650 }
651
652 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_03, TestSize.Level1)
653 {
654 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
655 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
656 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
657 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
658 {
659 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100d02() 660 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
661 }
662 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
663 Release();
664 }
665
666 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_04, TestSize.Level1)
667 {
668 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
669 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
670 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
671 Release();
672 }
673
674 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_05, TestSize.Level1)
675 {
676 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
677 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
678 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
679 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
680 {
681 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100e02() 682 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
683 }
684 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
685 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
686 Release();
687 }
688
689 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Reset_06, TestSize.Level1)
690 {
691 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
692 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
693 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
694 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
695 {
696 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346100f02() 697 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
698 }
699 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Reset(audioDec_));
700 Release();
701 }
702
703 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_01, TestSize.Level1)
704 {
705 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
706 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
707 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
708 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
709 {
710 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346101002() 711 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
712 }
713 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
714 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
715 }
716
717 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_02, TestSize.Level1)
718 {
719 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
720 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
721 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
722
723 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
724 }
725
726 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_03, TestSize.Level1)
727 {
728 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
729 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
730 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
731 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
732 {
733 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346101102() 734 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
735 }
736 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
737 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
738 }
739
740 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Destroy_04, TestSize.Level1)
741 {
742 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
743 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
744 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
745
746 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
747 }
748
749 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_01, TestSize.Level1)
750 {
751 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
752 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
753 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
754
755 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
756 Release();
757 }
758
759 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_GetOutputFormat_02, TestSize.Level1)
760 {
761 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
762 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
763 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
764
765 EXPECT_NE(nullptr, OH_AudioCodec_GetOutputDescription(audioDec_));
766 Release();
767 }
768
769 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_IsValid_01, TestSize.Level1)
770 {
771 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
772 bool isValid = false;
773 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_IsValid(audioDec_, &isValid));
774 Release();
775 }
776
777 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_01, TestSize.Level1)
778 {
779 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
780 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
781 Release();
782 }
783
784 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_02, TestSize.Level1)
785 {
786 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
787 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
788 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
789 Release();
790 }
791
792 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_Prepare_03, TestSize.Level1)
793 {
794 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
795 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
796 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Prepare(audioDec_));
797 Release();
798 }
799
800 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_01, TestSize.Level1)
801 {
802 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
803 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
804 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
805 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
806
807 uint32_t index = 0;
808 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
809 Release();
810 }
811
812 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_PushInputData_02, TestSize.Level1)
813 {
814 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
815 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
816 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
817 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
818
819 uint32_t index = 0;
820 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_PushInputBuffer(audioDec_, index));
821 Release();
822 }
823
824 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_01, TestSize.Level1)
825 {
826 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
827 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
828 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
829 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
830
831 uint32_t index = 1024;
832 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
833 Release();
834 }
835
836 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_ReleaseOutputBuffer_02, TestSize.Level1)
837 {
838 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
839 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
840 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure24Bit());
841 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
842
843 uint32_t index = 1024;
844 EXPECT_NE(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_FreeOutputBuffer(audioDec_, index));
845 Release();
846 }
847
848 HWTEST_F(AudioVividCodeCapiDecoderUnitTest, audioDecoder_Vivid_formatChanged, TestSize.Level1)
849 {
850 isTestingFormat_ = true;
851 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, InitFile(CODEC_VIVID_NAME));
852 ASSERT_EQ(OH_AVErrCode::AV_ERR_OK, CreateCodecFunc(CODEC_VIVID_NAME));
853 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Configure());
854 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Start());
855 {
856 unique_lock<mutex> lock(signal_->startMutex_);
__anon9bd346101202() 857 signal_->startCond_.wait(lock, [this]() { return (!(isRunning_.load())); });
858 }
859 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, Stop());
860 EXPECT_EQ(OH_AVErrCode::AV_ERR_OK, OH_AudioCodec_Destroy(audioDec_));
861 }
862
863 } // namespace MediaAVCodec
864 } // namespace OHOS