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

   int work;
   
begin loop
   int tempRed = *_r++;   // you might also try int& tempRed = *_r++;
   //ditto for other colors
   // I am pretty sure that dotNet has strict endian rules, so this should be safe.
   *imgPtr++ = alpha | ((tempRed & 0x000000FF) << 16) | ((tempGreen & 0x000000FF) << 8)  | ((tempBlue & 0x000000FF));
   *imgPtr++ = alpha | ((tempRed & 0x0000FF00) << 8)  | ((tempGreen & 0x0000FF00))       | ((tempBlue & 0x0000FF00) >> 8);
   *imgPtr++ = alpha | ((tempRed & 0x00FF0000) )      | ((tempGreen & 0x00FF0000) >> 8)  | ((tempBlue & 0xFF0000) >> 16);
   *imgPtr++ = alpha | ((tempRed & 0xFF000000) >> 8)  | ((tempGreen & 0xFF000000) >> 16) | ((tempBlue & 0xFF000000) >> 24);
end loop

You will need some after-loop checks that perform the same logic for stragglers. (modulus 4 or 8).
switch(leftover_modulus) {
   case 3:
      *imgPtr++ = alpha | ((tempRed & 0x00FF0000) ) | ((tempGreen & 0xFF0000) >> 8) | ((tempBlue & 0xFF0000) >> 16);
      // fall thru
   case 2:
      ...
      // fall thru
   case 1:
      ...
      break;
   default:
      // nothing to do if 0 since it would have been handled in the loop
}