mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-10-26 09:07:30 +09:00
Merge remote-tracking branch 'origin/tracking' into custom
This commit is contained in:
roytam1
commit
f08dd1422d
29 changed files with 1084 additions and 672 deletions
|
|
@ -1068,7 +1068,7 @@ var Debugger =
|
|||
// be either 3, or 5, or 6. This influences support for strict
|
||||
// mode, the set of reserved words, support for getters and
|
||||
// setters and other features.
|
||||
ecmaVersion: 5,
|
||||
ecmaVersion: 6,
|
||||
// Turn on `strictSemicolons` to prevent the parser from doing
|
||||
// automatic semicolon insertion.
|
||||
strictSemicolons: false,
|
||||
|
|
|
|||
|
|
@ -1299,7 +1299,7 @@ var defaultOptions = {
|
|||
// be either 3, or 5, or 6. This influences support for strict
|
||||
// mode, the set of reserved words, support for getters and
|
||||
// setters and other features.
|
||||
ecmaVersion: 5,
|
||||
ecmaVersion: 6,
|
||||
// Source type ("script" or "module") for different semantics
|
||||
sourceType: "script",
|
||||
// `onInsertedSemicolon` can be a callback that will be called
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ Crypto::GetRandomValues(JSContext* aCx, const ArrayBufferView& aArray,
|
|||
void Crypto::RandomUUID(nsAString& aRetVal)
|
||||
{
|
||||
// NSID_LENGTH == 39 == 36 UUID chars + 2 curly braces + 1 NUL byte
|
||||
static_assert(NSID_LENGTH == 39, "NSID_LENGTH must be 39");
|
||||
static_assert(NSID_LENGTH == 39, "Crypto:RandomUUID: NSID_LENGTH must be 39");
|
||||
|
||||
nsCOMPtr<nsIUUIDGenerator> uuidgen =
|
||||
do_GetService("@mozilla.org/uuid-generator;1");
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#ifndef MOZILLA_GFX_BASESIZE_H_
|
||||
#define MOZILLA_GFX_BASESIZE_H_
|
||||
|
||||
#include <algorithm>
|
||||
#include "mozilla/Attributes.h"
|
||||
|
||||
namespace mozilla {
|
||||
|
|
@ -92,6 +93,16 @@ struct BaseSize {
|
|||
Sub operator/(const Sub& aSize) const {
|
||||
return Sub(width / aSize.width, height / aSize.height);
|
||||
}
|
||||
|
||||
friend Sub Min(const Sub& aA, const Sub& aB) {
|
||||
return Sub(std::min(aA.width, aB.width),
|
||||
std::min(aA.height, aB.height));
|
||||
}
|
||||
|
||||
friend Sub Max(const Sub& aA, const Sub& aB) {
|
||||
return Sub(std::max(aA.width, aB.width),
|
||||
std::max(aA.height, aB.height));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace gfx
|
||||
|
|
|
|||
465
gfx/2d/Blur.cpp
465
gfx/2d/Blur.cpp
|
|
@ -25,159 +25,268 @@ namespace mozilla {
|
|||
namespace gfx {
|
||||
|
||||
/**
|
||||
* Box blur involves looking at one pixel, and setting its value to the average
|
||||
* of its neighbouring pixels.
|
||||
* @param aInput The input buffer.
|
||||
* @param aOutput The output buffer.
|
||||
* @param aLeftLobe The number of pixels to blend on the left.
|
||||
* @param aRightLobe The number of pixels to blend on the right.
|
||||
* @param aWidth The number of columns in the buffers.
|
||||
* @param aRows The number of rows in the buffers.
|
||||
* @param aSkipRect An area to skip blurring in.
|
||||
* XXX shouldn't we pass stride in separately here?
|
||||
* Helper function to process each row of the box blur.
|
||||
* It takes care of transposing the data on input or output depending
|
||||
* on whether we intend a horizontal or vertical blur, and whether we're
|
||||
* reading from the initial source or writing to the final destination.
|
||||
* It allows starting or ending anywhere within the row to accomodate
|
||||
* a skip rect.
|
||||
*/
|
||||
static void
|
||||
BoxBlurHorizontal(unsigned char* aInput,
|
||||
unsigned char* aOutput,
|
||||
int32_t aLeftLobe,
|
||||
int32_t aRightLobe,
|
||||
int32_t aWidth,
|
||||
int32_t aRows,
|
||||
const IntRect& aSkipRect)
|
||||
template<bool aTransposeInput, bool aTransposeOutput>
|
||||
static inline void
|
||||
BoxBlurRow(const uint8_t* aInput,
|
||||
uint8_t* aOutput,
|
||||
int32_t aLeftLobe,
|
||||
int32_t aRightLobe,
|
||||
int32_t aWidth,
|
||||
int32_t aStride,
|
||||
int32_t aStart,
|
||||
int32_t aEnd)
|
||||
{
|
||||
MOZ_ASSERT(aWidth > 0);
|
||||
// If the input or output is transposed, then we will move down a row
|
||||
// for each step, instead of moving over a column. Since these values
|
||||
// only depend on a template parameter, they will more easily get
|
||||
// copy-propagated in the non-transposed case, which is why they
|
||||
// are not passed as parameters.
|
||||
const int32_t inputStep = aTransposeInput ? aStride : 1;
|
||||
const int32_t outputStep = aTransposeOutput ? aStride : 1;
|
||||
|
||||
int32_t boxSize = aLeftLobe + aRightLobe + 1;
|
||||
bool skipRectCoversWholeRow = 0 >= aSkipRect.x &&
|
||||
aWidth <= aSkipRect.XMost();
|
||||
if (boxSize == 1) {
|
||||
memcpy(aOutput, aInput, aWidth*aRows);
|
||||
return;
|
||||
// We need to sample aLeftLobe pixels to the left and aRightLobe pixels
|
||||
// to the right of the current position, then average them. So this is
|
||||
// the size of the total width of this filter.
|
||||
const int32_t boxSize = aLeftLobe + aRightLobe + 1;
|
||||
|
||||
// Instead of dividing the pixel sum by boxSize to average, we can just
|
||||
// compute a scale that will normalize the result so that it can be quickly
|
||||
// shifted into the desired range.
|
||||
const uint32_t reciprocal = (1 << 24) / boxSize;
|
||||
|
||||
// The shift would normally truncate the result, whereas we would rather
|
||||
// prefer to round the result to the closest increment. By adding 0.5 units
|
||||
// to the initial sum, we bias the sum so that it will be rounded by the
|
||||
// truncation instead.
|
||||
uint32_t alphaSum = (boxSize + 1) / 2;
|
||||
|
||||
// We process the row with a moving filter, keeping a sum (alphaSum) of
|
||||
// boxSize pixels. As we move over a pixel, we need to add on a pixel
|
||||
// from the right extreme of the window that moved into range, and subtract
|
||||
// off a pixel from the left extreme of window that moved out of range.
|
||||
// But first, we need to initialization alphaSum to the contents of
|
||||
// the window before we can get going. If the window moves out of bounds
|
||||
// of the row, we clamp each sample to be the closest pixel from within
|
||||
// row bounds, so the 0th and aWidth-1th pixel.
|
||||
int32_t initLeft = aStart - aLeftLobe;
|
||||
if (initLeft < 0) {
|
||||
// If the left lobe samples before the row, add in clamped samples.
|
||||
alphaSum += -initLeft * aInput[0];
|
||||
initLeft = 0;
|
||||
}
|
||||
int32_t initRight = aStart + boxSize - aLeftLobe;
|
||||
if (initRight > aWidth) {
|
||||
// If the right lobe samples after the row, add in clamped samples.
|
||||
alphaSum += (initRight - aWidth) * aInput[(aWidth - 1) * inputStep];
|
||||
initRight = aWidth;
|
||||
}
|
||||
// Finally, add in all the valid, non-clamped samples to fill up the
|
||||
// rest of the window.
|
||||
const uint8_t* src = &aInput[initLeft * inputStep];
|
||||
const uint8_t* iterEnd = &aInput[initRight * inputStep];
|
||||
|
||||
#define INIT_ITER \
|
||||
alphaSum += *src; \
|
||||
src += inputStep;
|
||||
|
||||
// We unroll the per-pixel loop here substantially. The amount of work
|
||||
// done per sample is so small that the cost of a loop condition check
|
||||
// and a branch can substantially add to or even dominate the performance
|
||||
// of the loop.
|
||||
while (src + 16 * inputStep <= iterEnd) {
|
||||
INIT_ITER; INIT_ITER; INIT_ITER; INIT_ITER;
|
||||
INIT_ITER; INIT_ITER; INIT_ITER; INIT_ITER;
|
||||
INIT_ITER; INIT_ITER; INIT_ITER; INIT_ITER;
|
||||
INIT_ITER; INIT_ITER; INIT_ITER; INIT_ITER;
|
||||
}
|
||||
while (src < iterEnd) {
|
||||
INIT_ITER;
|
||||
}
|
||||
|
||||
// Now we start moving the window over the row. We will be accessing
|
||||
// pixels form aStart - aLeftLobe up to aEnd + aRightLobe, which may be
|
||||
// out of bounds of the row. To avoid having to check within the inner
|
||||
// loops if we are in bound, we instead compute the points at which
|
||||
// we will move out of bounds of the row on the left side (splitLeft)
|
||||
// and right side (splitRight).
|
||||
int32_t splitLeft = min(max(aLeftLobe, aStart), aEnd);
|
||||
int32_t splitRight = min(max(aWidth - (boxSize - aLeftLobe), aStart), aEnd);
|
||||
// If the filter window is actually large than the size of the row,
|
||||
// there will be a middle area of overlap where the leftmost and rightmost
|
||||
// pixel of the filter will both be outside the row. In this case, we need
|
||||
// to invert the splits so that splitLeft <= splitRight.
|
||||
if (boxSize > aWidth) {
|
||||
swap(splitLeft, splitRight);
|
||||
}
|
||||
|
||||
// Process all pixels up to splitLeft that would sample before the start of the row.
|
||||
// Note that because inputStep and outputStep may not be a const 1 value, it is more
|
||||
// performant to increment pointers here for the source and destination rather than
|
||||
// use a loop counter, since doing so would entail an expensive multiplication that
|
||||
// significantly slows down the loop.
|
||||
uint8_t* dst = &aOutput[aStart * outputStep];
|
||||
iterEnd = &aOutput[splitLeft * outputStep];
|
||||
src = &aInput[(aStart + boxSize - aLeftLobe) * inputStep];
|
||||
uint8_t firstVal = aInput[0];
|
||||
|
||||
#define LEFT_ITER \
|
||||
*dst = (alphaSum * reciprocal) >> 24; \
|
||||
alphaSum += *src - firstVal; \
|
||||
dst += outputStep; \
|
||||
src += inputStep;
|
||||
|
||||
while (dst + 16 * outputStep <= iterEnd) {
|
||||
LEFT_ITER; LEFT_ITER; LEFT_ITER; LEFT_ITER;
|
||||
LEFT_ITER; LEFT_ITER; LEFT_ITER; LEFT_ITER;
|
||||
LEFT_ITER; LEFT_ITER; LEFT_ITER; LEFT_ITER;
|
||||
LEFT_ITER; LEFT_ITER; LEFT_ITER; LEFT_ITER;
|
||||
}
|
||||
while (dst < iterEnd) {
|
||||
LEFT_ITER;
|
||||
}
|
||||
|
||||
// Process all pixels between splitLeft and splitRight.
|
||||
iterEnd = &aOutput[splitRight * outputStep];
|
||||
if (boxSize <= aWidth) {
|
||||
// The filter window is smaller than the row size, so the leftmost and rightmost
|
||||
// samples are both within row bounds.
|
||||
src = &aInput[(splitLeft - aLeftLobe) * inputStep];
|
||||
int32_t boxStep = boxSize * inputStep;
|
||||
|
||||
#define CENTER_ITER \
|
||||
*dst = (alphaSum * reciprocal) >> 24; \
|
||||
alphaSum += src[boxStep] - *src; \
|
||||
dst += outputStep; \
|
||||
src += inputStep;
|
||||
|
||||
while (dst + 16 * outputStep <= iterEnd) {
|
||||
CENTER_ITER; CENTER_ITER; CENTER_ITER; CENTER_ITER;
|
||||
CENTER_ITER; CENTER_ITER; CENTER_ITER; CENTER_ITER;
|
||||
CENTER_ITER; CENTER_ITER; CENTER_ITER; CENTER_ITER;
|
||||
CENTER_ITER; CENTER_ITER; CENTER_ITER; CENTER_ITER;
|
||||
}
|
||||
uint32_t reciprocal = uint32_t((uint64_t(1) << 32) / boxSize);
|
||||
|
||||
for (int32_t y = 0; y < aRows; y++) {
|
||||
// Check whether the skip rect intersects this row. If the skip
|
||||
// rect covers the whole surface in this row, we can avoid
|
||||
// this row entirely (and any others along the skip rect).
|
||||
bool inSkipRectY = y >= aSkipRect.y &&
|
||||
y < aSkipRect.YMost();
|
||||
if (inSkipRectY && skipRectCoversWholeRow) {
|
||||
y = aSkipRect.YMost() - 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
uint32_t alphaSum = 0;
|
||||
for (int32_t i = 0; i < boxSize; i++) {
|
||||
int32_t pos = i - aLeftLobe;
|
||||
// See assertion above; if aWidth is zero, then we would have no
|
||||
// valid position to clamp to.
|
||||
pos = max(pos, 0);
|
||||
pos = min(pos, aWidth - 1);
|
||||
alphaSum += aInput[aWidth * y + pos];
|
||||
}
|
||||
for (int32_t x = 0; x < aWidth; x++) {
|
||||
// Check whether we are within the skip rect. If so, go
|
||||
// to the next point outside the skip rect.
|
||||
if (inSkipRectY && x >= aSkipRect.x &&
|
||||
x < aSkipRect.XMost()) {
|
||||
x = aSkipRect.XMost();
|
||||
if (x >= aWidth)
|
||||
break;
|
||||
|
||||
// Recalculate the neighbouring alpha values for
|
||||
// our new point on the surface.
|
||||
alphaSum = 0;
|
||||
for (int32_t i = 0; i < boxSize; i++) {
|
||||
int32_t pos = x + i - aLeftLobe;
|
||||
// See assertion above; if aWidth is zero, then we would have no
|
||||
// valid position to clamp to.
|
||||
pos = max(pos, 0);
|
||||
pos = min(pos, aWidth - 1);
|
||||
alphaSum += aInput[aWidth * y + pos];
|
||||
}
|
||||
}
|
||||
int32_t tmp = x - aLeftLobe;
|
||||
int32_t last = max(tmp, 0);
|
||||
int32_t next = min(tmp + boxSize, aWidth - 1);
|
||||
|
||||
aOutput[aWidth * y + x] = (uint64_t(alphaSum) * reciprocal) >> 32;
|
||||
|
||||
alphaSum += aInput[aWidth * y + next] -
|
||||
aInput[aWidth * y + last];
|
||||
}
|
||||
while (dst < iterEnd) {
|
||||
CENTER_ITER;
|
||||
}
|
||||
} else {
|
||||
// The filter window is larger than the row size, and we're in the area of split
|
||||
// overlap. So the leftmost and rightmost samples are both out of bounds and need
|
||||
// to be clamped. We can just precompute the difference here consequently.
|
||||
int32_t firstLastDiff = aInput[(aWidth -1) * inputStep] - aInput[0];
|
||||
while (dst < iterEnd) {
|
||||
*dst = (alphaSum * reciprocal) >> 24;
|
||||
alphaSum += firstLastDiff;
|
||||
dst += outputStep;
|
||||
}
|
||||
}
|
||||
|
||||
// Process all remaining pixels after splitRight that would sample after the row end.
|
||||
iterEnd = &aOutput[aEnd * outputStep];
|
||||
src = &aInput[(splitRight - aLeftLobe) * inputStep];
|
||||
uint8_t lastVal = aInput[(aWidth - 1) * inputStep];
|
||||
|
||||
#define RIGHT_ITER \
|
||||
*dst = (alphaSum * reciprocal) >> 24; \
|
||||
alphaSum += lastVal - *src; \
|
||||
dst += outputStep; \
|
||||
src += inputStep;
|
||||
|
||||
while (dst + 16 * outputStep <= iterEnd) {
|
||||
RIGHT_ITER; RIGHT_ITER; RIGHT_ITER; RIGHT_ITER;
|
||||
RIGHT_ITER; RIGHT_ITER; RIGHT_ITER; RIGHT_ITER;
|
||||
RIGHT_ITER; RIGHT_ITER; RIGHT_ITER; RIGHT_ITER;
|
||||
RIGHT_ITER; RIGHT_ITER; RIGHT_ITER; RIGHT_ITER;
|
||||
}
|
||||
while (dst < iterEnd) {
|
||||
RIGHT_ITER;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Identical to BoxBlurHorizontal, except it blurs top and bottom instead of
|
||||
* left and right.
|
||||
* XXX shouldn't we pass stride in separately here?
|
||||
* Box blur involves looking at one pixel, and setting its value to the average
|
||||
* of its neighbouring pixels. This is meant to provide a 3-pass approximation of a
|
||||
* Gaussian blur.
|
||||
* @param aTranspose Whether to transpose the buffer when reading and writing to it.
|
||||
* @param aData The buffer to be blurred.
|
||||
* @param aLobes The number of pixels to blend on the left and right for each of 3 passes.
|
||||
* @param aWidth The number of columns in the buffers.
|
||||
* @param aRows The number of rows in the buffers.
|
||||
* @param aStride The stride of the buffer.
|
||||
*/
|
||||
template<bool aTranspose>
|
||||
static void
|
||||
BoxBlurVertical(unsigned char* aInput,
|
||||
unsigned char* aOutput,
|
||||
int32_t aTopLobe,
|
||||
int32_t aBottomLobe,
|
||||
int32_t aWidth,
|
||||
int32_t aRows,
|
||||
const IntRect& aSkipRect)
|
||||
BoxBlur(uint8_t* aData,
|
||||
const int32_t aLobes[3][2],
|
||||
int32_t aWidth,
|
||||
int32_t aRows,
|
||||
int32_t aStride,
|
||||
IntRect aSkipRect)
|
||||
{
|
||||
MOZ_ASSERT(aRows > 0);
|
||||
if (aTranspose) {
|
||||
swap(aWidth, aRows);
|
||||
swap(aSkipRect.x, aSkipRect.y);
|
||||
swap(aSkipRect.width, aSkipRect.height);
|
||||
}
|
||||
|
||||
int32_t boxSize = aTopLobe + aBottomLobe + 1;
|
||||
bool skipRectCoversWholeColumn = 0 >= aSkipRect.y &&
|
||||
aRows <= aSkipRect.YMost();
|
||||
if (boxSize == 1) {
|
||||
memcpy(aOutput, aInput, aWidth*aRows);
|
||||
return;
|
||||
MOZ_ASSERT(aWidth > 0);
|
||||
|
||||
// All three passes of the box blur that approximate the Gaussian are done
|
||||
// on each row in turn, so we only need two temporary row buffers to process
|
||||
// each row, instead of a full-sized buffer. Data moves from the source to the
|
||||
// first temporary, from the first temporary to the second, then from the second
|
||||
// back to the destination. This way is more cache-friendly than processing whe
|
||||
// whole buffer in each pass and thus yields a nice speedup.
|
||||
uint8_t* tmpRow = new (std::nothrow) uint8_t[2 * aWidth];
|
||||
if (!tmpRow) {
|
||||
return;
|
||||
}
|
||||
uint8_t* tmpRow2 = tmpRow + aWidth;
|
||||
|
||||
const int32_t stride = aTranspose ? 1 : aStride;
|
||||
bool skipRectCoversWholeRow = 0 >= aSkipRect.x &&
|
||||
aWidth <= aSkipRect.XMost();
|
||||
|
||||
for (int32_t y = 0; y < aRows; y++) {
|
||||
// Check whether the skip rect intersects this row. If the skip
|
||||
// rect covers the whole surface in this row, we can avoid
|
||||
// this row entirely (and any others along the skip rect).
|
||||
bool inSkipRectY = y >= aSkipRect.y &&
|
||||
y < aSkipRect.YMost();
|
||||
if (inSkipRectY && skipRectCoversWholeRow) {
|
||||
aData += stride * (aSkipRect.YMost() - y);
|
||||
y = aSkipRect.YMost() - 1;
|
||||
continue;
|
||||
}
|
||||
uint32_t reciprocal = uint32_t((uint64_t(1) << 32) / boxSize);
|
||||
|
||||
for (int32_t x = 0; x < aWidth; x++) {
|
||||
bool inSkipRectX = x >= aSkipRect.x &&
|
||||
x < aSkipRect.XMost();
|
||||
if (inSkipRectX && skipRectCoversWholeColumn) {
|
||||
x = aSkipRect.XMost() - 1;
|
||||
continue;
|
||||
}
|
||||
// Read in data from the source transposed if necessary.
|
||||
BoxBlurRow<aTranspose, false>(aData, tmpRow, aLobes[0][0], aLobes[0][1], aWidth, aStride, 0, aWidth);
|
||||
|
||||
uint32_t alphaSum = 0;
|
||||
for (int32_t i = 0; i < boxSize; i++) {
|
||||
int32_t pos = i - aTopLobe;
|
||||
// See assertion above; if aRows is zero, then we would have no
|
||||
// valid position to clamp to.
|
||||
pos = max(pos, 0);
|
||||
pos = min(pos, aRows - 1);
|
||||
alphaSum += aInput[aWidth * pos + x];
|
||||
}
|
||||
for (int32_t y = 0; y < aRows; y++) {
|
||||
if (inSkipRectX && y >= aSkipRect.y &&
|
||||
y < aSkipRect.YMost()) {
|
||||
y = aSkipRect.YMost();
|
||||
if (y >= aRows)
|
||||
break;
|
||||
// For the middle pass, the data is already pre-transposed and does not need to be post-transposed yet.
|
||||
BoxBlurRow<false, false>(tmpRow, tmpRow2, aLobes[1][0], aLobes[1][1], aWidth, aStride, 0, aWidth);
|
||||
|
||||
alphaSum = 0;
|
||||
for (int32_t i = 0; i < boxSize; i++) {
|
||||
int32_t pos = y + i - aTopLobe;
|
||||
// See assertion above; if aRows is zero, then we would have no
|
||||
// valid position to clamp to.
|
||||
pos = max(pos, 0);
|
||||
pos = min(pos, aRows - 1);
|
||||
alphaSum += aInput[aWidth * pos + x];
|
||||
}
|
||||
}
|
||||
int32_t tmp = y - aTopLobe;
|
||||
int32_t last = max(tmp, 0);
|
||||
int32_t next = min(tmp + boxSize, aRows - 1);
|
||||
|
||||
aOutput[aWidth * y + x] = (uint64_t(alphaSum) * reciprocal) >> 32;
|
||||
|
||||
alphaSum += aInput[aWidth * next + x] -
|
||||
aInput[aWidth * last + x];
|
||||
}
|
||||
// Write back data to the destination transposed if necessary too.
|
||||
// Make sure not to overwrite the skip rect by only outputting to the
|
||||
// destination before and after the skip rect, if requested.
|
||||
int32_t skipStart = inSkipRectY ? min(max(aSkipRect.x, 0), aWidth) : aWidth;
|
||||
int32_t skipEnd = max(skipStart, aSkipRect.XMost());
|
||||
if (skipStart > 0) {
|
||||
BoxBlurRow<false, aTranspose>(tmpRow2, aData, aLobes[2][0], aLobes[2][1], aWidth, aStride, 0, skipStart);
|
||||
}
|
||||
if (skipEnd < aWidth) {
|
||||
BoxBlurRow<false, aTranspose>(tmpRow2, aData, aLobes[2][0], aLobes[2][1], aWidth, aStride, skipEnd, aWidth);
|
||||
}
|
||||
|
||||
aData += stride;
|
||||
}
|
||||
|
||||
delete[] tmpRow;
|
||||
}
|
||||
|
||||
static void ComputeLobes(int32_t aRadius, int32_t aLobes[3][2])
|
||||
|
|
@ -226,8 +335,8 @@ static void ComputeLobes(int32_t aRadius, int32_t aLobes[3][2])
|
|||
}
|
||||
|
||||
static void
|
||||
SpreadHorizontal(unsigned char* aInput,
|
||||
unsigned char* aOutput,
|
||||
SpreadHorizontal(uint8_t* aInput,
|
||||
uint8_t* aOutput,
|
||||
int32_t aRadius,
|
||||
int32_t aWidth,
|
||||
int32_t aRows,
|
||||
|
|
@ -274,8 +383,8 @@ SpreadHorizontal(unsigned char* aInput,
|
|||
}
|
||||
|
||||
static void
|
||||
SpreadVertical(unsigned char* aInput,
|
||||
unsigned char* aOutput,
|
||||
SpreadVertical(uint8_t* aInput,
|
||||
uint8_t* aOutput,
|
||||
int32_t aRadius,
|
||||
int32_t aWidth,
|
||||
int32_t aRows,
|
||||
|
|
@ -335,10 +444,26 @@ AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
|
|||
const IntSize& aBlurRadius,
|
||||
const Rect* aDirtyRect,
|
||||
const Rect* aSkipRect)
|
||||
: mSpreadRadius(aSpreadRadius),
|
||||
mBlurRadius(aBlurRadius),
|
||||
mSurfaceAllocationSize(0)
|
||||
: mSurfaceAllocationSize(0)
|
||||
{
|
||||
Init(aRect, aSpreadRadius, aBlurRadius, aDirtyRect, aSkipRect);
|
||||
}
|
||||
|
||||
AlphaBoxBlur::AlphaBoxBlur()
|
||||
: mSurfaceAllocationSize(0)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
AlphaBoxBlur::Init(const Rect& aRect,
|
||||
const IntSize& aSpreadRadius,
|
||||
const IntSize& aBlurRadius,
|
||||
const Rect* aDirtyRect,
|
||||
const Rect* aSkipRect)
|
||||
{
|
||||
mSpreadRadius = aSpreadRadius;
|
||||
mBlurRadius = aBlurRadius;
|
||||
|
||||
Rect rect(aRect);
|
||||
rect.Inflate(Size(aBlurRadius + aSpreadRadius));
|
||||
rect.RoundOut();
|
||||
|
|
@ -355,8 +480,7 @@ AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
|
|||
mHasDirtyRect = false;
|
||||
}
|
||||
|
||||
mRect = IntRect(int32_t(rect.x), int32_t(rect.y),
|
||||
int32_t(rect.width), int32_t(rect.height));
|
||||
mRect = TruncatedToInt(rect);
|
||||
if (mRect.IsEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -366,11 +490,8 @@ AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
|
|||
// blurring/spreading we need to do. We convert it to IntRect to avoid
|
||||
// expensive int<->float conversions if we were to use Rect instead.
|
||||
Rect skipRect = *aSkipRect;
|
||||
skipRect.RoundIn();
|
||||
skipRect.Deflate(Size(aBlurRadius + aSpreadRadius));
|
||||
mSkipRect = IntRect(int32_t(skipRect.x), int32_t(skipRect.y),
|
||||
int32_t(skipRect.width), int32_t(skipRect.height));
|
||||
|
||||
mSkipRect = RoundedIn(skipRect);
|
||||
mSkipRect = mSkipRect.Intersect(mRect);
|
||||
if (mSkipRect.IsEqualInterior(mRect))
|
||||
return;
|
||||
|
|
@ -397,8 +518,7 @@ AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
|
|||
int32_t aStride,
|
||||
float aSigmaX,
|
||||
float aSigmaY)
|
||||
: mRect(int32_t(aRect.x), int32_t(aRect.y),
|
||||
int32_t(aRect.width), int32_t(aRect.height)),
|
||||
: mRect(TruncatedToInt(aRect)),
|
||||
mSpreadRadius(),
|
||||
mBlurRadius(CalculateBlurRadius(Point(aSigmaX, aSigmaY))),
|
||||
mStride(aStride),
|
||||
|
|
@ -469,7 +589,7 @@ AlphaBoxBlur::Blur(uint8_t* aData)
|
|||
if (mSpreadRadius.width > 0 || mSpreadRadius.height > 0) {
|
||||
// No need to use CheckedInt here - we have validated it in the constructor.
|
||||
size_t szB = stride * size.height;
|
||||
unsigned char* tmpData = new (std::nothrow) uint8_t[szB];
|
||||
uint8_t* tmpData = new (std::nothrow) uint8_t[szB];
|
||||
|
||||
if (!tmpData) {
|
||||
return;
|
||||
|
|
@ -477,8 +597,8 @@ AlphaBoxBlur::Blur(uint8_t* aData)
|
|||
|
||||
memset(tmpData, 0, szB);
|
||||
|
||||
SpreadHorizontal(aData, tmpData, mSpreadRadius.width, GetSize().width, GetSize().height, stride, mSkipRect);
|
||||
SpreadVertical(tmpData, aData, mSpreadRadius.height, GetSize().width, GetSize().height, stride, mSkipRect);
|
||||
SpreadHorizontal(aData, tmpData, mSpreadRadius.width, size.width, size.height, stride, mSkipRect);
|
||||
SpreadVertical(tmpData, aData, mSpreadRadius.height, size.width, size.height, stride, mSkipRect);
|
||||
|
||||
delete [] tmpData;
|
||||
}
|
||||
|
|
@ -497,39 +617,12 @@ AlphaBoxBlur::Blur(uint8_t* aData)
|
|||
if ((integralImageSize.width * integralImageSize.height) > (1 << 24)) {
|
||||
// Fallback to old blurring code when the surface is so large it may
|
||||
// overflow our integral image!
|
||||
|
||||
// No need to use CheckedInt here - we have validated it in the constructor.
|
||||
size_t szB = stride * size.height;
|
||||
uint8_t* tmpData = new (std::nothrow) uint8_t[szB];
|
||||
if (!tmpData) {
|
||||
return;
|
||||
}
|
||||
|
||||
memset(tmpData, 0, szB);
|
||||
|
||||
uint8_t* a = aData;
|
||||
uint8_t* b = tmpData;
|
||||
if (mBlurRadius.width > 0) {
|
||||
BoxBlurHorizontal(a, b, horizontalLobes[0][0], horizontalLobes[0][1], stride, GetSize().height, mSkipRect);
|
||||
BoxBlurHorizontal(b, a, horizontalLobes[1][0], horizontalLobes[1][1], stride, GetSize().height, mSkipRect);
|
||||
BoxBlurHorizontal(a, b, horizontalLobes[2][0], horizontalLobes[2][1], stride, GetSize().height, mSkipRect);
|
||||
} else {
|
||||
a = tmpData;
|
||||
b = aData;
|
||||
BoxBlur<false>(aData, horizontalLobes, size.width, size.height, stride, mSkipRect);
|
||||
}
|
||||
// The result is in 'b' here.
|
||||
if (mBlurRadius.height > 0) {
|
||||
BoxBlurVertical(b, a, verticalLobes[0][0], verticalLobes[0][1], stride, GetSize().height, mSkipRect);
|
||||
BoxBlurVertical(a, b, verticalLobes[1][0], verticalLobes[1][1], stride, GetSize().height, mSkipRect);
|
||||
BoxBlurVertical(b, a, verticalLobes[2][0], verticalLobes[2][1], stride, GetSize().height, mSkipRect);
|
||||
} else {
|
||||
a = b;
|
||||
BoxBlur<true>(aData, verticalLobes, size.width, size.height, stride, mSkipRect);
|
||||
}
|
||||
// The result is in 'a' here.
|
||||
if (a == tmpData) {
|
||||
memcpy(aData, tmpData, szB);
|
||||
}
|
||||
delete [] tmpData;
|
||||
} else {
|
||||
size_t integralImageStride = GetAlignedStride<16>(integralImageSize.width, 4);
|
||||
if (integralImageStride == 0) {
|
||||
|
|
@ -765,5 +858,11 @@ AlphaBoxBlur::CalculateBlurRadius(const Point& aStd)
|
|||
return size;
|
||||
}
|
||||
|
||||
Float
|
||||
AlphaBoxBlur::CalculateBlurSigma(int32_t aBlurRadius)
|
||||
{
|
||||
return aBlurRadius / GAUSSIAN_SCALE_FACTOR;
|
||||
}
|
||||
|
||||
} // namespace gfx
|
||||
} // namespace mozilla
|
||||
|
|
|
|||
|
|
@ -68,6 +68,14 @@ public:
|
|||
float aSigmaX,
|
||||
float aSigmaY);
|
||||
|
||||
AlphaBoxBlur();
|
||||
|
||||
void Init(const Rect& aRect,
|
||||
const IntSize& aSpreadRadius,
|
||||
const IntSize& aBlurRadius,
|
||||
const Rect* aDirtyRect,
|
||||
const Rect* aSkipRect);
|
||||
|
||||
~AlphaBoxBlur();
|
||||
|
||||
/**
|
||||
|
|
@ -91,6 +99,16 @@ public:
|
|||
*/
|
||||
Rect* GetDirtyRect();
|
||||
|
||||
/**
|
||||
* Return the spread radius, in pixels.
|
||||
*/
|
||||
IntSize GetSpreadRadius() const { return mSpreadRadius; }
|
||||
|
||||
/**
|
||||
* Return the blur radius, in pixels.
|
||||
*/
|
||||
IntSize GetBlurRadius() const { return mBlurRadius; }
|
||||
|
||||
/**
|
||||
* Return the minimum buffer size that should be given to Blur() method. If
|
||||
* zero, the class is not properly setup for blurring. Note that this
|
||||
|
|
@ -114,6 +132,7 @@ public:
|
|||
* constructor, above.
|
||||
*/
|
||||
static IntSize CalculateBlurRadius(const Point& aStandardDeviation);
|
||||
static Float CalculateBlurSigma(int32_t aBlurRadius);
|
||||
|
||||
private:
|
||||
|
||||
|
|
|
|||
|
|
@ -931,16 +931,18 @@ DrawTargetCairo::DrawSurfaceWithShadow(SourceSurface *aSurface,
|
|||
if (cairo_surface_get_type(sourcesurf) == CAIRO_SURFACE_TYPE_TEE) {
|
||||
blursurf = cairo_tee_surface_index(sourcesurf, 0);
|
||||
surf = cairo_tee_surface_index(sourcesurf, 1);
|
||||
} else {
|
||||
blursurf = sourcesurf;
|
||||
surf = sourcesurf;
|
||||
}
|
||||
|
||||
if (aSigma != 0.0f) {
|
||||
MOZ_ASSERT(cairo_surface_get_type(blursurf) == CAIRO_SURFACE_TYPE_IMAGE);
|
||||
Rect extents(0, 0, width, height);
|
||||
AlphaBoxBlur blur(extents,
|
||||
cairo_image_surface_get_stride(blursurf),
|
||||
aSigma, aSigma);
|
||||
blur.Blur(cairo_image_surface_get_data(blursurf));
|
||||
} else {
|
||||
blursurf = sourcesurf;
|
||||
surf = sourcesurf;
|
||||
}
|
||||
|
||||
WillChange();
|
||||
|
|
@ -951,25 +953,24 @@ DrawTargetCairo::DrawSurfaceWithShadow(SourceSurface *aSurface,
|
|||
cairo_identity_matrix(mContext);
|
||||
cairo_translate(mContext, aDest.x, aDest.y);
|
||||
|
||||
if (IsOperatorBoundByMask(aOperator)){
|
||||
cairo_set_source_rgba(mContext, aColor.r, aColor.g, aColor.b, aColor.a);
|
||||
cairo_mask_surface(mContext, blursurf, aOffset.x, aOffset.y);
|
||||
bool needsGroup = !IsOperatorBoundByMask(aOperator);
|
||||
if (needsGroup) {
|
||||
cairo_push_group(mContext);
|
||||
}
|
||||
|
||||
cairo_set_source_rgba(mContext, aColor.r, aColor.g, aColor.b, aColor.a);
|
||||
cairo_mask_surface(mContext, blursurf, aOffset.x, aOffset.y);
|
||||
|
||||
if (blursurf != surf ||
|
||||
aSurface->GetFormat() != SurfaceFormat::A8) {
|
||||
// Now that the shadow has been drawn, we can draw the surface on top.
|
||||
cairo_set_source_surface(mContext, surf, 0, 0);
|
||||
cairo_new_path(mContext);
|
||||
cairo_rectangle(mContext, 0, 0, width, height);
|
||||
cairo_fill(mContext);
|
||||
} else {
|
||||
cairo_push_group(mContext);
|
||||
cairo_set_source_rgba(mContext, aColor.r, aColor.g, aColor.b, aColor.a);
|
||||
cairo_mask_surface(mContext, blursurf, aOffset.x, aOffset.y);
|
||||
}
|
||||
|
||||
// Now that the shadow has been drawn, we can draw the surface on top.
|
||||
cairo_set_source_surface(mContext, surf, 0, 0);
|
||||
cairo_new_path(mContext);
|
||||
cairo_rectangle(mContext, 0, 0, width, height);
|
||||
cairo_fill(mContext);
|
||||
if (needsGroup) {
|
||||
cairo_pop_group_to_source(mContext);
|
||||
cairo_paint(mContext);
|
||||
}
|
||||
|
|
@ -1924,7 +1925,7 @@ DrawTargetCairo::CreateShadowDrawTarget(const IntSize &aSize, SurfaceFormat aFor
|
|||
|
||||
// If we don't have a blur then we can use the RGBA mask and keep all the
|
||||
// operations in graphics memory.
|
||||
if (aSigma == 0.0F) {
|
||||
if (aSigma == 0.0f || aFormat == SurfaceFormat::A8) {
|
||||
RefPtr<DrawTargetCairo> target = new DrawTargetCairo();
|
||||
if (target->InitAlreadyReferenced(similar, aSize)) {
|
||||
return target.forget();
|
||||
|
|
|
|||
|
|
@ -244,21 +244,29 @@ DrawTargetD2D1::DrawSurfaceWithShadow(SourceSurface *aSurface,
|
|||
|
||||
// Step 1, create the shadow effect.
|
||||
RefPtr<ID2D1Effect> shadowEffect;
|
||||
HRESULT hr = mDC->CreateEffect(CLSID_D2D1Shadow, getter_AddRefs(shadowEffect));
|
||||
HRESULT hr = mDC->CreateEffect(mFormat == SurfaceFormat::A8 ? CLSID_D2D1GaussianBlur : CLSID_D2D1Shadow,
|
||||
getter_AddRefs(shadowEffect));
|
||||
if (FAILED(hr) || !shadowEffect) {
|
||||
gfxWarning() << "Failed to create shadow effect. Code: " << hexa(hr);
|
||||
return;
|
||||
}
|
||||
shadowEffect->SetInput(0, image);
|
||||
shadowEffect->SetValue(D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION, aSigma);
|
||||
D2D1_VECTOR_4F color = { aColor.r, aColor.g, aColor.b, aColor.a };
|
||||
shadowEffect->SetValue(D2D1_SHADOW_PROP_COLOR, color);
|
||||
if (mFormat == SurfaceFormat::A8) {
|
||||
shadowEffect->SetValue(D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION, aSigma);
|
||||
shadowEffect->SetValue(D2D1_GAUSSIANBLUR_PROP_BORDER_MODE, D2D1_BORDER_MODE_HARD);
|
||||
} else {
|
||||
shadowEffect->SetValue(D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION, aSigma);
|
||||
D2D1_VECTOR_4F color = { aColor.r, aColor.g, aColor.b, aColor.a };
|
||||
shadowEffect->SetValue(D2D1_SHADOW_PROP_COLOR, color);
|
||||
}
|
||||
|
||||
D2D1_POINT_2F shadowPoint = D2DPoint(aDest + aOffset);
|
||||
mDC->DrawImage(shadowEffect, &shadowPoint, nullptr, D2D1_INTERPOLATION_MODE_LINEAR, D2DCompositionMode(aOperator));
|
||||
|
||||
D2D1_POINT_2F imgPoint = D2DPoint(aDest);
|
||||
mDC->DrawImage(image, &imgPoint, nullptr, D2D1_INTERPOLATION_MODE_LINEAR, D2DCompositionMode(aOperator));
|
||||
if (aSurface->GetFormat() != SurfaceFormat::A8) {
|
||||
D2D1_POINT_2F imgPoint = D2DPoint(aDest);
|
||||
mDC->DrawImage(image, &imgPoint, nullptr, D2D1_INTERPOLATION_MODE_LINEAR, D2DCompositionMode(aOperator));
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -713,9 +713,11 @@ DrawTargetSkia::DrawSurfaceWithShadow(SourceSurface *aSurface,
|
|||
mCanvas->drawImage(image, shadowDest.x, shadowDest.y, &shadowPaint);
|
||||
}
|
||||
|
||||
// Composite the original image after the shadow
|
||||
auto dest = IntPoint::Round(aDest);
|
||||
mCanvas->drawImage(image, dest.x, dest.y, &paint);
|
||||
if (aSurface->GetFormat() != SurfaceFormat::A8) {
|
||||
// Composite the original image after the shadow
|
||||
auto dest = IntPoint::Round(aDest);
|
||||
mCanvas->drawImage(image, dest.x, dest.y, &paint);
|
||||
}
|
||||
|
||||
mCanvas->restore();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -595,6 +595,8 @@ CreatePartialBitmapForSurface(DataSourceSurface *aSurface, const Matrix &aDestin
|
|||
//
|
||||
//
|
||||
|
||||
int Bpp = BytesPerPixel(aSurface->GetFormat());
|
||||
|
||||
if (uploadRect.Contains(rect)) {
|
||||
// Extend mode is irrelevant, the displayed rect is completely contained
|
||||
// by the source bitmap.
|
||||
|
|
@ -631,7 +633,7 @@ CreatePartialBitmapForSurface(DataSourceSurface *aSurface, const Matrix &aDestin
|
|||
|
||||
// A partial upload will suffice.
|
||||
aRT->CreateBitmap(D2D1::SizeU(uint32_t(uploadRect.width), uint32_t(uploadRect.height)),
|
||||
mapping.GetData() + int(uploadRect.x) * 4 + int(uploadRect.y) * mapping.GetStride(),
|
||||
mapping.GetData() + int(uploadRect.x) * Bpp + int(uploadRect.y) * mapping.GetStride(),
|
||||
mapping.GetStride(),
|
||||
D2D1::BitmapProperties(D2DPixelFormat(aSurface->GetFormat())),
|
||||
getter_AddRefs(bitmap));
|
||||
|
|
@ -641,8 +643,6 @@ CreatePartialBitmapForSurface(DataSourceSurface *aSurface, const Matrix &aDestin
|
|||
|
||||
return bitmap.forget();
|
||||
} else {
|
||||
int Bpp = BytesPerPixel(aSurface->GetFormat());
|
||||
|
||||
if (Bpp != 4) {
|
||||
// This shouldn't actually happen in practice!
|
||||
MOZ_ASSERT(false);
|
||||
|
|
|
|||
|
|
@ -224,6 +224,15 @@ struct RectCornerRadii {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool AreRadiiSame() const {
|
||||
for (size_t i = 1; i < RectCorner::Count; i++) {
|
||||
if (radii[i] != radii[0]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Scale(Float aXScale, Float aYScale) {
|
||||
for (int i = 0; i < RectCorner::Count; i++) {
|
||||
radii[i].Scale(aXScale, aYScale);
|
||||
|
|
|
|||
|
|
@ -285,7 +285,7 @@ typedef IntSizeTyped<UnknownUnits> IntSize;
|
|||
|
||||
template<class units, class F = Float>
|
||||
struct SizeTyped :
|
||||
public BaseSize< F, SizeTyped<units> >,
|
||||
public BaseSize< F, SizeTyped<units, F> >,
|
||||
public units {
|
||||
static_assert(IsPixel<units>::value,
|
||||
"'units' must be a coordinate system tag");
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -10,14 +10,13 @@
|
|||
#include "nsSize.h"
|
||||
#include "gfxPoint.h"
|
||||
#include "mozilla/RefPtr.h"
|
||||
#include "mozilla/UniquePtr.h"
|
||||
#include "mozilla/gfx/Blur.h"
|
||||
|
||||
class gfxContext;
|
||||
struct gfxRect;
|
||||
|
||||
namespace mozilla {
|
||||
namespace gfx {
|
||||
class AlphaBoxBlur;
|
||||
struct Color;
|
||||
struct RectCornerRadii;
|
||||
class SourceSurface;
|
||||
|
|
@ -57,6 +56,9 @@ public:
|
|||
|
||||
/**
|
||||
* Constructs a box blur and initializes the temporary surface.
|
||||
*
|
||||
* @param aDestinationCtx The destination to blur to.
|
||||
*
|
||||
* @param aRect The coordinates of the surface to create in device units.
|
||||
*
|
||||
* @param aBlurRadius The blur radius in pixels. This is the radius of
|
||||
|
|
@ -73,24 +75,28 @@ public:
|
|||
* represents an area where blurring is unnecessary and shouldn't be done
|
||||
* for speed reasons. It is safe to pass nullptr here.
|
||||
*/
|
||||
gfxContext* Init(const gfxRect& aRect,
|
||||
const mozilla::gfx::IntSize& aSpreadRadius,
|
||||
const mozilla::gfx::IntSize& aBlurRadius,
|
||||
const gfxRect* aDirtyRect,
|
||||
const gfxRect* aSkipRect);
|
||||
already_AddRefed<gfxContext>
|
||||
Init(gfxContext* aDestinationCtx,
|
||||
const gfxRect& aRect,
|
||||
const mozilla::gfx::IntSize& aSpreadRadius,
|
||||
const mozilla::gfx::IntSize& aBlurRadius,
|
||||
const gfxRect* aDirtyRect,
|
||||
const gfxRect* aSkipRect);
|
||||
|
||||
already_AddRefed<DrawTarget>
|
||||
InitDrawTarget(const mozilla::gfx::DrawTarget* aReferenceDT,
|
||||
const mozilla::gfx::Rect& aRect,
|
||||
const mozilla::gfx::IntSize& aSpreadRadius,
|
||||
const mozilla::gfx::IntSize& aBlurRadius,
|
||||
const mozilla::gfx::Rect* aDirtyRect = nullptr,
|
||||
const mozilla::gfx::Rect* aSkipRect = nullptr);
|
||||
|
||||
/**
|
||||
* Returns the context that should be drawn to supply the alpha mask to be
|
||||
* blurred. If the returned surface is null, then there was an error in
|
||||
* its creation.
|
||||
* Performs the blur and optionally colors the result if aShadowColor is not null.
|
||||
*/
|
||||
gfxContext* GetContext()
|
||||
{
|
||||
return mContext;
|
||||
}
|
||||
|
||||
already_AddRefed<mozilla::gfx::SourceSurface>
|
||||
DoBlur(DrawTarget* aDT, mozilla::gfx::IntPoint* aTopLeft);
|
||||
DoBlur(const mozilla::gfx::Color* aShadowColor = nullptr,
|
||||
mozilla::gfx::IntPoint* aOutTopLeft = nullptr);
|
||||
|
||||
/**
|
||||
* Does the actual blurring/spreading and mask applying. Users of this
|
||||
|
|
@ -129,7 +135,7 @@ public:
|
|||
*/
|
||||
static void BlurRectangle(gfxContext *aDestinationCtx,
|
||||
const gfxRect& aRect,
|
||||
RectCornerRadii* aCornerRadii,
|
||||
const RectCornerRadii* aCornerRadii,
|
||||
const gfxPoint& aBlurStdDev,
|
||||
const Color& aShadowColor,
|
||||
const gfxRect& aDirtyRect,
|
||||
|
|
@ -154,41 +160,45 @@ public:
|
|||
* @param aSKipRect An area in device pixels we don't have to paint in.
|
||||
*/
|
||||
void BlurInsetBox(gfxContext* aDestinationCtx,
|
||||
const mozilla::gfx::Rect aDestinationRect,
|
||||
const mozilla::gfx::Rect aShadowClipRect,
|
||||
const mozilla::gfx::IntSize aBlurRadius,
|
||||
const mozilla::gfx::IntSize aSpreadRadius,
|
||||
const mozilla::gfx::Rect& aDestinationRect,
|
||||
const mozilla::gfx::Rect& aShadowClipRect,
|
||||
const mozilla::gfx::IntSize& aBlurRadius,
|
||||
const mozilla::gfx::Color& aShadowColor,
|
||||
const bool aHasBorderRadius,
|
||||
const RectCornerRadii& aInnerClipRadii,
|
||||
const mozilla::gfx::Rect aSkipRect,
|
||||
const mozilla::gfx::Point aShadowOffset);
|
||||
const RectCornerRadii* aInnerClipRadii,
|
||||
const mozilla::gfx::Rect& aSkipRect,
|
||||
const mozilla::gfx::Point& aShadowOffset);
|
||||
|
||||
protected:
|
||||
already_AddRefed<mozilla::gfx::SourceSurface>
|
||||
GetInsetBlur(const mozilla::gfx::Rect aOuterRect,
|
||||
const mozilla::gfx::Rect aWhitespaceRect,
|
||||
const bool aIsDestRect,
|
||||
GetInsetBlur(const mozilla::gfx::Rect& aOuterRect,
|
||||
const mozilla::gfx::Rect& aWhitespaceRect,
|
||||
bool aIsDestRect,
|
||||
const mozilla::gfx::Color& aShadowColor,
|
||||
const mozilla::gfx::IntSize& aBlurRadius,
|
||||
const bool aHasBorderRadius,
|
||||
const RectCornerRadii& aInnerClipRadii,
|
||||
DrawTarget* aDestDrawTarget);
|
||||
const RectCornerRadii* aInnerClipRadii,
|
||||
DrawTarget* aDestDrawTarget,
|
||||
bool aMirrorCorners);
|
||||
|
||||
|
||||
/**
|
||||
* The context of the temporary alpha surface.
|
||||
* The DrawTarget of the temporary alpha surface.
|
||||
*/
|
||||
RefPtr<gfxContext> mContext;
|
||||
RefPtr<DrawTarget> mDrawTarget;
|
||||
|
||||
/**
|
||||
* The temporary alpha surface.
|
||||
*/
|
||||
mozilla::UniquePtr<unsigned char[]> mData;
|
||||
uint8_t* mData;
|
||||
|
||||
/**
|
||||
* The object that actually does the blurring for us.
|
||||
*/
|
||||
mozilla::UniquePtr<mozilla::gfx::AlphaBoxBlur> mBlur;
|
||||
mozilla::gfx::AlphaBoxBlur mBlur;
|
||||
|
||||
/**
|
||||
* Indicates using DrawTarget-accelerated blurs.
|
||||
*/
|
||||
bool mAccelerated;
|
||||
};
|
||||
|
||||
#endif /* GFX_BLUR_H */
|
||||
|
|
|
|||
|
|
@ -1309,7 +1309,12 @@ gfxPlatform::CreateSimilarSoftwareDrawTarget(DrawTarget* aDT,
|
|||
if (Factory::DoesBackendSupportDataDrawtarget(aDT->GetBackendType())) {
|
||||
dt = aDT->CreateSimilarDrawTarget(aSize, aFormat);
|
||||
} else {
|
||||
dt = Factory::CreateDrawTarget(BackendType::SKIA, aSize, aFormat);
|
||||
#ifdef USE_SKIA
|
||||
BackendType backendType = BackendType::SKIA;
|
||||
#else
|
||||
BackendType backendType = BackendType::CAIRO;
|
||||
#endif
|
||||
dt = Factory::CreateDrawTarget(backendType, aSize, aFormat);
|
||||
}
|
||||
|
||||
return dt.forget();
|
||||
|
|
@ -1322,7 +1327,11 @@ gfxPlatform::CreateDrawTargetForData(unsigned char* aData, const IntSize& aSize,
|
|||
NS_ASSERTION(backendType != BackendType::NONE, "No backend.");
|
||||
|
||||
if (!Factory::DoesBackendSupportDataDrawtarget(backendType)) {
|
||||
#ifdef USE_SKIA
|
||||
backendType = BackendType::SKIA;
|
||||
#else
|
||||
backendType = BackendType::CAIRO;
|
||||
#endif
|
||||
}
|
||||
|
||||
RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForData(backendType,
|
||||
|
|
|
|||
|
|
@ -692,7 +692,7 @@ gfxUtils::ClipToRegion(DrawTarget* aTarget, const nsIntRegion& aRegion)
|
|||
}
|
||||
|
||||
/*static*/ gfxFloat
|
||||
gfxUtils::ClampToScaleFactor(gfxFloat aVal)
|
||||
gfxUtils::ClampToScaleFactor(gfxFloat aVal, bool aRoundDown)
|
||||
{
|
||||
// Arbitary scale factor limitation. We can increase this
|
||||
// for better scaling performance at the cost of worse
|
||||
|
|
@ -713,14 +713,17 @@ gfxUtils::ClampToScaleFactor(gfxFloat aVal)
|
|||
|
||||
gfxFloat power = log(aVal)/log(kScaleResolution);
|
||||
|
||||
// If power is within 1e-5 of an integer, round to nearest to
|
||||
// prevent floating point errors, otherwise round up to the
|
||||
// next integer value.
|
||||
if (fabs(power - NS_round(power)) < 1e-5) {
|
||||
// If power is within 1e-5 of an integer, round to nearest to
|
||||
// prevent floating point errors.
|
||||
power = NS_round(power);
|
||||
} else if (inverse) {
|
||||
} else if (inverse != aRoundDown) {
|
||||
// Use floor when we are either inverted or rounding down, but
|
||||
// not both.
|
||||
power = floor(power);
|
||||
} else {
|
||||
// Otherwise, ceil when we are not inverted and not rounding
|
||||
// down, or we are inverted and rounding down.
|
||||
power = ceil(power);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -128,9 +128,10 @@ public:
|
|||
|
||||
/**
|
||||
* Return the smallest power of kScaleResolution (2) greater than or equal to
|
||||
* aVal.
|
||||
* aVal. If aRoundDown is specified, the power of 2 will be less than
|
||||
* or equal to aVal.
|
||||
*/
|
||||
static gfxFloat ClampToScaleFactor(gfxFloat aVal);
|
||||
static gfxFloat ClampToScaleFactor(gfxFloat aVal, bool aRoundDown = false);
|
||||
|
||||
/**
|
||||
* Clears surface to aColor (which defaults to transparent black).
|
||||
|
|
|
|||
|
|
@ -288,24 +288,6 @@ class CodeGeneratorARM : public CodeGeneratorShared
|
|||
void visitUDiv(LUDiv* ins);
|
||||
void visitUMod(LUMod* ins);
|
||||
void visitSoftUDivOrMod(LSoftUDivOrMod* ins);
|
||||
|
||||
public:
|
||||
// Unimplemented SIMD instructions
|
||||
void visitSimdSplatX4(LSimdSplatX4* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimd128Int(LSimd128Int* ins) { MOZ_CRASH("NYI"); }
|
||||
void visitSimd128Float(LSimd128Float* ins) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdReinterpretCast(LSimdReinterpretCast* ins) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdExtractElementI(LSimdExtractElementI* ins) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdExtractElementF(LSimdExtractElementF* ins) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdGeneralShuffleI(LSimdGeneralShuffleI* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdGeneralShuffleF(LSimdGeneralShuffleF* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdSwizzleI(LSimdSwizzleI* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdSwizzleF(LSimdSwizzleF* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdBinaryCompIx4(LSimdBinaryCompIx4* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdBinaryCompFx4(LSimdBinaryCompFx4* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdBinaryArithIx4(LSimdBinaryArithIx4* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdBinaryArithFx4(LSimdBinaryArithFx4* lir) { MOZ_CRASH("NYI"); }
|
||||
void visitSimdBinaryBitwise(LSimdBinaryBitwise* lir) { MOZ_CRASH("NYI"); }
|
||||
};
|
||||
|
||||
typedef CodeGeneratorARM CodeGeneratorSpecific;
|
||||
|
|
|
|||
|
|
@ -3013,7 +3013,7 @@ MacroAssemblerARMCompat::testInt32(Condition cond, const BaseIndex& src)
|
|||
return cond;
|
||||
}
|
||||
|
||||
+Assembler::Condition
|
||||
Assembler::Condition
|
||||
MacroAssemblerARMCompat::testBigInt(Condition cond,const BaseIndex& src)
|
||||
{
|
||||
MOZ_ASSERT(cond == Equal || cond == NotEqual);
|
||||
|
|
@ -3766,7 +3766,7 @@ MacroAssemblerARMCompat::testStringTruthy(bool truthy, const ValueOperand& value
|
|||
return truthy ? Assembler::NotEqual : Assembler::Equal;
|
||||
}
|
||||
|
||||
+Assembler::Condition
|
||||
Assembler::Condition
|
||||
MacroAssemblerARMCompat::testBigIntTruthy(bool truthy, const ValueOperand& value)
|
||||
{
|
||||
Register bi = value.payloadReg();
|
||||
|
|
|
|||
|
|
@ -201,6 +201,17 @@ ICUnaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
|
|||
// Compile -x as 0 - x.
|
||||
masm.as_rsb(R0.payloadReg(), R0.payloadReg(), Imm8(0));
|
||||
break;
|
||||
case JSOP_INC: {
|
||||
RegisterOrInt32Constant rval = RegisterOrInt32Constant(R0.payloadReg());
|
||||
masm.inc32(&rval);
|
||||
break;
|
||||
}
|
||||
case JSOP_DEC: {
|
||||
RegisterOrInt32Constant rval = RegisterOrInt32Constant(R0.payloadReg());
|
||||
masm.dec32(&rval);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
MOZ_CRASH("Unexpected op");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5245,6 +5245,23 @@ static void RestrictScaleToMaxLayerSize(gfxSize& aScale,
|
|||
aScale.height /= scale;
|
||||
}
|
||||
}
|
||||
|
||||
static nsSize
|
||||
ComputeDesiredDisplaySizeForAnimation(nsIFrame* aContainerFrame)
|
||||
{
|
||||
// Use the size of the nearest widget as the maximum size. This
|
||||
// is important since it might be a popup that is bigger than the
|
||||
// pres context's size.
|
||||
nsPresContext* presContext = aContainerFrame->PresContext();
|
||||
nsIWidget* widget = aContainerFrame->GetNearestWidget();
|
||||
if (widget) {
|
||||
return LayoutDevicePixel::ToAppUnits(widget->GetClientSize(),
|
||||
presContext->AppUnitsPerDevPixel());
|
||||
} else {
|
||||
return presContext->GetVisibleArea().Size();
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
ChooseScaleAndSetTransform(FrameLayerBuilder* aLayerBuilder,
|
||||
nsDisplayListBuilder* aDisplayListBuilder,
|
||||
|
|
@ -5309,20 +5326,7 @@ ChooseScaleAndSetTransform(FrameLayerBuilder* aLayerBuilder,
|
|||
aContainerItem->GetType() == nsDisplayItem::TYPE_TRANSFORM &&
|
||||
EffectCompositor::HasAnimationsForCompositor(
|
||||
aContainerFrame, eCSSProperty_transform)) {
|
||||
// Use the size of the nearest widget as the maximum size. This
|
||||
// is important since it might be a popup that is bigger than the
|
||||
// pres context's size.
|
||||
nsPresContext* presContext = aContainerFrame->PresContext();
|
||||
nsIWidget* widget = aContainerFrame->GetNearestWidget();
|
||||
nsSize displaySize;
|
||||
if (widget) {
|
||||
LayoutDeviceIntSize widgetSize = widget->GetClientSize();
|
||||
int32_t p2a = presContext->AppUnitsPerDevPixel();
|
||||
displaySize.width = NSIntPixelsToAppUnits(widgetSize.width, p2a);
|
||||
displaySize.height = NSIntPixelsToAppUnits(widgetSize.height, p2a);
|
||||
} else {
|
||||
displaySize = presContext->GetVisibleArea().Size();
|
||||
}
|
||||
nsSize displaySize = ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
|
||||
// compute scale using the animation on the container (ignoring
|
||||
// its ancestors)
|
||||
scale = nsLayoutUtils::ComputeSuitableScaleForAnimation(
|
||||
|
|
@ -5359,6 +5363,19 @@ ChooseScaleAndSetTransform(FrameLayerBuilder* aLayerBuilder,
|
|||
if (clamp) {
|
||||
scale.width = gfxUtils::ClampToScaleFactor(scale.width);
|
||||
scale.height = gfxUtils::ClampToScaleFactor(scale.height);
|
||||
|
||||
// Limit animated scale factors to not grow excessively beyond the display size.
|
||||
nsSize maxScale(4, 4);
|
||||
if (!aVisibleRect.IsEmpty()) {
|
||||
nsSize displaySize = ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
|
||||
maxScale = Max(maxScale, displaySize / aVisibleRect.Size());
|
||||
}
|
||||
if (scale.width > maxScale.width) {
|
||||
scale.width = gfxUtils::ClampToScaleFactor(maxScale.width, true);
|
||||
}
|
||||
if (scale.height > maxScale.height) {
|
||||
scale.height = gfxUtils::ClampToScaleFactor(maxScale.height, true);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// XXX Do we need to move nearly-integer values to integers here?
|
||||
|
|
|
|||
|
|
@ -1631,7 +1631,6 @@ nsCSSRendering::PaintBoxShadowInner(nsPresContext* aPresContext,
|
|||
// transparent in the shadow, so drawing them changes nothing.
|
||||
gfxContext* renderContext = aRenderingContext.ThebesContext();
|
||||
DrawTarget* drawTarget = renderContext->GetDrawTarget();
|
||||
nsContextBoxBlur blurringArea;
|
||||
|
||||
// Clip the context to the area of the frame's padding rect, so no part of the
|
||||
// shadow is painted outside. Also cut out anything beyond where the inset shadow
|
||||
|
|
@ -6030,10 +6029,10 @@ nsContextBoxBlur::Init(const nsRect& aRect, nscoord aSpreadRadius,
|
|||
dirtyRect = transform.TransformBounds(dirtyRect);
|
||||
if (aSkipRect) {
|
||||
gfxRect skipRect = transform.TransformBounds(*aSkipRect);
|
||||
mContext = mAlphaBoxBlur.Init(rect, spreadRadius,
|
||||
mContext = mAlphaBoxBlur.Init(aDestinationCtx, rect, spreadRadius,
|
||||
blurRadius, &dirtyRect, &skipRect);
|
||||
} else {
|
||||
mContext = mAlphaBoxBlur.Init(rect, spreadRadius,
|
||||
mContext = mAlphaBoxBlur.Init(aDestinationCtx, rect, spreadRadius,
|
||||
blurRadius, &dirtyRect, nullptr);
|
||||
}
|
||||
|
||||
|
|
@ -6243,9 +6242,8 @@ nsContextBoxBlur::InsetBoxBlur(gfxContext* aDestinationCtx,
|
|||
|
||||
mAlphaBoxBlur.BlurInsetBox(aDestinationCtx, transformedDestRect,
|
||||
transformedShadowClipRect,
|
||||
blurRadius, spreadRadius,
|
||||
aShadowColor, aHasBorderRadius,
|
||||
aInnerClipRectRadii, transformedSkipRect,
|
||||
aShadowOffset);
|
||||
blurRadius, aShadowColor,
|
||||
aHasBorderRadius ? &aInnerClipRectRadii : nullptr,
|
||||
transformedSkipRect, aShadowOffset);
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,19 +18,19 @@ fuzzy-if(skiaContent,1,50) HTTP(..) == boxshadow-dynamic.xul boxshadow-dynamic-r
|
|||
random-if(d2d) == boxshadow-onecorner.html boxshadow-onecorner-ref.html
|
||||
random-if(d2d) == boxshadow-twocorners.html boxshadow-twocorners-ref.html
|
||||
random-if(d2d) == boxshadow-threecorners.html boxshadow-threecorners-ref.html
|
||||
== boxshadow-skiprect.html boxshadow-skiprect-ref.html
|
||||
fuzzy(2,440) == boxshadow-skiprect.html boxshadow-skiprect-ref.html
|
||||
== boxshadow-opacity.html boxshadow-opacity-ref.html
|
||||
== boxshadow-color-rounding.html boxshadow-color-rounding-ref.html
|
||||
== boxshadow-color-rounding-middle.html boxshadow-color-rounding-middle-ref.html
|
||||
fuzzy-if(OSX==1010,1,24) fuzzy-if(d2d,16,568) == boxshadow-large-border-radius.html boxshadow-large-border-radius-ref.html # Bug 1209649
|
||||
fuzzy-if(d2d,2,1080) == boxshadow-border-radius-int.html boxshadow-border-radius-int-ref.html
|
||||
fuzzy-if(OSX==1010,1,24) fuzzy-if(d2d,16,908) == boxshadow-large-border-radius.html boxshadow-large-border-radius-ref.html # Bug 1209649
|
||||
fuzzy(3,500) fuzzy-if(d2d,2,1080) == boxshadow-border-radius-int.html boxshadow-border-radius-int-ref.html
|
||||
== boxshadow-inset-neg-spread.html about:blank
|
||||
== boxshadow-inset-neg-spread2.html boxshadow-inset-neg-spread2-ref.html
|
||||
fuzzy(26,3610) == boxshadow-rotated.html boxshadow-rotated-ref.html # Bug 1211264
|
||||
fuzzy(26,3610) fuzzy-if(d2d,26,5910) == boxshadow-rotated.html boxshadow-rotated-ref.html # Bug 1211264
|
||||
== boxshadow-inset-large-border-radius.html boxshadow-inset-large-border-radius-ref.html
|
||||
|
||||
# fuzzy due to blur going inside, but as long as it's essentially black instead of a light gray its ok.
|
||||
fuzzy(12,9445) == boxshadow-inset-large-offset.html boxshadow-inset-large-offset-ref.html
|
||||
fuzzy(12,9445) fuzzy-if(d2d,13,10926) == boxshadow-inset-large-offset.html boxshadow-inset-large-offset-ref.html
|
||||
|
||||
== overflow-not-scrollable-1.html overflow-not-scrollable-1-ref.html
|
||||
== overflow-not-scrollable-1.html overflow-not-scrollable-1-ref2.html
|
||||
|
|
|
|||
|
|
@ -1818,7 +1818,7 @@ HTTP(..) == 983985-2.html 983985-2-ref.html
|
|||
== 985303-1a.html 985303-1-ref.html
|
||||
== 985303-1b.html 985303-1-ref.html
|
||||
== 987680-1.html 987680-1-ref.html
|
||||
fuzzy-if(d2d,1,36) == 991046-1.html 991046-1-ref.html
|
||||
fuzzy-if(d2d,1,601) == 991046-1.html 991046-1-ref.html
|
||||
pref(layout.css.overflow-clip-box.enabled,true) fuzzy-if(skiaContent,2,845) == 992447.html 992447-ref.html
|
||||
== 1003425-1.html 1003425-1-ref.html
|
||||
== 1003425-2.html 1003425-2-ref.html
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
== outline-and-box-shadow.html outline-and-box-shadow-ref.html
|
||||
fuzzy(2,18) == outline-and-box-shadow.html outline-and-box-shadow-ref.html
|
||||
== outline-and-3d-transform-1a.html outline-and-3d-transform-1-ref.html
|
||||
== outline-and-3d-transform-1b.html outline-and-3d-transform-1-ref.html
|
||||
fuzzy-if(gtkWidget,136,120) fuzzy-if(d2d,16,96) fuzzy-if(cocoaWidget,255,120) fuzzy-if(winWidget,255,216) == outline-and-3d-transform-2.html outline-and-3d-transform-2-ref.html
|
||||
|
|
|
|||
|
|
@ -91,6 +91,7 @@ if CONFIG['LIBJPEG_TURBO_ASFLAGS']:
|
|||
'simd/arm/jidctred-neon.c',
|
||||
'simd/arm/jquanti-neon.c',
|
||||
]
|
||||
CFLAGS += ['-mfpu=neon']
|
||||
elif CONFIG['CPU_ARCH'] == 'aarch64':
|
||||
SOURCES += [
|
||||
'simd/jsimd_arm64.c',
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@
|
|||
'defines': [
|
||||
'LIBYUV_NEON',
|
||||
],
|
||||
'cflags!': [
|
||||
'cflags_mozilla!': [
|
||||
'-mfpu=vfp',
|
||||
'-mfpu=vfpv3',
|
||||
'-mfpu=vfpv3-d16',
|
||||
|
|
@ -73,14 +73,14 @@
|
|||
'conditions': [
|
||||
# Disable LTO in libyuv_neon target due to gcc 4.9 compiler bug.
|
||||
['clang == 0 and use_lto == 1', {
|
||||
'cflags!': [
|
||||
'cflags_mozilla!': [
|
||||
'-flto',
|
||||
'-ffat-lto-objects',
|
||||
],
|
||||
}],
|
||||
# arm64 does not need -mfpu=neon option as neon is not optional
|
||||
['target_arch != "arm64"', {
|
||||
'cflags': [
|
||||
'cflags_mozilla': [
|
||||
'-mfpu=neon',
|
||||
# '-marm', # arm32 not thumb
|
||||
],
|
||||
|
|
|
|||
|
|
@ -20,10 +20,26 @@ libyuv_non_unified_sources = [
|
|||
'source/scale_common.cc',
|
||||
'source/scale_uv.cc',
|
||||
]
|
||||
|
||||
if CONFIG['CPU_ARCH'] == 'arm':
|
||||
libyuv_non_unified_sources += [
|
||||
'source/compare_neon.cc',
|
||||
'source/rotate_neon.cc',
|
||||
'source/row_neon.cc',
|
||||
'source/scale_neon.cc',
|
||||
]
|
||||
if CONFIG['CPU_ARCH'] == 'aarch64':
|
||||
libyuv_non_unified_sources += [
|
||||
'source/compare_neon64.cc',
|
||||
'source/rotate_neon64.cc',
|
||||
'source/row_neon64.cc',
|
||||
'source/scale_neon64.cc',
|
||||
]
|
||||
|
||||
GYP_DIRS['.'].input = 'libyuv.gyp'
|
||||
GYP_DIRS['.'].variables = gyp_vars
|
||||
GYP_DIRS['.'].sandbox_vars['FINAL_LIBRARY'] = 'xul'
|
||||
GYP_DIRS['.'].non_unified_sources += libyuv_non_unified_sources
|
||||
GYP_DIRS['.'].non_unified_sources += sorted(libyuv_non_unified_sources)
|
||||
|
||||
# We allow warnings for third-party code that can be updated from upstream.
|
||||
GYP_DIRS['.'].sandbox_vars['ALLOW_COMPILER_WARNINGS'] = True
|
||||
|
|
|
|||
|
|
@ -2949,7 +2949,7 @@ if test -z "$MOZ_SYSTEM_LIBVPX"; then
|
|||
dnl These flags are a lie; they're just used to enable the requisite
|
||||
dnl opcodes; actual arch detection is done at runtime.
|
||||
VPX_ASFLAGS="-march=armv7-a -mfpu=neon"
|
||||
VPX_AS_CONVERSION='$(PERL) $(topsrcdir)/media/libvpx/build/make/ads2gas.pl'
|
||||
VPX_AS_CONVERSION='$(PERL) $(topsrcdir)/media/libvpx/libvpx/build/make/ads2gas.pl'
|
||||
VPX_ARM_ASM=1
|
||||
dnl Building with -mfpu=neon requires either the "softfp" or the
|
||||
dnl "hardfp" ABI. Depending on the compiler's default target, and the
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue