/*
** Read command line params, call search
*/
int
main(int argc, char *argv[]) {
if (argc != 4) {
usage(argv[0]);
return(-1);
}
// plotter is not really a "grid" but why not use the read routine
// to save coding!
grid_t *sonar = readGrid(strcmp(argv[1],"-")?fopen(argv[1],"r"):stdin, TRUE);
grid_t *actual = readGrid(strcmp(argv[2],"-")?fopen(argv[2],"r"):stdin, TRUE);
grid_t *plotter = readGrid(strcmp(argv[3],"-")?fopen(argv[3],"r"):stdin, FALSE);
assert(sonar);
assert(actual);
assert(plotter);
// create output file
char i = argv[2][6];
char output_file_name[] = "actual1.txt.bit";
output_file_name[6] = i;
bit_file_t *bitfile = BitFileOpen(output_file_name, BF_WRITE);
assert(bitfile);
uint32_t bits_sent=0, moves_made=0;
data_t current_position = plotter->data[0];
for(int i = 0 ; i < plotter->width * plotter->height ; i++) {
data_t new_position = plotter->data[i];
moves_made += gridDistance(plotter, current_position, new_position);
current_position = new_position;
//store the PBF of difference between sonar reading and actual height in tempArray
char tempArray[PBFLIMIT];
int inaccuracy = sonar->data[current_position] - actual->data[current_position];
int numBits, i;
numBits = intToPBF(inaccuracy, tempArray, PBFLIMIT);
//put the PBF into output file
for (i = 0; i < numBits; i++) {
BitFilePutBit((int)tempArray[i] - ASCII_ZERO, bitfile);
}
bits_sent += numBits;
}
assert(!BitFileClose(bitfile));
printf("M: %10d B: %10d Bat: %10.1f\n",
moves_made, bits_sent,
(float)moves_made/(float)MOVES_PER_BATTERY + (float)bits_sent);
return 0;
}
/*
** Read command line params, call search
*/
int
main(int argc, char *argv[]) {
if (argc != 4) {
usage(argv[0]);
return(-1);
}
grid_t *sonar = readGrid(strcmp(argv[1],"-")?fopen(argv[1],"r"):stdin, TRUE);
grid_t *plotter = readGrid(strcmp(argv[2],"-")?fopen(argv[2],"r"):stdin, FALSE);
bit_file_t *bitfile = BitFileOpen(argv[3], BF_READ);
assert(sonar);
assert(plotter);
assert(bitfile);
// temporary home for terrain heights
data_t *result = (data_t *)malloc(sizeof(data_t) * plotter->width * plotter->height);
assert(result);
for(uint32_t pos = 0 ; pos < plotter->width * plotter->height ; pos++) {
data_t temp = 0, len = 0, tempLen = 0;
//get the length of the data part of the PBF from the length defining part, store it into "len"
do {
tempLen = 0;
BitFileGetBitsInt(bitfile, &tempLen, 3, sizeof(len));
len += tempLen;
} while (tempLen == 7);
//get the stored data from the data part
for (int i = 0; i < len; i++) {
int lastbit = BitFileGetBit(bitfile);
temp = temp*2 + lastbit;
}
//actual height = sonar reading - inaccuracy
temp = sonar->data[plotter->data[pos]] - temp;
result[plotter->data[pos]] = temp;
}
assert(!BitFileClose(bitfile));
printf("%d %d\n", plotter->width, plotter->height);
for(uint32_t pos = 0 ; pos < plotter->width * plotter->height ; pos++)
printf("%d\n",result[pos]);
free(result);
return 0;
}
/*
* aazip - compress files using a transform based compression system
*/
int main(int argc, char** argv)
{
FILE* f;
bit_file_t* of;
char* infile,*outfile;
uint8_t* input,*lupdate,*bwt,lumode;
int32_t I,osize,opt;
uint32_t size;
mode_t lupdate_alg;
float ient,oent;
uint64_t cost,tstart,tstop,elapsed;
/* parse command line parameter */
opt = GETOPT_FINISHED;
if (argc <= 1) {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
while ((opt = getopt(argc, argv, "m:h")) != GETOPT_FINISHED) {
switch (opt) {
case 'm':
if (strcmp(optarg, "simple") == 0) lupdate_alg = SIMPLE;
else if (strcmp(optarg, "mtf") == 0) lupdate_alg = MTF;
else if (strcmp(optarg, "fc") == 0) lupdate_alg = FC;
else if (strcmp(optarg, "wfc") == 0) lupdate_alg = WFC;
else if (strcmp(optarg, "timestamp") == 0) lupdate_alg = TS;
else fatal("ERROR: mode <%s> unknown!\n", optarg);
break;
case 'h':
default:
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
}
/* read input file name */
if (optind < argc) infile = argv[optind];
else {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
/* read input file */
f = safe_fopen(infile,"r");
size = safe_filesize(f);
input = (uint8_t*) safe_malloc(size+1);
if (fread(input,1,size,f)!=(size_t)size) {
fatal("read input file.");
}
safe_fclose(f);
input[size] = 0;
/* TODO calculate input entropy */
ient = 0.0f;
/* perform bwt */
bwt = (uint8_t*) safe_malloc(size);
tstart = gettime();
bwt = transform_bwt(input,size,bwt,&I);
/* peform list update */
switch (lupdate_alg) {
case SIMPLE:
fprintf(stdout,"ALGORITHM: simple\n");
lupdate = lupdate_simple(bwt,size,input,&cost);
break;
case MTF:
fprintf(stdout,"ALGORITHM: move to front\n");
lupdate = lupdate_movetofront(bwt,size,input,&cost);
break;
case FC:
fprintf(stdout,"ALGORITHM: frequency count\n");
lupdate = lupdate_freqcount(bwt,size,input,&cost);
break;
case WFC:
fprintf(stdout,"ALGORITHM: weighted frequency count\n");
lupdate = lupdate_wfc(bwt,size,input,&cost);
break;
case TS:
fprintf(stdout,"ALGORITHM: timestamp\n");
lupdate = lupdate_timestamp(bwt,size,input,&cost);
break;
default:
fatal("unkown list update algorithm.");
}
fprintf(stdout,"INPUT: %s (%d bytes)\n",infile,size);
fprintf(stdout,"COST: %lu\n",cost);
/* TODO calculate entropy after list update*/
oent = 0.0f;
/* write output */
outfile = safe_strcat(infile,".aazip");
/* create bit file for writing */
of = BitFileOpen(outfile, BF_WRITE);
/* write aa zip header */
BitFilePutChar('A', of);
BitFilePutChar('A', of);
/* write I */
BitFilePutBitsInt(of,&I,32,sizeof(uint32_t));
/* write lupdate mode */
lumode = lupdate_alg;
BitFilePutBitsInt(of,&lumode,8,sizeof(uint8_t));
fprintf(stderr,"I %d lumode %d\n",I,lumode);
/* perform huffman coding */
encode_huffman(lupdate,size,of);
tstop = gettime();
elapsed = tstop - tstart;
fprintf(stdout,"TIME: %.3f s\n",(float)elapsed/1000000);
/* flush and get file stats */
BitFileFlushOutput(of,0);
f = BitFileToFILE(of);
osize = ftell(f);
fprintf(stdout,"OUTPUT: %s\n",outfile);
fprintf(stdout,"ENTROPY: %.2f bps / %.2f bps\n",ient,oent);
fprintf(stdout,"COMPRESSION: %.2f\n",((float)osize/(float)size)*100);
/* clean up*/
safe_fclose(f);
free(input);
free(bwt);
return (EXIT_SUCCESS);
}
/***************************************************************************
* Function : LZWDecodeFile
* Description: This routine reads an input file 1 encoded string at a
* time and decodes it using the LZW algorithm.
* Parameters : inFile - Name of file to decode
* outFile - Name of file to write decoded output to
* Effects : File is decoded using the LZW algorithm with CODE_LEN
* codes.
* Returned : TRUE for success, otherwise FALSE.
***************************************************************************/
int LZWDecodeFile(char *inFile, char *outFile)
{
bit_file_t *bfpIn; /* encoded input */
FILE *fpOut; /* decoded output */
unsigned int nextCode; /* value of next code */
unsigned int lastCode; /* last decoded code word */
unsigned int code; /* code word to decode */
unsigned char c; /* last decoded character */
/* open input and output files */
if (NULL == (bfpIn = BitFileOpen(inFile, BF_READ)))
{
perror(inFile);
return FALSE;
}
if (NULL == outFile)
{
fpOut = stdout;
}
else
{
if (NULL == (fpOut = fopen(outFile, "wb")))
{
BitFileClose(bfpIn);
perror(outFile);
return FALSE;
}
}
/* start with 9 bit code words */
currentCodeLen = 9;
/* initialize for decoding */
nextCode = FIRST_CODE; /* code for next (first) string */
/* first code from file must be a character. use it for initial values */
lastCode = GetCodeWord(bfpIn);
c = lastCode;
fputc(lastCode, fpOut);
/* decode rest of file */
while ((code = GetCodeWord(bfpIn)) != EOF)
{
/* look for code length increase marker */
if (((CURRENT_MAX_CODES(currentCodeLen) - 1) == code) &&
(currentCodeLen < MAX_CODE_LEN))
{
currentCodeLen++;
code = GetCodeWord(bfpIn);
}
if (code < nextCode)
{
/* we have a known code. decode it */
c = DecodeRecursive(code, fpOut);
}
else
{
/***************************************************************
* We got a code that's not in our dictionary. This must be due
* to the string + char + string + char + string exception.
* Build the decoded string using the last character + the
* string from the last code.
***************************************************************/
unsigned char tmp;
tmp = c;
c = DecodeRecursive(lastCode, fpOut);
fputc(tmp, fpOut);
}
/* if room, add new code to the dictionary */
if (nextCode < MAX_CODES)
{
dictionary[nextCode - FIRST_CODE].prefixCode = lastCode;
dictionary[nextCode - FIRST_CODE].suffixChar = c;
nextCode++;
}
/* save character and code for use in unknown code word case */
lastCode = code;
}
fclose(fpOut);
BitFileClose(bfpIn);
return TRUE;
}
/***************************************************************************
* Function : main
* Description: This function demonstrates the usage of each of the bit
* bit file functions.
* Parameters : argc - the number command line arguments (not used)
* Parameters : argv - array of command line arguments (not used)
* Effects : Writes bit file, reads back results, printing them to
* stdout.
* Returned : EXIT_SUCCESS
***************************************************************************/
int main(int argc, char *argv[])
{
bit_file_t *bfp;
FILE *fp;
int i, numCalls, value;
if (argc < 2)
{
numCalls = NUM_CALLS;
}
else
{
numCalls = atoi(argv[1]);
}
/* create bit file for writing */
bfp = BitFileOpen("testfile", BF_WRITE);
if (bfp == NULL)
{
perror("opening file");
return (EXIT_FAILURE);
}
/* write chars */
value = (int)'A';
for (i = 0; i < numCalls; i++)
{
printf("writing char %c\n", value);
if(BitFilePutChar(value, bfp) == EOF)
{
perror("writing char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value++;
}
/* write single bits */
value = 0;
for (i = 0; i < numCalls; i++)
{
printf("writing bit %d\n", value);
if(BitFilePutBit(value, bfp) == EOF)
{
perror("writing bit");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value = 1 - value;
}
/* write ints as bits */
value = 0x11111111;
for (i = 0; i < numCalls; i++)
{
printf("writing bits %0X\n", (unsigned int)value);
if(BitFilePutBits(bfp, &value,
(unsigned int)(8 * sizeof(int))) == EOF)
{
perror("writing bits");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value += 0x11111111;
}
/* close bit file */
if (BitFileClose(bfp) != 0)
{
perror("closing file");
return (EXIT_FAILURE);
}
else
{
printf("closed file\n");
}
/* reopen file for appending */
bfp = BitFileOpen("testfile", BF_APPEND);
if (bfp == NULL)
{
perror("opening file");
return (EXIT_FAILURE);
}
/* append some chars */
value = (int)'A';
for (i = 0; i < numCalls; i++)
{
printf("appending char %c\n", value);
if(BitFilePutChar(value, bfp) == EOF)
{
perror("appending char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value++;
}
/* write some bits from an integer */
value = 0x111;
for (i = 0; i < numCalls; i++)
{
printf("writing 12 bits from an integer %03X\n", (unsigned int)value);
if(BitFilePutBitsInt(bfp, &value, 12, sizeof(value)) == EOF)
{
perror("writing bits from an integer");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value += 0x111;
}
/* convert to normal file */
fp = BitFileToFILE(bfp);
if (fp == NULL)
{
perror("converting to stdio FILE");
return (EXIT_FAILURE);
}
else
{
printf("converted to stdio FILE\n");
}
/* append some chars */
value = (int)'a';
for (i = 0; i < numCalls; i++)
{
printf("appending char %c\n", value);
if(fputc(value, fp) == EOF)
{
perror("appending char to FILE");
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
}
return (EXIT_FAILURE);
}
value++;
}
/* close file */
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
return (EXIT_FAILURE);
}
/* now read back writes */
/* open bit file */
bfp = BitFileOpen("testfile", BF_READ);
if (bfp == NULL)
{
perror("reopening file");
return (EXIT_FAILURE);
}
/* read chars */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetChar(bfp);
if(value == EOF)
{
perror("reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read %c\n", value);
}
}
/* read single bits */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetBit(bfp);
if(value == EOF)
{
perror("reading bit");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read bit %d\n", value);
}
}
/* read ints as bits */
for (i = 0; i < numCalls; i++)
{
if(BitFileGetBits(bfp, &value, (unsigned int)(8 * sizeof(int))) == EOF)
{
perror("reading bits");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read bits %0X\n", (unsigned int)value);
}
}
if (BitFileByteAlign(bfp) == EOF)
{
fprintf(stderr, "failed to align file\n");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("byte aligning file\n");
}
/* read appended characters */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetChar(bfp);
if(value == EOF)
{
perror("reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read %c\n", value);
}
}
/* read some bits into an integer */
for (i = 0; i < numCalls; i++)
{
value = 0;
if(BitFileGetBitsInt(bfp, &value, 12, sizeof(value)) == EOF)
{
perror("reading bits from an integer");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read 12 bits into an integer %03X\n", (unsigned int)value);
}
}
/* convert to stdio FILE */
fp = BitFileToFILE(bfp);
if (fp == NULL)
{
perror("converting to stdio FILE");
return (EXIT_FAILURE);
}
else
{
printf("converted to stdio FILE\n");
}
/* read append some chars */
value = (int)'a';
for (i = 0; i < numCalls; i++)
{
value = fgetc(fp);
if(value == EOF)
{
perror("stdio reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("stdio read %c\n", value);
}
}
/* close file */
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
return (EXIT_FAILURE);
}
return(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
bit_file_t* f;
FILE* outf;
char* infile,*outfile;
uint8_t* input,*bwt,*output,lumode;
int32_t I,n;
mode_t lupdate_alg;
/* parse command line parameter */
if (argc !=2) {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
infile = argv[1];
/* read input file */
f = BitFileOpen(infile, BF_READ);
if (!f) {
fatal("could not open file %s.",infile);
}
/* check if compressed with aazip */
if (BitFileGetChar(f) != 'A' || BitFileGetChar(f) != 'A') {
fatal("file %s not compressed with aazip.",infile);
}
fprintf(stdout,"FILE: %s\n",infile);
/* read header */
BitFileGetBitsInt(f,&I,32,sizeof(I));
BitFileGetBitsInt(f,&lumode,8,sizeof(lumode));
lupdate_alg = lumode;
input = decode_huffman(f,&n);
/* malloc output memory */
bwt = safe_malloc(n*sizeof(uint8_t));
/* peform list update */
switch (lupdate_alg) {
case SIMPLE:
fprintf(stdout,"LUPDATE: Simple\n");
bwt = lupdate_simple(input,n,bwt);
break;
case MTF:
fprintf(stdout,"LUPDATE: Move-To-Front\n");
bwt = lupdate_movetofront(input,n,bwt);
break;
case FC:
fprintf(stdout,"LUPDATE: FC\n");
bwt = lupdate_freqcount(input,n,bwt);
break;
case WFC:
fprintf(stdout,"LUPDATE: WFC\n");
bwt = lupdate_wfc(input,n,bwt);
break;
case TS:
fprintf(stdout,"LUPDATE: TS\n");
bwt = lupdate_timestamp(input,n,bwt);
break;
default:
fatal("unkown list update algorithm.");
}
/* reverse bwt */
output = reverse_bwt(bwt,n,I,input);
/* write output */
outfile = safe_strcat(infile,".org");
outf = safe_fopen(outfile,"w");
if (fwrite(output,sizeof(uint8_t),n,outf)!= (size_t)n) {
fatal("error writing output.");
}
safe_fclose(outf);
/* clean up */
free(bwt);
free(input);
BitFileClose(f);
return (EXIT_SUCCESS);
}
