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 
__anonf075f8a20202() 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 
__anonf075f8a20302() 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 
225 static const std::set<std::pair<PixelFormat, PixelFormat>> conversions = {
226     {PixelFormat::NV12, PixelFormat::RGBA_1010102},
227     {PixelFormat::NV21, PixelFormat::RGBA_1010102},
228     {PixelFormat::RGB_565, PixelFormat::YCBCR_P010},
229     {PixelFormat::RGBA_8888, PixelFormat::YCBCR_P010},
230     {PixelFormat::BGRA_8888, PixelFormat::YCBCR_P010},
231     {PixelFormat::RGB_888, PixelFormat::YCBCR_P010},
232     {PixelFormat::RGBA_F16, PixelFormat::YCBCR_P010},
233     {PixelFormat::RGB_565, PixelFormat::YCRCB_P010},
234     {PixelFormat::RGBA_8888, PixelFormat::YCRCB_P010},
235     {PixelFormat::BGRA_8888, PixelFormat::YCRCB_P010},
236     {PixelFormat::RGB_888, PixelFormat::YCRCB_P010},
237     {PixelFormat::RGBA_F16, PixelFormat::YCRCB_P010}
238 };
239 
CalcRGBStride(PixelFormat format,uint32_t width,uint32_t & stride)240 static void CalcRGBStride(PixelFormat format, uint32_t width, uint32_t &stride)
241 {
242     switch (format) {
243         case PixelFormat::RGB_565:
244             stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGB565);
245             break;
246         case PixelFormat::RGBA_8888:
247             stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGBA);
248             break;
249         case PixelFormat::BGRA_8888:
250             stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_BGRA);
251             break;
252         case PixelFormat::RGB_888:
253             stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGB);
254             break;
255         case PixelFormat::RGBA_F16:
256             stride = static_cast<uint32_t>(width * STRIDES_PER_PLANE);
257             break;
258         default:
259             stride = static_cast<uint32_t>(width * BYTES_PER_PIXEL_RGBA);
260     }
261 }
262 
ConvertImageFormat(const ConvertDataInfo & srcDataInfo,DestConvertInfo & destInfo)263 uint32_t ImageFormatConvert::ConvertImageFormat(const ConvertDataInfo &srcDataInfo, DestConvertInfo &destInfo)
264 {
265     if (!CheckConvertDataInfo(srcDataInfo)) {
266         IMAGE_LOGE("source convert data info is invalid");
267         return ERR_IMAGE_INVALID_PARAMETER;
268     }
269     if (!IsSupport(destInfo.format)) {
270         IMAGE_LOGE("destination format is not support or invalid");
271         return ERR_IMAGE_INVALID_PARAMETER;
272     }
273     ConvertFunction cvtFunc = GetConvertFuncByFormat(srcDataInfo.pixelFormat, destInfo.format);
274     if (cvtFunc == nullptr) {
275         IMAGE_LOGE("get convert function by format failed!");
276         return ERR_IMAGE_INVALID_PARAMETER;
277     }
278     YUVStrideInfo dstStrides;
279     auto m = CreateMemory(destInfo.format, destInfo.allocType, destInfo.width,
280                           destInfo.height, dstStrides);
281     if (m == nullptr) {
282         return ERR_IMAGE_INVALID_PARAMETER;
283     }
284     destInfo.context = m->extend.data;
285     destInfo.yStride = dstStrides.yStride;
286     destInfo.uvStride = dstStrides.uvStride;
287     destInfo.yOffset = dstStrides.yOffset;
288     destInfo.uvOffset = dstStrides.uvOffset;
289     destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
290     destInfo.bufferSize = GetBufferSizeByFormat(destInfo.format, {destInfo.width, destInfo.height});
291     uint32_t srcStride = 0;
292     CalcRGBStride(srcDataInfo.pixelFormat, srcDataInfo.imageSize.width, srcStride);
293     RGBDataInfo rgbDataInfo = {srcDataInfo.imageSize.width, srcDataInfo.imageSize.height, srcStride};
294     if (!cvtFunc(srcDataInfo.buffer, rgbDataInfo, destInfo, srcDataInfo.colorSpace)) {
295         IMAGE_LOGE("format convert failed!");
296         m->Release();
297         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
298     }
299     return SUCCESS;
300 }
301 
IsYUVConvert(PixelFormat srcFormat)302 static bool IsYUVConvert(PixelFormat srcFormat)
303 {
304     bool ret = srcFormat == PixelFormat::NV21 || srcFormat == PixelFormat::NV12 ||
305         srcFormat == PixelFormat::YCBCR_P010 || srcFormat == PixelFormat::YCRCB_P010;
306     return ret;
307 }
308 
ConvertImageFormat(std::shared_ptr<PixelMap> & srcPiexlMap,PixelFormat destFormat)309 uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
310 {
311     if (srcPiexlMap == nullptr) {
312         IMAGE_LOGE("source pixel map is null");
313         return ERR_IMAGE_INVALID_PARAMETER;
314     }
315     if (!IsSupport(destFormat)) {
316         IMAGE_LOGE("destination format not support");
317         return ERR_MEDIA_FORMAT_UNSUPPORT;
318     }
319     PixelFormat srcFormat = srcPiexlMap->GetPixelFormat();
320     if (IsYUVConvert(srcFormat)) {
321         uint32_t ret = 0;
322         ret = YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
323         if (ret != SUCCESS) {
324             IMAGE_LOGE("convert yuv format failed!");
325         }
326         return ret;
327     }
328     uint32_t ret = RGBConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
329     if (ret != SUCCESS) {
330         IMAGE_LOGE("convert rgb format failed!");
331         return ret;
332     }
333     return SUCCESS;
334 }
335 
SetConvertImageMetaData(PixelMap * srcPixelMap,PixelMap * dstPixelMap)336 bool ImageFormatConvert::SetConvertImageMetaData(PixelMap *srcPixelMap, PixelMap *dstPixelMap)
337 {
338     if (srcPixelMap == nullptr || dstPixelMap == nullptr) {
339         return false;
340     }
341     auto hdrMetadata = srcPixelMap->GetHdrMetadata();
342     if (hdrMetadata != nullptr) {
343         dstPixelMap->SetHdrMetadata(hdrMetadata);
344     }
345     auto exifData = srcPixelMap->GetExifMetadata();
346     if (exifData != nullptr) {
347         dstPixelMap->SetExifMetadata(exifData);
348     }
349     return true;
350 }
351 
352 
IsValidSize(const Size & size)353 bool ImageFormatConvert::IsValidSize(const Size &size)
354 {
355     return size.width > 0 && size.height > 0;
356 }
357 
CheckConvertDataInfo(const ConvertDataInfo & convertDataInfo)358 bool ImageFormatConvert::CheckConvertDataInfo(const ConvertDataInfo &convertDataInfo)
359 {
360     if (convertDataInfo.buffer == nullptr) {
361         IMAGE_LOGE("buffer is null");
362         return false;
363     }
364 
365     if (!IsSupport(convertDataInfo.pixelFormat)) {
366         IMAGE_LOGE("format is not support or invalid");
367         return false;
368     }
369 
370     if (!IsValidSize(convertDataInfo.imageSize)) {
371         IMAGE_LOGE("image size is invalid");
372         return false;
373     }
374 
375     if (GetBufferSizeByFormat(convertDataInfo.pixelFormat, convertDataInfo.imageSize) != convertDataInfo.bufferSize) {
376         IMAGE_LOGE("buffer size is wrong");
377         return false;
378     }
379 
380     return true;
381 }
382 
GetBufferSizeByFormat(PixelFormat format,const Size & size)383 size_t ImageFormatConvert::GetBufferSizeByFormat(PixelFormat format, const Size &size)
384 {
385     switch (format) {
386         case PixelFormat::RGB_565:{
387             return size.width * size.height * NUM_2;
388         }
389         case PixelFormat::RGB_888:{
390             return size.width * size.height * NUM_3;
391         }
392         case PixelFormat::ARGB_8888:
393         case PixelFormat::RGBA_8888:
394         case PixelFormat::BGRA_8888:
395         case PixelFormat::RGBA_1010102:{
396             return size.width * size.height * NUM_4;
397         }
398         case PixelFormat::RGBA_F16:{
399             return (((size.width + NUM_1) / NUM_2) * NUM_2) * size.height * NUM_8;
400         }
401         case PixelFormat::NV21:
402         case PixelFormat::NV12:{
403             return size.width * size.height + ((size.width + NUM_1) / NUM_2) *
404                 ((size.height + NUM_1) / NUM_2) * NUM_2;
405         }
406         case PixelFormat::YCBCR_P010:
407         case PixelFormat::YCRCB_P010: {
408             return (size.width * size.height + ((size.width + NUM_1) / NUM_2) *
409                 ((size.height + NUM_1) / NUM_2) * NUM_2) * NUM_2;
410         }
411         default:{
412             return NUM_0;
413         }
414     }
415 }
416 
GetConvertFuncByFormat(PixelFormat srcFormat,PixelFormat destFormat)417 ConvertFunction ImageFormatConvert::GetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat)
418 {
419     auto iter = g_cvtFuncMap.find(std::make_pair(srcFormat, destFormat));
420     if (iter == g_cvtFuncMap.end()) {
421         IMAGE_LOGE("current format is not supported or format is wrong");
422         return nullptr;
423     }
424     return iter->second;
425 }
426 
YUVGetConvertFuncByFormat(PixelFormat srcFormat,PixelFormat destFormat)427 YUVConvertFunction ImageFormatConvert::YUVGetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat)
428 {
429     auto iter = g_yuvCvtFuncMap.find(std::make_pair(srcFormat, destFormat));
430     if (iter == g_yuvCvtFuncMap.end()) {
431         IMAGE_LOGE("current format is not supported or format is wrong");
432         return nullptr;
433     }
434     return iter->second;
435 }
436 
IsSupport(PixelFormat format)437 bool ImageFormatConvert::IsSupport(PixelFormat format)
438 {
439     switch (format) {
440         case PixelFormat::ARGB_8888:
441         case PixelFormat::RGB_565:
442         case PixelFormat::RGBA_8888:
443         case PixelFormat::BGRA_8888:
444         case PixelFormat::RGB_888:
445         case PixelFormat::RGBA_F16:
446         case PixelFormat::RGBA_1010102:
447         case PixelFormat::YCBCR_P010:
448         case PixelFormat::YCRCB_P010:
449         case PixelFormat::NV21:
450         case PixelFormat::NV12:{
451             return true;
452         }
453         default:{
454             return false;
455         }
456     }
457 }
458 
459 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
GetYUVStrideInfo(int32_t pixelFmt,OH_NativeBuffer_Planes * planes,YUVStrideInfo & dstStrides)460 static void GetYUVStrideInfo(int32_t pixelFmt, OH_NativeBuffer_Planes *planes, YUVStrideInfo &dstStrides)
461 {
462     if (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_420_SP) {
463         auto yStride = planes->planes[PLANE_Y].columnStride;
464         auto uvStride = planes->planes[PLANE_U].columnStride;
465         auto yOffset = planes->planes[PLANE_Y].offset;
466         auto uvOffset = planes->planes[PLANE_U].offset;
467         dstStrides = {yStride, uvStride, yOffset, uvOffset};
468     } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCRCB_420_SP) {
469         auto yStride = planes->planes[PLANE_Y].columnStride;
470         auto uvStride = planes->planes[PLANE_V].columnStride;
471         auto yOffset = planes->planes[PLANE_Y].offset;
472         auto uvOffset = planes->planes[PLANE_V].offset;
473         dstStrides = {yStride, uvStride, yOffset, uvOffset};
474     } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_P010) {
475         auto yStride = planes->planes[PLANE_Y].columnStride / 2;
476         auto uvStride = planes->planes[PLANE_U].columnStride / 2;
477         auto yOffset = planes->planes[PLANE_Y].offset / 2;
478         auto uvOffset = planes->planes[PLANE_U].offset / 2;
479         dstStrides = {yStride, uvStride, yOffset, uvOffset};
480     } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCRCB_P010) {
481         auto yStride = planes->planes[PLANE_Y].columnStride / 2;
482         auto uvStride = planes->planes[PLANE_V].columnStride / 2;
483         auto yOffset = planes->planes[PLANE_Y].offset / 2;
484         auto uvOffset = planes->planes[PLANE_V].offset / 2;
485         dstStrides = {yStride, uvStride, yOffset, uvOffset};
486     }
487 }
488 #endif
489 
CreateMemory(PixelFormat pixelFormat,AllocatorType allocatorType,int32_t width,int32_t height,YUVStrideInfo & strides)490 std::unique_ptr<AbsMemory> ImageFormatConvert::CreateMemory(PixelFormat pixelFormat, AllocatorType allocatorType,
491                                                             int32_t width, int32_t height, YUVStrideInfo &strides)
492 {
493     if (width == 0 || height == 0 || pixelFormat == PixelFormat::UNKNOWN) {
494         IMAGE_LOGE("CreateMemory err ERR_IMAGE_INVALID_PARAMETER!");
495         return nullptr;
496     }
497     uint32_t pictureSize = GetBufferSizeByFormat(pixelFormat, {width, height});
498     if (IsYUVConvert(pixelFormat)) {
499         strides = {width, (width + 1) / NUM_2 * NUM_2, 0, width * height};
500     } else {
501         uint32_t stride = 0;
502         CalcRGBStride(pixelFormat, width, stride);
503         strides = {stride, 0, 0, 0};
504     }
505     MemoryData memoryData = {nullptr, pictureSize, "PixelConvert", {width, height}, pixelFormat};
506     auto m = MemoryManager::CreateMemory(allocatorType, memoryData);
507     if (m == nullptr) {
508         IMAGE_LOGE("CreateMemory failed");
509         return m;
510     }
511 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
512     if (allocatorType != AllocatorType::DMA_ALLOC) {
513         return m;
514     }
515     if (m->extend.data == nullptr) {
516         IMAGE_LOGE("CreateMemory get surfacebuffer failed");
517         return m;
518     }
519     auto sb = reinterpret_cast<SurfaceBuffer*>(m->extend.data);
520     OH_NativeBuffer_Planes *planes = nullptr;
521     GSError retVal = sb->GetPlanesInfo(reinterpret_cast<void**>(&planes));
522     auto stride = sb->GetStride();
523     strides = {stride, 0, 0, 0};
524     if (retVal != OHOS::GSERROR_OK || planes == nullptr) {
525         IMAGE_LOGE("CreateMemory Get planesInfo failed, retVal:%{public}d", retVal);
526     } else if (planes->planeCount >= NUM_2) {
527         int32_t pixelFmt = sb->GetFormat();
528         GetYUVStrideInfo(pixelFmt, planes, strides);
529     }
530 #endif
531     return m;
532 }
533 
RGBConvertImageFormatOption(std::shared_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)534 uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
535                                                          const PixelFormat &srcFormat, PixelFormat destFormat)
536 {
537     ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
538     if (cvtFunc == nullptr) {
539         IMAGE_LOGE("get convert function by format failed!");
540         return ERR_IMAGE_INVALID_PARAMETER;
541     }
542     const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
543     ImageInfo imageInfo;
544     srcPiexlMap->GetImageInfo(imageInfo);
545 
546     int32_t width = imageInfo.size.width;
547     int32_t height = imageInfo.size.height;
548     YUVStrideInfo dstStrides;
549     auto allocType = srcPiexlMap->GetAllocatorType();
550     auto m = CreateMemory(destFormat, allocType, width, height, dstStrides);
551     if (m == nullptr) {
552         IMAGE_LOGE("CreateMemory failed");
553         return ERR_IMAGE_INVALID_PARAMETER;
554     }
555     int32_t stride = srcPiexlMap->GetRowStride();
556     #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
557     if (allocType == AllocatorType::DMA_ALLOC) {
558         auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
559         stride = sb->GetStride();
560         sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
561         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
562         VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
563     }
564     #endif
565     RGBDataInfo rgbDataInfo = {width, height, static_cast<uint32_t>(stride)};
566     DestConvertInfo destInfo = {width, height, destFormat, allocType};
567     destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
568     destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
569     destInfo.yStride = dstStrides.yStride;
570     destInfo.uvStride = dstStrides.uvStride;
571     destInfo.yOffset = dstStrides.yOffset;
572     destInfo.uvOffset = dstStrides.uvOffset;
573     if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
574         IMAGE_LOGE("format convert failed!");
575         m->Release();
576         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
577     }
578     auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
579     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
580         m->Release();
581     }
582     return ret;
583 }
584 
RGBConvertImageFormatOptionUnique(std::unique_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)585 uint32_t ImageFormatConvert::RGBConvertImageFormatOptionUnique(
586     std::unique_ptr<PixelMap> &srcPiexlMap, const PixelFormat &srcFormat, PixelFormat destFormat)
587 {
588     ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
589     if (cvtFunc == nullptr) {
590         IMAGE_LOGE("get convert function by format failed!");
591         return ERR_IMAGE_INVALID_PARAMETER;
592     }
593     const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
594     ImageInfo imageInfo;
595     srcPiexlMap->GetImageInfo(imageInfo);
596 
597     int32_t width = imageInfo.size.width;
598     int32_t height = imageInfo.size.height;
599     YUVStrideInfo dstStrides;
600     auto allocType = srcPiexlMap->GetAllocatorType();
601     auto memory = CreateMemory(destFormat, allocType, width, height, dstStrides);
602     if (memory == nullptr) {
603         IMAGE_LOGE("CreateMemory failed");
604         return ERR_IMAGE_INVALID_PARAMETER;
605     }
606     int32_t stride = srcPiexlMap->GetRowStride();
607     #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
608     if (allocType == AllocatorType::DMA_ALLOC) {
609         auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
610         stride = sb->GetStride();
611         sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
612         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(memory->extend.data));
613         VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
614     }
615     #endif
616     RGBDataInfo rgbDataInfo = {width, height, static_cast<uint32_t>(stride)};
617     DestConvertInfo destInfo = {width, height, destFormat, allocType};
618     destInfo.buffer = reinterpret_cast<uint8_t *>(memory->data.data);
619     destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
620     destInfo.yStride = dstStrides.yStride;
621     destInfo.uvStride = dstStrides.uvStride;
622     destInfo.yOffset = dstStrides.yOffset;
623     destInfo.uvOffset = dstStrides.uvOffset;
624     if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
625         IMAGE_LOGE("format convert failed!");
626         memory->Release();
627         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
628     }
629     auto ret = MakeDestPixelMapUnique(srcPiexlMap, imageInfo, destInfo, memory->extend.data);
630     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
631         memory->Release();
632     }
633     return ret;
634 }
635 
GetAllocatorType(std::shared_ptr<PixelMap> & srcPiexlMap,PixelFormat destFormat)636 static AllocatorType GetAllocatorType(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
637 {
638     auto allocType = srcPiexlMap->GetAllocatorType();
639     if (destFormat == PixelFormat::RGB_888 || destFormat == PixelFormat::RGB_565 ||
640         destFormat == PixelFormat::RGBA_F16) {
641         allocType = AllocatorType::SHARE_MEM_ALLOC;
642     }
643     return allocType;
644 }
645 
YUVConvertImageFormatOption(std::shared_ptr<PixelMap> & srcPiexlMap,const PixelFormat & srcFormat,PixelFormat destFormat)646 uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
647                                                          const PixelFormat &srcFormat, PixelFormat destFormat)
648 {
649     YUVConvertFunction yuvCvtFunc = YUVGetConvertFuncByFormat(srcFormat, destFormat);
650     if (yuvCvtFunc == nullptr) {
651         return ERR_IMAGE_INVALID_PARAMETER;
652     }
653     const_uint8_buffer_type data = srcPiexlMap->GetPixels();
654     YUVDataInfo yDInfo;
655     srcPiexlMap->GetImageYUVInfo(yDInfo);
656     ImageInfo imageInfo;
657     srcPiexlMap->GetImageInfo(imageInfo);
658     if ((srcFormat == PixelFormat::NV21 || srcFormat == PixelFormat::YCBCR_P010 ||
659         srcFormat == PixelFormat::YCRCB_P010) &&
660         (yDInfo.yWidth == 0 || yDInfo.yHeight == 0 || yDInfo.uvWidth == 0 || yDInfo.uvHeight == 0)) {
661         yDInfo.yWidth = static_cast<uint32_t>(imageInfo.size.width);
662         yDInfo.yHeight = static_cast<uint32_t>(imageInfo.size.height);
663         yDInfo.uvWidth = static_cast<uint32_t>((imageInfo.size.width + 1) / NUM_2);
664         yDInfo.uvHeight = static_cast<uint32_t>((imageInfo.size.height + 1) / NUM_2);
665     }
666     YUVStrideInfo dstStrides;
667     auto allocType = GetAllocatorType(srcPiexlMap, destFormat);
668     DestConvertInfo destInfo = {imageInfo.size.width, imageInfo.size.height, destFormat, allocType};
669     auto m = CreateMemory(destFormat, allocType, destInfo.width, destInfo.height, dstStrides);
670     if (m == nullptr) {
671         return ERR_IMAGE_INVALID_PARAMETER;
672     }
673 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
674     if (allocType == AllocatorType::DMA_ALLOC) {
675         sptr<SurfaceBuffer> sourceSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd()));
676         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
677         VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
678     }
679 #endif
680     destInfo.buffer = reinterpret_cast<uint8_t *>(m->data.data);
681     destInfo.bufferSize = GetBufferSizeByFormat(destFormat, {destInfo.width, destInfo.height});
682     destInfo.yStride = dstStrides.yStride;
683     destInfo.uvStride = dstStrides.uvStride;
684     destInfo.yOffset = dstStrides.yOffset;
685     destInfo.uvOffset = dstStrides.uvOffset;
686     if (!yuvCvtFunc(data, yDInfo, destInfo, srcPiexlMap->GetColorSpace())) {
687         m->Release();
688         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
689     }
690     auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
691     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
692         m->Release();
693     }
694     return ret;
695 }
696 
NeedProtectionConversion(const PixelFormat inputFormat,const PixelFormat outputFormat)697 bool NeedProtectionConversion(const PixelFormat inputFormat, const PixelFormat outputFormat)
698 {
699     if (conversions.find({inputFormat, outputFormat}) != conversions.end()) {
700         return true;
701     }
702     return false;
703 }
704 
SetImageInfo(ImageInfo & srcImageinfo,DestConvertInfo & destInfo)705 ImageInfo SetImageInfo(ImageInfo &srcImageinfo, DestConvertInfo &destInfo)
706 {
707     ImageInfo info;
708     info.alphaType = srcImageinfo.alphaType;
709     info.baseDensity = srcImageinfo.baseDensity;
710     info.colorSpace = srcImageinfo.colorSpace;
711     info.pixelFormat = destInfo.format;
712     info.size = {destInfo.width, destInfo.height};
713     return info;
714 }
715 
MakeDestPixelMap(std::shared_ptr<PixelMap> & destPixelMap,ImageInfo & srcImageinfo,DestConvertInfo & destInfo,void * context)716 uint32_t ImageFormatConvert::MakeDestPixelMap(std::shared_ptr<PixelMap> &destPixelMap, ImageInfo &srcImageinfo,
717                                               DestConvertInfo &destInfo, void *context)
718 {
719     if (srcImageinfo.size.width == 0 || srcImageinfo.size.height == 0 || destInfo.width == 0
720         || destInfo.height == 0 || destInfo.format == PixelFormat::UNKNOWN) {
721         return ERR_IMAGE_INVALID_PARAMETER;
722     }
723     ImageInfo info = SetImageInfo(srcImageinfo, destInfo);
724     auto allcatorType = destInfo.allocType;
725     std::unique_ptr<PixelMap> pixelMap;
726     if (info.pixelFormat == PixelFormat::NV21 || info.pixelFormat == PixelFormat::NV12 ||
727         info.pixelFormat == PixelFormat::YCBCR_P010 || info.pixelFormat == PixelFormat::YCRCB_P010) {
728 #ifdef EXT_PIXEL
729         pixelMap = std::make_unique<PixelYuvExt>();
730 #else
731         pixelMap = std::make_unique<PixelYuv>();
732 #endif
733         if (pixelMap == nullptr) {
734             return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
735         }
736         if (allcatorType != AllocatorType::DMA_ALLOC) {
737             pixelMap->AssignYuvDataOnType(info.pixelFormat, info.size.width, info.size.height);
738         } else {
739             YUVStrideInfo strides = {destInfo.yStride, destInfo.uvStride, destInfo.yOffset, destInfo.uvOffset};
740             pixelMap->UpdateYUVDataInfo(info.pixelFormat, info.size.width, info.size.height, strides);
741         }
742     } else {
743         pixelMap = std::make_unique<PixelMap>();
744         if (pixelMap == nullptr) {
745             return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
746         }
747     }
748     pixelMap->SetPixelsAddr(destInfo.buffer, context, destInfo.bufferSize, allcatorType, nullptr);
749     auto ret = pixelMap->SetImageInfo(info, true);
750     bool isSetMetaData = SetConvertImageMetaData(destPixelMap.get(), pixelMap.get());
751     if (ret != SUCCESS || isSetMetaData == false) {
752         IMAGE_LOGE("set imageInfo failed");
753         return ret;
754     }
755 #ifdef IMAGE_COLORSPACE_FLAG
756     if (NeedProtectionConversion(srcImageinfo.pixelFormat, info.pixelFormat)) {
757         pixelMap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(ColorManager::ColorSpaceName::BT2020_HLG));
758     } else {
759         pixelMap->InnerSetColorSpace(destPixelMap->InnerGetGrColorSpace());
760     }
761 #endif
762     destPixelMap = std::move(pixelMap);
763     return SUCCESS;
764 }
765 
MakeDestPixelMapUnique(std::unique_ptr<PixelMap> & destPixelMap,ImageInfo & srcImageinfo,DestConvertInfo & destInfo,void * context)766 uint32_t ImageFormatConvert::MakeDestPixelMapUnique(std::unique_ptr<PixelMap> &destPixelMap, ImageInfo &srcImageinfo,
767     DestConvertInfo &destInfo, void *context)
768 {
769     if (srcImageinfo.size.width == 0 || srcImageinfo.size.height == 0 || destInfo.width == 0 ||
770         destInfo.height == 0 || destInfo.format == PixelFormat::UNKNOWN) {
771             return ERR_IMAGE_INVALID_PARAMETER;
772     }
773     ImageInfo info = SetImageInfo(srcImageinfo, destInfo);
774     auto allcatorType = destInfo.allocType;
775     std::unique_ptr<PixelMap> pixelMap;
776     if (info.pixelFormat == PixelFormat::NV21 || info.pixelFormat == PixelFormat::NV12 ||
777         info.pixelFormat == PixelFormat::YCBCR_P010 || info.pixelFormat == PixelFormat::YCRCB_P010) {
778 #ifdef EXT_PIXEL
779         pixelMap = std::make_unique<PixelYuvExt>();
780 #else
781         pixelMap = std::make_unique<PixelYuv>();
782 #endif
783         if (pixelMap == nullptr) {
784             return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
785         }
786         if (allcatorType != AllocatorType::DMA_ALLOC) {
787             pixelMap->AssignYuvDataOnType(info.pixelFormat, info.size.width, info.size.height);
788         } else {
789             YUVStrideInfo strides = {destInfo.yStride, destInfo.uvStride, destInfo.yOffset, destInfo.uvOffset};
790             pixelMap->UpdateYUVDataInfo(info.pixelFormat, info.size.width, info.size.height, strides);
791         }
792     } else {
793         pixelMap = std::make_unique<PixelMap>();
794         if (pixelMap == nullptr) {
795             return ERR_IMAGE_PIXELMAP_CREATE_FAILED;
796         }
797     }
798     pixelMap->SetPixelsAddr(destInfo.buffer, context, destInfo.bufferSize, allcatorType, nullptr);
799     auto ret = pixelMap->SetImageInfo(info, true);
800     bool isSetMetaData = SetConvertImageMetaData(destPixelMap.get(), pixelMap.get());
801     if (ret != SUCCESS || isSetMetaData == false) {
802         IMAGE_LOGE("set imageInfo failed");
803         return ret;
804     }
805 #ifdef IMAGE_COLORSPACE_FLAG
806     if (NeedProtectionConversion(srcImageinfo.pixelFormat, info.pixelFormat)) {
807         pixelMap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(ColorManager::ColorSpaceName::BT2020_HLG));
808     } else {
809         pixelMap->InnerSetColorSpace(destPixelMap->InnerGetGrColorSpace());
810     }
811 #endif
812     destPixelMap = std::move(pixelMap);
813     return SUCCESS;
814 }
815 } // namespace Media
816 } // namespace OHOS