Discussion :

[Cheepy]

Bonjour,
J'ai codé un encodeur Base64 mais pour coder le décodeur je cale devant un problème :s
A un moment je dois récupérer 4 groupes de 6 bits passés dans 3 octets pour l'encodeur comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
            ind1 = (octet1 & 0xFC) >> 2 ;
            ind2 = ((octet1 & 0x03) << 4) + ((octet2 & 0xF0) >> 4);
            ind3 = ((octet2 & 0x0F) << 2) + ((octet3 & 0xC0) >> 6);
            ind4 = octet3 & 0x3F ;

Mais pour le décodeur je dois passer 3 octets dans 4 groupes de 6 bits soit trouver non pas les "indx" mais les "octetx" et visiblement ça ne fonctionne pas pas comme des équations mathématiques :s

En espérant que vous saurez m'aider,
Merci d'avance.

[Cheepy]

Bon finalement je pense avoir trouvé la réponse après avoir gratté plus de deux heures sur papier.
Je donne ma réponse au cas où ça en intéresserait certains même si je ne suis pas vraiment sûr de ce que j'ai fait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
            octet1 = (ind1 & 0x3F) + ((ind2 & 0x30) << 2) ;
            octet2 = ((ind2 & 0x0F) >> 4) + ((ind3 & 0x3C) << 4) ;
            octet3 = ((ind3 & 0x03) >> 2) + (ind4 & 0x3F) ;

[jo_link_noir]

Fais plus de test, j'ai l'impression que l'encodage et le décodage ne sont pas symétrique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <array>
 
std::array<unsigned, 4> encode(std::array<unsigned, 3> const & octets)
{
    return {
        (octets[0] & 0xFC) >> 2,
        ((octets[0] & 0x03) << 4) + ((octets[1] & 0xF0) >> 4),
        ((octets[1] & 0x0F) << 2) + ((octets[2] & 0xC0) >> 6),
        octets[2] & 0x3F
    };
}
 
std::array<unsigned, 3> decode(std::array<unsigned, 4> const & indexes)
{
    return {
        ((indexes[0] << 2) & 0xFC) + ((indexes[1] >> 4) & 0x03),
        ((indexes[1] << 4) & 0xF0) + ((indexes[2] >> 2) & 0x0F),
        ((indexes[2] << 6) & 0xC0) + (indexes[3] & 0x3F)
    };
}
 
int main() {
    for (unsigned i1 = 0; i1 < 0b111111; ++i1) {
        for (unsigned i2 = 0; i2 < 0b111111; ++i2) {
            for (unsigned i3 = 0; i3 < 0b111111; ++i3) {
                std::array<unsigned, 3> const arr{{i1,i2,i3}};
                if (arr != decode(encode(arr))) {
                    std::cerr << "noop\n";
                    return 1;
                }
            }
        }
    }
    std::cout << "ok\n";
    return 0;
}

Tu remarqueras que les opérations sont les même mais en inversés (x & m) << d devient (x >> d) & m.

[Cheepy]

Tout d'abord merci de ta réponse mais en fait je ne pense pas que ce soit symétrique, voilà comment j'ai résonné sur papier :

[jo_link_noir]

Bah si, un encodeur et symétrique à son décodeur.

Sur ton image il y a les bonnes valeurs, mais dans ton code les décalages son mauvais.

[Bousk]

Salut,

c'est on ne peut plus mathématique et symétrique, qu'est-ce qui pourrait te faire penser le contraire ?!
A priori, j'ai pas vérifié en détail, le code de jo est bon. En tous cas l'idée y est

[yann.falevoz]

Bonjour,

Est ce que ce ne serait pas beaucoup plus simple d'utiliser une structure avec des champs de bits?

Cordialement
Yann

[Iradrille]

Est ce que ce ne serait pas beaucoup plus simple d'utiliser une structure avec des champs de bits?

Quelques chose de ce genre ? (Qui ne marche absolument pas )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct foo {
	union {
		// 1 byte de perdu, mais ya pas de multiple de 6, 8 et
		// d'une puissance de 2 assez petite pour que le type existe
		struct {
			uint8_t byte1;
			uint8_t byte2;
			uint8_t byte3;
		};
		struct {
			uint32_t ind1 : 6;
			uint32_t ind2 : 6;
			uint32_t ind3 : 6;
			uint32_t ind4 : 6;
		};
	};
};

C'est une idée intéressante en tout cas de laisser le compilo se démerder avec les masks et shifts.

[yann.falevoz]

Je pensais tout simplement à quelque chose de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
typedef struct
{
     uint32_t ind1 : 6;
     uint32_t ind2 : 6;
     uint32_t ind3 : 6;
     uint32_t ind4 : 6;
}Groupe4Ind;

Si on a besoin d'accéder aux octets, un char* devrait permettre de le faire.

Par contre, si seulement 3 octets sont utilisés, 4 sont alloués en mémoire. Cela ne répond donc peut être pas au besoin.

Cordialement
Yann

[Médinoc]

À ma connaissance, les champs de bits ne servent en pratique à rien de portable car leur agencement n'est pas normalisé.