void FEDropShadow::applySoftware()
{
FilterEffect* in = inputEffect(0);
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
Filter* filter = this->filter();
FloatSize blurRadius(filter->applyHorizontalScale(m_stdX), filter->applyVerticalScale(m_stdY));
FloatSize offset(filter->applyHorizontalScale(m_dx), filter->applyVerticalScale(m_dy));
FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect());
GraphicsContext* resultContext = resultImage->context();
ASSERT(resultContext);
Color color = adaptColorToOperatingColorSpace(m_shadowColor.combineWithAlpha(m_shadowOpacity));
SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(blurRadius.width(), blurRadius.height()));
SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(color.rgb(), SkXfermode::kSrcIn_Mode));
SkPaint paint;
paint.setImageFilter(blurFilter.get());
paint.setColorFilter(colorFilter.get());
paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
RefPtr<Image> image = in->asImageBuffer()->copyImage(DontCopyBackingStore);
RefPtr<NativeImageSkia> nativeImage = image->nativeImageForCurrentFrame();
if (!nativeImage)
return;
resultContext->drawBitmap(nativeImage->bitmap(), drawingRegion.x() + offset.width(), drawingRegion.y() + offset.height(), &paint);
resultContext->drawBitmap(nativeImage->bitmap(), drawingRegion.x(), drawingRegion.y());
}
// This detector detects that image filter phase of the pixel pipeline receives the correct value.
static void install_detector_image_filter(SkPaint* drawPaint) {
sk_sp<SkColorFilter> colorFilter(make_detector_color_filter());
sk_sp<SkImageFilter> imageFilter(
SkColorFilterImageFilter::Make(std::move(colorFilter),
sk_ref_sp(drawPaint->getImageFilter())));
drawPaint->setImageFilter(std::move(imageFilter));
}
SkBitmap CCRenderSurfaceFilters::apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize& size, WebKit::WebGraphicsContext3D* context3D, GrContext* grContext)
{
if (!context3D || !grContext)
return SkBitmap();
WebKit::WebFilterOperations optimizedFilters = optimize(filters);
FilterBufferState state(grContext, size, textureId);
if (!state.init(optimizedFilters.size()))
return SkBitmap();
for (unsigned i = 0; i < optimizedFilters.size(); ++i) {
const WebKit::WebFilterOperation& op = optimizedFilters.at(i);
SkCanvas* canvas = state.canvas();
switch (op.type()) {
case WebKit::WebFilterOperation::FilterTypeColorMatrix: {
SkPaint paint;
paint.setColorFilter(new SkColorMatrixFilter(op.matrix()))->unref();
canvas->drawBitmap(state.source(), 0, 0, &paint);
break;
}
case WebKit::WebFilterOperation::FilterTypeBlur: {
float stdDeviation = op.amount();
SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdDeviation, stdDeviation));
SkPaint paint;
paint.setImageFilter(filter.get());
canvas->drawSprite(state.source(), 0, 0, &paint);
break;
}
case WebKit::WebFilterOperation::FilterTypeDropShadow: {
SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(op.amount(), op.amount()));
SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(op.dropShadowColor(), SkXfermode::kSrcIn_Mode));
SkPaint paint;
paint.setImageFilter(blurFilter.get());
paint.setColorFilter(colorFilter.get());
paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
canvas->saveLayer(0, &paint);
canvas->drawBitmap(state.source(), op.dropShadowOffset().x, -op.dropShadowOffset().y);
canvas->restore();
canvas->drawBitmap(state.source(), 0, 0);
break;
}
case WebKit::WebFilterOperation::FilterTypeBrightness:
case WebKit::WebFilterOperation::FilterTypeContrast:
case WebKit::WebFilterOperation::FilterTypeGrayscale:
case WebKit::WebFilterOperation::FilterTypeSepia:
case WebKit::WebFilterOperation::FilterTypeSaturate:
case WebKit::WebFilterOperation::FilterTypeHueRotate:
case WebKit::WebFilterOperation::FilterTypeInvert:
case WebKit::WebFilterOperation::FilterTypeOpacity:
ASSERT_NOT_REACHED();
break;
}
state.swap();
}
context3D->flush();
return state.source();
}
static void TestColorFilterSerialization(skiatest::Reporter* reporter) {
uint8_t table[256];
for (int i = 0; i < 256; ++i) {
table[i] = (i * 41) % 256;
}
SkAutoTUnref<SkColorFilter> colorFilter(SkTableColorFilter::Create(table));
SkAutoTUnref<SkColorFilter> copy(
TestFlattenableSerialization<SkColorFilter>(colorFilter.get(), true, reporter));
}
void SpaceStation::draw()
{
node()->clear();
float r = _size / 2;
Color4F darkGray = colorFilter(Color4F(0.3f, 0.3f, 0.3f, 1.0f));
node()->drawSolidCircle(Vec2::ZERO, r*1.05, 0, 12, darkGray);
node()->drawSolidCircle(Vec2::ZERO, r, 0, 12, colorFilter(Color4F::GRAY));
node()->drawSolidRect(
Vec2(-7*r/10, 4*r/10),
Vec2( 7*r/10, 6*r/10),
darkGray
);
node()->drawTriangleGradient(
Vec2(-7*r/10, -6*r/10),
Vec2( 7*r/10, -6*r/10),
Vec2( 0, r),
colorFilter(Color4F::GRAY), colorFilter(Color4F::GRAY), uniformColor()
);
}
void Tank::draw()
{
node()->clear();
node()->drawSegment(
_gunBegin,
_gunBegin + _gunLength * Vec2::forAngle(CC_DEGREES_TO_RADIANS(_angle)),
1, uniformColor()
);
node()->drawSolidPoly(_base, sizeof(_base)/sizeof(*_base), colorFilter(Color4F::WHITE));
node()->drawSolidPoly(_head, sizeof(_head)/sizeof(*_head), uniformColor());
}
SkImageFilter* FEComponentTransfer::createImageFilter(SkiaImageFilterBuilder* builder)
{
SkImageFilter* input = builder->build(inputEffect(0));
unsigned char rValues[256], gValues[256], bValues[256], aValues[256];
getValues(rValues, gValues, bValues, aValues);
SkAutoTUnref<SkColorFilter> colorFilter(SkTableColorFilter::CreateARGB(aValues, rValues, gValues, bValues));
return SkColorFilterImageFilter::Create(colorFilter, input);
}
PassRefPtr<SkImageFilter> SourceAlpha::createImageFilter(SkiaImageFilterBuilder& builder)
{
RefPtr<SkImageFilter> sourceGraphic(builder.build(inputEffect(0), operatingColorSpace()));
SkScalar matrix[20] = {
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, SK_Scalar1, 0
};
RefPtr<SkColorFilter> colorFilter(adoptRef(SkColorMatrixFilter::Create(matrix)));
return adoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), sourceGraphic.get()));
}
PassRefPtr<SkImageFilter> FEComponentTransfer::createImageFilter(SkiaImageFilterBuilder* builder)
{
RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace()));
unsigned char rValues[256], gValues[256], bValues[256], aValues[256];
getValues(rValues, gValues, bValues, aValues);
SkAutoTUnref<SkColorFilter> colorFilter(SkTableColorFilter::CreateARGB(aValues, rValues, gValues, bValues));
SkImageFilter::CropRect cropRect = getCropRect(builder->cropOffset());
return adoptRef(SkColorFilterImageFilter::Create(colorFilter, input.get(), &cropRect));
}
void DropCapsid::draw()
{
node()->clear();
float r = _size / 2;
node()->drawSolidCircle(Vec2::ZERO, r, 0, 12, colorFilter(Color4F::WHITE));
node()->drawSolidRect(
Vec2(-r/10, -9*r/10),
Vec2( r/10, 9*r/10),
uniformColor()
);
node()->drawSolidRect(
Vec2(-9*r/10, -r/10),
Vec2( 9*r/10, r/10),
uniformColor()
);
}
bool SkDropShadowImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source,
const Context& ctx,
SkBitmap* result, SkIPoint* offset) const
{
SkBitmap src = source;
SkIPoint srcOffset = SkIPoint::Make(0, 0);
if (!this->filterInput(0, proxy, source, ctx, &src, &srcOffset))
return false;
SkIRect srcBounds = src.bounds();
srcBounds.offset(srcOffset);
SkIRect bounds;
if (!this->applyCropRect(ctx, srcBounds, &bounds)) {
return false;
}
SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
if (nullptr == device.get()) {
return false;
}
SkCanvas canvas(device.get());
SkVector sigma = SkVector::Make(fSigmaX, fSigmaY);
ctx.ctm().mapVectors(&sigma, 1);
sigma.fX = SkMaxScalar(0, sigma.fX);
sigma.fY = SkMaxScalar(0, sigma.fY);
SkAutoTUnref<SkImageFilter> blurFilter(SkBlurImageFilter::Create(sigma.fX, sigma.fY));
SkAutoTUnref<SkColorFilter> colorFilter(
SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode));
SkPaint paint;
paint.setImageFilter(blurFilter.get());
paint.setColorFilter(colorFilter.get());
paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
SkVector offsetVec = SkVector::Make(fDx, fDy);
ctx.ctm().mapVectors(&offsetVec, 1);
canvas.translate(SkIntToScalar(srcOffset.fX - bounds.fLeft),
SkIntToScalar(srcOffset.fY - bounds.fTop));
canvas.drawBitmap(src, offsetVec.fX, offsetVec.fY, &paint);
if (fShadowMode == kDrawShadowAndForeground_ShadowMode) {
canvas.drawBitmap(src, 0, 0);
}
*result = device->accessBitmap(false);
offset->fX = bounds.fLeft;
offset->fY = bounds.fTop;
return true;
}
int do_pipes(int numProcesses, int level, int childNum, int** A, int color, int turn_pipe[2], int confirm_pipe[2])
{
// child processes for pipe implementation
// see report for pseudocode algorithm and reasoning
// as this is a full binary tree, there are 2^level children
int totalChildren = 1 << level;
if (numProcesses <= totalChildren) {
// compute filter
int xStart = childNum * X / numProcesses; // start row
int xEnd = (childNum + 1) * (X - 1) / numProcesses; // end row
// run filter on just these rows
colorFilter(A, xStart, xEnd, 0, Y-1, color); // rows
// now this process waits until its turn to print is sent via turn_pipe
int current_turn, confirm_message;
while(1){ // loop indefinitely until its turn is over
read(turn_pipe[0], ¤t_turn, sizeof(current_turn));
if (current_turn == childNum){
// it is this child's turn to print
printf("Doing process %0.2d of %d.\n", childNum, numProcesses-1);
printImage(A, xStart, xEnd, 0, Y-1);
// send confirmation message to tell parent that it's done printing
confirm_message = current_turn;
write(confirm_pipe[1], &confirm_message, sizeof(confirm_message));
// now stop waiting to process/print as we are done
break;
}
// write back turn for the next process to read
write(turn_pipe[1], ¤t_turn, sizeof(current_turn));
}
} else {
// have not forked enough to create the necessary number of children
// in our binary tree, so fork this process and recurse
pid_t this_pid;
int result;
switch (this_pid = fork()) {
case -1:
perror("fork() failure");
exit(-1);
break;
case 0: // this is the child
do_pipes(numProcesses, level + 1, childNum * 2, A, color, turn_pipe, confirm_pipe);
break;
default: // parent
do_pipes(numProcesses, level + 1, childNum * 2 + 1, A, color, turn_pipe, confirm_pipe);
break;
}
}
wait(NULL); // reliquish control until all children have printed and have died
return 0;
}
