Convert Little Endian to Big Endian

Question

I just want to ask if my method is correct to convert from little endian to big endian  just to make sure if I understand the difference   I have a number which is stored in little-endian  here are the binary and hex representations of the number    0001 0010 0011 0100 0101 0110 0111 1000    12345678    In big-endian format I believe the bytes should be swapped  like this   1000 0111 0110 0101 0100 0011 0010 0001   87654321   Is this correct   Also  the code below attempts to do this but fails  Is there anything obviously wrong or can I optimize something  If the code is bad for this conversion can you please explain why and show a better method of performing the same conversion   uint32 t num   0x12345678  uint32 t b0 b1 b2 b3 b4 b5 b6 b7  uint32 t res   0   b0    num  amp  0xf   lt  lt  28  b1    num  amp  0xf0   lt  lt  24  b2    num  amp  0xf00   lt  lt  20  b3    num  amp  0xf000   lt  lt  16  b4    num  amp  0xf0000   lt  lt  12  b5    num  amp  0xf00000   lt  lt  8  b6    num  amp  0xf000000   lt  lt  4  b7    num  amp  0xf0000000   lt  lt  4   res   b0   b1   b2   b3   b4   b5   b6   b7   printf   d n   res

User · Answer

A Simple C program to convert from little to big   include  lt stdio h gt   int main     unsigned int little 0x1234ABCD big 0  unsigned char tmp 0 l   printf   Little endian little  x n  little    for l 0 l  lt  4 l           tmp 0      tmp   little   tmp      big   tmp    big  lt  lt  8       little   little  gt  gt  8    printf   Big endian big  x n  big    return 0

User · Answer

Below program produce the result as needed   include  lt stdio h gt    unsigned int Little To Big Endian unsigned int num     int main          int num   0x11223344            printf  quot  n Little Endian   0x X n quot  num            printf  quot  n Big Endian      0x X n quot  Little To Big Endian num          unsigned int Little To Big Endian unsigned int num        return    num  gt  gt  24   amp  0x000000ff      num  gt  gt  8   amp  0x0000ff00      num  lt  lt  8   amp  0x00ff0000      num  lt  lt  24   amp  0xff000000       And also below function can be used      unsigned int Little To Big Endian unsigned int num                return    num  amp  0x000000ff   lt  lt  24      num  amp  0x0000ff00   lt  lt  8       num  amp  0x00ff0000   gt  gt  8      num  amp  0xff000000   gt  gt  24

User · Answer

Below is an other approach that was useful for me  convertLittleEndianByteArrayToBigEndianByteArray  byte littlendianByte    byte bigEndianByte    int ArraySize       int i  0       for i  0 i lt ArraySize i           bigEndianByte i     littlendianByte ArraySize-i-1   lt  lt  7  amp  0x80     littlendianByte ArraySize-i-1   lt  lt  5  amp  0x40                                 littlendianByte ArraySize-i-1   lt  lt  3  amp  0x20     littlendianByte ArraySize-i-1   lt  lt  1  amp  0x10                                 littlendianByte ArraySize-i-1   gt  gt 1  amp  0x08     littlendianByte ArraySize-i-1   gt  gt  3  amp  0x04                                 littlendianByte ArraySize-i-1   gt  gt 5  amp  0x02     littlendianByte ArraySize-i-1   gt  gt  7  amp  0x01

User · Answer

I am assuming you are on linux  Include  byteswap h   amp  Use int32 t bswap 32 int32 t argument     It is logical view  In actual see   usr include byteswap h

User · Answer

One slightly different way of tackling this that can sometimes be useful is to have a union of the sixteen or thirty-two bit value and an array of chars  I ve just been doing this when getting serial messages that come in with big endian order  yet am working on a little endian micro    union MessageLengthUnion        uint16 t asInt      uint8 t asChars 2         Then when I get the messages in I put the first received uint8 in  asChars 1   the second in  asChars 0  then I access it as the  asInt part of the union in the rest of my program    If you have a thirty-two bit value to store you can have the array four long

User · Answer

one more suggestion    unsigned int a   0xABCDEF23  a     a amp  0x0000FFFF    lt  lt  16      a amp  0xFFFF0000    gt  gt  16   a     a amp  0x00FF00FF    lt  lt  8      a amp  0xFF00FF00    gt  gt 8   printf   0x n  a

User · Answer

I swap each bytes right   -  yes  to convert between little and big endian  you just give the bytes the opposite order  But at first realize few things    size of uint32 t is 32bits  which is 4 bytes  which is 8 HEX digits mask 0xf retrieves the 4 least significant bits  to retrieve 8 bits  you need 0xff   so in case you want to swap the order of 4 bytes with that kind of masks  you could   uint32 t res   0  b0    num  amp  0xff   lt  lt  24           least significant to most significant b1    num  amp  0xff00   lt  lt  8          2nd least sig  to 2nd most sig  b2    num  amp  0xff0000   gt  gt  8        2nd most sig  to 2nd least sig  b3    num  amp  0xff000000   gt  gt  24     most sig  to least sig  res   b0   b1   b2   b3

User · Answer

You could do this   int x   0x12345678   x     x  gt  gt  24        x  lt  lt  8   amp  0x00ff0000      x  gt  gt  8   amp  0x0000ff00      x  lt  lt  24       printf  value    x   x       x will be printed as 0x78563412

User · Answer

Sorry  my answer is a bit too late  but it seems nobody mentioned built-in functions to reverse byte order  which in very important in terms of performance   Most of the modern processors are little-endian  while all network protocols are big-endian  That is history and more on that you can find on Wikipedia  But that means our processors convert between little- and big-endian millions of times while we browse the Internet   That is why most architectures have a dedicated processor instructions to facilitate this task  For x86 architectures there is BSWAP instruction  and for ARMs there is REV  This is the most efficient way to reverse byte order   To avoid assembly in our C code  we can use built-ins instead  For GCC there is   builtin bswap32   function and for Visual C   there is  byteswap ulong    Those function will generate just one processor instruction on most architectures   Here is an example    include  lt stdio h gt   include  lt inttypes h gt   int main         uint32 t le   0x12345678      uint32 t be     builtin bswap32 le        printf  Little-endian  0x   PRIx32   n   le       printf  Big-endian     0x   PRIx32   n   be        return 0      Here is the output it produces   Little-endian  0x12345678 Big-endian     0x78563412   And here is the disassembly  without optimization  i e  -O0            uint32 t be     builtin bswap32 le      0x0000000000400535  lt  15 gt      mov    -0x8  rbp   eax    0x0000000000400538  lt  18 gt      bswap   eax    0x000000000040053a  lt  20 gt      mov     eax -0x4  rbp    There is just one BSWAP instruction indeed   So  if we do care about the performance  we should use those built-in functions instead of any other method of byte reversing  Just my 2 cents

User · Answer

I think you can use function htonl    Network byte order is big endian

User · Answer

OP s sample code is incorrect   Endian conversion works at the bit and 8-bit byte level   Most endian issues deal with the byte level   OP code is doing a endian change at the 4-bit nibble level   Recommend instead      Swap endian  big to little  or  little to big  uint32 t num   9  uint32 t b0 b1 b2 b3  uint32 t res   b0    num  amp  0x000000ff   lt  lt  24u  b1    num  amp  0x0000ff00   lt  lt  8u  b2    num  amp  0x00ff0000   gt  gt  8u  b3    num  amp  0xff000000   gt  gt  24u   res   b0   b1   b2   b3   printf     PRIX32   n   res     If performance is truly important  the particular processor would need to be known   Otherwise  leave it to the compiler    Edit  OP added a comment that changes things   32bit numerical value represented by the hexadecimal representation  st uv wx yz  shall be recorded in a four-byte field as  st uv wx yz     It appears in this case  the endian of the 32-bit number is unknown and the result needs to be store in memory in little endian order   uint32 t num   9  uint8 t b 4   b 0     uint8 t   num  gt  gt   0u   b 1     uint8 t   num  gt  gt   8u   b 2     uint8 t   num  gt  gt  16u   b 3     uint8 t   num  gt  gt  24u        2016 Edit  Simplification         The type of the result is that of the promoted left operand      Bitwise shift operators C11   6 5 7 3    Using a u after the shift constants  right operands  results in the same as without it   b3    num  amp  0xff000000   gt  gt  24u  b 3     uint8 t   num  gt  gt  24u      same as  b3    num  amp  0xff000000   gt  gt  24  b 3     uint8 t   num  gt  gt  24

User · Answer

You can use the lib functions   They boil down to assembly  but if you are open to alternate implementations in C  here they are  assuming int is 32-bits     void byte swap16 unsigned short int  pVal16        define method one 1     define method two 1  define method three 1  ifdef method one     unsigned char  pByte       pByte    unsigned char    pVal16       pVal16    pByte 0   lt  lt  8    pByte 1    endif   ifdef method two     unsigned char  pByte0      unsigned char  pByte1       pByte0    unsigned char    pVal16      pByte1   pByte0   1       pByte0    pByte0    pByte1       pByte1    pByte0    pByte1       pByte0    pByte0    pByte1   endif   ifdef method three     unsigned char  pByte       pByte    unsigned char    pVal16      pByte 0    pByte 0    pByte 1       pByte 1    pByte 0    pByte 1       pByte 0    pByte 0    pByte 1    endif        void byte swap32 unsigned int  pVal32      ifdef method one     unsigned char  pByte          0x1234 5678 -- gt  0x7856 3412       pByte    unsigned char    pVal32       pVal32     pByte 0   lt  lt  24      pByte 1   lt  lt  16     pByte 2   lt  lt  8      pByte 3      endif   if defined method two     defined  method three      unsigned char  pByte       pByte    unsigned char    pVal32         move lsb to msb     pByte 0    pByte 0    pByte 3       pByte 3    pByte 0    pByte 3       pByte 0    pByte 0    pByte 3          move lsb to msb     pByte 1    pByte 1    pByte 2       pByte 2    pByte 1    pByte 2       pByte 1    pByte 1    pByte 2    endif     And the usage is performed like so   unsigned short int u16Val   0x1234  byte swap16  amp u16Val   unsigned int u32Val   0x12345678  byte swap32  amp u32Val

User · Answer

OP s code is incorrect for the following reasons   The swaps are being performed on a nibble  4-bit  boundary  instead of a byte  8-bit  boundary  The shift-left  lt  lt  operations of the final four swaps are incorrect  they should be shift-right  gt  gt  operations and their shift values would also need to be corrected  The use of intermediary storage is unnecessary  and the code can therefore be rewritten to be more concise recognizable  In doing so  some compilers will be able to better-optimize the code by recognizing the oft-used pattern   Consider the following code  which efficiently converts an unsigned value     Swap endian  big to little  or  little to big  uint32 t num   0x12345678  uint32 t res         num  amp  0x000000FF   lt  lt  24          num  amp  0x0000FF00   lt  lt  8          num  amp  0x00FF0000   gt  gt  8          num  amp  0xFF000000   gt  gt  24    printf  quot  0x n quot   res    The result is represented here in both binary and hex  notice how the bytes have swapped   0111 1000 0101 0110 0011 0100 0001 0010   78563412  Optimizing In terms of performance  leave it to the compiler to optimize your code when possible  You should avoid unnecessary data structures like arrays for simple algorithms like this  doing so will usually cause different instruction behavior such as accessing RAM instead of using CPU registers

[c] Convert Little Endian to Big Endian

Examples related to c

Examples related to endianness