src/tools/bitcompress.cpp

@@ -0,0 +1,128 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <eyd.hh>
+#include <exception>
+#include <vector>
+
+void usage(){
+	printf("usage : bitcopy <int> <file>\n");
+}
+
+int main(int argc, char ** argv){
+	EydLib::BitGroup bg;
+	int cell_size; 
+	std::string original;
+	std::string copy;
+
+	if (argc<2){ usage(); exit(-1); }
+	cell_size = atoi(argv[1]);
+	original = argv[2];
+
+	copy = original + ".rl1";
+
+	EydLib::BitReader bitread(cell_size, 256);
+	bitread.open(original);
+
+	EydLib::BitWriter bitwrite(cell_size,256);
+	bitwrite.open(copy);
+	unsigned char c = (unsigned char)cell_size;
+	bitwrite.writeDirect(&c, 1);
+
+	EydLib::BitGroup rleBg(cell_size);
+	EydLib::BitGroup lenBg(cell_size);
+
+	printf("Maximum value of cell : %d\n",lenBg.maxValue()); 
+	printf("File opened\n");
+
+	bool done=false;
+	std::vector<EydLib::BitGroup> record;
+	while(!done){
+		try{
+			bg = bitread.read();
+			printf("%s ",bg.toString().c_str());
+			fflush(stdout);
+			// on pousse le bit sur dans la file
+			if (record.size() == 0){
+				// on attend la suite...
+			} else {
+				EydLib::BitGroup tmpBg;
+				EydLib::BitGroup oldBg;
+
+				tmpBg = record.back();
+				// si le caractère est différent de celui d'avant
+				if (tmpBg != bg){
+					// on compte le nombre d'éléments
+					// on pose un marqueur
+					oldBg = record.back();
+					if (record.size()<4) {
+						// soit c'est uniquement des RLE
+						// soit c'est autre chose...
+						// FIXME: dans le cas de cellules "0" ?
+						// on ecrit les cellules telles quelles...
+						// si la taille est incompressible
+						for (int i=0; i<record.size(); i++){
+							oldBg = record[i];
+							if (oldBg.getValue() == rleBg.getValue()){
+								// on échape le caractere avec un RLE
+								bitwrite.write(rleBg); // echapement
+								fprintf(stderr,"\nRLE ");
+							}
+							bitwrite.write(oldBg);
+							fprintf(stderr,"%s ",oldBg.toString().c_str());
+						}
+						record.clear();
+					} else {
+						// la cellule courante est différente de l'ancienne
+						// et la taille est compressible
+						bitwrite.write(rleBg); // echapement
+						fprintf(stderr,"\nRLE ");
+						lenBg.setValue(record.size());
+						bitwrite.write(lenBg); // longueur
+						fprintf(stderr,"%s ",lenBg.toString().c_str());
+						// on a pas besoind d'échaper le caractere avec un RLE
+						// parce qu'il est reconnaissable (2 places apres un RLE)
+						bitwrite.write(tmpBg); // cellule
+						fprintf(stderr,"%s ",tmpBg.toString().c_str());
+						// TODO: penser a calculer le taux de compression
+						record.clear();
+					}
+				} else {
+					// on ne fait rien car le caractère est le meme qu'avant
+					// sauf si la longueur est >  a celle "enregistrable"
+					// par une cellule de donnée
+					if (record.size() >= rleBg.maxValue()){
+						// on flushe artificiellement
+						bitwrite.write(rleBg); // echapement
+						fprintf(stderr,"\nRLE ");
+						lenBg.setValue(record.size());
+						bitwrite.write(lenBg); // longueur
+						fprintf(stderr,"%s ",lenBg.toString().c_str());
+						
+						// on a pas besoind d'échaper le caractere avec un RLE
+						// parce qu'il est reconnaissable (2 places apres un RLE)
+						bitwrite.write(tmpBg); // cellule
+						fprintf(stderr,"%s ",tmpBg.toString().c_str());
+						// TODO: penser a calculer le taux de compression
+						record.clear();
+					} else {
+						// sinon on ne fait rien, on a encore de la marge
+					}
+				}
+
+			}
+			record.push_back(bg);
+			//bitwrite.write(bg);	
+		} catch (EydLib::eBitReaderEndOfFile& e) {
+			done = true;		
+			// TODO: on flushe le contenu de record
+		} catch (std::exception& e){
+			printf("ERROR\n");
+		}
+	}
+	printf("compression done\n");
+
+	bitread.close();
+	bitwrite.close();
+
+	printf("file closed\n");
+}

src/tools/bitdecompress.cpp

@@ -0,0 +1,123 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <eyd.hh>
+#include <exception>
+#include <vector>
+
+void usage(){
+	printf("usage : bitcopy <int> <file>\n");
+}
+
+int main(int argc, char ** argv){
+	EydLib::BitGroup bg;
+	int cell_size; 
+	std::string original;
+	std::string copy;
+
+	if (argc<2){ usage(); exit(-1); }
+	cell_size = atoi(argv[1]);
+	original = argv[2];
+
+	copy = original + ".rl1";
+
+	EydLib::BitReader bitread(cell_size, 256);
+	bitread.open(original);
+
+	EydLib::BitWriter bitwrite(cell_size,256);
+	bitwrite.open(copy);
+
+	EydLib::BitGroup rleBg(cell_size);
+	EydLib::BitGroup lenBg(cell_size);
+
+	printf("Maximum value of cell : %d\n",lenBg.maxValue()); 
+	printf("File opened\n");
+
+	bool done=false;
+	std::vector<EydLib::BitGroup> record;
+	while(!done){
+		try{
+			bg = bitread.read();
+			printf("%s ",bg.toString().c_str());
+			fflush(stdout);
+			// on pousse le bit sur dans la file
+			if (record.size() == 0){
+				// on attend la suite...
+			} else {
+				EydLib::BitGroup tmpBg;
+				EydLib::BitGroup oldBg;
+
+				tmpBg = record.back();
+				// si le caractère est différent de celui d'avant
+				if (tmpBg != bg){
+					// on compte le nombre d'éléments
+					// on pose un marqueur
+					if (record.size()<3){
+						// FIXME: dans le cas de cellules "0" ?
+						// on ecrit les cellules telles quelles...
+						// si la taille est incompressible
+						for (int i=0; i<record.size(); i++){
+							oldBg = record[i];
+							if (oldBg.getValue() == 0){
+								// on échape le caractere avec un RLE
+								bitwrite.write(rleBg); // echapement
+								fprintf(stderr,"RLE ");
+							}
+							bitwrite.write(oldBg);
+							fprintf(stderr,"%s ",oldBg.toString().c_str());
+						}
+						record.clear();
+					} else {
+						// la cellule courante est différente de l'ancienne
+						// et la taille est compressible
+						bitwrite.write(rleBg); // echapement
+						fprintf(stderr,"RLE ");
+						lenBg.setValue(record.size());
+						bitwrite.write(lenBg); // longueur
+						fprintf(stderr,"%s ",lenBg.toString().c_str());
+						// on a pas besoind d'échaper le caractere avec un RLE
+						// parce qu'il est reconnaissable (2 places apres un RLE)
+						bitwrite.write(tmpBg); // cellule
+						fprintf(stderr,"%s ",tmpBg.toString().c_str());
+						// TODO: penser a calculer le taux de compression
+						record.clear();
+					}
+				} else {
+					// on ne fait rien car le caractère est le meme qu'avant
+					// sauf si la longueur est >  a celle "enregistrable"
+					// par une cellule de donnée
+					if (record.size() >= rleBg.maxValue()){
+						// on flushe artificiellement
+						bitwrite.write(rleBg); // echapement
+						fprintf(stderr,"RLE ");
+						lenBg.setValue(record.size());
+						bitwrite.write(lenBg); // longueur
+						fprintf(stderr,"%s ",lenBg.toString().c_str());
+						
+						// on a pas besoind d'échaper le caractere avec un RLE
+						// parce qu'il est reconnaissable (2 places apres un RLE)
+						bitwrite.write(tmpBg); // cellule
+						fprintf(stderr,"%s ",tmpBg.toString().c_str());
+						// TODO: penser a calculer le taux de compression
+						record.clear();
+					} else {
+						// sinon on ne fait rien, on a encore de la marge
+					}
+				}
+
+			}
+			record.push_back(bg);
+			//bitwrite.write(bg);	
+		} catch (EydLib::eBitReaderEndOfFile& e) {
+			done = true;		
+			// TODO: on flushe le contenu de record
+		} catch (std::exception& e){
+			printf("ERROR\n");
+		}
+	}
+	printf("compression done\n");
+
+	bitread.close();
+	bitwrite.close();
+
+	printf("file closed\n");
+}