void compress(InputBuffer& input, OutputStream& output) {
header h;
h.fileSize = input.getSize();
uint8* pInputBuffer = input.getBuffer();
uint8* pOutputBuffer = new uint8[h.fileSize];
RLE(pInputBuffer, pOutputBuffer, h.fileSize, &h.tempSize);
BWT(pOutputBuffer, pInputBuffer, h.tempSize, &h.first);
MTF(pInputBuffer, h.tempSize);
optimizeIncrements(pInputBuffer, h.tempSize, h.increments);
#if 0
float model_stats[8];
getModelStatistics(pInputBuffer, h.tempSize, h.increments, model_stats);
float sum = 0;
for (uint32 i = 0; i < 8; i++) {
printf("model #%d: %12.2f bits (increment: %3d)\n", i, model_stats[i], h.increments[i]);
sum += model_stats[i];
}
printf("%f bpb\n", sum / h.fileSize);
#endif
writeHeader(output, h);
ArithmeticEncoder encoder(output);
StructuredModel model(h.increments);
model.encode(encoder, pInputBuffer, h.tempSize);
delete[] pInputBuffer;
delete[] pOutputBuffer;
}
void
sgiWritFB(ppf rgb[4], int dX, int dY, unt dW, unt dH, unt dD, char *path)
{
IMAGE *sgim;
int k,y,yI;
flt *sr, *sg, *sb ;
pus dr, dg, db, rr, gg, bb;
mallocAss(rr,ush,dW);
mallocAss(gg,ush,dW);
mallocAss(bb,ush,dW);
wrn("sgiWritFB dD: %u path: %s", dD,path);
if (dD < 3 || rgb[1] == NULL) {
sgiWritFlt(rgb[0],dX,dY,dW,dH,path);
return;
}
sgim = iopen(path,"w",RLE(1),3,dW,dH,3); /* WHAT'S the 1st 3? */
for (y = 0, yI = dH+dY; yI > dY ; y++) {
sr = &rgb[1][--yI][dX];
sg = &rgb[2][ yI][dX];
sb = &rgb[3][ yI][dX];
for (dr = rr, dg = gg, db = bb, k = dW; k; k--) {
*dr++ = 0.5F + *sr++;
*dg++ = 0.5F + *sg++;
*db++ = 0.5F + *sb++;
}
putrow(sgim,rr,y,0);
putrow(sgim,gg,y,1);
putrow(sgim,bb,y,2);
}
iclose(sgim); free(rr); free(gg); free(bb);
}
void saveSGIImage(char *name, int doAlphaToo)
{
IMAGE *img;
FILE *fp;
GLubyte *pixels;
int x, y;
int numComp = doAlphaToo ? 4 : 3;
pixels = malloc(winWidth * winHeight * numComp * sizeof(GLubyte));
glReadPixels(0, 0, winWidth, winHeight, doAlphaToo ? GL_RGBA : GL_RGB,
GL_UNSIGNED_BYTE, pixels);
img = iopen(name, "w", RLE(1), numComp, winWidth, winHeight, numComp);
for(y = 0; y < winHeight; y++) {
for(x = 0; x < winWidth; x++) {
rrow[x] = pixels[(y * winWidth + x) * numComp + 0];
grow[x] = pixels[(y * winWidth + x) * numComp + 1];
brow[x] = pixels[(y * winWidth + x) * numComp + 2];
if(doAlphaToo)
arow[x] = pixels[(y * winWidth + x) * numComp + 3];
}
putrow(img, rrow, y, 0);
putrow(img, grow, y, 1);
putrow(img, brow, y, 2);
if(doAlphaToo)
putrow(img, arow, y, 3);
}
iclose(img);
free(pixels);
}
void
sgiWritUB(ppu rgb[4], unt dW, unt dH, char *path)
{
IMAGE *sgim;
int k,y,yI;
unc *sr, *sg, *sb ;
ush *dr, *dg, *db, rr[512], gg[512], bb[512];
assert(dW <= 512);
sgim = iopen(path,"w",RLE(1),3,dW,dH,3); /* WHAT'S the 1st 3? */
for (y = 0, yI = dH; yI ; y++) {
sr = rgb[1][--yI];
sg = rgb[2][ yI];
sb = rgb[3][ yI];
for (dr = rr, dg = gg, db = bb, k = dW; k; k--) {
*dr++ = *sr++;
*dg++ = *sg++;
*db++ = *sb++;
}
putrow(sgim,rr,y,0);
putrow(sgim,gg,y,1);
putrow(sgim,bb,y,2);
}
iclose(sgim);
}
void
writSgiUsh(ppus rgb[4], unt dW, unt dH, char *path)
{
IMAGE *sgim;
unt y,yI;
sgim = iopen(path,"w",RLE(1),3,dW,dH,3); /* WHAT'S the 1st 3? */
for (y = 0, yI = dH; yI-- ; y++) {
putrow(sgim,rgb[1][yI],y,0);
putrow(sgim,rgb[2][yI],y,1);
putrow(sgim,rgb[3][yI],y,2);
}
iclose(sgim);
}
void
rowWriteSGI(ppf src, int sX, int sY, unt sW, unt sH, char *path)
{
IMAGE *sgim;
int k,y,yI;
flt *fp;
ush *up, *urow;
mallocAss(urow,unsigned short,sW);
sgim = iopen(path,"w",RLE(1),2,sW,sH,1);
for (y = 0, yI = sH+sY; yI > sY ; y++) {
fp = &src[--yI][sX];
for (up = urow, k = sW; k-- ; ) {
*up++ = 0.5F + *fp++;
}
putrow(sgim,urow,y,0);
}
iclose(sgim);
}
void
sgiWritFlt (ppf src, int sX, int sY, unt sW, unt sH, char *path)
{
IMAGE *image;
int k;
unsigned short *rowp, *row;
pfl srcp;
if (! (image = iopen(path,"w",RLE(1),2,sW,sH)))
die("sgiWritFlt: iopen(%s)", path);
mallocAss(row,unsigned short,sW);
for (src += sY; sH; ) {
for (rowp = row, srcp = *src++ + sX, k = sW; k-- ; )
*rowp++ = 0.5F + *srcp++; /* Not IRINTF */
putrow(image,row,--sH,0);
}
iclose(image);
free(row);
}
int /** replaced rowWriteSGIN **/
rowWritSGImU(ppu *srcU, int dX, int dY, unt dW, unt dH, unt chan, char *path)
{
ush sbuf[1536];
ppu srcp;
int q,j,yI;
IMAGE *sgim = iopen(path,"w",RLE(1),3,dW,dH,chan);
if (!sgim) {
warn("rowWritSGImU: iopen failed");
return -1;
}
for (q = 0; q < chan; q++) {
for (srcp = &srcU[q][dY], j = dH, yI = dY; j-- ; ) {
ushUnc(sbuf,*srcp++ + dX,dW);
putrow(sgim,sbuf,j,q);
}
}
return iclose(sgim);
}
void
rowGraySGI (ppu src, int sX, int sY, unt sW, unt sH, char *path)
{
IMAGE *image;
int k;
unsigned short *rowp, *row;
puc ucp;
mallocAss(row,unsigned short,sW);
if (! (image = iopen(path,"w",RLE(1),2,sW,sH)))
die("rowGraySGI: iopen(%s)", path);
for (src += sY; sH; ) {
for (rowp = row, ucp = *src++ + sX, k = 0; k < sW; k++)
*rowp++ = *ucp++;
putrow(image,row,--sH,0);
}
iclose(image);
free(row);
}
int /* DOES NOT FLIP IMAGE AROUND X-AXIS -- ORIGIN AT BOTTOM LEFT */
rowWritSgiU(ppu *srcU, int dX, int dY, unt dW, unt dH, unt chan, char *path)
{
ush sbuf[1024];
ppu srcp;
int j,q;
IMAGE *sgim = iopen(path,"w",RLE(1),3,dW,dH,chan);
if (!sgim) {
warn("rowWritSgiU: iopen failed");
return -1;
}
for (q = 0; q < chan; q++) {
for (srcp = &srcU[q][dY], j = 0; j < dH; j++) {
ushUnc(sbuf,*srcp++ + dX,dW);
putrow(sgim, sbuf,j,q);
}
}
return iclose(sgim);
/* 0:success, -1:stdlib close err (check errno), EOF:sgi err */
}
void
rgbWriteSGI(ppf rgb, int dX, int dY, unt dW, unt dH, char *path)
{
IMAGE *sgim;
int k,y,yI;
flt *sp;
ush *rp, *gp, *bp, rr[1024], gg[1024], bb[1024];
assert(dW <= 1024);
sgim = iopen(path,"w",RLE(1),3,dW,dH,3); /* WHAT'S the 1st 3? */
for (dX *= 3, y = 0, yI = dH+dY; yI > dY ; y++) {
sp = &rgb[--yI][dX];
for (rp = rr, gp = gg, bp = bb, k = dW; k; k--) {
*rp++ = 0.5F + *sp++;
*gp++ = 0.5F + *sp++;
*bp++ = 0.5F + *sp++;
}
putrow(sgim,rr,y,0);
putrow(sgim,gg,y,1);
putrow(sgim,bb,y,2);
}
iclose(sgim);
}
void
rgbWriteSGIn(ppf rgb, int dX, int dY, unt dW, unt dH, char *path)
{
IMAGE *sgim;
int k,y;
flt *sp;
ush *rp, *gp, *bp, rr[1280], gg[1280], bb[1280];
assert(dW <= 1280);
sgim = iopen(path,"w",RLE(1),3,dW,dH,3); /* WHAT'S the 1st 3? */
for (rgb += dY, dX *= 3, y = 0; y < dH; y++) {
sp = *rgb++ + dX;
for (rp = rr, gp = gg, bp = bb, k = dW; k; k--) {
*rp++ = 0.5F + *sp++;
*gp++ = 0.5F + *sp++;
*bp++ = 0.5F + *sp++;
}
putrow(sgim,rr,y,0);
putrow(sgim,gg,y,1);
putrow(sgim,bb,y,2);
}
iclose(sgim);
}
int main(int argc, char **argv)
{
char* modeDEmploie = "\nNAME : Compression\n\nSYNOPSIS : \n ./compresser [OPTIONS] nomFichier nom \n\nDESCRIPTION : \n -p\n compression package merge sans prétraitement\n\n -r,-m,-rm\n compression avec prétraitement rle(r) ou mtf(m) ou rle et mtf (mr)\n\nExemple : ./compresser -p nomFichier, ./compresser -r nomFichier, ./compresser -p -m nomFichier\n\n";
if(argc < 3)
{
printf("%s", modeDEmploie);
}
else if (argc == 3)
{
printf("Compression sans pretraitement avec huffman\n");
lancementSimple(argv[1], argv[2]);
}
else if (argc < 6)
{
if(argc==4)
{
char* chemin = argv[2];
if(strcmp("-p",argv[1])==0)
{
printf("Lancement avec package merge\n");
lancementPackageMarge(argv[2], argv[3]);
}
else if (strcmp("-m",argv[1])==0)
{
printf("Lancement avec prétraitement mtf \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
MTF(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementSimple("../bin/temp.txt", argv[3]);
}
else if (strcmp("-r",argv[1])==0)
{
printf("Lancement avec prétraitement rle\n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
RLE(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementSimple("../bin/temp.txt", argv[3]);
}
else if (strcmp("-rm",argv[1])==0)
{
printf("Lancement prétraitement avec rle et mtf \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
comp_RLE_MTF(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementSimple("../bin/temp.txt", argv[3]);
}
else if (strcmp("-mr",argv[1])==0)
{
printf("Lancement prétraitement avec mtf et rel \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
comp_MTF_RLE(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementSimple("../bin/temp.txt", argv[3]);
}
else{printf("%s",modeDEmploie);}
}
else
{
char* chemin = argv[3];
if (strcmp("-p",argv[1])==0)
{
if (strcmp("-m",argv[2])==0)
{
printf("Lancement avec prétraitement mtf \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
MTF(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementPackageMarge("../bin/temp.txt", argv[4]);
}
else if (strcmp("-r",argv[2])==0)
{
printf("Lancement avec prétraitement rle\n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
RLE(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementPackageMarge("../bin/temp.txt", argv[4]);
}
else if (strcmp("-mr",argv[2])==0)
{
printf("Lancement prétraitement avec rle et mtf \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
comp_RLE_MTF(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementPackageMarge("../bin/temp.txt", argv[4]);
}
else if (strcmp("-rm",argv[2])==0)
{
printf("Lancement prétraitement avec mtf et rel \n");
FILE* src=ouvertureFichierLecture(chemin);
FILE* resultat=ouvertureFichierEcriture("../bin/temp.txt");
comp_MTF_RLE(src,resultat);
fermetureFichier(src);
fermetureFichier(resultat);
lancementPackageMarge("../bin/temp.txt", argv[4]);
}
else{printf("%s",modeDEmploie);}
}
else{printf("%s",modeDEmploie);}
}
}
else
{
printf("%s",modeDEmploie);
}
return 0;
}
