static void advance_byte (struct bit_buffer *buf)
{
buf->byte_idx++;
buf->bit_idx = 8;
if (buf->byte_idx == BIT_BUF_SIZE)
flush_bits (buf);
}
static void flush_icf_block(struct isal_zstream *stream)
{
struct isal_zstate *state = &stream->internal_state;
struct level_2_buf *level_buf = (struct level_2_buf *)stream->level_buf;
struct BitBuf2 *write_buf = &state->bitbuf;
struct deflate_icf *icf_buf_encoded_next;
set_buf(write_buf, stream->next_out, stream->avail_out);
#if defined (USE_BITBUF8) || (USE_BITBUF_ELSE)
if (!is_full(write_buf))
flush_bits(write_buf);
#endif
icf_buf_encoded_next = encode_deflate_icf(level_buf->icf_buf_start + state->count,
level_buf->icf_buf_next, write_buf,
&level_buf->encode_tables);
state->count = icf_buf_encoded_next - level_buf->icf_buf_start;
stream->next_out = buffer_ptr(write_buf);
stream->total_out += buffer_used(write_buf);
stream->avail_out -= buffer_used(write_buf);
if (level_buf->icf_buf_next <= icf_buf_encoded_next) {
state->count = 0;
if (stream->avail_in == 0 && stream->end_of_stream)
state->state = ZSTATE_TRL;
else if (stream->avail_in == 0 && stream->flush != NO_FLUSH)
state->state = ZSTATE_SYNC_FLUSH;
else
state->state = ZSTATE_NEW_HDR;
}
}
static int getDCsizeChr(bitstream *bs)
{
// [Ag][note] bad code
if (show_bits(bs, 12) == 1) {
flush_bits(bs, 12);
return 12;
}
if (show_bits(bs, 11) == 1) {
flush_bits(bs, 11);
return 11;
}
if (show_bits(bs, 10) == 1) {
flush_bits(bs, 10);
return 10;
}
if (show_bits(bs, 9) == 1) {
flush_bits(bs, 9);
return 9;
}
if (show_bits(bs, 8) == 1) {
flush_bits(bs, 8);
return 8;
}
if (show_bits(bs, 7) == 1) {
flush_bits(bs, 7);
return 7;
}
if (show_bits(bs, 6) == 1) {
flush_bits(bs, 6);
return 6;
}
if (show_bits(bs, 5) == 1) {
flush_bits(bs, 5);
return 5;
}
if (show_bits(bs, 4) == 1) {
flush_bits(bs, 4);
return 4;
}
if (show_bits(bs, 3) == 1) {
flush_bits(bs, 3);
return 3;
}
return (3 - get_bits(bs, 2));
}
void finish_pass_huff (void)
{
/* Flush out the last data */
flush_bits();
/* End of file flag */
buffer[next_buffer++] = (char) 0xff;
buffer[next_buffer++] = (char) 0xd9;
write_data();
}
main() {
int c;
unsigned char t0;
init();
#ifdef UN
while (apoint!=low) {
#else
while (EOF!=(c=getchar())) {
#endif
++low; /* send no EOF */
t[at]=t0=0x80;
while (t0) {
set_point();
#ifdef UN
if(apoint>point){c=t0;}
else {c=0;}
sendb(c);
#else
sendb(c&t0);
#endif
hk=(HKSIZE+hk-t[at])%HKSIZE;
hv=(HVSIZE+hv-t[at])%HVSIZE;
#ifdef UN
if (c==0) t[at]^=t0;
t0>>=1;
t[at]|=t0;
#else
t0>>=1;
t[at]=(t[at]&c)|t0;
#endif
}
hk+=t[at];
hv+=t[at];
hash();
at=(1+at)%TSIZE;
if(at==to) backhash();
}
high=low; /* send EOF */
send_bits();
flush_bits();
}
emit_restart(phuff_entropy_ptr entropy, int restart_num)
{
int ci;
emit_eobrun(entropy);
if (!entropy->gather_statistics) {
flush_bits(entropy);
emit_byte(entropy, 0xFF);
emit_byte(entropy, JPEG_RST0 + restart_num);
}
if (entropy->cinfo->Ss == 0) {
/* Re-initialize DC predictions to 0 */
for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
entropy->last_dc_val[ci] = 0;
} else {
/* Re-initialize all AC-related fields to 0 */
entropy->EOBRUN = 0;
entropy->BE = 0;
}
}
Int CVTCEncoder::
ByteAlignmentEnc_Still()
{
flush_bits();
return(0);
}
static int getDCsizeLum(bitstream *bs)
{
int code;
// [Ag][note] bad code
if (show_bits(bs, 11) == 1) {
flush_bits(bs, 11);
return 12;
}
if (show_bits(bs, 10) == 1) {
flush_bits(bs, 10);
return 11;
}
if (show_bits(bs, 9) == 1) {
flush_bits(bs, 9);
return 10;
}
if (show_bits(bs, 8) == 1) {
flush_bits(bs, 8);
return 9;
}
if (show_bits(bs, 7) == 1) {
flush_bits(bs, 7);
return 8;
}
if (show_bits(bs, 6) == 1) {
flush_bits(bs, 6);
return 7;
}
if (show_bits(bs, 5) == 1) {
flush_bits(bs, 5);
return 6;
}
if (show_bits(bs, 4) == 1) {
flush_bits(bs, 4);
return 5;
}
code = show_bits(bs, 3);
if (code == 1) {
flush_bits(bs, 3);
return 4;
} else if (code == 2) {
flush_bits(bs, 3);
return 3;
} else if (code == 3) {
flush_bits(bs, 3);
return 0;
}
code = show_bits(bs, 2);
if (code == 2) {
flush_bits(bs, 2);
return 2;
} else if (code == 3) {
flush_bits(bs, 2);
return 1;
}
return 0;
}
int compress_block(
unsigned char *outbuf, /* compressed output buffer */
int *obytes, /* number of compressed bytes */
short *sip, /* quantized image */
const int sip_siz, /* size of quantized image to compress */
const int MaxCoeff, /* Maximum values for coefficients */
const int MaxZRun, /* Maximum zero runs */
HUFFCODE *codes) /* huffman code table */
{
unsigned char *optr;
int LoMaxCoeff; /* lower (negative) MaxCoeff limit */
short pix; /* temp pixel pointer */
unsigned int rcnt = 0, state; /* zero run count and if current pixel
is in a zero run or just a coefficient */
int cnt; /* pixel counter */
int outbit, bytes; /* parameters used by write_bits to */
unsigned char bits; /* output the "coded" image to the */
/* output buffer */
LoMaxCoeff = 1 - MaxCoeff;
optr = outbuf;
outbit = 7;
bytes = 0;
bits = 0;
state = COEFF_CODE;
for (cnt = 0; cnt < sip_siz; cnt++) {
pix = *(sip + cnt);
switch (state) {
case COEFF_CODE:
if (pix == 0) {
state = RUN_CODE;
rcnt = 1;
break;
}
if (pix > MaxCoeff) {
if (pix > 255) {
/* 16bit pos esc */
write_bits( &optr, (unsigned short) codes[103].code,
codes[103].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) pix, 16,
&outbit, &bits, &bytes);
}
else {
/* 8bit pos esc */
write_bits( &optr, (unsigned short) codes[101].code,
codes[101].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) pix, 8,
&outbit, &bits, &bytes);
}
}
else if (pix < LoMaxCoeff) {
if (pix < -255) {
/* 16bit neg esc */
write_bits( &optr, (unsigned short) codes[104].code,
codes[104].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) -pix, 16,
&outbit, &bits, &bytes);
}
else {
/* 8bit neg esc */
write_bits( &optr, (unsigned short) codes[102].code,
codes[102].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) -pix, 8,
&outbit, &bits, &bytes);
}
}
else {
/* within table */
write_bits( &optr, (unsigned short) codes[pix+180].code,
codes[pix+180].size, &outbit, &bits, &bytes);
}
break;
case RUN_CODE:
if (pix == 0 && rcnt < 0xFFFF) {
++rcnt;
break;
}
if (rcnt <= MaxZRun) {
/* log zero run length */
write_bits( &optr, (unsigned short) codes[rcnt].code,
codes[rcnt].size, &outbit, &bits, &bytes );
}
else if (rcnt <= 0xFF) {
/* 8bit zrun esc */
write_bits( &optr, (unsigned short) codes[105].code,
codes[105].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) rcnt, 8,
&outbit, &bits, &bytes);
}
else if (rcnt <= 0xFFFF) {
/* 16bit zrun esc */
write_bits( &optr, (unsigned short) codes[106].code,
codes[106].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) rcnt, 16,
&outbit, &bits, &bytes);
}
else {
fprintf(stderr,
"ERROR : compress_block : zrun too large.\n");
return(-47);
}
if(pix != 0) {
if (pix > MaxCoeff) {
/** log current pix **/
if (pix > 255) {
/* 16bit pos esc */
write_bits( &optr, (unsigned short) codes[103].code,
codes[103].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) pix, 16,
&outbit, &bits, &bytes);
}
else {
/* 8bit pos esc */
write_bits( &optr, (unsigned short) codes[101].code,
codes[101].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) pix, 8,
&outbit, &bits, &bytes);
}
}
else if (pix < LoMaxCoeff) {
if (pix < -255) {
/* 16bit neg esc */
write_bits( &optr, (unsigned short) codes[104].code,
codes[104].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) -pix, 16,
&outbit, &bits, &bytes);
}
else {
/* 8bit neg esc */
write_bits( &optr, (unsigned short) codes[102].code,
codes[102].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) -pix, 8,
&outbit, &bits, &bytes);
}
}
else {
/* within table */
write_bits( &optr, (unsigned short) codes[pix+180].code,
codes[pix+180].size, &outbit, &bits, &bytes);
}
state = COEFF_CODE;
}
else {
rcnt = 1;
state = RUN_CODE;
}
break;
}
}
if (state == RUN_CODE) {
if (rcnt <= MaxZRun) {
write_bits( &optr, (unsigned short) codes[rcnt].code,
codes[rcnt].size, &outbit, &bits, &bytes );
}
else if (rcnt <= 0xFF) {
write_bits( &optr, (unsigned short) codes[105].code,
codes[105].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) rcnt, 8,
&outbit, &bits, &bytes);
}
else if (rcnt <= 0xFFFF) {
write_bits( &optr, (unsigned short) codes[106].code,
codes[106].size, &outbit, &bits, &bytes );
write_bits( &optr, (unsigned short) rcnt, 16,
&outbit, &bits, &bytes);
}
else {
fprintf(stderr, "ERROR : compress_block : zrun2 too large.\n");
return(-48);
}
}
flush_bits( &optr, &outbit, &bits, &bytes);
*obytes = bytes;
return(0);
}
