C#

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
}

for ( int col = 0; col < w; col += 2 ) {
 *imgPtr++ = *b++;
  *imgPtr++ = *g++;
  *imgPtr++ = *r++;
  *imgPtr++ = *b++;
  *imgPtr++ = *g++;
  *imgPtr++ = *r++;
}