Discussion :

[rubisvert]

Bonjour,

Je programme en Csharp et j'ai trouvé sur le net LZ4Sharp qui permet de compresser des fichiers.

J'arrive à compresser 1 seul fichier, mais je voudrais regrouper plusieurs fichiers en 1 seul pour les compresser avec LZ4Sharp?

Je ne sais pas comment faire, est-ce que quelqu'un sais si on peut le faire avec LZ4Sharp?

Merci.

[jopopmk]

Salut,

ne connaissant pas cette bilbi j'ai deux questions pour toi :
- es-tu sûr qu'elle permet de faire des archives ?
- pourquoi ne pas utiliser les fonctionnalités du framework .NET (System.IO.Compression.ZipFile) ?

[rubisvert]

1- je ne sais pas si on peut y faire une archive, c'est mon but mais je ne sais pas comment faire. J' ai pour l'instant réussi à compression qu'un seul fichier
2- Je souhaite utiliser LZ4 car c'est un nouvel algo qui est assez récent et apparement plus performant.

[jopopmk]

D'après la fiche wiki :
- il est effectivement des plus rapides, toutefois ce sera aux dépens de la taille finale,
- il s'agit uniquement d'un algo de compression, il n'est aucunement question d'archivage
(ça ne veut pas dire que la lib que tu utilises ne le fait pas, mais c'est pas le but premier de l'algo).
Peut-être faudra-t-il trouver une bilbi qui prend en charge cette partie (genre un truc qui gère les TAR).

T'as un lien vers la doc de cette bilbi ?

[rubisvert]

tu peux charger la dll de LZ4 sur https://lz4net.codeplex.com/ et la mettre en référence dans un projet.
sinon, j'ai trouver un lien d'exemple: http://justonesandzeros.typepad.com/...mpression.html
Pour le code simplifié, j'ai fait:

Code :

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

1
2
3
4
5
6
// Compression
            string fichier = "C:\\Users\\Idem\\Desktop\\test.txt";
            byte[] uncompressed = System.IO.File.ReadAllBytes(fichier);
            byte[] compressed = LZ4Sharp.LZ4.Compress(uncompressed);
            string fichierLZ4 = "C:\\Users\\Idem\\Desktop\\test.LZ4";
            System.IO.File.WriteAllBytes(fichierLZ4, compressed);

Code :

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

1
2
3
4
5
6
// Décompression
            string fichierLZ4 = "C:\\Users\\Idem\\Desktop\\test.LZ4";
            byte[] compressed = System.IO.File.ReadAllBytes(fichierLZ4);
            byte[] uncompressed = LZ4Sharp.LZ4.Decompress(compressed);
            string fichier = "C:\\Users\\Idem\\Desktop\\test.txt";
            System.IO.File.WriteAllBytes(fichier, uncompressed);

Ca marche bien pour 1 fichier.

Apparement, pour de de l'archivage, rien n'est proposé.

Comme on traite un tableau de byte[], je pense que pour de l'archivage il suffit d'enrichir ce tableau de byte[] en empilant la compression des multiples fichiers et en rajoutant une en-tête qui donne la longueur des compressions et les nom des différents fichiers.

Tu penses que peut s'en sortir comme ça pour de l'archivage?

[Max]

Salut

LZ4 est un algorithme compression. Bien qu'utilisées souvent conjointement, la création d'archive et la compression sont deux choses différentes.

Tu peux donc soit essayer d'implémenter ton propre système de création d'archivage (mais selon moi, ce serait du temps perdu), soit utiliser un existant (tar, ZIP, etc.) et placer dans ces archives tes fichiers compressés en LZ4. Pour ma part, j'utilise depuis des années la bibliothèque SharpZipLib sous toutes ses formes en prod, elle fait parfaitement le boulot (ZIP, Gzip, tar, bzip2).

[rubisvert]

Merci, mais j'ai pas utilisé SharpZipLib finalement.

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
private void CompressionLZ4_Archivage(List<string> fichiers, string fichierArchive)
        {
            // codage: entête t1[]+fichiers non compressé t2[]
            // t1:
            // 1- nombre de fichiers [0] [1] [2] [3]
            // 2- taille du fichier [0] [1] [2] [3]
            // 3- taille du nom du fichier [0] [1] [2] [3]
            // 4- nom du fichier
            // ... répétition
            // t2:
            // t2+uncompressed[]
            // fin: compression du codage
            // En-tête
            int nbFichiers = fichiers.Count;
            byte[] t1 = BitConverter.GetBytes(nbFichiers); // [0] [1] [2] [3]
            // 1er fichier
            byte[] t2 = System.IO.File.ReadAllBytes(fichiers[0].ToString());
            // En-Tête
            int tailleFichier = t2.Length;
            byte[] t3 = BitConverter.GetBytes(tailleFichier); // [0] [1] [2] [3]
            t1 = CollerBytes(t1, t3);
            string nomFichier = System.IO.Path.GetFileName(fichiers[0].ToString());
            t3 = Encoding.ASCII.GetBytes(nomFichier);
            byte[] t4 = BitConverter.GetBytes(t3.Length); // [0] [1] [2] [3]
            t1 = CollerBytes(t1, t4);
            t1 = CollerBytes(t1, t3);
            for (int i = 1; i < nbFichiers; i++)
            {
                // Empile la compression
                nomFichier = System.IO.Path.GetFileName(fichiers[i].ToString());
                byte[] uncompressed = System.IO.File.ReadAllBytes(fichiers[i].ToString());
                t2 = CollerBytes(t2, uncompressed);
                // Modifie l'en-tête
                tailleFichier = uncompressed.Length;
                t3 = BitConverter.GetBytes(tailleFichier); // [0] [1] [2] [3]
                t1 = CollerBytes(t1, t3);
                t3 = Encoding.ASCII.GetBytes(nomFichier);
                t4 = BitConverter.GetBytes(t3.Length); // [0] [1] [2] [3]
                t1 = CollerBytes(t1, t4);
                t1 = CollerBytes(t1, t3);
            }
            byte[] final = CollerBytes(t1, t2);
            byte[] compressed = LZ4Sharp.LZ4.Compress(final);
            System.IO.File.WriteAllBytes(fichierArchive, compressed);
        }
 
private void DecompressionLZ4_Archivage(string fichierArchive, string repertoireSortie)
        {
            // codage: entête t1[]+fichiers non compressé t2[]
            // t1:
            // 1- nombre de fichiers [0] [1] [2] [3]
            // 2- taille du fichier [0] [1] [2] [3]
            // 3- taille du nom du fichier [0] [1] [2] [3]
            // 4- nom du fichier
            // ... répétition
            // t2:
            // t2+uncompressed[]
            // fin: compression du codage
            byte[] compressed = System.IO.File.ReadAllBytes(fichierArchive);
            byte[] uncompressed = LZ4Sharp.LZ4.Decompress(compressed);
            // Entête
            int index = 0;
            byte[] t1 = new byte[4];
            System.Buffer.BlockCopy(uncompressed, index, t1, 0, 4);
            index += 4;
            int nbFichiers = BitConverter.ToInt32(t1, 0);
            List<int> tailleFichier = new List<int>();
            List<string> nomFichier = new List<string>();
            for (int i = 0; i < nbFichiers; i++)
            {
                // Taille fichier
                System.Buffer.BlockCopy(uncompressed, index, t1, 0, 4);
                tailleFichier.Add(BitConverter.ToInt32(t1, 0));
                index += 4;
                // Taille du nom du fichier
                System.Buffer.BlockCopy(uncompressed, index, t1, 0, 4);
                int tailleNomFichier = BitConverter.ToInt32(t1, 0);
                index += 4;
                // Nom du fichier
                byte[] t = new byte[tailleNomFichier];
                System.Buffer.BlockCopy(uncompressed, index, t, 0, tailleNomFichier);
                nomFichier.Add(Encoding.ASCII.GetString(t));
                index += tailleNomFichier;
            }
            // Fichiers
            for (int i = 0; i < nbFichiers; i++)
            {
                byte[] t = new byte[tailleFichier[i]];
                System.Buffer.BlockCopy(uncompressed, index, t, 0, tailleFichier[i]);
                index += tailleFichier[i];
                string fichier = repertoireSortie + "\\" + nomFichier[i];
                System.IO.File.WriteAllBytes(fichier, t);
            }
        }
 
private byte[] CollerBytes(byte[] t1, byte[] t2)
        {
            byte[] t3 = new byte[t1.Length + t2.Length];
            System.Buffer.BlockCopy(t1, 0, t3, 0, t1.Length);
            System.Buffer.BlockCopy(t2, 0, t3, t1.Length, t2.Length);
            return t3;
        }

Ca marche, mais je sais pas si c'est performant car j'ai pas fait de tests benchmark.

Toutefois, j'ai un doute sur la méthode BitConverter.ToInt32() avec Array.Reverse() et BitConverter.IsLittleEndian.
Faut-il inverser le tableau de bytes[] comme:

Code :

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

1
2
3
4
 
if (BitConverter.IsLittleEndian)
    Array.Reverse(bytes);
int i = BitConverter.ToInt32(bytes, 0);

Est-ce nécessaire de faire le test IsLittleEndian pour l'inversion ?

[rubisvert]

Voici un BenchMark allant jusqu'à un fichier de 100 Mo (mélange de fichiers texte, 3 images de 9 Mo , exe).
LZ4 est apparement moins performant en compression, mais toutefois très rapide.
Je note néanmoins que la taille des fichiers restent limité au maxi autour de 250-300Mo, j'ai pas calculé précisément.

[rubisvert]

oubli:
(C) -> compression
(D) -> décompression