C#

Ennis Ray Lynch, Jr. wrote:

About as fast as C# will get. C++ is must faster.

Parallel.For( 0, bmp.Height, row => {
    //
    // establish pointer into the three source color planes, each based on the the row this
    // task is to process
    byte* b = (byte*)_b + ( row * bmp.Width );
    byte* g = (byte*)_g + ( row * bmp.Width );
    byte* r = (byte*)_r + ( row * bmp.Width );
    //
    // calc the starting position in the destination bitmap for the first byte of this row
    byte* dst = row <= 0 ? (byte*)bmp.Scan0 : (byte*)bmp.Scan0 + ( ( bmp.Width * 3 ) * row ) + ( ( bmp.Stride / 3 ) - bmp.Width ) * 3;
    //
    // copy the bytes from the three sources into the bitmap row
    for ( int col = 0; col < bmp.Width; col++ ) {
        *dst++ = *b++;
        *dst++ = *g++;
        *dst++ = *r++;
    }
} );

jkohler wrote:

Unfortunately that's not the production target.

private static unsafe void CopyColorPlanes32( BitmapData bmp, IntPtr _b, IntPtr _g, IntPtr _r )
{
    int* imgPtr = (int*)bmp.Scan0;

    const int h = bmp.Height;
    const int w = bmp.Width;
    const int alphaValue = 0xff << 24; // opaque

    byte* b = (byte*)_b;
    byte* g = (byte*)_g;
    byte* r = (byte*)_r;

    for ( int row = 0; row < h; row++ )
        for ( int col = 0; col < w; col++ )
            *imgPtr++ = alphaValue | *b++ | ( *g++ << 8 ) | ( *r++ << 16 );
}

Michael B. Hansen wrote:

Although the compiler/JIT should already have done some the above optimizations, I have seen measurable improvements doing the above in certain areas.

private static unsafe void PlanarToPackedByteRgb32(
    int width, int height,
    IntPtr rSrc, IntPtr gSrc, IntPtr bSrc,
    IntPtr dest, int stride)
{
    var rSrcPtr = (byte*)rSrc.ToPointer();
    var gSrcPtr = (byte*)gSrc.ToPointer();
    var bSrcPtr = (byte*)bSrc.ToPointer();
    var destPtr = (byte*)dest.ToPointer();
    var destEndPtr = destPtr + stride * height;
    var rowStep = 4 * width;

    while (destPtr != destEndPtr)
    {
        var it = (uint*)destPtr;
        var end = (uint*)(destPtr + rowStep);
        destPtr += stride;

        while (it != end)
        {
            *it++ =
                ((uint)(*rSrcPtr++) << 16) |
                ((uint)(*gSrcPtr++) << 8) |
                ((uint)(*bSrcPtr++) << 0);
        }
    }
}