C++ types de données primitives: lire non signé 30 bits

Question

je un réseau de unsigned chars. Fondamentalement, j'ai un tableau de bits.

je sais que les 16 premiers bits correspond à un entier non signé et je récupérer sa valeur en utilisant (u16)(*(buffer+ 1) << 8 | *abcBuffer)

Puis vient un type de données appelé u30 qui est décrit comme suit: . La variable codage pour u30 utilise un à cinq octets, en fonction de l'amplitude de la valeur codée. Chaque octet attribue ses sept bits inférieurs à la valeur. Si le huitième octet d'un octet est défini, l'octet suivant fait également partie de la valeur.

Je ne comprends pas cette description: il est dit u30 (trente ans!) Et il dit 1 à 5 octets? J'ai aussi un autre type de données appelé s24 - three-byte signed integer value.

Comment doit-on lire (récupérer leurs valeurs) ces types de données non typiques? Toute aide serait appréciée.

Merci beaucoup!

Answer 1

En supposant que je comprends bien (toujours une question discutable), ce qui suit lire les valeurs. Il commence à la position zéro dans cet exemple (i devrait être compensée par la position réelle dans la mémoire tampon):

unsigned int val; 
    unsigned char buf[300]; 
    int i; 
    int shift; 

    i = 0; 

    buf[0] = 0x81; 
    buf[1] = 0x3; 
    val = 0; 
    shift = 0; 
    do 
     { 
     val |= (0x7F & buf[i]) << shift; 
     shift += 7; 
     i++; 
     } while ((buf[i-1] & 0x80) && (i < 5)); 
    printf("Val = %u\n", val); 

Answer 2

La description du format de codage est un peu peut-être informelle, mais devrait être suffisant. L'idée sera que vous lisez un octet (appelez-le x), vous prenez les 7 bits les plus bas x & 0x7F et en même temps vérifiez si c'est le bit le plus élevé est mis. Vous aurez besoin d'écrire une petite boucle qui fusionne les séquences de 7 bits dans une variable uint jusqu'à ce que l'octet actuel n'ait plus son bit le plus élevé.

Vous devrez déterminer si vous avez besoin de fusionner les nouveaux bits à l'extrémité supérieure ou à l'extrémité inférieure du nombre (a = (a << 7) | (x & 0x7F)). Pour cela, vous avez besoin d'une séquence de test dont vous connaissez la sortie correcte.

Answer 3

i=0;  
val = buf[i]&0x7F; 
while (buf[i++]&0x80) 
{ 
    val |= (buf[i]&0x7F)<<(i*7); 
} 

Answer 4

Pour lire la longueur variable 30 valeur binaire, vous pouvez faire quelque chose comme par exemple:

const char HIGH_BIT = 0x80; 
const char DATA_MASK = 0x7F; 
const char LAST_MASK = 0x03; // only need 2 bits of last byte 
char tmpValue = 0; // tmp holder for value of byte; 
int value = 0; holder for the actual value; 
char* ptr = buffer; // assume buffer is at the start of the 30 bit number 
for(int i = 0; i < 5; i++) 
{ 
    if(i == 4) 
    { 
     tmpValue = LAST_MASK & *ptr; 
    } 
    else 
    { 
     tmpValue = DATA_MASK & *ptr; 
    } 

    value |= tmpValue << (7 * i); 

    if(!(HIGH_BIT & *ptr)) 
    { 
     break; 
    } 
    if(i != 4) 
    { 
    ++ptr; 
    } 
} 
buff = ptr; // advance the buffer afterwards. 

@ Mark: votre réponse a été publiée alors que je tapais cela, et travaillerait à l'exception du haut octet. la valeur est seulement de 30 bits, donc seulement les 2 premiers bits de l'octet haut sont utilisés pour la valeur et vous utilisez les 8 bits entiers de la valeur.