# Tutorial :convert big endian to little endian in C [without using provided func] [closed]

### Question:

I need to write a function to convert big endian to little endian in C. I can not use any library function.

### Solution:1

Assuming what you need is a simple byte swap, try something like

Unsigned 16 bit conversion:

``swapped = (num>>8) | (num<<8);``

Unsigned 32-bit conversion:

``swapped = ((num>>24)&0xff) | // move byte 3 to byte 0                      ((num<<8)&0xff0000) | // move byte 1 to byte 2                      ((num>>8)&0xff00) | // move byte 2 to byte 1                      ((num<<24)&0xff000000); // byte 0 to byte 3``

This swaps the byte orders from positions 1234 to 4321. If your input was `0xdeadbeef`, a 32-bit endian swap might have output of `0xefbeadde`.

The code above should be cleaned up with macros or at least constants instead of magic numbers, but hopefully it helps as is

EDIT: as another answer pointed out, there are platform, OS, and instruction set specific alternatives which can be MUCH faster than the above. In the Linux kernel there are macros (cpu_to_be32 for example) which handle endianness pretty nicely. But these alternatives are specific to their environments. In practice endianness is best dealt with using a blend of available approaches

### Solution:2

By including:

``#include <byteswap.h>  ``

you can get an optimized version of machine-dependent byte-swapping functions. Then, you can easily use the following functions:

``__bswap_32 (uint32_t input)  ``

or

``__bswap_16 (uint16_t input)  ``

### Solution:3

``#include <stdint.h>      //! Byte swap unsigned short  uint16_t swap_uint16( uint16_t val )   {      return (val << 8) | (val >> 8 );  }    //! Byte swap short  int16_t swap_int16( int16_t val )   {      return (val << 8) | ((val >> 8) & 0xFF);  }    //! Byte swap unsigned int  uint32_t swap_uint32( uint32_t val )  {      val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF );       return (val << 16) | (val >> 16);  }    //! Byte swap int  int32_t swap_int32( int32_t val )  {      val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF );       return (val << 16) | ((val >> 16) & 0xFFFF);  }  ``

Update : Added 64bit byte swapping

``int64_t swap_int64( int64_t val )  {      val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );      val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );      return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);  }    uint64_t swap_uint64( uint64_t val )  {      val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );      val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );      return (val << 32) | (val >> 32);  }  ``

### Solution:4

Here's a fairly generic version; I haven't compiled it, so there are probably typos, but you should get the idea,

``void SwapBytes(void *pv, size_t n)  {      assert(n > 0);        char *p = pv;      size_t lo, hi;      for(lo=0, hi=n-1; hi>lo; lo++, hi--)      {          char tmp=p[lo];          p[lo] = p[hi];          p[hi] = tmp;      }  }  #define SWAP(x) SwapBytes(&x, sizeof(x));  ``

NB: This is not optimised for speed or space. It is intended to be clear (easy to debug) and portable.

Update 2018-04-04 Added the assert() to trap the invalid case of n == 0, as spotted by commenter @chux.

### Solution:5

If you need macros (e.g. embedded system):

``#define SWAP_UINT16(x) (((x) >> 8) | ((x) << 8))  #define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))  ``

### Solution:6

Edit: These are library functions. Following them is the manual way to do it.

I am absolutely stunned by the number of people unaware of __byteswap_ushort, __byteswap_ulong, and __byteswap_uint64. Sure they are Visual C++ specific, but they compile down to some delicious code on x86/IA-64 architectures. :)

Here's an explicit usage of the `bswap` instruction, pulled from this page. Note that the intrinsic form above will always be faster than this, I only added it to give an answer without a library routine.

``uint32 cq_ntohl(uint32 a) {      __asm{          mov eax, a;          bswap eax;       }  }  ``

### Solution:7

As a joke:

``  #include <stdio.h>    int main (int argc, char *argv[])  {      size_t sizeofInt = sizeof (int);      int i;        union      {          int x;          char c[sizeof (int)];      } original, swapped;        original.x = 0x12345678;        for (i = 0; i < sizeofInt; i++)          swapped.c[sizeofInt - i - 1] = original.c[i];        fprintf (stderr, "%x\n", swapped.x);        return 0;  }  ``

### Solution:8

Will this work / be faster?

`` uint32_t swapped, result;    ((byte*)&swapped)[0] = ((byte*)&result)[3];  ((byte*)&swapped)[1] = ((byte*)&result)[2];  ((byte*)&swapped)[2] = ((byte*)&result)[1];  ((byte*)&swapped)[3] = ((byte*)&result)[0];  ``

### Solution:9

here's a way using the SSSE3 instruction pshufb using its Intel intrinsic, assuming you have a multiple of 4 `int`s:

``unsigned int *bswap(unsigned int *destination, unsigned int *source, int length) {      int i;      __m128i mask = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3);      for (i = 0; i < length; i += 4) {          _mm_storeu_si128((__m128i *)&destination[i],          _mm_shuffle_epi8(_mm_loadu_si128((__m128i *)&source[i]), mask));      }      return destination;  }  ``

### Solution:10

Here's a function I have been using - tested and works on any basic data type:

``//  SwapBytes.h  //  //  Function to perform in-place endian conversion of basic types  //  //  Usage:  //  //    double d;  //    SwapBytes(&d, sizeof(d));  //    inline void SwapBytes(void *source, int size)  {      typedef unsigned char TwoBytes[2];      typedef unsigned char FourBytes[4];      typedef unsigned char EightBytes[8];        unsigned char temp;        if(size == 2)      {          TwoBytes *src = (TwoBytes *)source;          temp = (*src)[0];          (*src)[0] = (*src)[1];          (*src)[1] = temp;            return;      }        if(size == 4)      {          FourBytes *src = (FourBytes *)source;          temp = (*src)[0];          (*src)[0] = (*src)[3];          (*src)[3] = temp;            temp = (*src)[1];          (*src)[1] = (*src)[2];          (*src)[2] = temp;            return;      }        if(size == 8)      {          EightBytes *src = (EightBytes *)source;          temp = (*src)[0];          (*src)[0] = (*src)[7];          (*src)[7] = temp;            temp = (*src)[1];          (*src)[1] = (*src)[6];          (*src)[6] = temp;            temp = (*src)[2];          (*src)[2] = (*src)[5];          (*src)[5] = temp;            temp = (*src)[3];          (*src)[3] = (*src)[4];          (*src)[4] = temp;            return;      }    }  ``

### Solution:11

EDIT: This function only swaps the endianness of aligned 16 bit words. A function often necessary for UTF-16/UCS-2 encodings. EDIT END.

If you want to change the endianess of a memory block you can use my blazingly fast approach. Your memory array should have a size that is a multiple of 8.

``#include <stddef.h>  #include <limits.h>  #include <stdint.h>    void ChangeMemEndianness(uint64_t *mem, size_t size)   {  uint64_t m1 = 0xFF00FF00FF00FF00ULL, m2 = m1 >> CHAR_BIT;    size = (size + (sizeof (uint64_t) - 1)) / sizeof (uint64_t);  for(; size; size--, mem++)    *mem = ((*mem & m1) >> CHAR_BIT) | ((*mem & m2) << CHAR_BIT);  }  ``

This kind of function is useful for changing the endianess of Unicode UCS-2/UTF-16 files.

### Solution:12

This code snippet can convert 32bit little Endian number to Big Endian number.

``#include <stdio.h>  main(){          unsigned int i = 0xfafbfcfd;      unsigned int j;          j= ((i&0xff000000)>>24)| ((i&0xff0000)>>8) | ((i&0xff00)<<8) | ((i&0xff)<<24);          printf("unsigned int j = %x\n ", j);      }  ``

### Solution:13

If you are running on a x86 or x86_64 processor, the big endian is native. so

for 16 bit values

``unsigned short wBigE = value;  unsigned short wLittleE = ((wBigE & 0xFF) << 8) | (wBigE >> 8);  ``

for 32 bit values

``unsigned int   iBigE = value;  unsigned int   iLittleE = ((iBigE & 0xFF) << 24)                          | ((iBigE & 0xFF00) << 8)                          | ((iBigE >> 8) & 0xFF00)                          | (iBigE >> 24);  ``

This isn't the most efficient solution unless the compiler recognises that this is byte level manipulation and generates byte swapping code. But it doesn't depend on any memory layout tricks and can be turned into a macro pretty easily.

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »