1 /*
2 * Copyright (C) 2021 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_format_convert.h"
17 #ifdef EXT_PIXEL
18 #include "pixel_yuv_ext.h"
19 #endif
20
21 #include <map>
22 #include <memory>
23 #include "hilog/log.h"
24 #include "image_format_convert_ext_utils.h"
25 #include "image_log.h"
26 #include "image_source.h"
27 #include "log_tags.h"
28 #include "media_errors.h"
29 #include "pixel_yuv.h"
30 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
31 #include "v1_0/buffer_handle_meta_key_type.h"
32 #include "v1_0/cm_color_space.h"
33 #include "v1_0/hdr_static_metadata.h"
34 #include "surface_buffer.h"
35 #endif
36 #include "vpe_utils.h"
37
38 namespace {
39 constexpr uint8_t NUM_0 = 0;
40 constexpr uint8_t NUM_1 = 1;
41 constexpr uint8_t NUM_2 = 2;
42 constexpr uint8_t NUM_3 = 3;
43 constexpr uint8_t NUM_4 = 4;
44 constexpr uint8_t NUM_8 = 8;
45 constexpr uint8_t PLANE_Y = 0;
46 constexpr uint8_t PLANE_U = 1;
47 constexpr uint8_t PLANE_V = 2;
48 constexpr uint32_t BYTES_PER_PIXEL_RGB565 = 2;
49 constexpr uint32_t BYTES_PER_PIXEL_RGB = 3;
50 constexpr uint32_t BYTES_PER_PIXEL_RGBA = 4;
51 constexpr uint32_t BYTES_PER_PIXEL_BGRA = 4;
52 constexpr uint32_t STRIDES_PER_PLANE = 8;
53 }
54
55 #undef LOG_DOMAIN
56 #define LOG_DOMAIN LOG_TAG_DOMAIN_ID_IMAGE
57
58 #undef LOG_TAG
59 #define LOG_TAG "ImageFormatConvert"
60
61 namespace OHOS {
62 namespace Media {
63 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
64 using namespace HDI::Display::Graphic::Common::V1_0;
65 #endif
66
__anon3196f56a0202() 67 static const std::map<std::pair<PixelFormat, PixelFormat>, ConvertFunction> g_cvtFuncMap = []() {
68 #ifndef EXT_PIXEL
69 static const std::map<std::pair<PixelFormat, PixelFormat>, ConvertFunction> cvtFuncMap = {
70 {std::make_pair(PixelFormat::RGB_565, PixelFormat::NV21), ImageFormatConvertUtils::RGB565ToNV21},
71 {std::make_pair(PixelFormat::RGB_565, PixelFormat::NV12), ImageFormatConvertUtils::RGB565ToNV12},
72 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::NV21), ImageFormatConvertUtils::RGBAToNV21},
73 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::NV12), ImageFormatConvertUtils::RGBAToNV12},
74 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::NV21), ImageFormatConvertUtils::BGRAToNV21},
75 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::NV12), ImageFormatConvertUtils::BGRAToNV12},
76 {std::make_pair(PixelFormat::RGB_888, PixelFormat::NV21), ImageFormatConvertUtils::RGBToNV21},
77 {std::make_pair(PixelFormat::RGB_888, PixelFormat::NV12), ImageFormatConvertUtils::RGBToNV12},
78 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::NV21), ImageFormatConvertUtils::RGBAF16ToNV21},
79 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::NV12), ImageFormatConvertUtils::RGBAF16ToNV12},
80 {std::make_pair(PixelFormat::RGB_565, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::RGB565ToNV12P010},
81 {std::make_pair(PixelFormat::RGB_565, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::RGB565ToNV21P010},
82 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::RGBAToNV12P010},
83 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::RGBAToNV21P010},
84 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::BGRAToNV12P010},
85 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::BGRAToNV21P010},
86 {std::make_pair(PixelFormat::RGB_888, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::RGBToNV12P010},
87 {std::make_pair(PixelFormat::RGB_888, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::RGBToNV21P010},
88 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::RGBAF16ToNV12P010},
89 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::RGBAF16ToNV21P010},
90 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::NV12), ImageFormatConvertUtils::RGBA1010102ToNV12},
91 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::NV21), ImageFormatConvertUtils::RGBA1010102ToNV21},
92 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::YCBCR_P010),
93 ImageFormatConvertUtils::RGBA1010102ToNV12P010},
94 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::YCRCB_P010),
95 ImageFormatConvertUtils::RGBA1010102ToNV21P010},
96 };
97 #else
98 static const std::map<std::pair<PixelFormat, PixelFormat>, ConvertFunction> cvtFuncMap = {
99 {std::make_pair(PixelFormat::RGB_565, PixelFormat::NV21), ImageFormatConvertExtUtils::RGB565ToNV21},
100 {std::make_pair(PixelFormat::RGB_565, PixelFormat::NV12), ImageFormatConvertExtUtils::RGB565ToNV12},
101 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::NV21), ImageFormatConvertExtUtils::RGBAToNV21},
102 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::NV12), ImageFormatConvertExtUtils::RGBAToNV12},
103 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::NV21), ImageFormatConvertExtUtils::BGRAToNV21},
104 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::NV12), ImageFormatConvertExtUtils::BGRAToNV12},
105 {std::make_pair(PixelFormat::RGB_888, PixelFormat::NV21), ImageFormatConvertUtils::RGBToNV21},
106 {std::make_pair(PixelFormat::RGB_888, PixelFormat::NV12), ImageFormatConvertUtils::RGBToNV12},
107 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::NV21), ImageFormatConvertUtils::RGBAF16ToNV21},
108 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::NV12), ImageFormatConvertUtils::RGBAF16ToNV12},
109 {std::make_pair(PixelFormat::RGB_565, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::RGB565ToNV12P010},
110 {std::make_pair(PixelFormat::RGB_565, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::RGB565ToNV21P010},
111 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::RGBAToNV12P010},
112 {std::make_pair(PixelFormat::RGBA_8888, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::RGBAToNV21P010},
113 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::BGRAToNV12P010},
114 {std::make_pair(PixelFormat::BGRA_8888, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::BGRAToNV21P010},
115 {std::make_pair(PixelFormat::RGB_888, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::RGBToNV12P010},
116 {std::make_pair(PixelFormat::RGB_888, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::RGBToNV21P010},
117 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::NV12), ImageFormatConvertExtUtils::RGBA1010102ToNV12},
118 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::NV21), ImageFormatConvertExtUtils::RGBA1010102ToNV21},
119 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::YCBCR_P010),
120 ImageFormatConvertUtils::RGBA1010102ToNV12P010},
121 {std::make_pair(PixelFormat::RGBA_1010102, PixelFormat::YCRCB_P010),
122 ImageFormatConvertUtils::RGBA1010102ToNV21P010},
123 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::RGBAF16ToNV12P010},
124 {std::make_pair(PixelFormat::RGBA_F16, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::RGBAF16ToNV21P010},
125 };
126 #endif
127 return cvtFuncMap;
128 }();
129
__anon3196f56a0302() 130 static const std::map<std::pair<PixelFormat, PixelFormat>, YUVConvertFunction> g_yuvCvtFuncMap = []() {
131 #ifndef EXT_PIXEL
132 std::map<std::pair<PixelFormat, PixelFormat>, YUVConvertFunction> yuvCvtFuncMap = {
133 {std::make_pair(PixelFormat::NV12, PixelFormat::NV21), ImageFormatConvertUtils::NV12ToNV21},
134 {std::make_pair(PixelFormat::NV12, PixelFormat::RGB_888), ImageFormatConvertUtils::NV12ToRGB},
135 {std::make_pair(PixelFormat::NV12, PixelFormat::RGB_565), ImageFormatConvertUtils::NV12ToRGB565},
136 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV12ToRGBAF16},
137 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_8888), ImageFormatConvertUtils::NV12ToRGBA},
138 {std::make_pair(PixelFormat::NV12, PixelFormat::BGRA_8888), ImageFormatConvertUtils::NV12ToBGRA},
139 {std::make_pair(PixelFormat::NV21, PixelFormat::NV12), ImageFormatConvertUtils::NV21ToNV12},
140 {std::make_pair(PixelFormat::NV21, PixelFormat::RGB_888), ImageFormatConvertUtils::NV21ToRGB},
141 {std::make_pair(PixelFormat::NV21, PixelFormat::RGB_565), ImageFormatConvertUtils::NV21ToRGB565},
142 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV21ToRGBAF16},
143 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_8888), ImageFormatConvertUtils::NV21ToRGBA},
144 {std::make_pair(PixelFormat::NV21, PixelFormat::BGRA_8888), ImageFormatConvertUtils::NV21ToBGRA},
145 {std::make_pair(PixelFormat::NV12, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::NV12ToNV12P010},
146 {std::make_pair(PixelFormat::NV12, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::NV12ToNV21P010},
147 {std::make_pair(PixelFormat::NV21, PixelFormat::YCBCR_P010), ImageFormatConvertUtils::NV21ToNV12P010},
148 {std::make_pair(PixelFormat::NV21, PixelFormat::YCRCB_P010), ImageFormatConvertUtils::NV21ToNV21P010},
149 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_1010102), ImageFormatConvertUtils::NV12ToRGBA1010102},
150 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_1010102), ImageFormatConvertUtils::NV21ToRGBA1010102},
151 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::NV12), ImageFormatConvertUtils::NV12P010ToNV12},
152 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::NV21), ImageFormatConvertUtils::NV12P010ToNV21},
153 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::YCRCB_P010),
154 ImageFormatConvertUtils::NV12P010ToNV21P010},
155 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGB_565), ImageFormatConvertUtils::NV12P010ToRGB565},
156 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_8888), ImageFormatConvertUtils::NV12P010ToRGBA8888},
157 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::BGRA_8888), ImageFormatConvertUtils::NV12P010ToBGRA8888},
158 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGB_888), ImageFormatConvertUtils::NV12P010ToRGB888},
159 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV12P010ToRGBAF16},
160 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::NV12), ImageFormatConvertUtils::NV21P010ToNV12},
161 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::NV21), ImageFormatConvertUtils::NV21P010ToNV21},
162 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::YCBCR_P010),
163 ImageFormatConvertUtils::NV21P010ToNV12P010},
164 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_1010102),
165 ImageFormatConvertUtils::NV12P010ToRGBA1010102},
166 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGB_565), ImageFormatConvertUtils::NV21P010ToRGB565},
167 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_8888), ImageFormatConvertUtils::NV21P010ToRGBA8888},
168 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::BGRA_8888), ImageFormatConvertUtils::NV21P010ToBGRA8888},
169 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGB_888), ImageFormatConvertUtils::NV21P010ToRGB888},
170 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV21P010ToRGBAF16},
171 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_1010102),
172 ImageFormatConvertUtils::NV21P010ToRGBA1010102},
173 };
174 #else
175 std::map<std::pair<PixelFormat, PixelFormat>, YUVConvertFunction> yuvCvtFuncMap = {
176 {std::make_pair(PixelFormat::NV21, PixelFormat::RGB_888), ImageFormatConvertExtUtils::NV21ToRGB},
177 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_8888), ImageFormatConvertExtUtils::NV21ToRGBA},
178 {std::make_pair(PixelFormat::NV21, PixelFormat::BGRA_8888), ImageFormatConvertExtUtils::NV21ToBGRA},
179 {std::make_pair(PixelFormat::NV21, PixelFormat::RGB_565), ImageFormatConvertExtUtils::NV21ToRGB565},
180 {std::make_pair(PixelFormat::NV12, PixelFormat::RGB_565), ImageFormatConvertExtUtils::NV12ToRGB565},
181 {std::make_pair(PixelFormat::NV21, PixelFormat::NV12), ImageFormatConvertUtils::NV21ToNV12},
182 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV21ToRGBAF16},
183 {std::make_pair(PixelFormat::NV12, PixelFormat::NV21), ImageFormatConvertUtils::NV12ToNV21},
184 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV12ToRGBAF16},
185 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_8888), ImageFormatConvertExtUtils::NV12ToRGBA},
186 {std::make_pair(PixelFormat::NV12, PixelFormat::BGRA_8888), ImageFormatConvertExtUtils::NV12ToBGRA},
187 {std::make_pair(PixelFormat::NV12, PixelFormat::RGB_888), ImageFormatConvertExtUtils::NV12ToRGB},
188 {std::make_pair(PixelFormat::NV12, PixelFormat::RGBA_1010102), ImageFormatConvertExtUtils::NV12ToRGBA1010102},
189 {std::make_pair(PixelFormat::NV21, PixelFormat::RGBA_1010102), ImageFormatConvertExtUtils::NV21ToRGBA1010102},
190 {std::make_pair(PixelFormat::NV12, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::NV12ToNV12P010},
191 {std::make_pair(PixelFormat::NV12, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::NV12ToNV21P010},
192 {std::make_pair(PixelFormat::NV21, PixelFormat::YCBCR_P010), ImageFormatConvertExtUtils::NV21ToNV12P010},
193 {std::make_pair(PixelFormat::NV21, PixelFormat::YCRCB_P010), ImageFormatConvertExtUtils::NV21ToNV21P010},
194 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::NV12), ImageFormatConvertExtUtils::NV12P010ToNV12},
195 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::NV21), ImageFormatConvertExtUtils::NV12P010ToNV21},
196 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::YCRCB_P010),
197 ImageFormatConvertUtils::NV12P010ToNV21P010},
198 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGB_565), ImageFormatConvertExtUtils::NV12P010ToRGB565},
199 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_8888),
200 ImageFormatConvertExtUtils::NV12P010ToRGBA8888},
201 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::BGRA_8888),
202 ImageFormatConvertExtUtils::NV12P010ToBGRA8888},
203 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGB_888), ImageFormatConvertExtUtils::NV12P010ToRGB888},
204 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV12P010ToRGBAF16},
205 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::NV12), ImageFormatConvertExtUtils::NV21P010ToNV12},
206 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::NV21), ImageFormatConvertExtUtils::NV21P010ToNV21},
207 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::YCBCR_P010),
208 ImageFormatConvertUtils::NV21P010ToNV12P010},
209 {std::make_pair(PixelFormat::YCBCR_P010, PixelFormat::RGBA_1010102),
210 ImageFormatConvertExtUtils::NV12P010ToRGBA1010102},
211 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGB_565), ImageFormatConvertExtUtils::NV21P010ToRGB565},
212 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_8888),
213 ImageFormatConvertExtUtils::NV21P010ToRGBA8888},
214 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::BGRA_8888),
215 ImageFormatConvertExtUtils::NV21P010ToBGRA8888},
216 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGB_888), ImageFormatConvertExtUtils::NV21P010ToRGB888},
217 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_F16), ImageFormatConvertUtils::NV21P010ToRGBAF16},
218 {std::make_pair(PixelFormat::YCRCB_P010, PixelFormat::RGBA_1010102),
219 ImageFormatConvertExtUtils::NV21P010ToRGBA1010102},
220 };
221 #endif
222 return yuvCvtFuncMap;
223 }();
224
CalcRGBStride(PixelFormat format,uint32_t width,uint32_t & stride)225 static void CalcRGBStride(PixelFormat format, uint32_t width, uint32_t &stride)
226 {
227 switch (format) {
228 case PixelFormat::RGB_565:
229 stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGB565);
230 break;
231 case PixelFormat::RGBA_8888:
232 stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGBA);
233 break;
234 case PixelFormat::BGRA_8888:
235 stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_BGRA);
236 break;
237 case PixelFormat::RGB_888:
238 stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGB);
239 break;
240 case PixelFormat::RGBA_F16:
241 stride = static_cast<uint32_t>(width * STRIDES_PER_PLANE);
242 break;
243 default:
244 stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGBA);
245 }
246 }
247
ConvertImageFormat(const ConvertDataInfo & srcDataInfo,DestConvertInfo & destInfo)248 uint32_t ImageFormatConvert::ConvertImageFormat(const ConvertDataInfo &srcDataInfo, DestConvertInfo &destInfo)
249 {
250 if (!CheckConvertDataInfo(srcDataInfo)) {
251 IMAGE_LOGE("source convert data info is invalid");
252 return ERR_IMAGE_INVALID_PARAMETER;
253 }
254 if (!IsSupport(destInfo.format)) {
255 IMAGE_LOGE("destination format is not support or invalid");
256 return ERR_IMAGE_INVALID_PARAMETER;
257 }
258 ConvertFunction cvtFunc = GetConvertFuncByFormat(srcDataInfo.pixelFormat, destInfo.format);
259 if (cvtFunc == nullptr) {
260 IMAGE_LOGE("get convert function by format failed!");
261 return ERR_IMAGE_INVALID_PARAMETER;
262 }
263 YUVStrideInfo dstStrides;
264 auto m = CreateMemory(destInfo.format, destInfo.allocType, destInfo.width,
265 destInfo.height, dstStrides);
266 if (m == nullptr) {
267 return ERR_IMAGE_INVALID_PARAMETER;
268 }
269 destInfo.context = m->extend.data;
270 destInfo.yStride = dstStrides.yStride;
271 destInfo.uvStride = dstStrides.uvStride;
272 destInfo.yOffset = dstStrides.yOffset;
273 destInfo.uvOffset = dstStrides.uvOffset;
274 destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
275 destInfo.bufferSize = GetBufferSizeByFormat(destInfo.format, {destInfo.width, destInfo.height});
276 uint32_t srcStride = 0;
277 CalcRGBStride(srcDataInfo.pixelFormat, srcDataInfo.imageSize.width, srcStride);
278 RGBDataInfo rgbDataInfo = {srcDataInfo.imageSize.width, srcDataInfo.imageSize.height, srcStride};
279 if (!cvtFunc(srcDataInfo.buffer, rgbDataInfo, destInfo, srcDataInfo.colorSpace)) {
280 IMAGE_LOGE("format convert failed!");
281 m->Release();
282 return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
283 }
284 return SUCCESS;
285 }
286
IsYUVConvert(PixelFormat srcFormat)287 static bool IsYUVConvert(PixelFormat srcFormat)
288 {
289 bool ret = srcFormat == PixelFormat::NV21 || srcFormat == PixelFormat::NV12 ||
290 srcFormat == PixelFormat::YCBCR_P010 || srcFormat == PixelFormat::YCRCB_P010;
291 return ret;
292 }
293
ConvertImageFormat(std::shared_ptr<PixelMap> & srcPiexlMap,PixelFormat destFormat)294 uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
295 {
296 if (srcPiexlMap == nullptr) {
297 IMAGE_LOGE("source pixel map is null");
298 return ERR_IMAGE_INVALID_PARAMETER;
299 }
300 if (!IsSupport(destFormat)) {
301 IMAGE_LOGE("destination format not support");
302 return ERR_MEDIA_FORMAT_UNSUPPORT;
303 }
304 PixelFormat srcFormat = srcPiexlMap->GetPixelFormat();
305 if (IsYUVConvert(srcFormat)) {
306 uint32_t ret = 0;
307 ret = YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
308 if (ret != SUCCESS) {
309 IMAGE_LOGE("convert yuv format failed!");
310 }
311 return ret;
312 }
313 uint32_t ret = RGBConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
314 if (ret != SUCCESS) {
315 IMAGE_LOGE("convert rgb format failed!");
316 return ret;
317 }
318 return SUCCESS;
319 }
320
IsValidSize(const Size & size)321 bool ImageFormatConvert::IsValidSize(const Size &size)
322 {
323 return size.width > 0 && size.height > 0;
324 }
325
CheckConvertDataInfo(const ConvertDataInfo & convertDataInfo)326 bool ImageFormatConvert::CheckConvertDataInfo(const ConvertDataInfo &convertDataInfo)
327 {
328 if (convertDataInfo.buffer == nullptr) {
329 IMAGE_LOGE("buffer is null");
330 return false;
331 }
332
333 if (!IsSupport(convertDataInfo.pixelFormat)) {
334 IMAGE_LOGE("format is not support or invalid");
335 return false;
336 }
337
338 if (!IsValidSize(convertDataInfo.imageSize)) {
339 IMAGE_LOGE("image size is invalid");
340 return false;
341 }
342
343 if (GetBufferSizeByFormat(convertDataInfo.pixelFormat, convertDataInfo.imageSize) != convertDataInfo.bufferSize) {
344 IMAGE_LOGE("buffer size is wrong");
345 return false;
346 }
347
348 return true;
349 }
350
GetBufferSizeByFormat(PixelFormat format,const Size & size)351 size_t ImageFormatConvert::GetBufferSizeByFormat(PixelFormat format, const Size &size)
352 {
353 switch (format) {
354 case PixelFormat::RGB_565:{
355 return size.width * size.height * NUM_2;
356 }
357 case PixelFormat::RGB_888:{
358 return size.width * size.height * NUM_3;
359 }
360 case PixelFormat::ARGB_8888:
361 case PixelFormat::RGBA_8888:
362 case PixelFormat::BGRA_8888:
363 case PixelFormat::RGBA_1010102:{
364 return size.width * size.height * NUM_4;
365 }
366 case PixelFormat::RGBA_F16:{
367 return (((size.width + NUM_1) / NUM_2) * NUM_2) * size.height * NUM_8;
368 }
369 case PixelFormat::NV21:
370 case PixelFormat::NV12:{
371 return size.width * size.height + ((size.width + NUM_1) / NUM_2) *
372 ((size.height + NUM_1) / NUM_2) * NUM_2;
373 }
374 case PixelFormat::YCBCR_P010:
375 case PixelFormat::YCRCB_P010: {
376 return (size.width * size.height + ((size.width + NUM_1) / NUM_2) *
377 ((size.height + NUM_1) / NUM_2) * NUM_2) * NUM_2;
378 }
379 default:{
380 return NUM_0;
381 }
382 }
383 }
384
GetConvertFuncByFormat(PixelFormat srcFormat,PixelFormat destFormat)385 ConvertFunction ImageFormatConvert::GetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat)
386 {
387 auto iter = g_cvtFuncMap.find(std::make_pair(srcFormat, destFormat));
388 if (iter == g_cvtFuncMap.end()) {
389 IMAGE_LOGE("current format is not supported or format is wrong");
390 return nullptr;
391 }
392 return iter->second;
393 }
394
YUVGetConvertFuncByFormat(PixelFormat srcFormat,PixelFormat destFormat)395 YUVConvertFunction ImageFormatConvert::YUVGetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat)
396 {
397 auto iter = g_yuvCvtFuncMap.find(std::make_pair(srcFormat, destFormat));
398 if (iter == g_yuvCvtFuncMap.end()) {
399 IMAGE_LOGE("current format is not supported or format is wrong");
400 return nullptr;
401 }
402 return iter->second;
403 }
404
IsSupport(PixelFormat format)405 bool ImageFormatConvert::IsSupport(PixelFormat format)
406 {
407 switch (format) {
408 case PixelFormat::ARGB_8888:
409 case PixelFormat::RGB_565:
410 case PixelFormat::RGBA_8888:
411 case PixelFormat::BGRA_8888:
412 case PixelFormat::RGB_888:
413 case PixelFormat::RGBA_F16:
414 case PixelFormat::RGBA_1010102:
415 case PixelFormat::YCBCR_P010:
416 case PixelFormat::YCRCB_P010:
417 case PixelFormat::NV21:
418 case PixelFormat::NV12:{
419 return true;
420 }
421 default:{
422 return false;
423 }
424 }
425 }
426
427 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
GetYUVStrideInfo(int32_t pixelFmt,OH_NativeBuffer_Planes * planes,YUVStrideInfo & dstStrides)428 static void GetYUVStrideInfo(int32_t pixelFmt, OH_NativeBuffer_Planes *planes, YUVStrideInfo &dstStrides)
429 {
430 if (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_420_SP) {
431 auto yStride = planes->planes[PLANE_Y].columnStride;
432 auto uvStride = planes->planes[PLANE_U].columnStride;
433 auto yOffset = planes->planes[PLANE_Y].offset;
434 auto uvOffset = planes->planes[PLANE_U].offset;
435 dstStrides = {yStride, uvStride, yOffset, uvOffset};
436 } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCRCB_420_SP) {
437 auto yStride = planes->planes[PLANE_Y].columnStride;
438 auto uvStride = planes->planes[PLANE_V].columnStride;
439 auto yOffset = planes->planes[PLANE_Y].offset;
440 auto uvOffset = planes->planes[PLANE_V].offset;
441 dstStrides = {yStride, uvStride, yOffset, uvOffset};
442 } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_P010) {
443 auto yStride = planes->planes[PLANE_Y].columnStride / 2;
444 auto uvStride = planes->planes[PLANE_U].columnStride / 2;
445 auto yOffset = planes->planes[PLANE_Y].offset / 2;
446 auto uvOffset = planes->planes[PLANE_U].offset / 2;
447 dstStrides = {yStride, uvStride, yOffset, uvOffset};
448 } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCRCB_P010) {
449 auto yStride = planes->planes[PLANE_Y].columnStride / 2;
450 auto uvStride = planes->planes[PLANE_V].columnStride / 2;
451 auto yOffset = planes->planes[PLANE_Y].offset / 2;
452 auto uvOffset = planes->planes[PLANE_V].offset / 2;
453 dstStrides = {yStride, uvStride, yOffset, uvOffset};
454 }
455 }
456 #endif
457
CreateMemory(PixelFormat pixelFormat,AllocatorType allocatorType,int32_t width,int32_t height,YUVStrideInfo & strides)458 std::unique_ptr<AbsMemory> ImageFormatConvert::CreateMemory(PixelFormat pixelFormat, AllocatorType allocatorType,
459 int32_t width, int32_t height, YUVStrideInfo &strides)
460 {
461 if (width == 0 || height == 0 || pixelFormat == PixelFormat::UNKNOWN) {
462 IMAGE_LOGE("CreateMemory err ERR_IMAGE_INVALID_PARAMETER!");
463 return nullptr;
464 }
465 uint32_t pictureSize = GetBufferSizeByFormat(pixelFormat, {width, height});
466 if (IsYUVConvert(pixelFormat)) {
467 strides = {width, (width + 1) / NUM_2 * NUM_2, 0, width * height};
468 } else {
469 uint32_t stride = 0;
470 CalcRGBStride(pixelFormat, width, stride);
471 strides = {stride, 0, 0, 0};
472 }
473 MemoryData memoryData = {nullptr, pictureSize, "PixelConvert", {width, height}, pixelFormat};
474 auto m = MemoryManager::CreateMemory(allocatorType, memoryData);
475 if (m == nullptr) {
476 IMAGE_LOGE("CreateMemory failed");
477 return m;
478 }
479 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
480 if (allocatorType != AllocatorType::DMA_ALLOC) {
481 return m;
482 }
483 if (m->extend.data == nullptr) {
484 IMAGE_LOGE("CreateMemory get surfacebuffer failed");
485 return m;
486 }
487 auto sb = reinterpret_cast<SurfaceBuffer*>(m->extend.data);
488 OH_NativeBuffer_Planes *planes = nullptr;
489 GSError retVal = sb->GetPlanesInfo(reinterpret_cast<void**>(&planes));
490 auto stride = sb->GetStride();
491 strides = {stride, 0, 0, 0};
492 if (retVal != OHOS::GSERROR_OK || planes == nullptr) {
493 IMAGE_LOGE("CreateMemory Get planesInfo failed, retVal:%{public}d", retVal);
494 } else if (planes->planeCount >= NUM_2) {
495 int32_t pixelFmt = sb->GetFormat();
496 GetYUVStrideInfo(pixelFmt, planes, strides);
497 }
498 #endif
499 return m;
500 }
501
RGBConvertImageFormatOption(std::shared_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)502 uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
503 const PixelFormat &srcFormat, PixelFormat destFormat)
504 {
505 ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
506 if (cvtFunc == nullptr) {
507 IMAGE_LOGE("get convert function by format failed!");
508 return ERR_IMAGE_INVALID_PARAMETER;
509 }
510 const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
511 ImageInfo imageInfo;
512 srcPiexlMap->GetImageInfo(imageInfo);
513
514 int32_t width = imageInfo.size.width;
515 int32_t height = imageInfo.size.height;
516 YUVStrideInfo dstStrides;
517 auto allocType = srcPiexlMap->GetAllocatorType();
518 auto m = CreateMemory(destFormat, allocType, width, height, dstStrides);
519 if (m == nullptr) {
520 IMAGE_LOGE("CreateMemory failed");
521 return ERR_IMAGE_INVALID_PARAMETER;
522 }
523 int32_t stride = srcPiexlMap->GetRowStride();
524 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
525 if (allocType == AllocatorType::DMA_ALLOC) {
526 auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
527 stride = sb->GetStride();
528 sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
529 sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
530 VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
531 }
532 #endif
533 RGBDataInfo rgbDataInfo = {width, height, static_cast<uint32_t>(stride)};
534 DestConvertInfo destInfo = {width, height, destFormat, allocType};
535 destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
536 destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
537 destInfo.yStride = dstStrides.yStride;
538 destInfo.uvStride = dstStrides.uvStride;
539 destInfo.yOffset = dstStrides.yOffset;
540 destInfo.uvOffset = dstStrides.uvOffset;
541 if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
542 IMAGE_LOGE("format convert failed!");
543 m->Release();
544 return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
545 }
546 auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
547 if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
548 m->Release();
549 }
550 return ret;
551 }
552
RGBConvertImageFormatOptionUnique(std::unique_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)553 uint32_t ImageFormatConvert::RGBConvertImageFormatOptionUnique(
554 std::unique_ptr<PixelMap> &srcPiexlMap, const PixelFormat &srcFormat, PixelFormat destFormat)
555 {
556 ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
557 if (cvtFunc == nullptr) {
558 IMAGE_LOGE("get convert function by format failed!");
559 return ERR_IMAGE_INVALID_PARAMETER;
560 }
561 const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
562 ImageInfo imageInfo;
563 srcPiexlMap->GetImageInfo(imageInfo);
564
565 int32_t width = imageInfo.size.width;
566 int32_t height = imageInfo.size.height;
567 YUVStrideInfo dstStrides;
568 auto allocType = srcPiexlMap->GetAllocatorType();
569 auto memory = CreateMemory(destFormat, allocType, width, height, dstStrides);
570 if (memory == nullptr) {
571 IMAGE_LOGE("CreateMemory failed");
572 return ERR_IMAGE_INVALID_PARAMETER;
573 }
574 int32_t stride = srcPiexlMap->GetRowStride();
575 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
576 if (allocType == AllocatorType::DMA_ALLOC) {
577 auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
578 stride = sb->GetStride();
579 sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
580 sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(memory->extend.data));
581 VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
582 }
583 #endif
584 RGBDataInfo rgbDataInfo = {width, height, static_cast<uint32_t>(stride)};
585 DestConvertInfo destInfo = {width, height, destFormat, allocType};
586 destInfo.buffer = reinterpret_cast<uint8_t *>(memory->data.data);
587 destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
588 destInfo.yStride = dstStrides.yStride;
589 destInfo.uvStride = dstStrides.uvStride;
590 destInfo.yOffset = dstStrides.yOffset;
591 destInfo.uvOffset = dstStrides.uvOffset;
592 if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
593 IMAGE_LOGE("format convert failed!");
594 memory->Release();
595 return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
596 }
597 auto ret = MakeDestPixelMapUnique(srcPiexlMap, imageInfo, destInfo, memory->extend.data);
598 if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
599 memory->Release();
600 }
601 return ret;
602 }
603
GetAllocatorType(std::shared_ptr<PixelMap> & srcPiexlMap,PixelFormat destFormat)604 static AllocatorType GetAllocatorType(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
605 {
606 auto allocType = srcPiexlMap->GetAllocatorType();
607 if (destFormat == PixelFormat::RGB_888 || destFormat == PixelFormat::RGB_565 ||
608 destFormat == PixelFormat::RGBA_F16) {
609 allocType = AllocatorType::SHARE_MEM_ALLOC;
610 }
611 return allocType;
612 }
613
YUVConvertImageFormatOption(std::shared_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)614 uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
615 const PixelFormat &srcFormat, PixelFormat destFormat)
616 {
617 YUVConvertFunction yuvCvtFunc = YUVGetConvertFuncByFormat(srcFormat, destFormat);
618 if (yuvCvtFunc == nullptr) {
619 return ERR_IMAGE_INVALID_PARAMETER;
620 }
621 const_uint8_buffer_type data = srcPiexlMap->GetPixels();
622 YUVDataInfo yDInfo;
623 srcPiexlMap->GetImageYUVInfo(yDInfo);
624 ImageInfo imageInfo;
625 srcPiexlMap->GetImageInfo(imageInfo);
626 if ((srcFormat == PixelFormat::NV21 || srcFormat == PixelFormat::YCBCR_P010 ||
627 srcFormat == PixelFormat::YCRCB_P010) &&
628 (yDInfo.yWidth == 0 || yDInfo.yHeight == 0 || yDInfo.uvWidth == 0 || yDInfo.uvHeight == 0)) {
629 yDInfo.yWidth = static_cast<uint32_t>(imageInfo.size.width);
630 yDInfo.yHeight = static_cast<uint32_t>(imageInfo.size.height);
631 yDInfo.uvWidth = static_cast<uint32_t>((imageInfo.size.width + 1) / NUM_2);
632 yDInfo.uvHeight = static_cast<uint32_t>((imageInfo.size.height + 1) / NUM_2);
633 }
634 YUVStrideInfo dstStrides;
635 auto allocType = GetAllocatorType(srcPiexlMap, destFormat);
636 DestConvertInfo destInfo = {imageInfo.size.width, imageInfo.size.height, destFormat, allocType};
637 auto m = CreateMemory(destFormat, allocType, destInfo.width, destInfo.height, dstStrides);
638 if (m == nullptr) {
639 return ERR_IMAGE_INVALID_PARAMETER;
640 }
641 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
642 if (allocType == AllocatorType::DMA_ALLOC) {
643 sptr<SurfaceBuffer> sourceSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd()));
644 sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
645 VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
646 }
647 #endif
648 destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
649 destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
650 destInfo.yStride = dstStrides.yStride;
651 destInfo.uvStride = dstStrides.uvStride;
652 destInfo.yOffset = dstStrides.yOffset;
653 destInfo.uvOffset = dstStrides.uvOffset;
654 if (!yuvCvtFunc(data, yDInfo, destInfo, srcPiexlMap->GetColorSpace())) {
655 m->Release();
656 return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
657 }
658 auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
659 if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
660 m->Release();
661 }
662 return ret;
663 }
664
MakeDestPixelMap(std::shared_ptr<PixelMap> & destPixelMap,ImageInfo & srcImageinfo,DestConvertInfo & destInfo,void * context)665 uint32_t ImageFormatConvert::MakeDestPixelMap(std::shared_ptr<PixelMap> &destPixelMap, ImageInfo &srcImageinfo,
666 DestConvertInfo &destInfo, void *context)
667 {
668 if (srcImageinfo.size.width == 0 || srcImageinfo.size.height == 0 || destInfo.width == 0
669 || destInfo.height == 0 || destInfo.format == PixelFormat::UNKNOWN) {
670 return ERR_IMAGE_INVALID_PARAMETER;
671 }
672 ImageInfo info;
673 info.alphaType = srcImageinfo.alphaType;
674 info.baseDensity = srcImageinfo.baseDensity;
675 info.colorSpace = srcImageinfo.colorSpace;
676 info.pixelFormat = destInfo.format;
677 info.size = {destInfo.width, destInfo.height};
678 auto allcatorType = destInfo.allocType;
679 std::unique_ptr<PixelMap> pixelMap;
680 if (info.pixelFormat == PixelFormat::NV21 || info.pixelFormat == PixelFormat::NV12 ||
681 info.pixelFormat == PixelFormat::YCBCR_P010 || info.pixelFormat == PixelFormat::YCRCB_P010) {
682 #ifdef EXT_PIXEL
683 pixelMap = std::make_unique<PixelYuvExt>();
684 #else
685 pixelMap = std::make_unique<PixelYuv>();
686 #endif
687 if (pixelMap == nullptr) {
688 return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
689 }
690 if (allcatorType != AllocatorType::DMA_ALLOC) {
691 pixelMap->AssignYuvDataOnType(info.pixelFormat, info.size.width, info.size.height);
692 } else {
693 YUVStrideInfo strides = {destInfo.yStride, destInfo.uvStride, destInfo.yOffset, destInfo.uvOffset};
694 pixelMap->UpdateYUVDataInfo(info.pixelFormat, info.size.width, info.size.height, strides);
695 }
696 } else {
697 pixelMap = std::make_unique<PixelMap>();
698 if (pixelMap == nullptr) {
699 return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
700 }
701 }
702
703 pixelMap->SetPixelsAddr(destInfo.buffer, context, destInfo.bufferSize, allcatorType, nullptr);
704 auto ret = pixelMap->SetImageInfo(info, true);
705 if (ret != SUCCESS) {
706 IMAGE_LOGE("set imageInfo failed");
707 return ret;
708 }
709 #ifdef IMAGE_COLORSPACE_FLAG
710 if (info.pixelFormat == PixelFormat::RGBA_1010102 || info.pixelFormat == PixelFormat::YCBCR_P010 ||
711 info.pixelFormat == PixelFormat::YCRCB_P010) {
712 pixelMap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(ColorManager::ColorSpaceName::BT2020_HLG));
713 }
714 #endif
715 destPixelMap = std::move(pixelMap);
716 return SUCCESS;
717 }
718
MakeDestPixelMapUnique(std::unique_ptr<PixelMap> & destPixelMap,ImageInfo & srcImageinfo,DestConvertInfo & destInfo,void * context)719 uint32_t ImageFormatConvert::MakeDestPixelMapUnique(std::unique_ptr<PixelMap> &destPixelMap, ImageInfo &srcImageinfo,
720 DestConvertInfo &destInfo, void *context)
721 {
722 if (srcImageinfo.size.width == 0 || srcImageinfo.size.height == 0 || destInfo.width == 0 ||
723 destInfo.height == 0 || destInfo.format == PixelFormat::UNKNOWN) {
724 return ERR_IMAGE_INVALID_PARAMETER;
725 }
726 ImageInfo info;
727 info.alphaType = srcImageinfo.alphaType;
728 info.baseDensity = srcImageinfo.baseDensity;
729 info.colorSpace = srcImageinfo.colorSpace;
730 info.pixelFormat = destInfo.format;
731 info.size = {destInfo.width, destInfo.height};
732 auto allcatorType = destInfo.allocType;
733 std::unique_ptr<PixelMap> pixelMap;
734 if (info.pixelFormat == PixelFormat::NV21 || info.pixelFormat == PixelFormat::NV12 ||
735 info.pixelFormat == PixelFormat::YCBCR_P010 || info.pixelFormat == PixelFormat::YCRCB_P010) {
736 #ifdef EXT_PIXEL
737 pixelMap = std::make_unique<PixelYuvExt>();
738 #else
739 pixelMap = std::make_unique<PixelYuv>();
740 #endif
741 if (pixelMap == nullptr) {
742 return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
743 }
744 if (allcatorType != AllocatorType::DMA_ALLOC) {
745 pixelMap->AssignYuvDataOnType(info.pixelFormat, info.size.width, info.size.height);
746 } else {
747 YUVStrideInfo strides = {destInfo.yStride, destInfo.uvStride, destInfo.yOffset, destInfo.uvOffset};
748 pixelMap->UpdateYUVDataInfo(info.pixelFormat, info.size.width, info.size.height, strides);
749 }
750 } else {
751 pixelMap = std::make_unique<PixelMap>();
752 if (pixelMap == nullptr) {
753 return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
754 }
755 }
756
757 pixelMap->SetPixelsAddr(destInfo.buffer, context, destInfo.bufferSize, allcatorType, nullptr);
758 auto ret = pixelMap->SetImageInfo(info, true);
759 if (ret != SUCCESS) {
760 IMAGE_LOGE("set imageInfo failed");
761 return ret;
762 }
763 #ifdef IMAGE_COLORSPACE_FLAG
764 if (info.pixelFormat == PixelFormat::RGBA_1010102 || info.pixelFormat == PixelFormat::YCBCR_P010 ||
765 info.pixelFormat == PixelFormat::YCRCB_P010) {
766 pixelMap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(ColorManager::ColorSpaceName::BT2020_HLG));
767 }
768 #endif
769 destPixelMap = std::move(pixelMap);
770 return SUCCESS;
771 }
772 } // namespace Media
773 } // namespace OHOS