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); }