Coverage Report

Created: 2025-06-10 06:59

/src/ghostpdl/obj/jcomapi.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * jcomapi.c
3
 *
4
 * Copyright (C) 1994-1997, Thomas G. Lane.
5
 * Modified 2019 by Guido Vollbeding.
6
 * This file is part of the Independent JPEG Group's software.
7
 * For conditions of distribution and use, see the accompanying README file.
8
 *
9
 * This file contains application interface routines that are used for both
10
 * compression and decompression.
11
 */
12
13
#define JPEG_INTERNALS
14
#include "jinclude.h"
15
#include "jpeglib.h"
16
17
18
/*
19
 * Abort processing of a JPEG compression or decompression operation,
20
 * but don't destroy the object itself.
21
 *
22
 * For this, we merely clean up all the nonpermanent memory pools.
23
 * Note that temp files (virtual arrays) are not allowed to belong to
24
 * the permanent pool, so we will be able to close all temp files here.
25
 * Closing a data source or destination, if necessary, is the application's
26
 * responsibility.
27
 */
28
29
GLOBAL(void)
30
jpeg_abort (j_common_ptr cinfo)
31
392
{
32
392
  int pool;
33
34
  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
35
392
  if (cinfo->mem == NULL)
36
0
    return;
37
38
  /* Releasing pools in reverse order might help avoid fragmentation
39
   * with some (brain-damaged) malloc libraries.
40
   */
41
784
  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
42
392
    (*cinfo->mem->free_pool) (cinfo, pool);
43
392
  }
44
45
  /* Reset overall state for possible reuse of object */
46
392
  if (cinfo->is_decompressor) {
47
392
    cinfo->global_state = DSTATE_START;
48
    /* Try to keep application from accessing now-deleted marker list.
49
     * A bit kludgy to do it here, but this is the most central place.
50
     */
51
392
    ((j_decompress_ptr) cinfo)->marker_list = NULL;
52
392
  } else {
53
0
    cinfo->global_state = CSTATE_START;
54
0
  }
55
392
}
56
57
58
/*
59
 * Destruction of a JPEG object.
60
 *
61
 * Everything gets deallocated except the master jpeg_compress_struct itself
62
 * and the error manager struct.  Both of these are supplied by the application
63
 * and must be freed, if necessary, by the application.  (Often they are on
64
 * the stack and so don't need to be freed anyway.)
65
 * Closing a data source or destination, if necessary, is the application's
66
 * responsibility.
67
 */
68
69
GLOBAL(void)
70
jpeg_destroy (j_common_ptr cinfo)
71
538
{
72
  /* We need only tell the memory manager to release everything. */
73
  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
74
538
  if (cinfo->mem != NULL)
75
538
    (*cinfo->mem->self_destruct) (cinfo);
76
538
  cinfo->mem = NULL;    /* be safe if jpeg_destroy is called twice */
77
538
  cinfo->global_state = 0;  /* mark it destroyed */
78
538
}
79
80
81
/*
82
 * Convenience routines for allocating quantization and Huffman tables.
83
 * (Would jutils.c be a more reasonable place to put these?)
84
 */
85
86
GLOBAL(JQUANT_TBL *)
87
jpeg_alloc_quant_table (j_common_ptr cinfo)
88
911
{
89
911
  JQUANT_TBL *tbl;
90
91
911
  tbl = (JQUANT_TBL *)
92
911
    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
93
911
  tbl->sent_table = FALSE;  /* make sure this is false in any new table */
94
911
  return tbl;
95
911
}
96
97
98
GLOBAL(JHUFF_TBL *)
99
jpeg_alloc_huff_table (j_common_ptr cinfo)
100
1.69k
{
101
1.69k
  JHUFF_TBL *tbl;
102
103
1.69k
  tbl = (JHUFF_TBL *)
104
1.69k
    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
105
1.69k
  tbl->sent_table = FALSE;  /* make sure this is false in any new table */
106
1.69k
  return tbl;
107
1.69k
}
108
109
110
/*
111
 * Set up the standard Huffman tables (cf. JPEG standard section K.3).
112
 * IMPORTANT: these are only valid for 8-bit data precision!
113
 * (Would jutils.c be a more reasonable place to put this?)
114
 */
115
116
GLOBAL(JHUFF_TBL *)
117
jpeg_std_huff_table (j_common_ptr cinfo, boolean isDC, int tblno)
118
16
{
119
16
  JHUFF_TBL **htblptr, *htbl;
120
16
  const UINT8 *bits, *val;
121
16
  int nsymbols, len;
122
123
16
  static const UINT8 bits_dc_luminance[17] =
124
16
    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
125
16
  static const UINT8 val_dc_luminance[] =
126
16
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
127
128
16
  static const UINT8 bits_dc_chrominance[17] =
129
16
    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
130
16
  static const UINT8 val_dc_chrominance[] =
131
16
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
132
133
16
  static const UINT8 bits_ac_luminance[17] =
134
16
    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
135
16
  static const UINT8 val_ac_luminance[] =
136
16
    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
137
16
      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
138
16
      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
139
16
      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
140
16
      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
141
16
      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
142
16
      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
143
16
      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
144
16
      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
145
16
      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
146
16
      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
147
16
      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
148
16
      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
149
16
      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
150
16
      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
151
16
      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
152
16
      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
153
16
      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
154
16
      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
155
16
      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
156
16
      0xf9, 0xfa };
157
158
16
  static const UINT8 bits_ac_chrominance[17] =
159
16
    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
160
16
  static const UINT8 val_ac_chrominance[] =
161
16
    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
162
16
      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
163
16
      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
164
16
      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
165
16
      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
166
16
      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
167
16
      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
168
16
      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
169
16
      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
170
16
      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
171
16
      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
172
16
      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
173
16
      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
174
16
      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
175
16
      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
176
16
      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
177
16
      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
178
16
      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
179
16
      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
180
16
      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
181
16
      0xf9, 0xfa };
182
183
16
  if (cinfo->is_decompressor) {
184
16
    if (isDC)
185
8
      htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
186
8
    else
187
8
      htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
188
16
  } else {
189
0
    if (isDC)
190
0
      htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
191
0
    else
192
0
      htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
193
0
  }
194
195
16
  switch (tblno) {
196
0
  case 0:
197
0
    if (isDC) {
198
0
      bits = bits_dc_luminance;
199
0
      val = val_dc_luminance;
200
0
    } else {
201
0
      bits = bits_ac_luminance;
202
0
      val = val_ac_luminance;
203
0
    }
204
0
    break;
205
16
  case 1:
206
16
    if (isDC) {
207
8
      bits = bits_dc_chrominance;
208
8
      val = val_dc_chrominance;
209
8
    } else {
210
8
      bits = bits_ac_chrominance;
211
8
      val = val_ac_chrominance;
212
8
    }
213
16
    break;
214
0
  default:
215
0
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
216
0
    return NULL; /* avoid compiler warnings for uninitialized variables */
217
16
  }
218
219
16
  if (htblptr[tblno] == NULL)
220
16
    htblptr[tblno] = jpeg_alloc_huff_table(cinfo);
221
222
16
  htbl = htblptr[tblno];
223
224
  /* Copy the number-of-symbols-of-each-code-length counts */
225
16
  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
226
227
  /* Validate the counts.  We do this here mainly so we can copy the right
228
   * number of symbols from the val[] array, without risking marching off
229
   * the end of memory.  jxhuff.c will do a more thorough test later.
230
   */
231
16
  nsymbols = 0;
232
272
  for (len = 1; len <= 16; len++)
233
256
    nsymbols += bits[len];
234
16
  if (nsymbols > 256)
235
0
    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
236
237
16
  if (nsymbols > 0)
238
16
    MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));
239
240
  /* Initialize sent_table FALSE so table will be written to JPEG file. */
241
16
  htbl->sent_table = FALSE;
242
243
16
  return htbl;
244
16
}