private unsafe void Process32bppImage(byte* src, byte* dst,
int srcStride, int dstStride, int srcOffset, int dstOffset,
int startX, int startY, int stopX, int stopY)
{
// loop and array indexes
int i, j, t, k, ir, jr;
// kernel's radius
int radius = size >> 1;
// color sums
long r, g, b, a, div;
// kernel size
int kernelSize = size * size;
// number of kernel elements taken into account
int processedKernelSize;
byte* p;
// for each line
for (int y = startY; y < stopY; y++)
{
// for each pixel
for (int x = startX; x < stopX; x++, src += 4, dst += 4)
{
r = g = b = a = div = processedKernelSize = 0;
// for each kernel row
for (i = 0; i < size; i++)
{
ir = i - radius;
t = y + ir;
// skip row
if (t < startY)
continue;
// break
if (t >= stopY)
break;
// for each kernel column
for (j = 0; j < size; j++)
{
jr = j - radius;
t = x + jr;
// skip column
if (t < startX)
continue;
if (t < stopX)
{
k = kernel[i, j];
p = &src[ir * srcStride + jr * 4];
div += k;
r += k * p[RGB.R];
g += k * p[RGB.G];
b += k * p[RGB.B];
a += k * p[RGB.A];
processedKernelSize++;
}
}
}
// check if all kernel elements were processed
if (processedKernelSize == kernelSize)
{
// all kernel elements are processed - we are not on the edge
div = divisor;
}
else
{
// we are on edge. do we need to use dynamic divisor or not?
if (!dynamicDivisorForEdges)
{
// do
div = divisor;
}
}
// check divider
if (div != 0)
{
r /= div;
g /= div;
b /= div;
a /= div;
}
r += threshold;
g += threshold;
b += threshold;
a += threshold;
dst[RGB.R] = (byte)((r > 255) ? 255 : ((r < 0) ? 0 : r));
dst[RGB.G] = (byte)((g > 255) ? 255 : ((g < 0) ? 0 : g));
dst[RGB.B] = (byte)((b > 255) ? 255 : ((b < 0) ? 0 : b));
dst[RGB.A] = (byte)((a > 255) ? 255 : ((a < 0) ? 0 : a));
}
src += srcOffset;
dst += dstOffset;
}
}