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 expect in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <memory>
17 #include "avcodec_errors.h"
18 #include "codeclist_core.h"
19 #include "codec_server_coverage_unit_test.h"
20 #include "meta/meta_key.h"
21 #include "media_description.h"
22 #define EXPECT_CALL_GET_HCODEC_CAPS_MOCK \
23 EXPECT_CALL(*codecBaseMock_, GetHCapabilityList).Times(AtLeast(1)).WillRepeatedly
24 #define EXPECT_CALL_GET_FCODEC_CAPS_MOCK \
25 EXPECT_CALL(*codecBaseMock_, GetFCapabilityList).Times(AtLeast(1)).WillRepeatedly
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::Media;
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace MediaAVCodec {
CreateCodecByMime()34 void CodecServerUnitTest::CreateCodecByMime()
35 {
36 std::string codecName = "video.H.Encoder.Name.00";
37 std::string codecMime = CODEC_MIME_MOCK_00;
38
39 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
40 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
41 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
42 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
43 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
44 .Times(1)
45 .WillOnce(Return(std::make_shared<CodecBase>()));
46 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
47 .Times(1)
48 .WillOnce(Return(AVCS_ERR_OK));
49 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
50 .Times(1)
51 .WillOnce(Return(AVCS_ERR_OK));
52
53 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, true, codecMime,
54 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
55 EXPECT_EQ(ret, AVCS_ERR_OK);
56 }
57
58 /**
59 * @tc.name: PreparePostProcessing_Invalid_Test_001
60 * @tc.desc: postProcessing controller is nullptr
61 */
62 HWTEST_F(CodecServerUnitTest, PreparePostProcessing_Invalid_Test_001, TestSize.Level1)
63 {
64 CreateCodecByMime();
65 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
66 int32_t ret = server_->PreparePostProcessing();
67 EXPECT_NE(ret, AVCS_ERR_OK);
68 }
69
70 /**
71 * @tc.name: PreparePostProcessing_Valid_Test_002
72 * @tc.desc: codec PreparePostProcessing
73 */
74 HWTEST_F(CodecServerUnitTest, PreparePostProcessing_Valid_Test_002, TestSize.Level1)
75 {
76 CreateCodecByMime();
77 server_->postProcessing_ = nullptr;
78 int32_t ret = server_->PreparePostProcessing();
79 EXPECT_EQ(ret, AVCS_ERR_OK);
80 }
81
82 /**
83 * @tc.name: PostProcessingOnError_Valid_Test_001
84 * @tc.desc: videoCb_ is not nullptr
85 */
86 HWTEST_F(CodecServerUnitTest, PostProcessingOnError_Valid_Test_001, TestSize.Level1)
87 {
88 CreateCodecByMime();
89 auto mock = std::make_shared<MediaCodecCallbackMock>();
90 server_->videoCb_ = mock;
91 int32_t errorCode = AVCS_ERR_OK;
92 server_->PostProcessingOnError(errorCode);
93 }
94
95 /**
96 * @tc.name: PostProcessingOnOutputBufferAvailable_Valid_Test_001
97 * @tc.desc: videoCb_ is not nullptr
98 */
99 HWTEST_F(CodecServerUnitTest, PostProcessingOnOutputBufferAvailable_Valid_Test_001, TestSize.Level1)
100 {
101 CreateCodecByMime();
102 auto mock = std::make_shared<MediaCodecCallbackMock>();
103 server_->videoCb_ = mock;
104 int32_t index = 1;
105 int32_t flag = 1;
106 server_->PostProcessingOnOutputBufferAvailable(index, flag);
107 }
108
109 /**
110 * @tc.name: PostProcessingOnOutputBufferAvailable_Valid_Test_002
111 * @tc.desc: videoCb_ is nullptr
112 */
113 HWTEST_F(CodecServerUnitTest, PostProcessingOnOutputBufferAvailable_Valid_Test_002, TestSize.Level1)
114 {
115 CreateCodecByMime();
116 server_->videoCb_ = nullptr;
117 int32_t index = 1;
118 int32_t flag = 1;
119 server_->PostProcessingOnOutputBufferAvailable(index, flag);
120 }
121
122 /**
123 * @tc.name: StartPostProcessing_Invalid_Test_001
124 * @tc.desc: postProcessing controller is nullptr
125 */
126 HWTEST_F(CodecServerUnitTest, StartPostProcessing_Invalid_Test_001, TestSize.Level1)
127 {
128 CreateCodecByMime();
129 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
130 int32_t ret = server_->StartPostProcessing();
131 EXPECT_NE(ret, AVCS_ERR_OK);
132 }
133
134 /**
135 * @tc.name: StopPostProcessing_inValid_Test_001
136 * @tc.desc: postProcessing controller is nullptr
137 */
138 HWTEST_F(CodecServerUnitTest, StopPostProcessing_inValid_Test_001, TestSize.Level1)
139 {
140 CreateCodecByMime();
141 server_->postProcessingTask_ = nullptr;
142 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
143 int32_t ret = server_->StopPostProcessing();
144 EXPECT_NE(ret, AVCS_ERR_OK);
145 }
146
147 /**
148 * @tc.name: StopPostProcessing_Valid_Test_002
149 * @tc.desc: codec StopPostProcessing
150 */
151 HWTEST_F(CodecServerUnitTest, StopPostProcessing_Valid_Test_002, TestSize.Level1)
152 {
153 CreateCodecByMime();
154 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
155 auto postprocessingBufferInfoQueue =
156 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
157 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
158 server_->postProcessing_ = nullptr;
159 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
160 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
161 server_->postProcessingOutputBufferInfoQueue_ = postprocessingBufferInfoQueue;
162 int32_t ret = server_->StopPostProcessing();
163 EXPECT_EQ(ret, AVCS_ERR_OK);
164 }
165
166 /**
167 * @tc.name: FlushPostProcessing_Invalid_Test_001
168 * @tc.desc: postProcessing flush failed
169 */
170 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Invalid_Test_001, TestSize.Level1)
171 {
172 CreateCodecByMime();
173 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
174 auto postprocessingBufferInfoQueue =
175 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
176 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
177 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
178 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
179 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
180 server_->postProcessingOutputBufferInfoQueue_ = postprocessingBufferInfoQueue;
181 int32_t ret = server_->FlushPostProcessing();
182 EXPECT_NE(ret, AVCS_ERR_OK);
183 }
184
185 /**
186 * @tc.name: FlushPostProcessing_Invalid_Test_002
187 * @tc.desc: postProcessing flush failed
188 */
189 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Invalid_Test_002, TestSize.Level1)
190 {
191 CreateCodecByMime();
192 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
193 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
194 server_->postProcessingTask_ = nullptr;
195 server_->decodedBufferInfoQueue_ = nullptr;
196 server_->postProcessingInputBufferInfoQueue_ = nullptr;
197 server_->postProcessingOutputBufferInfoQueue_ = nullptr;
198 int32_t ret = server_->FlushPostProcessing();
199 EXPECT_NE(ret, AVCS_ERR_OK);
200 }
201
202 /**
203 * @tc.name: FlushPostProcessing_Valid_Test_002
204 * @tc.desc: codec FlushPostProcessing
205 */
206 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Valid_Test_002, TestSize.Level1)
207 {
208 CreateCodecByMime();
209 server_->postProcessing_ = nullptr;
210 int32_t ret = server_->FlushPostProcessing();
211 EXPECT_EQ(ret, AVCS_ERR_OK);
212 }
213
214 /**
215 * @tc.name: ResetPostProcessing_Valid_Test_001
216 * @tc.desc: codec ResetPostProcessing
217 */
218 HWTEST_F(CodecServerUnitTest, ResetPostProcessing_Valid_Test_001, TestSize.Level1)
219 {
220 CreateCodecByMime();
221 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
222 int32_t ret = server_->ResetPostProcessing();
223 EXPECT_EQ(ret, AVCS_ERR_OK);
224 }
225
226 /**
227 * @tc.name: StartPostProcessingTask_Valid_Test_001
228 * @tc.desc: codec StartPostProcessingTask
229 */
230 HWTEST_F(CodecServerUnitTest, StartPostProcessingTask_Valid_Test_001, TestSize.Level1)
231 {
232 CreateCodecByMime();
233 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
234 auto postprocessingBufferInfoQueue =
235 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
236 server_->postProcessingTask_ = nullptr;
237 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
238 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
239 server_->postProcessingOutputBufferInfoQueue_ = postprocessingBufferInfoQueue;
240 server_->StartPostProcessingTask();
241 EXPECT_NE(server_->postProcessingTask_, nullptr);
242 }
243
244 /**
245 * @tc.name: StartPostProcessingTask_Valid_Test_002
246 * @tc.desc: codec StartPostProcessingTask
247 */
248 HWTEST_F(CodecServerUnitTest, StartPostProcessingTask_Valid_Test_002, TestSize.Level1)
249 {
250 CreateCodecByMime();
251 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
252 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
253 server_->decodedBufferInfoQueue_ = nullptr;
254 server_->postProcessingInputBufferInfoQueue_ = nullptr;
255 server_->postProcessingOutputBufferInfoQueue_ = nullptr;
256 server_->StartPostProcessingTask();
257 }
258
259 /**
260 * @tc.name: DeactivatePostProcessingQueue_Valid_Test_001
261 * @tc.desc: codec DeactivatePostProcessingQueue
262 */
263 HWTEST_F(CodecServerUnitTest, DeactivatePostProcessingQueue_Valid_Test_001, TestSize.Level1)
264 {
265 CreateCodecByMime();
266 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
267 auto postprocessingBufferInfoQueue =
268 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
269 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
270 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
271 server_->postProcessingOutputBufferInfoQueue_ = postprocessingBufferInfoQueue;
272 server_->DeactivatePostProcessingQueue();
273 EXPECT_EQ(server_->decodedBufferInfoQueue_->active_, false);
274 EXPECT_EQ(server_->postProcessingInputBufferInfoQueue_->active_, false);
275 EXPECT_EQ(server_->postProcessingOutputBufferInfoQueue_->active_, false);
276 }
277
278 /**
279 * @tc.name: CleanPostProcessingResource_Valid_Test_001
280 * @tc.desc: codec CleanPostProcessingResource
281 */
282 HWTEST_F(CodecServerUnitTest, CleanPostProcessingResource_Valid_Test_001, TestSize.Level1)
283 {
284 CreateCodecByMime();
285 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
286 auto postprocessingBufferInfoQueue =
287 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
288 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
289 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
290 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
291 server_->postProcessingOutputBufferInfoQueue_ = postprocessingBufferInfoQueue;
292 server_->CleanPostProcessingResource();
293 EXPECT_EQ(server_->postProcessingTask_, nullptr);
294 EXPECT_EQ(server_->decodedBufferInfoQueue_, nullptr);
295 EXPECT_EQ(server_->postProcessingInputBufferInfoQueue_, nullptr);
296 EXPECT_EQ(server_->postProcessingOutputBufferInfoQueue_, nullptr);
297 }
298 } // MediaAVCodec
299 } // namespace