uint32_t color = 0xFFFF00AA;

uint8_t a = (color >> 24) & 0xFF;
uint8_t b = (color >> 16) & 0xFF;
uint8_t g = (color >> 8) & 0xFF;
uint8_t r = (color >> 0) & 0xFF;

uint32_t p_color = (a << 24) + (r << 16) + (g << 8) + (b << 0);

(x&0xFF00FF00)|((x&0x00FF0000)>>16)|((x&0x000000FF)<<16)

IRO>для x84 и для ARM и вообще для мобильных и тд

constexpr uint32_t rgba_to_bgra(uint32_t rgba)
{
  return (rgba & 0x00FF00FF) | (rgba & 0xFF000000 >> 16) | (rgba & 0x0000FF00 << 16);
}

IRO>uint8_t a = (color >> 24) & 0xFF;
IRO>uint8_t b = (color >> 16) & 0xFF;
IRO>uint8_t g = (color >> 8) & 0xFF;
IRO>uint8_t r = (color >> 0) & 0xFF;
IRO>uint32_t p_color = (a << 24) + (r << 16) + (g << 8) + (b << 0);
IRO>

#define ___constant_swab32(x) ((__u32)(                         \
        (((__u32)(x) & (__u32)0x000000ffUL) << 24) |            \
        (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) |            \
        (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
        (((__u32)(x) & (__u32)0xff000000UL) >> 24)))

IRO>для x84 и для ARM и вообще для мобильных и тд

(x&0xFF00FF00)|((x&0x00FF0000)>>16)|((x&0x000000FF)<<16)

Generalized Bit Reversal

[GLS1] suggests that the following sort of generalization of bit reversal, which he calls "flip," is a good candidate to consider for a computer's instruction set:

if (k & 1) x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1;
if (k & 2) x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2;
if (k & 4) x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4;
if (k & 8) x = (x & 0x00FF00FF) << 8 | (x & 0xFF00FF00) >> 8;
if (k & 16) x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;
(The last two and operations can be omitted.) For k = 31, this operation reverses the bits in a word. For k = 24, it reverses the bytes in a word. For k = 7, it reverses the bits in each byte, without changing the positions of the bytes. For k = 16, it swaps the left and right halfwords of a word, and so on. In general, it moves the bit at position m to position m xor k. It can be implemented in hardware very similarly to the way a rotate shifter is usually implemented (five stages of MUX's, with each stage controlled by a bit of the shift amount k).

IRO>>uint32_t color = 0xFFFF00AA;
IRO>>

IRO>>>uint32_t color = 0xFFFF00AA;
IRO>>>

MD>>Всё уже придумано до нас, с учётом endianness и прочее. Взять в интернете/Линуксе/etc реализацию htonl/ntohl, убрать лишние байт-манипуляции Получаете свой макрос (или функцию, смотрите что удобнее).

inline uint32_t color_swap4(uint32_t color)
{
    return ((color & 0xFF)  << 16) | ((color >> 16) & 0xFF) | (color & 0xFF00FF00);
}

00401057 8B 44 8C 40      mov         eax,dword ptr [esp+ecx*4+40h] 
0040105B 0F B6 D0         movzx       edx,al 
0040105E 8B E8            mov         ebp,eax 
00401060 C1 ED 10         shr         ebp,10h 
00401063 C1 E2 10         shl         edx,10h 
00401066 81 E5 FF 00 00 00 and         ebp,0FFh 
0040106C 0B D5            or          edx,ebp 
0040106E 25 00 FF 00 FF   and         eax,0FF00FF00h 
00401073 0B D0            or          edx,eax

union color_t1
{
//    color_t(uint32_t v): v4(v)
    uint32_t v4;
    struct
    {
        uint32_t v1_1:8;
        uint32_t v1_2:8;
        uint32_t v1_3:8;
        uint32_t v1_4:8;
    };
};
inline uint32_t color_swap3(uint32_t color)
{
    uint8_t tmp = ((color_t1 &)color).v1_1;
    ((color_t1 &)color).v1_1 = ((color_t1 &)color).v1_3;
    ((color_t1 &)color).v1_3 = tmp;
    return color;
}


00401057 8B 44 8C 40      mov         eax,dword ptr [esp+ecx*4+40h] 
0040105B 8B D0            mov         edx,eax 
0040105D C1 EA 10         shr         edx,10h 
00401060 0F B6 E8         movzx       ebp,al 
00401063 81 E2 FF 00 00 00 and         edx,0FFh 
00401069 C1 E5 10         shl         ebp,10h 
0040106C 0B D5            or          edx,ebp 
0040106E 25 00 FF 00 FF   and         eax,0FF00FF00h 
00401073 0B D0            or          edx,eax