1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
/*
* Copyright 2023 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkImageChromium_DEFINED
#define SkImageChromium_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/private/base/SkAPI.h"
class GrBackendFormat;
class GrContextThreadSafeProxy;
class GrPromiseImageTexture;
class GrDirectContext;
class GrYUVABackendTextureInfo;
class SkColorSpace;
class SkImage;
enum SkAlphaType : int;
enum SkColorType : int;
enum GrSurfaceOrigin : int;
namespace skgpu {
enum class Mipmapped : bool;
}
struct SkISize;
/**
* These functions expose features that are only for external use in Chromium.
*/
namespace SkImages {
using PromiseImageTextureContext = void*;
using PromiseImageTextureFulfillProc = sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext);
using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
/** Create a new GPU-backed SkImage that is very similar to an SkImage created by BorrowTextureFrom.
The difference is that the caller need not have created the texture nor populated it with the
image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
image does not require access to the backend API or GrDirectContext. Instead of passing a
GrBackendTexture the client supplies a description of the texture consisting of
GrBackendFormat, width, height, and skgpu::Mipmapped state. The resulting SkImage can be drawn
to a GrDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
When the actual texture is required to perform a backend API draw, textureFulfillProc will
be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
those set during the SkImage creation, and it must refer to a valid existing texture in the
backend API context/device, and be populated with the image pixel data. The texture cannot
be deleted until textureReleaseProc is called.
There is at most one call to each of textureFulfillProc and textureReleaseProc.
textureReleaseProc is always called even if image creation fails or if the
image is never fulfilled (e.g. it is never drawn or all draws are clipped out)
@param gpuContextProxy the thread-safe proxy of the gpu context. required.
@param backendFormat format of promised gpu texture
@param dimensions width & height of promised gpu texture
@param mipmapped mip mapped state of promised gpu texture
@param origin surface origin of promised gpu texture
@param colorType color type of promised gpu texture
@param alphaType alpha type of promised gpu texture
@param colorSpace range of colors; may be nullptr
@param textureFulfillProc function called to get actual gpu texture
@param textureReleaseProc function called when texture can be deleted
@param textureContext state passed to textureFulfillProc and textureReleaseProc
@return created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> PromiseTextureFrom(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
const GrBackendFormat& backendFormat,
SkISize dimensions,
skgpu::Mipmapped mipmapped,
GrSurfaceOrigin origin,
SkColorType colorType,
SkAlphaType alphaType,
sk_sp<SkColorSpace> colorSpace,
PromiseImageTextureFulfillProc textureFulfillProc,
PromiseImageTextureReleaseProc textureReleaseProc,
PromiseImageTextureContext textureContext);
/** This is similar to 'PromiseTextureFrom' but it creates a GPU-backed SkImage from YUV[A] data.
The source data may be planar (i.e. spread across multiple textures). In
the extreme Y, U, V, and A are all in different planes and thus the image is specified by
four textures. 'backendTextureInfo' describes the planar arrangement, texture formats,
conversion to RGB, and origin of the textures. Separate 'textureFulfillProc' and
'textureReleaseProc' calls are made for each texture. Each texture has its own
PromiseImageTextureContext. If 'backendTextureInfo' is not valid then no release proc
calls are made. Otherwise, the calls will be made even on failure. 'textureContexts' has one
entry for each of the up to four textures, as indicated by 'backendTextureInfo'.
Currently the mip mapped property of 'backendTextureInfo' is ignored. However, in the
near future it will be required that if it is kYes then textureFulfillProc must return
a mip mapped texture for each plane in order to successfully draw the image.
@param gpuContextProxy the thread-safe proxy of the gpu context. required.
@param backendTextureInfo info about the promised yuva gpu texture
@param imageColorSpace range of colors; may be nullptr
@param textureFulfillProc function called to get actual gpu texture
@param textureReleaseProc function called when texture can be deleted
@param textureContexts state passed to textureFulfillProc and textureReleaseProc
@return created SkImage, or nullptr
*/
SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
const GrYUVABackendTextureInfo& backendTextureInfo,
sk_sp<SkColorSpace> imageColorSpace,
PromiseImageTextureFulfillProc textureFulfillProc,
PromiseImageTextureReleaseProc textureReleaseProc,
PromiseImageTextureContext textureContexts[]);
/** Returns the GPU context associated with this image or nullptr if the image is not Ganesh-backed.
We expose this only to help transition certain API calls and do not intend for this to stick
around forever.
*/
SK_API GrDirectContext* GetContext(const SkImage* src);
inline GrDirectContext* GetContext(const sk_sp<const SkImage>& src) {
return GetContext(src.get());
}
} // namespace SkImages
#endif
|
