AForge.Imaging.Filters.Convolution.Process32bppImage C# (CSharp) Method

        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;
            }
        }