1 /*
2 * Copyright (C) 2025 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 <gtest/gtest.h>
16 #include <fstream>
17 #include "plugin/plugin_manager_v2.h"
18 #include "plugin/codec_plugin.h"
19 #include "avcodec_codec_name.h"
20 #include "ffmpeg_converter.h"
21
22 #define BUFFER_FLAG_EOS 1
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS::Media;
27 using namespace OHOS::Media::Plugins;
28
29 namespace OHOS {
30 namespace Media {
31 namespace Plugins {
32 constexpr int32_t FLAC_CHANNELS = 2;
33 constexpr int32_t FLAC_BIT_RATE = 32000;
34 constexpr int32_t COMPLIANCE_LEVEL = 2;
35 constexpr int32_t FLAC_ENCODER_SAMPLE_RATE = 32000;
36 constexpr int32_t ONE_FRAME_SIZE = 64000;
37
38 class FfmpegBaseCodec : public testing::Test, public DataCallback {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp() override;
43 void TearDown() override;
44
OnInputBufferDone(const shared_ptr<Media::AVBuffer> & inputBuffer)45 void OnInputBufferDone(const shared_ptr<Media::AVBuffer> &inputBuffer) override
46 {
47 (void)inputBuffer;
48 std::shared_ptr<Meta> para = std::make_shared<Meta>();
49 // for mutex test
50 flacDec_->GetParameter(para);
51 }
52
OnOutputBufferDone(const shared_ptr<Media::AVBuffer> & outputBuffer)53 void OnOutputBufferDone(const shared_ptr<Media::AVBuffer> &outputBuffer) override
54 {
55 (void)outputBuffer;
56 std::shared_ptr<Meta> para = std::make_shared<Meta>();
57 // for mutex test
58 flacDec_->GetParameter(para);
59 }
60
OnEvent(const shared_ptr<Plugins::PluginEvent> event)61 void OnEvent(const shared_ptr<Plugins::PluginEvent> event) override
62 {
63 (void)event;
64 }
65
66 protected:
67 shared_ptr<Media::Meta> meta_ = nullptr;
68 shared_ptr<CodecPlugin> flacEnc_ = nullptr;
69 shared_ptr<CodecPlugin> flacDec_ = nullptr;
70 };
71
SetUpTestCase(void)72 void FfmpegBaseCodec::SetUpTestCase(void)
73 {
74 cout << "[SetUpTestCase]: " << endl;
75 }
76
TearDownTestCase(void)77 void FfmpegBaseCodec::TearDownTestCase(void)
78 {
79 cout << "[TearDownTestCase]: " << endl;
80 }
81
SetUp(void)82 void FfmpegBaseCodec::SetUp(void)
83 {
84 auto encPlugin = PluginManagerV2::Instance().CreatePluginByName("OH.Media.Codec.Encoder.Audio.Flac");
85 auto decPlugin = PluginManagerV2::Instance().CreatePluginByName("OH.Media.Codec.Decoder.Audio.Flac");
86 if (encPlugin == nullptr) {
87 cout << "not support flacEnc" << endl;
88 return;
89 }
90 if (decPlugin == nullptr) {
91 cout << "not support flacDec" << endl;
92 return;
93 }
94 flacEnc_ = reinterpret_pointer_cast<CodecPlugin>(encPlugin);
95 flacDec_ = reinterpret_pointer_cast<CodecPlugin>(decPlugin);
96 meta_ = make_shared<Media::Meta>();
97 }
98
TearDown(void)99 void FfmpegBaseCodec::TearDown(void)
100 {
101 if (flacEnc_ != nullptr) {
102 flacEnc_ = nullptr;
103 }
104 if (flacDec_ != nullptr) {
105 flacDec_ = nullptr;
106 }
107 }
108
109 HWTEST_F(FfmpegBaseCodec, FlacCheckFormat_001, TestSize.Level1)
110 {
111 EXPECT_EQ(Status::OK, flacEnc_->Init());
112 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_ENCODER_SAMPLE_RATE);
113 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
114 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
115 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
116 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
117 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
118 EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, flacEnc_->SetParameter(meta_));
119 }
120
121 HWTEST_F(FfmpegBaseCodec, FlacCheckFormat_002, TestSize.Level1)
122 {
123 EXPECT_EQ(Status::OK, flacEnc_->Init());
124 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(FLAC_CHANNELS);
125 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
126 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
127 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
128 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
129 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
130 EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, flacEnc_->SetParameter(meta_));
131 }
132
133 HWTEST_F(FfmpegBaseCodec, ProcessSendData_001, TestSize.Level1)
134 {
135 EXPECT_EQ(Status::OK, flacEnc_->Init());
136 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(FLAC_CHANNELS);
137 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_ENCODER_SAMPLE_RATE);
138 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
139 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
140 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
141 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
142 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
143 EXPECT_EQ(Status::OK, flacEnc_->SetParameter(meta_));
144 EXPECT_EQ(Status::OK, flacEnc_->Start());
145 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
146 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, ONE_FRAME_SIZE);
147 inputBuffer->memory_ = nullptr;
148 EXPECT_NE(Status::OK, flacEnc_->QueueInputBuffer(inputBuffer));
149 }
150
151 HWTEST_F(FfmpegBaseCodec, ProcessSendData_002, TestSize.Level1)
152 {
153 EXPECT_EQ(Status::OK, flacEnc_->Init());
154 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(FLAC_CHANNELS);
155 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_ENCODER_SAMPLE_RATE);
156 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
157 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
158 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
159 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
160 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
161 EXPECT_EQ(Status::OK, flacEnc_->SetParameter(meta_));
162 EXPECT_EQ(Status::OK, flacEnc_->Start());
163 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
164 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, ONE_FRAME_SIZE);
165 inputBuffer->memory_->SetSize(ONE_FRAME_SIZE);
166 inputBuffer->meta_ = nullptr;
167 EXPECT_NE(Status::OK, flacEnc_->QueueInputBuffer(inputBuffer));
168 }
169
170 HWTEST_F(FfmpegBaseCodec, ProcessSendData_003, TestSize.Level1)
171 {
172 EXPECT_EQ(Status::OK, flacEnc_->Init());
173 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(FLAC_CHANNELS);
174 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_ENCODER_SAMPLE_RATE);
175 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
176 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
177 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
178 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
179 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
180 EXPECT_EQ(Status::OK, flacEnc_->SetParameter(meta_));
181 EXPECT_EQ(Status::OK, flacEnc_->Start());
182 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
183 shared_ptr<AVBuffer> inputBuffer = AVBuffer::CreateAVBuffer(avAllocator, ONE_FRAME_SIZE);
184 inputBuffer->memory_->SetSize(1600); // valid size
185 inputBuffer->meta_ = nullptr;
186 inputBuffer->flag_ = BUFFER_FLAG_EOS;
187 EXPECT_NE(Status::OK, flacEnc_->QueueInputBuffer(inputBuffer));
188 }
189
190 HWTEST_F(FfmpegBaseCodec, ProcessReceiveData_001, TestSize.Level1)
191 {
192 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
193 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, ONE_FRAME_SIZE);
194 outputBuffer = nullptr;
195 EXPECT_NE(Status::OK, flacEnc_->QueueOutputBuffer(outputBuffer));
196 }
197
198 HWTEST_F(FfmpegBaseCodec, ProcessReceiveData_002, TestSize.Level1)
199 {
200 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
201 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, ONE_FRAME_SIZE);
202 EXPECT_EQ(Status::OK, flacEnc_->Reset());
203 EXPECT_NE(Status::OK, flacEnc_->QueueOutputBuffer(outputBuffer));
204 }
205
206 HWTEST_F(FfmpegBaseCodec, ReceivePacketSucc_001, TestSize.Level1)
207 {
208 meta_->Set<Tag::AUDIO_CHANNEL_COUNT>(FLAC_CHANNELS);
209 meta_->Set<Tag::AUDIO_SAMPLE_RATE>(FLAC_ENCODER_SAMPLE_RATE);
210 meta_->Set<Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::SAMPLE_S16LE);
211 meta_->Set<Tag::MEDIA_BITRATE>(FLAC_BIT_RATE);
212 meta_->Set<Tag::AUDIO_BITS_PER_CODED_SAMPLE>(AudioSampleFormat::SAMPLE_S16LE);
213 meta_->Set<Tag::AUDIO_FLAC_COMPLIANCE_LEVEL>(COMPLIANCE_LEVEL);
214 meta_->Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
215 EXPECT_EQ(Status::OK, flacEnc_->SetParameter(meta_));
216
217 auto avAllocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
218 shared_ptr<AVBuffer> outputBuffer = AVBuffer::CreateAVBuffer(avAllocator, 640);
219 outputBuffer->memory_->SetSize(640);
220 EXPECT_NE(Status::OK, flacEnc_->QueueOutputBuffer(outputBuffer));
221 }
222
223 HWTEST_F(FfmpegBaseCodec, Stop_001, TestSize.Level1)
224 {
225 EXPECT_EQ(Status::OK, flacEnc_->Stop()); // set outBuffer_ nullptr
226 EXPECT_EQ(Status::OK, flacEnc_->Stop());
227 }
228
229 HWTEST_F(FfmpegBaseCodec, Stop_002, TestSize.Level1)
230 {
231 EXPECT_EQ(Status::OK, flacEnc_->Reset()); // set avCodecContext_ nullptr
232 EXPECT_EQ(Status::OK, flacEnc_->Stop());
233 }
234 }
235 }
236 }