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
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkImagePriv_DEFINED
#define SkImagePriv_DEFINED
#include "SkImage.h"
#include "SkSurface.h"
enum SkCopyPixelsMode {
kIfMutable_SkCopyPixelsMode, //!< only copy src pixels if they are marked mutable
kAlways_SkCopyPixelsMode, //!< always copy src pixels (even if they are marked immutable)
kNever_SkCopyPixelsMode, //!< never copy src pixels (even if they are marked mutable)
};
// A good size for creating shader contexts on the stack.
enum {kSkBlitterContextSize = 3332};
// If alloc is non-nullptr, it will be used to allocate the returned SkShader, and MUST outlive
// the SkShader.
sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode, SkShader::TileMode,
const SkMatrix* localMatrix, SkCopyPixelsMode);
/**
* Examines the bitmap to decide if it can share the existing pixelRef, or
* if it needs to make a deep-copy of the pixels.
*
* The bitmap's pixelref will be shared if either the bitmap is marked as
* immutable, or CopyPixelsMode allows it. Shared pixel refs are also
* locked when kLocked_SharedPixelRefMode is specified.
*
* Passing kLocked_SharedPixelRefMode allows the image's peekPixels() method
* to succeed, but it will force any lazy decodes/generators to execute if
* they exist on the pixelref.
*
* It is illegal to call this with a texture-backed bitmap.
*
* If the bitmap's colortype cannot be converted into a corresponding
* SkImageInfo, or the bitmap's pixels cannot be accessed, this will return
* nullptr.
*/
extern SK_API sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap&, SkCopyPixelsMode);
// Given an image created from SkNewImageFromBitmap, return its pixelref. This
// may be called to see if the surface and the image share the same pixelref,
// in which case the surface may need to perform a copy-on-write.
extern const SkPixelRef* SkBitmapImageGetPixelRef(const SkImage* rasterImage);
/**
* Will attempt to upload and lock the contents of the image as a texture, so that subsequent
* draws to a gpu-target will come from that texture (and not by looking at the original image
* src). In particular this is intended to use the texture even if the image's original content
* changes subsequent to this call (i.e. the src is mutable!).
*
* All successful calls must be balanced by an equal number of calls to SkImage_unpinAsTexture().
*
* Once in this "pinned" state, the image has all of the same thread restrictions that exist
* for a natively created gpu image (e.g. SkImage::MakeFromTexture)
* - all drawing, pinning, unpinning must happen in the same thread as the GrContext.
*
* @return true if the image was successfully uploaded and locked into a texture
*/
bool SkImage_pinAsTexture(const SkImage*, GrContext*);
/**
* The balancing call to a successful invokation of SkImage_pinAsTexture. When a balanced number of
* calls have been made, then the "pinned" texture is free to be purged, etc. This also means that a
* subsequent "pin" call will look at the original content again, and if its uniqueID/generationID
* has changed, then a newer texture will be uploaded/pinned.
*
* The context passed to unpin must match the one passed to pin.
*/
void SkImage_unpinAsTexture(const SkImage*, GrContext*);
/**
* Returns the bounds of the image relative to its encoded buffer. For all non-lazy images,
* this returns (0,0,width,height). For a lazy-image, it may return a subset of that rect.
*/
SkIRect SkImage_getSubset(const SkImage*);
/**
* Returns a new image containing the same pixel values as the source, but with a different color
* space assigned. This performs no color space conversion. Primarily used in tests, to visualize
* the results of rendering in wide or narrow gamuts.
*/
sk_sp<SkImage> SkImageMakeRasterCopyAndAssignColorSpace(const SkImage*, SkColorSpace*);
/** \enum SkImageInfo::SkImageSourceChannel
Describes different channels we could read from image source.
*/
enum SkImageSourceChannel {
/** Describes the red channel; */
kR_SkImageSourceChannel,
/** Describes the green channel; */
kG_SkImageSourceChannel,
/** Describes the blue channel; */
kB_SkImageSourceChannel,
/** Describes the alpha channel; */
kA_SkImageSourceChannel,
/** Describes the alpha channel; */
kLastEnum_SkImageSourceChannel = kA_SkImageSourceChannel,
};
/** \struct SkYUVAIndex
Describes from which image source and which channel to read each individual YUVA plane.
SkYUVAIndex contains a index for which image source to read from and a enum for which channel
to read from.
*/
struct SK_API SkYUVAIndex {
/** The index is a number between -1..3 which definies which image source to read from, where -1
* means the image source doesn't exist. The assumption is we will always have image sources for
* each of YUV planes, but optionally have image source for A plane. */
int fIndex;
/** The channel describes from which channel to read the info from. Currently we only deal with
* YUV and NV12 and channel info is ignored. */
SkImageSourceChannel fChannel;
};
#endif
|
