aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/core/SkBitmapProcShader.h2
-rw-r--r--src/core/SkLinearBitmapPipeline.cpp107
-rw-r--r--src/core/SkLinearBitmapPipeline.h44
-rw-r--r--src/core/SkLinearBitmapPipeline_core.h20
-rw-r--r--src/core/SkLinearBitmapPipeline_sample.h253
5 files changed, 287 insertions, 139 deletions
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 5f0b5eeffe..a4591c7355 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -56,7 +56,7 @@ private:
typedef SkShader INHERITED;
};
-enum {kSkBlitterContextSize = 3100};
+enum {kSkBlitterContextSize = 3200};
// Commonly used allocator. It currently is only used to allocate up to 3 objects. The total
// bytes requested is calculated using one of our large shaders, its context size plus the size of
diff --git a/src/core/SkLinearBitmapPipeline.cpp b/src/core/SkLinearBitmapPipeline.cpp
index cfad6ec364..088e829345 100644
--- a/src/core/SkLinearBitmapPipeline.cpp
+++ b/src/core/SkLinearBitmapPipeline.cpp
@@ -567,62 +567,70 @@ private:
using Blender = SkLinearBitmapPipeline::BlendProcessorInterface;
-template <SkColorType colorType, template <SkColorType, SkGammaType, typename> class Sampler>
-static void choose_specific_sampler(
- Blender* next,
- const SkPixmap& srcPixmap,
- SkLinearBitmapPipeline::SampleStage* sampleStage)
+template <SkColorType colorType>
+static SkLinearBitmapPipeline::PixelAccessorInterface* choose_specific_accessor(
+ const SkPixmap& srcPixmap, SkLinearBitmapPipeline::Accessor* accessor)
{
if (srcPixmap.info().gammaCloseToSRGB()) {
- using S = Sampler<colorType, kSRGB_SkGammaType, Blender>;
- sampleStage->initStage<S>(next, srcPixmap);
+ using PA = PixelAccessor<colorType, kSRGB_SkGammaType>;
+ accessor->init<PA>(srcPixmap);
+ return accessor->get();
} else {
- using S = Sampler<colorType, kLinear_SkGammaType, Blender>;
- sampleStage->initStage<S>(next, srcPixmap);
+ using PA = PixelAccessor<colorType, kLinear_SkGammaType>;
+ accessor->init<PA>(srcPixmap);
+ return accessor->get();
}
}
-template<template <SkColorType, SkGammaType, typename> class Sampler>
+template<template <typename, typename> class Sampler>
static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
Blender* next,
const SkPixmap& srcPixmap,
const SkColor A8TintColor,
- SkLinearBitmapPipeline::SampleStage* sampleStage)
+ SkLinearBitmapPipeline::SampleStage* sampleStage,
+ SkLinearBitmapPipeline::Accessor* accessor)
{
const SkImageInfo& imageInfo = srcPixmap.info();
+
+ SkLinearBitmapPipeline::PixelAccessorInterface* pixelAccessor = nullptr;
switch (imageInfo.colorType()) {
case kAlpha_8_SkColorType: {
- using S = Sampler<kAlpha_8_SkColorType, kLinear_SkGammaType, Blender>;
- sampleStage->initStage<S>(next, srcPixmap, A8TintColor);
+ using PA = PixelAccessor<kAlpha_8_SkColorType, kLinear_SkGammaType>;
+ accessor->init<PA>(srcPixmap, A8TintColor);
+ pixelAccessor = accessor->get();
}
break;
case kARGB_4444_SkColorType:
- choose_specific_sampler<kARGB_4444_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kARGB_4444_SkColorType>(srcPixmap, accessor);
break;
case kRGB_565_SkColorType:
- choose_specific_sampler<kRGB_565_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kRGB_565_SkColorType>(srcPixmap, accessor);
break;
case kRGBA_8888_SkColorType:
- choose_specific_sampler<kRGBA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kRGBA_8888_SkColorType>(srcPixmap, accessor);
break;
case kBGRA_8888_SkColorType:
- choose_specific_sampler<kBGRA_8888_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kBGRA_8888_SkColorType>(srcPixmap, accessor);
break;
case kIndex_8_SkColorType:
- choose_specific_sampler<kIndex_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kIndex_8_SkColorType>(srcPixmap, accessor);
break;
case kGray_8_SkColorType:
- choose_specific_sampler<kGray_8_SkColorType, Sampler>(next, srcPixmap, sampleStage);
+ pixelAccessor = choose_specific_accessor<kGray_8_SkColorType>(srcPixmap, accessor);
break;
case kRGBA_F16_SkColorType: {
- using S = Sampler<kRGBA_F16_SkColorType, kLinear_SkGammaType, Blender>;
- sampleStage->initStage<S>(next, srcPixmap);
+ using PA = PixelAccessor<kRGBA_F16_SkColorType, kLinear_SkGammaType>;
+ accessor->init<PA>(srcPixmap);
+ pixelAccessor = accessor->get();
}
break;
default:
SkFAIL("Not implemented. Unsupported src");
break;
}
+
+ using S = Sampler<PixelAccessorShim, Blender>;
+ sampleStage->initStage<S>(next, pixelAccessor);
return sampleStage->get();
}
@@ -631,13 +639,60 @@ SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler(
SkFilterQuality filterQuality,
const SkPixmap& srcPixmap,
const SkColor A8TintColor,
- SkLinearBitmapPipeline::SampleStage* sampleStage)
-{
+ SkLinearBitmapPipeline::SampleStage* sampleStage,
+ SkLinearBitmapPipeline::Accessor* accessor) {
+ const SkImageInfo& imageInfo = srcPixmap.info();
+
+ // Special case samplers with fully expanded templates
+ if (imageInfo.gammaCloseToSRGB()) {
+ if (filterQuality == kNone_SkFilterQuality) {
+ switch (imageInfo.colorType()) {
+ case kN32_SkColorType: {
+ using S =
+ NearestNeighborSampler<
+ PixelAccessor<kN32_SkColorType, kSRGB_SkGammaType>, Blender>;
+ sampleStage->initStage<S>(next, srcPixmap);
+ return sampleStage->get();
+ }
+ case kIndex_8_SkColorType: {
+ using S =
+ NearestNeighborSampler<
+ PixelAccessor<kIndex_8_SkColorType, kSRGB_SkGammaType>, Blender>;
+ sampleStage->initStage<S>(next, srcPixmap);
+ return sampleStage->get();
+ }
+ default:
+ break;
+ }
+ } else {
+ switch (imageInfo.colorType()) {
+ case kN32_SkColorType: {
+ using S =
+ BilerpSampler<
+ PixelAccessor<kN32_SkColorType, kSRGB_SkGammaType>, Blender>;
+ sampleStage->initStage<S>(next, srcPixmap);
+ return sampleStage->get();
+ }
+ case kIndex_8_SkColorType: {
+ using S =
+ BilerpSampler<
+ PixelAccessor<kIndex_8_SkColorType, kSRGB_SkGammaType>, Blender>;
+ sampleStage->initStage<S>(next, srcPixmap);
+ return sampleStage->get();
+ }
+ default:
+ break;
+ }
+ }
+ }
+
+ // General cases.
if (filterQuality == kNone_SkFilterQuality) {
return choose_pixel_sampler_base<NearestNeighborSampler>(
- next, srcPixmap, A8TintColor, sampleStage);
+ next, srcPixmap, A8TintColor, sampleStage, accessor);
} else {
- return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, A8TintColor, sampleStage);
+ return choose_pixel_sampler_base<BilerpSampler>(
+ next, srcPixmap, A8TintColor, sampleStage, accessor);
}
}
@@ -742,7 +797,7 @@ SkLinearBitmapPipeline::SkLinearBitmapPipeline(
// identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
auto blenderStage = choose_blender_for_shading(alphaType, postAlpha, &fBlenderStage);
auto samplerStage = choose_pixel_sampler(
- blenderStage, filterQuality, srcPixmap, paintColor, &fSampleStage);
+ blenderStage, filterQuality, srcPixmap, paintColor, &fSampleStage, &fAccessor);
auto tilerStage = choose_tiler(samplerStage, dimensions, xTile, yTile,
filterQuality, dx, &fTileStage);
fFirstStage = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
diff --git a/src/core/SkLinearBitmapPipeline.h b/src/core/SkLinearBitmapPipeline.h
index 452ab8ef4e..b0f7e9dd20 100644
--- a/src/core/SkLinearBitmapPipeline.h
+++ b/src/core/SkLinearBitmapPipeline.h
@@ -91,16 +91,51 @@ public:
mutable Space fSpace;
};
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// PolyMemory
+ template <typename Base, size_t kSize>
+ class PolyMemory {
+ public:
+ PolyMemory() : fIsInitialized{false} { }
+ ~PolyMemory() {
+ if (fIsInitialized) {
+ this->get()->~Base();
+ }
+ }
+ template<typename Variant, typename... Args>
+ void init(Args&& ... args) {
+ SkASSERTF(sizeof(Variant) <= sizeof(fSpace),
+ "Size Variant: %d, Space: %d", sizeof(Variant), sizeof(fSpace));
+
+ new (&fSpace) Variant(std::forward<Args>(args)...);
+ fIsInitialized = true;
+ }
+
+ Base* get() const { return reinterpret_cast<Base*>(&fSpace); }
+ Base* operator->() const { return this->get(); }
+ Base& operator*() const { return *(this->get()); }
+
+ private:
+ struct SK_STRUCT_ALIGN(16) Space {
+ char space[kSize];
+ };
+ mutable Space fSpace;
+ bool fIsInitialized;
+
+ };
+
class PointProcessorInterface;
class SampleProcessorInterface;
class BlendProcessorInterface;
class DestinationInterface;
+ class PixelAccessorInterface;
// These values were generated by the assert above in Stage::init{Sink|Stage}.
- using MatrixStage = Stage<PointProcessorInterface, 160, PointProcessorInterface>;
- using TileStage = Stage<PointProcessorInterface, 160, SampleProcessorInterface>;
- using SampleStage = Stage<SampleProcessorInterface, 100, BlendProcessorInterface>;
- using BlenderStage = Stage<BlendProcessorInterface, 40>;
+ using MatrixStage = Stage<PointProcessorInterface, 160, PointProcessorInterface>;
+ using TileStage = Stage<PointProcessorInterface, 160, SampleProcessorInterface>;
+ using SampleStage = Stage<SampleProcessorInterface, 100, BlendProcessorInterface>;
+ using BlenderStage = Stage<BlendProcessorInterface, 40>;
+ using Accessor = PolyMemory<PixelAccessorInterface, 48>;
private:
PointProcessorInterface* fFirstStage;
@@ -109,6 +144,7 @@ private:
SampleStage fSampleStage;
BlenderStage fBlenderStage;
DestinationInterface* fLastStage;
+ Accessor fAccessor;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkLinearBitmapPipeline_core.h b/src/core/SkLinearBitmapPipeline_core.h
index 21fa48793d..2c39a38320 100644
--- a/src/core/SkLinearBitmapPipeline_core.h
+++ b/src/core/SkLinearBitmapPipeline_core.h
@@ -8,6 +8,7 @@
#ifndef SkLinearBitmapPipeline_core_DEFINED
#define SkLinearBitmapPipeline_core_DEFINED
+#include <algorithm>
#include <cmath>
#include "SkNx.h"
@@ -238,4 +239,23 @@ public:
virtual void SK_VECTORCALL blend4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
};
+class SkLinearBitmapPipeline::PixelAccessorInterface {
+public:
+ virtual ~PixelAccessorInterface() { }
+ virtual void SK_VECTORCALL getFewPixels(
+ int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) const = 0;
+
+ virtual void SK_VECTORCALL get4Pixels(
+ Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const = 0;
+
+ virtual void get4Pixels(
+ const void* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const = 0;
+
+ virtual Sk4f getPixelFromRow(const void* row, int index) const = 0;
+
+ virtual Sk4f getPixelAt(int index) const = 0;
+
+ virtual const void* row(int y) const = 0;
+};
+
#endif // SkLinearBitmapPipeline_core_DEFINED
diff --git a/src/core/SkLinearBitmapPipeline_sample.h b/src/core/SkLinearBitmapPipeline_sample.h
index 5d1f26fc8f..39400f6750 100644
--- a/src/core/SkLinearBitmapPipeline_sample.h
+++ b/src/core/SkLinearBitmapPipeline_sample.h
@@ -53,23 +53,23 @@ static Sk4s SK_VECTORCALL bilerp4(Sk4s xs, Sk4s ys, Sk4f px00, Sk4f px10,
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-// PixelGetter is the lowest level interface to the source data. There is a PixelGetter for each
+// PixelGetter is the lowest level interface to the source data. There is a PixelConverter for each
// of the different SkColorTypes.
-template <SkColorType, SkGammaType> class PixelGetter;
+template <SkColorType, SkGammaType> class PixelConverter;
// Alpha handling:
// The alpha from the paint (tintColor) is used in the blend part of the pipeline to modulate
// the entire bitmap. So, the tint color is given an alpha of 1.0 so that the later alpha can
// modulate this color later.
template <>
-class PixelGetter<kAlpha_8_SkColorType, kLinear_SkGammaType> {
+class PixelConverter<kAlpha_8_SkColorType, kLinear_SkGammaType> {
public:
using Element = uint8_t;
- PixelGetter(const SkPixmap& srcPixmap, SkColor tintColor)
+ PixelConverter(const SkPixmap& srcPixmap, SkColor tintColor)
: fTintColor{set_alpha(Sk4f_from_SkColor(tintColor), 1.0f)} { }
- Sk4f getPixelAt(const uint8_t* src) {
- return fTintColor * (*src * (1.0f/255.0f));
+ Sk4f toSk4f(const Element pixel) const {
+ return fTintColor * (pixel * (1.0f/255.0f));
}
private:
@@ -77,65 +77,63 @@ private:
};
template <SkGammaType gammaType>
-class PixelGetter<kRGB_565_SkColorType, gammaType> {
+class PixelConverter<kRGB_565_SkColorType, gammaType> {
public:
using Element = uint16_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
- Sk4f getPixelAt(const uint16_t* src) {
- SkPMColor pixel = SkPixel16ToPixel32(*src);
+ Sk4f toSk4f(Element pixel) const {
+ SkPMColor pixel32 = SkPixel16ToPixel32(pixel);
return gammaType == kSRGB_SkGammaType
- ? Sk4f_fromS32(pixel)
- : Sk4f_fromL32(pixel);
+ ? Sk4f_fromS32(pixel32)
+ : Sk4f_fromL32(pixel32);
}
};
template <SkGammaType gammaType>
-class PixelGetter<kARGB_4444_SkColorType, gammaType> {
+class PixelConverter<kARGB_4444_SkColorType, gammaType> {
public:
using Element = uint16_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
- Sk4f getPixelAt(const uint16_t* src) {
- SkPMColor pixel = SkPixel4444ToPixel32(*src);
+ Sk4f toSk4f(Element pixel) const {
+ SkPMColor pixel32 = SkPixel4444ToPixel32(pixel);
return gammaType == kSRGB_SkGammaType
- ? Sk4f_fromS32(pixel)
- : Sk4f_fromL32(pixel);
+ ? Sk4f_fromS32(pixel32)
+ : Sk4f_fromL32(pixel32);
}
};
template <SkGammaType gammaType>
-class PixelGetter<kRGBA_8888_SkColorType, gammaType> {
+class PixelConverter<kRGBA_8888_SkColorType, gammaType> {
public:
using Element = uint32_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
- Sk4f getPixelAt(const uint32_t* src) {
+ Sk4f toSk4f(Element pixel) const {
return gammaType == kSRGB_SkGammaType
- ? Sk4f_fromS32(*src)
- : Sk4f_fromL32(*src);
+ ? Sk4f_fromS32(pixel)
+ : Sk4f_fromL32(pixel);
}
};
template <SkGammaType gammaType>
-class PixelGetter<kBGRA_8888_SkColorType, gammaType> {
+class PixelConverter<kBGRA_8888_SkColorType, gammaType> {
public:
using Element = uint32_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
- Sk4f getPixelAt(const uint32_t* src) {
- Sk4f pixel = gammaType == kSRGB_SkGammaType
- ? Sk4f_fromS32(*src)
- : Sk4f_fromL32(*src);
- return swizzle_rb(pixel);
+ Sk4f toSk4f(Element pixel) const {
+ return swizzle_rb(
+ gammaType == kSRGB_SkGammaType ? Sk4f_fromS32(pixel) : Sk4f_fromL32(pixel));
}
};
template <SkGammaType gammaType>
-class PixelGetter<kIndex_8_SkColorType, gammaType> {
+class PixelConverter<kIndex_8_SkColorType, gammaType> {
public:
using Element = uint8_t;
- PixelGetter(const SkPixmap& srcPixmap) {
+ PixelConverter(const SkPixmap& srcPixmap) {
SkColorTable* skColorTable = srcPixmap.ctable();
SkASSERT(skColorTable != nullptr);
@@ -145,7 +143,7 @@ public:
}
}
- PixelGetter(const PixelGetter& strategy) {
+ PixelConverter(const PixelConverter& strategy) {
fColorTable = (Sk4f*)SkAlign16((intptr_t)fColorTableStorage.get());
// TODO: figure out the count.
for (int i = 0; i < 256; i++) {
@@ -153,8 +151,8 @@ public:
}
}
- Sk4f getPixelAt(const uint8_t* src) {
- return fColorTable[*src];
+ Sk4f toSk4f(Element index) const {
+ return fColorTable[index];
}
private:
@@ -179,44 +177,81 @@ private:
};
template <SkGammaType gammaType>
-class PixelGetter<kGray_8_SkColorType, gammaType> {
+class PixelConverter<kGray_8_SkColorType, gammaType> {
public:
using Element = uint8_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
- Sk4f getPixelAt(const uint8_t* src) {
- float gray = *src * (1.0f/255.0f);
- Sk4f pixel = Sk4f{gray, gray, gray, 1.0f};
+ Sk4f toSk4f(Element pixel) const {
+ float gray = pixel * (1.0f/255.0f);
+ Sk4f result = Sk4f{gray, gray, gray, 1.0f};
return gammaType == kSRGB_SkGammaType
- ? srgb_to_linear(pixel)
- : pixel;
+ ? srgb_to_linear(result)
+ : result;
}
};
template <>
-class PixelGetter<kRGBA_F16_SkColorType, kLinear_SkGammaType> {
+class PixelConverter<kRGBA_F16_SkColorType, kLinear_SkGammaType> {
public:
using Element = uint64_t;
- PixelGetter(const SkPixmap& srcPixmap) { }
+ PixelConverter(const SkPixmap& srcPixmap) { }
+
+ Sk4f toSk4f(const Element pixel) const {
+ return SkHalfToFloat_01(pixel);
+ }
+};
+
+class PixelAccessorShim {
+public:
+ explicit PixelAccessorShim(SkLinearBitmapPipeline::PixelAccessorInterface* accessor)
+ : fPixelAccessor(accessor) { }
- Sk4f getPixelAt(const uint64_t* src) {
- return SkHalfToFloat_01(*src);
+ void SK_VECTORCALL getFewPixels(
+ int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) const {
+ fPixelAccessor->getFewPixels(n, xs, ys, px0, px1, px2);
}
+
+ void SK_VECTORCALL get4Pixels(
+ Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const {
+ fPixelAccessor->get4Pixels(xs, ys, px0, px1, px2, px3);
+ }
+
+ void get4Pixels(
+ const void* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const {
+ fPixelAccessor->get4Pixels(src, index, px0, px1, px2, px3);
+ };
+
+ Sk4f getPixelFromRow(const void* row, int index) const {
+ return fPixelAccessor->getPixelFromRow(row, index);
+ }
+
+ Sk4f getPixelAt(int index) const {
+ return fPixelAccessor->getPixelAt(index);
+ }
+
+ const void* row(int y) const {
+ return fPixelAccessor->row(y);
+ }
+
+private:
+ SkLinearBitmapPipeline::PixelAccessorInterface* const fPixelAccessor;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
// PixelAccessor handles all the same plumbing for all the PixelGetters.
template <SkColorType colorType, SkGammaType gammaType>
-class PixelAccessor {
- using Element = typename PixelGetter<colorType, gammaType>::Element;
+class PixelAccessor final : public SkLinearBitmapPipeline::PixelAccessorInterface {
+ using Element = typename PixelConverter<colorType, gammaType>::Element;
public:
template <typename... Args>
PixelAccessor(const SkPixmap& srcPixmap, Args&&... args)
: fSrc{static_cast<const Element*>(srcPixmap.addr())}
, fWidth{srcPixmap.rowBytesAsPixels()}
- , fGetter{srcPixmap, std::move<Args>(args)...} { }
+ , fConverter{srcPixmap, std::move<Args>(args)...} { }
- void SK_VECTORCALL getFewPixels(int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
+ void SK_VECTORCALL getFewPixels (
+ int n, Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) const override {
Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
Sk4i bufferLoc = YIs * fWidth + XIs;
@@ -232,7 +267,8 @@ public:
}
}
- void SK_VECTORCALL get4Pixels(Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
+ void SK_VECTORCALL get4Pixels(
+ Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const override {
Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
Sk4i bufferLoc = YIs * fWidth + XIs;
@@ -242,28 +278,29 @@ public:
*px3 = this->getPixelAt(bufferLoc[3]);
}
- void get4Pixels(const void* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
+ void get4Pixels(
+ const void* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) const override {
*px0 = this->getPixelFromRow(src, index + 0);
*px1 = this->getPixelFromRow(src, index + 1);
*px2 = this->getPixelFromRow(src, index + 2);
*px3 = this->getPixelFromRow(src, index + 3);
}
- Sk4f getPixelFromRow(const void* row, int index) {
+ Sk4f getPixelFromRow(const void* row, int index) const override {
const Element* src = static_cast<const Element*>(row);
- return fGetter.getPixelAt(src + index);
+ return fConverter.toSk4f(src[index]);
}
- Sk4f getPixelAt(int index) {
+ Sk4f getPixelAt(int index) const override {
return this->getPixelFromRow(fSrc, index);
}
- const void* row(int y) const { return fSrc + y * fWidth[0]; }
+ const void* row(int y) const override { return fSrc + y * fWidth; }
private:
const Element* const fSrc;
- const Sk4i fWidth;
- PixelGetter<colorType, gammaType> fGetter;
+ const int fWidth;
+ PixelConverter<colorType, gammaType> fConverter;
};
// We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
@@ -308,21 +345,21 @@ static void src_strategy_blend(Span span, Next* next, Strategy* strategy) {
}
// NearestNeighborSampler - use nearest neighbor filtering to create runs of destination pixels.
-template<SkColorType colorType, SkGammaType gammaType, typename Next>
+template<typename Accessor, typename Next>
class NearestNeighborSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
public:
template<typename... Args>
NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
- : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
+ : fNext{next}, fAccessor{std::forward<Args>(args)...} { }
NearestNeighborSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
const NearestNeighborSampler& sampler)
- : fNext{next}, fStrategy{sampler.fStrategy} { }
+ : fNext{next}, fAccessor{sampler.fAccessor} { }
void SK_VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
SkASSERT(0 < n && n < 4);
Sk4f px0, px1, px2;
- fStrategy.getFewPixels(n, xs, ys, &px0, &px1, &px2);
+ fAccessor.getFewPixels(n, xs, ys, &px0, &px1, &px2);
if (n >= 1) fNext->blendPixel(px0);
if (n >= 2) fNext->blendPixel(px1);
if (n >= 3) fNext->blendPixel(px2);
@@ -330,7 +367,7 @@ public:
void SK_VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
Sk4f px0, px1, px2, px3;
- fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
+ fAccessor.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
fNext->blend4Pixels(px0, px1, px2, px3);
}
@@ -344,7 +381,7 @@ public:
if (absLength < (count - 1)) {
this->spanSlowRate(span);
} else if (absLength == (count - 1)) {
- src_strategy_blend(span, fNext, &fStrategy);
+ src_strategy_blend(span, fNext, &fAccessor);
} else {
this->spanFastRate(span);
}
@@ -378,19 +415,19 @@ private:
SkScalar dx = length / (count - 1);
SkFixed fdx = SkScalarToFixed(dx);
- const void* row = fStrategy.row((int)std::floor(Y(start)));
+ const void* row = fAccessor.row((int)std::floor(Y(start)));
Next* next = fNext;
int ix = SkFixedFloorToInt(fx);
int prevIX = ix;
- Sk4f fpixel = fStrategy.getPixelFromRow(row, ix);
+ Sk4f fpixel = fAccessor.getPixelFromRow(row, ix);
// When dx is less than one, each pixel is used more than once. Using the fixed point fx
// allows the code to quickly check that the same pixel is being used. The code uses this
// same pixel check to do the sRGB and normalization only once.
auto getNextPixel = [&]() {
if (ix != prevIX) {
- fpixel = fStrategy.getPixelFromRow(row, ix);
+ fpixel = fAccessor.getPixelFromRow(row, ix);
prevIX = ix;
}
fx += fdx;
@@ -415,7 +452,7 @@ private:
// We're moving through source space at a rate of 1 source pixel per 1 dst pixel.
// We'll never re-use pixels, but we can at least load contiguous pixels.
void spanUnitRate(Span span) {
- src_strategy_blend(span, fNext, &fStrategy);
+ src_strategy_blend(span, fNext, &fAccessor);
}
// We're moving through source space faster than dst (zoomed out),
@@ -424,22 +461,22 @@ private:
span_fallback(span, this);
}
- Next* const fNext;
- PixelAccessor<colorType, gammaType> fStrategy;
+ Next* const fNext;
+ Accessor fAccessor;
};
// -- BilerpSampler --------------------------------------------------------------------------------
// BilerpSampler - use a bilerp filter to create runs of destination pixels.
-template<SkColorType colorType, SkGammaType gammaType, typename Next>
+template<typename Accessor, typename Next>
class BilerpSampler : public SkLinearBitmapPipeline::SampleProcessorInterface {
public:
template<typename... Args>
BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next, Args&& ... args)
- : fNext{next}, fStrategy{std::forward<Args>(args)...} { }
+ : fNext{next}, fAccessor{std::forward<Args>(args)...} { }
BilerpSampler(SkLinearBitmapPipeline::BlendProcessorInterface* next,
const BilerpSampler& sampler)
- : fNext{next}, fStrategy{sampler.fStrategy} { }
+ : fNext{next}, fAccessor{sampler.fAccessor} { }
Sk4f bilerpNonEdgePixel(SkScalar x, SkScalar y) {
Sk4f px00, px10, px01, px11;
@@ -449,7 +486,7 @@ public:
Sk4f ys = Sk4f{y} - 0.5f;
Sk4f sampleXs = xs + Sk4f{0.0f, 1.0f, 0.0f, 1.0f};
Sk4f sampleYs = ys + Sk4f{0.0f, 0.0f, 1.0f, 1.0f};
- fStrategy.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
+ fAccessor.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
return bilerp4(xs, ys, px00, px10, px01, px11);
}
@@ -486,7 +523,7 @@ public:
Sk4f px00, px10, px01, px11;
Sk4f xs = Sk4f{sampleXs[0]};
Sk4f ys = Sk4f{sampleYs[0]};
- fStrategy.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
+ fAccessor.get4Pixels(sampleXs, sampleYs, &px00, &px10, &px01, &px11);
Sk4f pixel = bilerp4(xs, ys, px00, px10, px01, px11);
fNext->blendPixel(pixel);
}
@@ -505,7 +542,7 @@ public:
} else if (absLength == (count - 1)) {
if (std::fmod(span.startX() - 0.5f, 1.0f) == 0.0f) {
if (std::fmod(span.startY() - 0.5f, 1.0f) == 0.0f) {
- src_strategy_blend(span, fNext, &fStrategy);
+ src_strategy_blend(span, fNext, &fAccessor);
} else {
this->spanUnitRateAlignedX(span, y);
}
@@ -526,8 +563,8 @@ private:
SkScalar filterY0 = 1.0f - filterY1;
int iy1 = SkScalarFloorToInt(y1);
int ix = SkScalarFloorToInt(span.startX());
- Sk4f pixelY0 = fStrategy.getPixelFromRow(fStrategy.row(iy0), ix);
- Sk4f pixelY1 = fStrategy.getPixelFromRow(fStrategy.row(iy1), ix);
+ Sk4f pixelY0 = fAccessor.getPixelFromRow(fAccessor.row(iy0), ix);
+ Sk4f pixelY1 = fAccessor.getPixelFromRow(fAccessor.row(iy1), ix);
Sk4f filterPixel = pixelY0 * filterY0 + pixelY1 * filterY1;
int count = span.count();
while (count >= 4) {
@@ -566,18 +603,18 @@ private:
SkScalar yFloor = std::floor(ry0);
Sk4f y1 = Sk4f{ry0 - yFloor};
Sk4f y0 = Sk4f{1.0f} - y1;
- const void* const row0 = fStrategy.row(SkScalarFloorToInt(ry0));
- const void* const row1 = fStrategy.row(SkScalarFloorToInt(ry1));
- Sk4f fpixel00 = y0 * fStrategy.getPixelFromRow(row0, ix);
- Sk4f fpixel01 = y1 * fStrategy.getPixelFromRow(row1, ix);
- Sk4f fpixel10 = y0 * fStrategy.getPixelFromRow(row0, ix + 1);
- Sk4f fpixel11 = y1 * fStrategy.getPixelFromRow(row1, ix + 1);
+ const void* const row0 = fAccessor.row(SkScalarFloorToInt(ry0));
+ const void* const row1 = fAccessor.row(SkScalarFloorToInt(ry1));
+ Sk4f fpixel00 = y0 * fAccessor.getPixelFromRow(row0, ix);
+ Sk4f fpixel01 = y1 * fAccessor.getPixelFromRow(row1, ix);
+ Sk4f fpixel10 = y0 * fAccessor.getPixelFromRow(row0, ix + 1);
+ Sk4f fpixel11 = y1 * fAccessor.getPixelFromRow(row1, ix + 1);
auto getNextPixel = [&]() {
if (ix != ioldx) {
fpixel00 = fpixel10;
fpixel01 = fpixel11;
- fpixel10 = y0 * fStrategy.getPixelFromRow(row0, ix + 1);
- fpixel11 = y1 * fStrategy.getPixelFromRow(row1, ix + 1);
+ fpixel10 = y0 * fAccessor.getPixelFromRow(row0, ix + 1);
+ fpixel11 = y1 * fAccessor.getPixelFromRow(row1, ix + 1);
ioldx = ix;
x = x + xAdjust;
}
@@ -618,25 +655,25 @@ private:
SkScalar filterY1 = y0 - iy0;
SkScalar filterY0 = 1.0f - filterY1;
int iy1 = SkScalarFloorToInt(y1);
- const void* rowY0 = fStrategy.row(iy0);
- const void* rowY1 = fStrategy.row(iy1);
+ const void* rowY0 = fAccessor.row(iy0);
+ const void* rowY1 = fAccessor.row(iy1);
SkScalar x0 = span.startX() - 0.5f;
int ix0 = SkScalarFloorToInt(x0);
SkScalar filterX1 = x0 - ix0;
SkScalar filterX0 = 1.0f - filterX1;
auto getPixelY0 = [&]() {
- Sk4f px = fStrategy.getPixelFromRow(rowY0, ix0);
+ Sk4f px = fAccessor.getPixelFromRow(rowY0, ix0);
return px * filterY0;
};
auto getPixelY1 = [&]() {
- Sk4f px = fStrategy.getPixelFromRow(rowY1, ix0);
+ Sk4f px = fAccessor.getPixelFromRow(rowY1, ix0);
return px * filterY1;
};
auto get4PixelsY0 = [&](int ix, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
- fStrategy.get4Pixels(rowY0, ix, px0, px1, px2, px3);
+ fAccessor.get4Pixels(rowY0, ix, px0, px1, px2, px3);
*px0 = *px0 * filterY0;
*px1 = *px1 * filterY0;
*px2 = *px2 * filterY0;
@@ -644,7 +681,7 @@ private:
};
auto get4PixelsY1 = [&](int ix, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
- fStrategy.get4Pixels(rowY1, ix, px0, px1, px2, px3);
+ fAccessor.get4Pixels(rowY1, ix, px0, px1, px2, px3);
*px0 = *px0 * filterY1;
*px1 = *px1 * filterY1;
*px2 = *px2 * filterY1;
@@ -678,8 +715,8 @@ private:
count -= 4;
}
while (count > 0) {
- Sk4f pixelY0 = fStrategy.getPixelFromRow(rowY0, ix0);
- Sk4f pixelY1 = fStrategy.getPixelFromRow(rowY1, ix0);
+ Sk4f pixelY0 = fAccessor.getPixelFromRow(rowY0, ix0);
+ Sk4f pixelY1 = fAccessor.getPixelFromRow(rowY1, ix0);
fNext->blendPixel(lerp(pixelY0, pixelY1));
ix0 += 1;
@@ -706,8 +743,8 @@ private:
count -= 4;
}
while (count > 0) {
- Sk4f pixelY0 = fStrategy.getPixelFromRow(rowY0, ix0);
- Sk4f pixelY1 = fStrategy.getPixelFromRow(rowY1, ix0);
+ Sk4f pixelY0 = fAccessor.getPixelFromRow(rowY0, ix0);
+ Sk4f pixelY1 = fAccessor.getPixelFromRow(rowY1, ix0);
fNext->blendPixel(lerp(pixelY0, pixelY1));
ix0 -= 1;
@@ -724,8 +761,8 @@ private:
SkScalar filterY0 = 1.0f - filterY1;
int iy1 = SkScalarFloorToInt(y1);
int ix = SkScalarFloorToInt(span.startX());
- const void* rowY0 = fStrategy.row(iy0);
- const void* rowY1 = fStrategy.row(iy1);
+ const void* rowY0 = fAccessor.row(iy0);
+ const void* rowY1 = fAccessor.row(iy1);
auto lerp = [&](Sk4f* pixelY0, Sk4f* pixelY1) {
return *pixelY0 * filterY0 + *pixelY1 * filterY1;
};
@@ -734,17 +771,17 @@ private:
int count = span.count();
while (count >= 4) {
Sk4f px00, px10, px20, px30;
- fStrategy.get4Pixels(rowY0, ix, &px00, &px10, &px20, &px30);
+ fAccessor.get4Pixels(rowY0, ix, &px00, &px10, &px20, &px30);
Sk4f px01, px11, px21, px31;
- fStrategy.get4Pixels(rowY1, ix, &px01, &px11, &px21, &px31);
+ fAccessor.get4Pixels(rowY1, ix, &px01, &px11, &px21, &px31);
fNext->blend4Pixels(
lerp(&px00, &px01), lerp(&px10, &px11), lerp(&px20, &px21), lerp(&px30, &px31));
ix += 4;
count -= 4;
}
while (count > 0) {
- Sk4f pixelY0 = fStrategy.getPixelFromRow(rowY0, ix);
- Sk4f pixelY1 = fStrategy.getPixelFromRow(rowY1, ix);
+ Sk4f pixelY0 = fAccessor.getPixelFromRow(rowY0, ix);
+ Sk4f pixelY1 = fAccessor.getPixelFromRow(rowY1, ix);
fNext->blendPixel(lerp(&pixelY0, &pixelY1));
ix += 1;
@@ -754,17 +791,17 @@ private:
int count = span.count();
while (count >= 4) {
Sk4f px00, px10, px20, px30;
- fStrategy.get4Pixels(rowY0, ix - 3, &px30, &px20, &px10, &px00);
+ fAccessor.get4Pixels(rowY0, ix - 3, &px30, &px20, &px10, &px00);
Sk4f px01, px11, px21, px31;
- fStrategy.get4Pixels(rowY1, ix - 3, &px31, &px21, &px11, &px01);
+ fAccessor.get4Pixels(rowY1, ix - 3, &px31, &px21, &px11, &px01);
fNext->blend4Pixels(
lerp(&px00, &px01), lerp(&px10, &px11), lerp(&px20, &px21), lerp(&px30, &px31));
ix -= 4;
count -= 4;
}
while (count > 0) {
- Sk4f pixelY0 = fStrategy.getPixelFromRow(rowY0, ix);
- Sk4f pixelY1 = fStrategy.getPixelFromRow(rowY1, ix);
+ Sk4f pixelY0 = fAccessor.getPixelFromRow(rowY0, ix);
+ Sk4f pixelY1 = fAccessor.getPixelFromRow(rowY1, ix);
fNext->blendPixel(lerp(&pixelY0, &pixelY1));
ix -= 1;
@@ -801,8 +838,8 @@ private:
}
}
- Next* const fNext;
- PixelAccessor<colorType, gammaType> fStrategy;
+ Next* const fNext;
+ Accessor fAccessor;
};
} // namespace
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 22:38:26 +0000