Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * jcarith.c |
| 3 | * |
DRC | 5de454b | 2014-05-18 19:04:03 +0000 | [diff] [blame] | 4 | * This file was part of the Independent JPEG Group's software: |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 5 | * Developed 1997-2009 by Guido Vollbeding. |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 6 | * libjpeg-turbo Modifications: |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 7 | * Copyright (C) 2015, 2018, D. R. Commander. |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 8 | * For conditions of distribution and use, see the accompanying README.ijg |
| 9 | * file. |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 10 | * |
| 11 | * This file contains portable arithmetic entropy encoding routines for JPEG |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 12 | * (implementing Recommendation ITU-T T.81 | ISO/IEC 10918-1). |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 13 | * |
| 14 | * Both sequential and progressive modes are supported in this single module. |
| 15 | * |
| 16 | * Suspension is not currently supported in this module. |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 17 | * |
| 18 | * NOTE: All referenced figures are from |
| 19 | * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994. |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 20 | */ |
| 21 | |
| 22 | #define JPEG_INTERNALS |
| 23 | #include "jinclude.h" |
| 24 | #include "jpeglib.h" |
| 25 | |
| 26 | |
| 27 | /* Expanded entropy encoder object for arithmetic encoding. */ |
| 28 | |
| 29 | typedef struct { |
| 30 | struct jpeg_entropy_encoder pub; /* public fields */ |
| 31 | |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 32 | JLONG c; /* C register, base of coding interval, layout as in sec. D.1.3 */ |
| 33 | JLONG a; /* A register, normalized size of coding interval */ |
| 34 | JLONG sc; /* counter for stacked 0xFF values which might overflow */ |
| 35 | JLONG zc; /* counter for pending 0x00 output values which might * |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 36 | * be discarded at the end ("Pacman" termination) */ |
| 37 | int ct; /* bit shift counter, determines when next byte will be written */ |
| 38 | int buffer; /* buffer for most recent output byte != 0xFF */ |
| 39 | |
| 40 | int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ |
| 41 | int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */ |
| 42 | |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 43 | unsigned int restarts_to_go; /* MCUs left in this restart interval */ |
| 44 | int next_restart_num; /* next restart number to write (0-7) */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 45 | |
| 46 | /* Pointers to statistics areas (these workspaces have image lifespan) */ |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 47 | unsigned char *dc_stats[NUM_ARITH_TBLS]; |
| 48 | unsigned char *ac_stats[NUM_ARITH_TBLS]; |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 49 | |
| 50 | /* Statistics bin for coding with fixed probability 0.5 */ |
| 51 | unsigned char fixed_bin[4]; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 52 | } arith_entropy_encoder; |
| 53 | |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 54 | typedef arith_entropy_encoder *arith_entropy_ptr; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 55 | |
| 56 | /* The following two definitions specify the allocation chunk size |
| 57 | * for the statistics area. |
| 58 | * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least |
| 59 | * 49 statistics bins for DC, and 245 statistics bins for AC coding. |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 60 | * |
| 61 | * We use a compact representation with 1 byte per statistics bin, |
| 62 | * thus the numbers directly represent byte sizes. |
| 63 | * This 1 byte per statistics bin contains the meaning of the MPS |
| 64 | * (more probable symbol) in the highest bit (mask 0x80), and the |
| 65 | * index into the probability estimation state machine table |
| 66 | * in the lower bits (mask 0x7F). |
| 67 | */ |
| 68 | |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 69 | #define DC_STAT_BINS 64 |
| 70 | #define AC_STAT_BINS 256 |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 71 | |
| 72 | /* NOTE: Uncomment the following #define if you want to use the |
| 73 | * given formula for calculating the AC conditioning parameter Kx |
| 74 | * for spectral selection progressive coding in section G.1.3.2 |
| 75 | * of the spec (Kx = Kmin + SRL (8 + Se - Kmin) 4). |
| 76 | * Although the spec and P&M authors claim that this "has proven |
| 77 | * to give good results for 8 bit precision samples", I'm not |
| 78 | * convinced yet that this is really beneficial. |
| 79 | * Early tests gave only very marginal compression enhancements |
| 80 | * (a few - around 5 or so - bytes even for very large files), |
| 81 | * which would turn out rather negative if we'd suppress the |
| 82 | * DAC (Define Arithmetic Conditioning) marker segments for |
| 83 | * the default parameters in the future. |
| 84 | * Note that currently the marker writing module emits 12-byte |
| 85 | * DAC segments for a full-component scan in a color image. |
| 86 | * This is not worth worrying about IMHO. However, since the |
| 87 | * spec defines the default values to be used if the tables |
| 88 | * are omitted (unlike Huffman tables, which are required |
| 89 | * anyway), one might optimize this behaviour in the future, |
| 90 | * and then it would be disadvantageous to use custom tables if |
| 91 | * they don't provide sufficient gain to exceed the DAC size. |
| 92 | * |
| 93 | * On the other hand, I'd consider it as a reasonable result |
| 94 | * that the conditioning has no significant influence on the |
| 95 | * compression performance. This means that the basic |
| 96 | * statistical model is already rather stable. |
| 97 | * |
| 98 | * Thus, at the moment, we use the default conditioning values |
| 99 | * anyway, and do not use the custom formula. |
| 100 | * |
| 101 | #define CALCULATE_SPECTRAL_CONDITIONING |
| 102 | */ |
| 103 | |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 104 | /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than JLONG. |
| 105 | * We assume that int right shift is unsigned if JLONG right shift is, |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 106 | * which should be safe. |
| 107 | */ |
| 108 | |
| 109 | #ifdef RIGHT_SHIFT_IS_UNSIGNED |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 110 | #define ISHIFT_TEMPS int ishift_temp; |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 111 | #define IRIGHT_SHIFT(x, shft) \ |
| 112 | ((ishift_temp = (x)) < 0 ? \ |
| 113 | (ishift_temp >> (shft)) | ((~0) << (16 - (shft))) : \ |
| 114 | (ishift_temp >> (shft))) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 115 | #else |
| 116 | #define ISHIFT_TEMPS |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 117 | #define IRIGHT_SHIFT(x, shft) ((x) >> (shft)) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 118 | #endif |
| 119 | |
| 120 | |
| 121 | LOCAL(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 122 | emit_byte(int val, j_compress_ptr cinfo) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 123 | /* Write next output byte; we do not support suspension in this module. */ |
| 124 | { |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 125 | struct jpeg_destination_mgr *dest = cinfo->dest; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 126 | |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 127 | *dest->next_output_byte++ = (JOCTET)val; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 128 | if (--dest->free_in_buffer == 0) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 129 | if (!(*dest->empty_output_buffer) (cinfo)) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 130 | ERREXIT(cinfo, JERR_CANT_SUSPEND); |
| 131 | } |
| 132 | |
| 133 | |
| 134 | /* |
| 135 | * Finish up at the end of an arithmetic-compressed scan. |
| 136 | */ |
| 137 | |
| 138 | METHODDEF(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 139 | finish_pass(j_compress_ptr cinfo) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 140 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 141 | arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy; |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 142 | JLONG temp; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 143 | |
| 144 | /* Section D.1.8: Termination of encoding */ |
| 145 | |
| 146 | /* Find the e->c in the coding interval with the largest |
| 147 | * number of trailing zero bits */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 148 | if ((temp = (e->a - 1 + e->c) & 0xFFFF0000UL) < e->c) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 149 | e->c = temp + 0x8000L; |
| 150 | else |
| 151 | e->c = temp; |
| 152 | /* Send remaining bytes to output */ |
| 153 | e->c <<= e->ct; |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 154 | if (e->c & 0xF8000000UL) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 155 | /* One final overflow has to be handled */ |
| 156 | if (e->buffer >= 0) { |
| 157 | if (e->zc) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 158 | do emit_byte(0x00, cinfo); |
| 159 | while (--e->zc); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 160 | emit_byte(e->buffer + 1, cinfo); |
| 161 | if (e->buffer + 1 == 0xFF) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 162 | emit_byte(0x00, cinfo); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 163 | } |
| 164 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ |
| 165 | e->sc = 0; |
| 166 | } else { |
| 167 | if (e->buffer == 0) |
| 168 | ++e->zc; |
| 169 | else if (e->buffer >= 0) { |
| 170 | if (e->zc) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 171 | do emit_byte(0x00, cinfo); |
| 172 | while (--e->zc); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 173 | emit_byte(e->buffer, cinfo); |
| 174 | } |
| 175 | if (e->sc) { |
| 176 | if (e->zc) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 177 | do emit_byte(0x00, cinfo); |
| 178 | while (--e->zc); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 179 | do { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 180 | emit_byte(0xFF, cinfo); |
| 181 | emit_byte(0x00, cinfo); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 182 | } while (--e->sc); |
| 183 | } |
| 184 | } |
| 185 | /* Output final bytes only if they are not 0x00 */ |
| 186 | if (e->c & 0x7FFF800L) { |
| 187 | if (e->zc) /* output final pending zero bytes */ |
| 188 | do emit_byte(0x00, cinfo); |
| 189 | while (--e->zc); |
| 190 | emit_byte((e->c >> 19) & 0xFF, cinfo); |
| 191 | if (((e->c >> 19) & 0xFF) == 0xFF) |
| 192 | emit_byte(0x00, cinfo); |
| 193 | if (e->c & 0x7F800L) { |
| 194 | emit_byte((e->c >> 11) & 0xFF, cinfo); |
| 195 | if (((e->c >> 11) & 0xFF) == 0xFF) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 196 | emit_byte(0x00, cinfo); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 197 | } |
| 198 | } |
| 199 | } |
| 200 | |
| 201 | |
| 202 | /* |
| 203 | * The core arithmetic encoding routine (common in JPEG and JBIG). |
| 204 | * This needs to go as fast as possible. |
| 205 | * Machine-dependent optimization facilities |
| 206 | * are not utilized in this portable implementation. |
| 207 | * However, this code should be fairly efficient and |
| 208 | * may be a good base for further optimizations anyway. |
| 209 | * |
| 210 | * Parameter 'val' to be encoded may be 0 or 1 (binary decision). |
| 211 | * |
| 212 | * Note: I've added full "Pacman" termination support to the |
| 213 | * byte output routines, which is equivalent to the optional |
| 214 | * Discard_final_zeros procedure (Figure D.15) in the spec. |
| 215 | * Thus, we always produce the shortest possible output |
| 216 | * stream compliant to the spec (no trailing zero bytes, |
| 217 | * except for FF stuffing). |
| 218 | * |
| 219 | * I've also introduced a new scheme for accessing |
| 220 | * the probability estimation state machine table, |
| 221 | * derived from Markus Kuhn's JBIG implementation. |
| 222 | */ |
| 223 | |
| 224 | LOCAL(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 225 | arith_encode(j_compress_ptr cinfo, unsigned char *st, int val) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 226 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 227 | register arith_entropy_ptr e = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 228 | register unsigned char nl, nm; |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 229 | register JLONG qe, temp; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 230 | register int sv; |
| 231 | |
| 232 | /* Fetch values from our compact representation of Table D.2: |
| 233 | * Qe values and probability estimation state machine |
| 234 | */ |
| 235 | sv = *st; |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 236 | qe = jpeg_aritab[sv & 0x7F]; /* => Qe_Value */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 237 | nl = qe & 0xFF; qe >>= 8; /* Next_Index_LPS + Switch_MPS */ |
| 238 | nm = qe & 0xFF; qe >>= 8; /* Next_Index_MPS */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 239 | |
| 240 | /* Encode & estimation procedures per sections D.1.4 & D.1.5 */ |
| 241 | e->a -= qe; |
| 242 | if (val != (sv >> 7)) { |
| 243 | /* Encode the less probable symbol */ |
| 244 | if (e->a >= qe) { |
| 245 | /* If the interval size (qe) for the less probable symbol (LPS) |
| 246 | * is larger than the interval size for the MPS, then exchange |
| 247 | * the two symbols for coding efficiency, otherwise code the LPS |
| 248 | * as usual: */ |
| 249 | e->c += e->a; |
| 250 | e->a = qe; |
| 251 | } |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 252 | *st = (sv & 0x80) ^ nl; /* Estimate_after_LPS */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 253 | } else { |
| 254 | /* Encode the more probable symbol */ |
| 255 | if (e->a >= 0x8000L) |
| 256 | return; /* A >= 0x8000 -> ready, no renormalization required */ |
| 257 | if (e->a < qe) { |
| 258 | /* If the interval size (qe) for the less probable symbol (LPS) |
| 259 | * is larger than the interval size for the MPS, then exchange |
| 260 | * the two symbols for coding efficiency: */ |
| 261 | e->c += e->a; |
| 262 | e->a = qe; |
| 263 | } |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 264 | *st = (sv & 0x80) ^ nm; /* Estimate_after_MPS */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | /* Renormalization & data output per section D.1.6 */ |
| 268 | do { |
| 269 | e->a <<= 1; |
| 270 | e->c <<= 1; |
| 271 | if (--e->ct == 0) { |
| 272 | /* Another byte is ready for output */ |
| 273 | temp = e->c >> 19; |
| 274 | if (temp > 0xFF) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 275 | /* Handle overflow over all stacked 0xFF bytes */ |
| 276 | if (e->buffer >= 0) { |
| 277 | if (e->zc) |
| 278 | do emit_byte(0x00, cinfo); |
| 279 | while (--e->zc); |
| 280 | emit_byte(e->buffer + 1, cinfo); |
| 281 | if (e->buffer + 1 == 0xFF) |
| 282 | emit_byte(0x00, cinfo); |
| 283 | } |
| 284 | e->zc += e->sc; /* carry-over converts stacked 0xFF bytes to 0x00 */ |
| 285 | e->sc = 0; |
| 286 | /* Note: The 3 spacer bits in the C register guarantee |
| 287 | * that the new buffer byte can't be 0xFF here |
| 288 | * (see page 160 in the P&M JPEG book). */ |
| 289 | e->buffer = temp & 0xFF; /* new output byte, might overflow later */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 290 | } else if (temp == 0xFF) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 291 | ++e->sc; /* stack 0xFF byte (which might overflow later) */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 292 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 293 | /* Output all stacked 0xFF bytes, they will not overflow any more */ |
| 294 | if (e->buffer == 0) |
| 295 | ++e->zc; |
| 296 | else if (e->buffer >= 0) { |
| 297 | if (e->zc) |
| 298 | do emit_byte(0x00, cinfo); |
| 299 | while (--e->zc); |
| 300 | emit_byte(e->buffer, cinfo); |
| 301 | } |
| 302 | if (e->sc) { |
| 303 | if (e->zc) |
| 304 | do emit_byte(0x00, cinfo); |
| 305 | while (--e->zc); |
| 306 | do { |
| 307 | emit_byte(0xFF, cinfo); |
| 308 | emit_byte(0x00, cinfo); |
| 309 | } while (--e->sc); |
| 310 | } |
| 311 | e->buffer = temp & 0xFF; /* new output byte (can still overflow) */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 312 | } |
| 313 | e->c &= 0x7FFFFL; |
| 314 | e->ct += 8; |
| 315 | } |
| 316 | } while (e->a < 0x8000L); |
| 317 | } |
| 318 | |
| 319 | |
| 320 | /* |
| 321 | * Emit a restart marker & resynchronize predictions. |
| 322 | */ |
| 323 | |
| 324 | LOCAL(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 325 | emit_restart(j_compress_ptr cinfo, int restart_num) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 326 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 327 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 328 | int ci; |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 329 | jpeg_component_info *compptr; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 330 | |
| 331 | finish_pass(cinfo); |
| 332 | |
| 333 | emit_byte(0xFF, cinfo); |
| 334 | emit_byte(JPEG_RST0 + restart_num, cinfo); |
| 335 | |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 336 | /* Re-initialize statistics areas */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 337 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
| 338 | compptr = cinfo->cur_comp_info[ci]; |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 339 | /* DC needs no table for refinement scan */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 340 | if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 341 | MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS); |
| 342 | /* Reset DC predictions to 0 */ |
| 343 | entropy->last_dc_val[ci] = 0; |
| 344 | entropy->dc_context[ci] = 0; |
| 345 | } |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 346 | /* AC needs no table when not present */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 347 | if (cinfo->progressive_mode == 0 || cinfo->Se) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 348 | MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS); |
| 349 | } |
| 350 | } |
| 351 | |
| 352 | /* Reset arithmetic encoding variables */ |
| 353 | entropy->c = 0; |
| 354 | entropy->a = 0x10000L; |
| 355 | entropy->sc = 0; |
| 356 | entropy->zc = 0; |
| 357 | entropy->ct = 11; |
| 358 | entropy->buffer = -1; /* empty */ |
| 359 | } |
| 360 | |
| 361 | |
| 362 | /* |
| 363 | * MCU encoding for DC initial scan (either spectral selection, |
| 364 | * or first pass of successive approximation). |
| 365 | */ |
| 366 | |
| 367 | METHODDEF(boolean) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 368 | encode_mcu_DC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 369 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 370 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 371 | JBLOCKROW block; |
| 372 | unsigned char *st; |
| 373 | int blkn, ci, tbl; |
| 374 | int v, v2, m; |
| 375 | ISHIFT_TEMPS |
| 376 | |
| 377 | /* Emit restart marker if needed */ |
| 378 | if (cinfo->restart_interval) { |
| 379 | if (entropy->restarts_to_go == 0) { |
| 380 | emit_restart(cinfo, entropy->next_restart_num); |
| 381 | entropy->restarts_to_go = cinfo->restart_interval; |
| 382 | entropy->next_restart_num++; |
| 383 | entropy->next_restart_num &= 7; |
| 384 | } |
| 385 | entropy->restarts_to_go--; |
| 386 | } |
| 387 | |
| 388 | /* Encode the MCU data blocks */ |
| 389 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
| 390 | block = MCU_data[blkn]; |
| 391 | ci = cinfo->MCU_membership[blkn]; |
| 392 | tbl = cinfo->cur_comp_info[ci]->dc_tbl_no; |
| 393 | |
| 394 | /* Compute the DC value after the required point transform by Al. |
| 395 | * This is simply an arithmetic right shift. |
| 396 | */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 397 | m = IRIGHT_SHIFT((int)((*block)[0]), cinfo->Al); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 398 | |
| 399 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ |
| 400 | |
| 401 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ |
| 402 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; |
| 403 | |
| 404 | /* Figure F.4: Encode_DC_DIFF */ |
| 405 | if ((v = m - entropy->last_dc_val[ci]) == 0) { |
| 406 | arith_encode(cinfo, st, 0); |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 407 | entropy->dc_context[ci] = 0; /* zero diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 408 | } else { |
| 409 | entropy->last_dc_val[ci] = m; |
| 410 | arith_encode(cinfo, st, 1); |
| 411 | /* Figure F.6: Encoding nonzero value v */ |
| 412 | /* Figure F.7: Encoding the sign of v */ |
| 413 | if (v > 0) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 414 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ |
| 415 | st += 2; /* Table F.4: SP = S0 + 2 */ |
| 416 | entropy->dc_context[ci] = 4; /* small positive diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 417 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 418 | v = -v; |
| 419 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ |
| 420 | st += 3; /* Table F.4: SN = S0 + 3 */ |
| 421 | entropy->dc_context[ci] = 8; /* small negative diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 422 | } |
| 423 | /* Figure F.8: Encoding the magnitude category of v */ |
| 424 | m = 0; |
| 425 | if (v -= 1) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 426 | arith_encode(cinfo, st, 1); |
| 427 | m = 1; |
| 428 | v2 = v; |
| 429 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ |
| 430 | while (v2 >>= 1) { |
| 431 | arith_encode(cinfo, st, 1); |
| 432 | m <<= 1; |
| 433 | st += 1; |
| 434 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 435 | } |
| 436 | arith_encode(cinfo, st, 0); |
| 437 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 438 | if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1)) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 439 | entropy->dc_context[ci] = 0; /* zero diff category */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 440 | else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1)) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 441 | entropy->dc_context[ci] += 8; /* large diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 442 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
| 443 | st += 14; |
| 444 | while (m >>= 1) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 445 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 446 | } |
| 447 | } |
| 448 | |
| 449 | return TRUE; |
| 450 | } |
| 451 | |
| 452 | |
| 453 | /* |
| 454 | * MCU encoding for AC initial scan (either spectral selection, |
| 455 | * or first pass of successive approximation). |
| 456 | */ |
| 457 | |
| 458 | METHODDEF(boolean) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 459 | encode_mcu_AC_first(j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 460 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 461 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 462 | JBLOCKROW block; |
| 463 | unsigned char *st; |
| 464 | int tbl, k, ke; |
| 465 | int v, v2, m; |
| 466 | |
| 467 | /* Emit restart marker if needed */ |
| 468 | if (cinfo->restart_interval) { |
| 469 | if (entropy->restarts_to_go == 0) { |
| 470 | emit_restart(cinfo, entropy->next_restart_num); |
| 471 | entropy->restarts_to_go = cinfo->restart_interval; |
| 472 | entropy->next_restart_num++; |
| 473 | entropy->next_restart_num &= 7; |
| 474 | } |
| 475 | entropy->restarts_to_go--; |
| 476 | } |
| 477 | |
| 478 | /* Encode the MCU data block */ |
| 479 | block = MCU_data[0]; |
| 480 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; |
| 481 | |
| 482 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ |
| 483 | |
| 484 | /* Establish EOB (end-of-block) index */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 485 | for (ke = cinfo->Se; ke > 0; ke--) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 486 | /* We must apply the point transform by Al. For AC coefficients this |
| 487 | * is an integer division with rounding towards 0. To do this portably |
| 488 | * in C, we shift after obtaining the absolute value. |
| 489 | */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 490 | if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 491 | if (v >>= cinfo->Al) break; |
| 492 | } else { |
| 493 | v = -v; |
| 494 | if (v >>= cinfo->Al) break; |
| 495 | } |
| 496 | |
| 497 | /* Figure F.5: Encode_AC_Coefficients */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 498 | for (k = cinfo->Ss; k <= ke; k++) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 499 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 500 | arith_encode(cinfo, st, 0); /* EOB decision */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 501 | for (;;) { |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 502 | if ((v = (*block)[jpeg_natural_order[k]]) >= 0) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 503 | if (v >>= cinfo->Al) { |
| 504 | arith_encode(cinfo, st + 1, 1); |
| 505 | arith_encode(cinfo, entropy->fixed_bin, 0); |
| 506 | break; |
| 507 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 508 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 509 | v = -v; |
| 510 | if (v >>= cinfo->Al) { |
| 511 | arith_encode(cinfo, st + 1, 1); |
| 512 | arith_encode(cinfo, entropy->fixed_bin, 1); |
| 513 | break; |
| 514 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 515 | } |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 516 | arith_encode(cinfo, st + 1, 0); st += 3; k++; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 517 | } |
| 518 | st += 2; |
| 519 | /* Figure F.8: Encoding the magnitude category of v */ |
| 520 | m = 0; |
| 521 | if (v -= 1) { |
| 522 | arith_encode(cinfo, st, 1); |
| 523 | m = 1; |
| 524 | v2 = v; |
| 525 | if (v2 >>= 1) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 526 | arith_encode(cinfo, st, 1); |
| 527 | m <<= 1; |
| 528 | st = entropy->ac_stats[tbl] + |
| 529 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); |
| 530 | while (v2 >>= 1) { |
| 531 | arith_encode(cinfo, st, 1); |
| 532 | m <<= 1; |
| 533 | st += 1; |
| 534 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 535 | } |
| 536 | } |
| 537 | arith_encode(cinfo, st, 0); |
| 538 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
| 539 | st += 14; |
| 540 | while (m >>= 1) |
| 541 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
| 542 | } |
| 543 | /* Encode EOB decision only if k <= cinfo->Se */ |
| 544 | if (k <= cinfo->Se) { |
| 545 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
| 546 | arith_encode(cinfo, st, 1); |
| 547 | } |
| 548 | |
| 549 | return TRUE; |
| 550 | } |
| 551 | |
| 552 | |
| 553 | /* |
| 554 | * MCU encoding for DC successive approximation refinement scan. |
| 555 | */ |
| 556 | |
| 557 | METHODDEF(boolean) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 558 | encode_mcu_DC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 559 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 560 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 561 | unsigned char *st; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 562 | int Al, blkn; |
| 563 | |
| 564 | /* Emit restart marker if needed */ |
| 565 | if (cinfo->restart_interval) { |
| 566 | if (entropy->restarts_to_go == 0) { |
| 567 | emit_restart(cinfo, entropy->next_restart_num); |
| 568 | entropy->restarts_to_go = cinfo->restart_interval; |
| 569 | entropy->next_restart_num++; |
| 570 | entropy->next_restart_num &= 7; |
| 571 | } |
| 572 | entropy->restarts_to_go--; |
| 573 | } |
| 574 | |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 575 | st = entropy->fixed_bin; /* use fixed probability estimation */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 576 | Al = cinfo->Al; |
| 577 | |
| 578 | /* Encode the MCU data blocks */ |
| 579 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 580 | /* We simply emit the Al'th bit of the DC coefficient value. */ |
| 581 | arith_encode(cinfo, st, (MCU_data[blkn][0][0] >> Al) & 1); |
| 582 | } |
| 583 | |
| 584 | return TRUE; |
| 585 | } |
| 586 | |
| 587 | |
| 588 | /* |
| 589 | * MCU encoding for AC successive approximation refinement scan. |
| 590 | */ |
| 591 | |
| 592 | METHODDEF(boolean) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 593 | encode_mcu_AC_refine(j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 594 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 595 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 596 | JBLOCKROW block; |
| 597 | unsigned char *st; |
| 598 | int tbl, k, ke, kex; |
| 599 | int v; |
| 600 | |
| 601 | /* Emit restart marker if needed */ |
| 602 | if (cinfo->restart_interval) { |
| 603 | if (entropy->restarts_to_go == 0) { |
| 604 | emit_restart(cinfo, entropy->next_restart_num); |
| 605 | entropy->restarts_to_go = cinfo->restart_interval; |
| 606 | entropy->next_restart_num++; |
| 607 | entropy->next_restart_num &= 7; |
| 608 | } |
| 609 | entropy->restarts_to_go--; |
| 610 | } |
| 611 | |
| 612 | /* Encode the MCU data block */ |
| 613 | block = MCU_data[0]; |
| 614 | tbl = cinfo->cur_comp_info[0]->ac_tbl_no; |
| 615 | |
| 616 | /* Section G.1.3.3: Encoding of AC coefficients */ |
| 617 | |
| 618 | /* Establish EOB (end-of-block) index */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 619 | for (ke = cinfo->Se; ke > 0; ke--) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 620 | /* We must apply the point transform by Al. For AC coefficients this |
| 621 | * is an integer division with rounding towards 0. To do this portably |
| 622 | * in C, we shift after obtaining the absolute value. |
| 623 | */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 624 | if ((v = (*block)[jpeg_natural_order[ke]]) >= 0) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 625 | if (v >>= cinfo->Al) break; |
| 626 | } else { |
| 627 | v = -v; |
| 628 | if (v >>= cinfo->Al) break; |
| 629 | } |
| 630 | |
| 631 | /* Establish EOBx (previous stage end-of-block) index */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 632 | for (kex = ke; kex > 0; kex--) |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 633 | if ((v = (*block)[jpeg_natural_order[kex]]) >= 0) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 634 | if (v >>= cinfo->Ah) break; |
| 635 | } else { |
| 636 | v = -v; |
| 637 | if (v >>= cinfo->Ah) break; |
| 638 | } |
| 639 | |
| 640 | /* Figure G.10: Encode_AC_Coefficients_SA */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 641 | for (k = cinfo->Ss; k <= ke; k++) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 642 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 643 | if (k > kex) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 644 | arith_encode(cinfo, st, 0); /* EOB decision */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 645 | for (;;) { |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 646 | if ((v = (*block)[jpeg_natural_order[k]]) >= 0) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 647 | if (v >>= cinfo->Al) { |
| 648 | if (v >> 1) /* previously nonzero coef */ |
| 649 | arith_encode(cinfo, st + 2, (v & 1)); |
| 650 | else { /* newly nonzero coef */ |
| 651 | arith_encode(cinfo, st + 1, 1); |
| 652 | arith_encode(cinfo, entropy->fixed_bin, 0); |
| 653 | } |
| 654 | break; |
| 655 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 656 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 657 | v = -v; |
| 658 | if (v >>= cinfo->Al) { |
| 659 | if (v >> 1) /* previously nonzero coef */ |
| 660 | arith_encode(cinfo, st + 2, (v & 1)); |
| 661 | else { /* newly nonzero coef */ |
| 662 | arith_encode(cinfo, st + 1, 1); |
| 663 | arith_encode(cinfo, entropy->fixed_bin, 1); |
| 664 | } |
| 665 | break; |
| 666 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 667 | } |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 668 | arith_encode(cinfo, st + 1, 0); st += 3; k++; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 669 | } |
| 670 | } |
| 671 | /* Encode EOB decision only if k <= cinfo->Se */ |
| 672 | if (k <= cinfo->Se) { |
| 673 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
| 674 | arith_encode(cinfo, st, 1); |
| 675 | } |
| 676 | |
| 677 | return TRUE; |
| 678 | } |
| 679 | |
| 680 | |
| 681 | /* |
| 682 | * Encode and output one MCU's worth of arithmetic-compressed coefficients. |
| 683 | */ |
| 684 | |
| 685 | METHODDEF(boolean) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 686 | encode_mcu(j_compress_ptr cinfo, JBLOCKROW *MCU_data) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 687 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 688 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 689 | jpeg_component_info *compptr; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 690 | JBLOCKROW block; |
| 691 | unsigned char *st; |
| 692 | int blkn, ci, tbl, k, ke; |
| 693 | int v, v2, m; |
| 694 | |
| 695 | /* Emit restart marker if needed */ |
| 696 | if (cinfo->restart_interval) { |
| 697 | if (entropy->restarts_to_go == 0) { |
| 698 | emit_restart(cinfo, entropy->next_restart_num); |
| 699 | entropy->restarts_to_go = cinfo->restart_interval; |
| 700 | entropy->next_restart_num++; |
| 701 | entropy->next_restart_num &= 7; |
| 702 | } |
| 703 | entropy->restarts_to_go--; |
| 704 | } |
| 705 | |
| 706 | /* Encode the MCU data blocks */ |
| 707 | for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { |
| 708 | block = MCU_data[blkn]; |
| 709 | ci = cinfo->MCU_membership[blkn]; |
| 710 | compptr = cinfo->cur_comp_info[ci]; |
| 711 | |
| 712 | /* Sections F.1.4.1 & F.1.4.4.1: Encoding of DC coefficients */ |
| 713 | |
| 714 | tbl = compptr->dc_tbl_no; |
| 715 | |
| 716 | /* Table F.4: Point to statistics bin S0 for DC coefficient coding */ |
| 717 | st = entropy->dc_stats[tbl] + entropy->dc_context[ci]; |
| 718 | |
| 719 | /* Figure F.4: Encode_DC_DIFF */ |
| 720 | if ((v = (*block)[0] - entropy->last_dc_val[ci]) == 0) { |
| 721 | arith_encode(cinfo, st, 0); |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 722 | entropy->dc_context[ci] = 0; /* zero diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 723 | } else { |
| 724 | entropy->last_dc_val[ci] = (*block)[0]; |
| 725 | arith_encode(cinfo, st, 1); |
| 726 | /* Figure F.6: Encoding nonzero value v */ |
| 727 | /* Figure F.7: Encoding the sign of v */ |
| 728 | if (v > 0) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 729 | arith_encode(cinfo, st + 1, 0); /* Table F.4: SS = S0 + 1 */ |
| 730 | st += 2; /* Table F.4: SP = S0 + 2 */ |
| 731 | entropy->dc_context[ci] = 4; /* small positive diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 732 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 733 | v = -v; |
| 734 | arith_encode(cinfo, st + 1, 1); /* Table F.4: SS = S0 + 1 */ |
| 735 | st += 3; /* Table F.4: SN = S0 + 3 */ |
| 736 | entropy->dc_context[ci] = 8; /* small negative diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 737 | } |
| 738 | /* Figure F.8: Encoding the magnitude category of v */ |
| 739 | m = 0; |
| 740 | if (v -= 1) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 741 | arith_encode(cinfo, st, 1); |
| 742 | m = 1; |
| 743 | v2 = v; |
| 744 | st = entropy->dc_stats[tbl] + 20; /* Table F.4: X1 = 20 */ |
| 745 | while (v2 >>= 1) { |
| 746 | arith_encode(cinfo, st, 1); |
| 747 | m <<= 1; |
| 748 | st += 1; |
| 749 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 750 | } |
| 751 | arith_encode(cinfo, st, 0); |
| 752 | /* Section F.1.4.4.1.2: Establish dc_context conditioning category */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 753 | if (m < (int)((1L << cinfo->arith_dc_L[tbl]) >> 1)) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 754 | entropy->dc_context[ci] = 0; /* zero diff category */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 755 | else if (m > (int)((1L << cinfo->arith_dc_U[tbl]) >> 1)) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 756 | entropy->dc_context[ci] += 8; /* large diff category */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 757 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
| 758 | st += 14; |
| 759 | while (m >>= 1) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 760 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 761 | } |
| 762 | |
| 763 | /* Sections F.1.4.2 & F.1.4.4.2: Encoding of AC coefficients */ |
| 764 | |
| 765 | tbl = compptr->ac_tbl_no; |
| 766 | |
| 767 | /* Establish EOB (end-of-block) index */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 768 | for (ke = DCTSIZE2 - 1; ke > 0; ke--) |
| 769 | if ((*block)[jpeg_natural_order[ke]]) break; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 770 | |
| 771 | /* Figure F.5: Encode_AC_Coefficients */ |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 772 | for (k = 1; k <= ke; k++) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 773 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 774 | arith_encode(cinfo, st, 0); /* EOB decision */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 775 | while ((v = (*block)[jpeg_natural_order[k]]) == 0) { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 776 | arith_encode(cinfo, st + 1, 0); st += 3; k++; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 777 | } |
| 778 | arith_encode(cinfo, st + 1, 1); |
| 779 | /* Figure F.6: Encoding nonzero value v */ |
| 780 | /* Figure F.7: Encoding the sign of v */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 781 | if (v > 0) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 782 | arith_encode(cinfo, entropy->fixed_bin, 0); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 783 | } else { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 784 | v = -v; |
| 785 | arith_encode(cinfo, entropy->fixed_bin, 1); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 786 | } |
| 787 | st += 2; |
| 788 | /* Figure F.8: Encoding the magnitude category of v */ |
| 789 | m = 0; |
| 790 | if (v -= 1) { |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 791 | arith_encode(cinfo, st, 1); |
| 792 | m = 1; |
| 793 | v2 = v; |
| 794 | if (v2 >>= 1) { |
| 795 | arith_encode(cinfo, st, 1); |
| 796 | m <<= 1; |
| 797 | st = entropy->ac_stats[tbl] + |
| 798 | (k <= cinfo->arith_ac_K[tbl] ? 189 : 217); |
| 799 | while (v2 >>= 1) { |
| 800 | arith_encode(cinfo, st, 1); |
| 801 | m <<= 1; |
| 802 | st += 1; |
| 803 | } |
| 804 | } |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 805 | } |
| 806 | arith_encode(cinfo, st, 0); |
| 807 | /* Figure F.9: Encoding the magnitude bit pattern of v */ |
| 808 | st += 14; |
| 809 | while (m >>= 1) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 810 | arith_encode(cinfo, st, (m & v) ? 1 : 0); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 811 | } |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 812 | /* Encode EOB decision only if k <= DCTSIZE2 - 1 */ |
| 813 | if (k <= DCTSIZE2 - 1) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 814 | st = entropy->ac_stats[tbl] + 3 * (k - 1); |
| 815 | arith_encode(cinfo, st, 1); |
| 816 | } |
| 817 | } |
| 818 | |
| 819 | return TRUE; |
| 820 | } |
| 821 | |
| 822 | |
| 823 | /* |
| 824 | * Initialize for an arithmetic-compressed scan. |
| 825 | */ |
| 826 | |
| 827 | METHODDEF(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 828 | start_pass(j_compress_ptr cinfo, boolean gather_statistics) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 829 | { |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 830 | arith_entropy_ptr entropy = (arith_entropy_ptr)cinfo->entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 831 | int ci, tbl; |
Alex Naidis | 6eb7d37 | 2016-10-16 23:10:08 +0200 | [diff] [blame] | 832 | jpeg_component_info *compptr; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 833 | |
| 834 | if (gather_statistics) |
| 835 | /* Make sure to avoid that in the master control logic! |
| 836 | * We are fully adaptive here and need no extra |
| 837 | * statistics gathering pass! |
| 838 | */ |
| 839 | ERREXIT(cinfo, JERR_NOT_COMPILED); |
| 840 | |
| 841 | /* We assume jcmaster.c already validated the progressive scan parameters. */ |
| 842 | |
| 843 | /* Select execution routines */ |
| 844 | if (cinfo->progressive_mode) { |
| 845 | if (cinfo->Ah == 0) { |
| 846 | if (cinfo->Ss == 0) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 847 | entropy->pub.encode_mcu = encode_mcu_DC_first; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 848 | else |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 849 | entropy->pub.encode_mcu = encode_mcu_AC_first; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 850 | } else { |
| 851 | if (cinfo->Ss == 0) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 852 | entropy->pub.encode_mcu = encode_mcu_DC_refine; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 853 | else |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 854 | entropy->pub.encode_mcu = encode_mcu_AC_refine; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 855 | } |
| 856 | } else |
| 857 | entropy->pub.encode_mcu = encode_mcu; |
| 858 | |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 859 | /* Allocate & initialize requested statistics areas */ |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 860 | for (ci = 0; ci < cinfo->comps_in_scan; ci++) { |
| 861 | compptr = cinfo->cur_comp_info[ci]; |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 862 | /* DC needs no table for refinement scan */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 863 | if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 864 | tbl = compptr->dc_tbl_no; |
| 865 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 866 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 867 | if (entropy->dc_stats[tbl] == NULL) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 868 | entropy->dc_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small) |
| 869 | ((j_common_ptr)cinfo, JPOOL_IMAGE, DC_STAT_BINS); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 870 | MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS); |
| 871 | /* Initialize DC predictions to 0 */ |
| 872 | entropy->last_dc_val[ci] = 0; |
| 873 | entropy->dc_context[ci] = 0; |
| 874 | } |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 875 | /* AC needs no table when not present */ |
DRC | 66f97e6 | 2010-11-23 05:49:54 +0000 | [diff] [blame] | 876 | if (cinfo->progressive_mode == 0 || cinfo->Se) { |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 877 | tbl = compptr->ac_tbl_no; |
| 878 | if (tbl < 0 || tbl >= NUM_ARITH_TBLS) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 879 | ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 880 | if (entropy->ac_stats[tbl] == NULL) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 881 | entropy->ac_stats[tbl] = (unsigned char *)(*cinfo->mem->alloc_small) |
| 882 | ((j_common_ptr)cinfo, JPOOL_IMAGE, AC_STAT_BINS); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 883 | MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS); |
| 884 | #ifdef CALCULATE_SPECTRAL_CONDITIONING |
| 885 | if (cinfo->progressive_mode) |
DRC | e5eaf37 | 2014-05-09 18:00:32 +0000 | [diff] [blame] | 886 | /* Section G.1.3.2: Set appropriate arithmetic conditioning value Kx */ |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 887 | cinfo->arith_ac_K[tbl] = cinfo->Ss + |
| 888 | ((8 + cinfo->Se - cinfo->Ss) >> 4); |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 889 | #endif |
| 890 | } |
| 891 | } |
| 892 | |
| 893 | /* Initialize arithmetic encoding variables */ |
| 894 | entropy->c = 0; |
| 895 | entropy->a = 0x10000L; |
| 896 | entropy->sc = 0; |
| 897 | entropy->zc = 0; |
| 898 | entropy->ct = 11; |
| 899 | entropy->buffer = -1; /* empty */ |
| 900 | |
| 901 | /* Initialize restart stuff */ |
| 902 | entropy->restarts_to_go = cinfo->restart_interval; |
| 903 | entropy->next_restart_num = 0; |
| 904 | } |
| 905 | |
| 906 | |
| 907 | /* |
| 908 | * Module initialization routine for arithmetic entropy encoding. |
| 909 | */ |
| 910 | |
| 911 | GLOBAL(void) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 912 | jinit_arith_encoder(j_compress_ptr cinfo) |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 913 | { |
| 914 | arith_entropy_ptr entropy; |
| 915 | int i; |
| 916 | |
| 917 | entropy = (arith_entropy_ptr) |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 918 | (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE, |
DRC | 5de454b | 2014-05-18 19:04:03 +0000 | [diff] [blame] | 919 | sizeof(arith_entropy_encoder)); |
Leon Scroggins III | 3993b37 | 2018-07-16 10:43:45 -0400 | [diff] [blame] | 920 | cinfo->entropy = (struct jpeg_entropy_encoder *)entropy; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 921 | entropy->pub.start_pass = start_pass; |
| 922 | entropy->pub.finish_pass = finish_pass; |
| 923 | |
| 924 | /* Mark tables unallocated */ |
| 925 | for (i = 0; i < NUM_ARITH_TBLS; i++) { |
| 926 | entropy->dc_stats[i] = NULL; |
| 927 | entropy->ac_stats[i] = NULL; |
| 928 | } |
Guido Vollbeding | 989630f | 2010-01-10 00:00:00 +0000 | [diff] [blame] | 929 | |
| 930 | /* Initialize index for fixed probability estimation */ |
| 931 | entropy->fixed_bin[0] = 113; |
Guido Vollbeding | 1e247ac | 1998-03-28 00:00:00 +0000 | [diff] [blame] | 932 | } |