]> Creatis software - gdcm.git/blob - src/gdcmjpeg/jdpred.c
* Test for a bug fix
[gdcm.git] / src / gdcmjpeg / jdpred.c
1 /*
2  * jdpred.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 undifferencing (reconstruction) 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 undifferencing
13  * functions for each case.
14  *
15  * We are able to avoid duplicating source code by implementing the predictors
16  * and undifferencers as macros.  Each of the undifferencing functions are
17  * simply wrappers around an UNDIFFERENCE 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 D_LOSSLESS_SUPPORTED
28
29 /* Predictor for the first column of the first row: 2^(P-Pt-1) */
30 #define INITIAL_PREDICTORx  (1 << (cinfo->data_precision - cinfo->Al - 1))
31
32 /* Predictor for the first column of the remaining rows: Rb */
33 #define INITIAL_PREDICTOR2  GETJSAMPLE(prev_row[0])
34
35
36 /*
37  * 1-Dimensional undifferencer routine.
38  *
39  * This macro implements the 1-D horizontal predictor (1).  INITIAL_PREDICTOR
40  * is used as the special case predictor for the first column, which must be
41  * either INITIAL_PREDICTOR2 or INITIAL_PREDICTORx.  The remaining samples
42  * use PREDICTOR1.
43  *
44  * The reconstructed sample is supposed to be calculated modulo 2^16, so we
45  * logically AND the result with 0xFFFF.
46 */
47
48 #define UNDIFFERENCE_1D(INITIAL_PREDICTOR) \
49   unsigned int xindex; \
50   int Ra; \
51  \
52   Ra = (diff_buf[0] + INITIAL_PREDICTOR) & 0xFFFF; \
53   undiff_buf[0] = Ra; \
54  \
55   for (xindex = 1; xindex < width; xindex++) { \
56     Ra = (diff_buf[xindex] + PREDICTOR1) & 0xFFFF; \
57     undiff_buf[xindex] = Ra; \
58   }
59
60 /*
61  * 2-Dimensional undifferencer routine.
62  *
63  * This macro implements the 2-D horizontal predictors (#2-7).  PREDICTOR2 is
64  * used as the special case predictor for the first column.  The remaining
65  * samples use PREDICTOR, which is a function of Ra, Rb, Rc.
66  *
67  * Because prev_row and output_buf may point to the same storage area (in an
68  * interleaved image with Vi=1, for example), we must take care to buffer Rb/Rc
69  * before writing the current reconstructed sample value into output_buf.
70  *
71  * The reconstructed sample is supposed to be calculated modulo 2^16, so we
72  * logically AND the result with 0xFFFF.
73  */
74
75 #define UNDIFFERENCE_2D_BUG(PREDICTOR) \
76   Rb = GETJSAMPLE(prev_row[0]); \
77   Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \
78   undiff_buf[0] = Ra; \
79  \
80   for (xindex = 1; xindex < width; xindex++) { \
81     Rc = Rb; \
82     Rb = GETJSAMPLE(prev_row[xindex]); \
83     Ra = (diff_buf[xindex] + PREDICTOR) & 0xFFFF; \
84     undiff_buf[xindex] = Ra; \
85   }
86
87 #define UNDIFFERENCE_2D(PREDICTOR) \
88   unsigned int xindex; \
89   int Ra, Rb, Rc; \
90  \
91   Rb = GETJSAMPLE(prev_row[0]); \
92   Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \
93   undiff_buf[0] = Ra; \
94  \
95   for (xindex = 1; xindex < width; xindex++) { \
96     Rc = Rb; \
97     Rb = GETJSAMPLE(prev_row[xindex]); \
98     Ra = (diff_buf[xindex] + PREDICTOR) & 0xFFFF; \
99     undiff_buf[xindex] = Ra; \
100   }
101
102
103 /*
104  * Undifferencers for the all rows but the first in a scan or restart interval.
105  * The first sample in the row is undifferenced using the vertical
106  * predictor (2).  The rest of the samples are undifferenced using the
107  * predictor specified in the scan header.
108  */
109
110 METHODDEF(void)
111 jpeg_undifference1(j_decompress_ptr cinfo, int comp_index,
112        JDIFFROW diff_buf, JDIFFROW prev_row,
113        JDIFFROW undiff_buf, JDIMENSION width)
114 {
115   UNDIFFERENCE_1D(INITIAL_PREDICTOR2);
116   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
117 }
118
119 METHODDEF(void)
120 jpeg_undifference2(j_decompress_ptr cinfo, int comp_index,
121        JDIFFROW diff_buf, JDIFFROW prev_row,
122        JDIFFROW undiff_buf, JDIMENSION width)
123 {
124   UNDIFFERENCE_2D(PREDICTOR2);
125   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
126 }
127
128 METHODDEF(void)
129 jpeg_undifference3(j_decompress_ptr cinfo, int comp_index,
130        JDIFFROW diff_buf, JDIFFROW prev_row,
131        JDIFFROW undiff_buf, JDIMENSION width)
132 {
133   UNDIFFERENCE_2D(PREDICTOR3);
134   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
135 }
136
137 METHODDEF(void)
138 jpeg_undifference4(j_decompress_ptr cinfo, int comp_index,
139        JDIFFROW diff_buf, JDIFFROW prev_row,
140        JDIFFROW undiff_buf, JDIMENSION width)
141 {
142   UNDIFFERENCE_2D(PREDICTOR4);
143   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
144 }
145
146 METHODDEF(void)
147 jpeg_undifference5(j_decompress_ptr cinfo, int comp_index,
148        JDIFFROW diff_buf, JDIFFROW prev_row,
149        JDIFFROW undiff_buf, JDIMENSION width)
150 {
151   SHIFT_TEMPS
152   UNDIFFERENCE_2D(PREDICTOR5);
153   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
154 }
155
156 #ifdef SUPPORT_DICOMOBJECTS_BUG
157 /* uniitialized */
158 static int dicomobjectsbug = -1; /* 0 == nobug, 1 == bug */
159 #endif
160
161 METHODDEF(void)
162 jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
163        JDIFFROW diff_buf, JDIFFROW prev_row,
164        JDIFFROW undiff_buf, JDIMENSION width)
165 {
166 #ifdef SUPPORT_DICOMOBJECTS_BUG
167   unsigned int xindex;
168   int Ra, Rb, Rc;
169   int min, max, temp;
170   SHIFT_TEMPS
171   if( dicomobjectsbug == -1 )
172     {
173     dicomobjectsbug = 0; /* no bug by default */
174
175     Rb = GETJSAMPLE(prev_row[0]);
176     Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF;
177     undiff_buf[0] = Ra;
178     temp = min = max = undiff_buf[0];
179
180     for (xindex = 1; xindex < width; xindex++) {
181       Rc = Rb;
182       Rb = GETJSAMPLE(prev_row[xindex]);
183       Ra = (diff_buf[xindex] + PREDICTOR6) & 0xFFFF;
184       temp = Ra;
185       min = temp < min ? temp : min;
186       max = temp > max ? temp : max;
187     }
188     if( (max - min) > 50000) /* magic number */
189       {
190       dicomobjectsbug = 1;
191       }
192     }
193   if(dicomobjectsbug)
194     {
195     UNDIFFERENCE_2D_BUG(PREDICTOR6_BUG);
196     }
197   else
198     {
199     UNDIFFERENCE_2D_BUG(PREDICTOR6);
200     }
201 #else
202   SHIFT_TEMPS
203   UNDIFFERENCE_2D(PREDICTOR6);
204 #endif
205   (void)comp_index;(void)cinfo;
206 }
207
208 METHODDEF(void)
209 jpeg_undifference7(j_decompress_ptr cinfo, int comp_index,
210        JDIFFROW diff_buf, JDIFFROW prev_row,
211        JDIFFROW undiff_buf, JDIMENSION width)
212 {
213   SHIFT_TEMPS
214   UNDIFFERENCE_2D(PREDICTOR7);
215   (void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
216 }
217
218
219 /*
220  * Undifferencer for the first row in a scan or restart interval.  The first
221  * sample in the row is undifferenced using the special predictor constant
222  * x=2^(P-Pt-1).  The rest of the samples are undifferenced using the
223  * 1-D horizontal predictor (1).
224  */
225
226 METHODDEF(void)
227 jpeg_undifference_first_row(j_decompress_ptr cinfo, int comp_index,
228           JDIFFROW diff_buf, JDIFFROW prev_row,
229           JDIFFROW undiff_buf, JDIMENSION width)
230 {
231   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
232
233   UNDIFFERENCE_1D(INITIAL_PREDICTORx);
234   (void)prev_row;
235
236   /*
237    * Now that we have undifferenced the first row, we want to use the
238    * undifferencer which corresponds to the predictor specified in the
239    * scan header.
240    */
241   switch (cinfo->Ss) {
242   case 1:
243     losslsd->predict_undifference[comp_index] = jpeg_undifference1;
244     break;
245   case 2:
246     losslsd->predict_undifference[comp_index] = jpeg_undifference2;
247     break;
248   case 3:
249     losslsd->predict_undifference[comp_index] = jpeg_undifference3;
250     break;
251   case 4:
252     losslsd->predict_undifference[comp_index] = jpeg_undifference4;
253     break;
254   case 5:
255     losslsd->predict_undifference[comp_index] = jpeg_undifference5;
256     break;
257   case 6:
258     losslsd->predict_undifference[comp_index] = jpeg_undifference6;
259     break;
260   case 7:
261     losslsd->predict_undifference[comp_index] = jpeg_undifference7;
262     break;
263   }
264 }
265
266
267 /*
268  * Initialize for an input processing pass.
269  */
270
271 METHODDEF(void)
272 predict_start_pass (j_decompress_ptr cinfo)
273 {
274   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
275   int ci;
276
277   /* Check that the scan parameters Ss, Se, Ah, Al are OK for lossless JPEG.
278    *
279    * Ss is the predictor selection value (psv).  Legal values for sequential
280    * lossless JPEG are: 1 <= psv <= 7.
281    *
282    * Se and Ah are not used and should be zero.
283    *
284    * Al specifies the point transform (Pt).  Legal values are: 0 <= Pt <= 15.
285    */
286   if (cinfo->Ss < 1 || cinfo->Ss > 7 ||
287       cinfo->Se != 0 || cinfo->Ah != 0 ||
288       cinfo->Al > 15)        /* need not check for < 0 */
289     ERREXIT4(cinfo, JERR_BAD_LOSSLESS,
290        cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
291
292   /* Set undifference functions to first row function */
293   for (ci = 0; ci < cinfo->num_components; ci++)
294     losslsd->predict_undifference[ci] = jpeg_undifference_first_row;
295 }
296
297
298 /*
299  * Module initialization routine for the undifferencer.
300  */
301
302 GLOBAL(void)
303 jinit_undifferencer (j_decompress_ptr cinfo)
304 {
305   j_lossless_d_ptr losslsd = (j_lossless_d_ptr) cinfo->codec;
306
307   losslsd->predict_start_pass = predict_start_pass;
308   losslsd->predict_process_restart = predict_start_pass;
309 }
310
311 #endif /* D_LOSSLESS_SUPPORTED */
312