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
25 using namespace testing::ext;
26 using ::testing::_;
27 using ::testing::A;
28 using ::testing::InSequence;
29 using ::testing::Mock;
30 using ::testing::Return;
31 using namespace OHOS::Media::Effect::Test;
32
33 namespace {
34 constexpr uint32_t CROP_FACTOR = 2;
35 }
36
37 namespace OHOS {
38 namespace Media {
39 namespace Effect {
40 class FakeEFilter : public EFilter {
41 public:
FakeEFilter(const std::string & name)42 explicit FakeEFilter(const std::string &name) : EFilter(name) {}
~FakeEFilter()43 ~FakeEFilter() {}
44
Render(EffectBuffer * buffer,std::shared_ptr<EffectContext> & context)45 ErrorCode Render(EffectBuffer *buffer, std::shared_ptr<EffectContext> &context) override
46 {
47 return PushData(buffer, context);
48 }
49
Render(EffectBuffer * src,EffectBuffer * dst,std::shared_ptr<EffectContext> & context)50 ErrorCode Render(EffectBuffer *src, EffectBuffer *dst, std::shared_ptr<EffectContext> &context) override
51 {
52 return ErrorCode::SUCCESS;
53 }
54
Restore(const EffectJsonPtr & values)55 ErrorCode Restore(const EffectJsonPtr &values) override
56 {
57 return ErrorCode::SUCCESS;
58 }
59 };
60
61 class FakeImageEffect : public ImageEffect {
62 public:
FakeImageEffect()63 explicit FakeImageEffect() : ImageEffect("ImageEffect") {}
~FakeImageEffect()64 ~FakeImageEffect() {}
65 };
66
SetUpTestCase()67 void ImageEffectInnerUnittest::SetUpTestCase() {}
68
TearDownTestCase()69 void ImageEffectInnerUnittest::TearDownTestCase() {}
70
SetUp()71 void ImageEffectInnerUnittest::SetUp()
72 {
73 ExternLoader::Instance()->InitExt();
74 EFilterFactory::Instance()->functions_.clear();
75 EFilterFactory::Instance()->RegisterEFilter<BrightnessEFilter>(BRIGHTNESS_EFILTER);
76 EFilterFactory::Instance()->RegisterEFilter<ContrastEFilter>(CONTRAST_EFILTER);
77 EFilterFactory::Instance()->RegisterEFilter<CropEFilter>(CROP_EFILTER);
78 EFilterFactory::Instance()->delegates_.clear();
79 mockPixelMap_ = new MockPixelMap();
80 imageEffect_ = new FakeImageEffect();
81 efilter_ = new FakeEFilter(BRIGHTNESS_EFILTER);
82
83 std::shared_ptr<BufferInfo> info = std::make_unique<BufferInfo>();
84 info->width_ = mockPixelMap_->GetWidth();
85 info->height_ = mockPixelMap_->GetHeight();
86 info->rowStride_ = mockPixelMap_->GetRowStride();
87 info->len_ = mockPixelMap_->GetHeight() * mockPixelMap_->GetRowStride();
88 info->formatType_ = IEffectFormat::RGBA8888;
89 std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
90 extraInfo->dataType = DataType::PIXEL_MAP;
91 extraInfo->bufferType = BufferType::HEAP_MEMORY;
92 extraInfo->pixelMap = mockPixelMap_;
93 extraInfo->surfaceBuffer = nullptr;
94 effectBuffer_ = new EffectBuffer(info, (void *)mockPixelMap_->GetPixels(), extraInfo);
95 }
96
TearDown()97 void ImageEffectInnerUnittest::TearDown()
98 {
99 delete(mockPixelMap_);
100 mockPixelMap_ = nullptr;
101 Mock::AllowLeak(imageEffect_);
102 Mock::AllowLeak(efilter_);
103 delete(effectBuffer_);
104 effectBuffer_ = nullptr;
105 }
106
107 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_001, TestSize.Level1)
108 {
109 InSequence s;
110 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
111 imageEffect_->AddEFilter(efilter);
112 Plugin::Any value = 200.f;
113 efilter->SetValue(KEY_FILTER_INTENSITY, value);
114 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
115 ASSERT_EQ(result, ErrorCode::SUCCESS);
116 result = imageEffect_->Start();
117 ASSERT_EQ(result, ErrorCode::SUCCESS);
118 }
119
120 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_002, TestSize.Level1)
121 {
122 InSequence s;
123 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
124 Plugin::Any value = 200.f;
125 efilter->SetValue(KEY_FILTER_INTENSITY, value);
126 std::shared_ptr<EffectBuffer> src = std::make_shared<EffectBuffer>(
127 effectBuffer_->bufferInfo_, effectBuffer_->buffer_, effectBuffer_->extraInfo_);
128
129 ErrorCode result = efilter->Render(src, src);
130 ASSERT_EQ(result, ErrorCode::SUCCESS);
131 }
132
133 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_003, TestSize.Level1)
134 {
135 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
136 imageEffect_->AddEFilter(efilter);
137 Plugin::Any value = 100.f;
138 efilter->SetValue(KEY_FILTER_INTENSITY, value);
139 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
140 ASSERT_EQ(result, ErrorCode::SUCCESS);
141 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
142 ASSERT_EQ(result, ErrorCode::SUCCESS);
143 result = imageEffect_->Start();
144 ASSERT_EQ(result, ErrorCode::SUCCESS);
145 }
146
147 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_004, TestSize.Level1)
148 {
149 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
150 imageEffect_->AddEFilter(efilter);
151 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
152 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
153 uint32_t areaInfo[] = { 0, 0, x1, y1};
154 Plugin::Any value = static_cast<void *>(areaInfo);
155 efilter->SetValue(KEY_FILTER_REGION, value);
156 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
157 ASSERT_EQ(result, ErrorCode::SUCCESS);
158 result = imageEffect_->SetOutputPixelMap(mockPixelMap_);
159 ASSERT_EQ(result, ErrorCode::SUCCESS);
160 result = imageEffect_->Start();
161 ASSERT_EQ(result, ErrorCode::SUCCESS);
162 }
163
164 HWTEST_F(ImageEffectInnerUnittest, Image_effect_unittest_005, TestSize.Level1)
165 {
166 std::shared_ptr<EFilter> efilter = EFilterFactory::Instance()->Create(CROP_EFILTER);
167 imageEffect_->AddEFilter(efilter);
168 uint32_t x1 = static_cast<uint32_t>(mockPixelMap_->GetWidth() / CROP_FACTOR);
169 uint32_t y1 = static_cast<uint32_t>(mockPixelMap_->GetHeight() / CROP_FACTOR);
170 uint32_t areaInfo[] = { 0, 0, x1, y1};
171 Plugin::Any value = static_cast<void *>(areaInfo);
172 efilter->SetValue(KEY_FILTER_REGION, value);
173 ErrorCode result = imageEffect_->SetInputPixelMap(mockPixelMap_);
174 ASSERT_EQ(result, ErrorCode::SUCCESS);
175 result = imageEffect_->Start();
176 ASSERT_EQ(result, ErrorCode::SUCCESS);
177 }
178 } // namespace Effect
179 } // namespace Media
180 } // namespace OHOS