bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
const Options& options) override {
REPORTER_ASSERT(fReporter, pixels != nullptr);
REPORTER_ASSERT(fReporter, rowBytes >= info.minRowBytes());
if (fType != kSucceedGetPixels_TestType) {
return false;
}
if (info.colorType() != kN32_SkColorType && info.colorType() != getInfo().colorType()) {
return false;
}
char* bytePtr = static_cast<char*>(pixels);
switch (info.colorType()) {
case kN32_SkColorType:
for (int y = 0; y < info.height(); ++y) {
sk_memset32((uint32_t*)bytePtr,
TestImageGenerator::PMColor(), info.width());
bytePtr += rowBytes;
}
break;
case kRGB_565_SkColorType:
for (int y = 0; y < info.height(); ++y) {
sk_memset16((uint16_t*)bytePtr,
SkPixel32ToPixel16(TestImageGenerator::PMColor()), info.width());
bytePtr += rowBytes;
}
break;
default:
return false;
}
return true;
}
void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
fDstPtr = fDst.writable_addr(0,y);
if (fCanMemsetInBlitH) {
switch (fDst.shiftPerPixel()) {
case 0: memset ((uint8_t *)fDstPtr + x, fMemsetColor, w); return;
case 1: sk_memset16((uint16_t*)fDstPtr + x, fMemsetColor, w); return;
case 2: sk_memset32((uint32_t*)fDstPtr + x, fMemsetColor, w); return;
case 3: sk_memset64((uint64_t*)fDstPtr + x, fMemsetColor, w); return;
default: break;
}
}
if (!fBlitH) {
SkRasterPipeline p(fAlloc);
p.extend(fColorPipeline);
if (fBlend == SkBlendMode::kSrcOver
&& fDst.info().colorType() == kRGBA_8888_SkColorType
&& !fDst.colorSpace()
&& fDst.info().alphaType() != kUnpremul_SkAlphaType
&& fDitherRate == 0.0f) {
p.append(SkRasterPipeline::srcover_rgba_8888, &fDstPtr);
} else {
if (fBlend != SkBlendMode::kSrc) {
this->append_load_d(&p);
this->append_blend(&p);
this->maybe_clamp(&p);
}
this->append_store(&p);
}
fBlitH = p.compile();
}
this->maybe_shade(x,y,w);
fBlitH(x,y,w);
}
void SkRasterPipelineBlitter::blitH(int x, int y, int w) {
fDstPtr = fDst.writable_addr(0,y);
fCurrentY = y;
if (fCanMemsetInBlitH) {
switch (fDst.shiftPerPixel()) {
case 0: memset ((uint8_t *)fDstPtr + x, fMemsetColor, w); return;
case 1: sk_memset16((uint16_t*)fDstPtr + x, fMemsetColor, w); return;
case 2: sk_memset32((uint32_t*)fDstPtr + x, fMemsetColor, w); return;
case 3: sk_memset64((uint64_t*)fDstPtr + x, fMemsetColor, w); return;
default: break;
}
}
auto& p = fBlitH;
if (p.empty()) {
p.extend(fShader);
if (fBlend != SkBlendMode::kSrc) {
this->append_load_d(&p);
this->append_blend(&p);
this->maybe_clamp(&p);
}
this->append_store(&p);
}
p.run(x,w);
}
void SkAlphaRuns::reset(int width) {
SkASSERT(width > 0);
#ifdef SK_DEBUG
sk_memset16((uint16_t*)fRuns, (uint16_t)(-42), width);
#endif
fRuns[0] = SkToS16(width);
fRuns[width] = 0;
fAlpha[0] = 0;
SkDEBUGCODE(fWidth = width;)
void SkSampler::Fill(const SkImageInfo& info, void* dst, size_t rowBytes,
SkCodec::ZeroInitialized zeroInit) {
SkASSERT(dst != nullptr);
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
return;
}
const int width = info.width();
const int numRows = info.height();
// Use the proper memset routine to fill the remaining bytes
switch (info.colorType()) {
case kRGBA_8888_SkColorType:
case kBGRA_8888_SkColorType: {
uint32_t* dstRow = (uint32_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset32(dstRow, 0, width);
dstRow = SkTAddOffset<uint32_t>(dstRow, rowBytes);
}
break;
}
case kRGB_565_SkColorType: {
uint16_t* dstRow = (uint16_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset16(dstRow, 0, width);
dstRow = SkTAddOffset<uint16_t>(dstRow, rowBytes);
}
break;
}
case kGray_8_SkColorType: {
uint8_t* dstRow = (uint8_t*) dst;
for (int row = 0; row < numRows; row++) {
memset(dstRow, 0, width);
dstRow = SkTAddOffset<uint8_t>(dstRow, rowBytes);
}
break;
}
case kRGBA_F16_SkColorType: {
uint64_t* dstRow = (uint64_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset64(dstRow, 0, width);
dstRow = SkTAddOffset<uint64_t>(dstRow, rowBytes);
}
break;
}
default:
SkCodecPrintf("Error: Unsupported dst color type for fill(). Doing nothing.\n");
SkASSERT(false);
break;
}
}
static void test_16(skiatest::Reporter* reporter) {
uint16_t buffer[TOTAL];
for (int count = 0; count < MAX_COUNT; ++count) {
for (int alignment = 0; alignment < MAX_ALIGNMENT; ++alignment) {
set_zero(buffer, sizeof(buffer));
uint16_t* base = &buffer[PAD + alignment];
sk_memset16(base, VALUE16, count);
compare16(buffer, 0, PAD + alignment);
compare16(base, VALUE16, count);
compare16(base + count, 0, TOTAL - count - PAD - alignment);
}
}
}
void drawBG(SkCanvas* canvas)
{
canvas->drawColor(0xFFDDDDDD);
return;
#if 0
SkColorTable ct;
SkPMColor colors[] = { SK_ColorRED, SK_ColorBLUE };
ct.setColors(colors, 2);
ct.setFlags(ct.getFlags() | SkColorTable::kColorsAreOpaque_Flag);
SkBitmap bm;
bm.setConfig(SkBitmap::kIndex8_Config, 20, 20, 21);
bm.setColorTable(&ct);
bm.allocPixels();
sk_memset16((uint16_t*)bm.getAddr8(0, 0), 0x0001, bm.rowBytes() * bm.height() / 2);
#endif
#if 0
SkBitmap bm;
bm.setConfig(SkBitmap::kRGB_565_Config, 20, 20, 42);
bm.allocPixels();
sk_memset32((uint32_t*)bm.getAddr16(0, 0), 0x0000FFFF, bm.rowBytes() * bm.height() / 4);
#endif
#if 1
SkBitmap bm;
bm.setConfig(SkBitmap::kARGB_8888_Config, 20, 20);
bm.allocPixels();
sk_memset32((uint32_t*)bm.getAddr32(0, 0), 0xFFDDDDDD, bm.rowBytes() * bm.height() / 4);
#endif
SkPaint paint;
// SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kBilinear_FilterType, SkShader::kRepeat_TileMode);
SkPoint pts[] = { 0, 0, SkIntToScalar(100), SkIntToScalar(0) };
SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
SkShader* shader = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode);
paint.setShader(shader)->unref();
canvas->drawPaint(paint);
}
virtual void filterSpan16(const uint16_t shader[], int count,
uint16_t result[]) {
SkASSERT(this->getFlags() & kHasFilter16_Flag);
sk_memset16(result, SkPixel32ToPixel16(fPMColor), count);
}
bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
if (nullptr == fPixels) {
return false;
}
SkIRect area;
if (!area.intersect(this->bounds(), inArea)) {
return false;
}
U8CPU a = SkColorGetA(color);
U8CPU r = SkColorGetR(color);
U8CPU g = SkColorGetG(color);
U8CPU b = SkColorGetB(color);
int height = area.height();
const int width = area.width();
const int rowBytes = this->rowBytes();
switch (this->colorType()) {
case kGray_8_SkColorType: {
if (255 != a) {
r = SkMulDiv255Round(r, a);
g = SkMulDiv255Round(g, a);
b = SkMulDiv255Round(b, a);
}
int gray = SkComputeLuminance(r, g, b);
uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
while (--height >= 0) {
memset(p, gray, width);
p += rowBytes;
}
break;
}
case kAlpha_8_SkColorType: {
uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
while (--height >= 0) {
memset(p, a, width);
p += rowBytes;
}
break;
}
case kARGB_4444_SkColorType:
case kRGB_565_SkColorType: {
uint16_t* p = this->writable_addr16(area.fLeft, area.fTop);
uint16_t v;
// make rgb premultiplied
if (255 != a) {
r = SkMulDiv255Round(r, a);
g = SkMulDiv255Round(g, a);
b = SkMulDiv255Round(b, a);
}
if (kARGB_4444_SkColorType == this->colorType()) {
v = pack_8888_to_4444(a, r, g, b);
} else {
v = SkPackRGB16(r >> (8 - SK_R16_BITS),
g >> (8 - SK_G16_BITS),
b >> (8 - SK_B16_BITS));
}
while (--height >= 0) {
sk_memset16(p, v, width);
p = (uint16_t*)((char*)p + rowBytes);
}
break;
}
case kBGRA_8888_SkColorType:
case kRGBA_8888_SkColorType: {
uint32_t* p = this->writable_addr32(area.fLeft, area.fTop);
if (255 != a && kPremul_SkAlphaType == this->alphaType()) {
r = SkMulDiv255Round(r, a);
g = SkMulDiv255Round(g, a);
b = SkMulDiv255Round(b, a);
}
uint32_t v = kRGBA_8888_SkColorType == this->colorType()
? SkPackARGB_as_RGBA(a, r, g, b)
: SkPackARGB_as_BGRA(a, r, g, b);
while (--height >= 0) {
sk_memset32(p, v, width);
p = (uint32_t*)((char*)p + rowBytes);
}
break;
}
default:
return false; // no change, so don't call notifyPixelsChanged()
}
return true;
}
void SkColorShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
sk_memset16(span, fColor16, count);
}
void SkSampler::Fill(const SkImageInfo& info, void* dst, size_t rowBytes,
uint64_t colorOrIndex, SkCodec::ZeroInitialized zeroInit) {
SkASSERT(dst != nullptr);
// Calculate bytes to fill.
const size_t bytesToFill = info.computeByteSize(rowBytes);
const int width = info.width();
const int numRows = info.height();
// Use the proper memset routine to fill the remaining bytes
switch (info.colorType()) {
case kRGBA_8888_SkColorType:
case kBGRA_8888_SkColorType: {
// If memory is zero initialized, we may not need to fill
uint32_t color = (uint32_t) colorOrIndex;
if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
return;
}
uint32_t* dstRow = (uint32_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset32((uint32_t*) dstRow, color, width);
dstRow = SkTAddOffset<uint32_t>(dstRow, rowBytes);
}
break;
}
case kRGB_565_SkColorType: {
// If the destination is k565, the caller passes in a 16-bit color.
// We will not assert that the high bits of colorOrIndex must be zeroed.
// This allows us to take advantage of the fact that the low 16 bits of an
// SKPMColor may be a valid a 565 color. For example, the low 16
// bits of SK_ColorBLACK are identical to the 565 representation
// for black.
// If memory is zero initialized, we may not need to fill
uint16_t color = (uint16_t) colorOrIndex;
if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
return;
}
uint16_t* dstRow = (uint16_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset16((uint16_t*) dstRow, color, width);
dstRow = SkTAddOffset<uint16_t>(dstRow, rowBytes);
}
break;
}
case kGray_8_SkColorType:
// If the destination is kGray, the caller passes in an 8-bit color.
// We will not assert that the high bits of colorOrIndex must be zeroed.
// This allows us to take advantage of the fact that the low 8 bits of an
// SKPMColor may be a valid a grayscale color. For example, the low 8
// bits of SK_ColorBLACK are identical to the grayscale representation
// for black.
// If memory is zero initialized, we may not need to fill
if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == (uint8_t) colorOrIndex) {
return;
}
memset(dst, (uint8_t) colorOrIndex, bytesToFill);
break;
case kRGBA_F16_SkColorType: {
uint64_t color = colorOrIndex;
if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
return;
}
uint64_t* dstRow = (uint64_t*) dst;
for (int row = 0; row < numRows; row++) {
sk_memset64((uint64_t*) dstRow, color, width);
dstRow = SkTAddOffset<uint64_t>(dstRow, rowBytes);
}
break;
}
default:
SkCodecPrintf("Error: Unsupported dst color type for fill(). Doing nothing.\n");
SkASSERT(false);
break;
}
}
