LZ4 compression multi-fichiers

Version imprimable

06/09/2016, 15h37
rubisvert

LZ4 compression multi-fichiers

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.
06/09/2016, 16h16
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) ?
06/09/2016, 16h31
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.
06/09/2016, 16h43
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 ?

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:

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:

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?

07/09/2016, 09h30
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).

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

Code:

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:

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 ?

08/09/2016, 22h26
rubisvert

1 pièce(s) jointe(s)

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.
Pièce jointe 219929
08/09/2016, 22h28
rubisvert

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