Coverage Report

Created: 2025-10-13 06:06

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libjpeg-turbo.3.0.x/jdlossls.c
Line
Count
Source
1
/*
2
 * jdlossls.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1998, Thomas G. Lane.
6
 * Lossless JPEG Modifications:
7
 * Copyright (C) 1999, Ken Murchison.
8
 * libjpeg-turbo Modifications:
9
 * Copyright (C) 2022, D. R. Commander.
10
 * For conditions of distribution and use, see the accompanying README.ijg
11
 * file.
12
 *
13
 * This file contains prediction, sample undifferencing, point transform, and
14
 * sample scaling routines for the lossless JPEG decompressor.
15
 */
16
17
#define JPEG_INTERNALS
18
#include "jinclude.h"
19
#include "jpeglib.h"
20
#include "jlossls.h"
21
22
#ifdef D_LOSSLESS_SUPPORTED
23
24
25
/**************** Sample undifferencing (reconstruction) *****************/
26
27
/*
28
 * In order to avoid a performance penalty for checking which predictor is
29
 * being used and which row is being processed for each call of the
30
 * undifferencer, and to promote optimization, we have separate undifferencing
31
 * functions for each predictor selection value.
32
 *
33
 * We are able to avoid duplicating source code by implementing the predictors
34
 * and undifferencers as macros.  Each of the undifferencing functions is
35
 * simply a wrapper around an UNDIFFERENCE macro with the appropriate PREDICTOR
36
 * macro passed as an argument.
37
 */
38
39
/* Predictor for the first column of the first row: 2^(P-Pt-1) */
40
#define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))
41
42
/* Predictor for the first column of the remaining rows: Rb */
43
#define INITIAL_PREDICTOR2  prev_row[0]
44
45
46
/*
47
 * 1-Dimensional undifferencer routine.
48
 *
49
 * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
50
 * is used as the special case predictor for the first column, which must be
51
 * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
52
 * use PREDICTOR1.
53
 *
54
 * The reconstructed sample is supposed to be calculated modulo 2^16, so we
55
 * logically AND the result with 0xFFFF.
56
 */
57
58
#define UNDIFFERENCE_1D(INITIAL_PREDICTOR) \
59
97.4M
  int Ra; \
60
97.4M
  \
61
97.4M
  Ra = (*diff_buf++ + INITIAL_PREDICTOR) & 0xFFFF; \
62
97.4M
  *undiff_buf++ = Ra; \
63
97.4M
  \
64
950M
  while (--width) { \
65
853M
    Ra = (*diff_buf++ + PREDICTOR1) & 0xFFFF; \
66
853M
    *undiff_buf++ = Ra; \
67
853M
  }
68
69
70
/*
71
 * 2-Dimensional undifferencer routine.
72
 *
73
 * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
74
 * used as the special case predictor for the first column.  The remaining
75
 * samples use PREDICTOR, which is a function of Ra, Rb, and Rc.
76
 *
77
 * Because prev_row and output_buf may point to the same storage area (in an
78
 * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
79
 * before writing the current reconstructed sample value into output_buf.
80
 *
81
 * The reconstructed sample is supposed to be calculated modulo 2^16, so we
82
 * logically AND the result with 0xFFFF.
83
 */
84
85
#define UNDIFFERENCE_2D(PREDICTOR) \
86
15.1M
  int Ra, Rb, Rc; \
87
15.1M
  \
88
15.1M
  Rb = *prev_row++; \
89
15.1M
  Ra = (*diff_buf++ + PREDICTOR2) & 0xFFFF; \
90
15.1M
  *undiff_buf++ = Ra; \
91
15.1M
  \
92
284M
  while (--width) { \
93
269M
    Rc = Rb; \
94
269M
    Rb = *prev_row++; \
95
269M
    Ra = (*diff_buf++ + PREDICTOR) & 0xFFFF; \
96
269M
    *undiff_buf++ = Ra; \
97
269M
  }
98
99
100
/*
101
 * Undifferencers for the second and subsequent rows in a scan or restart
102
 * interval.  The first sample in the row is undifferenced using the vertical
103
 * predictor (2).  The rest of the samples are undifferenced using the
104
 * predictor specified in the scan header.
105
 */
106
107
METHODDEF(void)
108
jpeg_undifference1(j_decompress_ptr cinfo, int comp_index,
109
                   JDIFFROW diff_buf, JDIFFROW prev_row,
110
                   JDIFFROW undiff_buf, JDIMENSION width)
111
2.57M
{
112
2.57M
  UNDIFFERENCE_1D(INITIAL_PREDICTOR2);
113
2.57M
}
114
115
METHODDEF(void)
116
jpeg_undifference2(j_decompress_ptr cinfo, int comp_index,
117
                   JDIFFROW diff_buf, JDIFFROW prev_row,
118
                   JDIFFROW undiff_buf, JDIMENSION width)
119
523k
{
120
523k
  UNDIFFERENCE_2D(PREDICTOR2);
121
523k
  (void)(Rc);
122
523k
}
123
124
METHODDEF(void)
125
jpeg_undifference3(j_decompress_ptr cinfo, int comp_index,
126
                   JDIFFROW diff_buf, JDIFFROW prev_row,
127
                   JDIFFROW undiff_buf, JDIMENSION width)
128
1.02M
{
129
1.02M
  UNDIFFERENCE_2D(PREDICTOR3);
130
1.02M
}
131
132
METHODDEF(void)
133
jpeg_undifference4(j_decompress_ptr cinfo, int comp_index,
134
                   JDIFFROW diff_buf, JDIFFROW prev_row,
135
                   JDIFFROW undiff_buf, JDIMENSION width)
136
827k
{
137
827k
  UNDIFFERENCE_2D(PREDICTOR4);
138
827k
}
139
140
METHODDEF(void)
141
jpeg_undifference5(j_decompress_ptr cinfo, int comp_index,
142
                   JDIFFROW diff_buf, JDIFFROW prev_row,
143
                   JDIFFROW undiff_buf, JDIMENSION width)
144
10.6M
{
145
10.6M
  UNDIFFERENCE_2D(PREDICTOR5);
146
10.6M
}
147
148
METHODDEF(void)
149
jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
150
                   JDIFFROW diff_buf, JDIFFROW prev_row,
151
                   JDIFFROW undiff_buf, JDIMENSION width)
152
1.06M
{
153
1.06M
  UNDIFFERENCE_2D(PREDICTOR6);
154
1.06M
}
155
156
METHODDEF(void)
157
jpeg_undifference7(j_decompress_ptr cinfo, int comp_index,
158
                   JDIFFROW diff_buf, JDIFFROW prev_row,
159
                   JDIFFROW undiff_buf, JDIMENSION width)
160
1.04M
{
161
1.04M
  UNDIFFERENCE_2D(PREDICTOR7);
162
1.04M
  (void)(Rc);
163
1.04M
}
164
165
166
/*
167
 * Undifferencer for the first row in a scan or restart interval.  The first
168
 * sample in the row is undifferenced using the special predictor constant
169
 * x=2^(P-Pt-1).  The rest of the samples are undifferenced using the
170
 * 1-D horizontal predictor (1).
171
 */
172
173
METHODDEF(void)
174
jpeg_undifference_first_row(j_decompress_ptr cinfo, int comp_index,
175
                            JDIFFROW diff_buf, JDIFFROW prev_row,
176
                            JDIFFROW undiff_buf, JDIMENSION width)
177
94.8M
{
178
94.8M
  lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct;
179
180
94.8M
  UNDIFFERENCE_1D(INITIAL_PREDICTORx);
181
182
  /*
183
   * Now that we have undifferenced the first row, we want to use the
184
   * undifferencer that corresponds to the predictor specified in the
185
   * scan header.
186
   */
187
94.8M
  switch (cinfo->Ss) {
188
5.95M
  case 1:
189
5.95M
    losslessd->predict_undifference[comp_index] = jpeg_undifference1;
190
5.95M
    break;
191
1.32M
  case 2:
192
1.32M
    losslessd->predict_undifference[comp_index] = jpeg_undifference2;
193
1.32M
    break;
194
21.5M
  case 3:
195
21.5M
    losslessd->predict_undifference[comp_index] = jpeg_undifference3;
196
21.5M
    break;
197
30.3M
  case 4:
198
30.3M
    losslessd->predict_undifference[comp_index] = jpeg_undifference4;
199
30.3M
    break;
200
32.1M
  case 5:
201
32.1M
    losslessd->predict_undifference[comp_index] = jpeg_undifference5;
202
32.1M
    break;
203
2.31M
  case 6:
204
2.31M
    losslessd->predict_undifference[comp_index] = jpeg_undifference6;
205
2.31M
    break;
206
1.25M
  case 7:
207
1.25M
    losslessd->predict_undifference[comp_index] = jpeg_undifference7;
208
1.25M
    break;
209
94.8M
  }
210
94.8M
}
211
212
213
/*********************** Sample upscaling by 2^Pt ************************/
214
215
METHODDEF(void)
216
simple_upscale(j_decompress_ptr cinfo,
217
               JDIFFROW diff_buf, _JSAMPROW output_buf, JDIMENSION width)
218
68.3M
{
219
490M
  do {
220
490M
    *output_buf++ = (_JSAMPLE)(*diff_buf++ << cinfo->Al);
221
490M
  } while (--width);
222
68.3M
}
223
224
METHODDEF(void)
225
noscale(j_decompress_ptr cinfo,
226
        JDIFFROW diff_buf, _JSAMPROW output_buf, JDIMENSION width)
227
44.2M
{
228
745M
  do {
229
745M
    *output_buf++ = (_JSAMPLE)(*diff_buf++);
230
745M
  } while (--width);
231
44.2M
}
232
233
234
/*
235
 * Initialize for an input processing pass.
236
 */
237
238
METHODDEF(void)
239
start_pass_lossless(j_decompress_ptr cinfo)
240
94.5M
{
241
94.5M
  lossless_decomp_ptr losslessd = (lossless_decomp_ptr)cinfo->idct;
242
94.5M
  int ci;
243
244
  /* Check that the scan parameters Ss, Se, Ah, Al are OK for lossless JPEG.
245
   *
246
   * Ss is the predictor selection value (psv).  Legal values for sequential
247
   * lossless JPEG are: 1 <= psv <= 7.
248
   *
249
   * Se and Ah are not used and should be zero.
250
   *
251
   * Al specifies the point transform (Pt).
252
   * Legal values are: 0 <= Pt <= (data precision - 1).
253
   */
254
94.5M
  if (cinfo->Ss < 1 || cinfo->Ss > 7 ||
255
94.5M
      cinfo->Se != 0 || cinfo->Ah != 0 ||
256
94.5M
      cinfo->Al < 0 || cinfo->Al >= cinfo->data_precision)
257
213
    ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
258
94.5M
             cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
259
260
  /* Set undifference functions to first row function */
261
378M
  for (ci = 0; ci < cinfo->num_components; ci++)
262
283M
    losslessd->predict_undifference[ci] = jpeg_undifference_first_row;
263
264
  /* Set scaler function based on Pt */
265
94.5M
  if (cinfo->Al)
266
65.6M
    losslessd->scaler_scale = simple_upscale;
267
28.9M
  else
268
28.9M
    losslessd->scaler_scale = noscale;
269
94.5M
}
270
271
272
/*
273
 * Initialize the lossless decompressor.
274
 */
275
276
GLOBAL(void)
277
_jinit_lossless_decompressor(j_decompress_ptr cinfo)
278
2.55k
{
279
2.55k
  lossless_decomp_ptr losslessd;
280
281
  /* Create subobject in permanent pool */
282
2.55k
  losslessd = (lossless_decomp_ptr)
283
2.55k
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
284
2.55k
                                sizeof(jpeg_lossless_decompressor));
285
2.55k
  cinfo->idct = (struct jpeg_inverse_dct *)losslessd;
286
2.55k
  losslessd->pub.start_pass = start_pass_lossless;
287
2.55k
}
j12init_lossless_decompressor
Line
Count
Source
278
874
{
279
874
  lossless_decomp_ptr losslessd;
280
281
  /* Create subobject in permanent pool */
282
874
  losslessd = (lossless_decomp_ptr)
283
874
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
284
874
                                sizeof(jpeg_lossless_decompressor));
285
874
  cinfo->idct = (struct jpeg_inverse_dct *)losslessd;
286
874
  losslessd->pub.start_pass = start_pass_lossless;
287
874
}
j16init_lossless_decompressor
Line
Count
Source
278
874
{
279
874
  lossless_decomp_ptr losslessd;
280
281
  /* Create subobject in permanent pool */
282
874
  losslessd = (lossless_decomp_ptr)
283
874
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
284
874
                                sizeof(jpeg_lossless_decompressor));
285
874
  cinfo->idct = (struct jpeg_inverse_dct *)losslessd;
286
874
  losslessd->pub.start_pass = start_pass_lossless;
287
874
}
jinit_lossless_decompressor
Line
Count
Source
278
806
{
279
806
  lossless_decomp_ptr losslessd;
280
281
  /* Create subobject in permanent pool */
282
806
  losslessd = (lossless_decomp_ptr)
283
806
    (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_PERMANENT,
284
806
                                sizeof(jpeg_lossless_decompressor));
285
806
  cinfo->idct = (struct jpeg_inverse_dct *)losslessd;
286
806
  losslessd->pub.start_pass = start_pass_lossless;
287
806
}
288
289
#endif /* D_LOSSLESS_SUPPORTED */