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