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 "avcodec_audio_decoder.h"
16 #include "avcodec_codec_name.h"
17 #include "avcodec_common.h"
18 #include "avcodec_errors.h"
19 #include "buffer/avbuffer.h"
20 #include "buffer/avbuffer_queue.h"
21 #include "buffer/avbuffer_queue_consumer.h"
22 #include "buffer/avbuffer_queue_define.h"
23 #include "inner_api/native/avcodec_audio_codec.h"
24 #include "media_description.h"
25 #include "meta/audio_types.h"
26 #include "meta/format.h"
27 #include <atomic>
28 #include <fstream>
29 #include <gtest/gtest.h>
30 #include <mutex>
31 #include <queue>
32 #include <string>
33 #include <thread>
34 #include <vector>
35 
36 using namespace std;
37 using namespace testing::ext;
38 using namespace OHOS::Media;
39 
40 namespace {
41 constexpr std::string_view INPUT_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.dat";
42 constexpr std::string_view OUTPUT_PCM_FILE_PATH = "/data/test/media/vivid_2c_44100hz_320k.pcm";
43 constexpr int32_t TIME_OUT_MS = 8;
44 constexpr uint32_t DEFAULT_WIDTH = 0;
45 constexpr uint32_t DEFAULT_CHANNEL_COUNT = 2;
46 constexpr uint32_t DEFAULT_BUFFER_COUNT = 4;
47 constexpr uint32_t MAX_CHANNEL_COUNT = 17;
48 constexpr uint32_t INVALID_CHANNEL_COUNT = -1;
49 constexpr uint32_t DEFAULT_SAMPLE_RATE = 48000;
50 constexpr uint32_t INVALID_SAMPLE_RATE = 9075000;
51 constexpr uint32_t DEFAULT_BITRATE = 128000;
52 
53 typedef enum OH_AVCodecBufferFlags {
54     AVCODEC_BUFFER_FLAGS_NONE = 0,
55     /* Indicates that the Buffer is an End-of-Stream frame */
56     AVCODEC_BUFFER_FLAGS_EOS = 1 << 0,
57     /* Indicates that the Buffer contains keyframes */
58     AVCODEC_BUFFER_FLAGS_SYNC_FRAME = 1 << 1,
59     /* Indicates that the data contained in the Buffer is only part of a frame */
60     AVCODEC_BUFFER_FLAGS_INCOMPLETE_FRAME = 1 << 2,
61     /* Indicates that the Buffer contains Codec-Specific-Data */
62     AVCODEC_BUFFER_FLAGS_CODEC_DATA = 1 << 3,
63 } OH_AVCodecBufferFlags;
64 
65 #define LOG_MAX_SIZE 200
66 } // namespace
67 
68 namespace OHOS {
69 namespace MediaAVCodec {
70 class ADecVividInnerDemoApiEleven : public testing::Test {
71 public:
72     static void SetUpTestCase(void);
73     static void TearDownTestCase(void);
74     ADecVividInnerDemoApiEleven() = default;
75     ~ADecVividInnerDemoApiEleven();
76     void SetUp();
77     void TearDown();
78 
79     int32_t CreateVividCodec();
80     int32_t ProcessVivid();
81     int32_t ProcessVivid24Bit();
82     void InputFunc();
83     void OutputFunc();
84 
85 protected:
86     std::shared_ptr<Media::Meta> meta;
87     std::shared_ptr<AVCodecAudioCodec> audiocodec_;
88     std::shared_ptr<Media::AVBufferQueue> innerBufferQueue_;
89     sptr<Media::AVBufferQueueConsumer> implConsumer_;
90     sptr<Media::AVBufferQueueProducer> mediaCodecProducer_;
91     std::unique_ptr<std::ifstream> inputFile_;
92     std::unique_ptr<std::ofstream> outputFile_;
93 private:
94     int32_t GetInputBufferSize();
95     int32_t GetFileSize(const std::string &filePath);
96     int32_t fileSize_;
97     std::atomic<int32_t> bufferConsumerAvailableCount_ = 0;
98     std::atomic<bool> isRunning_ = false;
99     std::unique_ptr<std::ifstream> testFile_;
100 };
101 
102 class AudioCodecConsumerListener : public OHOS::Media::IConsumerListener {
103 public:
104     explicit AudioCodecConsumerListener(ADecVividInnerDemoApiEleven *demo);
105     ~AudioCodecConsumerListener();
106     void OnBufferAvailable() override;
107 
108 private:
109     ADecVividInnerDemoApiEleven *demo_;
110 };
111 
~AudioCodecConsumerListener()112 AudioCodecConsumerListener::~AudioCodecConsumerListener()
113 {
114     demo_ = nullptr;
115 }
116 
AudioCodecConsumerListener(ADecVividInnerDemoApiEleven * demo)117 AudioCodecConsumerListener::AudioCodecConsumerListener(ADecVividInnerDemoApiEleven *demo)
118 {
119     demo_ = demo;
120 }
121 
OnBufferAvailable()122 void AudioCodecConsumerListener::OnBufferAvailable()
123 {
124     demo_->OutputFunc();
125 }
126 
SetUpTestCase(void)127 void ADecVividInnerDemoApiEleven::SetUpTestCase(void)
128 {
129     cout << "[SetUpTestCase]: " << endl;
130 }
131 
TearDownTestCase(void)132 void ADecVividInnerDemoApiEleven::TearDownTestCase(void)
133 {
134     cout << "[TearDownTestCase]: " << endl;
135 }
136 
SetUp(void)137 void ADecVividInnerDemoApiEleven::SetUp(void)
138 {
139     cout << "[SetUp]: SetUp!!!" << endl;
140 }
141 
TearDown(void)142 void ADecVividInnerDemoApiEleven::TearDown(void)
143 {
144     cout << "[TearDown]: over!!!" << endl;
145     sleep(1);
146 }
147 
~ADecVividInnerDemoApiEleven()148 ADecVividInnerDemoApiEleven::~ADecVividInnerDemoApiEleven()
149 {
150     implConsumer_ = nullptr;
151     mediaCodecProducer_ = nullptr;
152 }
153 
CreateVividCodec()154 int32_t ADecVividInnerDemoApiEleven::CreateVividCodec()
155 {
156     audiocodec_ = AudioCodecFactory::CreateByName(std::string(AVCodecCodecName::AUDIO_DECODER_VIVID_NAME));
157     if (audiocodec_ == nullptr) {
158         std::cout << "codec == nullptr" << std::endl;
159         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
160     }
161     innerBufferQueue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_COUNT, Media::MemoryType::SHARED_MEMORY,
162                                                      "Vivid_InnerDemo");
163     meta = std::make_shared<Media::Meta>();
164     return  AVCodecServiceErrCode::AVCS_ERR_OK;
165 }
166 
ProcessVivid()167 int32_t ADecVividInnerDemoApiEleven::ProcessVivid()
168 {
169     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(DEFAULT_CHANNEL_COUNT);
170     meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
171     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
172     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
173     audiocodec_->Configure(meta);
174 
175     audiocodec_->SetOutputBufferQueue(innerBufferQueue_->GetProducer());
176     audiocodec_->Prepare();
177 
178     implConsumer_ = innerBufferQueue_->GetConsumer();
179     sptr<Media::IConsumerListener> comsumerListener = new AudioCodecConsumerListener(this);
180     implConsumer_->SetBufferAvailableListener(comsumerListener);
181     mediaCodecProducer_ = audiocodec_->GetInputBufferQueue();
182 
183     audiocodec_->Start();
184     isRunning_.store(true);
185 
186     fileSize_ = GetFileSize(INPUT_FILE_PATH.data());
187     inputFile_ = std::make_unique<std::ifstream>(INPUT_FILE_PATH, std::ios::binary);
188     outputFile_ = std::make_unique<std::ofstream>(OUTPUT_PCM_FILE_PATH, std::ios::binary);
189     InputFunc();
190     inputFile_->close();
191     outputFile_->close();
192     return  AVCodecServiceErrCode::AVCS_ERR_OK;
193 }
194 
ProcessVivid24Bit()195 int32_t ADecVividInnerDemoApiEleven::ProcessVivid24Bit()
196 {
197     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(DEFAULT_CHANNEL_COUNT);
198     meta->Set<Tag::AUDIO_CHANNEL_LAYOUT>(Media::Plugins::AudioChannelLayout::STEREO);
199     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S24LE);
200     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
201     audiocodec_->Configure(meta);
202 
203     audiocodec_->SetOutputBufferQueue(innerBufferQueue_->GetProducer());
204     audiocodec_->Prepare();
205 
206     implConsumer_ = innerBufferQueue_->GetConsumer();
207     sptr<Media::IConsumerListener> comsumerListener = new AudioCodecConsumerListener(this);
208     implConsumer_->SetBufferAvailableListener(comsumerListener);
209     mediaCodecProducer_ = audiocodec_->GetInputBufferQueue();
210 
211     audiocodec_->Start();
212     isRunning_.store(true);
213 
214     fileSize_ = GetFileSize(INPUT_FILE_PATH.data());
215     inputFile_ = std::make_unique<std::ifstream>(INPUT_FILE_PATH, std::ios::binary);
216     outputFile_ = std::make_unique<std::ofstream>(OUTPUT_PCM_FILE_PATH, std::ios::binary);
217     InputFunc();
218     inputFile_->close();
219     outputFile_->close();
220     return AVCodecServiceErrCode::AVCS_ERR_OK;
221 }
222 
GetFileSize(const std::string & filePath)223 int32_t ADecVividInnerDemoApiEleven::GetFileSize(const std::string &filePath)
224 {
225     std::ifstream file(filePath, std::ios::binary | std::ios::ate);
226     if (!file) {
227         std::cerr << "Failed to open file: " << filePath << std::endl;
228         return -1;
229     }
230 
231     std::streampos fileSize = file.tellg();
232     file.close();
233 
234     return (int32_t)fileSize;
235 }
236 
GetInputBufferSize()237 int32_t ADecVividInnerDemoApiEleven::GetInputBufferSize()
238 {
239     int32_t capacity = 0;
240     if (audiocodec_ == nullptr) {
241         std::cout << "audiocodec_ is nullptr\n";
242         return capacity;
243     }
244     std::shared_ptr<Media::Meta> bufferConfig = std::make_shared<Media::Meta>();
245     if (bufferConfig == nullptr) {
246         std::cout << "bufferConfig is nullptr\n";
247         return capacity;
248     }
249     int32_t ret = audiocodec_->GetOutputFormat(bufferConfig);
250     if (ret != AVCodecServiceErrCode::AVCS_ERR_OK) {
251         std::cout << "GetOutputFormat fail\n";
252         return capacity;
253     }
254     if (!bufferConfig->Get<Media::Tag::AUDIO_MAX_INPUT_SIZE>(capacity)) {
255         std::cout << "get max input buffer size fail\n";
256         return capacity;
257     }
258     return capacity;
259 }
260 
InputFunc()261 void ADecVividInnerDemoApiEleven::InputFunc()
262 {
263     if (!(inputFile_ != nullptr && inputFile_->is_open())) {
264         std::cout << "Fatal: open file fail\n";
265         return;
266     }
267     Media::Status ret;
268     int64_t size;
269     int64_t pts;
270     Media::AVBufferConfig avBufferConfig;
271     avBufferConfig.size = GetInputBufferSize();
272     while (isRunning_) {
273         std::shared_ptr<AVBuffer> inputBuffer = nullptr;
274         if (mediaCodecProducer_ == nullptr) {
275             break;
276         }
277         ret = mediaCodecProducer_->RequestBuffer(inputBuffer, avBufferConfig, TIME_OUT_MS);
278         if (ret != Media::Status::OK) {
279             std::cout << "produceInputBuffer RequestBuffer fail,ret=" << (int32_t)ret << std::endl;
280             break;
281         }
282         if (inputBuffer == nullptr) {
283             break;
284         }
285         inputFile_->read(reinterpret_cast<char *>(&size), sizeof(size));
286         if (inputFile_->eof() || inputFile_->gcount() == 0 || size == 0) {
287             inputBuffer->memory_->SetSize(1);
288             inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_EOS;
289             mediaCodecProducer_->PushBuffer(inputBuffer, true);
290             std::cout << "end buffer\n";
291             break;
292         }
293         if (inputFile_->gcount() != sizeof(size)) {
294             return;
295         }
296         inputFile_->read(reinterpret_cast<char *>(&pts), sizeof(pts));
297         if (inputFile_->gcount() != sizeof(pts)) {
298             return;
299         }
300         inputFile_->read((char *)inputBuffer->memory_->GetAddr(), size);
301         if (inputFile_->gcount() != size) {
302             return;
303         }
304         inputBuffer->memory_->SetSize(size);
305         inputBuffer->flag_ = AVCODEC_BUFFER_FLAGS_NONE;
306         mediaCodecProducer_->PushBuffer(inputBuffer, true);
307     }
308 }
309 
OutputFunc()310 void ADecVividInnerDemoApiEleven::OutputFunc()
311 {
312     bufferConsumerAvailableCount_++;
313     Media::Status ret = Media::Status::OK;
314     while (isRunning_ && (bufferConsumerAvailableCount_ > 0)) {
315         std::shared_ptr<AVBuffer> outputBuffer;
316         ret = implConsumer_->AcquireBuffer(outputBuffer);
317         if (ret != Media::Status::OK) {
318             isRunning_.store(false);
319             std::cout << "Consumer AcquireBuffer fail,ret=" << (int32_t)ret << std::endl;
320             break;
321         }
322         if (outputBuffer == nullptr) {
323             isRunning_.store(false);
324             std::cout << "OutputFunc OH_AVBuffer is nullptr" << std::endl;
325             break;
326         }
327         outputFile_->write(reinterpret_cast<char *>(outputBuffer->memory_->GetAddr()),
328             outputBuffer->memory_->GetSize());
329         if (outputBuffer != nullptr &&
330             (outputBuffer->flag_ == AVCODEC_BUFFER_FLAGS_EOS || outputBuffer->memory_->GetSize() == 0)) {
331             std::cout << "out eos" << std::endl;
332             isRunning_.store(false);
333         }
334         implConsumer_->ReleaseBuffer(outputBuffer);
335         bufferConsumerAvailableCount_--;
336     }
337 }
338 
339 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_01, TestSize.Level1)
340 {
341     // lack of correct key
342     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
343     meta->Set<Tag::VIDEO_WIDTH>(DEFAULT_WIDTH);
344     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
345 }
346 
347 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_02, TestSize.Level1)
348 {
349     // correct key input
350     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
351     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
352     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
353     meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_BITRATE);
354     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
355 }
356 
357 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_03, TestSize.Level1)
358 {
359     // correct key input with redundancy key input
360     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
361     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(-1);
362     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
363     meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_BITRATE);
364     meta->Set<Tag::VIDEO_WIDTH>(DEFAULT_WIDTH);
365     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
366 }
367 
368 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_04, TestSize.Level1)
369 {
370     // correct key input with wrong value type input
371     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
372     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
373     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
374     meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_BITRATE);
375     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
376 }
377 
378 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_05, TestSize.Level1)
379 {
380     // correct key input with wrong value type input
381     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
382     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(INVALID_CHANNEL_COUNT);
383     meta->Set<Tag::AUDIO_SAMPLE_RATE>(INVALID_SAMPLE_RATE);
384     meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_BITRATE);
385     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
386 }
387 
388 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_06, TestSize.Level1)
389 {
390     // empty format input
391     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
392     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
393 }
394 
395 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_07, TestSize.Level1)
396 {
397     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
398     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S16LE);
399     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
400 }
401 
402 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_08, TestSize.Level1)
403 {
404     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
405     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S24LE);
406     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
407 }
408 
409 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Configure_09, TestSize.Level1)
410 {
411     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
412     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S32LE);
413     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
414 }
415 
416 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Start_01, TestSize.Level1)
417 {
418     // correct flow 1
419     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
420     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
421 }
422 
423 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Start_02, TestSize.Level1)
424 {
425     // correct flow 2
426     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
427     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
428     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
429     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Start());
430 }
431 
432 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Start_03, TestSize.Level1)
433 {
434     // wrong flow 1
435     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
436     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Start());
437 }
438 
439 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Start_04, TestSize.Level1)
440 {
441     // wrong flow 2
442     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
443     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
444     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
445     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Start());
446 }
447 
448 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Start_05, TestSize.Level1)
449 {
450     // wrong flow 2
451     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
452     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid24Bit());
453 }
454 
455 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Stop_01, TestSize.Level1)
456 {
457     // correct flow 1
458     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
459     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
460     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
461 }
462 
463 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Stop_02, TestSize.Level1)
464 {
465     // correct flow 2
466     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
467     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
468     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
469     meta->Set<Tag::MEDIA_BITRATE>(DEFAULT_BITRATE);
470     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
471     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
472 }
473 
474 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Stop_03, TestSize.Level1)
475 {
476     // correct flow 2
477     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
478     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid24Bit());
479     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
480 }
481 
482 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Flush_01, TestSize.Level1)
483 {
484     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
485     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
486     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Flush());
487 }
488 
489 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Flush_02, TestSize.Level1)
490 {
491     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
492     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
493     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
494     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Release());
495     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Flush());
496 }
497 
498 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Reset_01, TestSize.Level1)
499 {
500     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
501     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
502     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
503     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Reset());
504 }
505 
506 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Reset_02, TestSize.Level1)
507 {
508     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
509     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
510     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
511     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
512     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Reset());
513 }
514 
515 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Reset_03, TestSize.Level1)
516 {
517     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
518     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
519     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Reset());
520 }
521 
522 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Release_01, TestSize.Level1)
523 {
524     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
525     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
526     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Stop());
527     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Release());
528 }
529 
530 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Release_02, TestSize.Level1)
531 {
532     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
533     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
534     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
535     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Configure(meta));
536     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Release());
537 }
538 
539 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_Release_03, TestSize.Level1)
540 {
541     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
542     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
543     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->Release());
544 }
545 
546 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_SetParameter_01, TestSize.Level1)
547 {
548     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
549     meta->Set<Tag::AUDIO_CHANNEL_COUNT>(MAX_CHANNEL_COUNT);
550     meta->Set<Tag::AUDIO_SAMPLE_RATE>(DEFAULT_SAMPLE_RATE);
551     int32_t ret = audiocodec_->SetParameter(meta);
552     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, ret);
553 }
554 
555 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_SetParameter_02, TestSize.Level1)
556 {
557     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
558     meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Media::Plugins::AudioSampleFormat::SAMPLE_S24LE);
559     int32_t ret = audiocodec_->SetParameter(meta);
560     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, ret);
561 }
562 
563 HWTEST_F(ADecVividInnerDemoApiEleven, audioDecoder_Vivid_GetOutputmeta01, TestSize.Level1)
564 {
565     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateVividCodec());
566     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProcessVivid());
567     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, audiocodec_->GetOutputFormat(meta));
568 }
569 } // namespace MediaAVCodec
570 } // namespace OHOS