Coverage Report

Created: 2024-05-04 12:45

/proc/self/cwd/external/libjpeg_turbo/jchuff.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * jchuff.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1991-1997, Thomas G. Lane.
6
 * libjpeg-turbo Modifications:
7
 * Copyright (C) 2009-2011, 2014-2016, 2018-2022, D. R. Commander.
8
 * Copyright (C) 2015, Matthieu Darbois.
9
 * Copyright (C) 2018, Matthias Räncker.
10
 * Copyright (C) 2020, Arm Limited.
11
 * For conditions of distribution and use, see the accompanying README.ijg
12
 * file.
13
 *
14
 * This file contains Huffman entropy encoding routines.
15
 *
16
 * Much of the complexity here has to do with supporting output suspension.
17
 * If the data destination module demands suspension, we want to be able to
18
 * back up to the start of the current MCU.  To do this, we copy state
19
 * variables into local working storage, and update them back to the
20
 * permanent JPEG objects only upon successful completion of an MCU.
21
 *
22
 * NOTE: All referenced figures are from
23
 * Recommendation ITU-T T.81 (1992) | ISO/IEC 10918-1:1994.
24
 */
25
26
#define JPEG_INTERNALS
27
#include "jinclude.h"
28
#include "jpeglib.h"
29
#include "jsimd.h"
30
#include "jconfigint.h"
31
#include <limits.h>
32
33
/*
34
 * NOTE: If USE_CLZ_INTRINSIC is defined, then clz/bsr instructions will be
35
 * used for bit counting rather than the lookup table.  This will reduce the
36
 * memory footprint by 64k, which is important for some mobile applications
37
 * that create many isolated instances of libjpeg-turbo (web browsers, for
38
 * instance.)  This may improve performance on some mobile platforms as well.
39
 * This feature is enabled by default only on Arm processors, because some x86
40
 * chips have a slow implementation of bsr, and the use of clz/bsr cannot be
41
 * shown to have a significant performance impact even on the x86 chips that
42
 * have a fast implementation of it.  When building for Armv6, you can
43
 * explicitly disable the use of clz/bsr by adding -mthumb to the compiler
44
 * flags (this defines __thumb__).
45
 */
46
47
/* NOTE: Both GCC and Clang define __GNUC__ */
48
#if (defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__))) || \
49
    defined(_M_ARM) || defined(_M_ARM64)
50
#if !defined(__thumb__) || defined(__thumb2__)
51
#define USE_CLZ_INTRINSIC
52
#endif
53
#endif
54
55
#ifdef USE_CLZ_INTRINSIC
56
#if defined(_MSC_VER) && !defined(__clang__)
57
#define JPEG_NBITS_NONZERO(x)  (32 - _CountLeadingZeros(x))
58
#else
59
#define JPEG_NBITS_NONZERO(x)  (32 - __builtin_clz(x))
60
#endif
61
#define JPEG_NBITS(x)          (x ? JPEG_NBITS_NONZERO(x) : 0)
62
#else
63
#include "jpeg_nbits_table.h"
64
0
#define JPEG_NBITS(x)          (jpeg_nbits_table[x])
65
0
#define JPEG_NBITS_NONZERO(x)  JPEG_NBITS(x)
66
#endif
67
68
69
/* Expanded entropy encoder object for Huffman encoding.
70
 *
71
 * The savable_state subrecord contains fields that change within an MCU,
72
 * but must not be updated permanently until we complete the MCU.
73
 */
74
75
#if defined(__x86_64__) && defined(__ILP32__)
76
typedef unsigned long long bit_buf_type;
77
#else
78
typedef size_t bit_buf_type;
79
#endif
80
81
/* NOTE: The more optimal Huffman encoding algorithm is only used by the
82
 * intrinsics implementation of the Arm Neon SIMD extensions, which is why we
83
 * retain the old Huffman encoder behavior when using the GAS implementation.
84
 */
85
#if defined(WITH_SIMD) && !(defined(__arm__) || defined(__aarch64__) || \
86
                            defined(_M_ARM) || defined(_M_ARM64))
87
typedef unsigned long long simd_bit_buf_type;
88
#else
89
typedef bit_buf_type simd_bit_buf_type;
90
#endif
91
92
#if (defined(SIZEOF_SIZE_T) && SIZEOF_SIZE_T == 8) || defined(_WIN64) || \
93
    (defined(__x86_64__) && defined(__ILP32__))
94
0
#define BIT_BUF_SIZE  64
95
#elif (defined(SIZEOF_SIZE_T) && SIZEOF_SIZE_T == 4) || defined(_WIN32)
96
#define BIT_BUF_SIZE  32
97
#else
98
#error Cannot determine word size
99
#endif
100
2.79k
#define SIMD_BIT_BUF_SIZE  (sizeof(simd_bit_buf_type) * 8)
101
102
typedef struct {
103
  union {
104
    bit_buf_type c;
105
    simd_bit_buf_type simd;
106
  } put_buffer;                         /* current bit accumulation buffer */
107
  int free_bits;                        /* # of bits available in it */
108
                                        /* (Neon GAS: # of bits now in it) */
109
  int last_dc_val[MAX_COMPS_IN_SCAN];   /* last DC coef for each component */
110
} savable_state;
111
112
typedef struct {
113
  struct jpeg_entropy_encoder pub; /* public fields */
114
115
  savable_state saved;          /* Bit buffer & DC state at start of MCU */
116
117
  /* These fields are NOT loaded into local working state. */
118
  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
119
  int next_restart_num;         /* next restart number to write (0-7) */
120
121
  /* Pointers to derived tables (these workspaces have image lifespan) */
122
  c_derived_tbl *dc_derived_tbls[NUM_HUFF_TBLS];
123
  c_derived_tbl *ac_derived_tbls[NUM_HUFF_TBLS];
124
125
#ifdef ENTROPY_OPT_SUPPORTED    /* Statistics tables for optimization */
126
  long *dc_count_ptrs[NUM_HUFF_TBLS];
127
  long *ac_count_ptrs[NUM_HUFF_TBLS];
128
#endif
129
130
  int simd;
131
} huff_entropy_encoder;
132
133
typedef huff_entropy_encoder *huff_entropy_ptr;
134
135
/* Working state while writing an MCU.
136
 * This struct contains all the fields that are needed by subroutines.
137
 */
138
139
typedef struct {
140
  JOCTET *next_output_byte;     /* => next byte to write in buffer */
141
  size_t free_in_buffer;        /* # of byte spaces remaining in buffer */
142
  savable_state cur;            /* Current bit buffer & DC state */
143
  j_compress_ptr cinfo;         /* dump_buffer needs access to this */
144
  int simd;
145
} working_state;
146
147
148
/* Forward declarations */
149
METHODDEF(boolean) encode_mcu_huff(j_compress_ptr cinfo, JBLOCKROW *MCU_data);
150
METHODDEF(void) finish_pass_huff(j_compress_ptr cinfo);
151
#ifdef ENTROPY_OPT_SUPPORTED
152
METHODDEF(boolean) encode_mcu_gather(j_compress_ptr cinfo,
153
                                     JBLOCKROW *MCU_data);
154
METHODDEF(void) finish_pass_gather(j_compress_ptr cinfo);
155
#endif
156
157
158
/*
159
 * Initialize for a Huffman-compressed scan.
160
 * If gather_statistics is TRUE, we do not output anything during the scan,
161
 * just count the Huffman symbols used and generate Huffman code tables.
162
 */
163
164
METHODDEF(void)
165
start_pass_huff(j_compress_ptr cinfo, boolean gather_statistics)
166
933
{
167
933
  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
168
933
  int ci, dctbl, actbl;
169
933
  jpeg_component_info *compptr;
170
171
933
  if (gather_statistics) {
172
0
#ifdef ENTROPY_OPT_SUPPORTED
173
0
    entropy->pub.encode_mcu = encode_mcu_gather;
174
0
    entropy->pub.finish_pass = finish_pass_gather;
175
#else
176
    ERREXIT(cinfo, JERR_NOT_COMPILED);
177
#endif
178
933
  } else {
179
933
    entropy->pub.encode_mcu = encode_mcu_huff;
180
933
    entropy->pub.finish_pass = finish_pass_huff;
181
933
  }
182
183
933
  entropy->simd = jsimd_can_huff_encode_one_block();
184
185
2.18k
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
186
1.25k
    compptr = cinfo->cur_comp_info[ci];
187
1.25k
    dctbl = compptr->dc_tbl_no;
188
1.25k
    actbl = compptr->ac_tbl_no;
189
1.25k
    if (gather_statistics) {
190
0
#ifdef ENTROPY_OPT_SUPPORTED
191
      /* Check for invalid table indexes */
192
      /* (make_c_derived_tbl does this in the other path) */
193
0
      if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
194
0
        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
195
0
      if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
196
0
        ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
197
      /* Allocate and zero the statistics tables */
198
      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
199
0
      if (entropy->dc_count_ptrs[dctbl] == NULL)
200
0
        entropy->dc_count_ptrs[dctbl] = (long *)
201
0
          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
202
0
                                      257 * sizeof(long));
203
0
      memset(entropy->dc_count_ptrs[dctbl], 0, 257 * sizeof(long));
204
0
      if (entropy->ac_count_ptrs[actbl] == NULL)
205
0
        entropy->ac_count_ptrs[actbl] = (long *)
206
0
          (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
207
0
                                      257 * sizeof(long));
208
0
      memset(entropy->ac_count_ptrs[actbl], 0, 257 * sizeof(long));
209
0
#endif
210
1.25k
    } else {
211
      /* Compute derived values for Huffman tables */
212
      /* We may do this more than once for a table, but it's not expensive */
213
1.25k
      jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
214
1.25k
                              &entropy->dc_derived_tbls[dctbl]);
215
1.25k
      jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
216
1.25k
                              &entropy->ac_derived_tbls[actbl]);
217
1.25k
    }
218
    /* Initialize DC predictions to 0 */
219
1.25k
    entropy->saved.last_dc_val[ci] = 0;
220
1.25k
  }
221
222
  /* Initialize bit buffer to empty */
223
933
  if (entropy->simd) {
224
933
    entropy->saved.put_buffer.simd = 0;
225
#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
226
    entropy->saved.free_bits = 0;
227
#else
228
933
    entropy->saved.free_bits = SIMD_BIT_BUF_SIZE;
229
933
#endif
230
933
  } else {
231
0
    entropy->saved.put_buffer.c = 0;
232
0
    entropy->saved.free_bits = BIT_BUF_SIZE;
233
0
  }
234
235
  /* Initialize restart stuff */
236
933
  entropy->restarts_to_go = cinfo->restart_interval;
237
933
  entropy->next_restart_num = 0;
238
933
}
239
240
241
/*
242
 * Compute the derived values for a Huffman table.
243
 * This routine also performs some validation checks on the table.
244
 *
245
 * Note this is also used by jcphuff.c.
246
 */
247
248
GLOBAL(void)
249
jpeg_make_c_derived_tbl(j_compress_ptr cinfo, boolean isDC, int tblno,
250
                        c_derived_tbl **pdtbl)
251
2.50k
{
252
2.50k
  JHUFF_TBL *htbl;
253
2.50k
  c_derived_tbl *dtbl;
254
2.50k
  int p, i, l, lastp, si, maxsymbol;
255
2.50k
  char huffsize[257];
256
2.50k
  unsigned int huffcode[257];
257
2.50k
  unsigned int code;
258
259
  /* Note that huffsize[] and huffcode[] are filled in code-length order,
260
   * paralleling the order of the symbols themselves in htbl->huffval[].
261
   */
262
263
  /* Find the input Huffman table */
264
2.50k
  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
265
0
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
266
2.50k
  htbl =
267
2.50k
    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
268
2.50k
  if (htbl == NULL)
269
0
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
270
271
  /* Allocate a workspace if we haven't already done so. */
272
2.50k
  if (*pdtbl == NULL)
273
2.18k
    *pdtbl = (c_derived_tbl *)
274
2.18k
      (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
275
2.18k
                                  sizeof(c_derived_tbl));
276
2.50k
  dtbl = *pdtbl;
277
278
  /* Figure C.1: make table of Huffman code length for each symbol */
279
280
2.50k
  p = 0;
281
42.5k
  for (l = 1; l <= 16; l++) {
282
40.0k
    i = (int)htbl->bits[l];
283
40.0k
    if (i < 0 || p + i > 256)   /* protect against table overrun */
284
0
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
285
257k
    while (i--)
286
217k
      huffsize[p++] = (char)l;
287
40.0k
  }
288
2.50k
  huffsize[p] = 0;
289
2.50k
  lastp = p;
290
291
  /* Figure C.2: generate the codes themselves */
292
  /* We also validate that the counts represent a legal Huffman code tree. */
293
294
2.50k
  code = 0;
295
2.50k
  si = huffsize[0];
296
2.50k
  p = 0;
297
31.9k
  while (huffsize[p]) {
298
247k
    while (((int)huffsize[p]) == si) {
299
217k
      huffcode[p++] = code;
300
217k
      code++;
301
217k
    }
302
    /* code is now 1 more than the last code used for codelength si; but
303
     * it must still fit in si bits, since no code is allowed to be all ones.
304
     */
305
29.4k
    if (((JLONG)code) >= (((JLONG)1) << si))
306
0
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
307
29.4k
    code <<= 1;
308
29.4k
    si++;
309
29.4k
  }
310
311
  /* Figure C.3: generate encoding tables */
312
  /* These are code and size indexed by symbol value */
313
314
  /* Set all codeless symbols to have code length 0;
315
   * this lets us detect duplicate VAL entries here, and later
316
   * allows emit_bits to detect any attempt to emit such symbols.
317
   */
318
2.50k
  memset(dtbl->ehufco, 0, sizeof(dtbl->ehufco));
319
2.50k
  memset(dtbl->ehufsi, 0, sizeof(dtbl->ehufsi));
320
321
  /* This is also a convenient place to check for out-of-range
322
   * and duplicated VAL entries.  We allow 0..255 for AC symbols
323
   * but only 0..15 for DC.  (We could constrain them further
324
   * based on data depth and mode, but this seems enough.)
325
   */
326
2.50k
  maxsymbol = isDC ? 15 : 255;
327
328
220k
  for (p = 0; p < lastp; p++) {
329
217k
    i = htbl->huffval[p];
330
217k
    if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
331
0
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
332
217k
    dtbl->ehufco[i] = huffcode[p];
333
217k
    dtbl->ehufsi[i] = huffsize[p];
334
217k
  }
335
2.50k
}
336
337
338
/* Outputting bytes to the file */
339
340
/* Emit a byte, taking 'action' if must suspend. */
341
0
#define emit_byte(state, val, action) { \
342
0
  *(state)->next_output_byte++ = (JOCTET)(val); \
343
0
  if (--(state)->free_in_buffer == 0) \
344
0
    if (!dump_buffer(state)) \
345
0
      { action; } \
346
0
}
347
348
349
LOCAL(boolean)
350
dump_buffer(working_state *state)
351
/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
352
1.43k
{
353
1.43k
  struct jpeg_destination_mgr *dest = state->cinfo->dest;
354
355
1.43k
  if (!(*dest->empty_output_buffer) (state->cinfo))
356
0
    return FALSE;
357
  /* After a successful buffer dump, must reset buffer pointers */
358
1.43k
  state->next_output_byte = dest->next_output_byte;
359
1.43k
  state->free_in_buffer = dest->free_in_buffer;
360
1.43k
  return TRUE;
361
1.43k
}
362
363
364
/* Outputting bits to the file */
365
366
/* Output byte b and, speculatively, an additional 0 byte.  0xFF must be
367
 * encoded as 0xFF 0x00, so the output buffer pointer is advanced by 2 if the
368
 * byte is 0xFF.  Otherwise, the output buffer pointer is advanced by 1, and
369
 * the speculative 0 byte will be overwritten by the next byte.
370
 */
371
4.13k
#define EMIT_BYTE(b) { \
372
4.13k
  buffer[0] = (JOCTET)(b); \
373
4.13k
  buffer[1] = 0; \
374
4.13k
  buffer -= -2 + ((JOCTET)(b) < 0xFF); \
375
4.13k
}
376
377
/* Output the entire bit buffer.  If there are no 0xFF bytes in it, then write
378
 * directly to the output buffer.  Otherwise, use the EMIT_BYTE() macro to
379
 * encode 0xFF as 0xFF 0x00.
380
 */
381
#if BIT_BUF_SIZE == 64
382
383
0
#define FLUSH() { \
384
0
  if (put_buffer & 0x8080808080808080 & ~(put_buffer + 0x0101010101010101)) { \
385
0
    EMIT_BYTE(put_buffer >> 56) \
386
0
    EMIT_BYTE(put_buffer >> 48) \
387
0
    EMIT_BYTE(put_buffer >> 40) \
388
0
    EMIT_BYTE(put_buffer >> 32) \
389
0
    EMIT_BYTE(put_buffer >> 24) \
390
0
    EMIT_BYTE(put_buffer >> 16) \
391
0
    EMIT_BYTE(put_buffer >>  8) \
392
0
    EMIT_BYTE(put_buffer      ) \
393
0
  } else { \
394
0
    buffer[0] = (JOCTET)(put_buffer >> 56); \
395
0
    buffer[1] = (JOCTET)(put_buffer >> 48); \
396
0
    buffer[2] = (JOCTET)(put_buffer >> 40); \
397
0
    buffer[3] = (JOCTET)(put_buffer >> 32); \
398
0
    buffer[4] = (JOCTET)(put_buffer >> 24); \
399
0
    buffer[5] = (JOCTET)(put_buffer >> 16); \
400
0
    buffer[6] = (JOCTET)(put_buffer >> 8); \
401
0
    buffer[7] = (JOCTET)(put_buffer); \
402
0
    buffer += 8; \
403
0
  } \
404
0
}
405
406
#else
407
408
#define FLUSH() { \
409
  if (put_buffer & 0x80808080 & ~(put_buffer + 0x01010101)) { \
410
    EMIT_BYTE(put_buffer >> 24) \
411
    EMIT_BYTE(put_buffer >> 16) \
412
    EMIT_BYTE(put_buffer >>  8) \
413
    EMIT_BYTE(put_buffer      ) \
414
  } else { \
415
    buffer[0] = (JOCTET)(put_buffer >> 24); \
416
    buffer[1] = (JOCTET)(put_buffer >> 16); \
417
    buffer[2] = (JOCTET)(put_buffer >> 8); \
418
    buffer[3] = (JOCTET)(put_buffer); \
419
    buffer += 4; \
420
  } \
421
}
422
423
#endif
424
425
/* Fill the bit buffer to capacity with the leading bits from code, then output
426
 * the bit buffer and put the remaining bits from code into the bit buffer.
427
 */
428
0
#define PUT_AND_FLUSH(code, size) { \
429
0
  put_buffer = (put_buffer << (size + free_bits)) | (code >> -free_bits); \
430
0
  FLUSH() \
431
0
  free_bits += BIT_BUF_SIZE; \
432
0
  put_buffer = code; \
433
0
}
434
435
/* Insert code into the bit buffer and output the bit buffer if needed.
436
 * NOTE: We can't flush with free_bits == 0, since the left shift in
437
 * PUT_AND_FLUSH() would have undefined behavior.
438
 */
439
0
#define PUT_BITS(code, size) { \
440
0
  free_bits -= size; \
441
0
  if (free_bits < 0) \
442
0
    PUT_AND_FLUSH(code, size) \
443
0
  else \
444
0
    put_buffer = (put_buffer << size) | code; \
445
0
}
446
447
0
#define PUT_CODE(code, size) { \
448
0
  temp &= (((JLONG)1) << nbits) - 1; \
449
0
  temp |= code << nbits; \
450
0
  nbits += size; \
451
0
  PUT_BITS(temp, nbits) \
452
0
}
453
454
455
/* Although it is exceedingly rare, it is possible for a Huffman-encoded
456
 * coefficient block to be larger than the 128-byte unencoded block.  For each
457
 * of the 64 coefficients, PUT_BITS is invoked twice, and each invocation can
458
 * theoretically store 16 bits (for a maximum of 2048 bits or 256 bytes per
459
 * encoded block.)  If, for instance, one artificially sets the AC
460
 * coefficients to alternating values of 32767 and -32768 (using the JPEG
461
 * scanning order-- 1, 8, 16, etc.), then this will produce an encoded block
462
 * larger than 200 bytes.
463
 */
464
1.79M
#define BUFSIZE  (DCTSIZE2 * 8)
465
466
1.79M
#define LOAD_BUFFER() { \
467
1.79M
  if (state->free_in_buffer < BUFSIZE) { \
468
12.6k
    localbuf = 1; \
469
12.6k
    buffer = _buffer; \
470
12.6k
  } else \
471
1.79M
    buffer = state->next_output_byte; \
472
1.79M
}
473
474
1.79M
#define STORE_BUFFER() { \
475
1.79M
  if (localbuf) { \
476
12.6k
    size_t bytes, bytestocopy; \
477
12.6k
    bytes = buffer - _buffer; \
478
12.6k
    buffer = _buffer; \
479
24.5k
    while (bytes > 0) { \
480
11.9k
      bytestocopy = MIN(bytes, state->free_in_buffer); \
481
11.9k
      memcpy(state->next_output_byte, buffer, bytestocopy); \
482
11.9k
      state->next_output_byte += bytestocopy; \
483
11.9k
      buffer += bytestocopy; \
484
11.9k
      state->free_in_buffer -= bytestocopy; \
485
11.9k
      if (state->free_in_buffer == 0) \
486
11.9k
        if (!dump_buffer(state)) return FALSE; \
487
11.9k
      bytes -= bytestocopy; \
488
11.9k
    } \
489
1.77M
  } else { \
490
1.77M
    state->free_in_buffer -= (buffer - state->next_output_byte); \
491
1.77M
    state->next_output_byte = buffer; \
492
1.77M
  } \
493
1.79M
}
494
495
496
LOCAL(boolean)
497
flush_bits(working_state *state)
498
933
{
499
933
  JOCTET _buffer[BUFSIZE], *buffer, temp;
500
933
  simd_bit_buf_type put_buffer;  int put_bits;
501
933
  int localbuf = 0;
502
503
933
  if (state->simd) {
504
#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
505
    put_bits = state->cur.free_bits;
506
#else
507
933
    put_bits = SIMD_BIT_BUF_SIZE - state->cur.free_bits;
508
933
#endif
509
933
    put_buffer = state->cur.put_buffer.simd;
510
933
  } else {
511
0
    put_bits = BIT_BUF_SIZE - state->cur.free_bits;
512
0
    put_buffer = state->cur.put_buffer.c;
513
0
  }
514
515
933
  LOAD_BUFFER()
516
517
4.26k
  while (put_bits >= 8) {
518
3.33k
    put_bits -= 8;
519
3.33k
    temp = (JOCTET)(put_buffer >> put_bits);
520
3.33k
    EMIT_BYTE(temp)
521
3.33k
  }
522
933
  if (put_bits) {
523
    /* fill partial byte with ones */
524
804
    temp = (JOCTET)((put_buffer << (8 - put_bits)) | (0xFF >> put_bits));
525
804
    EMIT_BYTE(temp)
526
804
  }
527
528
933
  if (state->simd) {                    /* and reset bit buffer to empty */
529
933
    state->cur.put_buffer.simd = 0;
530
#if defined(__aarch64__) && !defined(NEON_INTRINSICS)
531
    state->cur.free_bits = 0;
532
#else
533
933
    state->cur.free_bits = SIMD_BIT_BUF_SIZE;
534
933
#endif
535
933
  } else {
536
0
    state->cur.put_buffer.c = 0;
537
0
    state->cur.free_bits = BIT_BUF_SIZE;
538
0
  }
539
933
  STORE_BUFFER()
540
541
933
  return TRUE;
542
933
}
543
544
545
/* Encode a single block's worth of coefficients */
546
547
LOCAL(boolean)
548
encode_one_block_simd(working_state *state, JCOEFPTR block, int last_dc_val,
549
                      c_derived_tbl *dctbl, c_derived_tbl *actbl)
550
1.79M
{
551
1.79M
  JOCTET _buffer[BUFSIZE], *buffer;
552
1.79M
  int localbuf = 0;
553
554
1.79M
  LOAD_BUFFER()
555
556
1.79M
  buffer = jsimd_huff_encode_one_block(state, buffer, block, last_dc_val,
557
1.79M
                                       dctbl, actbl);
558
559
1.79M
  STORE_BUFFER()
560
561
1.79M
  return TRUE;
562
1.79M
}
563
564
LOCAL(boolean)
565
encode_one_block(working_state *state, JCOEFPTR block, int last_dc_val,
566
                 c_derived_tbl *dctbl, c_derived_tbl *actbl)
567
0
{
568
0
  int temp, nbits, free_bits;
569
0
  bit_buf_type put_buffer;
570
0
  JOCTET _buffer[BUFSIZE], *buffer;
571
0
  int localbuf = 0;
572
573
0
  free_bits = state->cur.free_bits;
574
0
  put_buffer = state->cur.put_buffer.c;
575
0
  LOAD_BUFFER()
576
577
  /* Encode the DC coefficient difference per section F.1.2.1 */
578
579
0
  temp = block[0] - last_dc_val;
580
581
  /* This is a well-known technique for obtaining the absolute value without a
582
   * branch.  It is derived from an assembly language technique presented in
583
   * "How to Optimize for the Pentium Processors", Copyright (c) 1996, 1997 by
584
   * Agner Fog.  This code assumes we are on a two's complement machine.
585
   */
586
0
  nbits = temp >> (CHAR_BIT * sizeof(int) - 1);
587
0
  temp += nbits;
588
0
  nbits ^= temp;
589
590
  /* Find the number of bits needed for the magnitude of the coefficient */
591
0
  nbits = JPEG_NBITS(nbits);
592
593
  /* Emit the Huffman-coded symbol for the number of bits.
594
   * Emit that number of bits of the value, if positive,
595
   * or the complement of its magnitude, if negative.
596
   */
597
0
  PUT_CODE(dctbl->ehufco[nbits], dctbl->ehufsi[nbits])
598
599
  /* Encode the AC coefficients per section F.1.2.2 */
600
601
0
  {
602
0
    int r = 0;                  /* r = run length of zeros */
603
604
/* Manually unroll the k loop to eliminate the counter variable.  This
605
 * improves performance greatly on systems with a limited number of
606
 * registers (such as x86.)
607
 */
608
0
#define kloop(jpeg_natural_order_of_k) { \
609
0
  if ((temp = block[jpeg_natural_order_of_k]) == 0) { \
610
0
    r += 16; \
611
0
  } else { \
612
    /* Branch-less absolute value, bitwise complement, etc., same as above */ \
613
0
    nbits = temp >> (CHAR_BIT * sizeof(int) - 1); \
614
0
    temp += nbits; \
615
0
    nbits ^= temp; \
616
0
    nbits = JPEG_NBITS_NONZERO(nbits); \
617
    /* if run length > 15, must emit special run-length-16 codes (0xF0) */ \
618
0
    while (r >= 16 * 16) { \
619
0
      r -= 16 * 16; \
620
0
      PUT_BITS(actbl->ehufco[0xf0], actbl->ehufsi[0xf0]) \
621
0
    } \
622
    /* Emit Huffman symbol for run length / number of bits */ \
623
0
    r += nbits; \
624
0
    PUT_CODE(actbl->ehufco[r], actbl->ehufsi[r]) \
625
0
    r = 0; \
626
0
  } \
627
0
}
628
629
    /* One iteration for each value in jpeg_natural_order[] */
630
0
    kloop(1);   kloop(8);   kloop(16);  kloop(9);   kloop(2);   kloop(3);
631
0
    kloop(10);  kloop(17);  kloop(24);  kloop(32);  kloop(25);  kloop(18);
632
0
    kloop(11);  kloop(4);   kloop(5);   kloop(12);  kloop(19);  kloop(26);
633
0
    kloop(33);  kloop(40);  kloop(48);  kloop(41);  kloop(34);  kloop(27);
634
0
    kloop(20);  kloop(13);  kloop(6);   kloop(7);   kloop(14);  kloop(21);
635
0
    kloop(28);  kloop(35);  kloop(42);  kloop(49);  kloop(56);  kloop(57);
636
0
    kloop(50);  kloop(43);  kloop(36);  kloop(29);  kloop(22);  kloop(15);
637
0
    kloop(23);  kloop(30);  kloop(37);  kloop(44);  kloop(51);  kloop(58);
638
0
    kloop(59);  kloop(52);  kloop(45);  kloop(38);  kloop(31);  kloop(39);
639
0
    kloop(46);  kloop(53);  kloop(60);  kloop(61);  kloop(54);  kloop(47);
640
0
    kloop(55);  kloop(62);  kloop(63);
641
642
    /* If the last coef(s) were zero, emit an end-of-block code */
643
0
    if (r > 0) {
644
0
      PUT_BITS(actbl->ehufco[0], actbl->ehufsi[0])
645
0
    }
646
0
  }
647
648
0
  state->cur.put_buffer.c = put_buffer;
649
0
  state->cur.free_bits = free_bits;
650
0
  STORE_BUFFER()
651
652
0
  return TRUE;
653
0
}
654
655
656
/*
657
 * Emit a restart marker & resynchronize predictions.
658
 */
659
660
LOCAL(boolean)
661
emit_restart(working_state *state, int restart_num)
662
0
{
663
0
  int ci;
664
665
0
  if (!flush_bits(state))
666
0
    return FALSE;
667
668
0
  emit_byte(state, 0xFF, return FALSE);
669
0
  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
670
671
  /* Re-initialize DC predictions to 0 */
672
0
  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
673
0
    state->cur.last_dc_val[ci] = 0;
674
675
  /* The restart counter is not updated until we successfully write the MCU. */
676
677
0
  return TRUE;
678
0
}
679
680
681
/*
682
 * Encode and output one MCU's worth of Huffman-compressed coefficients.
683
 */
684
685
METHODDEF(boolean)
686
encode_mcu_huff(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
687
1.67M
{
688
1.67M
  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
689
1.67M
  working_state state;
690
1.67M
  int blkn, ci;
691
1.67M
  jpeg_component_info *compptr;
692
693
  /* Load up working state */
694
1.67M
  state.next_output_byte = cinfo->dest->next_output_byte;
695
1.67M
  state.free_in_buffer = cinfo->dest->free_in_buffer;
696
1.67M
  state.cur = entropy->saved;
697
1.67M
  state.cinfo = cinfo;
698
1.67M
  state.simd = entropy->simd;
699
700
  /* Emit restart marker if needed */
701
1.67M
  if (cinfo->restart_interval) {
702
0
    if (entropy->restarts_to_go == 0)
703
0
      if (!emit_restart(&state, entropy->next_restart_num))
704
0
        return FALSE;
705
0
  }
706
707
  /* Encode the MCU data blocks */
708
1.67M
  if (entropy->simd) {
709
3.46M
    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
710
1.79M
      ci = cinfo->MCU_membership[blkn];
711
1.79M
      compptr = cinfo->cur_comp_info[ci];
712
1.79M
      if (!encode_one_block_simd(&state,
713
1.79M
                                 MCU_data[blkn][0], state.cur.last_dc_val[ci],
714
1.79M
                                 entropy->dc_derived_tbls[compptr->dc_tbl_no],
715
1.79M
                                 entropy->ac_derived_tbls[compptr->ac_tbl_no]))
716
0
        return FALSE;
717
      /* Update last_dc_val */
718
1.79M
      state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
719
1.79M
    }
720
1.67M
  } else {
721
0
    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
722
0
      ci = cinfo->MCU_membership[blkn];
723
0
      compptr = cinfo->cur_comp_info[ci];
724
0
      if (!encode_one_block(&state,
725
0
                            MCU_data[blkn][0], state.cur.last_dc_val[ci],
726
0
                            entropy->dc_derived_tbls[compptr->dc_tbl_no],
727
0
                            entropy->ac_derived_tbls[compptr->ac_tbl_no]))
728
0
        return FALSE;
729
      /* Update last_dc_val */
730
0
      state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
731
0
    }
732
0
  }
733
734
  /* Completed MCU, so update state */
735
1.67M
  cinfo->dest->next_output_byte = state.next_output_byte;
736
1.67M
  cinfo->dest->free_in_buffer = state.free_in_buffer;
737
1.67M
  entropy->saved = state.cur;
738
739
  /* Update restart-interval state too */
740
1.67M
  if (cinfo->restart_interval) {
741
0
    if (entropy->restarts_to_go == 0) {
742
0
      entropy->restarts_to_go = cinfo->restart_interval;
743
0
      entropy->next_restart_num++;
744
0
      entropy->next_restart_num &= 7;
745
0
    }
746
0
    entropy->restarts_to_go--;
747
0
  }
748
749
1.67M
  return TRUE;
750
1.67M
}
751
752
753
/*
754
 * Finish up at the end of a Huffman-compressed scan.
755
 */
756
757
METHODDEF(void)
758
finish_pass_huff(j_compress_ptr cinfo)
759
933
{
760
933
  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
761
933
  working_state state;
762
763
  /* Load up working state ... flush_bits needs it */
764
933
  state.next_output_byte = cinfo->dest->next_output_byte;
765
933
  state.free_in_buffer = cinfo->dest->free_in_buffer;
766
933
  state.cur = entropy->saved;
767
933
  state.cinfo = cinfo;
768
933
  state.simd = entropy->simd;
769
770
  /* Flush out the last data */
771
933
  if (!flush_bits(&state))
772
0
    ERREXIT(cinfo, JERR_CANT_SUSPEND);
773
774
  /* Update state */
775
933
  cinfo->dest->next_output_byte = state.next_output_byte;
776
933
  cinfo->dest->free_in_buffer = state.free_in_buffer;
777
933
  entropy->saved = state.cur;
778
933
}
779
780
781
/*
782
 * Huffman coding optimization.
783
 *
784
 * We first scan the supplied data and count the number of uses of each symbol
785
 * that is to be Huffman-coded. (This process MUST agree with the code above.)
786
 * Then we build a Huffman coding tree for the observed counts.
787
 * Symbols which are not needed at all for the particular image are not
788
 * assigned any code, which saves space in the DHT marker as well as in
789
 * the compressed data.
790
 */
791
792
#ifdef ENTROPY_OPT_SUPPORTED
793
794
795
/* Process a single block's worth of coefficients */
796
797
LOCAL(void)
798
htest_one_block(j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
799
                long dc_counts[], long ac_counts[])
800
0
{
801
0
  register int temp;
802
0
  register int nbits;
803
0
  register int k, r;
804
805
  /* Encode the DC coefficient difference per section F.1.2.1 */
806
807
0
  temp = block[0] - last_dc_val;
808
0
  if (temp < 0)
809
0
    temp = -temp;
810
811
  /* Find the number of bits needed for the magnitude of the coefficient */
812
0
  nbits = 0;
813
0
  while (temp) {
814
0
    nbits++;
815
0
    temp >>= 1;
816
0
  }
817
  /* Check for out-of-range coefficient values.
818
   * Since we're encoding a difference, the range limit is twice as much.
819
   */
820
0
  if (nbits > MAX_COEF_BITS + 1)
821
0
    ERREXIT(cinfo, JERR_BAD_DCT_COEF);
822
823
  /* Count the Huffman symbol for the number of bits */
824
0
  dc_counts[nbits]++;
825
826
  /* Encode the AC coefficients per section F.1.2.2 */
827
828
0
  r = 0;                        /* r = run length of zeros */
829
830
0
  for (k = 1; k < DCTSIZE2; k++) {
831
0
    if ((temp = block[jpeg_natural_order[k]]) == 0) {
832
0
      r++;
833
0
    } else {
834
      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
835
0
      while (r > 15) {
836
0
        ac_counts[0xF0]++;
837
0
        r -= 16;
838
0
      }
839
840
      /* Find the number of bits needed for the magnitude of the coefficient */
841
0
      if (temp < 0)
842
0
        temp = -temp;
843
844
      /* Find the number of bits needed for the magnitude of the coefficient */
845
0
      nbits = 1;                /* there must be at least one 1 bit */
846
0
      while ((temp >>= 1))
847
0
        nbits++;
848
      /* Check for out-of-range coefficient values */
849
0
      if (nbits > MAX_COEF_BITS)
850
0
        ERREXIT(cinfo, JERR_BAD_DCT_COEF);
851
852
      /* Count Huffman symbol for run length / number of bits */
853
0
      ac_counts[(r << 4) + nbits]++;
854
855
0
      r = 0;
856
0
    }
857
0
  }
858
859
  /* If the last coef(s) were zero, emit an end-of-block code */
860
0
  if (r > 0)
861
0
    ac_counts[0]++;
862
0
}
863
864
865
/*
866
 * Trial-encode one MCU's worth of Huffman-compressed coefficients.
867
 * No data is actually output, so no suspension return is possible.
868
 */
869
870
METHODDEF(boolean)
871
encode_mcu_gather(j_compress_ptr cinfo, JBLOCKROW *MCU_data)
872
0
{
873
0
  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
874
0
  int blkn, ci;
875
0
  jpeg_component_info *compptr;
876
877
  /* Take care of restart intervals if needed */
878
0
  if (cinfo->restart_interval) {
879
0
    if (entropy->restarts_to_go == 0) {
880
      /* Re-initialize DC predictions to 0 */
881
0
      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
882
0
        entropy->saved.last_dc_val[ci] = 0;
883
      /* Update restart state */
884
0
      entropy->restarts_to_go = cinfo->restart_interval;
885
0
    }
886
0
    entropy->restarts_to_go--;
887
0
  }
888
889
0
  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
890
0
    ci = cinfo->MCU_membership[blkn];
891
0
    compptr = cinfo->cur_comp_info[ci];
892
0
    htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
893
0
                    entropy->dc_count_ptrs[compptr->dc_tbl_no],
894
0
                    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
895
0
    entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
896
0
  }
897
898
0
  return TRUE;
899
0
}
900
901
902
/*
903
 * Generate the best Huffman code table for the given counts, fill htbl.
904
 * Note this is also used by jcphuff.c.
905
 *
906
 * The JPEG standard requires that no symbol be assigned a codeword of all
907
 * one bits (so that padding bits added at the end of a compressed segment
908
 * can't look like a valid code).  Because of the canonical ordering of
909
 * codewords, this just means that there must be an unused slot in the
910
 * longest codeword length category.  Annex K (Clause K.2) of
911
 * Rec. ITU-T T.81 (1992) | ISO/IEC 10918-1:1994 suggests reserving such a slot
912
 * by pretending that symbol 256 is a valid symbol with count 1.  In theory
913
 * that's not optimal; giving it count zero but including it in the symbol set
914
 * anyway should give a better Huffman code.  But the theoretically better code
915
 * actually seems to come out worse in practice, because it produces more
916
 * all-ones bytes (which incur stuffed zero bytes in the final file).  In any
917
 * case the difference is tiny.
918
 *
919
 * The JPEG standard requires Huffman codes to be no more than 16 bits long.
920
 * If some symbols have a very small but nonzero probability, the Huffman tree
921
 * must be adjusted to meet the code length restriction.  We currently use
922
 * the adjustment method suggested in JPEG section K.2.  This method is *not*
923
 * optimal; it may not choose the best possible limited-length code.  But
924
 * typically only very-low-frequency symbols will be given less-than-optimal
925
 * lengths, so the code is almost optimal.  Experimental comparisons against
926
 * an optimal limited-length-code algorithm indicate that the difference is
927
 * microscopic --- usually less than a hundredth of a percent of total size.
928
 * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
929
 */
930
931
GLOBAL(void)
932
jpeg_gen_optimal_table(j_compress_ptr cinfo, JHUFF_TBL *htbl, long freq[])
933
0
{
934
0
#define MAX_CLEN  32            /* assumed maximum initial code length */
935
0
  UINT8 bits[MAX_CLEN + 1];     /* bits[k] = # of symbols with code length k */
936
0
  int codesize[257];            /* codesize[k] = code length of symbol k */
937
0
  int others[257];              /* next symbol in current branch of tree */
938
0
  int c1, c2;
939
0
  int p, i, j;
940
0
  long v;
941
942
  /* This algorithm is explained in section K.2 of the JPEG standard */
943
944
0
  memset(bits, 0, sizeof(bits));
945
0
  memset(codesize, 0, sizeof(codesize));
946
0
  for (i = 0; i < 257; i++)
947
0
    others[i] = -1;             /* init links to empty */
948
949
0
  freq[256] = 1;                /* make sure 256 has a nonzero count */
950
  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
951
   * that no real symbol is given code-value of all ones, because 256
952
   * will be placed last in the largest codeword category.
953
   */
954
955
  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
956
957
0
  for (;;) {
958
    /* Find the smallest nonzero frequency, set c1 = its symbol */
959
    /* In case of ties, take the larger symbol number */
960
0
    c1 = -1;
961
0
    v = 1000000000L;
962
0
    for (i = 0; i <= 256; i++) {
963
0
      if (freq[i] && freq[i] <= v) {
964
0
        v = freq[i];
965
0
        c1 = i;
966
0
      }
967
0
    }
968
969
    /* Find the next smallest nonzero frequency, set c2 = its symbol */
970
    /* In case of ties, take the larger symbol number */
971
0
    c2 = -1;
972
0
    v = 1000000000L;
973
0
    for (i = 0; i <= 256; i++) {
974
0
      if (freq[i] && freq[i] <= v && i != c1) {
975
0
        v = freq[i];
976
0
        c2 = i;
977
0
      }
978
0
    }
979
980
    /* Done if we've merged everything into one frequency */
981
0
    if (c2 < 0)
982
0
      break;
983
984
    /* Else merge the two counts/trees */
985
0
    freq[c1] += freq[c2];
986
0
    freq[c2] = 0;
987
988
    /* Increment the codesize of everything in c1's tree branch */
989
0
    codesize[c1]++;
990
0
    while (others[c1] >= 0) {
991
0
      c1 = others[c1];
992
0
      codesize[c1]++;
993
0
    }
994
995
0
    others[c1] = c2;            /* chain c2 onto c1's tree branch */
996
997
    /* Increment the codesize of everything in c2's tree branch */
998
0
    codesize[c2]++;
999
0
    while (others[c2] >= 0) {
1000
0
      c2 = others[c2];
1001
0
      codesize[c2]++;
1002
0
    }
1003
0
  }
1004
1005
  /* Now count the number of symbols of each code length */
1006
0
  for (i = 0; i <= 256; i++) {
1007
0
    if (codesize[i]) {
1008
      /* The JPEG standard seems to think that this can't happen, */
1009
      /* but I'm paranoid... */
1010
0
      if (codesize[i] > MAX_CLEN)
1011
0
        ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
1012
1013
0
      bits[codesize[i]]++;
1014
0
    }
1015
0
  }
1016
1017
  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
1018
   * Huffman procedure assigned any such lengths, we must adjust the coding.
1019
   * Here is what Rec. ITU-T T.81 | ISO/IEC 10918-1 says about how this next
1020
   * bit works: Since symbols are paired for the longest Huffman code, the
1021
   * symbols are removed from this length category two at a time.  The prefix
1022
   * for the pair (which is one bit shorter) is allocated to one of the pair;
1023
   * then, skipping the BITS entry for that prefix length, a code word from the
1024
   * next shortest nonzero BITS entry is converted into a prefix for two code
1025
   * words one bit longer.
1026
   */
1027
1028
0
  for (i = MAX_CLEN; i > 16; i--) {
1029
0
    while (bits[i] > 0) {
1030
0
      j = i - 2;                /* find length of new prefix to be used */
1031
0
      while (bits[j] == 0)
1032
0
        j--;
1033
1034
0
      bits[i] -= 2;             /* remove two symbols */
1035
0
      bits[i - 1]++;            /* one goes in this length */
1036
0
      bits[j + 1] += 2;         /* two new symbols in this length */
1037
0
      bits[j]--;                /* symbol of this length is now a prefix */
1038
0
    }
1039
0
  }
1040
1041
  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
1042
0
  while (bits[i] == 0)          /* find largest codelength still in use */
1043
0
    i--;
1044
0
  bits[i]--;
1045
1046
  /* Return final symbol counts (only for lengths 0..16) */
1047
0
  memcpy(htbl->bits, bits, sizeof(htbl->bits));
1048
1049
  /* Return a list of the symbols sorted by code length */
1050
  /* It's not real clear to me why we don't need to consider the codelength
1051
   * changes made above, but Rec. ITU-T T.81 | ISO/IEC 10918-1 seems to think
1052
   * this works.
1053
   */
1054
0
  p = 0;
1055
0
  for (i = 1; i <= MAX_CLEN; i++) {
1056
0
    for (j = 0; j <= 255; j++) {
1057
0
      if (codesize[j] == i) {
1058
0
        htbl->huffval[p] = (UINT8)j;
1059
0
        p++;
1060
0
      }
1061
0
    }
1062
0
  }
1063
1064
  /* Set sent_table FALSE so updated table will be written to JPEG file. */
1065
0
  htbl->sent_table = FALSE;
1066
0
}
1067
1068
1069
/*
1070
 * Finish up a statistics-gathering pass and create the new Huffman tables.
1071
 */
1072
1073
METHODDEF(void)
1074
finish_pass_gather(j_compress_ptr cinfo)
1075
0
{
1076
0
  huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
1077
0
  int ci, dctbl, actbl;
1078
0
  jpeg_component_info *compptr;
1079
0
  JHUFF_TBL **htblptr;
1080
0
  boolean did_dc[NUM_HUFF_TBLS];
1081
0
  boolean did_ac[NUM_HUFF_TBLS];
1082
1083
  /* It's important not to apply jpeg_gen_optimal_table more than once
1084
   * per table, because it clobbers the input frequency counts!
1085
   */
1086
0
  memset(did_dc, 0, sizeof(did_dc));
1087
0
  memset(did_ac, 0, sizeof(did_ac));
1088
1089
0
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1090
0
    compptr = cinfo->cur_comp_info[ci];
1091
0
    dctbl = compptr->dc_tbl_no;
1092
0
    actbl = compptr->ac_tbl_no;
1093
0
    if (!did_dc[dctbl]) {
1094
0
      htblptr = &cinfo->dc_huff_tbl_ptrs[dctbl];
1095
0
      if (*htblptr == NULL)
1096
0
        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
1097
0
      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
1098
0
      did_dc[dctbl] = TRUE;
1099
0
    }
1100
0
    if (!did_ac[actbl]) {
1101
0
      htblptr = &cinfo->ac_huff_tbl_ptrs[actbl];
1102
0
      if (*htblptr == NULL)
1103
0
        *htblptr = jpeg_alloc_huff_table((j_common_ptr)cinfo);
1104
0
      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
1105
0
      did_ac[actbl] = TRUE;
1106
0
    }
1107
0
  }
1108
0
}
1109
1110
1111
#endif /* ENTROPY_OPT_SUPPORTED */
1112
1113
1114
/*
1115
 * Module initialization routine for Huffman entropy encoding.
1116
 */
1117
1118
GLOBAL(void)
1119
jinit_huff_encoder(j_compress_ptr cinfo)
1120
933
{
1121
933
  huff_entropy_ptr entropy;
1122
933
  int i;
1123
1124
933
  entropy = (huff_entropy_ptr)
1125
933
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
1126
933
                                sizeof(huff_entropy_encoder));
1127
933
  cinfo->entropy = (struct jpeg_entropy_encoder *)entropy;
1128
933
  entropy->pub.start_pass = start_pass_huff;
1129
1130
  /* Mark tables unallocated */
1131
4.66k
  for (i = 0; i < NUM_HUFF_TBLS; i++) {
1132
3.73k
    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
1133
3.73k
#ifdef ENTROPY_OPT_SUPPORTED
1134
3.73k
    entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
1135
3.73k
#endif
1136
3.73k
  }
1137
933
}