int virt_putc(char c, VIRT_FILE *f)
{
if (f==NULL)
{ errno=EBADF;
return EOF;
}
#ifdef __MSDOS__
if (f->file == NULL)
#else
if (f->buf == NULL)
#endif
{ errno=EBADF;
return EOF;
}
if (f->offbody && c=='\n')
f->lines++;
if (f->offbody==0 && f->waslf)
if (c=='\n')
f->offbody=f->curpos;
f->waslf = (c=='\n');
msgsize++;
#ifdef __MSDOS__
f->curpos++;
return putc(c, f->file);
#else
if (f->curpos == f->bufsize)
{ void *newbuf;
if ((newbuf = bufrealloc(f->buf, f->bufsize+=BUFSIZE)) == NULL)
{ errno=ENOMEM;
freebuf(f->buf);
f->buf = NULL;
return EOF;
}
f->buf=newbuf;
}
bufcopy(f->buf, f->curpos++, &c, 1);
return 1;
#endif
}
static int
qtree_encode(char *outfile, int a[], int n, int nqx, int nqy, int nbitplanes)
{
/*
int a[];
int n; physical dimension of row in a
int nqx; length of row
int nqy; length of column (<=n)
int nbitplanes; number of bit planes to output
*/
int log2n, i, k, bit, b, bmax, nqmax, nqx2, nqy2, nx, ny;
unsigned char *scratch, *buffer;
/*
* log2n is log2 of max(nqx,nqy) rounded up to next power of 2
*/
nqmax = (nqx>nqy) ? nqx : nqy;
log2n = (int) (log((float) nqmax)/log(2.0)+0.5);
if (nqmax > (1<<log2n)) {
log2n += 1;
}
/*
* initialize buffer point, max buffer size
*/
nqx2 = (nqx+1)/2;
nqy2 = (nqy+1)/2;
bmax = (nqx2*nqy2+1)/2;
/*
* We're indexing A as a 2-D array with dimensions (nqx,nqy).
* Scratch is 2-D with dimensions (nqx/2,nqy/2) rounded up.
* Buffer is used to store string of codes for output.
*/
scratch = (unsigned char *) malloc(2*bmax);
buffer = (unsigned char *) malloc(bmax);
if ((scratch == (unsigned char *) NULL) ||
(buffer == (unsigned char *) NULL)) {
ffpmsg("qtree_encode: insufficient memory");
return(DATA_COMPRESSION_ERR);
}
/*
* now encode each bit plane, starting with the top
*/
for (bit=nbitplanes-1; bit >= 0; bit--) {
/*
* initial bit buffer
*/
b = 0;
bitbuffer = 0;
bits_to_go3 = 0;
/*
* on first pass copy A to scratch array
*/
qtree_onebit(a,n,nqx,nqy,scratch,bit);
nx = (nqx+1)>>1;
ny = (nqy+1)>>1;
/*
* copy non-zero values to output buffer, which will be written
* in reverse order
*/
if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) {
/*
* quadtree is expanding data,
* change warning code and just fill buffer with bit-map
*/
write_bdirect(outfile,a,n,nqx,nqy,scratch,bit);
goto bitplane_done;
}
/*
* do log2n reductions
*/
for (k = 1; k<log2n; k++) {
qtree_reduce(scratch,ny,nx,ny,scratch);
nx = (nx+1)>>1;
ny = (ny+1)>>1;
if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) {
write_bdirect(outfile,a,n,nqx,nqy,scratch,bit);
goto bitplane_done;
}
}
/*
* OK, we've got the code in buffer
* Write quadtree warning code, then write buffer in reverse order
*/
output_nybble(outfile,0xF);
if (b==0) {
if (bits_to_go3>0) {
/*
* put out the last few bits
*/
output_nbits(outfile, bitbuffer & ((1<<bits_to_go3)-1),
bits_to_go3);
} else {
/*
* have to write a zero nybble if there are no 1's in array
*/
output_huffman(outfile,0);
}
} else {
if (bits_to_go3>0) {
/*
* put out the last few bits
*/
output_nbits(outfile, bitbuffer & ((1<<bits_to_go3)-1),
bits_to_go3);
}
for (i=b-1; i>=0; i--) {
output_nbits(outfile,buffer[i],8);
}
}
bitplane_done: ;
}
free(buffer);
free(scratch);
return(0);
}
ByteArray::ByteArray(const char *buffer, uint32 size) : _buffer(new std::vector<char>()) {
bufcopy(buffer, size);
}
ByteArray& ByteArray::operator=(ByteArray const& cpy) {
bufcopy(cpy.getBuffer());
return *this;
}
ByteArray::ByteArray(ByteArray const& cpy) : _buffer(new std::vector<char>()) {
bufcopy(cpy.getBuffer());
}
