зеркало из https://github.com/mozilla/gecko-dev.git
Bug 955854 - Remove unused colour space mapping code and move the rest to nsSVGMaskFrame. r=dholbert
This commit is contained in:
Robert Longson
Родитель
db05696865
Коммит
9fdf63147a
|
|
@ -15,6 +15,142 @@
|
|||
|
||||
using namespace mozilla::dom;
|
||||
|
||||
/**
|
||||
* Byte offsets of channels in a native packed gfxColor or cairo image surface.
|
||||
*/
|
||||
#ifdef IS_BIG_ENDIAN
|
||||
#define GFX_ARGB32_OFFSET_A 0
|
||||
#define GFX_ARGB32_OFFSET_R 1
|
||||
#define GFX_ARGB32_OFFSET_G 2
|
||||
#define GFX_ARGB32_OFFSET_B 3
|
||||
#else
|
||||
#define GFX_ARGB32_OFFSET_A 3
|
||||
#define GFX_ARGB32_OFFSET_R 2
|
||||
#define GFX_ARGB32_OFFSET_G 1
|
||||
#define GFX_ARGB32_OFFSET_B 0
|
||||
#endif
|
||||
|
||||
// c = n / 255
|
||||
// c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4)) * 255 + 0.5
|
||||
static const uint8_t gsRGBToLinearRGBMap[256] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 3, 3, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 4, 5, 5, 5,
|
||||
5, 6, 6, 6, 6, 7, 7, 7,
|
||||
8, 8, 8, 8, 9, 9, 9, 10,
|
||||
10, 10, 11, 11, 12, 12, 12, 13,
|
||||
13, 13, 14, 14, 15, 15, 16, 16,
|
||||
17, 17, 17, 18, 18, 19, 19, 20,
|
||||
20, 21, 22, 22, 23, 23, 24, 24,
|
||||
25, 25, 26, 27, 27, 28, 29, 29,
|
||||
30, 30, 31, 32, 32, 33, 34, 35,
|
||||
35, 36, 37, 37, 38, 39, 40, 41,
|
||||
41, 42, 43, 44, 45, 45, 46, 47,
|
||||
48, 49, 50, 51, 51, 52, 53, 54,
|
||||
55, 56, 57, 58, 59, 60, 61, 62,
|
||||
63, 64, 65, 66, 67, 68, 69, 70,
|
||||
71, 72, 73, 74, 76, 77, 78, 79,
|
||||
80, 81, 82, 84, 85, 86, 87, 88,
|
||||
90, 91, 92, 93, 95, 96, 97, 99,
|
||||
100, 101, 103, 104, 105, 107, 108, 109,
|
||||
111, 112, 114, 115, 116, 118, 119, 121,
|
||||
122, 124, 125, 127, 128, 130, 131, 133,
|
||||
134, 136, 138, 139, 141, 142, 144, 146,
|
||||
147, 149, 151, 152, 154, 156, 157, 159,
|
||||
161, 163, 164, 166, 168, 170, 171, 173,
|
||||
175, 177, 179, 181, 183, 184, 186, 188,
|
||||
190, 192, 194, 196, 198, 200, 202, 204,
|
||||
206, 208, 210, 212, 214, 216, 218, 220,
|
||||
222, 224, 226, 229, 231, 233, 235, 237,
|
||||
239, 242, 244, 246, 248, 250, 253, 255
|
||||
};
|
||||
|
||||
static void
|
||||
ComputesRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
|
||||
uint8_t luminance;
|
||||
if (a) {
|
||||
/* sRGB -> intensity (unpremultiply cancels out the
|
||||
* (a/255.0) multiplication with aOpacity */
|
||||
luminance =
|
||||
static_cast<uint8_t>
|
||||
((pixel[GFX_ARGB32_OFFSET_R] * 0.2125 +
|
||||
pixel[GFX_ARGB32_OFFSET_G] * 0.7154 +
|
||||
pixel[GFX_ARGB32_OFFSET_B] * 0.0721) *
|
||||
aOpacity);
|
||||
} else {
|
||||
luminance = 0;
|
||||
}
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
ComputeLinearRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
|
||||
uint8_t luminance;
|
||||
// unpremultiply
|
||||
if (a) {
|
||||
if (a != 255) {
|
||||
pixel[GFX_ARGB32_OFFSET_B] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_B]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_G] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_G]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_R] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_R]) / a;
|
||||
}
|
||||
|
||||
/* sRGB -> linearRGB -> intensity */
|
||||
luminance =
|
||||
static_cast<uint8_t>
|
||||
((gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_R]] *
|
||||
0.2125 +
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_G]] *
|
||||
0.7154 +
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_B]] *
|
||||
0.0721) * (a / 255.0) * aOpacity);
|
||||
} else {
|
||||
luminance = 0;
|
||||
}
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
ComputeAlphaMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t luminance = pixel[GFX_ARGB32_OFFSET_A] * aOpacity;
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Implementation
|
||||
|
||||
|
|
@ -118,12 +254,12 @@ nsSVGMaskFrame::ComputeMaskAlpha(nsRenderingContext *aContext,
|
|||
if (StyleSVGReset()->mMaskType == NS_STYLE_MASK_TYPE_LUMINANCE) {
|
||||
if (StyleSVG()->mColorInterpolation ==
|
||||
NS_STYLE_COLOR_INTERPOLATION_LINEARRGB) {
|
||||
nsSVGUtils::ComputeLinearRGBLuminanceMask(data, stride, rect, aOpacity);
|
||||
ComputeLinearRGBLuminanceMask(data, stride, rect, aOpacity);
|
||||
} else {
|
||||
nsSVGUtils::ComputesRGBLuminanceMask(data, stride, rect, aOpacity);
|
||||
ComputesRGBLuminanceMask(data, stride, rect, aOpacity);
|
||||
}
|
||||
} else {
|
||||
nsSVGUtils::ComputeAlphaMask(data, stride, rect, aOpacity);
|
||||
ComputeAlphaMask(data, stride, rect, aOpacity);
|
||||
}
|
||||
|
||||
nsRefPtr<gfxPattern> retval = new gfxPattern(image);
|
||||
|
|
|
|||
|
|
@ -58,80 +58,6 @@ using namespace mozilla;
|
|||
using namespace mozilla::dom;
|
||||
using namespace mozilla::gfx;
|
||||
|
||||
// c = n / 255
|
||||
// (c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1 / 2.4) - 0.055) * 255 + 0.5
|
||||
static const uint8_t glinearRGBTosRGBMap[256] = {
|
||||
0, 13, 22, 28, 34, 38, 42, 46,
|
||||
50, 53, 56, 59, 61, 64, 66, 69,
|
||||
71, 73, 75, 77, 79, 81, 83, 85,
|
||||
86, 88, 90, 92, 93, 95, 96, 98,
|
||||
99, 101, 102, 104, 105, 106, 108, 109,
|
||||
110, 112, 113, 114, 115, 117, 118, 119,
|
||||
120, 121, 122, 124, 125, 126, 127, 128,
|
||||
129, 130, 131, 132, 133, 134, 135, 136,
|
||||
137, 138, 139, 140, 141, 142, 143, 144,
|
||||
145, 146, 147, 148, 148, 149, 150, 151,
|
||||
152, 153, 154, 155, 155, 156, 157, 158,
|
||||
159, 159, 160, 161, 162, 163, 163, 164,
|
||||
165, 166, 167, 167, 168, 169, 170, 170,
|
||||
171, 172, 173, 173, 174, 175, 175, 176,
|
||||
177, 178, 178, 179, 180, 180, 181, 182,
|
||||
182, 183, 184, 185, 185, 186, 187, 187,
|
||||
188, 189, 189, 190, 190, 191, 192, 192,
|
||||
193, 194, 194, 195, 196, 196, 197, 197,
|
||||
198, 199, 199, 200, 200, 201, 202, 202,
|
||||
203, 203, 204, 205, 205, 206, 206, 207,
|
||||
208, 208, 209, 209, 210, 210, 211, 212,
|
||||
212, 213, 213, 214, 214, 215, 215, 216,
|
||||
216, 217, 218, 218, 219, 219, 220, 220,
|
||||
221, 221, 222, 222, 223, 223, 224, 224,
|
||||
225, 226, 226, 227, 227, 228, 228, 229,
|
||||
229, 230, 230, 231, 231, 232, 232, 233,
|
||||
233, 234, 234, 235, 235, 236, 236, 237,
|
||||
237, 238, 238, 238, 239, 239, 240, 240,
|
||||
241, 241, 242, 242, 243, 243, 244, 244,
|
||||
245, 245, 246, 246, 246, 247, 247, 248,
|
||||
248, 249, 249, 250, 250, 251, 251, 251,
|
||||
252, 252, 253, 253, 254, 254, 255, 255
|
||||
};
|
||||
|
||||
// c = n / 255
|
||||
// c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4)) * 255 + 0.5
|
||||
static const uint8_t gsRGBToLinearRGBMap[256] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 3, 3, 3, 3, 3, 3,
|
||||
4, 4, 4, 4, 4, 5, 5, 5,
|
||||
5, 6, 6, 6, 6, 7, 7, 7,
|
||||
8, 8, 8, 8, 9, 9, 9, 10,
|
||||
10, 10, 11, 11, 12, 12, 12, 13,
|
||||
13, 13, 14, 14, 15, 15, 16, 16,
|
||||
17, 17, 17, 18, 18, 19, 19, 20,
|
||||
20, 21, 22, 22, 23, 23, 24, 24,
|
||||
25, 25, 26, 27, 27, 28, 29, 29,
|
||||
30, 30, 31, 32, 32, 33, 34, 35,
|
||||
35, 36, 37, 37, 38, 39, 40, 41,
|
||||
41, 42, 43, 44, 45, 45, 46, 47,
|
||||
48, 49, 50, 51, 51, 52, 53, 54,
|
||||
55, 56, 57, 58, 59, 60, 61, 62,
|
||||
63, 64, 65, 66, 67, 68, 69, 70,
|
||||
71, 72, 73, 74, 76, 77, 78, 79,
|
||||
80, 81, 82, 84, 85, 86, 87, 88,
|
||||
90, 91, 92, 93, 95, 96, 97, 99,
|
||||
100, 101, 103, 104, 105, 107, 108, 109,
|
||||
111, 112, 114, 115, 116, 118, 119, 121,
|
||||
122, 124, 125, 127, 128, 130, 131, 133,
|
||||
134, 136, 138, 139, 141, 142, 144, 146,
|
||||
147, 149, 151, 152, 154, 156, 157, 159,
|
||||
161, 163, 164, 166, 168, 170, 171, 173,
|
||||
175, 177, 179, 181, 183, 184, 186, 188,
|
||||
190, 192, 194, 196, 198, 200, 202, 204,
|
||||
206, 208, 210, 212, 214, 216, 218, 220,
|
||||
222, 224, 226, 229, 231, 233, 235, 237,
|
||||
239, 242, 244, 246, 248, 250, 253, 255
|
||||
};
|
||||
|
||||
static bool sSVGDisplayListHitTestingEnabled;
|
||||
static bool sSVGDisplayListPaintingEnabled;
|
||||
|
||||
|
|
@ -209,179 +135,6 @@ nsSVGUtils::Init()
|
|||
"svg.display-lists.painting.enabled");
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::UnPremultiplyImageDataAlpha(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect)
|
||||
{
|
||||
for (int32_t y = rect.y; y < rect.YMost(); y++) {
|
||||
for (int32_t x = rect.x; x < rect.XMost(); x++) {
|
||||
uint8_t *pixel = data + stride * y + 4 * x;
|
||||
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
if (a == 255)
|
||||
continue;
|
||||
|
||||
if (a) {
|
||||
pixel[GFX_ARGB32_OFFSET_B] = (255 * pixel[GFX_ARGB32_OFFSET_B]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_G] = (255 * pixel[GFX_ARGB32_OFFSET_G]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_R] = (255 * pixel[GFX_ARGB32_OFFSET_R]) / a;
|
||||
} else {
|
||||
pixel[GFX_ARGB32_OFFSET_B] = 0;
|
||||
pixel[GFX_ARGB32_OFFSET_G] = 0;
|
||||
pixel[GFX_ARGB32_OFFSET_R] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::PremultiplyImageDataAlpha(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect)
|
||||
{
|
||||
for (int32_t y = rect.y; y < rect.YMost(); y++) {
|
||||
for (int32_t x = rect.x; x < rect.XMost(); x++) {
|
||||
uint8_t *pixel = data + stride * y + 4 * x;
|
||||
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
if (a == 255)
|
||||
continue;
|
||||
|
||||
FAST_DIVIDE_BY_255(pixel[GFX_ARGB32_OFFSET_B],
|
||||
pixel[GFX_ARGB32_OFFSET_B] * a);
|
||||
FAST_DIVIDE_BY_255(pixel[GFX_ARGB32_OFFSET_G],
|
||||
pixel[GFX_ARGB32_OFFSET_G] * a);
|
||||
FAST_DIVIDE_BY_255(pixel[GFX_ARGB32_OFFSET_R],
|
||||
pixel[GFX_ARGB32_OFFSET_R] * a);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::ConvertImageDataToLinearRGB(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect)
|
||||
{
|
||||
for (int32_t y = rect.y; y < rect.YMost(); y++) {
|
||||
for (int32_t x = rect.x; x < rect.XMost(); x++) {
|
||||
uint8_t *pixel = data + stride * y + 4 * x;
|
||||
|
||||
pixel[GFX_ARGB32_OFFSET_B] =
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_B]];
|
||||
pixel[GFX_ARGB32_OFFSET_G] =
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_G]];
|
||||
pixel[GFX_ARGB32_OFFSET_R] =
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_R]];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::ConvertImageDataFromLinearRGB(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect)
|
||||
{
|
||||
for (int32_t y = rect.y; y < rect.YMost(); y++) {
|
||||
for (int32_t x = rect.x; x < rect.XMost(); x++) {
|
||||
uint8_t *pixel = data + stride * y + 4 * x;
|
||||
|
||||
pixel[GFX_ARGB32_OFFSET_B] =
|
||||
glinearRGBTosRGBMap[pixel[GFX_ARGB32_OFFSET_B]];
|
||||
pixel[GFX_ARGB32_OFFSET_G] =
|
||||
glinearRGBTosRGBMap[pixel[GFX_ARGB32_OFFSET_G]];
|
||||
pixel[GFX_ARGB32_OFFSET_R] =
|
||||
glinearRGBTosRGBMap[pixel[GFX_ARGB32_OFFSET_R]];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::ComputesRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
|
||||
uint8_t luminance;
|
||||
if (a) {
|
||||
/* sRGB -> intensity (unpremultiply cancels out the
|
||||
* (a/255.0) multiplication with aOpacity */
|
||||
luminance =
|
||||
static_cast<uint8_t>
|
||||
((pixel[GFX_ARGB32_OFFSET_R] * 0.2125 +
|
||||
pixel[GFX_ARGB32_OFFSET_G] * 0.7154 +
|
||||
pixel[GFX_ARGB32_OFFSET_B] * 0.0721) *
|
||||
aOpacity);
|
||||
} else {
|
||||
luminance = 0;
|
||||
}
|
||||
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::ComputeLinearRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t a = pixel[GFX_ARGB32_OFFSET_A];
|
||||
|
||||
uint8_t luminance;
|
||||
// unpremultiply
|
||||
if (a) {
|
||||
if (a != 255) {
|
||||
pixel[GFX_ARGB32_OFFSET_B] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_B]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_G] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_G]) / a;
|
||||
pixel[GFX_ARGB32_OFFSET_R] =
|
||||
(255 * pixel[GFX_ARGB32_OFFSET_R]) / a;
|
||||
}
|
||||
|
||||
/* sRGB -> linearRGB -> intensity */
|
||||
luminance =
|
||||
static_cast<uint8_t>
|
||||
((gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_R]] *
|
||||
0.2125 +
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_G]] *
|
||||
0.7154 +
|
||||
gsRGBToLinearRGBMap[pixel[GFX_ARGB32_OFFSET_B]] *
|
||||
0.0721) * (a / 255.0) * aOpacity);
|
||||
} else {
|
||||
luminance = 0;
|
||||
}
|
||||
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsSVGUtils::ComputeAlphaMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity)
|
||||
{
|
||||
for (int32_t y = aRect.y; y < aRect.YMost(); y++) {
|
||||
for (int32_t x = aRect.x; x < aRect.XMost(); x++) {
|
||||
uint8_t *pixel = aData + aStride * y + 4 * x;
|
||||
uint8_t luminance = pixel[GFX_ARGB32_OFFSET_A] * aOpacity;
|
||||
memset(pixel, luminance, 4);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nsSVGDisplayContainerFrame*
|
||||
nsSVGUtils::GetNearestSVGViewport(nsIFrame *aFrame)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -111,21 +111,6 @@ class SourceSurface;
|
|||
|
||||
#define NS_STATE_SVG_TEXT_IN_REFLOW NS_FRAME_STATE_BIT(24)
|
||||
|
||||
/**
|
||||
* Byte offsets of channels in a native packed gfxColor or cairo image surface.
|
||||
*/
|
||||
#ifdef IS_BIG_ENDIAN
|
||||
#define GFX_ARGB32_OFFSET_A 0
|
||||
#define GFX_ARGB32_OFFSET_R 1
|
||||
#define GFX_ARGB32_OFFSET_G 2
|
||||
#define GFX_ARGB32_OFFSET_B 3
|
||||
#else
|
||||
#define GFX_ARGB32_OFFSET_A 3
|
||||
#define GFX_ARGB32_OFFSET_R 2
|
||||
#define GFX_ARGB32_OFFSET_G 1
|
||||
#define GFX_ARGB32_OFFSET_B 0
|
||||
#endif
|
||||
|
||||
// maximum dimension of an offscreen surface - choose so that
|
||||
// the surface size doesn't overflow a 32-bit signed int using
|
||||
// 4 bytes per pixel; in line with gfxASurface::CheckSurfaceSize
|
||||
|
|
@ -247,55 +232,6 @@ public:
|
|||
|
||||
static void Init();
|
||||
|
||||
/*
|
||||
* Converts image data from premultipled to unpremultiplied alpha
|
||||
*/
|
||||
static void UnPremultiplyImageDataAlpha(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect);
|
||||
/*
|
||||
* Converts image data from unpremultipled to premultiplied alpha
|
||||
*/
|
||||
static void PremultiplyImageDataAlpha(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect);
|
||||
/*
|
||||
* Converts image data from premultiplied sRGB to Linear RGB
|
||||
*/
|
||||
static void ConvertImageDataToLinearRGB(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect);
|
||||
/*
|
||||
* Converts image data from LinearRGB to premultiplied sRGB
|
||||
*/
|
||||
static void ConvertImageDataFromLinearRGB(uint8_t *data,
|
||||
int32_t stride,
|
||||
const nsIntRect &rect);
|
||||
|
||||
/*
|
||||
* Converts image data from sRGB to luminance
|
||||
*/
|
||||
static void ComputesRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity);
|
||||
|
||||
/*
|
||||
* Converts image data from sRGB to luminance assuming
|
||||
* Linear RGB Interpolation
|
||||
*/
|
||||
static void ComputeLinearRGBLuminanceMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity);
|
||||
/*
|
||||
* Converts image data to luminance using the value of alpha as luminance
|
||||
*/
|
||||
static void ComputeAlphaMask(uint8_t *aData,
|
||||
int32_t aStride,
|
||||
const nsIntRect &aRect,
|
||||
float aOpacity);
|
||||
|
||||
/**
|
||||
* Gets the nearest nsSVGInnerSVGFrame or nsSVGOuterSVGFrame frame. aFrame
|
||||
* must be an SVG frame. If aFrame is of type nsGkAtoms::svgOuterSVGFrame,
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче