Comment passer un tableau d'octets par 12 bits

Hourra pour les pointeurs!

Ce code fonctionne en regardant vers l'avant 12 bits de chaque octet et la copie du bon de bits de l'avant. 12 bits est le fond de la moitié (nybble) de l'octet suivant et la moitié supérieure de 2 octets loin.

unsigned char length = 10;
unsigned char data[10] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0A,0xBC};
unsigned char *shift = data;
while (shift < data+(length-2)) {
    *shift = (*(shift+1)&0x0F)<<4 | (*(shift+2)&0xF0)>>4;
    shift++;
}
*(data+length-2) = (*(data+length-1)&0x0F)<<4;
*(data+length-1) = 0x00;

Justin a écrit:

@Mike, ta solution fonctionne, mais ne portent pas.

Bien, je dirais un quart de travail normal de l'opération n'est juste que (appelé dépassement de capacité), et laisse le supplément de bits de la droite ou vers la gauche. Il est assez simple à réaliser si vous voulaient simplement enregistrer l'12 bits avant de commencer à se déplacer. Peut-être que vous voulez une permutation circulaire, de mettre la débordé bits dos, au fond? Peut-être vous voulez realloc le tableau et le rendre plus gros? Retour le débordement de l'appelant? Retourner un booléen si elle est non nulle de données a été débordé? Vous devez définir ce que procéder pour vous.

unsigned char overflow[2];
*overflow = (*data&0xF0)>>4;
*(overflow+1) = (*data&0x0F)<<4 | (*(data+1)&0xF0)>>4;
while (shift < data+(length-2)) {
    /* normal shifting */
}  
/* now would be the time to copy it back if you want to carry it somewhere */
*(data+length-2) = (*(data+length-1)&0x0F)<<4 | (*(overflow)&0x0F);
*(data+length-1) = *(overflow+1);  

/* You could return a 16-bit carry int, 
 * but endian-ness makes that look weird 
 * if you care about the physical layout */
unsigned short carry = *(overflow+1)<<8 | *overflow;

OriginalL'auteur Mike Haboustak

Permet de faire le meilleur moyen de modifier N bits dans la gamme de 8 bits entiers.

N            - Total number of bits to shift
F = (N / 8) - Full 8 bit integers shifted
R = (N % 8) - Remaining bits that need to be shifted

Je pense partir d'ici, vous devez trouver la manière la plus optimale pour rendre l'utilisation de ces données pour se déplacer entiers dans un tableau. Algorithmes génériques serait d'appliquer l'ensemble des entiers changements en partant de la droite du tableau et le déplacement de chaque entier F index. Zéro remplissez le nouvellement espaces vides. Puis, enfin, effectuer une R de décalage de bits sur tous les indices, à partir de la droite.

Dans le cas de changement de 0xBC par R bits, vous pouvez calculer le dépassement en procédant de l'une ET au niveau du bit, et de le changer à l'aide de la bitshift opérateur:

//0xAB shifted 4 bits is:
(0xAB & 0x0F) >> 4   //is the overflow      (0x0A)
0xAB << 4            //is the shifted value (0xB0)

Gardez à l'esprit que les 4 bits de poids est juste un simple masque: 0x0F ou tout simplement 0b00001111. C'est facile à calculer, à construire, de façon dynamique, ou vous pouvez même utiliser un simple statique de la table de recherche.

J'espère que c'est assez générique. Je ne suis pas bon avec le C/C++ à tous alors peut-être que quelqu'un peut nettoyer ma syntaxe ou d'être plus précis.

Bonus: Si vous êtes astucieux avec votre C vous pourriez être en mesure de fudge plusieurs indices de tableau en une seule 16, 32 ou même 64 bits d'un entier et d'effectuer les changements. Mais c'est prabably pas très portable et je le recommande à cet égard. Juste une optimisation possible.

OriginalL'auteur Joseph Pecoraro

La version 32 bits... 🙂 Poignées 1 <= nombre <= num_words

#include <stdio.h>

unsigned int array[] = {0x12345678,0x9abcdef0,0x12345678,0x9abcdef0,0x66666666};

int main(void) {
  int count;
  unsigned int *from, *to;
  from = &array[0];
  to = &array[0];
  count = 5;

  while (count-- > 1) {
    *to++ = (*from<<12) | ((*++from>>20)&0xfff);
  };
  *to = (*from<<12);

  printf("%x\n", array[0]);
  printf("%x\n", array[1]);
  printf("%x\n", array[2]);
  printf("%x\n", array[3]);
  printf("%x\n", array[4]);

  return 0;
}

OriginalL'auteur DMC

Il y a un couple de pointe-des cas qui font de ce un pur problème:

• le tableau d'entrée peut être vide
• le dernier et avant-dernier de bits doivent être traités de manière particulière, parce qu'ils ont zéro des bits décalés dans leur

Voici une solution simple qui passe en boucle sur le tableau de copier le bas de grignoter de l'octet suivant dans son haut afin de grignoter, et le haut afin de grignoter de la next-next (+2) octet dans son bas de grignoter. Pour enregistrer un déréférencement le " look-ahead pointeur deux fois, elle entretient une à deux éléments de la mémoire tampon avec le "dernier" et "prochain" octets:

void shl12(uint8_t *v, size_t length) {
  if (length == 0) {
    return; //nothing to do
  }

  if (length > 1) {
    uint8_t last_byte, next_byte;
    next_byte = *(v + 1);

    for (size_t i = 0; i + 2 < length; i++, v++) {
      last_byte = next_byte;
      next_byte = *(v + 2);
      *v = ((last_byte & 0x0f) << 4) | (((next_byte) & 0xf0) >> 4);
    }

    //the next-to-last byte is half-empty
    *(v++) = (next_byte & 0x0f) << 4;
  }

  //the last byte is always empty
  *v = 0;
}

Pensez à la limite des cas, ce qui activer successivement plusieurs parties de la fonction:

• Quand length est égal à zéro, nous renflouer sans toucher à la mémoire.
• Quand length est l'un, nous avons fixé le seul et unique élément à zéro.
• Quand length est deux, nous avons mis le haut afin de grignoter du premier octet de poids faible de l'ordre de grignoter le deuxième octet (qui est, les bits 12 à 16), et le deuxième octet à zéro. Nous n'avons pas d'activer la boucle.
• Quand length est plus grand que deux, nous avons touché la boucle, brouiller les octets entre les deux éléments de la mémoire tampon.

Si l'efficacité est votre but, la réponse dépend probablement en grande partie sur votre machine de l'architecture. Habituellement, vous devez maintenir les deux éléments de la mémoire tampon, mais la poignée d'une machine word (32/64 bits entier non signé) à la fois. Si vous êtes à la vitesse d'un grand nombre de données, il sera peut être utile de traiter les premiers octets comme un cas particulier de sorte que vous pouvez obtenir votre machine word pointeurs mot-alignés. La plupart des Processeurs d'accès mémoire plus efficacement si l'accès de l'automne sur la machine, les limites des mots. Bien sûr, la fuite d'octets doivent être traitées spécialement trop afin de ne pas toucher à la mémoire passé la fin du tableau.

OriginalL'auteur Dominic Cooney