/*
** 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;
}
int main(int argc, char *argv[])
{
FILE *fpIn;
bit_file_t bfpOut;
huffman_node_t *huffmanTree; /* root of huffman tree */
char outBuf[1024];
/* open binary input file and bitfile output file */
if ((fpIn = fopen(filename, "rb")) == NULL)
{
perror(filename);
return FALSE;
}
bfpOut.mode = BF_WRITE;
bfpOut.buf = outBuf;
bfpOut.bufLen = sizeof(outBuf);
BitFileInit(&bfpOut);
/* build tree */
if ((huffmanTree = GenerateTreeFromFile(fpIn)) == NULL)
{
fclose(fpIn);
BitFileClose(&bfpOut);
return FALSE;
}
/* use tree to generate a canonical code */
if (!BuildCanonicalCode(huffmanTree, canonicalList))
{
fclose(fpIn);
BitFileClose(&bfpOut);
FreeHuffmanTree(huffmanTree); /* free allocated memory */
return FALSE;
}
WriteHeader(canonicalList, &bfpOut);
return TRUE;
}
int CHuffmanEncode(struct CHuffman *ch)
{
bit_file_t bfpOut;
int i;
unsigned char c;
bfpOut.buf = ch->outBuf;
bfpOut.bufLen = ch->outLen;
bfpOut.mode = BF_WRITE;
BitFileInit(&bfpOut);
/* read characters from file and write them to encoded file */
for (i = 0; i < ch->inLen; i++) {
c = ch->inBuf[i];
/* write encoded symbols */
if (BitFilePutBits(&bfpOut,
BitArrayGetBits(ch->canonicalList[c].code),
ch->canonicalList[c].codeLen) == EOF)
{
fprintf(stderr, "buffer full writing\n");
exit(1);
}
}
/* now write EOF */
if (BitFilePutBits(&bfpOut,
BitArrayGetBits(ch->canonicalList[EOF_CHAR].code),
ch->canonicalList[EOF_CHAR].codeLen) == EOF)
{
fprintf(stderr, "buffer full writing\n");
exit(1);
}
/* clean up */
BitFileClose(&bfpOut);
ch->outIndex = bfpOut.bufPos;
return 0;
}
/***************************************************************************
* 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);
}
int CHuffmanDecode(struct CHuffman *ch)
{
bit_file_t bfpIn;
int i, newBit;
bfpIn.mode = BF_READ;
bfpIn.buf = ch->inBuf;
bfpIn.bufLen = ch->inLen;
BitFileInit(&bfpIn);
/* open binary output file and bitfile input file */
/* decode input file */
ch->outIndex = 0;
if (!ch->resume) {
BitArrayClearAll(ch->code);
ch->decode_length = 0;
}
while (1) {
newBit = BitFileGetBit(&bfpIn);
if (newBit == EOF) {
fprintf(stderr, "error reading bitfile\n");
exit(1);
}
if (newBit == BUFFER_EMPTY) {
ch->resume = 1;
return BUFFER_EMPTY;
}
if (newBit != 0)
{
BitArraySetBit(ch->code, ch->decode_length);
}
ch->decode_length++;
if (ch->lenIndex[ch->decode_length] != NUM_CHARS)
{
/* there are code of this length */
for(i = ch->lenIndex[ch->decode_length];
(i < NUM_CHARS) && (ch->canonicalList[i].codeLen == ch->decode_length);
i++)
{
if (BitArrayCompare(ch->canonicalList[i].code, ch->code) == 0)
{
/* we just read a symbol output decoded value */
if (ch->canonicalList[i].value == EOF_CHAR) {
if (BitFileByteAlign(&bfpIn)) {
fprintf(stderr, "buffer full\n");
exit(1);
}
}
else {
if (ch->outIndex >= ch->outLen) {
/* buffer limit reached */
fprintf(stderr, "buffer full\n");
exit(1);
}
ch->outBuf[ch->outIndex++] = ch->canonicalList[i].value;
}
BitArrayClearAll(ch->code);
ch->decode_length = 0;
break;
}
}
}
}
ch->resume = 0;
/* close all files */
BitFileClose(&bfpIn);
return 0;
}
