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 "colorspace_converter.h"
17 
18 #include "vpe_helper.h"
19 #include "effect_log.h"
20 #include "v1_0/cm_color_space.h"
21 #include "colorspace_helper.h"
22 #include "format_helper.h"
23 #include "common_utils.h"
24 #include "pixel_map.h"
25 
26 #define VPE_INVALID_INSTANCE_ID (-1)
27 
28 namespace OHOS {
29 namespace Media {
30 namespace Effect {
31 
32 using namespace OHOS::ColorManager;
33 using namespace OHOS::HDI::Display::Graphic::Common::V1_0;
34 
~ColorSpaceConverter()35 ColorSpaceConverter::~ColorSpaceConverter()
36 {
37     memoryDataArray_.clear();
38 }
39 
40 // The same instance cannot be used for ComposeImage and DecomposeImage.
CreateVpeColorSpaceInstance()41 int32_t ColorSpaceConverter::CreateVpeColorSpaceInstance()
42 {
43     int instance = VPE_INVALID_INSTANCE_ID;
44     int32_t res = VpeHelper::ColorSpaceConverterCreate(&instance);
45     CHECK_AND_RETURN_RET_LOG(res == 0, VPE_INVALID_INSTANCE_ID,
46         "GetVpeColorSpaceInstance: get instance fail! res=%{public}d", res);
47     EFFECT_LOGD("GetVpeColorSpaceInstance: instance=%{public}d", instance);
48 
49     return instance;
50 }
51 
DestroyVpeColorSpaceInstance(int32_t vpeColorSpaceInstance)52 void ColorSpaceConverter::DestroyVpeColorSpaceInstance(int32_t vpeColorSpaceInstance)
53 {
54     // destroy vpe color space converter instance.
55     if (vpeColorSpaceInstance != VPE_INVALID_INSTANCE_ID) {
56         VpeHelper::ColorSpaceConverterDestroy(&vpeColorSpaceInstance);
57     }
58 }
59 
AllocSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> & memoryDataArray,MemoryInfo & allocMemInfo,CM_HDR_Metadata_Type type,CM_ColorSpaceType colorSpace)60 SurfaceBuffer *AllocSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> &memoryDataArray, MemoryInfo &allocMemInfo,
61     CM_HDR_Metadata_Type type, CM_ColorSpaceType colorSpace)
62 {
63     BufferInfo &bufferInfo = allocMemInfo.bufferInfo;
64     EFFECT_LOGD("AllocSurfaceBuffer: Alloc surface buffer memory! w=%{public}d, h=%{public}d, format=%{public}d",
65         bufferInfo.width_, bufferInfo.height_, bufferInfo.formatType_);
66 
67     std::unique_ptr<AbsMemory> absMemory = EffectMemory::CreateMemory(BufferType::DMA_BUFFER);
68     CHECK_AND_RETURN_RET_LOG(absMemory != nullptr, nullptr, "AllocSurfaceBuffer: absMemory is null!");
69     std::shared_ptr<MemoryData> memoryData = absMemory->Alloc(allocMemInfo);
70     CHECK_AND_RETURN_RET_LOG(memoryData != nullptr, nullptr, "AllocSurfaceBuffer: memoryData is null!");
71 
72     void *surfaceBuffer = memoryData->memoryInfo.extra;
73     CHECK_AND_RETURN_RET_LOG(surfaceBuffer != nullptr, nullptr, "AllocSurfaceBuffer: extra info is null!");
74 
75     auto *sb = static_cast<SurfaceBuffer *>(surfaceBuffer);
76     ColorSpaceHelper::SetSurfaceBufferMetadataType(sb, type);
77     ColorSpaceHelper::SetSurfaceBufferColorSpaceType(sb, colorSpace);
78     memoryDataArray.emplace_back(memoryData);
79     return sb;
80 }
81 
AllocSdrSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> & memoryDataArray,const EffectBuffer * inputHdr,CM_HDR_Metadata_Type type,CM_ColorSpaceType colorSpaceType,EffectColorSpace effectColorSpace)82 sptr<SurfaceBuffer> AllocSdrSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> &memoryDataArray,
83     const EffectBuffer *inputHdr, CM_HDR_Metadata_Type type, CM_ColorSpaceType colorSpaceType,
84     EffectColorSpace effectColorSpace)
85 {
86     MemoryInfo allocMemInfo;
87     BufferInfo &bufferInfo = allocMemInfo.bufferInfo;
88     bufferInfo = *inputHdr->bufferInfo_;
89     bufferInfo.formatType_ = IEffectFormat::RGBA8888;
90     bufferInfo.colorSpace_ = effectColorSpace;
91     SurfaceBuffer *sb = AllocSurfaceBuffer(memoryDataArray, allocMemInfo, type, colorSpaceType);
92     CHECK_AND_RETURN_RET_LOG(sb != nullptr, nullptr,
93         "AllocSdrSurfaceBuffer: alloc fail! w=%{public}d, h=%{public}d, format=%{public}d",
94         bufferInfo.width_, bufferInfo.height_, bufferInfo.formatType_);
95 
96     return sb;
97 }
98 
AllocGainmapSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> & memoryDataArray,const EffectBuffer * inputHdr,CM_HDR_Metadata_Type type,CM_ColorSpaceType colorSpaceType,EffectColorSpace effectColorSpace)99 sptr<SurfaceBuffer> AllocGainmapSurfaceBuffer(std::vector<std::shared_ptr<MemoryData>> &memoryDataArray,
100     const EffectBuffer *inputHdr, CM_HDR_Metadata_Type type, CM_ColorSpaceType colorSpaceType,
101     EffectColorSpace effectColorSpace)
102 {
103     MemoryInfo allocMemInfo;
104     BufferInfo &bufferInfo = allocMemInfo.bufferInfo;
105     bufferInfo = *inputHdr->bufferInfo_;
106     uint32_t half = 2;
107     bufferInfo.width_ = bufferInfo.width_ / half;
108     bufferInfo.height_ = bufferInfo.height_ / half;
109     bufferInfo.formatType_ = IEffectFormat::RGBA8888;
110     bufferInfo.colorSpace_ = effectColorSpace;
111     SurfaceBuffer *sb = AllocSurfaceBuffer(memoryDataArray, allocMemInfo, type, colorSpaceType);
112     CHECK_AND_RETURN_RET_LOG(sb != nullptr, nullptr,
113         "AllocGainmapSurfaceBuffer: alloc fail! w=%{public}d, h=%{public}d, format=%{public}d",
114         bufferInfo.width_, bufferInfo.height_, bufferInfo.formatType_);
115 
116     return sb;
117 }
118 
PrintColorSpaceInfo(const sptr<SurfaceBuffer> & surfaceBuffer,const std::string & tag)119 void PrintColorSpaceInfo(const sptr<SurfaceBuffer> &surfaceBuffer, const std::string &tag)
120 {
121     if (surfaceBuffer == nullptr) {
122         return;
123     }
124 
125     CM_HDR_Metadata_Type metadataType = CM_HDR_Metadata_Type::CM_METADATA_NONE;
126     ColorSpaceHelper::GetSurfaceBufferMetadataType(surfaceBuffer, metadataType);
127     CM_ColorSpaceType colorSpaceType = CM_ColorSpaceType::CM_COLORSPACE_NONE;
128     ColorSpaceHelper::GetSurfaceBufferColorSpaceType(surfaceBuffer, colorSpaceType);
129 
130     EFFECT_LOGD("%{public}s: metadataType=%{public}d, colorSpaceType=%{public}d, format=%{public}d",
131         tag.c_str(), metadataType, colorSpaceType, surfaceBuffer->GetFormat());
132 }
133 
ComposeHdrImageInner(int32_t vpeColorSpaceInstance,const EffectBuffer * inputSdr,const SurfaceBuffer * inputGainmap,EffectBuffer * outputHdr)134 ErrorCode ColorSpaceConverter::ComposeHdrImageInner(int32_t vpeColorSpaceInstance, const EffectBuffer *inputSdr,
135     const SurfaceBuffer *inputGainmap, EffectBuffer *outputHdr)
136 {
137     CHECK_AND_RETURN_RET_LOG(vpeColorSpaceInstance != VPE_INVALID_INSTANCE_ID,
138         ErrorCode::ERR_INVALID_VPE_INSTANCE, "ComposeHdrImageInner: invalid vpe instance!");
139     CHECK_AND_RETURN_RET_LOG(inputSdr != nullptr && inputGainmap != nullptr && outputHdr != nullptr,
140         ErrorCode::ERR_INPUT_NULL, "ComposeHdrImageInner: inputSdr or inputGainmap or outputHdr is null!");
141 
142     sptr<SurfaceBuffer> sdrSb = inputSdr->extraInfo_->surfaceBuffer;
143     sptr<SurfaceBuffer> gainmapSb = const_cast<SurfaceBuffer *>(inputGainmap);
144     sptr<SurfaceBuffer> hdrSb = outputHdr->extraInfo_->surfaceBuffer;
145     CHECK_AND_RETURN_RET_LOG(sdrSb != nullptr && gainmapSb != nullptr && hdrSb != nullptr,
146         ErrorCode::ERR_INVALID_SURFACE_BUFFER, "ComposeHdrImageInner: invalid surface buffer! sdrSb=%{public}d,"
147         "gainmapSb=%{public}d, hdrSb=%{public}d", sdrSb == nullptr, gainmapSb == nullptr, hdrSb == nullptr);
148 
149     PrintColorSpaceInfo(sdrSb, "ComposeHdrImageInner:SdrSurfaceBuffer");
150     PrintColorSpaceInfo(gainmapSb, "ComposeHdrImageInner:GainmapSurfaceBuffer");
151     PrintColorSpaceInfo(hdrSb, "ComposeHdrImageInner:HdrSurfaceBuffer");
152 
153     int32_t res = VpeHelper::ColorSpaceConverterComposeImage(vpeColorSpaceInstance, sdrSb, gainmapSb, hdrSb, false);
154     CHECK_AND_RETURN_RET_LOG(res == 0, ErrorCode::ERR_VPE_COMPOSE_IMAGE_FAIL,
155         "ComposeHdrImageInner: ColorSpaceConverterComposeImage fail! res=%{public}d", res);
156 
157     return ErrorCode::SUCCESS;
158 }
159 
ComposeHdrImage(const EffectBuffer * inputSdr,const SurfaceBuffer * inputGainmap,EffectBuffer * outputHdr)160 ErrorCode ColorSpaceConverter::ComposeHdrImage(const EffectBuffer *inputSdr, const SurfaceBuffer *inputGainmap,
161     EffectBuffer *outputHdr)
162 {
163     EFFECT_LOGI("ComposeHdrImage IN");
164     int32_t vpeColorSpaceInstance = CreateVpeColorSpaceInstance();
165     ErrorCode res = ComposeHdrImageInner(vpeColorSpaceInstance, inputSdr, inputGainmap, outputHdr);
166     DestroyVpeColorSpaceInstance(vpeColorSpaceInstance);
167     EFFECT_LOGI("ComposeHdrImage OUT");
168     return res;
169 }
170 
DecomposeHdrImageInner(int32_t vpeColorSpaceInstance,const EffectBuffer * inputHdr,std::shared_ptr<EffectBuffer> & outputSdr,SurfaceBuffer ** outputGainmap)171 ErrorCode ColorSpaceConverter::DecomposeHdrImageInner(int32_t vpeColorSpaceInstance, const EffectBuffer *inputHdr,
172     std::shared_ptr<EffectBuffer> &outputSdr, SurfaceBuffer **outputGainmap)
173 {
174     CHECK_AND_RETURN_RET_LOG(vpeColorSpaceInstance != VPE_INVALID_INSTANCE_ID,
175         ErrorCode::ERR_INVALID_VPE_INSTANCE, "DecomposeHdrImageInner: invalid vpe instance!");
176     CHECK_AND_RETURN_RET_LOG(inputHdr != nullptr && outputGainmap != nullptr,
177         ErrorCode::ERR_INPUT_NULL, "DecomposeHdrImageInner: inputHdr or outputGainmap is null!");
178 
179     sptr<SurfaceBuffer> hdrSb = inputHdr->extraInfo_->surfaceBuffer;
180     sptr<SurfaceBuffer> sdrSb = AllocSdrSurfaceBuffer(memoryDataArray_, inputHdr, CM_IMAGE_HDR_VIVID_DUAL, CM_P3_FULL,
181         EffectColorSpace::DISPLAY_P3);
182     sptr<SurfaceBuffer> gainmapSb = AllocGainmapSurfaceBuffer(memoryDataArray_, inputHdr, CM_METADATA_NONE, CM_P3_FULL,
183         EffectColorSpace::DISPLAY_P3);
184     CHECK_AND_RETURN_RET_LOG(hdrSb != nullptr && sdrSb != nullptr && gainmapSb != nullptr,
185         ErrorCode::ERR_INVALID_SURFACE_BUFFER, "DecomposeHdrImageInner: invalid surface buffer! hdrSb=%{public}d,"
186         "sdrSb=%{public}d, gainmapSb=%{public}d", hdrSb == nullptr, sdrSb == nullptr, gainmapSb == nullptr);
187 
188     ColorSpaceHelper::SetHDRDynamicMetadata(hdrSb, std::vector<uint8_t>(0));
189     ColorSpaceHelper::SetHDRStaticMetadata(hdrSb, std::vector<uint8_t>(0));
190 
191     PrintColorSpaceInfo(hdrSb, "DecomposeHdrImageInner:HdrSurfaceBuffer");
192     PrintColorSpaceInfo(sdrSb, "DecomposeHdrImageInner:SdrSurfaceBuffer");
193     PrintColorSpaceInfo(gainmapSb, "DecomposeHdrImageInner:GainmapSurfaceBuffer");
194 
195     int32_t res = VpeHelper::ColorSpaceConverterDecomposeImage(vpeColorSpaceInstance, hdrSb, sdrSb, gainmapSb);
196     CHECK_AND_RETURN_RET_LOG(res == 0, ErrorCode::ERR_VPE_DECOMPOSE_IMAGE_FAIL,
197         "DecomposeHdrImageInner: ColorSpaceConverterDecomposeImage fail! res=%{public}d", res);
198 
199     // update effectBuffer
200     std::shared_ptr<EffectBuffer> buffer = nullptr;
201     ErrorCode errorCode = CommonUtils::ParseSurfaceData(sdrSb, buffer, inputHdr->extraInfo_->dataType);
202     CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, errorCode,
203         "DecomposeHdrImageInner: ParseSurfaceData fail! errorCode=%{public}d", errorCode);
204     CHECK_AND_RETURN_RET_LOG(buffer != nullptr && buffer->extraInfo_ != nullptr, ErrorCode::ERR_INPUT_NULL,
205         "DecomposeHdrImageInner: buffer is null or extraInfo of buffer is null!"
206         "buffer=%{public}d, buffer->extraInfo_=%{public}d", buffer == nullptr, buffer->extraInfo_ == nullptr);
207     *buffer->extraInfo_ = *inputHdr->extraInfo_;
208     buffer->extraInfo_->surfaceBuffer = sdrSb;
209     buffer->extraInfo_->bufferType = BufferType::DMA_BUFFER;
210 
211     outputSdr = buffer;
212     *outputGainmap = gainmapSb;
213 
214     return ErrorCode::SUCCESS;
215 }
216 
DecomposeHdrImage(const EffectBuffer * inputHdr,std::shared_ptr<EffectBuffer> & outputSdr,SurfaceBuffer ** outputGainmap)217 ErrorCode ColorSpaceConverter::DecomposeHdrImage(const EffectBuffer *inputHdr, std::shared_ptr<EffectBuffer> &outputSdr,
218     SurfaceBuffer **outputGainmap)
219 {
220     EFFECT_LOGI("DecomposeHdrImage IN");
221     int32_t vpeColorSpaceInstance = CreateVpeColorSpaceInstance();
222     ErrorCode res = DecomposeHdrImageInner(vpeColorSpaceInstance, inputHdr, outputSdr, outputGainmap);
223     DestroyVpeColorSpaceInstance(vpeColorSpaceInstance);
224     EFFECT_LOGI("DecomposeHdrImage OUT");
225     return res;
226 }
227 
ProcessHdrImageInner(int32_t vpeColorSpaceInstance,const EffectBuffer * inputHdr,std::shared_ptr<EffectBuffer> & outputSdr)228 ErrorCode ColorSpaceConverter::ProcessHdrImageInner(int32_t vpeColorSpaceInstance, const EffectBuffer *inputHdr,
229     std::shared_ptr<EffectBuffer> &outputSdr)
230 {
231     CHECK_AND_RETURN_RET_LOG(vpeColorSpaceInstance != VPE_INVALID_INSTANCE_ID,
232         ErrorCode::ERR_INVALID_VPE_INSTANCE, "ProcessHdrImageInner: invalid vpe instance!");
233     CHECK_AND_RETURN_RET_LOG(inputHdr != nullptr, ErrorCode::ERR_INPUT_NULL,
234         "ProcessHdrImageInner: inputHdr is null!");
235 
236     sptr<SurfaceBuffer> sdrSb = AllocSdrSurfaceBuffer(memoryDataArray_, inputHdr, CM_IMAGE_HDR_VIVID_DUAL, CM_P3_FULL,
237         EffectColorSpace::DISPLAY_P3);
238     sptr<SurfaceBuffer> hdrSb = inputHdr->extraInfo_->surfaceBuffer;
239     CHECK_AND_RETURN_RET_LOG(sdrSb != nullptr && hdrSb != nullptr, ErrorCode::ERR_INVALID_SURFACE_BUFFER,
240         "ProcessHdrImageInner: invalid surface buffer! sdrSb=%{public}d, hdrSb=%{public}d",
241         sdrSb == nullptr, hdrSb == nullptr);
242 
243     PrintColorSpaceInfo(hdrSb, "ProcessHdrImageInner:HdrSurfaceBuffer");
244     PrintColorSpaceInfo(sdrSb, "ProcessHdrImageInner:SdrSurfaceBuffer");
245 
246     ColorSpaceHelper::SetHDRDynamicMetadata(hdrSb, std::vector<uint8_t>(0));
247     ColorSpaceHelper::SetHDRStaticMetadata(hdrSb, std::vector<uint8_t>(0));
248 
249     int32_t res = VpeHelper::ColorSpaceConverterProcessImage(vpeColorSpaceInstance, hdrSb, sdrSb);
250     CHECK_AND_RETURN_RET_LOG(res == 0, ErrorCode::ERR_VPE_PROCESS_IMAGE_FAIL,
251         "ProcessHdrImageInner: ColorSpaceConverterProcessImage fail! res=%{public}d", res);
252 
253     // update effectBuffer
254     std::shared_ptr<EffectBuffer> buffer;
255     ErrorCode errorCode = CommonUtils::ParseSurfaceData(sdrSb, buffer, inputHdr->extraInfo_->dataType);
256     CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, errorCode,
257         "ProcessHdrImageInner: ParseSurfaceData fail! errorCode=%{public}d", errorCode);
258     *buffer->extraInfo_ = *inputHdr->extraInfo_;
259     buffer->extraInfo_->surfaceBuffer = sdrSb;
260     buffer->extraInfo_->bufferType = BufferType::DMA_BUFFER;
261 
262     outputSdr = buffer;
263     return ErrorCode::SUCCESS;
264 }
265 
ProcessHdrImage(const EffectBuffer * inputHdr,std::shared_ptr<EffectBuffer> & outputSdr)266 ErrorCode ColorSpaceConverter::ProcessHdrImage(const EffectBuffer *inputHdr, std::shared_ptr<EffectBuffer> &outputSdr)
267 {
268     EFFECT_LOGI("ProcessHdrImage IN");
269     int32_t vpeColorSpaceInstance = CreateVpeColorSpaceInstance();
270     ErrorCode res = ProcessHdrImageInner(vpeColorSpaceInstance, inputHdr, outputSdr);
271     DestroyVpeColorSpaceInstance(vpeColorSpaceInstance);
272     EFFECT_LOGI("ProcessHdrImage OUT");
273     return res;
274 }
275 
GetMemoryData(SurfaceBuffer * sb)276 std::shared_ptr<MemoryData> ColorSpaceConverter::GetMemoryData(SurfaceBuffer *sb)
277 {
278     CHECK_AND_RETURN_RET_LOG(sb != nullptr, nullptr, "GetMemoryData: sb is null!");
279 
280     void *pSurfaceBuffer = static_cast<void *>(sb);
281     for (const auto &memoryData : memoryDataArray_) {
282         if (memoryData->memoryInfo.extra == pSurfaceBuffer) {
283             return memoryData;
284         }
285     }
286 
287     return nullptr;
288 }
289 
CreatePixelMap(EffectBuffer * effectBuffer)290 PixelMap *CreatePixelMap(EffectBuffer *effectBuffer)
291 {
292     std::shared_ptr<BufferInfo> &bufferInfo = effectBuffer->bufferInfo_;
293     InitializationOptions options = {
294         .size = {
295             .width = static_cast<int32_t>(bufferInfo->width_),
296             .height = static_cast<int32_t>(bufferInfo->height_),
297         },
298         .srcPixelFormat = CommonUtils::SwitchToPixelFormat(bufferInfo->formatType_),
299         .pixelFormat = CommonUtils::SwitchToPixelFormat(bufferInfo->formatType_),
300     };
301     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(static_cast<uint32_t *>(effectBuffer->buffer_),
302         bufferInfo->len_, 0, static_cast<int32_t>(bufferInfo->rowStride_), options, true);
303     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, nullptr, "CreatePixelMap: create fail!");
304     CHECK_AND_RETURN_RET_LOG(pixelMap->GetPixelFormat() == options.pixelFormat, nullptr,
305         "CreatePixelMap: pixelFormat error! pixelFormat=%{public}d, optionPixelFormat=%{public}d",
306         pixelMap->GetPixelFormat(), options.pixelFormat);
307 
308     const std::shared_ptr<ExtraInfo> &extraInfo = effectBuffer->extraInfo_;
309     extraInfo->innerPixelMap = std::move(pixelMap);
310     return extraInfo->innerPixelMap.get();
311 }
312 
GetPixelMap(EffectBuffer * effectBuffer)313 PixelMap *GetPixelMap(EffectBuffer *effectBuffer)
314 {
315     std::shared_ptr<ExtraInfo> &extraInfo = effectBuffer->extraInfo_;
316     switch (extraInfo->dataType) {
317         case DataType::PIXEL_MAP:
318             return extraInfo->pixelMap;
319         case DataType::URI:
320         case DataType::PATH:
321         case DataType::PICTURE:
322             return extraInfo->innerPixelMap.get();
323         case DataType::SURFACE:
324         case DataType::SURFACE_BUFFER:
325             return CreatePixelMap(effectBuffer);
326         default:
327             EFFECT_LOGE("Data type not support! dataType=%{public}d", extraInfo->dataType);
328             return nullptr;
329     }
330 }
331 
ApplyColorSpace(EffectBuffer * effectBuffer,EffectColorSpace targetColorSpace)332 ErrorCode ColorSpaceConverter::ApplyColorSpace(EffectBuffer *effectBuffer, EffectColorSpace targetColorSpace)
333 {
334     CHECK_AND_RETURN_RET_LOG(effectBuffer != nullptr && effectBuffer->bufferInfo_ != nullptr &&
335         effectBuffer->buffer_ != nullptr && effectBuffer->extraInfo_ != nullptr,
336         ErrorCode::ERR_INPUT_NULL, "ApplyColorSpace: effectBuffer is null!");
337 
338     ColorSpaceName colorSpaceName = ColorSpaceHelper::ConvertToColorSpaceName(targetColorSpace);
339     CHECK_AND_RETURN_RET_LOG(colorSpaceName != ColorSpaceName::NONE, ErrorCode::ERR_INVALID_COLORSPACE,
340         "ApplyColorSpace: invalid color space! targetColorSpace=%{public}d", targetColorSpace);
341 
342     PixelMap *pixelMap = GetPixelMap(effectBuffer);
343     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, ErrorCode::ERR_CREATE_PIXELMAP_FAIL,
344         "ApplyColorSpace create pixelmap fail!");
345 
346     OHOS::ColorManager::ColorSpace grColorSpace(colorSpaceName);
347     uint32_t res = pixelMap->ApplyColorSpace(grColorSpace);
348     CHECK_AND_RETURN_RET_LOG(res == 0, ErrorCode::ERR_APPLYCOLORSPACE_FAIL, "ApplyColorSpace: pixelMap "
349         "ApplyColorSpace fail! res=%{public}d, colorSpaceName=%{public}d", res, colorSpaceName);
350 
351     // update effectBuffer
352     std::shared_ptr<EffectBuffer> buffer;
353     ErrorCode errorCode = CommonUtils::LockPixelMap(pixelMap, buffer);
354     CHECK_AND_RETURN_RET_LOG(errorCode == ErrorCode::SUCCESS, errorCode, "ApplyColorSpace: pixelMap parse fail!"
355         "res=%{public}d, colorSpaceName=%{public}d", res, colorSpaceName);
356 
357     effectBuffer->bufferInfo_ = buffer->bufferInfo_;
358     effectBuffer->buffer_ = buffer->buffer_;
359     effectBuffer->extraInfo_->surfaceBuffer = buffer->extraInfo_->surfaceBuffer;
360 
361     return ErrorCode::SUCCESS;
362 }
363 } // namespace Effect
364 } // namespace Media
365 } // namespace OHOS