]> Creatis software - gdcm.git/blob - src/gdcmjpeg/jcpred.c
Doxygenation
[gdcm.git] / src / gdcmjpeg / jcpred.c
1 /*
2  * jcpred.c
3  *
4  * Copyright (C) 1998, Thomas G. Lane.
5  * This file is part of the Independent JPEG Group's software.
6  * For conditions of distribution and use, see the accompanying README file.
7  *
8  * This file contains sample differencing for lossless JPEG.
9  *
10  * In order to avoid paying the performance penalty of having to check the
11  * predictor being used and the row being processed for each call of the
12  * undifferencer, and to promote optimization, we have separate differencing
13  * functions for each case.
14  *
15  * We are able to avoid duplicating source code by implementing the predictors
16  * and differencers as macros.  Each of the differencing functions are
17  * simply wrappers around a DIFFERENCE macro with the appropriate PREDICTOR
18  * macro passed as an argument.
19  */
20
21 #define JPEG_INTERNALS
22 #include "jinclude.h"
23 #include "jpeglib.h"
24 #include "jlossls.h"    /* Private declarations for lossless codec */
25
26
27 #ifdef C_LOSSLESS_SUPPORTED
28
29 /* Private predictor object */
30
31 typedef struct {
32   /* MCU-rows left in the restart interval for each component */
33   unsigned int restart_rows_to_go[MAX_COMPONENTS];
34 } c_predictor;
35
36 typedef c_predictor * c_pred_ptr;
37
38 /* Forward declarations */
39 LOCAL(void) reset_predictor
40   JPP((j_compress_ptr cinfo, int ci));
41 METHODDEF(void) start_pass
42   JPP((j_compress_ptr cinfo));
43
44
45 /* Predictor for the first column of the first row: 2^(P-Pt-1) */
46 #define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))
47
48 /* Predictor for the first column of the remaining rows: Rb */
49 #define INITIAL_PREDICTOR2  GETJSAMPLE(prev_row[0])
50
51
52 /*
53  * 1-Dimensional differencer routine.
54  *
55  * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
56  * is used as the special case predictor for the first column, which must be
57  * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
58  * use PREDICTOR1.
59  */
60
61 #define DIFFERENCE_1D(INITIAL_PREDICTOR) \
62   j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec; \
63   c_pred_ptr pred = (c_pred_ptr) losslsc->pred_private; \
64   boolean restart = FALSE; \
65   unsigned int xindex; \
66   int samp, Ra; \
67  \
68   samp = GETJSAMPLE(input_buf[0]); \
69   diff_buf[0] = samp - INITIAL_PREDICTOR; \
70  \
71   for (xindex = 1; xindex < width; xindex++) { \
72     Ra = samp; \
73     samp = GETJSAMPLE(input_buf[xindex]); \
74     diff_buf[xindex] = samp - PREDICTOR1; \
75   } \
76  \
77   /* Account for restart interval (no-op if not using restarts) */ \
78   if (cinfo->restart_interval) { \
79     if (--(pred->restart_rows_to_go[ci]) == 0) { \
80       reset_predictor(cinfo, ci); \
81       restart = TRUE; \
82     } \
83   }
84
85
86 /*
87  * 2-Dimensional differencer routine.
88  *
89  * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
90  * used as the special case predictor for the first column.  The remaining
91  * samples use PREDICTOR, which is a function of Ra, Rb, Rc.
92  *
93  * Because prev_row and output_buf may point to the same storage area (in an
94  * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
95  * before writing the current reconstructed sample value into output_buf.
96  */
97
98 #define DIFFERENCE_2D(PREDICTOR) \
99   j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec; \
100   c_pred_ptr pred = (c_pred_ptr) losslsc->pred_private; \
101   unsigned int xindex; \
102   int samp, Ra, Rb, Rc; \
103  \
104   Rb = GETJSAMPLE(prev_row[0]); \
105   samp = GETJSAMPLE(input_buf[0]); \
106   diff_buf[0] = samp - PREDICTOR2; \
107  \
108   for (xindex = 1; xindex < width; xindex++) { \
109     Rc = Rb; \
110     Rb = GETJSAMPLE(prev_row[xindex]); \
111     Ra = samp; \
112     samp = GETJSAMPLE(input_buf[xindex]); \
113     diff_buf[xindex] = samp - PREDICTOR; \
114   } \
115  \
116   /* Account for restart interval (no-op if not using restarts) */ \
117   if (cinfo->restart_interval) { \
118     if (--pred->restart_rows_to_go[ci] == 0) \
119       reset_predictor(cinfo, ci); \
120   }
121
122
123 /*
124  * Differencers for the all rows but the first in a scan or restart interval.
125  * The first sample in the row is differenced using the vertical
126  * predictor (2).  The rest of the samples are differenced using the
127  * predictor specified in the scan header.
128  */
129
130 METHODDEF(void)
131 jpeg_difference1(j_compress_ptr cinfo, int ci,
132      JSAMPROW input_buf, JSAMPROW prev_row,
133      JDIFFROW diff_buf, JDIMENSION width)
134 {
135   DIFFERENCE_1D(INITIAL_PREDICTOR2);
136 }
137
138 METHODDEF(void)
139 jpeg_difference2(j_compress_ptr cinfo, int ci,
140      JSAMPROW input_buf, JSAMPROW prev_row,
141      JDIFFROW diff_buf, JDIMENSION width)
142 {
143   DIFFERENCE_2D(PREDICTOR2);
144 }
145
146 METHODDEF(void)
147 jpeg_difference3(j_compress_ptr cinfo, int ci,
148      JSAMPROW input_buf, JSAMPROW prev_row,
149      JDIFFROW diff_buf, JDIMENSION width)
150 {
151   DIFFERENCE_2D(PREDICTOR3);
152 }
153
154 METHODDEF(void)
155 jpeg_difference4(j_compress_ptr cinfo, int ci,
156      JSAMPROW input_buf, JSAMPROW prev_row,
157      JDIFFROW diff_buf, JDIMENSION width)
158 {
159   DIFFERENCE_2D(PREDICTOR4);
160 }
161
162 METHODDEF(void)
163 jpeg_difference5(j_compress_ptr cinfo, int ci,
164      JSAMPROW input_buf, JSAMPROW prev_row,
165      JDIFFROW diff_buf, JDIMENSION width)
166 {
167   SHIFT_TEMPS
168   DIFFERENCE_2D(PREDICTOR5);
169 }
170
171 METHODDEF(void)
172 jpeg_difference6(j_compress_ptr cinfo, int ci,
173      JSAMPROW input_buf, JSAMPROW prev_row,
174      JDIFFROW diff_buf, JDIMENSION width)
175 {
176   SHIFT_TEMPS
177   DIFFERENCE_2D(PREDICTOR6);
178 }
179
180 METHODDEF(void)
181 jpeg_difference7(j_compress_ptr cinfo, int ci,
182      JSAMPROW input_buf, JSAMPROW prev_row,
183      JDIFFROW diff_buf, JDIMENSION width)
184 {
185   SHIFT_TEMPS
186   DIFFERENCE_2D(PREDICTOR7);
187 }
188
189
190 /*
191  * Differencer for the first row in a scan or restart interval.  The first
192  * sample in the row is differenced using the special predictor constant
193  * x=2^(P-Pt-1).  The rest of the samples are differenced using the
194  * 1-D horizontal predictor (1).
195  */
196
197 METHODDEF(void)
198 jpeg_difference_first_row(j_compress_ptr cinfo, int ci,
199      JSAMPROW input_buf, JSAMPROW prev_row,
200      JDIFFROW diff_buf, JDIMENSION width)
201 {
202   DIFFERENCE_1D(INITIAL_PREDICTORx);
203   (void)prev_row;
204
205   /*
206    * Now that we have differenced the first row, we want to use the
207    * differencer which corresponds to the predictor specified in the
208    * scan header.
209    *
210    * Note that we don't to do this if we have just reset the predictor
211    * for a new restart interval.
212    */
213   if (!restart) {
214     switch (cinfo->Ss) {
215     case 1:
216       losslsc->predict_difference[ci] = jpeg_difference1;
217       break;
218     case 2:
219       losslsc->predict_difference[ci] = jpeg_difference2;
220       break;
221     case 3:
222       losslsc->predict_difference[ci] = jpeg_difference3;
223       break;
224     case 4:
225       losslsc->predict_difference[ci] = jpeg_difference4;
226       break;
227     case 5:
228       losslsc->predict_difference[ci] = jpeg_difference5;
229       break;
230     case 6:
231       losslsc->predict_difference[ci] = jpeg_difference6;
232       break;
233     case 7:
234       losslsc->predict_difference[ci] = jpeg_difference7;
235       break;
236     }
237   }
238 }
239
240 /*
241  * Reset predictor at the start of a pass or restart interval.
242  */
243
244 LOCAL(void)
245 reset_predictor (j_compress_ptr cinfo, int ci)
246 {
247   j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec;
248   c_pred_ptr pred = (c_pred_ptr) losslsc->pred_private;
249
250   /* Initialize restart counter */
251   pred->restart_rows_to_go[ci] =
252     cinfo->restart_interval / cinfo->MCUs_per_row;
253
254   /* Set difference function to first row function */
255   losslsc->predict_difference[ci] = jpeg_difference_first_row;
256 }
257
258
259 /*
260  * Initialize for an input processing pass.
261  */
262
263 METHODDEF(void)
264 start_pass (j_compress_ptr cinfo)
265 {
266   /* j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec; */
267   /* c_pred_ptr pred = (c_pred_ptr) losslsc->pred_private; */
268   int ci;
269
270   /* Check that the restart interval is an integer multiple of the number 
271    * of MCU in an MCU-row.
272    */
273   if (cinfo->restart_interval % cinfo->MCUs_per_row != 0)
274     ERREXIT2(cinfo, JERR_BAD_RESTART,
275        cinfo->restart_interval, cinfo->MCUs_per_row);
276
277   /* Set predictors for start of pass */
278   for (ci = 0; ci < cinfo->num_components; ci++)
279     reset_predictor(cinfo, ci);
280 }
281
282
283 /*
284  * Module initialization routine for the differencer.
285  */
286
287 GLOBAL(void)
288 jinit_differencer (j_compress_ptr cinfo)
289 {
290   j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec;
291   c_pred_ptr pred;
292
293   pred = (c_pred_ptr)
294     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
295         SIZEOF(c_predictor));
296   losslsc->pred_private = (void *) pred;
297   losslsc->predict_start_pass = start_pass;
298 }
299
300 #endif /* C_LOSSLESS_SUPPORTED */
301