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