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 "gtest/gtest.h"
17 #include "effect_log.h"
18 #include "image_source.h"
19 #include "pixel_map.h"
20 #include "colorspace_processor.h"
21 #include "colorspace_helper.h"
22 #include "colorspace_manager.h"
23 #include "colorspace_strategy.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Media {
29 namespace Effect {
30 namespace Test {
31
32 static const std::string TAG = "ColorSpaceTest";
33 constexpr char TEST_IMAGE_PATH[] = "/data/test/resource/image_effect_1k_test1.jpg";
34
CreatePictureByPath(std::string imagePath)35 static std::unique_ptr<Picture> CreatePictureByPath(std::string imagePath)
36 {
37 SourceOptions opts;
38 uint32_t errorCode = 0;
39 EFFECT_LOGW("%{public}s create pixelmap by path %{public}s", TAG.c_str(), imagePath.c_str());
40 std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(imagePath, opts, errorCode);
41 CHECK_AND_RETURN_RET_LOG(imageSource != nullptr, nullptr,
42 "CreateImageSource fail! path=%{public}s, errorCode=%{public}d", imagePath.c_str(), errorCode);
43
44 DecodingOptionsForPicture decodingOptions;
45 decodingOptions.desireAuxiliaryPictures.insert(AuxiliaryPictureType::GAINMAP);
46 std::unique_ptr<Picture> picture = imageSource->CreatePicture(decodingOptions, errorCode);
47 CHECK_AND_RETURN_RET_LOG(picture != nullptr, nullptr,
48 "CreatePicture fail! path=%{public}s, errorCode=%{public}d", imagePath.c_str(), errorCode);
49
50 return picture;
51 }
52
CreateEffectBufferByPicture(Picture * picture)53 static std::shared_ptr<EffectBuffer> CreateEffectBufferByPicture(Picture* picture)
54 {
55 if (picture == nullptr) {
56 return nullptr;
57 }
58
59 std::shared_ptr<PixelMap> pixelMap = picture->GetMainPixel();
60 if (pixelMap == nullptr) {
61 return nullptr;
62 }
63
64 std::shared_ptr<BufferInfo> info = std::make_shared<BufferInfo>();
65 info->width_ = pixelMap->GetWidth();
66 info->height_ = pixelMap->GetHeight();
67 info->rowStride_ = pixelMap->GetRowStride();
68 info->len_ = info->rowStride_ * info->height_;
69 info->formatType_ = IEffectFormat::RGBA8888;
70 info->surfaceBuffer_ = nullptr;
71 uint8_t *pixels = const_cast<uint8_t *>(pixelMap->GetPixels());
72 void *addr = static_cast<void *>(pixels);
73 info->pixelMap_ = pixelMap.get();
74
75 std::shared_ptr<ExtraInfo> extraInfo = std::make_shared<ExtraInfo>();
76 extraInfo->dataType = DataType::PIXEL_MAP;
77 extraInfo->bufferType = BufferType::HEAP_MEMORY;
78 extraInfo->picture = picture;
79
80 std::shared_ptr<EffectBuffer> effectBuf = std::make_shared<EffectBuffer>(info, addr, extraInfo);
81 return effectBuf != nullptr && effectBuf->buffer_ != nullptr ? effectBuf : nullptr;
82 }
83
84 static std::unique_ptr<Picture> g_picture = nullptr;
85
86 class TestEffectColorSpaceManager : public testing::Test {
87 public:
88 TestEffectColorSpaceManager() = default;
89
90 ~TestEffectColorSpaceManager() override = default;
91
SetUpTestCase()92 static void SetUpTestCase()
93 {
94 g_picture = CreatePictureByPath(TEST_IMAGE_PATH);
95 EXPECT_NE(g_picture, nullptr);
96 }
97
TearDownTestCase()98 static void TearDownTestCase()
99 {
100 g_picture = nullptr;
101 }
102
SetUp()103 void SetUp() override
104 {
105 effectContext_->memoryManager_ = std::make_shared<EffectMemoryManager>();
106 effectContext_->colorSpaceManager_ = std::make_shared<ColorSpaceManager>();
107 }
108
TearDown()109 void TearDown() override
110 {
111 effectContext_ = nullptr;
112 }
113
114 std::shared_ptr<EffectContext> effectContext_ = std::make_shared<EffectContext>();
115 };
116
117 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceConverter_ApplyColorSpace001, TestSize.Level1)
118 {
119 EFFECT_LOGW("%{public}s ColorSpaceConverter_ApplyColorSpace001 enter", TAG.c_str());
120 std::shared_ptr<EffectBuffer> inputEffectBuffer = CreateEffectBufferByPicture(g_picture.get());
121 EXPECT_NE(inputEffectBuffer, nullptr);
122
123 EffectColorSpace targetColorSpace = EffectColorSpace::SRGB;
124 ErrorCode result = ColorSpaceProcessor::ApplyColorSpace(inputEffectBuffer.get(), targetColorSpace);
125 EXPECT_EQ(result, ErrorCode::SUCCESS);
126
127 inputEffectBuffer->extraInfo_->dataType = DataType::URI;
128 result = ColorSpaceProcessor::ApplyColorSpace(inputEffectBuffer.get(), targetColorSpace);
129 EXPECT_EQ(result, ErrorCode::SUCCESS);
130
131 inputEffectBuffer->extraInfo_->dataType = DataType::UNKNOWN;
132 result = ColorSpaceProcessor::ApplyColorSpace(inputEffectBuffer.get(), targetColorSpace);
133 EXPECT_NE(result, ErrorCode::SUCCESS);
134 EFFECT_LOGW("%{public}s ColorSpaceConverter_ApplyColorSpace001 end", TAG.c_str());
135 }
136
137 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceConverter_GetMemoryData001, TestSize.Level1)
138 {
139 EFFECT_LOGW("%{public}s ColorSpaceConverter_GetMemoryData001 enter", TAG.c_str());
140 SurfaceBuffer *sb = OHOS::SurfaceBuffer::Create();
141 std::shared_ptr<ColorSpaceProcessor> colorSpaceConverter = std::make_shared<ColorSpaceProcessor>();
142 auto result = colorSpaceConverter->GetMemoryData(sb);
143 EXPECT_EQ(result, nullptr);
144
145 std::shared_ptr<MemoryData> memoryData = std::make_shared<MemoryData>();
146 memoryData->memoryInfo.extra = static_cast<void *>(sb);
147
148 colorSpaceConverter->memoryDataArray_.emplace_back(memoryData);
149 result = colorSpaceConverter->GetMemoryData(sb);
150 EXPECT_NE(result, nullptr);
151 EFFECT_LOGW("%{public}s ColorSpaceConverter_GetMemoryData001 end", TAG.c_str());
152 }
153
154 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceHelper_ConvertToColorSpaceName001, TestSize.Level1)
155 {
156 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertToColorSpaceName001 enter", TAG.c_str());
157 EffectColorSpace colorSpace = EffectColorSpace::DEFAULT;
158 OHOS::ColorManager::ColorSpaceName result = ColorSpaceHelper::ConvertToColorSpaceName(colorSpace);
159 EXPECT_EQ(result, OHOS::ColorManager::ColorSpaceName::NONE);
160 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertToColorSpaceName001 end", TAG.c_str());
161 }
162
163 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceHelper_ConvertToCMColorSpace001, TestSize.Level1)
164 {
165 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertToCMColorSpace001 enter", TAG.c_str());
166 EffectColorSpace colorSpace = EffectColorSpace::DEFAULT;
167 OHOS::HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType type =
168 ColorSpaceHelper::ConvertToCMColorSpace(colorSpace);
169 EXPECT_EQ(type, OHOS::HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType::CM_COLORSPACE_NONE);
170
171 colorSpace = EffectColorSpace::SRGB;
172 type = ColorSpaceHelper::ConvertToCMColorSpace(colorSpace);
173 EXPECT_NE(type, OHOS::HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType::CM_COLORSPACE_NONE);
174 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertToCMColorSpace001 end", TAG.c_str());
175 }
176
177 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceHelper_ConvertColorSpace001, TestSize.Level1)
178 {
179 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertColorSpace001 enter", TAG.c_str());
180 std::shared_ptr<EffectBuffer> inputEffectBuffer = CreateEffectBufferByPicture(g_picture.get());
181 EXPECT_NE(inputEffectBuffer, nullptr);
182
183 inputEffectBuffer->bufferInfo_->colorSpace_ = EffectColorSpace::ADOBE_RGB;
184 effectContext_->colorSpaceManager_->strategy_ = std::make_shared<ColorSpaceStrategy>();
185 effectContext_->colorSpaceManager_->strategy_->src_ = CreateEffectBufferByPicture(g_picture.get());
186
187 ErrorCode result = ColorSpaceHelper::ConvertColorSpace(inputEffectBuffer, effectContext_);
188 EXPECT_EQ(result, ErrorCode::SUCCESS);
189 EFFECT_LOGW("%{public}s ColorSpaceHelper_ConvertColorSpace001 end", TAG.c_str());
190 }
191
192 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceHelper_UpdateMetadata001, TestSize.Level1)
193 {
194 EFFECT_LOGW("%{public}s ColorSpaceHelper_UpdateMetadata001 enter", TAG.c_str());
195 std::shared_ptr<EffectBuffer> inputEffectBuffer = CreateEffectBufferByPicture(g_picture.get());
196 EXPECT_NE(inputEffectBuffer, nullptr);
197
198 inputEffectBuffer->bufferInfo_->surfaceBuffer_ = nullptr;
199 std::shared_ptr<EffectContext> context = std::make_unique<EffectContext>();
200 ErrorCode result = ColorSpaceHelper::UpdateMetadata(inputEffectBuffer.get(), context);
201 EXPECT_EQ(result, ErrorCode::SUCCESS);
202
203 inputEffectBuffer->bufferInfo_->surfaceBuffer_ = OHOS::SurfaceBuffer::Create();
204 inputEffectBuffer->bufferInfo_->colorSpace_ = EffectColorSpace::DEFAULT;
205 result = ColorSpaceHelper::UpdateMetadata(inputEffectBuffer.get(), context);
206 EXPECT_EQ(result, ErrorCode::SUCCESS);
207
208 inputEffectBuffer->bufferInfo_->colorSpace_ = EffectColorSpace::SRGB;
209 result = ColorSpaceHelper::UpdateMetadata(inputEffectBuffer.get(), context);
210 EXPECT_EQ(result, ErrorCode::SUCCESS);
211 EFFECT_LOGW("%{public}s ColorSpaceHelper_UpdateMetadata001 end", TAG.c_str());
212 }
213
214 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceManager_ApplyColorSpace001, TestSize.Level1)
215 {
216 EFFECT_LOGW("%{public}s ColorSpaceManager_ApplyColorSpace001 enter", TAG.c_str());
217 std::shared_ptr<EffectBuffer> inputEffectBuffer = CreateEffectBufferByPicture(g_picture.get());
218 EXPECT_NE(inputEffectBuffer, nullptr);
219
220 EffectColorSpace colorSpace = EffectColorSpace::DEFAULT;
221 EffectColorSpace outputColorSpace = EffectColorSpace::DEFAULT;
222 std::shared_ptr<ColorSpaceManager> colorSpaceManager = std::make_shared<ColorSpaceManager>();
223 ErrorCode result = colorSpaceManager->ApplyColorSpace(inputEffectBuffer.get(), colorSpace, outputColorSpace);
224 EXPECT_EQ(result, ErrorCode::SUCCESS);
225
226 colorSpace = EffectColorSpace::ADOBE_RGB;
227 result = colorSpaceManager->ApplyColorSpace(inputEffectBuffer.get(), colorSpace, outputColorSpace);
228 EXPECT_NE(result, ErrorCode::SUCCESS);
229 EFFECT_LOGW("%{public}s ColorSpaceManager_ApplyColorSpace001 end", TAG.c_str());
230 }
231
232 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceStrategy_IsSupportedColorSpace001, TestSize.Level1)
233 {
234 EFFECT_LOGW("%{public}s ColorSpaceStrategy_IsSupportedColorSpace001 enter", TAG.c_str());
235 EffectColorSpace colorSpace = EffectColorSpace::SRGB;
236 bool result = ColorSpaceStrategy::IsSupportedColorSpace(colorSpace);
237 EXPECT_EQ(result, true);
238
239 colorSpace = EffectColorSpace::DEFAULT;
240 result = ColorSpaceStrategy::IsSupportedColorSpace(colorSpace);
241 EXPECT_EQ(result, false);
242 EFFECT_LOGW("%{public}s ColorSpaceStrategy_IsSupportedColorSpace001 end", TAG.c_str());
243 }
244
245 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceStrategy_ChooseColorSpace001, TestSize.Level1)
246 {
247 EFFECT_LOGW("%{public}s ColorSpaceStrategy_ChooseColorSpace001 enter", TAG.c_str());
248 std::unordered_set<EffectColorSpace> filtersSupportedColorSpace = { EffectColorSpace::SRGB };
249 EffectColorSpace srcRealColorSpace = EffectColorSpace::SRGB;
250 EffectColorSpace outputColorSpace = EffectColorSpace::DEFAULT;
251
252 std::shared_ptr<ColorSpaceStrategy> colorSpaceStrategy = std::make_shared<ColorSpaceStrategy>();
253 colorSpaceStrategy->src_ = CreateEffectBufferByPicture(g_picture.get());
254 colorSpaceStrategy->dst_ = nullptr;
255 ErrorCode result = colorSpaceStrategy->ChooseColorSpace(filtersSupportedColorSpace,
256 srcRealColorSpace, outputColorSpace);
257 EXPECT_EQ(result, ErrorCode::SUCCESS);
258
259 colorSpaceStrategy->dst_ = CreateEffectBufferByPicture(g_picture.get());
260 result = colorSpaceStrategy->ChooseColorSpace(filtersSupportedColorSpace, srcRealColorSpace, outputColorSpace);
261 EXPECT_EQ(result, ErrorCode::SUCCESS);
262
263 colorSpaceStrategy->dst_->buffer_ = nullptr;
264 result = colorSpaceStrategy->ChooseColorSpace(filtersSupportedColorSpace, srcRealColorSpace, outputColorSpace);
265 EXPECT_EQ(result, ErrorCode::SUCCESS);
266
267 srcRealColorSpace = EffectColorSpace::ADOBE_RGB;
268 result = colorSpaceStrategy->ChooseColorSpace(filtersSupportedColorSpace, srcRealColorSpace, outputColorSpace);
269 EXPECT_NE(result, ErrorCode::SUCCESS);
270 EFFECT_LOGW("%{public}s ColorSpaceStrategy_ChooseColorSpace001 end", TAG.c_str());
271 }
272
273 HWTEST_F(TestEffectColorSpaceManager, ColorSpaceStrategy_CheckConverterColorSpace001, TestSize.Level1)
274 {
275 EFFECT_LOGW("%{public}s ColorSpaceStrategy_CheckConverterColorSpace001 enter", TAG.c_str());
276 EffectColorSpace targetColorSpace = EffectColorSpace::SRGB;
277 std::shared_ptr<ColorSpaceStrategy> colorSpaceStrategy = std::make_shared<ColorSpaceStrategy>();
278 colorSpaceStrategy->src_ = CreateEffectBufferByPicture(g_picture.get());
279 colorSpaceStrategy->dst_ = nullptr;
280 ErrorCode result = colorSpaceStrategy->CheckConverterColorSpace(targetColorSpace);
281 EXPECT_EQ(result, ErrorCode::SUCCESS);
282
283 colorSpaceStrategy->dst_ = CreateEffectBufferByPicture(g_picture.get());
284 result = colorSpaceStrategy->CheckConverterColorSpace(targetColorSpace);
285 EXPECT_EQ(result, ErrorCode::SUCCESS);
286
287 colorSpaceStrategy->dst_->buffer_ = nullptr;
288 result = colorSpaceStrategy->CheckConverterColorSpace(targetColorSpace);
289 EXPECT_NE(result, ErrorCode::SUCCESS);
290 EFFECT_LOGW("%{public}s ColorSpaceStrategy_CheckConverterColorSpace001 end", TAG.c_str());
291 }
292 }
293 }
294 }
295 }
296
