/*
** 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;
}
/**
* Loads a DWT file
*/
void DWT::load(const string &fileName)
{
// Open file and read magic number
FILE *fHan = fopen(fileName.data(), "rb");
char thisMagic[2];
fread(thisMagic, 1, 2, fHan);
if (magic[0] != thisMagic[0] || magic[1] != thisMagic[1]) {
cerr << "Unrecognized file format for " << fileName << endl;
exit(1);
}
// Read header
fread(&bpp, sizeof(bpp), 1, fHan);
fread(&realWidth, sizeof(int), 1, fHan);
fread(&realHeight, sizeof(int), 1, fHan);
#ifdef __BIG_ENDIAN__
bpp = swap_endian32(bpp);
realWidth = swap_endian32(realWidth);
realHeight = swap_endian32(realHeight);
#endif
// Calculate padded width and height
width = 1;
while (width < realWidth) width <<= 1;
height = 1;
while (height < realHeight) height <<= 1;
// Drops half of the padding when reading
unsigned int stopHeight = height - (height - realHeight)/2;
unsigned int stopWidth = width - (width - realWidth)/2;
unsigned int stopPrHeight = stopHeight * PREVIEW / height;
unsigned int stopPrWidth = stopWidth * PREVIEW / width;
cout << "bpp: " << bpp << endl
<< "width: " << width << endl
<< "height: " << height << endl
<< "realWidth: " << realWidth << endl
<< "realHeight: " << realHeight << endl;
coeff = new float[width * height];
int maxAbsVal;
fread(&maxAbsVal, sizeof(int), 1, fHan);
cout << "maxValue: " << maxAbsVal << endl;
const float C = ((1 << (bpp-1))-1)/(float)(maxAbsVal); // Range value
const float M = (1 << (bpp-1)); // Added to get only positive values
float W = 1, w = 1/sqrt(2); // Factor of multiplication for preview
for (unsigned int i = PREVIEW; i < height; i <<= 1) W *= w;
for (unsigned int i = PREVIEW; i < width; i <<= 1) W *= w;
// Reading the preview
for (unsigned int i = 0; i < stopPrHeight && i < PREVIEW; i++) {
for (unsigned int j = 0; j < stopPrWidth && j < PREVIEW; j++) {
unsigned char l;
fread(&l, 1, 1, fHan);
coeff[i*width + j] = l/W;
}
}
// Reading the rest of the transform, decoding Huffman and RLE
unsigned int zeros = 0;
bit_file_t *bf = MakeBitFile(fHan, BF_READ);
Huffman *huffman = new Huffman(bpp);
huffman->setFile(bf);
huffman->readTree();
for (unsigned int i = 0; i < stopHeight; i++) {
for (unsigned int j = 0; j < stopWidth; j++) {
if (i >= PREVIEW || j >= PREVIEW) {
int l = 0;
if (zeros > 0) {
coeff[i * width + j] = 0;
zeros--;
} else {
bool seq0 = BitFileGetBit(bf);
if (seq0) {
// RLE: read the number of coefficents to set to 0 and set the first
coeff[i * width + j] = 0;
bool cod8 = BitFileGetBit(bf);
if (cod8) {
BitFileGetBitsInt(bf, &zeros, 8, sizeof(zeros));
} else {
BitFileGetBitsInt(bf, &zeros, 3, sizeof(zeros));
}
} else {
// Huffman: read coefficent and dequantize it
l = huffman->readSymbol();
coeff[i*width + j] = (l-M)/C;
}
}
}
}
}
delete huffman;
fclose(fHan);
}
/***************************************************************************
* 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);
}