JCPHUFF.c
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:26k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Note : this file is included as part of the Smaller Animals Software
  4. // JpegFile package. Though this file has not been modified from it's 
  5. // original IJG 6a form, it is not the responsibility on the Independent
  6. // JPEG Group to answer questions regarding this code.
  7. //
  8. // Any questions you have about this code should be addressed to :
  9. //
  10. // CHRISDL@PAGESZ.NET - the distributor of this package.
  11. //
  12. // Remember, by including this code in the JpegFile package, Smaller 
  13. // Animals Software assumes all responsibilities for answering questions
  14. // about it. If we (SA Software) can't answer your questions ourselves, we 
  15. // will direct you to people who can.
  16. //
  17. // Thanks, CDL.
  18. //
  19. ////////////////////////////////////////////////////////////////////////
  20. /*
  21.  * jcphuff.c
  22.  *
  23.  * Copyright (C) 1995-1996, Thomas G. Lane.
  24.  * This file is part of the Independent JPEG Group's software.
  25.  * For conditions of distribution and use, see the accompanying README file.
  26.  *
  27.  * This file contains Huffman entropy encoding routines for progressive JPEG.
  28.  *
  29.  * We do not support output suspension in this module, since the library
  30.  * currently does not allow multiple-scan files to be written with output
  31.  * suspension.
  32.  */
  33. #define JPEG_INTERNALS
  34. #include "jinclude.h"
  35. #include "jpeglib.h"
  36. #include "jchuff.h" /* Declarations shared with jchuff.c */
  37. #ifdef C_PROGRESSIVE_SUPPORTED
  38. /* Expanded entropy encoder object for progressive Huffman encoding. */
  39. typedef struct {
  40.   struct jpeg_entropy_encoder pub; /* public fields */
  41.   /* Mode flag: TRUE for optimization, FALSE for actual data output */
  42.   unsigned int gather_statistics;
  43.   /* Bit-level coding status.
  44.    * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
  45.    */
  46.   JOCTET * next_output_byte; /* => next byte to write in buffer */
  47.   size_t free_in_buffer; /* # of byte spaces remaining in buffer */
  48.   long put_buffer; /* current bit-accumulation buffer */
  49.   int put_bits; /* # of bits now in it */
  50.   j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */
  51.   /* Coding status for DC components */
  52.   int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
  53.   /* Coding status for AC components */
  54.   int ac_tbl_no; /* the table number of the single component */
  55.   unsigned int EOBRUN; /* run length of EOBs */
  56.   unsigned int BE; /* # of buffered correction bits before MCU */
  57.   char * bit_buffer; /* buffer for correction bits (1 per char) */
  58.   /* packing correction bits tightly would save some space but cost time... */
  59.   unsigned int restarts_to_go; /* MCUs left in this restart interval */
  60.   int next_restart_num; /* next restart number to write (0-7) */
  61.   /* Pointers to derived tables (these workspaces have image lifespan).
  62.    * Since any one scan codes only DC or only AC, we only need one set
  63.    * of tables, not one for DC and one for AC.
  64.    */
  65.   c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
  66.   /* Statistics tables for optimization; again, one set is enough */
  67.   long * count_ptrs[NUM_HUFF_TBLS];
  68. } phuff_entropy_encoder;
  69. typedef phuff_entropy_encoder * phuff_entropy_ptr;
  70. /* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
  71.  * buffer can hold.  Larger sizes may slightly improve compression, but
  72.  * 1000 is already well into the realm of overkill.
  73.  * The minimum safe size is 64 bits.
  74.  */
  75. #define MAX_CORR_BITS  1000 /* Max # of correction bits I can buffer */
  76. /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than long.
  77.  * We assume that int right shift is unsigned if long right shift is,
  78.  * which should be safe.
  79.  */
  80. #ifdef RIGHT_SHIFT_IS_UNSIGNED
  81. #define ISHIFT_TEMPS int ishift_temp;
  82. #define IRIGHT_SHIFT(x,shft)  
  83. ((ishift_temp = (x)) < 0 ? 
  84.  (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : 
  85.  (ishift_temp >> (shft)))
  86. #else
  87. #define ISHIFT_TEMPS
  88. #define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
  89. #endif
  90. /* Forward declarations */
  91. METHODDEF(unsigned int) encode_mcu_DC_first JPP((j_compress_ptr cinfo,
  92.     JBLOCKROW *MCU_data));
  93. METHODDEF(unsigned int) encode_mcu_AC_first JPP((j_compress_ptr cinfo,
  94.     JBLOCKROW *MCU_data));
  95. METHODDEF(unsigned int) encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
  96.      JBLOCKROW *MCU_data));
  97. METHODDEF(unsigned int) encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
  98.      JBLOCKROW *MCU_data));
  99. METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo));
  100. METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
  101. /*
  102.  * Initialize for a Huffman-compressed scan using progressive JPEG.
  103.  */
  104. METHODDEF(void)
  105. start_pass_phuff (j_compress_ptr cinfo, unsigned int gather_statistics)
  106. {  
  107.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  108.   unsigned int is_DC_band;
  109.   int ci, tbl;
  110.   jpeg_component_info * compptr;
  111.   entropy->cinfo = cinfo;
  112.   entropy->gather_statistics = gather_statistics;
  113.   is_DC_band = (cinfo->Ss == 0);
  114.   /* We assume jcmaster.c already validated the scan parameters. */
  115.   /* Select execution routines */
  116.   if (cinfo->Ah == 0) {
  117.     if (is_DC_band)
  118.       entropy->pub.encode_mcu = encode_mcu_DC_first;
  119.     else
  120.       entropy->pub.encode_mcu = encode_mcu_AC_first;
  121.   } else {
  122.     if (is_DC_band)
  123.       entropy->pub.encode_mcu = encode_mcu_DC_refine;
  124.     else {
  125.       entropy->pub.encode_mcu = encode_mcu_AC_refine;
  126.       /* AC refinement needs a correction bit buffer */
  127.       if (entropy->bit_buffer == NULL)
  128. entropy->bit_buffer = (char *)
  129.   (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  130.       MAX_CORR_BITS * SIZEOF(char));
  131.     }
  132.   }
  133.   if (gather_statistics)
  134.     entropy->pub.finish_pass = finish_pass_gather_phuff;
  135.   else
  136.     entropy->pub.finish_pass = finish_pass_phuff;
  137.   /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
  138.    * for AC coefficients.
  139.    */
  140.   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  141.     compptr = cinfo->cur_comp_info[ci];
  142.     /* Initialize DC predictions to 0 */
  143.     entropy->last_dc_val[ci] = 0;
  144.     /* Make sure requested tables are present */
  145.     /* (In gather mode, tables need not be allocated yet) */
  146.     if (is_DC_band) {
  147.       if (cinfo->Ah != 0) /* DC refinement needs no table */
  148. continue;
  149.       tbl = compptr->dc_tbl_no;
  150.       if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
  151.   (cinfo->dc_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
  152. ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
  153.     } else {
  154.       entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
  155.       if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
  156.           (cinfo->ac_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
  157.         ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
  158.     }
  159.     if (gather_statistics) {
  160.       /* Allocate and zero the statistics tables */
  161.       /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
  162.       if (entropy->count_ptrs[tbl] == NULL)
  163. entropy->count_ptrs[tbl] = (long *)
  164.   (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  165.       257 * SIZEOF(long));
  166.       MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
  167.     } else {
  168.       /* Compute derived values for Huffman tables */
  169.       /* We may do this more than once for a table, but it's not expensive */
  170.       if (is_DC_band)
  171.         jpeg_make_c_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[tbl],
  172. & entropy->derived_tbls[tbl]);
  173.       else
  174.         jpeg_make_c_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[tbl],
  175. & entropy->derived_tbls[tbl]);
  176.     }
  177.   }
  178.   /* Initialize AC stuff */
  179.   entropy->EOBRUN = 0;
  180.   entropy->BE = 0;
  181.   /* Initialize bit buffer to empty */
  182.   entropy->put_buffer = 0;
  183.   entropy->put_bits = 0;
  184.   /* Initialize restart stuff */
  185.   entropy->restarts_to_go = cinfo->restart_interval;
  186.   entropy->next_restart_num = 0;
  187. }
  188. /* Outputting bytes to the file.
  189.  * NB: these must be called only when actually outputting,
  190.  * that is, entropy->gather_statistics == FALSE.
  191.  */
  192. /* Emit a byte */
  193. #define emit_byte(entropy,val)  
  194. { *(entropy)->next_output_byte++ = (JOCTET) (val);  
  195.   if (--(entropy)->free_in_buffer == 0)  
  196.     dump_buffer(entropy); }
  197. LOCAL(void)
  198. dump_buffer (phuff_entropy_ptr entropy)
  199. /* Empty the output buffer; we do not support suspension in this module. */
  200. {
  201.   struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
  202.   if (! (*dest->empty_output_buffer) (entropy->cinfo))
  203.     ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
  204.   /* After a successful buffer dump, must reset buffer pointers */
  205.   entropy->next_output_byte = dest->next_output_byte;
  206.   entropy->free_in_buffer = dest->free_in_buffer;
  207. }
  208. /* Outputting bits to the file */
  209. /* Only the right 24 bits of put_buffer are used; the valid bits are
  210.  * left-justified in this part.  At most 16 bits can be passed to emit_bits
  211.  * in one call, and we never retain more than 7 bits in put_buffer
  212.  * between calls, so 24 bits are sufficient.
  213.  */
  214. INLINE
  215. LOCAL(void)
  216. emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
  217. /* Emit some bits, unless we are in gather mode */
  218. {
  219.   /* This routine is heavily used, so it's worth coding tightly. */
  220.   register long put_buffer = (long) code;
  221.   register int put_bits = entropy->put_bits;
  222.   /* if size is 0, caller used an invalid Huffman table entry */
  223.   if (size == 0)
  224.     ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
  225.   if (entropy->gather_statistics)
  226.     return; /* do nothing if we're only getting stats */
  227.   put_buffer &= (((long) 1)<<size) - 1; /* mask off any extra bits in code */
  228.   
  229.   put_bits += size; /* new number of bits in buffer */
  230.   
  231.   put_buffer <<= 24 - put_bits; /* align incoming bits */
  232.   put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
  233.   while (put_bits >= 8) {
  234.     int c = (int) ((put_buffer >> 16) & 0xFF);
  235.     
  236.     emit_byte(entropy, c);
  237.     if (c == 0xFF) { /* need to stuff a zero byte? */
  238.       emit_byte(entropy, 0);
  239.     }
  240.     put_buffer <<= 8;
  241.     put_bits -= 8;
  242.   }
  243.   entropy->put_buffer = put_buffer; /* update variables */
  244.   entropy->put_bits = put_bits;
  245. }
  246. LOCAL(void)
  247. flush_bits (phuff_entropy_ptr entropy)
  248. {
  249.   emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
  250.   entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
  251.   entropy->put_bits = 0;
  252. }
  253. /*
  254.  * Emit (or just count) a Huffman symbol.
  255.  */
  256. INLINE
  257. LOCAL(void)
  258. emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
  259. {
  260.   if (entropy->gather_statistics)
  261.     entropy->count_ptrs[tbl_no][symbol]++;
  262.   else {
  263.     c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
  264.     emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
  265.   }
  266. }
  267. /*
  268.  * Emit bits from a correction bit buffer.
  269.  */
  270. LOCAL(void)
  271. emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
  272.     unsigned int nbits)
  273. {
  274.   if (entropy->gather_statistics)
  275.     return; /* no real work */
  276.   while (nbits > 0) {
  277.     emit_bits(entropy, (unsigned int) (*bufstart), 1);
  278.     bufstart++;
  279.     nbits--;
  280.   }
  281. }
  282. /*
  283.  * Emit any pending EOBRUN symbol.
  284.  */
  285. LOCAL(void)
  286. emit_eobrun (phuff_entropy_ptr entropy)
  287. {
  288.   register int temp, nbits;
  289.   if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */
  290.     temp = entropy->EOBRUN;
  291.     nbits = 0;
  292.     while ((temp >>= 1))
  293.       nbits++;
  294.     emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
  295.     if (nbits)
  296.       emit_bits(entropy, entropy->EOBRUN, nbits);
  297.     entropy->EOBRUN = 0;
  298.     /* Emit any buffered correction bits */
  299.     emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
  300.     entropy->BE = 0;
  301.   }
  302. }
  303. /*
  304.  * Emit a restart marker & resynchronize predictions.
  305.  */
  306. LOCAL(void)
  307. emit_restart (phuff_entropy_ptr entropy, int restart_num)
  308. {
  309.   int ci;
  310.   emit_eobrun(entropy);
  311.   if (! entropy->gather_statistics) {
  312.     flush_bits(entropy);
  313.     emit_byte(entropy, 0xFF);
  314.     emit_byte(entropy, JPEG_RST0 + restart_num);
  315.   }
  316.   if (entropy->cinfo->Ss == 0) {
  317.     /* Re-initialize DC predictions to 0 */
  318.     for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
  319.       entropy->last_dc_val[ci] = 0;
  320.   } else {
  321.     /* Re-initialize all AC-related fields to 0 */
  322.     entropy->EOBRUN = 0;
  323.     entropy->BE = 0;
  324.   }
  325. }
  326. /*
  327.  * MCU encoding for DC initial scan (either spectral selection,
  328.  * or first pass of successive approximation).
  329.  */
  330. METHODDEF(unsigned int)
  331. encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  332. {
  333.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  334.   register int temp, temp2;
  335.   register int nbits;
  336.   int blkn, ci;
  337.   int Al = cinfo->Al;
  338.   JBLOCKROW block;
  339.   jpeg_component_info * compptr;
  340.   ISHIFT_TEMPS
  341.   entropy->next_output_byte = cinfo->dest->next_output_byte;
  342.   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
  343.   /* Emit restart marker if needed */
  344.   if (cinfo->restart_interval)
  345.     if (entropy->restarts_to_go == 0)
  346.       emit_restart(entropy, entropy->next_restart_num);
  347.   /* Encode the MCU data blocks */
  348.   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
  349.     block = MCU_data[blkn];
  350.     ci = cinfo->MCU_membership[blkn];
  351.     compptr = cinfo->cur_comp_info[ci];
  352.     /* Compute the DC value after the required point transform by Al.
  353.      * This is simply an arithmetic right shift.
  354.      */
  355.     temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
  356.     /* DC differences are figured on the point-transformed values. */
  357.     temp = temp2 - entropy->last_dc_val[ci];
  358.     entropy->last_dc_val[ci] = temp2;
  359.     /* Encode the DC coefficient difference per section G.1.2.1 */
  360.     temp2 = temp;
  361.     if (temp < 0) {
  362.       temp = -temp; /* temp is abs value of input */
  363.       /* For a negative input, want temp2 = bitwise complement of abs(input) */
  364.       /* This code assumes we are on a two's complement machine */
  365.       temp2--;
  366.     }
  367.     
  368.     /* Find the number of bits needed for the magnitude of the coefficient */
  369.     nbits = 0;
  370.     while (temp) {
  371.       nbits++;
  372.       temp >>= 1;
  373.     }
  374.     
  375.     /* Count/emit the Huffman-coded symbol for the number of bits */
  376.     emit_symbol(entropy, compptr->dc_tbl_no, nbits);
  377.     
  378.     /* Emit that number of bits of the value, if positive, */
  379.     /* or the complement of its magnitude, if negative. */
  380.     if (nbits) /* emit_bits rejects calls with size 0 */
  381.       emit_bits(entropy, (unsigned int) temp2, nbits);
  382.   }
  383.   cinfo->dest->next_output_byte = entropy->next_output_byte;
  384.   cinfo->dest->free_in_buffer = entropy->free_in_buffer;
  385.   /* Update restart-interval state too */
  386.   if (cinfo->restart_interval) {
  387.     if (entropy->restarts_to_go == 0) {
  388.       entropy->restarts_to_go = cinfo->restart_interval;
  389.       entropy->next_restart_num++;
  390.       entropy->next_restart_num &= 7;
  391.     }
  392.     entropy->restarts_to_go--;
  393.   }
  394.   return TRUE;
  395. }
  396. /*
  397.  * MCU encoding for AC initial scan (either spectral selection,
  398.  * or first pass of successive approximation).
  399.  */
  400. METHODDEF(unsigned int)
  401. encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  402. {
  403.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  404.   register int temp, temp2;
  405.   register int nbits;
  406.   register int r, k;
  407.   int Se = cinfo->Se;
  408.   int Al = cinfo->Al;
  409.   JBLOCKROW block;
  410.   entropy->next_output_byte = cinfo->dest->next_output_byte;
  411.   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
  412.   /* Emit restart marker if needed */
  413.   if (cinfo->restart_interval)
  414.     if (entropy->restarts_to_go == 0)
  415.       emit_restart(entropy, entropy->next_restart_num);
  416.   /* Encode the MCU data block */
  417.   block = MCU_data[0];
  418.   /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
  419.   
  420.   r = 0; /* r = run length of zeros */
  421.    
  422.   for (k = cinfo->Ss; k <= Se; k++) {
  423.     if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
  424.       r++;
  425.       continue;
  426.     }
  427.     /* We must apply the point transform by Al.  For AC coefficients this
  428.      * is an integer division with rounding towards 0.  To do this portably
  429.      * in C, we shift after obtaining the absolute value; so the code is
  430.      * interwoven with finding the abs value (temp) and output bits (temp2).
  431.      */
  432.     if (temp < 0) {
  433.       temp = -temp; /* temp is abs value of input */
  434.       temp >>= Al; /* apply the point transform */
  435.       /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
  436.       temp2 = ~temp;
  437.     } else {
  438.       temp >>= Al; /* apply the point transform */
  439.       temp2 = temp;
  440.     }
  441.     /* Watch out for case that nonzero coef is zero after point transform */
  442.     if (temp == 0) {
  443.       r++;
  444.       continue;
  445.     }
  446.     /* Emit any pending EOBRUN */
  447.     if (entropy->EOBRUN > 0)
  448.       emit_eobrun(entropy);
  449.     /* if run length > 15, must emit special run-length-16 codes (0xF0) */
  450.     while (r > 15) {
  451.       emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
  452.       r -= 16;
  453.     }
  454.     /* Find the number of bits needed for the magnitude of the coefficient */
  455.     nbits = 1; /* there must be at least one 1 bit */
  456.     while ((temp >>= 1))
  457.       nbits++;
  458.     /* Count/emit Huffman symbol for run length / number of bits */
  459.     emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
  460.     /* Emit that number of bits of the value, if positive, */
  461.     /* or the complement of its magnitude, if negative. */
  462.     emit_bits(entropy, (unsigned int) temp2, nbits);
  463.     r = 0; /* reset zero run length */
  464.   }
  465.   if (r > 0) { /* If there are trailing zeroes, */
  466.     entropy->EOBRUN++; /* count an EOB */
  467.     if (entropy->EOBRUN == 0x7FFF)
  468.       emit_eobrun(entropy); /* force it out to avoid overflow */
  469.   }
  470.   cinfo->dest->next_output_byte = entropy->next_output_byte;
  471.   cinfo->dest->free_in_buffer = entropy->free_in_buffer;
  472.   /* Update restart-interval state too */
  473.   if (cinfo->restart_interval) {
  474.     if (entropy->restarts_to_go == 0) {
  475.       entropy->restarts_to_go = cinfo->restart_interval;
  476.       entropy->next_restart_num++;
  477.       entropy->next_restart_num &= 7;
  478.     }
  479.     entropy->restarts_to_go--;
  480.   }
  481.   return TRUE;
  482. }
  483. /*
  484.  * MCU encoding for DC successive approximation refinement scan.
  485.  * Note: we assume such scans can be multi-component, although the spec
  486.  * is not very clear on the point.
  487.  */
  488. METHODDEF(unsigned int)
  489. encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  490. {
  491.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  492.   register int temp;
  493.   int blkn;
  494.   int Al = cinfo->Al;
  495.   JBLOCKROW block;
  496.   entropy->next_output_byte = cinfo->dest->next_output_byte;
  497.   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
  498.   /* Emit restart marker if needed */
  499.   if (cinfo->restart_interval)
  500.     if (entropy->restarts_to_go == 0)
  501.       emit_restart(entropy, entropy->next_restart_num);
  502.   /* Encode the MCU data blocks */
  503.   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
  504.     block = MCU_data[blkn];
  505.     /* We simply emit the Al'th bit of the DC coefficient value. */
  506.     temp = (*block)[0];
  507.     emit_bits(entropy, (unsigned int) (temp >> Al), 1);
  508.   }
  509.   cinfo->dest->next_output_byte = entropy->next_output_byte;
  510.   cinfo->dest->free_in_buffer = entropy->free_in_buffer;
  511.   /* Update restart-interval state too */
  512.   if (cinfo->restart_interval) {
  513.     if (entropy->restarts_to_go == 0) {
  514.       entropy->restarts_to_go = cinfo->restart_interval;
  515.       entropy->next_restart_num++;
  516.       entropy->next_restart_num &= 7;
  517.     }
  518.     entropy->restarts_to_go--;
  519.   }
  520.   return TRUE;
  521. }
  522. /*
  523.  * MCU encoding for AC successive approximation refinement scan.
  524.  */
  525. METHODDEF(unsigned int)
  526. encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
  527. {
  528.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  529.   register int temp;
  530.   register int r, k;
  531.   int EOB;
  532.   char *BR_buffer;
  533.   unsigned int BR;
  534.   int Se = cinfo->Se;
  535.   int Al = cinfo->Al;
  536.   JBLOCKROW block;
  537.   int absvalues[DCTSIZE2];
  538.   entropy->next_output_byte = cinfo->dest->next_output_byte;
  539.   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
  540.   /* Emit restart marker if needed */
  541.   if (cinfo->restart_interval)
  542.     if (entropy->restarts_to_go == 0)
  543.       emit_restart(entropy, entropy->next_restart_num);
  544.   /* Encode the MCU data block */
  545.   block = MCU_data[0];
  546.   /* It is convenient to make a pre-pass to determine the transformed
  547.    * coefficients' absolute values and the EOB position.
  548.    */
  549.   EOB = 0;
  550.   for (k = cinfo->Ss; k <= Se; k++) {
  551.     temp = (*block)[jpeg_natural_order[k]];
  552.     /* We must apply the point transform by Al.  For AC coefficients this
  553.      * is an integer division with rounding towards 0.  To do this portably
  554.      * in C, we shift after obtaining the absolute value.
  555.      */
  556.     if (temp < 0)
  557.       temp = -temp; /* temp is abs value of input */
  558.     temp >>= Al; /* apply the point transform */
  559.     absvalues[k] = temp; /* save abs value for main pass */
  560.     if (temp == 1)
  561.       EOB = k; /* EOB = index of last newly-nonzero coef */
  562.   }
  563.   /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
  564.   
  565.   r = 0; /* r = run length of zeros */
  566.   BR = 0; /* BR = count of buffered bits added now */
  567.   BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
  568.   for (k = cinfo->Ss; k <= Se; k++) {
  569.     if ((temp = absvalues[k]) == 0) {
  570.       r++;
  571.       continue;
  572.     }
  573.     /* Emit any required ZRLs, but not if they can be folded into EOB */
  574.     while (r > 15 && k <= EOB) {
  575.       /* emit any pending EOBRUN and the BE correction bits */
  576.       emit_eobrun(entropy);
  577.       /* Emit ZRL */
  578.       emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
  579.       r -= 16;
  580.       /* Emit buffered correction bits that must be associated with ZRL */
  581.       emit_buffered_bits(entropy, BR_buffer, BR);
  582.       BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
  583.       BR = 0;
  584.     }
  585.     /* If the coef was previously nonzero, it only needs a correction bit.
  586.      * NOTE: a straight translation of the spec's figure G.7 would suggest
  587.      * that we also need to test r > 15.  But if r > 15, we can only get here
  588.      * if k > EOB, which implies that this coefficient is not 1.
  589.      */
  590.     if (temp > 1) {
  591.       /* The correction bit is the next bit of the absolute value. */
  592.       BR_buffer[BR++] = (char) (temp & 1);
  593.       continue;
  594.     }
  595.     /* Emit any pending EOBRUN and the BE correction bits */
  596.     emit_eobrun(entropy);
  597.     /* Count/emit Huffman symbol for run length / number of bits */
  598.     emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
  599.     /* Emit output bit for newly-nonzero coef */
  600.     temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
  601.     emit_bits(entropy, (unsigned int) temp, 1);
  602.     /* Emit buffered correction bits that must be associated with this code */
  603.     emit_buffered_bits(entropy, BR_buffer, BR);
  604.     BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
  605.     BR = 0;
  606.     r = 0; /* reset zero run length */
  607.   }
  608.   if (r > 0 || BR > 0) { /* If there are trailing zeroes, */
  609.     entropy->EOBRUN++; /* count an EOB */
  610.     entropy->BE += BR; /* concat my correction bits to older ones */
  611.     /* We force out the EOB if we risk either:
  612.      * 1. overflow of the EOB counter;
  613.      * 2. overflow of the correction bit buffer during the next MCU.
  614.      */
  615.     if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
  616.       emit_eobrun(entropy);
  617.   }
  618.   cinfo->dest->next_output_byte = entropy->next_output_byte;
  619.   cinfo->dest->free_in_buffer = entropy->free_in_buffer;
  620.   /* Update restart-interval state too */
  621.   if (cinfo->restart_interval) {
  622.     if (entropy->restarts_to_go == 0) {
  623.       entropy->restarts_to_go = cinfo->restart_interval;
  624.       entropy->next_restart_num++;
  625.       entropy->next_restart_num &= 7;
  626.     }
  627.     entropy->restarts_to_go--;
  628.   }
  629.   return TRUE;
  630. }
  631. /*
  632.  * Finish up at the end of a Huffman-compressed progressive scan.
  633.  */
  634. METHODDEF(void)
  635. finish_pass_phuff (j_compress_ptr cinfo)
  636. {   
  637.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  638.   entropy->next_output_byte = cinfo->dest->next_output_byte;
  639.   entropy->free_in_buffer = cinfo->dest->free_in_buffer;
  640.   /* Flush out any buffered data */
  641.   emit_eobrun(entropy);
  642.   flush_bits(entropy);
  643.   cinfo->dest->next_output_byte = entropy->next_output_byte;
  644.   cinfo->dest->free_in_buffer = entropy->free_in_buffer;
  645. }
  646. /*
  647.  * Finish up a statistics-gathering pass and create the new Huffman tables.
  648.  */
  649. METHODDEF(void)
  650. finish_pass_gather_phuff (j_compress_ptr cinfo)
  651. {
  652.   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  653.   unsigned int is_DC_band;
  654.   int ci, tbl;
  655.   jpeg_component_info * compptr;
  656.   JHUFF_TBL **htblptr;
  657.   unsigned int did[NUM_HUFF_TBLS];
  658.   /* Flush out buffered data (all we care about is counting the EOB symbol) */
  659.   emit_eobrun(entropy);
  660.   is_DC_band = (cinfo->Ss == 0);
  661.   /* It's important not to apply jpeg_gen_optimal_table more than once
  662.    * per table, because it clobbers the input frequency counts!
  663.    */
  664.   MEMZERO(did, SIZEOF(did));
  665.   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  666.     compptr = cinfo->cur_comp_info[ci];
  667.     if (is_DC_band) {
  668.       if (cinfo->Ah != 0) /* DC refinement needs no table */
  669. continue;
  670.       tbl = compptr->dc_tbl_no;
  671.     } else {
  672.       tbl = compptr->ac_tbl_no;
  673.     }
  674.     if (! did[tbl]) {
  675.       if (is_DC_band)
  676.         htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
  677.       else
  678.         htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
  679.       if (*htblptr == NULL)
  680.         *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
  681.       jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
  682.       did[tbl] = TRUE;
  683.     }
  684.   }
  685. }
  686. /*
  687.  * Module initialization routine for progressive Huffman entropy encoding.
  688.  */
  689. GLOBAL(void)
  690. jinit_phuff_encoder (j_compress_ptr cinfo)
  691. {
  692.   phuff_entropy_ptr entropy;
  693.   int i;
  694.   entropy = (phuff_entropy_ptr)
  695.     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  696. SIZEOF(phuff_entropy_encoder));
  697.   cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
  698.   entropy->pub.start_pass = start_pass_phuff;
  699.   /* Mark tables unallocated */
  700.   for (i = 0; i < NUM_HUFF_TBLS; i++) {
  701.     entropy->derived_tbls[i] = NULL;
  702.     entropy->count_ptrs[i] = NULL;
  703.   }
  704.   entropy->bit_buffer = NULL; /* needed only in AC refinement scan */
  705. }
  706. #endif /* C_PROGRESSIVE_SUPPORTED */