1ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#if !defined(_FX_JPEG_TURBO_) 2ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 3ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * jchuff.c 4ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 5ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Copyright (C) 1991-1997, Thomas G. Lane. 6ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * This file is part of the Independent JPEG Group's software. 7ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * For conditions of distribution and use, see the accompanying README file. 8ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 9ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * This file contains Huffman entropy encoding routines. 10ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 11ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Much of the complexity here has to do with supporting output suspension. 12ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * If the data destination module demands suspension, we want to be able to 13ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * back up to the start of the current MCU. To do this, we copy state 14ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * variables into local working storage, and update them back to the 15ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * permanent JPEG objects only upon successful completion of an MCU. 16ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 17ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 18ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define JPEG_INTERNALS 19ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#include "jinclude.h" 20ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#include "jpeglib.h" 21ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#include "jchuff.h" /* Declarations shared with jcphuff.c */ 22ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 23ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef _FX_MANAGED_CODE_ 24ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define savable_state savable_state_c 25ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 26ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 27ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Expanded entropy encoder object for Huffman encoding. 28ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 29ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * The savable_state subrecord contains fields that change within an MCU, 30ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * but must not be updated permanently until we complete the MCU. 31ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 32ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 33ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovtypedef struct { 34ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov INT32 put_buffer; /* current bit-accumulation buffer */ 35ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int put_bits; /* # of bits now in it */ 36ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ 37ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} savable_state; 38ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 39ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* This macro is to work around compilers with missing or broken 40ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * structure assignment. You'll need to fix this code if you have 41ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * such a compiler and you change MAX_COMPS_IN_SCAN. 42ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 43ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 44ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifndef NO_STRUCT_ASSIGN 45ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define ASSIGN_STATE(dest,src) ((dest) = (src)) 46ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#else 47ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#if MAX_COMPS_IN_SCAN == 4 48ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define ASSIGN_STATE(dest,src) \ 49ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ((dest).put_buffer = (src).put_buffer, \ 50ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (dest).put_bits = (src).put_bits, \ 51ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (dest).last_dc_val[0] = (src).last_dc_val[0], \ 52ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (dest).last_dc_val[1] = (src).last_dc_val[1], \ 53ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (dest).last_dc_val[2] = (src).last_dc_val[2], \ 54ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (dest).last_dc_val[3] = (src).last_dc_val[3]) 55ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 56ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 57ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 58ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 59ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovtypedef struct { 60ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov struct jpeg_entropy_encoder pub; /* public fields */ 61ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 62ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov savable_state saved; /* Bit buffer & DC state at start of MCU */ 63ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 64ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* These fields are NOT loaded into local working state. */ 65ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov unsigned int restarts_to_go; /* MCUs left in this restart interval */ 66ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int next_restart_num; /* next restart number to write (0-7) */ 67ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 68ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Pointers to derived tables (these workspaces have image lifespan) */ 69ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]; 70ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]; 71ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 72ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED /* Statistics tables for optimization */ 73ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov long * dc_count_ptrs[NUM_HUFF_TBLS]; 74ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov long * ac_count_ptrs[NUM_HUFF_TBLS]; 75ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 76ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} huff_entropy_encoder; 77ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 78ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovtypedef huff_entropy_encoder * huff_entropy_ptr; 79ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 80ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Working state while writing an MCU. 81ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * This struct contains all the fields that are needed by subroutines. 82ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 83ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 84ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovtypedef struct { 85ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov JOCTET * next_output_byte; /* => next byte to write in buffer */ 86ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov size_t free_in_buffer; /* # of byte spaces remaining in buffer */ 87ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov savable_state cur; /* Current bit buffer & DC state */ 88ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov j_compress_ptr cinfo; /* dump_buffer needs access to this */ 89ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} working_state; 90ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 91ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 92ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Forward declarations */ 93ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo, 94ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov JBLOCKROW *MCU_data)); 95ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo)); 96ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED 97ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo, 98ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov JBLOCKROW *MCU_data)); 99ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo)); 100ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 101ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 102ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 103ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 104ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Initialize for a Huffman-compressed scan. 105ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * If gather_statistics is TRUE, we do not output anything during the scan, 106ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * just count the Huffman symbols used and generate Huffman code tables. 107ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 108ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 109ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(void) 110ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovstart_pass_huff (j_compress_ptr cinfo, boolean gather_statistics) 111ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 112ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; 113ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int ci, dctbl, actbl; 114ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_component_info * compptr; 115ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 116ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (gather_statistics) { 117ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED 118ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->pub.encode_mcu = encode_mcu_gather; 119ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->pub.finish_pass = finish_pass_gather; 120ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#else 121ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_NOT_COMPILED); 122ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 123ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } else { 124ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->pub.encode_mcu = encode_mcu_huff; 125ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->pub.finish_pass = finish_pass_huff; 126ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 127ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 128ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 129ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov compptr = cinfo->cur_comp_info[ci]; 130ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dctbl = compptr->dc_tbl_no; 131ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov actbl = compptr->ac_tbl_no; 132ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (gather_statistics) { 133ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED 134ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Check for invalid table indexes */ 135ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* (make_c_derived_tbl does this in the other path) */ 136ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS) 137ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl); 138ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (actbl < 0 || actbl >= NUM_HUFF_TBLS) 139ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl); 140ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Allocate and zero the statistics tables */ 141ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ 142ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (entropy->dc_count_ptrs[dctbl] == NULL) 143ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->dc_count_ptrs[dctbl] = (long *) 144ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 145ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 257 * SIZEOF(long)); 146ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long)); 147ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (entropy->ac_count_ptrs[actbl] == NULL) 148ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->ac_count_ptrs[actbl] = (long *) 149ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 150ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 257 * SIZEOF(long)); 151ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long)); 152ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 153ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } else { 154ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Compute derived values for Huffman tables */ 155ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* We may do this more than once for a table, but it's not expensive */ 156ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl, 157ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov & entropy->dc_derived_tbls[dctbl]); 158ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_make_c_derived_tbl(cinfo, FALSE, actbl, 159ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov & entropy->ac_derived_tbls[actbl]); 160ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 161ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Initialize DC predictions to 0 */ 162ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->saved.last_dc_val[ci] = 0; 163ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 164ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 165ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Initialize bit buffer to empty */ 166ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->saved.put_buffer = 0; 167ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->saved.put_bits = 0; 168ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 169ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Initialize restart stuff */ 170ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->restarts_to_go = cinfo->restart_interval; 171ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->next_restart_num = 0; 172ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 173ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 174ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 175ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 176ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Compute the derived values for a Huffman table. 177ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * This routine also performs some validation checks on the table. 178ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 179ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Note this is also used by jcphuff.c. 180ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 181ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 182ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovGLOBAL(void) 183ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovjpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno, 184ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c_derived_tbl ** pdtbl) 185ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 186ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov JHUFF_TBL *htbl; 187ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c_derived_tbl *dtbl; 188ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int p, i, l, lastp, _si, maxsymbol; 189ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov char huffsize[257]; 190ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov unsigned int huffcode[257]; 191ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov unsigned int code; 192ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 193ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Note that huffsize[] and huffcode[] are filled in code-length order, 194ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * paralleling the order of the symbols themselves in htbl->huffval[]. 195ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 196ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 197ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the input Huffman table */ 198ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (tblno < 0 || tblno >= NUM_HUFF_TBLS) 199ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); 200ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htbl = 201ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno]; 202ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (htbl == NULL) 203ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); 204ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 205ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Allocate a workspace if we haven't already done so. */ 206ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (*pdtbl == NULL) 207ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov *pdtbl = (c_derived_tbl *) 208ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 209ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov SIZEOF(c_derived_tbl)); 210ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dtbl = *pdtbl; 211ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 212ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Figure C.1: make table of Huffman code length for each symbol */ 213ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 214ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov p = 0; 215ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (l = 1; l <= 16; l++) { 216ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov i = (int) htbl->bits[l]; 217ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (i < 0 || p + i > 256) /* protect against table overrun */ 218ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); 219ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (i--) 220ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huffsize[p++] = (char) l; 221ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 222ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huffsize[p] = 0; 223ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov lastp = p; 224ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 225ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Figure C.2: generate the codes themselves */ 226ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* We also validate that the counts represent a legal Huffman code tree. */ 227ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 228ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov code = 0; 229ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov _si = huffsize[0]; 230ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov p = 0; 231ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (huffsize[p]) { 232ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (((int) huffsize[p]) == _si) { 233ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huffcode[p++] = code; 234ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov code++; 235ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 236ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* code is now 1 more than the last code used for codelength si; but 237ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * it must still fit in si bits, since no code is allowed to be all ones. 238ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 239ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (((INT32) code) >= (((INT32) 1) << _si)) 240ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); 241ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov code <<= 1; 242ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov _si++; 243ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 244ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 245ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Figure C.3: generate encoding tables */ 246ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* These are code and size indexed by symbol value */ 247ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 248ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Set all codeless symbols to have code length 0; 249ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * this lets us detect duplicate VAL entries here, and later 250ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * allows emit_bits to detect any attempt to emit such symbols. 251ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 252ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi)); 253ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 254ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* This is also a convenient place to check for out-of-range 255ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * and duplicated VAL entries. We allow 0..255 for AC symbols 256ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * but only 0..15 for DC. (We could constrain them further 257ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * based on data depth and mode, but this seems enough.) 258ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 259ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov maxsymbol = isDC ? 15 : 255; 260ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 261ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (p = 0; p < lastp; p++) { 262ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov i = htbl->huffval[p]; 263ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (i < 0 || i > maxsymbol || dtbl->ehufsi[i]) 264ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); 265ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dtbl->ehufco[i] = huffcode[p]; 266ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dtbl->ehufsi[i] = huffsize[p]; 267ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 268ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 269ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 270ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 271ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Outputting bytes to the file */ 272ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 273ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Emit a byte, taking 'action' if must suspend. */ 274ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define emit_byte(state,val,action) \ 275ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov { *(state)->next_output_byte++ = (JOCTET) (val); \ 276ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (--(state)->free_in_buffer == 0) \ 277ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! dump_buffer(state)) \ 278ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov { action; } } 279ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 280ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 281ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(boolean) 282ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovdump_buffer (working_state * state) 283ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */ 284ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 285ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov struct jpeg_destination_mgr * dest = state->cinfo->dest; 286ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 287ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! (*dest->empty_output_buffer) (state->cinfo)) 288ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 289ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* After a successful buffer dump, must reset buffer pointers */ 290ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->next_output_byte = dest->next_output_byte; 291ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->free_in_buffer = dest->free_in_buffer; 292ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 293ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 294ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 295ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 296ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Outputting bits to the file */ 297ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 298ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Only the right 24 bits of put_buffer are used; the valid bits are 299ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * left-justified in this part. At most 16 bits can be passed to emit_bits 300ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * in one call, and we never retain more than 7 bits in put_buffer 301ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * between calls, so 24 bits are sufficient. 302ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 303ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 304ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovINLINE 305ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(boolean) 306ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovemit_bits (working_state * state, unsigned int code, int size) 307ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Emit some bits; return TRUE if successful, FALSE if must suspend */ 308ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 309ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* This routine is heavily used, so it's worth coding tightly. */ 310ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register INT32 put_buffer = (INT32) code; 311ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int put_bits = state->cur.put_bits; 312ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 313ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* if size is 0, caller used an invalid Huffman table entry */ 314ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (size == 0) 315ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE); 316ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 317ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */ 318ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 319ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_bits += size; /* new number of bits in buffer */ 320ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 321ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_buffer <<= 24 - put_bits; /* align incoming bits */ 322ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 323ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */ 324ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 325ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (put_bits >= 8) { 326ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int c = (int) ((put_buffer >> 16) & 0xFF); 327ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 328ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov emit_byte(state, c, return FALSE); 329ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (c == 0xFF) { /* need to stuff a zero byte? */ 330ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov emit_byte(state, 0, return FALSE); 331ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 332ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_buffer <<= 8; 333ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov put_bits -= 8; 334ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 335ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 336ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->cur.put_buffer = put_buffer; /* update state variables */ 337ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->cur.put_bits = put_bits; 338ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 339ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 340ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 341ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 342ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 343ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(boolean) 344ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovflush_bits (working_state * state) 345ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 346ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */ 347ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 348ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->cur.put_buffer = 0; /* and reset bit-buffer to empty */ 349ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->cur.put_bits = 0; 350ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 351ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 352ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 353ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 354ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Encode a single block's worth of coefficients */ 355ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 356ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(boolean) 357ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovencode_one_block (working_state * state, JCOEFPTR block, int last_dc_val, 358ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c_derived_tbl *dctbl, c_derived_tbl *actbl) 359ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 360ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int temp, temp2; 361ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int nbits; 362ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int k, r, i; 363ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 364ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Encode the DC coefficient difference per section F.1.2.1 */ 365ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 366ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = temp2 = block[0] - last_dc_val; 367ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 368ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (temp < 0) { 369ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = -temp; /* temp is abs value of input */ 370ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* For a negative input, want temp2 = bitwise complement of abs(input) */ 371ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* This code assumes we are on a two's complement machine */ 372ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp2--; 373ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 374ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 375ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the number of bits needed for the magnitude of the coefficient */ 376ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits = 0; 377ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (temp) { 378ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits++; 379ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp >>= 1; 380ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 381ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Check for out-of-range coefficient values. 382ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Since we're encoding a difference, the range limit is twice as much. 383ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 384ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (nbits > MAX_COEF_BITS+1) 385ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); 386ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 387ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Emit the Huffman-coded symbol for the number of bits */ 388ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits])) 389ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 390ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 391ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Emit that number of bits of the value, if positive, */ 392ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* or the complement of its magnitude, if negative. */ 393ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (nbits) /* emit_bits rejects calls with size 0 */ 394ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, (unsigned int) temp2, nbits)) 395ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 396ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 397ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Encode the AC coefficients per section F.1.2.2 */ 398ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 399ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r = 0; /* r = run length of zeros */ 400ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 401ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (k = 1; k < DCTSIZE2; k++) { 402ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if ((temp = block[jpeg_natural_order[k]]) == 0) { 403ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r++; 404ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } else { 405ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* if run length > 15, must emit special run-length-16 codes (0xF0) */ 406ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (r > 15) { 407ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0])) 408ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 409ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r -= 16; 410ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 411ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 412ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp2 = temp; 413ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (temp < 0) { 414ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = -temp; /* temp is abs value of input */ 415ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* This code assumes we are on a two's complement machine */ 416ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp2--; 417ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 418ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 419ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the number of bits needed for the magnitude of the coefficient */ 420ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits = 1; /* there must be at least one 1 bit */ 421ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while ((temp >>= 1)) 422ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits++; 423ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Check for out-of-range coefficient values */ 424ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (nbits > MAX_COEF_BITS) 425ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); 426ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 427ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Emit Huffman symbol for run length / number of bits */ 428ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov i = (r << 4) + nbits; 429ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i])) 430ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 431ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 432ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Emit that number of bits of the value, if positive, */ 433ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* or the complement of its magnitude, if negative. */ 434ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, (unsigned int) temp2, nbits)) 435ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 436ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 437ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r = 0; 438ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 439ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 440ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 441ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* If the last coef(s) were zero, emit an end-of-block code */ 442ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (r > 0) 443ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0])) 444ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 445ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 446ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 447ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 448ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 449ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 450ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 451ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Emit a restart marker & resynchronize predictions. 452ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 453ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 454ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(boolean) 455ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovemit_restart (working_state * state, int restart_num) 456ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 457ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int ci; 458ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 459ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! flush_bits(state)) 460ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 461ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 462ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov emit_byte(state, 0xFF, return FALSE); 463ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov emit_byte(state, JPEG_RST0 + restart_num, return FALSE); 464ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 465ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Re-initialize DC predictions to 0 */ 466ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (ci = 0; ci < state->cinfo->comps_in_scan; ci++) 467ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state->cur.last_dc_val[ci] = 0; 468ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 469ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* The restart counter is not updated until we successfully write the MCU. */ 470ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 471ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 472ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 473ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 474ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 475ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 476ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Encode and output one MCU's worth of Huffman-compressed coefficients. 477ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 478ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 479ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(boolean) 480ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovencode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 481ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 482ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; 483ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov working_state state; 484ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int blkn, ci; 485ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_component_info * compptr; 486ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 487ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Load up working state */ 488ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.next_output_byte = cinfo->dest->next_output_byte; 489ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.free_in_buffer = cinfo->dest->free_in_buffer; 490ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ASSIGN_STATE(state.cur, entropy->saved); 491ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.cinfo = cinfo; 492ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 493ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Emit restart marker if needed */ 494ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (cinfo->restart_interval) { 495ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (entropy->restarts_to_go == 0) 496ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! emit_restart(&state, entropy->next_restart_num)) 497ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 498ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 499ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 500ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Encode the MCU data blocks */ 501ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 502ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ci = cinfo->MCU_membership[blkn]; 503ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov compptr = cinfo->cur_comp_info[ci]; 504ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! encode_one_block(&state, 505ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MCU_data[blkn][0], state.cur.last_dc_val[ci], 506ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->dc_derived_tbls[compptr->dc_tbl_no], 507ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->ac_derived_tbls[compptr->ac_tbl_no])) 508ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return FALSE; 509ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Update last_dc_val */ 510ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.cur.last_dc_val[ci] = MCU_data[blkn][0][0]; 511ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 512ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 513ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Completed MCU, so update state */ 514ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov cinfo->dest->next_output_byte = state.next_output_byte; 515ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov cinfo->dest->free_in_buffer = state.free_in_buffer; 516ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ASSIGN_STATE(entropy->saved, state.cur); 517ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 518ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Update restart-interval state too */ 519ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (cinfo->restart_interval) { 520ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (entropy->restarts_to_go == 0) { 521ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->restarts_to_go = cinfo->restart_interval; 522ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->next_restart_num++; 523ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->next_restart_num &= 7; 524ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 525ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->restarts_to_go--; 526ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 527ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 528ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 529ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 530ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 531ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 532ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 533ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Finish up at the end of a Huffman-compressed scan. 534ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 535ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 536ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(void) 537ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovfinish_pass_huff (j_compress_ptr cinfo) 538ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 539ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; 540ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov working_state state; 541ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 542ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Load up working state ... flush_bits needs it */ 543ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.next_output_byte = cinfo->dest->next_output_byte; 544ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.free_in_buffer = cinfo->dest->free_in_buffer; 545ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ASSIGN_STATE(state.cur, entropy->saved); 546ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov state.cinfo = cinfo; 547ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 548ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Flush out the last data */ 549ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! flush_bits(&state)) 550ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_CANT_SUSPEND); 551ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 552ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Update state */ 553ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov cinfo->dest->next_output_byte = state.next_output_byte; 554ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov cinfo->dest->free_in_buffer = state.free_in_buffer; 555ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ASSIGN_STATE(entropy->saved, state.cur); 556ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 557ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 558ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 559ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 560ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Huffman coding optimization. 561ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 562ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * We first scan the supplied data and count the number of uses of each symbol 563ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * that is to be Huffman-coded. (This process MUST agree with the code above.) 564ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Then we build a Huffman coding tree for the observed counts. 565ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Symbols which are not needed at all for the particular image are not 566ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * assigned any code, which saves space in the DHT marker as well as in 567ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * the compressed data. 568ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 569ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 570ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED 571ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 572ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 573ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* Process a single block's worth of coefficients */ 574ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 575ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovLOCAL(void) 576ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovhtest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val, 577ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov long dc_counts[], long ac_counts[]) 578ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 579ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int temp; 580ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int nbits; 581ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov register int k, r; 582ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 583ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Encode the DC coefficient difference per section F.1.2.1 */ 584ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 585ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = block[0] - last_dc_val; 586ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (temp < 0) 587ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = -temp; 588ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 589ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the number of bits needed for the magnitude of the coefficient */ 590ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits = 0; 591ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (temp) { 592ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits++; 593ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp >>= 1; 594ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 595ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Check for out-of-range coefficient values. 596ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Since we're encoding a difference, the range limit is twice as much. 597ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 598ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (nbits > MAX_COEF_BITS+1) 599ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_BAD_DCT_COEF); 600ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 601ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Count the Huffman symbol for the number of bits */ 602ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dc_counts[nbits]++; 603ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 604ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Encode the AC coefficients per section F.1.2.2 */ 605ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 606ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r = 0; /* r = run length of zeros */ 607ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 608ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (k = 1; k < DCTSIZE2; k++) { 609ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if ((temp = block[jpeg_natural_order[k]]) == 0) { 610ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r++; 611ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } else { 612ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* if run length > 15, must emit special run-length-16 codes (0xF0) */ 613ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (r > 15) { 614ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ac_counts[0xF0]++; 615ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r -= 16; 616ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 617ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 618ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the number of bits needed for the magnitude of the coefficient */ 619ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (temp < 0) 620ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov temp = -temp; 621ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 622ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the number of bits needed for the magnitude of the coefficient */ 623ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits = 1; /* there must be at least one 1 bit */ 624ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while ((temp >>= 1)) 625ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov nbits++; 626ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Check for out-of-range coefficient values */ 627ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (nbits > MAX_COEF_BITS) 628ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_BAD_DCT_COEF); 629ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 630ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Count Huffman symbol for run length / number of bits */ 631ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ac_counts[(r << 4) + nbits]++; 632ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 633ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov r = 0; 634ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 635ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 636ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 637ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* If the last coef(s) were zero, emit an end-of-block code */ 638ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (r > 0) 639ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ac_counts[0]++; 640ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 641ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 642ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 643ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 644ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Trial-encode one MCU's worth of Huffman-compressed coefficients. 645ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * No data is actually output, so no suspension return is possible. 646ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 647ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 648ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(boolean) 649ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovencode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data) 650ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 651ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; 652ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int blkn, ci; 653ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_component_info * compptr; 654ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 655ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Take care of restart intervals if needed */ 656ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (cinfo->restart_interval) { 657ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (entropy->restarts_to_go == 0) { 658ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Re-initialize DC predictions to 0 */ 659ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (ci = 0; ci < cinfo->comps_in_scan; ci++) 660ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->saved.last_dc_val[ci] = 0; 661ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Update restart state */ 662ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->restarts_to_go = cinfo->restart_interval; 663ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 664ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->restarts_to_go--; 665ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 666ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 667ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { 668ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ci = cinfo->MCU_membership[blkn]; 669ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov compptr = cinfo->cur_comp_info[ci]; 670ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci], 671ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->dc_count_ptrs[compptr->dc_tbl_no], 672ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->ac_count_ptrs[compptr->ac_tbl_no]); 673ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0]; 674ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 675ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 676ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov return TRUE; 677ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 678ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 679ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 680ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 681ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Generate the best Huffman code table for the given counts, fill htbl. 682ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Note this is also used by jcphuff.c. 683ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 684ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * The JPEG standard requires that no symbol be assigned a codeword of all 685ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * one bits (so that padding bits added at the end of a compressed segment 686ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * can't look like a valid code). Because of the canonical ordering of 687ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * codewords, this just means that there must be an unused slot in the 688ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * longest codeword length category. Section K.2 of the JPEG spec suggests 689ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * reserving such a slot by pretending that symbol 256 is a valid symbol 690ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * with count 1. In theory that's not optimal; giving it count zero but 691ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * including it in the symbol set anyway should give a better Huffman code. 692ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * But the theoretically better code actually seems to come out worse in 693ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * practice, because it produces more all-ones bytes (which incur stuffed 694ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * zero bytes in the final file). In any case the difference is tiny. 695ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * 696ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * The JPEG standard requires Huffman codes to be no more than 16 bits long. 697ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * If some symbols have a very small but nonzero probability, the Huffman tree 698ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * must be adjusted to meet the code length restriction. We currently use 699ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * the adjustment method suggested in JPEG section K.2. This method is *not* 700ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * optimal; it may not choose the best possible limited-length code. But 701ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * typically only very-low-frequency symbols will be given less-than-optimal 702ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * lengths, so the code is almost optimal. Experimental comparisons against 703ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * an optimal limited-length-code algorithm indicate that the difference is 704ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * microscopic --- usually less than a hundredth of a percent of total size. 705ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * So the extra complexity of an optimal algorithm doesn't seem worthwhile. 706ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 707ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 708ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovGLOBAL(void) 709ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovjpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]) 710ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 711ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#define MAX_CLEN 32 /* assumed maximum initial code length */ 712ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */ 713ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int codesize[257]; /* codesize[k] = code length of symbol k */ 714ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int others[257]; /* next symbol in current branch of tree */ 715ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int c1, c2; 716ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int p, i, j; 717ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov long v; 718ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 719ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* This algorithm is explained in section K.2 of the JPEG standard */ 720ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 721ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(bits, SIZEOF(bits)); 722ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(codesize, SIZEOF(codesize)); 723ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 0; i < 257; i++) 724ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov others[i] = -1; /* init links to empty */ 725ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 726ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov freq[256] = 1; /* make sure 256 has a nonzero count */ 727ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Including the pseudo-symbol 256 in the Huffman procedure guarantees 728ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * that no real symbol is given code-value of all ones, because 256 729ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * will be placed last in the largest codeword category. 730ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 731ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 732ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Huffman's basic algorithm to assign optimal code lengths to symbols */ 733ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 734ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (;;) { 735ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the smallest nonzero frequency, set c1 = its symbol */ 736ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* In case of ties, take the larger symbol number */ 737ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c1 = -1; 738ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov v = 1000000000L; 739ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 0; i <= 256; i++) { 740ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (freq[i] && freq[i] <= v) { 741ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov v = freq[i]; 742ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c1 = i; 743ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 744ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 745ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 746ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Find the next smallest nonzero frequency, set c2 = its symbol */ 747ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* In case of ties, take the larger symbol number */ 748ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c2 = -1; 749ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov v = 1000000000L; 750ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 0; i <= 256; i++) { 751ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (freq[i] && freq[i] <= v && i != c1) { 752ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov v = freq[i]; 753ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c2 = i; 754ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 755ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 756ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 757ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Done if we've merged everything into one frequency */ 758ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (c2 < 0) 759ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov break; 760ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 761ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Else merge the two counts/trees */ 762ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov freq[c1] += freq[c2]; 763ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov freq[c2] = 0; 764ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 765ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Increment the codesize of everything in c1's tree branch */ 766ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov codesize[c1]++; 767ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (others[c1] >= 0) { 768ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c1 = others[c1]; 769ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov codesize[c1]++; 770ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 771ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 772ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov others[c1] = c2; /* chain c2 onto c1's tree branch */ 773ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 774ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Increment the codesize of everything in c2's tree branch */ 775ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov codesize[c2]++; 776ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (others[c2] >= 0) { 777ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov c2 = others[c2]; 778ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov codesize[c2]++; 779ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 780ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 781ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 782ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Now count the number of symbols of each code length */ 783ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 0; i <= 256; i++) { 784ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (codesize[i]) { 785ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* The JPEG standard seems to think that this can't happen, */ 786ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* but I'm paranoid... */ 787ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (codesize[i] > MAX_CLEN) 788ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW); 789ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 790ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[codesize[i]]++; 791ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 792ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 793ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 794ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure 795ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Huffman procedure assigned any such lengths, we must adjust the coding. 796ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Here is what the JPEG spec says about how this next bit works: 797ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Since symbols are paired for the longest Huffman code, the symbols are 798ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * removed from this length category two at a time. The prefix for the pair 799ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * (which is one bit shorter) is allocated to one of the pair; then, 800ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * skipping the BITS entry for that prefix length, a code word from the next 801ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * shortest nonzero BITS entry is converted into a prefix for two code words 802ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * one bit longer. 803ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 804ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 805ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = MAX_CLEN; i > 16; i--) { 806ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (bits[i] > 0) { 807ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov j = i - 2; /* find length of new prefix to be used */ 808ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (bits[j] == 0) 809ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov j--; 810ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 811ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[i] -= 2; /* remove two symbols */ 812ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[i-1]++; /* one goes in this length */ 813ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[j+1] += 2; /* two new symbols in this length */ 814ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[j]--; /* symbol of this length is now a prefix */ 815ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 816ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 817ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 818ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Remove the count for the pseudo-symbol 256 from the largest codelength */ 819ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov while (bits[i] == 0) /* find largest codelength still in use */ 820ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov i--; 821ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov bits[i]--; 822ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 823ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Return final symbol counts (only for lengths 0..16) */ 824ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits)); 825ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 826ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Return a list of the symbols sorted by code length */ 827ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* It's not real clear to me why we don't need to consider the codelength 828ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * changes made above, but the JPEG spec seems to think this works. 829ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 830ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov p = 0; 831ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 1; i <= MAX_CLEN; i++) { 832ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (j = 0; j <= 255; j++) { 833ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (codesize[j] == i) { 834ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htbl->huffval[p] = (UINT8) j; 835ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov p++; 836ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 837ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 838ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 839ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 840ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Set sent_table FALSE so updated table will be written to JPEG file. */ 841ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htbl->sent_table = FALSE; 842ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 843ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 844ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 845ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 846ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Finish up a statistics-gathering pass and create the new Huffman tables. 847ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 848ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 849ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovMETHODDEF(void) 850ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovfinish_pass_gather (j_compress_ptr cinfo) 851ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 852ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; 853ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int ci, dctbl, actbl; 854ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_component_info * compptr; 855ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov JHUFF_TBL **htblptr; 856ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov boolean did_dc[NUM_HUFF_TBLS]; 857ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov boolean did_ac[NUM_HUFF_TBLS]; 858ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 859ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* It's important not to apply jpeg_gen_optimal_table more than once 860ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * per table, because it clobbers the input frequency counts! 861ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 862ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(did_dc, SIZEOF(did_dc)); 863ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov MEMZERO(did_ac, SIZEOF(did_ac)); 864ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 865ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (ci = 0; ci < cinfo->comps_in_scan; ci++) { 866ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov compptr = cinfo->cur_comp_info[ci]; 867ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov dctbl = compptr->dc_tbl_no; 868ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov actbl = compptr->ac_tbl_no; 869ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! did_dc[dctbl]) { 870ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl]; 871ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (*htblptr == NULL) 872ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 873ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]); 874ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov did_dc[dctbl] = TRUE; 875ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 876ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (! did_ac[actbl]) { 877ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov htblptr = & cinfo->ac_huff_tbl_ptrs[actbl]; 878ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov if (*htblptr == NULL) 879ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 880ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]); 881ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov did_ac[actbl] = TRUE; 882ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 883ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 884ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 885ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 886ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 887ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif /* ENTROPY_OPT_SUPPORTED */ 888ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 889ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 890ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov/* 891ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov * Module initialization routine for Huffman entropy encoding. 892ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov */ 893ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 894ee451cb395940862dad63c85adfe8f2fd55e864cSvet GanovGLOBAL(void) 895ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganovjinit_huff_encoder (j_compress_ptr cinfo) 896ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov{ 897ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov huff_entropy_ptr entropy; 898ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov int i; 899ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 900ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy = (huff_entropy_ptr) 901ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 902ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov SIZEOF(huff_entropy_encoder)); 903ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; 904ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->pub.start_pass = start_pass_huff; 905ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 906ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov /* Mark tables unallocated */ 907ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov for (i = 0; i < NUM_HUFF_TBLS; i++) { 908ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; 909ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#ifdef ENTROPY_OPT_SUPPORTED 910ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL; 911ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif 912ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov } 913ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov} 914ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov 915ee451cb395940862dad63c85adfe8f2fd55e864cSvet Ganov#endif //_FX_JPEG_TURBO_ 916