src/effects/SkBlurMask.cpp - platform/external/skia - Git at Google

 /* libs/graphics/effects/SkBlurMask.cpp
 **
 ** Copyright 2006, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */

 #include "SkBlurMask.h"
 #include "SkTemplates.h"

 static void build_sum_buffer(uint32_t dst[], int w, int h, const uint8_t src[], int srcRB)
 {
     SkASSERT(srcRB >= w);
     // mod srcRB so we can apply it after each row
     srcRB -= w;

     int x, y;

     // special case first row
     uint32_t X = 0;
     for (x = w - 1; x >= 0; --x)
     {
         X = *src++ + X;
         *dst++ = X;
     }
     src += srcRB;

     // now do the rest of the rows
     for (y = h - 1; y > 0; --y)
     {
         uint32_t L = 0;
         uint32_t C = 0;
         for (x = w - 1; x >= 0; --x)
         {
             uint32_t T = dst[-w];
             X = *src++ + L + T - C;
             *dst++ = X;
             L = X;
             C = T;
         }
         src += srcRB;
     }
 }

 static void apply_kernel(uint8_t dst[], int rx, int ry, const uint32_t src[], int sw, int sh)
 {
     uint32_t scale = (1 << 24) / ((2*rx + 1)*(2*ry + 1));

     int rowBytes = sw;

     int dw = sw + 2*rx;
     int dh = sh + 2*ry;

     sw -= 1;    // now it is max_x
     sh -= 1;    // now it is max_y

     int prev_y = -ry - 1    -ry;
     int next_y = ry         -ry;

     for (int y = 0; y < dh; y++)
     {
         int py = SkClampPos(prev_y) * rowBytes;
         int ny = SkFastMin32(next_y, sh) * rowBytes;

         int prev_x = -rx - 1    -rx;
         int next_x = rx         -rx;

         for (int x = 0; x < dw; x++)
         {
             int px = SkClampPos(prev_x);
             int nx = SkFastMin32(next_x, sw);

             uint32_t sum = src[px+py] + src[nx+ny] - src[nx+py] - src[px+ny];
             *dst++ = SkToU8(sum * scale >> 24);

             prev_x += 1;
             next_x += 1;
         }
         prev_y += 1;
         next_y += 1;
     }
 }

 static void apply_kernel_interp(uint8_t dst[], int rx, int ry, const uint32_t src[], int sw, int sh, U8CPU outer_weight)
 {
     SkASSERT(rx > 0 && ry > 0);
     SkASSERT(outer_weight <= 255);

     int inner_weight = 255 - outer_weight;

     // round these guys up if they're bigger than 127
     outer_weight += outer_weight >> 7;
     inner_weight += inner_weight >> 7;

     uint32_t outer_scale = (outer_weight << 16) / ((2*rx + 1)*(2*ry + 1));
     uint32_t inner_scale = (inner_weight << 16) / ((2*rx - 1)*(2*ry - 1));

     int rowBytes = sw;

     int dw = sw + 2*rx;
     int dh = sh + 2*ry;

     sw -= 1;    // now it is max_x
     sh -= 1;    // now it is max_y

     int prev_y = -ry - 1    -ry;
     int next_y = ry         -ry;

     for (int y = 0; y < dh; y++)
     {
         int py = SkClampPos(prev_y) * rowBytes;
         int ny = SkFastMin32(next_y, sh) * rowBytes;

         int ipy = SkClampPos(prev_y + 1) * rowBytes;
         int iny = SkClampMax(next_y - 1, sh) * rowBytes;

         int prev_x = -rx - 1    -rx;
         int next_x = rx         -rx;

         for (int x = 0; x < dw; x++)
         {
             int px = SkClampPos(prev_x);
             int nx = SkFastMin32(next_x, sw);

             int ipx = SkClampPos(prev_x + 1);
             int inx = SkClampMax(next_x - 1, sw);

             uint32_t outer_sum = src[px+py] + src[nx+ny] - src[nx+py] - src[px+ny];
             uint32_t inner_sum = src[ipx+ipy] + src[inx+iny] - src[inx+ipy] - src[ipx+iny];
             *dst++ = SkToU8((outer_sum * outer_scale + inner_sum * inner_scale) >> 24);

             prev_x += 1;
             next_x += 1;
         }
         prev_y += 1;
         next_y += 1;
     }
 }

 #include "SkColorPriv.h"

 static void merge_src_with_blur(uint8_t dst[],
                                 const uint8_t src[], int sw, int sh,
                                 const uint8_t blur[], int blurRowBytes)
 {
     while (--sh >= 0)
     {
         for (int x = sw - 1; x >= 0; --x)
         {
             *dst = SkToU8(SkAlphaMul(*blur, SkAlpha255To256(*src)));
             dst += 1;
             src += 1;
             blur += 1;
         }
         blur += blurRowBytes - sw;
     }
 }

 static void clamp_with_orig(uint8_t dst[], int dstRowBytes,
                             const uint8_t src[], int sw, int sh,
                             SkBlurMask::Style style)
 {
     int x;
     while (--sh >= 0)
     {
         switch (style) {
         case SkBlurMask::kSolid_Style:
             for (x = sw - 1; x >= 0; --x)
             {
                 *dst = SkToU8(*src + SkAlphaMul(*dst, SkAlpha255To256(255 - *src)));
                 dst += 1;
                 src += 1;
             }
             break;
         case SkBlurMask::kOuter_Style:
             for (x = sw - 1; x >= 0; --x)
             {
                 if (*src)
                     *dst = SkToU8(SkAlphaMul(*dst, SkAlpha255To256(255 - *src)));
                 dst += 1;
                 src += 1;
             }
             break;
         default:
             SkASSERT(!"Unexpected blur style here");
             break;
         }
         dst += dstRowBytes - sw;
     }
 }

 ////////////////////////////////////////////////////////////////////////

 // we use a local funciton to wrap the class static method to work around
 // a bug in gcc98
 void SkMask_FreeImage(uint8_t* image);
 void SkMask_FreeImage(uint8_t* image)
 {
     SkMask::FreeImage(image);
 }

 bool SkBlurMask::Blur(SkMask* dst, const SkMask& src,
                       SkScalar radius, Style style)
 {
     if (src.fFormat != SkMask::kA8_Format)
         return false;

     int rx = SkScalarCeil(radius);
     int outer_weight = 255 - SkScalarRound((SkIntToScalar(rx) - radius) * 255);

     SkASSERT(rx >= 0);
     SkASSERT((unsigned)outer_weight <= 255);

     if (rx == 0)
         return false;

     int ry = rx;    // only do square blur for now

     dst->fBounds.set(src.fBounds.fLeft - rx, src.fBounds.fTop - ry,
                         src.fBounds.fRight + rx, src.fBounds.fBottom + ry);
     dst->fRowBytes = SkToU16(dst->fBounds.width());
     dst->fFormat = SkMask::kA8_Format;
     dst->fImage = NULL;

     if (src.fImage)
     {
         int             sw = src.fBounds.width();
         int             sh = src.fBounds.height();
         const uint8_t*  sp = src.fImage;
         uint8_t*        dp = SkMask::AllocImage(dst->computeImageSize());

         SkAutoTCallVProc<uint8_t, SkMask_FreeImage> autoCall(dp);

         // build the blurry destination
         {
             SkAutoTMalloc<uint32_t> storage(sw * sh);
             uint32_t*               sumBuffer = storage.get();

             build_sum_buffer(sumBuffer, sw, sh, sp, src.fRowBytes);
             if (outer_weight == 255)
                 apply_kernel(dp, rx, ry, sumBuffer, sw, sh);
             else
                 apply_kernel_interp(dp, rx, ry, sumBuffer, sw, sh, outer_weight);
         }

         dst->fImage = dp;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
         if (style == kInner_Style)
         {
             dst->fImage = SkMask::AllocImage(src.computeImageSize());
             merge_src_with_blur(dst->fImage, sp, sw, sh,
                                 dp + rx + ry*dst->fBounds.width(),
                                 dst->fBounds.width());
             SkMask::FreeImage(dp);
         }
         else if (style != kNormal_Style)
         {
             clamp_with_orig(dp + rx + ry*dst->fBounds.width(),
                             dst->fBounds.width(),
                             sp, sw, sh,
                             style);
         }
         (void)autoCall.detach();
     }

     if (style == kInner_Style)
     {
         dst->fBounds = src.fBounds; // restore trimmed bounds
         dst->fRowBytes = SkToU16(dst->fBounds.width());
     }

 #if 0
     if (gamma && dst->fImage)
     {
         uint8_t*    image = dst->fImage;
         uint8_t*    stop = image + dst->computeImageSize();

         for (; image < stop; image += 1)
             *image = gamma[*image];
     }
 #endif
     return true;
 }

 #if 0
 void SkBlurMask::BuildSqrtGamma(uint8_t gamma[256], SkScalar percent)
 {
     SkASSERT(gamma);
     SkASSERT(percent >= 0 && percent <= SK_Scalar1);

     int scale = SkScalarRound(percent * 256);

     for (int i = 0; i < 256; i++)
     {
         SkFixed n = i * 257;
         n += n >> 15;
         SkASSERT(n >= 0 && n <= SK_Fixed1);
         n = SkFixedSqrt(n);
         n = n * 255 >> 16;
         n = SkAlphaBlend(n, i, scale);
         gamma[i] = SkToU8(n);
     }
 }

 void SkBlurMask::BuildSqrGamma(uint8_t gamma[256], SkScalar percent)
 {
     SkASSERT(gamma);
     SkASSERT(percent >= 0 && percent <= SK_Scalar1);

     int     scale = SkScalarRound(percent * 256);
     SkFixed div255 = SK_Fixed1 / 255;

     for (int i = 0; i < 256; i++)
     {
         int square = i * i;
         int linear = i * 255;
         int n = SkAlphaBlend(square, linear, scale);
         gamma[i] = SkToU8(n * div255 >> 16);
     }
 }
 #endif
	/* libs/graphics/effects/SkBlurMask.cpp
	**
	** Copyright 2006, The Android Open Source Project
	**
	** Licensed under the Apache License, Version 2.0 (the "License");
	** you may not use this file except in compliance with the License.
	** You may obtain a copy of the License at
	**
	** http://www.apache.org/licenses/LICENSE-2.0
	**
	** Unless required by applicable law or agreed to in writing, software
	** distributed under the License is distributed on an "AS IS" BASIS,
	** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	** See the License for the specific language governing permissions and
	** limitations under the License.
	*/

	#include "SkBlurMask.h"
	#include "SkTemplates.h"

	static void build_sum_buffer(uint32_t dst[], int w, int h, const uint8_t src[], int srcRB)
	{
	SkASSERT(srcRB >= w);
	// mod srcRB so we can apply it after each row
	srcRB -= w;

	int x, y;

	// special case first row
	uint32_t X = 0;
	for (x = w - 1; x >= 0; --x)
	{
	X = *src++ + X;
	*dst++ = X;
	}
	src += srcRB;

	// now do the rest of the rows
	for (y = h - 1; y > 0; --y)
	{
	uint32_t L = 0;
	uint32_t C = 0;
	for (x = w - 1; x >= 0; --x)
	{
	uint32_t T = dst[-w];
	X = *src++ + L + T - C;
	*dst++ = X;
	L = X;
	C = T;
	}
	src += srcRB;
	}
	}

	static void apply_kernel(uint8_t dst[], int rx, int ry, const uint32_t src[], int sw, int sh)
	{
	uint32_t scale = (1 << 24) / ((2rx + 1)(2*ry + 1));

	int rowBytes = sw;

	int dw = sw + 2*rx;
	int dh = sh + 2*ry;

	sw -= 1; // now it is max_x
	sh -= 1; // now it is max_y

	int prev_y = -ry - 1 -ry;
	int next_y = ry -ry;

	for (int y = 0; y < dh; y++)
	{
	int py = SkClampPos(prev_y) * rowBytes;
	int ny = SkFastMin32(next_y, sh) * rowBytes;

	int prev_x = -rx - 1 -rx;
	int next_x = rx -rx;

	for (int x = 0; x < dw; x++)
	{
	int px = SkClampPos(prev_x);
	int nx = SkFastMin32(next_x, sw);

	uint32_t sum = src[px+py] + src[nx+ny] - src[nx+py] - src[px+ny];
	dst++ = SkToU8(sum scale >> 24);

	prev_x += 1;
	next_x += 1;
	}
	prev_y += 1;
	next_y += 1;
	}
	}

	static void apply_kernel_interp(uint8_t dst[], int rx, int ry, const uint32_t src[], int sw, int sh, U8CPU outer_weight)
	{
	SkASSERT(rx > 0 && ry > 0);
	SkASSERT(outer_weight <= 255);

	int inner_weight = 255 - outer_weight;

	// round these guys up if they're bigger than 127
	outer_weight += outer_weight >> 7;
	inner_weight += inner_weight >> 7;

	uint32_t outer_scale = (outer_weight << 16) / ((2rx + 1)(2*ry + 1));
	uint32_t inner_scale = (inner_weight << 16) / ((2rx - 1)(2*ry - 1));

	int rowBytes = sw;

	int dw = sw + 2*rx;
	int dh = sh + 2*ry;

	sw -= 1; // now it is max_x
	sh -= 1; // now it is max_y

	int prev_y = -ry - 1 -ry;
	int next_y = ry -ry;

	for (int y = 0; y < dh; y++)
	{
	int py = SkClampPos(prev_y) * rowBytes;
	int ny = SkFastMin32(next_y, sh) * rowBytes;

	int ipy = SkClampPos(prev_y + 1) * rowBytes;
	int iny = SkClampMax(next_y - 1, sh) * rowBytes;

	int prev_x = -rx - 1 -rx;
	int next_x = rx -rx;

	for (int x = 0; x < dw; x++)
	{
	int px = SkClampPos(prev_x);
	int nx = SkFastMin32(next_x, sw);

	int ipx = SkClampPos(prev_x + 1);
	int inx = SkClampMax(next_x - 1, sw);

	uint32_t outer_sum = src[px+py] + src[nx+ny] - src[nx+py] - src[px+ny];
	uint32_t inner_sum = src[ipx+ipy] + src[inx+iny] - src[inx+ipy] - src[ipx+iny];
	dst++ = SkToU8((outer_sum outer_scale + inner_sum * inner_scale) >> 24);

	prev_x += 1;
	next_x += 1;
	}
	prev_y += 1;
	next_y += 1;
	}
	}

	#include "SkColorPriv.h"

	static void merge_src_with_blur(uint8_t dst[],
	const uint8_t src[], int sw, int sh,
	const uint8_t blur[], int blurRowBytes)
	{
	while (--sh >= 0)
	{
	for (int x = sw - 1; x >= 0; --x)
	{
	dst = SkToU8(SkAlphaMul(blur, SkAlpha255To256(*src)));
	dst += 1;
	src += 1;
	blur += 1;
	}
	blur += blurRowBytes - sw;
	}
	}

	static void clamp_with_orig(uint8_t dst[], int dstRowBytes,
	const uint8_t src[], int sw, int sh,
	SkBlurMask::Style style)
	{
	int x;
	while (--sh >= 0)
	{
	switch (style) {
	case SkBlurMask::kSolid_Style:
	for (x = sw - 1; x >= 0; --x)
	{
	dst = SkToU8(src + SkAlphaMul(dst, SkAlpha255To256(255 - src)));
	dst += 1;
	src += 1;
	}
	break;
	case SkBlurMask::kOuter_Style:
	for (x = sw - 1; x >= 0; --x)
	{
	if (*src)
	dst = SkToU8(SkAlphaMul(dst, SkAlpha255To256(255 - *src)));
	dst += 1;
	src += 1;
	}
	break;
	default:
	SkASSERT(!"Unexpected blur style here");
	break;
	}
	dst += dstRowBytes - sw;
	}
	}

	////////////////////////////////////////////////////////////////////////

	// we use a local funciton to wrap the class static method to work around
	// a bug in gcc98
	void SkMask_FreeImage(uint8_t* image);
	void SkMask_FreeImage(uint8_t* image)
	{
	SkMask::FreeImage(image);
	}

	bool SkBlurMask::Blur(SkMask* dst, const SkMask& src,
	SkScalar radius, Style style)
	{
	if (src.fFormat != SkMask::kA8_Format)
	return false;

	int rx = SkScalarCeil(radius);
	int outer_weight = 255 - SkScalarRound((SkIntToScalar(rx) - radius) * 255);

	SkASSERT(rx >= 0);
	SkASSERT((unsigned)outer_weight <= 255);

	if (rx == 0)
	return false;

	int ry = rx; // only do square blur for now

	dst->fBounds.set(src.fBounds.fLeft - rx, src.fBounds.fTop - ry,
	src.fBounds.fRight + rx, src.fBounds.fBottom + ry);
	dst->fRowBytes = SkToU16(dst->fBounds.width());
	dst->fFormat = SkMask::kA8_Format;
	dst->fImage = NULL;

	if (src.fImage)
	{
	int sw = src.fBounds.width();
	int sh = src.fBounds.height();
	const uint8_t* sp = src.fImage;
	uint8_t* dp = SkMask::AllocImage(dst->computeImageSize());

	SkAutoTCallVProc<uint8_t, SkMask_FreeImage> autoCall(dp);

	// build the blurry destination
	{
	SkAutoTMalloc<uint32_t> storage(sw * sh);
	uint32_t* sumBuffer = storage.get();

	build_sum_buffer(sumBuffer, sw, sh, sp, src.fRowBytes);
	if (outer_weight == 255)
	apply_kernel(dp, rx, ry, sumBuffer, sw, sh);
	else
	apply_kernel_interp(dp, rx, ry, sumBuffer, sw, sh, outer_weight);
	}

	dst->fImage = dp;
	// if need be, alloc the "real" dst (same size as src) and copy/merge
	// the blur into it (applying the src)
	if (style == kInner_Style)
	{
	dst->fImage = SkMask::AllocImage(src.computeImageSize());
	merge_src_with_blur(dst->fImage, sp, sw, sh,
	dp + rx + ry*dst->fBounds.width(),
	dst->fBounds.width());
	SkMask::FreeImage(dp);
	}
	else if (style != kNormal_Style)
	{
	clamp_with_orig(dp + rx + ry*dst->fBounds.width(),
	dst->fBounds.width(),
	sp, sw, sh,
	style);
	}
	(void)autoCall.detach();
	}

	if (style == kInner_Style)
	{
	dst->fBounds = src.fBounds; // restore trimmed bounds
	dst->fRowBytes = SkToU16(dst->fBounds.width());
	}

	#if 0
	if (gamma && dst->fImage)
	{
	uint8_t* image = dst->fImage;
	uint8_t* stop = image + dst->computeImageSize();

	for (; image < stop; image += 1)
	image = gamma[image];
	}
	#endif
	return true;
	}

	#if 0
	void SkBlurMask::BuildSqrtGamma(uint8_t gamma[256], SkScalar percent)
	{
	SkASSERT(gamma);
	SkASSERT(percent >= 0 && percent <= SK_Scalar1);

	int scale = SkScalarRound(percent * 256);

	for (int i = 0; i < 256; i++)
	{
	SkFixed n = i * 257;
	n += n >> 15;
	SkASSERT(n >= 0 && n <= SK_Fixed1);
	n = SkFixedSqrt(n);
	n = n * 255 >> 16;
	n = SkAlphaBlend(n, i, scale);
	gamma[i] = SkToU8(n);
	}
	}

	void SkBlurMask::BuildSqrGamma(uint8_t gamma[256], SkScalar percent)
	{
	SkASSERT(gamma);
	SkASSERT(percent >= 0 && percent <= SK_Scalar1);

	int scale = SkScalarRound(percent * 256);
	SkFixed div255 = SK_Fixed1 / 255;

	for (int i = 0; i < 256; i++)
	{
	int square = i * i;
	int linear = i * 255;
	int n = SkAlphaBlend(square, linear, scale);
	gamma[i] = SkToU8(n * div255 >> 16);
	}
	}
	#endif