Discussion :

[flyingfr]

Bonjour,

J'ai un fichier binaire constitué d'un header de 11 octets suivi d'un bloc de donnéees compressé en gz qui fait une centaine de Ko
Je veux charger le fichier, separer l'entete et decompresser le buffer de valeurs qui sont encodées sur un octet signé.
Je dois recuperer une suite de int de 730 par 730 valeurs

Etant debutant en C++ , pour l'instant je fais la chose suivante en m'inspirant de divers exemples :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
#include <iostream>
#include <string>
#include <fstream>
#include <zlib.h>
#include <vector>
 
using std::ios;
using std::cout;
using std::endl;
using std::string;
using std::ifstream;
using namespace std;
 
int main()
{
 
    std::string  filein= "Divers/modeles/1_-2_47.deg";
    std::string  fileout="Divers/modeles/1_-2_47out.deg";
    ifstream fluxentree(filein.c_str(),ios::in | ios::binary);
    ofstream fluxsortie(fileout.c_str(),ios::out | ios::binary);
 
    const int N=11 ;                                          //nombre d'octets à supprimer en-tête
    if (fluxentree.fail()) { cout << "erreur fichier "<<endl; return 1;}
    fluxentree.seekg(N+1, ios::beg);                          //décalage du pointeur de lecture
    fluxsortie << fluxentree.rdbuf();                        //ici la ligne de copie vers la sortie rdbuf retourne un pointeur 
 
 
 
    gzFile inFileZ = gzopen(fileout.c_str(), "rb");
    if (inFileZ == NULL) { cout<<" Erreur";printf("Error: Failed to gzopen %s\n", fileout.c_str()); exit(0);}
    else{ cout<<" Fichier ouvert \n";}
   unsigned char unzipBuffer[8192];
   unsigned int unzippedBytes;
   std::vector<int> unzippedData;
   while (true) {
        unzippedBytes = gzread(inFileZ, unzipBuffer, 8192);
        if (unzippedBytes > 0) {
            unzippedData.insert(unzippedData.end(), unzipBuffer, unzipBuffer + unzippedBytes);
        } else {
            break;
        }
    }
 
 
   gzclose(inFileZ);
cout<<"\n Resultat \n";
for (auto const valeur : unzippedData)
    {std::cout << valeur << " ";   }
 
return 0;
}

J'ai plusieurs problèmes.
D'abord je passe par un fichier intermediaire fileout , ce qui n'est pas tres utile mais je n'arrive pas a utiliser correctement le Buffer, je pense que la solution est très simple mais je suis trop debutant !
Meme si j'arrive à compiler , la decompression ne marche visiblement pas, j'obtiens la meme sortie que pour le fichier compressé.

Merci de votre aide

[flyingfr]

Rebonjour,
Je me suis essayé à demander la réponse à Chat GPT (C'est la première fois que j'essayais ChatGPT) .

Après 2 3 essais, La réponse fournie fonctionne et me convient parfaitement , Le resultat est etonnant

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <iostream>
#include <fstream>
#include <zlib.h>
#include <vector>
 
int main() {
    //std::string filename = "nom_du_fichier.bin";
    std::string  filename= "Divers/modeles/1_2_47.deg";
    // Ouverture du fichier en mode binaire
    std::ifstream infile(filename, std::ios::binary);
 
    if (!infile) {
        std::cerr << "Erreur: impossible d'ouvrir le fichier " << filename << std::endl;
        return 1;
    }
 
    // Lecture de l'entête
    char header[11];
    infile.read(header, 11);
 
    // Lecture du bloc de données
    std::vector<char> gzbuf((std::istreambuf_iterator<char>(infile)), std::istreambuf_iterator<char>());
 
    // Décompression du bloc de données
    std::vector<int8_t> databuf(730 * 730);
    z_stream zs;
    zs.zalloc = Z_NULL;
    zs.zfree = Z_NULL;
    zs.opaque = Z_NULL;
    zs.avail_in = gzbuf.size();
    zs.next_in = (Bytef*) gzbuf.data();
    zs.avail_out = databuf.size() * sizeof(int8_t);
    zs.next_out = (Bytef*) databuf.data();
 
    if (inflateInit2(&zs, -MAX_WBITS) != Z_OK) {
        std::cerr << "Erreur: impossible d'initialiser la décompression." << std::endl;
        return 1;
    }
 
    int ret = inflate(&zs, Z_FINISH);
    if (ret != Z_STREAM_END) {
        std::cerr << "Erreur: impossible de décompresser les données." << std::endl;
        inflateEnd(&zs);
        return 1;
    }
 
    inflateEnd(&zs);
 
    // Conversion des données en une matrice de 730 par 730 entiers
    std::vector<std::vector<int>> matrix(730, std::vector<int>(730));
    for (int i = 0; i < 730; i++) {
        for (int j = 0; j < 730; j++) {
            int idx = i * 730 + j;
            matrix[i][j] = static_cast<int>(databuf[idx]);
        }
    }
 
    //Affichage de la matrice
    for (int i = 0; i < 730; i++) {
        for (int j = 0; j < 730; j++) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
 
 
    return 0;
}

[LittleWhite]

Bonjour,

Félicitations pour votre code (s'il correspond à ce que vous vouliez). Je me demandais, est-ce que binwalk n'aurait pas pu vous le faire automatiquement ?