convertir big endian en little endian en C [sans utiliser les fonctions fournies].

Question

J'ai besoin d'écrire une fonction pour convertir big endian en little endian en C. Je ne peux pas utiliser de fonction de bibliothèque.

Answer 1

En supposant que ce dont vous avez besoin est un simple échange d'octets, essayez quelque chose comme

Conversion 16 bits non signée :

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

Conversion de 32 bits non signés :

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

Cela permute les ordres d'octets des positions 1234 à 4321. Si votre entrée était 0xdeadbeef un swap 32 bits endian pourrait avoir une sortie de 0xefbeadde .

Le code ci-dessus devrait être nettoyé avec des macros ou au moins des constantes à la place des nombres magiques, mais j'espère qu'il sera utile tel quel.

EDIT : comme l'a souligné une autre réponse, il existe des alternatives spécifiques à la plate-forme, au système d'exploitation et au jeu d'instructions qui peuvent être BEAUCOUP plus rapides que les solutions ci-dessus. Dans le noyau Linux, il y a des macros (cpu_to_be32 par exemple) qui gèrent très bien l'endiannité. Mais ces alternatives sont spécifiques à leurs environnements. En pratique, la meilleure façon de gérer l'endiveté est d'utiliser un mélange des approches disponibles.

Answer 2

En incluant :

#include <byteswap.h>

vous pouvez obtenir une version optimisée des fonctions d'échange d'octets dépendantes de la machine. Ensuite, vous pouvez facilement utiliser les fonctions suivantes :

__bswap_32 (uint32_t input)

ou

__bswap_16 (uint16_t input)

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

Mise à jour : Ajout de l'échange d'octets en 64 bits

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

Answer 4

Si vous avez besoin de macros (par exemple, système embarqué) :

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

Answer 5

Pour tous vos besoins de manipulation de bits
http://graphics.stanford.edu/~seander/bithacks.html