Update rive-cpp to 2.0 version
[platform/core/uifw/rive-tizen.git] / submodule / skia / tools / gpu / YUVUtils.cpp
1 /*
2  * Copyright 2019 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7
8 #include "tools/gpu/YUVUtils.h"
9
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkColorFilter.h"
12 #include "include/core/SkColorPriv.h"
13 #include "include/core/SkData.h"
14 #include "include/core/SkSurface.h"
15 #include "include/gpu/GrRecordingContext.h"
16 #include "include/gpu/GrYUVABackendTextures.h"
17 #include "src/codec/SkCodecImageGenerator.h"
18 #include "src/core/SkYUVAInfoLocation.h"
19 #include "src/core/SkYUVMath.h"
20 #include "src/gpu/ganesh/GrDirectContextPriv.h"
21 #include "src/gpu/ganesh/GrRecordingContextPriv.h"
22 #include "tools/gpu/ManagedBackendTexture.h"
23
24 namespace {
25
26 static SkPMColor convert_yuva_to_rgba(const float mtx[20], uint8_t yuva[4]) {
27     uint8_t y = yuva[0];
28     uint8_t u = yuva[1];
29     uint8_t v = yuva[2];
30     uint8_t a = yuva[3];
31
32     uint8_t r = SkTPin(SkScalarRoundToInt(mtx[ 0]*y + mtx[ 1]*u + mtx[ 2]*v + mtx[ 4]*255), 0, 255);
33     uint8_t g = SkTPin(SkScalarRoundToInt(mtx[ 5]*y + mtx[ 6]*u + mtx[ 7]*v + mtx[ 9]*255), 0, 255);
34     uint8_t b = SkTPin(SkScalarRoundToInt(mtx[10]*y + mtx[11]*u + mtx[12]*v + mtx[14]*255), 0, 255);
35
36     return SkPremultiplyARGBInline(a, r, g, b);
37 }
38
39 static uint8_t look_up(SkPoint normPt, const SkPixmap& pmap, SkColorChannel channel) {
40     SkASSERT(normPt.x() > 0 && normPt.x() < 1.0f);
41     SkASSERT(normPt.y() > 0 && normPt.y() < 1.0f);
42     int x = SkScalarFloorToInt(normPt.x() * pmap.width());
43     int y = SkScalarFloorToInt(normPt.y() * pmap.height());
44
45     auto ii = pmap.info().makeColorType(kRGBA_8888_SkColorType).makeWH(1, 1);
46     uint32_t pixel;
47     SkAssertResult(pmap.readPixels(ii, &pixel, sizeof(pixel), x, y));
48     int shift = static_cast<int>(channel) * 8;
49     return static_cast<uint8_t>((pixel >> shift) & 0xff);
50 }
51
52 class Generator : public SkImageGenerator {
53 public:
54     Generator(SkYUVAPixmaps pixmaps, sk_sp<SkColorSpace> cs)
55             : SkImageGenerator(SkImageInfo::Make(pixmaps.yuvaInfo().dimensions(),
56                                                  kN32_SkColorType,
57                                                  kPremul_SkAlphaType,
58                                                  std::move(cs)))
59             , fPixmaps(std::move(pixmaps)) {}
60
61 protected:
62     bool onGetPixels(const SkImageInfo& info,
63                      void* pixels,
64                      size_t rowBytes,
65                      const Options&) override {
66         if (kUnknown_SkColorType == fFlattened.colorType()) {
67             fFlattened.allocPixels(info);
68             SkASSERT(info == this->getInfo());
69
70             float mtx[20];
71             SkColorMatrix_YUV2RGB(fPixmaps.yuvaInfo().yuvColorSpace(), mtx);
72             SkYUVAInfo::YUVALocations yuvaLocations = fPixmaps.toYUVALocations();
73             SkASSERT(SkYUVAInfo::YUVALocation::AreValidLocations(yuvaLocations));
74
75             SkMatrix om = fPixmaps.yuvaInfo().originMatrix();
76             SkAssertResult(om.invert(&om));
77             float normX = 1.f/info.width();
78             float normY = 1.f/info.height();
79             if (SkEncodedOriginSwapsWidthHeight(fPixmaps.yuvaInfo().origin())) {
80                 using std::swap;
81                 swap(normX, normY);
82             }
83             for (int y = 0; y < info.height(); ++y) {
84                 for (int x = 0; x < info.width(); ++x) {
85                     SkPoint xy1 {(x + 0.5f),
86                                  (y + 0.5f)};
87                     xy1 = om.mapPoint(xy1);
88                     xy1.fX *= normX;
89                     xy1.fY *= normY;
90
91                     uint8_t yuva[4] = {0, 0, 0, 255};
92
93                     for (auto c : {SkYUVAInfo::YUVAChannels::kY,
94                                    SkYUVAInfo::YUVAChannels::kU,
95                                    SkYUVAInfo::YUVAChannels::kV}) {
96                         const auto& pmap = fPixmaps.plane(yuvaLocations[c].fPlane);
97                         yuva[c] = look_up(xy1, pmap, yuvaLocations[c].fChannel);
98                     }
99                     auto [aPlane, aChan] = yuvaLocations[SkYUVAInfo::YUVAChannels::kA];
100                     if (aPlane >= 0) {
101                         const auto& pmap = fPixmaps.plane(aPlane);
102                         yuva[3] = look_up(xy1, pmap, aChan);
103                     }
104
105                     // Making premul here.
106                     *fFlattened.getAddr32(x, y) = convert_yuva_to_rgba(mtx, yuva);
107                 }
108             }
109         }
110
111         return fFlattened.readPixels(info, pixels, rowBytes, 0, 0);
112     }
113
114     bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& types,
115                          SkYUVAPixmapInfo* info) const override {
116         *info = fPixmaps.pixmapsInfo();
117         return info->isValid();
118     }
119
120     bool onGetYUVAPlanes(const SkYUVAPixmaps& pixmaps) override {
121         SkASSERT(pixmaps.yuvaInfo() == fPixmaps.yuvaInfo());
122         for (int i = 0; i < pixmaps.numPlanes(); ++i) {
123             SkASSERT(fPixmaps.plane(i).colorType() == pixmaps.plane(i).colorType());
124             SkASSERT(fPixmaps.plane(i).dimensions() == pixmaps.plane(i).dimensions());
125             SkASSERT(fPixmaps.plane(i).rowBytes() == pixmaps.plane(i).rowBytes());
126             fPixmaps.plane(i).readPixels(pixmaps.plane(i));
127         }
128         return true;
129     }
130
131 private:
132     SkYUVAPixmaps fPixmaps;
133     SkBitmap      fFlattened;
134 };
135
136 }  // anonymous namespace
137
138 namespace sk_gpu_test {
139
140 std::tuple<std::array<sk_sp<SkImage>, SkYUVAInfo::kMaxPlanes>, SkYUVAInfo>
141 MakeYUVAPlanesAsA8(SkImage* src,
142                    SkYUVColorSpace cs,
143                    SkYUVAInfo::Subsampling ss,
144                    GrRecordingContext* rContext) {
145     float rgbToYUV[20];
146     SkColorMatrix_RGB2YUV(cs, rgbToYUV);
147
148     SkYUVAInfo::PlaneConfig config = src->isOpaque() ? SkYUVAInfo::PlaneConfig::kY_U_V
149                                                      : SkYUVAInfo::PlaneConfig::kY_U_V_A;
150     SkISize dims[SkYUVAInfo::kMaxPlanes];
151     int n = SkYUVAInfo::PlaneDimensions(src->dimensions(),
152                                         config,
153                                         ss,
154                                         kTopLeft_SkEncodedOrigin,
155                                         dims);
156     std::array<sk_sp<SkImage>, 4> planes;
157     for (int i = 0; i < n; ++i) {
158         SkImageInfo info = SkImageInfo::MakeA8(dims[i]);
159         sk_sp<SkSurface> surf;
160         if (rContext) {
161             surf = SkSurface::MakeRenderTarget(rContext, SkBudgeted::kYes, info, 1, nullptr);
162         } else {
163             surf = SkSurface::MakeRaster(info);
164         }
165         if (!surf) {
166             return {};
167         }
168
169         SkPaint paint;
170         paint.setBlendMode(SkBlendMode::kSrc);
171
172         // Make a matrix with the ith row of rgbToYUV copied to the A row since we're drawing to A8.
173         float m[20] = {};
174         std::copy_n(rgbToYUV + 5*i, 5, m + 15);
175         paint.setColorFilter(SkColorFilters::Matrix(m));
176         surf->getCanvas()->drawImageRect(src,
177                                          SkRect::Make(dims[i]),
178                                          SkSamplingOptions(SkFilterMode::kLinear),
179                                          &paint);
180         planes[i] = surf->makeImageSnapshot();
181         if (!planes[i]) {
182             return {};
183         }
184     }
185     SkYUVAInfo info(src->dimensions(), config, ss, cs);
186     return {planes, info};
187 }
188
189 std::unique_ptr<LazyYUVImage> LazyYUVImage::Make(sk_sp<SkData> data,
190                                                  GrMipmapped mipmapped,
191                                                  sk_sp<SkColorSpace> cs) {
192     std::unique_ptr<LazyYUVImage> image(new LazyYUVImage());
193     if (image->reset(std::move(data), mipmapped, std::move(cs))) {
194         return image;
195     } else {
196         return nullptr;
197     }
198 }
199
200 std::unique_ptr<LazyYUVImage> LazyYUVImage::Make(SkYUVAPixmaps pixmaps,
201                                                  GrMipmapped mipmapped,
202                                                  sk_sp<SkColorSpace> cs) {
203     std::unique_ptr<LazyYUVImage> image(new LazyYUVImage());
204     if (image->reset(std::move(pixmaps), mipmapped, std::move(cs))) {
205         return image;
206     } else {
207         return nullptr;
208     }
209 }
210
211 sk_sp<SkImage> LazyYUVImage::refImage(GrRecordingContext* rContext, Type type) {
212     if (this->ensureYUVImage(rContext, type)) {
213         size_t idx = static_cast<size_t>(type);
214         SkASSERT(idx < SK_ARRAY_COUNT(fYUVImage));
215         return fYUVImage[idx];
216     } else {
217         return nullptr;
218     }
219 }
220
221 bool LazyYUVImage::reset(sk_sp<SkData> data, GrMipmapped mipmapped, sk_sp<SkColorSpace> cs) {
222     fMipmapped = mipmapped;
223     auto codec = SkCodecImageGenerator::MakeFromEncodedCodec(data);
224     if (!codec) {
225         return false;
226     }
227
228     SkYUVAPixmapInfo yuvaPixmapInfo;
229     if (!codec->queryYUVAInfo(SkYUVAPixmapInfo::SupportedDataTypes::All(), &yuvaPixmapInfo)) {
230         return false;
231     }
232     fPixmaps = SkYUVAPixmaps::Allocate(yuvaPixmapInfo);
233     if (!fPixmaps.isValid()) {
234         return false;
235     }
236
237     if (!codec->getYUVAPlanes(fPixmaps)) {
238         return false;
239     }
240
241     fColorSpace = std::move(cs);
242
243     // The SkPixmap data is fully configured now for MakeFromYUVAPixmaps once we get a GrContext
244     return true;
245 }
246
247 bool LazyYUVImage::reset(SkYUVAPixmaps pixmaps, GrMipmapped mipmapped, sk_sp<SkColorSpace> cs) {
248     if (!pixmaps.isValid()) {
249         return false;
250     }
251     fMipmapped = mipmapped;
252     if (pixmaps.ownsStorage()) {
253         fPixmaps = std::move(pixmaps);
254     } else {
255         fPixmaps = SkYUVAPixmaps::MakeCopy(std::move(pixmaps));
256     }
257     fColorSpace = std::move(cs);
258     // The SkPixmap data is fully configured now for MakeFromYUVAPixmaps once we get a GrContext
259     return true;
260 }
261
262 bool LazyYUVImage::ensureYUVImage(GrRecordingContext* rContext, Type type) {
263     size_t idx = static_cast<size_t>(type);
264     SkASSERT(idx < SK_ARRAY_COUNT(fYUVImage));
265     if (fYUVImage[idx] && fYUVImage[idx]->isValid(rContext)) {
266         return true;  // Have already made a YUV image valid for this context.
267     }
268     // Try to make a new YUV image for this context.
269     switch (type) {
270         case Type::kFromPixmaps:
271             if (!rContext || rContext->abandoned()) {
272                 return false;
273             }
274             fYUVImage[idx] = SkImage::MakeFromYUVAPixmaps(rContext,
275                                                           fPixmaps,
276                                                           fMipmapped,
277                                                           /*limit to max tex size*/ false,
278                                                           fColorSpace);
279             break;
280         case Type::kFromGenerator: {
281             // Make sure the generator has ownership of its backing planes.
282             auto generator = std::make_unique<Generator>(fPixmaps, fColorSpace);
283             fYUVImage[idx] = SkImage::MakeFromGenerator(std::move(generator));
284             break;
285         }
286         case Type::kFromTextures:
287             if (!rContext || rContext->abandoned()) {
288                 return false;
289             }
290             if (fMipmapped == GrMipmapped::kYes) {
291                 // If this becomes necessary we should invoke SkMipmapBuilder here to make mip
292                 // maps from our src data (and then pass a pixmaps array to initialize the planar
293                 // textures.
294                 return false;
295             }
296             if (auto direct = rContext->asDirectContext()) {
297                 sk_sp<sk_gpu_test::ManagedBackendTexture> mbets[SkYUVAInfo::kMaxPlanes];
298                 GrBackendTexture textures[SkYUVAInfo::kMaxPlanes];
299                 for (int i = 0; i < fPixmaps.numPlanes(); ++i) {
300                     mbets[i] = sk_gpu_test::ManagedBackendTexture::MakeWithData(
301                             direct,
302                             fPixmaps.plane(i),
303                             kTopLeft_GrSurfaceOrigin,
304                             GrRenderable::kNo,
305                             GrProtected::kNo);
306                     if (mbets[i]) {
307                         textures[i] = mbets[i]->texture();
308                     } else {
309                         return false;
310                     }
311                 }
312                 GrYUVABackendTextures yuvaTextures(fPixmaps.yuvaInfo(),
313                                                    textures,
314                                                    kTopLeft_GrSurfaceOrigin);
315                 if (!yuvaTextures.isValid()) {
316                     return false;
317                 }
318                 void* planeRelContext =
319                         sk_gpu_test::ManagedBackendTexture::MakeYUVAReleaseContext(mbets);
320                 fYUVImage[idx] = SkImage::MakeFromYUVATextures(
321                         direct,
322                         yuvaTextures,
323                         fColorSpace,
324                         sk_gpu_test::ManagedBackendTexture::ReleaseProc,
325                         planeRelContext);
326             }
327     }
328     return fYUVImage[idx] != nullptr;
329 }
330 } // namespace sk_gpu_test