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
16 #include "image_effect_inner_unittest.h"
17
18 #include "efilter_factory.h"
19 #include "brightness_efilter.h"
20 #include "contrast_efilter.h"
21 #include "test_common.h"
22 #include "external_loader.h"
23 #include "crop_efilter.h"
24 #include "mock_picture.h"
25 #include "mock_producer_surface.h"
26
27 using namespace testing::ext;
28 using ::testing::_;
29 using ::testing::A;
30 using ::testing::InSequence;
31 using ::testing::Mock;
32 using ::testing::Return;
33 using namespace OHOS::Media::Effect::Test;
34
35 namespace {
36 constexpr uint32_t CROP_FACTOR = 2;
37 }
38
39 namespace OHOS {
40 namespace Media {
41 namespace Effect {
42 class FakeEFilter : public EFilter {
43 public:
FakeEFilter(const std::string & name)44 explicit FakeEFilter(const std::string &name) : EFilter(name) {}
~FakeEFilter()45 ~FakeEFilter() {}
46
Render(EffectBuffer * buffer,std::shared_ptr<EffectContext> & context)47 ErrorCode Render(EffectBuffer *buffer, std::shared_ptr<EffectContext> &context) override
48 {
49 return PushData(buffer, context);
50 }
51
Render(EffectBuffer * src,EffectBuffer * dst,std::shared_ptr<EffectContext> & context)52 ErrorCode Render(EffectBuffer *src, EffectBuffer *dst, std::shared_ptr<EffectContext> &context) override
53 {
54 return ErrorCode::SUCCESS;
55 }
56
Restore(const EffectJsonPtr & values)57 ErrorCode Restore(const EffectJsonPtr &values) override
58 {
59 return ErrorCode::SUCCESS;
60 }
61 };
62
63 class FakeImageEffect : public ImageEffect {
64 public:
FakeImageEffect()65 explicit FakeImageEffect() : ImageEffect("ImageEffect") {}
~FakeImageEffect()66 ~FakeImageEffect() {}
67 };
68
SetUpTestCase()69 void ImageEffectInnerUnittest::SetUpTestCase() {}
70
TearDownTestCase()71 void ImageEffectInnerUnittest::TearDownTestCase() {}
72
SetUp()73 void ImageEffectInnerUnittest::SetUp()
74 {
75 ExternLoader::Instance()->InitExt();
76 EFilterFactory::Instance()->functions_.clear();
77 EFilterFactory::Instance()->RegisterEFilter<BrightnessEFilter>(BRIGHTNESS_EFILTER);
78 EFilterFactory::Instance()->RegisterEFilter<ContrastEFilter>(CONTRAST_EFILTER);
79 EFilterFactory::Instance()->RegisterEFilter<CropEFilter>(CROP_EFILTER);
80 EFilterFactory::Instance()->delegates_.clear();
81 mockPixelMap_ = new MockPixelMap();
82 imageEffect_ = new FakeImageEffect();
83 efilter_ = new FakeEFilter(BRIGHTNESS_EFILTER);
84
85 std::shared_ptr<BufferInfo> info = std::make_unique<BufferInfo>();
86 info->width_ = mockPixelMap_->GetWidth();
87 info->height_ = mockPixelMap_->GetHeight();
88 info->rowStride_ = mockPixelMap_->GetRowStride();
89 info->len_ = mockPixelMap_->GetHeight() * mockPixelMap_->GetRowStride();
90 info->formatType_ = IEffectFormat::RGBA8888;
91 std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
92 extraInfo->dataType = DataType::PIXEL_MAP;
93 extraInfo->bufferType = BufferType::HEAP_MEMORY;
94 extraInfo->pixelMap = mockPixelMap_;
95 extraInfo->surfaceBuffer = nullptr;
96 effectBuffer_ = new EffectBuffer(info, (void *)mockPixelMap_->GetPixels(), extraInfo);
97 }
98
TearDown()99 void ImageEffectInnerUnittest::TearDown()
100 {
101 delete(mockPixelMap_);
102 mockPixelMap_ = nullptr;
103 Mock::AllowLeak(imageEffect_);
104 Mock::AllowLeak(efilter_);
105 delete(effectBuffer_);
106 effectBuffer_ = nullptr;
107 }
108
109 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_001, TestSize.Level1)
110 {
111 InSequence s;
112 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
113 imageEffect_->AddEFilter(efilter);
114 Plugin::Any value = 200.f;
115 efilter->SetValue(KEY_FILTER_INTENSITY, value);
116 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
117 ASSERT_EQ(result, ErrorCode::SUCCESS);
118 result = imageEffect_->Start();
119 ASSERT_EQ(result, ErrorCode::SUCCESS);
120 }
121
122 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_002, TestSize.Level1)
123 {
124 InSequence s;
125 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
126 Plugin::Any value = 200.f;
127 efilter->SetValue(KEY_FILTER_INTENSITY, value);
128 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
129 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
130
131 ErrorCode result = efilter->Render(src, src);
132 ASSERT_EQ(result, ErrorCode::SUCCESS);
133 }
134
135 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_003, TestSize.Level1)
136 {
137 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
138 imageEffect_->AddEFilter(efilter);
139 Plugin::Any value = 100.f;
140 efilter->SetValue(KEY_FILTER_INTENSITY, value);
141 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
142 ASSERT_EQ(result, ErrorCode::SUCCESS);
143 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
144 ASSERT_EQ(result, ErrorCode::SUCCESS);
145 result = imageEffect_->Start();
146 ASSERT_EQ(result, ErrorCode::SUCCESS);
147 }
148
149 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_004, TestSize.Level1)
150 {
151 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
152 imageEffect_->AddEFilter(efilter);
153 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
154 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
155 uint32_t areaInfo[] = { 0, 0, x1, y1};
156 Plugin::Any value = static_cast<void *>(areaInfo);
157 efilter->SetValue(KEY_FILTER_REGION, value);
158 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
159 ASSERT_EQ(result, ErrorCode::SUCCESS);
160 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
161 ASSERT_EQ(result, ErrorCode::SUCCESS);
162 result = imageEffect_->Start();
163 ASSERT_EQ(result, ErrorCode::SUCCESS);
164 }
165
166 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_005, TestSize.Level1)
167 {
168 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
169 imageEffect_->AddEFilter(efilter);
170 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
171 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
172 uint32_t areaInfo[] = { 0, 0, x1, y1};
173 Plugin::Any value = static_cast<void *>(areaInfo);
174 efilter->SetValue(KEY_FILTER_REGION, value);
175 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
176 ASSERT_EQ(result, ErrorCode::SUCCESS);
177 result = imageEffect_->Start();
178 ASSERT_EQ(result, ErrorCode::SUCCESS);
179 }
180
181 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_006, TestSize.Level1)
182 {
183 DataInfo dataInfo;
184 std::shared_ptr<BufferInfo> bufferInfo = std::make_unique<BufferInfo>();
185 std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
186 std::shared_ptr<EffectBuffer> effectBuffer = std::make_unique<EffectBuffer>(bufferInfo, nullptr, extraInfo);
187 std::shared_ptr<ImageEffect> imageEffect = std::make_unique<ImageEffect>();
188
189 dataInfo.dataType_ = DataType::PATH;
190 dataInfo.path_ = "path";
191 IEffectFormat format = IEffectFormat::RGBA8888;
192 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, true, format), ErrorCode::SUCCESS);
193
194 dataInfo.dataType_ = DataType::NATIVE_WINDOW;
195 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::SUCCESS);
196
197 dataInfo.dataType_ = DataType::UNKNOWN;
198 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::ERR_NO_DATA);
199
200 dataInfo.dataType_ = static_cast<DataType>(100);
201 EXPECT_EQ(imageEffect->ParseDataInfo(dataInfo, effectBuffer, false, format), ErrorCode::ERR_UNSUPPORTED_DATA_TYPE);
202 }
203
204 HWTEST_F(ImageEffectInnerUnittest, SetOutputPicture_001, TestSize.Level1)
205 {
206 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
207 ErrorCode result = imageEffect_->SetOutputPicture(nullptr);
208 ASSERT_EQ(result, ErrorCode::SUCCESS);
209 }
210
211 HWTEST_F(ImageEffectInnerUnittest, SetOutputPicture_002, TestSize.Level1)
212 {
213 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
214 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>();
215 ErrorCode result = imageEffect_->SetOutputPicture(picture.get());
216 ASSERT_EQ(result, ErrorCode::SUCCESS);
217 }
218
219 HWTEST_F(ImageEffectInnerUnittest, SetInputPicture_001, TestSize.Level1)
220 {
221 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
222 ErrorCode result = imageEffect_->SetInputPicture(nullptr);
223 ASSERT_NE(result, ErrorCode::SUCCESS);
224 }
225
226 HWTEST_F(ImageEffectInnerUnittest, SetInputPicture_002, TestSize.Level1)
227 {
228 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
229 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>();
230 ErrorCode result = imageEffect_->SetInputPicture(picture.get());
231 ASSERT_EQ(result, ErrorCode::SUCCESS);
232 }
233
234 HWTEST_F(ImageEffectInnerUnittest, SetExtraInfo_001, TestSize.Level1)
235 {
236 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
237 ErrorCode result = imageEffect_->SetExtraInfo(nullptr);
238 ASSERT_EQ(result, ErrorCode::SUCCESS);
239 }
240
241 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurfaceBuffer_001, TestSize.Level1)
242 {
243 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
244 ErrorCode result = imageEffect_->SetOutputSurfaceBuffer(nullptr);
245 ASSERT_EQ(result, ErrorCode::SUCCESS);
246 }
247
248 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurfaceBuffer_002, TestSize.Level1)
249 {
250 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
251 sptr<SurfaceBuffer> surfaceBuffer;
252 MockProducerSurface::AllocDmaMemory(surfaceBuffer);
253 ErrorCode result = imageEffect_->SetOutputSurfaceBuffer(surfaceBuffer);
254 ASSERT_EQ(result, ErrorCode::SUCCESS);
255 MockProducerSurface::ReleaseDmaBuffer(surfaceBuffer);
256 }
257
258 HWTEST_F(ImageEffectInnerUnittest, SetInputSurfaceBuffer_001, TestSize.Level1)
259 {
260 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
261 ErrorCode result = imageEffect_->SetInputSurfaceBuffer(nullptr);
262 ASSERT_NE(result, ErrorCode::SUCCESS);
263 }
264
265 HWTEST_F(ImageEffectInnerUnittest, SetInputSurfaceBuffer_002, TestSize.Level1)
266 {
267 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
268 sptr<SurfaceBuffer> surfaceBuffer;
269 MockProducerSurface::AllocDmaMemory(surfaceBuffer);
270 ErrorCode result = imageEffect_->SetInputSurfaceBuffer(surfaceBuffer);
271 ASSERT_EQ(result, ErrorCode::SUCCESS);
272 MockProducerSurface::ReleaseDmaBuffer(surfaceBuffer);
273 }
274
275 HWTEST_F(ImageEffectInnerUnittest, SetOutputSurface_001, TestSize.Level1)
276 {
277 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
278 sptr<Surface> surface = nullptr;
279 ErrorCode result = imageEffect_->SetOutputSurface(surface);
280 ASSERT_NE(result, ErrorCode::SUCCESS);
281 }
282
283 HWTEST_F(ImageEffectInnerUnittest, SetOutputPixelMap_001, TestSize.Level1)
284 {
285 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
286 ErrorCode result = imageEffect_->SetOutputPixelMap(nullptr);
287 ASSERT_EQ(result, ErrorCode::SUCCESS);
288 }
289
290 HWTEST_F(ImageEffectInnerUnittest, SetInputPixelMap_001, TestSize.Level1)
291 {
292 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
293 ErrorCode result = imageEffect_->SetInputPixelMap(nullptr);
294 ASSERT_NE(result, ErrorCode::SUCCESS);
295 }
296
297 HWTEST_F(ImageEffectInnerUnittest, SetOutNativeWindow_001, TestSize.Level1)
298 {
299 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
300 ErrorCode result = imageEffect_->SetOutNativeWindow(nullptr);
301 ASSERT_NE(result, ErrorCode::SUCCESS);
302 }
303
304 HWTEST_F(ImageEffectInnerUnittest, SetOutNativeWindow_002, TestSize.Level1)
305 {
306 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
307 OHNativeWindow *nativeWindow = new OHNativeWindow();
308 nativeWindow->surface = nullptr;
309 ErrorCode result = imageEffect_->SetOutNativeWindow(nativeWindow);
310 ASSERT_NE(result, ErrorCode::SUCCESS);
311 delete nativeWindow;
312 nativeWindow = nullptr;
313 }
314
315 HWTEST_F(ImageEffectInnerUnittest, ReplaceEFilter_001, TestSize.Level1)
316 {
317 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
318 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
319 imageEffect_->AddEFilter(efilter);
320 std::shared_ptr<EFilter> efilter2 = EFilterFactory::Instance()->Create(CONTRAST_EFILTER);
321
322 ErrorCode result = imageEffect_->ReplaceEFilter(efilter2, -1);
323 ASSERT_NE(result, ErrorCode::SUCCESS);
324
325 result = imageEffect_->ReplaceEFilter(efilter2, 0);
326 ASSERT_EQ(result, ErrorCode::SUCCESS);
327 }
328
329 HWTEST_F(ImageEffectInnerUnittest, SetInputUri_001, TestSize.Level1)
330 {
331 std::string g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg");
332 std::string g_notJpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.png");
333 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
334
335 ErrorCode result = imageEffect_->SetInputUri(g_notJpgUri);
336 EXPECT_NE(result, ErrorCode::SUCCESS);
337
338 result = imageEffect_->SetInputUri(g_jpgUri);
339 EXPECT_EQ(result, ErrorCode::SUCCESS);
340 }
341
342 HWTEST_F(ImageEffectInnerUnittest, SetOutputUri_001, TestSize.Level1)
343 {
344 std::string g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg");
345 std::string g_notJpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.png");
346 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
347
348 ErrorCode result = imageEffect_->SetOutputUri("");
349 EXPECT_EQ(result, ErrorCode::SUCCESS);
350
351 result = imageEffect_->SetOutputUri(g_notJpgUri);
352 EXPECT_NE(result, ErrorCode::SUCCESS);
353
354 result = imageEffect_->SetOutputUri(g_jpgUri);
355 EXPECT_EQ(result, ErrorCode::SUCCESS);
356 }
357
358 HWTEST_F(ImageEffectInnerUnittest, SetInputPath_001, TestSize.Level1)
359 {
360 std::string g_jpgPath = std::string("/data/test/resource/image_effect_1k_test1.jpg");
361 std::string g_notJpgPath = std::string("/data/test/resource/image_effect_1k_test1.png");
362 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
363
364 ErrorCode result = imageEffect_->SetInputPath(g_notJpgPath);
365 EXPECT_NE(result, ErrorCode::SUCCESS);
366
367 result = imageEffect_->SetInputPath(g_jpgPath);
368 EXPECT_EQ(result, ErrorCode::SUCCESS);
369 }
370
371 HWTEST_F(ImageEffectInnerUnittest, SetOutputPath_001, TestSize.Level1)
372 {
373 std::string g_jpgPath = std::string("/data/test/resource/image_effect_1k_test1.jpg");
374 std::string g_notJpgPath = std::string("/data/test/resource/image_effect_1k_test1.png");
375 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
376
377 ErrorCode result = imageEffect_->SetOutputPath("");
378 EXPECT_EQ(result, ErrorCode::SUCCESS);
379
380 result = imageEffect_->SetOutputPath(g_notJpgPath);
381 EXPECT_NE(result, ErrorCode::SUCCESS);
382
383 result = imageEffect_->SetOutputPath(g_jpgPath);
384 EXPECT_EQ(result, ErrorCode::SUCCESS);
385 }
386
387 HWTEST_F(ImageEffectInnerUnittest, Save_001, TestSize.Level1)
388 {
389 std::shared_ptr<ImageEffect> imageEffect_ = std::make_unique<ImageEffect>(IMAGE_EFFECT_NAME);
390 EffectJsonPtr jsonValues = EffectJsonHelper::CreateObject();
391 ErrorCode result = imageEffect_->Save(jsonValues);
392 ASSERT_EQ(result, ErrorCode::SUCCESS);
393 }
394 } // namespace Effect
395 } // namespace Media
396 } // namespace OHOS
397
